[wxWidgets.git] / src / common / imagtga.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        imagtga.cpp
// Purpose:     wxImage TGA handler
// Author:      Seth Jackson
// CVS-ID:      $Id$
// Copyright:   (c) 2005 Seth Jackson
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

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

#ifdef __BORLANDC__
  #pragma hdrstop
#endif

#if wxUSE_IMAGE && wxUSE_TGA

#ifndef WX_PRECOMP
    #include "wx/palette.h"
#endif

#include "wx/imagtga.h"
#include "wx/log.h"
#include "wx/scopeguard.h"

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// TGA error codes.
enum
{
    wxTGA_OK,
    wxTGA_INVFORMAT,
    wxTGA_MEMERR,
    wxTGA_IOERR
};

// TGA header bytes.
enum
{
    HDR_OFFSET = 0,
    HDR_COLORTYPE  = 1,
    HDR_IMAGETYPE = 2,
    HDR_PALETTESTART = 3,
    HDR_PALETTELENGTH = 5,
    HDR_PALETTEBITS = 7,
    HDR_XORIGIN = 8,
    HDR_YORIGIN = 10,
    HDR_WIDTH = 12,
    HDR_HEIGHT = 14,
    HDR_BPP = 16,
    HDR_ORIENTATION = 17,
    HDR_SIZE
};

// TGA color types.
enum
{
    wxTGA_UNMAPPED = 0,
    wxTGA_MAPPED = 1
};

// ============================================================================
// implementation
// ============================================================================

IMPLEMENT_DYNAMIC_CLASS(wxTGAHandler, wxImageHandler)

#if wxUSE_STREAMS

// ----------------------------------------------------------------------------
// worker functions
// ----------------------------------------------------------------------------

static
void FlipTGA(unsigned char* imageData, int width, int height, short pixelSize)
{
    int lineLength = width * pixelSize;
    unsigned char *line1 = imageData;
    unsigned char *line2 = &imageData[lineLength * (height - 1)];

    unsigned char temp;
    for ( ; line1 < line2; line2 -= (lineLength * 2))
    {
        for (int index = 0; index < lineLength; line1++, line2++, index++)
        {
            temp = *line1;
            *line1 = *line2;
            *line2 = temp;
        }
    }
}

// return wxTGA_OK or wxTGA_IOERR
static
int DecodeRLE(unsigned char* imageData, unsigned long imageSize,
               short pixelSize, wxInputStream& stream)
{
    unsigned long index = 0;
    unsigned char current;
    unsigned int length;
    unsigned char buf[4];

    while (index < imageSize)
    {
        int ch = stream.GetC();
        if ( ch == wxEOF )
            return wxTGA_IOERR;

        current = ch;

        // RLE packet.
        if ( current & 0x80 )
        {
            // Get the run length of the packet.
            current &= 0x7f;

            current++;

            length = current;

            index += current * pixelSize;

            // Repeat the pixel length times.
            if ( !stream.Read(buf, pixelSize) )
                return wxTGA_IOERR;

            for (unsigned int i = 0; i < length; i++)
            {
                memcpy(imageData, buf, pixelSize);

                imageData += pixelSize;
            }
        }
        else // Raw packet.
        {
            // Get the run length of the packet.
            current++;

            length = current * pixelSize;

            index += length;

            // Write the next length pixels directly to the image data.
            if ( !stream.Read(imageData, length) )
                return wxTGA_IOERR;

            imageData += length;
        }
    }

    return wxTGA_OK;
}

