src/common/imagiff.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/imagiff.cpp
// Purpose:     wxImage handler for Amiga IFF images
// Author:      Steffen Gutmann, Thomas Meyer
// Copyright:   (c) Steffen Gutmann, 2002
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// Parts of this source are based on the iff loading algorithm found
// in xviff.c.  Permission by the original author, Thomas Meyer, and
// by the author of xv, John Bradley for using the iff loading part
// in wxWidgets has been gratefully given.

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_IMAGE && wxUSE_IFF

#ifndef WX_PRECOMP
    #include "wx/log.h"
    #include "wx/intl.h"
#endif

#include "wx/imagiff.h"
#include "wx/wfstream.h"

#if wxUSE_PALETTE
    #include "wx/palette.h"
#endif // wxUSE_PALETTE

#include <stdlib.h>
#include <string.h>


// --------------------------------------------------------------------------
// Constants
// --------------------------------------------------------------------------

// Error codes:
//  Note that the error code wxIFF_TRUNCATED means that the image itself
//  is most probably OK, but the decoder didn't reach the end of the data
//  stream; this means that if it was not reading directly from file,
//  the stream will not be correctly positioned.
//

enum
{
    wxIFF_OK = 0,                   /* everything was OK */
    wxIFF_INVFORMAT,                /* error in iff header */
    wxIFF_MEMERR,                   /* error allocating memory */
    wxIFF_TRUNCATED                 /* file appears to be truncated */
};

// --------------------------------------------------------------------------
// wxIFFDecoder class
// --------------------------------------------------------------------------

// internal class for storing IFF image data
class IFFImage
{
public:
    unsigned int w;                 /* width */
    unsigned int h;                 /* height */
    int transparent;                /* transparent color (-1 = none) */
    int colors;                     /* number of colors */
    unsigned char *p;               /* bitmap */
    unsigned char *pal;             /* palette */

    IFFImage() : w(0), h(0), colors(0), p(0), pal(0) {}
    ~IFFImage() { delete [] p; delete [] pal; }
};

class WXDLLEXPORT wxIFFDecoder
{
private:
    IFFImage *m_image;        // image data
    wxInputStream *m_f;       // input stream
    unsigned char *databuf;
    unsigned char *decomp_mem;

    void Destroy();

public:
    // get data of current frame
    unsigned char* GetData() const;
    unsigned char* GetPalette() const;
    int GetNumColors() const;
    unsigned int GetWidth() const;
    unsigned int GetHeight() const;
    int GetTransparentColour() const;

    // constructor, destructor, etc.
    wxIFFDecoder(wxInputStream *s);
    ~wxIFFDecoder() { Destroy(); }

    // NOTE: this function modifies the current stream position
    bool CanRead();

    int ReadIFF();
    bool ConvertToImage(wxImage *image) const;
};


//---------------------------------------------------------------------------
// wxIFFDecoder constructor and destructor
//---------------------------------------------------------------------------

wxIFFDecoder::wxIFFDecoder(wxInputStream *s)
{
    m_f = s;
    m_image = 0;
    databuf = 0;
    decomp_mem = 0;
}

void wxIFFDecoder::Destroy()
{
    wxDELETE(m_image);
    wxDELETEA(databuf);
    wxDELETEA(decomp_mem);
}

//---------------------------------------------------------------------------
// Convert this image to a wxImage object
//---------------------------------------------------------------------------

// This function was designed by Vaclav Slavik

