1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/imagpng.cpp
3 // Purpose: wxImage PNG handler
4 // Author: Robert Roebling
6 // Copyright: (c) Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // ============================================================================
12 // ============================================================================
14 // ----------------------------------------------------------------------------
16 // ----------------------------------------------------------------------------
18 // For compilers that support precompilation, includes "wx.h".
19 #include "wx/wxprec.h"
25 #if wxUSE_IMAGE && wxUSE_LIBPNG
27 #include "wx/imagpng.h"
28 #include "wx/versioninfo.h"
33 #include "wx/palette.h"
34 #include "wx/stream.h"
42 // ----------------------------------------------------------------------------
44 // ----------------------------------------------------------------------------
46 // image can not 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
57 // ----------------------------------------------------------------------------
59 // ----------------------------------------------------------------------------
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
64 CheckTransparency(unsigned char **lines
,
65 png_uint_32 x
, png_uint_32 y
, png_uint_32 w
, png_uint_32 h
,
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
);
71 // find a free colour for the mask in the PNG data array
73 FindMaskColour(unsigned char **lines
, png_uint_32 width
, png_uint_32 height
,
74 unsigned char& rMask
, unsigned char& gMask
, unsigned char& bMask
);
76 // is the pixel with this value of alpha a fully opaque one?
78 bool IsOpaque(unsigned char a
)
83 // is the pixel with this value of alpha a fully transparent one?
85 bool IsTransparent(unsigned char a
)
90 // ============================================================================
91 // wxPNGHandler implementation
92 // ============================================================================
94 IMPLEMENT_DYNAMIC_CLASS(wxPNGHandler
,wxImageHandler
)
98 #ifndef PNGLINKAGEMODE
100 #define PNGLINKAGEMODE PNGAPI
101 #elif defined(__WATCOMC__)
102 // we need an explicit cdecl for Watcom, at least according to
104 // http://sf.net/tracker/index.php?func=detail&aid=651492&group_id=9863&atid=109863
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
110 #define PNGLINKAGEMODE LINKAGEMODE
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.
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.
131 struct wxPNGInfoStruct
143 #define WX_PNG_INFO(png_ptr) ((wxPNGInfoStruct*)png_get_io_ptr(png_ptr))
145 // ----------------------------------------------------------------------------
147 // ----------------------------------------------------------------------------
152 static void PNGLINKAGEMODE
wx_PNG_stream_reader( png_structp png_ptr
, png_bytep data
,
155 WX_PNG_INFO(png_ptr
)->stream
.in
->Read(data
, length
);
158 static void PNGLINKAGEMODE
wx_PNG_stream_writer( png_structp png_ptr
, png_bytep data
,
161 WX_PNG_INFO(png_ptr
)->stream
.out
->Write(data
, length
);
165 PNGLINKAGEMODE
wx_png_warning(png_structp png_ptr
, png_const_charp message
)
167 wxPNGInfoStruct
*info
= png_ptr
? WX_PNG_INFO(png_ptr
) : NULL
;
168 if ( !info
|| info
->verbose
)
170 wxLogWarning( wxString::FromAscii(message
) );
175 // so that the libpng doesn't send anything on stderr
177 PNGLINKAGEMODE
wx_png_error(png_structp png_ptr
, png_const_charp message
)
179 wx_png_warning(NULL
, message
);
181 // we're not using libpng built-in jump buffer (see comment before
182 // wxPNGInfoStruct above) so we have to return ourselves, otherwise libpng
184 longjmp(WX_PNG_INFO(png_ptr
)->jmpbuf
, 1);
189 // ----------------------------------------------------------------------------
190 // LoadFile() helpers
191 // ----------------------------------------------------------------------------
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
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)
205 CheckTransparency(unsigned char **lines
,
206 png_uint_32 x
, png_uint_32 y
, png_uint_32 w
, png_uint_32 h
,
209 // suppose that a mask will suffice and check all the remaining alpha
210 // values to see if it does
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));
217 for ( png_uint_32 x2
= x
; x2
< w
; x2
++ )
219 // skip the grey or colour byte(s)
222 unsigned char a2
= *ptr
++;
224 if ( !IsTransparent(a2
) && !IsOpaque(a2
) )
226 // not fully opaque nor fully transparent, hence need alpha
227 return Transparency_Alpha
;
231 // during the next loop iteration check all the pixels in the row
235 // mask will be enough
236 return Transparency_Mask
;
239 unsigned char *InitAlpha(wxImage
*image
, png_uint_32 x
, png_uint_32 y
)
241 // create alpha channel
244 unsigned char *alpha
= image
->GetAlpha();
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
++ )
250 // all the previous pixels were opaque
258 FindMaskColour(unsigned char **lines
, png_uint_32 width
, png_uint_32 height
,
259 unsigned char& rMask
, unsigned char& gMask
, unsigned char& bMask
)
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
267 unsigned nentries
= 0;
268 unsigned char r2
, g2
, b2
;
269 for ( png_uint_32 y2
= 0; y2
< height
; y2
++ )
271 const unsigned char *p
= lines
[y2
];
272 for ( png_uint_32 x2
= 0; x2
< width
; x2
++ )
277 ++p
; // jump over alpha
279 wxImageHistogramEntry
&
280 entry
= h
[wxImageHistogram:: MakeKey(r2
, g2
, b2
)];
282 if ( entry
.value
++ == 0 )
283 entry
.index
= nentries
++;
287 if ( !h
.FindFirstUnusedColour(&rMask
, &gMask
, &bMask
) )
289 wxLogWarning(_("Too many colours in PNG, the image may be slightly blurred."));
291 // use a fixed mask colour and we'll fudge
292 // the real pixels with this colour (see
300 // ----------------------------------------------------------------------------
302 // ----------------------------------------------------------------------------
304 bool wxPNGHandler::DoCanRead( wxInputStream
& stream
)
306 unsigned char hdr
[4];
308 if ( !stream
.Read(hdr
, WXSIZEOF(hdr
)) ) // it's ok to modify the stream position here
311 return memcmp(hdr
, "\211PNG", WXSIZEOF(hdr
)) == 0;
314 // convert data from RGB to wxImage format
316 void CopyDataFromPNG(wxImage
*image
,
317 unsigned char **lines
,
322 Transparency transparency
= Transparency_None
;
324 // only non NULL if transparency == Transparency_Alpha
325 unsigned char *alpha
= NULL
;
327 // RGB of the mask colour if transparency == Transparency_Mask
328 // (but init them anyhow to avoid compiler warnings)
329 unsigned char rMask
= 0,
333 unsigned char *ptrDst
= image
->GetData();
334 if ( !(color_type
& PNG_COLOR_MASK_COLOR
) )
336 // grey image: GAGAGA... where G == grey component and A == alpha
337 for ( png_uint_32 y
= 0; y
< height
; y
++ )
339 const unsigned char *ptrSrc
= lines
[y
];
340 for ( png_uint_32 x
= 0; x
< width
; x
++ )
342 unsigned char g
= *ptrSrc
++;
343 unsigned char a
= *ptrSrc
++;
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
)
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
361 if ( transparency
== Transparency_Mask
)
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
371 else // transparency == Transparency_Alpha
373 alpha
= InitAlpha(image
, x
, y
);
377 switch ( transparency
)
379 case Transparency_Mask
:
380 if ( IsTransparent(a
) )
387 // else: !transparent
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") );
395 case Transparency_Alpha
:
400 case Transparency_None
:
409 else // colour image: RGBRGB...
411 for ( png_uint_32 y
= 0; y
< height
; y
++ )
413 const unsigned char *ptrSrc
= lines
[y
];
414 for ( png_uint_32 x
= 0; x
< width
; x
++ )
416 unsigned char r
= *ptrSrc
++;
417 unsigned char g
= *ptrSrc
++;
418 unsigned char b
= *ptrSrc
++;
419 unsigned char a
= *ptrSrc
++;
421 // the logic here is the same as for the grey case except
423 if ( !IsOpaque(a
) && transparency
== Transparency_None
)
425 transparency
= CheckTransparency
433 if ( transparency
== Transparency_Mask
)
435 FindMaskColour(lines
, width
, height
,
436 rMask
, gMask
, bMask
);
438 else // transparency == Transparency_Alpha
440 alpha
= InitAlpha(image
, x
, y
);
445 switch ( transparency
)
447 case Transparency_Mask
:
448 if ( IsTransparent(a
) )
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") );
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
466 if ( r
== rMask
&& g
== gMask
&& b
== bMask
)
474 case Transparency_Alpha
:
479 case Transparency_None
:
489 if ( transparency
== Transparency_Mask
)
491 image
->SetMaskColour(rMask
, gMask
, bMask
);
495 // temporarily disable the warning C4611 (interaction between '_setjmp' and
496 // C++ object destruction is non-portable) - I don't see any dtors here
498 #pragma warning(disable:4611)
502 wxPNGHandler::LoadFile(wxImage
*image
,
503 wxInputStream
& stream
,
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...)
510 unsigned char **lines
= NULL
;
511 png_infop info_ptr
= (png_infop
) NULL
;
512 wxPNGInfoStruct wxinfo
;
514 png_uint_32 i
, width
, height
= 0;
515 int bit_depth
, color_type
, interlace_type
;
517 wxinfo
.verbose
= verbose
;
518 wxinfo
.stream
.in
= &stream
;
522 png_structp png_ptr
= png_create_read_struct
524 PNG_LIBPNG_VER_STRING
,
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
);
536 info_ptr
= png_create_info_struct( png_ptr
);
540 if (setjmp(wxinfo
.jmpbuf
))
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
);
546 if (color_type
== PNG_COLOR_TYPE_PALETTE
)
547 png_set_expand( png_ptr
);
549 // Fix for Bug [ 439207 ] Monochrome PNG images come up black
551 png_set_expand( png_ptr
);
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
);
559 image
->Create((int)width
, (int)height
, (bool) false /* no need to init pixels */);
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 *));
570 for (i
= 0; i
< height
; i
++)
572 if ((lines
[i
] = (unsigned char *)malloc( (size_t)(width
* (sizeof(unsigned char) * 4)))) == NULL
)
576 png_read_image( png_ptr
, lines
);
577 png_read_end( png_ptr
, info_ptr
);
580 if (color_type
== PNG_COLOR_TYPE_PALETTE
)
582 png_colorp palette
= NULL
;
585 (void) png_get_PLTE(png_ptr
, info_ptr
, &palette
, &numPalette
);
587 unsigned char* r
= new unsigned char[numPalette
];
588 unsigned char* g
= new unsigned char[numPalette
];
589 unsigned char* b
= new unsigned char[numPalette
];
591 for (int j
= 0; j
< numPalette
; j
++)
593 r
[j
] = palette
[j
].red
;
594 g
[j
] = palette
[j
].green
;
595 b
[j
] = palette
[j
].blue
;
598 image
->SetPalette(wxPalette(numPalette
, r
, g
, b
));
603 #endif // wxUSE_PALETTE
605 png_destroy_read_struct( &png_ptr
, &info_ptr
, (png_infopp
) NULL
);
607 // loaded successfully, now init wxImage with this data
608 CopyDataFromPNG(image
, lines
, width
, height
, color_type
);
610 for ( i
= 0; i
< height
; i
++ )
619 wxLogError(_("Couldn't load a PNG image - file is corrupted or not enough memory."));
629 for ( unsigned int n
= 0; n
< height
; n
++ )
639 png_destroy_read_struct( &png_ptr
, &info_ptr
, (png_infopp
) NULL
);
643 png_destroy_read_struct( &png_ptr
, (png_infopp
) NULL
, (png_infopp
) NULL
);
648 // ----------------------------------------------------------------------------
649 // SaveFile() helpers
650 // ----------------------------------------------------------------------------
654 static int PaletteFind(const png_color
& clr
, const png_color
*pal
, int palCount
)
656 for (int i
= 0; i
< palCount
; ++i
)
658 if ( (clr
.red
== pal
[i
].red
)
659 && (clr
.green
== pal
[i
].green
)
660 && (clr
.blue
== pal
[i
].blue
))
669 #endif // wxUSE_PALETTE
671 // ----------------------------------------------------------------------------
673 // ----------------------------------------------------------------------------
675 bool wxPNGHandler::SaveFile( wxImage
*image
, wxOutputStream
& stream
, bool verbose
)
677 wxPNGInfoStruct wxinfo
;
679 wxinfo
.verbose
= verbose
;
680 wxinfo
.stream
.out
= &stream
;
682 png_structp png_ptr
= png_create_write_struct
684 PNG_LIBPNG_VER_STRING
,
693 wxLogError(_("Couldn't save PNG image."));
698 png_infop info_ptr
= png_create_info_struct(png_ptr
);
699 if (info_ptr
== NULL
)
701 png_destroy_write_struct( &png_ptr
, (png_infopp
)NULL
);
704 wxLogError(_("Couldn't save PNG image."));
709 if (setjmp(wxinfo
.jmpbuf
))
711 png_destroy_write_struct( &png_ptr
, (png_infopp
)NULL
);
714 wxLogError(_("Couldn't save PNG image."));
719 // NB: please see the comment near wxPNGInfoStruct declaration for
720 // explanation why this line is mandatory
721 png_set_write_fn( png_ptr
, &wxinfo
, wx_PNG_stream_writer
, NULL
);
723 const bool bHasPngFormatOption
724 = image
->HasOption(wxIMAGE_OPTION_PNG_FORMAT
);
726 int iColorType
= bHasPngFormatOption
727 ? image
->GetOptionInt(wxIMAGE_OPTION_PNG_FORMAT
)
730 bool bHasAlpha
= image
->HasAlpha();
731 bool bHasMask
= image
->HasMask();
735 Only save as an indexed image if the number of palette entries does not
736 exceed libpng's limit (256).
737 We assume here that we will need an extra palette entry if there's an
738 alpha or mask, regardless of whether a possibly needed conversion from
739 alpha to a mask fails (unlikely), or whether the mask colour already
740 can be found in the palette (more likely). In the latter case an extra
741 palette entry would not be required later on and the image could actually
742 be saved as a palettised PNG (instead now it will be saved as true colour).
743 A little bit of precision is lost, but at the benefit of a lot more
747 (!bHasPngFormatOption
|| iColorType
== wxPNG_TYPE_PALETTE
)
748 && image
->HasPalette()
749 && image
->GetPalette().GetColoursCount()
750 + ((bHasAlpha
|| bHasMask
) ? 1 : 0) <= PNG_MAX_PALETTE_LENGTH
;
752 wxImage
temp_image(*image
);
753 if (bUsePalette
&& image
->HasAlpha() && !bHasMask
)
756 Only convert alpha to mask if saving as a palettised image was
757 explicitly requested. We don't want to lose alpha's precision
758 by converting to a mask just to be able to save palettised.
760 if (iColorType
== wxPNG_TYPE_PALETTE
761 && temp_image
.ConvertAlphaToMask())
765 bHasAlpha
= image
->HasAlpha();
770 iColorType
= wxPNG_TYPE_COLOUR
;
774 bool bUsePalette
= false;
775 #endif // wxUSE_PALETTE
778 If saving palettised was requested but it was decided we can't use a
779 palette then reset the colour type to RGB.
781 if (!bUsePalette
&& iColorType
== wxPNG_TYPE_PALETTE
)
783 iColorType
= wxPNG_TYPE_COLOUR
;
786 bool bUseAlpha
= !bUsePalette
&& (bHasAlpha
|| bHasMask
);
791 mask
.red
= image
->GetMaskRed();
792 mask
.green
= image
->GetMaskGreen();
793 mask
.blue
= image
->GetMaskBlue();
802 iPngColorType
= PNG_COLOR_TYPE_PALETTE
;
803 iColorType
= wxPNG_TYPE_PALETTE
;
806 #endif // wxUSE_PALETTE
807 if ( iColorType
==wxPNG_TYPE_COLOUR
)
809 iPngColorType
= bUseAlpha
? PNG_COLOR_TYPE_RGB_ALPHA
810 : PNG_COLOR_TYPE_RGB
;
814 iPngColorType
= bUseAlpha
? PNG_COLOR_TYPE_GRAY_ALPHA
815 : PNG_COLOR_TYPE_GRAY
;
818 if (image
->HasOption(wxIMAGE_OPTION_PNG_FILTER
))
819 png_set_filter( png_ptr
, PNG_FILTER_TYPE_BASE
, image
->GetOptionInt(wxIMAGE_OPTION_PNG_FILTER
) );
821 if (image
->HasOption(wxIMAGE_OPTION_PNG_COMPRESSION_LEVEL
))
822 png_set_compression_level( png_ptr
, image
->GetOptionInt(wxIMAGE_OPTION_PNG_COMPRESSION_LEVEL
) );
824 if (image
->HasOption(wxIMAGE_OPTION_PNG_COMPRESSION_MEM_LEVEL
))
825 png_set_compression_mem_level( png_ptr
, image
->GetOptionInt(wxIMAGE_OPTION_PNG_COMPRESSION_MEM_LEVEL
) );
827 if (image
->HasOption(wxIMAGE_OPTION_PNG_COMPRESSION_STRATEGY
))
828 png_set_compression_strategy( png_ptr
, image
->GetOptionInt(wxIMAGE_OPTION_PNG_COMPRESSION_STRATEGY
) );
830 if (image
->HasOption(wxIMAGE_OPTION_PNG_COMPRESSION_BUFFER_SIZE
))
831 png_set_compression_buffer_size( png_ptr
, image
->GetOptionInt(wxIMAGE_OPTION_PNG_COMPRESSION_BUFFER_SIZE
) );
833 int iBitDepth
= !bUsePalette
&& image
->HasOption(wxIMAGE_OPTION_PNG_BITDEPTH
)
834 ? image
->GetOptionInt(wxIMAGE_OPTION_PNG_BITDEPTH
)
837 png_set_IHDR( png_ptr
, info_ptr
, image
->GetWidth(), image
->GetHeight(),
838 iBitDepth
, iPngColorType
,
839 PNG_INTERLACE_NONE
, PNG_COMPRESSION_TYPE_BASE
,
840 PNG_FILTER_TYPE_BASE
);
843 png_colorp palette
= NULL
;
848 const wxPalette
& pal
= image
->GetPalette();
849 const int palCount
= pal
.GetColoursCount();
850 palette
= (png_colorp
) malloc(
851 (palCount
+ 1 /*headroom for trans */) * sizeof(png_color
));
855 png_destroy_write_struct( &png_ptr
, (png_infopp
)NULL
);
858 wxLogError(_("Couldn't save PNG image."));
863 for (int i
= 0; i
< palCount
; ++i
)
865 pal
.GetRGB(i
, &palette
[i
].red
, &palette
[i
].green
, &palette
[i
].blue
);
868 numPalette
= palCount
;
871 int index
= PaletteFind(mask
, palette
, numPalette
);
875 if (index
== wxNOT_FOUND
)
879 palette
[index
] = mask
;
882 wxSwap(palette
[0], palette
[index
]);
886 png_set_tRNS(png_ptr
, info_ptr
, &trans
, 1, NULL
);
889 png_set_PLTE(png_ptr
, info_ptr
, palette
, numPalette
);
893 // Let palette point to libpng's copy of the palette.
894 (void) png_get_PLTE(png_ptr
, info_ptr
, &palette
, &numPalette
);
896 #endif // wxUSE_PALETTE
901 if ( iPngColorType
& PNG_COLOR_MASK_COLOR
)
905 sig_bit
.blue
= (png_byte
)iBitDepth
;
910 sig_bit
.gray
= (png_byte
)iBitDepth
;
914 if ( iPngColorType
& PNG_COLOR_MASK_ALPHA
)
916 sig_bit
.alpha
= (png_byte
)iBitDepth
;
920 if ( iBitDepth
== 16 )
923 // save the image resolution if we have it
925 switch ( GetResolutionFromOptions(*image
, &resX
, &resY
) )
927 case wxIMAGE_RESOLUTION_INCHES
:
929 const double INCHES_IN_METER
= 10000.0 / 254;
930 resX
= int(resX
* INCHES_IN_METER
);
931 resY
= int(resY
* INCHES_IN_METER
);
935 case wxIMAGE_RESOLUTION_CM
:
940 case wxIMAGE_RESOLUTION_NONE
:
944 wxFAIL_MSG( wxT("unsupported image resolution units") );
948 png_set_pHYs( png_ptr
, info_ptr
, resX
, resY
, PNG_RESOLUTION_METER
);
950 png_set_sBIT( png_ptr
, info_ptr
, &sig_bit
);
951 png_write_info( png_ptr
, info_ptr
);
952 png_set_shift( png_ptr
, &sig_bit
);
953 png_set_packing( png_ptr
);
956 data
= (unsigned char *)malloc( image
->GetWidth() * iElements
);
959 png_destroy_write_struct( &png_ptr
, (png_infopp
)NULL
);
964 pAlpha
= (unsigned char *)(bHasAlpha
? image
->GetAlpha() : NULL
);
965 int iHeight
= image
->GetHeight();
966 int iWidth
= image
->GetWidth();
968 unsigned char *pColors
= image
->GetData();
970 for (int y
= 0; y
!= iHeight
; ++y
)
972 unsigned char *pData
= data
;
973 for (int x
= 0; x
!= iWidth
; x
++)
976 clr
.red
= *pColors
++;
977 clr
.green
= *pColors
++;
978 clr
.blue
= *pColors
++;
980 switch ( iColorType
)
983 wxFAIL_MSG( wxT("unknown wxPNG_TYPE_XXX") );
986 case wxPNG_TYPE_COLOUR
:
988 if ( iBitDepth
== 16 )
990 *pData
++ = clr
.green
;
991 if ( iBitDepth
== 16 )
994 if ( iBitDepth
== 16 )
998 case wxPNG_TYPE_GREY
:
1000 // where do these coefficients come from? maybe we
1001 // should have image options for them as well?
1003 (unsigned) (76.544*(unsigned)clr
.red
+
1004 150.272*(unsigned)clr
.green
+
1005 36.864*(unsigned)clr
.blue
);
1007 *pData
++ = (unsigned char)((uiColor
>> 8) & 0xFF);
1008 if ( iBitDepth
== 16 )
1009 *pData
++ = (unsigned char)(uiColor
& 0xFF);
1013 case wxPNG_TYPE_GREY_RED
:
1015 if ( iBitDepth
== 16 )
1020 case wxPNG_TYPE_PALETTE
:
1021 *pData
++ = (unsigned char) PaletteFind(clr
,
1022 palette
, numPalette
);
1024 #endif // wxUSE_PALETTE
1029 unsigned char uchAlpha
= 255;
1031 uchAlpha
= *pAlpha
++;
1035 if ( (clr
.red
== mask
.red
)
1036 && (clr
.green
== mask
.green
)
1037 && (clr
.blue
== mask
.blue
) )
1041 *pData
++ = uchAlpha
;
1042 if ( iBitDepth
== 16 )
1047 png_bytep row_ptr
= data
;
1048 png_write_rows( png_ptr
, &row_ptr
, 1 );
1052 png_write_end( png_ptr
, info_ptr
);
1053 png_destroy_write_struct( &png_ptr
, (png_infopp
)&info_ptr
);
1059 #pragma warning(default:4611)
1062 #endif // wxUSE_STREAMS
1064 /*static*/ wxVersionInfo
wxPNGHandler::GetLibraryVersionInfo()
1066 // The version string seems to always have a leading space and a trailing
1067 // new line, get rid of them both.
1068 wxString str
= png_get_header_version(NULL
) + 1;
1069 str
.Replace("\n", "");
1071 return wxVersionInfo("libpng",
1072 PNG_LIBPNG_VER_MAJOR
,
1073 PNG_LIBPNG_VER_MINOR
,
1074 PNG_LIBPNG_VER_RELEASE
,
1078 #endif // wxUSE_LIBPNG