/* -*- mode: C; c-file-style: "linux" -*- */

/* GdkPixbuf library - JPEG image loader

 *

 * Copyright (C) 1999 Michael Zucchi

 * Copyright (C) 1999 The Free Software Foundation

 * 

 * Progressive loading code Copyright (C) 1999 Red Hat, Inc.

 *

 * Authors: Michael Zucchi <zucchi@zedzone.mmc.com.au>

 *          Federico Mena-Quintero <federico@gimp.org>

 *          Michael Fulbright <drmike@redhat.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include "config.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <setjmp.h>

#include <jpeglib.h>

#include <jerror.h>

#include <math.h>

#include "gdk-pixbuf-private.h"

#include "fallback-c89.c"

#ifndef HAVE_SIGSETJMP

#define sigjmp_buf jmp_buf

#define sigsetjmp(jb, x) setjmp(jb)

#define siglongjmp longjmp

#endif

/* we are a "source manager" as far as libjpeg is concerned */

#define JPEG_PROG_BUF_SIZE 65536

typedef struct {

	struct jpeg_source_mgr pub;   /* public fields */

	JOCTET buffer[JPEG_PROG_BUF_SIZE];              /* start of buffer */

	long  skip_next;              /* number of bytes to skip next read */

} my_source_mgr;

typedef my_source_mgr * my_src_ptr;

/* error handler data */

struct error_handler_data {

	struct jpeg_error_mgr pub;

	sigjmp_buf setjmp_buffer;

        GError **error;

};

/* progressive loader context */

typedef struct {

        GdkPixbufModuleSizeFunc     size_func;

	GdkPixbufModuleUpdatedFunc  updated_func;

	GdkPixbufModulePreparedFunc prepared_func;

	gpointer                    user_data;

	GdkPixbuf                *pixbuf;

	guchar                   *dptr;   /* current position in pixbuf */

	gboolean                 did_prescan;  /* are we in image data yet? */

	gboolean                 got_header;  /* have we loaded jpeg header? */

	gboolean                 src_initialized;/* TRUE when jpeg lib initialized */

	gboolean                 in_output;   /* did we get suspended in an output pass? */

	struct jpeg_decompress_struct cinfo;

	struct error_handler_data     jerr;

} JpegProgContext;

/* EXIF context */

typedef struct {

	gint			 orientation;

	gchar			*icc_profile;

	gsize			 icc_profile_size;

	gsize			 icc_profile_size_allocated;

} JpegExifContext;

static GdkPixbuf *gdk_pixbuf__jpeg_image_load (FILE *f, GError **error);

static gpointer gdk_pixbuf__jpeg_image_begin_load (GdkPixbufModuleSizeFunc           func0,

                                                   GdkPixbufModulePreparedFunc func1, 

                                                   GdkPixbufModuleUpdatedFunc func2,

                                                   gpointer user_data,

                                                   GError **error);

static gboolean gdk_pixbuf__jpeg_image_stop_load (gpointer context, GError **error);

static gboolean gdk_pixbuf__jpeg_image_load_increment(gpointer context,

                                                      const guchar *buf, guint size,

                                                      GError **error);

static void

fatal_error_handler (j_common_ptr cinfo)

{

	struct error_handler_data *errmgr;

        char buffer[JMSG_LENGTH_MAX];

	errmgr = (struct error_handler_data *) cinfo->err;

        /* Create the message */

        (* cinfo->err->format_message) (cinfo, buffer);

        /* broken check for *error == NULL for robustness against

         * crappy JPEG library

         */

        if (errmgr->error && *errmgr->error == NULL) {

                g_set_error (errmgr->error,

                             GDK_PIXBUF_ERROR,

                             cinfo->err->msg_code == JERR_OUT_OF_MEMORY 

			     ? GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY 

			     : GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                             _("Error interpreting JPEG image file (%s)"),

                             buffer);

        }

	siglongjmp (errmgr->setjmp_buffer, 1);

        g_assert_not_reached ();

}

static void

output_message_handler (j_common_ptr cinfo)

{

  /* This method keeps libjpeg from dumping crap to stderr */

  /* do nothing */

}

/* explode gray image data from jpeg library into rgb components in pixbuf */

static void

explode_gray_into_buf (struct jpeg_decompress_struct *cinfo,

		       guchar **lines) 