bool wxIFFDecoder::ConvertToImage(wxImage *image) const
{
    // just in case...
    image->Destroy();

    // create the image
    image->Create(GetWidth(), GetHeight());

    if (!image->IsOk())
        return false;

    unsigned char *pal = GetPalette();
    unsigned char *src = GetData();
    unsigned char *dst = image->GetData();
    int colors = GetNumColors();
    int transparent = GetTransparentColour();
    long i;

    // set transparent colour mask
    if (transparent != -1)
    {
        for (i = 0; i < colors; i++)
        {
            if ((pal[3 * i + 0] == 255) &&
                (pal[3 * i + 1] == 0) &&
                (pal[3 * i + 2] == 255))
            {
                pal[3 * i + 2] = 254;
            }
        }

        pal[3 * transparent + 0] = 255,
        pal[3 * transparent + 1] = 0,
        pal[3 * transparent + 2] = 255;

        image->SetMaskColour(255, 0, 255);
    }
    else
        image->SetMask(false);

#if wxUSE_PALETTE
    if (pal && colors > 0)
    {
        unsigned char* r = new unsigned char[colors];
        unsigned char* g = new unsigned char[colors];
        unsigned char* b = new unsigned char[colors];

        for (i = 0; i < colors; i++)
        {
            r[i] = pal[3*i + 0];
            g[i] = pal[3*i + 1];
            b[i] = pal[3*i + 2];
        }

        image->SetPalette(wxPalette(colors, r, g, b));

        delete [] r;
        delete [] g;
        delete [] b;
    }
#endif // wxUSE_PALETTE

    // copy image data
    for (i = 0; i < (long)(GetWidth() * GetHeight()); i++, src += 3, dst += 3)
    {
    dst[0] = src[0];
    dst[1] = src[1];
    dst[2] = src[2];
    }

    return true;
}


//---------------------------------------------------------------------------
// Data accessors
//---------------------------------------------------------------------------

// Get data for current frame

unsigned char* wxIFFDecoder::GetData() const    { return (m_image->p); }
unsigned char* wxIFFDecoder::GetPalette() const { return (m_image->pal); }
int wxIFFDecoder::GetNumColors() const          { return m_image->colors; }
unsigned int wxIFFDecoder::GetWidth() const     { return (m_image->w); }
unsigned int wxIFFDecoder::GetHeight() const    { return (m_image->h); }
int wxIFFDecoder::GetTransparentColour() const { return m_image->transparent; }

//---------------------------------------------------------------------------
// IFF reading and decoding
//---------------------------------------------------------------------------

//
// CanRead:
//  Returns true if the file looks like a valid IFF, false otherwise.
//
bool wxIFFDecoder::CanRead()
{
    unsigned char buf[12];

    if ( !m_f->Read(buf, WXSIZEOF(buf)) )
        return false;

    return (memcmp(buf, "FORM", 4) == 0) && (memcmp(buf+8, "ILBM", 4) == 0);
}


// ReadIFF:
// Based on xv source code by Thomas Meyer
// Permission for use in wxWidgets has been gratefully given.

typedef unsigned char byte;
#define IFFDEBUG 0

/*************************************************************************
void decomprle(source, destination, source length, buffer size)

Decompress run-length encoded data from source to destination. Terminates
when source is decoded completely or destination buffer is full.

The decruncher is as optimized as I could make it, without risking
safety in case of corrupt BODY chunks.
**************************************************************************/

static void decomprle(const byte *sptr, byte *dptr, long slen, long dlen)
{
    byte codeByte, dataByte;

    while ((slen > 0) && (dlen > 0)) {
    // read control byte
    codeByte = *sptr++;

    if (codeByte < 0x80) {
        codeByte++;
        if ((slen > (long) codeByte) && (dlen >= (long) codeByte)) {
        slen -= codeByte + 1;
        dlen -= codeByte;
        while (codeByte > 0) {
            *dptr++ = *sptr++;
            codeByte--;
        }
        }
        else slen = 0;
    }

    else if (codeByte > 0x80) {
        codeByte = 0x81 - (codeByte & 0x7f);
        if ((slen > (long) 0) && (dlen >= (long) codeByte)) {
        dataByte = *sptr++;
        slen -= 2;
        dlen -= codeByte;
        while (codeByte > 0) {
            *dptr++ = dataByte;
            codeByte--;
        }
        }
        else slen = 0;
    }
    }
}

/******************************************/
static unsigned int iff_getword(const byte *ptr)
{
    unsigned int v;

    v = *ptr++;
    v = (v << 8) + *ptr;
    return v;
}

