lvfulong
314 lines
9.0 KiB
C++
314 lines
9.0 KiB
C++
/**
|
|
@file JCPngImg.cpp
|
|
@brief
|
|
@author hugao
|
|
@version 1.0
|
|
@date 2016_5_11
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include "png.h"
|
|
#include "pngconf.h"
|
|
#include <stdio.h>
|
|
#include <memory.h>
|
|
#include <stdlib.h>
|
|
#include "../util/JCCommonMethod.h"
|
|
#include "JCImageRW.h"
|
|
|
|
//------------------------------------------------------------------------------
|
|
#pragma warning (disable: 4996)
|
|
namespace laya
|
|
{
|
|
typedef struct
|
|
{
|
|
unsigned char* data;
|
|
int size;
|
|
int offset;
|
|
}ImageSource;
|
|
|
|
//从内存读取PNG图片的回调函数
|
|
static void pngReadCallback(png_structp png_ptr, png_bytep data, png_size_t length)
|
|
{
|
|
ImageSource* isource = (ImageSource*)png_get_io_ptr(png_ptr);
|
|
if( (int)(isource->offset + length) <= isource->size)
|
|
{
|
|
memcpy(data, isource->data+isource->offset, length);
|
|
isource->offset += length;
|
|
}
|
|
else
|
|
png_error(png_ptr, "pngReaderCallback failed");
|
|
}
|
|
void my_error_fn(png_structp png_ptr, png_const_charp error_msg)
|
|
{
|
|
|
|
}
|
|
void my_warning_fn(png_structp png_ptr,png_const_charp warning_msg)
|
|
{
|
|
|
|
}
|
|
|
|
static unsigned int multiply_alpha(unsigned int alpha, unsigned int color)
|
|
{
|
|
unsigned int temp = alpha * color + 0x80;
|
|
return (temp + (temp >> 8)) >> 8;
|
|
}
|
|
|
|
static void premultiply_data(png_structp png, png_row_infop row_info, png_bytep data)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < row_info->rowbytes; i += 4)
|
|
{
|
|
unsigned char* base = &data[i];
|
|
unsigned int alpha = base[3];
|
|
|
|
|
|
if (alpha == 0)
|
|
base[0] = base[1] = base[2] = base[3] = 0;
|
|
|
|
else
|
|
{
|
|
unsigned int red = base[0];
|
|
unsigned int green = base[1];
|
|
unsigned int blue = base[2];
|
|
|
|
|
|
if (alpha != 0xFF)
|
|
{
|
|
red = multiply_alpha(alpha, red);
|
|
green = multiply_alpha(alpha, green);
|
|
blue = multiply_alpha(alpha, blue);
|
|
}
|
|
|
|
base[0] = (unsigned char)red;
|
|
base[1] = (unsigned char)green;
|
|
base[2] = (unsigned char)blue;
|
|
base[3] = (unsigned char)alpha;
|
|
}
|
|
}
|
|
}
|
|
unsigned char* ReadPNGFromMem(unsigned char* data, int dataSize, PNG_UINT32* w, PNG_UINT32* h)
|
|
{
|
|
//unsigned char sig[8];
|
|
png_structp png_ptr;
|
|
png_infop info_ptr;
|
|
unsigned char* image_data;
|
|
int bit_depth;
|
|
int color_type;
|
|
unsigned int rowbytes;
|
|
png_uint_32 i;
|
|
png_bytepp row_pointers;
|
|
|
|
if ((png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, my_error_fn, my_warning_fn)) == NULL) {
|
|
return NULL;
|
|
}
|
|
if ((info_ptr = png_create_info_struct(png_ptr)) == NULL) {
|
|
png_destroy_read_struct(&png_ptr, NULL, NULL);
|
|
return NULL;
|
|
}
|
|
|
|
if (setjmp(png_jmpbuf(png_ptr))) {
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
|
return NULL;
|
|
}
|
|
|
|
ImageSource imgsource;
|
|
imgsource.data = data;
|
|
imgsource.size = dataSize;
|
|
imgsource.offset = 0;
|
|
png_set_read_fn(png_ptr, &imgsource,pngReadCallback);
|
|
png_read_info(png_ptr, info_ptr);
|
|
png_set_sig_bytes(png_ptr, 8);
|
|
png_get_IHDR(png_ptr, info_ptr, w, h, &bit_depth, &color_type, NULL, NULL, NULL);
|
|
|
|
//预乘alpha
|
|
//png_set_read_user_transform_fn(png_ptr, premultiply_data);
|
|
|
|
//if (color_type & PNG_COLOR_MASK_ALPHA)
|
|
// png_set_strip_alpha(png_ptr); //去掉alhpa信息了。TODO 以后要加上。
|
|
if (bit_depth >8)
|
|
png_set_strip_16(png_ptr); //16bit的通道要转换成8bit的
|
|
if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
|
|
png_set_gray_to_rgb(png_ptr);
|
|
if (color_type == PNG_COLOR_TYPE_PALETTE)
|
|
png_set_palette_to_rgb(png_ptr);
|
|
if(png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
|
|
png_set_tRNS_to_alpha(png_ptr);
|
|
// if (color_type == PNG_COLOR_TYPE_RGB)
|
|
png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);//PNG_FILLER_BEFORE);
|
|
|
|
png_read_update_info(png_ptr, info_ptr);
|
|
|
|
rowbytes = png_get_rowbytes(png_ptr, info_ptr);
|
|
if ((image_data =(unsigned char *) malloc(*h * rowbytes)) == NULL) {
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
|
return NULL;
|
|
}
|
|
if ((row_pointers =(png_bytepp) malloc(*h * sizeof(png_bytep))) == NULL) {
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
|
free(image_data);
|
|
return NULL;
|
|
}
|
|
|
|
for (i = 0; i < *h; i++)
|
|
//row_pointers[*h - 1 - i] = image_data + i*rowbytes;
|
|
row_pointers[i] = image_data + i*rowbytes;
|
|
|
|
png_read_image(png_ptr, row_pointers);
|
|
free(row_pointers);
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
|
|
|
return image_data;
|
|
}
|
|
/*
|
|
//获得宽高信息，并不最终解码
|
|
bool LoadPngWH( const char* p_sFileName,int& p_nWidth,int& p_nHeight )
|
|
{
|
|
FILE* f;
|
|
unsigned char sig[8];
|
|
png_structp png_ptr;
|
|
png_infop info_ptr;
|
|
//unsigned char* image_data;
|
|
int bit_depth;
|
|
int color_type;
|
|
//unsigned int rowbytes;
|
|
//png_uint_32 i;
|
|
//png_bytepp row_pointers;
|
|
|
|
if ((f = fopen(p_sFileName, "rb")) == NULL)
|
|
return false;
|
|
fread(sig, sizeof(*sig), sizeof(sig), f);
|
|
if (!png_check_sig(sig, sizeof(*sig))) {
|
|
fclose(f);
|
|
return false;
|
|
}
|
|
if ((png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)) == NULL) {
|
|
fclose(f);
|
|
return false;
|
|
}
|
|
if ((info_ptr = png_create_info_struct(png_ptr)) == NULL) {
|
|
png_destroy_read_struct(&png_ptr, NULL, NULL);
|
|
fclose(f);
|
|
return false;
|
|
}
|
|
|
|
if (setjmp(png_jmpbuf(png_ptr))) {
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
|
fclose(f);
|
|
return false;
|
|
}
|
|
png_ptr->io_ptr = (png_voidp) f;
|
|
png_set_sig_bytes(png_ptr, 8);
|
|
|
|
png_read_info(png_ptr, info_ptr);
|
|
png_uint_32 w,h;
|
|
png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &color_type, NULL, NULL, NULL);
|
|
p_nWidth = w;
|
|
p_nHeight = h;
|
|
fclose(f);
|
|
return true;
|
|
}
|
|
*/
|
|
int SavePng(char* png_file_name, char **data, int width, int height, int bit_depth)
|
|
{
|
|
png_structp png_ptr;
|
|
png_infop info_ptr;
|
|
FILE *png_file = fopen(png_file_name, "wb");
|
|
//assert(png_file);
|
|
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
|
|
if(png_ptr == NULL)
|
|
{
|
|
//cerr<<"ERROR:png_create_write_struct/n";
|
|
if (png_file)
|
|
fclose(png_file);
|
|
return 0;
|
|
}
|
|
info_ptr = png_create_info_struct(png_ptr);
|
|
if(info_ptr == NULL)
|
|
{
|
|
//cerr<<"ERROR:png_create_info_struct/n";
|
|
if (png_file) {
|
|
fclose(png_file);
|
|
}
|
|
png_destroy_write_struct(&png_ptr, NULL);
|
|
return 0;
|
|
}
|
|
png_init_io(png_ptr, png_file);
|
|
png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_RGB_ALPHA,
|
|
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
|
|
//png_set_PLTE(png_ptr, info_ptr, palette, palette_len);
|
|
png_write_info(png_ptr, info_ptr);
|
|
|
|
png_bytepp row_pointers = new png_bytep[height];
|
|
for (int i=0; i<height; ++i)
|
|
{
|
|
row_pointers[i] = (png_bytep)data[i];
|
|
}
|
|
png_write_image(png_ptr, row_pointers);
|
|
delete[] row_pointers;
|
|
png_write_end(png_ptr, info_ptr);
|
|
//png_free(png_ptr, palette);
|
|
//palette=NULL;
|
|
png_destroy_write_struct(&png_ptr, &info_ptr);
|
|
fclose(png_file);
|
|
return 0;
|
|
}
|
|
|
|
typedef unsigned char ui8;
|
|
static void PngWriteToMemoryFunc(png_structp png_ptr, png_bytep data, png_size_t length) {
|
|
std::vector<ui8> *p = (std::vector<ui8>*)png_get_io_ptr(png_ptr);
|
|
p->insert(p->end(), data, data + length);
|
|
}
|
|
|
|
std::pair<unsigned char*, unsigned long> convertBitmapToPng(const char* p_pData, int nWidth, int nHeight, int nBitDepth)
|
|
{
|
|
std::vector<unsigned char> buffer;
|
|
buffer.reserve(nWidth * nHeight * 4);
|
|
|
|
|
|
std::pair<unsigned char*, unsigned long> res
|
|
= std::make_pair((unsigned char*)NULL, 0);
|
|
|
|
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, NULL, NULL);
|
|
if (!png_ptr)
|
|
return res;
|
|
png_infop info_ptr = png_create_info_struct(png_ptr);
|
|
if (!info_ptr)
|
|
return res;
|
|
|
|
if (setjmp(png_jmpbuf(png_ptr)))
|
|
return res;
|
|
|
|
png_set_write_fn(png_ptr, &buffer, PngWriteToMemoryFunc, NULL);
|
|
|
|
|
|
png_set_IHDR(png_ptr, info_ptr,
|
|
nWidth,
|
|
nHeight,
|
|
8,
|
|
PNG_COLOR_TYPE_RGB_ALPHA,
|
|
PNG_INTERLACE_NONE,
|
|
PNG_COMPRESSION_TYPE_DEFAULT,
|
|
PNG_FILTER_TYPE_DEFAULT);
|
|
|
|
png_write_info(png_ptr, info_ptr);
|
|
for (int i = 0; i < nHeight; i++)
|
|
png_write_row(png_ptr, (unsigned char*)p_pData + i * nWidth * 4);
|
|
|
|
png_write_end(png_ptr, info_ptr);
|
|
|
|
png_destroy_write_struct(&png_ptr, &info_ptr);
|
|
|
|
unsigned long nByte = buffer.size();
|
|
unsigned char* pBuffer = new unsigned char[nByte];
|
|
memcpy(pBuffer, &buffer[0], nByte);
|
|
res.first = pBuffer;
|
|
res.second = nByte;
|
|
return res;
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
//-----------------------------END FILE--------------------------------
|