PCX handler now working for reading (8bit and 24bit images).

Still no wxPCXHandler::SaveFile, though.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3518 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

src/common/imagpcx.cpp

@@ -3,8 +3,8 @@
 // Purpose:     wxImage PCX handler
 // Author:      Guillermo Rodriguez Garcia <guille@iies.es>
 // Version:     1.00
-// Last rev:    1999/08/24
+// CVS-ID:      $Id$
-// Copyright:   (c) Guillermo Rodriguez Garcia
+// Copyright:   (c) 1999 Guillermo Rodriguez Garcia
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -25,6 +25,185 @@
 #include "wx/module.h"
 #include "wx/log.h"
 
+//-----------------------------------------------------------------------------
+// PCX decoding
+//-----------------------------------------------------------------------------
+
+void RLEencode(unsigned char *p, unsigned int size, wxOutputStream& s)
+{
+}
+
+void RLEdecode(unsigned char *p, unsigned int size, wxInputStream& s)
+{
+    unsigned int i, data, cont;
+
+    // Read 'size' bytes. The PCX official specs say there will be
+    // a decoding break at the end of each scanline (but not at the
+    // end of each plane inside a scanline). Only use this function
+    // to read one or more _complete_ scanlines. Else, more than
+    // 'size' bytes might be read and the buffer might overflow.
+    //
+    while (size > 0)
+    {
+        data = (unsigned char)s.GetC();
+
+        // If ((data & 0xC0) != 0xC0), then the value read is a data
+        // byte. Else, it is a counter (cont = val & 0x3F) and the
+        // next byte is the data byte.
+        //
+        if ((data & 0xC0) != 0xC0)
+        {
+            *(p++) = data;
+            size--;
+        }
+        else
+        {
+            cont = data & 0x3F;
+            data = (unsigned char)s.GetC();
+            for (i = 1; i <= cont; i++)
+                *(p++) = data;
+            size -= cont;
+        }
+    }
+}
+
+
+/* PCX header */
+#define HDR_VERSION         1        
+#define HDR_ENCODING        2
+#define HDR_BITSPERPIXEL    3
+#define HDR_XMIN            4
+#define HDR_YMIN            6
+#define HDR_XMAX            8 
+#define HDR_YMAX            10
+#define HDR_NPLANES         65
+#define HDR_BYTESPERLINE    66
+
+/* image formats */
+#define IMAGE_8BIT  0       // 8 bpp, 1 plane (8 bit)
+#define IMAGE_24BIT 1       // 8 bpp, 3 planes (24 bit)
+
+/* error codes */
+#define E_OK        0       // everything was OK
+#define E_FORMATO   1       // error in pcx file format
+#define E_MEMORIA   2       // error allocating memory
+#define E_VERSION   3       // error in pcx version number
+
+
+// ReadPCX:
+//  Loads a PCX file into the wxImage object pointed by image.
+//  Returns E_OK on success, or an error code otherwise (see
+//  above for error codes)
+//
+int ReadPCX(wxImage *image, wxInputStream& stream)
+{
+    unsigned char hdr[128];         // PCX header
+    unsigned char pal[768];         // palette for 8 bit images
+    unsigned char *p;               // space to store one scanline
+    unsigned char *dst;             // pointer into wxImage data
+    unsigned int width, height;     // size of the image
+    unsigned int bytesperline;      // bytes per line (each plane)
+    int bitsperpixel;               // bits per pixel (each plane)
+    int nplanes;                    // number of planes
+    int encoding;                   // is the image RLE encoded?
+    int format;                     // image format (8 bit, 24 bit)
+    unsigned int i;
+    off_t pos;
+
+    // Read PCX header and check the version number (it must
+    // be at least 5 or higher for 8 bit and 24 bit images).
+    //
+    stream.Read(hdr, 128);
+
+    if (hdr[HDR_VERSION] < 5) return E_VERSION;
+
+    // Extract all image info from the PCX header.
+    //
+    encoding     = hdr[HDR_ENCODING];
+    nplanes      = hdr[HDR_NPLANES];
+    bitsperpixel = hdr[HDR_BITSPERPIXEL];
+    bytesperline = hdr[HDR_BYTESPERLINE] + 256 * hdr[HDR_BYTESPERLINE + 1];
+    width        = (hdr[HDR_XMAX] + 256 * hdr[HDR_XMAX + 1]) -
+                   (hdr[HDR_XMIN] + 256 * hdr[HDR_XMIN + 1]) + 1;
+    height       = (hdr[HDR_YMAX] + 256 * hdr[HDR_YMAX + 1]) -
+                   (hdr[HDR_YMIN] + 256 * hdr[HDR_YMIN + 1]) + 1;
+
+    // Check image format. Currently supported formats are
+    // 8 bits (8 bpp, 1 plane) and 24 bits (8 bpp, 3 planes).
+    //
+    if ((nplanes == 3) && (bitsperpixel == 8))
+        format = IMAGE_24BIT;
+    else if ((nplanes == 1) && (bitsperpixel == 8))
+        format = IMAGE_8BIT;
+    else
+        return E_FORMATO;
+
+    // If the image is of type IMAGE_8BIT, then there is a
+    // palette at the end of the file. Read it now before
+    // proceeding.
+    //
+    pos = stream.TellI();
+    stream.SeekI(-769, wxFromEnd);
+
+    if (stream.GetC() != 12)
+        return E_FORMATO;
+
+    stream.Read(pal, 768);
+    stream.SeekI(pos, wxFromStart);
+
+    // Allocate memory for a scanline and resize the image.
+    //
+    image->Create(width, height);
+
+    if (!image->Ok())
+        return E_MEMORIA;
+
+    if ((p = (unsigned char *) malloc(bytesperline * nplanes)) == NULL)
+        return E_MEMORIA;
+
+    // Now start reading the file, line by line, and store
+    // the data in the format required by wxImage.
+    //
+    dst = image->GetData();
+
+    for (; height; height--)
+    {
+        if (encoding)
+            RLEdecode(p, bytesperline * nplanes, stream);
+        else
+            stream.Read(p, bytesperline * nplanes);
+
+        switch (format)
+        {
+            case IMAGE_8BIT:
+            {
+                for (i = 0; i < width; i++)
+                {
+                    *(dst++) = pal[ 3 * (p[i]) ];
+                    *(dst++) = pal[ 3 * (p[i]) + 1];
+                    *(dst++) = pal[ 3 * (p[i]) + 2];
+                }
+                break;
+            }
+            case IMAGE_24BIT:
+            {
+                for (i = 0; i < width; i++)
+                {
+                    *(dst++) = p[i];
+                    *(dst++) = p[i + bytesperline];
+                    *(dst++) = p[i + 2 * bytesperline]; 
+                }
+                break;
+            }
+        }
+    }
+
+    free(p);
+
+    return E_OK;
+}
+
+
 //-----------------------------------------------------------------------------
 // wxPCXHandler
 //-----------------------------------------------------------------------------
