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