/// "public" fields

struct jpeg_error_mgr pub;

/// for return to caller

jmp_buf setjmp_buffer;

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

/// public fields

struct jpeg_destination_mgr pub;

/// destination stream

fi_handle outfile;

FreeImageIO *m_io;

/// start of buffer

JOCTET * buffer;

freeimage_error_ptr error_ptr = (freeimage_error_ptr)cinfo->err;

error_ptr->pub.msg_code = code;

error_ptr->pub.error_exit(cinfo);

freeimage_error_ptr error_ptr = (freeimage_error_ptr)cinfo->err;

error_ptr->pub.msg_code = code;

error_ptr->pub.emit_message(cinfo, -1);

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

}

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

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;

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;

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

}

}

freeimage_src_ptr src = (freeimage_src_ptr) cinfo->src;

size_t nbytes = src->m_io->read_proc(src->buffer, 1, INPUT_BUF_SIZE, src->infile);

if (nbytes <= 0) {

if (src->start_of_file) {

// treat empty input file as fatal error

// let the memory manager delete any temp files before we die

jpeg_destroy((j_common_ptr)cinfo);

JPEG_EXIT((j_common_ptr)cinfo, JERR_INPUT_EMPTY);

}

JPEG_WARNING((j_common_ptr)cinfo, JWRN_JPEG_EOF);

/* Insert a fake EOI marker */

src->buffer[0] = (JOCTET) 0xFF;

src->buffer[1] = (JOCTET) JPEG_EOI;

nbytes = 2;

}

src->pub.next_input_byte = src->buffer;

src->pub.bytes_in_buffer = nbytes;

src->start_of_file = FALSE;

return TRUE;

freeimage_src_ptr src = (freeimage_src_ptr) cinfo->src;

/* Just a dumb implementation for now. Could use fseek() except

if (num_bytes > 0) {

while (num_bytes > (long) src->pub.bytes_in_buffer) {

num_bytes -= (long) src->pub.bytes_in_buffer;

(void) fill_input_buffer(cinfo);

/* note we assume that fill_input_buffer will never return FALSE,

}

src->pub.next_input_byte += (size_t) num_bytes;

src->pub.bytes_in_buffer -= (size_t) num_bytes;

}

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

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;

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;

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

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;

/**

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;

/**

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;

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

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;

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;

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;

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

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

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

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

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