/src/freeimage-svn/FreeImage/trunk/Source/FreeImage/PluginJXR.cpp

Source
// ==========================================================
// JPEG XR Loader & Writer
//
// Design and implementation by
// - Herve Drolon (drolon@infonie.fr)
//
// This file is part of FreeImage 3
//
// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
// THIS DISCLAIMER.
//
// Use at your own risk!
// ==========================================================

#include "FreeImage.h"
#include "Utilities.h"
#include "../Metadata/FreeImageTag.h"

#include "../LibJXR/jxrgluelib/JXRGlue.h"

// ==========================================================
// Plugin Interface
// ==========================================================

static int s_format_id;

// ==========================================================
// FreeImageIO interface (I/O streaming functions)
// ==========================================================

/**
JXR wrapper for FreeImage I/O handle
*/
typedef struct tagFreeImageJXRIO {
    FreeImageIO *io;
  fi_handle handle;
} FreeImageJXRIO;

static ERR 
_jxr_io_Read(WMPStream* pWS, void* pv, size_t cb) {
  FreeImageJXRIO *fio = (FreeImageJXRIO*)pWS->state.pvObj;
  return (fio->io->read_proc(pv, (unsigned)cb, 1, fio->handle) == 1) ? WMP_errSuccess : WMP_errFileIO;
}

static ERR 
_jxr_io_Write(WMPStream* pWS, const void* pv, size_t cb) {
  FreeImageJXRIO *fio = (FreeImageJXRIO*)pWS->state.pvObj;
  if(0 != cb) {
    return (fio->io->write_proc((void*)pv, (unsigned)cb, 1, fio->handle) == 1) ? WMP_errSuccess : WMP_errFileIO;
  }
  return WMP_errFileIO;
}

static ERR 
_jxr_io_SetPos(WMPStream* pWS, size_t offPos) {
  FreeImageJXRIO *fio = (FreeImageJXRIO*)pWS->state.pvObj;
    return (fio->io->seek_proc(fio->handle, (long)offPos, SEEK_SET) == 0) ? WMP_errSuccess : WMP_errFileIO;
}

static ERR 
_jxr_io_GetPos(WMPStream* pWS, size_t* poffPos) {
  FreeImageJXRIO *fio = (FreeImageJXRIO*)pWS->state.pvObj;
    long lOff = fio->io->tell_proc(fio->handle);
  if(lOff == -1) {
    return WMP_errFileIO;
  }
    *poffPos = (size_t)lOff;
  return WMP_errSuccess;
}

static Bool 
_jxr_io_EOS(WMPStream* pWS) {
  FreeImageJXRIO *fio = (FreeImageJXRIO*)pWS->state.pvObj;
    long currentPos = fio->io->tell_proc(fio->handle);
    fio->io->seek_proc(fio->handle, 0, SEEK_END);
    long fileRemaining = fio->io->tell_proc(fio->handle) - currentPos;
    fio->io->seek_proc(fio->handle, currentPos, SEEK_SET);
    return (fileRemaining > 0);
}

static ERR 
_jxr_io_Close(WMPStream** ppWS) {
  WMPStream *pWS = *ppWS;
  // HACK : we use fMem to avoid a stream destruction by the library
  // because FreeImage MUST HAVE the ownership of the stream
  // see _jxr_io_Create
  if(pWS && pWS->fMem) {
    free(pWS);
    *ppWS = NULL;
  }
  return WMP_errSuccess;
}

static ERR 
_jxr_io_Create(WMPStream **ppWS, FreeImageJXRIO *jxr_io) {
  *ppWS = (WMPStream*)calloc(1, sizeof(**ppWS));
  if(*ppWS) {
    WMPStream *pWS = *ppWS;

    pWS->state.pvObj = jxr_io;
    pWS->Close = _jxr_io_Close;
    pWS->EOS = _jxr_io_EOS;
    pWS->Read = _jxr_io_Read;
    pWS->Write = _jxr_io_Write;
    pWS->SetPos = _jxr_io_SetPos;
    pWS->GetPos = _jxr_io_GetPos;

    // HACK : we use fMem to avoid a stream destruction by the library
    // because FreeImage MUST HAVE the ownership of the stream
    // see _jxr_io_Close
    pWS->fMem = FALSE;

    return WMP_errSuccess;
  }
  return WMP_errOutOfMemory;
}

// ==========================================================
// JPEG XR Error handling
// ==========================================================

static const char* 
JXR_ErrorMessage(const int error) {
  switch(error) {
    case WMP_errNotYetImplemented:
    case WMP_errAbstractMethod:
      return "Not yet implemented";
    case WMP_errOutOfMemory:
      return "Out of memory";
    case WMP_errFileIO:
      return "File I/O error";
    case WMP_errBufferOverflow:
      return "Buffer overflow";
    case WMP_errInvalidParameter:
      return "Invalid parameter";
    case WMP_errInvalidArgument:
      return "Invalid argument";
    case WMP_errUnsupportedFormat:
      return "Unsupported format";
    case WMP_errIncorrectCodecVersion:
      return "Incorrect codec version";
    case WMP_errIndexNotFound:
      return "Format converter: Index not found";
    case WMP_errOutOfSequence:
      return "Metadata: Out of sequence";
    case WMP_errMustBeMultipleOf16LinesUntilLastCall:
      return "Must be multiple of 16 lines until last call";
    case WMP_errPlanarAlphaBandedEncRequiresTempFile:
      return "Planar alpha banded encoder requires temp files";
    case WMP_errAlphaModeCannotBeTranscoded:
      return "Alpha mode cannot be transcoded";
    case WMP_errIncorrectCodecSubVersion:
      return "Incorrect codec subversion";
    case WMP_errFail:
    case WMP_errNotInitialized:
    default:
      return "Invalid instruction - please contact the FreeImage team";
  }
}

// ==========================================================
// Helper functions & macro
// ==========================================================

#define JXR_CHECK(error_code) \
  if(error_code < 0) { \
    const char *error_message = JXR_ErrorMessage(error_code); \
    throw error_message; \
  }

// --------------------------------------------------------------------------

/**
Input conversions natively understood by FreeImage
@see GetNativePixelFormat
*/
typedef struct tagJXRInputConversion {
  BITDEPTH_BITS bdBitDepth;
  U32 cbitUnit;
  FREE_IMAGE_TYPE image_type;
  unsigned red_mask;
  unsigned green_mask;
  unsigned blue_mask;
} JXRInputConversion;

