Alien-FreeImage
view release on metacpan or search on metacpan
src/Source/FreeImage/PluginJPEG.cpp view on Meta::CPAN
// - Jan L. Nauta (jln@magentammt.com)
// - Markus Loibl (markus.loibl@epost.de)
// - Karl-Heinz Bussian (khbussian@moss.de)
// - Hervé Drolon (drolon@infonie.fr)
// - Jascha Wetzel (jascha@mainia.de)
// - Mihail Naydenov (mnaydenov@users.sourceforge.net)
//
// 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!
// ==========================================================
#ifdef _MSC_VER
#pragma warning (disable : 4786) // identifier was truncated to 'number' characters
#endif
extern "C" {
#define XMD_H
#undef FAR
#include <setjmp.h>
#include "../LibJPEG/jinclude.h"
#include "../LibJPEG/jpeglib.h"
#include "../LibJPEG/jerror.h"
}
#include "FreeImage.h"
#include "Utilities.h"
#include "../Metadata/FreeImageTag.h"
// ==========================================================
// Plugin Interface
// ==========================================================
static int s_format_id;
// ----------------------------------------------------------
// Constant declarations
// ----------------------------------------------------------
#define INPUT_BUF_SIZE 4096 // choose an efficiently fread'able size
#define OUTPUT_BUF_SIZE 4096 // choose an efficiently fwrite'able size
#define EXIF_MARKER (JPEG_APP0+1) // EXIF marker / Adobe XMP marker
#define ICC_MARKER (JPEG_APP0+2) // ICC profile marker
#define IPTC_MARKER (JPEG_APP0+13) // IPTC marker / BIM marker
#define ICC_HEADER_SIZE 14 // size of non-profile data in APP2
#define MAX_BYTES_IN_MARKER 65533L // maximum data length of a JPEG marker
#define MAX_DATA_BYTES_IN_MARKER 65519L // maximum data length of a JPEG APP2 marker
#define MAX_JFXX_THUMB_SIZE (MAX_BYTES_IN_MARKER - 5 - 1)
#define JFXX_TYPE_JPEG 0x10 // JFIF extension marker: JPEG-compressed thumbnail image
#define JFXX_TYPE_8bit 0x11 // JFIF extension marker: palette thumbnail image
#define JFXX_TYPE_24bit 0x13 // JFIF extension marker: RGB thumbnail image
// ----------------------------------------------------------
// Typedef declarations
// ----------------------------------------------------------
typedef struct tagErrorManager {
/// "public" fields
struct jpeg_error_mgr pub;
/// for return to caller
jmp_buf setjmp_buffer;
} ErrorManager;
typedef struct tagSourceManager {
/// public fields
struct jpeg_source_mgr pub;
/// source stream
fi_handle infile;
FreeImageIO *m_io;
/// start of buffer
JOCTET * buffer;
/// have we gotten any data yet ?
boolean start_of_file;
} SourceManager;
typedef struct tagDestinationManager {
/// public fields
struct jpeg_destination_mgr pub;
/// destination stream
fi_handle outfile;
FreeImageIO *m_io;
/// start of buffer
JOCTET * buffer;
} DestinationManager;
typedef SourceManager* freeimage_src_ptr;
typedef DestinationManager* freeimage_dst_ptr;
typedef ErrorManager* freeimage_error_ptr;
// ----------------------------------------------------------
// Error handling
// ----------------------------------------------------------
/** Fatal errors (print message and exit) */
static inline void
JPEG_EXIT(j_common_ptr cinfo, int code) {
freeimage_error_ptr error_ptr = (freeimage_error_ptr)cinfo->err;
error_ptr->pub.msg_code = code;
error_ptr->pub.error_exit(cinfo);
}
/** Nonfatal errors (we can keep going, but the data is probably corrupt) */
static inline void
JPEG_WARNING(j_common_ptr cinfo, int code) {
freeimage_error_ptr error_ptr = (freeimage_error_ptr)cinfo->err;
src/Source/FreeImage/PluginJPEG.cpp view on Meta::CPAN
generally this routine will exit() or longjmp() somewhere.
*/
METHODDEF(void)
jpeg_error_exit (j_common_ptr cinfo) {
freeimage_error_ptr error_ptr = (freeimage_error_ptr)cinfo->err;
// always display the message
error_ptr->pub.output_message(cinfo);
// allow JPEG with unknown markers
if(error_ptr->pub.msg_code != JERR_UNKNOWN_MARKER) {
// let the memory manager delete any temp files before we die
jpeg_destroy(cinfo);
// return control to the setjmp point
longjmp(error_ptr->setjmp_buffer, 1);
}
}
/**
Actual output of any JPEG message. Note that this method does not know
how to generate a message, only where to send it.
*/
METHODDEF(void)
jpeg_output_message (j_common_ptr cinfo) {
char buffer[JMSG_LENGTH_MAX];
freeimage_error_ptr error_ptr = (freeimage_error_ptr)cinfo->err;
// create the message
error_ptr->pub.format_message(cinfo, buffer);
// send it to user's message proc
FreeImage_OutputMessageProc(s_format_id, buffer);
}
// ----------------------------------------------------------
// Destination manager
// ----------------------------------------------------------
/**
Initialize destination. This is called by jpeg_start_compress()
before any data is actually written. It must initialize
next_output_byte and free_in_buffer. free_in_buffer must be
initialized to a positive value.
*/
METHODDEF(void)
init_destination (j_compress_ptr cinfo) {
freeimage_dst_ptr dest = (freeimage_dst_ptr) cinfo->dest;
dest->buffer = (JOCTET *)
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
OUTPUT_BUF_SIZE * sizeof(JOCTET));
dest->pub.next_output_byte = dest->buffer;
dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
}
/**
This is called whenever the buffer has filled (free_in_buffer
reaches zero). In typical applications, it should write out the
*entire* buffer (use the saved start address and buffer length;
ignore the current state of next_output_byte and free_in_buffer).
Then reset the pointer & count to the start of the buffer, and
return TRUE indicating that the buffer has been dumped.
free_in_buffer must be set to a positive value when TRUE is
returned. A FALSE return should only be used when I/O suspension is
desired.
*/
METHODDEF(boolean)
empty_output_buffer (j_compress_ptr cinfo) {
freeimage_dst_ptr dest = (freeimage_dst_ptr) cinfo->dest;
if (dest->m_io->write_proc(dest->buffer, 1, OUTPUT_BUF_SIZE, dest->outfile) != OUTPUT_BUF_SIZE) {
// let the memory manager delete any temp files before we die
jpeg_destroy((j_common_ptr)cinfo);
JPEG_EXIT((j_common_ptr)cinfo, JERR_FILE_WRITE);
}
dest->pub.next_output_byte = dest->buffer;
dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
return TRUE;
}
/**
Terminate destination --- called by jpeg_finish_compress() after all
data has been written. In most applications, this must flush any
data remaining in the buffer. Use either next_output_byte or
free_in_buffer to determine how much data is in the buffer.
*/
METHODDEF(void)
term_destination (j_compress_ptr cinfo) {
freeimage_dst_ptr dest = (freeimage_dst_ptr) cinfo->dest;
size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
// write any data remaining in the buffer
if (datacount > 0) {
if (dest->m_io->write_proc(dest->buffer, 1, (unsigned int)datacount, dest->outfile) != datacount) {
// let the memory manager delete any temp files before we die
jpeg_destroy((j_common_ptr)cinfo);
JPEG_EXIT((j_common_ptr)cinfo, JERR_FILE_WRITE);
}
}
}
// ----------------------------------------------------------
// Source manager
// ----------------------------------------------------------
/**
Initialize source. This is called by jpeg_read_header() before any
data is actually read. Unlike init_destination(), it may leave
bytes_in_buffer set to 0 (in which case a fill_input_buffer() call
will occur immediately).
*/
METHODDEF(void)
init_source (j_decompress_ptr cinfo) {
src/Source/FreeImage/PluginJPEG.cpp view on Meta::CPAN
jpeg_freeimage_src (j_decompress_ptr cinfo, fi_handle infile, FreeImageIO *io) {
freeimage_src_ptr src;
// allocate memory for the buffer. is released automatically in the end
if (cinfo->src == NULL) {
cinfo->src = (struct jpeg_source_mgr *) (*cinfo->mem->alloc_small)
((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(SourceManager));
src = (freeimage_src_ptr) cinfo->src;
src->buffer = (JOCTET *) (*cinfo->mem->alloc_small)
((j_common_ptr) cinfo, JPOOL_PERMANENT, INPUT_BUF_SIZE * sizeof(JOCTET));
}
// initialize the jpeg pointer struct with pointers to functions
src = (freeimage_src_ptr) cinfo->src;
src->pub.init_source = init_source;
src->pub.fill_input_buffer = fill_input_buffer;
src->pub.skip_input_data = skip_input_data;
src->pub.resync_to_restart = jpeg_resync_to_restart; // use default method
src->pub.term_source = term_source;
src->infile = infile;
src->m_io = io;
src->pub.bytes_in_buffer = 0; // forces fill_input_buffer on first read
src->pub.next_input_byte = NULL; // until buffer loaded
}
/**
Prepare for output to a stdio stream.
The caller must have already opened the stream, and is responsible
for closing it after finishing compression.
*/
GLOBAL(void)
jpeg_freeimage_dst (j_compress_ptr cinfo, fi_handle outfile, FreeImageIO *io) {
freeimage_dst_ptr dest;
if (cinfo->dest == NULL) {
cinfo->dest = (struct jpeg_destination_mgr *)(*cinfo->mem->alloc_small)
((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(DestinationManager));
}
dest = (freeimage_dst_ptr) cinfo->dest;
dest->pub.init_destination = init_destination;
dest->pub.empty_output_buffer = empty_output_buffer;
dest->pub.term_destination = term_destination;
dest->outfile = outfile;
dest->m_io = io;
}
// ----------------------------------------------------------
// Special markers read functions
// ----------------------------------------------------------
/**
Read JPEG_COM marker (comment)
*/
static BOOL
jpeg_read_comment(FIBITMAP *dib, const BYTE *dataptr, unsigned int datalen) {
size_t length = datalen;
BYTE *profile = (BYTE*)dataptr;
// read the comment
char *value = (char*)malloc((length + 1) * sizeof(char));
if(value == NULL) return FALSE;
memcpy(value, profile, length);
value[length] = '\0';
// create a tag
FITAG *tag = FreeImage_CreateTag();
if(tag) {
unsigned int count = (unsigned int)length + 1; // includes the null value
FreeImage_SetTagID(tag, JPEG_COM);
FreeImage_SetTagKey(tag, "Comment");
FreeImage_SetTagLength(tag, count);
FreeImage_SetTagCount(tag, count);
FreeImage_SetTagType(tag, FIDT_ASCII);
FreeImage_SetTagValue(tag, value);
// store the tag
FreeImage_SetMetadata(FIMD_COMMENTS, dib, FreeImage_GetTagKey(tag), tag);
// destroy the tag
FreeImage_DeleteTag(tag);
}
free(value);
return TRUE;
}
/**
Read JPEG_APP2 marker (ICC profile)
*/
/**
Handy subroutine to test whether a saved marker is an ICC profile marker.
*/
static BOOL
marker_is_icc(jpeg_saved_marker_ptr marker) {
// marker identifying string "ICC_PROFILE" (null-terminated)
const BYTE icc_signature[12] = { 0x49, 0x43, 0x43, 0x5F, 0x50, 0x52, 0x4F, 0x46, 0x49, 0x4C, 0x45, 0x00 };
if(marker->marker == ICC_MARKER) {
// verify the identifying string
if(marker->data_length >= ICC_HEADER_SIZE) {
if(memcmp(icc_signature, marker->data, sizeof(icc_signature)) == 0) {
return TRUE;
}
}
}
return FALSE;
}
/**
See if there was an ICC profile in the JPEG file being read;
if so, reassemble and return the profile data.
TRUE is returned if an ICC profile was found, FALSE if not.
If TRUE is returned, *icc_data_ptr is set to point to the
returned data, and *icc_data_len is set to its length.
IMPORTANT: the data at **icc_data_ptr has been allocated with malloc()
and must be freed by the caller with free() when the caller no longer
needs it. (Alternatively, we could write this routine to use the
IJG library's memory allocator, so that the data would be freed implicitly
at jpeg_finish_decompress() time. But it seems likely that many apps
will prefer to have the data stick around after decompression finishes.)
NOTE: if the file contains invalid ICC APP2 markers, we just silently
return FALSE. You might want to issue an error message instead.
*/
static BOOL
jpeg_read_icc_profile(j_decompress_ptr cinfo, JOCTET **icc_data_ptr, unsigned *icc_data_len) {
jpeg_saved_marker_ptr marker;
int num_markers = 0;
int seq_no;
JOCTET *icc_data;
unsigned total_length;
const int MAX_SEQ_NO = 255; // sufficient since marker numbers are bytes
BYTE marker_present[MAX_SEQ_NO+1]; // 1 if marker found
unsigned data_length[MAX_SEQ_NO+1]; // size of profile data in marker
unsigned data_offset[MAX_SEQ_NO+1]; // offset for data in marker
*icc_data_ptr = NULL; // avoid confusion if FALSE return
*icc_data_len = 0;
/**
this first pass over the saved markers discovers whether there are
any ICC markers and verifies the consistency of the marker numbering.
*/
memset(marker_present, 0, (MAX_SEQ_NO + 1));
for(marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
if (marker_is_icc(marker)) {
if (num_markers == 0) {
// number of markers
num_markers = GETJOCTET(marker->data[13]);
}
else if (num_markers != GETJOCTET(marker->data[13])) {
return FALSE; // inconsistent num_markers fields
}
// sequence number
seq_no = GETJOCTET(marker->data[12]);
if (seq_no <= 0 || seq_no > num_markers) {
return FALSE; // bogus sequence number
}
if (marker_present[seq_no]) {
return FALSE; // duplicate sequence numbers
}
marker_present[seq_no] = 1;
data_length[seq_no] = marker->data_length - ICC_HEADER_SIZE;
}
}
if (num_markers == 0)
return FALSE;
/**
check for missing markers, count total space needed,
compute offset of each marker's part of the data.
*/
total_length = 0;
for(seq_no = 1; seq_no <= num_markers; seq_no++) {
if (marker_present[seq_no] == 0) {
return FALSE; // missing sequence number
}
data_offset[seq_no] = total_length;
total_length += data_length[seq_no];
}
if (total_length <= 0)
return FALSE; // found only empty markers ?
// allocate space for assembled data
icc_data = (JOCTET *) malloc(total_length * sizeof(JOCTET));
if (icc_data == NULL)
return FALSE; // out of memory
// and fill it in
for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
if (marker_is_icc(marker)) {
JOCTET FAR *src_ptr;
JOCTET *dst_ptr;
unsigned length;
seq_no = GETJOCTET(marker->data[12]);
dst_ptr = icc_data + data_offset[seq_no];
src_ptr = marker->data + ICC_HEADER_SIZE;
length = data_length[seq_no];
while (length--) {
*dst_ptr++ = *src_ptr++;
}
}
}
*icc_data_ptr = icc_data;
*icc_data_len = total_length;
return TRUE;
}
/**
Read JPEG_APPD marker (IPTC or Adobe Photoshop profile)
*/
static BOOL
jpeg_read_iptc_profile(FIBITMAP *dib, const BYTE *dataptr, unsigned int datalen) {
return read_iptc_profile(dib, dataptr, datalen);
}
/**
Read JPEG_APP1 marker (XMP profile)
@param dib Input FIBITMAP
@param dataptr Pointer to the APP1 marker
@param datalen APP1 marker length
@return Returns TRUE if successful, FALSE otherwise
*/
static BOOL
jpeg_read_xmp_profile(FIBITMAP *dib, const BYTE *dataptr, unsigned int datalen) {
// marker identifying string for XMP (null terminated)
const char *xmp_signature = "http://ns.adobe.com/xap/1.0/";
// XMP signature is 29 bytes long
const size_t xmp_signature_size = strlen(xmp_signature) + 1;
size_t length = datalen;
BYTE *profile = (BYTE*)dataptr;
if(length <= xmp_signature_size) {
// avoid reading corrupted or empty data
return FALSE;
}
// verify the identifying string
if(memcmp(xmp_signature, profile, strlen(xmp_signature)) == 0) {
// XMP profile
profile += xmp_signature_size;
length -= xmp_signature_size;
// create a tag
FITAG *tag = FreeImage_CreateTag();
if(tag) {
FreeImage_SetTagID(tag, JPEG_APP0+1); // 0xFFE1
FreeImage_SetTagKey(tag, g_TagLib_XMPFieldName);
FreeImage_SetTagLength(tag, (DWORD)length);
FreeImage_SetTagCount(tag, (DWORD)length);
FreeImage_SetTagType(tag, FIDT_ASCII);
FreeImage_SetTagValue(tag, profile);
// store the tag
FreeImage_SetMetadata(FIMD_XMP, dib, FreeImage_GetTagKey(tag), tag);
// destroy the tag
FreeImage_DeleteTag(tag);
}
return TRUE;
}
return FALSE;
}
/**
Read JFIF "JFXX" extension APP0 marker
@param dib Input FIBITMAP
@param dataptr Pointer to the APP0 marker
@param datalen APP0 marker length
@return Returns TRUE if successful, FALSE otherwise
*/
static BOOL
jpeg_read_jfxx(FIBITMAP *dib, const BYTE *dataptr, unsigned int datalen) {
if(datalen < 6) {
return FALSE;
}
const int id_length = 5;
const BYTE *data = dataptr + id_length;
unsigned remaining = datalen - id_length;
const BYTE type = *data;
++data, --remaining;
switch(type) {
case JFXX_TYPE_JPEG:
{
// load the thumbnail
FIMEMORY* hmem = FreeImage_OpenMemory(const_cast<BYTE*>(data), remaining);
FIBITMAP* thumbnail = FreeImage_LoadFromMemory(FIF_JPEG, hmem);
FreeImage_CloseMemory(hmem);
// store the thumbnail
FreeImage_SetThumbnail(dib, thumbnail);
// then delete it
FreeImage_Unload(thumbnail);
break;
}
case JFXX_TYPE_8bit:
// colormapped uncompressed thumbnail (no supported)
break;
case JFXX_TYPE_24bit:
// truecolor uncompressed thumbnail (no supported)
break;
default:
break;
}
return TRUE;
}
/**
Read JPEG special markers
*/
static BOOL
read_markers(j_decompress_ptr cinfo, FIBITMAP *dib) {
jpeg_saved_marker_ptr marker;
for(marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
switch(marker->marker) {
case JPEG_APP0:
// JFIF is handled by libjpeg already, handle JFXX
if(memcmp(marker->data, "JFIF" , 5) == 0) {
continue;
}
if(memcmp(marker->data, "JFXX" , 5) == 0) {
if(!cinfo->saw_JFIF_marker || cinfo->JFIF_minor_version < 2) {
FreeImage_OutputMessageProc(s_format_id, "Warning: non-standard JFXX segment");
}
jpeg_read_jfxx(dib, marker->data, marker->data_length);
}
// other values such as 'Picasa' : ignore safely unknown APP0 marker
break;
case JPEG_COM:
// JPEG comment
jpeg_read_comment(dib, marker->data, marker->data_length);
break;
case EXIF_MARKER:
// Exif or Adobe XMP profile
jpeg_read_exif_profile(dib, marker->data, marker->data_length);
jpeg_read_xmp_profile(dib, marker->data, marker->data_length);
jpeg_read_exif_profile_raw(dib, marker->data, marker->data_length);
break;
case IPTC_MARKER:
// IPTC/NAA or Adobe Photoshop profile
jpeg_read_iptc_profile(dib, marker->data, marker->data_length);
break;
}
}
// ICC profile
BYTE *icc_profile = NULL;
unsigned icc_length = 0;
if( jpeg_read_icc_profile(cinfo, &icc_profile, &icc_length) ) {
// copy ICC profile data
FreeImage_CreateICCProfile(dib, icc_profile, icc_length);
// clean up
free(icc_profile);
}
return TRUE;
}
// ----------------------------------------------------------
// Special markers write functions
// ----------------------------------------------------------
/**
Write JPEG_COM marker (comment)
*/
static BOOL
jpeg_write_comment(j_compress_ptr cinfo, FIBITMAP *dib) {
FITAG *tag = NULL;
// write user comment as a JPEG_COM marker
FreeImage_GetMetadata(FIMD_COMMENTS, dib, "Comment", &tag);
if(tag) {
const char *tag_value = (char*)FreeImage_GetTagValue(tag);
if(NULL != tag_value) {
for(long i = 0; i < (long)strlen(tag_value); i+= MAX_BYTES_IN_MARKER) {
jpeg_write_marker(cinfo, JPEG_COM, (BYTE*)tag_value + i, MIN((long)strlen(tag_value + i), MAX_BYTES_IN_MARKER));
}
return TRUE;
}
}
return FALSE;
}
/**
Write JPEG_APP2 marker (ICC profile)
*/
static BOOL
jpeg_write_icc_profile(j_compress_ptr cinfo, FIBITMAP *dib) {
// marker identifying string "ICC_PROFILE" (null-terminated)
BYTE icc_signature[12] = { 0x49, 0x43, 0x43, 0x5F, 0x50, 0x52, 0x4F, 0x46, 0x49, 0x4C, 0x45, 0x00 };
FIICCPROFILE *iccProfile = FreeImage_GetICCProfile(dib);
if (iccProfile->size && iccProfile->data) {
// ICC_HEADER_SIZE: ICC signature is 'ICC_PROFILE' + 2 bytes
BYTE *profile = (BYTE*)malloc((iccProfile->size + ICC_HEADER_SIZE) * sizeof(BYTE));
if(profile == NULL) return FALSE;
memcpy(profile, icc_signature, 12);
for(long i = 0; i < (long)iccProfile->size; i += MAX_DATA_BYTES_IN_MARKER) {
unsigned length = MIN((long)(iccProfile->size - i), MAX_DATA_BYTES_IN_MARKER);
// sequence number
profile[12] = (BYTE) ((i / MAX_DATA_BYTES_IN_MARKER) + 1);
// number of markers
profile[13] = (BYTE) (iccProfile->size / MAX_DATA_BYTES_IN_MARKER + 1);
memcpy(profile + ICC_HEADER_SIZE, (BYTE*)iccProfile->data + i, length);
jpeg_write_marker(cinfo, ICC_MARKER, profile, (length + ICC_HEADER_SIZE));
}
free(profile);
return TRUE;
}
return FALSE;
}
/**
Write JPEG_APPD marker (IPTC or Adobe Photoshop profile)
@return Returns TRUE if successful, FALSE otherwise
*/
static BOOL
jpeg_write_iptc_profile(j_compress_ptr cinfo, FIBITMAP *dib) {
//const char *ps_header = "Photoshop 3.0\x08BIM\x04\x04\x0\x0\x0\x0";
const unsigned tag_length = 26;
if(FreeImage_GetMetadataCount(FIMD_IPTC, dib)) {
BYTE *profile = NULL;
unsigned profile_size = 0;
// create a binary profile
if(write_iptc_profile(dib, &profile, &profile_size)) {
// write the profile
for(long i = 0; i < (long)profile_size; i += 65517L) {
unsigned length = MIN((long)profile_size - i, 65517L);
unsigned roundup = length & 0x01; // needed for Photoshop
BYTE *iptc_profile = (BYTE*)malloc(length + roundup + tag_length);
if(iptc_profile == NULL) break;
// Photoshop identification string
memcpy(&iptc_profile[0], "Photoshop 3.0\x0", 14);
// 8BIM segment type
memcpy(&iptc_profile[14], "8BIM\x04\x04\x0\x0\x0\x0", 10);
// segment size
iptc_profile[24] = (BYTE)(length >> 8);
iptc_profile[25] = (BYTE)(length & 0xFF);
// segment data
memcpy(&iptc_profile[tag_length], &profile[i], length);
if(roundup)
iptc_profile[length + tag_length] = 0;
jpeg_write_marker(cinfo, IPTC_MARKER, iptc_profile, length + roundup + tag_length);
free(iptc_profile);
}
// release profile
free(profile);
return TRUE;
}
}
return FALSE;
}
/**
Write JPEG_APP1 marker (XMP profile)
@return Returns TRUE if successful, FALSE otherwise
*/
static BOOL
jpeg_write_xmp_profile(j_compress_ptr cinfo, FIBITMAP *dib) {
// marker identifying string for XMP (null terminated)
const char *xmp_signature = "http://ns.adobe.com/xap/1.0/";
FITAG *tag_xmp = NULL;
FreeImage_GetMetadata(FIMD_XMP, dib, g_TagLib_XMPFieldName, &tag_xmp);
if(tag_xmp) {
const BYTE *tag_value = (BYTE*)FreeImage_GetTagValue(tag_xmp);
if(NULL != tag_value) {
// XMP signature is 29 bytes long
unsigned int xmp_header_size = (unsigned int)strlen(xmp_signature) + 1;
DWORD tag_length = FreeImage_GetTagLength(tag_xmp);
BYTE *profile = (BYTE*)malloc((tag_length + xmp_header_size) * sizeof(BYTE));
if(profile == NULL) return FALSE;
memcpy(profile, xmp_signature, xmp_header_size);
for(DWORD i = 0; i < tag_length; i += 65504L) {
unsigned length = MIN((long)(tag_length - i), 65504L);
memcpy(profile + xmp_header_size, tag_value + i, length);
jpeg_write_marker(cinfo, EXIF_MARKER, profile, (length + xmp_header_size));
}
free(profile);
return TRUE;
}
}
return FALSE;
}
/**
Write JPEG_APP1 marker (Exif profile)
@return Returns TRUE if successful, FALSE otherwise
*/
static BOOL
jpeg_write_exif_profile_raw(j_compress_ptr cinfo, FIBITMAP *dib) {
// marker identifying string for Exif = "Exif\0\0"
BYTE exif_signature[6] = { 0x45, 0x78, 0x69, 0x66, 0x00, 0x00 };
FITAG *tag_exif = NULL;
FreeImage_GetMetadata(FIMD_EXIF_RAW, dib, g_TagLib_ExifRawFieldName, &tag_exif);
if(tag_exif) {
const BYTE *tag_value = (BYTE*)FreeImage_GetTagValue(tag_exif);
// verify the identifying string
if(memcmp(exif_signature, tag_value, sizeof(exif_signature)) != 0) {
// not an Exif profile
return FALSE;
}
if(NULL != tag_value) {
DWORD tag_length = FreeImage_GetTagLength(tag_exif);
BYTE *profile = (BYTE*)malloc(tag_length * sizeof(BYTE));
if(profile == NULL) return FALSE;
for(DWORD i = 0; i < tag_length; i += 65504L) {
unsigned length = MIN((long)(tag_length - i), 65504L);
memcpy(profile, tag_value + i, length);
jpeg_write_marker(cinfo, EXIF_MARKER, profile, length);
}
free(profile);
return TRUE;
}
}
return FALSE;
}
/**
Write thumbnail (JFXX segment, JPEG compressed)
*/
static BOOL
jpeg_write_jfxx(j_compress_ptr cinfo, FIBITMAP *dib) {
// get the thumbnail to be stored
FIBITMAP* thumbnail = FreeImage_GetThumbnail(dib);
if(!thumbnail) {
return TRUE;
}
// check for a compatible output format
if((FreeImage_GetImageType(thumbnail) != FIT_BITMAP) || (FreeImage_GetBPP(thumbnail) != 8) && (FreeImage_GetBPP(thumbnail) != 24)) {
FreeImage_OutputMessageProc(s_format_id, FI_MSG_WARNING_INVALID_THUMBNAIL);
return FALSE;
}
// stores the thumbnail as a baseline JPEG into a memory block
// return the memory block only if its size is within JFXX marker size limit!
FIMEMORY *stream = FreeImage_OpenMemory();
if(FreeImage_SaveToMemory(FIF_JPEG, thumbnail, stream, JPEG_BASELINE)) {
// check that the memory block size is within JFXX marker size limit
FreeImage_SeekMemory(stream, 0, SEEK_END);
const long eof = FreeImage_TellMemory(stream);
if(eof > MAX_JFXX_THUMB_SIZE) {
FreeImage_OutputMessageProc(s_format_id, "Warning: attached thumbnail is %d bytes larger than maximum supported size - Thumbnail saving aborted", eof - MAX_JFXX_THUMB_SIZE);
FreeImage_CloseMemory(stream);
return FALSE;
}
} else {
FreeImage_CloseMemory(stream);
return FALSE;
}
BYTE* thData = NULL;
DWORD thSize = 0;
FreeImage_AcquireMemory(stream, &thData, &thSize);
BYTE id_length = 5; //< "JFXX"
BYTE type = JFXX_TYPE_JPEG;
DWORD totalsize = id_length + sizeof(type) + thSize;
jpeg_write_m_header(cinfo, JPEG_APP0, totalsize);
jpeg_write_m_byte(cinfo, 'J');
jpeg_write_m_byte(cinfo, 'F');
jpeg_write_m_byte(cinfo, 'X');
jpeg_write_m_byte(cinfo, 'X');
jpeg_write_m_byte(cinfo, '\0');
jpeg_write_m_byte(cinfo, type);
// write thumbnail to destination.
// We "cram it straight into the data destination module", because write_m_byte is slow
freeimage_dst_ptr dest = (freeimage_dst_ptr) cinfo->dest;
BYTE* & out = dest->pub.next_output_byte;
size_t & bufRemain = dest->pub.free_in_buffer;
const BYTE *thData_end = thData + thSize;
while(thData < thData_end) {
*(out)++ = *(thData)++;
if (--bufRemain == 0) {
// buffer full - flush
if (!dest->pub.empty_output_buffer(cinfo)) {
break;
}
}
}
FreeImage_CloseMemory(stream);
return TRUE;
}
/**
Write JPEG special markers
*/
static BOOL
write_markers(j_compress_ptr cinfo, FIBITMAP *dib) {
// write thumbnail as a JFXX marker
jpeg_write_jfxx(cinfo, dib);
// write user comment as a JPEG_COM marker
jpeg_write_comment(cinfo, dib);
// write ICC profile
jpeg_write_icc_profile(cinfo, dib);
// write IPTC profile
jpeg_write_iptc_profile(cinfo, dib);
// write Adobe XMP profile
jpeg_write_xmp_profile(cinfo, dib);
// write Exif raw data
jpeg_write_exif_profile_raw(cinfo, dib);
return TRUE;
}
// ------------------------------------------------------------
// Keep original size info when using scale option on loading
// ------------------------------------------------------------
static void
store_size_info(FIBITMAP *dib, JDIMENSION width, JDIMENSION height) {
char buffer[256];
// create a tag
FITAG *tag = FreeImage_CreateTag();
if(tag) {
size_t length = 0;
// set the original width
sprintf(buffer, "%d", (int)width);
length = strlen(buffer) + 1; // include the NULL/0 value
FreeImage_SetTagKey(tag, "OriginalJPEGWidth");
FreeImage_SetTagLength(tag, (DWORD)length);
FreeImage_SetTagCount(tag, (DWORD)length);
FreeImage_SetTagType(tag, FIDT_ASCII);
FreeImage_SetTagValue(tag, buffer);
FreeImage_SetMetadata(FIMD_COMMENTS, dib, FreeImage_GetTagKey(tag), tag);
// set the original height
sprintf(buffer, "%d", (int)height);
length = strlen(buffer) + 1; // include the NULL/0 value
FreeImage_SetTagKey(tag, "OriginalJPEGHeight");
FreeImage_SetTagLength(tag, (DWORD)length);
FreeImage_SetTagCount(tag, (DWORD)length);
FreeImage_SetTagType(tag, FIDT_ASCII);
FreeImage_SetTagValue(tag, buffer);
FreeImage_SetMetadata(FIMD_COMMENTS, dib, FreeImage_GetTagKey(tag), tag);
// destroy the tag
FreeImage_DeleteTag(tag);
}
}
// ==========================================================
// Plugin Implementation
// ==========================================================
static const char * DLL_CALLCONV
Format() {
return "JPEG";
}
static const char * DLL_CALLCONV
Description() {
return "JPEG - JFIF Compliant";
}
static const char * DLL_CALLCONV
Extension() {
return "jpg,jif,jpeg,jpe";
}
static const char * DLL_CALLCONV
RegExpr() {
return "^\377\330\377";
}
static const char * DLL_CALLCONV
MimeType() {
return "image/jpeg";
}
static BOOL DLL_CALLCONV
Validate(FreeImageIO *io, fi_handle handle) {
BYTE jpeg_signature[] = { 0xFF, 0xD8 };
BYTE signature[2] = { 0, 0 };
io->read_proc(signature, 1, sizeof(jpeg_signature), handle);
return (memcmp(jpeg_signature, signature, sizeof(jpeg_signature)) == 0);
}
static BOOL DLL_CALLCONV
SupportsExportDepth(int depth) {
return (
(depth == 8) ||
(depth == 24)
);
}
static BOOL DLL_CALLCONV
SupportsExportType(FREE_IMAGE_TYPE type) {
return (type == FIT_BITMAP) ? TRUE : FALSE;
}
( run in 1.731 second using v1.01-cache-2.11-cpan-119454b85a5 )