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