You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
401 lines
13 KiB
401 lines
13 KiB
/*--------------------------------------------------------------------------- |
|
|
|
wpng - simple PNG-writing program writepng.c |
|
|
|
--------------------------------------------------------------------------- |
|
|
|
Copyright (c) 1998-2007, 2017 Greg Roelofs. All rights reserved. |
|
|
|
This software is provided "as is," without warranty of any kind, |
|
express or implied. In no event shall the author or contributors |
|
be held liable for any damages arising in any way from the use of |
|
this software. |
|
|
|
The contents of this file are DUAL-LICENSED. You may modify and/or |
|
redistribute this software according to the terms of one of the |
|
following two licenses (at your option): |
|
|
|
|
|
LICENSE 1 ("BSD-like with advertising clause"): |
|
|
|
Permission is granted to anyone to use this software for any purpose, |
|
including commercial applications, and to alter it and redistribute |
|
it freely, subject to the following restrictions: |
|
|
|
1. Redistributions of source code must retain the above copyright |
|
notice, disclaimer, and this list of conditions. |
|
2. Redistributions in binary form must reproduce the above copyright |
|
notice, disclaimer, and this list of conditions in the documenta- |
|
tion and/or other materials provided with the distribution. |
|
3. All advertising materials mentioning features or use of this |
|
software must display the following acknowledgment: |
|
|
|
This product includes software developed by Greg Roelofs |
|
and contributors for the book, "PNG: The Definitive Guide," |
|
published by O'Reilly and Associates. |
|
|
|
|
|
LICENSE 2 (GNU GPL v2 or later): |
|
|
|
This program is free software; you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation; either version 2 of the License, or |
|
(at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program; if not, write to the Free Software Foundation, |
|
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
|
|
---------------------------------------------------------------------------*/ |
|
|
|
|
|
#include <stdlib.h> /* for exit() prototype */ |
|
#include <zlib.h> |
|
|
|
#include "png.h" /* libpng header, includes setjmp.h */ |
|
#include "writepng.h" /* typedefs, common macros, public prototypes */ |
|
|
|
|
|
/* local prototype */ |
|
|
|
static void writepng_error_handler(png_structp png_ptr, png_const_charp msg); |
|
|
|
|
|
|
|
void writepng_version_info(void) |
|
{ |
|
fprintf(stderr, " Compiled with libpng %s; using libpng %s.\n", |
|
PNG_LIBPNG_VER_STRING, png_libpng_ver); |
|
fprintf(stderr, " Compiled with zlib %s; using zlib %s.\n", |
|
ZLIB_VERSION, zlib_version); |
|
} |
|
|
|
|
|
|
|
|
|
/* 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) |
|
{ |
|
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: */ |
|
|
|
png_ptr = png_create_write_struct(png_get_libpng_ver(NULL), 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 some other method to return control to |
|
* application code, 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 */ |
|
|
|
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; |
|
} |
|
|
|
|
|
|
|
|
|
|
|
/* returns 0 for success, 2 for libpng (longjmp) problem */ |
|
|
|
int writepng_encode_image(mainprog_info *mainprog_ptr) |
|
{ |
|
png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr; |
|
png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr; |
|
|
|
|
|
/* as always, setjmp() must be called in every function that calls a |
|
* PNG-writing libpng function */ |
|
|
|
if (setjmp(mainprog_ptr->jmpbuf)) { |
|
png_destroy_write_struct(&png_ptr, &info_ptr); |
|
mainprog_ptr->png_ptr = NULL; |
|
mainprog_ptr->info_ptr = NULL; |
|
return 2; |
|
} |
|
|
|
|
|
/* and now we just write the whole image; libpng takes care of interlacing |
|
* for us */ |
|
|
|
png_write_image(png_ptr, mainprog_ptr->row_pointers); |
|
|
|
|
|
/* since that's it, we also close out the end of the PNG file now--if we |
|
* had any text or time info to write after the IDATs, second argument |
|
* would be info_ptr, but we optimize slightly by sending NULL pointer: */ |
|
|
|
png_write_end(png_ptr, NULL); |
|
|
|
return 0; |
|
} |
|
|
|
|
|
|
|
|
|
|
|
/* returns 0 if succeeds, 2 if libpng problem */ |
|
|
|
int writepng_encode_row(mainprog_info *mainprog_ptr) /* NON-interlaced only! */ |
|
{ |
|
png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr; |
|
png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr; |
|
|
|
|
|
/* as always, setjmp() must be called in every function that calls a |
|
* PNG-writing libpng function */ |
|
|
|
if (setjmp(mainprog_ptr->jmpbuf)) { |
|
png_destroy_write_struct(&png_ptr, &info_ptr); |
|
mainprog_ptr->png_ptr = NULL; |
|
mainprog_ptr->info_ptr = NULL; |
|
return 2; |
|
} |
|
|
|
|
|
/* image_data points at our one row of image data */ |
|
|
|
png_write_row(png_ptr, mainprog_ptr->image_data); |
|
|
|
return 0; |
|
} |
|
|
|
|
|
|
|
|
|
|
|
/* returns 0 if succeeds, 2 if libpng problem */ |
|
|
|
int writepng_encode_finish(mainprog_info *mainprog_ptr) /* NON-interlaced! */ |
|
{ |
|
png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr; |
|
png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr; |
|
|
|
|
|
/* as always, setjmp() must be called in every function that calls a |
|
* PNG-writing libpng function */ |
|
|
|
if (setjmp(mainprog_ptr->jmpbuf)) { |
|
png_destroy_write_struct(&png_ptr, &info_ptr); |
|
mainprog_ptr->png_ptr = NULL; |
|
mainprog_ptr->info_ptr = NULL; |
|
return 2; |
|
} |
|
|
|
|
|
/* close out PNG file; if we had any text or time info to write after |
|
* the IDATs, second argument would be info_ptr: */ |
|
|
|
png_write_end(png_ptr, NULL); |
|
|
|
return 0; |
|
} |
|
|
|
|
|
|
|
|
|
|
|
void writepng_cleanup(mainprog_info *mainprog_ptr) |
|
{ |
|
png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr; |
|
png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr; |
|
|
|
if (png_ptr && info_ptr) |
|
png_destroy_write_struct(&png_ptr, &info_ptr); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
static void writepng_error_handler(png_structp png_ptr, png_const_charp msg) |
|
{ |
|
mainprog_info *mainprog_ptr; |
|
|
|
/* This function, aside from the extra step of retrieving the "error |
|
* pointer" (below) and the fact that it exists within the application |
|
* rather than within libpng, is essentially identical to libpng's |
|
* default error handler. The second point is critical: since both |
|
* setjmp() and longjmp() are called from the same code, they are |
|
* guaranteed to have compatible notions of how big a jmp_buf is, |
|
* regardless of whether _BSD_SOURCE or anything else has (or has not) |
|
* been defined. */ |
|
|
|
fprintf(stderr, "writepng libpng error: %s\n", msg); |
|
fflush(stderr); |
|
|
|
mainprog_ptr = png_get_error_ptr(png_ptr); |
|
if (mainprog_ptr == NULL) { /* we are completely hosed now */ |
|
fprintf(stderr, |
|
"writepng severe error: jmpbuf not recoverable; terminating.\n"); |
|
fflush(stderr); |
|
exit(99); |
|
} |
|
|
|
/* Now we have our data structure we can use the information in it |
|
* to return control to our own higher level code (all the points |
|
* where 'setjmp' is called in this file.) This will work with other |
|
* error handling mechanisms as well - libpng always calls png_error |
|
* when it can proceed no further, thus, so long as the error handler |
|
* is intercepted, application code can do its own error recovery. |
|
*/ |
|
longjmp(mainprog_ptr->jmpbuf, 1); |
|
}
|
|
|