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