/******************************************/
static unsigned long iff_getlong(const byte *ptr)
{
    unsigned long l;

    l = *ptr++;
    l = (l << 8) + *ptr++;
    l = (l << 8) + *ptr++;
    l = (l << 8) + *ptr;
    return l;
}

// Define internal ILBM types
#define ILBM_NORMAL     0
#define ILBM_EHB        1
#define ILBM_HAM        2
#define ILBM_HAM8       3
#define ILBM_24BIT      4

int wxIFFDecoder::ReadIFF()
{
    Destroy();

    m_image = new IFFImage();
    if (m_image == 0) {
        Destroy();
        return wxIFF_MEMERR;
    }

    // compute file length
    wxFileOffset currentPos = m_f->TellI();
    if (m_f->SeekI(0, wxFromEnd) == wxInvalidOffset) {
        Destroy();
        return wxIFF_MEMERR;
    }

    long filesize = m_f->TellI();
    if (m_f->SeekI(currentPos, wxFromStart) == wxInvalidOffset) {
        Destroy();
        return wxIFF_MEMERR;
    }

    // allocate memory for complete file
    if ((databuf = new byte[filesize]) == 0) {
        Destroy();
        return wxIFF_MEMERR;
    }

    m_f->Read(databuf, filesize);
    const byte *dataend = databuf + filesize;

    // initialize work pointer. used to trace the buffer for IFF chunks
    const byte *dataptr = databuf;

    // check for minmal size
    if (dataptr + 12 > dataend) {
        Destroy();
        return wxIFF_INVFORMAT;
    }

    // check if we really got an IFF file
    if (strncmp((char *)dataptr, "FORM", 4) != 0) {
        Destroy();
        return wxIFF_INVFORMAT;
    }

    dataptr = dataptr + 8;                  // skip ID and length of FORM

    // check if the IFF file is an ILBM (picture) file
    if (strncmp((char *) dataptr, "ILBM", 4) != 0) {
        Destroy();
        return wxIFF_INVFORMAT;
    }

    wxLogTrace(wxT("iff"), wxT("IFF ILBM file recognized"));

    dataptr = dataptr + 4;                                // skip ID

    //
    // main decoding loop. searches IFF chunks and handles them.
    // terminates when BODY chunk was found or dataptr ran over end of file
    //
    bool BMHDok = false, CAMGok = false;
    int bmhd_width = 0, bmhd_height = 0, bmhd_bitplanes = 0, bmhd_transcol = -1;
    byte bmhd_compression = 0;
    long camg_viewmode = 0;
    int colors = 0;
    while (dataptr + 8 <= dataend) {
    // get chunk length and make even
    long chunkLen = (iff_getlong(dataptr + 4) + 1) & 0xfffffffe;
    if (chunkLen < 0) {     // format error?
        break;
    }
    bool truncated = (dataptr + 8 + chunkLen > dataend);

    if (strncmp((char *)dataptr, "BMHD", 4) == 0) { // BMHD chunk?
        if (chunkLen < 12 + 2 || truncated) {
        break;
        }
        bmhd_width = iff_getword(dataptr + 8);      // width of picture
        bmhd_height= iff_getword(dataptr + 8 + 2);  // height of picture
        bmhd_bitplanes = *(dataptr + 8 + 8);        // # of bitplanes
        // bmhd_masking  = *(dataptr + 8 + 9); -- unused currently
        bmhd_compression = *(dataptr + 8 + 10);     // get compression
        bmhd_transcol    = iff_getword(dataptr + 8 + 12);
        BMHDok = true;                              // got BMHD
        dataptr += 8 + chunkLen;                    // to next chunk
    }
    else if (strncmp((char *)dataptr, "CMAP", 4) == 0) { // CMAP ?
        if (truncated) {
        break;
        }
        const byte *cmapptr = dataptr + 8;
        colors = chunkLen / 3;                  // calc no of colors

        wxDELETE(m_image->pal);
        m_image->colors = colors;
        if (colors > 0) {
        m_image->pal = new byte[3*colors];
        if (!m_image->pal) {
            Destroy();
            return wxIFF_MEMERR;
        }

        // copy colors to color map
        for (int i=0; i < colors; i++) {
            m_image->pal[3*i + 0] = *cmapptr++;
            m_image->pal[3*i + 1] = *cmapptr++;
            m_image->pal[3*i + 2] = *cmapptr++;
        }
        }

        wxLogTrace(wxT("iff"), wxT("Read %d colors from IFF file."),
            colors);

        dataptr += 8 + chunkLen;                    // to next chunk
    } else if (strncmp((char *)dataptr, "CAMG", 4) == 0) { // CAMG ?
        if (chunkLen < 4 || truncated) {
        break;
        }
        camg_viewmode = iff_getlong(dataptr + 8);   // get viewmodes
        CAMGok = true;                              // got CAMG
        dataptr += 8 + chunkLen;                    // to next chunk
    }
    else if (strncmp((char *)dataptr, "BODY", 4) == 0) { // BODY ?
        if (!BMHDok) {                              // BMHD found?
        break;
        }
        const byte *bodyptr = dataptr + 8;          // -> BODY data

        if (truncated) {
        chunkLen = dataend - dataptr;
        }

        //
            // if BODY is compressed, allocate buffer for decrunched BODY
        // and decompress it (run length encoding)
        //
        if (bmhd_compression == 1) {
        // calc size of decrunch buffer - (size of the actual pic.
        // decompressed in interleaved Amiga bitplane format)

        size_t decomp_bufsize = (((bmhd_width + 15) >> 4) << 1)
            * bmhd_height * bmhd_bitplanes;

        if ((decomp_mem = new byte[decomp_bufsize]) == 0) {
            Destroy();
            return wxIFF_MEMERR;
        }

        decomprle(bodyptr, decomp_mem, chunkLen, decomp_bufsize);
        bodyptr = decomp_mem;                 // -> uncompressed BODY
        chunkLen = decomp_bufsize;
        wxDELETEA(databuf);
        }

        // the following determines the type of the ILBM file.
        // it's either NORMAL, EHB, HAM, HAM8 or 24BIT

        int fmt = ILBM_NORMAL;                 // assume normal ILBM
        if (bmhd_bitplanes == 24) {
        fmt = ILBM_24BIT;
        } else if (bmhd_bitplanes == 8) {
        if (CAMGok && (camg_viewmode & 0x800)) {
            fmt = ILBM_HAM8;
        }
        } else if ((bmhd_bitplanes > 5) && CAMGok) {
        if (camg_viewmode & 0x80) {
            fmt = ILBM_EHB;
        } else if (camg_viewmode & 0x800) {
            fmt = ILBM_HAM;
        }
        }

        wxLogTrace(wxT("iff"),
            wxT("LoadIFF: %s %dx%d, planes=%d (%d cols), comp=%d"),
            (fmt==ILBM_NORMAL) ? "Normal ILBM" :
            (fmt==ILBM_HAM)    ? "HAM ILBM" :
            (fmt==ILBM_HAM8)   ? "HAM8 ILBM" :
            (fmt==ILBM_EHB)    ? "EHB ILBM" :
            (fmt==ILBM_24BIT)  ? "24BIT ILBM" : "unknown ILBM",
            bmhd_width, bmhd_height, bmhd_bitplanes,
            1<<bmhd_bitplanes, bmhd_compression);

        if ((fmt==ILBM_NORMAL) || (fmt==ILBM_EHB) || (fmt==ILBM_HAM)) {
        wxLogTrace(wxT("iff"),
            wxT("Converting CMAP from normal ILBM CMAP"));

        switch(fmt) {
            case ILBM_NORMAL: colors = 1 << bmhd_bitplanes; break;
            case ILBM_EHB:    colors = 32*2; break;
            case ILBM_HAM:    colors = 16; break;
        }

        if (colors > m_image->colors) {
            byte *pal = new byte[colors*3];
            if (!pal) {
            Destroy();
            return wxIFF_MEMERR;
            }
            int i;
            for (i = 0; i < m_image->colors; i++) {
            pal[3*i + 0] = m_image->pal[3*i + 0];
            pal[3*i + 1] = m_image->pal[3*i + 1];
            pal[3*i + 2] = m_image->pal[3*i + 2];
            }
            for (; i < colors; i++) {
            pal[3*i + 0] = 0;
            pal[3*i + 1] = 0;
            pal[3*i + 2] = 0;
            }
            delete m_image->pal;
            m_image->pal = pal;
            m_image->colors = colors;
        }

            for (int i=0; i < colors; i++) {
            m_image->pal[3*i + 0] = (m_image->pal[3*i + 0] >> 4) * 17;
            m_image->pal[3*i + 1] = (m_image->pal[3*i + 1] >> 4) * 17;
            m_image->pal[3*i + 2] = (m_image->pal[3*i + 2] >> 4) * 17;
        }
        }

        m_image->p = new byte[bmhd_width * bmhd_height * 3];
        byte *picptr = m_image->p;
        if (!picptr) {
        Destroy();
        return wxIFF_MEMERR;
        }

        byte *pal = m_image->pal;
        int lineskip = ((bmhd_width + 15) >> 4) << 1;
            int height = chunkLen / (lineskip * bmhd_bitplanes);

        if (bmhd_height < height) {
            height = bmhd_height;
        }

        if (fmt == ILBM_HAM || fmt == ILBM_HAM8 || fmt == ILBM_24BIT) {
        byte *pic = picptr;
        const byte *workptr = bodyptr;

        for (int i=0; i < height; i++) {
            byte bitmsk = 0x80;
            const byte *workptr2 = workptr;

            // at start of each line, init RGB values to background
            byte rval = pal[0];
            byte gval = pal[1];
            byte bval = pal[2];

            for (int j=0; j < bmhd_width; j++) {
            long col = 0;
            long colbit = 1;
            const byte *workptr3 = workptr2;
            for (int k=0; k < bmhd_bitplanes; k++) {
                if (*workptr3 & bitmsk) {
                col += colbit;
                }
                workptr3 += lineskip;
                colbit <<= 1;
            }

            if (fmt==ILBM_HAM) {
                int c = (col & 0x0f);
                switch (col & 0x30) {
                case 0x00: if (c >= 0 && c < colors) {
                        rval = pal[3*c + 0];
                        gval = pal[3*c + 1];
                        bval = pal[3*c + 2];
                    }
                    break;

                case 0x10: bval = c * 17;
                    break;

                case 0x20: rval = c * 17;
                    break;

                case 0x30: gval = c * 17;
                    break;
                }
            } else if (fmt == ILBM_HAM8) {
                int c = (col & 0x3f);
                switch(col & 0xc0) {
                case 0x00: if (c >= 0 && c < colors) {
                        rval = pal[3*c + 0];
                        gval = pal[3*c + 1];
                        bval = pal[3*c + 2];
                    }
                    break;

                case 0x40: bval = (bval & 3) | (c << 2);
                    break;

                case 0x80: rval = (rval & 3) | (c << 2);
                    break;

                case 0xc0: gval = (rval & 3) | (c << 2);
                }
            } else {
                rval = col & 0xff;
                gval = (col >> 8) & 0xff;
                bval = (col >> 16) & 0xff;
            }

            *pic++ = rval;
            *pic++ = gval;
            *pic++ = bval;

            bitmsk = bitmsk >> 1;
            if (bitmsk == 0) {
                bitmsk = 0x80;
                workptr2++;
            }
            }
            workptr += lineskip * bmhd_bitplanes;
        }
        }  else if ((fmt == ILBM_NORMAL) || (fmt == ILBM_EHB)) {
        if (fmt == ILBM_EHB) {
            wxLogTrace(wxT("iff"), wxT("Doubling CMAP for EHB mode"));

            for (int i=0; i<32; i++) {
            pal[3*(i + 32) + 0] = pal[3*i + 0] >> 1;
            pal[3*(i + 32) + 1] = pal[3*i + 1] >> 1;
            pal[3*(i + 32) + 2] = pal[3*i + 2] >> 1;
            }
        }

        byte *pic = picptr;         // ptr to buffer
        const byte *workptr = bodyptr;  // ptr to pic, planar format

        if (bmhd_height < height) {
            height = bmhd_height;
        }

        for (int i=0; i < height; i++) {
            byte bitmsk = 0x80;                 // left most bit (mask)
            const byte *workptr2 = workptr;     // work ptr to source
            for (int j=0; j < bmhd_width; j++) {
            long col = 0;
            long colbit = 1;
            const byte *workptr3 = workptr2;  // 1st byte in 1st pln

            for (int k=0; k < bmhd_bitplanes; k++) {
                if (*workptr3 & bitmsk) { // if bit set in this pln
                col = col + colbit; // add bit to chunky byte
                }
                workptr3 += lineskip;   // go to next line
                colbit <<= 1;           // shift color bit
            }

            if (col >= 0 && col < colors) {
                pic[0] = pal[3*col + 0];
                pic[1] = pal[3*col + 1];
                pic[2] = pal[3*col + 2];
            } else {
                pic[0] = pic[1] = pic[2] = 0;
            }
            pic += 3;
            bitmsk = bitmsk >> 1;   // shift mask to next bit
            if (bitmsk == 0) {      // if mask is zero
                bitmsk = 0x80;      // reset mask
                workptr2++;         // mv ptr to next byte
            }
            }

            workptr += lineskip * bmhd_bitplanes;  // to next line
        }
        } else {
        break;      // unknown format
        }

        m_image->w = bmhd_width;
        m_image->h = height;
        m_image->transparent = bmhd_transcol;

        wxLogTrace(wxT("iff"), wxT("Loaded IFF picture %s"),
            truncated? "truncated" : "completely");

        return (truncated? wxIFF_TRUNCATED : wxIFF_OK);
    } else {
        wxLogTrace(wxT("iff"), wxT("Skipping unknown chunk '%c%c%c%c'"),
                *dataptr, *(dataptr+1), *(dataptr+2), *(dataptr+3));

        dataptr = dataptr + 8 + chunkLen;      // skip unknown chunk
    }
    }

    Destroy();
    return wxIFF_INVFORMAT;
}