static
int ReadTGA(wxImage* image, wxInputStream& stream)
{
    // Read in the TGA header
    unsigned char hdr[HDR_SIZE];
    stream.Read(hdr, HDR_SIZE);

    short offset = hdr[HDR_OFFSET] + HDR_SIZE;
    short colorType = hdr[HDR_COLORTYPE];
    short imageType = hdr[HDR_IMAGETYPE];
    int paletteLength = hdr[HDR_PALETTELENGTH] + 256 * hdr[HDR_PALETTELENGTH + 1];
    int width = (hdr[HDR_WIDTH] + 256 * hdr[HDR_WIDTH + 1]) -
                (hdr[HDR_XORIGIN] + 256 * hdr[HDR_XORIGIN + 1]);
    int height = (hdr[HDR_HEIGHT] + 256 * hdr[HDR_HEIGHT + 1]) -
                 (hdr[HDR_YORIGIN] + 256 * hdr[HDR_YORIGIN + 1]);
    short bpp = hdr[HDR_BPP];
    short orientation = hdr[HDR_ORIENTATION] & 0x20;

    image->Create(width, height);

    if (!image->Ok())
    {
        return wxTGA_MEMERR;
    }

    const short pixelSize = bpp / 8;

    const unsigned long imageSize = width * height * pixelSize;

    unsigned char *imageData = (unsigned char* )malloc(imageSize);

    if (!imageData)
    {
        return wxTGA_MEMERR;
    }

    wxON_BLOCK_EXIT1(free, imageData);

    unsigned char *dst = image->GetData();

    unsigned char* alpha = NULL;
    if (bpp == 16 || bpp == 32)
    {
        image->SetAlpha();

        alpha = image->GetAlpha();
    }

    // Seek from the offset we got from the TGA header.
    stream.SeekI(offset, wxFromStart);

    // Load a palette if we have one.
    if (colorType == wxTGA_MAPPED)
    {
        unsigned char buf[3];

        unsigned char* r = new unsigned char[paletteLength];
        unsigned char* g = new unsigned char[paletteLength];
        unsigned char* b = new unsigned char[paletteLength];

        for (int i = 0; i < paletteLength; i++)
        {
            stream.Read(buf, 3);

            r[i] = buf[2];
            g[i] = buf[1];
            b[i] = buf[0];
        }

#if wxUSE_PALETTE
        // Set the palette of the image.
        image->SetPalette(wxPalette(paletteLength, r, g, b));
#endif // wxUSE_PALETTE

        delete[] r;
        delete[] g;
        delete[] b;
    }

    // Handle the various TGA formats we support.

    switch (imageType)
    {
#if wxUSE_PALETTE
        // Raw indexed.

        case 1:
        {
            const wxPalette& palette = image->GetPalette();
            unsigned char r;
            unsigned char g;
            unsigned char b;

            // No compression read the data directly to imageData.

            stream.Read(imageData, imageSize);

            // If orientation == 0, then the image is stored upside down.
            // We need to store it right side up.

            if (orientation == 0)
            {
                FlipTGA(imageData, width, height, pixelSize);
            }

            // Handle the different pixel depths.

            switch (bpp)
            {
                // 8 bpp.

                case 8:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        palette.GetRGB(imageData[index], &r, &g, &b);

                        *(dst++) = r;
                        *(dst++) = g;
                        *(dst++) = b;
                    }
                }
                break;

                // 16 bpp.

                case 16:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        palette.GetRGB(imageData[index], &r, &g, &b);

                        *(dst++) = r;
                        *(dst++) = g;
                        *(dst++) = b;
                        *(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
                    }
                }
                break;

                default:
                    return wxTGA_INVFORMAT;
            }
        }
        break;
#endif // wxUSE_PALETTE

        // Raw RGB.

        case 2:
        {
            // No compression read the data directly to imageData.

            stream.Read(imageData, imageSize);

            // If orientation == 0, then the image is stored upside down.
            // We need to store it right side up.

            if (orientation == 0)
            {
                FlipTGA(imageData, width, height, pixelSize);
            }

            // Handle the different pixel depths.

            switch (bpp)
            {
                //16 bpp.

                case 16:
                {
                    unsigned char temp;

                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        temp = (imageData[index + 1] & 0x7c) << 1;
                        temp |= temp >> 5;
                        *(dst++) = temp;

                        temp = ((imageData[index + 1] & 0x03) << 6) | ((imageData[index] & 0xe0) >> 2);
                        temp |= temp >> 5;
                        *(dst++) = temp;

                        temp = (imageData[index] & 0x1f) << 3;
                        temp |= temp >> 5;
                        *(dst++) = temp;

                        *(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
                    }
                }
                break;

                // 24 bpp.

                case 24:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        *(dst++) = imageData[index + 2];
                        *(dst++) = imageData[index + 1];
                        *(dst++) = imageData[index];
                    }
                }
                break;

                // 32 bpp.

                case 32:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        *(dst++) = imageData[index + 2];
                        *(dst++) = imageData[index + 1];
                        *(dst++) = imageData[index];
                        *(alpha++) = imageData[index + 3];
                    }
                }
                break;

                default:
                    return wxTGA_INVFORMAT;
            }
        }
        break;

        // Raw grayscale.

        case 3:
        {
            // No compression read the data directly to imageData.

            stream.Read(imageData, imageSize);

            // If orientation == 0, then the image is stored upside down.
            // We need to store it right side up.

            if (orientation == 0)
            {
                FlipTGA(imageData, width, height, pixelSize);
            }

            // Handle the different pixel depths.

            switch (bpp)
            {
                // 8 bpp.

                case 8:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        *(dst++) = imageData[index];
                        *(dst++) = imageData[index];
                        *(dst++) = imageData[index];
                    }
                }
                break;

                // 16 bpp.

                case 16:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        *(dst++) = imageData[index];
                        *(dst++) = imageData[index];
                        *(dst++) = imageData[index];
                        *(alpha++) = imageData[index + 1];
                    }
                }
                break;

                default:
                    return wxTGA_INVFORMAT;
            }
        }
        break;

