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#include <zlib.h>
59
60#include "png.h"        /* libpng header, includes setjmp.h */
61#include "writepng.h"   /* typedefs, common macros, public prototypes */
62
63
64/* local prototype */
65
66static void writepng_error_handler(png_structp png_ptr, png_const_charp msg);
67
68
69
70void writepng_version_info(void)
71{
72  fprintf(stderr, "   Compiled with libpng %s; using libpng %s.\n",
73    PNG_LIBPNG_VER_STRING, png_libpng_ver);
74  fprintf(stderr, "   Compiled with zlib %s; using zlib %s.\n",
75    ZLIB_VERSION, zlib_version);
76}
77
78
79
80
81/* returns 0 for success, 2 for libpng problem, 4 for out of memory, 11 for
82 *  unexpected pnmtype; note that outfile might be stdout */
83
84int writepng_init(mainprog_info *mainprog_ptr)
85{
86    png_structp  png_ptr;       /* note:  temporary variables! */
87    png_infop  info_ptr;
88    int color_type, interlace_type;
89
90
91    /* could also replace libpng warning-handler (final NULL), but no need: */
92
93    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
94      writepng_error_handler, NULL);
95    if (!png_ptr)
96        return 4;   /* out of memory */
97
98    info_ptr = png_create_info_struct(png_ptr);
99    if (!info_ptr) {
100        png_destroy_write_struct(&png_ptr, NULL);
101        return 4;   /* out of memory */
102    }
103
104
105    /* setjmp() must be called in every function that calls a PNG-writing
106     * libpng function, unless an alternate error handler was installed--
107     * but compatible error handlers must either use longjmp() themselves
108     * (as in this program) or some other method to return control to
109     * application code, so here we go: */
110
111    if (setjmp(mainprog_ptr->jmpbuf)) {
112        png_destroy_write_struct(&png_ptr, &info_ptr);
113        return 2;
114    }
115
116
117    /* make sure outfile is (re)opened in BINARY mode */
118
119    png_init_io(png_ptr, mainprog_ptr->outfile);
120
121
122    /* set the compression levels--in general, always want to leave filtering
123     * turned on (except for palette images) and allow all of the filters,
124     * which is the default; want 32K zlib window, unless entire image buffer
125     * is 16K or smaller (unknown here)--also the default; usually want max
126     * compression (NOT the default); and remaining compression flags should
127     * be left alone */
128
129    png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
130/*
131    >> this is default for no filtering; Z_FILTERED is default otherwise:
132    png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
133    >> these are all defaults:
134    png_set_compression_mem_level(png_ptr, 8);
135    png_set_compression_window_bits(png_ptr, 15);
136    png_set_compression_method(png_ptr, 8);
137 */
138
139
140    /* set the image parameters appropriately */
141
142    if (mainprog_ptr->pnmtype == 5)
143        color_type = PNG_COLOR_TYPE_GRAY;
144    else if (mainprog_ptr->pnmtype == 6)
145        color_type = PNG_COLOR_TYPE_RGB;
146    else if (mainprog_ptr->pnmtype == 8)
147        color_type = PNG_COLOR_TYPE_RGB_ALPHA;
148    else {
149        png_destroy_write_struct(&png_ptr, &info_ptr);
150        return 11;
151    }
152
153    interlace_type = mainprog_ptr->interlaced? PNG_INTERLACE_ADAM7 :
154                                               PNG_INTERLACE_NONE;
155
156    png_set_IHDR(png_ptr, info_ptr, mainprog_ptr->width, mainprog_ptr->height,
157      mainprog_ptr->sample_depth, color_type, interlace_type,
158      PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
159
160    if (mainprog_ptr->gamma > 0.0)
161        png_set_gAMA(png_ptr, info_ptr, mainprog_ptr->gamma);
162
163    if (mainprog_ptr->have_bg) {   /* we know it's RGBA, not gray+alpha */
164        png_color_16  background;
165
166        background.red = mainprog_ptr->bg_red;
167        background.green = mainprog_ptr->bg_green;
168        background.blue = mainprog_ptr->bg_blue;
169        png_set_bKGD(png_ptr, info_ptr, &background);
170    }
171
172    if (mainprog_ptr->have_time) {
173        png_time  modtime;
174
175        png_convert_from_time_t(&modtime, mainprog_ptr->modtime);
176        png_set_tIME(png_ptr, info_ptr, &modtime);
177    }
178
179    if (mainprog_ptr->have_text) {
180        png_text  text[6];
181        int  num_text = 0;
182
183        if (mainprog_ptr->have_text & TEXT_TITLE) {
184            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
185            text[num_text].key = "Title";
186            text[num_text].text = mainprog_ptr->title;
187            ++num_text;
188        }
189        if (mainprog_ptr->have_text & TEXT_AUTHOR) {
190            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
191            text[num_text].key = "Author";
192            text[num_text].text = mainprog_ptr->author;
193            ++num_text;
194        }
195        if (mainprog_ptr->have_text & TEXT_DESC) {
196            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
197            text[num_text].key = "Description";
198            text[num_text].text = mainprog_ptr->desc;
199            ++num_text;
200        }
201        if (mainprog_ptr->have_text & TEXT_COPY) {
202            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
203            text[num_text].key = "Copyright";
204            text[num_text].text = mainprog_ptr->copyright;
205            ++num_text;
206        }
207        if (mainprog_ptr->have_text & TEXT_EMAIL) {
208            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
209            text[num_text].key = "E-mail";
210            text[num_text].text = mainprog_ptr->email;
211            ++num_text;
212        }
213        if (mainprog_ptr->have_text & TEXT_URL) {
214            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
215            text[num_text].key = "URL";
216            text[num_text].text = mainprog_ptr->url;
217            ++num_text;
218        }
219        png_set_text(png_ptr, info_ptr, text, num_text);
220    }
221
222
223    /* write all chunks up to (but not including) first IDAT */
224
225    png_write_info(png_ptr, info_ptr);
226
227
228    /* if we wanted to write any more text info *after* the image data, we
229     * would set up text struct(s) here and call png_set_text() again, with
230     * just the new data; png_set_tIME() could also go here, but it would
231     * have no effect since we already called it above (only one tIME chunk
232     * allowed) */
233
234
235    /* set up the transformations:  for now, just pack low-bit-depth pixels
236     * into bytes (one, two or four pixels per byte) */
237
238    png_set_packing(png_ptr);
239/*  png_set_shift(png_ptr, &sig_bit);  to scale low-bit-depth values */
240
241
242    /* make sure we save our pointers for use in writepng_encode_image() */
243
244    mainprog_ptr->png_ptr = png_ptr;
245    mainprog_ptr->info_ptr = info_ptr;
246
247
248    /* OK, that's all we need to do for now; return happy */
249
250    return 0;
251}
252
253
254
255
256
257/* returns 0 for success, 2 for libpng (longjmp) problem */
258
259int writepng_encode_image(mainprog_info *mainprog_ptr)
260{
261    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
262    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
263
264
265    /* as always, setjmp() must be called in every function that calls a
266     * PNG-writing libpng function */
267
268    if (setjmp(mainprog_ptr->jmpbuf)) {
269        png_destroy_write_struct(&png_ptr, &info_ptr);
270        mainprog_ptr->png_ptr = NULL;
271        mainprog_ptr->info_ptr = NULL;
272        return 2;
273    }
274
275
276    /* and now we just write the whole image; libpng takes care of interlacing
277     * for us */
278
279    png_write_image(png_ptr, mainprog_ptr->row_pointers);
280
281
282    /* since that's it, we also close out the end of the PNG file now--if we
283     * had any text or time info to write after the IDATs, second argument
284     * would be info_ptr, but we optimize slightly by sending NULL pointer: */
285
286    png_write_end(png_ptr, NULL);
287
288    return 0;
289}
290
291
292
293
294
295/* returns 0 if succeeds, 2 if libpng problem */
296
297int writepng_encode_row(mainprog_info *mainprog_ptr)  /* NON-interlaced only! */
298{
299    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
300    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
301
302
303    /* as always, setjmp() must be called in every function that calls a
304     * PNG-writing libpng function */
305
306    if (setjmp(mainprog_ptr->jmpbuf)) {
307        png_destroy_write_struct(&png_ptr, &info_ptr);
308        mainprog_ptr->png_ptr = NULL;
309        mainprog_ptr->info_ptr = NULL;
310        return 2;
311    }
312
313
314    /* image_data points at our one row of image data */
315
316    png_write_row(png_ptr, mainprog_ptr->image_data);
317
318    return 0;
319}
320
321
322
323
324
325/* returns 0 if succeeds, 2 if libpng problem */
326
327int writepng_encode_finish(mainprog_info *mainprog_ptr)   /* NON-interlaced! */
328{
329    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
330    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
331
332
333    /* as always, setjmp() must be called in every function that calls a
334     * PNG-writing libpng function */
335
336    if (setjmp(mainprog_ptr->jmpbuf)) {
337        png_destroy_write_struct(&png_ptr, &info_ptr);
338        mainprog_ptr->png_ptr = NULL;
339        mainprog_ptr->info_ptr = NULL;
340        return 2;
341    }
342
343
344    /* close out PNG file; if we had any text or time info to write after
345     * the IDATs, second argument would be info_ptr: */
346
347    png_write_end(png_ptr, NULL);
348
349    return 0;
350}
351
352
353
354
355
356void writepng_cleanup(mainprog_info *mainprog_ptr)
357{
358    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
359    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
360
361    if (png_ptr && info_ptr)
362        png_destroy_write_struct(&png_ptr, &info_ptr);
363}
364
365
366
367
368
369static void writepng_error_handler(png_structp png_ptr, png_const_charp msg)
370{
371    mainprog_info  *mainprog_ptr;
372
373    /* This function, aside from the extra step of retrieving the "error
374     * pointer" (below) and the fact that it exists within the application
375     * rather than within libpng, is essentially identical to libpng's
376     * default error handler.  The second point is critical:  since both
377     * setjmp() and longjmp() are called from the same code, they are
378     * guaranteed to have compatible notions of how big a jmp_buf is,
379     * regardless of whether _BSD_SOURCE or anything else has (or has not)
380     * been defined. */
381
382    fprintf(stderr, "writepng libpng error: %s\n", msg);
383    fflush(stderr);
384
385    mainprog_ptr = png_get_error_ptr(png_ptr);
386    if (mainprog_ptr == NULL) {         /* we are completely hosed now */
387        fprintf(stderr,
388          "writepng severe error:  jmpbuf not recoverable; terminating.\n");
389        fflush(stderr);
390        exit(99);
391    }
392
393    /* Now we have our data structure we can use the information in it
394     * to return control to our own higher level code (all the points
395     * where 'setjmp' is called in this file.)  This will work with other
396     * error handling mechanisms as well - libpng always calls png_error
397     * when it can proceed no further, thus, so long as the error handler
398     * is intercepted, application code can do its own error recovery.
399     */
400    longjmp(mainprog_ptr->jmpbuf, 1);
401}
402