view release on metacpan or  search on metacpan

src/Source/FreeImage/PluginJXR.cpp  view on Meta::CPAN

		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) {

src/Source/FreeImage/PluginJXR.cpp  view on Meta::CPAN

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));