1 /*---------------------------------------------------------------------------

     2 

     3    wpng - simple PNG-writing program                             writepng.c

     4 

     5   ---------------------------------------------------------------------------

     6 

     7       Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.

     8 

     9       This software is provided "as is," without warranty of any kind,

    10       express or implied.  In no event shall the author or contributors

    11       be held liable for any damages arising in any way from the use of

    12       this software.

    13 

    14       The contents of this file are DUAL-LICENSED.  You may modify and/or

    15       redistribute this software according to the terms of one of the

    16       following two licenses (at your option):

    17 

    18 

    19       LICENSE 1 ("BSD-like with advertising clause"):

    20 

    21       Permission is granted to anyone to use this software for any purpose,

    22       including commercial applications, and to alter it and redistribute

    23       it freely, subject to the following restrictions:

    24 

    25       1. Redistributions of source code must retain the above copyright

    26          notice, disclaimer, and this list of conditions.

    27       2. Redistributions in binary form must reproduce the above copyright

    28          notice, disclaimer, and this list of conditions in the documenta-

    29          tion and/or other materials provided with the distribution.

    30       3. All advertising materials mentioning features or use of this

    31          software must display the following acknowledgment:

    32 

    33             This product includes software developed by Greg Roelofs

    34             and contributors for the book, "PNG: The Definitive Guide,"

    35             published by O'Reilly and Associates.

    36 

    37 

    38       LICENSE 2 (GNU GPL v2 or later):

    39 

    40       This program is free software; you can redistribute it and/or modify

    41       it under the terms of the GNU General Public License as published by

    42       the Free Software Foundation; either version 2 of the License, or

    43       (at your option) any later version.

    44 

    45       This program is distributed in the hope that it will be useful,

    46       but WITHOUT ANY WARRANTY; without even the implied warranty of

    47       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    48       GNU General Public License for more details.

    49 

    50       You should have received a copy of the GNU General Public License

    51       along with this program; if not, write to the Free Software Foundation,

    52       Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    53 

    54   ---------------------------------------------------------------------------*/

    55 

    56 

    57 #include <stdlib.h>     /* for exit() prototype */

    58 

    59 #include "png.h"        /* libpng header; includes zlib.h and setjmp.h */

    60 #include "writepng.h"   /* typedefs, common macros, public prototypes */

    61 

    62 

    63 /* local prototype */

    64 

    65 static void writepng_error_handler(png_structp png_ptr, png_const_charp msg);

    66 

    67 

    68 

    69 void writepng_version_info(void)

    70 {

    71   fprintf(stderr, "   Compiled with libpng %s; using libpng %s.\n",

    72     PNG_LIBPNG_VER_STRING, png_libpng_ver);

    73   fprintf(stderr, "   Compiled with zlib %s; using zlib %s.\n",

    74     ZLIB_VERSION, zlib_version);

    75 }

    76 

    77 

    78 

    79 

    80 /* returns 0 for success, 2 for libpng problem, 4 for out of memory, 11 for

    81  *  unexpected pnmtype; note that outfile might be stdout */

    82 

    83 int writepng_init(mainprog_info *mainprog_ptr)

    84 {

    85     png_structp  png_ptr;       /* note:  temporary variables! */

    86     png_infop  info_ptr;

    87     int color_type, interlace_type;

    88 

    89 

    90     /* could also replace libpng warning-handler (final NULL), but no need: */

    91 

    92     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,

    93       writepng_error_handler, NULL);

    94     if (!png_ptr)

    95         return 4;   /* out of memory */

    96 

    97     info_ptr = png_create_info_struct(png_ptr);

    98     if (!info_ptr) {

    99         png_destroy_write_struct(&png_ptr, NULL);

   100         return 4;   /* out of memory */

   101     }

   102 

   103 

   104     /* setjmp() must be called in every function that calls a PNG-writing

   105      * libpng function, unless an alternate error handler was installed--

   106      * but compatible error handlers must either use longjmp() themselves

   107      * (as in this program) or exit immediately, so here we go: */

   108 

   109     if (setjmp(mainprog_ptr->jmpbuf)) {

   110         png_destroy_write_struct(&png_ptr, &info_ptr);

   111         return 2;

   112     }

   113 

   114 

   115     /* make sure outfile is (re)opened in BINARY mode */

   116 

   117     png_init_io(png_ptr, mainprog_ptr->outfile);

   118 

   119 

   120     /* set the compression levels--in general, always want to leave filtering

   121      * turned on (except for palette images) and allow all of the filters,

   122      * which is the default; want 32K zlib window, unless entire image buffer

   123      * is 16K or smaller (unknown here)--also the default; usually want max

   124      * compression (NOT the default); and remaining compression flags should

   125      * be left alone */

   126 

   127     png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);

   128 /*

   129     >> this is default for no filtering; Z_FILTERED is default otherwise:

   130     png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);

   131     >> these are all defaults:

   132     png_set_compression_mem_level(png_ptr, 8);

   133     png_set_compression_window_bits(png_ptr, 15);

   134     png_set_compression_method(png_ptr, 8);

   135  */

   136 

   137 

   138     /* set the image parameters appropriately */

   139 

   140     if (mainprog_ptr->pnmtype == 5)

   141         color_type = PNG_COLOR_TYPE_GRAY;

   142     else if (mainprog_ptr->pnmtype == 6)

   143         color_type = PNG_COLOR_TYPE_RGB;

   144     else if (mainprog_ptr->pnmtype == 8)

   145         color_type = PNG_COLOR_TYPE_RGB_ALPHA;

   146     else {

   147         png_destroy_write_struct(&png_ptr, &info_ptr);

   148         return 11;

   149     }

   150 

   151     interlace_type = mainprog_ptr->interlaced? PNG_INTERLACE_ADAM7 :

   152                                                PNG_INTERLACE_NONE;

   153 

   154     png_set_IHDR(png_ptr, info_ptr, mainprog_ptr->width, mainprog_ptr->height,

   155       mainprog_ptr->sample_depth, color_type, interlace_type,

   156       PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

   157 

   158     if (mainprog_ptr->gamma > 0.0)

   159         png_set_gAMA(png_ptr, info_ptr, mainprog_ptr->gamma);

   160 

   161     if (mainprog_ptr->have_bg) {   /* we know it's RGBA, not gray+alpha */

   162         png_color_16  background;

   163 

   164         background.red = mainprog_ptr->bg_red;

   165         background.green = mainprog_ptr->bg_green;

   166         background.blue = mainprog_ptr->bg_blue;

   167         png_set_bKGD(png_ptr, info_ptr, &background);

   168     }

   169 

   170     if (mainprog_ptr->have_time) {

   171         png_time  modtime;

   172 

   173         png_convert_from_time_t(&modtime, mainprog_ptr->modtime);

   174         png_set_tIME(png_ptr, info_ptr, &modtime);

   175     }

   176 

   177     if (mainprog_ptr->have_text) {

   178         png_text  text[6];

   179         int  num_text = 0;

   180 

   181         if (mainprog_ptr->have_text & TEXT_TITLE) {

   182             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;

   183             text[num_text].key = "Title";

   184             text[num_text].text = mainprog_ptr->title;

   185             ++num_text;

   186         }

   187         if (mainprog_ptr->have_text & TEXT_AUTHOR) {

   188             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;

   189             text[num_text].key = "Author";

   190             text[num_text].text = mainprog_ptr->author;

   191             ++num_text;

   192         }

   193         if (mainprog_ptr->have_text & TEXT_DESC) {

   194             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;

   195             text[num_text].key = "Description";

   196             text[num_text].text = mainprog_ptr->desc;

   197             ++num_text;

   198         }

   199         if (mainprog_ptr->have_text & TEXT_COPY) {

   200             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;

   201             text[num_text].key = "Copyright";

   202             text[num_text].text = mainprog_ptr->copyright;

   203             ++num_text;

   204         }

   205         if (mainprog_ptr->have_text & TEXT_EMAIL) {

   206             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;

   207             text[num_text].key = "E-mail";

   208             text[num_text].text = mainprog_ptr->email;

   209             ++num_text;

   210         }

   211         if (mainprog_ptr->have_text & TEXT_URL) {

   212             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;

   213             text[num_text].key = "URL";

   214             text[num_text].text = mainprog_ptr->url;

   215             ++num_text;

   216         }

   217         png_set_text(png_ptr, info_ptr, text, num_text);

   218     }

   219 

   220 

   221     /* write all chunks up to (but not including) first IDAT */

   222 

   223     png_write_info(png_ptr, info_ptr);

   224 

   225 

   226     /* if we wanted to write any more text info *after* the image data, we

   227      * would set up text struct(s) here and call png_set_text() again, with

   228      * just the new data; png_set_tIME() could also go here, but it would

   229      * have no effect since we already called it above (only one tIME chunk

   230      * allowed) */

   231 

   232 

   233     /* set up the transformations:  for now, just pack low-bit-depth pixels

   234      * into bytes (one, two or four pixels per byte) */

   235 

   236     png_set_packing(png_ptr);

   237 /*  png_set_shift(png_ptr, &sig_bit);  to scale low-bit-depth values */

   238 

   239 

   240     /* make sure we save our pointers for use in writepng_encode_image() */

   241 

   242     mainprog_ptr->png_ptr = png_ptr;

   243     mainprog_ptr->info_ptr = info_ptr;

   244 

   245 

   246     /* OK, that's all we need to do for now; return happy */

   247 

   248     return 0;

   249 }

   250 

   251 

   252 

   253 

   254 

   255 /* returns 0 for success, 2 for libpng (longjmp) problem */

   256 

   257 int writepng_encode_image(mainprog_info *mainprog_ptr)

   258 {

   259     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;

   260     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;

   261 

   262 

   263     /* as always, setjmp() must be called in every function that calls a

   264      * PNG-writing libpng function */

   265 

   266     if (setjmp(mainprog_ptr->jmpbuf)) {

   267         png_destroy_write_struct(&png_ptr, &info_ptr);

   268         mainprog_ptr->png_ptr = NULL;

   269         mainprog_ptr->info_ptr = NULL;

   270         return 2;

   271     }

   272 

   273 

   274     /* and now we just write the whole image; libpng takes care of interlacing

   275      * for us */

   276 

   277     png_write_image(png_ptr, mainprog_ptr->row_pointers);

   278 

   279 

   280     /* since that's it, we also close out the end of the PNG file now--if we

   281      * had any text or time info to write after the IDATs, second argument

   282      * would be info_ptr, but we optimize slightly by sending NULL pointer: */

   283 

   284     png_write_end(png_ptr, NULL);

   285 

   286     return 0;

   287 }

   288 

   289 

   290 

   291 

   292 

   293 /* returns 0 if succeeds, 2 if libpng problem */

   294 

   295 int writepng_encode_row(mainprog_info *mainprog_ptr)  /* NON-interlaced only! */

   296 {

   297     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;

   298     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;

   299 

   300 

   301     /* as always, setjmp() must be called in every function that calls a

   302      * PNG-writing libpng function */

   303 

   304     if (setjmp(mainprog_ptr->jmpbuf)) {

   305         png_destroy_write_struct(&png_ptr, &info_ptr);

   306         mainprog_ptr->png_ptr = NULL;

   307         mainprog_ptr->info_ptr = NULL;

   308         return 2;

   309     }

   310 

   311 

   312     /* image_data points at our one row of image data */

   313 

   314     png_write_row(png_ptr, mainprog_ptr->image_data);

   315 

   316     return 0;

   317 }

   318 

   319 

   320 

   321 

   322 

   323 /* returns 0 if succeeds, 2 if libpng problem */

   324 

   325 int writepng_encode_finish(mainprog_info *mainprog_ptr)   /* NON-interlaced! */

   326 {

   327     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;

   328     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;

   329 

   330 

   331     /* as always, setjmp() must be called in every function that calls a

   332      * PNG-writing libpng function */

   333 

   334     if (setjmp(mainprog_ptr->jmpbuf)) {

   335         png_destroy_write_struct(&png_ptr, &info_ptr);

   336         mainprog_ptr->png_ptr = NULL;

   337         mainprog_ptr->info_ptr = NULL;

   338         return 2;

   339     }

   340 

   341 

   342     /* close out PNG file; if we had any text or time info to write after

   343      * the IDATs, second argument would be info_ptr: */

   344 

   345     png_write_end(png_ptr, NULL);

   346 

   347     return 0;

   348 }

   349 

   350 

   351 

   352 

   353 

   354 void writepng_cleanup(mainprog_info *mainprog_ptr)

   355 {

   356     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;

   357     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;

   358 

   359     if (png_ptr && info_ptr)

   360         png_destroy_write_struct(&png_ptr, &info_ptr);

   361 }

   362 

   363 

   364 

   365 

   366 

   367 static void writepng_error_handler(png_structp png_ptr, png_const_charp msg)

   368 {

   369     mainprog_info  *mainprog_ptr;

   370 

   371     /* This function, aside from the extra step of retrieving the "error

   372      * pointer" (below) and the fact that it exists within the application

   373      * rather than within libpng, is essentially identical to libpng's

   374      * default error handler.  The second point is critical:  since both

   375      * setjmp() and longjmp() are called from the same code, they are

   376      * guaranteed to have compatible notions of how big a jmp_buf is,

   377      * regardless of whether _BSD_SOURCE or anything else has (or has not)

   378      * been defined. */

   379 

   380     fprintf(stderr, "writepng libpng error: %s\n", msg);

   381     fflush(stderr);

   382 

   383     mainprog_ptr = png_get_error_ptr(png_ptr);

   384     if (mainprog_ptr == NULL) {         /* we are completely hosed now */

   385         fprintf(stderr,

   386           "writepng severe error:  jmpbuf not recoverable; terminating.\n");

   387         fflush(stderr);

   388         exit(99);

   389     }

   390 

   391     longjmp(mainprog_ptr->jmpbuf, 1);

   392 }