/**
Conversion table for native FreeImage formats
@see GetNativePixelFormat
*/
static JXRInputConversion s_FreeImagePixelInfo[] = {
  // 1-bit bitmap
  { BD_1, 1, FIT_BITMAP, 0, 0, 0 },
  // 8-, 24-, 32-bit bitmap
  { BD_8, 8, FIT_BITMAP, 0, 0, 0 },
  { BD_8, 24, FIT_BITMAP, 0, 0, 0 },
  { BD_8, 32, FIT_BITMAP, 0, 0, 0 },
  // 16-bit RGB 565
  { BD_565, 16, FIT_BITMAP, FI16_565_RED_MASK, FI16_565_GREEN_MASK, FI16_565_BLUE_MASK },
  // 16-bit RGB 555
  { BD_5, 16, FIT_BITMAP, FI16_555_RED_MASK, FI16_555_GREEN_MASK, FI16_555_BLUE_MASK },
  // 16-bit greyscale, RGB16, RGBA16 bitmap
  { BD_16, 16, FIT_UINT16, 0, 0, 0 },
  { BD_16, 48, FIT_RGB16, 0, 0, 0 },
  { BD_16, 64, FIT_RGBA16, 0, 0, 0 },
  // 32-bit float, RGBF, RGBAF bitmap
  { BD_32F, 32, FIT_FLOAT, 0, 0, 0 },
  { BD_32F, 96, FIT_RGBF, 0, 0, 0 },
  { BD_32F, 128, FIT_RGBAF, 0, 0, 0 }
};

/**
Scan input pixelInfo specifications and return the equivalent FreeImage info for loading
@param pixelInfo Image specifications
@param out_guid_format (returned value) output pixel format
@param image_type (returned value) Image type
@param bpp (returned value) Image bit depth
@param red_mask (returned value) RGB mask
@param green_mask (returned value) RGB mask
@param blue_mask (returned value) RGB mask
@return Returns WMP_errSuccess if successful, returns WMP_errFail otherwise
@see GetInputPixelFormat
*/
static ERR
GetNativePixelFormat(const PKPixelInfo *pixelInfo, PKPixelFormatGUID *out_guid_format, FREE_IMAGE_TYPE *image_type, unsigned *bpp, unsigned *red_mask, unsigned *green_mask, unsigned *blue_mask) {
  const unsigned s_FreeImagePixelInfoSize = (unsigned)sizeof(s_FreeImagePixelInfo) / sizeof(*(s_FreeImagePixelInfo));

  for(unsigned i = 0; i < s_FreeImagePixelInfoSize; i++) {
    if(pixelInfo->bdBitDepth == s_FreeImagePixelInfo[i].bdBitDepth) {
      if(pixelInfo->cbitUnit == s_FreeImagePixelInfo[i].cbitUnit) {
        // found ! now get dst image format specifications
        memcpy(out_guid_format, pixelInfo->pGUIDPixFmt, sizeof(PKPixelFormatGUID));
        *image_type = s_FreeImagePixelInfo[i].image_type;
        *bpp = s_FreeImagePixelInfo[i].cbitUnit;
        *red_mask = s_FreeImagePixelInfo[i].red_mask;
        *green_mask = s_FreeImagePixelInfo[i].green_mask;
        *blue_mask  = s_FreeImagePixelInfo[i].blue_mask;
        return WMP_errSuccess;
      }
    }
  }

  // not found : need pixel format conversion
  return WMP_errFail;
}

/**
Scan input file guid format and return the equivalent FreeImage info & target guid format for loading
@param pDecoder Decoder handle
@param guid_format (returned value) Output pixel format
@param image_type (returned value) Image type
@param bpp (returned value) Image bit depth
@param red_mask (returned value) RGB mask
@param green_mask (returned value) RGB mask
@param blue_mask (returned value) RGB mask
@return Returns TRUE if successful, returns FALSE otherwise
*/
static ERR
GetInputPixelFormat(PKImageDecode *pDecoder, PKPixelFormatGUID *guid_format, FREE_IMAGE_TYPE *image_type, unsigned *bpp, unsigned *red_mask, unsigned *green_mask, unsigned *blue_mask) {
  ERR error_code = 0;   // error code as returned by the interface
  PKPixelInfo pixelInfo;  // image specifications

  try {   
    // get input file pixel format ...
    PKPixelFormatGUID pguidSourcePF;
    error_code = pDecoder->GetPixelFormat(pDecoder, &pguidSourcePF);
    JXR_CHECK(error_code);
    pixelInfo.pGUIDPixFmt = &pguidSourcePF;
    // ... check for a supported format and get the format specifications
    error_code = PixelFormatLookup(&pixelInfo, LOOKUP_FORWARD);
    JXR_CHECK(error_code);

    // search for an equivalent native FreeImage format
    error_code = GetNativePixelFormat(&pixelInfo, guid_format, image_type, bpp, red_mask, green_mask, blue_mask);

    if(error_code != WMP_errSuccess) {
      // try to find a suitable conversion function ...
      const PKPixelFormatGUID *ppguidTargetPF = NULL; // target pixel format
      unsigned iIndex = 0;  // first available conversion function
      do {
        error_code = PKFormatConverter_EnumConversions(&pguidSourcePF, iIndex, &ppguidTargetPF);
        if(error_code == WMP_errSuccess) {
          // found a conversion function, is the converted format a native FreeImage format ?
          pixelInfo.pGUIDPixFmt = ppguidTargetPF;
          error_code = PixelFormatLookup(&pixelInfo, LOOKUP_FORWARD);
          JXR_CHECK(error_code);
          error_code = GetNativePixelFormat(&pixelInfo, guid_format, image_type, bpp, red_mask, green_mask, blue_mask);
          if(error_code == WMP_errSuccess) {
            break;
          }
        }
        // try next conversion function
        iIndex++;
      } while(error_code != WMP_errIndexNotFound);

    }

    return (error_code == WMP_errSuccess) ? WMP_errSuccess : WMP_errUnsupportedFormat;

  } catch(...) {
    return error_code;
  }
}

// --------------------------------------------------------------------------

