Progressive loading is working

git-svn-id: http://gdk-pixbuf-psd.googlecode.com/svn/trunk@3 c5539ac3-5556-0410-9a1f-7faf0b045682

1 files changed, 459 insertions, 13 deletions

diff --git a/io-psd.c b/io-psd.c
index 664d42f..275f66a 100644
--- a/io-psd.c
+++ b/io-psd.c
@@ -20,8 +20,17 @@
  * Boston, MA 02111-1307, USA.
  */
 
+/*
+ * TODO
+ * - use http://library.gnome.org/devel/glib/unstable/glib-Byte-Order-Macros.html
+ * - report errors from parse_psd_header
+ * - other color modes
+ * - ...
+ */
+
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 #include <gdk-pixbuf/gdk-pixbuf-io.h>
 #include <glib/gstdio.h>
 
@@ -31,13 +40,15 @@ typedef struct
 	guchar  signature[4];  /* file ID, always "8BPS" */
 	guint16 version;       /* version number, always 1 */
 	guchar  reserved[6];
-	guint8  channels;      /* number of color channels (1-24) */
+	guint16 channels;      /* number of color channels (1-24) */
 	guint32 rows;          /* height of image in pixels (1-30000) */
 	guint32 columns;       /* width of image in pixels (1-30000) */
 	guint16 depth;         /* number of bits per channel (1, 8, and 16) */
 	guint16 color_mode;    /* color mode as defined below */
 } PsdHeader;
 
+#define PSD_HEADER_SIZE 26
+
 typedef enum
 {
 	PSD_MODE_MONO = 0,
@@ -56,6 +67,49 @@ typedef enum
 	PSD_COMPRESSION_RLE = 1
 } PsdCompressionType;
 
+typedef enum
+{
+	PSD_STATE_HEADER,
+	PSD_STATE_COLOR_MODE_BLOCK,
+	PSD_STATE_RESOURCES_BLOCK,
+	PSD_STATE_LAYERS_BLOCK,
+	PSD_STATE_COMPRESSION,
+	PSD_STATE_LINES_LENGTHS,
+	PSD_STATE_CHANNEL_DATA,
+	PSD_STATE_DONE
+} PsdReadState;
+
+typedef struct
+{
+	PsdReadState       state;
+	
+	GdkPixbuf*                  pixbuf;
+
+	GdkPixbufModuleSizeFunc     size_func;
+	GdkPixbufModuleUpdatedFunc  updated_func;
+	GdkPixbufModulePreparedFunc prepared_func; 
+	gpointer                    user_data;
+
+	guchar*            buffer;
+	guint              bytes_read;
+	guint32            bytes_to_skip;
+	gboolean           bytes_to_skip_known;
+
+	//PsdHeader          hd;
+	guint32            width;         /* width of image in pixels (1-30000) */
+	guint32            height;        /* height of image in pixels (1-30000) */
+	guint16            channels;      /* number of color channels (1-24) */
+	guint16            depth;         /* number of bits per channel (1, 8, and 16) */
+	PsdColorMode       color_mode;
+	PsdCompressionType compression;
+
+	guchar**           channels_buffers;
+	guint              current_channel;
+	guint              current_row;
+	guint              position; // ? redundant?
+	guint16*           lines_lengths;
+} PsdContext;
+
 static guint16
 read_uint16 (FILE *fp)
 {
@@ -76,6 +130,19 @@ read_uint32 (FILE *fp)
 	return t;
 }
 
+static guint16
+parse_uint16 (guchar* buf)
+{
+	return (buf[0] << 8) | buf[1];
+}
+
+static guint32
+parse_uint32 (guchar* buf)
+{
+	return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+}
+
+
 static PsdHeader
 psd_read_header (FILE *fp)
 {
@@ -106,6 +173,28 @@ psd_read_header (FILE *fp)
 	return hd;
 }
 
+/*
+ * Parse Psdheader from buffer
+ * str is expected to be at least PSD_HEADER_SIZE long
+ */
+static PsdHeader
+psd_parse_header (guchar* str)
+{
+	PsdHeader hd;
+	
+	memcpy(hd.signature, str, 4);
+	hd.version = parse_uint16(str + 4);
+	hd.channels = parse_uint16(str + 12);
+	hd.rows = parse_uint32(str + 14);
+	hd.columns = parse_uint32(str + 18);
+	hd.depth = parse_uint16(str + 22);
+	hd.color_mode = parse_uint16(str + 24);
+
+	return hd;
+}
+
+// -- non-progressive loading --------------------------------------------------
+
 static GdkPixbuf*
 gdk_pixbuf__psd_image_load (FILE *fp,
                             GError **error)
