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 (idstring) {
 724     i_tags_add(&img->tags, "tga_idstring", 0, idstring, header.idlength, 0);
 725     myfree(idstring);
 726   }
 727
 728   if (mapped &&
 729       !tga_palette_read(ig,
 730                         img,
 731                         bpp_to_bytes(header.colourmapdepth),
 732                         header.colourmaplength)
 733       ) {
 734     i_push_error(0, "Targa Image has none of 15/16/24/32 pixel layout");
 735     if (idstring) myfree(idstring);
 736     if (img) i_img_destroy(img);
 737     return NULL;
 738   }
 739
 740   /* Allocate buffers */
 741   databuf = mymalloc(width*src.bytepp);
 742   if (!mapped) linebuf = mymalloc(width*sizeof(i_color));
 743
 744   for(y=0; y<height; y++) {
 745     if (!tga_source_read(&src, databuf, width)) {
 746       i_push_error(errno, "read for targa data failed");
 747       myfree(databuf);
 748       if (img) i_img_destroy(img);
 749       return NULL;
 750     }
 751     if (mapped && header.colourmaporigin) for(x=0; x<width; x++) databuf[x] -= header.colourmaporigin;
 752     if (mapped) i_ppal(img, 0, width, header.imagedescriptor & (1<<5) ? y : height-1-y, databuf);
 753     else {
 754       for(x=0; x<width; x++) color_unpack(databuf+x*src.bytepp, src.bytepp, linebuf+x);
 755       i_plin(img, 0, width, header.imagedescriptor & (1<<5) ? y : height-1-y, linebuf);
 756     }
 757   }
 758   myfree(databuf);
 759   if (linebuf) myfree(linebuf);
 760
 761   i_tags_addn(&img->tags, "tga_bitspp", 0, mapped?header.colourmapdepth:header.bitsperpixel);
 762   if (src.compressed) i_tags_addn(&img->tags, "compressed", 0, 1);
 763   return img;
 764 }
 765
 766
 767
 768 /*
 769 =item i_writetga_wiol(img, ig)
 770
 771 Writes an image in targa format.  Returns 0 on error.
 772
 773    img    - image to store
 774    ig     - io_glue object
 775
 776 =cut
 777 */
 778
 779 undef_int
 780 i_writetga_wiol(i_img *img, io_glue *ig, int wierdpack, int compress, char *idstring, size_t idlen) {
 781   static int rgb_chan[] = { 2, 1, 0, 3 };
 782   tga_header header;
 783   tga_dest dest;
 784   unsigned char headbuf[18];
 785   unsigned int bitspp;
 786
 787   int mapped;
 788
 789   /* parameters */
 790
 791   /*
 792     int compress = 1;
 793     char *idstring = "testing";
 794     int wierdpack = 0;
 795   */
 796
 797   idlen = strlen(idstring);
 798   mapped = img->type == i_palette_type;
 799
 800   mm_log((1,"i_writetga_wiol(img %p, ig %p, idstring %p, idlen %d, wierdpack %d, compress %d)\n",
 801           img, ig, idstring, idlen, wierdpack, compress));
 802   mm_log((1, "virtual %d, paletted %d\n", img->virtual, mapped));
 803   mm_log((1, "channels %d\n", img->channels));
 804
 805   i_clear_error();
 806
 807   switch (img->channels) {
 808   case 1:
 809     bitspp = 8;
 810     if (wierdpack) {
 811       mm_log((1,"wierdpack option ignored for 1 channel images\n"));
 812       wierdpack=0;
 813     }
 814     break;
 815   case 2:
 816     i_push_error(0, "Cannot store 2 channel image in targa format");
 817     return 0;
 818     break;
 819   case 3:
 820     bitspp = wierdpack ? 15 : 24;
 821     break;
 822   case 4:
 823     bitspp = wierdpack ? 16 : 32;
 824     break;
 825   default:
 826     i_push_error(0, "Targa only handles 1,3 and 4 channel images.");
 827     return 0;
 828   }
 829
 830   io_glue_commit_types(ig);
 831
 832   header.idlength;
 833   header.idlength = idlen;
 834   header.colourmaptype   = mapped ? 1 : 0;
 835   header.datatypecode    = mapped ? 1 : img->channels == 1 ? 3 : 2;
 836   header.datatypecode   += compress ? 8 : 0;
 837   mm_log((1, "datatypecode %d\n", header.datatypecode));
 838   header.colourmaporigin = 0;
 839   header.colourmaplength = mapped ? i_colorcount(img) : 0;
 840   header.colourmapdepth  = mapped ? bitspp : 0;
 841   header.x_origin        = 0;
 842   header.y_origin        = 0;
 843   header.width           = img->xsize;
 844   header.height          = img->ysize;
 845   header.bitsperpixel    = mapped ? 8 : bitspp;
 846   header.imagedescriptor = (1<<5); /* normal order instead of upside down */
 847
 848   tga_header_pack(&header, headbuf);
 849
 850   if (ig->writecb(ig, &headbuf, sizeof(headbuf)) != sizeof(headbuf)) {
 851     i_push_error(errno, "could not write targa header");
 852     return 0;
 853   }
 854
 855   if (idlen) {
 856     if (ig->writecb(ig, idstring, idlen) != idlen) {
 857       i_push_error(errno, "could not write targa idstring");
 858       return 0;
 859     }
 860   }
 861
 862   /* Make this into a constructor? */
 863   dest.compressed = compress;
 864   dest.bytepp     = mapped ? 1 : bpp_to_bytes(bitspp);
 865   dest.ig         = ig;
 866
 867   mm_log((1, "dest.compressed = %d\n", dest.compressed));
 868   mm_log((1, "dest.bytepp = %d\n", dest.bytepp));
 869
 870   if (img->type == i_palette_type) {
 871     int i;
 872     int bytepp = bpp_to_bytes(bitspp);
 873     if (!tga_palette_write(ig, img, bitspp, i_colorcount(img))) return 0;
 874
 875     if (!img->virtual && !dest.compressed) {
 876       if (ig->writecb(ig, img->idata, img->bytes) != img->bytes) {
 877         i_push_error(errno, "could not write targa image data");
 878         return 0;
 879       }
 880     } else {
 881       int y;
 882       i_palidx *vals = mymalloc(sizeof(i_palidx)*img->xsize);
 883       for(y=0; y<img->ysize; y++) {
 884         i_gpal(img, 0, img->xsize, y, vals);
 885         tga_dest_write(&dest, vals, img->xsize);
 886       }
 887       myfree(vals);
 888     }
 889   } else { /* direct type */
 890     int x, y;
 891     int bytepp = wierdpack ? 2 : bpp_to_bytes(bitspp);
 892     int lsize = bytepp * img->xsize;
 893     i_color *vals = mymalloc(img->xsize*sizeof(i_color));
 894     unsigned char *buf = mymalloc(lsize);
 895
 896     for(y=0; y<img->ysize; y++) {
 897       i_glin(img, 0, img->xsize, y, vals);
 898       for(x=0; x<img->xsize; x++) color_pack(buf+x*bytepp, bitspp, vals+x);
 899       tga_dest_write(&dest, buf, img->xsize);
 900     }
 901     myfree(buf);
 902     myfree(vals);
 903   }
 904
 905   ig->closecb(ig);
 906
 907   return 1;
 908 }
 909
 910 /*
 911 =back
 912
 913 =head1 AUTHOR
 914
 915 Arnar M. Hrafnkelsson <addi@umich.edu>
 916
 917 =head1 SEE ALSO
 918
 919 Imager(3)
 920
 921 =cut
 922 */