1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15 // Third party copyrights are property of their respective owners.
16 //
17 // Redistribution and use in source and binary forms, with or without modification,
18 // are permitted provided that the following conditions are met:
19 //
20 // * Redistribution's of source code must retain the above copyright notice,
21 // this list of conditions and the following disclaimer.
22 //
23 // * Redistribution's in binary form must reproduce the above copyright notice,
24 // this list of conditions and the following disclaimer in the documentation
25 // and/or other materials provided with the distribution.
26 //
27 // * The name of the copyright holders may not be used to endorse or promote products
28 // derived from this software without specific prior written permission.
29 //
30 // This software is provided by the copyright holders and contributors "as is" and
31 // any express or implied warranties, including, but not limited to, the implied
32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
33 // In no event shall the Intel Corporation or contributors be liable for any direct,
34 // indirect, incidental, special, exemplary, or consequential damages
35 // (including, but not limited to, procurement of substitute goods or services;
36 // loss of use, data, or profits; or business interruption) however caused
37 // and on any theory of liability, whether in contract, strict liability,
38 // or tort (including negligence or otherwise) arising in any way out of
39 // the use of this software, even if advised of the possibility of such damage.
40 //
41 //M*/
42
43 #include "precomp.hpp"
44
45 #ifdef HAVE_PNG
46
47 /****************************************************************************************\
48 This part of the file implements PNG codec on base of libpng library,
49 in particular, this code is based on example.c from libpng
50 (see otherlibs/_graphics/readme.txt for copyright notice)
51 and png2bmp sample from libpng distribution (Copyright (C) 1999-2001 MIYASAKA Masaru)
52 \****************************************************************************************/
53
54 #ifndef _LFS64_LARGEFILE
55 # define _LFS64_LARGEFILE 0
56 #endif
57 #ifndef _FILE_OFFSET_BITS
58 # define _FILE_OFFSET_BITS 0
59 #endif
60
61 #ifdef HAVE_LIBPNG_PNG_H
62 #include <libpng/png.h>
63 #else
64 #include <png.h>
65 #endif
66 #include <zlib.h>
67
68 #include "grfmt_png.hpp"
69
70 #if defined _MSC_VER && _MSC_VER >= 1200
71 // interaction between '_setjmp' and C++ object destruction is non-portable
72 #pragma warning( disable: 4611 )
73 #endif
74
75 // the following defines are a hack to avoid multiple problems with frame ponter handling and setjmp
76 // see http://gcc.gnu.org/ml/gcc/2011-10/msg00324.html for some details
77 #define mingw_getsp(...) 0
78 #define __builtin_frame_address(...) 0
79
80 namespace cv
81 {
82
83 /////////////////////// PngDecoder ///////////////////
84
PngDecoder()85 PngDecoder::PngDecoder()
86 {
87 m_signature = "\x89\x50\x4e\x47\xd\xa\x1a\xa";
88 m_color_type = 0;
89 m_png_ptr = 0;
90 m_info_ptr = m_end_info = 0;
91 m_f = 0;
92 m_buf_supported = true;
93 m_buf_pos = 0;
94 }
95
96
~PngDecoder()97 PngDecoder::~PngDecoder()
98 {
99 close();
100 }
101
newDecoder() const102 ImageDecoder PngDecoder::newDecoder() const
103 {
104 return makePtr<PngDecoder>();
105 }
106
close()107 void PngDecoder::close()
108 {
109 if( m_f )
110 {
111 fclose( m_f );
112 m_f = 0;
113 }
114
115 if( m_png_ptr )
116 {
117 png_structp png_ptr = (png_structp)m_png_ptr;
118 png_infop info_ptr = (png_infop)m_info_ptr;
119 png_infop end_info = (png_infop)m_end_info;
120 png_destroy_read_struct( &png_ptr, &info_ptr, &end_info );
121 m_png_ptr = m_info_ptr = m_end_info = 0;
122 }
123 }
124
125
readDataFromBuf(void * _png_ptr,uchar * dst,size_t size)126 void PngDecoder::readDataFromBuf( void* _png_ptr, uchar* dst, size_t size )
127 {
128 png_structp png_ptr = (png_structp)_png_ptr;
129 PngDecoder* decoder = (PngDecoder*)(png_get_io_ptr(png_ptr));
130 CV_Assert( decoder );
131 const Mat& buf = decoder->m_buf;
132 if( decoder->m_buf_pos + size > buf.cols*buf.rows*buf.elemSize() )
133 {
134 png_error(png_ptr, "PNG input buffer is incomplete");
135 return;
136 }
137 memcpy( dst, decoder->m_buf.ptr() + decoder->m_buf_pos, size );
138 decoder->m_buf_pos += size;
139 }
140
readHeader()141 bool PngDecoder::readHeader()
142 {
143 bool result = false;
144 close();
145
146 png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 );
147
148 if( png_ptr )
149 {
150 png_infop info_ptr = png_create_info_struct( png_ptr );
151 png_infop end_info = png_create_info_struct( png_ptr );
152
153 m_png_ptr = png_ptr;
154 m_info_ptr = info_ptr;
155 m_end_info = end_info;
156 m_buf_pos = 0;
157
158 if( info_ptr && end_info )
159 {
160 if( setjmp( png_jmpbuf( png_ptr ) ) == 0 )
161 {
162 if( !m_buf.empty() )
163 png_set_read_fn(png_ptr, this, (png_rw_ptr)readDataFromBuf );
164 else
165 {
166 m_f = fopen( m_filename.c_str(), "rb" );
167 if( m_f )
168 png_init_io( png_ptr, m_f );
169 }
170
171 if( !m_buf.empty() || m_f )
172 {
173 png_uint_32 wdth, hght;
174 int bit_depth, color_type, num_trans=0;
175 png_bytep trans;
176 png_color_16p trans_values;
177
178 png_read_info( png_ptr, info_ptr );
179
180 png_get_IHDR( png_ptr, info_ptr, &wdth, &hght,
181 &bit_depth, &color_type, 0, 0, 0 );
182
183 m_width = (int)wdth;
184 m_height = (int)hght;
185 m_color_type = color_type;
186 m_bit_depth = bit_depth;
187
188 if( bit_depth <= 8 || bit_depth == 16 )
189 {
190 switch(color_type)
191 {
192 case PNG_COLOR_TYPE_RGB:
193 m_type = CV_8UC3;
194 break;
195 case PNG_COLOR_TYPE_PALETTE:
196 png_get_tRNS( png_ptr, info_ptr, &trans, &num_trans, &trans_values);
197 //Check if there is a transparency value in the palette
198 if ( num_trans > 0 )
199 m_type = CV_8UC4;
200 else
201 m_type = CV_8UC3;
202 break;
203 case PNG_COLOR_TYPE_RGB_ALPHA:
204 m_type = CV_8UC4;
205 break;
206 default:
207 m_type = CV_8UC1;
208 }
209 if( bit_depth == 16 )
210 m_type = CV_MAKETYPE(CV_16U, CV_MAT_CN(m_type));
211 result = true;
212 }
213 }
214 }
215 }
216 }
217
218 if( !result )
219 close();
220
221 return result;
222 }
223
224
readData(Mat & img)225 bool PngDecoder::readData( Mat& img )
226 {
227 bool result = false;
228 AutoBuffer<uchar*> _buffer(m_height);
229 uchar** buffer = _buffer;
230 int color = img.channels() > 1;
231 uchar* data = img.ptr();
232 int step = (int)img.step;
233
234 if( m_png_ptr && m_info_ptr && m_end_info && m_width && m_height )
235 {
236 png_structp png_ptr = (png_structp)m_png_ptr;
237 png_infop info_ptr = (png_infop)m_info_ptr;
238 png_infop end_info = (png_infop)m_end_info;
239
240 if( setjmp( png_jmpbuf ( png_ptr ) ) == 0 )
241 {
242 int y;
243
244 if( img.depth() == CV_8U && m_bit_depth == 16 )
245 png_set_strip_16( png_ptr );
246 else if( !isBigEndian() )
247 png_set_swap( png_ptr );
248
249 if(img.channels() < 4)
250 {
251 /* observation: png_read_image() writes 400 bytes beyond
252 * end of data when reading a 400x118 color png
253 * "mpplus_sand.png". OpenCV crashes even with demo
254 * programs. Looking at the loaded image I'd say we get 4
255 * bytes per pixel instead of 3 bytes per pixel. Test
256 * indicate that it is a good idea to always ask for
257 * stripping alpha.. 18.11.2004 Axel Walthelm
258 */
259 png_set_strip_alpha( png_ptr );
260 }
261
262 if( m_color_type == PNG_COLOR_TYPE_PALETTE )
263 png_set_palette_to_rgb( png_ptr );
264
265 if( m_color_type == PNG_COLOR_TYPE_GRAY && m_bit_depth < 8 )
266 #if (PNG_LIBPNG_VER_MAJOR*10000 + PNG_LIBPNG_VER_MINOR*100 + PNG_LIBPNG_VER_RELEASE >= 10209) || \
267 (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR == 0 && PNG_LIBPNG_VER_RELEASE >= 18)
268 png_set_expand_gray_1_2_4_to_8( png_ptr );
269 #else
270 png_set_gray_1_2_4_to_8( png_ptr );
271 #endif
272
273 if( CV_MAT_CN(m_type) > 1 && color )
274 png_set_bgr( png_ptr ); // convert RGB to BGR
275 else if( color )
276 png_set_gray_to_rgb( png_ptr ); // Gray->RGB
277 else
278 png_set_rgb_to_gray( png_ptr, 1, 0.299, 0.587 ); // RGB->Gray
279
280 png_set_interlace_handling( png_ptr );
281 png_read_update_info( png_ptr, info_ptr );
282
283 for( y = 0; y < m_height; y++ )
284 buffer[y] = data + y*step;
285
286 png_read_image( png_ptr, buffer );
287 png_read_end( png_ptr, end_info );
288
289 result = true;
290 }
291 }
292
293 close();
294 return result;
295 }
296
297
298 /////////////////////// PngEncoder ///////////////////
299
300
PngEncoder()301 PngEncoder::PngEncoder()
302 {
303 m_description = "Portable Network Graphics files (*.png)";
304 m_buf_supported = true;
305 }
306
307
~PngEncoder()308 PngEncoder::~PngEncoder()
309 {
310 }
311
312
isFormatSupported(int depth) const313 bool PngEncoder::isFormatSupported( int depth ) const
314 {
315 return depth == CV_8U || depth == CV_16U;
316 }
317
newEncoder() const318 ImageEncoder PngEncoder::newEncoder() const
319 {
320 return makePtr<PngEncoder>();
321 }
322
323
writeDataToBuf(void * _png_ptr,uchar * src,size_t size)324 void PngEncoder::writeDataToBuf(void* _png_ptr, uchar* src, size_t size)
325 {
326 if( size == 0 )
327 return;
328 png_structp png_ptr = (png_structp)_png_ptr;
329 PngEncoder* encoder = (PngEncoder*)(png_get_io_ptr(png_ptr));
330 CV_Assert( encoder && encoder->m_buf );
331 size_t cursz = encoder->m_buf->size();
332 encoder->m_buf->resize(cursz + size);
333 memcpy( &(*encoder->m_buf)[cursz], src, size );
334 }
335
336
flushBuf(void *)337 void PngEncoder::flushBuf(void*)
338 {
339 }
340
write(const Mat & img,const std::vector<int> & params)341 bool PngEncoder::write( const Mat& img, const std::vector<int>& params )
342 {
343 png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 );
344 png_infop info_ptr = 0;
345 FILE* f = 0;
346 int y, width = img.cols, height = img.rows;
347 int depth = img.depth(), channels = img.channels();
348 bool result = false;
349 AutoBuffer<uchar*> buffer;
350
351 if( depth != CV_8U && depth != CV_16U )
352 return false;
353
354 if( png_ptr )
355 {
356 info_ptr = png_create_info_struct( png_ptr );
357
358 if( info_ptr )
359 {
360 if( setjmp( png_jmpbuf ( png_ptr ) ) == 0 )
361 {
362 if( m_buf )
363 {
364 png_set_write_fn(png_ptr, this,
365 (png_rw_ptr)writeDataToBuf, (png_flush_ptr)flushBuf);
366 }
367 else
368 {
369 f = fopen( m_filename.c_str(), "wb" );
370 if( f )
371 png_init_io( png_ptr, f );
372 }
373
374 int compression_level = -1; // Invalid value to allow setting 0-9 as valid
375 int compression_strategy = Z_RLE; // Default strategy
376 bool isBilevel = false;
377
378 for( size_t i = 0; i < params.size(); i += 2 )
379 {
380 if( params[i] == CV_IMWRITE_PNG_COMPRESSION )
381 {
382 compression_level = params[i+1];
383 compression_level = MIN(MAX(compression_level, 0), Z_BEST_COMPRESSION);
384 }
385 if( params[i] == CV_IMWRITE_PNG_STRATEGY )
386 {
387 compression_strategy = params[i+1];
388 compression_strategy = MIN(MAX(compression_strategy, 0), Z_FIXED);
389 }
390 if( params[i] == CV_IMWRITE_PNG_BILEVEL )
391 {
392 isBilevel = params[i+1] != 0;
393 }
394 }
395
396 if( m_buf || f )
397 {
398 if( compression_level >= 0 )
399 {
400 png_set_compression_level( png_ptr, compression_level );
401 }
402 else
403 {
404 // tune parameters for speed
405 // (see http://wiki.linuxquestions.org/wiki/Libpng)
406 png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, PNG_FILTER_SUB);
407 png_set_compression_level(png_ptr, Z_BEST_SPEED);
408 }
409 png_set_compression_strategy(png_ptr, compression_strategy);
410
411 png_set_IHDR( png_ptr, info_ptr, width, height, depth == CV_8U ? isBilevel?1:8 : 16,
412 channels == 1 ? PNG_COLOR_TYPE_GRAY :
413 channels == 3 ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGBA,
414 PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
415 PNG_FILTER_TYPE_DEFAULT );
416
417 png_write_info( png_ptr, info_ptr );
418
419 if (isBilevel)
420 png_set_packing(png_ptr);
421
422 png_set_bgr( png_ptr );
423 if( !isBigEndian() )
424 png_set_swap( png_ptr );
425
426 buffer.allocate(height);
427 for( y = 0; y < height; y++ )
428 buffer[y] = img.data + y*img.step;
429
430 png_write_image( png_ptr, buffer );
431 png_write_end( png_ptr, info_ptr );
432
433 result = true;
434 }
435 }
436 }
437 }
438
439 png_destroy_write_struct( &png_ptr, &info_ptr );
440 if(f) fclose( f );
441
442 return result;
443 }
444
445 }
446
447 #endif
448
449 /* End of file. */
450