{

	gint i, j;

	guint w;

	g_return_if_fail (cinfo != NULL);

	g_return_if_fail (cinfo->output_components == 1);

	g_return_if_fail (cinfo->out_color_space == JCS_GRAYSCALE);

	/* Expand grey->colour.  Expand from the end of the

	 * memory down, so we can use the same buffer.

	 */

	w = cinfo->output_width;

	for (i = cinfo->rec_outbuf_height - 1; i >= 0; i--) {

		guchar *from, *to;

		from = lines[i] + w - 1;

		to = lines[i] + (w - 1) * 3;

		for (j = w - 1; j >= 0; j--) {

			to[0] = from[0];

			to[1] = from[0];

			to[2] = from[0];

			to -= 3;

			from--;

		}

	}

}

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

			/* We now assume that all CMYK JPEG files

			 * use inverted CMYK, as Photoshop does

			 * See https://bugzilla.gnome.org/show_bug.cgi?id=618096 */

			p[0] = k*c / 255;

			p[1] = k*m / 255;

			p[2] = k*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";

	}

}

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

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;

}

/* application specific data segment */

static gboolean

jpeg_parse_exif_app2_segment (JpegExifContext *context, jpeg_saved_marker_ptr marker)

{

	guint ret = FALSE;

	guint sequence_number;

	guint number_of_chunks;

	guint chunk_size;

	guint offset;

	/* do we have enough data? */

	if (marker->data_length < 16)

		goto out;

	/* unique identification string */

	if (memcmp (marker->data, "ICC_PROFILE\0", 12) != 0)

		goto out;

	/* get data about this segment */

	sequence_number = marker->data[12];

	number_of_chunks = marker->data[13];

	/* this is invalid, the base offset is 1 */

	if (sequence_number == 0)

		goto out;

	/* this is invalid, the base offset is 1 */

	if (sequence_number > number_of_chunks)

		goto out;

	/* size includes the id (12 bytes), length field (1 byte), and sequence field (1 byte) */

	chunk_size = marker->data_length - 14;

	offset = (sequence_number - 1) * 0xffef;

	/* Deal with the trivial profile (99% of images) to avoid allocating

	 * 64kb when we might only use a few kb. */

	if (number_of_chunks == 1) {

		if (context->icc_profile_size_allocated > 0)

			goto out;

		context->icc_profile_size = chunk_size;

		context->icc_profile_size_allocated = chunk_size;

		context->icc_profile = g_new (gchar, chunk_size);

		/* copy the segment data to the profile space */

		memcpy (context->icc_profile, marker->data + 14, chunk_size);

		goto out;

	}

	/* There is no promise the APP2 segments are going to be in order, so we

	 * have to allocate a huge swathe of memory and fill in the gaps when

	 * (if) we get the segment.

	 * Theoretically this could be as much as 16Mb, but display profiles are

	 * vary rarely above 100kb, and printer profiles are usually less than

	 * 2Mb */

	if (context->icc_profile_size_allocated == 0) {

		context->icc_profile_size_allocated = number_of_chunks * 0xffff;

		context->icc_profile = g_new0 (gchar, number_of_chunks * 0xffff);

	}

	/* check the data will fit in our previously allocated buffer */

	if (offset + chunk_size > context->icc_profile_size_allocated)

		goto out;

	/* copy the segment data to the profile space */

	memcpy (context->icc_profile + offset, marker->data + 14, chunk_size);

	/* it's now this big plus the new data we've just copied */

	context->icc_profile_size += chunk_size;

	/* success */

	ret = TRUE;

out:

	return ret;

}

static gboolean

jpeg_parse_exif_app1 (JpegExifContext *context, jpeg_saved_marker_ptr marker)

