int
Image::write_png(char *file) const
{
if (_width == 0 || _height == 0 || _data == 0) {
fprintf(stderr,"Image::write_png: image has no data");
return 0;
} else if (_bpp < 1 || _bpp > 4) {
fprintf(stderr,"Image::write_png: unsupported number of bytes/pixel (%d)",
_bpp);
return 0;
}
FILE* fp;
if ((fp = fopen(file, "wb")) == 0) {
fprintf(stderr,"Image::write_png: can't open file %s", file);
return 0;
}
// Create and initialize the png_struct with the desired error handler
// functions. If you want to use the default stderr and longjump method,
// you can supply NULL for the last three parameters. We also check that
// the library version is compatible with the one used at compile time,
// in case we are using dynamically linked libraries. REQUIRED.
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,0,0,0);
if (!png_ptr) {
fclose(fp);
fprintf(stderr,"Image::write_png: png_create_write_struct() failed");
return 0;
}
// Allocate/initialize the image information data. REQUIRED
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
fclose(fp);
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
fprintf(stderr,"Image::write_png: png_create_info_struct() failed");
return 0;
}
// Set error handling
if (setjmp(png_ptr->jmpbuf)) {
// jump here from error encountered inside PNG code...
// free all memory associated with the png_ptr and info_ptr
fclose(fp);
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
fprintf(stderr,"Image::write_png: error writing file %s", file);
return 0;
}
// Set up the input control (using standard C streams)
//
// see note re: C streams in read_png() above
//
png_init_io(png_ptr, fp);
// set the image information:
png_set_IHDR(png_ptr,
info_ptr,
_width,
_height,
8, // bit depth
((_bpp==4) ? PNG_COLOR_TYPE_RGB_ALPHA :
(_bpp==3) ? PNG_COLOR_TYPE_RGB :
(_bpp==2) ? PNG_COLOR_TYPE_GRAY_ALPHA :
PNG_COLOR_TYPE_GRAY),
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE,
PNG_FILTER_TYPE_BASE);
// set gamma
double gamma = getenv("JOT_GAMMA") ? atof(getenv("JOT_GAMMA")) : 0.45;
png_set_gAMA(png_ptr, info_ptr, gamma);
// write the file header information. REQUIRED
png_write_info(png_ptr, info_ptr);
// write the image data (inverted vertically):
for (int y=_height-1; y>=0; y--)
png_write_row(png_ptr, row(y));
// It is REQUIRED to call this to finish writing
png_write_end(png_ptr, info_ptr);
// clean up after the write, and free any memory allocated
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
// close the file
fclose(fp);
return 1;
}
/*!
* pixWriteStreamPng()
*
* Input: stream
* pix
* gamma (use 0.0 if gamma is not defined)
* Return: 0 if OK; 1 on error
*
* Notes:
* (1) If called from pixWriteStream(), the stream is positioned
* at the beginning of the file.
* (2) To do sequential writes of png format images to a stream,
* use pixWriteStreamPng() directly.
* (3) gamma is an optional png chunk. If no gamma value is to be
* placed into the file, use gamma = 0.0. Otherwise, if
* gamma > 0.0, its value is written into the header.
* (4) The use of gamma in png is highly problematic. For an illuminating
* discussion, see: http://hsivonen.iki.fi/png-gamma/
* (5) What is the effect/meaning of gamma in the png file? This
* gamma, which we can call the 'source' gamma, is the
* inverse of the gamma that was used in enhance.c to brighten
* or darken images. The 'source' gamma is supposed to indicate
* the intensity mapping that was done at the time the
* image was captured. Display programs typically apply a
* 'display' gamma of 2.2 to the output, which is intended
* to linearize the intensity based on the response of
* thermionic tubes (CRTs). Flat panel LCDs have typically
* been designed to give a similar response as CRTs (call it
* "backward compatibility"). The 'display' gamma is
* in some sense the inverse of the 'source' gamma.
* jpeg encoders attached to scanners and cameras will lighten
* the pixels, applying a gamma corresponding to approximately
* a square-root relation of output vs input:
* output = input^(gamma)
* where gamma is often set near 0.4545 (1/gamma is 2.2).
* This is stored in the image file. Then if the display
* program reads the gamma, it will apply a display gamma,
* typically about 2.2; the product is 1.0, and the
* display program produces a linear output. This works because
* the dark colors were appropriately boosted by the scanner,
* as described by the 'source' gamma, so they should not
* be further boosted by the display program.
* (6) As an example, with xv and display, if no gamma is stored,
* the program acts as if gamma were 0.4545, multiplies this by 2.2,
* and does a linear rendering. Taking this as a baseline
* brightness, if the stored gamma is:
* > 0.4545, the image is rendered lighter than baseline
* < 0.4545, the image is rendered darker than baseline
* In contrast, gqview seems to ignore the gamma chunk in png.
* (7) The only valid pixel depths in leptonica are 1, 2, 4, 8, 16
* and 32. However, it is possible, and in some cases desirable,
* to write out a png file using an rgb pix that has 24 bpp.
* For example, the open source xpdf SplashBitmap class generates
* 24 bpp rgb images. Consequently, we anble writing 24 bpp pix.
* To generate such a pix, you can make a 24 bpp pix without data
* and assign the data array to the pix; e.g.,
* pix = pixCreateHeader(w, h, 24);
* pixSetData(pix, rgbdata);
* See pixConvert32To24() for an example, where we get rgbdata
* from the 32 bpp pix. Caution: do not call pixSetPadBits(),
* because the alignment is wrong and you may erase part of the
* last pixel on each line.
*/
l_int32
pixWriteStreamPng(FILE *fp,
PIX *pix,
l_float32 gamma)
{
char commentstring[] = "Comment";
l_int32 i, j, k;
l_int32 wpl, d, cmflag;
l_int32 ncolors;
l_int32 *rmap, *gmap, *bmap;
l_uint32 *data, *ppixel;
png_byte bit_depth, color_type;
png_uint_32 w, h;
png_uint_32 xres, yres;
png_bytep *row_pointers;
png_bytep rowbuffer;
png_structp png_ptr;
png_infop info_ptr;
png_colorp palette;
PIX *pixt;
PIXCMAP *cmap;
char *text;
PROCNAME("pixWriteStreamPng");
if (!fp)
return ERROR_INT("stream not open", procName, 1);
if (!pix)
return ERROR_INT("pix not defined", procName, 1);
/* Allocate the 2 data structures */
if ((png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
(png_voidp)NULL, NULL, NULL)) == NULL)
return ERROR_INT("png_ptr not made", procName, 1);
if ((info_ptr = png_create_info_struct(png_ptr)) == NULL) {
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return ERROR_INT("info_ptr not made", procName, 1);
}
/* Set up png setjmp error handling */
if (setjmp(png_jmpbuf(png_ptr))) {
png_destroy_write_struct(&png_ptr, &info_ptr);
return ERROR_INT("internal png error", procName, 1);
}
png_init_io(png_ptr, fp);
/* With best zlib compression (9), get between 1 and 10% improvement
* over default (5), but the compression is 3 to 10 times slower.
* Our default compression is the zlib default (5). */
png_set_compression_level(png_ptr, var_ZLIB_COMPRESSION);
w = pixGetWidth(pix);
h = pixGetHeight(pix);
d = pixGetDepth(pix);
if ((cmap = pixGetColormap(pix)))
cmflag = 1;
else
cmflag = 0;
/* Set the color type and bit depth. */
if (d == 32 && var_PNG_WRITE_ALPHA == 1) {
bit_depth = 8;
color_type = PNG_COLOR_TYPE_RGBA; /* 6 */
cmflag = 0; /* ignore if it exists */
}
else if (d == 24 || d == 32) {
bit_depth = 8;
color_type = PNG_COLOR_TYPE_RGB; /* 2 */
cmflag = 0; /* ignore if it exists */
}
else {
bit_depth = d;
color_type = PNG_COLOR_TYPE_GRAY; /* 0 */
}
if (cmflag)
color_type = PNG_COLOR_TYPE_PALETTE; /* 3 */
#if DEBUG
fprintf(stderr, "cmflag = %d, bit_depth = %d, color_type = %d\n",
cmflag, bit_depth, color_type);
#endif /* DEBUG */
png_set_IHDR(png_ptr, info_ptr, w, h, bit_depth, color_type,
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,
PNG_FILTER_TYPE_BASE);
/* Store resolution in ppm, if known */
xres = (png_uint_32)(39.37 * (l_float32)pixGetXRes(pix) + 0.5);
yres = (png_uint_32)(39.37 * (l_float32)pixGetYRes(pix) + 0.5);
if ((xres == 0) || (yres == 0))
png_set_pHYs(png_ptr, info_ptr, 0, 0, PNG_RESOLUTION_UNKNOWN);
else
png_set_pHYs(png_ptr, info_ptr, xres, yres, PNG_RESOLUTION_METER);
if (cmflag) {
pixcmapToArrays(cmap, &rmap, &gmap, &bmap);
ncolors = pixcmapGetCount(cmap);
/* Make and save the palette */
if ((palette = (png_colorp)(CALLOC(ncolors, sizeof(png_color))))
== NULL)
return ERROR_INT("palette not made", procName, 1);
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);
/* Transfer the data */
png_write_image(png_ptr, row_pointers);
png_write_end(png_ptr, info_ptr);
if (cmflag)
FREE(palette);
FREE(row_pointers);
pixDestroy(&pixt);
png_destroy_write_struct(&png_ptr, &info_ptr);
return 0;
}
/* For rgb, compose and write a row at a time */
data = pixGetData(pix);
wpl = pixGetWpl(pix);
if (d == 24) { /* See note 7 above: special case of 24 bpp rgb */
for (i = 0; i < h; i++) {
ppixel = data + i * wpl;
png_write_rows(png_ptr, (png_bytepp)&ppixel, 1);
}
}
else { /* 32 bpp rgb and rgba */
if ((rowbuffer = (png_bytep)CALLOC(w, 4)) == NULL)
return ERROR_INT("rowbuffer not made", procName, 1);
for (i = 0; i < h; i++) {
ppixel = data + i * wpl;
for (j = k = 0; j < w; j++) {
rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_RED);
rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_GREEN);
rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_BLUE);
if (var_PNG_WRITE_ALPHA == 1)
rowbuffer[k++] = GET_DATA_BYTE(ppixel, L_ALPHA_CHANNEL);
ppixel++;
}
png_write_rows(png_ptr, &rowbuffer, 1);
}
FREE(rowbuffer);
}
png_write_end(png_ptr, info_ptr);
if (cmflag)
FREE(palette);
png_destroy_write_struct(&png_ptr, &info_ptr);
return 0;
}
void PNGAPI
png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
int intent)
{
#if defined(PNG_gAMA_SUPPORTED)
#ifdef PNG_FLOATING_POINT_SUPPORTED
float file_gamma;
#endif
#ifdef PNG_FIXED_POINT_SUPPORTED
png_fixed_point int_file_gamma;
#endif
#endif
#if defined(PNG_cHRM_SUPPORTED)
#ifdef PNG_FLOATING_POINT_SUPPORTED
float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
#endif
#ifdef PNG_FIXED_POINT_SUPPORTED
png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
int_green_y, int_blue_x, int_blue_y;
#endif
#endif
png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM");
if (png_ptr == NULL || info_ptr == NULL)
return;
png_set_sRGB(png_ptr, info_ptr, intent);
#if defined(PNG_gAMA_SUPPORTED)
#ifdef PNG_FLOATING_POINT_SUPPORTED
file_gamma = (float).45455;
png_set_gAMA(png_ptr, info_ptr, file_gamma);
#endif
#ifdef PNG_FIXED_POINT_SUPPORTED
int_file_gamma = 45455L;
png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);
#endif
#endif
#if defined(PNG_cHRM_SUPPORTED)
#ifdef PNG_FIXED_POINT_SUPPORTED
int_white_x = 31270L;
int_white_y = 32900L;
int_red_x = 64000L;
int_red_y = 33000L;
int_green_x = 30000L;
int_green_y = 60000L;
int_blue_x = 15000L;
int_blue_y = 6000L;
png_set_cHRM_fixed(png_ptr, info_ptr,
int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y,
int_blue_x, int_blue_y);
#endif
#ifdef PNG_FLOATING_POINT_SUPPORTED
white_x = (float).3127;
white_y = (float).3290;
red_x = (float).64;
red_y = (float).33;
green_x = (float).30;
green_y = (float).60;
blue_x = (float).15;
blue_y = (float).06;
png_set_cHRM(png_ptr, info_ptr,
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
#endif
#endif
}
/* returns 0 for success, 2 for libpng problem, 4 for out of memory, 11 for
* unexpected pnmtype; note that outfile might be stdout */
int writepng_init(mainprog_info *mainprog_ptr)
{
/* This has been altered
png_structp png_ptr;*/ /* note: temporary variables! */
png_infop info_ptr;
int color_type, interlace_type;
/* could also replace libpng warning-handler (final NULL), but no need: */
/* This was altered
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
writepng_error_handler, NULL); */
if (!png_ptr)
return 4; /* out of memory */
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, NULL);
return 4; /* out of memory */
}
/* setjmp() must be called in every function that calls a PNG-writing
* libpng function, unless an alternate error handler was installed--
* but compatible error handlers must either use longjmp() themselves
* (as in this program) or exit immediately, so here we go: */
if (setjmp(mainprog_ptr->jmpbuf)) {
png_destroy_write_struct(&png_ptr, &info_ptr);
return 2;
}
/* make sure outfile is (re)opened in BINARY mode */
/* This was altered
png_init_io(png_ptr, mainprog_ptr->outfile); */
/* set the compression levels--in general, always want to leave filtering
* turned on (except for palette images) and allow all of the filters,
* which is the default; want 32K zlib window, unless entire image buffer
* is 16K or smaller (unknown here)--also the default; usually want max
* compression (NOT the default); and remaining compression flags should
* be left alone */
png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
/*
>> this is default for no filtering; Z_FILTERED is default otherwise:
png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
>> these are all defaults:
png_set_compression_mem_level(png_ptr, 8);
png_set_compression_window_bits(png_ptr, 15);
png_set_compression_method(png_ptr, 8);
*/
/* set the image parameters appropriately */
if (mainprog_ptr->pnmtype == 5)
color_type = PNG_COLOR_TYPE_GRAY;
else if (mainprog_ptr->pnmtype == 6)
color_type = PNG_COLOR_TYPE_RGB;
else if (mainprog_ptr->pnmtype == 8)
color_type = PNG_COLOR_TYPE_RGB_ALPHA;
else {
png_destroy_write_struct(&png_ptr, &info_ptr);
return 11;
}
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 = "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 = "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 = "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 = "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 = "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 = "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;
}
bool MCImageEncodePNG(MCImageBitmap *p_bitmap, IO_handle p_stream, uindex_t &r_bytes_written)
{
bool t_success = true;
MCPNGWriteContext t_context;
t_context.stream = p_stream;
t_context.byte_count = 0;
png_structp t_png_ptr = nil;
png_infop t_info_ptr = nil;
png_color *t_png_palette = nil;
png_byte *t_png_transparency = nil;
png_bytep t_data_ptr = nil;
uindex_t t_stride = 0;
MCImageIndexedBitmap *t_indexed = nil;
if (MCImageConvertBitmapToIndexed(p_bitmap, false, t_indexed))
{
t_success = MCImageEncodePNG(t_indexed, p_stream, r_bytes_written);
MCImageFreeIndexedBitmap(t_indexed);
return t_success;
}
/*init png stuff*/
if (t_success)
{
t_success = nil != (t_png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
(png_voidp)NULL, (png_error_ptr)NULL,
(png_error_ptr)NULL));
}
if (t_success)
t_success = nil != (t_info_ptr = png_create_info_struct(t_png_ptr));
/*in case of png error*/
if (setjmp(png_jmpbuf(t_png_ptr)))
t_success = false;
if (t_success)
png_set_write_fn(t_png_ptr,(png_voidp)&t_context,fakewrite,fakeflush);
bool t_fully_opaque = true;
if (t_success)
{
t_fully_opaque = !MCImageBitmapHasTransparency(p_bitmap);
png_set_IHDR(t_png_ptr, t_info_ptr, p_bitmap->width, p_bitmap->height, 8,
t_fully_opaque ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_set_gAMA(t_png_ptr, t_info_ptr, 1/MCgamma);
}
if (t_success)
{
png_write_info(t_png_ptr, t_info_ptr);
//32 bit compensate for byte swapped systems
if (t_fully_opaque)
png_set_filler(t_png_ptr, 0, MCswapbytes ? PNG_FILLER_AFTER : PNG_FILLER_BEFORE);
if (MCswapbytes)
png_set_bgr(t_png_ptr);
else
png_set_swap_alpha(t_png_ptr);
}
if (t_success)
{
t_data_ptr = (png_bytep)p_bitmap->data;
t_stride = p_bitmap->stride;
}
if (t_success)
{
for (uindex_t i = 0; i < p_bitmap->height; i++)
{
png_write_row(t_png_ptr, t_data_ptr);
t_data_ptr += t_stride;
}
}
if (t_success)
png_write_end(t_png_ptr, t_info_ptr);
if (t_png_ptr != nil)
png_destroy_write_struct(&t_png_ptr, &t_info_ptr);
if (t_png_palette != nil)
MCMemoryDeleteArray(t_png_palette);
if (t_png_transparency != nil)
MCMemoryDeallocate(t_png_transparency);
if (t_success)
r_bytes_written = t_context.byte_count;
return t_success;
}
bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image, volatile int quality_in, const QString &description,
int off_x_in, int off_y_in)
{
QPoint offset = image.offset();
int off_x = off_x_in + offset.x();
int off_y = off_y_in + offset.y();
png_structp png_ptr;
png_infop info_ptr;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,0,0,0);
if (!png_ptr) {
return false;
}
png_set_error_fn(png_ptr, 0, 0, qt_png_warning);
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, 0);
return false;
}
if (setjmp(png_jmpbuf(png_ptr))) {
png_destroy_write_struct(&png_ptr, &info_ptr);
return false;
}
int quality = quality_in;
if (quality >= 0) {
if (quality > 9) {
qWarning("PNG: Quality %d out of range", quality);
quality = 9;
}
png_set_compression_level(png_ptr, quality);
}
png_set_write_fn(png_ptr, (void*)this, qpiw_write_fn, qpiw_flush_fn);
int color_type = 0;
if (image.colorCount()) {
if (image.isGrayscale())
color_type = PNG_COLOR_TYPE_GRAY;
else
color_type = PNG_COLOR_TYPE_PALETTE;
}
else if (image.format() == QImage::Format_Grayscale8)
color_type = PNG_COLOR_TYPE_GRAY;
else if (image.hasAlphaChannel())
color_type = PNG_COLOR_TYPE_RGB_ALPHA;
else
color_type = PNG_COLOR_TYPE_RGB;
png_set_IHDR(png_ptr, info_ptr, image.width(), image.height(),
image.depth() == 1 ? 1 : 8, // per channel
color_type, 0, 0, 0); // sets #channels
if (gamma != 0.0) {
png_set_gAMA(png_ptr, info_ptr, 1.0/gamma);
}
if (image.format() == QImage::Format_MonoLSB)
png_set_packswap(png_ptr);
if (color_type == PNG_COLOR_TYPE_PALETTE) {
// Paletted
int num_palette = qMin(256, image.colorCount());
png_color palette[256];
png_byte trans[256];
int num_trans = 0;
for (int i=0; i<num_palette; i++) {
QRgb rgba=image.color(i);
palette[i].red = qRed(rgba);
palette[i].green = qGreen(rgba);
palette[i].blue = qBlue(rgba);
trans[i] = qAlpha(rgba);
if (trans[i] < 255) {
num_trans = i+1;
}
}
png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
if (num_trans) {
png_set_tRNS(png_ptr, info_ptr, trans, num_trans, 0);
}
}
// Swap ARGB to RGBA (normal PNG format) before saving on
// BigEndian machines
if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
png_set_swap_alpha(png_ptr);
}
// Qt==ARGB==Big(ARGB)==Little(BGRA). But RGB888 is RGB regardless
if (QSysInfo::ByteOrder == QSysInfo::LittleEndian
&& image.format() != QImage::Format_RGB888) {
png_set_bgr(png_ptr);
}
if (off_x || off_y) {
png_set_oFFs(png_ptr, info_ptr, off_x, off_y, PNG_OFFSET_PIXEL);
}
if (frames_written > 0)
png_set_sig_bytes(png_ptr, 8);
if (image.dotsPerMeterX() > 0 || image.dotsPerMeterY() > 0) {
png_set_pHYs(png_ptr, info_ptr,
image.dotsPerMeterX(), image.dotsPerMeterY(),
PNG_RESOLUTION_METER);
}
set_text(image, png_ptr, info_ptr, description);
png_write_info(png_ptr, info_ptr);
if (image.depth() != 1)
png_set_packing(png_ptr);
if (color_type == PNG_COLOR_TYPE_RGB && image.format() != QImage::Format_RGB888)
png_set_filler(png_ptr, 0,
QSysInfo::ByteOrder == QSysInfo::BigEndian ?
PNG_FILLER_BEFORE : PNG_FILLER_AFTER);
if (looping >= 0 && frames_written == 0) {
uchar data[13] = "NETSCAPE2.0";
// 0123456789aBC
data[0xB] = looping%0x100;
data[0xC] = looping/0x100;
png_write_chunk(png_ptr, const_cast<png_bytep>((const png_byte *)"gIFx"), data, 13);
}
if (ms_delay >= 0 || disposal!=Unspecified) {
uchar data[4];
data[0] = disposal;
data[1] = 0;
data[2] = (ms_delay/10)/0x100; // hundredths
data[3] = (ms_delay/10)%0x100;
png_write_chunk(png_ptr, const_cast<png_bytep>((const png_byte *)"gIFg"), data, 4);
}
int height = image.height();
int width = image.width();
switch (image.format()) {
case QImage::Format_Mono:
case QImage::Format_MonoLSB:
case QImage::Format_Indexed8:
case QImage::Format_Grayscale8:
case QImage::Format_RGB32:
case QImage::Format_ARGB32:
case QImage::Format_RGB888:
{
png_bytep* row_pointers = new png_bytep[height];
for (int y=0; y<height; y++)
row_pointers[y] = const_cast<png_bytep>(image.constScanLine(y));
png_write_image(png_ptr, row_pointers);
delete [] row_pointers;
}
break;
default:
{
QImage::Format fmt = image.hasAlphaChannel() ? QImage::Format_ARGB32 : QImage::Format_RGB32;
QImage row;
png_bytep row_pointers[1];
for (int y=0; y<height; y++) {
row = image.copy(0, y, width, 1).convertToFormat(fmt);
row_pointers[0] = const_cast<png_bytep>(row.constScanLine(0));
png_write_rows(png_ptr, row_pointers, 1);
}
}
break;
}
png_write_end(png_ptr, info_ptr);
frames_written++;
png_destroy_write_struct(&png_ptr, &info_ptr);
return true;
}
void PNGImageDecoder::headerAvailable()
{
png_structp png = reader()->pngPtr();
png_infop info = reader()->infoPtr();
png_uint_32 width = png->width;
png_uint_32 height = png->height;
// Protect against large images.
if (png->width > cMaxPNGSize || png->height > cMaxPNGSize) {
m_failed = true;
longjmp(png->jmpbuf, 1);
return;
}
// We can fill in the size now that the header is available.
if (!m_sizeAvailable) {
m_sizeAvailable = true;
m_size = IntSize(width, height);
}
int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType,
&interlaceType, &compressionType, &filterType);
// The options we set here match what Mozilla does.
// Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
if (colorType == PNG_COLOR_TYPE_PALETTE ||
(colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
png_set_expand(png);
png_bytep trns = 0;
int trnsCount = 0;
if (png_get_valid(png, info, PNG_INFO_tRNS)) {
png_get_tRNS(png, info, &trns, &trnsCount, 0);
png_set_expand(png);
}
if (bitDepth == 16)
png_set_strip_16(png);
if (colorType == PNG_COLOR_TYPE_GRAY ||
colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb(png);
// Deal with gamma and keep it under our control.
double gamma;
if (png_get_gAMA(png, info, &gamma)) {
if ((gamma <= 0.0) || (gamma > cMaxGamma)) {
gamma = cInverseGamma;
png_set_gAMA(png, info, gamma);
}
png_set_gamma(png, cDefaultGamma, gamma);
}
else
png_set_gamma(png, cDefaultGamma, cInverseGamma);
// Tell libpng to send us rows for interlaced pngs.
if (interlaceType == PNG_INTERLACE_ADAM7)
png_set_interlace_handling(png);
// Update our info now
png_read_update_info(png, info);
channels = png_get_channels(png, info);
assert(channels == 3 || channels == 4);
reader()->setHasAlpha(channels == 4);
if (reader()->decodingSizeOnly()) {
// If we only needed the size, halt the reader.
reader()->setReadOffset(m_data->size() - png->buffer_size);
png->buffer_size = 0;
}
}
bool FPMWritePNGCustom(FloatPixMapRef srcPM, png_voidp ioPtr, png_rw_ptr writeDataFn, png_flush_ptr flushDataFn, FPMWritePNGFlags options, FPMGammaFactor sourceGamma, FPMGammaFactor fileGamma, FPMPNGErrorHandler errorHandler)
{
if (srcPM != NULL)
{
bool success = false;
png_structp png = NULL;
png_infop pngInfo = NULL;
FloatPixMapRef pm = NULL;
// Prepare data.
FPMDimension width = FPMGetWidth(srcPM);
FPMDimension height = FPMGetHeight(srcPM);
if (width > UINT32_MAX || height > UINT32_MAX)
{
if (errorHandler != NULL) errorHandler("image is too large for PNG format.", true);
return false;
}
pm = FPMCopy(srcPM);
if (pm == NULL) return false;
unsigned steps = (options & kFPMWritePNG16BPC) ? 0x10000 : 0x100;
FPMApplyGamma(pm, sourceGamma, fileGamma, steps);
FPMQuantize(pm, 0.0f, 1.0f, 0.0f, steps - 1, steps, (options & kFPMQuantizeDither & kFPMQuantizeJitter) | kFMPQuantizeClip | kFMPQuantizeAlpha);
png = png_create_write_struct(PNG_LIBPNG_VER_STRING, errorHandler, PNGError, PNGWarning);
if (png == NULL) goto FAIL;
pngInfo = png_create_info_struct(png);
if (pngInfo == NULL) goto FAIL;
if (setjmp(png_jmpbuf(png)))
{
// libpng will jump here on error.
goto FAIL;
}
png_set_write_fn(png, ioPtr, writeDataFn, flushDataFn);
png_set_IHDR(png, pngInfo, width, height, (options & kFPMWritePNG16BPC) ? 16 : 8,PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
if (fileGamma == kFPMGammaSRGB)
{
png_set_sRGB_gAMA_and_cHRM(png, pngInfo, PNG_sRGB_INTENT_PERCEPTUAL);
}
else
{
png_set_gAMA(png, pngInfo, fileGamma);
}
/* Select function used to transform a row of data to PNG-friendly
format. NOTE: these work in place,and overwrite the data in pm,
which is OK since we copied it.
*/
RowTransformer transformer = NULL;
if (options & kFPMWritePNG16BPC)
{
transformer = TransformRow16;
}
else
{
transformer = TransformRow8;
}
png_write_info(png, pngInfo);
size_t i;
size_t rowOffset = FPMGetRowByteCount(pm);
png_bytep row = (png_bytep)FPMGetBufferPointer(pm);
for (i = 0; i < height; i++)
{
transformer(row, width);
png_write_row(png, row);
row += rowOffset;
}
png_write_end(png, pngInfo);
success = true;
FAIL:
if (png != NULL) png_destroy_write_struct(&png, &pngInfo);
FPMRelease(&pm);
return success;
}
else
{
return false;
}
}
bool Image::save (const std::string &s)
{
// Open the file
std::ofstream outfile;
outfile.open(s.c_str(), std::ifstream::out | std::ifstream::binary);
png_structp png_ptr;
png_infop info_ptr;
// Create and initialize the png_struct with the desired error handler
// functions. If you want to use the default stderr and longjump method,
// you can supply NULL for the last three parameters. We also check that
// the library version is compatible with the one used at compile time,
// in case we are using dynamically linked libraries. REQUIRED.
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
return false;
}
// Allocate/initialize the image information data.
info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL) {
::png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return false;
}
// 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 reading the file
png_destroy_write_struct(&png_ptr, &info_ptr);
return false;
}
// Set custom write routine
png_set_write_fn(png_ptr, &outfile, &png_write_data, &png_flush_data);
// 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
png_set_IHDR(png_ptr, info_ptr, _window_width, _window_height, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
// We are dealing with a color image then
png_color_8 sig_bit;
sig_bit.red = 8;
sig_bit.green = 8;
sig_bit.blue = 8;
sig_bit.alpha = 8;
png_set_sBIT(png_ptr, info_ptr, &sig_bit);
// Optional gamma chunk is strongly suggested if you have any guess
// as to the correct gamma of the image.
//
png_set_gAMA(png_ptr, info_ptr, 0.0);
// Write the file header information.
png_write_info(png_ptr, info_ptr);
// Shift the pixels up to a legal bit depth and fill in
// as appropriate to correctly scale the image.
png_set_shift(png_ptr, &sig_bit);
// pack pixels into bytes
png_set_packing(png_ptr);
// swap location of alpha bytes from ARGB to RGBA
//png_set_swap_alpha(png_ptr);
// Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
// RGB (4 channels -> 3 channels). The second parameter is not used.
//png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
// flip BGR pixels to RGB
//png_set_bgr(png_ptr);
// swap bytes of 16-bit files to most significant byte first
//png_set_swap(png_ptr);
// swap bits of 1, 2, 4 bit packed pixel formats
//png_set_packswap(png_ptr);
// The easiest way to write the image (you may have a different memory
// layout, however, so choose what fits your needs best). You need to
// use the first method if you aren't handling interlacing yourself.
// Setup row pointers
png_bytep *row_pointers = new png_bytep[_window_height];
for (png_uint_32 k = 0; k < _window_height; k++)
row_pointers[k] = (png_bytep) &getPixel(0,k);
png_write_image(png_ptr, row_pointers);
delete row_pointers;
// It is REQUIRED to call this to finish writing the rest of the file
png_write_end(png_ptr, info_ptr);
// 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, NULL);
// clean up after the write, and free any memory allocated
png_destroy_write_struct(&png_ptr, &info_ptr);
return false;
}
int main( int argc, char *argv[] ) {
int f, rowbytes;
char buf[256];
static FILE *fpout; /* "static" prevents setjmp corruption */
png_structp write_ptr;
png_infop write_info_ptr, end_info_ptr;
png_bytep row_buf, here;
png_uint_32 y;
png_textp text_ptr, new_text_ptr;
int num_text;
int interlace_type, compression_type, filter_type, bit_depth, color_type;
int it, ct, ft, bd, clrt;
png_uint_32 width, height, w, h;
int duration;
if( argc < 4 ) {
printf( "makeanim v0.2\nusage: makeanim <duration in milliseconds> <input files ...> <output file>\n" );
printf( "example: makeanim 1500 a00.png a01.png a02.png a03.png a04.png a.anim\n" );
return 1;
}
duration = atoi( argv[1] );
if( duration < 1 ) {
printf( "duration is incorrect\n" );
return 1;
}
numfiles = argc - 3;
input = (struct inputstruct *)malloc( sizeof( struct inputstruct ) * numfiles );
if( !input ) return 1;
for( f = 0; f < numfiles; f++ ) {
input[f].name = argv[f + 2];
printf( "opening file %d, \"%s\"\n", f, input[f].name );
/* open the file handle */
input[f].file = fopen( input[f].name, "rb" );
if( input[f].file == NULL ) {
printf( "fopen() failed\n" );
return 1;
}
/* check if it's PNG */
if( fread( buf, 1, 8, input[f].file ) != 8 ) {
printf( "fread() failed for file \"%s\"\n", input[f].name );
return 1;
}
if( png_sig_cmp( buf, (png_size_t)0, 8 ) ) {
printf( "not a PNG file\n" );
return 1;
}
fseek( input[f].file, 0, SEEK_SET );
/* allocate read structure */
input[f].read_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL );
if( input[f].read_ptr == NULL ) {
printf( "png_create_read_struct() failed\n" );
return 1;
}
/* allocate read info structure */
input[f].read_info_ptr = png_create_info_struct( input[f].read_ptr );
if( input[f].read_info_ptr == NULL ) {
printf( "png_create_info_struct() failed\n" );
return 1;
}
/* set error handler code */
if( setjmp( input[f].read_ptr->jmpbuf ) ) {
printf( "libpng read error\n" );
return 1;
}
/* initialize stream */
png_init_io( input[f].read_ptr, input[f].file );
png_set_read_status_fn( input[f].read_ptr, NULL );
/* read png info struct */
png_read_info( input[f].read_ptr, input[f].read_info_ptr );
/* get the info */
if( !png_get_IHDR( input[f].read_ptr, input[f].read_info_ptr, &w, &h, &bd, &clrt, &it, &ct, &ft ) ) {
printf( "png_get_IHDR() failed\n" );
return 1;
}
/* save the info of the first frame */
if( f == 0 ) {
width = w;
height = h;
bit_depth = bd;
color_type = clrt;
interlace_type = it;
compression_type = ct;
filter_type = ft;
}
/* compare all other frames to first frame */
else if( (w != width) ||
(h != height) ||
(bd != bit_depth) ||
(clrt != color_type) ||
(it != interlace_type) ||
(ct != compression_type) ||
(ft != filter_type) ) {
if( w != width ) printf( "width is different\n" );
if( h != height ) printf( "height is different\n" );
if( bd != bit_depth ) printf( "bit depth is different\n" );
if( clrt != color_type ) printf( "color type is different\n" );
if( it != interlace_type ) printf( "interlace type is different\n" );
if( ct != compression_type ) printf( "compression type is different\n" );
if( ft != filter_type ) printf( "filter type is different\n" );
return 1;
}
}
row_buf = (png_bytep)NULL;
/* open output file */
printf( "opening file \"%s\"\n", argv[numfiles + 2] );
fpout = fopen( argv[numfiles + 2], "wb" );
if( fpout == NULL ) {
printf( "fopen() failed\n" );
return 1;
}
/* allocate write structure */
write_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL );
/* allocate info structures */
write_info_ptr = png_create_info_struct( write_ptr );
end_info_ptr = png_create_info_struct( write_ptr );
/* error handling */
if( setjmp( write_ptr->jmpbuf ) ) {
printf( "libpng write error\n" );
return 1;
}
/* initialize output stream */
png_init_io( write_ptr, fpout );
png_set_write_status_fn( write_ptr, NULL );
/* set info */
png_set_IHDR( write_ptr, write_info_ptr, width * numfiles, height, bit_depth, color_type, PNG_INTERLACE_NONE, compression_type, filter_type);
/* image characteristics */
{
png_color_16p background;
double white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
double gamma;
int intent;
png_uint_16p hist;
png_uint_32 offset_x, offset_y;
int unit_type;
png_charp purpose, units;
png_charpp params;
png_int_32 X0, X1;
int type, nparams;
png_uint_32 res_x, res_y;
png_colorp palette;
int num_palette;
png_color_8p sig_bit;
png_bytep trans;
int num_trans;
png_color_16p trans_values;
/* background color */
if( png_get_bKGD( input[0].read_ptr, input[0].read_info_ptr, &background ) ) {
png_set_bKGD( write_ptr, write_info_ptr, background );
}
if( png_get_cHRM( input[0].read_ptr, input[0].read_info_ptr, &white_x, &white_y, &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y ) ) {
png_set_cHRM( write_ptr, write_info_ptr, white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y );
}
/* gamma */
if( png_get_gAMA( input[0].read_ptr, input[0].read_info_ptr, &gamma ) ) {
png_set_gAMA( write_ptr, write_info_ptr, gamma );
}
/* rendering intent */
if( png_get_sRGB( input[0].read_ptr, input[0].read_info_ptr, &intent ) ) {
png_set_sRGB( write_ptr, write_info_ptr, intent );
}
/* Histogram */
if( png_get_hIST( input[0].read_ptr, input[0].read_info_ptr, &hist ) ) {
png_set_hIST( write_ptr, write_info_ptr, hist );
}
/* offsets */
if( png_get_oFFs( input[0].read_ptr, input[0].read_info_ptr, &offset_x, &offset_y, &unit_type ) ) {
png_set_oFFs( write_ptr, write_info_ptr, offset_x, offset_y, unit_type );
}
if( png_get_pCAL( input[0].read_ptr, input[0].read_info_ptr, &purpose, &X0, &X1, &type, &nparams, &units, ¶ms ) ) {
png_set_pCAL( write_ptr, write_info_ptr, purpose, X0, X1, type, nparams, units, params );
}
/* pixel density */
if( png_get_pHYs( input[0].read_ptr, input[0].read_info_ptr, &res_x, &res_y, &unit_type ) ) {
png_set_pHYs( write_ptr, write_info_ptr, res_x, res_y, unit_type );
}
/* text chunks */
/* if( png_get_text( input[0].read_ptr, input[0].read_info_ptr, &text_ptr, &num_text ) > 0 ) {
printf( "Handling %d tEXt/zTXt chunks\n", num_text );
png_set_text( write_ptr, write_info_ptr, text_ptr, num_text );
}
*/
/* palette */
if( png_get_PLTE( input[0].read_ptr, input[0].read_info_ptr, &palette, &num_palette ) ) {
png_set_PLTE( write_ptr, write_info_ptr, palette, num_palette );
}
/* significant bits */
if( png_get_sBIT( input[0].read_ptr, input[0].read_info_ptr, &sig_bit ) ) {
png_set_sBIT( write_ptr, write_info_ptr, sig_bit );
}
/* transparency */
if( png_get_tRNS( input[0].read_ptr, input[0].read_info_ptr, &trans, &num_trans, &trans_values ) ) {
png_set_tRNS( write_ptr, write_info_ptr, trans, num_trans, trans_values );
}
}
/* text chunks */
num_text = 0;
if( !png_get_text( input[0].read_ptr, input[0].read_info_ptr, &text_ptr, &num_text ) ) num_text = 0;
new_text_ptr = (struct png_text_struct *)malloc( sizeof( struct png_text_struct ) * num_text + 1 );
if( !new_text_ptr ) {
printf( "malloc() failed\n" );
return 1;
}
memcpy( new_text_ptr, text_ptr, sizeof( struct png_text_struct ) * num_text );
snprintf( buf, 255, "SDL_anim %d %d %d", duration, width, numfiles );
buf[255] = 0;
new_text_ptr[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
new_text_ptr[num_text].key = "format";
new_text_ptr[num_text].text = buf;
new_text_ptr[num_text].text_length = strlen( buf );
num_text++;
png_set_text( write_ptr, write_info_ptr, new_text_ptr, num_text );
/* write info */
png_write_info( write_ptr, write_info_ptr );
/* allocate buffer */
rowbytes = png_get_rowbytes( input[0].read_ptr, input[0].read_info_ptr );
row_buf = (png_bytep)png_malloc( write_ptr, rowbytes * numfiles );
if( row_buf == NULL ) {
printf( "png_malloc() failed\n" );
return 1;
}
/* copy raw data */
for( y = 0; y < height; y++ ) {
/* grab a scanline from each file */
here = row_buf;
for( f = 0; f < numfiles; f++ ) {
png_read_rows( input[f].read_ptr, (png_bytepp)&here, (png_bytepp)NULL, 1 );
here += rowbytes;
}
/* write the long scanline */
png_write_rows( write_ptr, (png_bytepp)&row_buf, 1 );
}
/* end io */
for( f = 0; f < numfiles; f++ ) png_read_end( input[f].read_ptr, end_info_ptr );
png_write_end( write_ptr, end_info_ptr );
/* cleanup */
png_free( write_ptr, row_buf );
for( f = 0; f < numfiles; f++ ) {
png_destroy_read_struct( &input[f].read_ptr, &input[f].read_info_ptr, &end_info_ptr);
fclose( input[f].file );
}
png_destroy_write_struct( &write_ptr, &write_info_ptr );
fclose( fpout );
return 0;
}
bool writePng(const Bitmap &image, FILE *fp) {
png_structp png_ptr;
png_infop info_ptr;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
fclose(fp);
return false;
}
/* Allocate/initialize the image information data. REQUIRED */
info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL) {
fclose(fp);
png_destroy_write_struct(&png_ptr, NULL);
return false;
}
/* 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);
return false;
}
/* Set up the output control if you are using standard C streams */
png_init_io(png_ptr, fp);
png_set_IHDR(png_ptr, info_ptr, image.width(), image.height(),
1, PNG_COLOR_TYPE_GRAY, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
/* Optional gamma chunk is strongly suggested if you have any guess
* as to the correct gamma of the image.
*/
png_set_gAMA(png_ptr, info_ptr, 1.0);
png_set_pHYs(png_ptr, info_ptr, image.xRes(), image.yRes(), image.resUnit());
/* Write the file header information. REQUIRED */
png_write_info(png_ptr, info_ptr);
int width_bytes = (image.width() + 7) >> 3;
png_bytep row = new png_byte[width_bytes];
for (int y = 0; y < image.height(); y++) {
for (int x = 0; x < image.width(); x += 8) {
uint8_t b = 0;
uint8_t mask = 0x80;
for (int xx = x; xx < x+8 && xx < image.width(); xx++) {
if (image.get(xx, y)) {
b |= mask;
}
mask >>= 1;
}
row[x >> 3] = ~b;
}
png_write_rows(png_ptr, &row, 1);
}
delete [] row;
/* It is REQUIRED to call this to finish writing the rest of the file */
png_write_end(png_ptr, info_ptr);
/* Clean up after the write, and free any memory allocated */
png_destroy_write_struct(&png_ptr, &info_ptr);
/* Close the file */
fclose(fp);
return true;
}
pngquant_error rwpng_write_image_init(FILE *outfile, write_info *mainprog_ptr)
{
png_structp png_ptr; /* note: temporary variables! */
png_infop info_ptr;
/* could also replace libpng warning-handler (final NULL), but no need: */
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
rwpng_error_handler, NULL);
if (!png_ptr) {
return INIT_OUT_OF_MEMORY_ERROR; /* out of memory */
}
mainprog_ptr->png_ptr = png_ptr;
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, NULL);
return INIT_OUT_OF_MEMORY_ERROR; /* out of memory */
}
/* setjmp() must be called in every function that calls a PNG-writing
* libpng function, unless an alternate error handler was installed--
* but compatible error handlers must either use longjmp() themselves
* (as in this program) or exit immediately, so here we go: */
if (setjmp(mainprog_ptr->jmpbuf)) {
png_destroy_write_struct(&png_ptr, &info_ptr);
return LIBPNG_INIT_ERROR; /* libpng error (via longjmp()) */
}
/* make sure outfile is (re)opened in BINARY mode */
png_init_io(png_ptr, outfile);
png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
// Palette images generally don't gain anything from filtering
png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, PNG_FILTER_VALUE_NONE);
/* set the image parameters appropriately */
int sample_depth;
if (mainprog_ptr->num_palette <= 2)
sample_depth = 1;
else if (mainprog_ptr->num_palette <= 4)
sample_depth = 2;
else if (mainprog_ptr->num_palette <= 16)
sample_depth = 4;
else
sample_depth = 8;
png_set_IHDR(png_ptr, info_ptr, mainprog_ptr->width, mainprog_ptr->height,
sample_depth, PNG_COLOR_TYPE_PALETTE,
mainprog_ptr->interlaced, PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_BASE);
/* GRR WARNING: cast of rwpng_colorp to png_colorp could fail in future
* major revisions of libpng (but png_ptr/info_ptr will fail, regardless) */
png_set_PLTE(png_ptr, info_ptr, &mainprog_ptr->palette[0], mainprog_ptr->num_palette);
if (mainprog_ptr->num_trans > 0)
png_set_tRNS(png_ptr, info_ptr, mainprog_ptr->trans, mainprog_ptr->num_trans, NULL);
if (mainprog_ptr->gamma > 0.0)
png_set_gAMA(png_ptr, info_ptr, mainprog_ptr->gamma);
/* 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);
/* 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 SUCCESS;
}
void PNGImageDecoder::headerAvailable()
{
png_structp png = m_reader->pngPtr();
png_infop info = m_reader->infoPtr();
png_uint_32 width = png->width;
png_uint_32 height = png->height;
// Protect against large images.
if (png->width > cMaxPNGSize || png->height > cMaxPNGSize) {
longjmp(JMPBUF(png), 1);
return;
}
// We can fill in the size now that the header is available. Avoid memory
// corruption issues by neutering setFailed() during this call; if we don't
// do this, failures will cause |m_reader| to be deleted, and our jmpbuf
// will cease to exist. Note that we'll still properly set the failure flag
// in this case as soon as we longjmp().
m_doNothingOnFailure = true;
bool result = setSize(width, height);
m_doNothingOnFailure = false;
if (!result) {
longjmp(JMPBUF(png), 1);
return;
}
int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceType, &compressionType, &filterType);
// The options we set here match what Mozilla does.
// Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
if (colorType == PNG_COLOR_TYPE_PALETTE || (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
png_set_expand(png);
png_bytep trns = 0;
int trnsCount = 0;
if (png_get_valid(png, info, PNG_INFO_tRNS)) {
png_get_tRNS(png, info, &trns, &trnsCount, 0);
png_set_expand(png);
}
if (bitDepth == 16)
png_set_strip_16(png);
if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb(png);
// Deal with gamma and keep it under our control.
double gamma;
if (png_get_gAMA(png, info, &gamma)) {
if ((gamma <= 0.0) || (gamma > cMaxGamma)) {
gamma = cInverseGamma;
png_set_gAMA(png, info, gamma);
}
png_set_gamma(png, cDefaultGamma, gamma);
} else
png_set_gamma(png, cDefaultGamma, cInverseGamma);
// Tell libpng to send us rows for interlaced pngs.
if (interlaceType == PNG_INTERLACE_ADAM7)
png_set_interlace_handling(png);
// Update our info now.
png_read_update_info(png, info);
channels = png_get_channels(png, info);
ASSERT(channels == 3 || channels == 4);
m_reader->setHasAlpha(channels == 4);
if (m_reader->decodingSizeOnly()) {
// If we only needed the size, halt the reader.
m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
png->buffer_size = 0;
}
}
void write_header( const View& view )
{
using png_rw_info_t = detail::png_write_support
<
typename channel_type<typename get_pixel_type<View>::type>::type,
typename color_space_type<View>::type
>;
// 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
png_set_IHDR( get_struct()
, get_info()
, static_cast< png_image_width::type >( view.width() )
, static_cast< png_image_height::type >( view.height() )
, static_cast< png_bitdepth::type >( png_rw_info_t::_bit_depth )
, static_cast< png_color_type::type >( png_rw_info_t::_color_type )
, _info._interlace_method
, _info._compression_type
, _info._filter_method
);
#ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
if( _info._valid_cie_colors )
{
png_set_cHRM( get_struct()
, get_info()
, _info._white_x
, _info._white_y
, _info._red_x
, _info._red_y
, _info._green_x
, _info._green_y
, _info._blue_x
, _info._blue_y
);
}
if( _info._valid_file_gamma )
{
png_set_gAMA( get_struct()
, get_info()
, _info._file_gamma
);
}
#else
if( _info._valid_cie_colors )
{
png_set_cHRM_fixed( get_struct()
, get_info()
, _info._white_x
, _info._white_y
, _info._red_x
, _info._red_y
, _info._green_x
, _info._green_y
, _info._blue_x
, _info._blue_y
);
}
if( _info._valid_file_gamma )
{
png_set_gAMA_fixed( get_struct()
, get_info()
, _info._file_gamma
);
}
#endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
if( _info._valid_icc_profile )
{
#if PNG_LIBPNG_VER_MINOR >= 5
png_set_iCCP( get_struct()
, get_info()
, const_cast< png_charp >( _info._icc_name.c_str() )
, _info._iccp_compression_type
, reinterpret_cast< png_const_bytep >( & (_info._profile.front ()) )
, _info._profile_length
);
#else
png_set_iCCP( get_struct()
, get_info()
, const_cast< png_charp >( _info._icc_name.c_str() )
, _info._iccp_compression_type
, const_cast< png_charp >( & (_info._profile.front()) )
, _info._profile_length
);
#endif
}
if( _info._valid_intent )
{
png_set_sRGB( get_struct()
, get_info()
, _info._intent
);
}
if( _info._valid_palette )
{
png_set_PLTE( get_struct()
, get_info()
, const_cast< png_colorp >( &_info._palette.front() )
, _info._num_palette
);
}
if( _info._valid_background )
{
png_set_bKGD( get_struct()
, get_info()
, const_cast< png_color_16p >( &_info._background )
);
}
if( _info._valid_histogram )
{
png_set_hIST( get_struct()
, get_info()
, const_cast< png_uint_16p >( &_info._histogram.front() )
);
}
if( _info._valid_offset )
{
png_set_oFFs( get_struct()
, get_info()
, _info._offset_x
, _info._offset_y
, _info._off_unit_type
);
}
if( _info._valid_pixel_calibration )
{
std::vector< const char* > params( _info._num_params );
for( std::size_t i = 0; i < params.size(); ++i )
{
params[i] = _info._params[ i ].c_str();
}
png_set_pCAL( get_struct()
, get_info()
, const_cast< png_charp >( _info._purpose.c_str() )
, _info._X0
, _info._X1
, _info._cal_type
, _info._num_params
, const_cast< png_charp >( _info._units.c_str() )
, const_cast< png_charpp >( ¶ms.front() )
);
}
if( _info._valid_resolution )
{
png_set_pHYs( get_struct()
, get_info()
, _info._res_x
, _info._res_y
, _info._phy_unit_type
);
}
if( _info._valid_significant_bits )
{
png_set_sBIT( get_struct()
, get_info()
, const_cast< png_color_8p >( &_info._sig_bits )
);
}
#ifndef BOOST_GIL_IO_PNG_1_4_OR_LOWER
#ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
if( _info._valid_scale_factors )
{
png_set_sCAL( get_struct()
, get_info()
, this->_info._scale_unit
, this->_info._scale_width
, this->_info._scale_height
);
}
#else
#ifdef BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED
if( _info._valid_scale_factors )
{
png_set_sCAL_fixed( get_struct()
, get_info()
, this->_info._scale_unit
, this->_info._scale_width
, this->_info._scale_height
);
}
#else
if( _info._valid_scale_factors )
{
png_set_sCAL_s( get_struct()
, get_info()
, this->_info._scale_unit
, const_cast< png_charp >( this->_info._scale_width.c_str() )
, const_cast< png_charp >( this->_info._scale_height.c_str() )
);
}
#endif // BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED
#endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
#endif // BOOST_GIL_IO_PNG_1_4_OR_LOWER
if( _info._valid_text )
{
std::vector< png_text > texts( _info._num_text );
for( std::size_t i = 0; i < texts.size(); ++i )
{
png_text pt;
pt.compression = _info._text[i]._compression;
pt.key = const_cast< png_charp >( this->_info._text[i]._key.c_str() );
pt.text = const_cast< png_charp >( this->_info._text[i]._text.c_str() );
pt.text_length = _info._text[i]._text.length();
texts[i] = pt;
}
png_set_text( get_struct()
, get_info()
, &texts.front()
, _info._num_text
);
}
if( _info._valid_modification_time )
{
png_set_tIME( get_struct()
, get_info()
, const_cast< png_timep >( &_info._mod_time )
);
}
if( _info._valid_transparency_factors )
{
int sample_max = ( 1u << _info._bit_depth );
/* libpng doesn't reject a tRNS chunk with out-of-range samples */
if( !( ( _info._color_type == PNG_COLOR_TYPE_GRAY
&& (int) _info._trans_values[0].gray > sample_max
)
|| ( _info._color_type == PNG_COLOR_TYPE_RGB
&&( (int) _info._trans_values[0].red > sample_max
|| (int) _info._trans_values[0].green > sample_max
|| (int) _info._trans_values[0].blue > sample_max
)
)
)
)
{
//@todo Fix that once reading transparency values works
/*
png_set_tRNS( get_struct()
, get_info()
, trans
, num_trans
, trans_values
);
*/
}
}
// Compression Levels - valid values are [0,9]
png_set_compression_level( get_struct()
, _info._compression_level
);
png_set_compression_mem_level( get_struct()
, _info._compression_mem_level
);
png_set_compression_strategy( get_struct()
, _info._compression_strategy
);
png_set_compression_window_bits( get_struct()
, _info._compression_window_bits
);
png_set_compression_method( get_struct()
, _info._compression_method
);
png_set_compression_buffer_size( get_struct()
, _info._compression_buffer_size
);
#ifdef BOOST_GIL_IO_PNG_DITHERING_SUPPORTED
// Dithering
if( _info._set_dithering )
{
png_set_dither( get_struct()
, &_info._dithering_palette.front()
, _info._dithering_num_palette
, _info._dithering_maximum_colors
, &_info._dithering_histogram.front()
, _info._full_dither
);
}
#endif // BOOST_GIL_IO_PNG_DITHERING_SUPPORTED
// Filter
if( _info._set_filter )
{
png_set_filter( get_struct()
, 0
, _info._filter
);
}
// Invert Mono
if( _info._invert_mono )
{
png_set_invert_mono( get_struct() );
}
// True Bits
if( _info._set_true_bits )
{
png_set_sBIT( get_struct()
, get_info()
, &_info._true_bits.front()
);
}
// sRGB Intent
if( _info._set_srgb_intent )
{
png_set_sRGB( get_struct()
, get_info()
, _info._srgb_intent
);
}
// Strip Alpha
if( _info._strip_alpha )
{
png_set_strip_alpha( get_struct() );
}
// Swap Alpha
if( _info._swap_alpha )
{
png_set_swap_alpha( get_struct() );
}
png_write_info( get_struct()
, get_info()
);
}
bool PNGImageFileType::write(const Image *OSG_PNG_ARG(pImage ),
std::ostream &OSG_PNG_ARG(os ),
const std::string &OSG_PNG_ARG(mimetype))
{
#ifdef OSG_WITH_PNG
png_structp png_ptr;
png_infop info_ptr;
if(pImage->getDimension() < 1 || pImage->getDimension() > 2)
{
FWARNING(("PNGImageFileType::write: invalid dimension %d!\n",
pImage->getDimension()));
return false;
}
/* Create and initialize the png_struct with the desired error handler
* functions. If you want to use the default stderr and longjump method,
* you can supply NULL for the last three parameters. We also check that
* the library version is compatible with the one used at compile time,
* in case we are using dynamically linked libraries. REQUIRED.
*/
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
0, &errorOutput, &warningOutput);
if(png_ptr == NULL)
return false;
/* Allocate/initialize the image information data. REQUIRED */
info_ptr = png_create_info_struct(png_ptr);
if(info_ptr == NULL)
{
png_destroy_write_struct(&png_ptr, NULL);
return false;
}
/* set up the output handlers */
png_set_write_fn(png_ptr, &os, &osWriteFunc, &osFlushFunc);
/* This is the hard way */
/* 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
*/
Int32 ctype;
switch(pImage->getPixelFormat())
{
case Image::OSG_L_PF:
ctype = PNG_COLOR_TYPE_GRAY;
break;
case Image::OSG_LA_PF:
ctype = PNG_COLOR_TYPE_GRAY_ALPHA;
break;
#if defined(GL_BGR) || defined(GL_BGR_EXT)
case Image::OSG_BGR_PF:
#endif
case Image::OSG_RGB_PF:
ctype = PNG_COLOR_TYPE_RGB;
break;
#if defined(GL_BGRA) || defined(GL_BGRA_EXT)
case Image::OSG_BGRA_PF:
#endif
case Image::OSG_RGBA_PF:
ctype = PNG_COLOR_TYPE_RGB_ALPHA;
break;
default:
FWARNING(("PNGImageFileType::write: unknown pixel format %d!\n",
pImage->getPixelFormat()));
png_destroy_write_struct(&png_ptr, NULL);
return false;
}
Int32 bit_depth;
switch(pImage->getDataType())
{
case Image::OSG_UINT8_IMAGEDATA:
bit_depth = 8;
break;
case Image::OSG_UINT16_IMAGEDATA:
bit_depth = 16;
break;
default:
FWARNING (("Invalid pixeldepth, cannot store data\n"));
return false;
};
png_set_IHDR(png_ptr, info_ptr, pImage->getWidth(), pImage->getHeight(),
bit_depth,ctype,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE,
PNG_FILTER_TYPE_BASE);
// set resolution png supports only meter per pixel,
// so we do a conversion from dpi with some rounding.
png_uint_32 res_x = png_uint_32(pImage->getResX());
png_uint_32 res_y = png_uint_32(pImage->getResY());
if(pImage->getResUnit() == Image::OSG_RESUNIT_INCH)
{
res_x = png_uint_32((pImage->getResX() * 39.37007874f) < 0.0f ?
(pImage->getResX() * 39.37007874f) - 0.5f :
(pImage->getResX() * 39.37007874f) + 0.5f);
res_y = png_uint_32((pImage->getResY() * 39.37007874f) < 0.0f ?
(pImage->getResY() * 39.37007874f) - 0.5f :
(pImage->getResY() * 39.37007874f) + 0.5f);
}
png_set_pHYs(png_ptr, info_ptr, res_x, res_y,
PNG_RESOLUTION_METER);
#if 0
/* optional significant bit chunk */
/* if we are dealing with a grayscale image then */
sig_bit.gray = true_bit_depth;
/* otherwise, if we are dealing with a color image then */
sig_bit.red = true_red_bit_depth;
sig_bit.green = true_green_bit_depth;
sig_bit.blue = true_blue_bit_depth;
/* if the image has an alpha channel then */
sig_bit.alpha = true_alpha_bit_depth;
png_set_sBIT(png_ptr, info_ptr, sig_bit);
/* Optional gamma chunk is strongly suggested if you have any guess
* as to the correct gamma of the image.
*/
png_set_gAMA(png_ptr, info_ptr, gamma);
/* Optionally write comments into the image */
text_ptr[0].key = "Title";
text_ptr[0].text = "Mona Lisa";
text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
text_ptr[1].key = "Author";
text_ptr[1].text = "Leonardo DaVinci";
text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;
text_ptr[2].key = "Description";
text_ptr[2].text = "<long text>";
text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt;
#ifdef PNG_iTXt_SUPPORTED
text_ptr[0].lang = NULL;
text_ptr[1].lang = NULL;
text_ptr[2].lang = NULL;
#endif
png_set_text(png_ptr, info_ptr, text_ptr, 3);
#endif
/* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */
/* note that if sRGB is present the gAMA and cHRM chunks must be ignored
* on read and must be written in accordance with the sRGB profile */
/* Write the file header information. REQUIRED */
png_write_info(png_ptr, info_ptr);
#if BYTE_ORDER == LITTLE_ENDIAN
if (bit_depth == 16)
png_set_swap(png_ptr);
#endif
#if 0
/* invert monochrome pixels */
png_set_invert_mono(png_ptr);
/* Shift the pixels up to a legal bit depth and fill in
* as appropriate to correctly scale the image.
*/
png_set_shift(png_ptr, &sig_bit);
/* pack pixels into bytes */
png_set_packing(png_ptr);
/* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
* RGB (4 channels -> 3 channels). The second parameter is not used.
*/
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
/* swap bytes of 16-bit files to most significant byte first */
png_set_swap(png_ptr);
/* swap bits of 1, 2, 4 bit packed pixel formats */
png_set_packswap(png_ptr);
#endif
if(pImage->getPixelFormat() == Image::OSG_BGR_PF ||
pImage->getPixelFormat() == Image::OSG_BGRA_PF )
{
/* flip BGR pixels to RGB */
png_set_bgr(png_ptr);
/* swap location of alpha bytes from ARGB to RGBA */
png_set_swap_alpha(png_ptr);
}
/* The easiest way to write the image (you may have a different memory
* layout, however, so choose what fits your needs best). You need to
* use the first method if you aren't handling interlacing yourself.
*/
png_bytep *row_pointers = new png_bytep [pImage->getHeight()];
for(Int32 k = 0; k < pImage->getHeight(); k++)
{
row_pointers[k] =
(const_cast<UInt8 *>(pImage->getData())) +
(pImage->getHeight() - 1 - k) *
pImage->getWidth() * pImage->getBpp();
}
/* write out the entire image data in one call */
png_write_image(png_ptr, row_pointers);
/* It is REQUIRED to call this to finish writing the rest of the file */
png_write_end(png_ptr, info_ptr);
/* clean up after the write, and free any memory allocated */
png_destroy_write_struct(&png_ptr, &info_ptr);
delete [] row_pointers;
/* that's it */
return true;
#else
SWARNING << getMimeType()
<< " write is not compiled into the current binary "
<< endLog;
return false;
#endif
}
void PNGImageDecoder::headerAvailable()
{
png_structp png = m_reader->pngPtr();
png_infop info = m_reader->infoPtr();
png_uint_32 width = png_get_image_width(png, info);
png_uint_32 height = png_get_image_height(png, info);
// Protect against large images.
if (width > cMaxPNGSize || height > cMaxPNGSize) {
longjmp(JMPBUF(png), 1);
return;
}
// We can fill in the size now that the header is available. Avoid memory
// corruption issues by neutering setFailed() during this call; if we don't
// do this, failures will cause |m_reader| to be deleted, and our jmpbuf
// will cease to exist. Note that we'll still properly set the failure flag
// in this case as soon as we longjmp().
m_doNothingOnFailure = true;
bool result = setSize(width, height);
m_doNothingOnFailure = false;
if (!result) {
longjmp(JMPBUF(png), 1);
return;
}
int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceType, &compressionType, &filterType);
if ((colorType == PNG_COLOR_TYPE_RGB || colorType == PNG_COLOR_TYPE_RGB_ALPHA) && !m_ignoreGammaAndColorProfile) {
// We currently support color profiles only for RGB and RGBA PNGs. Supporting
// color profiles for gray-scale images is slightly tricky, at least using the
// CoreGraphics ICC library, because we expand gray-scale images to RGB but we
// don't similarly transform the color profile. We'd either need to transform
// the color profile or we'd need to decode into a gray-scale image buffer and
// hand that to CoreGraphics.
m_colorProfile = readColorProfile(png, info);
}
// The options we set here match what Mozilla does.
// Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
if (colorType == PNG_COLOR_TYPE_PALETTE || (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
png_set_expand(png);
png_bytep trns = 0;
int trnsCount = 0;
if (png_get_valid(png, info, PNG_INFO_tRNS)) {
png_get_tRNS(png, info, &trns, &trnsCount, 0);
png_set_expand(png);
}
if (bitDepth == 16)
png_set_strip_16(png);
if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb(png);
// Deal with gamma and keep it under our control.
double gamma;
if (!m_ignoreGammaAndColorProfile && png_get_gAMA(png, info, &gamma)) {
if ((gamma <= 0.0) || (gamma > cMaxGamma)) {
gamma = cInverseGamma;
png_set_gAMA(png, info, gamma);
}
png_set_gamma(png, cDefaultGamma, gamma);
} else
png_set_gamma(png, cDefaultGamma, cInverseGamma);
// Tell libpng to send us rows for interlaced pngs.
if (interlaceType == PNG_INTERLACE_ADAM7)
png_set_interlace_handling(png);
// Update our info now.
png_read_update_info(png, info);
channels = png_get_channels(png, info);
ASSERT(channels == 3 || channels == 4);
m_reader->setHasAlpha(channels == 4);
if (m_reader->decodingSizeOnly()) {
// If we only needed the size, halt the reader.
#if defined(PNG_LIBPNG_VER_MAJOR) && defined(PNG_LIBPNG_VER_MINOR) && (PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 5))
// '0' argument to png_process_data_pause means: Do not cache unprocessed data.
m_reader->setReadOffset(m_reader->currentBufferSize() - png_process_data_pause(png, 0));
#else
m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
png->buffer_size = 0;
#endif
}
}
AFRAMES OneFrameReader(png_structp png_ptr_read, png_infop info_ptr_read,
png_structp png_ptr_write, png_infop info_ptr_write,
png_uint_32 width, png_uint_32 height)
{
/* IHDR */
/* struct data need from background */
AFRAMES pframe;
png_uint_32 garbage;
int bit_depth;
int colour_type;
int interlace_method;
int compression_method;
int filter_method;
/* PLTE */
png_colorp palette = NULL;
int palette_size = 0;
/* gAMA */
double gamma;
/* tRNS */
png_bytep trans;
int num_trans;
png_color_16p trans_values;
/* bKGD */
png_color_16p background;
png_get_IHDR(png_ptr_read, info_ptr_read, &garbage, &garbage,
&bit_depth, &colour_type, &interlace_method,
&compression_method, &filter_method);
png_set_IHDR(png_ptr_write, info_ptr_write, width, height,
bit_depth, colour_type, interlace_method,
compression_method, filter_method);
int r = 0, g = 0, b = 0;
int bpp = bit_depth;
switch (colour_type) {
case PNG_COLOR_TYPE_GRAY : break;
case PNG_COLOR_TYPE_RGB : bpp *= 3; break;
case PNG_COLOR_TYPE_PALETTE : break;
case PNG_COLOR_TYPE_GRAY_ALPHA: bpp *= 2; break;
case PNG_COLOR_TYPE_RGB_ALPHA : bpp *= 4; break;
default:
return pframe;
}
pframe.colortype = colour_type;
pframe.bytedep = bpp;
pframe.pngBG = trans_values;
/////////qDebug() << "### color type " << colour_type << bpp << num_trans;
if(png_get_valid(png_ptr_read, info_ptr_read, PNG_INFO_PLTE))
{
/////////qDebug() << "### PNG_INFO_PLTE";
png_get_PLTE(png_ptr_read, info_ptr_read, &palette, &palette_size);
png_set_PLTE(png_ptr_write, info_ptr_write, palette, palette_size);
}
if(png_get_valid(png_ptr_read, info_ptr_read, PNG_INFO_gAMA))
{
/////////qDebug() << "### PNG_INFO_gAMA";
png_get_gAMA(png_ptr_read, info_ptr_read, &gamma);
png_set_gAMA(png_ptr_write, info_ptr_write, gamma);
}
if(png_get_valid(png_ptr_read, info_ptr_read, PNG_INFO_tRNS))
{
//////////qDebug() << "### PNG_INFO_tRNS";
png_get_tRNS(png_ptr_read, info_ptr_read, &trans, &num_trans, &trans_values);
png_set_tRNS(png_ptr_write, info_ptr_write, trans, num_trans, trans_values);
}
if(png_get_valid(png_ptr_read, info_ptr_read, PNG_INFO_bKGD))
{
////////qDebug() << "### PNG_INFO_bKGD";
png_get_bKGD(png_ptr_read, info_ptr_read, &background);
png_set_bKGD(png_ptr_write, info_ptr_write, background);
png_color_16p bkgd = background;
pframe.pngBG = background;
int r = 0, g = 0, b = 0;
if(colour_type == PNG_COLOR_TYPE_RGB || colour_type == PNG_COLOR_TYPE_RGB_ALPHA) {
r = bkgd->red;
g = bkgd->green;
b = bkgd->blue;
}
if(colour_type == PNG_COLOR_TYPE_GRAY || colour_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
r = g = b = bkgd->gray;
}
if(colour_type == PNG_COLOR_TYPE_PALETTE) {
r = palette[bkgd->index].red;
g = palette[bkgd->index].green;
b = palette[bkgd->index].blue;
}
// scale down to 8 bit color since QColor doesn't support 16 bit colors
if(bit_depth > 8) {
r >>= 8;
g >>= 8;
b >>= 8;
}
////////qDebug() << "### color " << r << g << b;
pframe.bg = QColor(r,g,b);
pframe.foundcolor = true;
} else {
bool MCImageEncodePNG(MCImageIndexedBitmap *p_indexed, IO_handle p_stream, uindex_t &r_bytes_written)
{
bool t_success = true;
MCPNGWriteContext t_context;
t_context.stream = p_stream;
t_context.byte_count = 0;
png_structp t_png_ptr = nil;
png_infop t_info_ptr = nil;
png_color *t_png_palette = nil;
png_byte *t_png_transparency = nil;
png_bytep t_data_ptr = nil;
uindex_t t_stride = 0;
/*init png stuff*/
if (t_success)
{
t_success = nil != (t_png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
(png_voidp)NULL, (png_error_ptr)NULL,
(png_error_ptr)NULL));
}
if (t_success)
t_success = nil != (t_info_ptr = png_create_info_struct(t_png_ptr));
/*in case of png error*/
if (setjmp(png_jmpbuf(t_png_ptr)))
t_success = false;
if (t_success)
png_set_write_fn(t_png_ptr,(png_voidp)&t_context,fakewrite,fakeflush);
if (t_success)
{
png_set_IHDR(t_png_ptr, t_info_ptr, p_indexed->width, p_indexed->height, 8,
PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_set_gAMA(t_png_ptr, t_info_ptr, 1/MCgamma);
}
if (t_success)
t_success = MCMemoryNewArray(p_indexed->palette_size, t_png_palette);
/*create palette for 8 bit*/
if (t_success)
{
for (uindex_t i = 0; i < p_indexed->palette_size ; i++)
{
t_png_palette[i].red = p_indexed->palette[i].red >> 8;
t_png_palette[i].green = p_indexed->palette[i].green >> 8;
t_png_palette[i].blue = p_indexed->palette[i].blue >> 8;
}
png_set_PLTE(t_png_ptr, t_info_ptr, t_png_palette, p_indexed->palette_size);
}
if (MCImageIndexedBitmapHasTransparency(p_indexed))
{
if (t_success)
t_success = MCMemoryAllocate(p_indexed->palette_size, t_png_transparency);
if (t_success)
{
memset(t_png_transparency, 0xFF, p_indexed->palette_size);
t_png_transparency[p_indexed->transparent_index] = 0x00;
png_set_tRNS(t_png_ptr, t_info_ptr, t_png_transparency, p_indexed->palette_size, NULL);
}
}
if (t_success)
png_write_info(t_png_ptr, t_info_ptr);
if (t_success)
{
t_data_ptr = (png_bytep)p_indexed->data;
t_stride = p_indexed->stride;
}
if (t_success)
{
for (uindex_t i = 0; i < p_indexed->height; i++)
{
png_write_row(t_png_ptr, t_data_ptr);
t_data_ptr += t_stride;
}
}
if (t_success)
png_write_end(t_png_ptr, t_info_ptr);
if (t_png_ptr != nil)
png_destroy_write_struct(&t_png_ptr, &t_info_ptr);
if (t_png_palette != nil)
MCMemoryDeleteArray(t_png_palette);
if (t_png_transparency != nil)
MCMemoryDeallocate(t_png_transparency);
if (t_success)
r_bytes_written = t_context.byte_count;
return t_success;
}
/* ****************************************************************** */
void WritePNG (double ***Vdbl, char *var_name, char *filename,
Grid *grid)
/*
*
*
*
*
******************************************************************** */
{
int ic, ir, i;
png_structp png_ptr;
png_infop info_ptr;
int backgroundcolour_;
int bit_depth_;
int colortype_;
int compressionlevel_;
int indx;
double filegamma_;
Image *png;
unsigned char **image;
FILE *fp;
png = GetImage (var_name);
SetColorMap (png->r, png->g, png->b, png->colormap);
GetSlice (Vdbl, png, grid);
if (prank != 0) return;
image = (png_bytepp)malloc(png->nrow*sizeof(png_bytep));
for (ir = 0; ir < png->nrow; ir++) {
image[ir] = (png_bytep)malloc(6*png->ncol*sizeof(png_byte));
}
for(ic = 0; ic < png->ncol; ic++){
for(ir = 0; ir < png->nrow; ir++){
i = 6*ic;
image[ir][i] = png->rgb[ir][ic].r; /* -- red -- */
image[ir][i+1] = 0;
image[ir][i+2] = png->rgb[ir][ic].g; /* -- green -- */
image[ir][i+3] = 0;
image[ir][i+4] = png->rgb[ir][ic].b; /* -- blue -- */
image[ir][i+5] = 0;
}}
/* -- write --- */
compressionlevel_ = 6;
backgroundcolour_ = 0;
bit_depth_ = 16;
filegamma_ = 0.;
colortype_ = 2.;
fp = fopen(filename, "wb");
if(fp == NULL){
printf(" ! error opening file in writing data\n");
exit(1);
}
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
info_ptr = png_create_info_struct(png_ptr);
png_init_io(png_ptr, fp);
/* if(compressionlevel_ != -2){ */
png_set_compression_level(png_ptr, compressionlevel_);
/* }
else
{
png_set_compression_level(png_ptr, PNGWRITER_DEFAULT_COMPRESSION);
}*/
png_set_IHDR(png_ptr, info_ptr, png->ncol, png->nrow,
bit_depth_, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
if(filegamma_ < 1.0e-1){
filegamma_ = 0.7;
}
png_set_gAMA(png_ptr, info_ptr, filegamma_);
/*
time_t gmt;
png_time mod_time;
png_text text_ptr[5];
time(&gmt);
png_convert_from_time_t(&mod_time, gmt);
png_set_tIME(png_ptr, info_ptr, &mod_time);
*/
png_write_info(png_ptr, info_ptr);
png_write_image(png_ptr, image);
png_write_end(png_ptr, info_ptr);
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(fp);
free((char *) image[0]);
free((char *) image);
}
void PNGImageDecoder::headerAvailable()
{
png_structp png = m_reader->pngPtr();
png_infop info = m_reader->infoPtr();
png_uint_32 width = png_get_image_width(png, info);
png_uint_32 height = png_get_image_height(png, info);
// Protect against large PNGs. See http://bugzil.la/251381 for more details.
const unsigned long maxPNGSize = 1000000UL;
if (width > maxPNGSize || height > maxPNGSize) {
longjmp(JMPBUF(png), 1);
return;
}
// Set the image size now that the image header is available.
if (!setSize(width, height)) {
longjmp(JMPBUF(png), 1);
return;
}
int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceType, &compressionType, &filterType);
// The options we set here match what Mozilla does.
// Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
if (colorType == PNG_COLOR_TYPE_PALETTE || (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
png_set_expand(png);
png_bytep trns = 0;
int trnsCount = 0;
if (png_get_valid(png, info, PNG_INFO_tRNS)) {
png_get_tRNS(png, info, &trns, &trnsCount, 0);
png_set_expand(png);
}
if (bitDepth == 16)
png_set_strip_16(png);
if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb(png);
#if USE(QCMSLIB)
if ((colorType & PNG_COLOR_MASK_COLOR) && !m_ignoreGammaAndColorProfile) {
// We only support color profiles for color PALETTE and RGB[A] PNG. Supporting
// color profiles for gray-scale images is slightly tricky, at least using the
// CoreGraphics ICC library, because we expand gray-scale images to RGB but we
// do not similarly transform the color profile. We'd either need to transform
// the color profile or we'd need to decode into a gray-scale image buffer and
// hand that to CoreGraphics.
bool sRGB = false;
ColorProfile colorProfile;
getColorProfile(png, info, colorProfile, sRGB);
bool imageHasAlpha = (colorType & PNG_COLOR_MASK_ALPHA) || trnsCount;
m_reader->createColorTransform(colorProfile, imageHasAlpha, sRGB);
m_hasColorProfile = !!m_reader->colorTransform();
}
#endif
if (!m_hasColorProfile) {
// Deal with gamma and keep it under our control.
const double inverseGamma = 0.45455;
const double defaultGamma = 2.2;
double gamma;
if (!m_ignoreGammaAndColorProfile && png_get_gAMA(png, info, &gamma)) {
const double maxGamma = 21474.83;
if ((gamma <= 0.0) || (gamma > maxGamma)) {
gamma = inverseGamma;
png_set_gAMA(png, info, gamma);
}
png_set_gamma(png, defaultGamma, gamma);
} else {
png_set_gamma(png, defaultGamma, inverseGamma);
}
}
// Tell libpng to send us rows for interlaced pngs.
if (interlaceType == PNG_INTERLACE_ADAM7)
png_set_interlace_handling(png);
// Update our info now.
png_read_update_info(png, info);
channels = png_get_channels(png, info);
ASSERT(channels == 3 || channels == 4);
m_reader->setHasAlpha(channels == 4);
if (m_reader->decodingSizeOnly()) {
// If we only needed the size, halt the reader.
#if PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 5)
// '0' argument to png_process_data_pause means: Do not cache unprocessed data.
m_reader->setReadOffset(m_reader->currentBufferSize() - png_process_data_pause(png, 0));
#else
m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
png->buffer_size = 0;
#endif
}
}
static uint8_t png_write( png_structp writePtr, png_image * image, uint32_t flags )
{
const uint32_t h = image->height;
const uint32_t w = image->width;
const uint8_t * p = image->data;
const uint32_t bitDepth = 8;
const uint32_t channels = 4;
png_infop infoPtr = png_create_info_struct( writePtr );
if (!infoPtr)
{
pngio_error( "Couldn't initialize PNG info struct" );
png_destroy_write_struct( & writePtr, NULL );
return 0;
}
if (setjmp( png_jmpbuf( writePtr ) ))
{
png_destroy_write_struct( & writePtr, & infoPtr );
pngio_error( "An error occured while writing the PNG file." );
return 0;
}
png_set_filter( writePtr, 0, PNG_FILTER_NONE );
#ifdef PNG_APPLE_MODE_SUPPORTED
if (png_get_apple_mode())
{
png_write_sig( writePtr );
png_set_sig_bytes( writePtr, 8 );
png_set_compression_window_bits( writePtr, -15 );
png_set_write_user_transform_fn( writePtr, png_write_swap_and_premultiply_transform );
png_set_user_transform_info( writePtr, NULL, bitDepth, channels );
}
#endif
png_set_IHDR( writePtr, infoPtr, w, h, bitDepth, PNG_COLOR_TYPE_RGBA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT );
png_set_gAMA( writePtr, infoPtr, 0.45455 );
png_set_cHRM( writePtr, infoPtr, 0.312700, 0.329, 0.64, 0.33, 0.3, 0.6, 0.15, 0.06 );
png_set_sRGB( writePtr, infoPtr, 0);
#ifdef PNG_APPLE_MODE_SUPPORTED
if (png_get_apple_mode())
{
png_byte cname[] = { 'C', 'g', 'B', 'I', '\0' };
png_byte cdata[] = { 0x50, 0x00, 0x20, 0x02 };
png_write_chunk( writePtr, cname, cdata, 4 );
}
#endif
png_write_info( writePtr, infoPtr );
const size_t bytesPerRow = w * 4;
if (flags & PNG_IMAGE_FLIP_VERTICAL)
{
for (size_t i = 0; i < h; i++)
{
png_write_row( writePtr, p + (bytesPerRow * (h - i - 1)) );
}
}
else
{
for (size_t i = 0; i < h; i++)
{
png_write_row( writePtr, p + (bytesPerRow * i) );
}
}
png_write_end( writePtr, infoPtr );
png_destroy_write_struct( & writePtr, & infoPtr );
return 1;
}