src/common/imagpcx.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        imagpcx.cpp
// Purpose:     wxImage PCX handler
// Author:      Guillermo Rodriguez Garcia <guille@iies.es>
// Version:     1.00
// CVS-ID:      $Id$
// Copyright:   (c) 1999 Guillermo Rodriguez Garcia
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "imagpcx.h"
#endif

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

#ifdef __BORLANDC__
#pragma hdrstop
#endif

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

#if wxUSE_STREAMS && wxUSE_PCX

#include "wx/imagpcx.h"
#include "wx/wfstream.h"
#include "wx/module.h"
#include "wx/log.h"
#include "wx/intl.h"

#include "wx/hash.h"
#include "wx/list.h"
#include "wx/object.h"

//-----------------------------------------------------------------------------
// PCX decoding
//-----------------------------------------------------------------------------

void RLEencode(unsigned char *p, unsigned int size, wxOutputStream& s)
{
    unsigned int data, last, cont;

    // Write 'size' bytes. The PCX official specs say there will be
    // a decoding break at the end of each scanline, so in order to
    // force this decoding break use this function to write, at most,
    // _one_ complete scanline at a time.

    last = (unsigned char) *(p++);
    cont = 1;
    size--;

    while (size-- > 0)
    {
        data = (unsigned char) *(p++);

        // Up to 63 bytes with the same value can be stored using a
        // single { cont, value } pair.
        //
        if ((data == last) && (cont < 63))
        {
            cont++;
        }
        else
        {
            // Need to write a 'counter' byte?
            //
            if ((cont > 1) || ((last & 0xC0) == 0xC0))
                s.PutC((char) (cont | 0xC0));

            s.PutC((char) last);
            last = data;
            cont = 1;
        }
    }


    // Write the last one and return;
    //
    if ((cont > 1) || ((last & 0xC0) == 0xC0))
        s.PutC((char) (cont | 0xC0));

    s.PutC((char) last);
}

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_MANUFACTURER    0
#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
#define HDR_PALETTEINFO     68

// image formats
enum {
    wxPCX_8BIT,             // 8 bpp, 1 plane (8 bit)
    wxPCX_24BIT             // 8 bpp, 3 planes (24 bit)
};

// error codes
enum {
    wxPCX_OK = 0,           // everything was OK
    wxPCX_INVFORMAT = 1,    // error in pcx file format
    wxPCX_MEMERR = 2,       // error allocating memory
    wxPCX_VERERR = 3        // error in pcx version number
};


// ReadPCX:
//  Loads a PCX file into the wxImage object pointed by image.
//  Returns wxPCX_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 wxPCX_VERERR;

    // 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 = wxPCX_24BIT;
    else if ((nplanes == 1) && (bitsperpixel == 8))
        format = wxPCX_8BIT;
    else
        return wxPCX_INVFORMAT;

    // If the image is of type wxPCX_8BIT, then there is a
    // palette at the end of the file. Read it now before
    // proceeding.
    //
    if (format == wxPCX_8BIT)
    {
        pos = stream.TellI();
        stream.SeekI(-769, wxFromEnd);

        if (stream.GetC() != 12)
            return wxPCX_INVFORMAT;

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

    if ((p = (unsigned char *) malloc(bytesperline * nplanes)) == NULL)
        return wxPCX_MEMERR;

    // 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 wxPCX_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 wxPCX_24BIT:
            {
                for (i = 0; i < width; i++)
                {
                    *(dst++) = p[i];
                    *(dst++) = p[i + bytesperline];
                    *(dst++) = p[i + 2 * bytesperline];
                }
                break;
            }
        }
    }

    free(p);

    return wxPCX_OK;
}

