[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 = 0,
    wxTGA_INVFORMAT = 1,
    wxTGA_MEMERR = 2
};

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

static
void 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)
    {
        current = stream.GetC();

        // 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.
            stream.Read(buf, pixelSize);

            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.
            stream.Read(imageData, length);

            imageData += length;
        }
    }
}

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.

            DecodeRLE(imageData, imageSize, pixelSize, stream);

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

            DecodeRLE(imageData, imageSize, pixelSize, stream);

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

            DecodeRLE(imageData, imageSize, pixelSize, stream);

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

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