src/common/imagiff.cpp

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