add support for file write plugins

[imager.git] / bmp.c

diff --git a/bmp.c b/bmp.c
index 4e103272a9646c10fbd7e3c20dcd62d2ff0082c6..f2a15cd81fdeeff4ff9a848f35222eb01b20581b 100644 (file)
--- a/bmp.c
+++ b/bmp.c
@@ -1,5 +1,5 @@
-#include "image.h"

 #include <stdarg.h>
 #include <stdarg.h>

+#include "imageri.h"

 
 /*
 =head1 NAME
 
 /*
 =head1 NAME


@@ -45,13 +45,14 @@ static int write_8bit_data(io_glue *ig, i_img *im);
 static int write_24bit_data(io_glue *ig, i_img *im);
 static int read_bmp_pal(io_glue *ig, i_img *im, int count);
 static i_img *read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 
 static int write_24bit_data(io_glue *ig, i_img *im);
 static int read_bmp_pal(io_glue *ig, i_img *im, int count);
 static i_img *read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 

-                            int compression);
+                            int compression, long offbits);

 static i_img *read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 
 static i_img *read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 

-                            int compression);
+                            int compression, long offbits);

 static i_img *read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 
 static i_img *read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 

-                            int compression);
+                            int compression, long offbits);

 static i_img *read_direct_bmp(io_glue *ig, int xsize, int ysize, 
 static i_img *read_direct_bmp(io_glue *ig, int xsize, int ysize, 

-                              int bit_count, int clr_used, int compression);
+                              int bit_count, int clr_used, int compression,
+                              long offbits);

 
 /* 
 =item i_writebmp_wiol(im, io_glue)
 
 /* 
 =item i_writebmp_wiol(im, io_glue)


@@ -131,24 +132,30 @@ i_readbmp_wiol(io_glue *ig) {
           "clr_important %d\n", filesize, offbits, xsize, ysize, planes, 
           bit_count, compression, size_image, xres, yres, clr_used, 
           clr_important));
           "clr_important %d\n", filesize, offbits, xsize, ysize, planes, 
           bit_count, compression, size_image, xres, yres, clr_used, 
           clr_important));

+
+  if (!i_int_check_image_file_limits(xsize, ysize, 3, sizeof(i_sample_t))) {
+    mm_log((1, "i_readbmp_wiol: image size exceeds limits\n"));
+    return NULL;
+  }

   
   switch (bit_count) {
   case 1:
   
   switch (bit_count) {
   case 1:

-    im = read_1bit_bmp(ig, xsize, ysize, clr_used, compression);
+    im = read_1bit_bmp(ig, xsize, ysize, clr_used, compression, offbits);

     break;
 
   case 4:
     break;
 
   case 4:

-    im = read_4bit_bmp(ig, xsize, ysize, clr_used, compression);
+    im = read_4bit_bmp(ig, xsize, ysize, clr_used, compression, offbits);

     break;
 
   case 8:
     break;
 
   case 8:

-    im = read_8bit_bmp(ig, xsize, ysize, clr_used, compression);
+    im = read_8bit_bmp(ig, xsize, ysize, clr_used, compression, offbits);

     break;
 
   case 32:
   case 24:
   case 16:
     break;
 
   case 32:
   case 24:
   case 16:

-    im = read_direct_bmp(ig, xsize, ysize, bit_count, clr_used, compression);
+    im = read_direct_bmp(ig, xsize, ysize, bit_count, clr_used, compression,
+                         offbits);

     break;
 
   default:
     break;
 
   default:


@@ -163,8 +170,8 @@ i_readbmp_wiol(io_glue *ig) {
     else if (yres && !xres)
       xres = yres;
     if (xres) {
     else if (yres && !xres)
       xres = yres;
     if (xres) {

-      i_tags_set_float(&im->tags, "i_xres", 0, xres * 0.0254);
-      i_tags_set_float(&im->tags, "i_yres", 0, yres * 0.0254);
+      i_tags_set_float2(&im->tags, "i_xres", 0, xres * 0.0254, 4);
+      i_tags_set_float2(&im->tags, "i_yres", 0, yres * 0.0254, 4);

     }
     i_tags_addn(&im->tags, "bmp_compression", 0, compression);
     i_tags_addn(&im->tags, "bmp_important_colors", 0, clr_important);
     }
     i_tags_addn(&im->tags, "bmp_compression", 0, compression);
     i_tags_addn(&im->tags, "bmp_important_colors", 0, clr_important);


@@ -406,6 +413,7 @@ write_1bit_data(io_glue *ig, i_img *im) {
   unsigned char *out;
   int line_size = (im->xsize+7) / 8;
   int x, y;
   unsigned char *out;
   int line_size = (im->xsize+7) / 8;
   int x, y;

+  int unpacked_size;

 
   /* round up to nearest multiple of four */
   line_size = (line_size + 3) / 4 * 4;
 
   /* round up to nearest multiple of four */
   line_size = (line_size + 3) / 4 * 4;


