src/common/imagtga.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/imagtga.cpp
// Purpose:     wxImage TGA handler
// Author:      Seth Jackson
// 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;

            if (index >= imageSize)
            {
                return wxTGA_IOERR;
            }

            // 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;

            if (index >= imageSize)
            {
                return wxTGA_IOERR;
            }

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

            imageData += length;
        }
    }

    return wxTGA_OK;
}

/*
Mimic the behaviour of wxPalette.GetRGB and the way the TGA image handler
used it. That is: don't check the return value of GetRGB and continue decoding
using previous RGB values.

It might be better to check for palette index bounds and stop decoding if
it's out of range (and add something like wxTGA_DATAERR to indicate unexpected
pixel data).
*/
static
void Palette_GetRGB(const unsigned char *palette, unsigned int paletteCount,
    unsigned int index,
    unsigned char *red, unsigned char *green, unsigned char *blue)
{
    if (index >= paletteCount)
    {
        return;
    }

    *red   = palette[index];
    *green = palette[(paletteCount * 1) + index];
    *blue  = palette[(paletteCount * 2) + index];
}

static
void Palette_SetRGB(unsigned char *palette, unsigned int paletteCount,
    unsigned int index,
    unsigned char red, unsigned char green, unsigned char blue)
{
    palette[index] = red;
    palette[(paletteCount * 1) + index] = green;
    palette[(paletteCount * 2) + index] = blue;
}

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];
    unsigned 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->IsOk())
    {
        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.
    if (stream.SeekI(offset, wxFromStart) == wxInvalidOffset)
        return wxTGA_INVFORMAT;

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

        palette = (unsigned char *) malloc(paletteLength * 3);

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

            Palette_SetRGB(palette, paletteLength, i, buf[2], buf[1], buf[0]);
        }

#if wxUSE_PALETTE
        // Set the palette of the image.
        image->SetPalette(wxPalette((int) paletteLength, &palette[0],
            &palette[paletteLength * 1], &palette[paletteLength * 2]));
#endif // wxUSE_PALETTE

    }

    wxON_BLOCK_EXIT1(free, palette);

    // Handle the various TGA formats we support.

    switch (imageType)
    {
        // Raw indexed.

        case 1:
        {
            unsigned char r = 0;
            unsigned char g = 0;
            unsigned char b = 0;

            // 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(palette, paletteLength,
                            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(palette, paletteLength,
                            imageData[index], &r, &g, &b);

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

                default:
                    return wxTGA_INVFORMAT;
            }
        }
        break;

        // 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;

        // RLE indexed.

        case 9:
        {
            unsigned char r = 0;
            unsigned char g = 0;
            unsigned char b = 0;

            // 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(palette, paletteLength,
                            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(palette, paletteLength,
                            imageData[index], &r, &g, &b);

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

                default:
                    return wxTGA_INVFORMAT;
            }
        }
        break;

        // 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(const wxImage& image, wxOutputStream *stream)
{
    bool hasAlpha = image.HasAlpha();
    unsigned bytesPerPixel = 3 + (hasAlpha ? 1 : 0);
    wxSize size = image.GetSize();
    size_t scanlineSize = size.x * bytesPerPixel;
    unsigned char *scanlineData = (unsigned char *) malloc(scanlineSize);
    if (!scanlineData)
    {
        return wxTGA_MEMERR;
    }

    wxON_BLOCK_EXIT1(free, scanlineData);

    // Compose and write the TGA header
    unsigned char hdr[HDR_SIZE];
    (void) memset(&hdr, 0, HDR_SIZE);

    hdr[HDR_COLORTYPE] = wxTGA_UNMAPPED;
    hdr[HDR_IMAGETYPE] = 2 /* Uncompressed truecolour */;

    hdr[HDR_WIDTH] =  size.x & 0xFF;
    hdr[HDR_WIDTH + 1] =  (size.x >> 8) & 0xFF;

    hdr[HDR_HEIGHT] =  size.y & 0xFF;
    hdr[HDR_HEIGHT + 1] =  (size.y >> 8) & 0xFF;

    hdr[HDR_BPP] = hasAlpha ? 32 : 24;
    hdr[HDR_ORIENTATION] = 1 << 5; // set bit to indicate top-down order
    if (hasAlpha)
    {
        hdr[HDR_ORIENTATION] |= 8; // number of alpha bits
    }

    if ( !stream->Write(hdr, HDR_SIZE) )
    {
        return wxTGA_IOERR;
    }


    // Write image data, converting RGB to BGR and adding alpha if applicable

    unsigned char *src = image.GetData();
    unsigned char *alpha = image.GetAlpha();
    for (int y = 0; y < size.y; ++y)
    {
        unsigned char *dst = scanlineData;
        for (int x = 0; x < size.x; ++x)
        {
            dst[0] = src[2];
            dst[1] = src[1];
            dst[2] = src[0];
            if (alpha)
            {
                dst[3] = *(alpha++);
            }
            src += 3;
            dst += bytesPerPixel;
        }
        if ( !stream->Write(scanlineData, scanlineSize) )
        {
            return wxTGA_IOERR;
        }
    }

    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_MEMERR:
                    wxLogError(wxT("TGA: couldn't allocate memory."));
                    break;

                case wxTGA_IOERR:
                    wxLogError(wxT("TGA: couldn't write image data."));
                    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);     // it's ok to modify the stream position here

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