@@ -117,7 +206,7 @@ gdk_pixbuf__psd_image_load (FILE *fp,
 	guchar **buffers;
 
 	PsdHeader hd = psd_read_header(fp);
-	pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, hd.columns, hd.rows);
+	pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, hd.columns, hd.rows);
 
 	if (pixbuf == NULL) {
 		g_set_error (error, GDK_PIXBUF_ERROR,
@@ -167,7 +256,7 @@ gdk_pixbuf__psd_image_load (FILE *fp,
 					gchar byte = fgetc(fp);
 					++bytes_read;
 					
-					if (byte == -128) {
+						if (byte == -128) {
 						continue;
 					} else if (byte > -1) {
 						gint count = byte + 1;
@@ -199,9 +288,9 @@ gdk_pixbuf__psd_image_load (FILE *fp,
 	if (hd.color_mode == PSD_MODE_RGB) {
 		for (int i = 0; i < hd.rows; ++i) {
 			for (int j = 0; j < hd.columns; ++j) {
-				pixels[i * rowstride + 3 * j + 0] = buffers[0][i * hd.columns + j];
-				pixels[i * rowstride + 3 * j + 1] = buffers[1][i * hd.columns + j];
-				pixels[i * rowstride + 3 * j + 2] = buffers[2][i * hd.columns + j];
+				pixels[i*rowstride + 3*j + 0] = buffers[0][i*hd.columns + j];
+				pixels[i*rowstride + 3*j + 1] = buffers[1][i*hd.columns + j];
+				pixels[i*rowstride + 3*j + 2] = buffers[2][i*hd.columns + j];
 			}
 		}
 	}
@@ -210,16 +299,373 @@ gdk_pixbuf__psd_image_load (FILE *fp,
 	return pixbuf;
 }
 
+
+// --- progressive loading -----------------------------------------------------
+
+// Attempts to read bytes_needed bytes from data and stores them
+// in buffer.
+// Returns true if there were enough bytes and false otherwise
+// (which means we need to call feed_buffer again)
+
+static gboolean
+feed_buffer (guchar*        buffer,
+             guint*         bytes_read,
+             const guchar** data,
+             guint*         size,
+             guint          bytes_needed)
+{
+	gint how_many = bytes_needed - *bytes_read;
+	if (how_many > *size) {
+		how_many = *size;
+	}
+	memcpy(buffer + *bytes_read, *data, how_many);
+	*bytes_read += how_many;
+	*data += how_many;
+	*size -= how_many;
+	return (*bytes_read == bytes_needed);
+}
+
+// Attempts to read size of the block and then skip this block.
+// Returns true when finishes consuming block data, otherwise false
+// (false means we must call skip_block once again)
+
+static gboolean
+skip_block (PsdContext* context, const guchar** data, guint* size)
+{
+	static guint counter;
+
+	if (!context->bytes_to_skip_known) {
+		context->bytes_read = 0;
+		if (feed_buffer(context->buffer, &context->bytes_read, data, size, 4)) {
+			context->bytes_to_skip = parse_uint32(context->buffer);
+			context->bytes_to_skip_known = TRUE;
+			counter = 0;
+		} else {
+			return FALSE;
+		}
+	}
+	if (*size < context->bytes_to_skip) {
+		*data += *size;
+		context->bytes_to_skip -= *size;
+		counter += *size;
+		*size = 0;
+		return FALSE;
+	} else {
+		counter += context->bytes_to_skip;
+		*size -= context->bytes_to_skip;
+		*data += context->bytes_to_skip;
+		return TRUE;
+	}
+}
+
+// Decodes RLE-compressed data
+static void
+decompress_line(const guchar* src, guint line_length, guchar* dest)
+{
+	guint16 bytes_read = 0;
+	while (bytes_read < line_length) {
+		gchar byte = src[bytes_read];
+		++bytes_read;
+	
+		if (byte == -128) {
+			continue;
+		} else if (byte > -1) {
+			gint count = byte + 1;
+		
+			// copy next count bytes
+			for (int k = 0; k < count; ++k) {
+				*dest = src[bytes_read];
+				++dest;
+				++bytes_read;
+			}
+		} else {
+			gint count = -byte + 1;
+		
+			// copy next byte count times
+			guchar next_byte = src[bytes_read];
+			++bytes_read; 
+			for (int k = 0; k < count; ++k) {
+				*dest = next_byte;
+				++dest;
+			}
+		}
+	}
+}
+
+static void
+reset_context(PsdContext* ctx)
+{
+	ctx->bytes_read = 0;
+	ctx->bytes_to_skip = 0;
+	ctx->bytes_to_skip_known = FALSE;
+}
+
+static gpointer
+gdk_pixbuf__psd_image_begin_load (GdkPixbufModuleSizeFunc size_func,
+                                  GdkPixbufModulePreparedFunc prepared_func,
+                                  GdkPixbufModuleUpdatedFunc updated_func,
+                                  gpointer user_data,
+                                  GError **error)
+{
+	PsdContext* context = g_malloc(sizeof(PsdContext));
+	if (context == NULL) {
+		g_set_error (
+			error,
+			GDK_PIXBUF_ERROR,
+			GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+			("Not enough memory"));
+		return NULL;
+	}
+	context->size_func = size_func;
+	context->prepared_func = prepared_func;
+	context->updated_func = updated_func;
+	context->user_data = user_data;
+	
+	context->state = PSD_STATE_HEADER;
+
+	// we'll allocate larger buffer once we know image size
+	context->buffer = g_malloc(256);
+	reset_context(context);
+
+	//context->bytes_read = 0;
+	//context->bytes_to_skip = 0;
+	//context->bytes_to_skip_known = FALSE;
+
+	context->channels_buffers = NULL;
+	context->current_channel = 0;
+	context->current_row = 0;
+	context->position = 0;
+	context->lines_lengths = NULL;
+
+	return (gpointer) context;
+}
+
+static gboolean
+gdk_pixbuf__psd_image_stop_load (gpointer context_ptr, GError **error)
+{
+	PsdContext *ctx = (PsdContext *) context_ptr;
+	gboolean retval = TRUE;
+
+	if (ctx->state != PSD_STATE_DONE) {
+		g_set_error (
+			error,
+			GDK_PIXBUF_ERROR,
+			GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
+			("PSD file was corrupted or incomplete."));
+		retval = FALSE;
+	} else {
+		// convert or copy channel buffers to our GdkPixbuf
+
+		//for (int i = 0; i < ctx->channels; i++) {
+		guchar* pixels = gdk_pixbuf_get_pixels(ctx->pixbuf);
+		for (int i = 0; i < ctx->height; i++) {
+			for (int j = 0; j < ctx->width; j++) {
+				pixels[3*j+0] = 0x00;
+				pixels[3*j+1] = 0x00;
+				pixels[3*j+2] = 0x00;
+			}
+			pixels += gdk_pixbuf_get_rowstride(ctx->pixbuf);
+		}
+		
+		for (int i = 0; i < 3; i++) {
+			guchar* pixels = gdk_pixbuf_get_pixels(ctx->pixbuf);
+			for (int j = 0; j < ctx->height; j++) {
+				guchar* src_buf = &ctx->channels_buffers[i][ctx->width * j];
+				for (int k = 0; k < ctx->width; k++) {
+					pixels[3 * k + i] = src_buf[k];
+				}
+				pixels += gdk_pixbuf_get_rowstride(ctx->pixbuf);
+			}
+		}
+	}
+	
+	g_free (ctx->buffer); // TODO a few more buffers need freeing
+	g_free (ctx);
+	
+	return retval;
+}
+
+
+static gboolean
+gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
+                                      const guchar *data,
+                                      guint         size,
+                                      GError      **error)
+{
+
+	PsdContext* context = (PsdContext*) context_ptr;
+	PsdContext* ctx = context;
+	
+	while (size > 0) {
+		switch (context->state) {
+			case PSD_STATE_HEADER:
+				if (feed_buffer(
+						context->buffer, &context->bytes_read,
+						&data, &size, PSD_HEADER_SIZE))
+				{
+					PsdHeader hd = psd_parse_header(ctx->buffer);
+
+					ctx->width = hd.columns;
+					ctx->height = hd.rows;
+					ctx->channels = hd.channels;
+					ctx->depth = hd.depth;
+					ctx->color_mode = hd.color_mode;
+					
+					if (ctx->size_func) {
+						gint w = ctx->width;
+						gint h = ctx->height;
+						ctx->size_func(&w, &h, ctx->user_data);
+						if (w == 0 || h == 0) {
+							return FALSE;
+						}
+					}
+					
+					// we need buffer that can contain one channel data of one
+					// row in RLE compressed format. 2*width should be enough
+					g_free(ctx->buffer);
+					ctx->buffer = g_malloc(ctx->width * 2);
+					
+					// this will be needed for RLE decompression
+					ctx->lines_lengths =
+						g_malloc(2 * ctx->channels * ctx->height);
+					
+					ctx->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE,
+						8, ctx->width, ctx->height);
+
+					if (ctx->lines_lengths == NULL || ctx->buffer == NULL ||
+						ctx->pixbuf == NULL)
+					{
+						g_set_error (error, GDK_PIXBUF_ERROR,
+							GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+							("Insufficient memory to load PSD image file"));
+						return FALSE;
+					}
+					
+					// create separate buffers for each channel
+					context->channels_buffers =
+						g_malloc(sizeof(guchar*) * ctx->channels);
+					for (int i = 0; i <	ctx->channels; i++) {
+						ctx->channels_buffers[i] =
+							g_malloc(ctx->width * ctx->height);
+
+						if (ctx->channels_buffers[i] == NULL) {
+							g_set_error (error, GDK_PIXBUF_ERROR,
+								GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+								("Insufficient memory to load PSD image file"));
+							return FALSE;
+						}	
+					}
+					
+					ctx->prepared_func(ctx->pixbuf, NULL, ctx->user_data);
+					
+					ctx->state = PSD_STATE_COLOR_MODE_BLOCK;
+					reset_context(ctx);
+				}
+				break;
+			case PSD_STATE_COLOR_MODE_BLOCK:
+				if (skip_block(ctx, &data, &size)) {
+					ctx->state = PSD_STATE_RESOURCES_BLOCK;
+					reset_context(ctx);
+				}
+				break;
+			case PSD_STATE_RESOURCES_BLOCK:
+				if (skip_block(ctx, &data, &size)) {
+					ctx->state = PSD_STATE_LAYERS_BLOCK;
+					reset_context(ctx);
+				}
+				break;
+			case PSD_STATE_LAYERS_BLOCK:
+				if (skip_block(ctx, &data, &size)) {
+					ctx->state = PSD_STATE_COMPRESSION;
+					reset_context(ctx);
+				}
+				break;
+			case PSD_STATE_COMPRESSION:
+				if (feed_buffer(ctx->buffer, &ctx->bytes_read, &data, &size, 2))
+				{
+					ctx->compression = parse_uint16(ctx->buffer);
+
+					if (ctx->compression == PSD_COMPRESSION_RLE) {
+						ctx->state = PSD_STATE_LINES_LENGTHS;
+						reset_context(ctx);
+					} else if (ctx->compression == PSD_COMPRESSION_NONE) {
+						ctx->state = PSD_STATE_CHANNEL_DATA;
+					} else {
+						g_set_error (error, GDK_PIXBUF_ERROR,
+							GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
+							("Unsupported compression type"));
+						return FALSE;
+					}
+				}
+				break;
+			case PSD_STATE_LINES_LENGTHS:
+				if (feed_buffer(
+						(guchar*) ctx->lines_lengths, &ctx->bytes_read, &data,
+						 &size,	2 * ctx->height * ctx->channels))
+				{
+					// convert from different endianness
+					for (int i = 0; i <	ctx->height * ctx->channels; i++) {
+						ctx->lines_lengths[i] = parse_uint16(
+							(guchar*) &ctx->lines_lengths[i]);
+					}
+					ctx->state = PSD_STATE_CHANNEL_DATA;
+					reset_context(ctx);
+				}
+				break;
+			case PSD_STATE_CHANNEL_DATA:
+				if (context->compression == PSD_COMPRESSION_RLE)
+				{
+					guint line_length = ctx->lines_lengths[
+						ctx->current_channel * ctx->height + ctx->current_row];
+					if (feed_buffer(ctx->buffer, &ctx->bytes_read, &data,
+							&size, line_length))
+					{
+						ctx->bytes_read = 0;
+						decompress_line(
+							ctx->buffer,
+							line_length,
+							ctx->channels_buffers[ctx->current_channel]
+								+ ctx->position
+						);
+						context->position += context->width;
+						++context->current_row;
+						
+						if (ctx->current_row >= ctx->height) {
+							++ctx->current_channel;
+							ctx->current_row = 0;
+							ctx->position = 0;
+							if (ctx->current_channel >= ctx->channels) {
+								ctx->state = PSD_STATE_DONE;
+							}
+						}
+					}
+				} else {
+					if (feed_buffer(
+							context->buffer, &context->bytes_read,
+							&data, &size, context->width))
+					{
+						//memcpy(dest, context->buffer, context->hd.columns);
+						// TODO
+					}
+				}
+				break;
+			case PSD_STATE_DONE:
+			default:
+				size = 0;
+				break;
+		}
+	}
+	return TRUE;
+}
+
+
 void
 fill_vtable (GdkPixbufModule* module)
 {
-/*	module->load = gdk_pixbuf__xbm_image_load;
-	module->begin_load = gdk_pixbuf__xbm_image_begin_load;
-	module->stop_load = gdk_pixbuf__xbm_image_stop_loads
-	module->load_increment = gdk_pixbuf__xbm_image_load_increment;*/
-	// TODO progressive loading
-
-	module->load = gdk_pixbuf__psd_image_load;
+	//module->load = gdk_pixbuf__psd_image_load;
+	module->begin_load = gdk_pixbuf__psd_image_begin_load;
+	module->stop_load = gdk_pixbuf__psd_image_stop_load;
+	module->load_increment = gdk_pixbuf__psd_image_load_increment;
 }
 
 void