@@ -413,10 +421,18 @@ write_1bit_data(io_glue *ig, i_img *im) {
   if (!write_bmphead(ig, im, 1, line_size * im->ysize))
     return 0;
 
   if (!write_bmphead(ig, im, 1, line_size * im->ysize))
     return 0;
 

-  line = mymalloc(im->xsize + 8);
+  /* this shouldn't be an issue, but let's be careful */
+  unpacked_size = im->xsize + 8;
+  if (unpacked_size < im->xsize) {
+    i_push_error(0, "integer overflow during memory allocation");
+    return 0;
+  }
+  line = mymalloc(unpacked_size); /* checked 29jun05 tonyc */

   memset(line + im->xsize, 0, 8);
   memset(line + im->xsize, 0, 8);

-  
-  packed = mymalloc(line_size);
+
+  /* size allocated here is always much smaller than xsize, hence
+     can't overflow int */
+  packed = mymalloc(line_size); /* checked 29jun05 tonyc */

   memset(packed, 0, line_size);
   
   for (y = im->ysize-1; y >= 0; --y) {
   memset(packed, 0, line_size);
   
   for (y = im->ysize-1; y >= 0; --y) {


@@ -467,6 +483,7 @@ write_4bit_data(io_glue *ig, i_img *im) {
   unsigned char *out;
   int line_size = (im->xsize+1) / 2;
   int x, y;
   unsigned char *out;
   int line_size = (im->xsize+1) / 2;
   int x, y;

+  int unpacked_size;

 
   /* round up to nearest multiple of four */
   line_size = (line_size + 3) / 4 * 4;
 
   /* round up to nearest multiple of four */
   line_size = (line_size + 3) / 4 * 4;


@@ -474,10 +491,18 @@ write_4bit_data(io_glue *ig, i_img *im) {
   if (!write_bmphead(ig, im, 4, line_size * im->ysize))
     return 0;
 
   if (!write_bmphead(ig, im, 4, line_size * im->ysize))
     return 0;
 

-  line = mymalloc(im->xsize + 2);
+  /* this shouldn't be an issue, but let's be careful */
+  unpacked_size = im->xsize + 2;
+  if (unpacked_size < im->xsize) {
+    i_push_error(0, "integer overflow during memory allocation");
+    return 0;
+  }
+  line = mymalloc(unpacked_size); /* checked 29jun05 tonyc */

   memset(line + im->xsize, 0, 2);
   
   memset(line + im->xsize, 0, 2);
   

-  packed = mymalloc(line_size);
+  /* size allocated here is always much smaller than xsize, hence
+     can't overflow int */
+  packed = mymalloc(line_size); /* checked 29jun05 tonyc */

   memset(packed, 0, line_size);
   
   for (y = im->ysize-1; y >= 0; --y) {
   memset(packed, 0, line_size);
   
   for (y = im->ysize-1; y >= 0; --y) {


@@ -514,7 +539,8 @@ static int
 write_8bit_data(io_glue *ig, i_img *im) {
   i_palidx *line;
   int line_size = im->xsize;
 write_8bit_data(io_glue *ig, i_img *im) {
   i_palidx *line;
   int line_size = im->xsize;

-  int x, y;
+  int y;
+  int unpacked_size;

 
   /* round up to nearest multiple of four */
   line_size = (line_size + 3) / 4 * 4;
 
   /* round up to nearest multiple of four */
   line_size = (line_size + 3) / 4 * 4;


@@ -522,7 +548,13 @@ write_8bit_data(io_glue *ig, i_img *im) {
   if (!write_bmphead(ig, im, 8, line_size * im->ysize))
     return 0;
 
   if (!write_bmphead(ig, im, 8, line_size * im->ysize))
     return 0;
 

-  line = mymalloc(im->xsize + 4);
+  /* this shouldn't be an issue, but let's be careful */
+  unpacked_size = im->xsize + 4;
+  if (unpacked_size < im->xsize) {
+    i_push_error(0, "integer overflow during memory allocation");
+    return 0;
+  }
+  line = mymalloc(unpacked_size); /* checked 29jun05 tonyc */

   memset(line + im->xsize, 0, 4);
   
   for (y = im->ysize-1; y >= 0; --y) {
   memset(line + im->xsize, 0, 4);
   
   for (y = im->ysize-1; y >= 0; --y) {


@@ -556,15 +588,22 @@ static int
 write_24bit_data(io_glue *ig, i_img *im) {
   int *chans;
   unsigned char *samples;
 write_24bit_data(io_glue *ig, i_img *im) {
   int *chans;
   unsigned char *samples;

-  int x, y;
+  int y;

   int line_size = 3 * im->xsize;
   int line_size = 3 * im->xsize;

+
+  /* just in case we implement a direct format with 2bytes/pixel
+     (unlikely though) */
+  if (line_size / 3 != im->xsize) {
+    i_push_error(0, "integer overflow during memory allocation");
+    return 0;
+  }

   
   line_size = (line_size + 3) / 4 * 4;
   
   if (!write_bmphead(ig, im, 24, line_size * im->ysize))
     return 0;
   chans = im->channels >= 3 ? bgr_chans : grey_chans;
   
   line_size = (line_size + 3) / 4 * 4;
   
   if (!write_bmphead(ig, im, 24, line_size * im->ysize))
     return 0;
   chans = im->channels >= 3 ? bgr_chans : grey_chans;

-  samples = mymalloc(line_size);
+  samples = mymalloc(line_size); /* checked 29jun05 tonyc */

   memset(samples, 0, line_size);
   for (y = im->ysize-1; y >= 0; --y) {
     i_gsamp(im, 0, im->xsize, y, samples, chans, 3);
   memset(samples, 0, line_size);
   for (y = im->ysize-1; y >= 0; --y) {
     i_gsamp(im, 0, im->xsize, y, samples, chans, 3);


@@ -614,7 +653,7 @@ read_bmp_pal(io_glue *ig, i_img *im, int count) {
 }
 
 /*
 }
 
 /*

-=item read_1bit_bmp(ig, xsize, ysize, clr_used)
+=item read_1bit_bmp(ig, xsize, ysize, clr_used, compression, offbits)

 
 Reads in the palette and image data for a 1-bit/pixel image.
 
 
 Reads in the palette and image data for a 1-bit/pixel image.
 


@@ -624,20 +663,30 @@ Returns the image or NULL.
 */
 static i_img *
 read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 
 */
 static i_img *
 read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 

-              int compression) {
+              int compression, long offbits) {

   i_img *im;
   int x, y, lasty, yinc;
   i_palidx *line, *p;
   unsigned char *packed;
   int line_size = (xsize + 7)/8;
   i_img *im;
   int x, y, lasty, yinc;
   i_palidx *line, *p;
   unsigned char *packed;
   int line_size = (xsize + 7)/8;

-  int byte, bit;
+  int bit;

   unsigned char *in;
   unsigned char *in;

+  long base_offset;

 
   if (compression != BI_RGB) {
     i_push_errorf(0, "unknown 1-bit BMP compression (%d)", compression);
     return NULL;
   }
 
 
   if (compression != BI_RGB) {
     i_push_errorf(0, "unknown 1-bit BMP compression (%d)", compression);
     return NULL;
   }
 

+  if (xsize + 8 < xsize) { /* if there was overflow */
+    /* we check with 8 because we allocate that much for the decoded 
+       line buffer */
+    i_push_error(0, "integer overflow during memory allocation");
+    return NULL;
+  }
+
+  /* if xsize+7 is ok then (xsize+7)/8 will be and the minor
+     adjustments below won't make it overflow */

   line_size = (line_size+3) / 4 * 4;
 
   if (ysize > 0) {
   line_size = (line_size+3) / 4 * 4;
 
   if (ysize > 0) {


@@ -658,6 +707,13 @@ read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
     i_push_errorf(0, "out of range colors used (%d)", clr_used);
     return NULL;
   }
     i_push_errorf(0, "out of range colors used (%d)", clr_used);
     return NULL;
   }

+
+  base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE + clr_used * 4;
+  if (offbits < base_offset) {
+    i_push_errorf(0, "image data offset too small (%ld)", offbits);
+    return NULL;
+  }
+

   im = i_img_pal_new(xsize, ysize, 3, 256);
   if (!im)
     return NULL;
   im = i_img_pal_new(xsize, ysize, 3, 256);
   if (!im)
     return NULL;


@@ -665,11 +721,25 @@ read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
     i_img_destroy(im);
     return NULL;
   }
     i_img_destroy(im);
     return NULL;
   }

+
+  if (offbits > base_offset) {
+    /* this will be slow if the offset is large, but that should be
+       rare */
+    char buffer;
+    while (base_offset < offbits) {
+      if (ig->readcb(ig, &buffer, 1) != 1) {
+        i_img_destroy(im);
+        i_push_error(0, "failed skipping to image data offset");
+        return NULL;
+      }
+      ++base_offset;
+    }
+  }

   
   i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
 
   
   i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
 

-  packed = mymalloc(line_size);
-  line = mymalloc(xsize+8);
+  packed = mymalloc(line_size); /* checked 29jun05 tonyc */
+  line = mymalloc(xsize+8); /* checked 29jun05 tonyc */

   while (y != lasty) {
     if (ig->readcb(ig, packed, line_size) != line_size) {
       myfree(packed);
   while (y != lasty) {
     if (ig->readcb(ig, packed, line_size) != line_size) {
       myfree(packed);


@@ -712,7 +782,7 @@ point.
 */
 static i_img *
 read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 
 */
 static i_img *
 read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 

-              int compression) {
+              int compression, long offbits) {

   i_img *im;
   int x, y, lasty, yinc;
   i_palidx *line, *p;
   i_img *im;
   int x, y, lasty, yinc;
   i_palidx *line, *p;


@@ -720,7 +790,10 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   int line_size = (xsize + 1)/2;
   unsigned char *in;
   int size, i;
   int line_size = (xsize + 1)/2;
   unsigned char *in;
   int size, i;

+  long base_offset;

 
 

+  /* line_size is going to be smaller than xsize in most cases (and
+     when it's not, xsize is itself small), and hence not overflow */

   line_size = (line_size+3) / 4 * 4;
 
   if (ysize > 0) {
   line_size = (line_size+3) / 4 * 4;
 
   if (ysize > 0) {


@@ -743,6 +816,12 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
     return NULL;
   }
 
     return NULL;
   }
 

+  base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE + clr_used * 4;
+  if (offbits < base_offset) {
+    i_push_errorf(0, "image data offset too small (%ld)", offbits);
+    return NULL;
+  }
+

   im = i_img_pal_new(xsize, ysize, 3, 256);
   if (!im) /* error should have been pushed already */
     return NULL;
   im = i_img_pal_new(xsize, ysize, 3, 256);
   if (!im) /* error should have been pushed already */
     return NULL;


@@ -751,11 +830,26 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
     return NULL;
   }
 
     return NULL;
   }
 

+  if (offbits > base_offset) {
+    /* this will be slow if the offset is large, but that should be
+       rare */
+    char buffer;
+    while (base_offset < offbits) {
+      if (ig->readcb(ig, &buffer, 1) != 1) {
+        i_img_destroy(im);
+        i_push_error(0, "failed skipping to image data offset");
+        return NULL;
+      }
+      ++base_offset;
+    }
+  }
+  

   if (line_size < 260)
   if (line_size < 260)

-    packed = mymalloc(260);
+    packed = mymalloc(260); /* checked 29jun05 tonyc */

   else
   else

-    packed = mymalloc(line_size);
-  line = mymalloc(xsize+1);
+    packed = mymalloc(line_size); /* checked 29jun05 tonyc */
+  /* xsize won't approach MAXINT */
+  line = mymalloc(xsize+1); /* checked 29jun05 tonyc */

   if (compression == BI_RGB) {
     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
     while (y != lasty) {
   if (compression == BI_RGB) {
     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
     while (y != lasty) {


@@ -781,7 +875,6 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   }
   else if (compression == BI_RLE4) {
     int read_size;
   }
   else if (compression == BI_RLE4) {
     int read_size;

-    int want_high;

     int count;
 
     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RLE4", -1, 0);
     int count;
 
     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RLE4", -1, 0);


@@ -873,14 +966,18 @@ Returns the image or NULL.
 */
 static i_img *
 read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 
 */
 static i_img *
 read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used, 

-              int compression) {
+              int compression, long offbits) {

   i_img *im;
   int x, y, lasty, yinc;
   i_img *im;
   int x, y, lasty, yinc;

-  i_palidx *line, *p;
+  i_palidx *line;

   int line_size = xsize;
   int line_size = xsize;

-  unsigned char *in;
+  long base_offset;

 
   line_size = (line_size+3) / 4 * 4;
 
   line_size = (line_size+3) / 4 * 4;

+  if (line_size < xsize) { /* if it overflowed (unlikely, but check) */
+    i_push_error(0, "integer overflow during memory allocation");
+    return NULL;
+  }

 
   if (ysize > 0) {
     y = ysize-1;
 
   if (ysize > 0) {
     y = ysize-1;


@@ -901,6 +998,12 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
     return NULL;
   }
 
     return NULL;
   }
 

+  base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE + clr_used * 4;
+  if (offbits < base_offset) {
+    i_push_errorf(0, "image data offset too small (%ld)", offbits);
+    return NULL;
+  }
+

   im = i_img_pal_new(xsize, ysize, 3, 256);
   if (!im)
     return NULL;
   im = i_img_pal_new(xsize, ysize, 3, 256);
   if (!im)
     return NULL;


@@ -909,7 +1012,21 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
     return NULL;
   }
 
     return NULL;
   }
 

-  line = mymalloc(line_size);
+  if (offbits > base_offset) {
+    /* this will be slow if the offset is large, but that should be
+       rare */
+    char buffer;
+    while (base_offset < offbits) {
+      if (ig->readcb(ig, &buffer, 1) != 1) {
+        i_img_destroy(im);
+        i_push_error(0, "failed skipping to image data offset");
+        return NULL;
+      }
+      ++base_offset;
+    }
+  }
+  
+  line = mymalloc(line_size); /* checked 29jun05 tonyc */

   if (compression == BI_RGB) {
     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
     while (y != lasty) {
   if (compression == BI_RGB) {
     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
     while (y != lasty) {


@@ -926,7 +1043,6 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   }
   else if (compression == BI_RLE8) {
     int read_size;
   }
   else if (compression == BI_RLE8) {
     int read_size;

-    int want_high;

     int count;
     unsigned char packed[2];
 
     int count;
     unsigned char packed[2];
 


@@ -1023,11 +1139,10 @@ Returns the image or NULL.
 */
 static i_img *
 read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count, 
 */
 static i_img *
 read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count, 

-                int clr_used, int compression) {
+                int clr_used, int compression, long offbits) {

   i_img *im;
   int x, y, lasty, yinc;
   i_color *line, *p;
   i_img *im;
   int x, y, lasty, yinc;
   i_color *line, *p;

-  unsigned char *in;

   int pix_size = bit_count / 8;
   int line_size = xsize * pix_size;
   struct bm_masks masks;
   int pix_size = bit_count / 8;
   int line_size = xsize * pix_size;
   struct bm_masks masks;


@@ -1037,6 +1152,7 @@ read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
   char junk[4];
   const char *compression_name;
   int bytes;
   char junk[4];
   const char *compression_name;
   int bytes;

+  long base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE;

   
   unpack_code[0] = *("v3V"+pix_size-2);
   unpack_code[1] = '\0';
   
   unpack_code[0] = *("v3V"+pix_size-2);
   unpack_code[1] = '\0';


@@ -1067,6 +1183,7 @@ read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
         i_push_error(0, "skipping colors");
         return 0;
       }
         i_push_error(0, "skipping colors");
         return 0;
       }

+      base_offset += 4;

     }
   }
   else if (compression == BI_BITFIELDS) {
     }
   }
   else if (compression == BI_BITFIELDS) {


@@ -1087,12 +1204,26 @@ read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
       }
       masks.shifts[i] = pos - 8;
     }
       }
       masks.shifts[i] = pos - 8;
     }

+    base_offset += 4 * 4;

   }
   else {
     i_push_errorf(0, "unknown 24-bit BMP compression (%d)", compression);
     return NULL;
   }
 
   }
   else {
     i_push_errorf(0, "unknown 24-bit BMP compression (%d)", compression);
     return NULL;
   }
 

+  if (offbits > base_offset) {
+    /* this will be slow if the offset is large, but that should be
+       rare */
+    char buffer;
+    while (base_offset < offbits) {
+      if (ig->readcb(ig, &buffer, 1) != 1) {
+        i_push_error(0, "failed skipping to image data offset");
+        return NULL;
+      }
+      ++base_offset;
+    }
+  }
+  

   im = i_img_empty(NULL, xsize, ysize);
   if (!im)
     return NULL;
   im = i_img_empty(NULL, xsize, ysize);
   if (!im)
     return NULL;


@@ -1107,7 +1238,7 @@ read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
     i_push_error(0, "integer overflow calculating buffer size");
     return NULL;
   }
     i_push_error(0, "integer overflow calculating buffer size");
     return NULL;
   }

-  line = mymalloc(bytes);
+  line = mymalloc(bytes); /* checked 29jun05 tonyc */

   while (y != lasty) {
     p = line;
     for (x = 0; x < xsize; ++x) {
   while (y != lasty) {
     p = line;
     for (x = 0; x < xsize; ++x) {


@@ -1157,5 +1288,7 @@ Doesn't handle OS/2 bitmaps.
 
 BI_BITFIELDS compression hasn't been tested (I need an image).
 
 
 BI_BITFIELDS compression hasn't been tested (I need an image).
 

+The header handling for paletted images needs to be refactored
+

 =cut
 */
 =cut
 */