//-----------------------------------------------------------------------------
// wxIFFHandler
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxIFFHandler, wxImageHandler)

#if wxUSE_STREAMS

bool wxIFFHandler::LoadFile(wxImage *image, wxInputStream& stream,
                            bool verbose, int WXUNUSED(index))
{
    wxIFFDecoder *decod;
    int error;
    bool ok;

    decod = new wxIFFDecoder(&stream);
    error = decod->ReadIFF();

    if ((error != wxIFF_OK) && (error != wxIFF_TRUNCATED))
    {
        if (verbose)
        {
            switch (error)
            {
                case wxIFF_INVFORMAT:
                    wxLogError(_("IFF: error in IFF image format."));
                    break;
                case wxIFF_MEMERR:
                    wxLogError(_("IFF: not enough memory."));
                    break;
                default:
                    wxLogError(_("IFF: unknown error!!!"));
                    break;
            }
        }
        delete decod;
        return false;
    }

    if ((error == wxIFF_TRUNCATED) && verbose)
    {
        wxLogError(_("IFF: data stream seems to be truncated."));
        /* go on; image data is OK */
    }

    ok = decod->ConvertToImage(image);
    delete decod;

    return ok;
}

bool wxIFFHandler::SaveFile(wxImage * WXUNUSED(image),
                            wxOutputStream& WXUNUSED(stream), bool verbose)
{
    if (verbose)
    {
        wxLogDebug(wxT("IFF: the handler is read-only!!"));
    }

    return false;
}

bool wxIFFHandler::DoCanRead(wxInputStream& stream)
{
    wxIFFDecoder decod(&stream);

    return decod.CanRead();
         // it's ok to modify the stream position here
}

#endif // wxUSE_STREAMS

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