+static gboolean
+gdk_pixbuf__jpeg_image_load_increment (gpointer data,
+ const guchar *buf, guint size,
+ GError **error)
+{
+ JpegProgContext *context = (JpegProgContext *)data;
+ struct jpeg_decompress_struct *cinfo;
+ my_src_ptr src;
+ guint num_left, num_copy;
+ guint last_bytes_left;
+ guint spinguard;
+ gboolean first;
+ const guchar *bufhd;
+ gint width, height;
+
+ g_return_val_if_fail (context != NULL, FALSE);
+ g_return_val_if_fail (buf != NULL, FALSE);
+
+ src = (my_src_ptr) context->cinfo.src;
+
+ cinfo = &context->cinfo;
+
+ context->jerr.error = error;
+
+ /* check for fatal error */
+ if (sigsetjmp (context->jerr.setjmp_buffer, 1)) {
+ return FALSE;
+ }
+
+ /* skip over data if requested, handle unsigned int sizes cleanly */
+ /* only can happen if we've already called jpeg_get_header once */
+ if (context->src_initialized && src->skip_next) {
+ if (src->skip_next > size) {
+ src->skip_next -= size;
+ return TRUE;
+ } else {
+ num_left = size - src->skip_next;
+ bufhd = buf + src->skip_next;
+ src->skip_next = 0;
+ }
+ } else {
+ num_left = size;
+ bufhd = buf;
+ }
+
+ if (num_left == 0)
+ return TRUE;
+
+ last_bytes_left = 0;
+ spinguard = 0;
+ first = TRUE;
+ while (TRUE) {
+
+ /* handle any data from caller we haven't processed yet */
+ if (num_left > 0) {
+ if(src->pub.bytes_in_buffer &&
+ src->pub.next_input_byte != src->buffer)
+ memmove(src->buffer, src->pub.next_input_byte,
+ src->pub.bytes_in_buffer);
+
+
+ num_copy = MIN (JPEG_PROG_BUF_SIZE - src->pub.bytes_in_buffer,
+ num_left);
+
+ memcpy(src->buffer + src->pub.bytes_in_buffer, bufhd,num_copy);
+ src->pub.next_input_byte = src->buffer;
+ src->pub.bytes_in_buffer += num_copy;
+ bufhd += num_copy;
+ num_left -= num_copy;
+ } else {
+ /* did anything change from last pass, if not return */
+ if (first) {
+ last_bytes_left = src->pub.bytes_in_buffer;
+ first = FALSE;
+ } else if (src->pub.bytes_in_buffer == last_bytes_left)
+ spinguard++;
+ else
+ last_bytes_left = src->pub.bytes_in_buffer;
+ }
+
+ /* should not go through twice and not pull bytes out of buf */
+ if (spinguard > 2)
+ return TRUE;
+
+ /* try to load jpeg header */
+ if (!context->got_header) {
+ int rc;
+
+ rc = jpeg_read_header (cinfo, TRUE);
+ context->src_initialized = TRUE;
+
+ if (rc == JPEG_SUSPENDED)
+ continue;
+
+ context->got_header = TRUE;
+
+ width = cinfo->image_width;
+ height = cinfo->image_height;
+ if (context->size_func) {
+ (* context->size_func) (&width, &height, context->user_data);
+ if (width == 0 || height == 0)
+ return FALSE;
+ }
+
+ for (cinfo->scale_denom = 2; cinfo->scale_denom <= 8; cinfo->scale_denom *= 2) {
+ jpeg_calc_output_dimensions (cinfo);
+ if (cinfo->output_width < width || cinfo->output_height < height) {
+ cinfo->scale_denom /= 2;
+ break;
+ }
+ }
+ jpeg_calc_output_dimensions (cinfo);
+
+ context->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+ cinfo->output_components == 4 ? TRUE : FALSE,
+ 8,
+ cinfo->output_width,
+ cinfo->output_height);
+
+ if (context->pixbuf == NULL) {
+ g_set_error (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+ _("Couldn't allocate memory for loading JPEG file"));
+ return FALSE;
+ }
+
+ /* Use pixbuf buffer to store decompressed data */
+ context->dptr = context->pixbuf->pixels;
+
+ /* Notify the client that we are ready to go */
+ if (context->prepared_func)
+ (* context->prepared_func) (context->pixbuf,
+ NULL,
+ context->user_data);
+
+ } else if (!context->did_prescan) {
+ int rc;
+
+ /* start decompression */
+ cinfo->buffered_image = cinfo->progressive_mode;
+ rc = jpeg_start_decompress (cinfo);
+ cinfo->do_fancy_upsampling = FALSE;
+ cinfo->do_block_smoothing = FALSE;
+
+ if (rc == JPEG_SUSPENDED)
+ continue;
+
+ context->did_prescan = TRUE;
+ } else if (!cinfo->buffered_image) {
+ /* we're decompressing unbuffered so
+ * simply get scanline by scanline from jpeg lib
+ */
+ if (! gdk_pixbuf__jpeg_image_load_lines (context,
+ error))
+ return FALSE;
+
+ if (cinfo->output_scanline >= cinfo->output_height)
+ return TRUE;
+ } else {
+ /* we're decompressing buffered (progressive)
+ * so feed jpeg lib scanlines
+ */
+
+ /* keep going until we've done all passes */
+ while (!jpeg_input_complete (cinfo)) {
+ if (!context->in_output) {
+ if (jpeg_start_output (cinfo, cinfo->input_scan_number)) {
+ context->in_output = TRUE;
+ context->dptr = context->pixbuf->pixels;
+ }
+ else
+ break;
+ }
+
+ /* get scanlines from jpeg lib */
+ if (! gdk_pixbuf__jpeg_image_load_lines (context,
+ error))
+ return FALSE;
+
+ if (cinfo->output_scanline >= cinfo->output_height &&
+ jpeg_finish_output (cinfo))
+ context->in_output = FALSE;
+ else
+ break;
+ }
+ if (jpeg_input_complete (cinfo))
+ /* did entire image */
+ return TRUE;
+ else
+ continue;
+ }
+ }
+
+ return TRUE;
+}
+
+/* Save */
+
+#define TO_FUNCTION_BUF_SIZE 4096
+
+typedef struct {
+ struct jpeg_destination_mgr pub;
+ JOCTET *buffer;
+ GdkPixbufSaveFunc save_func;
+ gpointer user_data;
+ GError **error;
+} ToFunctionDestinationManager;
+
+void
+to_callback_init (j_compress_ptr cinfo)
+{
+ ToFunctionDestinationManager *destmgr;
+
+ destmgr = (ToFunctionDestinationManager*) cinfo->dest;
+ destmgr->pub.next_output_byte = destmgr->buffer;
+ destmgr->pub.free_in_buffer = TO_FUNCTION_BUF_SIZE;
+}
+
+static void
+to_callback_do_write (j_compress_ptr cinfo, gsize length)
+{
+ ToFunctionDestinationManager *destmgr;
+
+ destmgr = (ToFunctionDestinationManager*) cinfo->dest;
+ if (!destmgr->save_func (destmgr->buffer,
+ length,
+ destmgr->error,
+ destmgr->user_data)) {
+ struct error_handler_data *errmgr;
+
+ errmgr = (struct error_handler_data *) cinfo->err;
+ /* Use a default error message if the callback didn't set one,
+ * which it should have.
+ */
+ if (errmgr->error && *errmgr->error == NULL) {
+ g_set_error (errmgr->error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
+ "write function failed");
+ }
+ siglongjmp (errmgr->setjmp_buffer, 1);
+ g_assert_not_reached ();
+ }
+}
+
+static boolean
+to_callback_empty_output_buffer (j_compress_ptr cinfo)
+{
+ ToFunctionDestinationManager *destmgr;
+
+ destmgr = (ToFunctionDestinationManager*) cinfo->dest;
+ to_callback_do_write (cinfo, TO_FUNCTION_BUF_SIZE);
+ destmgr->pub.next_output_byte = destmgr->buffer;
+ destmgr->pub.free_in_buffer = TO_FUNCTION_BUF_SIZE;
+ return TRUE;
+}
+
+void
+to_callback_terminate (j_compress_ptr cinfo)
+{
+ ToFunctionDestinationManager *destmgr;
+
+ destmgr = (ToFunctionDestinationManager*) cinfo->dest;
+ to_callback_do_write (cinfo, TO_FUNCTION_BUF_SIZE - destmgr->pub.free_in_buffer);
+}
+
+static gboolean
+real_save_jpeg (GdkPixbuf *pixbuf,
+ gchar **keys,
+ gchar **values,
+ GError **error,
+ gboolean to_callback,
+ FILE *f,
+ GdkPixbufSaveFunc save_func,
+ gpointer user_data)
+{
+ /* FIXME error handling is broken */
+
+ struct jpeg_compress_struct cinfo;
+ guchar *buf = NULL;
+ guchar *ptr;
+ guchar *pixels = NULL;
+ JSAMPROW *jbuf;
+ int y = 0;
+ volatile int quality = 75; /* default; must be between 0 and 100 */
+ int i, j;
+ int w, h = 0;
+ int rowstride = 0;
+ int n_channels;
+ struct error_handler_data jerr;
+ ToFunctionDestinationManager to_callback_destmgr;
+
+ to_callback_destmgr.buffer = NULL;
+
+ if (keys && *keys) {
+ gchar **kiter = keys;
+ gchar **viter = values;
+
+ while (*kiter) {
+ if (strcmp (*kiter, "quality") == 0) {
+ char *endptr = NULL;
+ quality = strtol (*viter, &endptr, 10);
+
+ if (endptr == *viter) {
+ g_set_error (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_BAD_OPTION,
+ _("JPEG quality must be a value between 0 and 100; value '%s' could not be parsed."),
+ *viter);
+
+ return FALSE;
+ }
+
+ if (quality < 0 ||
+ quality > 100) {
+ /* This is a user-visible error;
+ * lets people skip the range-checking
+ * in their app.
+ */
+ g_set_error (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_BAD_OPTION,
+ _("JPEG quality must be a value between 0 and 100; value '%d' is not allowed."),
+ quality);
+
+ return FALSE;
+ }
+ } else {
+ g_warning ("Bad option name '%s' passed to JPEG saver",
+ *kiter);
+ return FALSE;
+ }
+
+ ++kiter;
+ ++viter;
+ }
+ }
+
+ rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+ n_channels = gdk_pixbuf_get_n_channels (pixbuf);
+
+ w = gdk_pixbuf_get_width (pixbuf);
+ h = gdk_pixbuf_get_height (pixbuf);
+
+ /* no image data? abort */
+ pixels = gdk_pixbuf_get_pixels (pixbuf);
+ g_return_val_if_fail (pixels != NULL, FALSE);
+
+ /* Allocate a small buffer to convert image data,
+ * and a larger buffer if doing to_callback save.
+ */
+ buf = g_try_malloc (w * 3 * sizeof (guchar));
+ if (!buf) {
+ g_set_error (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+ _("Couldn't allocate memory for loading JPEG file"));
+ return FALSE;
+ }
+ if (to_callback) {
+ to_callback_destmgr.buffer = g_try_malloc (TO_FUNCTION_BUF_SIZE);
+ if (!to_callback_destmgr.buffer) {
+ g_set_error (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+ _("Couldn't allocate memory for loading JPEG file"));
+ return FALSE;
+ }
+ }
+
+ /* set up error handling */
+ jerr.pub.error_exit = fatal_error_handler;
+ jerr.pub.output_message = output_message_handler;
+ jerr.error = error;
+
+ cinfo.err = jpeg_std_error (&(jerr.pub));
+ if (sigsetjmp (jerr.setjmp_buffer, 1)) {
+ jpeg_destroy_compress (&cinfo);
+ g_free (buf);
+ g_free (to_callback_destmgr.buffer);
+ return FALSE;
+ }
+
+ /* setup compress params */
+ jpeg_create_compress (&cinfo);
+ if (to_callback) {
+ to_callback_destmgr.pub.init_destination = to_callback_init;
+ to_callback_destmgr.pub.empty_output_buffer = to_callback_empty_output_buffer;
+ to_callback_destmgr.pub.term_destination = to_callback_terminate;
+ to_callback_destmgr.error = error;
+ to_callback_destmgr.save_func = save_func;
+ to_callback_destmgr.user_data = user_data;
+ cinfo.dest = (struct jpeg_destination_mgr*) &to_callback_destmgr;
+ } else {
+ jpeg_stdio_dest (&cinfo, f);
+ }
+ cinfo.image_width = w;
+ cinfo.image_height = h;
+ cinfo.input_components = 3;
+ cinfo.in_color_space = JCS_RGB;
+
+ /* set up jepg compression parameters */
+ jpeg_set_defaults (&cinfo);
+ jpeg_set_quality (&cinfo, quality, TRUE);
+ jpeg_start_compress (&cinfo, TRUE);
+ /* get the start pointer */
+ ptr = pixels;
+ /* go one scanline at a time... and save */
+ i = 0;
+ while (cinfo.next_scanline < cinfo.image_height) {
+ /* convert scanline from ARGB to RGB packed */
+ for (j = 0; j < w; j++)
+ memcpy (&(buf[j*3]), &(ptr[i*rowstride + j*n_channels]), 3);
+
+ /* write scanline */
+ jbuf = (JSAMPROW *)(&buf);
+ jpeg_write_scanlines (&cinfo, jbuf, 1);
+ i++;
+ y++;
+
+ }
+
+ /* finish off */
+ jpeg_finish_compress (&cinfo);
+ jpeg_destroy_compress(&cinfo);
+ g_free (buf);
+ g_free (to_callback_destmgr.buffer);
+ return TRUE;
+}
+
+static gboolean
+gdk_pixbuf__jpeg_image_save (FILE *f,
+ GdkPixbuf *pixbuf,
+ gchar **keys,
+ gchar **values,
+ GError **error)
+{
+ return real_save_jpeg (pixbuf, keys, values, error,
+ FALSE, f, NULL, NULL);
+}
+
+static gboolean
+gdk_pixbuf__jpeg_image_save_to_callback (GdkPixbufSaveFunc save_func,
+ gpointer user_data,
+ GdkPixbuf *pixbuf,
+ gchar **keys,
+ gchar **values,
+ GError **error)
+{
+ return real_save_jpeg (pixbuf, keys, values, error,
+ TRUE, NULL, save_func, user_data);
+}
+
+void
+MODULE_ENTRY (jpeg, fill_vtable) (GdkPixbufModule *module)
+{
+ module->load = gdk_pixbuf__jpeg_image_load;
+ module->begin_load = gdk_pixbuf__jpeg_image_begin_load;
+ module->stop_load = gdk_pixbuf__jpeg_image_stop_load;
+ module->load_increment = gdk_pixbuf__jpeg_image_load_increment;
+ module->save = gdk_pixbuf__jpeg_image_save;
+ module->save_to_callback = gdk_pixbuf__jpeg_image_save_to_callback;
+}
+
+void
+MODULE_ENTRY (jpeg, fill_info) (GdkPixbufFormat *info)
+{
+ static GdkPixbufModulePattern signature[] = {
+ { "\xff\xd8", NULL, 100 },
+ { NULL, NULL, 0 }
+ };
+ static gchar * mime_types[] = {
+ "image/jpeg",
+ NULL
+ };
+ static gchar * extensions[] = {
+ "jpeg",
+ "jpe",
+ "jpg",
+ NULL
+ };
+
+ info->name = "jpeg";
+ info->signature = signature;
+ info->description = N_("The JPEG image format");
+ info->mime_types = mime_types;
+ info->extensions = extensions;
+ info->flags = GDK_PIXBUF_FORMAT_WRITABLE | GDK_PIXBUF_FORMAT_THREADSAFE;
+ info->license = "LGPL";
+}