/**
Scan input dib format and return the equivalent PKPixelFormatGUID format for saving
@param dib Image to be saved
@param guid_format (returned value) GUID format
@param bHasAlpha (returned value) TRUE if an alpha layer is present
@return Returns TRUE if successful, returns FALSE otherwise
*/
static ERR
GetOutputPixelFormat(FIBITMAP *dib, PKPixelFormatGUID *guid_format, BOOL *bHasAlpha) {
  const FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);
  const unsigned bpp = FreeImage_GetBPP(dib);
  const FREE_IMAGE_COLOR_TYPE color_type = FreeImage_GetColorType(dib);

  *guid_format = GUID_PKPixelFormatDontCare;
  *bHasAlpha = FALSE;

  switch(image_type) {
    case FIT_BITMAP:  // standard image : 1-, 4-, 8-, 16-, 24-, 32-bit
      switch(bpp) {
        case 1:
          // assume FIC_MINISBLACK
          if(color_type == FIC_MINISBLACK) {
            *guid_format = GUID_PKPixelFormatBlackWhite;
          }
          break;
        case 8:
          // assume FIC_MINISBLACK
          if(color_type == FIC_MINISBLACK) {
            *guid_format = GUID_PKPixelFormat8bppGray;
          }
          break;
        case 16:
          if ((FreeImage_GetRedMask(dib) == FI16_565_RED_MASK) && (FreeImage_GetGreenMask(dib) == FI16_565_GREEN_MASK) && (FreeImage_GetBlueMask(dib) == FI16_565_BLUE_MASK)) {
            *guid_format = GUID_PKPixelFormat16bppRGB565;
          } else {
            // includes case where all the masks are 0
            *guid_format = GUID_PKPixelFormat16bppRGB555;
          }
          break;
#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
        case 24:
          *guid_format = GUID_PKPixelFormat24bppBGR;
          break;
        case 32:
          *guid_format = GUID_PKPixelFormat32bppBGRA;
          *bHasAlpha = TRUE;
          break;
#elif FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_RGB
        case 24:
          *guid_format = GUID_PKPixelFormat24bppRGB;
          break;
        case 32:
          *guid_format = GUID_PKPixelFormat32bppRGBA;
          *bHasAlpha = TRUE;
          break;
#endif
        case 4:
        default:
          // not supported
          break;
      }
      break;
    case FIT_UINT16:  // array of unsigned short  : unsigned 16-bit
      *guid_format = GUID_PKPixelFormat16bppGray;
      break;
    case FIT_FLOAT:   // array of float     : 32-bit IEEE floating point
      *guid_format = GUID_PKPixelFormat32bppGrayFloat;
      break;
    case FIT_RGB16:   // 48-bit RGB image     : 3 x 16-bit
      *guid_format = GUID_PKPixelFormat48bppRGB;
      break;
    case FIT_RGBA16:  // 64-bit RGBA image    : 4 x 16-bit
      *guid_format = GUID_PKPixelFormat64bppRGBA;
      *bHasAlpha = TRUE;
      break;
    case FIT_RGBF:    // 96-bit RGB float image : 3 x 32-bit IEEE floating point
      *guid_format = GUID_PKPixelFormat96bppRGBFloat;
      break;
    case FIT_RGBAF:   // 128-bit RGBA float image : 4 x 32-bit IEEE floating point
      *guid_format = GUID_PKPixelFormat128bppRGBAFloat;
      *bHasAlpha = TRUE;
      break;

    case FIT_INT16:   // array of short     : signed 16-bit
    case FIT_UINT32:  // array of unsigned long : unsigned 32-bit
    case FIT_INT32:   // array of long      : signed 32-bit
    case FIT_DOUBLE:  // array of double      : 64-bit IEEE floating point
    case FIT_COMPLEX: // array of FICOMPLEX   : 2 x 64-bit IEEE floating point

    default:
      // unsupported format
      break;
  }

  return (*guid_format != GUID_PKPixelFormatDontCare) ? WMP_errSuccess : WMP_errUnsupportedFormat;
}

// ==========================================================
// Metadata loading
// ==========================================================

/**
Read a JPEG-XR IFD as a buffer
@see ReadMetadata
*/
static ERR
ReadProfile(WMPStream* pStream, unsigned cbByteCount, unsigned uOffset, BYTE **ppbProfile) {
  // (re-)allocate profile buffer
  BYTE *pbProfile = *ppbProfile;
  pbProfile = (BYTE*)realloc(pbProfile, cbByteCount);
  if(!pbProfile) {
    return WMP_errOutOfMemory;
  }
  // read the profile
  if(WMP_errSuccess == pStream->SetPos(pStream, uOffset)) {
    if(WMP_errSuccess == pStream->Read(pStream, pbProfile, cbByteCount)) {
      *ppbProfile = pbProfile;
      return WMP_errSuccess;
    }
  }
  return WMP_errFileIO;
}

/**
Convert a DPKPROPVARIANT to a FITAG, then store the tag as FIMD_EXIF_MAIN
@see ReadDescriptiveMetadata
*/
static BOOL
ReadPropVariant(WORD tag_id, const DPKPROPVARIANT & varSrc, FIBITMAP *dib) {
  DWORD dwSize;

  if(varSrc.vt == DPKVT_EMPTY) {
    return FALSE;
  }

  // get the tag key
  TagLib& s = TagLib::instance();
  const char *key = s.getTagFieldName(TagLib::EXIF_MAIN, tag_id, NULL);
  if(!key) {
    return FALSE;
  }

  // create a tag
  FITAG *tag = FreeImage_CreateTag();
  if(tag) {
    // set tag ID
    FreeImage_SetTagID(tag, tag_id);
    // set tag type, count, length and value
    switch (varSrc.vt) {
      case DPKVT_LPSTR:
        FreeImage_SetTagType(tag, FIDT_ASCII);
        dwSize = (DWORD)strlen(varSrc.VT.pszVal) + 1;
        FreeImage_SetTagCount(tag, dwSize);
        FreeImage_SetTagLength(tag, dwSize);
        FreeImage_SetTagValue(tag, varSrc.VT.pszVal);
        break;
      
      case DPKVT_LPWSTR:
        FreeImage_SetTagType(tag, FIDT_UNDEFINED);
        dwSize = (DWORD)(sizeof(U16) * (wcslen((wchar_t *) varSrc.VT.pwszVal) + 1)); // +1 for NULL term
        FreeImage_SetTagCount(tag, dwSize);
        FreeImage_SetTagLength(tag, dwSize);
        FreeImage_SetTagValue(tag, varSrc.VT.pwszVal);
        break;
              
      case DPKVT_UI2:
        FreeImage_SetTagType(tag, FIDT_SHORT);
        FreeImage_SetTagCount(tag, 1);
        FreeImage_SetTagLength(tag, 2);
        FreeImage_SetTagValue(tag, &varSrc.VT.uiVal);
        break;

      case DPKVT_UI4:
        FreeImage_SetTagType(tag, FIDT_LONG);
        FreeImage_SetTagCount(tag, 1);
        FreeImage_SetTagLength(tag, 4);
        FreeImage_SetTagValue(tag, &varSrc.VT.ulVal);
        break;

      default:
        assert(FALSE); // This case is not handled
        break;
    }
    // get the tag desctiption
    const char *description = s.getTagDescription(TagLib::EXIF_MAIN, tag_id);
    FreeImage_SetTagDescription(tag, description);

    // store the tag
    FreeImage_SetMetadata(FIMD_EXIF_MAIN, dib, key, tag);

    FreeImage_DeleteTag(tag);
  }
  return TRUE;
}

