1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/imagpcx.cpp
3 // Purpose: wxImage PCX handler
4 // Author: Guillermo Rodriguez Garcia <guille@iies.es>
7 // Copyright: (c) 1999 Guillermo Rodriguez Garcia
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
11 // For compilers that support precompilation, includes "wx.h".
12 #include "wx/wxprec.h"
18 #if wxUSE_IMAGE && wxUSE_PCX
23 #include "wx/palette.h"
26 #include "wx/imagpcx.h"
27 #include "wx/wfstream.h"
28 #include "wx/module.h"
32 #include "wx/object.h"
34 //-----------------------------------------------------------------------------
36 //-----------------------------------------------------------------------------
38 IMPLEMENT_DYNAMIC_CLASS(wxPCXHandler
,wxImageHandler
)
42 //-----------------------------------------------------------------------------
43 // RLE encoding and decoding
44 //-----------------------------------------------------------------------------
46 void RLEencode(unsigned char *p
, unsigned int size
, wxOutputStream
& s
)
48 unsigned int data
, last
, cont
;
50 // Write 'size' bytes. The PCX official specs say there will be
51 // a decoding break at the end of each scanline, so in order to
52 // force this decoding break use this function to write, at most,
53 // _one_ complete scanline at a time.
55 last
= (unsigned char) *(p
++);
61 data
= (unsigned char) *(p
++);
63 // Up to 63 bytes with the same value can be stored using
64 // a single { cont, value } pair.
66 if ((data
== last
) && (cont
< 63))
72 // need to write a 'counter' byte?
73 if ((cont
> 1) || ((last
& 0xC0) == 0xC0))
74 s
.PutC((char) (cont
| 0xC0));
82 // write the last one and return;
83 if ((cont
> 1) || ((last
& 0xC0) == 0xC0))
84 s
.PutC((char) (cont
| 0xC0));
89 void RLEdecode(unsigned char *p
, unsigned int size
, wxInputStream
& s
)
91 unsigned int i
, data
, cont
;
93 // Read 'size' bytes. The PCX official specs say there will be
94 // a decoding break at the end of each scanline (but not at the
95 // end of each plane inside a scanline). Only use this function
96 // to read one or more _complete_ scanlines. Else, more than
97 // 'size' bytes might be read and the buffer might overflow.
101 data
= (unsigned char)s
.GetC();
103 // If ((data & 0xC0) != 0xC0), then the value read is a data
104 // byte. Else, it is a counter (cont = val & 0x3F) and the
105 // next byte is the data byte.
107 if ((data
& 0xC0) != 0xC0)
109 *(p
++) = (unsigned char)data
;
115 data
= (unsigned char)s
.GetC();
116 for (i
= 1; i
<= cont
; i
++)
117 *(p
++) = (unsigned char)data
;
124 //-----------------------------------------------------------------------------
125 // PCX reading and saving
126 //-----------------------------------------------------------------------------
129 #define HDR_MANUFACTURER 0
130 #define HDR_VERSION 1
131 #define HDR_ENCODING 2
132 #define HDR_BITSPERPIXEL 3
137 #define HDR_NPLANES 65
138 #define HDR_BYTESPERLINE 66
139 #define HDR_PALETTEINFO 68
143 wxPCX_8BIT
, // 8 bpp, 1 plane (8 bit)
144 wxPCX_24BIT
// 8 bpp, 3 planes (24 bit)
149 wxPCX_OK
= 0, // everything was OK
150 wxPCX_INVFORMAT
= 1, // error in pcx file format
151 wxPCX_MEMERR
= 2, // error allocating memory
152 wxPCX_VERERR
= 3 // error in pcx version number
157 // Loads a PCX file into the wxImage object pointed by image.
158 // Returns wxPCX_OK on success, or an error code otherwise
159 // (see above for error codes)
161 int ReadPCX(wxImage
*image
, wxInputStream
& stream
)
163 unsigned char hdr
[128]; // PCX header
164 unsigned char pal
[768]; // palette for 8 bit images
165 unsigned char *p
; // space to store one scanline
166 unsigned char *dst
; // pointer into wxImage data
167 unsigned int width
, height
; // size of the image
168 unsigned int bytesperline
; // bytes per line (each plane)
169 int bitsperpixel
; // bits per pixel (each plane)
170 int nplanes
; // number of planes
171 int encoding
; // is the image RLE encoded?
172 int format
; // image format (8 bit, 24 bit)
175 // Read PCX header and check the version number (it must
176 // be at least 5 or higher for 8 bit and 24 bit images).
178 stream
.Read(hdr
, 128);
180 if (hdr
[HDR_VERSION
] < 5) return wxPCX_VERERR
;
182 // Extract all image info from the PCX header.
184 encoding
= hdr
[HDR_ENCODING
];
185 nplanes
= hdr
[HDR_NPLANES
];
186 bitsperpixel
= hdr
[HDR_BITSPERPIXEL
];
187 bytesperline
= hdr
[HDR_BYTESPERLINE
] + 256 * hdr
[HDR_BYTESPERLINE
+ 1];
188 width
= (hdr
[HDR_XMAX
] + 256 * hdr
[HDR_XMAX
+ 1]) -
189 (hdr
[HDR_XMIN
] + 256 * hdr
[HDR_XMIN
+ 1]) + 1;
190 height
= (hdr
[HDR_YMAX
] + 256 * hdr
[HDR_YMAX
+ 1]) -
191 (hdr
[HDR_YMIN
] + 256 * hdr
[HDR_YMIN
+ 1]) + 1;
193 // Check image format. Currently supported formats are
194 // 8 bits (8 bpp, 1 plane) and 24 bits (8 bpp, 3 planes).
196 if ((nplanes
== 3) && (bitsperpixel
== 8))
197 format
= wxPCX_24BIT
;
198 else if ((nplanes
== 1) && (bitsperpixel
== 8))
201 return wxPCX_INVFORMAT
;
203 // If the image is of type wxPCX_8BIT, then there is
204 // a palette at the end of the image data. If we were
205 // working with a file, we could seek at the end to the
206 // end (SeekI(-769, wxFromEnd) and read the palette
207 // before proceeding. Unfortunately, this would prevent
208 // loading several PCXs in a single stream, so we can't
209 // do it. Thus, 8-bit images will have to be decoded in
210 // two passes: one to read and decode the image data,
211 // and another to replace 'colour indexes' with RGB
214 // Resize the image and allocate memory for a scanline.
216 image
->Create(width
, height
);
221 if ((p
= (unsigned char *) malloc(bytesperline
* nplanes
)) == NULL
)
224 // Now start reading the file, line by line, and store
225 // the data in the format required by wxImage.
227 dst
= image
->GetData();
229 for (j
= height
; j
; j
--)
232 RLEdecode(p
, bytesperline
* nplanes
, stream
);
234 stream
.Read(p
, bytesperline
* nplanes
);
240 for (i
= 0; i
< width
; i
++)
242 // first pass, just store the colour index
250 for (i
= 0; i
< width
; i
++)
253 *(dst
++) = p
[i
+ bytesperline
];
254 *(dst
++) = p
[i
+ 2 * bytesperline
];
263 // For 8 bit images, we read the palette, and then do a second
264 // pass replacing indexes with their RGB values;
266 if (format
== wxPCX_8BIT
)
270 if (stream
.GetC() != 12)
271 return wxPCX_INVFORMAT
;
273 stream
.Read(pal
, 768);
275 p
= image
->GetData();
276 for (unsigned long k
= height
* width
; k
; k
--)
279 *(p
++) = pal
[3 * index
];
280 *(p
++) = pal
[3 * index
+ 1];
281 *(p
++) = pal
[3 * index
+ 2];
285 unsigned char r
[256];
286 unsigned char g
[256];
287 unsigned char b
[256];
288 for (i
= 0; i
< 256; i
++)
294 image
->SetPalette(wxPalette(256, r
, g
, b
));
295 #endif // wxUSE_PALETTE
302 // Saves a PCX file into the wxImage object pointed by image.
303 // Returns wxPCX_OK on success, or an error code otherwise
304 // (see above for error codes). Will try to save as 8-bit
305 // PCX if possible, and then fall back to 24-bit if there
306 // are more than 256 different colours.
308 int SavePCX(wxImage
*image
, wxOutputStream
& stream
)
310 unsigned char hdr
[128]; // PCX header
311 unsigned char pal
[768]; // palette for 8 bit images
312 unsigned char *p
; // space to store one scanline
313 unsigned char *src
; // pointer into wxImage data
314 unsigned int width
, height
; // size of the image
315 unsigned int bytesperline
; // bytes per line (each plane)
316 unsigned char nplanes
= 3; // number of planes
317 int format
= wxPCX_24BIT
; // image format (8 bit, 24 bit)
318 wxImageHistogram histogram
; // image histogram
319 unsigned long key
; // key in the hashtable
322 // See if we can save as 8 bit.
324 if (image
->CountColours(256) <= 256)
326 image
->ComputeHistogram(histogram
);
331 // Get image dimensions, calculate bytesperline (must be even,
332 // according to PCX specs) and allocate space for one complete
336 return wxPCX_INVFORMAT
;
338 width
= image
->GetWidth();
339 height
= image
->GetHeight();
340 bytesperline
= width
;
341 if (bytesperline
% 2)
344 if ((p
= (unsigned char *) malloc(bytesperline
* nplanes
)) == NULL
)
347 // Build header data and write it to the stream. Initially,
348 // set all bytes to zero (most values default to zero).
350 memset(hdr
, 0, sizeof(hdr
));
352 hdr
[HDR_MANUFACTURER
] = 10;
353 hdr
[HDR_VERSION
] = 5;
354 hdr
[HDR_ENCODING
] = 1;
355 hdr
[HDR_NPLANES
] = nplanes
;
356 hdr
[HDR_BITSPERPIXEL
] = 8;
357 hdr
[HDR_BYTESPERLINE
] = (unsigned char)(bytesperline
% 256);
358 hdr
[HDR_BYTESPERLINE
+ 1] = (unsigned char)(bytesperline
/ 256);
359 hdr
[HDR_XMAX
] = (unsigned char)((width
- 1) % 256);
360 hdr
[HDR_XMAX
+ 1] = (unsigned char)((width
- 1) / 256);
361 hdr
[HDR_YMAX
] = (unsigned char)((height
- 1) % 256);
362 hdr
[HDR_YMAX
+ 1] = (unsigned char)((height
- 1) / 256);
363 hdr
[HDR_PALETTEINFO
] = 1;
365 stream
.Write(hdr
, 128);
367 // Encode image data line by line and write it to the stream
369 src
= image
->GetData();
371 for (; height
; height
--)
377 unsigned char r
, g
, b
;
379 for (i
= 0; i
< width
; i
++)
384 key
= (r
<< 16) | (g
<< 8) | b
;
386 p
[i
] = (unsigned char)histogram
[key
].index
;
392 for (i
= 0; i
< width
; i
++)
395 p
[i
+ bytesperline
] = *(src
++);
396 p
[i
+ 2 * bytesperline
] = *(src
++);
402 RLEencode(p
, bytesperline
* nplanes
, stream
);
407 // For 8 bit images, build the palette and write it to the stream:
408 if (format
== wxPCX_8BIT
)
410 // zero unused colours
411 memset(pal
, 0, sizeof(pal
));
415 for (wxImageHistogram::iterator entry
= histogram
.begin();
416 entry
!= histogram
.end(); ++entry
)
419 index
= entry
->second
.index
;
420 pal
[3 * index
] = (unsigned char)(key
>> 16);
421 pal
[3 * index
+ 1] = (unsigned char)(key
>> 8);
422 pal
[3 * index
+ 2] = (unsigned char)(key
);
426 stream
.Write(pal
, 768);
432 //-----------------------------------------------------------------------------
434 //-----------------------------------------------------------------------------
436 bool wxPCXHandler::LoadFile( wxImage
*image
, wxInputStream
& stream
, bool verbose
, int WXUNUSED(index
) )
440 if (!CanRead(stream
))
443 wxLogError(_("PCX: this is not a PCX file."));
450 if ((error
= ReadPCX(image
, stream
)) != wxPCX_OK
)
456 case wxPCX_INVFORMAT
: wxLogError(_("PCX: image format unsupported")); break;
457 case wxPCX_MEMERR
: wxLogError(_("PCX: couldn't allocate memory")); break;
458 case wxPCX_VERERR
: wxLogError(_("PCX: version number too low")); break;
459 default: wxLogError(_("PCX: unknown error !!!"));
469 bool wxPCXHandler::SaveFile( wxImage
*image
, wxOutputStream
& stream
, bool verbose
)
473 if ((error
= SavePCX(image
, stream
)) != wxPCX_OK
)
479 case wxPCX_INVFORMAT
: wxLogError(_("PCX: invalid image")); break;
480 case wxPCX_MEMERR
: wxLogError(_("PCX: couldn't allocate memory")); break;
481 default: wxLogError(_("PCX: unknown error !!!"));
486 return (error
== wxPCX_OK
);
489 bool wxPCXHandler::DoCanRead( wxInputStream
& stream
)
491 unsigned char c
= stream
.GetC();
495 // not very safe, but this is all we can get from PCX header :-(
499 #endif // wxUSE_STREAMS
501 #endif // wxUSE_IMAGE && wxUSE_PCX