| /*--------------------------------------------------------------------------- | |
| 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); | |
| } |