/**
Read JPEG-XR descriptive metadata and store as EXIF_MAIN metadata
@see ReadPropVariant
*/
static ERR
ReadDescriptiveMetadata(PKImageDecode *pID, FIBITMAP *dib) {
  // get Exif TIFF metadata
  const DESCRIPTIVEMETADATA *pDescMetadata = &pID->WMP.sDescMetadata;
  // convert metadata to FITAG and store into the EXIF_MAIN metadata model
  ReadPropVariant(WMP_tagImageDescription, pDescMetadata->pvarImageDescription, dib);
  ReadPropVariant(WMP_tagCameraMake, pDescMetadata->pvarCameraMake, dib);
  ReadPropVariant(WMP_tagCameraModel, pDescMetadata->pvarCameraModel, dib);
  ReadPropVariant(WMP_tagSoftware, pDescMetadata->pvarSoftware, dib);
  ReadPropVariant(WMP_tagDateTime, pDescMetadata->pvarDateTime, dib);
  ReadPropVariant(WMP_tagArtist, pDescMetadata->pvarArtist, dib);
  ReadPropVariant(WMP_tagCopyright, pDescMetadata->pvarCopyright, dib);
  ReadPropVariant(WMP_tagRatingStars, pDescMetadata->pvarRatingStars, dib);
  ReadPropVariant(WMP_tagRatingValue, pDescMetadata->pvarRatingValue, dib);
  ReadPropVariant(WMP_tagCaption, pDescMetadata->pvarCaption, dib);
  ReadPropVariant(WMP_tagDocumentName, pDescMetadata->pvarDocumentName, dib);
  ReadPropVariant(WMP_tagPageName, pDescMetadata->pvarPageName, dib);
  ReadPropVariant(WMP_tagPageNumber, pDescMetadata->pvarPageNumber, dib);
  ReadPropVariant(WMP_tagHostComputer, pDescMetadata->pvarHostComputer, dib);
  return WMP_errSuccess;
}

/**
Read ICC, XMP, Exif, Exif-GPS, IPTC, descriptive (i.e. Exif-TIFF) metadata
@see ReadProfile, ReadDescriptiveMetadata
*/
static ERR
ReadMetadata(PKImageDecode *pID, FIBITMAP *dib) {
  ERR error_code = 0;   // error code as returned by the interface
  size_t currentPos = 0;  // current stream position
  
  WMPStream *pStream = pID->pStream;
  WmpDEMisc *wmiDEMisc = &pID->WMP.wmiDEMisc;
  BYTE *pbProfile = NULL;

  try {
    // save current position
    error_code = pStream->GetPos(pStream, &currentPos);
    JXR_CHECK(error_code);

    // ICC profile
    if(0 != wmiDEMisc->uColorProfileByteCount) {
      unsigned cbByteCount = wmiDEMisc->uColorProfileByteCount;
      unsigned uOffset = wmiDEMisc->uColorProfileOffset;
      error_code = ReadProfile(pStream, cbByteCount, uOffset, &pbProfile);
      JXR_CHECK(error_code);
      FreeImage_CreateICCProfile(dib, pbProfile, cbByteCount);
    }

    // XMP metadata
    if(0 != wmiDEMisc->uXMPMetadataByteCount) {
      unsigned cbByteCount = wmiDEMisc->uXMPMetadataByteCount;
      unsigned uOffset = wmiDEMisc->uXMPMetadataOffset;
      error_code = ReadProfile(pStream, cbByteCount, uOffset, &pbProfile);
      JXR_CHECK(error_code);
      // store the tag as XMP
      FITAG *tag = FreeImage_CreateTag();
      if(tag) {
        FreeImage_SetTagLength(tag, cbByteCount);
        FreeImage_SetTagCount(tag, cbByteCount);
        FreeImage_SetTagType(tag, FIDT_ASCII);
        FreeImage_SetTagValue(tag, pbProfile);
        FreeImage_SetTagKey(tag, g_TagLib_XMPFieldName);
        FreeImage_SetMetadata(FIMD_XMP, dib, FreeImage_GetTagKey(tag), tag);
        FreeImage_DeleteTag(tag);
      }
    }

    // IPTC metadata
    if(0 != wmiDEMisc->uIPTCNAAMetadataByteCount) {
      unsigned cbByteCount = wmiDEMisc->uIPTCNAAMetadataByteCount;
      unsigned uOffset = wmiDEMisc->uIPTCNAAMetadataOffset;
      error_code = ReadProfile(pStream, cbByteCount, uOffset, &pbProfile);
      JXR_CHECK(error_code);
      // decode the IPTC profile
      read_iptc_profile(dib, pbProfile, cbByteCount);
    }

    // Exif metadata
    if(0 != wmiDEMisc->uEXIFMetadataByteCount) {
      unsigned cbByteCount = wmiDEMisc->uEXIFMetadataByteCount;
      unsigned uOffset = wmiDEMisc->uEXIFMetadataOffset;
      error_code = ReadProfile(pStream, cbByteCount, uOffset, &pbProfile);
      JXR_CHECK(error_code);
      // decode the Exif profile
      jpegxr_read_exif_profile(dib, pbProfile, cbByteCount, uOffset);
    }

    // Exif-GPS metadata
    if(0 != wmiDEMisc->uGPSInfoMetadataByteCount) {
      unsigned cbByteCount = wmiDEMisc->uGPSInfoMetadataByteCount;
      unsigned uOffset = wmiDEMisc->uGPSInfoMetadataOffset;
      error_code = ReadProfile(pStream, cbByteCount, uOffset, &pbProfile);
      JXR_CHECK(error_code);
      // decode the Exif-GPS profile
      jpegxr_read_exif_gps_profile(dib, pbProfile, cbByteCount, uOffset);
    }

    // free profile buffer
    free(pbProfile);
    pbProfile = NULL;

    // restore initial position
    error_code = pID->pStream->SetPos(pID->pStream, currentPos);
    JXR_CHECK(error_code);

    // as a LAST STEP, read descriptive metadata
    // these metadata overwrite possible identical Exif-TIFF metadata 
    // that could have been read inside the Exif IFD
    
    return ReadDescriptiveMetadata(pID, dib);

  } catch(...) {
    // free profile buffer
    free(pbProfile);
    pbProfile = NULL;
    if(currentPos) {
      // restore initial position
      pStream->SetPos(pStream, currentPos);
    }
    return error_code;
  }
}

// ==========================================================
// Metadata saving
// ==========================================================

/**
Convert a FITAG (coming from FIMD_EXIF_MAIN) to a DPKPROPVARIANT.
No allocation is needed here, the function just copy pointers when needed. 
@see WriteDescriptiveMetadata
*/
static BOOL
WritePropVariant(FIBITMAP *dib, WORD tag_id, DPKPROPVARIANT & varDst) {
  FITAG *tag = NULL;

  TagLib& s = TagLib::instance();
  
  // clear output DPKPROPVARIANT
  varDst.vt = DPKVT_EMPTY;

  // given the tag id, get the tag key
  const char *key = s.getTagFieldName(TagLib::EXIF_MAIN, tag_id, NULL);
  // then, get the tag info
  if(!FreeImage_GetMetadata(FIMD_EXIF_MAIN, dib, key, &tag)) {
    return FALSE;
  }

  // set the tag value
  switch(FreeImage_GetTagType(tag)) {
    case FIDT_ASCII:
      varDst.vt = DPKVT_LPSTR;
      varDst.VT.pszVal = (char*)FreeImage_GetTagValue(tag);
      break;
    case FIDT_BYTE:
    case FIDT_UNDEFINED:
      varDst.vt = DPKVT_LPWSTR;
      varDst.VT.pwszVal = (U16*)FreeImage_GetTagValue(tag);
      break;
    case FIDT_SHORT:
      varDst.vt = DPKVT_UI2;
      varDst.VT.uiVal = *((U16*)FreeImage_GetTagValue(tag));
      break;
    case FIDT_LONG:
      varDst.vt = DPKVT_UI4;
      varDst.VT.ulVal = *((U32*)FreeImage_GetTagValue(tag));
      break;
    default:
      break;
  }
  
  return TRUE;
}

