644 lines
23 KiB
C
644 lines
23 KiB
C
//*@@@+++@@@@******************************************************************
|
|
//
|
|
// Copyright © Microsoft Corp.
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are met:
|
|
//
|
|
// • Redistributions of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
// • Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
//*@@@---@@@@******************************************************************
|
|
#include <JXRTest.h>
|
|
#include <time.h>
|
|
|
|
|
|
//================================================================
|
|
static const size_t SKIPFLEXBITS = 0xff;
|
|
|
|
//================================================================
|
|
// Command line argument support
|
|
//================================================================
|
|
typedef struct tagWMPDECAPPARGS
|
|
{
|
|
char* szInputFile;
|
|
char* szOutputFile;
|
|
|
|
Bool bVerbose;
|
|
|
|
PKPixelFormatGUID guidPixFormat;
|
|
// Bool bFlagRGB_BGR;
|
|
|
|
// region decode
|
|
size_t rLeftX;
|
|
size_t rTopY;
|
|
size_t rWidth;
|
|
size_t rHeight;
|
|
|
|
// thumbnail
|
|
size_t tThumbnailFactor;
|
|
|
|
// orientation
|
|
ORIENTATION oOrientation;
|
|
|
|
// post processing
|
|
U8 cPostProcStrength;
|
|
|
|
U8 uAlphaMode; // 0:no alpha 1: alpha only else: something + alpha
|
|
|
|
SUBBAND sbSubband; // which subbands to keep (for transcoding)
|
|
|
|
BITSTREAMFORMAT bfBitstreamFormat; // desired bitsream format (for transcoding)
|
|
|
|
CWMIStrCodecParam wmiSCP;
|
|
|
|
Bool bIgnoreOverlap;
|
|
} WMPDECAPPARGS;
|
|
|
|
//----------------------------------------------------------------
|
|
void WmpDecAppUsage(const char* szExe)
|
|
{
|
|
printf(CRLF);
|
|
printf("JPEG XR Decoder Utility" CRLF);
|
|
printf("Copyright 2013 Microsoft Corporation - All Rights Reserved" CRLF);
|
|
printf(CRLF);
|
|
printf("%s [options]..." CRLF, szExe);
|
|
printf(CRLF);
|
|
printf(" -i input.jxr/wdp Input JPEG XR/HD Photo file name" CRLF);
|
|
printf(CRLF);
|
|
printf(" -o output.bmp/tif/jxr Output image file name" CRLF);
|
|
printf(" bmp: <=8bpc, BGR" CRLF);
|
|
printf(" tif: >=8bpc, RGB" CRLF);
|
|
printf(" jxr: for compressed domain transcode" CRLF);
|
|
printf(CRLF);
|
|
|
|
printf(" -c format Specifies the uncompressed output format" CRLF);
|
|
printf(" 0: 24bppBGR" CRLF);
|
|
printf(" 1: 1bppBlackWhite" CRLF);
|
|
printf(" 2: 8bppGray" CRLF);
|
|
printf(" 3: 16bppGray" CRLF);
|
|
printf(" 4: 16bppGrayFixedPoint" CRLF);
|
|
printf(" 5: 16bppGrayHalf" CRLF);
|
|
// printf(" 6: 32bppGray" CRLF);
|
|
printf(" 7: 32bppGrayFixedPoint" CRLF);
|
|
printf(" 8: 32bppGrayFloat" CRLF);
|
|
|
|
printf(" 9: 24bppRGB" CRLF);
|
|
printf(" 10: 48bppRGB" CRLF);
|
|
printf(" 11: 48bppRGBFixedPoint" CRLF);
|
|
printf(" 12: 48bppRGBHalf" CRLF);
|
|
// printf(" 13: 96bppRGB" CRLF);
|
|
printf(" 14: 96bppRGBFixedPoint" CRLF);
|
|
printf(" 15: 128bppRGBFloat" CRLF);
|
|
|
|
printf(" 16: 32bppRGBE" CRLF);
|
|
|
|
printf(" 17: 32bppCMYK" CRLF);
|
|
printf(" 18: 64bppCMYK" CRLF);
|
|
|
|
/*
|
|
printf(" 19 - YUV 420" CRLF);
|
|
printf(" 20 - YUV 422" CRLF);
|
|
printf(" 21 - YUV 444" CRLF);
|
|
*/
|
|
printf(" 22: 32bppBGRA" CRLF);
|
|
printf(" 23: 64bppRGBA" CRLF);
|
|
printf(" 24: 64bppRGBAFixedPoint" CRLF);
|
|
printf(" 25: 64bppRGBAHalf" CRLF);
|
|
// printf(" 26 - 128bpp RGBA" CRLF);
|
|
printf(" 27: 128bppRGBAFixedPoint" CRLF);
|
|
printf(" 28: 128bppRGBAFloat" CRLF);
|
|
|
|
printf(" 29: 16bppBGR555" CRLF);
|
|
printf(" 30: 16bppBGR565" CRLF);
|
|
printf(" 31: 32bppBGR101010" CRLF);
|
|
//printf(" 101..116 - 1..16 channel 8bpp" CRLF);
|
|
printf(" 32: 40bppCMYKA" CRLF);
|
|
printf(" 33: 80bppCMYKA" CRLF);
|
|
|
|
printf(" 34: 32bppBGR" CRLF);
|
|
/*
|
|
printf(" 35: 32bppPBGRA" CRLF);
|
|
printf(" 36: 64bppPRGBA" CRLF);
|
|
printf(" 37: 128bppPRGBA Float" CRLF);
|
|
*/
|
|
printf(CRLF);
|
|
|
|
printf(" -r top left height width Specifies the rectangle for region decode" CRLF);
|
|
printf(CRLF);
|
|
printf(" -T m Reduced resolution (mipmap) decode" CRLF);
|
|
printf(" 0: Full resolution (default)" CRLF);
|
|
printf(" 1: 1/2 res (down-sampled from full res)" CRLF);
|
|
printf(" 2: 1/4 res (native decode)" CRLF);
|
|
printf(" 3: 1/8 res (down-sampled from 1/4 res)" CRLF);
|
|
printf(" 4: 1/16 res (native decode)" CRLF);
|
|
printf(" >4: 1/(2^m) res (down-sampled from 1/16 res) " CRLF);
|
|
printf(CRLF);
|
|
|
|
printf(" -O orientation 0: No transformation (default)" CRLF);
|
|
printf(" 1: Flip vertically" CRLF);
|
|
printf(" 2: Flip horizontally" CRLF);
|
|
printf(" 3: Flip vertically & horizontally" CRLF);
|
|
printf(" 4: Rotate 90 degrees CW" CRLF);
|
|
printf(" 5: Rotate 90 degrees CW & flip vertically" CRLF);
|
|
printf(" 6: Rotate 90 degrees CW & flip horizontally" CRLF);
|
|
printf(" 7: Rotate 90 degrees CW & flip vert & horiz" CRLF);
|
|
printf(CRLF);
|
|
|
|
printf(" -s skip subbands Used for compressed domain transcoding" CRLF);
|
|
printf(" 0: All subbands included (default)" CRLF);
|
|
printf(" 1: Skip flexbits" CRLF);
|
|
printf(" 2: Skip highpass" CRLF);
|
|
printf(" 3: Skip highpass & lowpass (DC only)" CRLF);
|
|
printf(CRLF);
|
|
|
|
printf(" -a alpha decode 0: Decode without alpha channel" CRLF);
|
|
printf(" 1: Decode only alpha channel" CRLF);
|
|
printf(" 2: Decode image & alpha (default)" CRLF);
|
|
printf(CRLF);
|
|
|
|
printf(" -p strength Post processing filter strength" CRLF);
|
|
printf(" 0: None (default)" CRLF);
|
|
printf(" 1: Light" CRLF);
|
|
printf(" 2: Medium" CRLF);
|
|
printf(" 3: Strong" CRLF);
|
|
printf(" 4: Very strong" CRLF);
|
|
printf(CRLF);
|
|
|
|
printf(" -C Suppress overlapping boundary macro blocks" CRLF);
|
|
printf(" (Used for compressed domain tile extraction)" CRLF);
|
|
printf(CRLF);
|
|
|
|
printf(" -t Display timing information" CRLF);
|
|
printf(CRLF);
|
|
|
|
printf(" -v Display verbose decoder information" CRLF);
|
|
printf(CRLF);
|
|
printf("Eg: %s -i input.jxr -o output.bmp -c 0" CRLF, szExe);
|
|
}
|
|
|
|
void WmpDecAppShowArgs(WMPDECAPPARGS* args)
|
|
{
|
|
GUID guidPF = args->guidPixFormat;
|
|
|
|
printf("================================" CRLF);
|
|
printf("Input file: %s" CRLF, args->szInputFile);
|
|
printf("Output file: %s" CRLF, args->szOutputFile);
|
|
printf("Color format: %08X-%04X-%04X-%02X%02X%02X%02X%02X%02X%02X%02X" CRLF,
|
|
guidPF.Data1, guidPF.Data2, guidPF.Data3, guidPF.Data4[0], guidPF.Data4[1], guidPF.Data4[2],
|
|
guidPF.Data4[3], guidPF.Data4[4], guidPF.Data4[5], guidPF.Data4[6], guidPF.Data4[7]);
|
|
printf("Post processing strength: %d" CRLF, args->cPostProcStrength);
|
|
printf("Thumbnail: %d" CRLF, (int) args->tThumbnailFactor);
|
|
printf("================================" CRLF);
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
void WmpDecAppInitDefaultArgs(WMPDECAPPARGS* args)
|
|
{
|
|
memset(args, 0, sizeof(*args));
|
|
args->guidPixFormat = GUID_PKPixelFormatDontCare;
|
|
// args->bFlagRGB_BGR = FALSE; //default BGR
|
|
args->bVerbose = FALSE;
|
|
args->tThumbnailFactor = 0;
|
|
args->oOrientation = O_NONE;
|
|
args->cPostProcStrength = 0;
|
|
args->uAlphaMode = 255;
|
|
args->sbSubband = SB_ALL;
|
|
}
|
|
|
|
ERR WmpDecAppValidateArgs(WMPDECAPPARGS* args)
|
|
{
|
|
ERR err = WMP_errSuccess;
|
|
|
|
Test(NULL != args->szInputFile, WMP_errInvalidParameter);
|
|
Test(NULL != args->szOutputFile, WMP_errInvalidParameter);
|
|
//Test(GUID_PKPixelFormatDontCare != args->enPixelFormat, WMP_errInvalidParameter);
|
|
|
|
Cleanup:
|
|
return err;
|
|
}
|
|
|
|
ERR WmpDecAppParseArgs(int argc, char* argv[], WMPDECAPPARGS* args)
|
|
{
|
|
ERR err = WMP_errSuccess;
|
|
|
|
int c = 0, i = 1;
|
|
// char* arg = NULL;
|
|
|
|
static const PKPixelFormatGUID* pixelFormat[] =
|
|
{
|
|
&GUID_PKPixelFormat24bppRGB,
|
|
|
|
&GUID_PKPixelFormatBlackWhite,
|
|
|
|
&GUID_PKPixelFormat8bppGray,
|
|
&GUID_PKPixelFormat16bppGray,
|
|
&GUID_PKPixelFormat16bppGrayFixedPoint,
|
|
&GUID_PKPixelFormat16bppGrayHalf,
|
|
&GUID_PKPixelFormatDontCare, // &GUID_PKPixelFormat32bppGray,
|
|
&GUID_PKPixelFormat32bppGrayFixedPoint,
|
|
&GUID_PKPixelFormat32bppGrayFloat,
|
|
|
|
&GUID_PKPixelFormat24bppRGB,
|
|
&GUID_PKPixelFormat48bppRGB,
|
|
&GUID_PKPixelFormat48bppRGBFixedPoint,
|
|
&GUID_PKPixelFormat48bppRGBHalf,
|
|
&GUID_PKPixelFormatDontCare, // &GUID_PKPixelFormat96bppRGB,
|
|
&GUID_PKPixelFormat96bppRGBFixedPoint,
|
|
&GUID_PKPixelFormat128bppRGBFloat,
|
|
|
|
&GUID_PKPixelFormat32bppRGBE,
|
|
&GUID_PKPixelFormat32bppCMYK,
|
|
&GUID_PKPixelFormat64bppCMYK,
|
|
|
|
&GUID_PKPixelFormat12bppYUV420,
|
|
&GUID_PKPixelFormat16bppYUV422,
|
|
&GUID_PKPixelFormat24bppYUV444,
|
|
|
|
// &GUID_PKPixelFormat32bppRGBA,
|
|
&GUID_PKPixelFormat32bppBGRA,
|
|
&GUID_PKPixelFormat64bppRGBA,
|
|
&GUID_PKPixelFormat64bppRGBAFixedPoint,
|
|
&GUID_PKPixelFormat64bppRGBAHalf,
|
|
&GUID_PKPixelFormatDontCare, // &GUID_PKPixelFormat128bppRGBA,
|
|
&GUID_PKPixelFormat128bppRGBAFixedPoint,
|
|
&GUID_PKPixelFormat128bppRGBAFloat,
|
|
&GUID_PKPixelFormat16bppRGB555,
|
|
&GUID_PKPixelFormat16bppRGB565,
|
|
&GUID_PKPixelFormat32bppRGB101010,
|
|
&GUID_PKPixelFormat40bppCMYKAlpha,
|
|
&GUID_PKPixelFormat80bppCMYKAlpha,
|
|
&GUID_PKPixelFormat32bppBGR,
|
|
&GUID_PKPixelFormat32bppPBGRA,
|
|
&GUID_PKPixelFormat64bppPRGBA,
|
|
&GUID_PKPixelFormat128bppPRGBAFloat,
|
|
};
|
|
|
|
size_t InvalidPF[9] = {6, 13, 19, 20, 21, 26, 35, 36, 37};
|
|
int k;
|
|
|
|
WmpDecAppInitDefaultArgs(args);
|
|
|
|
while(i < argc && argv[i][0] == '-')
|
|
// while (EOF != (c = argit(argc, argv, "i:o:c:ptv", &arg)))
|
|
{
|
|
/* separate out the no-argument switches */
|
|
switch ((c = argv[i][1])) {
|
|
case 't':
|
|
// NOOP - now we always print timing info
|
|
break;
|
|
|
|
case 'v':
|
|
args->bVerbose = !FALSE;
|
|
break;
|
|
|
|
case 'C':
|
|
args->bIgnoreOverlap = TRUE;
|
|
break;
|
|
|
|
case 'f':
|
|
args->bfBitstreamFormat = FREQUENCY;
|
|
break;
|
|
|
|
default:
|
|
i ++;
|
|
if (i == argc || argv[i][0] == '-') // need more info
|
|
Call(WMP_errInvalidArgument);
|
|
|
|
switch (c)
|
|
{
|
|
case 'i':
|
|
args->szInputFile= argv[i];
|
|
break;
|
|
|
|
case 'o':
|
|
args->szOutputFile = argv[i];
|
|
break;
|
|
|
|
case 'p':
|
|
args->cPostProcStrength = (U8)atoi(argv[i]);
|
|
break;
|
|
|
|
case 'c':
|
|
{
|
|
size_t idxPF = (size_t)atol(argv[i]);
|
|
|
|
FailIf(sizeof2(pixelFormat) <= idxPF, WMP_errUnsupportedFormat);
|
|
|
|
for (k = 0; k < 9; k++)
|
|
{
|
|
if (InvalidPF[k] == idxPF)
|
|
{
|
|
printf("*** ERROR: Unsupported format in JPEG XR ***\n");
|
|
Call(WMP_errInvalidArgument);
|
|
}
|
|
}
|
|
|
|
args->guidPixFormat = *pixelFormat[idxPF];
|
|
|
|
break;
|
|
}
|
|
|
|
/* case 'R':
|
|
args->bFlagRGB_BGR = (Bool)atoi(argv[i]);
|
|
break;
|
|
*/
|
|
case 'a':
|
|
args->uAlphaMode = (U8)atoi(argv[i]);
|
|
break;
|
|
|
|
case 's':
|
|
args->sbSubband = (SUBBAND)atoi(argv[i]);
|
|
break;
|
|
|
|
case 'r': // Region decode
|
|
if(i + 3 >= argc || argv[i + 1][0] == '-' || argv[i + 2][0] == '-' || argv[i + 3][0] == '-') // not a valid region
|
|
Call(WMP_errInvalidArgument);
|
|
|
|
args->rTopY = (size_t)atoi(argv[i]);
|
|
args->rLeftX = (size_t)atoi(argv[i + 1]);
|
|
args->rHeight = (size_t)atoi(argv[i + 2]);
|
|
args->rWidth = (size_t)atoi(argv[i + 3]);
|
|
i += 3;
|
|
|
|
break;
|
|
|
|
case 'T': // thumnail decode
|
|
args->tThumbnailFactor = (size_t)atoi(argv[i]);
|
|
if (args->tThumbnailFactor == 0) { // skip flexbits
|
|
args->tThumbnailFactor = SKIPFLEXBITS;
|
|
}
|
|
break;
|
|
|
|
case 'O': // orientation
|
|
args->oOrientation = (atoi(argv[i]) < 8 ? atoi(argv[i]) : O_NONE);
|
|
break;
|
|
|
|
default:
|
|
Call(WMP_errInvalidArgument);
|
|
break;
|
|
}
|
|
}
|
|
|
|
i ++;
|
|
}
|
|
|
|
Call(WmpDecAppValidateArgs(args));
|
|
|
|
Cleanup:
|
|
return err;
|
|
}
|
|
|
|
|
|
//================================================================
|
|
// Encoder factory on file extension
|
|
//================================================================
|
|
ERR WmpDecAppCreateEncoderFromExt(
|
|
PKCodecFactory* pCFactory,
|
|
const char* szExt,
|
|
PKImageEncode** ppIE)
|
|
{
|
|
ERR err = WMP_errSuccess;
|
|
const PKIID* pIID = NULL;
|
|
|
|
UNREFERENCED_PARAMETER( pCFactory );
|
|
|
|
// get encod PKIID
|
|
Call(GetTestEncodeIID(szExt, &pIID));
|
|
|
|
// Create encoder
|
|
Call(PKTestFactory_CreateCodec(pIID, ppIE));
|
|
|
|
Cleanup:
|
|
return err;
|
|
}
|
|
|
|
|
|
//================================================================
|
|
// main function
|
|
//================================================================
|
|
int
|
|
#ifndef __ANSI__
|
|
__cdecl
|
|
#endif // __ANSI__
|
|
main(int argc, char* argv[])
|
|
{
|
|
ERR err = WMP_errSuccess;
|
|
|
|
PKFactory* pFactory = NULL;
|
|
PKCodecFactory* pCodecFactory = NULL;
|
|
PKImageDecode* pDecoder = NULL;
|
|
|
|
WMPDECAPPARGS args = {0};
|
|
char* pExt = NULL;
|
|
U32 cFrame = 0;
|
|
U32 i = 0;
|
|
PKPixelInfo PI;
|
|
// static size_t cChannels[CFT_MAX] = {1, 3, 3, 3, 4, 4, -1, 3, 3, -1};
|
|
|
|
//================================
|
|
// parse command line parameters
|
|
if (1 == argc)
|
|
{
|
|
WmpDecAppUsage(argv[0]);
|
|
return 0;
|
|
}
|
|
|
|
Call(WmpDecAppParseArgs(argc, argv, &args));
|
|
if (args.bVerbose)
|
|
{
|
|
WmpDecAppShowArgs(&args);
|
|
}
|
|
|
|
//================================
|
|
pExt = strrchr(args.szOutputFile, '.');
|
|
FailIf(NULL == pExt, WMP_errUnsupportedFormat);
|
|
|
|
//================================
|
|
Call(PKCreateFactory(&pFactory, PK_SDK_VERSION));
|
|
|
|
Call(PKCreateCodecFactory(&pCodecFactory, WMP_SDK_VERSION));
|
|
Call(pCodecFactory->CreateDecoderFromFile(args.szInputFile, &pDecoder));
|
|
|
|
//==== set default color format
|
|
if(IsEqualGUID(&args.guidPixFormat, &GUID_PKPixelFormatDontCare)) {
|
|
// take deocder color format and try to look up better one
|
|
// (e.g. 32bppBGR -> 24bppBGR etc.)
|
|
PKPixelInfo newPI;
|
|
newPI.pGUIDPixFmt = PI.pGUIDPixFmt = &pDecoder->guidPixFormat;
|
|
Call(PixelFormatLookup(&newPI, LOOKUP_FORWARD));
|
|
Call(PixelFormatLookup(&newPI, LOOKUP_BACKWARD_TIF));
|
|
args.guidPixFormat = *newPI.pGUIDPixFmt;
|
|
}
|
|
else
|
|
PI.pGUIDPixFmt = &args.guidPixFormat;
|
|
|
|
// pDecoder->WMP.wmiI.bRGB = args.bFlagRGB_BGR;
|
|
|
|
// == color transcoding,
|
|
if(IsEqualGUID(&args.guidPixFormat, &GUID_PKPixelFormat8bppGray) || IsEqualGUID(&args.guidPixFormat, &GUID_PKPixelFormat16bppGray)){ // ** => Y transcoding
|
|
pDecoder->guidPixFormat = args.guidPixFormat;
|
|
pDecoder->WMP.wmiI.cfColorFormat = Y_ONLY;
|
|
}
|
|
else if(IsEqualGUID(&args.guidPixFormat, &GUID_PKPixelFormat24bppRGB) && pDecoder->WMP.wmiI.cfColorFormat == CMYK){ // CMYK = > RGB
|
|
pDecoder->WMP.wmiI.cfColorFormat = CF_RGB;
|
|
pDecoder->guidPixFormat = args.guidPixFormat;
|
|
pDecoder->WMP.wmiI.bRGB = 1; //RGB
|
|
}
|
|
|
|
PixelFormatLookup(&PI, LOOKUP_FORWARD);
|
|
|
|
if(255 == args.uAlphaMode)//user didn't set
|
|
{
|
|
if(!!(PI.grBit & PK_pixfmtHasAlpha))
|
|
args.uAlphaMode = 2;//default is image & alpha for formats with alpha
|
|
else
|
|
args.uAlphaMode = 0;//otherwise, 0
|
|
}
|
|
|
|
pDecoder->WMP.wmiSCP.bfBitstreamFormat = args.bfBitstreamFormat;
|
|
pDecoder->WMP.wmiSCP.uAlphaMode = args.uAlphaMode;
|
|
pDecoder->WMP.wmiSCP.sbSubband = args.sbSubband;
|
|
pDecoder->WMP.bIgnoreOverlap = args.bIgnoreOverlap;
|
|
|
|
pDecoder->WMP.wmiI.cfColorFormat = PI.cfColorFormat;
|
|
|
|
pDecoder->WMP.wmiI.bdBitDepth = PI.bdBitDepth;
|
|
pDecoder->WMP.wmiI.cBitsPerUnit = PI.cbitUnit;
|
|
|
|
//==== Validate thumbnail decode parameters =====
|
|
pDecoder->WMP.wmiI.cThumbnailWidth = pDecoder->WMP.wmiI.cWidth;
|
|
pDecoder->WMP.wmiI.cThumbnailHeight = pDecoder->WMP.wmiI.cHeight;
|
|
pDecoder->WMP.wmiI.bSkipFlexbits = FALSE;
|
|
if(args.tThumbnailFactor > 0 && args.tThumbnailFactor != SKIPFLEXBITS){
|
|
size_t tSize = ((size_t)1 << args.tThumbnailFactor);
|
|
|
|
pDecoder->WMP.wmiI.cThumbnailWidth = (pDecoder->WMP.wmiI.cWidth + tSize - 1) / tSize;
|
|
pDecoder->WMP.wmiI.cThumbnailHeight = (pDecoder->WMP.wmiI.cHeight + tSize - 1) / tSize;
|
|
|
|
if(pDecoder->WMP.wmiI.cfColorFormat == YUV_420 || pDecoder->WMP.wmiI.cfColorFormat == YUV_422){ // unsupported thumbnail format
|
|
pDecoder->WMP.wmiI.cfColorFormat = YUV_444;
|
|
}
|
|
}
|
|
else if (args.tThumbnailFactor == SKIPFLEXBITS) {
|
|
pDecoder->WMP.wmiI.bSkipFlexbits = TRUE;
|
|
}
|
|
|
|
if(args.rWidth == 0 || args.rHeight == 0){ // no region decode
|
|
args.rLeftX = args.rTopY = 0;
|
|
args.rWidth = pDecoder->WMP.wmiI.cThumbnailWidth;
|
|
args.rHeight = pDecoder->WMP.wmiI.cThumbnailHeight;
|
|
}
|
|
pDecoder->WMP.wmiI.cROILeftX = args.rLeftX;
|
|
pDecoder->WMP.wmiI.cROITopY = args.rTopY;
|
|
pDecoder->WMP.wmiI.cROIWidth = args.rWidth;
|
|
pDecoder->WMP.wmiI.cROIHeight = args.rHeight;
|
|
|
|
pDecoder->WMP.wmiI.oOrientation = args.oOrientation;
|
|
|
|
pDecoder->WMP.wmiI.cPostProcStrength = args.cPostProcStrength;
|
|
|
|
pDecoder->WMP.wmiSCP.bVerbose = args.bVerbose;
|
|
|
|
Call(pDecoder->GetFrameCount(pDecoder, &cFrame));
|
|
|
|
//================================
|
|
for (i = 0; ; ++i)
|
|
{
|
|
struct WMPStream* pEncodeStream = NULL;
|
|
PKImageEncode* pEncoder = NULL;
|
|
|
|
PKFormatConverter* pConverter = NULL;
|
|
|
|
Float rX = 0.0, rY = 0.0;
|
|
PKRect rect = {0, 0, 0, 0};
|
|
|
|
//================================
|
|
Call(pCodecFactory->CreateFormatConverter(&pConverter));
|
|
|
|
Call(pConverter->Initialize(pConverter, pDecoder, pExt, args.guidPixFormat));
|
|
|
|
//================================
|
|
Call(pFactory->CreateStreamFromFilename(&pEncodeStream, args.szOutputFile, "wb"));
|
|
Call(WmpDecAppCreateEncoderFromExt(pCodecFactory, pExt, &pEncoder));
|
|
|
|
if(pEncoder->bWMP)
|
|
Call(pEncoder->Initialize(pEncoder, pEncodeStream, &args.wmiSCP, sizeof(args.wmiSCP)));
|
|
else
|
|
Call(pEncoder->Initialize(pEncoder, pEncodeStream, NULL, 0));
|
|
|
|
//================================
|
|
Call(pEncoder->SetPixelFormat(pEncoder, args.guidPixFormat));
|
|
pEncoder->WMP.wmiSCP.bBlackWhite = pDecoder->WMP.wmiSCP.bBlackWhite;
|
|
|
|
//Call(pDecoder->GetSize(pDecoder, &rect.Width, &rect.Height));
|
|
rect.Width = (I32)(pDecoder->WMP.wmiI.cROIWidth);
|
|
rect.Height = (I32)(pDecoder->WMP.wmiI.cROIHeight);
|
|
|
|
if(args.oOrientation > O_FLIPVH){ // allocate memory for rotated image!
|
|
I32 bah = rect.Width;
|
|
|
|
rect.Width = rect.Height;
|
|
rect.Height = bah;
|
|
}
|
|
|
|
Call(pEncoder->SetSize(pEncoder, rect.Width, rect.Height));
|
|
|
|
Call(pDecoder->GetResolution(pDecoder, &rX, &rY));
|
|
if(args.oOrientation > O_FLIPVH)
|
|
Call(pEncoder->SetResolution(pEncoder, rY, rX));
|
|
else
|
|
Call(pEncoder->SetResolution(pEncoder, rX, rY));
|
|
|
|
if(pEncoder->bWMP && args.tThumbnailFactor > 0){
|
|
printf("-T can not be used for compressed domain operation!\n");
|
|
return 0;
|
|
}
|
|
|
|
//================================
|
|
pEncoder->WriteSource = PKImageEncode_Transcode;
|
|
Call(pEncoder->WriteSource(pEncoder, pConverter, &rect));
|
|
|
|
//================================
|
|
// Call(pEncoder->Terminate(pEncoder));
|
|
pEncoder->Release(&pEncoder);
|
|
|
|
// multi-frame support NYI
|
|
if (i + 1 == cFrame)
|
|
{
|
|
break;
|
|
}
|
|
|
|
Call(pDecoder->SelectFrame(pDecoder, i + 1));
|
|
}
|
|
|
|
pDecoder->Release(&pDecoder);
|
|
|
|
Cleanup:
|
|
if (WMP_errUnsupportedFormat == err)
|
|
{
|
|
printf("*** ERROR: Unsupported format in JPEG XR ***\n");
|
|
}
|
|
else if (WMP_errSuccess != err)
|
|
{
|
|
WmpDecAppUsage(argv[0]);
|
|
}
|
|
|
|
return (int)err;
|
|
}
|