本文整理汇总了C++中png_write_info函数的典型用法代码示例。如果您正苦于以下问题：C++ png_write_info函数的具体用法？C++ png_write_info怎么用？C++ png_write_info使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了png_write_info函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: AssertFatal
bool DeferredPNGWriter::begin( GFXFormat format, S32 width, S32 height, Stream &stream, U32 compressionLevel )
{
// ONLY RGB bitmap writing supported at this time!
AssertFatal( format == GFXFormatR8G8B8 ||
format == GFXFormatR8G8B8A8 ||
format == GFXFormatR8G8B8X8 ||
format == GFXFormatA8 ||
format == GFXFormatR5G6B5, "_writePNG: ONLY RGB bitmap writing supported at this time.");
if ( format != GFXFormatR8G8B8 &&
format != GFXFormatR8G8B8A8 &&
format != GFXFormatR8G8B8X8 &&
format != GFXFormatA8 &&
format != GFXFormatR5G6B5 )
return false;
mData->png_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING,
NULL,
pngFatalErrorFn,
pngWarningFn,
NULL,
pngRealMallocFn,
pngRealFreeFn);
if (mData->png_ptr == NULL)
return (false);
mData->info_ptr = png_create_info_struct(mData->png_ptr);
if (mData->info_ptr == NULL)
{
png_destroy_write_struct(&mData->png_ptr, (png_infopp)NULL);
return false;
}
png_set_write_fn(mData->png_ptr, &stream, pngWriteDataFn, pngFlushDataFn);
// Set the compression level and image filters
png_set_compression_window_bits(mData->png_ptr, 15);
png_set_compression_level(mData->png_ptr, compressionLevel);
png_set_filter(mData->png_ptr, 0, PNG_ALL_FILTERS);
// Set the image information here. Width and height are up to 2^31,
// bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
// the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
// PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
// or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
// PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
// currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
if (format == GFXFormatR8G8B8)
{
png_set_IHDR(mData->png_ptr, mData->info_ptr,
width, height, // the width & height
8, PNG_COLOR_TYPE_RGB, // bit_depth, color_type,
NULL, // no interlace
NULL, // compression type
NULL); // filter type
}
else if (format == GFXFormatR8G8B8A8 || format == GFXFormatR8G8B8X8)
{
png_set_IHDR(mData->png_ptr, mData->info_ptr,
width, height, // the width & height
8, PNG_COLOR_TYPE_RGB_ALPHA, // bit_depth, color_type,
NULL, // no interlace
NULL, // compression type
NULL); // filter type
}
else if (format == GFXFormatA8)
{
png_set_IHDR(mData->png_ptr, mData->info_ptr,
width, height, // the width & height
8, PNG_COLOR_TYPE_GRAY, // bit_depth, color_type,
NULL, // no interlace
NULL, // compression type
NULL); // filter type
}
else if (format == GFXFormatR5G6B5)
{
png_set_IHDR(mData->png_ptr, mData->info_ptr,
width, height, // the width & height
16, PNG_COLOR_TYPE_GRAY, // bit_depth, color_type,
PNG_INTERLACE_NONE, // no interlace
PNG_COMPRESSION_TYPE_DEFAULT, // compression type
PNG_FILTER_TYPE_DEFAULT); // filter type
png_color_8_struct sigBit = { 0 };
sigBit.gray = 16;
png_set_sBIT(mData->png_ptr, mData->info_ptr, &sigBit );
png_set_swap( mData->png_ptr );
}
png_write_info(mData->png_ptr, mData->info_ptr);
mActive = true;
return true;
}示例2: TextureToPng
/*
TextureToPng
Inputs:
data : This is an array of RGBA with 8 bits per channel. 4 bytes for each pixel.
row_stride: Determines the amount of bytes per row of pixels.
*/
bool TextureToPng(u8* data, int row_stride, const std::string filename, int width, int height, bool saveAlpha)
{
bool success = false;
if (!data)
return false;
char title[] = "Dolphin Screenshot";
char title_key[] = "Title";
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
// Open file for writing (binary mode)
File::IOFile fp(filename, "wb");
if (!fp.IsOpen()) {
PanicAlert("Screenshot failed: Could not open file %s %d\n", filename.c_str(), errno);
goto finalise;
}
// Initialize write structure
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
PanicAlert("Screenshot failed: Could not allocate write struct\n");
goto finalise;
}
// Initialize info structure
info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL) {
PanicAlert("Screenshot failed: Could not allocate info struct\n");
goto finalise;
}
// Setup Exception handling
if (setjmp(png_jmpbuf(png_ptr))) {
PanicAlert("Screenshot failed: Error during png creation\n");
goto finalise;
}
png_init_io(png_ptr, fp.GetHandle());
// Write header (8 bit colour depth)
png_set_IHDR(png_ptr, info_ptr, width, height,
8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
png_text title_text;
title_text.compression = PNG_TEXT_COMPRESSION_NONE;
title_text.key = title_key;
title_text.text = title;
png_set_text(png_ptr, info_ptr, &title_text, 1);
png_write_info(png_ptr, info_ptr);
// Write image data
for (auto y = 0; y < height; ++y)
{
u8* row_ptr = (u8*)data + y * row_stride;
u8* ptr = row_ptr;
for (auto x = 0; x < row_stride / 4; ++x)
{
if (!saveAlpha)
ptr[3] = 0xff;
ptr += 4;
}
png_write_row(png_ptr, row_ptr);
}
// End write
png_write_end(png_ptr, NULL);
success = true;
finalise:
if (info_ptr != NULL) png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
if (png_ptr != NULL) png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return success;
}示例3: save_png_fast_progressive
PyObject *
save_png_fast_progressive (char *filename,
int w, int h,
bool has_alpha,
PyObject *data_generator,
bool write_legacy_png)
{
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
PyObject * result = NULL;
int bpc;
FILE * fp = NULL;
PyObject *iterator = NULL;
/* TODO: try if this silliness helps
#if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)
png_uint_32 mask, flags;
flags = png_get_asm_flags(png_ptr);
mask = png_get_asm_flagmask(PNG_SELECT_READ | PNG_SELECT_WRITE);
png_set_asm_flags(png_ptr, flags | mask);
#endif
*/
bpc = 8;
fp = fopen(filename, "wb");
if (!fp) {
PyErr_SetFromErrno(PyExc_IOError);
//PyErr_Format(PyExc_IOError, "Could not open PNG file for writing: %s", filename);
goto cleanup;
}
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, png_write_error_callback, NULL);
if (!png_ptr) {
PyErr_SetString(PyExc_MemoryError, "png_create_write_struct() failed");
goto cleanup;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
PyErr_SetString(PyExc_MemoryError, "png_create_info_struct() failed");
goto cleanup;
}
if (setjmp(png_jmpbuf(png_ptr))) {
goto cleanup;
}
png_init_io(png_ptr, fp);
png_set_IHDR (png_ptr, info_ptr,
w, h, bpc,
has_alpha ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE,
PNG_FILTER_TYPE_BASE);
if (! write_legacy_png) {
// Internal data is sRGB by the time it gets here.
// Explicitly save with the recommended chunks to advertise that fact.
png_set_sRGB_gAMA_and_cHRM (png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
}
// default (all filters enabled): 1350ms, 3.4MB
//png_set_filter(png_ptr, 0, PNG_FILTER_NONE); // 790ms, 3.8MB
//png_set_filter(png_ptr, 0, PNG_FILTER_PAETH); // 980ms, 3.5MB
png_set_filter(png_ptr, 0, PNG_FILTER_SUB); // 760ms, 3.4MB
//png_set_compression_level(png_ptr, 0); // 0.49s, 32MB
//png_set_compression_level(png_ptr, 1); // 0.98s, 9.6MB
png_set_compression_level(png_ptr, 2); // 1.08s, 9.4MB
//png_set_compression_level(png_ptr, 9); // 18.6s, 9.3MB
png_write_info(png_ptr, info_ptr);
if (!has_alpha) {
// input array format format is rgbu
png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
}
{
iterator = PyObject_GetIter(data_generator);
if (!iterator) goto cleanup;
int y = 0;
while (y < h) {
int rows;
PyObject * arr = PyIter_Next(iterator);
if (PyErr_Occurred()) goto cleanup;
assert(arr); // iterator should have data
assert(PyArray_ISALIGNED(arr));
assert(PyArray_NDIM(arr) == 3);
assert(PyArray_DIM(arr, 1) == w);
assert(PyArray_DIM(arr, 2) == 4); // rgbu
assert(PyArray_TYPE(arr) == NPY_UINT8);
assert(PyArray_STRIDE(arr, 1) == 4);
assert(PyArray_STRIDE(arr, 2) == 1);
rows = PyArray_DIM(arr, 0);
//.........这里部分代码省略.........
示例4: save_png
static int save_png(SDL_Surface* surface, char *path)
{
int w = surface->w;
int h = surface->h;
unsigned char * pix = (unsigned char *)surface->pixels;
unsigned char writeBuffer[1024 * 3];
FILE *f = fopen(path,"wb");
if(!f) return 0;
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
NULL,
NULL,
NULL);
if(!png_ptr) {
fclose(f);
return 0;
}
png_infop info_ptr = png_create_info_struct(png_ptr);
if(!info_ptr) {
png_destroy_write_struct(&png_ptr,NULL);
fclose(f);
return 0;
}
png_init_io(png_ptr,f);
png_set_IHDR(png_ptr,
info_ptr,
w,
h,
8,
PNG_COLOR_TYPE_RGB,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
png_write_info(png_ptr,info_ptr);
unsigned char *b = writeBuffer;
int sizeX = w;
int sizeY = h;
int y;
int x;
unsigned short *p = (unsigned short *)pix;
for(y = 0; y < sizeY; y++)
{
for(x = 0; x < sizeX; x++)
{
unsigned short v = p[x];
*b++ = ((v & systemRedMask ) >> systemRedShift ) << 3; // R
*b++ = ((v & systemGreenMask) >> systemGreenShift) << 2; // G
*b++ = ((v & systemBlueMask ) >> systemBlueShift ) << 3; // B
}
p += surface->pitch / 2;
png_write_row(png_ptr,writeBuffer);
b = writeBuffer;
}
png_write_end(png_ptr, info_ptr);
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(f);
return 1;
}示例5: WritePng
void WritePng(char *path, struct Image *image)
{
FILE *fp = fopen(path, "wb");
if (fp == NULL)
FATAL_ERROR("Failed to open \"%s\" for writing.\n", path);
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr)
FATAL_ERROR("Failed to create PNG write struct.\n");
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
FATAL_ERROR("Failed to create PNG info struct.\n");
if (setjmp(png_jmpbuf(png_ptr)))
FATAL_ERROR("Failed to init I/O for writing \"%s\".\n", path);
png_init_io(png_ptr, fp);
if (setjmp(png_jmpbuf(png_ptr)))
FATAL_ERROR("Error writing header for \"%s\".\n", path);
int color_type = image->hasPalette ? PNG_COLOR_TYPE_PALETTE : PNG_COLOR_TYPE_GRAY;
png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
image->bitDepth, color_type, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
if (image->hasPalette) {
SetPngPalette(png_ptr, info_ptr, &image->palette);
if (image->hasTransparency) {
png_byte trans = 0;
png_set_tRNS(png_ptr, info_ptr, &trans, 1, 0);
}
}
png_write_info(png_ptr, info_ptr);
png_bytepp row_pointers = malloc(image->height * sizeof(png_bytep));
if (row_pointers == NULL)
FATAL_ERROR("Failed to allocate row pointers.\n");
int rowbytes = png_get_rowbytes(png_ptr, info_ptr);
for (int i = 0; i < image->height; i++)
row_pointers[i] = (png_bytep)(image->pixels + (i * rowbytes));
if (setjmp(png_jmpbuf(png_ptr)))
FATAL_ERROR("Error writing \"%s\".\n", path);
png_write_image(png_ptr, row_pointers);
if (setjmp(png_jmpbuf(png_ptr)))
FATAL_ERROR("Error ending write of \"%s\".\n", path);
png_write_end(png_ptr, NULL);
fclose(fp);
png_destroy_write_struct(&png_ptr, &info_ptr);
free(row_pointers);
}示例6: pixWriteStreamPng
//.........这里部分代码省略.........
for (i = 0; i < ncolors; i++) {
palette[i].red = (png_byte)rmap[i];
palette[i].green = (png_byte)gmap[i];
palette[i].blue = (png_byte)bmap[i];
}
png_set_PLTE(png_ptr, info_ptr, palette, (int)ncolors);
FREE(rmap);
FREE(gmap);
FREE(bmap);
}
/* 0.4545 is treated as the default by some image
* display programs (not gqview). A value > 0.4545 will
* lighten an image as displayed by xv, display, etc. */
if (gamma > 0.0)
png_set_gAMA(png_ptr, info_ptr, (l_float64)gamma);
if ((text = pixGetText(pix))) {
png_text text_chunk;
text_chunk.compression = PNG_TEXT_COMPRESSION_NONE;
text_chunk.key = commentstring;
text_chunk.text = text;
text_chunk.text_length = strlen(text);
#ifdef PNG_ITXT_SUPPORTED
text_chunk.itxt_length = 0;
text_chunk.lang = NULL;
text_chunk.lang_key = NULL;
#endif
png_set_text(png_ptr, info_ptr, &text_chunk, 1);
}
/* Write header and palette info */
png_write_info(png_ptr, info_ptr);
if ((d != 32) && (d != 24)) { /* not rgb color */
/* Generate a temporary pix with bytes swapped.
* For a binary image, there are two conditions in
* which you must first invert the data for writing png:
* (a) no colormap
* (b) colormap with BLACK set to 0
* png writes binary with BLACK = 0, unless contradicted
* by a colormap. If the colormap has BLACK = "1"
* (typ. about 255), do not invert the data. If there
* is no colormap, you must invert the data to store
* in default BLACK = 0 state. */
if (d == 1 &&
(!cmap || (cmap && ((l_uint8 *)(cmap->array))[0] == 0x0))) {
pixt = pixInvert(NULL, pix);
pixEndianByteSwap(pixt);
}
else
pixt = pixEndianByteSwapNew(pix);
if (!pixt) {
png_destroy_write_struct(&png_ptr, &info_ptr);
return ERROR_INT("pixt not made", procName, 1);
}
/* Make and assign array of image row pointers */
if ((row_pointers = (png_bytep *)CALLOC(h, sizeof(png_bytep))) == NULL)
return ERROR_INT("row-pointers not made", procName, 1);
wpl = pixGetWpl(pixt);
data = pixGetData(pixt);
for (i = 0; i < h; i++)
row_pointers[i] = (png_bytep)(data + i * wpl);
png_set_rows(png_ptr, info_ptr, row_pointers);示例7: _lossless_pack_png
static DVector<uint8_t> _lossless_pack_png(const Image& p_image) {
Image img = p_image;
if (img.get_format() > Image::FORMAT_INDEXED_ALPHA)
img.decompress();
ERR_FAIL_COND_V(img.get_format() > Image::FORMAT_INDEXED_ALPHA, DVector<uint8_t>());
png_structp png_ptr;
png_infop info_ptr;
png_bytep * row_pointers;
/* initialize stuff */
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
ERR_FAIL_COND_V(!png_ptr,DVector<uint8_t>());
info_ptr = png_create_info_struct(png_ptr);
ERR_FAIL_COND_V(!info_ptr,DVector<uint8_t>());
if (setjmp(png_jmpbuf(png_ptr))) {
ERR_FAIL_V(DVector<uint8_t>());
}
DVector<uint8_t> ret;
ret.push_back('P');
ret.push_back('N');
ret.push_back('G');
ret.push_back(' ');
png_set_write_fn(png_ptr,&ret,_write_png_data,NULL);
/* write header */
if (setjmp(png_jmpbuf(png_ptr))) {
ERR_FAIL_V(DVector<uint8_t>());
}
int pngf=0;
int pngb=8;
int cs=0;
switch(img.get_format()) {
case Image::FORMAT_GRAYSCALE: {
pngf=PNG_COLOR_TYPE_GRAY;
cs=1;
} break;
case Image::FORMAT_GRAYSCALE_ALPHA: {
pngf=PNG_COLOR_TYPE_GRAY_ALPHA;
cs=2;
} break;
case Image::FORMAT_RGB: {
pngf=PNG_COLOR_TYPE_RGB;
cs=3;
} break;
case Image::FORMAT_RGBA: {
pngf=PNG_COLOR_TYPE_RGB_ALPHA;
cs=4;
} break;
default: {
if (img.detect_alpha()) {
img.convert(Image::FORMAT_RGBA);
pngf=PNG_COLOR_TYPE_RGB_ALPHA;
cs=4;
} else {
img.convert(Image::FORMAT_RGB);
pngf=PNG_COLOR_TYPE_RGB;
cs=3;
}
}
}
int w = img.get_width();
int h = img.get_height();
png_set_IHDR(png_ptr, info_ptr, w,h,
8, pngf, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
png_write_info(png_ptr, info_ptr);
/* write bytes */
if (setjmp(png_jmpbuf(png_ptr))) {
ERR_FAIL_V(DVector<uint8_t>());
}
DVector<uint8_t>::Read r = img.get_data().read();
//.........这里部分代码省略.........
示例8: ico_write_png
static gboolean
ico_write_png (FILE *fp,
gint32 layer,
gint32 depth)
{
png_structp png_ptr;
png_infop info_ptr;
png_byte **row_pointers;
gint i, rowstride;
gint width, height;
gint num_colors_used;
guchar *palette;
guchar *buf;
row_pointers = NULL;
palette = NULL;
buf = NULL;
width = gimp_drawable_width (layer);
height = gimp_drawable_height (layer);
png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if ( !png_ptr )
return FALSE;
info_ptr = png_create_info_struct (png_ptr);
if ( !info_ptr )
{
png_destroy_write_struct (&png_ptr, NULL);
return FALSE;
}
if (setjmp (png_jmpbuf (png_ptr)))
{
png_destroy_write_struct (&png_ptr, &info_ptr);
if ( row_pointers )
g_free (row_pointers);
if (palette)
g_free (palette);
if (buf)
g_free (buf);
return FALSE;
}
ico_image_get_reduced_buf (layer, depth, &num_colors_used,
&palette, &buf);
png_init_io (png_ptr, fp);
png_set_IHDR (png_ptr, info_ptr, width, height,
8,
PNG_COLOR_TYPE_RGBA,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
png_write_info (png_ptr, info_ptr);
rowstride = ico_rowstride (width, 32);
row_pointers = g_new (png_byte*, height);
for (i = 0; i < height; i++)
{
row_pointers[i] = buf + rowstride * i;
}
png_write_image (png_ptr, row_pointers);
row_pointers = NULL;
png_write_end (png_ptr, info_ptr);
png_destroy_write_struct (&png_ptr, &info_ptr);
g_free (row_pointers);
g_free (palette);
g_free (buf);
return TRUE;
}示例9: writepng_init
//.........这里部分代码省略.........
}
interlace_type = mainprog_ptr->interlaced? PNG_INTERLACE_ADAM7 :
PNG_INTERLACE_NONE;
png_set_IHDR(png_ptr, info_ptr, mainprog_ptr->width, mainprog_ptr->height,
mainprog_ptr->sample_depth, color_type, interlace_type,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
if (mainprog_ptr->gamma > 0.0)
png_set_gAMA(png_ptr, info_ptr, mainprog_ptr->gamma);
if (mainprog_ptr->have_bg) { /* we know it's RGBA, not gray+alpha */
png_color_16 background;
background.red = mainprog_ptr->bg_red;
background.green = mainprog_ptr->bg_green;
background.blue = mainprog_ptr->bg_blue;
png_set_bKGD(png_ptr, info_ptr, &background);
}
if (mainprog_ptr->have_time) {
png_time modtime;
png_convert_from_time_t(&modtime, mainprog_ptr->modtime);
png_set_tIME(png_ptr, info_ptr, &modtime);
}
if (mainprog_ptr->have_text) {
png_text text[6];
int num_text = 0;
if (mainprog_ptr->have_text & TEXT_TITLE) {
text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
text[num_text].key = (char*)"Title";
text[num_text].text = mainprog_ptr->title;
++num_text;
}
if (mainprog_ptr->have_text & TEXT_AUTHOR) {
text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
text[num_text].key = (char*)"Author";
text[num_text].text = mainprog_ptr->author;
++num_text;
}
if (mainprog_ptr->have_text & TEXT_DESC) {
text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
text[num_text].key = (char*)"Description";
text[num_text].text = mainprog_ptr->desc;
++num_text;
}
if (mainprog_ptr->have_text & TEXT_COPY) {
text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
text[num_text].key = (char*)"Copyright";
text[num_text].text = mainprog_ptr->copyright;
++num_text;
}
if (mainprog_ptr->have_text & TEXT_EMAIL) {
text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
text[num_text].key = (char*)"E-mail";
text[num_text].text = mainprog_ptr->email;
++num_text;
}
if (mainprog_ptr->have_text & TEXT_URL) {
text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
text[num_text].key = (char*)"URL";
text[num_text].text = mainprog_ptr->url;
++num_text;
}
png_set_text(png_ptr, info_ptr, text, num_text);
}
/* write all chunks up to (but not including) first IDAT */
png_write_info(png_ptr, info_ptr);
/* if we wanted to write any more text info *after* the image data, we
* would set up text struct(s) here and call png_set_text() again, with
* just the new data; png_set_tIME() could also go here, but it would
* have no effect since we already called it above (only one tIME chunk
* allowed) */
/* set up the transformations: for now, just pack low-bit-depth pixels
* into bytes (one, two or four pixels per byte) */
png_set_packing(png_ptr);
/* png_set_shift(png_ptr, &sig_bit); to scale low-bit-depth values */
/* make sure we save our pointers for use in writepng_encode_image() */
mainprog_ptr->png_ptr = png_ptr;
mainprog_ptr->info_ptr = info_ptr;
/* OK, that's all we need to do for now; return happy */
return 0;
}示例10: MIN
bool PngEncoder::write( const Mat& img, const vector<int>& params )
{
int compression_level = 0;
for( size_t i = 0; i < params.size(); i += 2 )
{
if( params[i] == CV_IMWRITE_PNG_COMPRESSION )
{
compression_level = params[i+1];
compression_level = MIN(MAX(compression_level, 0), MAX_MEM_LEVEL);
}
}
png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 );
png_infop info_ptr = 0;
FILE* f = 0;
int y, width = img.cols, height = img.rows;
int depth = img.depth(), channels = img.channels();
bool result = false;
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, f );
}
if( m_buf || f )
{
if( compression_level > 0 )
{
png_set_compression_mem_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, Z_HUFFMAN_ONLY);
png_set_IHDR( png_ptr, info_ptr, width, height, depth == CV_8U ? 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 );
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;
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( f );
return result;
}示例11: png_create_read_struct
//-----------------------------------------------------------------------------
bool abiword_document::garble_png( void*& data, size_t& size ) {
png_bytep * dib;
png_uint_32 width;
png_uint_32 height;
int compression_type;
int filter_type;
int interlace_type;
int bit_depth;
int color_type;
png_uint_32 rowbytes;
// read PNG data
{
png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, (void*) NULL, NULL, NULL );
if (!png_ptr)
return false;
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct( &png_ptr, (png_infopp)NULL, (png_infopp)NULL );
return false;
}
png_read_data _png_read_data = { data, size, 0 };
png_set_read_fn( png_ptr, (void*)&_png_read_data, &_png_read );
png_read_info( png_ptr, info_ptr );
png_get_IHDR( png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_type );
png_set_packing( png_ptr );
png_set_expand( png_ptr );
png_set_strip_16( png_ptr );
png_set_gray_to_rgb( png_ptr );
png_set_strip_alpha( png_ptr );
png_set_interlace_handling( png_ptr );
png_set_bgr( png_ptr );
rowbytes = png_get_rowbytes(png_ptr, info_ptr);
png_destroy_read_struct( &png_ptr, &info_ptr, NULL );
}
// we don't care about the image data itself, we just want a random garbled
// image of the same size
dib = (png_bytep*) malloc( sizeof(png_bytep) * height );
for (size_t i=0; i<height; ++i) {
dib[i] = (png_byte*) malloc( rowbytes );
garble_image_line( reinterpret_cast<char*>( dib[i] ), rowbytes );
}
bool result = false;
{
// write it back
png_structp png_ptrw = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL );
if (png_ptrw)
{
png_infop info_ptrw = png_create_info_struct( png_ptrw );
png_set_IHDR( png_ptrw, info_ptrw, width, height, bit_depth, color_type, interlace_type, compression_type, filter_type );
string newdata;
png_set_write_fn( png_ptrw, (void*)&newdata, &_png_write, NULL );
png_write_info( png_ptrw, info_ptrw );
png_write_image( png_ptrw, dib );
png_write_end( png_ptrw, NULL );
png_destroy_write_struct( &png_ptrw, NULL );
free(data);
size = newdata.size();
data = malloc( size );
memcpy( data, &newdata[0], size );
result = true;
}
}
// cleanup
for (size_t i=0; i<height; i++)
free( dib[i] );
free( dib );
return result;
}示例12: png_create
/**
* Write PNG image data
* @param buffer Image data
* @param filename A filename of the PNG image to save
* @param width Image width in pixels
* @param height Image height in pixels
* @param depth The bit depth of the image.
* Valid values shall include 1, 2, 4, 8, 16.
* @return TRUE if it completed successfully or FALSE otherwise
*/
static bool
png_create (char *buffer, const char *filename, Uint32 width, Uint32 height,
Sint32 depth)
{
Uint32 i;
FILE *out;
LOG_DBG ("Write %s", filename);
if (buffer == NULL)
{
LOG_ERR ("image_to_buffer() failed! (filename = %s)", filename);
return FALSE;
}
out = fopen_data (filename, "w");
if (out == NULL)
{
LOG_ERR ("can't open \"%s\"", filename);
return FALSE;
}
/* allocate and initialize png_ptr struct for writing */
png_structp png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING,
/* error_ptr */
(png_voidp) NULL,
/* error_fn */
NULL,
/* warn_fn */
NULL);
if (png_ptr == NULL)
{
LOG_ERR ("png_create_write_struct() failed");
return FALSE;
}
/* allocate and initialize the info structure */
png_infop info_ptr = png_create_info_struct (png_ptr);
if (png_ptr == NULL)
{
LOG_ERR ("png_create_info_struct() failed");
return FALSE;
}
/* initialize input/output for PNG file to the default functions */
png_init_io (png_ptr, out);
/* set library compression level */
png_set_IHDR (png_ptr, info_ptr,
/* width */
width,
/* height */
height,
/* bit depth */
depth,
PNG_COLOR_TYPE_RGB_ALPHA,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_set_compression_level (png_ptr, Z_BEST_COMPRESSION);
png_set_text (png_ptr, info_ptr, text, sizeof text / sizeof text[0]);
png_color_16 background;
background.red = 0;
background.green = 0;
background.blue = 0;
png_set_bKGD (png_ptr, info_ptr, &background);
png_write_info (png_ptr, info_ptr);
for (i = 0; i < height; i++)
{
{
png_write_row (png_ptr, (png_byte *) & buffer[i * width * 4]);
}
}
png_write_end (png_ptr, info_ptr);
png_destroy_write_struct (&png_ptr, &info_ptr);
fclose (out);
return TRUE;
}示例13: writeBmpBuffToPng
int writeBmpBuffToPng(const char *fileName, unsigned char *bmpBuff, unsigned int bmpWidth, unsigned int bmpHeight, int upSideDown)
{
int ERROR = 0;
int OK = 1;
FILE *fp = NULL;
png_structp png_ptr;
png_infop info_ptr;
fp = fopen(fileName, "wb");
if (fp == NULL) {
DEBUG_LOG("error in open %s\n", fileName);
return (ERROR);
}
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
fclose(fp);
DEBUG_LOG("error in png_create_write_struct \n");
return (ERROR);
}
info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL) {
fclose(fp);
png_destroy_write_struct(&png_ptr, NULL);
DEBUG_LOG("error png_create_info_struct \n");
return (ERROR);
}
/* Set error handling. REQUIRED if you aren't supplying your own
* error handling functions in the png_create_write_struct() call.
*/
if (setjmp(png_jmpbuf(png_ptr))) {
/* If we get here, we had a problem writing the file */
fclose(fp);
png_destroy_write_struct(&png_ptr, &info_ptr);
DEBUG_LOG("error png_create_info_struct \n");
return (ERROR);
}
png_init_io(png_ptr, fp);
/* This is the easy way. Use it if you already have all the
* image info living in the structure. You could "|" many
* PNG_TRANSFORM flags into the png_transforms integer here.
*/
// png_write_png(png_ptr, info_ptr, png_transforms, NULL);
png_set_IHDR(png_ptr, info_ptr, bmpWidth, bmpHeight, 8, PNG_COLOR_TYPE_RGBA,
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
png_write_info(png_ptr, info_ptr);
/* Flip BGR pixels to RGB */
// png_set_bgr(png_ptr);
{
/* Set up pointers into your "image" byte array */
png_bytep *row_pointers = (png_bytep *)malloc(bmpHeight * sizeof(png_byte));
if (upSideDown) {
unsigned int k = 0;
for (; k < bmpHeight; k++) {
row_pointers[k] = bmpBuff + (bmpHeight - 1 - k) * bmpWidth * 4;
}
}
else {
unsigned int k = 0;
for (; k < bmpHeight; k++) {
row_pointers[k] = bmpBuff + k * bmpWidth * 4;
}
}
png_write_image(png_ptr, row_pointers);
free(row_pointers);
}
/* Similarly, if you png_malloced any data that you passed in with
* png_set_something(), such as a hist or trans array, free it here,
* when you can be sure that libpng is through with it.
*/
// png_free(png_ptr, trans);
// trans = NULL;
/* Clean up after the write, and free any memory allocated */
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(fp);
return (OK);
}示例14: png_save
static void png_save(BPGDecoderContext *img, const char *filename, int bit_depth)
{
BPGImageInfo img_info_s, *img_info = &img_info_s;
FILE *f;
png_structp png_ptr;
png_infop info_ptr;
png_bytep row_pointer;
int y, color_type, bpp;
BPGDecoderOutputFormat out_fmt;
if (bit_depth != 8 && bit_depth != 16) {
fprintf(stderr, "Only bit_depth = 8 or 16 are supported for PNG output\n");
exit(1);
}
bpg_decoder_get_info(img, img_info);
f = fopen(filename, "wb");
if (!f) {
fprintf(stderr, "%s: I/O error\n", filename);
exit(1);
}
png_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING,
NULL,
NULL, /* error */
NULL, /* warning */
NULL,
NULL,
NULL);
info_ptr = png_create_info_struct(png_ptr);
png_set_write_fn(png_ptr, (png_voidp)f, &png_write_data, NULL);
if (setjmp(png_jmpbuf(png_ptr)) != 0) {
fprintf(stderr, "PNG write error\n");
exit(1);
}
if (img_info->has_alpha)
color_type = PNG_COLOR_TYPE_RGB_ALPHA;
else
color_type = PNG_COLOR_TYPE_RGB;
png_set_IHDR(png_ptr, info_ptr, img_info->width, img_info->height,
bit_depth, color_type, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_write_info(png_ptr, info_ptr);
#if __BYTE_ORDER__ != __ORDER_BIG_ENDIAN__
if (bit_depth == 16) {
png_set_swap(png_ptr);
}
#endif
if (bit_depth == 16) {
if (img_info->has_alpha)
out_fmt = BPG_OUTPUT_FORMAT_RGBA64;
else
out_fmt = BPG_OUTPUT_FORMAT_RGB48;
} else {
if (img_info->has_alpha)
out_fmt = BPG_OUTPUT_FORMAT_RGBA32;
else
out_fmt = BPG_OUTPUT_FORMAT_RGB24;
}
bpg_decoder_start(img, out_fmt);
bpp = (3 + img_info->has_alpha) * (bit_depth / 8);
row_pointer = (png_bytep)png_malloc(png_ptr, img_info->width * bpp);
for (y = 0; y < img_info->height; y++) {
bpg_decoder_get_line(img, row_pointer);
png_write_row(png_ptr, row_pointer);
}
png_free(png_ptr, row_pointer);
png_write_end(png_ptr, NULL);
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(f);
}示例15: icns_image_to_png
int icns_image_to_png(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
{
int width = 0;
int height = 0;
int image_channels = 0;
int image_pixel_depth = 0;
int mask_channels = 0;
png_structp png_ptr;
png_infop info_ptr;
png_bytep *row_pointers;
int i, j;
if(image == NULL)
{
icns_print_err("icns_image_to_png: Image is NULL!\n");
return ICNS_STATUS_NULL_PARAM;
}
if(dataSizeOut == NULL)
{
icns_print_err("icns_image_to_png: Data size NULL!\n");
return ICNS_STATUS_NULL_PARAM;
}
if(dataPtrOut == NULL)
{
icns_print_err("icns_image_to_png: Data ref is NULL!\n");
return ICNS_STATUS_NULL_PARAM;
}
if (image->pngFilename) {
FILE *fp = fopen(image->pngFilename, "rb");
if (fp) {
fseek(fp, 0, SEEK_END);
*dataSizeOut = ftell(fp);
fseek(fp, 0, SEEK_SET);
*dataPtrOut = malloc(*dataSizeOut);
if (fread(*dataPtrOut, 1, *dataSizeOut, fp)) {
return ICNS_STATUS_OK;
}
}
}
#ifdef ICNS_DEBUG
printf("Encoding PNG image...\n");
#endif
width = image->imageWidth;
height = image->imageHeight;
image_channels = image->imageChannels;
image_pixel_depth = image->imagePixelDepth;
png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL)
{
fprintf (stderr, "PNG error: cannot allocate libpng main struct\n");
return ICNS_STATUS_NO_MEMORY;
}
info_ptr = png_create_info_struct (png_ptr);
if (info_ptr == NULL)
{
fprintf (stderr, "PNG error: cannot allocate libpng info struct\n");
png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
return ICNS_STATUS_NO_MEMORY;
}
icns_png_io_ref io_data = { NULL, 0, 0 };
png_set_write_fn(png_ptr, (void *)&io_data, &icns_png_write_memory, NULL);
png_set_filter(png_ptr, 0, PNG_FILTER_NONE);
png_set_IHDR (png_ptr, info_ptr, width, height, image_pixel_depth, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_write_info (png_ptr, info_ptr);
if(image_pixel_depth < 8)
png_set_packing (png_ptr);
row_pointers = (png_bytep*)malloc(sizeof(png_bytep)*height);
if (row_pointers == NULL)
{
fprintf (stderr, "PNG error: unable to allocate row_pointers\n");
}
else
{
for (i = 0; i < height; i++)
{
if ((row_pointers[i] = (png_bytep)malloc(width*image_channels)) == NULL)
{
fprintf (stderr, "PNG error: unable to allocate rows\n");
for (j = 0; j < i; j++)
free(row_pointers[j]);
free(row_pointers);
return ICNS_STATUS_NO_MEMORY;
}
//.........这里部分代码省略.........