src/common/iffdecod.cpp

   1 //
   2 // iffdecod.cc  - image handler for IFF/ILBM images
   3 //        parts of the source are based on xviff by Thomas Meyer
   4 //        Permission for use in wxWindows has been gratefully given.
   5 //
   6 // (c) Steffen Gutmann, 2002
   7 //
   8 // Creation date: 08.01.2002
   9 // Last modified: 12.01.2002
  10 //
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "iffdecod.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #  pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #  include "wx/defs.h"
  25 #  include "wx/log.h"
  26 #endif
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include "wx/iffdecod.h"
  31
  32 #if wxUSE_STREAMS && wxUSE_IFF
  33
  34 //---------------------------------------------------------------------------
  35 // wxIFFDecoder constructor and destructor
  36 //---------------------------------------------------------------------------
  37
  38 wxIFFDecoder::wxIFFDecoder(wxInputStream *s)
  39 {
  40     m_f = s;
  41     m_image = 0;
  42     databuf = 0;
  43     decomp_mem = 0;
  44 }
  45
  46 void wxIFFDecoder::Destroy()
  47 {
  48     delete m_image;
  49     m_image = 0;
  50     delete [] databuf;
  51     databuf = 0;
  52     delete [] decomp_mem;
  53     decomp_mem = 0;
  54 }
  55
  56 //---------------------------------------------------------------------------
  57 // Convert this image to a wxImage object
  58 //---------------------------------------------------------------------------
  59
  60 // This function was designed by Vaclav Slavik
  61
  62 bool wxIFFDecoder::ConvertToImage(wxImage *image) const
  63 {
  64     // just in case...
  65     image->Destroy();
  66
  67     // create the image
  68     image->Create(GetWidth(), GetHeight());
  69
  70     if (!image->Ok())
  71         return FALSE;
  72
  73     unsigned char *pal = GetPalette();
  74     unsigned char *src = GetData();
  75     unsigned char *dst = image->GetData();
  76     int colors = GetNumColors();
  77     int transparent = GetTransparentColour();
  78     long i;
  79
  80     // set transparent colour mask
  81     if (transparent != -1)
  82     {
  83         for (i = 0; i < colors; i++)
  84         {
  85             if ((pal[3 * i + 0] == 255) &&
  86                 (pal[3 * i + 1] == 0) &&
  87                 (pal[3 * i + 2] == 255))
  88             {
  89                 pal[3 * i + 2] = 254;
  90             }
  91         }
  92
  93         pal[3 * transparent + 0] = 255,
  94         pal[3 * transparent + 1] = 0,
  95         pal[3 * transparent + 2] = 255;
  96
  97         image->SetMaskColour(255, 0, 255);
  98     }
  99     else
 100         image->SetMask(FALSE);
 101
 102 #if wxUSE_PALETTE
 103     if (pal && colors > 0)
 104     {
 105         unsigned char* r = new unsigned char[colors];
 106         unsigned char* g = new unsigned char[colors];
 107         unsigned char* b = new unsigned char[colors];
 108
 109         for (i = 0; i < colors; i++)
 110         {
 111             r[i] = pal[3*i + 0];
 112             g[i] = pal[3*i + 1];
 113             b[i] = pal[3*i + 2];
 114         }
 115
 116         image->SetPalette(wxPalette(colors, r, g, b));
 117
 118         delete [] r;
 119         delete [] g;
 120         delete [] b;
 121     }
 122 #endif // wxUSE_PALETTE
 123
 124     // copy image data
 125     for (i = 0; i < (long)(GetWidth() * GetHeight()); i++, src += 3, dst += 3)
 126     {
 127     dst[0] = src[0];
 128     dst[1] = src[1];
 129     dst[2] = src[2];
 130     }
 131
 132     return TRUE;
 133 }
 134
 135
 136 //---------------------------------------------------------------------------
 137 // Data accessors
 138 //---------------------------------------------------------------------------
 139
 140 // Get data for current frame
 141
 142 unsigned char* wxIFFDecoder::GetData() const    { return (m_image->p); }
 143 unsigned char* wxIFFDecoder::GetPalette() const { return (m_image->pal); }
 144 int wxIFFDecoder::GetNumColors() const          { return m_image->colors; }
 145 unsigned int wxIFFDecoder::GetWidth() const     { return (m_image->w); }
 146 unsigned int wxIFFDecoder::GetHeight() const    { return (m_image->h); }
 147 int wxIFFDecoder::GetTransparentColour() const { return m_image->transparent; }
 148
 149 //---------------------------------------------------------------------------
 150 // IFF reading and decoding
 151 //---------------------------------------------------------------------------
 152
 153 //
 154 // CanRead:
 155 //  Returns TRUE if the file looks like a valid IFF, FALSE otherwise.
 156 //
 157 bool wxIFFDecoder::CanRead()
 158 {
 159     unsigned char buf[12] = "";
 160
 161     m_f->Read(buf, 12);
 162     m_f->SeekI(-12, wxFromCurrent);
 163
 164     return (memcmp(buf, "FORM", 4) == 0 && memcmp(buf+8, "ILBM", 4) == 0);
 165 }
 166
 167
 168 // ReadIFF:
 169 // Based on xv source code by Thomas Meyer
 170 // Permission for use in wxWindows has been gratefully given.
 171
 172 typedef unsigned char byte;
 173 #define IFFDEBUG 0
 174
 175 /*************************************************************************
 176   void decomprle(source, destination, source length, buffer size)
 177
 178   Decompress run-length encoded data from source to destination. Terminates
 179   when source is decoded completely or destination buffer is full.
 180
 181   The decruncher is as optimized as I could make it, without risking
 182   safety in case of corrupt BODY chunks.
 183 **************************************************************************/
 184
 185 static void decomprle(const byte *sptr, byte *dptr, long slen, long dlen)
 186 {
 187     byte codeByte, dataByte;
 188
 189     while ((slen > 0) && (dlen > 0)) {
 190     // read control byte
 191     codeByte = *sptr++;
 192
 193     if (codeByte < 0x80) {
 194         codeByte++;
 195         if ((slen > (long) codeByte) && (dlen >= (long) codeByte)) {
 196         slen -= codeByte + 1;
 197         dlen -= codeByte;
 198         while (codeByte > 0) {
 199             *dptr++ = *sptr++;
 200             codeByte--;
 201         }
 202         }
 203         else slen = 0;
 204     }
 205
 206     else if (codeByte > 0x80) {
 207         codeByte = 0x81 - (codeByte & 0x7f);
 208         if ((slen > (long) 0) && (dlen >= (long) codeByte)) {
 209         dataByte = *sptr++;
 210         slen -= 2;
 211         dlen -= codeByte;
 212         while (codeByte > 0) {
 213             *dptr++ = dataByte;
 214             codeByte--;
 215         }
 216         }
 217         else slen = 0;
 218     }
 219     }
 220 }
 221
 222 /******************************************/
 223 static unsigned int iff_getword(const byte *ptr)
 224 {
 225     unsigned int v;
 226
 227     v = *ptr++;
 228     v = (v << 8) + *ptr;
 229     return v;
 230 }
 231
 232 /******************************************/
 233 static unsigned long iff_getlong(const byte *ptr)
 234 {
 235     unsigned long l;
 236
 237     l = *ptr++;
 238     l = (l << 8) + *ptr++;
 239     l = (l << 8) + *ptr++;
 240     l = (l << 8) + *ptr;
 241     return l;
 242 }
 243
 244 // Define internal ILBM types
 245 #define ILBM_NORMAL     0
 246 #define ILBM_EHB        1
 247 #define ILBM_HAM        2
 248 #define ILBM_HAM8       3
 249 #define ILBM_24BIT      4
 250
 251 int wxIFFDecoder::ReadIFF()
 252 {
 253     Destroy();
 254
 255     m_image = new IFFImage();
 256     if (m_image == 0) {
 257     Destroy();
 258     return wxIFF_MEMERR;
 259     }
 260
 261     // compute file length
 262     off_t currentPos = m_f->TellI();
 263     m_f->SeekI(0, wxFromEnd);
 264     long filesize = m_f->TellI();
 265     m_f->SeekI(currentPos, wxFromStart);
 266
 267     // allocate memory for complete file
 268     if ((databuf = new byte[filesize]) == 0) {
 269     Destroy();
 270     return wxIFF_MEMERR;
 271     }
 272
 273     m_f->Read(databuf, filesize);
 274     const byte *dataend = databuf + filesize;
 275
 276     // initialize work pointer. used to trace the buffer for IFF chunks
 277     const byte *dataptr = databuf;
 278
 279     // check for minmal size
 280     if (dataptr + 12 > dataend) {
 281     Destroy();
 282     return wxIFF_INVFORMAT;
 283     }
 284
 285     // check if we really got an IFF file
 286     if (strncmp((char *)dataptr, "FORM", 4) != 0) {
 287     Destroy();
 288     return wxIFF_INVFORMAT;
 289     }
 290
 291     dataptr = dataptr + 8;                  // skip ID and length of FORM
 292
 293     // check if the IFF file is an ILBM (picture) file
 294     if (strncmp((char *) dataptr, "ILBM", 4) != 0) {
 295     Destroy();
 296     return wxIFF_INVFORMAT;
 297     }
 298
 299     wxLogTrace(_T("iff"), _T("IFF ILBM file recognized"));
 300
 301     dataptr = dataptr + 4;                                // skip ID
 302
 303     //
 304     // main decoding loop. searches IFF chunks and handles them.
 305     // terminates when BODY chunk was found or dataptr ran over end of file
 306     //
 307     bool BMHDok = false, CMAPok = false, CAMGok = false;
 308     int bmhd_width = 0, bmhd_height = 0, bmhd_bitplanes = 0, bmhd_transcol = -1;
 309     byte bmhd_masking = 0, bmhd_compression = 0;
 310     long camg_viewmode = 0;
 311     int colors = 0;
 312     while (dataptr + 8 <= dataend) {
 313     // get chunk length and make even
 314     size_t chunkLen = (iff_getlong(dataptr + 4) + 1) & 0xfffffffe;
 315     if (chunkLen < 0) {     // format error?
 316        break;
 317     }
 318     bool truncated = (dataptr + 8 + chunkLen > dataend);
 319
 320     if (strncmp((char *)dataptr, "BMHD", 4) == 0) { // BMHD chunk?
 321         if (chunkLen < 12 + 2 || truncated) {
 322         break;
 323         }
 324         bmhd_width = iff_getword(dataptr + 8);      // width of picture
 325         bmhd_height= iff_getword(dataptr + 8 + 2);  // height of picture
 326         bmhd_bitplanes = *(dataptr + 8 + 8);        // # of bitplanes
 327         bmhd_masking  = *(dataptr + 8 + 9);
 328         bmhd_compression = *(dataptr + 8 + 10);     // get compression
 329         bmhd_transcol    = iff_getword(dataptr + 8 + 12);
 330         BMHDok = true;                              // got BMHD
 331         dataptr += 8 + chunkLen;                    // to next chunk
 332     }
 333     else if (strncmp((char *)dataptr, "CMAP", 4) == 0) { // CMAP ?
 334         if (truncated) {
 335         break;
 336         }
 337         const byte *cmapptr = dataptr + 8;
 338         colors = chunkLen / 3;                  // calc no of colors
 339
 340         delete m_image->pal;
 341         m_image->pal = 0;
 342         m_image->colors = colors;
 343         if (colors > 0) {
 344         m_image->pal = new byte[3*colors];
 345         if (!m_image->pal) {
 346             Destroy();
 347             return wxIFF_MEMERR;
 348         }
 349
 350         // copy colors to color map
 351         for (int i=0; i < colors; i++) {
 352             m_image->pal[3*i + 0] = *cmapptr++;
 353             m_image->pal[3*i + 1] = *cmapptr++;
 354             m_image->pal[3*i + 2] = *cmapptr++;
 355         }
 356         }
 357
 358         wxLogTrace(_T("iff"), _T("Read %d colors from IFF file."),
 359             colors);
 360
 361         CMAPok = true;                              // got CMAP
 362         dataptr += 8 + chunkLen;                    // to next chunk
 363     } else if (strncmp((char *)dataptr, "CAMG", 4) == 0) { // CAMG ?
 364         if (chunkLen < 4 || truncated) {
 365         break;
 366         }
 367         camg_viewmode = iff_getlong(dataptr + 8);   // get viewmodes
 368         CAMGok = true;                              // got CAMG
 369         dataptr += 8 + chunkLen;                    // to next chunk
 370     }
 371     else if (strncmp((char *)dataptr, "BODY", 4) == 0) { // BODY ?
 372         if (!BMHDok) {                              // BMHD found?
 373         break;
 374         }
 375         const byte *bodyptr = dataptr + 8;          // -> BODY data
 376
 377         if (truncated) {
 378         chunkLen = dataend - dataptr;
 379         }
 380
 381         //
 382             // if BODY is compressed, allocate buffer for decrunched BODY
 383         // and decompress it (run length encoding)
 384         //
 385         if (bmhd_compression == 1) {
 386         // calc size of decrunch buffer - (size of the actual pic.
 387         // decompressed in interleaved Amiga bitplane format)
 388
 389         size_t decomp_bufsize = (((bmhd_width + 15) >> 4) << 1)
 390             * bmhd_height * bmhd_bitplanes;
 391
 392         if ((decomp_mem = new byte[decomp_bufsize]) == 0) {
 393             Destroy();
 394             return wxIFF_MEMERR;
 395         }
 396
 397         decomprle(bodyptr, decomp_mem, chunkLen, decomp_bufsize);
 398         bodyptr = decomp_mem;                 // -> uncompressed BODY
 399         chunkLen = decomp_bufsize;
 400         delete [] databuf;
 401         databuf = 0;
 402         }
 403
 404         // the following determines the type of the ILBM file.
 405         // it's either NORMAL, EHB, HAM, HAM8 or 24BIT
 406
 407         int fmt = ILBM_NORMAL;                 // assume normal ILBM
 408         if (bmhd_bitplanes == 24) {
 409         fmt = ILBM_24BIT;
 410         } else if (bmhd_bitplanes == 8) {
 411         if (CAMGok && (camg_viewmode & 0x800)) {
 412             fmt = ILBM_HAM8;
 413         }
 414         } else if ((bmhd_bitplanes > 5) && CAMGok) {
 415         if (camg_viewmode & 0x80) {
 416             fmt = ILBM_EHB;
 417         } else if (camg_viewmode & 0x800) {
 418             fmt = ILBM_HAM;
 419         }
 420         }
 421
 422         wxLogTrace(_T("iff"),
 423             _T("LoadIFF: %s %dx%d, planes=%d (%d cols), comp=%d"),
 424             (fmt==ILBM_NORMAL) ? "Normal ILBM" :
 425             (fmt==ILBM_HAM)    ? "HAM ILBM" :
 426             (fmt==ILBM_HAM8)   ? "HAM8 ILBM" :
 427             (fmt==ILBM_EHB)    ? "EHB ILBM" :
 428             (fmt==ILBM_24BIT)  ? "24BIT ILBM" : "unknown ILBM",
 429             bmhd_width, bmhd_height, bmhd_bitplanes,
 430             1<<bmhd_bitplanes, bmhd_compression);
 431
 432         if ((fmt==ILBM_NORMAL) || (fmt==ILBM_EHB) || (fmt==ILBM_HAM)) {
 433         wxLogTrace(_T("iff"),
 434             _T("Converting CMAP from normal ILBM CMAP"));
 435
 436         switch(fmt) {
 437             case ILBM_NORMAL: colors = 1 << bmhd_bitplanes; break;
 438             case ILBM_EHB:    colors = 32*2; break;
 439             case ILBM_HAM:    colors = 16; break;
 440         }
 441
 442         if (colors > m_image->colors) {
 443             byte *pal = new byte[colors*3];
 444             if (!pal) {
 445             Destroy();
 446             return wxIFF_MEMERR;
 447             }
 448             int i;
 449             for (i = 0; i < m_image->colors; i++) {
 450             pal[3*i + 0] = m_image->pal[3*i + 0];
 451             pal[3*i + 1] = m_image->pal[3*i + 1];
 452             pal[3*i + 2] = m_image->pal[3*i + 2];
 453             }
 454             for (; i < colors; i++) {
 455             pal[3*i + 0] = 0;
 456             pal[3*i + 1] = 0;
 457             pal[3*i + 2] = 0;
 458             }
 459             delete m_image->pal;
 460             m_image->pal = pal;
 461             m_image->colors = colors;
 462         }
 463
 464             for (int i=0; i < colors; i++) {
 465             m_image->pal[3*i + 0] = (m_image->pal[3*i + 0] >> 4) * 17;
 466             m_image->pal[3*i + 1] = (m_image->pal[3*i + 1] >> 4) * 17;
 467             m_image->pal[3*i + 2] = (m_image->pal[3*i + 2] >> 4) * 17;
 468         }
 469         }
 470
 471         m_image->p = new byte[bmhd_width * bmhd_height * 3];
 472             byte *picptr = m_image->p;
 473         if (!picptr) {
 474         Destroy();
 475         return wxIFF_MEMERR;
 476         }
 477
 478         byte *pal = m_image->pal;
 479         int lineskip = ((bmhd_width + 15) >> 4) << 1;
 480             int height = chunkLen / (lineskip * bmhd_bitplanes);
 481
 482         if (bmhd_height < height) {
 483             height = bmhd_height;
 484         }
 485
 486         if (fmt == ILBM_HAM || fmt == ILBM_HAM8 || fmt == ILBM_24BIT) {
 487         byte *pic = picptr;
 488         const byte *workptr = bodyptr;
 489
 490         for (int i=0; i < height; i++) {
 491             byte bitmsk = 0x80;
 492             const byte *workptr2 = workptr;
 493
 494             // at start of each line, init RGB values to background
 495             byte rval = pal[0];
 496             byte gval = pal[1];
 497             byte bval = pal[2];
 498
 499             for (int j=0; j < bmhd_width; j++) {
 500             long col = 0;
 501             long colbit = 1;
 502             const byte *workptr3 = workptr2;
 503             for (int k=0; k < bmhd_bitplanes; k++) {
 504                 if (*workptr3 & bitmsk) {
 505                 col += colbit;
 506                 }
 507                 workptr3 += lineskip;
 508                 colbit <<= 1;
 509             }
 510
 511             if (fmt==ILBM_HAM) {
 512                 int c = (col & 0x0f);
 513                 switch (col & 0x30) {
 514                 case 0x00: if (c >= 0 && c < colors) {
 515                            rval = pal[3*c + 0];
 516                            gval = pal[3*c + 1];
 517                            bval = pal[3*c + 2];
 518                        }
 519                        break;
 520
 521                 case 0x10: bval = c * 17;
 522                        break;
 523
 524                 case 0x20: rval = c * 17;
 525                        break;
 526
 527                 case 0x30: gval = c * 17;
 528                        break;
 529                 }
 530             } else if (fmt == ILBM_HAM8) {
 531                 int c = (col & 0x3f);
 532                 switch(col & 0xc0) {
 533                 case 0x00: if (c >= 0 && c < colors) {
 534                            rval = pal[3*c + 0];
 535                            gval = pal[3*c + 1];
 536                            bval = pal[3*c + 2];
 537                        }
 538                        break;
 539
 540                 case 0x40: bval = (bval & 3) | (c << 2);
 541                        break;
 542
 543                 case 0x80: rval = (rval & 3) | (c << 2);
 544                        break;
 545
 546                 case 0xc0: gval = (rval & 3) | (c << 2);
 547                 }
 548             } else {
 549                 rval = col & 0xff;
 550                 gval = (col >> 8) & 0xff;
 551                 bval = (col >> 16) & 0xff;
 552             }
 553
 554             *pic++ = rval;
 555             *pic++ = gval;
 556             *pic++ = bval;
 557
 558             bitmsk = bitmsk >> 1;
 559             if (bitmsk == 0) {
 560                 bitmsk = 0x80;
 561                 workptr2++;
 562             }
 563             }
 564             workptr += lineskip * bmhd_bitplanes;
 565         }
 566         }  else if ((fmt == ILBM_NORMAL) || (fmt == ILBM_EHB)) {
 567         if (fmt == ILBM_EHB) {
 568             wxLogTrace(_T("iff"), _T("Doubling CMAP for EHB mode"));
 569
 570             for (int i=0; i<32; i++) {
 571             pal[3*(i + 32) + 0] = pal[3*i + 0] >> 1;
 572             pal[3*(i + 32) + 1] = pal[3*i + 1] >> 1;
 573             pal[3*(i + 32) + 2] = pal[3*i + 2] >> 1;
 574             }
 575         }
 576
 577         byte *pic = picptr;         // ptr to buffer
 578         const byte *workptr = bodyptr;  // ptr to pic, planar format
 579
 580         if (bmhd_height < height) {
 581             height = bmhd_height;
 582         }
 583
 584         for (int i=0; i < height; i++) {
 585             byte bitmsk = 0x80;                 // left most bit (mask)
 586             const byte *workptr2 = workptr;     // work ptr to source
 587             for (int j=0; j < bmhd_width; j++) {
 588             long col = 0;
 589             long colbit = 1;
 590             const byte *workptr3 = workptr2;  // 1st byte in 1st pln
 591
 592             for (int k=0; k < bmhd_bitplanes; k++) {
 593                 if (*workptr3 & bitmsk) { // if bit set in this pln
 594                 col = col + colbit; // add bit to chunky byte
 595                 }
 596                 workptr3 += lineskip;   // go to next line
 597                 colbit <<= 1;           // shift color bit
 598             }
 599
 600             if (col >= 0 && col < colors) {
 601                 pic[0] = pal[3*col + 0];
 602                 pic[1] = pal[3*col + 1];
 603                 pic[2] = pal[3*col + 2];
 604             } else {
 605                 pic[0] = pic[1] = pic[2] = 0;
 606             }
 607             pic += 3;
 608             bitmsk = bitmsk >> 1;   // shift mask to next bit
 609             if (bitmsk == 0) {      // if mask is zero
 610                 bitmsk = 0x80;      // reset mask
 611                 workptr2++;         // mv ptr to next byte
 612             }
 613             }
 614
 615             workptr += lineskip * bmhd_bitplanes;  // to next line
 616         }
 617         } else {
 618         break;      // unknown format
 619         }
 620
 621         m_image->w = bmhd_width;
 622         m_image->h = height;
 623         m_image->transparent = bmhd_transcol;
 624
 625         wxLogTrace(_T("iff"), _T("Loaded IFF picture %s"),
 626             truncated? "truncated" : "completely");
 627
 628         return (truncated? wxIFF_TRUNCATED : wxIFF_OK);
 629     } else {
 630         wxLogTrace(_T("iff"), _T("Skipping unknown chunk '%c%c%c%c'"),
 631                 *dataptr, *(dataptr+1), *(dataptr+2), *(dataptr+3));
 632
 633         dataptr = dataptr + 8 + chunkLen;      // skip unknown chunk
 634     }
 635     }
 636
 637     Destroy();
 638     return wxIFF_INVFORMAT;
 639 }
 640
 641 #endif // wxUSE_STREAMS && wxUSE_IFF
 642