{

	guint i;

	guint ret = FALSE;

	guint offset;

	guint tags;	   /* number of tags in current ifd */

	guint endian = 0;	/* detected endian of data */

	const char leth[]  = {0x49, 0x49, 0x2a, 0x00};	// Little endian TIFF header

	const char beth[]  = {0x4d, 0x4d, 0x00, 0x2a};	// Big endian TIFF header

	/* do we have enough data? */

	if (marker->data_length < 4)

		goto out;

	/* unique identification string */

	if (memcmp (marker->data, "Exif", 4) != 0)

		goto out;

	/* do we have enough data? */

	if (marker->data_length < 32)

		goto out;

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

		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.

	*/

	for (i=0; i<16; i++) {

		/* little endian TIFF header */

		if (memcmp (&marker->data[i], leth, 4) == 0) {

			endian = G_LITTLE_ENDIAN;

			ret = TRUE;

			break;

		}

		/* big endian TIFF header */

		if (memcmp (&marker->data[i], beth, 4) == 0) {

			endian = G_BIG_ENDIAN;

			ret = TRUE;

			break;

		}

	}

	/* could not find header */

	if (!ret)

		goto out;

	/* read out the offset pointer to IFD0 */

	offset  = de_get32(&marker->data[i] + 4, endian);

	i = i + offset;

	/* check that we still are within the buffer and can read the tag count */

	{

	    const size_t new_i = i + 2;

	    if (new_i < i || new_i > marker->data_length) {

		    ret = FALSE;

		    goto out;

	    }

	    /* 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(&marker->data[i], endian);

	    i = new_i;

	}

	/* 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. */

	{

	    const size_t new_i = i + tags * 12;

	    if (new_i < i || new_i > marker->data_length) {

		ret = FALSE;

		goto out;

	    }

	}

	/* check through IFD0 for tags */

	while (tags--) {

		size_t new_i;

		/* We check for integer overflow before the loop and

		 * at the end of each iteration */

		guint tag   = de_get16(&marker->data[i + 0], endian);

		guint type  = de_get16(&marker->data[i + 2], endian);

		guint count = de_get32(&marker->data[i + 4], endian);

		/* orientation tag? */

		if (tag == 0x112){

			/* The orientation field should consist of a single 2-byte integer,

			 * but might be a signed long.

			 * Values of types smaller than 4 bytes are stored directly in the

			 * Value Offset field */

			if (type == 0x3 && count == 1) {

				guint short_value = de_get16(&marker->data[i + 8], endian);

				context->orientation = short_value <= 8 ? short_value : 0;

			} else if (type == 0x9 && count == 1) {

				guint long_value = de_get32(&marker->data[i + 8], endian);

				context->orientation = long_value <= 8 ? long_value : 0;

			}

		}

		/* move the pointer to the next 12-byte tag field. */

		new_i = i + 12;

		if (new_i < i || new_i > marker->data_length) {

			ret = FALSE;

			goto out;

		}

		i = new_i;

	}

out:

	return ret;

}

static void

jpeg_parse_exif (JpegExifContext *context, j_decompress_ptr cinfo)

{

	jpeg_saved_marker_ptr cmarker;

	/* check for interesting Exif markers */

	cmarker = cinfo->marker_list;

	while (cmarker != NULL) {

		if (cmarker->marker == JPEG_APP0+1)

			jpeg_parse_exif_app1 (context, cmarker);

		else if (cmarker->marker == JPEG_APP0+2)

			jpeg_parse_exif_app2_segment (context, cmarker);

		cmarker = cmarker->next;

	}

}

static gchar *

jpeg_get_comment (j_decompress_ptr cinfo)

{

	jpeg_saved_marker_ptr cmarker;

	cmarker = cinfo->marker_list;

	while (cmarker != NULL) {

		if (cmarker->marker == JPEG_COM)

			return g_strndup ((const gchar *) cmarker->data, cmarker->data_length);

		cmarker = cmarker->next;

	}

	return NULL;

}

static void

jpeg_destroy_exif_context (JpegExifContext *context)

{

	g_free (context->icc_profile);

}

/* Shared library entry point */

static GdkPixbuf *

gdk_pixbuf__jpeg_image_load (FILE *f, GError **error)

{

	gint   i;

	char   otag_str[5];

	char  *density_str;

	GdkPixbuf * volatile pixbuf = NULL;

	guchar *dptr;

	guchar *lines[4]; /* Used to expand rows, via rec_outbuf_height, 

                           * from the header file: 

                           * " Usually rec_outbuf_height will be 1 or 2, 

                           * at most 4."

			   */

	guchar **lptr;

	struct jpeg_decompress_struct cinfo;

	struct error_handler_data jerr;

	stdio_src_ptr src;

	gchar *icc_profile_base64;

	gchar *comment;

	JpegExifContext exif_context = { 0, };

	/* setup error handler */

	cinfo.err = jpeg_std_error (&jerr.pub);

	jerr.pub.error_exit = fatal_error_handler;

        jerr.pub.output_message = output_message_handler;

        jerr.error = error;

	if (sigsetjmp (jerr.setjmp_buffer, 1)) {

		/* Whoops there was a jpeg error */

		if (pixbuf)

			g_object_unref (pixbuf);

		jpeg_destroy_decompress (&cinfo);

		jpeg_destroy_exif_context (&exif_context);

		/* error should have been set by fatal_error_handler () */

		return NULL;

	}

	/* load header, setup */

	jpeg_create_decompress (&cinfo);

	cinfo.src = (struct jpeg_source_mgr *)

	  (*cinfo.mem->alloc_small) ((j_common_ptr) &cinfo, JPOOL_PERMANENT,

				  sizeof (stdio_source_mgr));

	src = (stdio_src_ptr) cinfo.src;

	src->buffer = (JOCTET *)

	  (*cinfo.mem->alloc_small) ((j_common_ptr) &cinfo, JPOOL_PERMANENT,

				      JPEG_PROG_BUF_SIZE * sizeof (JOCTET));

	src->pub.init_source = stdio_init_source;

	src->pub.fill_input_buffer = stdio_fill_input_buffer;

	src->pub.skip_input_data = stdio_skip_input_data;

	src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */

	src->pub.term_source = stdio_term_source;

	src->infile = f;

	src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */

	src->pub.next_input_byte = NULL; /* until buffer loaded */

	jpeg_save_markers (&cinfo, JPEG_APP0+1, 0xffff);

	jpeg_save_markers (&cinfo, JPEG_APP0+2, 0xffff);

	jpeg_save_markers (&cinfo, JPEG_COM, 0xffff);

	jpeg_read_header (&cinfo, TRUE);

	/* parse exif data */

	jpeg_parse_exif (&exif_context, &cinfo);

	jpeg_start_decompress (&cinfo);

	cinfo.do_fancy_upsampling = FALSE;

	cinfo.do_block_smoothing = FALSE;

	pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 

				 cinfo.out_color_components == 4 ? TRUE : FALSE, 

				 8, cinfo.output_width, cinfo.output_height);

	if (!pixbuf) {

                /* broken check for *error == NULL for robustness against

                 * crappy JPEG library

                 */

                if (error && *error == NULL) {

                        g_set_error_literal (error,

                                             GDK_PIXBUF_ERROR,

                                             GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,

                                             _("Insufficient memory to load image, try exiting some applications to free memory"));

                }

		goto out; 

	}

	comment = jpeg_get_comment (&cinfo);

	if (comment != NULL) {

		gdk_pixbuf_set_option (pixbuf, "comment", comment);

		g_free (comment);

	}

	switch (cinfo.density_unit) {

	case 1:

		/* Dots per inch (no conversion required) */

		density_str = g_strdup_printf ("%d", cinfo.X_density);

		gdk_pixbuf_set_option (pixbuf, "x-dpi", density_str);

		g_free (density_str);

		density_str = g_strdup_printf ("%d", cinfo.Y_density);

		gdk_pixbuf_set_option (pixbuf, "y-dpi", density_str);

		g_free (density_str);

		break;

	case 2:

		/* Dots per cm - convert into dpi */

		density_str = g_strdup_printf ("%d", DPCM_TO_DPI (cinfo.X_density));

		gdk_pixbuf_set_option (pixbuf, "x-dpi", density_str);

		g_free (density_str);

		density_str = g_strdup_printf ("%d", DPCM_TO_DPI (cinfo.Y_density));

		gdk_pixbuf_set_option (pixbuf, "y-dpi", density_str);

		g_free (density_str);

		break;

	}

	/* if orientation tag was found */

	if (exif_context.orientation != 0) {

		g_snprintf (otag_str, sizeof (otag_str), "%d", exif_context.orientation);

		gdk_pixbuf_set_option (pixbuf, "orientation", otag_str);

	}

	/* if icc profile was found */

	if (exif_context.icc_profile != NULL) {

		icc_profile_base64 = g_base64_encode ((const guchar *) exif_context.icc_profile, exif_context.icc_profile_size);

		gdk_pixbuf_set_option (pixbuf, "icc-profile", icc_profile_base64);

		g_free (icc_profile_base64);

	}

	dptr = pixbuf->pixels;

	/* decompress all the lines, a few at a time */

	while (cinfo.output_scanline < cinfo.output_height) {

		lptr = lines;

		for (i = 0; i < cinfo.rec_outbuf_height; i++) {

			*lptr++ = dptr;

			dptr += pixbuf->rowstride;

		}

		jpeg_read_scanlines (&cinfo, lines, cinfo.rec_outbuf_height);

		switch (cinfo.out_color_space) {

		    case JCS_GRAYSCALE:

		      explode_gray_into_buf (&cinfo, lines);

		      break;

		    case JCS_RGB:

		      /* do nothing */

		      break;

		    case JCS_CMYK:

		      convert_cmyk_to_rgb (&cinfo, lines);

		      break;

		    default:

		      g_clear_object (&pixbuf);

                      g_set_error (error,

                                   GDK_PIXBUF_ERROR,

				   GDK_PIXBUF_ERROR_UNKNOWN_TYPE,

				   _("Unsupported JPEG color space (%s)"),

				   colorspace_name (cinfo.out_color_space));

		      goto out;

		}

	}

out:

	jpeg_finish_decompress (&cinfo);

	jpeg_destroy_decompress (&cinfo);

	jpeg_destroy_exif_context (&exif_context);

	return pixbuf;

}

