Minor fixes, removed non-incremental loading

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

1 files changed, 75 insertions, 226 deletions

diff --git a/io-psd.c b/io-psd.c
index 363b2ef..6470f71 100644
--- a/io-psd.c
+++ b/io-psd.c
@@ -26,6 +26,7 @@
  * - report errors from parse_psd_header
  * - other color modes
  * - ...
+ * - MODULE_ENTRY stuff
  */
 
 #include <stdlib.h>
@@ -39,7 +40,7 @@ typedef struct
 {
 	guchar  signature[4];  /* file ID, always "8BPS" */
 	guint16 version;       /* version number, always 1 */
-	guchar  reserved[6];
+	guchar  resetved[6];
 	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) */
@@ -95,7 +96,6 @@ typedef struct
 	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) */
@@ -103,79 +103,31 @@ typedef struct
 	PsdColorMode       color_mode;
 	PsdCompressionType compression;
 
-	guchar**           channels_buffers;
-	guint              current_channel;
-	guint              current_row;
-	guint              position; // ? redundant?
+	guchar**           ch_bufs;       /* channels buffers */
+	guint              curr_ch;       /* current channel */
+	guint              curr_row;
+	guint              pos;           // redundant?
 	guint16*           lines_lengths;
 	gboolean           finalized;
 } PsdContext;
 
-static guint16
-read_uint16 (FILE *fp)
-{
-	guint16 t;
-	t = fgetc(fp) << 8;
-	t |= fgetc(fp);
-	return t;
-}
-
-static guint32
-read_uint32 (FILE *fp)
-{
-	guint32 t;
-	t = fgetc(fp) << 24;
-	t |= fgetc(fp) << 16;
-	t |= fgetc(fp) << 8;
-	t |= fgetc(fp);
-	return t;
-}
 
 static guint16
-parse_uint16 (guchar* buf)
+read_uint16 (guchar* buf)
 {
 	return (buf[0] << 8) | buf[1];
 }
 
 static guint32
-parse_uint32 (guchar* buf)
+read_uint32 (guchar* buf)
 {
 	return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 }
 
 
-static PsdHeader
-psd_read_header (FILE *fp)
-{
-	PsdHeader hd;
-	int t;
-
-	fread(hd.signature, 1, 4, fp);
-	hd.version = read_uint16(fp);
-	fread(hd.reserved, 1, 6, fp);
-	hd.channels = read_uint16(fp);
-	hd.rows = read_uint32(fp);
-	hd.columns = read_uint32(fp);
-	hd.depth = read_uint16(fp);
-	hd.color_mode = read_uint16(fp);
-
-	// skip Color Mode Data Block
-	t = read_uint32(fp);
-	fseek(fp, t, SEEK_CUR);
-	
-	// skip Image Resources Block
-	t = read_uint32(fp);
-	fseek(fp, t, SEEK_CUR);
-	
-	// skip Layer and Mask Information Block
-	t = read_uint32(fp);
-	fseek(fp, t, SEEK_CUR);
-
-	return hd;
-}
-
 /*
  * Parse Psdheader from buffer
+ *
  * str is expected to be at least PSD_HEADER_SIZE long
  */
 static PsdHeader
@@ -184,130 +136,22 @@ 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);
+	hd.version = read_uint16(str + 4);
+	hd.channels = read_uint16(str + 12);
+	hd.rows = read_uint32(str + 14);
+	hd.columns = read_uint32(str + 18);
+	hd.depth = read_uint16(str + 22);
+	hd.color_mode = read_uint16(str + 24);
 
 	return hd;
 }
 
