/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/common/imagtga.cpp
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/src/common/imagtga.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (show annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (10 years, 2 months ago) by william
File size: 19807 byte(s)
committing r3113 initial commit again...
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: imagtga.cpp
3 // Purpose: wxImage TGA handler
4 // Author: Seth Jackson
5 // CVS-ID: $Id: imagtga.cpp 43681 2006-11-27 15:01:58Z VZ $
6 // Copyright: (c) 2005 Seth Jackson
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // ============================================================================
11 // declarations
12 // ============================================================================
13
14 // ----------------------------------------------------------------------------
15 // headers
16 // ----------------------------------------------------------------------------
17
18 // For compilers that support precompilation, includes "wx.h".
19 #include "wx/wxprec.h"
20
21 #ifdef __BORLANDC__
22 #pragma hdrstop
23 #endif
24
25 #if wxUSE_IMAGE && wxUSE_TGA
26
27 #ifndef WX_PRECOMP
28 #include "wx/palette.h"
29 #endif
30
31 #include "wx/imagtga.h"
32 #include "wx/log.h"
33 #include "wx/scopeguard.h"
34
35 // ----------------------------------------------------------------------------
36 // constants
37 // ----------------------------------------------------------------------------
38
39 // TGA error codes.
40 enum
41 {
42 wxTGA_OK = 0,
43 wxTGA_INVFORMAT = 1,
44 wxTGA_MEMERR = 2
45 };
46
47 // TGA header bytes.
48 enum
49 {
50 HDR_OFFSET = 0,
51 HDR_COLORTYPE = 1,
52 HDR_IMAGETYPE = 2,
53 HDR_PALETTESTART = 3,
54 HDR_PALETTELENGTH = 5,
55 HDR_PALETTEBITS = 7,
56 HDR_XORIGIN = 8,
57 HDR_YORIGIN = 10,
58 HDR_WIDTH = 12,
59 HDR_HEIGHT = 14,
60 HDR_BPP = 16,
61 HDR_ORIENTATION = 17,
62 HDR_SIZE
63 };
64
65 // TGA color types.
66 enum
67 {
68 wxTGA_UNMAPPED = 0,
69 wxTGA_MAPPED = 1
70 };
71
72 // ============================================================================
73 // implementation
74 // ============================================================================
75
76 IMPLEMENT_DYNAMIC_CLASS(wxTGAHandler, wxImageHandler)
77
78 #if wxUSE_STREAMS
79
80 // ----------------------------------------------------------------------------
81 // worker functions
82 // ----------------------------------------------------------------------------
83
84 static
85 void FlipTGA(unsigned char* imageData, int width, int height, short pixelSize)
86 {
87 int lineLength = width * pixelSize;
88 unsigned char *line1 = imageData;
89 unsigned char *line2 = &imageData[lineLength * (height - 1)];
90
91 unsigned char temp;
92 for ( ; line1 < line2; line2 -= (lineLength * 2))
93 {
94 for (int index = 0; index < lineLength; line1++, line2++, index++)
95 {
96 temp = *line1;
97 *line1 = *line2;
98 *line2 = temp;
99 }
100 }
101 }
102
103 static
104 void DecodeRLE(unsigned char* imageData, unsigned long imageSize,
105 short pixelSize, wxInputStream& stream)
106 {
107 unsigned long index = 0;
108 unsigned char current;
109 unsigned int length;
110 unsigned char buf[4];
111
112 while (index < imageSize)
113 {
114 current = stream.GetC();
115
116 // RLE packet.
117 if ( current & 0x80 )
118 {
119 // Get the run length of the packet.
120 current &= 0x7f;
121
122 current++;
123
124 length = current;
125
126 index += current * pixelSize;
127
128 // Repeat the pixel length times.
129 stream.Read(buf, pixelSize);
130
131 for (unsigned int i = 0; i < length; i++)
132 {
133 memcpy(imageData, buf, pixelSize);
134
135 imageData += pixelSize;
136 }
137 }
138 else // Raw packet.
139 {
140 // Get the run length of the packet.
141 current++;
142
143 length = current * pixelSize;
144
145 index += length;
146
147 // Write the next length pixels directly to the image data.
148 stream.Read(imageData, length);
149
150 imageData += length;
151 }
152 }
153 }
154
155 static
156 int ReadTGA(wxImage* image, wxInputStream& stream)
157 {
158 // Read in the TGA header
159 unsigned char hdr[HDR_SIZE];
160 stream.Read(hdr, HDR_SIZE);
161
162 short offset = hdr[HDR_OFFSET] + HDR_SIZE;
163 short colorType = hdr[HDR_COLORTYPE];
164 short imageType = hdr[HDR_IMAGETYPE];
165 int paletteLength = hdr[HDR_PALETTELENGTH] + 256 * hdr[HDR_PALETTELENGTH + 1];
166 int width = (hdr[HDR_WIDTH] + 256 * hdr[HDR_WIDTH + 1]) -
167 (hdr[HDR_XORIGIN] + 256 * hdr[HDR_XORIGIN + 1]);
168 int height = (hdr[HDR_HEIGHT] + 256 * hdr[HDR_HEIGHT + 1]) -
169 (hdr[HDR_YORIGIN] + 256 * hdr[HDR_YORIGIN + 1]);
170 short bpp = hdr[HDR_BPP];
171 short orientation = hdr[HDR_ORIENTATION] & 0x20;
172
173 image->Create(width, height);
174
175 if (!image->Ok())
176 {
177 return wxTGA_MEMERR;
178 }
179
180 const short pixelSize = bpp / 8;
181
182 const unsigned long imageSize = width * height * pixelSize;
183
184 unsigned char *imageData = (unsigned char* )malloc(imageSize);
185
186 if (!imageData)
187 {
188 return wxTGA_MEMERR;
189 }
190
191 wxON_BLOCK_EXIT1(free, imageData);
192
193 unsigned char *dst = image->GetData();
194
195 unsigned char* alpha = NULL;
196 if (bpp == 16 || bpp == 32)
197 {
198 image->SetAlpha();
199
200 alpha = image->GetAlpha();
201 }
202
203 // Seek from the offset we got from the TGA header.
204 stream.SeekI(offset, wxFromStart);
205
206 // Load a palette if we have one.
207 if (colorType == wxTGA_MAPPED)
208 {
209 unsigned char buf[3];
210
211 unsigned char* r = new unsigned char[paletteLength];
212 unsigned char* g = new unsigned char[paletteLength];
213 unsigned char* b = new unsigned char[paletteLength];
214
215 for (int i = 0; i < paletteLength; i++)
216 {
217 stream.Read(buf, 3);
218
219 r[i] = buf[2];
220 g[i] = buf[1];
221 b[i] = buf[0];
222 }
223
224 #if wxUSE_PALETTE
225 // Set the palette of the image.
226 image->SetPalette(wxPalette(paletteLength, r, g, b));
227 #endif // wxUSE_PALETTE
228
229 delete[] r;
230 delete[] g;
231 delete[] b;
232 }
233
234 // Handle the various TGA formats we support.
235
236 switch (imageType)
237 {
238 #if wxUSE_PALETTE
239 // Raw indexed.
240
241 case 1:
242 {
243 const wxPalette& palette = image->GetPalette();
244 unsigned char r;
245 unsigned char g;
246 unsigned char b;
247
248 // No compression read the data directly to imageData.
249
250 stream.Read(imageData, imageSize);
251
252 // If orientation == 0, then the image is stored upside down.
253 // We need to store it right side up.
254
255 if (orientation == 0)
256 {
257 FlipTGA(imageData, width, height, pixelSize);
258 }
259
260 // Handle the different pixel depths.
261
262 switch (bpp)
263 {
264 // 8 bpp.
265
266 case 8:
267 {
268 for (unsigned long index = 0; index < imageSize; index += pixelSize)
269 {
270 palette.GetRGB(imageData[index], &r, &g, &b);
271
272 *(dst++) = r;
273 *(dst++) = g;
274 *(dst++) = b;
275 }
276 }
277 break;
278
279 // 16 bpp.
280
281 case 16:
282 {
283 for (unsigned long index = 0; index < imageSize; index += pixelSize)
284 {
285 palette.GetRGB(imageData[index], &r, &g, &b);
286
287 *(dst++) = r;
288 *(dst++) = g;
289 *(dst++) = b;
290 *(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
291 }
292 }
293 break;
294
295 default:
296 return wxTGA_INVFORMAT;
297 }
298 }
299 break;
300 #endif // wxUSE_PALETTE
301
302 // Raw RGB.
303
304 case 2:
305 {
306 // No compression read the data directly to imageData.
307
308 stream.Read(imageData, imageSize);
309
310 // If orientation == 0, then the image is stored upside down.
311 // We need to store it right side up.
312
313 if (orientation == 0)
314 {
315 FlipTGA(imageData, width, height, pixelSize);
316 }
317
318 // Handle the different pixel depths.
319
320 switch (bpp)
321 {
322 //16 bpp.
323
324 case 16:
325 {
326 unsigned char temp;
327
328 for (unsigned long index = 0; index < imageSize; index += pixelSize)
329 {
330 temp = (imageData[index + 1] & 0x7c) << 1;
331 temp |= temp >> 5;
332 *(dst++) = temp;
333
334 temp = ((imageData[index + 1] & 0x03) << 6) | ((imageData[index] & 0xe0) >> 2);
335 temp |= temp >> 5;
336 *(dst++) = temp;
337
338 temp = (imageData[index] & 0x1f) << 3;
339 temp |= temp >> 5;
340 *(dst++) = temp;
341
342 *(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
343 }
344 }
345 break;
346
347 // 24 bpp.
348
349 case 24:
350 {
351 for (unsigned long index = 0; index < imageSize; index += pixelSize)
352 {
353 *(dst++) = imageData[index + 2];
354 *(dst++) = imageData[index + 1];
355 *(dst++) = imageData[index];
356 }
357 }
358 break;
359
360 // 32 bpp.
361
362 case 32:
363 {
364 for (unsigned long index = 0; index < imageSize; index += pixelSize)
365 {
366 *(dst++) = imageData[index + 2];
367 *(dst++) = imageData[index + 1];
368 *(dst++) = imageData[index];
369 *(alpha++) = imageData[index + 3];
370 }
371 }
372 break;
373
374 default:
375 return wxTGA_INVFORMAT;
376 }
377 }
378 break;
379
380 // Raw grayscale.
381
382 case 3:
383 {
384 // No compression read the data directly to imageData.
385
386 stream.Read(imageData, imageSize);
387
388 // If orientation == 0, then the image is stored upside down.
389 // We need to store it right side up.
390
391 if (orientation == 0)
392 {
393 FlipTGA(imageData, width, height, pixelSize);
394 }
395
396 // Handle the different pixel depths.
397
398 switch (bpp)
399 {
400 // 8 bpp.
401
402 case 8:
403 {
404 for (unsigned long index = 0; index < imageSize; index += pixelSize)
405 {
406 *(dst++) = imageData[index];
407 *(dst++) = imageData[index];
408 *(dst++) = imageData[index];
409 }
410 }
411 break;
412
413 // 16 bpp.
414
415 case 16:
416 {
417 for (unsigned long index = 0; index < imageSize; index += pixelSize)
418 {
419 *(dst++) = imageData[index];
420 *(dst++) = imageData[index];
421 *(dst++) = imageData[index];
422 *(alpha++) = imageData[index + 1];
423 }
424 }
425 break;
426
427 default:
428 return wxTGA_INVFORMAT;
429 }
430 }
431 break;
432
433 #if wxUSE_PALETTE
434 // RLE indexed.
435
436 case 9:
437 {
438 const wxPalette& palette = image->GetPalette();
439 unsigned char r;
440 unsigned char g;
441 unsigned char b;
442
443 // Decode the RLE data.
444
445 DecodeRLE(imageData, imageSize, pixelSize, stream);
446
447 // If orientation == 0, then the image is stored upside down.
448 // We need to store it right side up.
449
450 if (orientation == 0)
451 {
452 FlipTGA(imageData, width, height, pixelSize);
453 }
454
455 // Handle the different pixel depths.
456
457 switch (bpp)
458 {
459 // 8 bpp.
460
461 case 8:
462 {
463 for (unsigned long index = 0; index < imageSize; index += pixelSize)
464 {
465 palette.GetRGB(imageData[index], &r, &g, &b);
466
467 *(dst++) = r;
468 *(dst++) = g;
469 *(dst++) = b;
470 }
471 }
472 break;
473
474 // 16 bpp.
475
476 case 16:
477 {
478 for (unsigned long index = 0; index < imageSize; index += pixelSize)
479 {
480 palette.GetRGB(imageData[index], &r, &g, &b);
481
482 *(dst++) = r;
483 *(dst++) = g;
484 *(dst++) = b;
485 *(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
486 }
487 }
488 break;
489
490 default:
491 return wxTGA_INVFORMAT;
492 }
493 }
494 break;
495 #endif // wxUSE_PALETTE
496
497 // RLE RGB.
498
499 case 10:
500 {
501 // Decode the RLE data.
502
503 DecodeRLE(imageData, imageSize, pixelSize, stream);
504
505 // If orientation == 0, then the image is stored upside down.
506 // We need to store it right side up.
507
508 if (orientation == 0)
509 {
510 FlipTGA(imageData, width, height, pixelSize);
511 }
512
513 // Handle the different pixel depths.
514
515 switch (bpp)
516 {
517 //16 bpp.
518
519 case 16:
520 {
521 unsigned char temp;
522
523 for (unsigned long index = 0; index < imageSize; index += pixelSize)
524 {
525 temp = (imageData[index + 1] & 0x7c) << 1;
526 temp |= temp >> 5;
527 *(dst++) = temp;
528
529 temp = ((imageData[index + 1] & 0x03) << 6) | ((imageData[index] & 0xe0) >> 2);
530 temp |= temp >> 5;
531 *(dst++) = temp;
532
533 temp = (imageData[index] & 0x1f) << 3;
534 temp |= temp >> 5;
535 *(dst++) = temp;
536
537 *(alpha++) = (imageData[index + 1] & 0x80) ? 0 : 255;
538 }
539 }
540 break;
541
542 // 24 bpp.
543
544 case 24:
545 {
546 for (unsigned long index = 0; index < imageSize; index += pixelSize)
547 {
548 *(dst++) = imageData[index + 2];
549 *(dst++) = imageData[index + 1];
550 *(dst++) = imageData[index];
551 }
552 }
553 break;
554
555 // 32 bpp.
556
557 case 32:
558 {
559 for (unsigned long index = 0; index < imageSize; index += pixelSize)
560 {
561 *(dst++) = imageData[index + 2];
562 *(dst++) = imageData[index + 1];
563 *(dst++) = imageData[index];
564 *(alpha++) = imageData[index + 3];
565 }
566 }
567 break;
568
569 default:
570 return wxTGA_INVFORMAT;
571 }
572 }
573 break;
574
575 // RLE grayscale.
576
577 case 11:
578 {
579 // Decode the RLE data.
580
581 DecodeRLE(imageData, imageSize, pixelSize, stream);
582
583 // If orientation == 0, then the image is stored upside down.
584 // We need to store it right side up.
585
586 if (orientation == 0)
587 {
588 FlipTGA(imageData, width, height, pixelSize);
589 }
590
591 // Handle the different pixel depths.
592
593 switch (bpp)
594 {
595 // 8 bpp.
596
597 case 8:
598 {
599 for (unsigned long index = 0; index < imageSize; index += pixelSize)
600 {
601 *(dst++) = imageData[index];
602 *(dst++) = imageData[index];
603 *(dst++) = imageData[index];
604 }
605 }
606 break;
607
608 // 16 bpp.
609
610 case 16:
611 {
612 for (unsigned long index = 0; index < imageSize; index += pixelSize)
613 {
614 *(dst++) = imageData[index];
615 *(dst++) = imageData[index];
616 *(dst++) = imageData[index];
617 *(alpha++) = imageData[index + 1];
618 }
619 }
620 break;
621
622 default:
623 return wxTGA_INVFORMAT;
624 }
625 }
626 break;
627
628 default:
629 return wxTGA_INVFORMAT;
630 }
631
632 return wxTGA_OK;
633 }
634
635 static
636 int SaveTGA(wxImage* WXUNUSED(image), wxOutputStream& WXUNUSED(stream))
637 {
638 wxLogError(wxT("Saving in TGA format is not implemented."));
639
640 return wxTGA_OK;
641 }
642
643 // ----------------------------------------------------------------------------
644 // wxTGAHandler
645 // ----------------------------------------------------------------------------
646
647 bool wxTGAHandler::LoadFile(wxImage* image,
648 wxInputStream& stream,
649 bool verbose,
650 int WXUNUSED(index))
651 {
652 if ( !CanRead(stream) )
653 {
654 if ( verbose )
655 wxLogError(wxT("TGA: this is not a TGA file."));
656
657 return false;
658 }
659
660 image->Destroy();
661
662 int error = ReadTGA(image, stream);
663 if ( error != wxTGA_OK )
664 {
665 if ( verbose )
666 {
667 switch ( error )
668 {
669 case wxTGA_INVFORMAT:
670 wxLogError(wxT("TGA: image format unsupported."));
671 break;
672
673 case wxTGA_MEMERR:
674 wxLogError(wxT("TGA: couldn't allocate memory."));
675 break;
676
677 default:
678 wxLogError(wxT("TGA: unknown error!"));
679 }
680 }
681
682 image->Destroy();
683
684 return false;
685 }
686
687 return true;
688 }
689
690 bool wxTGAHandler::SaveFile(wxImage* image, wxOutputStream& stream, bool verbose)
691 {
692 int error = SaveTGA(image, stream);
693
694 if ( error != wxTGA_OK )
695 {
696 if ( verbose )
697 {
698 switch ( error )
699 {
700 case wxTGA_INVFORMAT:
701 wxLogError(wxT("TGA: invalid image."));
702 break;
703
704 case wxTGA_MEMERR:
705 wxLogError(wxT("TGA: couldn't allocate memory."));
706 break;
707
708 default:
709 wxLogError(wxT("TGA: unknown error!"));
710 }
711 }
712
713 return false;
714 }
715
716 return true;
717 }
718
719 bool wxTGAHandler::DoCanRead(wxInputStream& stream)
720 {
721 // read the fixed-size TGA headers
722 unsigned char hdr[HDR_SIZE];
723 stream.Read(hdr, HDR_SIZE);
724
725 // Check wether we can read the file or not.
726
727 short colorType = hdr[HDR_COLORTYPE];
728 if ( colorType != wxTGA_UNMAPPED && colorType != wxTGA_MAPPED )
729 {
730 return false;
731 }
732
733 short imageType = hdr[HDR_IMAGETYPE];
734 if ( imageType == 0 || imageType == 32 || imageType == 33 )
735 {
736 return false;
737 }
738
739 short bpp = hdr[HDR_BPP];
740 if ( bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32 )
741 {
742 return false;
743 }
744
745 return true;
746 }
747
748 #endif // wxUSE_STREAMS
749
750 #endif // wxUSE_IMAGE && wxUSE_TGA

  ViewVC Help
Powered by ViewVC 1.1.22