#if wxUSE_PALETTE
        // RLE indexed.

        case 9:
        {
            const wxPalette& palette = image->GetPalette();
            unsigned char r;
            unsigned char g;
            unsigned char b;

            // Decode the RLE data.

            int rc =  DecodeRLE(imageData, imageSize, pixelSize, stream);
            if ( rc != wxTGA_OK )
                return rc;

            // If orientation == 0, then the image is stored upside down.
            // We need to store it right side up.

            if (orientation == 0)
            {
                FlipTGA(imageData, width, height, pixelSize);
            }

            // Handle the different pixel depths.

            switch (bpp)
            {
                // 8 bpp.

                case 8:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        palette.GetRGB(imageData[index], &r, &g, &b);

                        *(dst++) = r;
                        *(dst++) = g;
                        *(dst++) = b;
                    }
                }
                break;

                // 16 bpp.

                case 16:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        palette.GetRGB(imageData[index], &r, &g, &b);

                        *(dst++) = r;
                        *(dst++) = g;
                        *(dst++) = b;
                        *(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
                    }
                }
                break;

                default:
                    return wxTGA_INVFORMAT;
            }
        }
        break;
#endif // wxUSE_PALETTE

        // RLE RGB.

        case 10:
        {
            // Decode the RLE data.

            int rc = DecodeRLE(imageData, imageSize, pixelSize, stream);
            if ( rc != wxTGA_OK )
                return rc;

            // If orientation == 0, then the image is stored upside down.
            // We need to store it right side up.

            if (orientation == 0)
            {
                FlipTGA(imageData, width, height, pixelSize);
            }

            // Handle the different pixel depths.

            switch (bpp)
            {
                //16 bpp.

                case 16:
                {
                    unsigned char temp;

                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        temp = (imageData[index + 1] & 0x7c) << 1;
                        temp |= temp >> 5;
                        *(dst++) = temp;

                        temp = ((imageData[index + 1] & 0x03) << 6) | ((imageData[index] & 0xe0) >> 2);
                        temp |= temp >> 5;
                        *(dst++) = temp;

                        temp = (imageData[index] & 0x1f) << 3;
                        temp |= temp >> 5;
                        *(dst++) = temp;

                        *(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
                    }
                }
                break;

                // 24 bpp.

                case 24:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        *(dst++) = imageData[index + 2];
                        *(dst++) = imageData[index + 1];
                        *(dst++) = imageData[index];
                    }
                }
                break;

                // 32 bpp.

                case 32:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        *(dst++) = imageData[index + 2];
                        *(dst++) = imageData[index + 1];
                        *(dst++) = imageData[index];
                        *(alpha++) = imageData[index + 3];
                    }
                }
                break;

                default:
                    return wxTGA_INVFORMAT;
            }
        }
        break;

        // RLE grayscale.

        case 11:
        {
            // Decode the RLE data.

            int rc = DecodeRLE(imageData, imageSize, pixelSize, stream);
            if ( rc != wxTGA_OK )
                return rc;

            // If orientation == 0, then the image is stored upside down.
            // We need to store it right side up.

            if (orientation == 0)
            {
                FlipTGA(imageData, width, height, pixelSize);
            }

            // Handle the different pixel depths.

            switch (bpp)
            {
                // 8 bpp.

                case 8:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        *(dst++) = imageData[index];
                        *(dst++) = imageData[index];
                        *(dst++) = imageData[index];
                    }
                }
                break;

                // 16 bpp.

                case 16:
                {
                    for (unsigned long index = 0; index < imageSize; index += pixelSize)
                    {
                        *(dst++) = imageData[index];
                        *(dst++) = imageData[index];
                        *(dst++) = imageData[index];
                        *(alpha++) = imageData[index + 1];
                    }
                }
                break;

                default:
                    return wxTGA_INVFORMAT;
            }
        }
        break;

        default:
            return wxTGA_INVFORMAT;
    }

    return wxTGA_OK;
}

static
int SaveTGA(wxImage* WXUNUSED(image), wxOutputStream& WXUNUSED(stream))
{
    wxLogError(wxT("Saving in TGA format is not implemented."));

    return wxTGA_OK;
}

// ----------------------------------------------------------------------------
// wxTGAHandler
// ----------------------------------------------------------------------------

bool wxTGAHandler::LoadFile(wxImage* image,
                            wxInputStream& stream,
                            bool verbose,
                            int WXUNUSED(index))
{
    if ( !CanRead(stream) )
    {
        if ( verbose )
            wxLogError(wxT("TGA: this is not a TGA file."));

        return false;
    }

    image->Destroy();

    int error = ReadTGA(image, stream);
    if ( error != wxTGA_OK )
    {
        if ( verbose )
        {
            switch ( error )
            {
                case wxTGA_INVFORMAT:
                    wxLogError(wxT("TGA: image format unsupported."));
                    break;

                case wxTGA_MEMERR:
                    wxLogError(wxT("TGA: couldn't allocate memory."));
                    break;

                case wxTGA_IOERR:
                    wxLogError(wxT("TGA: couldn't read image data."));
                    break;

                default:
                    wxLogError(wxT("TGA: unknown error!"));
            }
        }

        image->Destroy();

        return false;
    }

    return true;
}