-// -- non-progressive loading --------------------------------------------------
-
-static GdkPixbuf*
-gdk_pixbuf__psd_image_load (FILE *fp,
-                            GError **error)
-{
-	guint rowstride;
-	guint16 compression_type;
-	guchar *pixels;
-	GdkPixbuf *pixbuf;
-	guchar **buffers;
-
-	PsdHeader hd = psd_read_header(fp);
-	pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, hd.columns, hd.rows);
-
-	if (pixbuf == NULL) {
-		g_set_error (error, GDK_PIXBUF_ERROR,
-			GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
-			("Insufficient memory to load PSD image file"));
-		return NULL;
-	}
-	
-	pixels = gdk_pixbuf_get_pixels (pixbuf);
-	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
-	
-	compression_type = read_uint16(fp);
-	
-	if (compression_type != PSD_COMPRESSION_NONE &&
-	    compression_type != PSD_COMPRESSION_RLE) {
-		g_set_error (error, GDK_PIXBUF_ERROR,
-			GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
-			("Unsupported compression type"));
-		return NULL;
-	}
-	
-	if (hd.color_mode != PSD_MODE_RGB) {
-		g_set_error (error, GDK_PIXBUF_ERROR,
-			GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
-			("Unsupported color mode"));
-		return NULL;
-	}
-	
-	//g_message("mode=%d, channels=%d", hd.color_mode, hd.channels);
-	
-	buffers = g_malloc(sizeof(guchar*) * hd.channels);
-	
-	if (compression_type == PSD_COMPRESSION_RLE) {
-		guint16 *line_lengths = g_malloc(2 * hd.rows * hd.channels);
-		
-		for (int i = 0; i < hd.rows * hd.channels; ++i) {
-			line_lengths[i] = read_uint16(fp);
-		}
-		
-		for (int i = 0; i < hd.channels; ++i) {
-			buffers[i] = g_malloc(hd.rows * hd.columns);
-			gint position = 0;
-
-			for (int j = 0; j < hd.rows; ++j) {
-				guint16 bytes_read = 0;
-				while (bytes_read < line_lengths[i * hd.rows + j]) {
-					gchar byte = fgetc(fp);
-					++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) {
-							buffers[i][position] = fgetc(fp);
-							++bytes_read;
-							++position;
-						}
-					} else {
-						gint count = -byte + 1;
-						
-						// copy next byte count times
-						guchar next_byte = fgetc(fp);
-						++bytes_read; 
-						for (int k = 0; k < count; ++k) {
-							buffers[i][position] = next_byte;
-							++position;
-						}
-					}
-				}
-			}
-		}
-		
-		g_free(line_lengths);
-	}
-	
-	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];
-			}
-		}
-	}
-	// TODO: other color modes, CMYK at least
-	
-	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)
-
+/*
+ * 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,
@@ -326,10 +170,12 @@ feed_buffer (guchar*        buffer,
 	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)
-
+/*
+ * 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)
 {
@@ -338,7 +184,7 @@ skip_block (PsdContext* context, const guchar** data, guint* size)
 	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 = read_uint32(context->buffer);
 			context->bytes_to_skip_known = TRUE;
 			counter = 0;
 		} else {
@@ -359,7 +205,9 @@ skip_block (PsdContext* context, const guchar** data, guint* size)
 	}
 }
 
-// Decodes RLE-compressed data
+/*
+ * Decodes RLE-compressed data
+ */
 static void
 decompress_line(const guchar* src, guint line_length, guchar* dest)
 {
@@ -394,7 +242,7 @@ decompress_line(const guchar* src, guint line_length, guchar* dest)
 }
 
 static void