/**** Progressive image loading handling *****/

/* these routines required because we are acting as a source manager for */

/* libjpeg. */

static void

init_source (j_decompress_ptr cinfo)

{

	my_src_ptr src = (my_src_ptr) cinfo->src;

	src->skip_next = 0;

}

static void

term_source (j_decompress_ptr cinfo)

{

	/* XXXX - probably should scream something has happened */

}

/* for progressive loading (called "I/O Suspension" by libjpeg docs) */

/* we do nothing except return "FALSE"                               */

static boolean

fill_input_buffer (j_decompress_ptr cinfo)

{

	return FALSE;

}

static void

skip_input_data (j_decompress_ptr cinfo, long num_bytes)

{

	my_src_ptr src = (my_src_ptr) cinfo->src;

	long   num_can_do;

	/* move as far as we can into current buffer */

	/* then set skip_next to catch the rest      */

	if (num_bytes > 0) {

		num_can_do = MIN (src->pub.bytes_in_buffer, num_bytes);

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

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

		src->skip_next = num_bytes - num_can_do;

	}

}

/* 

 * func - called when we have pixmap created (but no image data)

 * user_data - passed as arg 1 to func

 * return context (opaque to user)

 */

static gpointer

gdk_pixbuf__jpeg_image_begin_load (GdkPixbufModuleSizeFunc size_func,

				   GdkPixbufModulePreparedFunc prepared_func, 

				   GdkPixbufModuleUpdatedFunc updated_func,

				   gpointer user_data,

                                   GError **error)

