edcef272fd7b085fbe030124aa257f7ab5e4e77f
[imager.git] / tga.c
1 #include "image.h"
2 #include "log.h"
3 #include "iolayer.h"
4
5 #include <stdlib.h>
6 #include <errno.h>
7
8
9 /*
10 =head1 NAME
11
12 tga.c - implements reading and writing targa files, uses io layer.
13
14 =head1 SYNOPSIS
15
16    io_glue *ig = io_new_fd( fd );
17    i_img *im   = i_readtga_wiol(ig, -1); // no limit on how much is read
18    // or 
19    io_glue *ig = io_new_fd( fd );
20    return_code = i_writetga_wiol(im, ig); 
21
22 =head1 DESCRIPTION
23
24 tga.c implements the basic functions to read and write portable targa
25 files.  It uses the iolayer and needs either a seekable source or an
26 entire memory mapped buffer.
27
28 =head1 FUNCTION REFERENCE
29
30 Some of these functions are internal.
31
32 =over
33
34 =cut
35 */
36
37
38
39
40 typedef struct {
41   char  idlength;
42   char  colourmaptype;
43   char  datatypecode;
44   short int colourmaporigin;
45   short int colourmaplength;
46   char  colourmapdepth;
47   short int x_origin;
48   short int y_origin;
49   short width;
50   short height;
51   char  bitsperpixel;
52   char  imagedescriptor;
53 } tga_header;
54
55
56 typedef enum { NoInit, Raw, Rle } rle_state;
57
58 typedef struct {
59   int compressed;
60   int bytepp;
61   rle_state state;
62   unsigned char cval[4];
63   int len;
64   unsigned char hdr;
65   io_glue *ig;
66 } tga_source;
67
68
69 typedef struct {
70   int compressed;
71   int bytepp;
72   io_glue *ig;
73 } tga_dest;
74
75
76
77 /*
78 =item bpp_to_bytes(bpp)
79
80 Convert bits per pixel into bytes per pixel
81
82    bpp - bits per pixel
83
84 =cut
85 */
86
87
88 static
89 int
90 bpp_to_bytes(unsigned int bpp) {
91   switch (bpp) {
92   case 8:
93     return 1;
94   case 15:
95   case 16:
96     return 2;
97   case 24:
98     return 3;
99   case 32:
100     return 4;
101   }
102   return 0;
103 }
104
105
106
107 /*
108 =item bpp_to_channels(bpp)
109
110 Convert bits per pixel into channels in the image
111
112    bpp - bits per pixel
113
114 =cut
115 */
116
117 static
118 int
119 bpp_to_channels(unsigned int bpp) {
120   switch (bpp) {
121   case 8:
122     return 1;
123   case 15:
124     return 3;
125   case 16:
126     return 4;
127   case 24:
128     return 3;
129   case 32:
130     return 4;
131   }
132   return 0;
133 }
134
135
136
137 /* 
138  * Packing functions - used for (un)packing
139  * datastructures into raw bytes.
140  */
141
142
143 /*
144 =item color_unpack(buf, bytepp, val)
145
146 Unpacks bytes into colour structures, for 2 byte type the first byte
147 coming from the file will actually be GGGBBBBB, and the second will be
148 ARRRRRGG.  "A" represents an attribute bit.  The 3 byte entry contains
149 1 byte each of blue, green, and red.  The 4 byte entry contains 1 byte
150 each of blue, green, red, and attribute.
151
152    buf - pointer to data
153    bytepp - bytes per pixel
154    val - pointer to color to store to
155
156 =cut
157 */
158
159 static
160 void
161 color_unpack(unsigned char *buf, int bytepp, i_color *val) {
162   switch (bytepp) {
163   case 1:
164     val->gray.gray_color = buf[0];
165     break;
166   case 2:
167     val->rgba.r = (buf[1] & 0x7c) << 1;
168     val->rgba.g = ((buf[1] & 0x03) << 6) | ((buf[0] & 0xe0) >> 2);
169     val->rgba.b = (buf[0] & 0x1f) << 3;
170     val->rgba.a = (buf[1] & 0x80) ? 255 : 0;
171     val->rgba.r |= val->rgba.r >> 5;
172     val->rgba.g |= val->rgba.g >> 5;
173     val->rgba.b |= val->rgba.b >> 5;
174     break;
175   case 3:
176     val->rgb.b = buf[0];
177     val->rgb.g = buf[1];
178     val->rgb.r = buf[2];
179     break;
180   case 4:
181     val->rgba.b = buf[0];
182     val->rgba.g = buf[1];
183     val->rgba.r = buf[2];
184     val->rgba.a = buf[3];
185     break;
186   }
187 }
188
189
190
191 /*
192 =item color_pack
193
194 Packs a colour into an array of bytes, for 2 byte type the first byte
195 will be GGGBBBBB, and the second will be ARRRRRGG.  "A" represents an
196 attribute bit.  The 3 byte entry contains 1 byte each of blue, green,
197 and red.  The 4 byte entry contains 1 byte each of blue, green, red,
198 and attribute.
199
200     buf - destination buffer
201     bitspp - bits per pixel
202     val - color to pack
203
204 =cut
205 */
206
207 static
208 void
209 color_pack(unsigned char *buf, int bitspp, i_color *val) {
210   switch (bitspp) {
211   case 8:
212     buf[0] = val->gray.gray_color;
213     break;
214   case 15:
215     buf[0]  = (val->rgba.b >> 3);
216     buf[0] |= (val->rgba.g & 0x38) << 2;
217     buf[1]  = (val->rgba.r & 0xf8)>> 1;
218     buf[1] |= (val->rgba.g >> 6);
219   case 16:
220     buf[1] |=  val->rgba.a & 0x80;
221     break;
222   case 24:
223     buf[0] = val->rgb.b;
224     buf[1] = val->rgb.g;
225     buf[2] = val->rgb.r;
226     break;
227   case 32:
228     buf[0] = val->rgba.b;
229     buf[1] = val->rgba.g;
230     buf[2] = val->rgba.r;
231     buf[3] = val->rgba.a;
232     break;
233   }
234 }
235
236
237 /*
238 =item find_repeat
239
240 Helper function for rle compressor to find the next triple repeat of the 
241 same pixel value in buffer.
242
243     buf - buffer
244     length - number of pixel values in buffer
245     bytepp - number of bytes in a pixel value
246
247 =cut
248 */
249
250 static
251 int
252 find_repeat(unsigned char *buf, int length, int bytepp) {
253   int i = 0;
254   
255   while(i<length-1) {
256     if(memcmp(buf+i*bytepp, buf+(i+1)*bytepp, bytepp) == 0) {
257       if (i == length-2) return -1;
258       if (memcmp(buf+(i+1)*bytepp, buf+(i+2)*bytepp,bytepp) == 0)  
259         return i;
260       else i++;
261     }
262     i++;
263   }
264   return -1;
265 }
266
267
268 /*
269 =item find_span
270
271 Helper function for rle compressor to find the length of a span where
272 the same pixel value is in the buffer.
273
274     buf - buffer
275     length - number of pixel values in buffer
276     bytepp - number of bytes in a pixel value
277
278 =cut
279 */
280
281 static
282 int
283 find_span(unsigned char *buf, int length, int bytepp) {
284   int i = 0;
285   while(i<length) {
286     if(memcmp(buf, buf+(i*bytepp), bytepp) != 0) return i;
287     i++;
288   }
289   return length;
290 }
291
292
293 /*
294 =item tga_header_unpack(header, headbuf)
295
296 Unpacks the header structure into from buffer and stores
297 in the header structure.
298
299     header - header structure
300     headbuf - buffer to unpack from
301
302 =cut
303 */
304
305 static
306 void
307 tga_header_unpack(tga_header *header, unsigned char headbuf[18]) {
308   header->idlength        = headbuf[0];
309   header->colourmaptype   = headbuf[1];
310   header->datatypecode    = headbuf[2];
311   header->colourmaporigin = (headbuf[4] << 8) + headbuf[3];
312   header->colourmaplength = (headbuf[6] << 8) + headbuf[5];
313   header->colourmapdepth  = headbuf[7];
314   header->x_origin        = (headbuf[9] << 8) + headbuf[8];
315   header->y_origin        = (headbuf[11] << 8) + headbuf[10];
316   header->width           = (headbuf[13] << 8) + headbuf[12];
317   header->height          = (headbuf[15] << 8) + headbuf[14];
318   header->bitsperpixel    = headbuf[16];
319   header->imagedescriptor = headbuf[17];
320 }
321
322
323
324 int
325 tga_header_verify(unsigned char headbuf[18]) {
326   tga_header header;
327   tga_header_unpack(&header, headbuf);
328   switch (header.datatypecode) { 
329   default:
330                 printf("bad typecode!\n");
331     return 0;
332   case 0:
333   case 1:  /* Uncompressed, color-mapped images */ 
334   case 2:  /* Uncompressed, rgb images          */ 
335   case 3:  /* Uncompressed, grayscale images    */ 
336   case 9:  /* Compressed,   color-mapped images */ 
337   case 10: /* Compressed,   rgb images          */ 
338   case 11: /* Compressed,   grayscale images    */ 
339           break;
340         }
341
342   switch (header.colourmaptype) { 
343   default:
344                 printf("bad colourmaptype!\n");
345     return 0;
346   case 0:
347   case 1:
348         break;
349         }
350   
351   return 1;
352 }
353
354
355 /*
356 =item tga_header_pack(header, headbuf)
357
358 Packs header structure into buffer for writing.
359
360     header - header structure
361     headbuf - buffer to pack into
362
363 =cut
364 */
365
366 static
367 void
368 tga_header_pack(tga_header *header, unsigned char headbuf[18]) {
369   headbuf[0] = header->idlength;
370   headbuf[1] = header->colourmaptype;
371   headbuf[2] = header->datatypecode;
372   headbuf[3] = header->colourmaporigin & 0xff;
373   headbuf[4] = header->colourmaporigin >> 8;
374   headbuf[5] = header->colourmaplength & 0xff;
375   headbuf[6] = header->colourmaplength >> 8;
376   headbuf[7] = header->colourmapdepth;
377   headbuf[8] = header->x_origin & 0xff;
378   headbuf[9] = header->x_origin >> 8;
379   headbuf[10] = header->y_origin & 0xff;
380   headbuf[11] = header->y_origin >> 8;
381   headbuf[12] = header->width & 0xff;
382   headbuf[13] = header->width >> 8;
383   headbuf[14] = header->height & 0xff;
384   headbuf[15] = header->height >> 8;
385   headbuf[16] = header->bitsperpixel;
386   headbuf[17] = header->imagedescriptor;
387 }
388
389
390 /*
391 =item tga_source_read(s, buf, pixels)
392
393 Reads pixel number of pixels from source s into buffer buf.  Takes
394 care of decompressing the stream if needed.
395
396     s - data source 
397     buf - destination buffer
398     pixels - number of pixels to put into buffer
399
400 =cut
401 */
402
403 static
404 int
405 tga_source_read(tga_source *s, unsigned char *buf, size_t pixels) {
406   int cp = 0, j, k;
407   if (!s->compressed) {
408     if (s->ig->readcb(s->ig, buf, pixels*s->bytepp) != pixels*s->bytepp) return 0;
409     return 1;
410   }
411   
412   while(cp < pixels) {
413     int ml;
414     if (s->len == 0) s->state = NoInit;
415     switch (s->state) {
416     case NoInit:
417       if (s->ig->readcb(s->ig, &s->hdr, 1) != 1) return 0;
418
419       s->len = (s->hdr &~(1<<7))+1;
420       s->state = (s->hdr & (1<<7)) ? Rle : Raw;
421       {
422 /*
423         static cnt = 0;
424         printf("%04d %s: %d\n", cnt++, s->state==Rle?"RLE":"RAW", s->len);
425  */
426      }
427       if (s->state == Rle && s->ig->readcb(s->ig, s->cval, s->bytepp) != s->bytepp) return 0;
428
429       break;
430     case Rle:
431       ml = i_min(s->len, pixels-cp);
432       for(k=0; k<ml; k++) for(j=0; j<s->bytepp; j++) 
433         buf[(cp+k)*s->bytepp+j] = s->cval[j];
434       cp     += ml;
435       s->len -= ml;
436       break;
437     case Raw:
438       ml = i_min(s->len, pixels-cp);
439       if (s->ig->readcb(s->ig, buf+cp*s->bytepp, ml*s->bytepp) != ml*s->bytepp) return 0;
440       cp     += ml;
441       s->len -= ml;
442       break;
443     }
444   }
445   return 1;
446 }
447
448
449
450
451 /*
452 =item tga_dest_write(s, buf, pixels)
453
454 Writes pixels from buf to destination s.  Takes care of compressing if the
455 destination is compressed.
456
457     s - data destination
458     buf - source buffer
459     pixels - number of pixels to put write to destination
460
461 =cut
462 */
463
464 static
465 int
466 tga_dest_write(tga_dest *s, unsigned char *buf, size_t pixels) {
467   int cp = 0, j, k;
468
469   if (!s->compressed) {
470     if (s->ig->writecb(s->ig, buf, pixels*s->bytepp) != pixels*s->bytepp) return 0;
471     return 1;
472   }
473   
474   while(cp < pixels) {
475     int tlen;
476     int nxtrip = find_repeat(buf+cp*s->bytepp, pixels-cp, s->bytepp);
477     tlen = (nxtrip == -1) ? pixels-cp : nxtrip;
478     while(tlen) {
479       unsigned char clen = (tlen>128) ? 128 : tlen;
480       clen--;
481       if (s->ig->writecb(s->ig, &clen, 1) != 1) return 0;
482       clen++;
483       if (s->ig->writecb(s->ig, buf+cp*s->bytepp, clen*s->bytepp) != clen*s->bytepp) return 0;
484       tlen -= clen;
485       cp += clen;
486     }
487     if (cp >= pixels) break;
488     tlen = find_span(buf+cp*s->bytepp, pixels-cp, s->bytepp);
489     if (tlen <3) continue;
490     while (tlen) {
491       unsigned char clen = (tlen>128) ? 128 : tlen;
492       clen = (clen - 1) | 0x80;
493       if (s->ig->writecb(s->ig, &clen, 1) != 1) return 0;
494       clen = (clen & ~0x80) + 1;
495       if (s->ig->writecb(s->ig, buf+cp*s->bytepp, s->bytepp) != s->bytepp) return 0;
496       tlen -= clen;
497       cp += clen;
498     }
499   }
500   return 1;
501 }
502
503
504
505
506
507
508 /*
509 =item tga_palette_read(ig, img, bytepp, colourmaplength)
510
511 Reads the colormap from a tga file and stores in the paletted image
512 structure.
513
514     ig - iolayer data source
515     img - image structure
516     bytepp - bytes per pixel
517     colourmaplength - number of colours in colourmap
518
519 =cut
520 */
521
522 static
523 int
524 tga_palette_read(io_glue *ig, i_img *img, int bytepp, int colourmaplength) {
525   int i;
526   size_t palbsize;
527   unsigned char *palbuf;
528   i_color val;
529
530   palbsize = colourmaplength*bytepp;
531   palbuf   = mymalloc(palbsize);
532   
533   if (ig->readcb(ig, palbuf, palbsize) != palbsize) {
534     i_push_error(errno, "could not read targa colourmap");
535     return 0;
536   }
537   
538   /* populate the palette of the new image */
539   for(i=0; i<colourmaplength; i++) {
540     color_unpack(palbuf+i*bytepp, bytepp, &val);
541     i_addcolors(img, &val, 1);
542   }
543   myfree(palbuf);
544   return 1;
545 }
546
547
548 /*
549 =item tga_palette_write(ig, img, bitspp, colourmaplength)
550
551 Stores the colormap of an image in the destination ig.
552
553     ig - iolayer data source
554     img - image structure
555     bitspp - bits per pixel in colourmap
556     colourmaplength - number of colours in colourmap
557
558 =cut
559 */
560
561 static
562 int
563 tga_palette_write(io_glue *ig, i_img *img, int bitspp, int colourmaplength) {
564   int i;
565   int bytepp = bpp_to_bytes(bitspp);
566   size_t palbsize = i_colorcount(img)*bytepp;
567   unsigned char *palbuf = mymalloc(palbsize);
568   
569   for(i=0; i<colourmaplength; i++) {
570     i_color val;
571     i_getcolors(img, i, &val, 1);
572     color_pack(palbuf+i*bytepp, bitspp, &val);
573   }
574   
575   if (ig->writecb(ig, palbuf, palbsize) != palbsize) {
576     i_push_error(errno, "could not write targa colourmap");
577     return 0;
578   }
579   myfree(palbuf);
580   return 1;
581 }
582
583
584
585 /*
586 =item i_readtga_wiol(ig, length)
587
588 Read in an image from the iolayer data source and return the image structure to it.
589 Returns NULL on error.
590
591    ig     - io_glue object
592    length - maximum length to read from data source, before closing it -1 
593             signifies no limit.
594
595 =cut
596 */
597
598 i_img *
599 i_readtga_wiol(io_glue *ig, int length) {
600   i_img* img = NULL;
601   int x, y, i;
602   int width, height, channels;
603   int mapped;
604   char *idstring = NULL;
605
606   tga_source src;
607   tga_header header;
608   unsigned char headbuf[18];
609   unsigned char *databuf;
610   unsigned char *reorderbuf;
611
612   i_color *linebuf = NULL;
613   i_clear_error();
614
615   mm_log((1,"i_readtga(ig %p, length %d)\n", ig, length));
616   
617   io_glue_commit_types(ig);
618
619   if (ig->readcb(ig, &headbuf, 18) != 18) {
620     i_push_error(errno, "could not read targa header");
621     return NULL;
622   }
623
624   tga_header_unpack(&header, headbuf);
625
626   mm_log((1,"Id length:         %d\n",header.idlength));
627   mm_log((1,"Colour map type:   %d\n",header.colourmaptype));
628   mm_log((1,"Image type:        %d\n",header.datatypecode));
629   mm_log((1,"Colour map offset: %d\n",header.colourmaporigin));
630   mm_log((1,"Colour map length: %d\n",header.colourmaplength));
631   mm_log((1,"Colour map depth:  %d\n",header.colourmapdepth));
632   mm_log((1,"X origin:          %d\n",header.x_origin));
633   mm_log((1,"Y origin:          %d\n",header.y_origin));
634   mm_log((1,"Width:             %d\n",header.width));
635   mm_log((1,"Height:            %d\n",header.height));
636   mm_log((1,"Bits per pixel:    %d\n",header.bitsperpixel));
637   mm_log((1,"Descriptor:        %d\n",header.imagedescriptor));
638
639   if (header.idlength) {
640     idstring = mymalloc(header.idlength+1);
641     if (ig->readcb(ig, idstring, header.idlength) != header.idlength) {
642       i_push_error(errno, "short read on targa idstring");
643       return NULL;
644     }
645   }
646
647   width = header.width;
648   height = header.height;
649   
650   /* Set tags here */
651   
652   switch (header.datatypecode) {
653   case 0: /* No data in image */
654     i_push_error(0, "Targa image contains no image data");
655     if (idstring) myfree(idstring);
656     return NULL;
657     break;
658   case 1:  /* Uncompressed, color-mapped images */
659   case 9:  /* Compressed,   color-mapped images */
660   case 3:  /* Uncompressed, grayscale images    */
661   case 11: /* Compressed,   grayscale images    */
662     if (header.bitsperpixel != 8) {
663       i_push_error(0, "Targa: mapped/grayscale image's bpp is not 8, unsupported.");
664       if (idstring) myfree(idstring);
665       return NULL;
666     }
667     src.bytepp = 1;
668     break;
669   case 2:  /* Uncompressed, rgb images          */
670   case 10: /* Compressed,   rgb images          */
671     if ((src.bytepp = bpp_to_bytes(header.bitsperpixel)))
672       break;
673     i_push_error(0, "Targa: direct color image's bpp is not 15/16/24/32 - unsupported.");
674     if (idstring) myfree(idstring);
675     return NULL;
676     break;
677   case 32: /* Compressed color-mapped, Huffman, Delta and runlength */
678   case 33: /* Compressed color-mapped, Huffman, Delta and runlength */
679     i_push_error(0, "Unsupported Targa (Huffman/delta/rle/quadtree) subformat is not supported");
680     if (idstring) myfree(idstring);
681     return NULL;
682     break;
683   default: /* All others which we don't know which might be */
684     i_push_error(0, "Unknown targa format");
685     if (idstring) myfree(idstring);
686     return NULL;
687     break;
688   }
689   
690   src.state = NoInit;
691   src.len = 0;
692   src.ig = ig;
693   src.compressed = !!(header.datatypecode & (1<<3));
694
695   /* Determine number of channels */
696   
697   mapped = 1;
698   switch (header.datatypecode) {
699     int tbpp;
700   case 2:  /* Uncompressed, rgb images          */
701   case 10: /* Compressed,   rgb images          */
702     mapped = 0;
703   case 1:  /* Uncompressed, color-mapped images */
704   case 9:  /* Compressed,   color-mapped images */
705     if ((channels = bpp_to_channels(mapped ? 
706                                    header.colourmapdepth : 
707                                    header.bitsperpixel))) break;
708     i_push_error(0, "Targa Image has none of 15/16/24/32 pixel layout");
709     if (idstring) myfree(idstring);
710     return NULL;
711     break;
712   case 3:  /* Uncompressed, grayscale images    */
713   case 11: /* Compressed,   grayscale images    */
714     mapped = 0;
715     channels = 1;
716     break;
717   }
718   
719   img = mapped ? 
720     i_img_pal_new(width, height, channels, 256) :
721     i_img_empty_ch(NULL, width, height, channels);
722
723   if (!img) {
724     if (idstring) 
725       myfree(idstring);
726     return NULL;
727   }
728   
729   if (idstring) {
730     i_tags_add(&img->tags, "tga_idstring", 0, idstring, header.idlength, 0);
731     myfree(idstring);
732   }
733
734   if (mapped &&
735       !tga_palette_read(ig,
736                         img,
737                         bpp_to_bytes(header.colourmapdepth),
738                         header.colourmaplength)
739       ) {
740     i_push_error(0, "Targa Image has none of 15/16/24/32 pixel layout");
741     if (idstring) myfree(idstring);
742     if (img) i_img_destroy(img);
743     return NULL;
744   }
745   
746   /* Allocate buffers */
747   databuf = mymalloc(width*src.bytepp);
748   if (!mapped) linebuf = mymalloc(width*sizeof(i_color));
749   
750   for(y=0; y<height; y++) {
751     if (!tga_source_read(&src, databuf, width)) {
752       i_push_error(errno, "read for targa data failed");
753       myfree(databuf);
754       if (img) i_img_destroy(img);
755       return NULL;
756     }
757     if (mapped && header.colourmaporigin) for(x=0; x<width; x++) databuf[x] -= header.colourmaporigin;
758     if (mapped) i_ppal(img, 0, width, header.imagedescriptor & (1<<5) ? y : height-1-y, databuf);
759     else {
760       for(x=0; x<width; x++) color_unpack(databuf+x*src.bytepp, src.bytepp, linebuf+x);
761       i_plin(img, 0, width, header.imagedescriptor & (1<<5) ? y : height-1-y, linebuf);
762     }
763   }
764   myfree(databuf);
765   if (linebuf) myfree(linebuf);
766   
767   i_tags_add(&img->tags, "i_format", 0, "tga", -1, 0);
768   i_tags_addn(&img->tags, "tga_bitspp", 0, mapped?header.colourmapdepth:header.bitsperpixel);
769   if (src.compressed) i_tags_addn(&img->tags, "compressed", 0, 1);
770   return img;
771 }
772
773
774
775 /*
776 =item i_writetga_wiol(img, ig)
777
778 Writes an image in targa format.  Returns 0 on error.
779
780    img    - image to store
781    ig     - io_glue object
782
783 =cut
784 */
785
786 undef_int
787 i_writetga_wiol(i_img *img, io_glue *ig, int wierdpack, int compress, char *idstring, size_t idlen) {
788   static int rgb_chan[] = { 2, 1, 0, 3 };
789   tga_header header;
790   tga_dest dest;
791   unsigned char headbuf[18];
792   unsigned int bitspp;
793   
794   int mapped;
795
796   /* parameters */
797
798   /*
799     int compress = 1;
800     char *idstring = "testing";
801     int wierdpack = 0;
802   */
803
804   idlen = strlen(idstring);
805   mapped = img->type == i_palette_type;
806
807   mm_log((1,"i_writetga_wiol(img %p, ig %p, idstring %p, idlen %d, wierdpack %d, compress %d)\n",
808           img, ig, idstring, idlen, wierdpack, compress));
809   mm_log((1, "virtual %d, paletted %d\n", img->virtual, mapped));
810   mm_log((1, "channels %d\n", img->channels));
811   
812   i_clear_error();
813   
814   switch (img->channels) {
815   case 1:
816     bitspp = 8;
817     if (wierdpack) {
818       mm_log((1,"wierdpack option ignored for 1 channel images\n"));
819       wierdpack=0;
820     }
821     break;
822   case 2:
823     i_push_error(0, "Cannot store 2 channel image in targa format");
824     return 0;
825     break;
826   case 3:
827     bitspp = wierdpack ? 15 : 24;
828     break;
829   case 4:
830     bitspp = wierdpack ? 16 : 32;
831     break;
832   default:
833     i_push_error(0, "Targa only handles 1,3 and 4 channel images.");
834     return 0;
835   }
836
837   io_glue_commit_types(ig);
838   
839   header.idlength;
840   header.idlength = idlen;
841   header.colourmaptype   = mapped ? 1 : 0;
842   header.datatypecode    = mapped ? 1 : img->channels == 1 ? 3 : 2;
843   header.datatypecode   += compress ? 8 : 0;
844   mm_log((1, "datatypecode %d\n", header.datatypecode));
845   header.colourmaporigin = 0;
846   header.colourmaplength = mapped ? i_colorcount(img) : 0;
847   header.colourmapdepth  = mapped ? bitspp : 0;
848   header.x_origin        = 0;
849   header.y_origin        = 0;
850   header.width           = img->xsize;
851   header.height          = img->ysize;
852   header.bitsperpixel    = mapped ? 8 : bitspp;
853   header.imagedescriptor = (1<<5); /* normal order instead of upside down */
854
855   tga_header_pack(&header, headbuf);
856
857   if (ig->writecb(ig, &headbuf, sizeof(headbuf)) != sizeof(headbuf)) {
858     i_push_error(errno, "could not write targa header");
859     return 0;
860   }
861
862   if (idlen) {
863     if (ig->writecb(ig, idstring, idlen) != idlen) {
864       i_push_error(errno, "could not write targa idstring");
865       return 0;
866     }
867   }
868   
869   /* Make this into a constructor? */
870   dest.compressed = compress;
871   dest.bytepp     = mapped ? 1 : bpp_to_bytes(bitspp);
872   dest.ig         = ig;
873
874   mm_log((1, "dest.compressed = %d\n", dest.compressed));
875   mm_log((1, "dest.bytepp = %d\n", dest.bytepp));
876
877   if (img->type == i_palette_type) {
878     int i;
879     int bytepp = bpp_to_bytes(bitspp);
880     if (!tga_palette_write(ig, img, bitspp, i_colorcount(img))) return 0;
881     
882     if (!img->virtual && !dest.compressed) {
883       if (ig->writecb(ig, img->idata, img->bytes) != img->bytes) {
884         i_push_error(errno, "could not write targa image data");
885         return 0;
886       }
887     } else {
888       int y;
889       i_palidx *vals = mymalloc(sizeof(i_palidx)*img->xsize);
890       for(y=0; y<img->ysize; y++) {
891         i_gpal(img, 0, img->xsize, y, vals);
892         tga_dest_write(&dest, vals, img->xsize);
893       }
894       myfree(vals);
895     }
896   } else { /* direct type */
897     int x, y;
898     int bytepp = wierdpack ? 2 : bpp_to_bytes(bitspp);
899     int lsize = bytepp * img->xsize;
900     i_color *vals = mymalloc(img->xsize*sizeof(i_color));
901     unsigned char *buf = mymalloc(lsize);
902     
903     for(y=0; y<img->ysize; y++) {
904       i_glin(img, 0, img->xsize, y, vals);
905       for(x=0; x<img->xsize; x++) color_pack(buf+x*bytepp, bitspp, vals+x);
906       tga_dest_write(&dest, buf, img->xsize);
907     }
908     myfree(buf);
909     myfree(vals);
910   }
911
912   ig->closecb(ig);
913
914   return 1;
915 }
916
917 /*
918 =back
919
920 =head1 AUTHOR
921
922 Arnar M. Hrafnkelsson <addi@umich.edu>
923
924 =head1 SEE ALSO
925
926 Imager(3)
927
928 =cut
929 */