]> git.saurik.com Git - wxWidgets.git/blob - src/common/imagiff.cpp
fixing forced link of quicktime backend on osx_cocoa
[wxWidgets.git] / src / common / imagiff.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/imagiff.cpp
3 // Purpose: wxImage handler for Amiga IFF images
4 // Author: Steffen Gutmann, Thomas Meyer
5 // RCS-ID: $Id$
6 // Copyright: (c) Steffen Gutmann, 2002
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // Parts of this source are based on the iff loading algorithm found
11 // in xviff.c. Permission by the original author, Thomas Meyer, and
12 // by the author of xv, John Bradley for using the iff loading part
13 // in wxWidgets has been gratefully given.
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 #if wxUSE_IMAGE && wxUSE_IFF
23
24 #ifndef WX_PRECOMP
25 #include "wx/log.h"
26 #include "wx/intl.h"
27 #endif
28
29 #include "wx/imagiff.h"
30 #include "wx/wfstream.h"
31
32 #if wxUSE_PALETTE
33 #include "wx/palette.h"
34 #endif // wxUSE_PALETTE
35
36 #include <stdlib.h>
37 #include <string.h>
38
39
40 // --------------------------------------------------------------------------
41 // Constants
42 // --------------------------------------------------------------------------
43
44 // Error codes:
45 // Note that the error code wxIFF_TRUNCATED means that the image itself
46 // is most probably OK, but the decoder didn't reach the end of the data
47 // stream; this means that if it was not reading directly from file,
48 // the stream will not be correctly positioned.
49 //
50
51 enum
52 {
53 wxIFF_OK = 0, /* everything was OK */
54 wxIFF_INVFORMAT, /* error in iff header */
55 wxIFF_MEMERR, /* error allocating memory */
56 wxIFF_TRUNCATED /* file appears to be truncated */
57 };
58
59 // --------------------------------------------------------------------------
60 // wxIFFDecoder class
61 // --------------------------------------------------------------------------
62
63 // internal class for storing IFF image data
64 class IFFImage
65 {
66 public:
67 unsigned int w; /* width */
68 unsigned int h; /* height */
69 int transparent; /* transparent color (-1 = none) */
70 int colors; /* number of colors */
71 unsigned char *p; /* bitmap */
72 unsigned char *pal; /* palette */
73
74 IFFImage() : w(0), h(0), colors(0), p(0), pal(0) {}
75 ~IFFImage() { delete [] p; delete [] pal; }
76 };
77
78 class WXDLLEXPORT wxIFFDecoder
79 {
80 private:
81 IFFImage *m_image; // image data
82 wxInputStream *m_f; // input stream
83 unsigned char *databuf;
84 unsigned char *decomp_mem;
85
86 void Destroy();
87
88 public:
89 // get data of current frame
90 unsigned char* GetData() const;
91 unsigned char* GetPalette() const;
92 int GetNumColors() const;
93 unsigned int GetWidth() const;
94 unsigned int GetHeight() const;
95 int GetTransparentColour() const;
96
97 // constructor, destructor, etc.
98 wxIFFDecoder(wxInputStream *s);
99 ~wxIFFDecoder() { Destroy(); }
100
101 // NOTE: this function modifies the current stream position
102 bool CanRead();
103
104 int ReadIFF();
105 bool ConvertToImage(wxImage *image) const;
106 };
107
108
109 //---------------------------------------------------------------------------
110 // wxIFFDecoder constructor and destructor
111 //---------------------------------------------------------------------------
112
113 wxIFFDecoder::wxIFFDecoder(wxInputStream *s)
114 {
115 m_f = s;
116 m_image = 0;
117 databuf = 0;
118 decomp_mem = 0;
119 }
120
121 void wxIFFDecoder::Destroy()
122 {
123 wxDELETE(m_image);
124 wxDELETEA(databuf);
125 wxDELETEA(decomp_mem);
126 }
127
128 //---------------------------------------------------------------------------
129 // Convert this image to a wxImage object
130 //---------------------------------------------------------------------------
131
132 // This function was designed by Vaclav Slavik
133
134 bool wxIFFDecoder::ConvertToImage(wxImage *image) const
135 {
136 // just in case...
137 image->Destroy();
138
139 // create the image
140 image->Create(GetWidth(), GetHeight());
141
142 if (!image->IsOk())
143 return false;
144
145 unsigned char *pal = GetPalette();
146 unsigned char *src = GetData();
147 unsigned char *dst = image->GetData();
148 int colors = GetNumColors();
149 int transparent = GetTransparentColour();
150 long i;
151
152 // set transparent colour mask
153 if (transparent != -1)
154 {
155 for (i = 0; i < colors; i++)
156 {
157 if ((pal[3 * i + 0] == 255) &&
158 (pal[3 * i + 1] == 0) &&
159 (pal[3 * i + 2] == 255))
160 {
161 pal[3 * i + 2] = 254;
162 }
163 }
164
165 pal[3 * transparent + 0] = 255,
166 pal[3 * transparent + 1] = 0,
167 pal[3 * transparent + 2] = 255;
168
169 image->SetMaskColour(255, 0, 255);
170 }
171 else
172 image->SetMask(false);
173
174 #if wxUSE_PALETTE
175 if (pal && colors > 0)
176 {
177 unsigned char* r = new unsigned char[colors];
178 unsigned char* g = new unsigned char[colors];
179 unsigned char* b = new unsigned char[colors];
180
181 for (i = 0; i < colors; i++)
182 {
183 r[i] = pal[3*i + 0];
184 g[i] = pal[3*i + 1];
185 b[i] = pal[3*i + 2];
186 }
187
188 image->SetPalette(wxPalette(colors, r, g, b));
189
190 delete [] r;
191 delete [] g;
192 delete [] b;
193 }
194 #endif // wxUSE_PALETTE
195
196 // copy image data
197 for (i = 0; i < (long)(GetWidth() * GetHeight()); i++, src += 3, dst += 3)
198 {
199 dst[0] = src[0];
200 dst[1] = src[1];
201 dst[2] = src[2];
202 }
203
204 return true;
205 }
206
207
208 //---------------------------------------------------------------------------
209 // Data accessors
210 //---------------------------------------------------------------------------
211
212 // Get data for current frame
213
214 unsigned char* wxIFFDecoder::GetData() const { return (m_image->p); }
215 unsigned char* wxIFFDecoder::GetPalette() const { return (m_image->pal); }
216 int wxIFFDecoder::GetNumColors() const { return m_image->colors; }
217 unsigned int wxIFFDecoder::GetWidth() const { return (m_image->w); }
218 unsigned int wxIFFDecoder::GetHeight() const { return (m_image->h); }
219 int wxIFFDecoder::GetTransparentColour() const { return m_image->transparent; }
220
221 //---------------------------------------------------------------------------
222 // IFF reading and decoding
223 //---------------------------------------------------------------------------
224
225 //
226 // CanRead:
227 // Returns true if the file looks like a valid IFF, false otherwise.
228 //
229 bool wxIFFDecoder::CanRead()
230 {
231 unsigned char buf[12];
232
233 if ( !m_f->Read(buf, WXSIZEOF(buf)) )
234 return false;
235
236 return (memcmp(buf, "FORM", 4) == 0) && (memcmp(buf+8, "ILBM", 4) == 0);
237 }
238
239
240 // ReadIFF:
241 // Based on xv source code by Thomas Meyer
242 // Permission for use in wxWidgets has been gratefully given.
243
244 typedef unsigned char byte;
245 #define IFFDEBUG 0
246
247 /*************************************************************************
248 void decomprle(source, destination, source length, buffer size)
249
250 Decompress run-length encoded data from source to destination. Terminates
251 when source is decoded completely or destination buffer is full.
252
253 The decruncher is as optimized as I could make it, without risking
254 safety in case of corrupt BODY chunks.
255 **************************************************************************/
256
257 static void decomprle(const byte *sptr, byte *dptr, long slen, long dlen)
258 {
259 byte codeByte, dataByte;
260
261 while ((slen > 0) && (dlen > 0)) {
262 // read control byte
263 codeByte = *sptr++;
264
265 if (codeByte < 0x80) {
266 codeByte++;
267 if ((slen > (long) codeByte) && (dlen >= (long) codeByte)) {
268 slen -= codeByte + 1;
269 dlen -= codeByte;
270 while (codeByte > 0) {
271 *dptr++ = *sptr++;
272 codeByte--;
273 }
274 }
275 else slen = 0;
276 }
277
278 else if (codeByte > 0x80) {
279 codeByte = 0x81 - (codeByte & 0x7f);
280 if ((slen > (long) 0) && (dlen >= (long) codeByte)) {
281 dataByte = *sptr++;
282 slen -= 2;
283 dlen -= codeByte;
284 while (codeByte > 0) {
285 *dptr++ = dataByte;
286 codeByte--;
287 }
288 }
289 else slen = 0;
290 }
291 }
292 }
293
294 /******************************************/
295 static unsigned int iff_getword(const byte *ptr)
296 {
297 unsigned int v;
298
299 v = *ptr++;
300 v = (v << 8) + *ptr;
301 return v;
302 }
303
304 /******************************************/
305 static unsigned long iff_getlong(const byte *ptr)
306 {
307 unsigned long l;
308
309 l = *ptr++;
310 l = (l << 8) + *ptr++;
311 l = (l << 8) + *ptr++;
312 l = (l << 8) + *ptr;
313 return l;
314 }
315
316 // Define internal ILBM types
317 #define ILBM_NORMAL 0
318 #define ILBM_EHB 1
319 #define ILBM_HAM 2
320 #define ILBM_HAM8 3
321 #define ILBM_24BIT 4
322
323 int wxIFFDecoder::ReadIFF()
324 {
325 Destroy();
326
327 m_image = new IFFImage();
328 if (m_image == 0) {
329 Destroy();
330 return wxIFF_MEMERR;
331 }
332
333 // compute file length
334 wxFileOffset currentPos = m_f->TellI();
335 if (m_f->SeekI(0, wxFromEnd) == wxInvalidOffset) {
336 Destroy();
337 return wxIFF_MEMERR;
338 }
339
340 long filesize = m_f->TellI();
341 if (m_f->SeekI(currentPos, wxFromStart) == wxInvalidOffset) {
342 Destroy();
343 return wxIFF_MEMERR;
344 }
345
346 // allocate memory for complete file
347 if ((databuf = new byte[filesize]) == 0) {
348 Destroy();
349 return wxIFF_MEMERR;
350 }
351
352 m_f->Read(databuf, filesize);
353 const byte *dataend = databuf + filesize;
354
355 // initialize work pointer. used to trace the buffer for IFF chunks
356 const byte *dataptr = databuf;
357
358 // check for minmal size
359 if (dataptr + 12 > dataend) {
360 Destroy();
361 return wxIFF_INVFORMAT;
362 }
363
364 // check if we really got an IFF file
365 if (strncmp((char *)dataptr, "FORM", 4) != 0) {
366 Destroy();
367 return wxIFF_INVFORMAT;
368 }
369
370 dataptr = dataptr + 8; // skip ID and length of FORM
371
372 // check if the IFF file is an ILBM (picture) file
373 if (strncmp((char *) dataptr, "ILBM", 4) != 0) {
374 Destroy();
375 return wxIFF_INVFORMAT;
376 }
377
378 wxLogTrace(wxT("iff"), wxT("IFF ILBM file recognized"));
379
380 dataptr = dataptr + 4; // skip ID
381
382 //
383 // main decoding loop. searches IFF chunks and handles them.
384 // terminates when BODY chunk was found or dataptr ran over end of file
385 //
386 bool BMHDok = false, CAMGok = false;
387 int bmhd_width = 0, bmhd_height = 0, bmhd_bitplanes = 0, bmhd_transcol = -1;
388 byte bmhd_compression = 0;
389 long camg_viewmode = 0;
390 int colors = 0;
391 while (dataptr + 8 <= dataend) {
392 // get chunk length and make even
393 long chunkLen = (iff_getlong(dataptr + 4) + 1) & 0xfffffffe;
394 if (chunkLen < 0) { // format error?
395 break;
396 }
397 bool truncated = (dataptr + 8 + chunkLen > dataend);
398
399 if (strncmp((char *)dataptr, "BMHD", 4) == 0) { // BMHD chunk?
400 if (chunkLen < 12 + 2 || truncated) {
401 break;
402 }
403 bmhd_width = iff_getword(dataptr + 8); // width of picture
404 bmhd_height= iff_getword(dataptr + 8 + 2); // height of picture
405 bmhd_bitplanes = *(dataptr + 8 + 8); // # of bitplanes
406 // bmhd_masking = *(dataptr + 8 + 9); -- unused currently
407 bmhd_compression = *(dataptr + 8 + 10); // get compression
408 bmhd_transcol = iff_getword(dataptr + 8 + 12);
409 BMHDok = true; // got BMHD
410 dataptr += 8 + chunkLen; // to next chunk
411 }
412 else if (strncmp((char *)dataptr, "CMAP", 4) == 0) { // CMAP ?
413 if (truncated) {
414 break;
415 }
416 const byte *cmapptr = dataptr + 8;
417 colors = chunkLen / 3; // calc no of colors
418
419 wxDELETE(m_image->pal);
420 m_image->colors = colors;
421 if (colors > 0) {
422 m_image->pal = new byte[3*colors];
423 if (!m_image->pal) {
424 Destroy();
425 return wxIFF_MEMERR;
426 }
427
428 // copy colors to color map
429 for (int i=0; i < colors; i++) {
430 m_image->pal[3*i + 0] = *cmapptr++;
431 m_image->pal[3*i + 1] = *cmapptr++;
432 m_image->pal[3*i + 2] = *cmapptr++;
433 }
434 }
435
436 wxLogTrace(wxT("iff"), wxT("Read %d colors from IFF file."),
437 colors);
438
439 dataptr += 8 + chunkLen; // to next chunk
440 } else if (strncmp((char *)dataptr, "CAMG", 4) == 0) { // CAMG ?
441 if (chunkLen < 4 || truncated) {
442 break;
443 }
444 camg_viewmode = iff_getlong(dataptr + 8); // get viewmodes
445 CAMGok = true; // got CAMG
446 dataptr += 8 + chunkLen; // to next chunk
447 }
448 else if (strncmp((char *)dataptr, "BODY", 4) == 0) { // BODY ?
449 if (!BMHDok) { // BMHD found?
450 break;
451 }
452 const byte *bodyptr = dataptr + 8; // -> BODY data
453
454 if (truncated) {
455 chunkLen = dataend - dataptr;
456 }
457
458 //
459 // if BODY is compressed, allocate buffer for decrunched BODY
460 // and decompress it (run length encoding)
461 //
462 if (bmhd_compression == 1) {
463 // calc size of decrunch buffer - (size of the actual pic.
464 // decompressed in interleaved Amiga bitplane format)
465
466 size_t decomp_bufsize = (((bmhd_width + 15) >> 4) << 1)
467 * bmhd_height * bmhd_bitplanes;
468
469 if ((decomp_mem = new byte[decomp_bufsize]) == 0) {
470 Destroy();
471 return wxIFF_MEMERR;
472 }
473
474 decomprle(bodyptr, decomp_mem, chunkLen, decomp_bufsize);
475 bodyptr = decomp_mem; // -> uncompressed BODY
476 chunkLen = decomp_bufsize;
477 wxDELETEA(databuf);
478 }
479
480 // the following determines the type of the ILBM file.
481 // it's either NORMAL, EHB, HAM, HAM8 or 24BIT
482
483 int fmt = ILBM_NORMAL; // assume normal ILBM
484 if (bmhd_bitplanes == 24) {
485 fmt = ILBM_24BIT;
486 } else if (bmhd_bitplanes == 8) {
487 if (CAMGok && (camg_viewmode & 0x800)) {
488 fmt = ILBM_HAM8;
489 }
490 } else if ((bmhd_bitplanes > 5) && CAMGok) {
491 if (camg_viewmode & 0x80) {
492 fmt = ILBM_EHB;
493 } else if (camg_viewmode & 0x800) {
494 fmt = ILBM_HAM;
495 }
496 }
497
498 wxLogTrace(wxT("iff"),
499 wxT("LoadIFF: %s %dx%d, planes=%d (%d cols), comp=%d"),
500 (fmt==ILBM_NORMAL) ? "Normal ILBM" :
501 (fmt==ILBM_HAM) ? "HAM ILBM" :
502 (fmt==ILBM_HAM8) ? "HAM8 ILBM" :
503 (fmt==ILBM_EHB) ? "EHB ILBM" :
504 (fmt==ILBM_24BIT) ? "24BIT ILBM" : "unknown ILBM",
505 bmhd_width, bmhd_height, bmhd_bitplanes,
506 1<<bmhd_bitplanes, bmhd_compression);
507
508 if ((fmt==ILBM_NORMAL) || (fmt==ILBM_EHB) || (fmt==ILBM_HAM)) {
509 wxLogTrace(wxT("iff"),
510 wxT("Converting CMAP from normal ILBM CMAP"));
511
512 switch(fmt) {
513 case ILBM_NORMAL: colors = 1 << bmhd_bitplanes; break;
514 case ILBM_EHB: colors = 32*2; break;
515 case ILBM_HAM: colors = 16; break;
516 }
517
518 if (colors > m_image->colors) {
519 byte *pal = new byte[colors*3];
520 if (!pal) {
521 Destroy();
522 return wxIFF_MEMERR;
523 }
524 int i;
525 for (i = 0; i < m_image->colors; i++) {
526 pal[3*i + 0] = m_image->pal[3*i + 0];
527 pal[3*i + 1] = m_image->pal[3*i + 1];
528 pal[3*i + 2] = m_image->pal[3*i + 2];
529 }
530 for (; i < colors; i++) {
531 pal[3*i + 0] = 0;
532 pal[3*i + 1] = 0;
533 pal[3*i + 2] = 0;
534 }
535 delete m_image->pal;
536 m_image->pal = pal;
537 m_image->colors = colors;
538 }
539
540 for (int i=0; i < colors; i++) {
541 m_image->pal[3*i + 0] = (m_image->pal[3*i + 0] >> 4) * 17;
542 m_image->pal[3*i + 1] = (m_image->pal[3*i + 1] >> 4) * 17;
543 m_image->pal[3*i + 2] = (m_image->pal[3*i + 2] >> 4) * 17;
544 }
545 }
546
547 m_image->p = new byte[bmhd_width * bmhd_height * 3];
548 byte *picptr = m_image->p;
549 if (!picptr) {
550 Destroy();
551 return wxIFF_MEMERR;
552 }
553
554 byte *pal = m_image->pal;
555 int lineskip = ((bmhd_width + 15) >> 4) << 1;
556 int height = chunkLen / (lineskip * bmhd_bitplanes);
557
558 if (bmhd_height < height) {
559 height = bmhd_height;
560 }
561
562 if (fmt == ILBM_HAM || fmt == ILBM_HAM8 || fmt == ILBM_24BIT) {
563 byte *pic = picptr;
564 const byte *workptr = bodyptr;
565
566 for (int i=0; i < height; i++) {
567 byte bitmsk = 0x80;
568 const byte *workptr2 = workptr;
569
570 // at start of each line, init RGB values to background
571 byte rval = pal[0];
572 byte gval = pal[1];
573 byte bval = pal[2];
574
575 for (int j=0; j < bmhd_width; j++) {
576 long col = 0;
577 long colbit = 1;
578 const byte *workptr3 = workptr2;
579 for (int k=0; k < bmhd_bitplanes; k++) {
580 if (*workptr3 & bitmsk) {
581 col += colbit;
582 }
583 workptr3 += lineskip;
584 colbit <<= 1;
585 }
586
587 if (fmt==ILBM_HAM) {
588 int c = (col & 0x0f);
589 switch (col & 0x30) {
590 case 0x00: if (c >= 0 && c < colors) {
591 rval = pal[3*c + 0];
592 gval = pal[3*c + 1];
593 bval = pal[3*c + 2];
594 }
595 break;
596
597 case 0x10: bval = c * 17;
598 break;
599
600 case 0x20: rval = c * 17;
601 break;
602
603 case 0x30: gval = c * 17;
604 break;
605 }
606 } else if (fmt == ILBM_HAM8) {
607 int c = (col & 0x3f);
608 switch(col & 0xc0) {
609 case 0x00: if (c >= 0 && c < colors) {
610 rval = pal[3*c + 0];
611 gval = pal[3*c + 1];
612 bval = pal[3*c + 2];
613 }
614 break;
615
616 case 0x40: bval = (bval & 3) | (c << 2);
617 break;
618
619 case 0x80: rval = (rval & 3) | (c << 2);
620 break;
621
622 case 0xc0: gval = (rval & 3) | (c << 2);
623 }
624 } else {
625 rval = col & 0xff;
626 gval = (col >> 8) & 0xff;
627 bval = (col >> 16) & 0xff;
628 }
629
630 *pic++ = rval;
631 *pic++ = gval;
632 *pic++ = bval;
633
634 bitmsk = bitmsk >> 1;
635 if (bitmsk == 0) {
636 bitmsk = 0x80;
637 workptr2++;
638 }
639 }
640 workptr += lineskip * bmhd_bitplanes;
641 }
642 } else if ((fmt == ILBM_NORMAL) || (fmt == ILBM_EHB)) {
643 if (fmt == ILBM_EHB) {
644 wxLogTrace(wxT("iff"), wxT("Doubling CMAP for EHB mode"));
645
646 for (int i=0; i<32; i++) {
647 pal[3*(i + 32) + 0] = pal[3*i + 0] >> 1;
648 pal[3*(i + 32) + 1] = pal[3*i + 1] >> 1;
649 pal[3*(i + 32) + 2] = pal[3*i + 2] >> 1;
650 }
651 }
652
653 byte *pic = picptr; // ptr to buffer
654 const byte *workptr = bodyptr; // ptr to pic, planar format
655
656 if (bmhd_height < height) {
657 height = bmhd_height;
658 }
659
660 for (int i=0; i < height; i++) {
661 byte bitmsk = 0x80; // left most bit (mask)
662 const byte *workptr2 = workptr; // work ptr to source
663 for (int j=0; j < bmhd_width; j++) {
664 long col = 0;
665 long colbit = 1;
666 const byte *workptr3 = workptr2; // 1st byte in 1st pln
667
668 for (int k=0; k < bmhd_bitplanes; k++) {
669 if (*workptr3 & bitmsk) { // if bit set in this pln
670 col = col + colbit; // add bit to chunky byte
671 }
672 workptr3 += lineskip; // go to next line
673 colbit <<= 1; // shift color bit
674 }
675
676 if (col >= 0 && col < colors) {
677 pic[0] = pal[3*col + 0];
678 pic[1] = pal[3*col + 1];
679 pic[2] = pal[3*col + 2];
680 } else {
681 pic[0] = pic[1] = pic[2] = 0;
682 }
683 pic += 3;
684 bitmsk = bitmsk >> 1; // shift mask to next bit
685 if (bitmsk == 0) { // if mask is zero
686 bitmsk = 0x80; // reset mask
687 workptr2++; // mv ptr to next byte
688 }
689 }
690
691 workptr += lineskip * bmhd_bitplanes; // to next line
692 }
693 } else {
694 break; // unknown format
695 }
696
697 m_image->w = bmhd_width;
698 m_image->h = height;
699 m_image->transparent = bmhd_transcol;
700
701 wxLogTrace(wxT("iff"), wxT("Loaded IFF picture %s"),
702 truncated? "truncated" : "completely");
703
704 return (truncated? wxIFF_TRUNCATED : wxIFF_OK);
705 } else {
706 wxLogTrace(wxT("iff"), wxT("Skipping unknown chunk '%c%c%c%c'"),
707 *dataptr, *(dataptr+1), *(dataptr+2), *(dataptr+3));
708
709 dataptr = dataptr + 8 + chunkLen; // skip unknown chunk
710 }
711 }
712
713 Destroy();
714 return wxIFF_INVFORMAT;
715 }
716
717
718
719 //-----------------------------------------------------------------------------
720 // wxIFFHandler
721 //-----------------------------------------------------------------------------
722
723 IMPLEMENT_DYNAMIC_CLASS(wxIFFHandler, wxImageHandler)
724
725 #if wxUSE_STREAMS
726
727 bool wxIFFHandler::LoadFile(wxImage *image, wxInputStream& stream,
728 bool verbose, int WXUNUSED(index))
729 {
730 wxIFFDecoder *decod;
731 int error;
732 bool ok;
733
734 decod = new wxIFFDecoder(&stream);
735 error = decod->ReadIFF();
736
737 if ((error != wxIFF_OK) && (error != wxIFF_TRUNCATED))
738 {
739 if (verbose)
740 {
741 switch (error)
742 {
743 case wxIFF_INVFORMAT:
744 wxLogError(_("IFF: error in IFF image format."));
745 break;
746 case wxIFF_MEMERR:
747 wxLogError(_("IFF: not enough memory."));
748 break;
749 default:
750 wxLogError(_("IFF: unknown error!!!"));
751 break;
752 }
753 }
754 delete decod;
755 return false;
756 }
757
758 if ((error == wxIFF_TRUNCATED) && verbose)
759 {
760 wxLogError(_("IFF: data stream seems to be truncated."));
761 /* go on; image data is OK */
762 }
763
764 ok = decod->ConvertToImage(image);
765 delete decod;
766
767 return ok;
768 }
769
770 bool wxIFFHandler::SaveFile(wxImage * WXUNUSED(image),
771 wxOutputStream& WXUNUSED(stream), bool verbose)
772 {
773 if (verbose)
774 {
775 wxLogDebug(wxT("IFF: the handler is read-only!!"));
776 }
777
778 return false;
779 }
780
781 bool wxIFFHandler::DoCanRead(wxInputStream& stream)
782 {
783 wxIFFDecoder decod(&stream);
784
785 return decod.CanRead();
786 // it's ok to modify the stream position here
787 }
788
789 #endif // wxUSE_STREAMS
790
791 #endif // wxUSE_IFF