// SavePCX:
//  Saves a PCX file into the wxImage object pointed by image.
//  Returns wxPCX_OK on success, or an error code otherwise
//  (see above for error codes). Currently, always saves images
//  in 24 bit format. XXX
//
int SavePCX(wxImage *image, wxOutputStream& 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 *src;             // pointer into wxImage data
    unsigned int width, height;     // size of the image
    unsigned int bytesperline;      // bytes per line (each plane)
    int nplanes;                    // number of planes
    int format;                     // image format (8 bit, 24 bit)
    wxHashTable h(wxKEY_INTEGER);   // image histogram
    unsigned long ncolours;         // num. of different colours
    unsigned long key;              // key in the hashtable
    unsigned int i;

    // Get the histogram of the image, and decide whether to save
    // as 8 bit or 24 bit, according to the number of colours.
    //
    ncolours = image->CountColours(257);

    if (ncolours <= 256)
    {
        image->ComputeHistogram(h);
        format = wxPCX_8BIT;
        nplanes = 1;
    }
    else
    {
        format = wxPCX_24BIT;
        nplanes = 3;
    }

    // Get image dimensions, calculate bytesperline (must be even,
    // according to PCX specs) and allocate space for one complete
    // scanline.
    //
    if (!image->Ok())
        return wxPCX_INVFORMAT;

    width = image->GetWidth();
    height = image->GetHeight();
    bytesperline = width;
    if (bytesperline % 2)
        bytesperline++;

    if ((p = (unsigned char *) malloc(bytesperline * nplanes)) == NULL)
        return wxPCX_MEMERR;

    // Build header data and write it to the stream. Initially,
    // set all bytes to zero (most values default to zero).
    //
    memset(hdr, 0, sizeof(hdr));

    hdr[HDR_MANUFACTURER]     = 10;
    hdr[HDR_VERSION]          = 5;
    hdr[HDR_ENCODING]         = 1;
    hdr[HDR_NPLANES]          = nplanes;
    hdr[HDR_BITSPERPIXEL]     = 8;
    hdr[HDR_BYTESPERLINE]     = bytesperline % 256;
    hdr[HDR_BYTESPERLINE + 1] = bytesperline / 256;
    hdr[HDR_XMAX]             = (width - 1)  % 256;
    hdr[HDR_XMAX + 1]         = (width - 1)  / 256;
    hdr[HDR_YMAX]             = (height - 1) % 256;
    hdr[HDR_YMAX + 1]         = (height - 1) / 256;
    hdr[HDR_PALETTEINFO]      = 1;

    stream.Write(hdr, 128);

    // Encode image data line by line and write it to the stream
    //
    src = image->GetData();

    for (; height; height--)
    {
        switch (format)
        {
            case wxPCX_8BIT:
            {
                unsigned char r, g, b;
                wxHNode *hnode;

                for (i = 0; i < width; i++)
                {
                    r = *(src++);
                    g = *(src++);
                    b = *(src++);
                    key = (r << 16) | (g << 8) | b;

                    hnode = (wxHNode *) h.Get(key);
                    p[i] = hnode->index;
                }
                break;
            }
            case wxPCX_24BIT:
            {
                for (i = 0; i < width; i++)
                {
                    p[i] = *(src++);
                    p[i + bytesperline] = *(src++);
                    p[i + 2 * bytesperline] = *(src++);
                }
                break;
            }
        }

        RLEencode(p, bytesperline * nplanes, stream);
    }

    free(p);

    // For 8 bit images, build the palette and write it to the stream
    //
    if (format == wxPCX_8BIT)
    {
        wxNode *node;
        wxHNode *hnode;

        // zero unused colours
        memset(pal, 0, sizeof(pal));

        h.BeginFind();
        while ((node = h.Next()) != NULL)
        {
            key = node->GetKeyInteger();
            hnode = (wxHNode *) node->GetData();

            pal[3 * hnode->index]     = (unsigned char)(key >> 16);
            pal[3 * hnode->index + 1] = (unsigned char)(key >> 8);
            pal[3 * hnode->index + 2] = (unsigned char)(key);
            delete hnode;
        }

        stream.PutC(12);
        stream.Write(pal, 768);
    }

    return wxPCX_OK;
}

//-----------------------------------------------------------------------------
// wxPCXHandler
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxPCXHandler,wxImageHandler)

bool wxPCXHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) )
{
    int error;

    if (!CanRead(stream))
    {
        if (verbose)
            wxLogError(_("PCX: this is not a PCX file."));

        return FALSE;
    }

    image->Destroy();

    if ((error = ReadPCX(image, stream)) != wxPCX_OK)
    {
        if (verbose)
        {
            switch (error)
            {
                case wxPCX_INVFORMAT: wxLogError(_("wxPCXHandler: image format unsupported")); break;
                case wxPCX_MEMERR:    wxLogError(_("wxPCXHandler: couldn't allocate memory")); break;
                case wxPCX_VERERR:    wxLogError(_("wxPCXHandler: version number too low")); break;
                default:              wxLogError(_("wxPCXHandler: unknown error !!!"));
            }
        }
        image->Destroy();
        return FALSE;
    }

    return TRUE;
}

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

    if ((error = SavePCX(image, stream)) != wxPCX_OK)
    {
        if (verbose)
        {
            switch (error)
            {
                case wxPCX_INVFORMAT: wxLogError(_("wxPCXHandler: invalid image")); break;
                case wxPCX_MEMERR:    wxLogError(_("wxPCXHandler: couldn't allocate memory")); break;
                default:              wxLogError(_("wxPCXHandler: unknown error !!!"));
            }
        }
    }

    return (error == wxPCX_OK);
}

