bmp.c

   1 #define IMAGER_NO_CONTEXT
   2 #include <stdarg.h>
   3 #include "imageri.h"
   4
   5 /*
   6 =head1 NAME
   7
   8 bmp.c - read and write windows BMP files
   9
  10 =head1 SYNOPSIS
  11
  12   i_img *im;
  13   io_glue *ig;
  14
  15   if (!i_writebmp_wiol(im, ig)) {
  16     ... error ...
  17   }
  18   im = i_readbmp(ig);
  19
  20 =head1 DESCRIPTION
  21
  22 Reads and writes Windows BMP files.
  23
  24 =over
  25
  26 =cut
  27 */
  28
  29 #define FILEHEAD_SIZE 14
  30 #define INFOHEAD_SIZE 40
  31 #define BI_RGB          0
  32 #define BI_RLE8         1
  33 #define BI_RLE4         2
  34 #define BI_BITFIELDS    3
  35 #define BMPRLE_ENDOFLINE 0
  36 #define BMPRLE_ENDOFBMP 1
  37 #define BMPRLE_DELTA 2
  38
  39 #define SIGNBIT32 ((i_upacked_t)1U << 31)
  40 #define SIGNBIT16 ((i_upacked_t)1U << 15)
  41
  42 #define SIGNMAX32 ((1UL << 31) - 1)
  43
  44 static int read_packed(io_glue *ig, char *format, ...);
  45 static int write_packed(io_glue *ig, char *format, ...);
  46 static int write_bmphead(io_glue *ig, i_img *im, int bit_count,
  47                          int data_size);
  48 static int write_1bit_data(io_glue *ig, i_img *im);
  49 static int write_4bit_data(io_glue *ig, i_img *im);
  50 static int write_8bit_data(io_glue *ig, i_img *im);
  51 static int write_24bit_data(io_glue *ig, i_img *im);
  52 static int read_bmp_pal(io_glue *ig, i_img *im, int count);
  53 static i_img *read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
  54                             int compression, long offbits, int allow_incomplete);
  55 static i_img *read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
  56                             int compression, long offbits, int allow_incomplete);
  57 static i_img *read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
  58                             int compression, long offbits, int allow_incomplete);
  59 static i_img *read_direct_bmp(io_glue *ig, int xsize, int ysize,
  60                               int bit_count, int clr_used, int compression,
  61                               long offbits, int allow_incomplete);
  62
  63 /* used for the read_packed() and write_packed() functions, an integer
  64  * type */
  65 typedef long i_packed_t;
  66 typedef unsigned long i_upacked_t;
  67
  68 /*
  69 =item i_writebmp_wiol(im, io_glue)
  70
  71 Writes the image as a BMP file.  Uses 1-bit, 4-bit, 8-bit or 24-bit
  72 formats depending on the image.
  73
  74 Never compresses the image.
  75
  76 =cut
  77 */
  78 int
  79 i_writebmp_wiol(i_img *im, io_glue *ig) {
  80   dIMCTXim(im);
  81   i_clear_error();
  82
  83   /* pick a format */
  84   if (im->type == i_direct_type) {
  85     return write_24bit_data(ig, im);
  86   }
  87   else {
  88     int pal_size;
  89
  90     /* must be paletted */
  91     pal_size = i_colorcount(im);
  92     if (pal_size <= 2) {
  93       return write_1bit_data(ig, im);
  94     }
  95     else if (pal_size <= 16) {
  96       return write_4bit_data(ig, im);
  97     }
  98     else {
  99       return write_8bit_data(ig, im);
 100     }
 101   }
 102 }
 103
 104 /*
 105 =item i_readbmp_wiol(ig)
 106
 107 Reads a Windows format bitmap from the given file.
 108
 109 Handles BI_RLE4 and BI_RLE8 compressed images.  Attempts to handle
 110 BI_BITFIELDS images too, but I need a test image.
 111
 112 =cut
 113 */
 114
 115 i_img *
 116 i_readbmp_wiol(io_glue *ig, int allow_incomplete) {
 117   i_packed_t b_magic, m_magic, filesize, res1, res2, infohead_size;
 118   i_packed_t xsize, ysize, planes, bit_count, compression, size_image, xres, yres;
 119   i_packed_t clr_used, clr_important, offbits;
 120   i_img *im;
 121   dIMCTXio(ig);
 122
 123   im_log((aIMCTX, 1, "i_readbmp_wiol(ig %p)\n", ig));
 124
 125   i_clear_error();
 126
 127   if (!read_packed(ig, "CCVvvVVV!V!vvVVVVVV", &b_magic, &m_magic, &filesize,
 128                    &res1, &res2, &offbits, &infohead_size,
 129                    &xsize, &ysize, &planes,
 130                    &bit_count, &compression, &size_image, &xres, &yres,
 131                    &clr_used, &clr_important)) {
 132     i_push_error(0, "file too short to be a BMP file");
 133     return 0;
 134   }
 135   if (b_magic != 'B' || m_magic != 'M' || infohead_size != INFOHEAD_SIZE
 136       || planes != 1) {
 137     i_push_error(0, "not a BMP file");
 138     return 0;
 139   }
 140
 141   im_log((aIMCTX, 1, " bmp header: filesize %d offbits %d xsize %d ysize %d planes %d "
 142           "bit_count %d compression %d size %d xres %d yres %d clr_used %d "
 143           "clr_important %d\n", (int)filesize, (int)offbits, (int)xsize,
 144           (int)ysize, (int)planes, (int)bit_count, (int)compression,
 145           (int)size_image, (int)xres, (int)yres, (int)clr_used,
 146           (int)clr_important));
 147
 148   if (!i_int_check_image_file_limits(xsize, abs(ysize), 3, sizeof(i_sample_t))) {
 149     im_log((aIMCTX, 1, "i_readbmp_wiol: image size exceeds limits\n"));
 150     return NULL;
 151   }
 152
 153   switch (bit_count) {
 154   case 1:
 155     im = read_1bit_bmp(ig, xsize, ysize, clr_used, compression, offbits,
 156                        allow_incomplete);
 157     break;
 158
 159   case 4:
 160     im = read_4bit_bmp(ig, xsize, ysize, clr_used, compression, offbits,
 161                        allow_incomplete);
 162     break;
 163
 164   case 8:
 165     im = read_8bit_bmp(ig, xsize, ysize, clr_used, compression, offbits,
 166                        allow_incomplete);
 167     break;
 168
 169   case 32:
 170   case 24:
 171   case 16:
 172     im = read_direct_bmp(ig, xsize, ysize, bit_count, clr_used, compression,
 173                          offbits, allow_incomplete);
 174     break;
 175
 176   default:
 177     im_push_errorf(aIMCTX, 0, "unknown bit count for BMP file (%d)", (int)bit_count);
 178     return NULL;
 179   }
 180
 181   if (im) {
 182     /* store the resolution */
 183     if (xres && !yres)
 184       yres = xres;
 185     else if (yres && !xres)
 186       xres = yres;
 187     if (xres) {
 188       i_tags_set_float2(&im->tags, "i_xres", 0, xres * 0.0254, 4);
 189       i_tags_set_float2(&im->tags, "i_yres", 0, yres * 0.0254, 4);
 190     }
 191     i_tags_addn(&im->tags, "bmp_compression", 0, compression);
 192     i_tags_addn(&im->tags, "bmp_important_colors", 0, clr_important);
 193     i_tags_addn(&im->tags, "bmp_used_colors", 0, clr_used);
 194     i_tags_addn(&im->tags, "bmp_filesize", 0, filesize);
 195     i_tags_addn(&im->tags, "bmp_bit_count", 0, bit_count);
 196     i_tags_add(&im->tags, "i_format", 0, "bmp", 3, 0);
 197   }
 198
 199   return im;
 200 }
 201
 202 /*
 203 =back
 204
 205 =head1 IMPLEMENTATION FUNCTIONS
 206
 207 Internal functions used in the implementation.
 208
 209 =over
 210
 211 =item read_packed(ig, format, ...)
 212
 213 Reads from the specified "file" the specified sizes.  The format codes
 214 match those used by perl's pack() function, though only a few are
 215 implemented.  In all cases the vararg arguement is an int *.
 216
 217 Returns non-zero if all of the arguments were read.
 218
 219 =cut
 220 */
 221 static int
 222 read_packed(io_glue *ig, char *format, ...) {
 223   unsigned char buf[4];
 224   va_list ap;
 225   i_packed_t *p;
 226   i_packed_t work;
 227   int code;
 228   int shrieking; /* format code has a ! flag */
 229
 230   va_start(ap, format);
 231
 232   while (*format) {
 233     p = va_arg(ap, i_packed_t *);
 234
 235     code = *format++;
 236     shrieking = *format == '!';
 237     if (shrieking) ++format;
 238
 239     switch (code) {
 240     case 'v':
 241       if (i_io_read(ig, buf, 2) != 2)
 242         goto fail;
 243       work = buf[0] + ((i_packed_t)buf[1] << 8);
 244       if (shrieking)
 245         *p = (work ^ SIGNBIT16) - SIGNBIT16;
 246       else
 247         *p = work;
 248       break;
 249
 250     case 'V':
 251       if (i_io_read(ig, buf, 4) != 4)
 252         goto fail;
 253       work = buf[0] + (buf[1] << 8) + ((i_packed_t)buf[2] << 16) + ((i_packed_t)buf[3] << 24);
 254       if (shrieking)
 255         *p = (work ^ SIGNBIT32) - SIGNBIT32;
 256       else
 257         *p = work;
 258       break;
 259
 260     case 'C':
 261       if (i_io_read(ig, buf, 1) != 1)
 262         goto fail;
 263       *p = buf[0];
 264       break;
 265
 266     case 'c':
 267       if (i_io_read(ig, buf, 1) != 1)
 268         goto fail;
 269       *p = (char)buf[0];
 270       break;
 271
 272     case '3': /* extension - 24-bit number */
 273       if (i_io_read(ig, buf, 3) != 3)
 274         goto fail;
 275       *p = buf[0] + (buf[1] << 8) + ((i_packed_t)buf[2] << 16);
 276       break;
 277
 278     default:
 279       {
 280         dIMCTXio(ig);
 281         im_fatal(aIMCTX, 1, "Unknown read_packed format code 0x%02x", code);
 282       }
 283     }
 284   }
 285   va_end(ap);
 286   return 1;
 287
 288  fail:
 289   va_end(ap);
 290   return 0;
 291 }
 292
 293 /*
 294 =item write_packed(ig, format, ...)
 295
 296 Writes packed data to the specified io_glue.
 297
 298 Returns non-zero on success.
 299
 300 =cut
 301 */
 302
 303 static int
 304 write_packed(io_glue *ig, char *format, ...) {
 305   unsigned char buf[4];
 306   va_list ap;
 307   int i;
 308
 309   va_start(ap, format);
 310
 311   while (*format) {
 312     i = va_arg(ap, i_upacked_t);
 313
 314     switch (*format) {
 315     case 'v':
 316       buf[0] = i & 255;
 317       buf[1] = i / 256;
 318       if (i_io_write(ig, buf, 2) == -1)
 319         goto fail;
 320       break;
 321
 322     case 'V':
 323       buf[0] = i & 0xFF;
 324       buf[1] = (i >> 8) & 0xFF;
 325       buf[2] = (i >> 16) & 0xFF;
 326       buf[3] = (i >> 24) & 0xFF;
 327       if (i_io_write(ig, buf, 4) == -1)
 328         goto fail;
 329       break;
 330
 331     case 'C':
 332     case 'c':
 333       buf[0] = i & 0xFF;
 334       if (i_io_write(ig, buf, 1) == -1)
 335         goto fail;
 336       break;
 337
 338     default:
 339       {
 340         dIMCTXio(ig);
 341         im_fatal(aIMCTX, 1, "Unknown write_packed format code 0x%02x", *format);
 342       }
 343     }
 344     ++format;
 345   }
 346   va_end(ap);
 347
 348   return 1;
 349
 350  fail:
 351   va_end(ap);
 352   return 0;
 353 }
 354
 355 /*
 356 =item write_bmphead(ig, im, bit_count, data_size)
 357
 358 Writes a Windows BMP header to the file.
 359
 360 Returns non-zero on success.
 361
 362 =cut
 363 */
 364
 365 static
 366 int write_bmphead(io_glue *ig, i_img *im, int bit_count, int data_size) {
 367   double xres, yres;
 368   int got_xres, got_yres, aspect_only;
 369   int colors_used = 0;
 370   int offset = FILEHEAD_SIZE + INFOHEAD_SIZE;
 371   dIMCTXim(im);
 372
 373   if (im->xsize > SIGNMAX32 || im->ysize > SIGNMAX32) {
 374     i_push_error(0, "image too large to write to BMP");
 375     return 0;
 376   }
 377
 378   got_xres = i_tags_get_float(&im->tags, "i_xres", 0, &xres);
 379   got_yres = i_tags_get_float(&im->tags, "i_yres", 0, &yres);
 380   if (!i_tags_get_int(&im->tags, "i_aspect_only", 0,&aspect_only))
 381     aspect_only = 0;
 382   if (!got_xres) {
 383     if (!got_yres)
 384       xres = yres = 72;
 385     else
 386       xres = yres;
 387   }
 388   else {
 389     if (!got_yres)
 390       yres = xres;
 391   }
 392   if (xres <= 0 || yres <= 0)
 393     xres = yres = 72;
 394   if (aspect_only) {
 395     /* scale so the smaller value is 72 */
 396     double ratio;
 397     if (xres < yres) {
 398       ratio = 72.0 / xres;
 399     }
 400     else {
 401       ratio = 72.0 / yres;
 402     }
 403     xres *= ratio;
 404     yres *= ratio;
 405   }
 406   /* now to pels/meter */
 407   xres *= 100.0/2.54;
 408   yres *= 100.0/2.54;
 409
 410   if (im->type == i_palette_type) {
 411     colors_used = i_colorcount(im);
 412     offset += 4 * colors_used;
 413   }
 414
 415   if (!write_packed(ig, "CCVvvVVVVvvVVVVVV", 'B', 'M',
 416                     (i_upacked_t)(data_size+offset),
 417                     (i_upacked_t)0, (i_upacked_t)0, (i_upacked_t)offset,
 418                     (i_upacked_t)INFOHEAD_SIZE, (i_upacked_t)im->xsize,
 419                     (i_upacked_t)im->ysize, (i_upacked_t)1,
 420                     (i_upacked_t)bit_count, (i_upacked_t)BI_RGB,
 421                     (i_upacked_t)data_size,
 422                     (i_upacked_t)(xres+0.5), (i_upacked_t)(yres+0.5),
 423                     (i_upacked_t)colors_used, (i_upacked_t)colors_used)){
 424     i_push_error(0, "cannot write bmp header");
 425     return 0;
 426   }
 427   if (im->type == i_palette_type) {
 428     int i;
 429     i_color c;
 430
 431     for (i = 0; i < colors_used; ++i) {
 432       i_getcolors(im, i, &c, 1);
 433       if (im->channels >= 3) {
 434         if (!write_packed(ig, "CCCC", (i_upacked_t)(c.channel[2]),
 435                           (i_upacked_t)(c.channel[1]),
 436                           (i_upacked_t)(c.channel[0]), (i_upacked_t)0)) {
 437           i_push_error(0, "cannot write palette entry");
 438           return 0;
 439         }
 440       }
 441       else {
 442         i_upacked_t v = c.channel[0];
 443         if (!write_packed(ig, "CCCC", v, v, v, 0)) {
 444           i_push_error(0, "cannot write palette entry");
 445           return 0;
 446         }
 447       }
 448     }
 449   }
 450
 451   return 1;
 452 }
 453
 454 /*
 455 =item write_1bit_data(ig, im)
 456
 457 Writes the image data as a 1-bit/pixel image.
 458
 459 Returns non-zero on success.
 460
 461 =cut
 462 */
 463 static int
 464 write_1bit_data(io_glue *ig, i_img *im) {
 465   i_palidx *line;
 466   unsigned char *packed;
 467   int byte;
 468   int mask;
 469   unsigned char *out;
 470   int line_size = (im->xsize+7) / 8;
 471   int x, y;
 472   int unpacked_size;
 473   dIMCTXim(im);
 474
 475   /* round up to nearest multiple of four */
 476   line_size = (line_size + 3) / 4 * 4;
 477
 478   if (!write_bmphead(ig, im, 1, line_size * im->ysize))
 479     return 0;
 480
 481   /* this shouldn't be an issue, but let's be careful */
 482   unpacked_size = im->xsize + 8;
 483   if (unpacked_size < im->xsize) {
 484     i_push_error(0, "integer overflow during memory allocation");
 485     return 0;
 486   }
 487   line = mymalloc(unpacked_size); /* checked 29jun05 tonyc */
 488   memset(line + im->xsize, 0, 8);
 489
 490   /* size allocated here is always much smaller than xsize, hence
 491      can't overflow int */
 492   packed = mymalloc(line_size); /* checked 29jun05 tonyc */
 493   memset(packed, 0, line_size);
 494
 495   for (y = im->ysize-1; y >= 0; --y) {
 496     i_gpal(im, 0, im->xsize, y, line);
 497     mask = 0x80;
 498     byte = 0;
 499     out = packed;
 500     for (x = 0; x < im->xsize; ++x) {
 501       if (line[x])
 502         byte |= mask;
 503       if ((mask >>= 1) == 0) {
 504         *out++ = byte;
 505         byte = 0;
 506         mask = 0x80;
 507       }
 508     }
 509     if (mask != 0x80) {
 510       *out++ = byte;
 511     }
 512     if (i_io_write(ig, packed, line_size) < 0) {
 513       myfree(packed);
 514       myfree(line);
 515       i_push_error(0, "writing 1 bit/pixel packed data");
 516       return 0;
 517     }
 518   }
 519   myfree(packed);
 520   myfree(line);
 521
 522   if (i_io_close(ig))
 523     return 0;
 524
 525   return 1;
 526 }
 527
 528 /*
 529 =item write_4bit_data(ig, im)
 530
 531 Writes the image data as a 4-bit/pixel image.
 532
 533 Returns non-zero on success.
 534
 535 =cut
 536 */
 537 static int
 538 write_4bit_data(io_glue *ig, i_img *im) {
 539   i_palidx *line;
 540   unsigned char *packed;
 541   unsigned char *out;
 542   int line_size = (im->xsize+1) / 2;
 543   int x, y;
 544   int unpacked_size;
 545   dIMCTXim(im);
 546
 547   /* round up to nearest multiple of four */
 548   line_size = (line_size + 3) / 4 * 4;
 549
 550   if (!write_bmphead(ig, im, 4, line_size * im->ysize))
 551     return 0;
 552
 553   /* this shouldn't be an issue, but let's be careful */
 554   unpacked_size = im->xsize + 2;
 555   if (unpacked_size < im->xsize) {
 556     i_push_error(0, "integer overflow during memory allocation");
 557     return 0;
 558   }
 559   line = mymalloc(unpacked_size); /* checked 29jun05 tonyc */
 560   memset(line + im->xsize, 0, 2);
 561
 562   /* size allocated here is always much smaller than xsize, hence
 563      can't overflow int */
 564   packed = mymalloc(line_size); /* checked 29jun05 tonyc */
 565   memset(packed, 0, line_size);
 566
 567   for (y = im->ysize-1; y >= 0; --y) {
 568     i_gpal(im, 0, im->xsize, y, line);
 569     out = packed;
 570     for (x = 0; x < im->xsize; x += 2) {
 571       *out++ = (line[x] << 4) + line[x+1];
 572     }
 573     if (i_io_write(ig, packed, line_size) < 0) {
 574       myfree(packed);
 575       myfree(line);
 576       i_push_error(0, "writing 4 bit/pixel packed data");
 577       return 0;
 578     }
 579   }
 580   myfree(packed);
 581   myfree(line);
 582
 583   if (i_io_close(ig))
 584     return 0;
 585
 586   return 1;
 587 }
 588
 589 /*
 590 =item write_8bit_data(ig, im)
 591
 592 Writes the image data as a 8-bit/pixel image.
 593
 594 Returns non-zero on success.
 595
 596 =cut
 597 */
 598 static int
 599 write_8bit_data(io_glue *ig, i_img *im) {
 600   i_palidx *line;
 601   int line_size = im->xsize;
 602   int y;
 603   int unpacked_size;
 604   dIMCTXim(im);
 605
 606   /* round up to nearest multiple of four */
 607   line_size = (line_size + 3) / 4 * 4;
 608
 609   if (!write_bmphead(ig, im, 8, line_size * im->ysize))
 610     return 0;
 611
 612   /* this shouldn't be an issue, but let's be careful */
 613   unpacked_size = im->xsize + 4;
 614   if (unpacked_size < im->xsize) {
 615     i_push_error(0, "integer overflow during memory allocation");
 616     return 0;
 617   }
 618   line = mymalloc(unpacked_size); /* checked 29jun05 tonyc */
 619   memset(line + im->xsize, 0, 4);
 620
 621   for (y = im->ysize-1; y >= 0; --y) {
 622     i_gpal(im, 0, im->xsize, y, line);
 623     if (i_io_write(ig, line, line_size) < 0) {
 624       myfree(line);
 625       i_push_error(0, "writing 8 bit/pixel packed data");
 626       return 0;
 627     }
 628   }
 629   myfree(line);
 630
 631   if (i_io_close(ig))
 632     return 0;
 633
 634   return 1;
 635 }
 636
 637 /*
 638 =item write_24bit_data(ig, im)
 639
 640 Writes the image data as a 24-bit/pixel image.
 641
 642 Returns non-zero on success.
 643
 644 =cut
 645 */
 646 static int
 647 write_24bit_data(io_glue *ig, i_img *im) {
 648   unsigned char *samples;
 649   int y;
 650   int line_size = 3 * im->xsize;
 651   i_color bg;
 652   dIMCTXim(im);
 653
 654   i_get_file_background(im, &bg);
 655
 656   /* just in case we implement a direct format with 2bytes/pixel
 657      (unlikely though) */
 658   if (line_size / 3 != im->xsize) {
 659     i_push_error(0, "integer overflow during memory allocation");
 660     return 0;
 661   }
 662
 663   line_size = (line_size + 3) / 4 * 4;
 664
 665   if (!write_bmphead(ig, im, 24, line_size * im->ysize))
 666     return 0;
 667   samples = mymalloc(4 * im->xsize);
 668   memset(samples, 0, line_size);
 669   for (y = im->ysize-1; y >= 0; --y) {
 670     unsigned char *samplep = samples;
 671     int x;
 672     i_gsamp_bg(im, 0, im->xsize, y, samples, 3, &bg);
 673     for (x = 0; x < im->xsize; ++x) {
 674       unsigned char tmp = samplep[2];
 675       samplep[2] = samplep[0];
 676       samplep[0] = tmp;
 677       samplep += 3;
 678     }
 679     if (i_io_write(ig, samples, line_size) < 0) {
 680       i_push_error(0, "writing image data");
 681       myfree(samples);
 682       return 0;
 683     }
 684   }
 685   myfree(samples);
 686
 687   if (i_io_close(ig))
 688     return 0;
 689
 690   return 1;
 691 }
 692
 693 /*
 694 =item read_bmp_pal(ig, im, count)
 695
 696 Reads count palette entries from the file and add them to the image.
 697
 698 Returns non-zero on success.
 699
 700 =cut
 701 */
 702 static int
 703 read_bmp_pal(io_glue *ig, i_img *im, int count) {
 704   int i;
 705   i_packed_t r, g, b, x;
 706   i_color c;
 707   dIMCTXio(ig);
 708
 709   for (i = 0; i < count; ++i) {
 710     if (!read_packed(ig, "CCCC", &b, &g, &r, &x)) {
 711       i_push_error(0, "reading BMP palette");
 712       return 0;
 713     }
 714     c.channel[0] = r;
 715     c.channel[1] = g;
 716     c.channel[2] = b;
 717     if (i_addcolors(im, &c, 1) < 0) {
 718       i_push_error(0, "out of space in image palette");
 719       return 0;
 720     }
 721   }
 722
 723   return 1;
 724 }
 725
 726 /*
 727 =item read_1bit_bmp(ig, xsize, ysize, clr_used, compression, offbits)
 728
 729 Reads in the palette and image data for a 1-bit/pixel image.
 730
 731 Returns the image or NULL.
 732
 733 =cut
 734 */
 735 static i_img *
 736 read_1bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
 737               int compression, long offbits, int allow_incomplete) {
 738   i_img *im;
 739   int x, y, lasty, yinc, start_y;
 740   i_palidx *line, *p;
 741   unsigned char *packed;
 742   int line_size = (xsize + 7)/8;
 743   int bit;
 744   unsigned char *in;
 745   long base_offset;
 746   dIMCTXio(ig);
 747
 748   if (compression != BI_RGB) {
 749     im_push_errorf(aIMCTX, 0, "unknown 1-bit BMP compression (%d)", compression);
 750     return NULL;
 751   }
 752
 753   if ((i_img_dim)((i_img_dim_u)xsize + 8) < xsize) { /* if there was overflow */
 754     /* we check with 8 because we allocate that much for the decoded
 755        line buffer */
 756     i_push_error(0, "integer overflow during memory allocation");
 757     return NULL;
 758   }
 759
 760   /* if xsize+7 is ok then (xsize+7)/8 will be and the minor
 761      adjustments below won't make it overflow */
 762   line_size = (line_size+3) / 4 * 4;
 763
 764   if (ysize > 0) {
 765     start_y = ysize-1;
 766     lasty = -1;
 767     yinc = -1;
 768   }
 769   else {
 770     /* when ysize is -ve it's a top-down image */
 771     ysize = -ysize;
 772     start_y = 0;
 773     lasty = ysize;
 774     yinc = 1;
 775   }
 776   y = start_y;
 777   if (!clr_used)
 778     clr_used = 2;
 779   if (clr_used < 0 || clr_used > 2) {
 780     im_push_errorf(aIMCTX, 0, "out of range colors used (%d)", clr_used);
 781     return NULL;
 782   }
 783
 784   base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE + clr_used * 4;
 785   if (offbits < base_offset) {
 786     im_push_errorf(aIMCTX, 0, "image data offset too small (%ld)", offbits);
 787     return NULL;
 788   }
 789
 790   im = i_img_pal_new(xsize, ysize, 3, 256);
 791   if (!im)
 792     return NULL;
 793   if (!read_bmp_pal(ig, im, clr_used)) {
 794     i_img_destroy(im);
 795     return NULL;
 796   }
 797
 798   if (offbits > base_offset) {
 799     /* this will be slow if the offset is large, but that should be
 800        rare */
 801     char buffer;
 802     while (base_offset < offbits) {
 803       if (i_io_read(ig, &buffer, 1) != 1) {
 804         i_img_destroy(im);
 805         i_push_error(0, "failed skipping to image data offset");
 806         return NULL;
 807       }
 808       ++base_offset;
 809     }
 810   }
 811
 812   i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
 813
 814   packed = mymalloc(line_size); /* checked 29jun05 tonyc */
 815   line = mymalloc(xsize+8); /* checked 29jun05 tonyc */
 816   while (y != lasty) {
 817     if (i_io_read(ig, packed, line_size) != line_size) {
 818       myfree(packed);
 819       myfree(line);
 820       if (allow_incomplete) {
 821         i_tags_setn(&im->tags, "i_incomplete", 1);
 822         i_tags_setn(&im->tags, "i_lines_read", abs(start_y - y));
 823         return im;
 824       }
 825       else {
 826         i_push_error(0, "failed reading 1-bit bmp data");
 827         i_img_destroy(im);
 828         return NULL;
 829       }
 830     }
 831     in = packed;
 832     bit = 0x80;
 833     p = line;
 834     for (x = 0; x < xsize; ++x) {
 835       *p++ = (*in & bit) ? 1 : 0;
 836       bit >>= 1;
 837       if (!bit) {
 838         ++in;
 839         bit = 0x80;
 840       }
 841     }
 842     i_ppal(im, 0, xsize, y, line);
 843     y += yinc;
 844   }
 845
 846   myfree(packed);
 847   myfree(line);
 848   return im;
 849 }
 850
 851 /*
 852 =item read_4bit_bmp(ig, xsize, ysize, clr_used, compression)
 853
 854 Reads in the palette and image data for a 4-bit/pixel image.
 855
 856 Returns the image or NULL.
 857
 858 Hopefully this will be combined with the following function at some
 859 point.
 860
 861 =cut
 862 */
 863 static i_img *
 864 read_4bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
 865               int compression, long offbits, int allow_incomplete) {
 866   i_img *im;
 867   int x, y, lasty, yinc;
 868   i_palidx *line, *p;
 869   unsigned char *packed;
 870   int line_size = (xsize + 1)/2;
 871   unsigned char *in;
 872   int size, i;
 873   long base_offset;
 874   int starty;
 875   dIMCTXio(ig);
 876
 877   /* line_size is going to be smaller than xsize in most cases (and
 878      when it's not, xsize is itself small), and hence not overflow */
 879   line_size = (line_size+3) / 4 * 4;
 880
 881   if (ysize > 0) {
 882     starty = ysize-1;
 883     lasty = -1;
 884     yinc = -1;
 885   }
 886   else {
 887     /* when ysize is -ve it's a top-down image */
 888     ysize = -ysize;
 889     starty = 0;
 890     lasty = ysize;
 891     yinc = 1;
 892   }
 893   y = starty;
 894   if (!clr_used)
 895     clr_used = 16;
 896
 897   if (clr_used > 16 || clr_used < 0) {
 898     im_push_errorf(aIMCTX, 0, "out of range colors used (%d)", clr_used);
 899     return NULL;
 900   }
 901
 902   base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE + clr_used * 4;
 903   if (offbits < base_offset) {
 904     im_push_errorf(aIMCTX, 0, "image data offset too small (%ld)", offbits);
 905     return NULL;
 906   }
 907
 908   im = i_img_pal_new(xsize, ysize, 3, 256);
 909   if (!im) /* error should have been pushed already */
 910     return NULL;
 911   if (!read_bmp_pal(ig, im, clr_used)) {
 912     i_img_destroy(im);
 913     return NULL;
 914   }
 915
 916   if (offbits > base_offset) {
 917     /* this will be slow if the offset is large, but that should be
 918        rare */
 919     char buffer;
 920     while (base_offset < offbits) {
 921       if (i_io_read(ig, &buffer, 1) != 1) {
 922         i_img_destroy(im);
 923         i_push_error(0, "failed skipping to image data offset");
 924         return NULL;
 925       }
 926       ++base_offset;
 927     }
 928   }
 929
 930   if (line_size < 260)
 931     packed = mymalloc(260); /* checked 29jun05 tonyc */
 932   else
 933     packed = mymalloc(line_size); /* checked 29jun05 tonyc */
 934   /* xsize won't approach MAXINT */
 935   line = mymalloc(xsize+1); /* checked 29jun05 tonyc */
 936   if (compression == BI_RGB) {
 937     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
 938     while (y != lasty) {
 939       if (i_io_read(ig, packed, line_size) != line_size) {
 940         myfree(packed);
 941         myfree(line);
 942         if (allow_incomplete) {
 943           i_tags_setn(&im->tags, "i_incomplete", 1);
 944           i_tags_setn(&im->tags, "i_lines_read", abs(y - starty));
 945           return im;
 946         }
 947         else {
 948           i_push_error(0, "failed reading 4-bit bmp data");
 949           i_img_destroy(im);
 950           return NULL;
 951         }
 952       }
 953       in = packed;
 954       p = line;
 955       for (x = 0; x < xsize; x+=2) {
 956         *p++ = *in >> 4;
 957         *p++ = *in & 0x0F;
 958         ++in;
 959       }
 960       i_ppal(im, 0, xsize, y, line);
 961       y += yinc;
 962     }
 963     myfree(packed);
 964     myfree(line);
 965   }
 966   else if (compression == BI_RLE4) {
 967     int read_size;
 968     int count;
 969     i_img_dim xlimit = (xsize + 1) / 2 * 2; /* rounded up */
 970
 971     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RLE4", -1, 0);
 972     x = 0;
 973     while (1) {
 974       /* there's always at least 2 bytes in a sequence */
 975       if (i_io_read(ig, packed, 2) != 2) {
 976         myfree(packed);
 977         myfree(line);
 978         if (allow_incomplete) {
 979           i_tags_setn(&im->tags, "i_incomplete", 1);
 980           i_tags_setn(&im->tags, "i_lines_read", abs(y - starty));
 981           return im;
 982         }
 983         else {
 984           i_push_error(0, "missing data during decompression");
 985           i_img_destroy(im);
 986           return NULL;
 987         }
 988       }
 989       else if (packed[0]) {
 990         int count = packed[0];
 991         if (x + count > xlimit) {
 992           /* this file is corrupt */
 993           myfree(packed);
 994           myfree(line);
 995           i_push_error(0, "invalid data during decompression");
 996           im_log((aIMCTX, 1, "read 4-bit: scanline overflow x %d + count %d vs xlimit %d (y %d)\n",
 997                   (int)x, count, (int)xlimit, (int)y));
 998           i_img_destroy(im);
 999           return NULL;
1000         }
1001         /* fill in the line */
1002         for (i = 0; i < count; i += 2)
1003           line[i] = packed[1] >> 4;
1004         for (i = 1; i < count; i += 2)
1005           line[i] = packed[1] & 0x0F;
1006         i_ppal(im, x, x+count, y, line);
1007         x += count;
1008       } else {
1009         switch (packed[1]) {
1010         case BMPRLE_ENDOFLINE:
1011           x = 0;
1012           y += yinc;
1013           break;
1014
1015         case BMPRLE_ENDOFBMP:
1016           myfree(packed);
1017           myfree(line);
1018           return im;
1019
1020         case BMPRLE_DELTA:
1021           if (i_io_read(ig, packed, 2) != 2) {
1022             myfree(packed);
1023             myfree(line);
1024             if (allow_incomplete) {
1025               i_tags_setn(&im->tags, "i_incomplete", 1);
1026               i_tags_setn(&im->tags, "i_lines_read", abs(y - starty));
1027               return im;
1028             }
1029             else {
1030               i_push_error(0, "missing data during decompression");
1031               i_img_destroy(im);
1032               return NULL;
1033             }
1034           }
1035           x += packed[0];
1036           y += yinc * packed[1];
1037           break;
1038
1039         default:
1040           count = packed[1];
1041           if (x + count > xlimit) {
1042             /* this file is corrupt */
1043             myfree(packed);
1044             myfree(line);
1045             i_push_error(0, "invalid data during decompression");
1046             im_log((aIMCTX, 1, "read 4-bit: scanline overflow (unpacked) x %d + count %d vs xlimit %d (y %d)\n",
1047                   (int)x, count, (int)xlimit, (int)y));
1048             i_img_destroy(im);
1049             return NULL;
1050           }
1051           size = (count + 1) / 2;
1052           read_size = (size+1) / 2 * 2;
1053           if (i_io_read(ig, packed, read_size) != read_size) {
1054             myfree(packed);
1055             myfree(line);
1056             if (allow_incomplete) {
1057               i_tags_setn(&im->tags, "i_incomplete", 1);
1058               i_tags_setn(&im->tags, "i_lines_read", abs(y - starty));
1059               return im;
1060             }
1061             else {
1062               i_push_error(0, "missing data during decompression");
1063               i_img_destroy(im);
1064               return NULL;
1065             }
1066           }
1067           for (i = 0; i < size; ++i) {
1068             line[0] = packed[i] >> 4;
1069             line[1] = packed[i] & 0xF;
1070             i_ppal(im, x, x+2, y, line);
1071             x += 2;
1072           }
1073           break;
1074         }
1075       }
1076     }
1077   }
1078   else { /*if (compression == BI_RLE4) {*/
1079     myfree(packed);
1080     myfree(line);
1081     im_push_errorf(aIMCTX, 0, "unknown 4-bit BMP compression (%d)", compression);
1082     i_img_destroy(im);
1083     return NULL;
1084   }
1085
1086   return im;
1087 }
1088
1089 /*
1090 =item read_8bit_bmp(ig, xsize, ysize, clr_used, compression, allow_incomplete)
1091
1092 Reads in the palette and image data for a 8-bit/pixel image.
1093
1094 Returns the image or NULL.
1095
1096 =cut
1097 */
1098 static i_img *
1099 read_8bit_bmp(io_glue *ig, int xsize, int ysize, int clr_used,
1100               int compression, long offbits, int allow_incomplete) {
1101   i_img *im;
1102   int x, y, lasty, yinc, start_y;
1103   i_palidx *line;
1104   int line_size = xsize;
1105   long base_offset;
1106   dIMCTXio(ig);
1107
1108   line_size = (line_size+3) / 4 * 4;
1109   if (line_size < xsize) { /* if it overflowed (unlikely, but check) */
1110     i_push_error(0, "integer overflow during memory allocation");
1111     return NULL;
1112   }
1113
1114   if (ysize > 0) {
1115     start_y = ysize-1;
1116     lasty = -1;
1117     yinc = -1;
1118   }
1119   else {
1120     /* when ysize is -ve it's a top-down image */
1121     ysize = -ysize;
1122     start_y = 0;
1123     lasty = ysize;
1124     yinc = 1;
1125   }
1126   y = start_y;
1127   if (!clr_used)
1128     clr_used = 256;
1129   if (clr_used > 256 || clr_used < 0) {
1130     im_push_errorf(aIMCTX, 0, "out of range colors used (%d)", clr_used);
1131     return NULL;
1132   }
1133
1134   base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE + clr_used * 4;
1135   if (offbits < base_offset) {
1136     im_push_errorf(aIMCTX, 0, "image data offset too small (%ld)", offbits);
1137     return NULL;
1138   }
1139
1140   im = i_img_pal_new(xsize, ysize, 3, 256);
1141   if (!im)
1142     return NULL;
1143   if (!read_bmp_pal(ig, im, clr_used)) {
1144     i_img_destroy(im);
1145     return NULL;
1146   }
1147
1148   if (offbits > base_offset) {
1149     /* this will be slow if the offset is large, but that should be
1150        rare */
1151     char buffer;
1152     while (base_offset < offbits) {
1153       if (i_io_read(ig, &buffer, 1) != 1) {
1154         i_img_destroy(im);
1155         i_push_error(0, "failed skipping to image data offset");
1156         return NULL;
1157       }
1158       ++base_offset;
1159     }
1160   }
1161
1162   line = mymalloc(line_size); /* checked 29jun05 tonyc */
1163   if (compression == BI_RGB) {
1164     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RGB", -1, 0);
1165     while (y != lasty) {
1166       if (i_io_read(ig, line, line_size) != line_size) {
1167         myfree(line);
1168         if (allow_incomplete) {
1169           i_tags_setn(&im->tags, "i_incomplete", 1);
1170           i_tags_setn(&im->tags, "i_lines_read", abs(start_y - y));
1171           return im;
1172         }
1173         else {
1174           i_push_error(0, "failed reading 8-bit bmp data");
1175           i_img_destroy(im);
1176           return NULL;
1177         }
1178       }
1179       i_ppal(im, 0, xsize, y, line);
1180       y += yinc;
1181     }
1182     myfree(line);
1183   }
1184   else if (compression == BI_RLE8) {
1185     int read_size;
1186     int count;
1187     unsigned char packed[2];
1188
1189     i_tags_add(&im->tags, "bmp_compression_name", 0, "BI_RLE8", -1, 0);
1190     x = 0;
1191     while (1) {
1192       /* there's always at least 2 bytes in a sequence */
1193       if (i_io_read(ig, packed, 2) != 2) {
1194         myfree(line);
1195         if (allow_incomplete) {
1196           i_tags_setn(&im->tags, "i_incomplete", 1);
1197           i_tags_setn(&im->tags, "i_lines_read", abs(start_y-y));
1198           return im;
1199         }
1200         else {
1201           i_push_error(0, "missing data during decompression");
1202           i_img_destroy(im);
1203           return NULL;
1204         }
1205       }
1206       if (packed[0]) {
1207         if (x + packed[0] > xsize) {
1208           /* this file isn't incomplete, it's corrupt */
1209           myfree(line);
1210           i_push_error(0, "invalid data during decompression");
1211           i_img_destroy(im);
1212           return NULL;
1213         }
1214         memset(line, packed[1], packed[0]);
1215         i_ppal(im, x, x+packed[0], y, line);
1216         x += packed[0];
1217       } else {
1218         switch (packed[1]) {
1219         case BMPRLE_ENDOFLINE:
1220           x = 0;
1221           y += yinc;
1222           break;
1223
1224         case BMPRLE_ENDOFBMP:
1225           myfree(line);
1226           return im;
1227
1228         case BMPRLE_DELTA:
1229           if (i_io_read(ig, packed, 2) != 2) {
1230             myfree(line);
1231             if (allow_incomplete) {
1232               i_tags_setn(&im->tags, "i_incomplete", 1);
1233               i_tags_setn(&im->tags, "i_lines_read", abs(start_y-y));
1234               return im;
1235             }
1236             else {
1237               i_push_error(0, "missing data during decompression");
1238               i_img_destroy(im);
1239               return NULL;
1240             }
1241           }
1242           x += packed[0];
1243           y += yinc * packed[1];
1244           break;
1245
1246         default:
1247           count = packed[1];
1248           if (x + count > xsize) {
1249             /* runs shouldn't cross a line boundary */
1250             /* this file isn't incomplete, it's corrupt */
1251             myfree(line);
1252             i_push_error(0, "invalid data during decompression");
1253             i_img_destroy(im);
1254             return NULL;
1255           }
1256           read_size = (count+1) / 2 * 2;
1257           if (i_io_read(ig, line, read_size) != read_size) {
1258             myfree(line);
1259             if (allow_incomplete) {
1260               i_tags_setn(&im->tags, "i_incomplete", 1);
1261               i_tags_setn(&im->tags, "i_lines_read", abs(start_y-y));
1262               return im;
1263             }
1264             else {
1265               i_push_error(0, "missing data during decompression");
1266               i_img_destroy(im);
1267               return NULL;
1268             }
1269           }
1270           i_ppal(im, x, x+count, y, line);
1271           x += count;
1272           break;
1273         }
1274       }
1275     }
1276   }
1277   else {
1278     myfree(line);
1279     im_push_errorf(aIMCTX, 0, "unknown 8-bit BMP compression (%d)", compression);
1280     i_img_destroy(im);
1281     return NULL;
1282   }
1283
1284   return im;
1285 }
1286
1287 struct bm_masks {
1288   unsigned masks[3];
1289   int shifts[3];
1290   int bits[3];
1291 };
1292 static struct bm_masks std_masks[] =
1293 {
1294   { /* 16-bit */
1295     { 0076000, 00001740, 00000037, },
1296     { 10, 5, 0, },
1297     { 5, 5, 5, }
1298   },
1299   { /* 24-bit */
1300     { 0xFF0000, 0x00FF00, 0x0000FF, },
1301     {       16,        8,        0, },
1302     {        8,        8,        8, },
1303   },
1304   { /* 32-bit */
1305     { 0xFF0000, 0x00FF00, 0x0000FF, },
1306     {       16,        8,        0, },
1307     {        8,        8,        8, },
1308   },
1309 };
1310
1311 /* multiplier and shift for converting from N bits to 8 bits */
1312 struct bm_sampconverts {
1313   int mult;
1314   int shift;
1315 };
1316 static struct bm_sampconverts samp_converts[] = {
1317   { 0xff, 0 }, /* 1 bit samples */
1318   { 0x55, 0 },
1319   { 0111, 1 },
1320   { 0x11, 0 },
1321   { 0x21, 2 },
1322   { 0x41, 4 },
1323   { 0x81, 6 }  /* 7 bit samples */
1324 };
1325
1326 /*
1327 =item read_direct_bmp(ig, xsize, ysize, bit_count, clr_used, compression, allow_incomplete)
1328
1329 Skips the palette and reads in the image data for a direct colour image.
1330
1331 Returns the image or NULL.
1332
1333 =cut
1334 */
1335 static i_img *
1336 read_direct_bmp(io_glue *ig, int xsize, int ysize, int bit_count,
1337                 int clr_used, int compression, long offbits,
1338                 int allow_incomplete) {
1339   i_img *im;
1340   int x, y, starty, lasty, yinc;
1341   i_color *line, *p;
1342   int pix_size = bit_count / 8;
1343   int line_size = xsize * pix_size;
1344   struct bm_masks masks;
1345   char unpack_code[2] = "";
1346   int i;
1347   int extras;
1348   char junk[4];
1349   const char *compression_name;
1350   int bytes;
1351   long base_offset = FILEHEAD_SIZE + INFOHEAD_SIZE;
1352   dIMCTXio(ig);
1353
1354   unpack_code[0] = *("v3V"+pix_size-2);
1355   unpack_code[1] = '\0';
1356
1357   line_size = (line_size+3) / 4 * 4;
1358   extras = line_size - xsize * pix_size;
1359
1360   if (ysize > 0) {
1361     starty = ysize-1;
1362     lasty = -1;
1363     yinc = -1;
1364   }
1365   else {
1366     /* when ysize is -ve it's a top-down image */
1367     ysize = -ysize;
1368     starty = 0;
1369     lasty = ysize;
1370     yinc = 1;
1371   }
1372   y = starty;
1373   if (compression == BI_RGB) {
1374     compression_name = "BI_RGB";
1375     masks = std_masks[pix_size-2];
1376
1377     /* there's a potential "palette" after the header */
1378     for (i = 0; i < clr_used; ++clr_used) {
1379       char buf[4];
1380       if (i_io_read(ig, buf, 4) != 4) {
1381         i_push_error(0, "skipping colors");
1382         return 0;
1383       }
1384       base_offset += 4;
1385     }
1386   }
1387   else if (compression == BI_BITFIELDS) {
1388     int pos;
1389     unsigned bits;
1390     compression_name = "BI_BITFIELDS";
1391
1392     for (i = 0; i < 3; ++i) {
1393       i_packed_t rmask;
1394       if (!read_packed(ig, "V", &rmask)) {
1395         i_push_error(0, "reading pixel masks");
1396         return 0;
1397       }
1398       if (rmask == 0) {
1399         im_push_errorf(aIMCTX, 0, "Zero mask for channel %d", i);
1400         return NULL;
1401       }
1402       masks.masks[i] = rmask;
1403       /* work out a shift for the mask */
1404       pos = 0;
1405       bits = masks.masks[i];
1406       while (!(bits & 1)) {
1407         ++pos;
1408         bits >>= 1;
1409       }
1410       masks.shifts[i] = pos;
1411       pos = 0;
1412       while (bits & 1) {
1413         ++pos;
1414         bits >>= 1;
1415       }
1416       masks.bits[i] = pos;
1417       /*fprintf(stderr, "%d: mask %08x shift %d bits %d\n", i, masks.masks[i], masks.shifts[i], masks.bits[i]);*/
1418     }
1419     /* account for the masks */
1420     base_offset += 3 * 4;
1421   }
1422   else {
1423     im_push_errorf(aIMCTX, 0, "unknown 24-bit BMP compression (%d)", compression);
1424     return NULL;
1425   }
1426
1427   if (offbits < base_offset) {
1428     im_push_errorf(aIMCTX, 0, "image data offset too small (%ld)", offbits);
1429     return NULL;
1430   }
1431
1432   if (offbits > base_offset) {
1433     /* this will be slow if the offset is large, but that should be
1434        rare */
1435     char buffer;
1436     while (base_offset < offbits) {
1437       if (i_io_read(ig, &buffer, 1) != 1) {
1438         i_push_error(0, "failed skipping to image data offset");
1439         return NULL;
1440       }
1441       ++base_offset;
1442     }
1443   }
1444
1445   im = i_img_empty(NULL, xsize, ysize);
1446   if (!im)
1447     return NULL;
1448
1449   i_tags_add(&im->tags, "bmp_compression_name", 0, compression_name, -1, 0);
1450
1451   /* I wasn't able to make this overflow in testing, but better to be
1452      safe */
1453   bytes = sizeof(i_color) * xsize;
1454   if (bytes / sizeof(i_color) != xsize) {
1455     i_img_destroy(im);
1456     i_push_error(0, "integer overflow calculating buffer size");
1457     return NULL;
1458   }
1459   line = mymalloc(bytes); /* checked 29jun05 tonyc */
1460   while (y != lasty) {
1461     p = line;
1462     for (x = 0; x < xsize; ++x) {
1463       i_packed_t pixel;
1464       if (!read_packed(ig, unpack_code, &pixel)) {
1465         myfree(line);
1466         if (allow_incomplete) {
1467           i_tags_setn(&im->tags, "i_incomplete", 1);
1468           i_tags_setn(&im->tags, "i_lines_read", abs(starty - y));
1469           return im;
1470         }
1471         else {
1472           i_push_error(0, "failed reading image data");
1473           i_img_destroy(im);
1474           return NULL;
1475         }
1476       }
1477       for (i = 0; i < 3; ++i) {
1478         int sample = (pixel & masks.masks[i]) >> masks.shifts[i];
1479         int bits = masks.bits[i];
1480         if (bits < 8) {
1481           sample = (sample * samp_converts[bits-1].mult) >> samp_converts[bits-1].shift;
1482         }
1483         else if (bits) {
1484           sample >>= bits - 8;
1485         }
1486         p->channel[i] = sample;
1487       }
1488       ++p;
1489     }
1490     i_plin(im, 0, xsize, y, line);
1491     if (extras)
1492       i_io_read(ig, junk, extras);
1493     y += yinc;
1494   }
1495   myfree(line);
1496
1497   return im;
1498 }
1499
1500 /*
1501 =head1 SEE ALSO
1502
1503 Imager(3)
1504
1505 =head1 AUTHOR
1506
1507 Tony Cook <tony@develop-help.com>
1508
1509 =head1 RESTRICTIONS
1510
1511 Cannot save as compressed BMP.
1512
1513 =head1 BUGS
1514
1515 Doesn't handle OS/2 bitmaps.
1516
1517 16-bit/pixel images haven't been tested.  (I need an image).
1518
1519 BI_BITFIELDS compression hasn't been tested (I need an image).
1520
1521 The header handling for paletted images needs to be refactored
1522
1523 =cut
1524 */