{

	JpegProgContext *context;

	my_source_mgr   *src;

	context = g_new0 (JpegProgContext, 1);

	context->size_func = size_func;

	context->prepared_func = prepared_func;

	context->updated_func  = updated_func;

	context->user_data = user_data;

	context->pixbuf = NULL;

	context->got_header = FALSE;

	context->did_prescan = FALSE;

	context->src_initialized = FALSE;

	context->in_output = FALSE;

        /* From jpeglib.h: "NB: you must set up the error-manager

         * BEFORE calling jpeg_create_xxx". */

	context->cinfo.err = jpeg_std_error (&context->jerr.pub);

	context->jerr.pub.error_exit = fatal_error_handler;

        context->jerr.pub.output_message = output_message_handler;

        context->jerr.error = error;

        if (sigsetjmp (context->jerr.setjmp_buffer, 1)) {

                jpeg_destroy_decompress (&context->cinfo);

                g_free(context);

                /* error should have been set by fatal_error_handler () */

                return NULL;

        }

	/* create libjpeg structures */

	jpeg_create_decompress (&context->cinfo);

	context->cinfo.src = (struct jpeg_source_mgr *) g_try_malloc (sizeof (my_source_mgr));

	if (!context->cinfo.src) {

		g_set_error_literal (error,

                                     GDK_PIXBUF_ERROR,

                                     GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,

                                     _("Couldn't allocate memory for loading JPEG file"));

		return NULL;

	}

	memset (context->cinfo.src, 0, sizeof (my_source_mgr));

	src = (my_src_ptr) context->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;

	src->pub.term_source = term_source;

	src->pub.bytes_in_buffer = 0;

	src->pub.next_input_byte = NULL;

        context->jerr.error = NULL;

	return (gpointer) context;

}

/*

 * context - returned from image_begin_load

 *

 * free context, unref gdk_pixbuf

 */

static gboolean

gdk_pixbuf__jpeg_image_stop_load (gpointer data, GError **error)

{

	JpegProgContext *context = (JpegProgContext *) data;

        gboolean retval;

	g_return_val_if_fail (context != NULL, TRUE);

        /* FIXME this thing needs to report errors if

         * we have unused image data

         */

	if (context->pixbuf)

		g_object_unref (context->pixbuf);

	/* if we have an error? */

	context->jerr.error = error;

	if (sigsetjmp (context->jerr.setjmp_buffer, 1)) {

                retval = FALSE;

	} else {

		jpeg_finish_decompress (&context->cinfo);

                retval = TRUE;

	}

        jpeg_destroy_decompress (&context->cinfo);

	if (context->cinfo.src) {

		my_src_ptr src = (my_src_ptr) context->cinfo.src;

		g_free (src);

	}

	g_free (context);

        return retval;

}

static gboolean

gdk_pixbuf__jpeg_image_load_lines (JpegProgContext  *context,