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