bool wxPCXHandler::DoCanRead( wxInputStream& stream )
{
    unsigned char c;

    c = stream.GetC();
    stream.SeekI(-1, wxFromCurrent);

    // not very safe, but this is all we can get from PCX header :-(
    return (c == 10);
}

#endif // wxUSE_STREAMS && wxUSE_PCX
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: imagpcx.cpp
	3	// Purpose: wxImage PCX handler
	4	// Author: Guillermo Rodriguez Garcia <guille@iies.es>
	5	// Version: 1.00
	6	// CVS-ID: $Id$
	7	// Copyright: (c) 1999 Guillermo Rodriguez Garcia
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	#ifdef __GNUG__
	12	#pragma implementation "imagpcx.h"
	13	#endif
	14
	15	// For compilers that support precompilation, includes "wx.h".
	16	#include "wx/wxprec.h"
	17
	18	#ifdef __BORLANDC__
	19	#pragma hdrstop
	20	#endif
	21
	22	#ifndef WX_PRECOMP
	23	# include "wx/defs.h"
	24	#endif
	25
	26	#if wxUSE_STREAMS && wxUSE_PCX
	27
	28	#include "wx/imagpcx.h"
	29	#include "wx/wfstream.h"
	30	#include "wx/module.h"
	31	#include "wx/log.h"
	32	#include "wx/intl.h"
	33
	34	#include "wx/hash.h"
	35	#include "wx/list.h"
	36	#include "wx/object.h"
	37
	38	//-----------------------------------------------------------------------------
	39	// PCX decoding
	40	//-----------------------------------------------------------------------------
	41
	42	void RLEencode(unsigned char *p, unsigned int size, wxOutputStream& s)
	43	{
	44	unsigned int data, last, cont;
	45
	46	// Write 'size' bytes. The PCX official specs say there will be
	47	// a decoding break at the end of each scanline, so in order to
	48	// force this decoding break use this function to write, at most,
	49	// _one_ complete scanline at a time.
	50
	51	last = (unsigned char) *(p++);
	52	cont = 1;
	53	size--;
	54
	55	while (size-- > 0)
	56	{
	57	data = (unsigned char) *(p++);
	58
	59	// Up to 63 bytes with the same value can be stored using a
	60	// single { cont, value } pair.
	61	//
	62	if ((data == last) && (cont < 63))
	63	{
	64	cont++;
	65	}
	66	else
	67	{
	68	// Need to write a 'counter' byte?
	69	//
	70	if ((cont > 1) \|\| ((last & 0xC0) == 0xC0))
	71	s.PutC((char) (cont \| 0xC0));
	72
	73	s.PutC((char) last);
	74	last = data;
	75	cont = 1;
	76	}
	77	}
	78
	79
	80	// Write the last one and return;
	81	//
	82	if ((cont > 1) \|\| ((last & 0xC0) == 0xC0))
	83	s.PutC((char) (cont \| 0xC0));
	84
	85	s.PutC((char) last);
	86	}
	87
	88	void RLEdecode(unsigned char *p, unsigned int size, wxInputStream& s)
	89	{
	90	unsigned int i, data, cont;
	91
	92	// Read 'size' bytes. The PCX official specs say there will be
	93	// a decoding break at the end of each scanline (but not at the
	94	// end of each plane inside a scanline). Only use this function
	95	// to read one or more _complete_ scanlines. Else, more than
	96	// 'size' bytes might be read and the buffer might overflow.
	97	//
	98	while (size > 0)
	99	{
	100	data = (unsigned char)s.GetC();
	101
	102	// If ((data & 0xC0) != 0xC0), then the value read is a data
	103	// byte. Else, it is a counter (cont = val & 0x3F) and the
	104	// next byte is the data byte.
	105	//
	106	if ((data & 0xC0) != 0xC0)
	107	{
	108	*(p++) = data;
	109	size--;
	110	}
	111	else
	112	{
	113	cont = data & 0x3F;
	114	data = (unsigned char)s.GetC();
	115	for (i = 1; i <= cont; i++)
	116	*(p++) = data;
	117	size -= cont;
	118	}
	119	}
	120	}
	121
	122
	123	/* PCX header */
	124	#define HDR_MANUFACTURER 0
	125	#define HDR_VERSION 1
	126	#define HDR_ENCODING 2
	127	#define HDR_BITSPERPIXEL 3
	128	#define HDR_XMIN 4
	129	#define HDR_YMIN 6
	130	#define HDR_XMAX 8
	131	#define HDR_YMAX 10
	132	#define HDR_NPLANES 65
	133	#define HDR_BYTESPERLINE 66
	134	#define HDR_PALETTEINFO 68
	135
	136	// image formats
	137	enum {
	138	wxPCX_8BIT, // 8 bpp, 1 plane (8 bit)
	139	wxPCX_24BIT // 8 bpp, 3 planes (24 bit)
	140	};
	141
	142	// error codes
	143	enum {
	144	wxPCX_OK = 0, // everything was OK
	145	wxPCX_INVFORMAT = 1, // error in pcx file format
	146	wxPCX_MEMERR = 2, // error allocating memory
	147	wxPCX_VERERR = 3 // error in pcx version number
	148	};
	149
	150
	151	// ReadPCX:
	152	// Loads a PCX file into the wxImage object pointed by image.
	153	// Returns wxPCX_OK on success, or an error code otherwise
	154	// (see above for error codes)
	155	//
	156	int ReadPCX(wxImage *image, wxInputStream& stream)
	157	{
	158	unsigned char hdr[128]; // PCX header
	159	unsigned char pal[768]; // palette for 8 bit images
	160	unsigned char *p; // space to store one scanline
	161	unsigned char *dst; // pointer into wxImage data
	162	unsigned int width, height; // size of the image
	163	unsigned int bytesperline; // bytes per line (each plane)
	164	int bitsperpixel; // bits per pixel (each plane)
	165	int nplanes; // number of planes
	166	int encoding; // is the image RLE encoded?
	167	int format; // image format (8 bit, 24 bit)
	168	unsigned int i;
	169	off_t pos;
	170
	171	// Read PCX header and check the version number (it must
	172	// be at least 5 or higher for 8 bit and 24 bit images).
	173	//
	174	stream.Read(hdr, 128);
	175
	176	if (hdr[HDR_VERSION] < 5) return wxPCX_VERERR;
	177
	178	// Extract all image info from the PCX header.
	179	//
	180	encoding = hdr[HDR_ENCODING];
	181	nplanes = hdr[HDR_NPLANES];
	182	bitsperpixel = hdr[HDR_BITSPERPIXEL];
	183	bytesperline = hdr[HDR_BYTESPERLINE] + 256 * hdr[HDR_BYTESPERLINE + 1];
	184	width = (hdr[HDR_XMAX] + 256 * hdr[HDR_XMAX + 1]) -
	185	(hdr[HDR_XMIN] + 256 * hdr[HDR_XMIN + 1]) + 1;
	186	height = (hdr[HDR_YMAX] + 256 * hdr[HDR_YMAX + 1]) -
	187	(hdr[HDR_YMIN] + 256 * hdr[HDR_YMIN + 1]) + 1;
	188
	189	// Check image format. Currently supported formats are
	190	// 8 bits (8 bpp, 1 plane) and 24 bits (8 bpp, 3 planes).
	191	//
	192	if ((nplanes == 3) && (bitsperpixel == 8))
	193	format = wxPCX_24BIT;
	194	else if ((nplanes == 1) && (bitsperpixel == 8))
	195	format = wxPCX_8BIT;
	196	else
	197	return wxPCX_INVFORMAT;
	198
	199	// If the image is of type wxPCX_8BIT, then there is a
	200	// palette at the end of the file. Read it now before
	201	// proceeding.
	202	//
	203	if (format == wxPCX_8BIT)
	204	{
	205	pos = stream.TellI();
	206	stream.SeekI(-769, wxFromEnd);
	207
	208	if (stream.GetC() != 12)
	209	return wxPCX_INVFORMAT;
	210
	211	stream.Read(pal, 768);
	212	stream.SeekI(pos, wxFromStart);
	213	}
	214
	215	// Allocate memory for a scanline and resize the image.
	216	//
	217	image->Create(width, height);
	218
	219	if (!image->Ok())
	220	return wxPCX_MEMERR;
	221
	222	if ((p = (unsigned char ) malloc(bytesperline nplanes)) == NULL)
	223	return wxPCX_MEMERR;
	224
	225	// Now start reading the file, line by line, and store
	226	// the data in the format required by wxImage.
	227	//
	228	dst = image->GetData();
	229
	230	for (; height; height--)
	231	{
	232	if (encoding)
	233	RLEdecode(p, bytesperline * nplanes, stream);
	234	else
	235	stream.Read(p, bytesperline * nplanes);
	236
	237	switch (format)
	238	{
	239	case wxPCX_8BIT:
	240	{
	241	for (i = 0; i < width; i++)
	242	{
	243	(dst++) = pal[ 3 (p[i]) ];
	244	(dst++) = pal[ 3 (p[i]) + 1];
	245	(dst++) = pal[ 3 (p[i]) + 2];
	246	}
	247	break;
	248	}
	249	case wxPCX_24BIT:
	250	{
	251	for (i = 0; i < width; i++)
	252	{
	253	*(dst++) = p[i];
	254	*(dst++) = p[i + bytesperline];
	255	(dst++) = p[i + 2 bytesperline];
	256	}
	257	break;
	258	}
	259	}
	260	}
	261
	262	free(p);
	263
	264	return wxPCX_OK;
	265	}
	266
	267	// SavePCX:
	268	// Saves a PCX file into the wxImage object pointed by image.
	269	// Returns wxPCX_OK on success, or an error code otherwise
	270	// (see above for error codes). Currently, always saves images
	271	// in 24 bit format. XXX
	272	//
	273	int SavePCX(wxImage *image, wxOutputStream& stream)
	274	{
	275	unsigned char hdr[128]; // PCX header
	276	unsigned char pal[768]; // palette for 8 bit images
	277	unsigned char *p; // space to store one scanline
	278	unsigned char *src; // pointer into wxImage data
	279	unsigned int width, height; // size of the image
	280	unsigned int bytesperline; // bytes per line (each plane)
	281	int nplanes; // number of planes
	282	int format; // image format (8 bit, 24 bit)
	283	wxHashTable h(wxKEY_INTEGER); // image histogram
	284	unsigned long ncolours; // num. of different colours
	285	unsigned long key; // key in the hashtable
	286	unsigned int i;
	287
	288	// Get the histogram of the image, and decide whether to save
	289	// as 8 bit or 24 bit, according to the number of colours.
	290	//
	291	ncolours = image->CountColours(257);
	292
	293	if (ncolours <= 256)
	294	{
	295	image->ComputeHistogram(h);
	296	format = wxPCX_8BIT;
	297	nplanes = 1;
	298	}
	299	else
	300	{
	301	format = wxPCX_24BIT;
	302	nplanes = 3;
	303	}
	304
	305	// Get image dimensions, calculate bytesperline (must be even,
	306	// according to PCX specs) and allocate space for one complete
	307	// scanline.
	308	//
	309	if (!image->Ok())
	310	return wxPCX_INVFORMAT;
	311
	312	width = image->GetWidth();
	313	height = image->GetHeight();
	314	bytesperline = width;
	315	if (bytesperline % 2)
	316	bytesperline++;
	317
	318	if ((p = (unsigned char ) malloc(bytesperline nplanes)) == NULL)
	319	return wxPCX_MEMERR;
	320
	321	// Build header data and write it to the stream. Initially,
	322	// set all bytes to zero (most values default to zero).
	323	//
	324	memset(hdr, 0, sizeof(hdr));
	325
	326	hdr[HDR_MANUFACTURER] = 10;
	327	hdr[HDR_VERSION] = 5;
	328	hdr[HDR_ENCODING] = 1;
	329	hdr[HDR_NPLANES] = nplanes;
	330	hdr[HDR_BITSPERPIXEL] = 8;
	331	hdr[HDR_BYTESPERLINE] = bytesperline % 256;
	332	hdr[HDR_BYTESPERLINE + 1] = bytesperline / 256;
	333	hdr[HDR_XMAX] = (width - 1) % 256;
	334	hdr[HDR_XMAX + 1] = (width - 1) / 256;
	335	hdr[HDR_YMAX] = (height - 1) % 256;
	336	hdr[HDR_YMAX + 1] = (height - 1) / 256;
	337	hdr[HDR_PALETTEINFO] = 1;
	338
	339	stream.Write(hdr, 128);
	340
	341	// Encode image data line by line and write it to the stream
	342	//
	343	src = image->GetData();
	344
	345	for (; height; height--)
	346	{
	347	switch (format)
	348	{
	349	case wxPCX_8BIT:
	350	{
	351	unsigned char r, g, b;
	352	wxHNode *hnode;
	353
	354	for (i = 0; i < width; i++)
	355	{
	356	r = *(src++);
	357	g = *(src++);
	358	b = *(src++);
	359	key = (r << 16) \| (g << 8) \| b;
	360
	361	hnode = (wxHNode *) h.Get(key);
	362	p[i] = hnode->index;
	363	}
	364	break;
	365	}
	366	case wxPCX_24BIT:
	367	{
	368	for (i = 0; i < width; i++)
	369	{
	370	p[i] = *(src++);
	371	p[i + bytesperline] = *(src++);
	372	p[i + 2 * bytesperline] = *(src++);
	373	}
	374	break;
	375	}
	376	}
	377
	378	RLEencode(p, bytesperline * nplanes, stream);
	379	}
	380
	381	free(p);
	382
	383	// For 8 bit images, build the palette and write it to the stream
	384	//
	385	if (format == wxPCX_8BIT)
	386	{
	387	wxNode *node;
	388	wxHNode *hnode;
	389
	390	// zero unused colours
	391	memset(pal, 0, sizeof(pal));
	392
	393	h.BeginFind();
	394	while ((node = h.Next()) != NULL)
	395	{
	396	key = node->GetKeyInteger();
	397	hnode = (wxHNode *) node->GetData();
	398
	399	pal[3 * hnode->index] = (unsigned char)(key >> 16);
	400	pal[3 * hnode->index + 1] = (unsigned char)(key >> 8);
	401	pal[3 * hnode->index + 2] = (unsigned char)(key);
	402	delete hnode;
	403	}
	404
	405	stream.PutC(12);
	406	stream.Write(pal, 768);
	407	}
	408
	409	return wxPCX_OK;
	410	}
	411
	412	//-----------------------------------------------------------------------------
	413	// wxPCXHandler
	414	//-----------------------------------------------------------------------------
	415
	416	IMPLEMENT_DYNAMIC_CLASS(wxPCXHandler,wxImageHandler)
	417
	418	bool wxPCXHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) )
	419	{
	420	int error;
	421
	422	if (!CanRead(stream))
	423	{
	424	if (verbose)
	425	wxLogError(_("PCX: this is not a PCX file."));
	426
	427	return FALSE;
	428	}
	429
	430	image->Destroy();
	431
	432	if ((error = ReadPCX(image, stream)) != wxPCX_OK)
	433	{
	434	if (verbose)
	435	{
	436	switch (error)
	437	{
	438	case wxPCX_INVFORMAT: wxLogError(_("wxPCXHandler: image format unsupported")); break;
	439	case wxPCX_MEMERR: wxLogError(_("wxPCXHandler: couldn't allocate memory")); break;
	440	case wxPCX_VERERR: wxLogError(_("wxPCXHandler: version number too low")); break;
	441	default: wxLogError(_("wxPCXHandler: unknown error !!!"));
	442	}
	443	}
	444	image->Destroy();
	445	return FALSE;
	446	}
	447
	448	return TRUE;
	449	}
	450
	451	bool wxPCXHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose )
	452	{
	453	int error;
	454
	455	if ((error = SavePCX(image, stream)) != wxPCX_OK)
	456	{
	457	if (verbose)
	458	{
	459	switch (error)
	460	{
	461	case wxPCX_INVFORMAT: wxLogError(_("wxPCXHandler: invalid image")); break;
	462	case wxPCX_MEMERR: wxLogError(_("wxPCXHandler: couldn't allocate memory")); break;
	463	default: wxLogError(_("wxPCXHandler: unknown error !!!"));
	464	}
	465	}
	466	}
	467
	468	return (error == wxPCX_OK);
	469	}
	470
	471	bool wxPCXHandler::DoCanRead( wxInputStream& stream )
	472	{
	473	unsigned char c;
	474
	475	c = stream.GetC();
	476	stream.SeekI(-1, wxFromCurrent);
	477
	478	// not very safe, but this is all we can get from PCX header :-(
	479	return (c == 10);
	480	}
	481
	482	#endif // wxUSE_STREAMS && wxUSE_PCX
	483