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