projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Warning fixes for OpenWatcom.
[wxWidgets.git] / src / common / imagbmp.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: imagbmp.cpp
3 // Purpose: wxImage BMP,ICO and CUR handlers
4 // Author: Robert Roebling, Chris Elliott
5 // RCS-ID: $Id$
6 // Copyright: (c) Robert Roebling, Chris Elliott
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
11 #pragma implementation "imagbmp.h"
12 #endif
13
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
16
17 #ifdef __BORLANDC__
18 #pragma hdrstop
19 #endif
20
21 #include "wx/defs.h"
22
23 #if wxUSE_IMAGE
24
25 #include "wx/imagbmp.h"
26 #include "wx/bitmap.h"
27 #include "wx/debug.h"
28 #include "wx/log.h"
29 #include "wx/app.h"
30 #include "wx/filefn.h"
31 #include "wx/wfstream.h"
32 #include "wx/intl.h"
33 #include "wx/module.h"
34 #include "wx/quantize.h"
35
36 // For memcpy
37 #include <string.h>
38
39 #ifdef __SALFORDC__
40 #ifdef FAR
41 #undef FAR
42 #endif
43 #endif
44
45 #ifdef __WXMSW__
46 #include "wx/msw/wrapwin.h"
47 #endif
48
49 //-----------------------------------------------------------------------------
50 // wxBMPHandler
51 //-----------------------------------------------------------------------------
52
53 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
54
55 #if wxUSE_STREAMS
56
57 #ifndef BI_RGB
58 #define BI_RGB 0
59 #endif
60
61 #ifndef BI_RLE8
62 #define BI_RLE8 1
63 #endif
64
65 #ifndef BI_RLE4
66 #define BI_RLE4 2
67 #endif
68
69 #ifndef BI_BITFIELDS
70 #define BI_BITFIELDS 3
71 #endif
72
73 #define poffset (line * width * 3 + column * 3)
74
75 bool wxBMPHandler::SaveFile(wxImage *image,
76 wxOutputStream& stream,
77 bool verbose)
78 {
79 return SaveDib(image, stream, verbose, true/*IsBmp*/, false/*IsMask*/);
80 }
81
82 bool wxBMPHandler::SaveDib(wxImage *image,
83 wxOutputStream& stream,
84 bool verbose,
85 bool IsBmp,
86 bool IsMask)
87
88 {
89 wxCHECK_MSG( image, false, _T("invalid pointer in wxBMPHandler::SaveFile") );
90
91 if ( !image->Ok() )
92 {
93 if ( verbose )
94 wxLogError(_("BMP: Couldn't save invalid image."));
95 return false;
96 }
97
98 // get the format of the BMP file to save, else use 24bpp
99 unsigned format = wxBMP_24BPP;
100 if ( image->HasOption(wxIMAGE_OPTION_BMP_FORMAT) )
101 format = image->GetOptionInt(wxIMAGE_OPTION_BMP_FORMAT);
102
103 wxUint16 bpp; // # of bits per pixel
104 int palette_size; // # of color map entries, ie. 2^bpp colors
105
106 // set the bpp and appropriate palette_size, and do additional checks
107 if ( (format == wxBMP_1BPP) || (format == wxBMP_1BPP_BW) )
108 {
109 bpp = 1;
110 palette_size = 2;
111 }
112 else if ( format == wxBMP_4BPP )
113 {
114 bpp = 4;
115 palette_size = 16;
116 }
117 else if ( (format == wxBMP_8BPP) || (format == wxBMP_8BPP_GREY) ||
118 (format == wxBMP_8BPP_RED) || (format == wxBMP_8BPP_PALETTE) )
119 {
120 // need to set a wxPalette to use this, HOW TO CHECK IF VALID, SIZE?
121 if ((format == wxBMP_8BPP_PALETTE)
122 #if wxUSE_PALETTE
123 && !image->HasPalette()
124 #endif // wxUSE_PALETTE
125 )
126 {
127 if ( verbose )
128 wxLogError(_("BMP: wxImage doesn't have own wxPalette."));
129 return false;
130 }
131 bpp = 8;
132 palette_size = 256;
133 }
134 else // you get 24bpp
135 {
136 format = wxBMP_24BPP;
137 bpp = 24;
138 palette_size = 0;
139 }
140
141 unsigned width = image->GetWidth();
142 unsigned row_padding = (4 - int(width*bpp/8.0) % 4) % 4; // # bytes to pad to dword
143 unsigned row_width = int(width * bpp/8.0) + row_padding; // # of bytes per row
144
145 struct
146 {
147 // BitmapHeader:
148 wxUint16 magic; // format magic, always 'BM'
149 wxUint32 filesize; // total file size, inc. headers
150 wxUint32 reserved; // for future use
151 wxUint32 data_offset; // image data offset in the file
152
153 // BitmapInfoHeader:
154 wxUint32 bih_size; // 2nd part's size
155 wxUint32 width, height; // bitmap's dimensions
156 wxUint16 planes; // num of planes
157 wxUint16 bpp; // bits per pixel
158 wxUint32 compression; // compression method
159 wxUint32 size_of_bmp; // size of the bitmap
160 wxUint32 h_res, v_res; // image resolution in dpi
161 wxUint32 num_clrs; // number of colors used
162 wxUint32 num_signif_clrs;// number of significant colors
163 } hdr;
164
165 wxUint32 hdr_size = 14/*BitmapHeader*/ + 40/*BitmapInfoHeader*/;
166
167 hdr.magic = wxUINT16_SWAP_ON_BE(0x4D42/*'BM'*/);
168 hdr.filesize = wxUINT32_SWAP_ON_BE( hdr_size + palette_size*4 +
169 row_width * image->GetHeight() );
170 hdr.reserved = 0;
171 hdr.data_offset = wxUINT32_SWAP_ON_BE(hdr_size + palette_size*4);
172
173 hdr.bih_size = wxUINT32_SWAP_ON_BE(hdr_size - 14);
174 hdr.width = wxUINT32_SWAP_ON_BE(image->GetWidth());
175 if ( IsBmp )
176 {
177 hdr.height = wxUINT32_SWAP_ON_BE(image->GetHeight());
178 }
179 else
180 {
181 hdr.height = wxUINT32_SWAP_ON_BE(2 * image->GetHeight());
182 }
183 hdr.planes = wxUINT16_SWAP_ON_BE(1); // always 1 plane
184 hdr.bpp = wxUINT16_SWAP_ON_BE(bpp);
185 hdr.compression = 0; // RGB uncompressed
186 hdr.size_of_bmp = wxUINT32_SWAP_ON_BE(row_width * image->GetHeight());
187 hdr.h_res = hdr.v_res = wxUINT32_SWAP_ON_BE(72); // 72dpi is standard
188 hdr.num_clrs = wxUINT32_SWAP_ON_BE(palette_size); // # colors in colormap
189 hdr.num_signif_clrs = 0; // all colors are significant
190
191 if ( IsBmp )
192 {
193 if (// VS: looks ugly but compilers tend to do ugly things with structs,
194 // like aligning hdr.filesize's ofset to dword :(
195 // VZ: we should add padding then...
196 !stream.Write(&hdr.magic, 2) ||
197 !stream.Write(&hdr.filesize, 4) ||
198 !stream.Write(&hdr.reserved, 4) ||
199 !stream.Write(&hdr.data_offset, 4)
200 )
201 {
202 if (verbose)
203 wxLogError(_("BMP: Couldn't write the file (Bitmap) header."));
204 return false;
205 }
206 }
207 if ( !IsMask )
208 {
209 if (
210 !stream.Write(&hdr.bih_size, 4) ||
211 !stream.Write(&hdr.width, 4) ||
212 !stream.Write(&hdr.height, 4) ||
213 !stream.Write(&hdr.planes, 2) ||
214 !stream.Write(&hdr.bpp, 2) ||
215 !stream.Write(&hdr.compression, 4) ||
216 !stream.Write(&hdr.size_of_bmp, 4) ||
217 !stream.Write(&hdr.h_res, 4) ||
218 !stream.Write(&hdr.v_res, 4) ||
219 !stream.Write(&hdr.num_clrs, 4) ||
220 !stream.Write(&hdr.num_signif_clrs, 4)
221 )
222 {
223 if (verbose)
224 wxLogError(_("BMP: Couldn't write the file (BitmapInfo) header."));
225 return false;
226 }
227 }
228
229 wxPalette *palette = NULL; // entries for quantized images
230 wxUint8 *rgbquad = NULL; // for the RGBQUAD bytes for the colormap
231 wxImage *q_image = NULL; // destination for quantized image
232
233 // if <24bpp use quantization to reduce colors for *some* of the formats
234 if ( (format == wxBMP_1BPP) || (format == wxBMP_4BPP) ||
235 (format == wxBMP_8BPP) || (format == wxBMP_8BPP_PALETTE) )
236 {
237 // make a new palette and quantize the image
238 if (format != wxBMP_8BPP_PALETTE)
239 {
240 q_image = new wxImage();
241
242 // I get a delete error using Quantize when desired colors > 236
243 int quantize = ((palette_size > 236) ? 236 : palette_size);
244 // fill the destination too, it gives much nicer 4bpp images
245 wxQuantize::Quantize( *image, *q_image, &palette, quantize, 0,
246 wxQUANTIZE_FILL_DESTINATION_IMAGE );
247 }
248 else
249 {
250 #if wxUSE_PALETTE
251 palette = new wxPalette(image->GetPalette());
252 #endif // wxUSE_PALETTE
253 }
254
255 int i;
256 unsigned char r, g, b;
257 rgbquad = new wxUint8 [palette_size*4];
258
259 for (i = 0; i < palette_size; i++)
260 {
261 #if wxUSE_PALETTE
262 if ( !palette->GetRGB(i, &r, &g, &b) )
263 #endif // wxUSE_PALETTE
264 r = g = b = 0;
265
266 rgbquad[i*4] = b;
267 rgbquad[i*4+1] = g;
268 rgbquad[i*4+2] = r;
269 rgbquad[i*4+3] = 0;
270 }
271 }
272 // make a 256 entry greyscale colormap or 2 entry black & white
273 else if ( (format == wxBMP_8BPP_GREY) || (format == wxBMP_8BPP_RED) ||
274 (format == wxBMP_1BPP_BW) )
275 {
276 int i;
277 rgbquad = new wxUint8 [palette_size*4];
278
279 for (i = 0; i < palette_size; i++)
280 {
281 // if 1BPP_BW then just 0 and 255 then exit
282 if (( i > 0) && (format == wxBMP_1BPP_BW)) i = 255;
283 rgbquad[i*4] = i;
284 rgbquad[i*4+1] = i;
285 rgbquad[i*4+2] = i;
286 rgbquad[i*4+3] = 0;
287 }
288 }
289
290 // if the colormap was made, then it needs to be written
291 if (rgbquad)
292 {
293 if ( !IsMask )
294 {
295 if ( !stream.Write(rgbquad, palette_size*4) )
296 {
297 if (verbose)
298 wxLogError(_("BMP: Couldn't write RGB color map."));
299 delete[] rgbquad;
300 #if wxUSE_PALETTE
301 delete palette;
302 #endif // wxUSE_PALETTE
303 delete q_image;
304 return false;
305 }
306 }
307 delete []rgbquad;
308 }
309
310 // pointer to the image data, use quantized if available
311 wxUint8 *data = (wxUint8*) image->GetData();
312 if (q_image) if (q_image->Ok()) data = (wxUint8*) q_image->GetData();
313
314 wxUint8 *buffer = new wxUint8[row_width];
315 memset(buffer, 0, row_width);
316 int y; unsigned x;
317 long int pixel;
318
319 for (y = image->GetHeight() -1; y >= 0; y--)
320 {
321 if ( format == wxBMP_24BPP ) // 3 bytes per pixel red,green,blue
322 {
323 for ( x = 0; x < width; x++ )
324 {
325 pixel = 3*(y*width + x);
326
327 buffer[3*x ] = data[pixel+2];
328 buffer[3*x + 1] = data[pixel+1];
329 buffer[3*x + 2] = data[pixel];
330 }
331 }
332 else if ((format == wxBMP_8BPP) || // 1 byte per pixel in color
333 (format == wxBMP_8BPP_PALETTE))
334 {
335 for (x = 0; x < width; x++)
336 {
337 pixel = 3*(y*width + x);
338 #if wxUSE_PALETTE
339 buffer[x] = palette->GetPixel( data[pixel],
340 data[pixel+1],
341 data[pixel+2] );
342 #else
343 // FIXME: what should this be? use some std palette maybe?
344 buffer[x] = 0;
345 #endif // wxUSE_PALETTE
346 }
347 }
348 else if ( format == wxBMP_8BPP_GREY ) // 1 byte per pix, rgb ave to grey
349 {
350 for (x = 0; x < width; x++)
351 {
352 pixel = 3*(y*width + x);
353 buffer[x] = (wxUint8)(.299*data[pixel] +
354 .587*data[pixel+1] +
355 .114*data[pixel+2]);
356 }
357 }
358 else if ( format == wxBMP_8BPP_RED ) // 1 byte per pixel, red as greys
359 {
360 for (x = 0; x < width; x++)
361 {
362 buffer[x] = (wxUint8)data[3*(y*width + x)];
363 }
364 }
365 else if ( format == wxBMP_4BPP ) // 4 bpp in color
366 {
367 for (x = 0; x < width; x+=2)
368 {
369 pixel = 3*(y*width + x);
370
371 // fill buffer, ignore if > width
372 #if wxUSE_PALETTE
373 buffer[x/2] =
374 ((wxUint8)palette->GetPixel(data[pixel],
375 data[pixel+1],
376 data[pixel+2]) << 4) |
377 (((x+1) > width)
378 ? 0
379 : ((wxUint8)palette->GetPixel(data[pixel+3],
380 data[pixel+4],
381 data[pixel+5]) ));
382 #else
383 // FIXME: what should this be? use some std palette maybe?
384 buffer[x/2] = 0;
385 #endif // wxUSE_PALETTE
386 }
387 }
388 else if ( format == wxBMP_1BPP ) // 1 bpp in "color"
389 {
390 for (x = 0; x < width; x+=8)
391 {
392 pixel = 3*(y*width + x);
393
394 #if wxUSE_PALETTE
395 buffer[x/8] = ((wxUint8)palette->GetPixel(data[pixel], data[pixel+1], data[pixel+2]) << 7) |
396 (((x+1) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+3], data[pixel+4], data[pixel+5]) << 6)) |
397 (((x+2) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+6], data[pixel+7], data[pixel+8]) << 5)) |
398 (((x+3) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+9], data[pixel+10], data[pixel+11]) << 4)) |
399 (((x+4) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+12], data[pixel+13], data[pixel+14]) << 3)) |
400 (((x+5) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+15], data[pixel+16], data[pixel+17]) << 2)) |
401 (((x+6) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+18], data[pixel+19], data[pixel+20]) << 1)) |
402 (((x+7) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+21], data[pixel+22], data[pixel+23]) ));
403 #else
404 // FIXME: what should this be? use some std palette maybe?
405 buffer[x/8] = 0;
406 #endif // wxUSE_PALETTE
407 }
408 }
409 else if ( format == wxBMP_1BPP_BW ) // 1 bpp B&W colormap from red color ONLY
410 {
411 for (x = 0; x < width; x+=8)
412 {
413 pixel = 3*(y*width + x);
414
415 buffer[x/8] =
416 (((wxUint8)(data[pixel] /128.)) << 7) |
417 (((x+1) > width) ? 0 : (((wxUint8)(data[pixel+3] /128.)) << 6)) |
418 (((x+2) > width) ? 0 : (((wxUint8)(data[pixel+6] /128.)) << 5)) |
419 (((x+3) > width) ? 0 : (((wxUint8)(data[pixel+9] /128.)) << 4)) |
420 (((x+4) > width) ? 0 : (((wxUint8)(data[pixel+12]/128.)) << 3)) |
421 (((x+5) > width) ? 0 : (((wxUint8)(data[pixel+15]/128.)) << 2)) |
422 (((x+6) > width) ? 0 : (((wxUint8)(data[pixel+18]/128.)) << 1)) |
423 (((x+7) > width) ? 0 : (((wxUint8)(data[pixel+21]/128.)) ));
424 }
425 }
426
427 if ( !stream.Write(buffer, row_width) )
428 {
429 if (verbose)
430 wxLogError(_("BMP: Couldn't write data."));
431 delete[] buffer;
432 #if wxUSE_PALETTE
433 delete palette;
434 #endif // wxUSE_PALETTE
435 delete q_image;
436 return false;
437 }
438 }
439 delete[] buffer;
440 #if wxUSE_PALETTE
441 delete palette;
442 #endif // wxUSE_PALETTE
443 delete q_image;
444
445 return true;
446 }
447
448
449 typedef struct
450 {
451 unsigned char r, g, b;
452 } _cmap;
453
454 bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
455 int bpp, int ncolors, int comp,
456 wxFileOffset bmpOffset, wxInputStream& stream,
457 bool verbose, bool IsBmp, bool hasPalette)
458 {
459 wxInt32 aDword, rmask = 0, gmask = 0, bmask = 0;
460 int rshift = 0, gshift = 0, bshift = 0;
461 int rbits = 0, gbits = 0, bbits = 0;
462 wxInt32 dbuf[4];
463 wxInt8 bbuf[4];
464 wxUint8 aByte;
465 wxUint16 aWord;
466
467 // allocate space for palette if needed:
468 _cmap *cmap;
469
470 if ( bpp < 16 )
471 {
472 cmap = new _cmap[ncolors];
473 if ( !cmap )
474 {
475 if (verbose)
476 wxLogError(_("BMP: Couldn't allocate memory."));
477 return false;
478 }
479 }
480 else
481 cmap = NULL;
482
483 // destroy existing here instead of:
484 image->Destroy();
485 image->Create(width, height);
486
487 unsigned char *ptr = image->GetData();
488
489 if ( !ptr )
490 {
491 if ( verbose )
492 wxLogError( _("BMP: Couldn't allocate memory.") );
493 if ( cmap )
494 delete[] cmap;
495 return false;
496 }
497
498 // Reading the palette, if it exists:
499 if ( bpp < 16 && ncolors != 0 )
500 {
501 unsigned char* r = new unsigned char[ncolors];
502 unsigned char* g = new unsigned char[ncolors];
503 unsigned char* b = new unsigned char[ncolors];
504 for (int j = 0; j < ncolors; j++)
505 {
506 if (hasPalette)
507 {
508 stream.Read(bbuf, 4);
509 cmap[j].b = bbuf[0];
510 cmap[j].g = bbuf[1];
511 cmap[j].r = bbuf[2];
512
513 r[j] = cmap[j].r;
514 g[j] = cmap[j].g;
515 b[j] = cmap[j].b;
516 }
517 else
518 {
519 //used in reading .ico file mask
520 r[j] = cmap[j].r = j * 255;
521 g[j] = cmap[j].g = j * 255;
522 b[j] = cmap[j].b = j * 255;
523 }
524 }
525
526 #if wxUSE_PALETTE
527 // Set the palette for the wxImage
528 image->SetPalette(wxPalette(ncolors, r, g, b));
529 #endif // wxUSE_PALETTE
530
531 delete[] r;
532 delete[] g;
533 delete[] b;
534 }
535 else if ( bpp == 16 || bpp == 32 )
536 {
537 if ( comp == BI_BITFIELDS )
538 {
539 int bit = 0;
540 stream.Read(dbuf, 4 * 3);
541 rmask = wxINT32_SWAP_ON_BE(dbuf[0]);
542 gmask = wxINT32_SWAP_ON_BE(dbuf[1]);
543 bmask = wxINT32_SWAP_ON_BE(dbuf[2]);
544 // find shift amount (Least significant bit of mask)
545 for (bit = bpp-1; bit>=0; bit--)
546 {
547 if (bmask & (1 << bit))
548 bshift = bit;
549 if (gmask & (1 << bit))
550 gshift = bit;
551 if (rmask & (1 << bit))
552 rshift = bit;
553 }
554 // Find number of bits in mask (MSB-LSB+1)
555 for (bit = 0; bit < bpp; bit++)
556 {
557 if (bmask & (1 << bit))
558 bbits = bit-bshift+1;
559 if (gmask & (1 << bit))
560 gbits = bit-gshift+1;
561 if (rmask & (1 << bit))
562 rbits = bit-rshift+1;
563 }
564 }
565 else if ( bpp == 16 )
566 {
567 rmask = 0x7C00;
568 gmask = 0x03E0;
569 bmask = 0x001F;
570 rshift = 10;
571 gshift = 5;
572 bshift = 0;
573 rbits = 5;
574 gbits = 5;
575 bbits = 5;
576 }
577 else if ( bpp == 32 )
578 {
579 rmask = 0x00FF0000;
580 gmask = 0x0000FF00;
581 bmask = 0x000000FF;
582 rshift = 16;
583 gshift = 8;
584 bshift = 0;
585 rbits = 8;
586 gbits = 8;
587 bbits = 8;
588 }
589 }
590
591 /*
592 * Reading the image data
593 */
594 if ( IsBmp )
595 stream.SeekI(bmpOffset); // else icon, just carry on
596
597 unsigned char *data = ptr;
598
599 /* set the whole image to the background color */
600 if ( bpp < 16 && (comp == BI_RLE4 || comp == BI_RLE8) )
601 {
602 for (int i = 0; i < width * height; i++)
603 {
604 *ptr++ = cmap[0].r;
605 *ptr++ = cmap[0].g;
606 *ptr++ = cmap[0].b;
607 }
608 ptr = data;
609 }
610
611 int linesize = ((width * bpp + 31) / 32) * 4;
612
613 /* BMPs are stored upside down */
614 for ( int line = (height - 1); line >= 0; line-- )
615 {
616 int linepos = 0;
617 for ( int column = 0; column < width ; )
618 {
619 if ( bpp < 16 )
620 {
621 linepos++;
622 aByte = stream.GetC();
623 if ( bpp == 1 )
624 {
625 for (int bit = 0; bit < 8 && column < width; bit++)
626 {
627 int index = ((aByte & (0x80 >> bit)) ? 1 : 0);
628 ptr[poffset] = cmap[index].r;
629 ptr[poffset + 1] = cmap[index].g;
630 ptr[poffset + 2] = cmap[index].b;
631 column++;
632 }
633 }
634 else if ( bpp == 4 )
635 {
636 if ( comp == BI_RLE4 )
637 {
638 wxUint8 first;
639 first = aByte;
640 aByte = stream.GetC();
641 if ( first == 0 )
642 {
643 if ( aByte == 0 )
644 {
645 if ( column > 0 )
646 column = width;
647 }
648 else if ( aByte == 1 )
649 {
650 column = width;
651 line = -1;
652 }
653 else if ( aByte == 2 )
654 {
655 aByte = stream.GetC();
656 column += aByte;
657 linepos = column * bpp / 4;
658 aByte = stream.GetC();
659 line -= aByte; // upside down
660 }
661 else
662 {
663 int absolute = aByte;
664 wxUint8 nibble[2] ;
665 int readBytes = 0 ;
666 for (int k = 0; k < absolute; k++)
667 {
668 if ( !(k % 2 ) )
669 {
670 ++readBytes ;
671 aByte = stream.GetC();
672 nibble[0] = ( (aByte & 0xF0) >> 4 ) ;
673 nibble[1] = ( aByte & 0x0F ) ;
674 }
675 ptr[poffset ] = cmap[nibble[k%2]].r;
676 ptr[poffset + 1] = cmap[nibble[k%2]].g;
677 ptr[poffset + 2] = cmap[nibble[k%2]].b;
678 column++;
679 if ( k % 2 )
680 linepos++;
681 }
682 if ( readBytes & 0x01 )
683 aByte = stream.GetC();
684 }
685 }
686 else
687 {
688 wxUint8 nibble[2] ;
689 nibble[0] = ( (aByte & 0xF0) >> 4 ) ;
690 nibble[1] = ( aByte & 0x0F ) ;
691
692 for ( int l = 0; l < first && column < width; l++ )
693 {
694 ptr[poffset ] = cmap[nibble[l%2]].r;
695 ptr[poffset + 1] = cmap[nibble[l%2]].g;
696 ptr[poffset + 2] = cmap[nibble[l%2]].b;
697 column++;
698 if ( l % 2 )
699 linepos++;
700 }
701 }
702 }
703 else
704 {
705 for (int nibble = 0; nibble < 2 && column < width; nibble++)
706 {
707 int index = ((aByte & (0xF0 >> nibble * 4)) >> (!nibble * 4));
708 if ( index >= 16 )
709 index = 15;
710 ptr[poffset] = cmap[index].r;
711 ptr[poffset + 1] = cmap[index].g;
712 ptr[poffset + 2] = cmap[index].b;
713 column++;
714 }
715 }
716 }
717 else if ( bpp == 8 )
718 {
719 if ( comp == BI_RLE8 )
720 {
721 unsigned char first;
722 first = aByte;
723 aByte = stream.GetC();
724 if ( first == 0 )
725 {
726 if ( aByte == 0 )
727 {
728 /* column = width; */
729 }
730 else if ( aByte == 1 )
731 {
732 column = width;
733 line = -1;
734 }
735 else if ( aByte == 2 )
736 {
737 aByte = stream.GetC();
738 column += aByte;
739 linepos = column * bpp / 8;
740 aByte = stream.GetC();
741 line += aByte;
742 }
743 else
744 {
745 int absolute = aByte;
746 for (int k = 0; k < absolute; k++)
747 {
748 linepos++;
749 aByte = stream.GetC();
750 ptr[poffset ] = cmap[aByte].r;
751 ptr[poffset + 1] = cmap[aByte].g;
752 ptr[poffset + 2] = cmap[aByte].b;
753 column++;
754 }
755 if ( absolute & 0x01 )
756 aByte = stream.GetC();
757 }
758 }
759 else
760 {
761 for ( int l = 0; l < first && column < width; l++ )
762 {
763 ptr[poffset ] = cmap[aByte].r;
764 ptr[poffset + 1] = cmap[aByte].g;
765 ptr[poffset + 2] = cmap[aByte].b;
766 column++;
767 linepos++;
768 }
769 }
770 }
771 else
772 {
773 ptr[poffset ] = cmap[aByte].r;
774 ptr[poffset + 1] = cmap[aByte].g;
775 ptr[poffset + 2] = cmap[aByte].b;
776 column++;
777 // linepos += size; seems to be wrong, RR
778 }
779 }
780 }
781 else if ( bpp == 24 )
782 {
783 stream.Read(bbuf, 3);
784 linepos += 3;
785 ptr[poffset ] = (unsigned char)bbuf[2];
786 ptr[poffset + 1] = (unsigned char)bbuf[1];
787 ptr[poffset + 2] = (unsigned char)bbuf[0];
788 column++;
789 }
790 else if ( bpp == 16 )
791 {
792 unsigned char temp;
793 stream.Read(&aWord, 2);
794 aWord = wxUINT16_SWAP_ON_BE(aWord);
795 linepos += 2;
796 /* use the masks and calculated amonut of shift
797 to retrieve the color data out of the word. Then
798 shift it left by (8 - number of bits) such that
799 the image has the proper dynamic range */
800 temp = (aWord & rmask) >> rshift << (8-rbits);
801 ptr[poffset] = temp;
802 temp = (aWord & gmask) >> gshift << (8-gbits);
803 ptr[poffset + 1] = temp;
804 temp = (aWord & bmask) >> bshift << (8-bbits);
805 ptr[poffset + 2] = temp;
806 column++;
807 }
808 else
809 {
810 unsigned char temp;
811 stream.Read(&aDword, 4);
812 aDword = wxINT32_SWAP_ON_BE(aDword);
813 linepos += 4;
814 temp = (aDword & rmask) >> rshift;
815 ptr[poffset] = temp;
816 temp = (aDword & gmask) >> gshift;
817 ptr[poffset + 1] = temp;
818 temp = (aDword & bmask) >> bshift;
819 ptr[poffset + 2] = temp;
820 column++;
821 }
822 }
823 while ( (linepos < linesize) && (comp != 1) && (comp != 2) )
824 {
825 stream.Read(&aByte, 1);
826 linepos += 1;
827 if ( !stream )
828 break;
829 }
830 }
831
832 delete[] cmap;
833
834 image->SetMask(false);
835
836 const wxStreamError err = stream.GetLastError();
837 return err == wxSTREAM_NO_ERROR || err == wxSTREAM_EOF;
838 }
839
840 bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
841 bool verbose, bool IsBmp)
842 {
843 wxUint16 aWord;
844 wxInt32 dbuf[4];
845 wxInt8 bbuf[4];
846
847 wxFileSize_t offset = 0; // keep gcc quiet
848 if ( IsBmp )
849 {
850 // read the header off the .BMP format file
851
852 offset = stream.TellI();
853 if (offset == wxInvalidOffset)
854 offset = 0;
855
856 stream.Read(bbuf, 2);
857 stream.Read(dbuf, 16);
858 }
859 else
860 {
861 stream.Read(dbuf, 4);
862 }
863 #if 0 // unused
864 wxInt32 size = wxINT32_SWAP_ON_BE(dbuf[0]);
865 #endif
866 offset = offset + wxINT32_SWAP_ON_BE(dbuf[2]);
867
868 stream.Read(dbuf, 4 * 2);
869 int width = (int)wxINT32_SWAP_ON_BE(dbuf[0]);
870 int height = (int)wxINT32_SWAP_ON_BE(dbuf[1]);
871 if ( !IsBmp)height = height / 2; // for icons divide by 2
872
873 if ( width > 32767 )
874 {
875 if (verbose)
876 wxLogError( _("DIB Header: Image width > 32767 pixels for file.") );
877 return false;
878 }
879 if ( height > 32767 )
880 {
881 if (verbose)
882 wxLogError( _("DIB Header: Image height > 32767 pixels for file.") );
883 return false;
884 }
885
886 stream.Read(&aWord, 2);
887 /*
888 TODO
889 int planes = (int)wxUINT16_SWAP_ON_BE( aWord );
890 */
891 stream.Read(&aWord, 2);
892 int bpp = (int)wxUINT16_SWAP_ON_BE(aWord);
893 if ( bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32 )
894 {
895 if (verbose)
896 wxLogError( _("DIB Header: Unknown bitdepth in file.") );
897 return false;
898 }
899
900 stream.Read(dbuf, 4 * 4);
901 int comp = (int)wxINT32_SWAP_ON_BE(dbuf[0]);
902 if ( comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 &&
903 comp != BI_BITFIELDS )
904 {
905 if (verbose)
906 wxLogError( _("DIB Header: Unknown encoding in file.") );
907 return false;
908 }
909
910 stream.Read(dbuf, 4 * 2);
911 int ncolors = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
912 if (ncolors == 0)
913 ncolors = 1 << bpp;
914 /* some more sanity checks */
915 if (((comp == BI_RLE4) && (bpp != 4)) ||
916 ((comp == BI_RLE8) && (bpp != 8)) ||
917 ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
918 {
919 if (verbose)
920 wxLogError( _("DIB Header: Encoding doesn't match bitdepth.") );
921 return false;
922 }
923
924 //read DIB; this is the BMP image or the XOR part of an icon image
925 if ( !DoLoadDib(image, width, height, bpp, ncolors, comp, offset, stream,
926 verbose, IsBmp, true) )
927 {
928 if (verbose)
929 wxLogError( _("Error in reading image DIB .") );
930 return false;
931 }
932
933 if ( !IsBmp )
934 {
935 //read Icon mask which is monochrome
936 //there is no palette, so we will create one
937 wxImage mask;
938 if ( !DoLoadDib(&mask, width, height, 1, 2, BI_RGB, offset, stream,
939 verbose, IsBmp, false) )
940 {
941 if (verbose)
942 wxLogError( _("ICO: Error in reading mask DIB.") );
943 return false;
944 }
945 image->SetMaskFromImage(mask, 255, 255, 255);
946
947 }
948
949 return true;
950 }
951
952 bool wxBMPHandler::LoadFile(wxImage *image, wxInputStream& stream,
953 bool verbose, int WXUNUSED(index))
954 {
955 // Read a single DIB fom the file:
956 return LoadDib(image, stream, verbose, true/*isBmp*/);
957 }
958
959 bool wxBMPHandler::DoCanRead(wxInputStream& stream)
960 {
961 unsigned char hdr[2];
962
963 if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
964 return false;
965
966 // do we have the BMP file signature?
967 return hdr[0] == 'B' && hdr[1] == 'M';
968 }
969
970 #endif // wxUSE_STREAMS
971
972
973 #if wxUSE_ICO_CUR
974 //-----------------------------------------------------------------------------
975 // wxICOHandler
976 //-----------------------------------------------------------------------------
977
978 IMPLEMENT_DYNAMIC_CLASS(wxICOHandler, wxBMPHandler)
979
980 #if wxUSE_STREAMS
981
982 struct ICONDIRENTRY
983 {
984 wxUint8 bWidth; // Width of the image
985 wxUint8 bHeight; // Height of the image (times 2)
986 wxUint8 bColorCount; // Number of colors in image (0 if >=8bpp)
987 wxUint8 bReserved; // Reserved
988
989 // these two are different in icons and cursors:
990 // icon or cursor
991 wxUint16 wPlanes; // Color Planes or XHotSpot
992 wxUint16 wBitCount; // Bits per pixel or YHotSpot
993
994 wxUint32 dwBytesInRes; // how many bytes in this resource?
995 wxUint32 dwImageOffset; // where in the file is this image
996 };
997
998 struct ICONDIR
999 {
1000 wxUint16 idReserved; // Reserved
1001 wxUint16 idType; // resource type (1 for icons, 2 for cursors)
1002 wxUint16 idCount; // how many images?
1003 };
1004
1005
1006 bool wxICOHandler::SaveFile(wxImage *image,
1007 wxOutputStream& stream,
1008 bool verbose)
1009
1010 {
1011 //sanity check; icon must be less than 127 pixels high and 255 wide
1012 if ( image->GetHeight () > 127 )
1013 {
1014 if ( verbose )
1015 wxLogError(_("ICO: Image too tall for an icon."));
1016 return false;
1017 }
1018 if ( image->GetWidth () > 255 )
1019 {
1020 if ( verbose )
1021 wxLogError(_("ICO: Image too wide for an icon."));
1022 return false;
1023 }
1024
1025 int images = 1; // only generate one image
1026
1027 // VS: This is a hack of sort - since ICO and CUR files are almost
1028 // identical, we have all the meat in wxICOHandler and check for
1029 // the actual (handler) type when the code has to distinguish between
1030 // the two formats
1031 int type = (this->GetType() == wxBITMAP_TYPE_CUR) ? 2 : 1;
1032
1033 // write a header, (ICONDIR)
1034 // Calculate the header size
1035 wxUint32 offset = 3 * sizeof(wxUint16);
1036
1037 ICONDIR IconDir;
1038 IconDir.idReserved = 0;
1039 IconDir.idType = wxUINT16_SWAP_ON_BE(type);
1040 IconDir.idCount = wxUINT16_SWAP_ON_BE(images);
1041 stream.Write(&IconDir.idReserved, sizeof(IconDir.idReserved));
1042 stream.Write(&IconDir.idType, sizeof(IconDir.idType));
1043 stream.Write(&IconDir.idCount, sizeof(IconDir.idCount));
1044 if ( !stream.IsOk() )
1045 {
1046 if ( verbose )
1047 wxLogError(_("ICO: Error writing the image file!"));
1048 return false;
1049 }
1050
1051 // for each iamage write a description ICONDIRENTRY:
1052 ICONDIRENTRY icondirentry;
1053 for (int i = 0; i < images; i++)
1054 {
1055 wxImage mask;
1056
1057 if ( image->HasMask() )
1058 {
1059 // make another image with black/white:
1060 mask = image->ConvertToMono (image->GetMaskRed(), image->GetMaskGreen(), image->GetMaskBlue() );
1061
1062 // now we need to change the masked regions to black:
1063 unsigned char r = image->GetMaskRed();
1064 unsigned char g = image->GetMaskGreen();
1065 unsigned char b = image->GetMaskBlue();
1066 if ( (r != 0) || (g != 0) || (b != 0) )
1067 {
1068 // Go round and apply black to the masked bits:
1069 int i, j;
1070 for (i = 0; i < mask.GetWidth(); i++)
1071 {
1072 for (j = 0; j < mask.GetHeight(); j++)
1073 {
1074 if ((r == mask.GetRed(i, j)) &&
1075 (g == mask.GetGreen(i, j))&&
1076 (b == mask.GetBlue(i, j)) )
1077 image->SetRGB(i, j, 0, 0, 0 );
1078 }
1079 }
1080 }
1081 }
1082 else
1083 {
1084 // just make a black mask all over:
1085 mask = image->Copy();
1086 int i, j;
1087 for (i = 0; i < mask.GetWidth(); i++)
1088 for (j = 0; j < mask.GetHeight(); j++)
1089 mask.SetRGB(i, j, 0, 0, 0 );
1090 }
1091 // Set the formats for image and mask
1092 // (Windows never saves with more than 8 colors):
1093 image->SetOption(wxIMAGE_OPTION_BMP_FORMAT, wxBMP_8BPP);
1094
1095 // monochome bitmap:
1096 mask.SetOption(wxIMAGE_OPTION_BMP_FORMAT, wxBMP_1BPP_BW);
1097 bool IsBmp = false;
1098 bool IsMask = false;
1099
1100 //calculate size and offset of image and mask
1101 wxCountingOutputStream cStream;
1102 bool bResult = SaveDib(image, cStream, verbose, IsBmp, IsMask);
1103 if ( !bResult )
1104 {
1105 if ( verbose )
1106 wxLogError(_("ICO: Error writing the image file!"));
1107 return false;
1108 }
1109 IsMask = true;
1110
1111 bResult = SaveDib(&mask, cStream, verbose, IsBmp, IsMask);
1112 if ( !bResult )
1113 {
1114 if ( verbose )
1115 wxLogError(_("ICO: Error writing the image file!"));
1116 return false;
1117 }
1118 wxUint32 Size = cStream.GetSize();
1119
1120 // wxCountingOutputStream::Ok() always returns true for now and this
1121 // "if" provokes VC++ warnings in optimized build
1122 #if 0
1123 if ( !cStream.Ok() )
1124 {
1125 if ( verbose )
1126 wxLogError(_("ICO: Error writing the image file!"));
1127 return false;
1128 }
1129 #endif // 0
1130
1131 offset = offset + sizeof(ICONDIRENTRY);
1132
1133 icondirentry.bWidth = image->GetWidth();
1134 icondirentry.bHeight = 2 * image->GetHeight();
1135 icondirentry.bColorCount = 0;
1136 icondirentry.bReserved = 0;
1137 icondirentry.wPlanes = wxUINT16_SWAP_ON_BE(1);
1138 icondirentry.wBitCount = wxUINT16_SWAP_ON_BE(wxBMP_8BPP);
1139 if ( type == 2 /*CUR*/)
1140 {
1141 int hx = image->HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) ?
1142 image->GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X) :
1143 image->GetWidth() / 2;
1144 int hy = image->HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) ?
1145 image->GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y) :
1146 image->GetHeight() / 2;
1147
1148 // actually write the values of the hot spot here:
1149 icondirentry.wPlanes = wxUINT16_SWAP_ON_BE((wxUint16)hx);
1150 icondirentry.wBitCount = wxUINT16_SWAP_ON_BE((wxUint16)hy);
1151 }
1152 icondirentry.dwBytesInRes = wxUINT32_SWAP_ON_BE(Size);
1153 icondirentry.dwImageOffset = wxUINT32_SWAP_ON_BE(offset);
1154
1155 // increase size to allow for the data written:
1156 offset += Size;
1157
1158 // write to stream:
1159 stream.Write(&icondirentry.bWidth, sizeof(icondirentry.bWidth));
1160 stream.Write(&icondirentry.bHeight, sizeof(icondirentry.bHeight));
1161 stream.Write(&icondirentry.bColorCount, sizeof(icondirentry.bColorCount));
1162 stream.Write(&icondirentry.bReserved, sizeof(icondirentry.bReserved));
1163 stream.Write(&icondirentry.wPlanes, sizeof(icondirentry.wPlanes));
1164 stream.Write(&icondirentry.wBitCount, sizeof(icondirentry.wBitCount));
1165 stream.Write(&icondirentry.dwBytesInRes, sizeof(icondirentry.dwBytesInRes));
1166 stream.Write(&icondirentry.dwImageOffset, sizeof(icondirentry.dwImageOffset));
1167 if ( !stream.IsOk() )
1168 {
1169 if ( verbose )
1170 wxLogError(_("ICO: Error writing the image file!"));
1171 return false;
1172 }
1173
1174 // actually save it:
1175 IsMask = false;
1176 bResult = SaveDib(image, stream, verbose, IsBmp, IsMask);
1177 if ( !bResult )
1178 {
1179 if ( verbose )
1180 wxLogError(_("ICO: Error writing the image file!"));
1181 return false;
1182 }
1183 IsMask = true;
1184
1185 bResult = SaveDib(&mask, stream, verbose, IsBmp, IsMask);
1186 if ( !bResult )
1187 {
1188 if ( verbose )
1189 wxLogError(_("ICO: Error writing the image file!"));
1190 return false;
1191 }
1192
1193 } // end of for loop
1194
1195 return true;
1196 }
1197
1198 bool wxICOHandler::LoadFile(wxImage *image, wxInputStream& stream,
1199 bool verbose, int index)
1200 {
1201 stream.SeekI(0);
1202 return DoLoadFile(image, stream, verbose, index);
1203 }
1204
1205 bool wxICOHandler::DoLoadFile(wxImage *image, wxInputStream& stream,
1206 bool WXUNUSED(verbose), int index)
1207 {
1208 bool bResult wxDUMMY_INITIALIZE(false);
1209 bool IsBmp = false;
1210
1211 ICONDIR IconDir;
1212
1213 wxFileOffset iPos = stream.TellI();
1214 stream.Read(&IconDir, sizeof(IconDir));
1215 wxUint16 nIcons = wxUINT16_SWAP_ON_BE(IconDir.idCount);
1216 // nType is 1 for Icons, 2 for Cursors:
1217 wxUint16 nType = wxUINT16_SWAP_ON_BE(IconDir.idType);
1218
1219 // loop round the icons and choose the best one:
1220 ICONDIRENTRY *pIconDirEntry = new ICONDIRENTRY[nIcons];
1221 ICONDIRENTRY *pCurrentEntry = pIconDirEntry;
1222 int wMax = 0;
1223 int colmax = 0;
1224 int iSel = wxNOT_FOUND;
1225
1226 for (int i = 0; i < nIcons; i++ )
1227 {
1228 stream.Read(pCurrentEntry, sizeof(ICONDIRENTRY));
1229 // bHeight and bColorCount are wxUint8
1230 if ( pCurrentEntry->bWidth >= wMax )
1231 {
1232 // see if we have more colors, ==0 indicates > 8bpp:
1233 if ( pCurrentEntry->bColorCount == 0 )
1234 pCurrentEntry->bColorCount = 255;
1235 if ( pCurrentEntry->bColorCount >= colmax )
1236 {
1237 iSel = i;
1238 wMax = pCurrentEntry->bWidth;
1239 colmax = pCurrentEntry->bColorCount;
1240 }
1241 }
1242 pCurrentEntry++;
1243 }
1244
1245 if ( index != -1 )
1246 {
1247 // VS: Note that we *have* to run the loop above even if index != -1, because
1248 // it reads ICONDIRENTRies.
1249 iSel = index;
1250 }
1251
1252 if ( iSel == wxNOT_FOUND || iSel < 0 || iSel >= nIcons )
1253 {
1254 wxLogError(_("ICO: Invalid icon index."));
1255 bResult = false;
1256 }
1257 else
1258 {
1259 // seek to selected icon:
1260 pCurrentEntry = pIconDirEntry + iSel;
1261 stream.SeekI(iPos + wxUINT32_SWAP_ON_BE(pCurrentEntry->dwImageOffset), wxFromStart);
1262 bResult = LoadDib(image, stream, true, IsBmp);
1263 bool bIsCursorType = (this->GetType() == wxBITMAP_TYPE_CUR) || (this->GetType() == wxBITMAP_TYPE_ANI);
1264 if ( bResult && bIsCursorType && nType == 2 )
1265 {
1266 // it is a cursor, so let's set the hotspot:
1267 image->SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, wxUINT16_SWAP_ON_BE(pCurrentEntry->wPlanes));
1268 image->SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, wxUINT16_SWAP_ON_BE(pCurrentEntry->wBitCount));
1269 }
1270 }
1271 delete[] pIconDirEntry;
1272 return bResult;
1273 }
1274
1275 int wxICOHandler::GetImageCount(wxInputStream& stream)
1276 {
1277 ICONDIR IconDir;
1278 wxFileOffset iPos = stream.TellI();
1279 stream.SeekI(0);
1280 stream.Read(&IconDir, sizeof(IconDir));
1281 wxUint16 nIcons = wxUINT16_SWAP_ON_BE(IconDir.idCount);
1282 stream.SeekI(iPos);
1283 return (int)nIcons;
1284 }
1285
1286 bool wxICOHandler::DoCanRead(wxInputStream& stream)
1287 {
1288 stream.SeekI(0);
1289 unsigned char hdr[4];
1290 if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
1291 return false;
1292
1293 // hdr[2] is one for an icon and two for a cursor
1294 return hdr[0] == '\0' && hdr[1] == '\0' && hdr[2] == '\1' && hdr[3] == '\0';
1295 }
1296
1297 #endif // wxUSE_STREAMS
1298
1299
1300 //-----------------------------------------------------------------------------
1301 // wxCURHandler
1302 //-----------------------------------------------------------------------------
1303
1304 IMPLEMENT_DYNAMIC_CLASS(wxCURHandler, wxICOHandler)
1305
1306 #if wxUSE_STREAMS
1307
1308 bool wxCURHandler::DoCanRead(wxInputStream& stream)
1309 {
1310 stream.SeekI(0);
1311 unsigned char hdr[4];
1312 if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
1313 return false;
1314
1315 // hdr[2] is one for an icon and two for a cursor
1316 return hdr[0] == '\0' && hdr[1] == '\0' && hdr[2] == '\2' && hdr[3] == '\0';
1317 }
1318
1319 #endif // wxUSE_STREAMS
1320
1321 //-----------------------------------------------------------------------------
1322 // wxANIHandler
1323 //-----------------------------------------------------------------------------
1324
1325 IMPLEMENT_DYNAMIC_CLASS(wxANIHandler, wxCURHandler)
1326
1327 #if wxUSE_STREAMS
1328
1329 bool wxANIHandler::LoadFile(wxImage *image, wxInputStream& stream,
1330 bool verbose, int index)
1331 {
1332 wxInt32 FCC1, FCC2;
1333 wxUint32 datalen;
1334
1335 wxInt32 riff32;
1336 memcpy( &riff32, "RIFF", 4 );
1337 wxInt32 list32;
1338 memcpy( &list32, "LIST", 4 );
1339 wxInt32 ico32;
1340 memcpy( &ico32, "icon", 4 );
1341 int iIcon = 0;
1342
1343 stream.SeekI(0);
1344 stream.Read(&FCC1, 4);
1345 if ( FCC1 != riff32 )
1346 return false;
1347
1348 // we have a riff file:
1349 while (stream.IsOk())
1350 {
1351 // we always have a data size
1352 stream.Read(&datalen, 4);
1353 datalen = wxINT32_SWAP_ON_BE(datalen) ;
1354 //data should be padded to make even number of bytes
1355 if (datalen % 2 == 1) datalen ++ ;
1356 //now either data or a FCC
1357 if ( (FCC1 == riff32) || (FCC1 == list32) )
1358 {
1359 stream.Read(&FCC2, 4);
1360 }
1361 else
1362 {
1363 if (FCC1 == ico32 && iIcon >= index)
1364 {
1365 return DoLoadFile(image, stream, verbose, -1);
1366 }
1367 else
1368 {
1369 stream.SeekI(stream.TellI() + datalen);
1370 if ( FCC1 == ico32 )
1371 iIcon ++;
1372 }
1373 }
1374
1375 // try to read next data chunk:
1376 stream.Read(&FCC1, 4);
1377 }
1378 return false;
1379 }
1380
1381 bool wxANIHandler::DoCanRead(wxInputStream& stream)
1382 {
1383 wxInt32 FCC1, FCC2;
1384 wxUint32 datalen ;
1385
1386 wxInt32 riff32;
1387 memcpy( &riff32, "RIFF", 4 );
1388 wxInt32 list32;
1389 memcpy( &list32, "LIST", 4 );
1390 wxInt32 ico32;
1391 memcpy( &ico32, "icon", 4 );
1392 wxInt32 anih32;
1393 memcpy( &anih32, "anih", 4 );
1394
1395 stream.SeekI(0);
1396 if ( !stream.Read(&FCC1, 4) )
1397 return false;
1398
1399 if ( FCC1 != riff32 )
1400 return false;
1401
1402 // we have a riff file:
1403 while ( stream.IsOk() )
1404 {
1405 if ( FCC1 == anih32 )
1406 return true;
1407 // we always have a data size:
1408 stream.Read(&datalen, 4);
1409 datalen = wxINT32_SWAP_ON_BE(datalen) ;
1410 //data should be padded to make even number of bytes
1411 if (datalen % 2 == 1) datalen ++ ;
1412 // now either data or a FCC:
1413 if ( (FCC1 == riff32) || (FCC1 == list32) )
1414 {
1415 stream.Read(&FCC2, 4);
1416 }
1417 else
1418 {
1419 stream.SeekI(stream.TellI() + datalen);
1420 }
1421
1422 // try to read next data chunk:
1423 if ( !stream.Read(&FCC1, 4) )
1424 {
1425 // reading failed -- either EOF or IO error, bail out anyhow
1426 return false;
1427 }
1428 }
1429
1430 return false;
1431 }
1432
1433 int wxANIHandler::GetImageCount(wxInputStream& stream)
1434 {
1435 wxInt32 FCC1, FCC2;
1436 wxUint32 datalen ;
1437
1438 wxInt32 riff32;
1439 memcpy( &riff32, "RIFF", 4 );
1440 wxInt32 list32;
1441 memcpy( &list32, "LIST", 4 );
1442 wxInt32 ico32;
1443 memcpy( &ico32, "icon", 4 );
1444 wxInt32 anih32;
1445 memcpy( &anih32, "anih", 4 );
1446
1447 stream.SeekI(0);
1448 stream.Read(&FCC1, 4);
1449 if ( FCC1 != riff32 )
1450 return wxNOT_FOUND;
1451
1452 // we have a riff file:
1453 while ( stream.IsOk() )
1454 {
1455 // we always have a data size:
1456 stream.Read(&datalen, 4);
1457 datalen = wxINT32_SWAP_ON_BE(datalen) ;
1458 //data should be padded to make even number of bytes
1459 if (datalen % 2 == 1) datalen ++ ;
1460 // now either data or a FCC:
1461 if ( (FCC1 == riff32) || (FCC1 == list32) )
1462 {
1463 stream.Read(&FCC2, 4);
1464 }
1465 else
1466 {
1467 if ( FCC1 == anih32 )
1468 {
1469 wxUint32 *pData = new wxUint32[datalen/4];
1470 stream.Read(pData, datalen);
1471 int nIcons = wxINT32_SWAP_ON_BE(*(pData + 1));
1472 delete[] pData;
1473 return nIcons;
1474 }
1475 else
1476 stream.SeekI(stream.TellI() + datalen);
1477 }
1478
1479 // try to read next data chunk:
1480 stream.Read(&FCC1, 4);
1481 }
1482
1483 return wxNOT_FOUND;
1484 }
1485
1486 #endif // wxUSE_STREAMS
1487
1488 #endif // wxUSE_ICO_CUR
1489
1490 #endif // wxUSE_IMAGE
wxWidgets (Impactor)