使用libpng直接在記憶體中對資料進行png編解碼
阿新 • • 發佈：2018-12-04
由於工作需要，需要在記憶體中直接對資料進行png編碼，然後再解碼以測試其解碼的速度，與現有的影象壓縮方法進行比較。由於初次接觸libpng，而網上這種直接在記憶體中操作的文章並不多，從頭學習要花不少的時間。鑑於此，我藉助第3方庫：opencv庫，來學習opencv是怎麼在記憶體中對資料進行操作的（opencv的imread和imwrite PNG格式的資料，底層就是使用libpng操作的）。
opencv中的imread和imwrite方法就是對相應格式的資料的一種編解碼，其原始碼在modules\imgcodecs\src中，找到grfmt_base.hpp
class BaseImageDecoder
{
public:
BaseImageDecoder();
virtual ~BaseImageDecoder() {}
int width() const { return m_width; }
int height() const { return m_height; }
virtual int type() const { return m_type; }
virtual bool setSource( const String& filename );\\設定解碼檔案路徑
virtual bool setSource( const Mat& buf );\\解碼資料來源，不設定的話，將使用的是解碼指定檔案路徑的檔案
virtual int setScale( const int& scale_denom );
virtual bool readHeader() = 0;
virtual bool readData( Mat& img ) = 0;
/// Called after readData to advance to the next page, if any.
virtual bool nextPage() { return false; }
virtual size_t signatureLength() const;
virtual bool checkSignature( const String& signature ) const;
virtual ImageDecoder newDecoder() const;
protected:
int m_width; // width of the image ( filled by readHeader )
int m_height; // height of the image ( filled by readHeader )
int m_type;
int m_scale_denom;
String m_filename;
String m_signature;
Mat m_buf;
bool m_buf_supported;
};
///////////////////////////// base class for encoders ////////////////////////////
class BaseImageEncoder
{
public:
BaseImageEncoder();
virtual ~BaseImageEncoder() {}
virtual bool isFormatSupported( int depth ) const;
virtual bool setDestination( const String& filename );\\設定輸出介面為檔案，將檔名告訴編碼器
#pragma once
#include <png.h>
#include <string>
#include <opencv2/core/core.hpp>
bool isBigEndian()
{
unsigned short usData = 0x1122;
unsigned char *pucData = (unsigned char*)&usData;
return (*pucData == 0x22);
}
enum ImwritePNGFlags_zc {
IMWRITE_PNG_STRATEGY_DEFAULT = 0,
IMWRITE_PNG_STRATEGY_FILTERED = 1,
IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2,
IMWRITE_PNG_STRATEGY_RLE = 3,
IMWRITE_PNG_STRATEGY_FIXED = 4
};
enum ImwriteFlags_zc {
IMWRITE_PNG_COMPRESSION = 16,
IMWRITE_PNG_STRATEGY = 17,
IMWRITE_PNG_BILEVEL = 18
};
class PngImageDecoder
{
public:
PngImageDecoder();
~PngImageDecoder();
int width() const { return m_width; }
int height() const { return m_height; }
bool setSource(const std::string& filename);
bool setSource(const cv::Mat& buf);
int setScale(const int& scale_denom);
bool readHeader();
bool readData(cv::Mat& img);
void close();
//virtual size_t signatureLength() const;
//virtual bool checkSignature(const String& signature) const;
//PngImageDecoder newDecoder() const;
protected:
int m_width; // width of the image ( filled by readHeader )
int m_height; // height of the image ( filled by readHeader )
int m_type;
int m_scale_denom;
std::string m_filename;
//String m_signature;
cv::Mat m_buf;
static void readDataFromBuf(void* png_ptr, uchar* dst, size_t size);
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;
};
///////////////////////////// base class for encoders ////////////////////////////
class PngImageEncoder
{
public:
PngImageEncoder();
~PngImageEncoder() {}
//bool isFormatSupported(int depth) const;
bool setDestination(const std::string& filename);
bool setDestination(std::vector<uchar>& buf);
bool write(const cv::Mat& img, const std::vector<int>& params);
//virtual bool writemulti(const std::vector<Mat>& img_vec, const std::vector<int>& params);
//virtual String getDescription() const;
//PngImageEncoder newEncoder() const;
//virtual void throwOnEror() const;
protected:
//String m_description;
static void writeDataToBuf(void* png_ptr, uchar* src, size_t size);
static void flushBuf(void* png_ptr);
std::string m_filename;
std::vector<uchar>* m_buf;
//bool m_buf_supported;
//String m_last_error;
};
#include "stdafx.h" #include "pngCoder.h" #define Z_NO_COMPRESSION 0 #define Z_BEST_SPEED 1 #define Z_BEST_COMPRESSION 9 #define Z_DEFAULT_COMPRESSION (-1) #define Z_FILTERED 1 #define Z_HUFFMAN_ONLY 2 #define Z_RLE 3 #define Z_FIXED 4 #define Z_DEFAULT_STRATEGY 0 //#include <zlib.h> PngImageEncoder::PngImageEncoder() { m_buf = 0; } bool PngImageEncoder::setDestination(const std::string& filename) { m_filename = filename; m_buf = 0; return true; } bool PngImageEncoder::setDestination(std::vector<uchar>& buf) { m_buf = &buf; m_buf->clear(); m_filename = std::string(); return true; } void PngImageEncoder::writeDataToBuf(void* _png_ptr, uchar* src, size_t size) { if (size == 0) return; png_structp png_ptr = reinterpret_cast<png_structp>(_png_ptr); PngImageEncoder* encoder = (PngImageEncoder*)(png_get_io_ptr(png_ptr)); CV_Assert(encoder && encoder->m_buf); size_t cursz = encoder->m_buf->size(); encoder->m_buf->resize(cursz + size); memcpy(&(*encoder->m_buf)[cursz], src, size); } void PngImageEncoder::flushBuf(void*) { } bool PngImageEncoder::write(const cv::Mat& img, const std::vector<int>& 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.cols, height = img.rows; int depth = img.depth(), channels = img.channels(); volatile bool result = false; cv::AutoBuffer<uchar*> buffer; if (depth != CV_8U && depth != CV_16U) return false; if (png_ptr) { info_ptr = png_create_info_struct(png_ptr); if (info_ptr) { if (setjmp(png_jmpbuf(png_ptr)) == 0) { if (m_buf) { png_set_write_fn(png_ptr, this, (png_rw_ptr)writeDataToBuf, (png_flush_ptr)flushBuf); } else { f = fopen(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; for (size_t i = 0; i < params.size(); i += 2) { if (params[i] == IMWRITE_PNG_COMPRESSION) { compression_strategy = IMWRITE_PNG_STRATEGY_DEFAULT; // Default strategy compression_level = params[i + 1]; compression_level = MIN(MAX(compression_level, 0), Z_BEST_COMPRESSION); } if (params[i] == IMWRITE_PNG_STRATEGY) { compression_strategy = params[i + 1]; compression_strategy = MIN(MAX(compression_strategy, 0), Z_FIXED); } if (params[i] == IMWRITE_PNG_BILEVEL) { isBilevel = params[i + 1] != 0; } } if (m_buf || f) { if (compression_level >= 0) { png_set_compression_level(png_ptr, compression_level); } else { 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, depth == CV_8U ? 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); buffer.allocate(height); for (y = 0; y < height; y++) buffer[y] = img.data + y*img.step; unsigned char** ptr = buffer.operator uchar **(); //png_write_image(png_ptr, buffer.data()); png_write_image(png_ptr, ptr); png_write_end(png_ptr, info_ptr); result = true; } } } } png_destroy_write_struct(&png_ptr, &info_ptr); if (f) fclose((FILE*)f); return result; } //------------------decoder--------------- PngImageDecoder::PngImageDecoder() { //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; //m_buf_supported = true; m_buf_pos = 0; m_bit_depth = 0; } PngImageDecoder::~PngImageDecoder() { close(); } bool PngImageDecoder::setSource(const std::string& filename) { m_filename = filename; m_buf.release(); return true; } bool PngImageDecoder::setSource(const cv::Mat& buf) { m_filename = std::string(); m_buf = buf; return true; } int PngImageDecoder::setScale(const int& scale_denom) { int temp = m_scale_denom; m_scale_denom = scale_denom; return temp; } void PngImageDecoder::readDataFromBuf(void* _png_ptr, uchar* dst, size_t size) { png_structp png_ptr = (png_structp)_png_ptr; PngImageDecoder* decoder = (PngImageDecoder*)(png_get_io_ptr(png_ptr)); //CV_Assert(decoder); const cv::Mat& buf = decoder->m_buf; if (decoder->m_buf_pos + size > buf.cols*buf.rows*buf.elemSize()) { png_error(png_ptr, "PNG input buffer is incomplete"); return; } memcpy(dst, decoder->m_buf.ptr() + decoder->m_buf_pos, size); decoder->m_buf_pos += size; } void PngImageDecoder::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; } } bool PngImageDecoder::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) { if (!m_buf.empty()) png_set_read_fn(png_ptr, this, (png_rw_ptr)readDataFromBuf); else { m_f = fopen(m_filename.c_str(), "rb"); if (m_f) png_init_io(png_ptr, m_f); } if (!m_buf.empty() || 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); m_width = (int)wdth; 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) m_type = CV_8UC4; else m_type = CV_8UC3; break; case PNG_COLOR_TYPE_GRAY_ALPHA: case PNG_COLOR_TYPE_RGB_ALPHA: m_type = CV_8UC4; break; default: m_type = CV_8UC1; } if (bit_depth == 16) m_type = CV_MAKETYPE(CV_16U, CV_MAT_CN(m_type)); result = true; } } } } } if (!result) close(); return result; } bool PngImageDecoder::readData(cv::Mat& img) { volatile bool result = false; cv::AutoBuffer<uchar*> _buffer(m_height); uchar** buffer = _buffer.operator uchar **(); bool color = img.channels() > 1; 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 && m_width && m_height) { if (setjmp(png_jmpbuf(png_ptr)) == 0) { int y; if (img.depth() == CV_8U && m_bit_depth == 16) png_set_strip_16(png_ptr); else if (!isBigEndian()) png_set_swap(png_ptr); if (img.channels() < 4) { 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); for (y = 0; y < m_height; y++) buffer[y] = img.data + y*img.step; png_read_image(png_ptr, buffer); png_read_end(png_ptr, end_info); result = true; } } close(); return result; }