projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge in from trunk r67662 to r64801
[wxWidgets.git] / src / common / imagpng.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/imagpng.cpp
3 // Purpose: wxImage PNG handler
4 // Author: Robert Roebling
5 // RCS-ID: $Id$
6 // Copyright: (c) Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // ============================================================================
11 // declarations
12 // ============================================================================
13
14 // ----------------------------------------------------------------------------
15 // headers
16 // ----------------------------------------------------------------------------
17
18 // For compilers that support precompilation, includes "wx.h".
19 #include "wx/wxprec.h"
20
21 #ifdef __BORLANDC__
22 #pragma hdrstop
23 #endif
24
25 #if wxUSE_IMAGE && wxUSE_LIBPNG
26
27 #include "wx/imagpng.h"
28 #include "wx/versioninfo.h"
29
30 #ifndef WX_PRECOMP
31 #include "wx/log.h"
32 #include "wx/intl.h"
33 #include "wx/palette.h"
34 #include "wx/stream.h"
35 #endif
36
37 #include "png.h"
38
39 // For memcpy
40 #include <string.h>
41
42 // ----------------------------------------------------------------------------
43 // constants
44 // ----------------------------------------------------------------------------
45
46 // image cannot have any transparent pixels at all, have only 100% opaque
47 // and/or 100% transparent pixels in which case a simple mask is enough to
48 // store this information in wxImage or have a real alpha channel in which case
49 // we need to have it in wxImage as well
50 enum Transparency
51 {
52 Transparency_None,
53 Transparency_Mask,
54 Transparency_Alpha
55 };
56
57 // ----------------------------------------------------------------------------
58 // local functions
59 // ----------------------------------------------------------------------------
60
61 // return the kind of transparency needed for this image assuming that it does
62 // have transparent pixels, i.e. either Transparency_Alpha or Transparency_Mask
63 static Transparency
64 CheckTransparency(unsigned char **lines,
65 png_uint_32 x, png_uint_32 y, png_uint_32 w, png_uint_32 h,
66 size_t numColBytes);
67
68 // init the alpha channel for the image and fill it with 1s up to (x, y)
69 static unsigned char *InitAlpha(wxImage *image, png_uint_32 x, png_uint_32 y);
70
71 // find a free colour for the mask in the PNG data array
72 static void
73 FindMaskColour(unsigned char **lines, png_uint_32 width, png_uint_32 height,
74 unsigned char& rMask, unsigned char& gMask, unsigned char& bMask);
75
76 // is the pixel with this value of alpha a fully opaque one?
77 static inline
78 bool IsOpaque(unsigned char a)
79 {
80 return a == 0xff;
81 }
82
83 // is the pixel with this value of alpha a fully transparent one?
84 static inline
85 bool IsTransparent(unsigned char a)
86 {
87 return !a;
88 }
89
90 // ============================================================================
91 // wxPNGHandler implementation
92 // ============================================================================
93
94 IMPLEMENT_DYNAMIC_CLASS(wxPNGHandler,wxImageHandler)
95
96 #if wxUSE_STREAMS
97
98 #ifndef PNGLINKAGEMODE
99 #ifdef PNGAPI
100 #define PNGLINKAGEMODE PNGAPI
101 #elif defined(__WATCOMC__)
102 // we need an explicit cdecl for Watcom, at least according to
103 //
104 // http://sf.net/tracker/index.php?func=detail&aid=651492&group_id=9863&atid=109863
105 //
106 // more testing is needed for this however, please remove this comment
107 // if you can confirm that my fix works with Watcom 11
108 #define PNGLINKAGEMODE cdecl
109 #else
110 #define PNGLINKAGEMODE LINKAGEMODE
111 #endif
112 #endif
113
114
115 // VS: wxPNGInfoStruct declared below is a hack that needs some explanation.
116 // First, let me describe what's the problem: libpng uses jmp_buf in
117 // its png_struct structure. Unfortunately, this structure is
118 // compiler-specific and may vary in size, so if you use libpng compiled
119 // as DLL with another compiler than the main executable, it may not work
120 // (this is for example the case with wxMGL port and SciTech MGL library
121 // that provides custom runtime-loadable libpng implementation with jmpbuf
122 // disabled altogether). Luckily, it is still possible to use setjmp() &
123 // longjmp() as long as the structure is not part of png_struct.
124 //
125 // Sadly, there's no clean way to attach user-defined data to png_struct.
126 // There is only one customizable place, png_struct.io_ptr, which is meant
127 // only for I/O routines and is set with png_set_read_fn or
128 // png_set_write_fn. The hacky part is that we use io_ptr to store
129 // a pointer to wxPNGInfoStruct that holds I/O structures _and_ jmp_buf.
130
131 struct wxPNGInfoStruct
132 {
133 jmp_buf jmpbuf;
134 bool verbose;
135
136 union
137 {
138 wxInputStream *in;
139 wxOutputStream *out;
140 } stream;
141 };
142
143 #define WX_PNG_INFO(png_ptr) ((wxPNGInfoStruct*)png_get_io_ptr(png_ptr))
144
145 // ----------------------------------------------------------------------------
146 // helper functions
147 // ----------------------------------------------------------------------------
148
149 extern "C"
150 {
151
152 static void PNGLINKAGEMODE wx_PNG_stream_reader( png_structp png_ptr, png_bytep data,
153 png_size_t length )
154 {
155 WX_PNG_INFO(png_ptr)->stream.in->Read(data, length);
156 }
157
158 static void PNGLINKAGEMODE wx_PNG_stream_writer( png_structp png_ptr, png_bytep data,
159 png_size_t length )
160 {
161 WX_PNG_INFO(png_ptr)->stream.out->Write(data, length);
162 }
163
164 static void
165 PNGLINKAGEMODE wx_png_warning(png_structp png_ptr, png_const_charp message)
166 {
167 wxPNGInfoStruct *info = png_ptr ? WX_PNG_INFO(png_ptr) : NULL;
168 if ( !info || info->verbose )
169 {
170 wxLogWarning( wxString::FromAscii(message) );
171 }
172 }
173
174 // from pngerror.c
175 // so that the libpng doesn't send anything on stderr
176 static void
177 PNGLINKAGEMODE wx_png_error(png_structp png_ptr, png_const_charp message)
178 {
179 wx_png_warning(NULL, message);
180
181 // we're not using libpng built-in jump buffer (see comment before
182 // wxPNGInfoStruct above) so we have to return ourselves, otherwise libpng
183 // would just abort
184 longjmp(WX_PNG_INFO(png_ptr)->jmpbuf, 1);
185 }
186
187 } // extern "C"
188
189 // ----------------------------------------------------------------------------
190 // LoadFile() helpers
191 // ----------------------------------------------------------------------------
192
193 // determine the kind of transparency we need for this image: if the only alpha
194 // values it has are 0 (transparent) and 0xff (opaque) then we can simply
195 // create a mask for it, we should be ok with a simple mask but otherwise we
196 // need a full blown alpha channel in wxImage
197 //
198 // parameters:
199 // lines raw PNG data
200 // x, y starting position
201 // w, h size of the image
202 // numColBytes number of colour bytes (1 for grey scale, 3 for RGB)
203 // (NB: alpha always follows the colour bytes)
204 Transparency
205 CheckTransparency(unsigned char **lines,
206 png_uint_32 x, png_uint_32 y, png_uint_32 w, png_uint_32 h,
207 size_t numColBytes)
208 {
209 // suppose that a mask will suffice and check all the remaining alpha
210 // values to see if it does
211 for ( ; y < h; y++ )
212 {
213 // each pixel is numColBytes+1 bytes, offset into the current line by
214 // the current x position
215 unsigned const char *ptr = lines[y] + (x * (numColBytes + 1));
216
217 for ( png_uint_32 x2 = x; x2 < w; x2++ )
218 {
219 // skip the grey or colour byte(s)
220 ptr += numColBytes;
221
222 unsigned char a2 = *ptr++;
223
224 if ( !IsTransparent(a2) && !IsOpaque(a2) )
225 {
226 // not fully opaque nor fully transparent, hence need alpha
227 return Transparency_Alpha;
228 }
229 }
230
231 // during the next loop iteration check all the pixels in the row
232 x = 0;
233 }
234
235 // mask will be enough
236 return Transparency_Mask;
237 }
238
239 unsigned char *InitAlpha(wxImage *image, png_uint_32 x, png_uint_32 y)
240 {
241 // create alpha channel
242 image->SetAlpha();
243
244 unsigned char *alpha = image->GetAlpha();
245
246 // set alpha for the pixels we had so far
247 png_uint_32 end = y * image->GetWidth() + x;
248 for ( png_uint_32 i = 0; i < end; i++ )
249 {
250 // all the previous pixels were opaque
251 *alpha++ = 0xff;
252 }
253
254 return alpha;
255 }
256
257 void
258 FindMaskColour(unsigned char **lines, png_uint_32 width, png_uint_32 height,
259 unsigned char& rMask, unsigned char& gMask, unsigned char& bMask)
260 {
261 // choosing the colour for the mask is more
262 // difficult: we need to iterate over the entire
263 // image for this in order to choose an unused
264 // colour (this is not very efficient but what else
265 // can we do?)
266 wxImageHistogram h;
267 unsigned nentries = 0;
268 unsigned char r2, g2, b2;
269 for ( png_uint_32 y2 = 0; y2 < height; y2++ )
270 {
271 const unsigned char *p = lines[y2];
272 for ( png_uint_32 x2 = 0; x2 < width; x2++ )
273 {
274 r2 = *p++;
275 g2 = *p++;
276 b2 = *p++;
277 ++p; // jump over alpha
278
279 wxImageHistogramEntry&
280 entry = h[wxImageHistogram:: MakeKey(r2, g2, b2)];
281
282 if ( entry.value++ == 0 )
283 entry.index = nentries++;
284 }
285 }
286
287 if ( !h.FindFirstUnusedColour(&rMask, &gMask, &bMask) )
288 {
289 wxLogWarning(_("Too many colours in PNG, the image may be slightly blurred."));
290
291 // use a fixed mask colour and we'll fudge
292 // the real pixels with this colour (see
293 // below)
294 rMask = 0xfe;
295 gMask = 0;
296 bMask = 0xff;
297 }
298 }
299
300 // ----------------------------------------------------------------------------
301 // reading PNGs
302 // ----------------------------------------------------------------------------
303
304 bool wxPNGHandler::DoCanRead( wxInputStream& stream )
305 {
306 unsigned char hdr[4];
307
308 if ( !stream.Read(hdr, WXSIZEOF(hdr)) ) // it's ok to modify the stream position here
309 return false;
310
311 return memcmp(hdr, "\211PNG", WXSIZEOF(hdr)) == 0;
312 }
313
314 // convert data from RGB to wxImage format
315 static
316 void CopyDataFromPNG(wxImage *image,
317 unsigned char **lines,
318 png_uint_32 width,
319 png_uint_32 height,
320 int color_type)
321 {
322 Transparency transparency = Transparency_None;
323
324 // only non NULL if transparency == Transparency_Alpha
325 unsigned char *alpha = NULL;
326
327 // RGB of the mask colour if transparency == Transparency_Mask
328 // (but init them anyhow to avoid compiler warnings)
329 unsigned char rMask = 0,
330 gMask = 0,
331 bMask = 0;
332
333 unsigned char *ptrDst = image->GetData();
334 if ( !(color_type & PNG_COLOR_MASK_COLOR) )
335 {
336 // grey image: GAGAGA... where G == grey component and A == alpha
337 for ( png_uint_32 y = 0; y < height; y++ )
338 {
339 const unsigned char *ptrSrc = lines[y];
340 for ( png_uint_32 x = 0; x < width; x++ )
341 {
342 unsigned char g = *ptrSrc++;
343 unsigned char a = *ptrSrc++;
344
345 // the first time we encounter a transparent pixel we must
346 // decide about what to do about them
347 if ( !IsOpaque(a) && transparency == Transparency_None )
348 {
349 // we'll need at least the mask for this image and
350 // maybe even full alpha channel info: the former is
351 // only enough if we have alpha values of 0 and 0xff
352 // only, otherwisewe need the latter
353 transparency = CheckTransparency
354 (
355 lines,
356 x, y,
357 width, height,
358 1
359 );
360
361 if ( transparency == Transparency_Mask )
362 {
363 // let's choose this colour for the mask: this is
364 // not a problem here as all the other pixels are
365 // grey, i.e. R == G == B which is not the case for
366 // this one so no confusion is possible
367 rMask = 0xff;
368 gMask = 0;
369 bMask = 0xff;
370 }
371 else // transparency == Transparency_Alpha
372 {
373 alpha = InitAlpha(image, x, y);
374 }
375 }
376
377 switch ( transparency )
378 {
379 case Transparency_Mask:
380 if ( IsTransparent(a) )
381 {
382 *ptrDst++ = rMask;
383 *ptrDst++ = gMask;
384 *ptrDst++ = bMask;
385 break;
386 }
387 // else: !transparent
388
389 // must be opaque then as otherwise we shouldn't be
390 // using the mask at all
391 wxASSERT_MSG( IsOpaque(a), wxT("logic error") );
392
393 // fall through
394
395 case Transparency_Alpha:
396 if ( alpha )
397 *alpha++ = a;
398 // fall through
399
400 case Transparency_None:
401 *ptrDst++ = g;
402 *ptrDst++ = g;
403 *ptrDst++ = g;
404 break;
405 }
406 }
407 }
408 }
409 else // colour image: RGBRGB...
410 {
411 for ( png_uint_32 y = 0; y < height; y++ )
412 {
413 const unsigned char *ptrSrc = lines[y];
414 for ( png_uint_32 x = 0; x < width; x++ )
415 {
416 unsigned char r = *ptrSrc++;
417 unsigned char g = *ptrSrc++;
418 unsigned char b = *ptrSrc++;
419 unsigned char a = *ptrSrc++;
420
421 // the logic here is the same as for the grey case except
422 // where noted
423 if ( !IsOpaque(a) && transparency == Transparency_None )
424 {
425 transparency = CheckTransparency
426 (
427 lines,
428 x, y,
429 width, height,
430 3
431 );
432
433 if ( transparency == Transparency_Mask )
434 {
435 FindMaskColour(lines, width, height,
436 rMask, gMask, bMask);
437 }
438 else // transparency == Transparency_Alpha
439 {
440 alpha = InitAlpha(image, x, y);
441 }
442
443 }
444
445 switch ( transparency )
446 {
447 case Transparency_Mask:
448 if ( IsTransparent(a) )
449 {
450 *ptrDst++ = rMask;
451 *ptrDst++ = gMask;
452 *ptrDst++ = bMask;
453 break;
454 }
455 else // !transparent
456 {
457 // must be opaque then as otherwise we shouldn't be
458 // using the mask at all
459 wxASSERT_MSG( IsOpaque(a), wxT("logic error") );
460
461 // if we couldn't find a unique colour for the
462 // mask, we can have real pixels with the same
463 // value as the mask and it's better to slightly
464 // change their colour than to make them
465 // transparent
466 if ( r == rMask && g == gMask && b == bMask )
467 {
468 r++;
469 }
470 }
471
472 // fall through
473
474 case Transparency_Alpha:
475 if ( alpha )
476 *alpha++ = a;
477 // fall through
478
479 case Transparency_None:
480 *ptrDst++ = r;
481 *ptrDst++ = g;
482 *ptrDst++ = b;
483 break;
484 }
485 }
486 }
487 }
488
489 if ( transparency == Transparency_Mask )
490 {
491 image->SetMaskColour(rMask, gMask, bMask);
492 }
493 }
494
495 // temporarily disable the warning C4611 (interaction between '_setjmp' and
496 // C++ object destruction is non-portable) - I don't see any dtors here
497 #ifdef __VISUALC__
498 #pragma warning(disable:4611)
499 #endif /* VC++ */
500
501 bool
502 wxPNGHandler::LoadFile(wxImage *image,
503 wxInputStream& stream,
504 bool verbose,
505 int WXUNUSED(index))
506 {
507 // VZ: as this function uses setjmp() the only fool-proof error handling
508 // method is to use goto (setjmp is not really C++ dtors friendly...)
509
510 unsigned char **lines = NULL;
511 png_infop info_ptr = (png_infop) NULL;
512 wxPNGInfoStruct wxinfo;
513
514 png_uint_32 i, width, height = 0;
515 int bit_depth, color_type, interlace_type;
516
517 wxinfo.verbose = verbose;
518 wxinfo.stream.in = &stream;
519
520 image->Destroy();
521
522 png_structp png_ptr = png_create_read_struct
523 (
524 PNG_LIBPNG_VER_STRING,
525 NULL,
526 wx_png_error,
527 wx_png_warning
528 );
529 if (!png_ptr)
530 goto error;
531
532 // NB: please see the comment near wxPNGInfoStruct declaration for
533 // explanation why this line is mandatory
534 png_set_read_fn( png_ptr, &wxinfo, wx_PNG_stream_reader);
535
536 info_ptr = png_create_info_struct( png_ptr );
537 if (!info_ptr)
538 goto error;
539
540 if (setjmp(wxinfo.jmpbuf))
541 goto error;
542
543 png_read_info( png_ptr, info_ptr );
544 png_get_IHDR( png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL );
545
546 if (color_type == PNG_COLOR_TYPE_PALETTE)
547 png_set_expand( png_ptr );
548
549 // Fix for Bug [ 439207 ] Monochrome PNG images come up black
550 if (bit_depth < 8)
551 png_set_expand( png_ptr );
552
553 png_set_strip_16( png_ptr );
554 png_set_packing( png_ptr );
555 if (png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS))
556 png_set_expand( png_ptr );
557 png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER );
558
559 image->Create((int)width, (int)height, (bool) false /* no need to init pixels */);
560
561 if (!image->IsOk())
562 goto error;
563
564 // initialize all line pointers to NULL to ensure that they can be safely
565 // free()d if an error occurs before all of them could be allocated
566 lines = (unsigned char **)calloc(height, sizeof(unsigned char *));
567 if ( !lines )
568 goto error;
569
570 for (i = 0; i < height; i++)
571 {
572 if ((lines[i] = (unsigned char *)malloc( (size_t)(width * (sizeof(unsigned char) * 4)))) == NULL)
573 goto error;
574 }
575
576 png_read_image( png_ptr, lines );
577 png_read_end( png_ptr, info_ptr );
578
579 #if wxUSE_PALETTE
580 if (color_type == PNG_COLOR_TYPE_PALETTE)
581 {
582 png_colorp palette = NULL;
583 int numPalette = 0;
584
585 (void) png_get_PLTE(png_ptr, info_ptr, &palette, &numPalette);
586
587 unsigned char* r = new unsigned char[numPalette];
588 unsigned char* g = new unsigned char[numPalette];
589 unsigned char* b = new unsigned char[numPalette];
590
591 for (int j = 0; j < numPalette; j++)
592 {
593 r[j] = palette[j].red;
594 g[j] = palette[j].green;
595 b[j] = palette[j].blue;
596 }
597
598 image->SetPalette(wxPalette(numPalette, r, g, b));
599 delete[] r;
600 delete[] g;
601 delete[] b;
602 }
603 #endif // wxUSE_PALETTE
604
605
606 // set the image resolution if it's available
607 png_uint_32 resX, resY;
608 int unitType;
609 if (png_get_pHYs(png_ptr, info_ptr, &resX, &resY, &unitType)
610 == PNG_INFO_pHYs)
611 {
612 wxImageResolution res = wxIMAGE_RESOLUTION_CM;
613
614 switch (unitType)
615 {
616 default:
617 wxLogWarning(_("Unknown PNG resolution unit %d"), unitType);
618 // fall through
619
620 case PNG_RESOLUTION_UNKNOWN:
621 image->SetOption(wxIMAGE_OPTION_RESOLUTIONX, resX);
622 image->SetOption(wxIMAGE_OPTION_RESOLUTIONY, resY);
623
624 res = wxIMAGE_RESOLUTION_NONE;
625 break;
626
627 case PNG_RESOLUTION_METER:
628 /*
629 Convert meters to centimeters.
630 Use a string to not lose precision (converting to cm and then
631 to inch would result in integer rounding error).
632 If an app wants an int, GetOptionInt will convert and round
633 down for them.
634 */
635 image->SetOption(wxIMAGE_OPTION_RESOLUTIONX,
636 wxString::FromCDouble((double) resX / 100.0, 2));
637 image->SetOption(wxIMAGE_OPTION_RESOLUTIONY,
638 wxString::FromCDouble((double) resY / 100.0, 2));
639 break;
640 }
641
642 image->SetOption(wxIMAGE_OPTION_RESOLUTIONUNIT, res);
643 }
644
645
646 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
647
648 // loaded successfully, now init wxImage with this data
649 CopyDataFromPNG(image, lines, width, height, color_type);
650
651 for ( i = 0; i < height; i++ )
652 free( lines[i] );
653 free( lines );
654
655 return true;
656
657 error:
658 if (verbose)
659 {
660 wxLogError(_("Couldn't load a PNG image - file is corrupted or not enough memory."));
661 }
662
663 if ( image->IsOk() )
664 {
665 image->Destroy();
666 }
667
668 if ( lines )
669 {
670 for ( unsigned int n = 0; n < height; n++ )
671 free( lines[n] );
672
673 free( lines );
674 }
675
676 if ( png_ptr )
677 {
678 if ( info_ptr )
679 {
680 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
681 free(info_ptr);
682 }
683 else
684 png_destroy_read_struct( &png_ptr, (png_infopp) NULL, (png_infopp) NULL );
685 }
686 return false;
687 }
688
689 // ----------------------------------------------------------------------------
690 // SaveFile() palette helpers
691 // ----------------------------------------------------------------------------
692
693 typedef wxLongToLongHashMap PaletteMap;
694
695 static unsigned long PaletteMakeKey(const png_color_8& clr)
696 {
697 return (wxImageHistogram::MakeKey(clr.red, clr.green, clr.blue) << 8) | clr.alpha;
698 }
699
700 static long PaletteFind(const PaletteMap& palette, const png_color_8& clr)
701 {
702 unsigned long value = PaletteMakeKey(clr);
703 PaletteMap::const_iterator it = palette.find(value);
704
705 return (it != palette.end()) ? it->second : wxNOT_FOUND;
706 }
707
708 static long PaletteAdd(PaletteMap *palette, const png_color_8& clr)
709 {
710 unsigned long value = PaletteMakeKey(clr);
711 PaletteMap::const_iterator it = palette->find(value);
712 size_t index;
713
714 if (it == palette->end())
715 {
716 index = palette->size();
717 (*palette)[value] = index;
718 }
719 else
720 {
721 index = it->second;
722 }
723
724 return index;
725 }
726
727 // ----------------------------------------------------------------------------
728 // writing PNGs
729 // ----------------------------------------------------------------------------
730
731 bool wxPNGHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose )
732 {
733 wxPNGInfoStruct wxinfo;
734
735 wxinfo.verbose = verbose;
736 wxinfo.stream.out = &stream;
737
738 png_structp png_ptr = png_create_write_struct
739 (
740 PNG_LIBPNG_VER_STRING,
741 NULL,
742 wx_png_error,
743 wx_png_warning
744 );
745 if (!png_ptr)
746 {
747 if (verbose)
748 {
749 wxLogError(_("Couldn't save PNG image."));
750 }
751 return false;
752 }
753
754 png_infop info_ptr = png_create_info_struct(png_ptr);
755 if (info_ptr == NULL)
756 {
757 png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
758 if (verbose)
759 {
760 wxLogError(_("Couldn't save PNG image."));
761 }
762 return false;
763 }
764
765 if (setjmp(wxinfo.jmpbuf))
766 {
767 png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
768 if (verbose)
769 {
770 wxLogError(_("Couldn't save PNG image."));
771 }
772 return false;
773 }
774
775 // NB: please see the comment near wxPNGInfoStruct declaration for
776 // explanation why this line is mandatory
777 png_set_write_fn( png_ptr, &wxinfo, wx_PNG_stream_writer, NULL);
778
779 const int iHeight = image->GetHeight();
780 const int iWidth = image->GetWidth();
781
782 const bool bHasPngFormatOption
783 = image->HasOption(wxIMAGE_OPTION_PNG_FORMAT);
784
785 int iColorType = bHasPngFormatOption
786 ? image->GetOptionInt(wxIMAGE_OPTION_PNG_FORMAT)
787 : wxPNG_TYPE_COLOUR;
788
789 bool bHasAlpha = image->HasAlpha();
790 bool bHasMask = image->HasMask();
791
792 bool bUsePalette = iColorType == wxPNG_TYPE_PALETTE
793 #if wxUSE_PALETTE
794 || (!bHasPngFormatOption && image->HasPalette() )
795 #endif
796 ;
797
798 png_color_8 mask = { 0, 0, 0, 0, 0 };
799
800 if (bHasMask)
801 {
802 mask.red = image->GetMaskRed();
803 mask.green = image->GetMaskGreen();
804 mask.blue = image->GetMaskBlue();
805 }
806
807 PaletteMap palette;
808
809 if (bUsePalette)
810 {
811 png_color png_rgb [PNG_MAX_PALETTE_LENGTH];
812 png_byte png_trans[PNG_MAX_PALETTE_LENGTH];
813
814 const unsigned char *pColors = image->GetData();
815 const unsigned char* pAlpha = image->GetAlpha();
816
817 if (bHasMask && !pAlpha)
818 {
819 // Mask must be first
820 PaletteAdd(&palette, mask);
821 }
822
823 for (int y = 0; y < iHeight; y++)
824 {
825 for (int x = 0; x < iWidth; x++)
826 {
827 png_color_8 rgba;
828
829 rgba.red = *pColors++;
830 rgba.green = *pColors++;
831 rgba.blue = *pColors++;
832 rgba.gray = 0;
833 rgba.alpha = (pAlpha && !bHasMask) ? *pAlpha++ : 0;
834
835 // save in our palette
836 long index = PaletteAdd(&palette, rgba);
837
838 if (index < PNG_MAX_PALETTE_LENGTH)
839 {
840 // save in libpng's palette
841 png_rgb[index].red = rgba.red;
842 png_rgb[index].green = rgba.green;
843 png_rgb[index].blue = rgba.blue;
844 png_trans[index] = rgba.alpha;
845 }
846 else
847 {
848 bUsePalette = false;
849 break;
850 }
851 }
852 }
853
854 if (bUsePalette)
855 {
856 png_set_PLTE(png_ptr, info_ptr, png_rgb, palette.size());
857
858 if (bHasMask && !pAlpha)
859 {
860 wxASSERT(PaletteFind(palette, mask) == 0);
861 png_trans[0] = 0;
862 png_set_tRNS(png_ptr, info_ptr, png_trans, 1, NULL);
863 }
864 else if (pAlpha && !bHasMask)
865 {
866 png_set_tRNS(png_ptr, info_ptr, png_trans, palette.size(), NULL);
867 }
868 }
869 }
870
871 /*
872 If saving palettised was requested but it was decided we can't use a
873 palette then reset the colour type to RGB.
874 */
875 if (!bUsePalette && iColorType == wxPNG_TYPE_PALETTE)
876 {
877 iColorType = wxPNG_TYPE_COLOUR;
878 }
879
880 bool bUseAlpha = !bUsePalette && (bHasAlpha || bHasMask);
881
882 int iPngColorType;
883
884 if (bUsePalette)
885 {
886 iPngColorType = PNG_COLOR_TYPE_PALETTE;
887 iColorType = wxPNG_TYPE_PALETTE;
888 }
889 else if ( iColorType==wxPNG_TYPE_COLOUR )
890 {
891 iPngColorType = bUseAlpha ? PNG_COLOR_TYPE_RGB_ALPHA
892 : PNG_COLOR_TYPE_RGB;
893 }
894 else
895 {
896 iPngColorType = bUseAlpha ? PNG_COLOR_TYPE_GRAY_ALPHA
897 : PNG_COLOR_TYPE_GRAY;
898 }
899
900 if (image->HasOption(wxIMAGE_OPTION_PNG_FILTER))
901 png_set_filter( png_ptr, PNG_FILTER_TYPE_BASE, image->GetOptionInt(wxIMAGE_OPTION_PNG_FILTER) );
902
903 if (image->HasOption(wxIMAGE_OPTION_PNG_COMPRESSION_LEVEL))
904 png_set_compression_level( png_ptr, image->GetOptionInt(wxIMAGE_OPTION_PNG_COMPRESSION_LEVEL) );
905
906 if (image->HasOption(wxIMAGE_OPTION_PNG_COMPRESSION_MEM_LEVEL))
907 png_set_compression_mem_level( png_ptr, image->GetOptionInt(wxIMAGE_OPTION_PNG_COMPRESSION_MEM_LEVEL) );
908
909 if (image->HasOption(wxIMAGE_OPTION_PNG_COMPRESSION_STRATEGY))
910 png_set_compression_strategy( png_ptr, image->GetOptionInt(wxIMAGE_OPTION_PNG_COMPRESSION_STRATEGY) );
911
912 if (image->HasOption(wxIMAGE_OPTION_PNG_COMPRESSION_BUFFER_SIZE))
913 png_set_compression_buffer_size( png_ptr, image->GetOptionInt(wxIMAGE_OPTION_PNG_COMPRESSION_BUFFER_SIZE) );
914
915 int iBitDepth = !bUsePalette && image->HasOption(wxIMAGE_OPTION_PNG_BITDEPTH)
916 ? image->GetOptionInt(wxIMAGE_OPTION_PNG_BITDEPTH)
917 : 8;
918
919 png_set_IHDR( png_ptr, info_ptr, image->GetWidth(), image->GetHeight(),
920 iBitDepth, iPngColorType,
921 PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,
922 PNG_FILTER_TYPE_BASE);
923
924 int iElements;
925 png_color_8 sig_bit;
926
927 if ( iPngColorType & PNG_COLOR_MASK_COLOR )
928 {
929 sig_bit.red =
930 sig_bit.green =
931 sig_bit.blue = (png_byte)iBitDepth;
932 iElements = 3;
933 }
934 else // grey
935 {
936 sig_bit.gray = (png_byte)iBitDepth;
937 iElements = 1;
938 }
939
940 if ( bUseAlpha )
941 {
942 sig_bit.alpha = (png_byte)iBitDepth;
943 iElements++;
944 }
945
946 if ( iBitDepth == 16 )
947 iElements *= 2;
948
949 // save the image resolution if we have it
950 int resX, resY;
951 switch ( GetResolutionFromOptions(*image, &resX, &resY) )
952 {
953 case wxIMAGE_RESOLUTION_INCHES:
954 {
955 const double INCHES_IN_METER = 10000.0 / 254;
956 resX = int(resX * INCHES_IN_METER);
957 resY = int(resY * INCHES_IN_METER);
958 }
959 break;
960
961 case wxIMAGE_RESOLUTION_CM:
962 resX *= 100;
963 resY *= 100;
964 break;
965
966 case wxIMAGE_RESOLUTION_NONE:
967 break;
968
969 default:
970 wxFAIL_MSG( wxT("unsupported image resolution units") );
971 }
972
973 if ( resX && resY )
974 png_set_pHYs( png_ptr, info_ptr, resX, resY, PNG_RESOLUTION_METER );
975
976 png_set_sBIT( png_ptr, info_ptr, &sig_bit );
977 png_write_info( png_ptr, info_ptr );
978 png_set_shift( png_ptr, &sig_bit );
979 png_set_packing( png_ptr );
980
981 unsigned char *
982 data = (unsigned char *)malloc( image->GetWidth() * iElements );
983 if ( !data )
984 {
985 png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
986 return false;
987 }
988
989 const unsigned char *
990 pAlpha = (const unsigned char *)(bHasAlpha ? image->GetAlpha() : NULL);
991
992 const unsigned char *pColors = image->GetData();
993
994 for (int y = 0; y != iHeight; ++y)
995 {
996 unsigned char *pData = data;
997 for (int x = 0; x != iWidth; x++)
998 {
999 png_color_8 clr;
1000 clr.red = *pColors++;
1001 clr.green = *pColors++;
1002 clr.blue = *pColors++;
1003 clr.gray = 0;
1004 clr.alpha = (bUsePalette && pAlpha) ? *pAlpha++ : 0; // use with wxPNG_TYPE_PALETTE only
1005
1006 switch ( iColorType )
1007 {
1008 default:
1009 wxFAIL_MSG( wxT("unknown wxPNG_TYPE_XXX") );
1010 // fall through
1011
1012 case wxPNG_TYPE_COLOUR:
1013 *pData++ = clr.red;
1014 if ( iBitDepth == 16 )
1015 *pData++ = 0;
1016 *pData++ = clr.green;
1017 if ( iBitDepth == 16 )
1018 *pData++ = 0;
1019 *pData++ = clr.blue;
1020 if ( iBitDepth == 16 )
1021 *pData++ = 0;
1022 break;
1023
1024 case wxPNG_TYPE_GREY:
1025 {
1026 // where do these coefficients come from? maybe we
1027 // should have image options for them as well?
1028 unsigned uiColor =
1029 (unsigned) (76.544*(unsigned)clr.red +
1030 150.272*(unsigned)clr.green +
1031 36.864*(unsigned)clr.blue);
1032
1033 *pData++ = (unsigned char)((uiColor >> 8) & 0xFF);
1034 if ( iBitDepth == 16 )
1035 *pData++ = (unsigned char)(uiColor & 0xFF);
1036 }
1037 break;
1038
1039 case wxPNG_TYPE_GREY_RED:
1040 *pData++ = clr.red;
1041 if ( iBitDepth == 16 )
1042 *pData++ = 0;
1043 break;
1044
1045 case wxPNG_TYPE_PALETTE:
1046 *pData++ = (unsigned char) PaletteFind(palette, clr);
1047 break;
1048 }
1049
1050 if ( bUseAlpha )
1051 {
1052 unsigned char uchAlpha = 255;
1053 if ( bHasAlpha )
1054 uchAlpha = *pAlpha++;
1055
1056 if ( bHasMask )
1057 {
1058 if ( (clr.red == mask.red)
1059 && (clr.green == mask.green)
1060 && (clr.blue == mask.blue) )
1061 uchAlpha = 0;
1062 }
1063
1064 *pData++ = uchAlpha;
1065 if ( iBitDepth == 16 )
1066 *pData++ = 0;
1067 }
1068 }
1069
1070 png_bytep row_ptr = data;
1071 png_write_rows( png_ptr, &row_ptr, 1 );
1072 }
1073
1074 free(data);
1075 png_write_end( png_ptr, info_ptr );
1076 png_destroy_write_struct( &png_ptr, (png_infopp)&info_ptr );
1077
1078 return true;
1079 }
1080
1081 #ifdef __VISUALC__
1082 #pragma warning(default:4611)
1083 #endif /* VC++ */
1084
1085 #endif // wxUSE_STREAMS
1086
1087 /*static*/ wxVersionInfo wxPNGHandler::GetLibraryVersionInfo()
1088 {
1089 // The version string seems to always have a leading space and a trailing
1090 // new line, get rid of them both.
1091 wxString str = png_get_header_version(NULL) + 1;
1092 str.Replace("\n", "");
1093
1094 return wxVersionInfo("libpng",
1095 PNG_LIBPNG_VER_MAJOR,
1096 PNG_LIBPNG_VER_MINOR,
1097 PNG_LIBPNG_VER_RELEASE,
1098 str);
1099 }
1100
1101 #endif // wxUSE_LIBPNG
wxWidgets (Impactor)