+/////////////////////////////////////////////////////////////////////////////
+// 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"
+
+// ----------------------------------------------------------------------------
+// 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;
+ }
+
+ 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)
+ {
+ // 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;
+
+ // 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:
+ {
+ 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;
+
+ // 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;
+ }
+
+ free(imageData);
+
+ 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
projects / wxWidgets.git / commitdiff