/**
Write EXIF_MAIN metadata to JPEG-XR descriptive metadata
@see WritePropVariant
*/
static ERR
WriteDescriptiveMetadata(PKImageEncode *pIE, FIBITMAP *dib) {
  ERR error_code = 0;   // error code as returned by the interface
  DESCRIPTIVEMETADATA DescMetadata;

  // fill the DESCRIPTIVEMETADATA structure (use pointers to arrays when needed)
  WritePropVariant(dib, WMP_tagImageDescription, DescMetadata.pvarImageDescription);
  WritePropVariant(dib, WMP_tagCameraMake, DescMetadata.pvarCameraMake);
  WritePropVariant(dib, WMP_tagCameraModel, DescMetadata.pvarCameraModel);
  WritePropVariant(dib, WMP_tagSoftware, DescMetadata.pvarSoftware);
  WritePropVariant(dib, WMP_tagDateTime, DescMetadata.pvarDateTime);
  WritePropVariant(dib, WMP_tagArtist, DescMetadata.pvarArtist);
  WritePropVariant(dib, WMP_tagCopyright, DescMetadata.pvarCopyright);
  WritePropVariant(dib, WMP_tagRatingStars, DescMetadata.pvarRatingStars);
  WritePropVariant(dib, WMP_tagRatingValue, DescMetadata.pvarRatingValue);
  WritePropVariant(dib, WMP_tagCaption, DescMetadata.pvarCaption);
  WritePropVariant(dib, WMP_tagDocumentName, DescMetadata.pvarDocumentName);
  WritePropVariant(dib, WMP_tagPageName, DescMetadata.pvarPageName);
  WritePropVariant(dib, WMP_tagPageNumber, DescMetadata.pvarPageNumber);
  WritePropVariant(dib, WMP_tagHostComputer, DescMetadata.pvarHostComputer);

  // copy the structure to the encoder
  error_code = pIE->SetDescriptiveMetadata(pIE, &DescMetadata);

  // no need to free anything here
  return error_code;
}

/**
Write ICC, XMP, Exif, Exif-GPS, IPTC, descriptive (i.e. Exif-TIFF) metadata
*/
static ERR
WriteMetadata(PKImageEncode *pIE, FIBITMAP *dib) {
  ERR error_code = 0;   // error code as returned by the interface
  BYTE *profile = NULL;
  unsigned profile_size = 0;
  
  try {
    // write ICC profile
    {
      FIICCPROFILE *iccProfile = FreeImage_GetICCProfile(dib);
      if(iccProfile->data) {
        error_code = pIE->SetColorContext(pIE, (U8*)iccProfile->data, iccProfile->size);
        JXR_CHECK(error_code);
      }
    }
    
    // write descriptive metadata
    if(FreeImage_GetMetadataCount(FIMD_EXIF_MAIN, dib)) {
      error_code = WriteDescriptiveMetadata(pIE, dib);
      JXR_CHECK(error_code);
    }

    // write IPTC metadata
    if(FreeImage_GetMetadataCount(FIMD_IPTC, dib)) {
      // create a binary profile
      if(write_iptc_profile(dib, &profile, &profile_size)) {
        // write the profile
        error_code = PKImageEncode_SetIPTCNAAMetadata_WMP(pIE, profile, profile_size);
        JXR_CHECK(error_code);
        // release profile
        free(profile);
        profile = NULL;
      }
    }

    // write XMP metadata
    {
      FITAG *tag_xmp = NULL;
      if(FreeImage_GetMetadata(FIMD_XMP, dib, g_TagLib_XMPFieldName, &tag_xmp)) {
        error_code = PKImageEncode_SetXMPMetadata_WMP(pIE, (BYTE*)FreeImage_GetTagValue(tag_xmp), FreeImage_GetTagLength(tag_xmp));
        JXR_CHECK(error_code);
      }
    }

    // write Exif metadata
    {
      if(tiff_get_ifd_profile(dib, FIMD_EXIF_EXIF, &profile, &profile_size)) {
        error_code = PKImageEncode_SetEXIFMetadata_WMP(pIE, profile, profile_size);
        JXR_CHECK(error_code);
        // release profile
        free(profile);
        profile = NULL;
      }
    }

    // write Exif GPS metadata
    {
      if(tiff_get_ifd_profile(dib, FIMD_EXIF_GPS, &profile, &profile_size)) {
        error_code = PKImageEncode_SetGPSInfoMetadata_WMP(pIE, profile, profile_size);
        JXR_CHECK(error_code);
        // release profile
        free(profile);
        profile = NULL;
      }
    }

    return WMP_errSuccess;

  } catch(...) {
    free(profile);
    profile = NULL;
    return error_code;
  }
}



// ==========================================================
// Quantization tables (Y, U, V, YHP, UHP, VHP), 
// optimized for PSNR
// ==========================================================

static const int DPK_QPS_420[11][6] = {      // for 8 bit only
    { 66, 65, 70, 72, 72, 77 },
    { 59, 58, 63, 64, 63, 68 },
    { 52, 51, 57, 56, 56, 61 },
    { 48, 48, 54, 51, 50, 55 },
    { 43, 44, 48, 46, 46, 49 },
    { 37, 37, 42, 38, 38, 43 },
    { 26, 28, 31, 27, 28, 31 },
    { 16, 17, 22, 16, 17, 21 },
    { 10, 11, 13, 10, 10, 13 },
    {  5,  5,  6,  5,  5,  6 },
    {  2,  2,  3,  2,  2,  2 }
};

static const int DPK_QPS_8[12][6] = {
    { 67, 79, 86, 72, 90, 98 },
    { 59, 74, 80, 64, 83, 89 },
    { 53, 68, 75, 57, 76, 83 },
    { 49, 64, 71, 53, 70, 77 },
    { 45, 60, 67, 48, 67, 74 },
    { 40, 56, 62, 42, 59, 66 },
    { 33, 49, 55, 35, 51, 58 },
    { 27, 44, 49, 28, 45, 50 },
    { 20, 36, 42, 20, 38, 44 },
    { 13, 27, 34, 13, 28, 34 },
    {  7, 17, 21,  8, 17, 21 }, // Photoshop 100%
    {  2,  5,  6,  2,  5,  6 }
};

static const int DPK_QPS_16[11][6] = {
    { 197, 203, 210, 202, 207, 213 },
    { 174, 188, 193, 180, 189, 196 },
    { 152, 167, 173, 156, 169, 174 },
    { 135, 152, 157, 137, 153, 158 },
    { 119, 137, 141, 119, 138, 142 },
    { 102, 120, 125, 100, 120, 124 },
    {  82,  98, 104,  79,  98, 103 },
    {  60,  76,  81,  58,  76,  81 },
    {  39,  52,  58,  36,  52,  58 },
    {  16,  27,  33,  14,  27,  33 },
    {   5,   8,   9,   4,   7,   8 }
};

