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