bmp.c

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