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