document when the slot destructor is called

[imager.git] / bmp.c

diff --git a/bmp.c b/bmp.c
index 9cf7615797d0c366fc8961d26c56997c059d469f..0e8fe8e75c2ee9674106979f611612fcb5a3ca59 100644 (file)
--- a/bmp.c
+++ b/bmp.c
@@ -1,3 +1,4 @@
+#define IMAGER_NO_CONTEXT

 #include <stdarg.h>
 #include "imageri.h"
 
 #include <stdarg.h>
 #include "imageri.h"
 


@@ -76,7 +77,7 @@ Never compresses the image.
 */
 int
 i_writebmp_wiol(i_img *im, io_glue *ig) {
 */
 int
 i_writebmp_wiol(i_img *im, io_glue *ig) {

-  io_glue_commit_types(ig);
+  dIMCTXim(im);

   i_clear_error();
 
   /* pick a format */
   i_clear_error();
 
   /* pick a format */


@@ -117,10 +118,10 @@ i_readbmp_wiol(io_glue *ig, int allow_incomplete) {
   i_packed_t xsize, ysize, planes, bit_count, compression, size_image, xres, yres;
   i_packed_t clr_used, clr_important, offbits;
   i_img *im;
   i_packed_t xsize, ysize, planes, bit_count, compression, size_image, xres, yres;
   i_packed_t clr_used, clr_important, offbits;
   i_img *im;

+  dIMCTXio(ig);

 
 

-  mm_log((1, "i_readbmp_wiol(ig %p)\n", ig));
+  im_log((aIMCTX, 1, "i_readbmp_wiol(ig %p)\n", ig));

   
   

-  io_glue_commit_types(ig);

   i_clear_error();
 
   if (!read_packed(ig, "CCVvvVVV!V!vvVVVVVV", &b_magic, &m_magic, &filesize, 
   i_clear_error();
 
   if (!read_packed(ig, "CCVvvVVV!V!vvVVVVVV", &b_magic, &m_magic, &filesize, 


@@ -137,7 +138,7 @@ i_readbmp_wiol(io_glue *ig, int allow_incomplete) {
     return 0;
   }
 
     return 0;
   }
 

-  mm_log((1, " bmp header: filesize %d offbits %d xsize %d ysize %d planes %d "
+  im_log((aIMCTX, 1, " bmp header: filesize %d offbits %d xsize %d ysize %d planes %d "

           "bit_count %d compression %d size %d xres %d yres %d clr_used %d "
           "clr_important %d\n", (int)filesize, (int)offbits, (int)xsize,
          (int)ysize, (int)planes, (int)bit_count, (int)compression, 
           "bit_count %d compression %d size %d xres %d yres %d clr_used %d "
           "clr_important %d\n", (int)filesize, (int)offbits, (int)xsize,
          (int)ysize, (int)planes, (int)bit_count, (int)compression, 


@@ -145,7 +146,7 @@ i_readbmp_wiol(io_glue *ig, int allow_incomplete) {
           (int)clr_important));
 
   if (!i_int_check_image_file_limits(xsize, abs(ysize), 3, sizeof(i_sample_t))) {
           (int)clr_important));
 
   if (!i_int_check_image_file_limits(xsize, abs(ysize), 3, sizeof(i_sample_t))) {

-    mm_log((1, "i_readbmp_wiol: image size exceeds limits\n"));
+    im_log((aIMCTX, 1, "i_readbmp_wiol: image size exceeds limits\n"));

     return NULL;
   }
   
     return NULL;
   }
   


@@ -173,7 +174,7 @@ i_readbmp_wiol(io_glue *ig, int allow_incomplete) {
     break;
 
   default:
     break;
 
   default:

-    i_push_errorf(0, "unknown bit count for BMP file (%d)", (int)bit_count);
+    im_push_errorf(aIMCTX, 0, "unknown bit count for BMP file (%d)", (int)bit_count);

     return NULL;
   }
 
     return NULL;
   }
 


@@ -237,7 +238,7 @@ read_packed(io_glue *ig, char *format, ...) {
 
     switch (code) {
     case 'v':
 
     switch (code) {
     case 'v':

-      if (ig->readcb(ig, buf, 2) != 2)
+      if (i_io_read(ig, buf, 2) != 2)

        return 0;
       work = buf[0] + ((i_packed_t)buf[1] << 8);
       if (shrieking)
        return 0;
       work = buf[0] + ((i_packed_t)buf[1] << 8);
       if (shrieking)


@@ -247,7 +248,7 @@ read_packed(io_glue *ig, char *format, ...) {
       break;
 
     case 'V':
       break;
 
     case 'V':

-      if (ig->readcb(ig, buf, 4) != 4)
+      if (i_io_read(ig, buf, 4) != 4)

        return 0;
       work = buf[0] + (buf[1] << 8) + ((i_packed_t)buf[2] << 16) + ((i_packed_t)buf[3] << 24);
       if (shrieking)
        return 0;
       work = buf[0] + (buf[1] << 8) + ((i_packed_t)buf[2] << 16) + ((i_packed_t)buf[3] << 24);
       if (shrieking)


@@ -257,25 +258,28 @@ read_packed(io_glue *ig, char *format, ...) {
       break;
 
     case 'C':
       break;
 
     case 'C':

-      if (ig->readcb(ig, buf, 1) != 1)
+      if (i_io_read(ig, buf, 1) != 1)

        return 0;
       *p = buf[0];
       break;
 
     case 'c':
        return 0;
       *p = buf[0];
       break;
 
     case 'c':

-      if (ig->readcb(ig, buf, 1) != 1)
+      if (i_io_read(ig, buf, 1) != 1)

        return 0;
       *p = (char)buf[0];
       break;
       
     case '3': /* extension - 24-bit number */
        return 0;
       *p = (char)buf[0];
       break;
       
     case '3': /* extension - 24-bit number */

-      if (ig->readcb(ig, buf, 3) != 3)
+      if (i_io_read(ig, buf, 3) != 3)

         return 0;
       *p = buf[0] + (buf[1] << 8) + ((i_packed_t)buf[2] << 16);
       break;
       
     default:
         return 0;
       *p = buf[0] + (buf[1] << 8) + ((i_packed_t)buf[2] << 16);
       break;
       
     default:

-      i_fatal(1, "Unknown read_packed format code 0x%02x", code);
+      {
+       dIMCTXio(ig);
+       im_fatal(aIMCTX, 1, "Unknown read_packed format code 0x%02x", code);
+      }

     }
   }
   return 1;
     }
   }
   return 1;


@@ -306,7 +310,7 @@ write_packed(io_glue *ig, char *format, ...) {
     case 'v':
       buf[0] = i & 255;
       buf[1] = i / 256;
     case 'v':
       buf[0] = i & 255;
       buf[1] = i / 256;

-      if (ig->writecb(ig, buf, 2) == -1)
+      if (i_io_write(ig, buf, 2) == -1)

        return 0;
       break;
 
        return 0;
       break;
 


@@ -315,19 +319,22 @@ write_packed(io_glue *ig, char *format, ...) {
       buf[1] = (i >> 8) & 0xFF;
       buf[2] = (i >> 16) & 0xFF;
       buf[3] = (i >> 24) & 0xFF;
       buf[1] = (i >> 8) & 0xFF;
       buf[2] = (i >> 16) & 0xFF;
       buf[3] = (i >> 24) & 0xFF;

-      if (ig->writecb(ig, buf, 4) == -1)
+      if (i_io_write(ig, buf, 4) == -1)

        return 0;
       break;
 
     case 'C':
     case 'c':
       buf[0] = i & 0xFF;
        return 0;
       break;
 
     case 'C':
     case 'c':
       buf[0] = i & 0xFF;

-      if (ig->writecb(ig, buf, 1) == -1)
+      if (i_io_write(ig, buf, 1) == -1)

        return 0;
       break;
 
     default:
        return 0;
       break;
 
     default:

-      i_fatal(1, "Unknown write_packed format code 0x%02x", *format);
+      {
+       dIMCTXio(ig);
+       im_fatal(aIMCTX, 1, "Unknown write_packed format code 0x%02x", *format);
+      }

     }
     ++format;
   }
     }
     ++format;
   }


@@ -352,6 +359,7 @@ int write_bmphead(io_glue *ig, i_img *im, int bit_count, int data_size) {
   int got_xres, got_yres, aspect_only;
   int colors_used = 0;
   int offset = FILEHEAD_SIZE + INFOHEAD_SIZE;
   int got_xres, got_yres, aspect_only;
   int colors_used = 0;
   int offset = FILEHEAD_SIZE + INFOHEAD_SIZE;

+  dIMCTXim(im);

 
   if (im->xsize > SIGNMAX32 || im->ysize > SIGNMAX32) {
     i_push_error(0, "image too large to write to BMP");
 
   if (im->xsize > SIGNMAX32 || im->ysize > SIGNMAX32) {
     i_push_error(0, "image too large to write to BMP");


@@ -453,6 +461,7 @@ write_1bit_data(io_glue *ig, i_img *im) {
   int line_size = (im->xsize+7) / 8;
   int x, y;
   int unpacked_size;
   int line_size = (im->xsize+7) / 8;
   int x, y;
   int unpacked_size;

+  dIMCTXim(im);

 
   /* 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;


@@ -491,7 +500,7 @@ write_1bit_data(io_glue *ig, i_img *im) {
     if (mask != 0x80) {
       *out++ = byte;
     }
     if (mask != 0x80) {
       *out++ = byte;
     }

-    if (ig->writecb(ig, packed, line_size) < 0) {
+    if (i_io_write(ig, packed, line_size) < 0) {

       myfree(packed);
       myfree(line);
       i_push_error(0, "writing 1 bit/pixel packed data");
       myfree(packed);
       myfree(line);
       i_push_error(0, "writing 1 bit/pixel packed data");


@@ -501,7 +510,8 @@ write_1bit_data(io_glue *ig, i_img *im) {
   myfree(packed);
   myfree(line);
 
   myfree(packed);
   myfree(line);
 

-  ig->closecb(ig);
+  if (i_io_close(ig))
+    return 0;

 
   return 1;
 }
 
   return 1;
 }


@@ -523,6 +533,7 @@ write_4bit_data(io_glue *ig, i_img *im) {
   int line_size = (im->xsize+1) / 2;
   int x, y;
   int unpacked_size;
   int line_size = (im->xsize+1) / 2;
   int x, y;
   int unpacked_size;

+  dIMCTXim(im);

 
   /* 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;


@@ -550,7 +561,7 @@ write_4bit_data(io_glue *ig, i_img *im) {
     for (x = 0; x < im->xsize; x += 2) {
       *out++ = (line[x] << 4) + line[x+1];
     }
     for (x = 0; x < im->xsize; x += 2) {
       *out++ = (line[x] << 4) + line[x+1];
     }

-    if (ig->writecb(ig, packed, line_size) < 0) {
+    if (i_io_write(ig, packed, line_size) < 0) {

       myfree(packed);
       myfree(line);
       i_push_error(0, "writing 4 bit/pixel packed data");
       myfree(packed);
       myfree(line);
       i_push_error(0, "writing 4 bit/pixel packed data");


@@ -560,7 +571,8 @@ write_4bit_data(io_glue *ig, i_img *im) {
   myfree(packed);
   myfree(line);
 
   myfree(packed);
   myfree(line);
 

-  ig->closecb(ig);
+  if (i_io_close(ig))
+    return 0;

 
   return 1;
 }
 
   return 1;
 }


@@ -580,6 +592,7 @@ write_8bit_data(io_glue *ig, i_img *im) {
   int line_size = im->xsize;
   int y;
   int unpacked_size;
   int line_size = im->xsize;
   int y;
   int unpacked_size;

+  dIMCTXim(im);

 
   /* 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;


@@ -598,7 +611,7 @@ write_8bit_data(io_glue *ig, i_img *im) {
   
   for (y = im->ysize-1; y >= 0; --y) {
     i_gpal(im, 0, im->xsize, y, line);
   
   for (y = im->ysize-1; y >= 0; --y) {
     i_gpal(im, 0, im->xsize, y, line);

-    if (ig->writecb(ig, line, line_size) < 0) {
+    if (i_io_write(ig, line, line_size) < 0) {

       myfree(line);
       i_push_error(0, "writing 8 bit/pixel packed data");
       return 0;
       myfree(line);
       i_push_error(0, "writing 8 bit/pixel packed data");
       return 0;


@@ -606,7 +619,8 @@ write_8bit_data(io_glue *ig, i_img *im) {
   }
   myfree(line);
 
   }
   myfree(line);
 

-  ig->closecb(ig);
+  if (i_io_close(ig))
+    return 0;

 
   return 1;
 }
 
   return 1;
 }


@@ -626,6 +640,7 @@ write_24bit_data(io_glue *ig, i_img *im) {
   int y;
   int line_size = 3 * im->xsize;
   i_color bg;
   int y;
   int line_size = 3 * im->xsize;
   i_color bg;

+  dIMCTXim(im);

 
   i_get_file_background(im, &bg);
 
 
   i_get_file_background(im, &bg);
 


@@ -652,7 +667,7 @@ write_24bit_data(io_glue *ig, i_img *im) {
       samplep[0] = tmp;
       samplep += 3;
     }
       samplep[0] = tmp;
       samplep += 3;
     }

-    if (ig->writecb(ig, samples, line_size) < 0) {
+    if (i_io_write(ig, samples, line_size) < 0) {

       i_push_error(0, "writing image data");
       myfree(samples);
       return 0;
       i_push_error(0, "writing image data");
       myfree(samples);
       return 0;


@@ -660,7 +675,8 @@ write_24bit_data(io_glue *ig, i_img *im) {
   }
   myfree(samples);
 
   }
   myfree(samples);
 

-  ig->closecb(ig);
+  if (i_io_close(ig))
+    return 0;

 
   return 1;
 }
 
   return 1;
 }


@@ -679,6 +695,7 @@ read_bmp_pal(io_glue *ig, i_img *im, int count) {
   int i;
   i_packed_t r, g, b, x;
   i_color c;
   int i;
   i_packed_t r, g, b, x;
   i_color c;

+  dIMCTXio(ig);

   
   for (i = 0; i < count; ++i) {
     if (!read_packed(ig, "CCCC", &b, &g, &r, &x)) {
   
   for (i = 0; i < count; ++i) {
     if (!read_packed(ig, "CCCC", &b, &g, &r, &x)) {


@@ -717,9 +734,10 @@ read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   int bit;
   unsigned char *in;
   long base_offset;
   int bit;
   unsigned char *in;
   long base_offset;

+  dIMCTXio(ig);

 
   if (compression != BI_RGB) {
 
   if (compression != BI_RGB) {

-    i_push_errorf(0, "unknown 1-bit BMP compression (%d)", compression);
+    im_push_errorf(aIMCTX, 0, "unknown 1-bit BMP compression (%d)", compression);

     return NULL;
   }
 
     return NULL;
   }
 


@@ -750,13 +768,13 @@ read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   if (!clr_used)
     clr_used = 2;
   if (clr_used < 0 || clr_used > 2) {
   if (!clr_used)
     clr_used = 2;
   if (clr_used < 0 || clr_used > 2) {

-    i_push_errorf(0, "out of range colors used (%d)", clr_used);
+    im_push_errorf(aIMCTX, 0, "out of range colors used (%d)", clr_used);

     return NULL;
   }
 
   base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE + clr_used * 4;
   if (offbits < base_offset) {
     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);
+    im_push_errorf(aIMCTX, 0, "image data offset too small (%ld)", offbits);

     return NULL;
   }
 
     return NULL;
   }
 


@@ -773,7 +791,7 @@ read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
        rare */
     char buffer;
     while (base_offset < offbits) {
        rare */
     char buffer;
     while (base_offset < offbits) {

-      if (ig->readcb(ig, &buffer, 1) != 1) {
+      if (i_io_read(ig, &buffer, 1) != 1) {

         i_img_destroy(im);
         i_push_error(0, "failed skipping to image data offset");
         return NULL;
         i_img_destroy(im);
         i_push_error(0, "failed skipping to image data offset");
         return NULL;


@@ -787,7 +805,7 @@ read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   packed = mymalloc(line_size); /* checked 29jun05 tonyc */
   line = mymalloc(xsize+8); /* checked 29jun05 tonyc */
   while (y != lasty) {
   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) {
+    if (i_io_read(ig, packed, line_size) != line_size) {

       myfree(packed);
       myfree(line);
       if (allow_incomplete) {
       myfree(packed);
       myfree(line);
       if (allow_incomplete) {


@@ -845,6 +863,7 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   int size, i;
   long base_offset;
   int starty;
   int size, i;
   long base_offset;
   int starty;

+  dIMCTXio(ig);

 
   /* 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 is going to be smaller than xsize in most cases (and
      when it's not, xsize is itself small), and hence not overflow */


@@ -867,13 +886,13 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
     clr_used = 16;
 
   if (clr_used > 16 || clr_used < 0) {
     clr_used = 16;
 
   if (clr_used > 16 || clr_used < 0) {

-    i_push_errorf(0, "out of range colors used (%d)", clr_used);
+    im_push_errorf(aIMCTX, 0, "out of range colors used (%d)", clr_used);

     return NULL;
   }
 
   base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE + clr_used * 4;
   if (offbits < base_offset) {
     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);
+    im_push_errorf(aIMCTX, 0, "image data offset too small (%ld)", offbits);

     return NULL;
   }
 
     return NULL;
   }
 


@@ -890,7 +909,7 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
        rare */
     char buffer;
     while (base_offset < offbits) {
        rare */
     char buffer;
     while (base_offset < offbits) {

-      if (ig->readcb(ig, &buffer, 1) != 1) {
+      if (i_io_read(ig, &buffer, 1) != 1) {

         i_img_destroy(im);
         i_push_error(0, "failed skipping to image data offset");
         return NULL;
         i_img_destroy(im);
         i_push_error(0, "failed skipping to image data offset");
         return NULL;


@@ -908,7 +927,7 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   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) {

-      if (ig->readcb(ig, packed, line_size) != line_size) {
+      if (i_io_read(ig, packed, line_size) != line_size) {

        myfree(packed);
        myfree(line);
         if (allow_incomplete) {
        myfree(packed);
        myfree(line);
         if (allow_incomplete) {


@@ -938,12 +957,13 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   else if (compression == BI_RLE4) {
     int read_size;
     int count;
   else if (compression == BI_RLE4) {
     int read_size;
     int count;

+    i_img_dim xlimit = (xsize + 1) / 2 * 2; /* rounded up */

 
     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RLE4", -1, 0);
     x = 0;
     while (1) {
       /* there's always at least 2 bytes in a sequence */
 
     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RLE4", -1, 0);
     x = 0;
     while (1) {
       /* there's always at least 2 bytes in a sequence */

-      if (ig->readcb(ig, packed, 2) != 2) {
+      if (i_io_read(ig, packed, 2) != 2) {

         myfree(packed);
         myfree(line);
         if (allow_incomplete) {
         myfree(packed);
         myfree(line);
         if (allow_incomplete) {


@@ -958,23 +978,24 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
         }
       }
       else if (packed[0]) {
         }
       }
       else if (packed[0]) {

-       if (x + packed[0] > xsize) {
+       int count = packed[0];
+       if (x + count > xlimit) {

          /* this file is corrupt */
          myfree(packed);
          myfree(line);
          i_push_error(0, "invalid data during decompression");
          /* this file is corrupt */
          myfree(packed);
          myfree(line);
          i_push_error(0, "invalid data during decompression");

+         im_log((aIMCTX, 1, "read 4-bit: scanline overflow x %d + count %d vs xlimit %d (y %d)\n",
+                 (int)x, count, (int)xlimit, (int)y));

          i_img_destroy(im);
          return NULL;
        }
          i_img_destroy(im);
          return NULL;
        }

-        line[0] = packed[1] >> 4;
-        line[1] = packed[1] & 0x0F;
-        for (i = 0; i < packed[0]; i += 2) {
-          if (i < packed[0]-1) 
-            i_ppal(im, x, x+2, y, line);
-          else
-            i_ppal(im, x, x+(packed[0]-i), y, line);
-          x += 2;
-        }
+       /* fill in the line */
+       for (i = 0; i < count; i += 2)
+         line[i] = packed[1] >> 4;
+       for (i = 1; i < count; i += 2)
+         line[i] = packed[1] & 0x0F;
+       i_ppal(im, x, x+count, y, line);
+       x += count;

       } else {
         switch (packed[1]) {
         case BMPRLE_ENDOFLINE:
       } else {
         switch (packed[1]) {
         case BMPRLE_ENDOFLINE:


@@ -988,7 +1009,7 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
           return im;
 
         case BMPRLE_DELTA:
           return im;
 
         case BMPRLE_DELTA:

-          if (ig->readcb(ig, packed, 2) != 2) {
+          if (i_io_read(ig, packed, 2) != 2) {

             myfree(packed);
             myfree(line);
             if (allow_incomplete) {
             myfree(packed);
             myfree(line);
             if (allow_incomplete) {


@@ -1008,17 +1029,19 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
 
         default:
           count = packed[1];
 
         default:
           count = packed[1];

-         if (x + count > xsize) {
+         if (x + count > xlimit) {

            /* this file is corrupt */
            myfree(packed);
            myfree(line);
            i_push_error(0, "invalid data during decompression");
            /* this file is corrupt */
            myfree(packed);
            myfree(line);
            i_push_error(0, "invalid data during decompression");

+           im_log((aIMCTX, 1, "read 4-bit: scanline overflow (unpacked) x %d + count %d vs xlimit %d (y %d)\n",
+                 (int)x, count, (int)xlimit, (int)y));

            i_img_destroy(im);
            return NULL;
          }
           size = (count + 1) / 2;
           read_size = (size+1) / 2 * 2;
            i_img_destroy(im);
            return NULL;
          }
           size = (count + 1) / 2;
           read_size = (size+1) / 2 * 2;

-          if (ig->readcb(ig, packed, read_size) != read_size) {
+          if (i_io_read(ig, packed, read_size) != read_size) {

             myfree(packed);
             myfree(line);
             if (allow_incomplete) {
             myfree(packed);
             myfree(line);
             if (allow_incomplete) {


@@ -1046,7 +1069,7 @@ read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   else { /*if (compression == BI_RLE4) {*/
     myfree(packed);
     myfree(line);
   else { /*if (compression == BI_RLE4) {*/
     myfree(packed);
     myfree(line);

-    i_push_errorf(0, "unknown 4-bit BMP compression (%d)", compression);
+    im_push_errorf(aIMCTX, 0, "unknown 4-bit BMP compression (%d)", compression);

     i_img_destroy(im);
     return NULL;
   }
     i_img_destroy(im);
     return NULL;
   }


@@ -1071,6 +1094,7 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   i_palidx *line;
   int line_size = xsize;
   long base_offset;
   i_palidx *line;
   int line_size = xsize;
   long base_offset;

+  dIMCTXio(ig);

 
   line_size = (line_size+3) / 4 * 4;
   if (line_size < xsize) { /* if it overflowed (unlikely, but check) */
 
   line_size = (line_size+3) / 4 * 4;
   if (line_size < xsize) { /* if it overflowed (unlikely, but check) */


@@ -1094,13 +1118,13 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   if (!clr_used)
     clr_used = 256;
   if (clr_used > 256 || clr_used < 0) {
   if (!clr_used)
     clr_used = 256;
   if (clr_used > 256 || clr_used < 0) {

-    i_push_errorf(0, "out of range colors used (%d)", clr_used);
+    im_push_errorf(aIMCTX, 0, "out of range colors used (%d)", clr_used);

     return NULL;
   }
 
   base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE + clr_used * 4;
   if (offbits < base_offset) {
     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);
+    im_push_errorf(aIMCTX, 0, "image data offset too small (%ld)", offbits);

     return NULL;
   }
 
     return NULL;
   }
 


@@ -1117,7 +1141,7 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
        rare */
     char buffer;
     while (base_offset < offbits) {
        rare */
     char buffer;
     while (base_offset < offbits) {

-      if (ig->readcb(ig, &buffer, 1) != 1) {
+      if (i_io_read(ig, &buffer, 1) != 1) {

         i_img_destroy(im);
         i_push_error(0, "failed skipping to image data offset");
         return NULL;
         i_img_destroy(im);
         i_push_error(0, "failed skipping to image data offset");
         return NULL;


@@ -1130,7 +1154,7 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   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) {

-      if (ig->readcb(ig, line, line_size) != line_size) {
+      if (i_io_read(ig, line, line_size) != line_size) {

        myfree(line);
         if (allow_incomplete) {
           i_tags_setn(&im->tags, "i_incomplete", 1);
        myfree(line);
         if (allow_incomplete) {
           i_tags_setn(&im->tags, "i_incomplete", 1);


@@ -1157,7 +1181,7 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
     x = 0;
     while (1) {
       /* there's always at least 2 bytes in a sequence */
     x = 0;
     while (1) {
       /* there's always at least 2 bytes in a sequence */

-      if (ig->readcb(ig, packed, 2) != 2) {
+      if (i_io_read(ig, packed, 2) != 2) {

         myfree(line);
         if (allow_incomplete) {
           i_tags_setn(&im->tags, "i_incomplete", 1);
         myfree(line);
         if (allow_incomplete) {
           i_tags_setn(&im->tags, "i_incomplete", 1);


@@ -1193,7 +1217,7 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
           return im;
 
         case BMPRLE_DELTA:
           return im;
 
         case BMPRLE_DELTA:

-          if (ig->readcb(ig, packed, 2) != 2) {
+          if (i_io_read(ig, packed, 2) != 2) {

             myfree(line);
             if (allow_incomplete) {
               i_tags_setn(&im->tags, "i_incomplete", 1);
             myfree(line);
             if (allow_incomplete) {
               i_tags_setn(&im->tags, "i_incomplete", 1);


@@ -1221,7 +1245,7 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
            return NULL;
          }
           read_size = (count+1) / 2 * 2;
            return NULL;
          }
           read_size = (count+1) / 2 * 2;

-          if (ig->readcb(ig, line, read_size) != read_size) {
+          if (i_io_read(ig, line, read_size) != read_size) {

             myfree(line);
             if (allow_incomplete) {
               i_tags_setn(&im->tags, "i_incomplete", 1);
             myfree(line);
             if (allow_incomplete) {
               i_tags_setn(&im->tags, "i_incomplete", 1);


@@ -1243,7 +1267,7 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
   }
   else { 
     myfree(line);
   }
   else { 
     myfree(line);

-    i_push_errorf(0, "unknown 8-bit BMP compression (%d)", compression);
+    im_push_errorf(aIMCTX, 0, "unknown 8-bit BMP compression (%d)", compression);

     i_img_destroy(im);
     return NULL;
   }
     i_img_destroy(im);
     return NULL;
   }


@@ -1254,23 +1278,42 @@ read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
 struct bm_masks {
   unsigned masks[3];
   int shifts[3];
 struct bm_masks {
   unsigned masks[3];
   int shifts[3];

+  int bits[3];

 };
 static struct bm_masks std_masks[] =
 {
   { /* 16-bit */
 };
 static struct bm_masks std_masks[] =
 {
   { /* 16-bit */

-    { 0770000, 00007700, 00000077, },
-    { 10, 4, -2, },
+    { 0076000, 00001740, 00000037, },
+    { 10, 5, 0, },
+    { 5, 5, 5, }

   },
   { /* 24-bit */
     { 0xFF0000, 0x00FF00, 0x0000FF, },
     {       16,        8,        0, },
   },
   { /* 24-bit */
     { 0xFF0000, 0x00FF00, 0x0000FF, },
     {       16,        8,        0, },

+    {        8,        8,        8, },

   },
   { /* 32-bit */
     { 0xFF0000, 0x00FF00, 0x0000FF, },
     {       16,        8,        0, },
   },
   { /* 32-bit */
     { 0xFF0000, 0x00FF00, 0x0000FF, },
     {       16,        8,        0, },

+    {        8,        8,        8, },

   },
 };
 
   },
 };
 

+/* multiplier and shift for converting from N bits to 8 bits */
+struct bm_sampconverts {
+  int mult;
+  int shift;
+};
+static struct bm_sampconverts samp_converts[] = {
+  { 0xff, 0 }, /* 1 bit samples */
+  { 0x55, 0 },
+  { 0111, 1 },
+  { 0x11, 0 },
+  { 0x21, 2 },
+  { 0x41, 4 },
+  { 0x81, 6 }  /* 7 bit samples */
+};
+

 /*
 =item read_direct_bmp(ig, xsize, ysize, bit_count, clr_used, compression, allow_incomplete)
 
 /*
 =item read_direct_bmp(ig, xsize, ysize, bit_count, clr_used, compression, allow_incomplete)
 


@@ -1297,6 +1340,7 @@ read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
   const char *compression_name;
   int bytes;
   long base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE;
   const char *compression_name;
   int bytes;
   long base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE;

+  dIMCTXio(ig);

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


@@ -1324,7 +1368,7 @@ read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
     /* there's a potential "palette" after the header */
     for (i = 0; i < clr_used; ++clr_used) {
       char buf[4];
     /* there's a potential "palette" after the header */
     for (i = 0; i < clr_used; ++clr_used) {
       char buf[4];

-      if (ig->readcb(ig, buf, 4) != 4) {
+      if (i_io_read(ig, buf, 4) != 4) {

         i_push_error(0, "skipping colors");
         return 0;
       }
         i_push_error(0, "skipping colors");
         return 0;
       }


@@ -1332,7 +1376,8 @@ read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
     }
   }
   else if (compression == BI_BITFIELDS) {
     }
   }
   else if (compression == BI_BITFIELDS) {

-    int pos, bit;
+    int pos;
+    unsigned bits;

     compression_name = "BI_BITFIELDS";
 
     for (i = 0; i < 3; ++i) {
     compression_name = "BI_BITFIELDS";
 
     for (i = 0; i < 3; ++i) {


@@ -1341,25 +1386,37 @@ read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
         i_push_error(0, "reading pixel masks");
         return 0;
       }
         i_push_error(0, "reading pixel masks");
         return 0;
       }

+      if (rmask == 0) {
+       im_push_errorf(aIMCTX, 0, "Zero mask for channel %d", i);
+       return NULL;
+      }

       masks.masks[i] = rmask;
       /* work out a shift for the mask */
       pos = 0;
       masks.masks[i] = rmask;
       /* work out a shift for the mask */
       pos = 0;

-      bit = masks.masks[i] & -masks.masks[i];
-      while (bit) {
+      bits = masks.masks[i];
+      while (!(bits & 1)) {

         ++pos;
         ++pos;

-        bit >>= 1;
+        bits >>= 1;

       }
       }

-      masks.shifts[i] = pos - 8;
+      masks.shifts[i] = pos;
+      pos = 0;
+      while (bits & 1) {
+       ++pos;
+       bits >>= 1;
+      }
+      masks.bits[i] = pos;
+      /*fprintf(stderr, "%d: mask %08x shift %d bits %d\n", i, masks.masks[i], masks.shifts[i], masks.bits[i]);*/

     }
     }

-    base_offset += 4 * 4;
+    /* account for the masks */
+    base_offset += 3 * 4;

   }
   else {
   }
   else {

-    i_push_errorf(0, "unknown 24-bit BMP compression (%d)", compression);
+    im_push_errorf(aIMCTX, 0, "unknown 24-bit BMP compression (%d)", compression);

     return NULL;
   }
 
   if (offbits < base_offset) {
     return NULL;
   }
 
   if (offbits < base_offset) {

-    i_push_errorf(0, "image data offset too small (%ld)", offbits);
+    im_push_errorf(aIMCTX, 0, "image data offset too small (%ld)", offbits);

     return NULL;
   }
 
     return NULL;
   }
 


@@ -1368,7 +1425,7 @@ read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
        rare */
     char buffer;
     while (base_offset < offbits) {
        rare */
     char buffer;
     while (base_offset < offbits) {

-      if (ig->readcb(ig, &buffer, 1) != 1) {
+      if (i_io_read(ig, &buffer, 1) != 1) {

         i_push_error(0, "failed skipping to image data offset");
         return NULL;
       }
         i_push_error(0, "failed skipping to image data offset");
         return NULL;
       }


@@ -1409,16 +1466,21 @@ read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
         }
       }
       for (i = 0; i < 3; ++i) {
         }
       }
       for (i = 0; i < 3; ++i) {

-        if (masks.shifts[i] > 0)
-          p->channel[i] = (pixel & masks.masks[i]) >> masks.shifts[i];
-        else 
-          p->channel[i] = (pixel & masks.masks[i]) << -masks.shifts[i];
+       int sample = (pixel & masks.masks[i]) >> masks.shifts[i];
+       int bits = masks.bits[i];
+       if (bits < 8) {
+         sample = (sample * samp_converts[bits-1].mult) >> samp_converts[bits-1].shift;
+       }
+       else if (bits) {
+         sample >>= bits - 8;
+       }
+       p->channel[i] = sample;

       }
       ++p;
     }
     i_plin(im, 0, xsize, y, line);
     if (extras)
       }
       ++p;
     }
     i_plin(im, 0, xsize, y, line);
     if (extras)

-      ig->readcb(ig, junk, extras);
+      i_io_read(ig, junk, extras);

     y += yinc;
   }
   myfree(line);
     y += yinc;
   }
   myfree(line);