bool wxTGAHandler::SaveFile(wxImage* image, wxOutputStream& stream, bool verbose)
{
    int error = SaveTGA(image, stream);

    if ( error != wxTGA_OK )
    {
        if ( verbose )
        {
            switch ( error )
            {
                case wxTGA_INVFORMAT:
                    wxLogError(wxT("TGA: invalid image."));
                    break;

                case wxTGA_MEMERR:
                    wxLogError(wxT("TGA: couldn't allocate memory."));
                    break;

                default:
                    wxLogError(wxT("TGA: unknown error!"));
            }
        }

        return false;
    }

    return true;
}

bool wxTGAHandler::DoCanRead(wxInputStream& stream)
{
    // read the fixed-size TGA headers
    unsigned char hdr[HDR_SIZE];
    stream.Read(hdr, HDR_SIZE);

    // Check wether we can read the file or not.

    short colorType = hdr[HDR_COLORTYPE];
    if ( colorType != wxTGA_UNMAPPED && colorType != wxTGA_MAPPED )
    {
        return false;
    }

    short imageType = hdr[HDR_IMAGETYPE];
    if ( imageType == 0 || imageType == 32 || imageType == 33 )
    {
        return false;
    }

    short bpp = hdr[HDR_BPP];
    if ( bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32 )
    {
        return false;
    }

    return true;
}

#endif // wxUSE_STREAMS

#endif // wxUSE_IMAGE && wxUSE_TGA
Commit	Line	Data
3af706cc VZ	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: imagtga.cpp
	3	// Purpose: wxImage TGA handler
	4	// Author: Seth Jackson
	5	// CVS-ID: $Id$
	6	// Copyright: (c) 2005 Seth Jackson
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	// ============================================================================
	11	// declarations
	12	// ============================================================================
	13
	14	// ----------------------------------------------------------------------------
	15	// headers
	16	// ----------------------------------------------------------------------------
	17
	18	// For compilers that support precompilation, includes "wx.h".
	19	#include "wx/wxprec.h"
	20
	21	#ifdef __BORLANDC__
	22	#pragma hdrstop
	23	#endif
	24
	25	#if wxUSE_IMAGE && wxUSE_TGA
	26
	27	#ifndef WX_PRECOMP
	28	#include "wx/palette.h"
	29	#endif
	30
	31	#include "wx/imagtga.h"
	32	#include "wx/log.h"
56692119	33	#include "wx/scopeguard.h"
3af706cc VZ	34
	35	// ----------------------------------------------------------------------------
	36	// constants
	37	// ----------------------------------------------------------------------------
	38
	39	// TGA error codes.
	40	enum
	41	{
8fee6306 VZ	42	wxTGA_OK,
	43	wxTGA_INVFORMAT,
	44	wxTGA_MEMERR,
	45	wxTGA_IOERR
3af706cc VZ	46	};
	47
	48	// TGA header bytes.
	49	enum
	50	{
	51	HDR_OFFSET = 0,
	52	HDR_COLORTYPE = 1,
	53	HDR_IMAGETYPE = 2,
	54	HDR_PALETTESTART = 3,
	55	HDR_PALETTELENGTH = 5,
	56	HDR_PALETTEBITS = 7,
	57	HDR_XORIGIN = 8,
	58	HDR_YORIGIN = 10,
	59	HDR_WIDTH = 12,
	60	HDR_HEIGHT = 14,
	61	HDR_BPP = 16,
	62	HDR_ORIENTATION = 17,
	63	HDR_SIZE
	64	};
	65
	66	// TGA color types.
	67	enum
	68	{
	69	wxTGA_UNMAPPED = 0,
	70	wxTGA_MAPPED = 1
	71	};
	72
	73	// ============================================================================
	74	// implementation
	75	// ============================================================================
	76
	77	IMPLEMENT_DYNAMIC_CLASS(wxTGAHandler, wxImageHandler)
	78
	79	#if wxUSE_STREAMS
	80
	81	// ----------------------------------------------------------------------------
	82	// worker functions
	83	// ----------------------------------------------------------------------------
	84
	85	static
	86	void FlipTGA(unsigned char* imageData, int width, int height, short pixelSize)
	87	{
	88	int lineLength = width * pixelSize;
	89	unsigned char *line1 = imageData;
	90	unsigned char line2 = &imageData[lineLength (height - 1)];
	91
	92	unsigned char temp;
	93	for ( ; line1 < line2; line2 -= (lineLength * 2))
	94	{
	95	for (int index = 0; index < lineLength; line1++, line2++, index++)
	96	{
	97	temp = *line1;
	98	line1 = line2;
	99	*line2 = temp;
	100	}
	101	}
	102	}
	103
