diff --git a/frontend/Interfaces/buddy/DIP/imgcodecs/grfmt_png.h b/frontend/Interfaces/buddy/DIP/imgcodecs/grfmt_png.h new file mode 100644 index 0000000000..666d09aac1 --- /dev/null +++ b/frontend/Interfaces/buddy/DIP/imgcodecs/grfmt_png.h @@ -0,0 +1,434 @@ +//===- Grfmt_png.hpp ---------------------------------------------------===// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this +// license. If you do not agree to this license, do not download, install, copy +// or use the software. +// +// +// Intel License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2000, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright +// notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of Intel Corporation may not be used to endorse or promote +// products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" +// and any express or implied warranties, including, but not limited to, the +// implied warranties of merchantability and fitness for a particular purpose +// are disclaimed. In no event shall the Intel Corporation or contributors be +// liable for any direct, indirect, incidental, special, exemplary, or +// consequential damages (including, but not limited to, procurement of +// substitute goods or services; loss of use, data, or profits; or business +// interruption) however caused and on any theory of liability, whether in +// contract, strict liability, or tort (including negligence or otherwise) +// arising in any way out of the use of this software, even if advised of the +// possibility of such damage. +// +// +//===----------------------------------------------------------------------===// +// +// This file is modified from opencv's modules/imgcodecs/src/grfmt_png.hpp file +// +//===----------------------------------------------------------------------===// + +#ifndef _GRFMT_PNG_H_ +#define _GRFMT_PNG_H_ + +#ifndef _LFS64_LARGEFILE +# define _LFS64_LARGEFILE 0 +#endif +#ifndef _FILE_OFFSET_BITS +# define _FILE_OFFSET_BITS 0 +#endif + +#include +#include + +#include "buddy/DIP/imgcodecs/grfmt_base.h" +#include "buddy/DIP/imgcodecs/bitstrm.h" + +#if defined _MSC_VER && _MSC_VER >= 1200 + // interaction between '_setjmp' and C++ object destruction is non-portable + #pragma warning( disable: 4611 ) +#endif + +// the following defines are a hack to avoid multiple problems with frame pointer handling and setjmp +// see http://gcc.gnu.org/ml/gcc/2011-10/msg00324.html for some details +#define mingw_getsp(...) 0 +#define __builtin_frame_address(...) 0 +namespace dip +{ +template +class PngDecoder : public BaseImageDecoder +{ +public: + + PngDecoder(); + virtual ~PngDecoder(); + bool readData( Img& img ) ; + bool readHeader() ; + void close(); + std::unique_ptr> newDecoder() const ; +protected: + + int m_bit_depth; + void* m_png_ptr; // pointer to decompression structure + void* m_info_ptr; // pointer to image information structure + void* m_end_info; // pointer to one more image information structure + FILE* m_f; + int m_color_type; + size_t m_buf_pos; +}; + +template +class PngEncoder : public BaseImageEncoder +{ +public: + PngEncoder(); + virtual ~PngEncoder(); + bool write( Img& img, const std::vector& params ) ; + std::unique_ptr> newEncoder() const; +protected: + static void writeDataToBuf(void* png_ptr, uchar* src, size_t size); +}; + +bool isBigEndian() { + int num = 1; + char* ptr = (char*)# + return (*ptr == 0); +} + + +/////////////////////// PngDecoder /////////////////// +template +PngDecoder::PngDecoder() +{ + this->m_signature = "\x89\x50\x4e\x47\xd\xa\x1a\xa"; + m_color_type = 0; + m_png_ptr = 0; + m_info_ptr = m_end_info = 0; + m_f = 0; + this->m_buf_supported = true; + m_buf_pos = 0; + m_bit_depth = 0; +} + +template +PngDecoder::~PngDecoder() +{ + close(); +} + +template +std::unique_ptr> PngDecoder::newDecoder() const { + return std::make_unique>(); +} + +template +void PngDecoder::close() +{ + if( m_f ) + { + fclose( m_f ); + m_f = 0; + } + + if( m_png_ptr ) + { + png_structp png_ptr = (png_structp)m_png_ptr; + png_infop info_ptr = (png_infop)m_info_ptr; + png_infop end_info = (png_infop)m_end_info; + png_destroy_read_struct( &png_ptr, &info_ptr, &end_info ); + m_png_ptr = m_info_ptr = m_end_info = 0; + } +} + + +template +bool PngDecoder::readHeader() +{ + volatile bool result = false; + close(); + png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 ); + if( png_ptr ) + { + png_infop info_ptr = png_create_info_struct( png_ptr ); + png_infop end_info = png_create_info_struct( png_ptr ); + m_png_ptr = png_ptr; + m_info_ptr = info_ptr; + m_end_info = end_info; + m_buf_pos = 0; + if( info_ptr && end_info ) + { + if( setjmp( png_jmpbuf( png_ptr ) ) == 0 ) + { + m_f = fopen( this->m_filename.c_str(), "rb" ); + if( m_f ) + png_init_io( png_ptr, m_f ); + if(m_f) + { + png_uint_32 wdth, hght; + int bit_depth, color_type, num_trans=0; + png_bytep trans; + png_color_16p trans_values; + png_read_info( png_ptr, info_ptr ); + png_get_IHDR( png_ptr, info_ptr, &wdth, &hght, + &bit_depth, &color_type, 0, 0, 0 ); + this->m_width = (int)wdth; + this->m_height = (int)hght; + m_color_type = color_type; + m_bit_depth = bit_depth; + if( bit_depth <= 8 || bit_depth == 16 ) + { + switch(color_type) + { + case PNG_COLOR_TYPE_RGB: + case PNG_COLOR_TYPE_PALETTE: + png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, &trans_values); + if( num_trans > 0 ) + this->m_channels = 4; + else + this->m_channels = 3; + break; + case PNG_COLOR_TYPE_GRAY_ALPHA: + case PNG_COLOR_TYPE_RGB_ALPHA: + this->m_channels = 4; + break; + default: + this->m_channels = 1; + } + result = true; + } + } + } + } + } + if( !result ) + close(); + return result; +} + +template +bool PngDecoder::readData( Img& img ) +{ + volatile bool result = false; + uchar**_buffer = new uchar*[this->m_height]; + uchar** buffer = _buffer; + bool color = img.channels() > 1; + T*data = img.getData(); + png_structp png_ptr = (png_structp)m_png_ptr; + png_infop info_ptr = (png_infop)m_info_ptr; + png_infop end_info = (png_infop)m_end_info; + if( m_png_ptr && m_info_ptr && m_end_info && this->m_width && this->m_height ) + { + if( setjmp( png_jmpbuf ( png_ptr ) ) == 0 ) + { + int y; + + if( m_bit_depth == 16 ) + png_set_strip_16( png_ptr ); + else if( !isBigEndian() ) + png_set_swap( png_ptr ); + + if(img.channels() < 4) + { + /* observation: png_read_image() writes 400 bytes beyond + * end of data when reading a 400x118 color png + * "mpplus_sand.png". OpenCV crashes even with demo + * programs. Looking at the loaded image I'd say we get 4 + * bytes per pixel instead of 3 bytes per pixel. Test + * indicate that it is a good idea to always ask for + * stripping alpha.. 18.11.2004 Axel Walthelm + */ + png_set_strip_alpha( png_ptr ); + } else + png_set_tRNS_to_alpha( png_ptr ); + + if( m_color_type == PNG_COLOR_TYPE_PALETTE ) + png_set_palette_to_rgb( png_ptr ); + + if( (m_color_type & PNG_COLOR_MASK_COLOR) == 0 && m_bit_depth < 8 ) +#if (PNG_LIBPNG_VER_MAJOR*10000 + PNG_LIBPNG_VER_MINOR*100 + PNG_LIBPNG_VER_RELEASE >= 10209) || \ + (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR == 0 && PNG_LIBPNG_VER_RELEASE >= 18) + png_set_expand_gray_1_2_4_to_8( png_ptr ); +#else + png_set_gray_1_2_4_to_8( png_ptr ); +#endif + + if( (m_color_type & PNG_COLOR_MASK_COLOR) && color ) + png_set_bgr( png_ptr ); // convert RGB to BGR + else if( color ) + png_set_gray_to_rgb( png_ptr ); // Gray->RGB + else + png_set_rgb_to_gray( png_ptr, 1, 0.299, 0.587 ); // RGB->Gray + + png_set_interlace_handling( png_ptr ); + png_read_update_info( png_ptr, info_ptr ); + + size_t step = this->m_width * img.channels(); + uchar *myArry = new uchar[img.getSize()]; + for(int y = 0; y < this->m_height; y++ ) + buffer[y] = myArry + y*step; + + png_read_image( png_ptr, buffer ); + png_read_end( png_ptr, end_info ); + for(int i = 0 ; i < img.getSize() ; i++) + { + data[i] = (T)myArry[i]; + } + +#ifdef PNG_eXIf_SUPPORTED + png_uint_32 num_exif = 0; + png_bytep exif = 0; + + // Exif info could be in info_ptr (intro_info) or end_info per specification + if( png_get_valid(png_ptr, info_ptr, PNG_INFO_eXIf) ) + png_get_eXIf_1(png_ptr, info_ptr, &num_exif, &exif); + else if( png_get_valid(png_ptr, end_info, PNG_INFO_eXIf) ) + png_get_eXIf_1(png_ptr, end_info, &num_exif, &exif); + +#endif + + result = true; + } + } + + close(); + return result; +} + + +/////////////////////// PngEncoder /////////////////// + +template +PngEncoder::PngEncoder() +{ + this->m_description = "Portable Network Graphics files (*.png)"; + this->m_buf_supported = true; +} + +template +PngEncoder::~PngEncoder() +{ +} + +template +std::unique_ptr> PngEncoder::newEncoder() const { + return std::make_unique>(); +} + +template +void PngEncoder::writeDataToBuf(void* _png_ptr, uchar* src, size_t size) +{ + if( size == 0 ) + return; + png_structp png_ptr = (png_structp)_png_ptr; + PngEncoder* encoder = (PngEncoder*)(png_get_io_ptr(png_ptr)); + size_t cursz = encoder->m_buf->size(); + encoder->m_buf->resize(cursz + size); + memcpy( &(*encoder->m_buf)[cursz], src, size ); +} + + + +template +bool PngEncoder::write( Img& img, const std::vector& params ) +{ + png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 ); + png_infop info_ptr = 0; + FILE * volatile f = 0; + int y, width = img.getSizes()[1], height = img.getSizes()[0]; + int channels = img.channels(); + volatile bool result = false; + uchar**buffer = new uchar*[height]; + T*data = img.getData(); + if( png_ptr ) + { + info_ptr = png_create_info_struct( png_ptr ); + + if( info_ptr ) + { + if( setjmp( png_jmpbuf ( png_ptr ) ) == 0 ) + { + + f = fopen( this->m_filename.c_str(), "wb" ); + if( f ) + png_init_io( png_ptr, (png_FILE_p)f ); + + + int compression_level = -1; // Invalid value to allow setting 0-9 as valid + int compression_strategy = IMWRITE_PNG_STRATEGY_RLE; // Default strategy + bool isBilevel = false; + + if( f ) + { + if( compression_level >= 0 ) + { + png_set_compression_level( png_ptr, compression_level ); + } + else + { + // tune parameters for speed + // (see http://wiki.linuxquestions.org/wiki/Libpng) + png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, PNG_FILTER_SUB); + png_set_compression_level(png_ptr, Z_BEST_SPEED); + } + png_set_compression_strategy(png_ptr, compression_strategy); + + png_set_IHDR( png_ptr, info_ptr, width, height, 1 ? isBilevel?1:8 : 16, + channels == 1 ? PNG_COLOR_TYPE_GRAY : + channels == 3 ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGBA, + PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, + PNG_FILTER_TYPE_DEFAULT ); + + png_write_info( png_ptr, info_ptr ); + + if (isBilevel) + png_set_packing(png_ptr); + + png_set_bgr( png_ptr ); + if( !isBigEndian() ) + png_set_swap( png_ptr ); + + size_t step = width * img.channels(); + uchar *myArry = new uchar[img.getSize()]; + for(int i = 0 ; i < img.getSize() ; i++) + { + myArry[i] = (uchar)data[i]; + } + + for(int y = 0; y < height; y++ ) + buffer[y] = myArry + y*step; + + png_write_image( png_ptr, buffer ); + png_write_end( png_ptr, info_ptr ); + + result = true; + } + } + } + } + + png_destroy_write_struct( &png_ptr, &info_ptr ); + if(f) fclose( (FILE*)f ); + + return result; +} +} // namespace dip +#endif/*_GRFMT_PNG_H_*/ \ No newline at end of file