bmp.c

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