Fixed uncompressed images. Reenabling CMYK. Support for Grayscale and

16-bit color depth.


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

1 files changed, 39 insertions, 23 deletions

diff --git a/io-psd.c b/io-psd.c
index 2cdb688..ccc7db0 100644
--- a/io-psd.c
+++ b/io-psd.c
@@ -22,7 +22,6 @@
 
 /*
  * TODO
- * - use http://library.gnome.org/devel/glib/unstable/glib-Byte-Order-Macros.html
  * - report errors from parse_psd_header
  * - other color modes (CMYK at least)
  * - i18n
@@ -43,7 +42,7 @@ typedef struct
         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 depth;         /* number of bits per channel (1, 8, 16 or 32) */
         guint16 color_mode;    /* color mode as defined below */
 } PsdHeader;
 
@@ -95,10 +94,11 @@ typedef struct
         guint32            bytes_to_skip;
         gboolean           bytes_to_skip_known;
 
-        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/16) */
+        guint32            width;
+        guint32            height;
+        guint16            channels;
+        guint16            depth;
+        guint16            depth_bytes;
         PsdColorMode       color_mode;
         PsdCompressionType compression;
 
@@ -336,6 +336,7 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
                                         ctx->height = hd.rows;
                                         ctx->channels = hd.channels;
                                         ctx->depth = hd.depth;
