openjp2/j2k: Report error if all wanted components are not decoded.
[openjpeg.git] / thirdparty / libpng / pngwrite.c
1
2 /* pngwrite.c - general routines to write a PNG file
3  *
4  * Last changed in libpng 1.6.24 [August 4, 2016]
5  * Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson
6  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
7  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
8  *
9  * This code is released under the libpng license.
10  * For conditions of distribution and use, see the disclaimer
11  * and license in png.h
12  */
13
14 #include "pngpriv.h"
15 #ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
16 #  include <errno.h>
17 #endif /* SIMPLIFIED_WRITE_STDIO */
18
19 #ifdef PNG_WRITE_SUPPORTED
20
21 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
22 /* Write out all the unknown chunks for the current given location */
23 static void
24 write_unknown_chunks(png_structrp png_ptr, png_const_inforp info_ptr,
25     unsigned int where)
26 {
27    if (info_ptr->unknown_chunks_num != 0)
28    {
29       png_const_unknown_chunkp up;
30
31       png_debug(5, "writing extra chunks");
32
33       for (up = info_ptr->unknown_chunks;
34            up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
35            ++up)
36          if ((up->location & where) != 0)
37       {
38          /* If per-chunk unknown chunk handling is enabled use it, otherwise
39           * just write the chunks the application has set.
40           */
41 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
42          int keep = png_handle_as_unknown(png_ptr, up->name);
43
44          /* NOTE: this code is radically different from the read side in the
45           * matter of handling an ancillary unknown chunk.  In the read side
46           * the default behavior is to discard it, in the code below the default
47           * behavior is to write it.  Critical chunks are, however, only
48           * written if explicitly listed or if the default is set to write all
49           * unknown chunks.
50           *
51           * The default handling is also slightly weird - it is not possible to
52           * stop the writing of all unsafe-to-copy chunks!
53           *
54           * TODO: REVIEW: this would seem to be a bug.
55           */
56          if (keep != PNG_HANDLE_CHUNK_NEVER &&
57              ((up->name[3] & 0x20) /* safe-to-copy overrides everything */ ||
58               keep == PNG_HANDLE_CHUNK_ALWAYS ||
59               (keep == PNG_HANDLE_CHUNK_AS_DEFAULT &&
60                png_ptr->unknown_default == PNG_HANDLE_CHUNK_ALWAYS)))
61 #endif
62          {
63             /* TODO: review, what is wrong with a zero length unknown chunk? */
64             if (up->size == 0)
65                png_warning(png_ptr, "Writing zero-length unknown chunk");
66
67             png_write_chunk(png_ptr, up->name, up->data, up->size);
68          }
69       }
70    }
71 }
72 #endif /* WRITE_UNKNOWN_CHUNKS */
73
74 /* Writes all the PNG information.  This is the suggested way to use the
75  * library.  If you have a new chunk to add, make a function to write it,
76  * and put it in the correct location here.  If you want the chunk written
77  * after the image data, put it in png_write_end().  I strongly encourage
78  * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing
79  * the chunk, as that will keep the code from breaking if you want to just
80  * write a plain PNG file.  If you have long comments, I suggest writing
81  * them in png_write_end(), and compressing them.
82  */
83 void PNGAPI
84 png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
85 {
86    png_debug(1, "in png_write_info_before_PLTE");
87
88    if (png_ptr == NULL || info_ptr == NULL)
89       return;
90
91    if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
92    {
93       /* Write PNG signature */
94       png_write_sig(png_ptr);
95
96 #ifdef PNG_MNG_FEATURES_SUPPORTED
97       if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 && \
98           png_ptr->mng_features_permitted != 0)
99       {
100          png_warning(png_ptr,
101              "MNG features are not allowed in a PNG datastream");
102          png_ptr->mng_features_permitted = 0;
103       }
104 #endif
105
106       /* Write IHDR information. */
107       png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
108           info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
109           info_ptr->filter_type,
110 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
111           info_ptr->interlace_type
112 #else
113           0
114 #endif
115          );
116
117       /* The rest of these check to see if the valid field has the appropriate
118        * flag set, and if it does, writes the chunk.
119        *
120        * 1.6.0: COLORSPACE support controls the writing of these chunks too, and
121        * the chunks will be written if the WRITE routine is there and
122        * information * is available in the COLORSPACE. (See
123        * png_colorspace_sync_info in png.c for where the valid flags get set.)
124        *
125        * Under certain circumstances the colorspace can be invalidated without
126        * syncing the info_struct 'valid' flags; this happens if libpng detects
127        * an error and calls png_error while the color space is being set, yet
128        * the application continues writing the PNG.  So check the 'invalid'
129        * flag here too.
130        */
131 #ifdef PNG_GAMMA_SUPPORTED
132 #  ifdef PNG_WRITE_gAMA_SUPPORTED
133       if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
134           (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_gAMA) != 0 &&
135           (info_ptr->valid & PNG_INFO_gAMA) != 0)
136          png_write_gAMA_fixed(png_ptr, info_ptr->colorspace.gamma);
137 #  endif
138 #endif
139
140 #ifdef PNG_COLORSPACE_SUPPORTED
141       /* Write only one of sRGB or an ICC profile.  If a profile was supplied
142        * and it matches one of the known sRGB ones issue a warning.
143        */
144 #  ifdef PNG_WRITE_iCCP_SUPPORTED
145          if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
146              (info_ptr->valid & PNG_INFO_iCCP) != 0)
147          {
148 #    ifdef PNG_WRITE_sRGB_SUPPORTED
149                if ((info_ptr->valid & PNG_INFO_sRGB) != 0)
150                   png_app_warning(png_ptr,
151                       "profile matches sRGB but writing iCCP instead");
152 #     endif
153
154             png_write_iCCP(png_ptr, info_ptr->iccp_name,
155                 info_ptr->iccp_profile);
156          }
157 #     ifdef PNG_WRITE_sRGB_SUPPORTED
158          else
159 #     endif
160 #  endif
161
162 #  ifdef PNG_WRITE_sRGB_SUPPORTED
163          if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
164              (info_ptr->valid & PNG_INFO_sRGB) != 0)
165             png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent);
166 #  endif /* WRITE_sRGB */
167 #endif /* COLORSPACE */
168
169 #ifdef PNG_WRITE_sBIT_SUPPORTED
170          if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
171             png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
172 #endif
173
174 #ifdef PNG_COLORSPACE_SUPPORTED
175 #  ifdef PNG_WRITE_cHRM_SUPPORTED
176          if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
177              (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0 &&
178              (info_ptr->valid & PNG_INFO_cHRM) != 0)
179             png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy);
180 #  endif
181 #endif
182
183 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
184          write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR);
185 #endif
186
187       png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
188    }
189 }
190
191 void PNGAPI
192 png_write_info(png_structrp png_ptr, png_const_inforp info_ptr)
193 {
194 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
195    int i;
196 #endif
197
198    png_debug(1, "in png_write_info");
199
200    if (png_ptr == NULL || info_ptr == NULL)
201       return;
202
203    png_write_info_before_PLTE(png_ptr, info_ptr);
204
205    if ((info_ptr->valid & PNG_INFO_PLTE) != 0)
206       png_write_PLTE(png_ptr, info_ptr->palette,
207           (png_uint_32)info_ptr->num_palette);
208
209    else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
210       png_error(png_ptr, "Valid palette required for paletted images");
211
212 #ifdef PNG_WRITE_tRNS_SUPPORTED
213    if ((info_ptr->valid & PNG_INFO_tRNS) !=0)
214    {
215 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
216       /* Invert the alpha channel (in tRNS) */
217       if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0 &&
218           info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
219       {
220          int j, jend;
221
222          jend = info_ptr->num_trans;
223          if (jend > PNG_MAX_PALETTE_LENGTH)
224             jend = PNG_MAX_PALETTE_LENGTH;
225
226          for (j = 0; j<jend; ++j)
227             info_ptr->trans_alpha[j] =
228                (png_byte)(255 - info_ptr->trans_alpha[j]);
229       }
230 #endif
231       png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),
232           info_ptr->num_trans, info_ptr->color_type);
233    }
234 #endif
235 #ifdef PNG_WRITE_bKGD_SUPPORTED
236    if ((info_ptr->valid & PNG_INFO_bKGD) != 0)
237       png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
238 #endif
239
240 #ifdef PNG_WRITE_hIST_SUPPORTED
241    if ((info_ptr->valid & PNG_INFO_hIST) != 0)
242       png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
243 #endif
244
245 #ifdef PNG_WRITE_oFFs_SUPPORTED
246    if ((info_ptr->valid & PNG_INFO_oFFs) != 0)
247       png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
248           info_ptr->offset_unit_type);
249 #endif
250
251 #ifdef PNG_WRITE_pCAL_SUPPORTED
252    if ((info_ptr->valid & PNG_INFO_pCAL) != 0)
253       png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
254           info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
255           info_ptr->pcal_units, info_ptr->pcal_params);
256 #endif
257
258 #ifdef PNG_WRITE_sCAL_SUPPORTED
259    if ((info_ptr->valid & PNG_INFO_sCAL) != 0)
260       png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
261           info_ptr->scal_s_width, info_ptr->scal_s_height);
262 #endif /* sCAL */
263
264 #ifdef PNG_WRITE_pHYs_SUPPORTED
265    if ((info_ptr->valid & PNG_INFO_pHYs) != 0)
266       png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
267           info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
268 #endif /* pHYs */
269
270 #ifdef PNG_WRITE_tIME_SUPPORTED
271    if ((info_ptr->valid & PNG_INFO_tIME) != 0)
272    {
273       png_write_tIME(png_ptr, &(info_ptr->mod_time));
274       png_ptr->mode |= PNG_WROTE_tIME;
275    }
276 #endif /* tIME */
277
278 #ifdef PNG_WRITE_sPLT_SUPPORTED
279    if ((info_ptr->valid & PNG_INFO_sPLT) != 0)
280       for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
281          png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
282 #endif /* sPLT */
283
284 #ifdef PNG_WRITE_TEXT_SUPPORTED
285    /* Check to see if we need to write text chunks */
286    for (i = 0; i < info_ptr->num_text; i++)
287    {
288       png_debug2(2, "Writing header text chunk %d, type %d", i,
289           info_ptr->text[i].compression);
290       /* An internationalized chunk? */
291       if (info_ptr->text[i].compression > 0)
292       {
293 #ifdef PNG_WRITE_iTXt_SUPPORTED
294          /* Write international chunk */
295          png_write_iTXt(png_ptr,
296              info_ptr->text[i].compression,
297              info_ptr->text[i].key,
298              info_ptr->text[i].lang,
299              info_ptr->text[i].lang_key,
300              info_ptr->text[i].text);
301          /* Mark this chunk as written */
302          if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
303             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
304          else
305             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
306 #else
307          png_warning(png_ptr, "Unable to write international text");
308 #endif
309       }
310
311       /* If we want a compressed text chunk */
312       else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
313       {
314 #ifdef PNG_WRITE_zTXt_SUPPORTED
315          /* Write compressed chunk */
316          png_write_zTXt(png_ptr, info_ptr->text[i].key,
317              info_ptr->text[i].text, info_ptr->text[i].compression);
318          /* Mark this chunk as written */
319          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
320 #else
321          png_warning(png_ptr, "Unable to write compressed text");
322 #endif
323       }
324
325       else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
326       {
327 #ifdef PNG_WRITE_tEXt_SUPPORTED
328          /* Write uncompressed chunk */
329          png_write_tEXt(png_ptr, info_ptr->text[i].key,
330              info_ptr->text[i].text,
331              0);
332          /* Mark this chunk as written */
333          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
334 #else
335          /* Can't get here */
336          png_warning(png_ptr, "Unable to write uncompressed text");
337 #endif
338       }
339    }
340 #endif /* tEXt */
341
342 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
343    write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_PLTE);
344 #endif
345 }
346
347 /* Writes the end of the PNG file.  If you don't want to write comments or
348  * time information, you can pass NULL for info.  If you already wrote these
349  * in png_write_info(), do not write them again here.  If you have long
350  * comments, I suggest writing them here, and compressing them.
351  */
352 void PNGAPI
353 png_write_end(png_structrp png_ptr, png_inforp info_ptr)
354 {
355    png_debug(1, "in png_write_end");
356
357    if (png_ptr == NULL)
358       return;
359
360    if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
361       png_error(png_ptr, "No IDATs written into file");
362
363 #ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
364    if (png_ptr->num_palette_max > png_ptr->num_palette)
365       png_benign_error(png_ptr, "Wrote palette index exceeding num_palette");
366 #endif
367
368    /* See if user wants us to write information chunks */
369    if (info_ptr != NULL)
370    {
371 #ifdef PNG_WRITE_TEXT_SUPPORTED
372       int i; /* local index variable */
373 #endif
374 #ifdef PNG_WRITE_tIME_SUPPORTED
375       /* Check to see if user has supplied a time chunk */
376       if ((info_ptr->valid & PNG_INFO_tIME) != 0 &&
377           (png_ptr->mode & PNG_WROTE_tIME) == 0)
378          png_write_tIME(png_ptr, &(info_ptr->mod_time));
379
380 #endif
381 #ifdef PNG_WRITE_TEXT_SUPPORTED
382       /* Loop through comment chunks */
383       for (i = 0; i < info_ptr->num_text; i++)
384       {
385          png_debug2(2, "Writing trailer text chunk %d, type %d", i,
386              info_ptr->text[i].compression);
387          /* An internationalized chunk? */
388          if (info_ptr->text[i].compression > 0)
389          {
390 #ifdef PNG_WRITE_iTXt_SUPPORTED
391             /* Write international chunk */
392             png_write_iTXt(png_ptr,
393                 info_ptr->text[i].compression,
394                 info_ptr->text[i].key,
395                 info_ptr->text[i].lang,
396                 info_ptr->text[i].lang_key,
397                 info_ptr->text[i].text);
398             /* Mark this chunk as written */
399             if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
400                info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
401             else
402                info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
403 #else
404             png_warning(png_ptr, "Unable to write international text");
405 #endif
406          }
407
408          else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)
409          {
410 #ifdef PNG_WRITE_zTXt_SUPPORTED
411             /* Write compressed chunk */
412             png_write_zTXt(png_ptr, info_ptr->text[i].key,
413                 info_ptr->text[i].text, info_ptr->text[i].compression);
414             /* Mark this chunk as written */
415             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
416 #else
417             png_warning(png_ptr, "Unable to write compressed text");
418 #endif
419          }
420
421          else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
422          {
423 #ifdef PNG_WRITE_tEXt_SUPPORTED
424             /* Write uncompressed chunk */
425             png_write_tEXt(png_ptr, info_ptr->text[i].key,
426                 info_ptr->text[i].text, 0);
427             /* Mark this chunk as written */
428             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
429 #else
430             png_warning(png_ptr, "Unable to write uncompressed text");
431 #endif
432          }
433       }
434 #endif
435 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
436       write_unknown_chunks(png_ptr, info_ptr, PNG_AFTER_IDAT);
437 #endif
438    }
439
440    png_ptr->mode |= PNG_AFTER_IDAT;
441
442    /* Write end of PNG file */
443    png_write_IEND(png_ptr);
444
445    /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,
446     * and restored again in libpng-1.2.30, may cause some applications that
447     * do not set png_ptr->output_flush_fn to crash.  If your application
448     * experiences a problem, please try building libpng with
449     * PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to
450     * png-mng-implement at lists.sf.net .
451     */
452 #ifdef PNG_WRITE_FLUSH_SUPPORTED
453 #  ifdef PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED
454    png_flush(png_ptr);
455 #  endif
456 #endif
457 }
458
459 #ifdef PNG_CONVERT_tIME_SUPPORTED
460 void PNGAPI
461 png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm * ttime)
462 {
463    png_debug(1, "in png_convert_from_struct_tm");
464
465    ptime->year = (png_uint_16)(1900 + ttime->tm_year);
466    ptime->month = (png_byte)(ttime->tm_mon + 1);
467    ptime->day = (png_byte)ttime->tm_mday;
468    ptime->hour = (png_byte)ttime->tm_hour;
469    ptime->minute = (png_byte)ttime->tm_min;
470    ptime->second = (png_byte)ttime->tm_sec;
471 }
472
473 void PNGAPI
474 png_convert_from_time_t(png_timep ptime, time_t ttime)
475 {
476    struct tm *tbuf;
477
478    png_debug(1, "in png_convert_from_time_t");
479
480    tbuf = gmtime(&ttime);
481    png_convert_from_struct_tm(ptime, tbuf);
482 }
483 #endif
484
485 /* Initialize png_ptr structure, and allocate any memory needed */
486 PNG_FUNCTION(png_structp,PNGAPI
487 png_create_write_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
488     png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)
489 {
490 #ifndef PNG_USER_MEM_SUPPORTED
491    png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
492        error_fn, warn_fn, NULL, NULL, NULL);
493 #else
494    return png_create_write_struct_2(user_png_ver, error_ptr, error_fn,
495        warn_fn, NULL, NULL, NULL);
496 }
497
498 /* Alternate initialize png_ptr structure, and allocate any memory needed */
499 PNG_FUNCTION(png_structp,PNGAPI
500 png_create_write_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
501     png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
502     png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
503 {
504    png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
505        error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
506 #endif /* USER_MEM */
507    if (png_ptr != NULL)
508    {
509       /* Set the zlib control values to defaults; they can be overridden by the
510        * application after the struct has been created.
511        */
512       png_ptr->zbuffer_size = PNG_ZBUF_SIZE;
513
514       /* The 'zlib_strategy' setting is irrelevant because png_default_claim in
515        * pngwutil.c defaults it according to whether or not filters will be
516        * used, and ignores this setting.
517        */
518       png_ptr->zlib_strategy = PNG_Z_DEFAULT_STRATEGY;
519       png_ptr->zlib_level = PNG_Z_DEFAULT_COMPRESSION;
520       png_ptr->zlib_mem_level = 8;
521       png_ptr->zlib_window_bits = 15;
522       png_ptr->zlib_method = 8;
523
524 #ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
525       png_ptr->zlib_text_strategy = PNG_TEXT_Z_DEFAULT_STRATEGY;
526       png_ptr->zlib_text_level = PNG_TEXT_Z_DEFAULT_COMPRESSION;
527       png_ptr->zlib_text_mem_level = 8;
528       png_ptr->zlib_text_window_bits = 15;
529       png_ptr->zlib_text_method = 8;
530 #endif /* WRITE_COMPRESSED_TEXT */
531
532       /* This is a highly dubious configuration option; by default it is off,
533        * but it may be appropriate for private builds that are testing
534        * extensions not conformant to the current specification, or of
535        * applications that must not fail to write at all costs!
536        */
537 #ifdef PNG_BENIGN_WRITE_ERRORS_SUPPORTED
538       /* In stable builds only warn if an application error can be completely
539        * handled.
540        */
541       png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
542 #endif
543
544       /* App warnings are warnings in release (or release candidate) builds but
545        * are errors during development.
546        */
547 #if PNG_RELEASE_BUILD
548       png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;
549 #endif
550
551       /* TODO: delay this, it can be done in png_init_io() (if the app doesn't
552        * do it itself) avoiding setting the default function if it is not
553        * required.
554        */
555       png_set_write_fn(png_ptr, NULL, NULL, NULL);
556    }
557
558    return png_ptr;
559 }
560
561
562 /* Write a few rows of image data.  If the image is interlaced,
563  * either you will have to write the 7 sub images, or, if you
564  * have called png_set_interlace_handling(), you will have to
565  * "write" the image seven times.
566  */
567 void PNGAPI
568 png_write_rows(png_structrp png_ptr, png_bytepp row,
569     png_uint_32 num_rows)
570 {
571    png_uint_32 i; /* row counter */
572    png_bytepp rp; /* row pointer */
573
574    png_debug(1, "in png_write_rows");
575
576    if (png_ptr == NULL)
577       return;
578
579    /* Loop through the rows */
580    for (i = 0, rp = row; i < num_rows; i++, rp++)
581    {
582       png_write_row(png_ptr, *rp);
583    }
584 }
585
586 /* Write the image.  You only need to call this function once, even
587  * if you are writing an interlaced image.
588  */
589 void PNGAPI
590 png_write_image(png_structrp png_ptr, png_bytepp image)
591 {
592    png_uint_32 i; /* row index */
593    int pass, num_pass; /* pass variables */
594    png_bytepp rp; /* points to current row */
595
596    if (png_ptr == NULL)
597       return;
598
599    png_debug(1, "in png_write_image");
600
601 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
602    /* Initialize interlace handling.  If image is not interlaced,
603     * this will set pass to 1
604     */
605    num_pass = png_set_interlace_handling(png_ptr);
606 #else
607    num_pass = 1;
608 #endif
609    /* Loop through passes */
610    for (pass = 0; pass < num_pass; pass++)
611    {
612       /* Loop through image */
613       for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
614       {
615          png_write_row(png_ptr, *rp);
616       }
617    }
618 }
619
620 #ifdef PNG_MNG_FEATURES_SUPPORTED
621 /* Performs intrapixel differencing  */
622 static void
623 png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
624 {
625    png_debug(1, "in png_do_write_intrapixel");
626
627    if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
628    {
629       int bytes_per_pixel;
630       png_uint_32 row_width = row_info->width;
631       if (row_info->bit_depth == 8)
632       {
633          png_bytep rp;
634          png_uint_32 i;
635
636          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
637             bytes_per_pixel = 3;
638
639          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
640             bytes_per_pixel = 4;
641
642          else
643             return;
644
645          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
646          {
647             *(rp)     = (png_byte)(*rp       - *(rp + 1));
648             *(rp + 2) = (png_byte)(*(rp + 2) - *(rp + 1));
649          }
650       }
651
652 #ifdef PNG_WRITE_16BIT_SUPPORTED
653       else if (row_info->bit_depth == 16)
654       {
655          png_bytep rp;
656          png_uint_32 i;
657
658          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
659             bytes_per_pixel = 6;
660
661          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
662             bytes_per_pixel = 8;
663
664          else
665             return;
666
667          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
668          {
669             png_uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);
670             png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);
671             png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);
672             png_uint_32 red  = (png_uint_32)((s0 - s1) & 0xffffL);
673             png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);
674             *(rp    ) = (png_byte)(red >> 8);
675             *(rp + 1) = (png_byte)red;
676             *(rp + 4) = (png_byte)(blue >> 8);
677             *(rp + 5) = (png_byte)blue;
678          }
679       }
680 #endif /* WRITE_16BIT */
681    }
682 }
683 #endif /* MNG_FEATURES */
684
685 /* Called by user to write a row of image data */
686 void PNGAPI
687 png_write_row(png_structrp png_ptr, png_const_bytep row)
688 {
689    /* 1.5.6: moved from png_struct to be a local structure: */
690    png_row_info row_info;
691
692    if (png_ptr == NULL)
693       return;
694
695    png_debug2(1, "in png_write_row (row %u, pass %d)",
696        png_ptr->row_number, png_ptr->pass);
697
698    /* Initialize transformations and other stuff if first time */
699    if (png_ptr->row_number == 0 && png_ptr->pass == 0)
700    {
701       /* Make sure we wrote the header info */
702       if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
703          png_error(png_ptr,
704              "png_write_info was never called before png_write_row");
705
706       /* Check for transforms that have been set but were defined out */
707 #if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
708       if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
709          png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined");
710 #endif
711
712 #if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
713       if ((png_ptr->transformations & PNG_FILLER) != 0)
714          png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined");
715 #endif
716 #if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
717     defined(PNG_READ_PACKSWAP_SUPPORTED)
718       if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
719          png_warning(png_ptr,
720              "PNG_WRITE_PACKSWAP_SUPPORTED is not defined");
721 #endif
722
723 #if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
724       if ((png_ptr->transformations & PNG_PACK) != 0)
725          png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined");
726 #endif
727
728 #if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
729       if ((png_ptr->transformations & PNG_SHIFT) != 0)
730          png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined");
731 #endif
732
733 #if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
734       if ((png_ptr->transformations & PNG_BGR) != 0)
735          png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined");
736 #endif
737
738 #if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
739       if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
740          png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined");
741 #endif
742
743       png_write_start_row(png_ptr);
744    }
745
746 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
747    /* If interlaced and not interested in row, return */
748    if (png_ptr->interlaced != 0 &&
749        (png_ptr->transformations & PNG_INTERLACE) != 0)
750    {
751       switch (png_ptr->pass)
752       {
753          case 0:
754             if ((png_ptr->row_number & 0x07) != 0)
755             {
756                png_write_finish_row(png_ptr);
757                return;
758             }
759             break;
760
761          case 1:
762             if ((png_ptr->row_number & 0x07) != 0 || png_ptr->width < 5)
763             {
764                png_write_finish_row(png_ptr);
765                return;
766             }
767             break;
768
769          case 2:
770             if ((png_ptr->row_number & 0x07) != 4)
771             {
772                png_write_finish_row(png_ptr);
773                return;
774             }
775             break;
776
777          case 3:
778             if ((png_ptr->row_number & 0x03) != 0 || png_ptr->width < 3)
779             {
780                png_write_finish_row(png_ptr);
781                return;
782             }
783             break;
784
785          case 4:
786             if ((png_ptr->row_number & 0x03) != 2)
787             {
788                png_write_finish_row(png_ptr);
789                return;
790             }
791             break;
792
793          case 5:
794             if ((png_ptr->row_number & 0x01) != 0 || png_ptr->width < 2)
795             {
796                png_write_finish_row(png_ptr);
797                return;
798             }
799             break;
800
801          case 6:
802             if ((png_ptr->row_number & 0x01) == 0)
803             {
804                png_write_finish_row(png_ptr);
805                return;
806             }
807             break;
808
809          default: /* error: ignore it */
810             break;
811       }
812    }
813 #endif
814
815    /* Set up row info for transformations */
816    row_info.color_type = png_ptr->color_type;
817    row_info.width = png_ptr->usr_width;
818    row_info.channels = png_ptr->usr_channels;
819    row_info.bit_depth = png_ptr->usr_bit_depth;
820    row_info.pixel_depth = (png_byte)(row_info.bit_depth * row_info.channels);
821    row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
822
823    png_debug1(3, "row_info->color_type = %d", row_info.color_type);
824    png_debug1(3, "row_info->width = %u", row_info.width);
825    png_debug1(3, "row_info->channels = %d", row_info.channels);
826    png_debug1(3, "row_info->bit_depth = %d", row_info.bit_depth);
827    png_debug1(3, "row_info->pixel_depth = %d", row_info.pixel_depth);
828    png_debug1(3, "row_info->rowbytes = %lu", (unsigned long)row_info.rowbytes);
829
830    /* Copy user's row into buffer, leaving room for filter byte. */
831    memcpy(png_ptr->row_buf + 1, row, row_info.rowbytes);
832
833 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
834    /* Handle interlacing */
835    if (png_ptr->interlaced && png_ptr->pass < 6 &&
836        (png_ptr->transformations & PNG_INTERLACE) != 0)
837    {
838       png_do_write_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass);
839       /* This should always get caught above, but still ... */
840       if (row_info.width == 0)
841       {
842          png_write_finish_row(png_ptr);
843          return;
844       }
845    }
846 #endif
847
848 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
849    /* Handle other transformations */
850    if (png_ptr->transformations != 0)
851       png_do_write_transformations(png_ptr, &row_info);
852 #endif
853
854    /* At this point the row_info pixel depth must match the 'transformed' depth,
855     * which is also the output depth.
856     */
857    if (row_info.pixel_depth != png_ptr->pixel_depth ||
858        row_info.pixel_depth != png_ptr->transformed_pixel_depth)
859       png_error(png_ptr, "internal write transform logic error");
860
861 #ifdef PNG_MNG_FEATURES_SUPPORTED
862    /* Write filter_method 64 (intrapixel differencing) only if
863     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
864     * 2. Libpng did not write a PNG signature (this filter_method is only
865     *    used in PNG datastreams that are embedded in MNG datastreams) and
866     * 3. The application called png_permit_mng_features with a mask that
867     *    included PNG_FLAG_MNG_FILTER_64 and
868     * 4. The filter_method is 64 and
869     * 5. The color_type is RGB or RGBA
870     */
871    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
872        (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
873    {
874       /* Intrapixel differencing */
875       png_do_write_intrapixel(&row_info, png_ptr->row_buf + 1);
876    }
877 #endif
878
879 /* Added at libpng-1.5.10 */
880 #ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
881    /* Check for out-of-range palette index */
882    if (row_info.color_type == PNG_COLOR_TYPE_PALETTE &&
883        png_ptr->num_palette_max >= 0)
884       png_do_check_palette_indexes(png_ptr, &row_info);
885 #endif
886
887    /* Find a filter if necessary, filter the row and write it out. */
888    png_write_find_filter(png_ptr, &row_info);
889
890    if (png_ptr->write_row_fn != NULL)
891       (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
892 }
893
894 #ifdef PNG_WRITE_FLUSH_SUPPORTED
895 /* Set the automatic flush interval or 0 to turn flushing off */
896 void PNGAPI
897 png_set_flush(png_structrp png_ptr, int nrows)
898 {
899    png_debug(1, "in png_set_flush");
900
901    if (png_ptr == NULL)
902       return;
903
904    png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
905 }
906
907 /* Flush the current output buffers now */
908 void PNGAPI
909 png_write_flush(png_structrp png_ptr)
910 {
911    png_debug(1, "in png_write_flush");
912
913    if (png_ptr == NULL)
914       return;
915
916    /* We have already written out all of the data */
917    if (png_ptr->row_number >= png_ptr->num_rows)
918       return;
919
920    png_compress_IDAT(png_ptr, NULL, 0, Z_SYNC_FLUSH);
921    png_ptr->flush_rows = 0;
922    png_flush(png_ptr);
923 }
924 #endif /* WRITE_FLUSH */
925
926 /* Free any memory used in png_ptr struct without freeing the struct itself. */
927 static void
928 png_write_destroy(png_structrp png_ptr)
929 {
930    png_debug(1, "in png_write_destroy");
931
932    /* Free any memory zlib uses */
933    if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)
934       deflateEnd(&png_ptr->zstream);
935
936    /* Free our memory.  png_free checks NULL for us. */
937    png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);
938    png_free(png_ptr, png_ptr->row_buf);
939    png_ptr->row_buf = NULL;
940 #ifdef PNG_WRITE_FILTER_SUPPORTED
941    png_free(png_ptr, png_ptr->prev_row);
942    png_free(png_ptr, png_ptr->try_row);
943    png_free(png_ptr, png_ptr->tst_row);
944    png_ptr->prev_row = NULL;
945    png_ptr->try_row = NULL;
946    png_ptr->tst_row = NULL;
947 #endif
948
949 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
950    png_free(png_ptr, png_ptr->chunk_list);
951    png_ptr->chunk_list = NULL;
952 #endif
953
954    /* The error handling and memory handling information is left intact at this
955     * point: the jmp_buf may still have to be freed.  See png_destroy_png_struct
956     * for how this happens.
957     */
958 }
959
960 /* Free all memory used by the write.
961  * In libpng 1.6.0 this API changed quietly to no longer accept a NULL value for
962  * *png_ptr_ptr.  Prior to 1.6.0 it would accept such a value and it would free
963  * the passed in info_structs but it would quietly fail to free any of the data
964  * inside them.  In 1.6.0 it quietly does nothing (it has to be quiet because it
965  * has no png_ptr.)
966  */
967 void PNGAPI
968 png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
969 {
970    png_debug(1, "in png_destroy_write_struct");
971
972    if (png_ptr_ptr != NULL)
973    {
974       png_structrp png_ptr = *png_ptr_ptr;
975
976       if (png_ptr != NULL) /* added in libpng 1.6.0 */
977       {
978          png_destroy_info_struct(png_ptr, info_ptr_ptr);
979
980          *png_ptr_ptr = NULL;
981          png_write_destroy(png_ptr);
982          png_destroy_png_struct(png_ptr);
983       }
984    }
985 }
986
987 /* Allow the application to select one or more row filters to use. */
988 void PNGAPI
989 png_set_filter(png_structrp png_ptr, int method, int filters)
990 {
991    png_debug(1, "in png_set_filter");
992
993    if (png_ptr == NULL)
994       return;
995
996 #ifdef PNG_MNG_FEATURES_SUPPORTED
997    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
998        (method == PNG_INTRAPIXEL_DIFFERENCING))
999       method = PNG_FILTER_TYPE_BASE;
1000
1001 #endif
1002    if (method == PNG_FILTER_TYPE_BASE)
1003    {
1004       switch (filters & (PNG_ALL_FILTERS | 0x07))
1005       {
1006 #ifdef PNG_WRITE_FILTER_SUPPORTED
1007          case 5:
1008          case 6:
1009          case 7: png_app_error(png_ptr, "Unknown row filter for method 0");
1010             /* FALL THROUGH */
1011 #endif /* WRITE_FILTER */
1012          case PNG_FILTER_VALUE_NONE:
1013             png_ptr->do_filter = PNG_FILTER_NONE; break;
1014
1015 #ifdef PNG_WRITE_FILTER_SUPPORTED
1016          case PNG_FILTER_VALUE_SUB:
1017             png_ptr->do_filter = PNG_FILTER_SUB; break;
1018
1019          case PNG_FILTER_VALUE_UP:
1020             png_ptr->do_filter = PNG_FILTER_UP; break;
1021
1022          case PNG_FILTER_VALUE_AVG:
1023             png_ptr->do_filter = PNG_FILTER_AVG; break;
1024
1025          case PNG_FILTER_VALUE_PAETH:
1026             png_ptr->do_filter = PNG_FILTER_PAETH; break;
1027
1028          default:
1029             png_ptr->do_filter = (png_byte)filters; break;
1030 #else
1031          default:
1032             png_app_error(png_ptr, "Unknown row filter for method 0");
1033 #endif /* WRITE_FILTER */
1034       }
1035
1036 #ifdef PNG_WRITE_FILTER_SUPPORTED
1037       /* If we have allocated the row_buf, this means we have already started
1038        * with the image and we should have allocated all of the filter buffers
1039        * that have been selected.  If prev_row isn't already allocated, then
1040        * it is too late to start using the filters that need it, since we
1041        * will be missing the data in the previous row.  If an application
1042        * wants to start and stop using particular filters during compression,
1043        * it should start out with all of the filters, and then remove them
1044        * or add them back after the start of compression.
1045        *
1046        * NOTE: this is a nasty constraint on the code, because it means that the
1047        * prev_row buffer must be maintained even if there are currently no
1048        * 'prev_row' requiring filters active.
1049        */
1050       if (png_ptr->row_buf != NULL)
1051       {
1052          int num_filters;
1053          png_alloc_size_t buf_size;
1054
1055          /* Repeat the checks in png_write_start_row; 1 pixel high or wide
1056           * images cannot benefit from certain filters.  If this isn't done here
1057           * the check below will fire on 1 pixel high images.
1058           */
1059          if (png_ptr->height == 1)
1060             filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);
1061
1062          if (png_ptr->width == 1)
1063             filters &= ~(PNG_FILTER_SUB|PNG_FILTER_AVG|PNG_FILTER_PAETH);
1064
1065          if ((filters & (PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH)) != 0
1066             && png_ptr->prev_row == NULL)
1067          {
1068             /* This is the error case, however it is benign - the previous row
1069              * is not available so the filter can't be used.  Just warn here.
1070              */
1071             png_app_warning(png_ptr,
1072                 "png_set_filter: UP/AVG/PAETH cannot be added after start");
1073             filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);
1074          }
1075
1076          num_filters = 0;
1077
1078          if (filters & PNG_FILTER_SUB)
1079             num_filters++;
1080
1081          if (filters & PNG_FILTER_UP)
1082             num_filters++;
1083
1084          if (filters & PNG_FILTER_AVG)
1085             num_filters++;
1086
1087          if (filters & PNG_FILTER_PAETH)
1088             num_filters++;
1089
1090          /* Allocate needed row buffers if they have not already been
1091           * allocated.
1092           */
1093          buf_size = PNG_ROWBYTES(png_ptr->usr_channels * png_ptr->usr_bit_depth,
1094              png_ptr->width) + 1;
1095
1096          if (png_ptr->try_row == NULL)
1097             png_ptr->try_row = png_voidcast(png_bytep,
1098                 png_malloc(png_ptr, buf_size));
1099
1100          if (num_filters > 1)
1101          {
1102             if (png_ptr->tst_row == NULL)
1103                png_ptr->tst_row = png_voidcast(png_bytep,
1104                    png_malloc(png_ptr, buf_size));
1105          }
1106       }
1107       png_ptr->do_filter = (png_byte)filters;
1108 #endif
1109    }
1110    else
1111       png_error(png_ptr, "Unknown custom filter method");
1112 }
1113
1114 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* DEPRECATED */
1115 /* Provide floating and fixed point APIs */
1116 #ifdef PNG_FLOATING_POINT_SUPPORTED
1117 void PNGAPI
1118 png_set_filter_heuristics(png_structrp png_ptr, int heuristic_method,
1119     int num_weights, png_const_doublep filter_weights,
1120     png_const_doublep filter_costs)
1121 {
1122    PNG_UNUSED(png_ptr)
1123    PNG_UNUSED(heuristic_method)
1124    PNG_UNUSED(num_weights)
1125    PNG_UNUSED(filter_weights)
1126    PNG_UNUSED(filter_costs)
1127 }
1128 #endif /* FLOATING_POINT */
1129
1130 #ifdef PNG_FIXED_POINT_SUPPORTED
1131 void PNGAPI
1132 png_set_filter_heuristics_fixed(png_structrp png_ptr, int heuristic_method,
1133     int num_weights, png_const_fixed_point_p filter_weights,
1134     png_const_fixed_point_p filter_costs)
1135 {
1136    PNG_UNUSED(png_ptr)
1137    PNG_UNUSED(heuristic_method)
1138    PNG_UNUSED(num_weights)
1139    PNG_UNUSED(filter_weights)
1140    PNG_UNUSED(filter_costs)
1141 }
1142 #endif /* FIXED_POINT */
1143 #endif /* WRITE_WEIGHTED_FILTER */
1144
1145 #ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
1146 void PNGAPI
1147 png_set_compression_level(png_structrp png_ptr, int level)
1148 {
1149    png_debug(1, "in png_set_compression_level");
1150
1151    if (png_ptr == NULL)
1152       return;
1153
1154    png_ptr->zlib_level = level;
1155 }
1156
1157 void PNGAPI
1158 png_set_compression_mem_level(png_structrp png_ptr, int mem_level)
1159 {
1160    png_debug(1, "in png_set_compression_mem_level");
1161
1162    if (png_ptr == NULL)
1163       return;
1164
1165    png_ptr->zlib_mem_level = mem_level;
1166 }
1167
1168 void PNGAPI
1169 png_set_compression_strategy(png_structrp png_ptr, int strategy)
1170 {
1171    png_debug(1, "in png_set_compression_strategy");
1172
1173    if (png_ptr == NULL)
1174       return;
1175
1176    /* The flag setting here prevents the libpng dynamic selection of strategy.
1177     */
1178    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
1179    png_ptr->zlib_strategy = strategy;
1180 }
1181
1182 /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
1183  * smaller value of window_bits if it can do so safely.
1184  */
1185 void PNGAPI
1186 png_set_compression_window_bits(png_structrp png_ptr, int window_bits)
1187 {
1188    if (png_ptr == NULL)
1189       return;
1190
1191    /* Prior to 1.6.0 this would warn but then set the window_bits value. This
1192     * meant that negative window bits values could be selected that would cause
1193     * libpng to write a non-standard PNG file with raw deflate or gzip
1194     * compressed IDAT or ancillary chunks.  Such files can be read and there is
1195     * no warning on read, so this seems like a very bad idea.
1196     */
1197    if (window_bits > 15)
1198    {
1199       png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
1200       window_bits = 15;
1201    }
1202
1203    else if (window_bits < 8)
1204    {
1205       png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
1206       window_bits = 8;
1207    }
1208
1209    png_ptr->zlib_window_bits = window_bits;
1210 }
1211
1212 void PNGAPI
1213 png_set_compression_method(png_structrp png_ptr, int method)
1214 {
1215    png_debug(1, "in png_set_compression_method");
1216
1217    if (png_ptr == NULL)
1218       return;
1219
1220    /* This would produce an invalid PNG file if it worked, but it doesn't and
1221     * deflate will fault it, so it is harmless to just warn here.
1222     */
1223    if (method != 8)
1224       png_warning(png_ptr, "Only compression method 8 is supported by PNG");
1225
1226    png_ptr->zlib_method = method;
1227 }
1228 #endif /* WRITE_CUSTOMIZE_COMPRESSION */
1229
1230 /* The following were added to libpng-1.5.4 */
1231 #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
1232 void PNGAPI
1233 png_set_text_compression_level(png_structrp png_ptr, int level)
1234 {
1235    png_debug(1, "in png_set_text_compression_level");
1236
1237    if (png_ptr == NULL)
1238       return;
1239
1240    png_ptr->zlib_text_level = level;
1241 }
1242
1243 void PNGAPI
1244 png_set_text_compression_mem_level(png_structrp png_ptr, int mem_level)
1245 {
1246    png_debug(1, "in png_set_text_compression_mem_level");
1247
1248    if (png_ptr == NULL)
1249       return;
1250
1251    png_ptr->zlib_text_mem_level = mem_level;
1252 }
1253
1254 void PNGAPI
1255 png_set_text_compression_strategy(png_structrp png_ptr, int strategy)
1256 {
1257    png_debug(1, "in png_set_text_compression_strategy");
1258
1259    if (png_ptr == NULL)
1260       return;
1261
1262    png_ptr->zlib_text_strategy = strategy;
1263 }
1264
1265 /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
1266  * smaller value of window_bits if it can do so safely.
1267  */
1268 void PNGAPI
1269 png_set_text_compression_window_bits(png_structrp png_ptr, int window_bits)
1270 {
1271    if (png_ptr == NULL)
1272       return;
1273
1274    if (window_bits > 15)
1275    {
1276       png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
1277       window_bits = 15;
1278    }
1279
1280    else if (window_bits < 8)
1281    {
1282       png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
1283       window_bits = 8;
1284    }
1285
1286    png_ptr->zlib_text_window_bits = window_bits;
1287 }
1288
1289 void PNGAPI
1290 png_set_text_compression_method(png_structrp png_ptr, int method)
1291 {
1292    png_debug(1, "in png_set_text_compression_method");
1293
1294    if (png_ptr == NULL)
1295       return;
1296
1297    if (method != 8)
1298       png_warning(png_ptr, "Only compression method 8 is supported by PNG");
1299
1300    png_ptr->zlib_text_method = method;
1301 }
1302 #endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
1303 /* end of API added to libpng-1.5.4 */
1304
1305 void PNGAPI
1306 png_set_write_status_fn(png_structrp png_ptr, png_write_status_ptr write_row_fn)
1307 {
1308    if (png_ptr == NULL)
1309       return;
1310
1311    png_ptr->write_row_fn = write_row_fn;
1312 }
1313
1314 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
1315 void PNGAPI
1316 png_set_write_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr
1317     write_user_transform_fn)
1318 {
1319    png_debug(1, "in png_set_write_user_transform_fn");
1320
1321    if (png_ptr == NULL)
1322       return;
1323
1324    png_ptr->transformations |= PNG_USER_TRANSFORM;
1325    png_ptr->write_user_transform_fn = write_user_transform_fn;
1326 }
1327 #endif
1328
1329
1330 #ifdef PNG_INFO_IMAGE_SUPPORTED
1331 void PNGAPI
1332 png_write_png(png_structrp png_ptr, png_inforp info_ptr,
1333     int transforms, voidp params)
1334 {
1335    if (png_ptr == NULL || info_ptr == NULL)
1336       return;
1337
1338    if ((info_ptr->valid & PNG_INFO_IDAT) == 0)
1339    {
1340       png_app_error(png_ptr, "no rows for png_write_image to write");
1341       return;
1342    }
1343
1344    /* Write the file header information. */
1345    png_write_info(png_ptr, info_ptr);
1346
1347    /* ------ these transformations don't touch the info structure ------- */
1348
1349    /* Invert monochrome pixels */
1350    if ((transforms & PNG_TRANSFORM_INVERT_MONO) != 0)
1351 #ifdef PNG_WRITE_INVERT_SUPPORTED
1352       png_set_invert_mono(png_ptr);
1353 #else
1354       png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_MONO not supported");
1355 #endif
1356
1357    /* Shift the pixels up to a legal bit depth and fill in
1358     * as appropriate to correctly scale the image.
1359     */
1360    if ((transforms & PNG_TRANSFORM_SHIFT) != 0)
1361 #ifdef PNG_WRITE_SHIFT_SUPPORTED
1362       if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
1363          png_set_shift(png_ptr, &info_ptr->sig_bit);
1364 #else
1365       png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
1366 #endif
1367
1368    /* Pack pixels into bytes */
1369    if ((transforms & PNG_TRANSFORM_PACKING) != 0)
1370 #ifdef PNG_WRITE_PACK_SUPPORTED
1371       png_set_packing(png_ptr);
1372 #else
1373       png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported");
1374 #endif
1375
1376    /* Swap location of alpha bytes from ARGB to RGBA */
1377    if ((transforms & PNG_TRANSFORM_SWAP_ALPHA) != 0)
1378 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
1379       png_set_swap_alpha(png_ptr);
1380 #else
1381       png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ALPHA not supported");
1382 #endif
1383
1384    /* Remove a filler (X) from XRGB/RGBX/AG/GA into to convert it into
1385     * RGB, note that the code expects the input color type to be G or RGB; no
1386     * alpha channel.
1387     */
1388    if ((transforms & (PNG_TRANSFORM_STRIP_FILLER_AFTER|
1389        PNG_TRANSFORM_STRIP_FILLER_BEFORE)) != 0)
1390    {
1391 #ifdef PNG_WRITE_FILLER_SUPPORTED
1392       if ((transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) != 0)
1393       {
1394          if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
1395             png_app_error(png_ptr,
1396                 "PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported");
1397
1398          /* Continue if ignored - this is the pre-1.6.10 behavior */
1399          png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
1400       }
1401
1402       else if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
1403          png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
1404 #else
1405       png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_FILLER not supported");
1406 #endif
1407    }
1408
1409    /* Flip BGR pixels to RGB */
1410    if ((transforms & PNG_TRANSFORM_BGR) != 0)
1411 #ifdef PNG_WRITE_BGR_SUPPORTED
1412       png_set_bgr(png_ptr);
1413 #else
1414       png_app_error(png_ptr, "PNG_TRANSFORM_BGR not supported");
1415 #endif
1416
1417    /* Swap bytes of 16-bit files to most significant byte first */
1418    if ((transforms & PNG_TRANSFORM_SWAP_ENDIAN) != 0)
1419 #ifdef PNG_WRITE_SWAP_SUPPORTED
1420       png_set_swap(png_ptr);
1421 #else
1422       png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ENDIAN not supported");
1423 #endif
1424
1425    /* Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats */
1426    if ((transforms & PNG_TRANSFORM_PACKSWAP) != 0)
1427 #ifdef PNG_WRITE_PACKSWAP_SUPPORTED
1428       png_set_packswap(png_ptr);
1429 #else
1430       png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported");
1431 #endif
1432
1433    /* Invert the alpha channel from opacity to transparency */
1434    if ((transforms & PNG_TRANSFORM_INVERT_ALPHA) != 0)
1435 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
1436       png_set_invert_alpha(png_ptr);
1437 #else
1438       png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_ALPHA not supported");
1439 #endif
1440
1441    /* ----------------------- end of transformations ------------------- */
1442
1443    /* Write the bits */
1444    png_write_image(png_ptr, info_ptr->row_pointers);
1445
1446    /* It is REQUIRED to call this to finish writing the rest of the file */
1447    png_write_end(png_ptr, info_ptr);
1448
1449    PNG_UNUSED(params)
1450 }
1451 #endif
1452
1453
1454 #ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
1455 /* Initialize the write structure - general purpose utility. */
1456 static int
1457 png_image_write_init(png_imagep image)
1458 {
1459    png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, image,
1460        png_safe_error, png_safe_warning);
1461
1462    if (png_ptr != NULL)
1463    {
1464       png_infop info_ptr = png_create_info_struct(png_ptr);
1465
1466       if (info_ptr != NULL)
1467       {
1468          png_controlp control = png_voidcast(png_controlp,
1469              png_malloc_warn(png_ptr, (sizeof *control)));
1470
1471          if (control != NULL)
1472          {
1473             memset(control, 0, (sizeof *control));
1474
1475             control->png_ptr = png_ptr;
1476             control->info_ptr = info_ptr;
1477             control->for_write = 1;
1478
1479             image->opaque = control;
1480             return 1;
1481          }
1482
1483          /* Error clean up */
1484          png_destroy_info_struct(png_ptr, &info_ptr);
1485       }
1486
1487       png_destroy_write_struct(&png_ptr, NULL);
1488    }
1489
1490    return png_image_error(image, "png_image_write_: out of memory");
1491 }
1492
1493 /* Arguments to png_image_write_main: */
1494 typedef struct
1495 {
1496    /* Arguments: */
1497    png_imagep      image;
1498    png_const_voidp buffer;
1499    png_int_32      row_stride;
1500    png_const_voidp colormap;
1501    int             convert_to_8bit;
1502    /* Local variables: */
1503    png_const_voidp first_row;
1504    ptrdiff_t       row_bytes;
1505    png_voidp       local_row;
1506    /* Byte count for memory writing */
1507    png_bytep        memory;
1508    png_alloc_size_t memory_bytes; /* not used for STDIO */
1509    png_alloc_size_t output_bytes; /* running total */
1510 } png_image_write_control;
1511
1512 /* Write png_uint_16 input to a 16-bit PNG; the png_ptr has already been set to
1513  * do any necessary byte swapping.  The component order is defined by the
1514  * png_image format value.
1515  */
1516 static int
1517 png_write_image_16bit(png_voidp argument)
1518 {
1519    png_image_write_control *display = png_voidcast(png_image_write_control*,
1520        argument);
1521    png_imagep image = display->image;
1522    png_structrp png_ptr = image->opaque->png_ptr;
1523
1524    png_const_uint_16p input_row = png_voidcast(png_const_uint_16p,
1525        display->first_row);
1526    png_uint_16p output_row = png_voidcast(png_uint_16p, display->local_row);
1527    png_uint_16p row_end;
1528    const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
1529    int aindex = 0;
1530    png_uint_32 y = image->height;
1531
1532    if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
1533    {
1534 #   ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
1535       if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
1536       {
1537          aindex = -1;
1538          ++input_row; /* To point to the first component */
1539          ++output_row;
1540       }
1541          else
1542             aindex = channels;
1543 #     else
1544          aindex = channels;
1545 #     endif
1546    }
1547
1548    else
1549       png_error(png_ptr, "png_write_image: internal call error");
1550
1551    /* Work out the output row end and count over this, note that the increment
1552     * above to 'row' means that row_end can actually be beyond the end of the
1553     * row; this is correct.
1554     */
1555    row_end = output_row + image->width * (channels+1);
1556
1557    while (y-- > 0)
1558    {
1559       png_const_uint_16p in_ptr = input_row;
1560       png_uint_16p out_ptr = output_row;
1561
1562       while (out_ptr < row_end)
1563       {
1564          const png_uint_16 alpha = in_ptr[aindex];
1565          png_uint_32 reciprocal = 0;
1566          int c;
1567
1568          out_ptr[aindex] = alpha;
1569
1570          /* Calculate a reciprocal.  The correct calculation is simply
1571           * component/alpha*65535 << 15. (I.e. 15 bits of precision); this
1572           * allows correct rounding by adding .5 before the shift.  'reciprocal'
1573           * is only initialized when required.
1574           */
1575          if (alpha > 0 && alpha < 65535)
1576             reciprocal = ((0xffff<<15)+(alpha>>1))/alpha;
1577
1578          c = channels;
1579          do /* always at least one channel */
1580          {
1581             png_uint_16 component = *in_ptr++;
1582
1583             /* The following gives 65535 for an alpha of 0, which is fine,
1584              * otherwise if 0/0 is represented as some other value there is more
1585              * likely to be a discontinuity which will probably damage
1586              * compression when moving from a fully transparent area to a
1587              * nearly transparent one.  (The assumption here is that opaque
1588              * areas tend not to be 0 intensity.)
1589              */
1590             if (component >= alpha)
1591                component = 65535;
1592
1593             /* component<alpha, so component/alpha is less than one and
1594              * component*reciprocal is less than 2^31.
1595              */
1596             else if (component > 0 && alpha < 65535)
1597             {
1598                png_uint_32 calc = component * reciprocal;
1599                calc += 16384; /* round to nearest */
1600                component = (png_uint_16)(calc >> 15);
1601             }
1602
1603             *out_ptr++ = component;
1604          }
1605          while (--c > 0);
1606
1607          /* Skip to next component (skip the intervening alpha channel) */
1608          ++in_ptr;
1609          ++out_ptr;
1610       }
1611
1612       png_write_row(png_ptr, png_voidcast(png_const_bytep, display->local_row));
1613       input_row += display->row_bytes/(sizeof (png_uint_16));
1614    }
1615
1616    return 1;
1617 }
1618
1619 /* Given 16-bit input (1 to 4 channels) write 8-bit output.  If an alpha channel
1620  * is present it must be removed from the components, the components are then
1621  * written in sRGB encoding.  No components are added or removed.
1622  *
1623  * Calculate an alpha reciprocal to reverse pre-multiplication.  As above the
1624  * calculation can be done to 15 bits of accuracy; however, the output needs to
1625  * be scaled in the range 0..255*65535, so include that scaling here.
1626  */
1627 #   define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+(alpha>>1))/alpha)
1628
1629 static png_byte
1630 png_unpremultiply(png_uint_32 component, png_uint_32 alpha,
1631     png_uint_32 reciprocal/*from the above macro*/)
1632 {
1633    /* The following gives 1.0 for an alpha of 0, which is fine, otherwise if 0/0
1634     * is represented as some other value there is more likely to be a
1635     * discontinuity which will probably damage compression when moving from a
1636     * fully transparent area to a nearly transparent one.  (The assumption here
1637     * is that opaque areas tend not to be 0 intensity.)
1638     *
1639     * There is a rounding problem here; if alpha is less than 128 it will end up
1640     * as 0 when scaled to 8 bits.  To avoid introducing spurious colors into the
1641     * output change for this too.
1642     */
1643    if (component >= alpha || alpha < 128)
1644       return 255;
1645
1646    /* component<alpha, so component/alpha is less than one and
1647     * component*reciprocal is less than 2^31.
1648     */
1649    else if (component > 0)
1650    {
1651       /* The test is that alpha/257 (rounded) is less than 255, the first value
1652        * that becomes 255 is 65407.
1653        * NOTE: this must agree with the PNG_DIV257 macro (which must, therefore,
1654        * be exact!)  [Could also test reciprocal != 0]
1655        */
1656       if (alpha < 65407)
1657       {
1658          component *= reciprocal;
1659          component += 64; /* round to nearest */
1660          component >>= 7;
1661       }
1662
1663       else
1664          component *= 255;
1665
1666       /* Convert the component to sRGB. */
1667       return (png_byte)PNG_sRGB_FROM_LINEAR(component);
1668    }
1669
1670    else
1671       return 0;
1672 }
1673
1674 static int
1675 png_write_image_8bit(png_voidp argument)
1676 {
1677    png_image_write_control *display = png_voidcast(png_image_write_control*,
1678        argument);
1679    png_imagep image = display->image;
1680    png_structrp png_ptr = image->opaque->png_ptr;
1681
1682    png_const_uint_16p input_row = png_voidcast(png_const_uint_16p,
1683        display->first_row);
1684    png_bytep output_row = png_voidcast(png_bytep, display->local_row);
1685    png_uint_32 y = image->height;
1686    const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
1687
1688    if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
1689    {
1690       png_bytep row_end;
1691       int aindex;
1692
1693 #   ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
1694       if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
1695       {
1696          aindex = -1;
1697          ++input_row; /* To point to the first component */
1698          ++output_row;
1699       }
1700
1701       else
1702 #   endif
1703       aindex = channels;
1704
1705       /* Use row_end in place of a loop counter: */
1706       row_end = output_row + image->width * (channels+1);
1707
1708       while (y-- > 0)
1709       {
1710          png_const_uint_16p in_ptr = input_row;
1711          png_bytep out_ptr = output_row;
1712
1713          while (out_ptr < row_end)
1714          {
1715             png_uint_16 alpha = in_ptr[aindex];
1716             png_byte alphabyte = (png_byte)PNG_DIV257(alpha);
1717             png_uint_32 reciprocal = 0;
1718             int c;
1719
1720             /* Scale and write the alpha channel. */
1721             out_ptr[aindex] = alphabyte;
1722
1723             if (alphabyte > 0 && alphabyte < 255)
1724                reciprocal = UNP_RECIPROCAL(alpha);
1725
1726             c = channels;
1727             do /* always at least one channel */
1728                *out_ptr++ = png_unpremultiply(*in_ptr++, alpha, reciprocal);
1729             while (--c > 0);
1730
1731             /* Skip to next component (skip the intervening alpha channel) */
1732             ++in_ptr;
1733             ++out_ptr;
1734          } /* while out_ptr < row_end */
1735
1736          png_write_row(png_ptr, png_voidcast(png_const_bytep,
1737              display->local_row));
1738          input_row += display->row_bytes/(sizeof (png_uint_16));
1739       } /* while y */
1740    }
1741
1742    else
1743    {
1744       /* No alpha channel, so the row_end really is the end of the row and it
1745        * is sufficient to loop over the components one by one.
1746        */
1747       png_bytep row_end = output_row + image->width * channels;
1748
1749       while (y-- > 0)
1750       {
1751          png_const_uint_16p in_ptr = input_row;
1752          png_bytep out_ptr = output_row;
1753
1754          while (out_ptr < row_end)
1755          {
1756             png_uint_32 component = *in_ptr++;
1757
1758             component *= 255;
1759             *out_ptr++ = (png_byte)PNG_sRGB_FROM_LINEAR(component);
1760          }
1761
1762          png_write_row(png_ptr, output_row);
1763          input_row += display->row_bytes/(sizeof (png_uint_16));
1764       }
1765    }
1766
1767    return 1;
1768 }
1769
1770 static void
1771 png_image_set_PLTE(png_image_write_control *display)
1772 {
1773    const png_imagep image = display->image;
1774    const void *cmap = display->colormap;
1775    const int entries = image->colormap_entries > 256 ? 256 :
1776        (int)image->colormap_entries;
1777
1778    /* NOTE: the caller must check for cmap != NULL and entries != 0 */
1779    const png_uint_32 format = image->format;
1780    const int channels = PNG_IMAGE_SAMPLE_CHANNELS(format);
1781
1782 #   if defined(PNG_FORMAT_BGR_SUPPORTED) &&\
1783       defined(PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED)
1784       const int afirst = (format & PNG_FORMAT_FLAG_AFIRST) != 0 &&
1785           (format & PNG_FORMAT_FLAG_ALPHA) != 0;
1786 #   else
1787 #     define afirst 0
1788 #   endif
1789
1790 #   ifdef PNG_FORMAT_BGR_SUPPORTED
1791       const int bgr = (format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
1792 #   else
1793 #     define bgr 0
1794 #   endif
1795
1796    int i, num_trans;
1797    png_color palette[256];
1798    png_byte tRNS[256];
1799
1800    memset(tRNS, 255, (sizeof tRNS));
1801    memset(palette, 0, (sizeof palette));
1802
1803    for (i=num_trans=0; i<entries; ++i)
1804    {
1805       /* This gets automatically converted to sRGB with reversal of the
1806        * pre-multiplication if the color-map has an alpha channel.
1807        */
1808       if ((format & PNG_FORMAT_FLAG_LINEAR) != 0)
1809       {
1810          png_const_uint_16p entry = png_voidcast(png_const_uint_16p, cmap);
1811
1812          entry += i * channels;
1813
1814          if ((channels & 1) != 0) /* no alpha */
1815          {
1816             if (channels >= 3) /* RGB */
1817             {
1818                palette[i].blue = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
1819                    entry[(2 ^ bgr)]);
1820                palette[i].green = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
1821                    entry[1]);
1822                palette[i].red = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
1823                    entry[bgr]);
1824             }
1825
1826             else /* Gray */
1827                palette[i].blue = palette[i].red = palette[i].green =
1828                   (png_byte)PNG_sRGB_FROM_LINEAR(255 * *entry);
1829          }
1830
1831          else /* alpha */
1832          {
1833             png_uint_16 alpha = entry[afirst ? 0 : channels-1];
1834             png_byte alphabyte = (png_byte)PNG_DIV257(alpha);
1835             png_uint_32 reciprocal = 0;
1836
1837             /* Calculate a reciprocal, as in the png_write_image_8bit code above
1838              * this is designed to produce a value scaled to 255*65535 when
1839              * divided by 128 (i.e. asr 7).
1840              */
1841             if (alphabyte > 0 && alphabyte < 255)
1842                reciprocal = (((0xffff*0xff)<<7)+(alpha>>1))/alpha;
1843
1844             tRNS[i] = alphabyte;
1845             if (alphabyte < 255)
1846                num_trans = i+1;
1847
1848             if (channels >= 3) /* RGB */
1849             {
1850                palette[i].blue = png_unpremultiply(entry[afirst + (2 ^ bgr)],
1851                    alpha, reciprocal);
1852                palette[i].green = png_unpremultiply(entry[afirst + 1], alpha,
1853                    reciprocal);
1854                palette[i].red = png_unpremultiply(entry[afirst + bgr], alpha,
1855                    reciprocal);
1856             }
1857
1858             else /* gray */
1859                palette[i].blue = palette[i].red = palette[i].green =
1860                    png_unpremultiply(entry[afirst], alpha, reciprocal);
1861          }
1862       }
1863
1864       else /* Color-map has sRGB values */
1865       {
1866          png_const_bytep entry = png_voidcast(png_const_bytep, cmap);
1867
1868          entry += i * channels;
1869
1870          switch (channels)
1871          {
1872             case 4:
1873                tRNS[i] = entry[afirst ? 0 : 3];
1874                if (tRNS[i] < 255)
1875                   num_trans = i+1;
1876                /* FALL THROUGH */
1877             case 3:
1878                palette[i].blue = entry[afirst + (2 ^ bgr)];
1879                palette[i].green = entry[afirst + 1];
1880                palette[i].red = entry[afirst + bgr];
1881                break;
1882
1883             case 2:
1884                tRNS[i] = entry[1 ^ afirst];
1885                if (tRNS[i] < 255)
1886                   num_trans = i+1;
1887                /* FALL THROUGH */
1888             case 1:
1889                palette[i].blue = palette[i].red = palette[i].green =
1890                   entry[afirst];
1891                break;
1892
1893             default:
1894                break;
1895          }
1896       }
1897    }
1898
1899 #   ifdef afirst
1900 #     undef afirst
1901 #   endif
1902 #   ifdef bgr
1903 #     undef bgr
1904 #   endif
1905
1906    png_set_PLTE(image->opaque->png_ptr, image->opaque->info_ptr, palette,
1907        entries);
1908
1909    if (num_trans > 0)
1910       png_set_tRNS(image->opaque->png_ptr, image->opaque->info_ptr, tRNS,
1911           num_trans, NULL);
1912
1913    image->colormap_entries = entries;
1914 }
1915
1916 static int
1917 png_image_write_main(png_voidp argument)
1918 {
1919    png_image_write_control *display = png_voidcast(png_image_write_control*,
1920        argument);
1921    png_imagep image = display->image;
1922    png_structrp png_ptr = image->opaque->png_ptr;
1923    png_inforp info_ptr = image->opaque->info_ptr;
1924    png_uint_32 format = image->format;
1925
1926    /* The following four ints are actually booleans */
1927    int colormap = (format & PNG_FORMAT_FLAG_COLORMAP);
1928    int linear = !colormap && (format & PNG_FORMAT_FLAG_LINEAR); /* input */
1929    int alpha = !colormap && (format & PNG_FORMAT_FLAG_ALPHA);
1930    int write_16bit = linear && !colormap && (display->convert_to_8bit == 0);
1931
1932 #   ifdef PNG_BENIGN_ERRORS_SUPPORTED
1933       /* Make sure we error out on any bad situation */
1934       png_set_benign_errors(png_ptr, 0/*error*/);
1935 #   endif
1936
1937    /* Default the 'row_stride' parameter if required, also check the row stride
1938     * and total image size to ensure that they are within the system limits.
1939     */
1940    {
1941       const unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format);
1942
1943       if (image->width <= 0x7FFFFFFFU/channels) /* no overflow */
1944       {
1945          png_uint_32 check;
1946          const png_uint_32 png_row_stride = image->width * channels;
1947
1948          if (display->row_stride == 0)
1949             display->row_stride = (png_int_32)/*SAFE*/png_row_stride;
1950
1951          if (display->row_stride < 0)
1952             check = -display->row_stride;
1953
1954          else
1955             check = display->row_stride;
1956
1957          if (check >= png_row_stride)
1958          {
1959             /* Now check for overflow of the image buffer calculation; this
1960              * limits the whole image size to 32 bits for API compatibility with
1961              * the current, 32-bit, PNG_IMAGE_BUFFER_SIZE macro.
1962              */
1963             if (image->height > 0xFFFFFFFF/png_row_stride)
1964                png_error(image->opaque->png_ptr, "memory image too large");
1965          }
1966
1967          else
1968             png_error(image->opaque->png_ptr, "supplied row stride too small");
1969       }
1970
1971       else
1972          png_error(image->opaque->png_ptr, "image row stride too large");
1973    }
1974
1975    /* Set the required transforms then write the rows in the correct order. */
1976    if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0)
1977    {
1978       if (display->colormap != NULL && image->colormap_entries > 0)
1979       {
1980          png_uint_32 entries = image->colormap_entries;
1981
1982          png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
1983              entries > 16 ? 8 : (entries > 4 ? 4 : (entries > 2 ? 2 : 1)),
1984              PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
1985              PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
1986
1987          png_image_set_PLTE(display);
1988       }
1989
1990       else
1991          png_error(image->opaque->png_ptr,
1992              "no color-map for color-mapped image");
1993    }
1994
1995    else
1996       png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
1997           write_16bit ? 16 : 8,
1998           ((format & PNG_FORMAT_FLAG_COLOR) ? PNG_COLOR_MASK_COLOR : 0) +
1999           ((format & PNG_FORMAT_FLAG_ALPHA) ? PNG_COLOR_MASK_ALPHA : 0),
2000           PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
2001
2002    /* Counter-intuitively the data transformations must be called *after*
2003     * png_write_info, not before as in the read code, but the 'set' functions
2004     * must still be called before.  Just set the color space information, never
2005     * write an interlaced image.
2006     */
2007
2008    if (write_16bit != 0)
2009    {
2010       /* The gamma here is 1.0 (linear) and the cHRM chunk matches sRGB. */
2011       png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_LINEAR);
2012
2013       if ((image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB) == 0)
2014          png_set_cHRM_fixed(png_ptr, info_ptr,
2015              /* color      x       y */
2016              /* white */ 31270, 32900,
2017              /* red   */ 64000, 33000,
2018              /* green */ 30000, 60000,
2019              /* blue  */ 15000,  6000
2020          );
2021    }
2022
2023    else if ((image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB) == 0)
2024       png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
2025
2026    /* Else writing an 8-bit file and the *colors* aren't sRGB, but the 8-bit
2027     * space must still be gamma encoded.
2028     */
2029    else
2030       png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_sRGB_INVERSE);
2031
2032    /* Write the file header. */
2033    png_write_info(png_ptr, info_ptr);
2034
2035    /* Now set up the data transformations (*after* the header is written),
2036     * remove the handled transformations from the 'format' flags for checking.
2037     *
2038     * First check for a little endian system if writing 16-bit files.
2039     */
2040    if (write_16bit != 0)
2041    {
2042       PNG_CONST png_uint_16 le = 0x0001;
2043
2044       if ((*(png_const_bytep) & le) != 0)
2045          png_set_swap(png_ptr);
2046    }
2047
2048 #   ifdef PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
2049       if ((format & PNG_FORMAT_FLAG_BGR) != 0)
2050       {
2051          if (colormap == 0 && (format & PNG_FORMAT_FLAG_COLOR) != 0)
2052             png_set_bgr(png_ptr);
2053          format &= ~PNG_FORMAT_FLAG_BGR;
2054       }
2055 #   endif
2056
2057 #   ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
2058       if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
2059       {
2060          if (colormap == 0 && (format & PNG_FORMAT_FLAG_ALPHA) != 0)
2061             png_set_swap_alpha(png_ptr);
2062          format &= ~PNG_FORMAT_FLAG_AFIRST;
2063       }
2064 #   endif
2065
2066    /* If there are 16 or fewer color-map entries we wrote a lower bit depth
2067     * above, but the application data is still byte packed.
2068     */
2069    if (colormap != 0 && image->colormap_entries <= 16)
2070       png_set_packing(png_ptr);
2071
2072    /* That should have handled all (both) the transforms. */
2073    if ((format & ~(png_uint_32)(PNG_FORMAT_FLAG_COLOR | PNG_FORMAT_FLAG_LINEAR |
2074          PNG_FORMAT_FLAG_ALPHA | PNG_FORMAT_FLAG_COLORMAP)) != 0)
2075       png_error(png_ptr, "png_write_image: unsupported transformation");
2076
2077    {
2078       png_const_bytep row = png_voidcast(png_const_bytep, display->buffer);
2079       ptrdiff_t row_bytes = display->row_stride;
2080
2081       if (linear != 0)
2082          row_bytes *= (sizeof (png_uint_16));
2083
2084       if (row_bytes < 0)
2085          row += (image->height-1) * (-row_bytes);
2086
2087       display->first_row = row;
2088       display->row_bytes = row_bytes;
2089    }
2090
2091    /* Apply 'fast' options if the flag is set. */
2092    if ((image->flags & PNG_IMAGE_FLAG_FAST) != 0)
2093    {
2094       png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, PNG_NO_FILTERS);
2095       /* NOTE: determined by experiment using pngstest, this reflects some
2096        * balance between the time to write the image once and the time to read
2097        * it about 50 times.  The speed-up in pngstest was about 10-20% of the
2098        * total (user) time on a heavily loaded system.
2099        */
2100 #   ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
2101       png_set_compression_level(png_ptr, 3);
2102 #   endif
2103    }
2104
2105    /* Check for the cases that currently require a pre-transform on the row
2106     * before it is written.  This only applies when the input is 16-bit and
2107     * either there is an alpha channel or it is converted to 8-bit.
2108     */
2109    if ((linear != 0 && alpha != 0 ) ||
2110        (colormap == 0 && display->convert_to_8bit != 0))
2111    {
2112       png_bytep row = png_voidcast(png_bytep, png_malloc(png_ptr,
2113           png_get_rowbytes(png_ptr, info_ptr)));
2114       int result;
2115
2116       display->local_row = row;
2117       if (write_16bit != 0)
2118          result = png_safe_execute(image, png_write_image_16bit, display);
2119       else
2120          result = png_safe_execute(image, png_write_image_8bit, display);
2121       display->local_row = NULL;
2122
2123       png_free(png_ptr, row);
2124
2125       /* Skip the 'write_end' on error: */
2126       if (result == 0)
2127          return 0;
2128    }
2129
2130    /* Otherwise this is the case where the input is in a format currently
2131     * supported by the rest of the libpng write code; call it directly.
2132     */
2133    else
2134    {
2135       png_const_bytep row = png_voidcast(png_const_bytep, display->first_row);
2136       ptrdiff_t row_bytes = display->row_bytes;
2137       png_uint_32 y = image->height;
2138
2139       while (y-- > 0)
2140       {
2141          png_write_row(png_ptr, row);
2142          row += row_bytes;
2143       }
2144    }
2145
2146    png_write_end(png_ptr, info_ptr);
2147    return 1;
2148 }
2149
2150
2151 static void (PNGCBAPI
2152 image_memory_write)(png_structp png_ptr, png_bytep/*const*/ data,
2153     png_size_t size)
2154 {
2155    png_image_write_control *display = png_voidcast(png_image_write_control*,
2156        png_ptr->io_ptr/*backdoor: png_get_io_ptr(png_ptr)*/);
2157    const png_alloc_size_t ob = display->output_bytes;
2158
2159    /* Check for overflow; this should never happen: */
2160    if (size <= ((png_alloc_size_t)-1) - ob)
2161    {
2162       /* I don't think libpng ever does this, but just in case: */
2163       if (size > 0)
2164       {
2165          if (display->memory_bytes >= ob+size) /* writing */
2166             memcpy(display->memory+ob, data, size);
2167
2168          /* Always update the size: */
2169          display->output_bytes = ob+size;
2170       }
2171    }
2172
2173    else
2174       png_error(png_ptr, "png_image_write_to_memory: PNG too big");
2175 }
2176
2177 static void (PNGCBAPI
2178 image_memory_flush)(png_structp png_ptr)
2179 {
2180    PNG_UNUSED(png_ptr)
2181 }
2182
2183 static int
2184 png_image_write_memory(png_voidp argument)
2185 {
2186    png_image_write_control *display = png_voidcast(png_image_write_control*,
2187        argument);
2188
2189    /* The rest of the memory-specific init and write_main in an error protected
2190     * environment.  This case needs to use callbacks for the write operations
2191     * since libpng has no built in support for writing to memory.
2192     */
2193    png_set_write_fn(display->image->opaque->png_ptr, display/*io_ptr*/,
2194        image_memory_write, image_memory_flush);
2195
2196    return png_image_write_main(display);
2197 }
2198
2199 int PNGAPI
2200 png_image_write_to_memory(png_imagep image, void *memory,
2201     png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8bit,
2202     const void *buffer, png_int_32 row_stride, const void *colormap)
2203 {
2204    /* Write the image to the given buffer, or count the bytes if it is NULL */
2205    if (image != NULL && image->version == PNG_IMAGE_VERSION)
2206    {
2207       if (memory_bytes != NULL && buffer != NULL)
2208       {
2209          /* This is to give the caller an easier error detection in the NULL
2210           * case and guard against uninitialized variable problems:
2211           */
2212          if (memory == NULL)
2213             *memory_bytes = 0;
2214
2215          if (png_image_write_init(image) != 0)
2216          {
2217             png_image_write_control display;
2218             int result;
2219
2220             memset(&display, 0, (sizeof display));
2221             display.image = image;
2222             display.buffer = buffer;
2223             display.row_stride = row_stride;
2224             display.colormap = colormap;
2225             display.convert_to_8bit = convert_to_8bit;
2226             display.memory = png_voidcast(png_bytep, memory);
2227             display.memory_bytes = *memory_bytes;
2228             display.output_bytes = 0;
2229
2230             result = png_safe_execute(image, png_image_write_memory, &display);
2231             png_image_free(image);
2232
2233             /* write_memory returns true even if we ran out of buffer. */
2234             if (result)
2235             {
2236                /* On out-of-buffer this function returns '0' but still updates
2237                 * memory_bytes:
2238                 */
2239                if (memory != NULL && display.output_bytes > *memory_bytes)
2240                   result = 0;
2241
2242                *memory_bytes = display.output_bytes;
2243             }
2244
2245             return result;
2246          }
2247
2248          else
2249             return 0;
2250       }
2251
2252       else
2253          return png_image_error(image,
2254              "png_image_write_to_memory: invalid argument");
2255    }
2256
2257    else if (image != NULL)
2258       return png_image_error(image,
2259           "png_image_write_to_memory: incorrect PNG_IMAGE_VERSION");
2260
2261    else
2262       return 0;
2263 }
2264
2265 #ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
2266 int PNGAPI
2267 png_image_write_to_stdio(png_imagep image, FILE *file, int convert_to_8bit,
2268     const void *buffer, png_int_32 row_stride, const void *colormap)
2269 {
2270    /* Write the image to the given (FILE*). */
2271    if (image != NULL && image->version == PNG_IMAGE_VERSION)
2272    {
2273       if (file != NULL && buffer != NULL)
2274       {
2275          if (png_image_write_init(image) != 0)
2276          {
2277             png_image_write_control display;
2278             int result;
2279
2280             /* This is slightly evil, but png_init_io doesn't do anything other
2281              * than this and we haven't changed the standard IO functions so
2282              * this saves a 'safe' function.
2283              */
2284             image->opaque->png_ptr->io_ptr = file;
2285
2286             memset(&display, 0, (sizeof display));
2287             display.image = image;
2288             display.buffer = buffer;
2289             display.row_stride = row_stride;
2290             display.colormap = colormap;
2291             display.convert_to_8bit = convert_to_8bit;
2292
2293             result = png_safe_execute(image, png_image_write_main, &display);
2294             png_image_free(image);
2295             return result;
2296          }
2297
2298          else
2299             return 0;
2300       }
2301
2302       else
2303          return png_image_error(image,
2304              "png_image_write_to_stdio: invalid argument");
2305    }
2306
2307    else if (image != NULL)
2308       return png_image_error(image,
2309           "png_image_write_to_stdio: incorrect PNG_IMAGE_VERSION");
2310
2311    else
2312       return 0;
2313 }
2314
2315 int PNGAPI
2316 png_image_write_to_file(png_imagep image, const char *file_name,
2317     int convert_to_8bit, const void *buffer, png_int_32 row_stride,
2318     const void *colormap)
2319 {
2320    /* Write the image to the named file. */
2321    if (image != NULL && image->version == PNG_IMAGE_VERSION)
2322    {
2323       if (file_name != NULL && buffer != NULL)
2324       {
2325          FILE *fp = fopen(file_name, "wb");
2326
2327          if (fp != NULL)
2328          {
2329             if (png_image_write_to_stdio(image, fp, convert_to_8bit, buffer,
2330                 row_stride, colormap) != 0)
2331             {
2332                int error; /* from fflush/fclose */
2333
2334                /* Make sure the file is flushed correctly. */
2335                if (fflush(fp) == 0 && ferror(fp) == 0)
2336                {
2337                   if (fclose(fp) == 0)
2338                      return 1;
2339
2340                   error = errno; /* from fclose */
2341                }
2342
2343                else
2344                {
2345                   error = errno; /* from fflush or ferror */
2346                   (void)fclose(fp);
2347                }
2348
2349                (void)remove(file_name);
2350                /* The image has already been cleaned up; this is just used to
2351                 * set the error (because the original write succeeded).
2352                 */
2353                return png_image_error(image, strerror(error));
2354             }
2355
2356             else
2357             {
2358                /* Clean up: just the opened file. */
2359                (void)fclose(fp);
2360                (void)remove(file_name);
2361                return 0;
2362             }
2363          }
2364
2365          else
2366             return png_image_error(image, strerror(errno));
2367       }
2368
2369       else
2370          return png_image_error(image,
2371              "png_image_write_to_file: invalid argument");
2372    }
2373
2374    else if (image != NULL)
2375       return png_image_error(image,
2376           "png_image_write_to_file: incorrect PNG_IMAGE_VERSION");
2377
2378    else
2379       return 0;
2380 }
2381 #endif /* SIMPLIFIED_WRITE_STDIO */
2382 #endif /* SIMPLIFIED_WRITE */
2383 #endif /* WRITE */