8fee6306	104	// return wxTGA_OK or wxTGA_IOERR
3af706cc	105	static
8fee6306	106	int DecodeRLE(unsigned char* imageData, unsigned long imageSize,
3af706cc VZ	107	short pixelSize, wxInputStream& stream)
	108	{
	109	unsigned long index = 0;
	110	unsigned char current;
	111	unsigned int length;
	112	unsigned char buf[4];
	113
	114	while (index < imageSize)
	115	{
8fee6306 VZ	116	int ch = stream.GetC();
	117	if ( ch == wxEOF )
	118	return wxTGA_IOERR;
	119
	120	current = ch;
3af706cc VZ	121
	122	// RLE packet.
	123	if ( current & 0x80 )
	124	{
	125	// Get the run length of the packet.
	126	current &= 0x7f;
	127
	128	current++;
	129
	130	length = current;
	131
	132	index += current * pixelSize;
	133
	134	// Repeat the pixel length times.
8fee6306 VZ	135	if ( !stream.Read(buf, pixelSize) )
8fee6306 VZ	136	return wxTGA_IOERR;
3af706cc VZ	137
	138	for (unsigned int i = 0; i < length; i++)
	139	{
	140	memcpy(imageData, buf, pixelSize);
	141
	142	imageData += pixelSize;
	143	}
	144	}
	145	else // Raw packet.
	146	{
	147	// Get the run length of the packet.
	148	current++;
	149
	150	length = current * pixelSize;
	151
	152	index += length;
	153
	154	// Write the next length pixels directly to the image data.
8fee6306 VZ	155	if ( !stream.Read(imageData, length) )
8fee6306 VZ	156	return wxTGA_IOERR;
3af706cc VZ	157
	158	imageData += length;
	159	}
	160	}
8fee6306 VZ	161
8fee6306 VZ	162	return wxTGA_OK;
3af706cc VZ	163	}
	164
	165	static
	166	int ReadTGA(wxImage* image, wxInputStream& stream)
	167	{
	168	// Read in the TGA header
	169	unsigned char hdr[HDR_SIZE];
	170	stream.Read(hdr, HDR_SIZE);
	171
	172	short offset = hdr[HDR_OFFSET] + HDR_SIZE;
	173	short colorType = hdr[HDR_COLORTYPE];
	174	short imageType = hdr[HDR_IMAGETYPE];
	175	int paletteLength = hdr[HDR_PALETTELENGTH] + 256 * hdr[HDR_PALETTELENGTH + 1];
	176	int width = (hdr[HDR_WIDTH] + 256 * hdr[HDR_WIDTH + 1]) -
	177	(hdr[HDR_XORIGIN] + 256 * hdr[HDR_XORIGIN + 1]);
	178	int height = (hdr[HDR_HEIGHT] + 256 * hdr[HDR_HEIGHT + 1]) -
	179	(hdr[HDR_YORIGIN] + 256 * hdr[HDR_YORIGIN + 1]);
	180	short bpp = hdr[HDR_BPP];
	181	short orientation = hdr[HDR_ORIENTATION] & 0x20;
	182
	183	image->Create(width, height);
	184
	185	if (!image->Ok())
	186	{
	187	return wxTGA_MEMERR;
	188	}
	189
	190	const short pixelSize = bpp / 8;
	191
	192	const unsigned long imageSize = width * height * pixelSize;
	193
	194	unsigned char imageData = (unsigned char )malloc(imageSize);
	195
	196	if (!imageData)
	197	{
	198	return wxTGA_MEMERR;
	199	}
	200
56692119 VZ	201	wxON_BLOCK_EXIT1(free, imageData);
56692119 VZ	202
3af706cc VZ	203	unsigned char *dst = image->GetData();
	204
	205	unsigned char* alpha = NULL;
	206	if (bpp == 16 \|\| bpp == 32)
	207	{
	208	image->SetAlpha();
	209
	210	alpha = image->GetAlpha();
	211	}
	212
	213	// Seek from the offset we got from the TGA header.
	214	stream.SeekI(offset, wxFromStart);
	215
	216	// Load a palette if we have one.
	217	if (colorType == wxTGA_MAPPED)
	218	{
	219	unsigned char buf[3];
	220
	221	unsigned char* r = new unsigned char[paletteLength];
	222	unsigned char* g = new unsigned char[paletteLength];
	223	unsigned char* b = new unsigned char[paletteLength];
	224
	225	for (int i = 0; i < paletteLength; i++)
	226	{
	227	stream.Read(buf, 3);
	228
	229	r[i] = buf[2];
	230	g[i] = buf[1];
	231	b[i] = buf[0];
	232	}
	233
6e3d5828	234	#if wxUSE_PALETTE
3af706cc	235	// Set the palette of the image.
3af706cc	236	image->SetPalette(wxPalette(paletteLength, r, g, b));
6e3d5828	237	#endif // wxUSE_PALETTE
3af706cc VZ	238
	239	delete[] r;
	240	delete[] g;
	241	delete[] b;
	242	}
	243
	244	// Handle the various TGA formats we support.
	245
	246	switch (imageType)
	247	{
6e3d5828	248	#if wxUSE_PALETTE
3af706cc VZ	249	// Raw indexed.
	250
	251	case 1:
	252	{
	253	const wxPalette& palette = image->GetPalette();
	254	unsigned char r;
	255	unsigned char g;
	256	unsigned char b;
	257
	258	// No compression read the data directly to imageData.
	259
	260	stream.Read(imageData, imageSize);
	261
	262	// If orientation == 0, then the image is stored upside down.
	263	// We need to store it right side up.
	264
	265	if (orientation == 0)
	266	{
	267	FlipTGA(imageData, width, height, pixelSize);
	268	}
	269
	270	// Handle the different pixel depths.
	271
	272	switch (bpp)
	273	{
	274	// 8 bpp.
	275
	276	case 8:
	277	{
	278	for (unsigned long index = 0; index < imageSize; index += pixelSize)
	279	{
	280	palette.GetRGB(imageData[index], &r, &g, &b);
	281
	282	*(dst++) = r;
	283	*(dst++) = g;
	284	*(dst++) = b;
	285	}
	286	}
	287	break;
	288
	289	// 16 bpp.
	290
	291	case 16:
	292	{
	293	for (unsigned long index = 0; index < imageSize; index += pixelSize)
	294	{
	295	palette.GetRGB(imageData[index], &r, &g, &b);
	296
	297	*(dst++) = r;
	298	*(dst++) = g;
	299	*(dst++) = b;
	300	*(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
	301	}
	302	}
	303	break;
	304
	305	default:
	306	return wxTGA_INVFORMAT;
	307	}
	308	}
	309	break;
6e3d5828	310	#endif // wxUSE_PALETTE
3af706cc VZ	311
	312	// Raw RGB.
	313
	314	case 2:
	315	{
	316	// No compression read the data directly to imageData.
	317
	318	stream.Read(imageData, imageSize);
	319
	320	// If orientation == 0, then the image is stored upside down.
	321	// We need to store it right side up.
	322
	323	if (orientation == 0)
	324	{
	325	FlipTGA(imageData, width, height, pixelSize);
	326	}
	327
	328	// Handle the different pixel depths.
	329
	330	switch (bpp)
	331	{
	332	//16 bpp.
	333
	334	case 16:
	335	{
	336	unsigned char temp;
	337
	338	for (unsigned long index = 0; index < imageSize; index += pixelSize)
	339	{
	340	temp = (imageData[index + 1] & 0x7c) << 1;
	341	temp \|= temp >> 5;
	342	*(dst++) = temp;
	343
	344	temp = ((imageData[index + 1] & 0x03) << 6) \| ((imageData[index] & 0xe0) >> 2);
	345	temp \|= temp >> 5;
	346	*(dst++) = temp;
	347
	348	temp = (imageData[index] & 0x1f) << 3;
	349	temp \|= temp >> 5;
	350	*(dst++) = temp;
	351
	352	*(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
	353	}
	354	}
	355	break;
	356
	357	// 24 bpp.
	358
	359	case 24:
	360	{
	361	for (unsigned long index = 0; index < imageSize; index += pixelSize)
	362	{
	363	*(dst++) = imageData[index + 2];
	364	*(dst++) = imageData[index + 1];
	365	*(dst++) = imageData[index];
	366	}
	367	}
	368	break;
	369
	370	// 32 bpp.
	371
	372	case 32:
	373	{
	374	for (unsigned long index = 0; index < imageSize; index += pixelSize)
375	{
376	*(dst++) = imageData[index + 2];
377	*(dst++) = imageData[index + 1];
378	*(dst++) = imageData[index];
379	*(alpha++) = imageData[index + 3];
380	}
381	}
382	break;
383
384	default:
385	return wxTGA_INVFORMAT;
386	}
387	}
388	break;
389
390	// Raw grayscale.
391
392	case 3:
393	{
394	// No compression read the data directly to imageData.
395
396	stream.Read(imageData, imageSize);
397
398	// If orientation == 0, then the image is stored upside down.
399	// We need to store it right side up.
400
401	if (orientation == 0)
402	{
403	FlipTGA(imageData, width, height, pixelSize);
404	}
405
406	// Handle the different pixel depths.
407
408	switch (bpp)
409	{
410	// 8 bpp.
411
412	case 8:
413	{
414	for (unsigned long index = 0; index < imageSize; index += pixelSize)
415	{
416	*(dst++) = imageData[index];
417	*(dst++) = imageData[index];
418	*(dst++) = imageData[index];
419	}
420	}
421	break;
422
423	// 16 bpp.
424
425	case 16:
426	{
427	for (unsigned long index = 0; index < imageSize; index += pixelSize)
428	{
429	*(dst++) = imageData[index];
430	*(dst++) = imageData[index];
431	*(dst++) = imageData[index];
432	*(alpha++) = imageData[index + 1];
433	}
434	}
435	break;
436
437	default:
438	return wxTGA_INVFORMAT;
439	}
440	}
441	break;
442
6e3d5828	443	#if wxUSE_PALETTE
3af706cc VZ	444	// RLE indexed.
	445
	446	case 9:
	447	{
	448	const wxPalette& palette = image->GetPalette();
	449	unsigned char r;
	450	unsigned char g;
	451	unsigned char b;
	452
	453	// Decode the RLE data.
	454
8fee6306 VZ	455	int rc = DecodeRLE(imageData, imageSize, pixelSize, stream);
	456	if ( rc != wxTGA_OK )
	457	return rc;
3af706cc VZ	458
	459	// If orientation == 0, then the image is stored upside down.
	460	// We need to store it right side up.
	461
	462	if (orientation == 0)
	463	{
	464	FlipTGA(imageData, width, height, pixelSize);
	465	}
	466
	467	// Handle the different pixel depths.
	468
	469	switch (bpp)
	470	{
	471	// 8 bpp.
	472
	473	case 8:
	474	{
	475	for (unsigned long index = 0; index < imageSize; index += pixelSize)
	476	{
	477	palette.GetRGB(imageData[index], &r, &g, &b);
	478
	479	*(dst++) = r;
	480	*(dst++) = g;
	481	*(dst++) = b;
	482	}
	483	}
	484	break;
	485
	486	// 16 bpp.
	487
	488	case 16:
	489	{
	490	for (unsigned long index = 0; index < imageSize; index += pixelSize)
	491	{
	492	palette.GetRGB(imageData[index], &r, &g, &b);
	493
	494	*(dst++) = r;
	495	*(dst++) = g;
	496	*(dst++) = b;
	497	*(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
	498	}
	499	}
	500	break;
	501
	502	default:
	503	return wxTGA_INVFORMAT;
	504	}
	505	}
	506	break;
6e3d5828	507	#endif // wxUSE_PALETTE
3af706cc VZ	508
	509	// RLE RGB.
	510
	511	case 10:
	512	{
	513	// Decode the RLE data.
	514
8fee6306 VZ	515	int rc = DecodeRLE(imageData, imageSize, pixelSize, stream);
	516	if ( rc != wxTGA_OK )
	517	return rc;
3af706cc VZ	518
	519	// If orientation == 0, then the image is stored upside down.
	520	// We need to store it right side up.
	521
	522	if (orientation == 0)
	523	{
	524	FlipTGA(imageData, width, height, pixelSize);
	525	}
	526
	527	// Handle the different pixel depths.
	528
	529	switch (bpp)
	530	{
	531	//16 bpp.
	532
	533	case 16:
	534	{
	535	unsigned char temp;
	536
	537	for (unsigned long index = 0; index < imageSize; index += pixelSize)
	538	{
	539	temp = (imageData[index + 1] & 0x7c) << 1;
	540	temp \|= temp >> 5;
	541	*(dst++) = temp;
	542
	543	temp = ((imageData[index + 1] & 0x03) << 6) \| ((imageData[index] & 0xe0) >> 2);
	544	temp \|= temp >> 5;
	545	*(dst++) = temp;
	546
	547	temp = (imageData[index] & 0x1f) << 3;
	548	temp \|= temp >> 5;
	549	*(dst++) = temp;
	550
	551	*(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
	552	}
	553	}
	554	break;
	555
	556	// 24 bpp.
	557
	558	case 24:
	559	{
	560	for (unsigned long index = 0; index < imageSize; index += pixelSize)
	561	{
	562	*(dst++) = imageData[index + 2];
	563	*(dst++) = imageData[index + 1];
	564	*(dst++) = imageData[index];
	565	}
	566	}
	567	break;
	568
	569	// 32 bpp.
	570
	571	case 32:
	572	{
	573	for (unsigned long index = 0; index < imageSize; index += pixelSize)
	574	{
	575	*(dst++) = imageData[index + 2];
	576	*(dst++) = imageData[index + 1];
	577	*(dst++) = imageData[index];
	578	*(alpha++) = imageData[index + 3];
	579	}
	580	}
	581	break;
582
583	default:
584	return wxTGA_INVFORMAT;
585	}
586	}
587	break;
588
589	// RLE grayscale.
590
591	case 11:
592	{
593	// Decode the RLE data.
594
8fee6306 VZ	595	int rc = DecodeRLE(imageData, imageSize, pixelSize, stream);
	596	if ( rc != wxTGA_OK )
	597	return rc;
3af706cc VZ	598
	599	// If orientation == 0, then the image is stored upside down.
	600	// We need to store it right side up.
	601
	602	if (orientation == 0)
	603	{
	604	FlipTGA(imageData, width, height, pixelSize);
	605	}
	606
	607	// Handle the different pixel depths.
	608
	609	switch (bpp)
	610	{
	611	// 8 bpp.
	612
	613	case 8:
	614	{
	615	for (unsigned long index = 0; index < imageSize; index += pixelSize)
	616	{
	617	*(dst++) = imageData[index];
	618	*(dst++) = imageData[index];
	619	*(dst++) = imageData[index];
	620	}
	621	}
	622	break;
	623
	624	// 16 bpp.
	625
	626	case 16:
	627	{
	628	for (unsigned long index = 0; index < imageSize; index += pixelSize)
	629	{
	630	*(dst++) = imageData[index];
	631	*(dst++) = imageData[index];
	632	*(dst++) = imageData[index];
	633	*(alpha++) = imageData[index + 1];
	634	}
	635	}
	636	break;
	637
	638	default:
	639	return wxTGA_INVFORMAT;
	640	}
	641	}
	642	break;
	643
	644	default:
	645	return wxTGA_INVFORMAT;
	646	}
	647
3af706cc VZ	648	return wxTGA_OK;
	649	}
	650
	651	static
	652	int SaveTGA(wxImage* WXUNUSED(image), wxOutputStream& WXUNUSED(stream))
	653	{
	654	wxLogError(wxT("Saving in TGA format is not implemented."));
	655
	656	return wxTGA_OK;
	657	}
	658
	659	// ----------------------------------------------------------------------------
	660	// wxTGAHandler
	661	// ----------------------------------------------------------------------------
	662
	663	bool wxTGAHandler::LoadFile(wxImage* image,
	664	wxInputStream& stream,
	665	bool verbose,
	666	int WXUNUSED(index))
	667	{
	668	if ( !CanRead(stream) )
	669	{
	670	if ( verbose )
	671	wxLogError(wxT("TGA: this is not a TGA file."));
	672
	673	return false;
	674	}
	675
	676	image->Destroy();
	677
	678	int error = ReadTGA(image, stream);
	679	if ( error != wxTGA_OK )
	680	{
	681	if ( verbose )
	682	{
	683	switch ( error )
	684	{
	685	case wxTGA_INVFORMAT:
	686	wxLogError(wxT("TGA: image format unsupported."));
	687	break;
	688
	689	case wxTGA_MEMERR:
	690	wxLogError(wxT("TGA: couldn't allocate memory."));
	691	break;
	692
8fee6306 VZ	693	case wxTGA_IOERR:
	694	wxLogError(wxT("TGA: couldn't read image data."));
	695	break;
	696
3af706cc VZ	697	default:
	698	wxLogError(wxT("TGA: unknown error!"));
	699	}
	700	}
	701
	702	image->Destroy();
	703
	704	return false;
	705	}
	706
	707	return true;
	708	}
	709
	710	bool wxTGAHandler::SaveFile(wxImage* image, wxOutputStream& stream, bool verbose)
	711	{
	712	int error = SaveTGA(image, stream);
	713
	714	if ( error != wxTGA_OK )
	715	{
	716	if ( verbose )
	717	{
	718	switch ( error )
	719	{
	720	case wxTGA_INVFORMAT:
	721	wxLogError(wxT("TGA: invalid image."));
	722	break;
	723
	724	case wxTGA_MEMERR:
	725	wxLogError(wxT("TGA: couldn't allocate memory."));
	726	break;
	727
	728	default:
	729	wxLogError(wxT("TGA: unknown error!"));
	730	}
	731	}
	732
	733	return false;
	734	}
	735
	736	return true;
	737	}
	738
	739	bool wxTGAHandler::DoCanRead(wxInputStream& stream)
	740	{
	741	// read the fixed-size TGA headers
	742	unsigned char hdr[HDR_SIZE];
	743	stream.Read(hdr, HDR_SIZE);
	744
	745	// Check wether we can read the file or not.
	746
	747	short colorType = hdr[HDR_COLORTYPE];
	748	if ( colorType != wxTGA_UNMAPPED && colorType != wxTGA_MAPPED )
	749	{
	750	return false;
	751	}
	752
	753	short imageType = hdr[HDR_IMAGETYPE];
	754	if ( imageType == 0 \|\| imageType == 32 \|\| imageType == 33 )
	755	{
	756	return false;
	757	}
	758
	759	short bpp = hdr[HDR_BPP];
	760	if ( bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32 )
761	{
762	return false;
763	}
764
765	return true;
766	}
767
768	#endif // wxUSE_STREAMS
769
770	#endif // wxUSE_IMAGE && wxUSE_TGA