+                                        ctx->depth_bytes = (ctx->depth/8 > 0 ? ctx->depth/8 : 1);
                                         ctx->color_mode = hd.color_mode;
                                         
                                         /*
@@ -347,7 +348,8 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
                                         //      ctx->color_mode, ctx->channels, ctx->depth);
                                         
                                         if (ctx->color_mode != PSD_MODE_RGB
-                                            //&& ctx->color_mode != PSD_MODE_CMYK
+                                            && ctx->color_mode != PSD_MODE_GRAYSCALE
+                                            && ctx->color_mode != PSD_MODE_CMYK
                                         ) {
                                                 g_set_error (error, GDK_PIXBUF_ERROR,
                                                         GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
@@ -355,7 +357,7 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
                                                 return FALSE;
                                         }
                                         
-                                        if (ctx->depth != 8) {
+                                        if (ctx->depth != 8 && ctx->depth != 16) {
                                                 g_set_error (error, GDK_PIXBUF_ERROR,
                                                         GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
                                                         ("Unsupported color depth"));
@@ -371,10 +373,10 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
                                                 }
                                         }
                                         
-                                        // we need buffer that can contain one channel data of one
+                                        // we need buffer that can contain one channel data for one
                                         // row in RLE compressed format. 2*width should be enough
                                         g_free(ctx->buffer);
-                                        ctx->buffer = g_malloc(ctx->width * 2);
+                                        ctx->buffer = g_malloc(ctx->width * 2 * ctx->depth_bytes);
                                         
                                         // this will be needed for RLE decompression
                                         ctx->lines_lengths =
@@ -396,7 +398,7 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
                                         ctx->ch_bufs = g_malloc(sizeof(guchar*) * ctx->channels);
                                         for (int i = 0; i <     ctx->channels; i++) {
                                                 ctx->ch_bufs[i] =
-                                                        g_malloc(ctx->width * ctx->height);
+                                                        g_malloc(ctx->width*ctx->height*ctx->depth_bytes);
 
                                                 if (ctx->ch_bufs[i] == NULL) {
                                                         g_set_error (error, GDK_PIXBUF_ERROR,
@@ -440,6 +442,7 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
                                                 reset_context_buffer(ctx);
                                         } else if (ctx->compression == PSD_COMPRESSION_NONE) {
                                                 ctx->state = PSD_STATE_CHANNEL_DATA;
+                                                reset_context_buffer(ctx);
                                         } else {
                                                 g_set_error (error, GDK_PIXBUF_ERROR,
                                                         GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
@@ -464,7 +467,7 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
                                 break;
                         case PSD_STATE_CHANNEL_DATA:
                                 {
-                                        guint line_length = ctx->width;
+                                        guint line_length = ctx->width * ctx->depth_bytes;
                                         if (ctx->compression == PSD_COMPRESSION_RLE) {
                                                 line_length = ctx->lines_lengths[
                                                         ctx->curr_ch * ctx->height + ctx->curr_row];
@@ -473,18 +476,16 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
                                         if (feed_buffer(ctx->buffer, &ctx->bytes_read, &data, &size,
                                                         line_length))
                                         {
-                                                reset_context_buffer(ctx);
-                                        
                                                 if (ctx->compression == PSD_COMPRESSION_RLE) {
                                                         decompress_line(ctx->buffer, line_length,
                                                                 ctx->ch_bufs[ctx->curr_ch] + ctx->pos
                                                         );
                                                 } else {
                                                         memcpy(ctx->ch_bufs[ctx->curr_ch] + ctx->pos,
-                                                                ctx->buffer, ctx->width);
+                                                                ctx->buffer, line_length);
                                                 }
-
-                                                ctx->pos += ctx->width;
+                                                
+                                                ctx->pos += ctx->width * ctx->depth_bytes;
                                                 ++ctx->curr_row;
                                         
                                                 if (ctx->curr_row >= ctx->height) {
@@ -495,6 +496,8 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
                                                                 ctx->state = PSD_STATE_DONE;
                                                         }
                                                 }
+                                                
+                                                reset_context_buffer(ctx);
                                         }
                                 }
                                 break;
@@ -507,17 +510,29 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
         
         if (ctx->state == PSD_STATE_DONE && !ctx->finalized) {
                 // convert or copy channel buffers to our GdkPixbuf
+                guchar* pixels = gdk_pixbuf_get_pixels(ctx->pixbuf);
+                guint b = ctx->depth_bytes;
+
                 if (ctx->color_mode == PSD_MODE_RGB && !ctx->use_alpha) {
-                        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->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[3*j+0] = ctx->ch_bufs[0][ctx->width*i*b + j*b];
+                                        pixels[3*j+1] = ctx->ch_bufs[1][ctx->width*i*b + j*b];
+                                        pixels[3*j+2] = ctx->ch_bufs[2][ctx->width*i*b + j*b];
                                 }
                                 pixels += gdk_pixbuf_get_rowstride(ctx->pixbuf);
                         }
-                } else if (ctx->color_mode == PSD_MODE_RGB && ctx->use_alpha) {
+                } else if (ctx->color_mode == PSD_MODE_GRAYSCALE) {
+                        for (int i = 0; i < ctx->height; i++) {
+                                for (int j = 0; j < ctx->width; j++) {
+                                        pixels[3*j+0] = pixels[3*j+1] = pixels[3*j+2] =
+                                                ctx->ch_bufs[0][ctx->width*i*b + j*b];
+                                }
+                                pixels += gdk_pixbuf_get_rowstride(ctx->pixbuf);
+                        }
+                }
+#if 0           
+                else if (ctx->color_mode == PSD_MODE_RGB && ctx->use_alpha) {
                         guchar* pixels = gdk_pixbuf_get_pixels(ctx->pixbuf);
                         for (int i = 0; i < ctx->height; i++) {
                                 for (int j = 0; j < ctx->width; j++) {
@@ -528,7 +543,8 @@ gdk_pixbuf__psd_image_load_increment (gpointer      context_ptr,
                                 }
                                 pixels += gdk_pixbuf_get_rowstride(ctx->pixbuf);
                         }
-                } else if (ctx->color_mode == PSD_MODE_CMYK) {
+#endif
+                else if (ctx->color_mode == PSD_MODE_CMYK) {
                         // unfortunately, this doesn't seem to work correctly...
                 
                         guchar* pixels = gdk_pixbuf_get_pixels(ctx->pixbuf);