static const int DPK_QPS_16f[11][6] = {
    { 148, 177, 171, 165, 187, 191 },
    { 133, 155, 153, 147, 172, 181 },
    { 114, 133, 138, 130, 157, 167 },
    {  97, 118, 120, 109, 137, 144 },
    {  76,  98, 103,  85, 115, 121 },
    {  63,  86,  91,  62,  96,  99 },
    {  46,  68,  71,  43,  73,  75 },
    {  29,  48,  52,  27,  48,  51 },
    {  16,  30,  35,  14,  29,  34 },
    {   8,  14,  17,   7,  13,  17 },
    {   3,   5,   7,   3,   5,   6 }
};

static const int DPK_QPS_32f[11][6] = {
    { 194, 206, 209, 204, 211, 217 },
    { 175, 187, 196, 186, 193, 205 },
    { 157, 170, 177, 167, 180, 190 },
    { 133, 152, 156, 144, 163, 168 },
    { 116, 138, 142, 117, 143, 148 },
    {  98, 120, 123,  96, 123, 126 },
    {  80,  99, 102,  78,  99, 102 },
    {  65,  79,  84,  63,  79,  84 },
    {  48,  61,  67,  45,  60,  66 },
    {  27,  41,  46,  24,  40,  45 },
    {   3,  22,  24,   2,  21,  22 }
};

// ==========================================================
// Plugin Implementation
// ==========================================================

static const char * DLL_CALLCONV
Format() {
  return "JPEG-XR";
}

static const char * DLL_CALLCONV
Description() {
  return "JPEG XR image format";
}

static const char * DLL_CALLCONV
Extension() {
  return "jxr,wdp,hdp";
}

static const char * DLL_CALLCONV
RegExpr() {
  return NULL;
}

static const char * DLL_CALLCONV
MimeType() {
  return "image/vnd.ms-photo";
}

static BOOL DLL_CALLCONV
Validate(FreeImageIO *io, fi_handle handle) {
  BYTE jxr_signature[4] = { 0x49, 0x49, 0xBC, 0x01 };
  BYTE signature[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

  if (io->read_proc(&signature, 1, 8, handle) == 8) {
    if (memcmp(jxr_signature, signature, 4) == 0) {
      // FIRST_IFD_OFFSET (little-endian format) specifies the byte position, relative to the beginning of the file, of the first
      // IMAGE_FILE_DIRECTORY() syntax structure(subclause A.6) in the file.
      // The value of FIRST_IFD_OFFSET shall be an integer multiple of 2.
      unsigned first_ifd_offset = *((unsigned*)(&signature[0] + 4));
      return (first_ifd_offset % 2 == 0) ? TRUE : FALSE;
    }
  }

  return FALSE;
}

static BOOL DLL_CALLCONV
SupportsExportDepth(int depth) {
  return (
    (depth == 1)  ||
    (depth == 8)  ||
    (depth == 16) ||
    (depth == 24) || 
    (depth == 32)
    );
}

static BOOL DLL_CALLCONV 
SupportsExportType(FREE_IMAGE_TYPE type) {
  return (
    (type == FIT_BITMAP) ||
    (type == FIT_UINT16) ||
    (type == FIT_RGB16)  ||
    (type == FIT_RGBA16) ||
    (type == FIT_FLOAT)  ||
    (type == FIT_RGBF)   ||
    (type == FIT_RGBAF)
  );
}

static BOOL DLL_CALLCONV
SupportsICCProfiles() {
  return TRUE;
}

static BOOL DLL_CALLCONV
SupportsNoPixels() {
  return TRUE;
}

// ==========================================================
//  Open & Close
// ==========================================================

static void * DLL_CALLCONV
Open(FreeImageIO *io, fi_handle handle, BOOL read) {
  WMPStream *pStream = NULL; // stream interface
  if(io && handle) {
    // allocate the FreeImageIO stream wrapper
    FreeImageJXRIO *jxr_io = (FreeImageJXRIO*)malloc(sizeof(FreeImageJXRIO));
    if(jxr_io) {
      jxr_io->io = io;
      jxr_io->handle = handle;
      // create a JXR stream wrapper
      if(_jxr_io_Create(&pStream, jxr_io) != WMP_errSuccess) {
        free(jxr_io);
        jxr_io = NULL;
        return NULL;
      }
    }
  }
  return pStream;
}

static void DLL_CALLCONV
Close(FreeImageIO *io, fi_handle handle, void *data) {
  WMPStream *pStream = (WMPStream*)data;
  if(pStream) {
    // free the FreeImageIO stream wrapper
    FreeImageJXRIO *jxr_io = (FreeImageJXRIO*)pStream->state.pvObj;
    free(jxr_io);
    jxr_io = NULL;
    // free the JXR stream wrapper
    pStream->fMem = TRUE;
    _jxr_io_Close(&pStream);
  }
}

// ==========================================================
//  Load
// ==========================================================

/**
Set decoder parameters
@param pDecoder Decoder handle
@param flags FreeImage load flags
*/
static void 
SetDecoderParameters(PKImageDecode *pDecoder, int flags) {
  // load image & alpha for formats with alpha
  pDecoder->WMP.wmiSCP.uAlphaMode = 2;
  // more options to come ...
}

/**
Copy or convert & copy decoded pixels into the dib
@param pDecoder Decoder handle
@param out_guid_format Target guid format
@param dib Output dib
@param width Image width
@param height Image height
@return Returns 0 if successful, returns ERR otherwise
*/
static ERR
CopyPixels(PKImageDecode *pDecoder, PKPixelFormatGUID out_guid_format, FIBITMAP *dib, int width, int height) {
  PKFormatConverter *pConverter = NULL; // pixel format converter
  ERR error_code = 0; // error code as returned by the interface
  BYTE *pb = NULL; // local buffer used for pixel format conversion
  
  // image dimensions
  const PKRect rect = {0, 0, width, height};

  try {
    // get input file pixel format ...
    PKPixelFormatGUID in_guid_format;
    error_code = pDecoder->GetPixelFormat(pDecoder, &in_guid_format);
    JXR_CHECK(error_code);
    
    // is a format conversion needed ?

    if(IsEqualGUID(out_guid_format, in_guid_format)) {
      // no conversion, load bytes "as is" ...

      // get a pointer to dst pixel data
      BYTE *dib_bits = FreeImage_GetBits(dib);

      // get dst pitch (count of BYTE for stride)
      const unsigned cbStride = FreeImage_GetPitch(dib);      

      // decode and copy bits to dst array
      error_code = pDecoder->Copy(pDecoder, &rect, dib_bits, cbStride);
      JXR_CHECK(error_code);   
    }
    else {
      // we need to use the conversion API ...
      
      // allocate the pixel format converter
      error_code = PKCodecFactory_CreateFormatConverter(&pConverter);
      JXR_CHECK(error_code);
      
      // set the conversion function
      error_code = pConverter->Initialize(pConverter, pDecoder, NULL, out_guid_format);
      JXR_CHECK(error_code);
      
      // get the maximum stride
      unsigned cbStride = 0;
      {
        PKPixelInfo pPIFrom;
        PKPixelInfo pPITo;
        
        pPIFrom.pGUIDPixFmt = &in_guid_format;
        error_code = PixelFormatLookup(&pPIFrom, LOOKUP_FORWARD);
        JXR_CHECK(error_code);

        pPITo.pGUIDPixFmt = &out_guid_format;
        error_code = PixelFormatLookup(&pPITo, LOOKUP_FORWARD);
        JXR_CHECK(error_code);

        unsigned cbStrideFrom = ((pPIFrom.cbitUnit + 7) >> 3) * width;
        unsigned cbStrideTo = ((pPITo.cbitUnit + 7) >> 3) * width;
        cbStride = MAX(cbStrideFrom, cbStrideTo);
      }

      // allocate a local decoder / encoder buffer
      error_code = PKAllocAligned((void **) &pb, cbStride * height, 128);
      JXR_CHECK(error_code);

      // copy / convert pixels
      error_code = pConverter->Copy(pConverter, &rect, pb, cbStride);
      JXR_CHECK(error_code);

      // now copy pixels into the dib
      const size_t line_size = FreeImage_GetLine(dib);
      for(int y = 0; y < height; y++) {
        BYTE *src_bits = (BYTE*)(pb + y * cbStride);
        BYTE *dst_bits = (BYTE*)FreeImage_GetScanLine(dib, y);
        memcpy(dst_bits, src_bits, line_size);
      }
      
      // free the local buffer
      PKFreeAligned((void **) &pb);

      // free the pixel format converter
      PKFormatConverter_Release(&pConverter);
    }

    // FreeImage DIB are upside-down relative to usual graphic conventions
    FreeImage_FlipVertical(dib);

    // post-processing ...
    // -------------------

    // swap RGB as needed

#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
    if(IsEqualGUID(out_guid_format, GUID_PKPixelFormat24bppRGB) || IsEqualGUID(out_guid_format, GUID_PKPixelFormat32bppRGB)) {
      SwapRedBlue32(dib);
    }
#elif FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_RGB
    if(IsEqualGUID(out_guid_format, GUID_PKPixelFormat24bppBGR) || IsEqualGUID(out_guid_format, GUID_PKPixelFormat32bppBGR)) {
      SwapRedBlue32(dib);
    }
#endif
    
    return WMP_errSuccess;

  } catch(...) {
    // free the local buffer
    PKFreeAligned((void **) &pb);
    // free the pixel format converter
    PKFormatConverter_Release(&pConverter);

    return error_code;
  }
}

// --------------------------------------------------------------------------

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);
    dib = NULL;
    // free the decoder
    pDecoder->Release(&pDecoder);

    if(NULL != message) {
      FreeImage_OutputMessageProc(s_format_id, message);
    }
  }

  return NULL;
}

