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