+/* -*- mode: C; c-file-style: "linux" -*- */
/* GdkPixbuf library - JPEG image loader
*
* Copyright (C) 1999 Michael Zucchi
*/
-/*
- Progressive file loading notes (11/03/1999) <drmike@redhat.com>...
-
- These are issues I know of and will be dealing with shortly:
-
- - Currently does not handle progressive jpegs - this
- requires a change in the way image_load_increment () calls
- libjpeg. Progressive jpegs are rarer but I will add this
- support asap.
-
- - error handling is not as good as it should be
-
- */
-
-
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
#include <jpeglib.h>
+#include <jerror.h>
#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-io.h"
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;
/* progressive loader context */
typedef struct {
- ModuleUpdatedNotifyFunc updated_func;
- ModulePreparedNotifyFunc prepared_func;
- gpointer user_data;
+ GdkPixbufModuleSizeFunc size_func;
+ GdkPixbufModuleUpdatedFunc updated_func;
+ GdkPixbufModulePreparedFunc prepared_func;
+ gpointer user_data;
GdkPixbuf *pixbuf;
guchar *dptr; /* current position in pixbuf */
} JpegProgContext;
static GdkPixbuf *gdk_pixbuf__jpeg_image_load (FILE *f, GError **error);
-static gpointer gdk_pixbuf__jpeg_image_begin_load (ModulePreparedNotifyFunc func,
- ModuleUpdatedNotifyFunc func2,
+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);
if (errmgr->error && *errmgr->error == NULL) {
g_set_error (errmgr->error,
GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
+ 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);
}
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->image_width;
+ w = cinfo->output_width;
for (i = cinfo->rec_outbuf_height - 1; i >= 0; i--) {
guchar *from, *to;
}
}
+
+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 */
{
}
+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";
+ }
+}
+
/* Shared library entry point */
static GdkPixbuf *
gdk_pixbuf__jpeg_image_load (FILE *f, GError **error)
cinfo.do_fancy_upsampling = FALSE;
cinfo.do_block_smoothing = FALSE;
- pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, cinfo.output_width, cinfo.output_height);
-
+ pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+ cinfo.out_color_components == 4 ? TRUE : FALSE,
+ 8, cinfo.output_width, cinfo.output_height);
+
if (!pixbuf) {
jpeg_destroy_decompress (&cinfo);
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++) {
jpeg_read_scanlines (&cinfo, lines, cinfo.rec_outbuf_height);
- if (cinfo.output_components == 1)
- explode_gray_into_buf (&cinfo, lines);
+ 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_object_unref (pixbuf);
+ if (error && *error == NULL) {
+ g_set_error (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
+ _("Unsupported JPEG color space (%s)"),
+ colorspace_name (cinfo.out_color_space));
+ }
+
+ jpeg_destroy_decompress (&cinfo);
+ return NULL;
+ }
}
jpeg_finish_decompress (&cinfo);
* return context (opaque to user)
*/
-gpointer
-gdk_pixbuf__jpeg_image_begin_load (ModulePreparedNotifyFunc prepared_func,
- ModuleUpdatedNotifyFunc updated_func,
+static gpointer
+gdk_pixbuf__jpeg_image_begin_load (GdkPixbufModuleSizeFunc size_func,
+ GdkPixbufModulePreparedFunc prepared_func,
+ GdkPixbufModuleUpdatedFunc updated_func,
gpointer user_data,
GError **error)
{
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->cinfo.src = (struct jpeg_source_mgr *) g_try_malloc (sizeof (my_source_mgr));
if (!context->cinfo.src) {
- g_set_error (error,
- GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
- _("Couldn't allocate memory for loading JPEG file"));
- return NULL;
+ g_set_error (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));
JpegProgContext *context = (JpegProgContext *) data;
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? */
if (sigsetjmp (context->jerr.setjmp_buffer, 1)) {
jpeg_destroy_decompress (&context->cinfo);
}
+static gboolean
+gdk_pixbuf__jpeg_image_load_lines (JpegProgContext *context,
+ GError **error)
+{
+ struct jpeg_decompress_struct *cinfo = &context->cinfo;
+ guchar *lines[4];
+ guchar **lptr;
+ guchar *rowptr;
+ gint nlines, i;
+
+ /* keep going until we've done all scanlines */
+ while (cinfo->output_scanline < cinfo->output_height) {
+ lptr = lines;
+ rowptr = context->dptr;
+ for (i=0; i < cinfo->rec_outbuf_height; i++) {
+ *lptr++ = rowptr;
+ rowptr += context->pixbuf->rowstride;
+ }
+
+ nlines = jpeg_read_scanlines (cinfo, lines,
+ cinfo->rec_outbuf_height);
+ if (nlines == 0)
+ break;
+
+ 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:
+ if (error && *error == NULL) {
+ g_set_error (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
+ _("Unsupported JPEG color space (%s)"),
+ colorspace_name (cinfo->out_color_space));
+ }
+
+ return FALSE;
+ }
+
+ context->dptr += nlines * context->pixbuf->rowstride;
+
+ /* send updated signal */
+ if (context->updated_func)
+ (* context->updated_func) (context->pixbuf,
+ 0,
+ cinfo->output_scanline - 1,
+ cinfo->image_width,
+ nlines,
+ context->user_data);
+ }
+
+ return TRUE;
+}
/*
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);
context->jerr.error = error;
- /* XXXXXXX (drmike) - loop(s) below need to be recoded now I
- * have a grasp of what the flow needs to be!
- */
-
/* check for fatal error */
if (sigsetjmp (context->jerr.setjmp_buffer, 1)) {
return FALSE;
/* 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;
-
- context->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
- FALSE,
- 8,
- cinfo->image_width,
- cinfo->image_height);
+
+ 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,
_("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 */
- (* context->prepared_func) (context->pixbuf,
- NULL,
- context->user_data);
-
+ if (context->prepared_func)
+ (* context->prepared_func) (context->pixbuf,
+ NULL,
+ context->user_data);
+
} else if (!context->did_prescan) {
- int rc;
+ int rc;
/* start decompression */
- cinfo->buffered_image = TRUE;
+ 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 so feed jpeg lib scanlines */
- guchar *lines[4];
- guchar **lptr;
- guchar *rowptr;
- gint nlines, i;
+ /* we're decompressing buffered (progressive)
+ * so feed jpeg lib scanlines
+ */
/* keep going until we've done all passes */
while (!jpeg_input_complete (cinfo)) {
else
break;
}
- /* keep going until we've done all scanlines */
- while (cinfo->output_scanline < cinfo->output_height) {
- lptr = lines;
- rowptr = context->dptr;
- for (i=0; i < cinfo->rec_outbuf_height; i++) {
- *lptr++ = rowptr;
- rowptr += context->pixbuf->rowstride;
- }
-
- nlines = jpeg_read_scanlines (cinfo, lines,
- cinfo->rec_outbuf_height);
- if (nlines == 0)
- break;
- /* handle gray */
- if (cinfo->output_components == 1)
- explode_gray_into_buf (cinfo, lines);
-
- context->dptr += nlines * context->pixbuf->rowstride;
-
- /* send updated signal */
- (* context->updated_func) (context->pixbuf,
- 0,
- cinfo->output_scanline-1,
- cinfo->image_width,
- nlines,
- context->user_data);
- }
- if (cinfo->output_scanline >= cinfo->output_height &&
+ /* 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
continue;
}
}
+}
+
+/* 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
-gdk_pixbuf__jpeg_image_save (FILE *f,
- GdkPixbuf *pixbuf,
- gchar **keys,
- gchar **values,
- GError **error)
+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 */
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;
}
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);
pixels = gdk_pixbuf_get_pixels (pixbuf);
g_return_val_if_fail (pixels != NULL, FALSE);
- /* allocate a small buffer to convert image data */
+ /* 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,
_("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;
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);
- jpeg_stdio_dest (&cinfo, f);
+ 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;
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*3]), 3);
+ memcpy (&(buf[j*3]), &(ptr[i*rowstride + j*n_channels]), 3);
/* write scanline */
jbuf = (JSAMPROW *)(&buf);
}
/* finish off */
- jpeg_finish_compress (&cinfo);
+ 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
-gdk_pixbuf__jpeg_fill_vtable (GdkPixbufModule *module)
+MODULE_ENTRY (jpeg, fill_info) (GdkPixbufFormat *info)
{
- 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;
+ 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";
}
projects / ~andy / gtk / blobdiff