ERR ilPKCodecFactory_CreateDecoderFromFile(PKImageDecode** ppDecoder)
{
ERR err = WMP_errSuccess;
char *pExt = ".wdp"; // We are loading a WDP file, so we have to tell the library that with this extension.
PKIID* pIID = NULL;
struct WMPStream* pStream = NULL;
PKImageDecode* pDecoder = NULL;
// get decode PKIID
Call(GetImageDecodeIID(pExt, &pIID));
// create stream
Call(ilCreateWS_File(&pStream, NULL, "rb"));
// Create decoder
Call(PKCodecFactory_CreateCodec(pIID, ppDecoder));
pDecoder = *ppDecoder;
// attach stream to decoder
Call(pDecoder->Initialize(pDecoder, pStream));
pDecoder->fStreamOwner = !0;
Cleanup:
return err;
}
ERR PKTestFactory_CreateDecoderFromFile(const char* szFilename, PKImageDecode** ppDecoder)
{
ERR err = WMP_errSuccess;
char *pExt = NULL;
PKIID* pIID = NULL;
struct WMPStream* pStream = NULL;
PKImageDecode* pDecoder = NULL;
// get file extension
pExt = strrchr(szFilename, '.');
FailIf(NULL == pExt, WMP_errUnsupportedFormat);
// get decode PKIID
Call(GetTestDecodeIID(pExt, &pIID));
// create stream
Call(CreateWS_File(&pStream, szFilename, "rb"));
// Create decoder
Call(PKTestFactory_CreateCodec(pIID, ppDecoder));
pDecoder = *ppDecoder;
// attach stream to decoder
Call(pDecoder->Initialize(pDecoder, pStream));
pDecoder->fStreamOwner = !0;
Cleanup:
return err;
}
ERR PKCodecFactory_CreateDecoderFromFile(const char* szFilename, PKImageDecode** ppDecoder)
{
ERR err = WMP_errSuccess;
char *pExt = NULL;
const PKIID* pIID = NULL;
struct WMPStream* pStream = NULL;
PKImageDecode* pDecoder = NULL;
// get file extension
pExt = strrchr(szFilename, '.');
FailIf(NULL == pExt, WMP_errUnsupportedFormat);
// get decode PKIID
Call(GetImageDecodeIID(pExt, &pIID));
// create stream
Call(CreateWS_File(&pStream, szFilename, "rb"));
// Create decoder
#if 0
Call(PKCodecFactory_CreateCodec(pIID, (void **) ppDecoder));
#else
// We know we are creating a decoder here
Call(PKImageDecode_Create_WMP(ppDecoder));
#endif
pDecoder = *ppDecoder;
// attach stream to decoder
Call(pDecoder->Initialize(pDecoder, pStream));
pDecoder->fStreamOwner = !0;
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;
}
//================================================================
// main function
//================================================================
int
#ifndef __ANSI__
__cdecl
#endif // __ANSI__
jxrlibDecodeMain(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));
#if 0
Call(pCodecFactory->CreateDecoderFromFile(args.szInputFile, &pDecoder));
#else
Call(PKCodecFactory_CreateDecoderFromFile(args.szInputFile, &pDecoder));
#endif
// Fix the wrong image plane byte count
{
long fileSize;
FILE *pFile = pDecoder->pStream->state.file.pFile;
fseek(pFile, 0, SEEK_END);
fileSize = ftell(pFile);
if (args.bVerbose) {
printf("File size: %ld\n", fileSize);
}
fseek(pFile, 0, SEEK_SET);
if ((U32)fileSize < pDecoder->WMP.wmiDEMisc.uImageOffset + pDecoder->WMP.wmiDEMisc.uImageByteCount)
{
size_t byteCount = fileSize - pDecoder->WMP.wmiDEMisc.uImageOffset;
pDecoder->WMP.wmiDEMisc.uImageByteCount = byteCount;
pDecoder->WMP.wmiI.uImageByteCount = byteCount;
}
// Circumvent the bug in JXELIB's JPEG-XR encoder that used to write wrong alpha plane byte count.
// Adjust the alpha plane byte count if the value is wrong.
if (pDecoder->WMP.wmiDEMisc.uAlphaOffset + pDecoder->WMP.wmiI_Alpha.uImageByteCount > (U32)fileSize)
pDecoder->WMP.wmiI_Alpha.uImageByteCount = fileSize - pDecoder->WMP.wmiDEMisc.uAlphaOffset;
}
//////////////// Save color profile ///////////////////
if (args.szColorProfileFile && pDecoder->WMP.wmiDEMisc.uColorProfileByteCount != 0)
{
size_t cb = pDecoder->WMP.wmiDEMisc.uColorProfileByteCount;
void *buf = malloc(cb);
if (buf)
{
U32 cbRead = cb;
ERR err = PKImageDecode_GetColorContext_WMP(pDecoder, (U8 *)buf, &cbRead);
if (WMP_errSuccess == err)
{
// Save color pfofile in a file
FILE *pFile;
#ifdef WIN32
FailIf(0 != fopen_s(&pFile, args.szColorProfileFile, "wb"), WMP_errFileIO);
#else
pFile = fopen(args.szColorProfileFile, "wb");
FailIf(NULL == pFile, WMP_errFileIO);
#endif
FailIf(1 != fwrite(buf, cb, 1, pFile), WMP_errFileIO);
fclose(pFile);
}
free(buf);
}
}
///////////////////////////////////////////////////////////////
//==== 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};
//================================
#if 0
Call(pCodecFactory->CreateFormatConverter(&pConverter));
#else
Call(PKCodecFactory_CreateFormatConverter(&pConverter));
#endif
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));
//!!! Do it here instead of JXRGlueEnc.c in order to avoid dependence of purely encoding applications on JXRDecodeLib.lib!!!
pEncoder->Transcode = PKImageEncode_Transcode_WMP;
//================================
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");
}
return (int)err;
}
//================================================================
// main function
//================================================================
int
#ifndef __ANSI__
__cdecl
#endif // __ANSI__
main(int argc, char* argv[])
{
if (argc != 5) {
fprintf(stderr, "Required arguments:\n");
fprintf(stderr, "1. JPEG quality value, 0-100\n");
fprintf(stderr, "2. Image size (e.g. '512x512')\n");
fprintf(stderr, "3. Path to YUV input file\n");
fprintf(stderr, "4. Path to JXR output file\n");
return 1;
}
errno = 0;
long quality = strtol(argv[1], NULL, 10);
if (errno != 0 || quality < 0 || quality > 100) {
fprintf(stderr, "Invalid JPEG quality value!\n");
return 1;
}
const char *size = argv[2];
const char *x = strchr(size, 'x');
if (!x && x != size && x != (x + strlen(x) - 1)) {
fprintf(stderr, "Invalid image size input!\n");
return 1;
}
long width = strtol(size, NULL, 10);
if (errno != 0) {
fprintf(stderr, "Invalid image size input!\n");
return 1;
}
long height = strtol(x + 1, NULL, 10);
if (errno != 0) {
fprintf(stderr, "Invalid image size input!\n");
return 1;
}
/* Right now we only support dimensions that are multiples of 16. */
if ((width % 16) != 0 || (height % 16) != 0) {
fprintf(stderr, "Image dimensions must be multiples of 16!\n");
return 1;
}
/* Will check these for validity when opening via 'fopen'. */
const char *yuv_path = argv[3];
const char *jxr_path = argv[4];
int yuv_size = width*height+2*(width>>1)*(height>>1);
unsigned char *image_buffer = (unsigned char*)malloc(yuv_size);
// set encoder parameters including quality
{
CWMIStrCodecParam params;
init_encoder_params(¶ms, quality);
// run encoder
ERR err;
PKFactory* pFactory = NULL;
PKCodecFactory* pCodecFactory = NULL;
struct WMPStream* pEncodeStream = NULL;
PKImageEncode* pEncoder = NULL;
const PKIID* pIID = NULL;
struct WMPStream* pDecodeStream = NULL;
PKImageDecode* pDecoder = NULL;
Call( PKCreateFactory(&pFactory, PK_SDK_VERSION) );
Call( pFactory->CreateStreamFromFilename(&pEncodeStream, jxr_path, "wb") );
Call( pFactory->CreateStreamFromFilename(&pDecodeStream, yuv_path, "rb") );
// decode
PKRect rc;
rc.X = 0;
rc.Y = 0;
rc.Width = width;
rc.Height = height;
Call( GetTestDecodeIID(".iyuv", &pIID) );
Call( PKTestFactory_CreateCodec(pIID, (void **) &pDecoder) );
Call( pDecoder->Initialize(pDecoder, pDecodeStream) );
pDecoder->uWidth = width;
pDecoder->uHeight = height;
Call( pDecoder->Copy(pDecoder, &rc, (U8*)image_buffer, width) );
Call( PKCreateCodecFactory(&pCodecFactory, WMP_SDK_VERSION) );
Call( pCodecFactory->CreateCodec(&IID_PKImageWmpEncode, (void**)&pEncoder) );
Call( pEncoder->Initialize(pEncoder, pEncodeStream, ¶ms, sizeof(params)) );
Call( pEncoder->SetPixelFormat(pEncoder, GUID_PKPixelFormat12bppYCC420) );
Call( pEncoder->SetSize(pEncoder, width, height) );
Call( pEncoder->WritePixels(pEncoder, height, (U8*)image_buffer, width*3) );
Cleanup:
if( pDecoder ) pDecoder->Release(&pDecoder);
if( pEncoder ) pEncoder->Release(&pEncoder);
if( pCodecFactory ) pCodecFactory->Release(&pCodecFactory);
if( pFactory ) pFactory->Release(&pFactory);
}
free(image_buffer);
return 0;
}
static FIBITMAP * DLL_CALLCONV
Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
PKImageDecode *pDecoder = NULL; // decoder interface
ERR error_code = 0; // error code as returned by the interface
PKPixelFormatGUID guid_format; // loaded pixel format (== input file pixel format if no conversion needed)
FREE_IMAGE_TYPE image_type = FIT_UNKNOWN; // input image type
unsigned bpp = 0; // input image bit depth
FIBITMAP *dib = NULL;
// get the I/O stream wrapper
WMPStream *pDecodeStream = (WMPStream*)data;
if(!handle || !pDecodeStream) {
return NULL;
}
BOOL header_only = (flags & FIF_LOAD_NOPIXELS) == FIF_LOAD_NOPIXELS;
try {
int width, height; // image dimensions (in pixels)
// create a JXR decoder interface and initialize function pointers with *_WMP functions
error_code = PKImageDecode_Create_WMP(&pDecoder);
JXR_CHECK(error_code);
// attach the stream to the decoder ...
// ... then read the image container and the metadata
error_code = pDecoder->Initialize(pDecoder, pDecodeStream);
JXR_CHECK(error_code);
// set decoder parameters
SetDecoderParameters(pDecoder, flags);
// get dst image format specifications
unsigned red_mask = 0, green_mask = 0, blue_mask = 0;
error_code = GetInputPixelFormat(pDecoder, &guid_format, &image_type, &bpp, &red_mask, &green_mask, &blue_mask);
JXR_CHECK(error_code);
// get image dimensions
pDecoder->GetSize(pDecoder, &width, &height);
// allocate dst image
{
dib = FreeImage_AllocateHeaderT(header_only, image_type, width, height, bpp, red_mask, green_mask, blue_mask);
if(!dib) {
throw FI_MSG_ERROR_DIB_MEMORY;
}
if(FreeImage_GetBPP(dib) == 1) {
// BD_1 - build a FIC_MINISBLACK palette
RGBQUAD *pal = FreeImage_GetPalette(dib);
pal[0].rgbRed = pal[0].rgbGreen = pal[0].rgbBlue = 0;
pal[1].rgbRed = pal[1].rgbGreen = pal[1].rgbBlue = 255;
}
}
// get image resolution
{
float resX, resY; // image resolution (in dots per inch)
// convert from English units, i.e. dots per inch to universal units, i.e. dots per meter
pDecoder->GetResolution(pDecoder, &resX, &resY);
FreeImage_SetDotsPerMeterX(dib, (unsigned)(resX / 0.0254F + 0.5F));
FreeImage_SetDotsPerMeterY(dib, (unsigned)(resY / 0.0254F + 0.5F));
}
// get metadata & ICC profile
error_code = ReadMetadata(pDecoder, dib);
JXR_CHECK(error_code);
if(header_only) {
// header only mode ...
// free the decoder
pDecoder->Release(&pDecoder);
assert(pDecoder == NULL);
return dib;
}
// copy pixels into the dib, perform pixel conversion if needed
error_code = CopyPixels(pDecoder, guid_format, dib, width, height);
JXR_CHECK(error_code);
// free the decoder
pDecoder->Release(&pDecoder);
assert(pDecoder == NULL);
return dib;
} catch (const char *message) {
// unload the dib
FreeImage_Unload(dib);
// free the decoder
pDecoder->Release(&pDecoder);
if(NULL != message) {
FreeImage_OutputMessageProc(s_format_id, message);
}
}
return NULL;
}