@@ -37,25 +216,57 @@ IMPLEMENT_DYNAMIC_CLASS(wxPCXHandler,wxImageHandler)
 
 bool wxPCXHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose )
 {
+    int error;
+
+    if (!CanRead(stream))
+    {
+        if (verbose)
+            wxLogError(_T("wxPCXHandler: this is not a PCX file"));
+
+        return FALSE;
+    }
+
     image->Destroy();
 
-    if (verbose)
+    if ((error = ReadPCX(image, stream)) != E_OK)
-        wxLogDebug(_T("wxPCXHandler::LoadFile still not implemented"));
+    {
+        if (verbose)
+        {
+            switch (error)
+            {
+                case E_FORMATO: wxLogError(_T("wxPCXHandler: image format unsupported")); break;
+                case E_MEMORIA: wxLogError(_T("wxPCXHandler: couldn't allocate memory")); break;
+                case E_VERSION: wxLogError(_T("wxPCXHandler: version number too low")); break;
+                default:        wxLogError(_T("wxPCXHandler: unknown error !!!"));
+            }
+        }
+        image->Destroy();
+        return FALSE;
+    }
 
-    return FALSE;
+    return TRUE;
 }
 
 bool wxPCXHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose )
 {
     if (verbose)
-        wxLogDebug(_T("wxPCXHandler::SaveFile still not implemented"));
+        wxLogError(_T("wxPCXHandler::SaveFile still not implemented"));
 
     return FALSE;
 }
 
 bool wxPCXHandler::CanRead( wxInputStream& stream )
 {
-    return FALSE;
+    unsigned char c;
+    off_t pos;
+
+    pos = stream.TellI();
+    stream.SeekI(0, wxFromStart);
+    c = stream.GetC();
+    stream.SeekI(pos, wxFromStart);
+
+    // not very safe, but this is all we can get from PCX header :-(
+    return (c == 10);
 }