// ==========================================================
//  Save
// ==========================================================

/**
Configure compression parameters

ImageQuality  Q (BD==1)  Q (BD==8)   Q (BD==16)  Q (BD==32F) Subsample   Overlap
[0.0, 0.4]    8-IQ*5     (see table) (see table) (see table) 4:4:4       2
(0.4, 0.8)    8-IQ*5     (see table) (see table) (see table) 4:4:4       1
[0.8, 1.0)    8-IQ*5     (see table) (see table) (see table) 4:4:4       1
[1.0, 1.0]    1          1           1           1           4:4:4       0

@param wmiSCP Encoder parameters
@param pixelInfo Image specifications
@param fltImageQuality Image output quality in [0..1), 1 means lossless
*/
static void 
SetCompression(CWMIStrCodecParam *wmiSCP, const PKPixelInfo *pixelInfo, float fltImageQuality) {
    if(fltImageQuality < 1.0F) {
        // overlap
    if(fltImageQuality >= 0.5F) {
      wmiSCP->olOverlap = OL_ONE;
    } else {
      wmiSCP->olOverlap = OL_TWO;
    }
    // chroma sub-sampling
    if(fltImageQuality >= 0.5F || pixelInfo->uBitsPerSample > 8) {
      wmiSCP->cfColorFormat = YUV_444;
    } else {
      wmiSCP->cfColorFormat = YUV_420;
    }

      // bit depth
    if(pixelInfo->bdBitDepth == BD_1) {
      wmiSCP->uiDefaultQPIndex = (U8)(8 - 5.0F * fltImageQuality + 0.5F);
    }
    else {
      // remap [0.8, 0.866, 0.933, 1.0] to [0.8, 0.9, 1.0, 1.1]
            // to use 8-bit DPK QP table (0.933 == Photoshop JPEG 100)
            if(fltImageQuality > 0.8F && pixelInfo->bdBitDepth == BD_8 && wmiSCP->cfColorFormat != YUV_420 && wmiSCP->cfColorFormat != YUV_422) {
        fltImageQuality = 0.8F + (fltImageQuality - 0.8F) * 1.5F;
      }

            const int qi = (int) (10.0F * fltImageQuality);
            const float qf = 10.0F * fltImageQuality - (float)qi;
      
      const int *pQPs = 
        (wmiSCP->cfColorFormat == YUV_420 || wmiSCP->cfColorFormat == YUV_422) ?
        DPK_QPS_420[qi] :
        (pixelInfo->bdBitDepth == BD_8 ? DPK_QPS_8[qi] :
        (pixelInfo->bdBitDepth == BD_16 ? DPK_QPS_16[qi] :
        (pixelInfo->bdBitDepth == BD_16F ? DPK_QPS_16f[qi] :
        DPK_QPS_32f[qi])));
        
      wmiSCP->uiDefaultQPIndex = (U8) (0.5F + (float) pQPs[0] * (1.0F - qf) + (float) (pQPs + 6)[0] * qf);
      wmiSCP->uiDefaultQPIndexU = (U8) (0.5F + (float) pQPs[1] * (1.0F - qf) + (float) (pQPs + 6)[1] * qf);
      wmiSCP->uiDefaultQPIndexV = (U8) (0.5F + (float) pQPs[2] * (1.0F - qf) + (float) (pQPs + 6)[2] * qf);
            wmiSCP->uiDefaultQPIndexYHP = (U8) (0.5F + (float) pQPs[3] * (1.0F - qf) + (float) (pQPs + 6)[3] * qf);
      wmiSCP->uiDefaultQPIndexUHP = (U8) (0.5F + (float) pQPs[4] * (1.0F - qf) + (float) (pQPs + 6)[4] * qf);
      wmiSCP->uiDefaultQPIndexVHP = (U8) (0.5F + (float) pQPs[5] * (1.0F - qf) + (float) (pQPs + 6)[5] * qf);
    }
  } // fltImageQuality < 1.0F
    else {
    // lossless mode
    wmiSCP->uiDefaultQPIndex = 1;
  }
}

