]> git.saurik.com Git - wxWidgets.git/blob - src/common/imagpng.cpp
changed version number
[wxWidgets.git] / src / common / imagpng.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: imagepng.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 #ifdef __GNUG__
11 #pragma implementation "imagpng.h"
12 #endif
13
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
16
17 #ifdef __BORLANDC__
18 #pragma hdrstop
19 #endif
20
21 #ifndef WX_PRECOMP
22 #include "wx/defs.h"
23 #endif
24
25 #if wxUSE_IMAGE && wxUSE_LIBPNG
26
27 #include "wx/imagpng.h"
28 #include "wx/bitmap.h"
29 #include "wx/debug.h"
30 #include "wx/log.h"
31 #include "wx/app.h"
32 #include "png.h"
33 #include "wx/filefn.h"
34 #include "wx/wfstream.h"
35 #include "wx/intl.h"
36 #include "wx/module.h"
37
38 // For memcpy
39 #include <string.h>
40
41 #ifdef __SALFORDC__
42 #ifdef FAR
43 #undef FAR
44 #endif
45 #endif
46
47 #ifdef __WXMSW__
48 #include <windows.h>
49 #endif
50
51 //-----------------------------------------------------------------------------
52 // wxPNGHandler
53 //-----------------------------------------------------------------------------
54
55 IMPLEMENT_DYNAMIC_CLASS(wxPNGHandler,wxImageHandler)
56
57 #if wxUSE_LIBPNG
58
59 #if defined(__VISAGECPP__)
60 #define PNGLINKAGEMODE _Optlink
61 #elif defined(__WATCOMC__)
62 #define PNGLINKAGEMODE _cdecl
63 #else
64 #define PNGLINKAGEMODE
65 #endif
66
67 static void PNGLINKAGEMODE _PNG_stream_reader( png_structp png_ptr, png_bytep data, png_size_t length )
68 {
69 ((wxInputStream*) png_get_io_ptr( png_ptr )) -> Read(data, length);
70 }
71
72 static void PNGLINKAGEMODE _PNG_stream_writer( png_structp png_ptr, png_bytep data, png_size_t length )
73 {
74 ((wxOutputStream*) png_get_io_ptr( png_ptr )) -> Write(data, length);
75 }
76
77 // from pngerror.c
78 // so that the libpng doesn't send anything on stderr
79 void
80 PNGLINKAGEMODE png_silent_error(png_structp png_ptr, png_const_charp WXUNUSED(message))
81 {
82 #ifdef USE_FAR_KEYWORD
83 {
84 jmp_buf jmpbuf;
85 png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
86 longjmp(jmpbuf, 1);
87 }
88 #else
89 longjmp(png_ptr->jmpbuf, 1);
90 #endif
91 }
92
93 void
94 PNGLINKAGEMODE png_silent_warning(png_structp WXUNUSED(png_ptr), png_const_charp WXUNUSED(message))
95 {
96 }
97
98 // temporarily disable the warning C4611 (interaction between '_setjmp' and
99 // C++ object destruction is non-portable) - I don't see any dtors here
100 #ifdef __VISUALC__
101 #pragma warning(disable:4611)
102 #endif /* VC++ */
103
104 bool wxPNGHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) )
105 {
106 // VZ: as this function uses setjmp() the only fool proof error handling
107 // method is to use goto (setjmp is not really C++ dtors friendly...)
108
109 unsigned char **lines;
110 unsigned int i;
111 png_infop info_ptr = (png_infop) NULL;
112
113 image->Destroy();
114
115 png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
116 (voidp) NULL,
117 (png_error_ptr) NULL,
118 (png_error_ptr) NULL );
119 if (!png_ptr)
120 goto error_nolines;
121
122 // the file example.c explain how to guess if the stream is a png image
123 if (!verbose) png_set_error_fn(png_ptr, (png_voidp)NULL, png_silent_error, png_silent_warning);
124
125 info_ptr = png_create_info_struct( png_ptr );
126 if (!info_ptr)
127 goto error_nolines;
128
129 if (setjmp(png_ptr->jmpbuf))
130 goto error_nolines;
131
132 if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
133 goto error_nolines;
134
135 png_set_read_fn( png_ptr, &stream, _PNG_stream_reader);
136
137 png_uint_32 width,height;
138 int bit_depth,color_type,interlace_type;
139
140 png_read_info( png_ptr, info_ptr );
141 png_get_IHDR( png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, (int*) NULL, (int*) NULL );
142
143 if (color_type == PNG_COLOR_TYPE_PALETTE)
144 png_set_expand( png_ptr );
145
146 png_set_strip_16( png_ptr );
147 png_set_packing( png_ptr );
148 if (png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS))
149 png_set_expand( png_ptr );
150 png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER );
151
152 image->Create( (int)width, (int)height );
153
154 if (!image->Ok())
155 goto error_nolines;
156
157 lines = (unsigned char **)malloc( (size_t)(height * sizeof(unsigned char *)) );
158 if (lines == NULL)
159 goto error_nolines;
160
161 for (i = 0; i < height; i++)
162 {
163 if ((lines[i] = (unsigned char *)malloc( (size_t)(width * (sizeof(unsigned char) * 4)))) == NULL)
164 {
165 for ( unsigned int n = 0; n < i; n++ )
166 free( lines[n] );
167 goto error;
168 }
169 }
170
171 // loaded successfully!
172 {
173 int transp = 0;
174 png_read_image( png_ptr, lines );
175 png_read_end( png_ptr, info_ptr );
176 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
177 unsigned char *ptr = image->GetData();
178 if ((color_type == PNG_COLOR_TYPE_GRAY) ||
179 (color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
180 {
181 for (unsigned int y = 0; y < height; y++)
182 {
183 unsigned char *ptr2 = lines[y];
184 for (unsigned int x = 0; x < width; x++)
185 {
186 unsigned char r = *ptr2++;
187 unsigned char a = *ptr2++;
188 if (a < 128)
189 {
190 *ptr++ = 255;
191 *ptr++ = 0;
192 *ptr++ = 255;
193 transp = 1;
194 }
195 else
196 {
197 *ptr++ = r;
198 *ptr++ = r;
199 *ptr++ = r;
200 }
201 }
202 }
203 }
204 else
205 {
206 for (unsigned int y = 0; y < height; y++)
207 {
208 unsigned char *ptr2 = lines[y];
209 for (unsigned int x = 0; x < width; x++)
210 {
211 unsigned char r = *ptr2++;
212 unsigned char g = *ptr2++;
213 unsigned char b = *ptr2++;
214 unsigned char a = *ptr2++;
215 if (a < 128)
216 {
217 *ptr++ = 255;
218 *ptr++ = 0;
219 *ptr++ = 255;
220 transp = 1;
221 }
222 else
223 {
224 if ((r == 255) && (g == 0) && (b == 255)) r = 254;
225 *ptr++ = r;
226 *ptr++ = g;
227 *ptr++ = b;
228 }
229 }
230 }
231 }
232
233 for ( unsigned int j = 0; j < height; j++ )
234 free( lines[j] );
235 free( lines );
236
237 if (transp)
238 {
239 image->SetMaskColour( 255, 0, 255 );
240 }
241 else
242 {
243 image->SetMask( FALSE );
244 }
245 }
246
247 return TRUE;
248
249 error_nolines:
250 lines = NULL; // called from before it was set
251 error:
252 if (verbose)
253 wxLogError(_("Couldn't load a PNG image - file is corrupted or not enough memory."));
254
255 if ( image->Ok() )
256 {
257 image->Destroy();
258 }
259
260 if ( lines )
261 {
262 free( lines );
263 }
264
265 if ( png_ptr )
266 {
267 if ( info_ptr )
268 {
269 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
270 free(info_ptr);
271 }
272 else
273 png_destroy_read_struct( &png_ptr, (png_infopp) NULL, (png_infopp) NULL );
274 }
275 return FALSE;
276 }
277
278 bool wxPNGHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose )
279 {
280 {
281 png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
282 if (!png_ptr)
283 {
284 return FALSE;
285 }
286
287 if (!verbose) png_set_error_fn(png_ptr, (png_voidp)NULL, png_silent_error, png_silent_warning);
288
289 png_infop info_ptr = png_create_info_struct(png_ptr);
290 if (info_ptr == NULL)
291 {
292 png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
293 return FALSE;
294 }
295
296 if (setjmp(png_ptr->jmpbuf))
297 {
298 png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
299 return FALSE;
300 }
301
302 png_set_write_fn( png_ptr, &stream, _PNG_stream_writer, NULL);
303
304 png_set_IHDR( png_ptr, info_ptr, image->GetWidth(), image->GetHeight(), 8,
305 PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
306 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
307
308 png_color_8 sig_bit;
309 sig_bit.red = 8;
310 sig_bit.green = 8;
311 sig_bit.blue = 8;
312 sig_bit.alpha = 8;
313 png_set_sBIT( png_ptr, info_ptr, &sig_bit );
314 png_write_info( png_ptr, info_ptr );
315 png_set_shift( png_ptr, &sig_bit );
316 png_set_packing( png_ptr );
317
318 unsigned char *data = (unsigned char *)malloc( image->GetWidth()*4 );
319 if (!data)
320 {
321 png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
322 return FALSE;
323 }
324
325 for (int y = 0; y < image->GetHeight(); y++)
326 {
327 unsigned char *ptr = image->GetData() + (y * image->GetWidth() * 3);
328 for (int x = 0; x < image->GetWidth(); x++)
329 {
330 data[(x << 2) + 0] = *ptr++;
331 data[(x << 2) + 1] = *ptr++;
332 data[(x << 2) + 2] = *ptr++;
333 if (( !image->HasMask() ) || \
334 (data[(x << 2) + 0] != image->GetMaskRed()) || \
335 (data[(x << 2) + 1] != image->GetMaskGreen()) || \
336 (data[(x << 2) + 2] != image->GetMaskBlue()))
337 {
338 data[(x << 2) + 3] = 255;
339 }
340 else
341 {
342 data[(x << 2) + 3] = 0;
343 }
344 }
345 png_bytep row_ptr = data;
346 png_write_rows( png_ptr, &row_ptr, 1 );
347 }
348
349 free(data);
350 png_write_end( png_ptr, info_ptr );
351 png_destroy_write_struct( &png_ptr, (png_infopp)&info_ptr );
352 }
353 return TRUE;
354 }
355
356 #ifdef __VISUALC__
357 #pragma warning(default:4611)
358 #endif /* VC++ */
359
360 bool wxPNGHandler::DoCanRead( wxInputStream& stream )
361 {
362 unsigned char hdr[4];
363
364 stream.Read(hdr, 4);
365 stream.SeekI(-4, wxFromCurrent);
366 return (hdr[0] == 0x89 && hdr[1] == 'P' && hdr[2] == 'N' && hdr[3] == 'G');
367 }
368
369 #endif // wxUSE_STREAMS
370
371 #endif // wxUSE_LIBPNG