-reset_context(PsdContext* ctx)
+reset_context_buffer(PsdContext* ctx)
 {
 	ctx->bytes_read = 0;
 	ctx->bytes_to_skip = 0;
@@ -426,12 +274,12 @@ gdk_pixbuf__psd_image_begin_load (GdkPixbufModuleSizeFunc size_func,
 
 	// we'll allocate larger buffer once we know image size
 	context->buffer = g_malloc(PSD_HEADER_SIZE);
-	reset_context(context);
+	reset_context_buffer(context);
 
-	context->channels_buffers = NULL;
-	context->current_channel = 0;
-	context->current_row = 0;
-	context->position = 0;
+	context->ch_bufs = NULL;
+	context->curr_ch = 0;
+	context->curr_row = 0;
+	context->pos = 0;
 	context->lines_lengths = NULL;
 	context->finalized = FALSE;
 
@@ -449,12 +297,16 @@ gdk_pixbuf__psd_image_stop_load (gpointer context_ptr, GError **error)
 			error,
 			GDK_PIXBUF_ERROR,
 			GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
-			("PSD file was corrupted or incomplete. (not PSD_STATE_DONE)"));
+			("PSD file was corrupted or incomplete."));
 		retval = FALSE;
 	}
 	
-	g_free (ctx->buffer); // TODO a few more buffers need freeing
-	g_free (ctx);
+	g_free(ctx->buffer);
+	g_free(ctx->lines_lengths);
+	for (int i = 0; i < ctx->channels; i++) {
+		g_free(ctx->ch_bufs[i]);
+	}
+	g_free(ctx);
 	
 	return retval;
 }