/**
Set encoder parameters
@param wmiSCP Encoder parameters
@param pixelInfo Image specifications
@param flags FreeImage save flags
@param bHasAlpha TRUE if an alpha layer is present
*/
static void 
SetEncoderParameters(CWMIStrCodecParam *wmiSCP, const PKPixelInfo *pixelInfo, int flags, BOOL bHasAlpha) {
  float fltImageQuality = 1.0F;

  // all values have been set to zero by the API
  // update default values for some attributes
    wmiSCP->cfColorFormat = YUV_444;    // color format
    wmiSCP->bdBitDepth = BD_LONG;     // internal bit depth
    wmiSCP->bfBitstreamFormat = SPATIAL;  // compressed image data in spatial order
    wmiSCP->bProgressiveMode = FALSE;   // sequential mode
    wmiSCP->olOverlap = OL_ONE;       // single level overlap processing 
  wmiSCP->cNumOfSliceMinus1H = 0;     // # of horizontal slices
  wmiSCP->cNumOfSliceMinus1V = 0;     // # of vertical slices
    wmiSCP->sbSubband = SB_ALL;       // keep all subbands
    wmiSCP->uAlphaMode = 0;         // 0:no alpha 1: alpha only else: something + alpha 
    wmiSCP->uiDefaultQPIndex = 1;     // quantization for grey or rgb layer(s), 1: lossless
    wmiSCP->uiDefaultQPIndexAlpha = 1;    // quantization for alpha layer, 1: lossless

  // process the flags
  // -----------------

  // progressive mode
  if((flags & JXR_PROGRESSIVE) == JXR_PROGRESSIVE) {
    // turn on progressive mode (instead of sequential mode)
    wmiSCP->bProgressiveMode = TRUE;
  }

  // quality in [0.01 - 1.0), 1.0 means lossless - default is 0.80
  int quality = flags & 0x7F;
  if(quality == 0) {
    // defaut to 0.80
    fltImageQuality = 0.8F;
  } else if((flags & JXR_LOSSLESS) == JXR_LOSSLESS) {
    fltImageQuality = 1.0F;
  } else {
    quality = (quality >= 100) ? 100 : quality;
    fltImageQuality = quality / 100.0F;
  }
  SetCompression(wmiSCP, pixelInfo, fltImageQuality);

  // alpha compression
  if(bHasAlpha) {
    wmiSCP->uAlphaMode = 2; // encode with a planar alpha channel
  }
}

// --------------------------------------------------------------------------

static BOOL DLL_CALLCONV
Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
  BOOL bIsFlipped = FALSE;   // FreeImage DIB are upside-down relative to usual graphic conventions
  PKPixelFormatGUID guid_format;  // image format
  PKPixelInfo pixelInfo;      // image specifications
  BOOL bHasAlpha = FALSE;     // is alpha layer present ?

  PKImageEncode *pEncoder = NULL;   // encoder interface
  ERR error_code = 0;         // error code as returned by the interface

  // get the I/O stream wrapper
  WMPStream *pEncodeStream = (WMPStream*)data;

  if(!dib || !handle || !pEncodeStream) {
    return FALSE;
  }

  try {
    // get image dimensions
    unsigned width = FreeImage_GetWidth(dib);
    unsigned height = FreeImage_GetHeight(dib);

    // check JPEG-XR limits
    if((width < MB_WIDTH_PIXEL) || (height < MB_HEIGHT_PIXEL)) {
      FreeImage_OutputMessageProc(s_format_id, "Unsupported image size: width x height = %d x %d", width, height);
      throw (const char*)NULL;
    }

    // get output pixel format
    error_code = GetOutputPixelFormat(dib, &guid_format, &bHasAlpha);
    JXR_CHECK(error_code);
    pixelInfo.pGUIDPixFmt = &guid_format;
    error_code = PixelFormatLookup(&pixelInfo, LOOKUP_FORWARD);
    JXR_CHECK(error_code);

    // create a JXR encoder interface and initialize function pointers with *_WMP functions
    error_code = PKImageEncode_Create_WMP(&pEncoder);
    JXR_CHECK(error_code);

    // attach the stream to the encoder and set all encoder parameters to zero ...
    error_code = pEncoder->Initialize(pEncoder, pEncodeStream, &pEncoder->WMP.wmiSCP, sizeof(CWMIStrCodecParam));
    JXR_CHECK(error_code);

    // ... then configure the encoder
    SetEncoderParameters(&pEncoder->WMP.wmiSCP, &pixelInfo, flags, bHasAlpha);

    // set pixel format
    pEncoder->SetPixelFormat(pEncoder, guid_format);

    // set image size
    pEncoder->SetSize(pEncoder, width, height);
    
    // set resolution (convert from universal units to English units)
    float resX = (float)(unsigned)(0.5F + 0.0254F * FreeImage_GetDotsPerMeterX(dib));
    float resY = (float)(unsigned)(0.5F + 0.0254F * FreeImage_GetDotsPerMeterY(dib));
    pEncoder->SetResolution(pEncoder, resX, resY);

    // set metadata
    WriteMetadata(pEncoder, dib);

    // write metadata & pixels
    // -----------------------

    // dib coordinates are upside-down relative to usual conventions
    bIsFlipped = FreeImage_FlipVertical(dib);

    // get a pointer to dst pixel data
    BYTE *dib_bits = FreeImage_GetBits(dib);

    // get dst pitch (count of BYTE for stride)
    const unsigned cbStride = FreeImage_GetPitch(dib);

    // write metadata + pixels on output
    error_code = pEncoder->WritePixels(pEncoder, height, dib_bits, cbStride);
    JXR_CHECK(error_code);

    // recover dib coordinates
    FreeImage_FlipVertical(dib);

    // free the encoder
    pEncoder->Release(&pEncoder);
    assert(pEncoder == NULL);
    
    return TRUE;

  } catch (const char *message) {
    if(bIsFlipped) {
      // recover dib coordinates
      FreeImage_FlipVertical(dib);
    }
    if(pEncoder) {
      // free the encoder
      pEncoder->Release(&pEncoder);
      assert(pEncoder == NULL);
    }
    if(NULL != message) {
      FreeImage_OutputMessageProc(s_format_id, message);
    }
  }

  return FALSE;
}

// ==========================================================
//   Init
// ==========================================================

void DLL_CALLCONV
InitJXR(Plugin *plugin, int format_id) {
  s_format_id = format_id;

  plugin->format_proc = Format;
  plugin->description_proc = Description;
  plugin->extension_proc = Extension;
  plugin->regexpr_proc = RegExpr;
  plugin->open_proc = Open;
  plugin->close_proc = Close;
  plugin->pagecount_proc = NULL;
  plugin->pagecapability_proc = NULL;
  plugin->load_proc = Load;
  plugin->save_proc = Save;
  plugin->validate_proc = Validate;
  plugin->mime_proc = MimeType;
  plugin->supports_export_bpp_proc = SupportsExportDepth;
  plugin->supports_export_type_proc = SupportsExportType;
  plugin->supports_icc_profiles_proc = SupportsICCProfiles;
  plugin->supports_no_pixels_proc = SupportsNoPixels;
}


Coverage Report

Created: 2026-06-09 06:12