+
+static void
+convert_cmyk_to_rgb (struct jpeg_decompress_struct *cinfo,
+ guchar **lines)
+{
+ gint i, j;
+
+ g_return_if_fail (cinfo != NULL);
+ g_return_if_fail (cinfo->output_components == 4);
+ g_return_if_fail (cinfo->out_color_space == JCS_CMYK);
+
+ for (i = cinfo->rec_outbuf_height - 1; i >= 0; i--) {
+ guchar *p;
+
+ p = lines[i];
+ for (j = 0; j < cinfo->output_width; j++) {
+ int c, m, y, k;
+ c = p[0];
+ m = p[1];
+ y = p[2];
+ k = p[3];
+ if (cinfo->saw_Adobe_marker) {
+ p[0] = k*c / 255;
+ p[1] = k*m / 255;
+ p[2] = k*y / 255;
+ }
+ else {
+ p[0] = (255 - k)*(255 - c) / 255;
+ p[1] = (255 - k)*(255 - m) / 255;
+ p[2] = (255 - k)*(255 - y) / 255;
+ }
+ p[3] = 255;
+ p += 4;
+ }
+ }
+}
+
+typedef struct {
+ struct jpeg_source_mgr pub; /* public fields */
+
+ FILE * infile; /* source stream */
+ JOCTET * buffer; /* start of buffer */
+ boolean start_of_file; /* have we gotten any data yet? */
+} stdio_source_mgr;
+
+typedef stdio_source_mgr * stdio_src_ptr;
+
+static void
+stdio_init_source (j_decompress_ptr cinfo)
+{
+ stdio_src_ptr src = (stdio_src_ptr)cinfo->src;
+ src->start_of_file = FALSE;
+}
+
+static boolean
+stdio_fill_input_buffer (j_decompress_ptr cinfo)
+{
+ stdio_src_ptr src = (stdio_src_ptr) cinfo->src;
+ size_t nbytes;
+
+ nbytes = fread (src->buffer, 1, JPEG_PROG_BUF_SIZE, src->infile);
+
+ if (nbytes <= 0) {
+#if 0
+ if (src->start_of_file) /* Treat empty input file as fatal error */
+ ERREXIT(cinfo, JERR_INPUT_EMPTY);
+ WARNMS(cinfo, JWRN_JPEG_EOF);
+#endif
+ /* 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;
+}
+
+static void
+stdio_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+{
+ stdio_src_ptr src = (stdio_src_ptr) cinfo->src;
+
+ if (num_bytes > 0) {
+ while (num_bytes > (long) src->pub.bytes_in_buffer) {
+ num_bytes -= (long) src->pub.bytes_in_buffer;
+ (void)stdio_fill_input_buffer(cinfo);
+ }
+ src->pub.next_input_byte += (size_t) num_bytes;
+ src->pub.bytes_in_buffer -= (size_t) num_bytes;
+ }
+}
+
+static void
+stdio_term_source (j_decompress_ptr cinfo)
+{
+}
+
+static gchar *
+colorspace_name (const J_COLOR_SPACE jpeg_color_space)
+{
+ switch (jpeg_color_space) {
+ case JCS_UNKNOWN: return "UNKNOWN";
+ case JCS_GRAYSCALE: return "GRAYSCALE";
+ case JCS_RGB: return "RGB";
+ case JCS_YCbCr: return "YCbCr";
+ case JCS_CMYK: return "CMYK";
+ case JCS_YCCK: return "YCCK";
+ default: return "invalid";
+ }
+}
+
+
+const char leth[] = {0x49, 0x49, 0x2a, 0x00}; // Little endian TIFF header
+const char beth[] = {0x4d, 0x4d, 0x00, 0x2a}; // Big endian TIFF header
+const char types[] = {0x00, 0x01, 0x01, 0x02, 0x04, 0x08, 0x00,
+ 0x08, 0x00, 0x04, 0x08}; // size in bytes for EXIF types
+
+#define DE_ENDIAN16(val) endian == G_BIG_ENDIAN ? GUINT16_FROM_BE(val) : GUINT16_FROM_LE(val)
+#define DE_ENDIAN32(val) endian == G_BIG_ENDIAN ? GUINT32_FROM_BE(val) : GUINT32_FROM_LE(val)
+
+#define ENDIAN16_IT(val) endian == G_BIG_ENDIAN ? GUINT16_TO_BE(val) : GUINT16_TO_LE(val)
+#define ENDIAN32_IT(val) endian == G_BIG_ENDIAN ? GUINT32_TO_BE(val) : GUINT32_TO_LE(val)
+
+#define EXIF_JPEG_MARKER JPEG_APP0+1
+#define EXIF_IDENT_STRING "Exif\000\000"
+
+static unsigned short de_get16(void *ptr, guint endian)
+{
+ unsigned short val;
+
+ memcpy(&val, ptr, sizeof(val));
+ val = DE_ENDIAN16(val);
+
+ return val;
+}
+
+static unsigned int de_get32(void *ptr, guint endian)
+{
+ unsigned int val;
+
+ memcpy(&val, ptr, sizeof(val));
+ val = DE_ENDIAN32(val);
+
+ return val;
+}
+
+static gint
+get_orientation (j_decompress_ptr cinfo)
+{
+ /* This function looks through the meta data in the libjpeg decompress structure to
+ determine if an EXIF Orientation tag is present and if so return its value (1-8).
+ If no EXIF Orientation tag is found 0 (zero) is returned. */
+
+ guint i; /* index into working buffer */
+ guint orient_tag_id; /* endianed version of orientation tag ID */
+ guint ret; /* Return value */
+ guint offset; /* de-endianed offset in various situations */
+ guint tags; /* number of tags in current ifd */
+ guint type; /* de-endianed type of tag used as index into types[] */
+ guint count; /* de-endianed count of elements in a tag */
+ guint tiff = 0; /* offset to active tiff header */
+ guint endian = 0; /* detected endian of data */
+
+ jpeg_saved_marker_ptr exif_marker; /* Location of the Exif APP1 marker */
+ jpeg_saved_marker_ptr cmarker; /* Location to check for Exif APP1 marker */
+
+ /* check for Exif marker (also called the APP1 marker) */
+ exif_marker = NULL;
+ cmarker = cinfo->marker_list;
+ while (cmarker) {
+ if (cmarker->marker == EXIF_JPEG_MARKER) {
+ /* The Exif APP1 marker should contain a unique
+ identification string ("Exif\0\0"). Check for it. */
+ if (!memcmp (cmarker->data, EXIF_IDENT_STRING, 6)) {
+ exif_marker = cmarker;
+ }
+ }
+ cmarker = cmarker->next;
+ }
+
+ /* Did we find the Exif APP1 marker? */
+ if (exif_marker == NULL)
+ return 0;
+
+ /* Do we have enough data? */
+ if (exif_marker->data_length < 32)
+ return 0;
+
+ /* Check for TIFF header and catch endianess */
+ i = 0;
+
+ /* Just skip data until TIFF header - it should be within 16 bytes from marker start.
+ Normal structure relative to APP1 marker -
+ 0x0000: APP1 marker entry = 2 bytes
+ 0x0002: APP1 length entry = 2 bytes
+ 0x0004: Exif Identifier entry = 6 bytes
+ 0x000A: Start of TIFF header (Byte order entry) - 4 bytes
+ - This is what we look for, to determine endianess.
+ 0x000E: 0th IFD offset pointer - 4 bytes
+
+ exif_marker->data points to the first data after the APP1 marker
+ and length entries, which is the exif identification string.
+ The TIFF header should thus normally be found at i=6, below,
+ and the pointer to IFD0 will be at 6+4 = 10.
+ */
+
+ while (i < 16) {
+
+ /* Little endian TIFF header */
+ if (memcmp (&exif_marker->data[i], leth, 4) == 0){
+ endian = G_LITTLE_ENDIAN;
+ }
+
+ /* Big endian TIFF header */
+ else if (memcmp (&exif_marker->data[i], beth, 4) == 0){
+ endian = G_BIG_ENDIAN;
+ }
+
+ /* Keep looking through buffer */
+ else {
+ i++;
+ continue;
+ }
+ /* We have found either big or little endian TIFF header */
+ tiff = i;
+ break;
+ }
+
+ /* So did we find a TIFF header or did we just hit end of buffer? */
+ if (tiff == 0)
+ return 0;
+
+ /* Endian the orientation tag ID, to locate it more easily */
+ orient_tag_id = ENDIAN16_IT(0x112);
+
+ /* Read out the offset pointer to IFD0 */
+ offset = de_get32(&exif_marker->data[i] + 4, endian);
+ i = i + offset;
+
+ /* Check that we still are within the buffer and can read the tag count */
+ if ((i + 2) > exif_marker->data_length)
+ return 0;
+
+ /* Find out how many tags we have in IFD0. As per the TIFF spec, the first
+ two bytes of the IFD contain a count of the number of tags. */
+ tags = de_get16(&exif_marker->data[i], endian);
+ i = i + 2;
+
+ /* Check that we still have enough data for all tags to check. The tags
+ are listed in consecutive 12-byte blocks. The tag ID, type, size, and
+ a pointer to the actual value, are packed into these 12 byte entries. */
+ if ((i + tags * 12) > exif_marker->data_length)
+ return 0;
+
+ /* Check through IFD0 for tags of interest */
+ while (tags--){
+ type = de_get16(&exif_marker->data[i + 2], endian);
+ count = de_get32(&exif_marker->data[i + 4], endian);
+
+ /* Is this the orientation tag? */
+ if (memcmp (&exif_marker->data[i], (char *) &orient_tag_id, 2) == 0){
+
+ /* Check that type and count fields are OK. The orientation field
+ will consist of a single (count=1) 2-byte integer (type=3). */
+ if (type != 3 || count != 1) return 0;
+
+ /* Return the orientation value. Within the 12-byte block, the
+ pointer to the actual data is at offset 8. */
+ ret = de_get16(&exif_marker->data[i + 8], endian);
+ return ret <= 8 ? ret : 0;
+ }
+ /* move the pointer to the next 12-byte tag field. */
+ i = i + 12;
+ }
+
+ return 0; /* No EXIF Orientation tag found */
+}
+
+