@@ -467,14 +319,13 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
                                       GError      **error)
 {
 
-	PsdContext* context = (PsdContext*) context_ptr;
-	PsdContext* ctx = context;
+	PsdContext* ctx = (PsdContext*) context_ptr;
 	
 	while (size > 0) {
-		switch (context->state) {
+		switch (ctx->state) {
 			case PSD_STATE_HEADER:
 				if (feed_buffer(
-						context->buffer, &context->bytes_read,
+						ctx->buffer, &ctx->bytes_read,
 						&data, &size, PSD_HEADER_SIZE))
 				{
 					PsdHeader hd = psd_parse_header(ctx->buffer);
@@ -485,8 +336,8 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
 					ctx->depth = hd.depth;
 					ctx->color_mode = hd.color_mode;
 					
-					g_message("color_mode=%d, channels=%d, depth=%d",
-						ctx->color_mode, ctx->channels, ctx->depth);
+					//g_message("color_mode=%d, channels=%d, depth=%d",
+					//	ctx->color_mode, ctx->channels, ctx->depth);
 					
 					if (ctx->color_mode != PSD_MODE_RGB/* &&
 					    ctx->color_mode != PSD_MODE_CMYK*/
@@ -535,13 +386,12 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
 					}
 					
 					// create separate buffers for each channel
-					context->channels_buffers =
-						g_malloc(sizeof(guchar*) * ctx->channels);
+					ctx->ch_bufs = g_malloc(sizeof(guchar*) * ctx->channels);
 					for (int i = 0; i <	ctx->channels; i++) {
-						ctx->channels_buffers[i] =
+						ctx->ch_bufs[i] =
 							g_malloc(ctx->width * ctx->height);
 
-						if (ctx->channels_buffers[i] == NULL) {
+						if (ctx->ch_bufs[i] == NULL) {
 							g_set_error (error, GDK_PIXBUF_ERROR,
 								GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
 								("Insufficient memory to load PSD image file"));
@@ -552,35 +402,35 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
 					ctx->prepared_func(ctx->pixbuf, NULL, ctx->user_data);
 					
 					ctx->state = PSD_STATE_COLOR_MODE_BLOCK;
-					reset_context(ctx);
+					reset_context_buffer(ctx);
 				}
 				break;
 			case PSD_STATE_COLOR_MODE_BLOCK:
 				if (skip_block(ctx, &data, &size)) {
 					ctx->state = PSD_STATE_RESOURCES_BLOCK;
-					reset_context(ctx);
+					reset_context_buffer(ctx);
 				}
 				break;
 			case PSD_STATE_RESOURCES_BLOCK:
 				if (skip_block(ctx, &data, &size)) {
 					ctx->state = PSD_STATE_LAYERS_BLOCK;
-					reset_context(ctx);
+					reset_context_buffer(ctx);
 				}
 				break;
 			case PSD_STATE_LAYERS_BLOCK:
 				if (skip_block(ctx, &data, &size)) {
 					ctx->state = PSD_STATE_COMPRESSION;
-					reset_context(ctx);
+					reset_context_buffer(ctx);
 				}
 				break;
 			case PSD_STATE_COMPRESSION:
 				if (feed_buffer(ctx->buffer, &ctx->bytes_read, &data, &size, 2))
 				{
-					ctx->compression = parse_uint16(ctx->buffer);
+					ctx->compression = read_uint16(ctx->buffer);
 
 					if (ctx->compression == PSD_COMPRESSION_RLE) {
 						ctx->state = PSD_STATE_LINES_LENGTHS;
-						reset_context(ctx);
+						reset_context_buffer(ctx);
 					} else if (ctx->compression == PSD_COMPRESSION_NONE) {
 						ctx->state = PSD_STATE_CHANNEL_DATA;
 					} else {
@@ -598,11 +448,11 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
 				{
 					// convert from different endianness
 					for (int i = 0; i <	ctx->height * ctx->channels; i++) {
-						ctx->lines_lengths[i] = parse_uint16(
+						ctx->lines_lengths[i] = read_uint16(
 							(guchar*) &ctx->lines_lengths[i]);
 					}
 					ctx->state = PSD_STATE_CHANNEL_DATA;
-					reset_context(ctx);
+					reset_context_buffer(ctx);
 				}
 				break;
 			case PSD_STATE_CHANNEL_DATA:
@@ -610,32 +460,31 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
 					guint line_length = ctx->width;
 					if (ctx->compression == PSD_COMPRESSION_RLE) {
 						line_length = ctx->lines_lengths[
-							ctx->current_channel * ctx->height + ctx->current_row];
+							ctx->curr_ch * ctx->height + ctx->curr_row];
 					}
 					
 					if (feed_buffer(ctx->buffer, &ctx->bytes_read, &data, &size,
 							line_length))
 					{
-						ctx->bytes_read = 0;
+						reset_context_buffer(ctx);
 					
 						if (ctx->compression == PSD_COMPRESSION_RLE) {
 							decompress_line(ctx->buffer, line_length,
-								ctx->channels_buffers[ctx->current_channel]
-									+ ctx->position
+								ctx->ch_bufs[ctx->curr_ch] + ctx->pos
 							);
 						} else {
-							memcpy(ctx->channels_buffers[ctx->current_channel]
-								+ ctx->position, ctx->buffer, ctx->width);
+							memcpy(ctx->ch_bufs[ctx->curr_ch] + ctx->pos,
+								ctx->buffer, ctx->width);
 						}
 
-						ctx->position += ctx->width;
-						++ctx->current_row;
+						ctx->pos += ctx->width;
+						++ctx->curr_row;
 					
-						if (ctx->current_row >= ctx->height) {
-							++ctx->current_channel;
-							ctx->current_row = 0;
-							ctx->position = 0;
-							if (ctx->current_channel >= ctx->channels) {
+						if (ctx->curr_row >= ctx->height) {
+							++ctx->curr_ch;
+							ctx->curr_row = 0;
+							ctx->pos = 0;
+							if (ctx->curr_ch >= ctx->channels) {
 								ctx->state = PSD_STATE_DONE;
 							}
 						}
@@ -655,9 +504,9 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
 			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] = ctx->channels_buffers[0][ctx->width*i + j];
-					pixels[3*j+1] = ctx->channels_buffers[1][ctx->width*i + j];
-					pixels[3*j+2] = ctx->channels_buffers[2][ctx->width*i + j];
+					pixels[3*j+0] = ctx->ch_bufs[0][ctx->width*i + j];
+					pixels[3*j+1] = ctx->ch_bufs[1][ctx->width*i + j];
+					pixels[3*j+2] = ctx->ch_bufs[2][ctx->width*i + j];
 				}
 				pixels += gdk_pixbuf_get_rowstride(ctx->pixbuf);
 			}