modules/highgui/src/grfmt_png.cpp

   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
  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
  97 PngDecoder::~PngDecoder()
  98 {
  99     close();
 100 }
 101
 102 ImageDecoder PngDecoder::newDecoder() const
 103 {
 104     return new PngDecoder;
 105 }
 106
 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
 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.data[decoder->m_buf_pos], size );
 138     decoder->m_buf_pos += size;
 139 }
 140
 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;
 175
 176                     png_read_info( png_ptr, info_ptr );
 177
 178                     png_get_IHDR( png_ptr, info_ptr, &wdth, &hght,
 179                                   &bit_depth, &color_type, 0, 0, 0 );
 180
 181                     m_width = (int)wdth;
 182                     m_height = (int)hght;
 183                     m_color_type = color_type;
 184                     m_bit_depth = bit_depth;
 185
 186                     if( bit_depth <= 8 || bit_depth == 16 )
 187                     {
 188                         switch(color_type)
 189                         {
 190                            case PNG_COLOR_TYPE_RGB:
 191                            case PNG_COLOR_TYPE_PALETTE:
 192                                m_type = CV_8UC3;
 193                                break;
 194                           case PNG_COLOR_TYPE_RGB_ALPHA:
 195                                m_type = CV_8UC4;
 196                                break;
 197                           default:
 198                                m_type = CV_8UC1;
 199                         }
 200                         if( bit_depth == 16 )
 201                             m_type = CV_MAKETYPE(CV_16U, CV_MAT_CN(m_type));
 202                         result = true;
 203                     }
 204                 }
 205             }
 206         }
 207     }
 208
 209     if( !result )
 210         close();
 211
 212     return result;
 213 }
 214
 215
 216 bool  PngDecoder::readData( Mat& img )
 217 {
 218     bool result = false;
 219     AutoBuffer<uchar*> _buffer(m_height);
 220     uchar** buffer = _buffer;
 221     int color = img.channels() > 1;
 222     uchar* data = img.data;
 223     int step = (int)img.step;
 224
 225     if( m_png_ptr && m_info_ptr && m_end_info && m_width && m_height )
 226     {
 227         png_structp png_ptr = (png_structp)m_png_ptr;
 228         png_infop info_ptr = (png_infop)m_info_ptr;
 229         png_infop end_info = (png_infop)m_end_info;
 230
 231         if( setjmp( png_jmpbuf ( png_ptr ) ) == 0 )
 232         {
 233             int y;
 234
 235             if( img.depth() == CV_8U && m_bit_depth == 16 )
 236                 png_set_strip_16( png_ptr );
 237             else if( !isBigEndian() )
 238                 png_set_swap( png_ptr );
 239
 240             if(img.channels() < 4)
 241             {
 242                 /* observation: png_read_image() writes 400 bytes beyond
 243                  * end of data when reading a 400x118 color png
 244                  * "mpplus_sand.png".  OpenCV crashes even with demo
 245                  * programs.  Looking at the loaded image I'd say we get 4
 246                  * bytes per pixel instead of 3 bytes per pixel.  Test
 247                  * indicate that it is a good idea to always ask for
 248                  * stripping alpha..  18.11.2004 Axel Walthelm
 249                  */
 250                  png_set_strip_alpha( png_ptr );
 251             }
 252
 253             if( m_color_type == PNG_COLOR_TYPE_PALETTE )
 254                 png_set_palette_to_rgb( png_ptr );
 255
 256             if( m_color_type == PNG_COLOR_TYPE_GRAY && m_bit_depth < 8 )
 257 #if (PNG_LIBPNG_VER_MAJOR*10000 + PNG_LIBPNG_VER_MINOR*100 + PNG_LIBPNG_VER_RELEASE >= 10209) || \
 258     (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR == 0 && PNG_LIBPNG_VER_RELEASE >= 18)
 259                 png_set_expand_gray_1_2_4_to_8( png_ptr );
 260 #else
 261                 png_set_gray_1_2_4_to_8( png_ptr );
 262 #endif
 263
 264             if( CV_MAT_CN(m_type) > 1 && color )
 265                 png_set_bgr( png_ptr ); // convert RGB to BGR
 266             else if( color )
 267                 png_set_gray_to_rgb( png_ptr ); // Gray->RGB
 268             else
 269                 png_set_rgb_to_gray( png_ptr, 1, 0.299, 0.587 ); // RGB->Gray
 270
 271             png_read_update_info( png_ptr, info_ptr );
 272
 273             for( y = 0; y < m_height; y++ )
 274                 buffer[y] = data + y*step;
 275
 276             png_read_image( png_ptr, buffer );
 277             png_read_end( png_ptr, end_info );
 278
 279             result = true;
 280         }
 281     }
 282
 283     close();
 284     return result;
 285 }
 286
 287
 288 /////////////////////// PngEncoder ///////////////////
 289
 290
 291 PngEncoder::PngEncoder()
 292 {
 293     m_description = "Portable Network Graphics files (*.png)";
 294     m_buf_supported = true;
 295 }
 296
 297
 298 PngEncoder::~PngEncoder()
 299 {
 300 }
 301
 302
 303 bool  PngEncoder::isFormatSupported( int depth ) const
 304 {
 305     return depth == CV_8U || depth == CV_16U;
 306 }
 307
 308 ImageEncoder PngEncoder::newEncoder() const
 309 {
 310     return new PngEncoder;
 311 }
 312
 313
 314 void PngEncoder::writeDataToBuf(void* _png_ptr, uchar* src, size_t size)
 315 {
 316     if( size == 0 )
 317         return;
 318     png_structp png_ptr = (png_structp)_png_ptr;
 319     PngEncoder* encoder = (PngEncoder*)(png_get_io_ptr(png_ptr));
 320     CV_Assert( encoder && encoder->m_buf );
 321     size_t cursz = encoder->m_buf->size();
 322     encoder->m_buf->resize(cursz + size);
 323     memcpy( &(*encoder->m_buf)[cursz], src, size );
 324 }
 325
 326
 327 void PngEncoder::flushBuf(void*)
 328 {
 329 }
 330
 331 bool  PngEncoder::write( const Mat& img, const vector<int>& params )
 332 {
 333     png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 );
 334     png_infop info_ptr = 0;
 335     FILE* f = 0;
 336     int y, width = img.cols, height = img.rows;
 337     int depth = img.depth(), channels = img.channels();
 338     bool result = false;
 339     AutoBuffer<uchar*> buffer;
 340
 341     if( depth != CV_8U && depth != CV_16U )
 342         return false;
 343
 344     if( png_ptr )
 345     {
 346         info_ptr = png_create_info_struct( png_ptr );
 347
 348         if( info_ptr )
 349         {
 350             if( setjmp( png_jmpbuf ( png_ptr ) ) == 0 )
 351             {
 352                 if( m_buf )
 353                 {
 354                     png_set_write_fn(png_ptr, this,
 355                         (png_rw_ptr)writeDataToBuf, (png_flush_ptr)flushBuf);
 356                 }
 357                 else
 358                 {
 359                     f = fopen( m_filename.c_str(), "wb" );
 360                     if( f )
 361                         png_init_io( png_ptr, f );
 362                 }
 363
 364                 int compression_level = -1; // Invalid value to allow setting 0-9 as valid
 365                 int compression_strategy = Z_RLE; // Default strategy
 366                 bool isBilevel = false;
 367
 368                 for( size_t i = 0; i < params.size(); i += 2 )
 369                 {
 370                     if( params[i] == CV_IMWRITE_PNG_COMPRESSION )
 371                     {
 372                         compression_level = params[i+1];
 373                         compression_level = MIN(MAX(compression_level, 0), Z_BEST_COMPRESSION);
 374                     }
 375                     if( params[i] == CV_IMWRITE_PNG_STRATEGY )
 376                     {
 377                         compression_strategy = params[i+1];
 378                         compression_strategy = MIN(MAX(compression_strategy, 0), Z_FIXED);
 379                     }
 380                     if( params[i] == CV_IMWRITE_PNG_BILEVEL )
 381                     {
 382                         isBilevel = params[i+1] != 0;
 383                     }
 384                 }
 385
 386                 if( m_buf || f )
 387                 {
 388                     if( compression_level >= 0 )
 389                     {
 390                         png_set_compression_level( png_ptr, compression_level );
 391                     }
 392                     else
 393                     {
 394                         // tune parameters for speed
 395                         // (see http://wiki.linuxquestions.org/wiki/Libpng)
 396                         png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, PNG_FILTER_SUB);
 397                         png_set_compression_level(png_ptr, Z_BEST_SPEED);
 398                     }
 399                     png_set_compression_strategy(png_ptr, compression_strategy);
 400
 401                     png_set_IHDR( png_ptr, info_ptr, width, height, depth == CV_8U ? isBilevel?1:8 : 16,
 402                         channels == 1 ? PNG_COLOR_TYPE_GRAY :
 403                         channels == 3 ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGBA,
 404                         PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
 405                         PNG_FILTER_TYPE_DEFAULT );
 406
 407                     png_write_info( png_ptr, info_ptr );
 408
 409                     if (isBilevel)
 410                         png_set_packing(png_ptr);
 411
 412                     png_set_bgr( png_ptr );
 413                     if( !isBigEndian() )
 414                         png_set_swap( png_ptr );
 415
 416                     buffer.allocate(height);
 417                     for( y = 0; y < height; y++ )
 418                         buffer[y] = img.data + y*img.step;
 419
 420                     png_write_image( png_ptr, buffer );
 421                     png_write_end( png_ptr, info_ptr );
 422
 423                     result = true;
 424                 }
 425             }
 426         }
 427     }
 428
 429     png_destroy_write_struct( &png_ptr, &info_ptr );
 430     if(f) fclose( f );
 431
 432     return result;
 433 }
 434
 435 }
 436
 437 #endif
 438
 439 /* End of file. */