2 /* pngwutil.c - utilities to write a PNG file
4 * Last changed in libpng 1.6.11 [June 5, 2014]
5 * Copyright (c) 1998-2014 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.)
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
16 #ifdef PNG_WRITE_SUPPORTED
18 #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
19 /* Place a 32-bit number into a buffer in PNG byte order. We work
20 * with unsigned numbers for convenience, although one supported
21 * ancillary chunk uses signed (two's complement) numbers.
24 png_save_uint_32(png_bytep buf
, png_uint_32 i
)
26 buf
[0] = (png_byte
)((i
>> 24) & 0xff);
27 buf
[1] = (png_byte
)((i
>> 16) & 0xff);
28 buf
[2] = (png_byte
)((i
>> 8) & 0xff);
29 buf
[3] = (png_byte
)(i
& 0xff);
32 /* Place a 16-bit number into a buffer in PNG byte order.
33 * The parameter is declared unsigned int, not png_uint_16,
34 * just to avoid potential problems on pre-ANSI C compilers.
37 png_save_uint_16(png_bytep buf
, unsigned int i
)
39 buf
[0] = (png_byte
)((i
>> 8) & 0xff);
40 buf
[1] = (png_byte
)(i
& 0xff);
44 /* Simple function to write the signature. If we have already written
45 * the magic bytes of the signature, or more likely, the PNG stream is
46 * being embedded into another stream and doesn't need its own signature,
47 * we should call png_set_sig_bytes() to tell libpng how many of the
48 * bytes have already been written.
51 png_write_sig(png_structrp png_ptr
)
53 png_byte png_signature
[8] = {137, 80, 78, 71, 13, 10, 26, 10};
55 #ifdef PNG_IO_STATE_SUPPORTED
56 /* Inform the I/O callback that the signature is being written */
57 png_ptr
->io_state
= PNG_IO_WRITING
| PNG_IO_SIGNATURE
;
60 /* Write the rest of the 8 byte signature */
61 png_write_data(png_ptr
, &png_signature
[png_ptr
->sig_bytes
],
62 (png_size_t
)(8 - png_ptr
->sig_bytes
));
64 if (png_ptr
->sig_bytes
< 3)
65 png_ptr
->mode
|= PNG_HAVE_PNG_SIGNATURE
;
68 /* Write the start of a PNG chunk. The type is the chunk type.
69 * The total_length is the sum of the lengths of all the data you will be
70 * passing in png_write_chunk_data().
73 png_write_chunk_header(png_structrp png_ptr
, png_uint_32 chunk_name
,
78 #if defined(PNG_DEBUG) && (PNG_DEBUG > 0)
79 PNG_CSTRING_FROM_CHUNK(buf
, chunk_name
);
80 png_debug2(0, "Writing %s chunk, length = %lu", buf
, (unsigned long)length
);
86 #ifdef PNG_IO_STATE_SUPPORTED
87 /* Inform the I/O callback that the chunk header is being written.
88 * PNG_IO_CHUNK_HDR requires a single I/O call.
90 png_ptr
->io_state
= PNG_IO_WRITING
| PNG_IO_CHUNK_HDR
;
93 /* Write the length and the chunk name */
94 png_save_uint_32(buf
, length
);
95 png_save_uint_32(buf
+ 4, chunk_name
);
96 png_write_data(png_ptr
, buf
, 8);
98 /* Put the chunk name into png_ptr->chunk_name */
99 png_ptr
->chunk_name
= chunk_name
;
101 /* Reset the crc and run it over the chunk name */
102 png_reset_crc(png_ptr
);
104 png_calculate_crc(png_ptr
, buf
+ 4, 4);
106 #ifdef PNG_IO_STATE_SUPPORTED
107 /* Inform the I/O callback that chunk data will (possibly) be written.
108 * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.
110 png_ptr
->io_state
= PNG_IO_WRITING
| PNG_IO_CHUNK_DATA
;
115 png_write_chunk_start(png_structrp png_ptr
, png_const_bytep chunk_string
,
118 png_write_chunk_header(png_ptr
, PNG_CHUNK_FROM_STRING(chunk_string
), length
);
121 /* Write the data of a PNG chunk started with png_write_chunk_header().
122 * Note that multiple calls to this function are allowed, and that the
123 * sum of the lengths from these calls *must* add up to the total_length
124 * given to png_write_chunk_header().
127 png_write_chunk_data(png_structrp png_ptr
, png_const_bytep data
,
130 /* Write the data, and run the CRC over it */
134 if (data
!= NULL
&& length
> 0)
136 png_write_data(png_ptr
, data
, length
);
138 /* Update the CRC after writing the data,
139 * in case that the user I/O routine alters it.
141 png_calculate_crc(png_ptr
, data
, length
);
145 /* Finish a chunk started with png_write_chunk_header(). */
147 png_write_chunk_end(png_structrp png_ptr
)
151 if (png_ptr
== NULL
) return;
153 #ifdef PNG_IO_STATE_SUPPORTED
154 /* Inform the I/O callback that the chunk CRC is being written.
155 * PNG_IO_CHUNK_CRC requires a single I/O function call.
157 png_ptr
->io_state
= PNG_IO_WRITING
| PNG_IO_CHUNK_CRC
;
160 /* Write the crc in a single operation */
161 png_save_uint_32(buf
, png_ptr
->crc
);
163 png_write_data(png_ptr
, buf
, (png_size_t
)4);
166 /* Write a PNG chunk all at once. The type is an array of ASCII characters
167 * representing the chunk name. The array must be at least 4 bytes in
168 * length, and does not need to be null terminated. To be safe, pass the
169 * pre-defined chunk names here, and if you need a new one, define it
170 * where the others are defined. The length is the length of the data.
171 * All the data must be present. If that is not possible, use the
172 * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
176 png_write_complete_chunk(png_structrp png_ptr
, png_uint_32 chunk_name
,
177 png_const_bytep data
, png_size_t length
)
182 /* On 64 bit architectures 'length' may not fit in a png_uint_32. */
183 if (length
> PNG_UINT_31_MAX
)
184 png_error(png_ptr
, "length exceeds PNG maxima");
186 png_write_chunk_header(png_ptr
, chunk_name
, (png_uint_32
)length
);
187 png_write_chunk_data(png_ptr
, data
, length
);
188 png_write_chunk_end(png_ptr
);
191 /* This is the API that calls the internal function above. */
193 png_write_chunk(png_structrp png_ptr
, png_const_bytep chunk_string
,
194 png_const_bytep data
, png_size_t length
)
196 png_write_complete_chunk(png_ptr
, PNG_CHUNK_FROM_STRING(chunk_string
), data
,
200 /* This is used below to find the size of an image to pass to png_deflate_claim,
201 * so it only needs to be accurate if the size is less than 16384 bytes (the
202 * point at which a lower LZ window size can be used.)
204 static png_alloc_size_t
205 png_image_size(png_structrp png_ptr
)
207 /* Only return sizes up to the maximum of a png_uint_32, do this by limiting
208 * the width and height used to 15 bits.
210 png_uint_32 h
= png_ptr
->height
;
212 if (png_ptr
->rowbytes
< 32768 && h
< 32768)
214 if (png_ptr
->interlaced
)
216 /* Interlacing makes the image larger because of the replication of
217 * both the filter byte and the padding to a byte boundary.
219 png_uint_32 w
= png_ptr
->width
;
220 unsigned int pd
= png_ptr
->pixel_depth
;
221 png_alloc_size_t cb_base
;
224 for (cb_base
=0, pass
=0; pass
<=6; ++pass
)
226 png_uint_32 pw
= PNG_PASS_COLS(w
, pass
);
229 cb_base
+= (PNG_ROWBYTES(pd
, pw
)+1) * PNG_PASS_ROWS(h
, pass
);
236 return (png_ptr
->rowbytes
+1) * h
;
243 #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
244 /* This is the code to hack the first two bytes of the deflate stream (the
245 * deflate header) to correct the windowBits value to match the actual data
246 * size. Note that the second argument is the *uncompressed* size but the
247 * first argument is the *compressed* data (and it must be deflate
251 optimize_cmf(png_bytep data
, png_alloc_size_t data_size
)
253 /* Optimize the CMF field in the zlib stream. The resultant zlib stream is
254 * still compliant to the stream specification.
256 if (data_size
<= 16384) /* else windowBits must be 15 */
258 unsigned int z_cmf
= data
[0]; /* zlib compression method and flags */
260 if ((z_cmf
& 0x0f) == 8 && (z_cmf
& 0xf0) <= 0x70)
262 unsigned int z_cinfo
;
263 unsigned int half_z_window_size
;
265 z_cinfo
= z_cmf
>> 4;
266 half_z_window_size
= 1U << (z_cinfo
+ 7);
268 if (data_size
<= half_z_window_size
) /* else no change */
274 half_z_window_size
>>= 1;
277 while (z_cinfo
> 0 && data_size
<= half_z_window_size
);
279 z_cmf
= (z_cmf
& 0x0f) | (z_cinfo
<< 4);
281 data
[0] = (png_byte
)z_cmf
;
282 tmp
= data
[1] & 0xe0;
283 tmp
+= 0x1f - ((z_cmf
<< 8) + tmp
) % 0x1f;
284 data
[1] = (png_byte
)tmp
;
290 # define optimize_cmf(dp,dl) ((void)0)
291 #endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */
293 /* Initialize the compressor for the appropriate type of compression. */
295 png_deflate_claim(png_structrp png_ptr
, png_uint_32 owner
,
296 png_alloc_size_t data_size
)
298 if (png_ptr
->zowner
!= 0)
302 PNG_STRING_FROM_CHUNK(msg
, owner
);
305 PNG_STRING_FROM_CHUNK(msg
+6, png_ptr
->zowner
);
306 /* So the message that results is "<chunk> using zstream"; this is an
307 * internal error, but is very useful for debugging. i18n requirements
310 (void)png_safecat(msg
, (sizeof msg
), 10, " using zstream");
311 # if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC
312 png_warning(png_ptr
, msg
);
314 /* Attempt sane error recovery */
315 if (png_ptr
->zowner
== png_IDAT
) /* don't steal from IDAT */
317 png_ptr
->zstream
.msg
= PNGZ_MSG_CAST("in use by IDAT");
318 return Z_STREAM_ERROR
;
323 png_error(png_ptr
, msg
);
328 int level
= png_ptr
->zlib_level
;
329 int method
= png_ptr
->zlib_method
;
330 int windowBits
= png_ptr
->zlib_window_bits
;
331 int memLevel
= png_ptr
->zlib_mem_level
;
332 int strategy
; /* set below */
333 int ret
; /* zlib return code */
335 if (owner
== png_IDAT
)
337 if (png_ptr
->flags
& PNG_FLAG_ZLIB_CUSTOM_STRATEGY
)
338 strategy
= png_ptr
->zlib_strategy
;
340 else if (png_ptr
->do_filter
!= PNG_FILTER_NONE
)
341 strategy
= PNG_Z_DEFAULT_STRATEGY
;
344 strategy
= PNG_Z_DEFAULT_NOFILTER_STRATEGY
;
349 # ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
350 level
= png_ptr
->zlib_text_level
;
351 method
= png_ptr
->zlib_text_method
;
352 windowBits
= png_ptr
->zlib_text_window_bits
;
353 memLevel
= png_ptr
->zlib_text_mem_level
;
354 strategy
= png_ptr
->zlib_text_strategy
;
356 /* If customization is not supported the values all come from the
357 * IDAT values except for the strategy, which is fixed to the
358 * default. (This is the pre-1.6.0 behavior too, although it was
359 * implemented in a very different way.)
361 strategy
= Z_DEFAULT_STRATEGY
;
365 /* Adjust 'windowBits' down if larger than 'data_size'; to stop this
366 * happening just pass 32768 as the data_size parameter. Notice that zlib
367 * requires an extra 262 bytes in the window in addition to the data to be
368 * able to see the whole of the data, so if data_size+262 takes us to the
369 * next windowBits size we need to fix up the value later. (Because even
370 * though deflate needs the extra window, inflate does not!)
372 if (data_size
<= 16384)
374 /* IMPLEMENTATION NOTE: this 'half_window_size' stuff is only here to
375 * work round a Microsoft Visual C misbehavior which, contrary to C-90,
376 * widens the result of the following shift to 64-bits if (and,
377 * apparently, only if) it is used in a test.
379 unsigned int half_window_size
= 1U << (windowBits
-1);
381 while (data_size
+ 262 <= half_window_size
)
383 half_window_size
>>= 1;
388 /* Check against the previous initialized values, if any. */
389 if ((png_ptr
->flags
& PNG_FLAG_ZSTREAM_INITIALIZED
) &&
390 (png_ptr
->zlib_set_level
!= level
||
391 png_ptr
->zlib_set_method
!= method
||
392 png_ptr
->zlib_set_window_bits
!= windowBits
||
393 png_ptr
->zlib_set_mem_level
!= memLevel
||
394 png_ptr
->zlib_set_strategy
!= strategy
))
396 if (deflateEnd(&png_ptr
->zstream
) != Z_OK
)
397 png_warning(png_ptr
, "deflateEnd failed (ignored)");
399 png_ptr
->flags
&= ~PNG_FLAG_ZSTREAM_INITIALIZED
;
402 /* For safety clear out the input and output pointers (currently zlib
403 * doesn't use them on Init, but it might in the future).
405 png_ptr
->zstream
.next_in
= NULL
;
406 png_ptr
->zstream
.avail_in
= 0;
407 png_ptr
->zstream
.next_out
= NULL
;
408 png_ptr
->zstream
.avail_out
= 0;
410 /* Now initialize if required, setting the new parameters, otherwise just
411 * to a simple reset to the previous parameters.
413 if (png_ptr
->flags
& PNG_FLAG_ZSTREAM_INITIALIZED
)
414 ret
= deflateReset(&png_ptr
->zstream
);
418 ret
= deflateInit2(&png_ptr
->zstream
, level
, method
, windowBits
,
422 png_ptr
->flags
|= PNG_FLAG_ZSTREAM_INITIALIZED
;
425 /* The return code is from either deflateReset or deflateInit2; they have
426 * pretty much the same set of error codes.
429 png_ptr
->zowner
= owner
;
432 png_zstream_error(png_ptr
, ret
);
438 /* Clean up (or trim) a linked list of compression buffers. */
440 png_free_buffer_list(png_structrp png_ptr
, png_compression_bufferp
*listp
)
442 png_compression_bufferp list
= *listp
;
450 png_compression_bufferp next
= list
->next
;
452 png_free(png_ptr
, list
);
455 while (list
!= NULL
);
459 #ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
460 /* This pair of functions encapsulates the operation of (a) compressing a
461 * text string, and (b) issuing it later as a series of chunk data writes.
462 * The compression_state structure is shared context for these functions
463 * set up by the caller to allow access to the relevant local variables.
465 * compression_buffer (new in 1.6.0) is just a linked list of zbuffer_size
466 * temporary buffers. From 1.6.0 it is retained in png_struct so that it will
467 * be correctly freed in the event of a write error (previous implementations
468 * just leaked memory.)
472 png_const_bytep input
; /* The uncompressed input data */
473 png_alloc_size_t input_len
; /* Its length */
474 png_uint_32 output_len
; /* Final compressed length */
475 png_byte output
[1024]; /* First block of output */
479 png_text_compress_init(compression_state
*comp
, png_const_bytep input
,
480 png_alloc_size_t input_len
)
483 comp
->input_len
= input_len
;
484 comp
->output_len
= 0;
487 /* Compress the data in the compression state input */
489 png_text_compress(png_structrp png_ptr
, png_uint_32 chunk_name
,
490 compression_state
*comp
, png_uint_32 prefix_len
)
494 /* To find the length of the output it is necessary to first compress the
495 * input, the result is buffered rather than using the two-pass algorithm
496 * that is used on the inflate side; deflate is assumed to be slower and a
497 * PNG writer is assumed to have more memory available than a PNG reader.
499 * IMPLEMENTATION NOTE: the zlib API deflateBound() can be used to find an
500 * upper limit on the output size, but it is always bigger than the input
501 * size so it is likely to be more efficient to use this linked-list
504 ret
= png_deflate_claim(png_ptr
, chunk_name
, comp
->input_len
);
509 /* Set up the compression buffers, we need a loop here to avoid overflowing a
510 * uInt. Use ZLIB_IO_MAX to limit the input. The output is always limited
511 * by the output buffer size, so there is no need to check that. Since this
512 * is ANSI-C we know that an 'int', hence a uInt, is always at least 16 bits
516 png_compression_bufferp
*end
= &png_ptr
->zbuffer_list
;
517 png_alloc_size_t input_len
= comp
->input_len
; /* may be zero! */
518 png_uint_32 output_len
;
520 /* zlib updates these for us: */
521 png_ptr
->zstream
.next_in
= PNGZ_INPUT_CAST(comp
->input
);
522 png_ptr
->zstream
.avail_in
= 0; /* Set below */
523 png_ptr
->zstream
.next_out
= comp
->output
;
524 png_ptr
->zstream
.avail_out
= (sizeof comp
->output
);
526 output_len
= png_ptr
->zstream
.avail_out
;
530 uInt avail_in
= ZLIB_IO_MAX
;
532 if (avail_in
> input_len
)
533 avail_in
= (uInt
)input_len
;
535 input_len
-= avail_in
;
537 png_ptr
->zstream
.avail_in
= avail_in
;
539 if (png_ptr
->zstream
.avail_out
== 0)
541 png_compression_buffer
*next
;
543 /* Chunk data is limited to 2^31 bytes in length, so the prefix
544 * length must be counted here.
546 if (output_len
+ prefix_len
> PNG_UINT_31_MAX
)
552 /* Need a new (malloc'ed) buffer, but there may be one present
558 next
= png_voidcast(png_compression_bufferp
, png_malloc_base
559 (png_ptr
, PNG_COMPRESSION_BUFFER_SIZE(png_ptr
)));
567 /* Link in this buffer (so that it will be freed later) */
572 png_ptr
->zstream
.next_out
= next
->output
;
573 png_ptr
->zstream
.avail_out
= png_ptr
->zbuffer_size
;
574 output_len
+= png_ptr
->zstream
.avail_out
;
576 /* Move 'end' to the next buffer pointer. */
580 /* Compress the data */
581 ret
= deflate(&png_ptr
->zstream
,
582 input_len
> 0 ? Z_NO_FLUSH
: Z_FINISH
);
584 /* Claw back input data that was not consumed (because avail_in is
585 * reset above every time round the loop).
587 input_len
+= png_ptr
->zstream
.avail_in
;
588 png_ptr
->zstream
.avail_in
= 0; /* safety */
592 /* There may be some space left in the last output buffer, this needs to
593 * be subtracted from output_len.
595 output_len
-= png_ptr
->zstream
.avail_out
;
596 png_ptr
->zstream
.avail_out
= 0; /* safety */
597 comp
->output_len
= output_len
;
599 /* Now double check the output length, put in a custom message if it is
600 * too long. Otherwise ensure the z_stream::msg pointer is set to
603 if (output_len
+ prefix_len
>= PNG_UINT_31_MAX
)
605 png_ptr
->zstream
.msg
= PNGZ_MSG_CAST("compressed data too long");
610 png_zstream_error(png_ptr
, ret
);
612 /* Reset zlib for another zTXt/iTXt or image data */
615 /* The only success case is Z_STREAM_END, input_len must be 0, if not this
616 * is an internal error.
618 if (ret
== Z_STREAM_END
&& input_len
== 0)
620 /* Fix up the deflate header, if required */
621 optimize_cmf(comp
->output
, comp
->input_len
);
623 /* But Z_OK is returned, not Z_STREAM_END; this allows the claim
624 * function above to return Z_STREAM_END on an error (though it never
625 * does in the current versions of zlib.)
635 /* Ship the compressed text out via chunk writes */
637 png_write_compressed_data_out(png_structrp png_ptr
, compression_state
*comp
)
639 png_uint_32 output_len
= comp
->output_len
;
640 png_const_bytep output
= comp
->output
;
641 png_uint_32 avail
= (sizeof comp
->output
);
642 png_compression_buffer
*next
= png_ptr
->zbuffer_list
;
646 if (avail
> output_len
)
649 png_write_chunk_data(png_ptr
, output
, avail
);
653 if (output_len
== 0 || next
== NULL
)
656 avail
= png_ptr
->zbuffer_size
;
657 output
= next
->output
;
661 /* This is an internal error; 'next' must have been NULL! */
663 png_error(png_ptr
, "error writing ancillary chunked compressed data");
665 #endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */
667 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
668 defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
669 /* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
670 * and if invalid, correct the keyword rather than discarding the entire
671 * chunk. The PNG 1.0 specification requires keywords 1-79 characters in
672 * length, forbids leading or trailing whitespace, multiple internal spaces,
673 * and the non-break space (0x80) from ISO 8859-1. Returns keyword length.
675 * The 'new_key' buffer must be 80 characters in size (for the keyword plus a
676 * trailing '\0'). If this routine returns 0 then there was no keyword, or a
677 * valid one could not be generated, and the caller must png_error.
680 png_check_keyword(png_structrp png_ptr
, png_const_charp key
, png_bytep new_key
)
682 png_const_charp orig_key
= key
;
683 png_uint_32 key_len
= 0;
684 int bad_character
= 0;
687 png_debug(1, "in png_check_keyword");
695 while (*key
&& key_len
< 79)
697 png_byte ch
= (png_byte
)(0xff & *key
++);
699 if ((ch
> 32 && ch
<= 126) || (ch
>= 161 /*&& ch <= 255*/))
700 *new_key
++ = ch
, ++key_len
, space
= 0;
704 /* A space or an invalid character when one wasn't seen immediately
705 * before; output just a space.
707 *new_key
++ = 32, ++key_len
, space
= 1;
709 /* If the character was not a space then it is invalid. */
714 else if (bad_character
== 0)
715 bad_character
= ch
; /* just skip it, record the first error */
718 if (key_len
> 0 && space
) /* trailing space */
720 --key_len
, --new_key
;
721 if (bad_character
== 0)
725 /* Terminate the keyword */
731 /* Try to only output one warning per keyword: */
732 if (*key
) /* keyword too long */
733 png_warning(png_ptr
, "keyword truncated");
735 else if (bad_character
!= 0)
737 PNG_WARNING_PARAMETERS(p
)
739 png_warning_parameter(p
, 1, orig_key
);
740 png_warning_parameter_signed(p
, 2, PNG_NUMBER_FORMAT_02x
, bad_character
);
742 png_formatted_warning(png_ptr
, p
, "keyword \"@1\": bad character '0x@2'");
749 /* Write the IHDR chunk, and update the png_struct with the necessary
750 * information. Note that the rest of this code depends upon this
751 * information being correct.
754 png_write_IHDR(png_structrp png_ptr
, png_uint_32 width
, png_uint_32 height
,
755 int bit_depth
, int color_type
, int compression_type
, int filter_type
,
758 png_byte buf
[13]; /* Buffer to store the IHDR info */
760 png_debug(1, "in png_write_IHDR");
762 /* Check that we have valid input data from the application info */
765 case PNG_COLOR_TYPE_GRAY
:
772 #ifdef PNG_WRITE_16BIT_SUPPORTED
775 png_ptr
->channels
= 1; break;
779 "Invalid bit depth for grayscale image");
783 case PNG_COLOR_TYPE_RGB
:
784 #ifdef PNG_WRITE_16BIT_SUPPORTED
785 if (bit_depth
!= 8 && bit_depth
!= 16)
789 png_error(png_ptr
, "Invalid bit depth for RGB image");
791 png_ptr
->channels
= 3;
794 case PNG_COLOR_TYPE_PALETTE
:
801 png_ptr
->channels
= 1;
805 png_error(png_ptr
, "Invalid bit depth for paletted image");
809 case PNG_COLOR_TYPE_GRAY_ALPHA
:
810 if (bit_depth
!= 8 && bit_depth
!= 16)
811 png_error(png_ptr
, "Invalid bit depth for grayscale+alpha image");
813 png_ptr
->channels
= 2;
816 case PNG_COLOR_TYPE_RGB_ALPHA
:
817 #ifdef PNG_WRITE_16BIT_SUPPORTED
818 if (bit_depth
!= 8 && bit_depth
!= 16)
822 png_error(png_ptr
, "Invalid bit depth for RGBA image");
824 png_ptr
->channels
= 4;
828 png_error(png_ptr
, "Invalid image color type specified");
831 if (compression_type
!= PNG_COMPRESSION_TYPE_BASE
)
833 png_warning(png_ptr
, "Invalid compression type specified");
834 compression_type
= PNG_COMPRESSION_TYPE_BASE
;
837 /* Write filter_method 64 (intrapixel differencing) only if
838 * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
839 * 2. Libpng did not write a PNG signature (this filter_method is only
840 * used in PNG datastreams that are embedded in MNG datastreams) and
841 * 3. The application called png_permit_mng_features with a mask that
842 * included PNG_FLAG_MNG_FILTER_64 and
843 * 4. The filter_method is 64 and
844 * 5. The color_type is RGB or RGBA
847 #ifdef PNG_MNG_FEATURES_SUPPORTED
848 !((png_ptr
->mng_features_permitted
& PNG_FLAG_MNG_FILTER_64
) &&
849 ((png_ptr
->mode
&PNG_HAVE_PNG_SIGNATURE
) == 0) &&
850 (color_type
== PNG_COLOR_TYPE_RGB
||
851 color_type
== PNG_COLOR_TYPE_RGB_ALPHA
) &&
852 (filter_type
== PNG_INTRAPIXEL_DIFFERENCING
)) &&
854 filter_type
!= PNG_FILTER_TYPE_BASE
)
856 png_warning(png_ptr
, "Invalid filter type specified");
857 filter_type
= PNG_FILTER_TYPE_BASE
;
860 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
861 if (interlace_type
!= PNG_INTERLACE_NONE
&&
862 interlace_type
!= PNG_INTERLACE_ADAM7
)
864 png_warning(png_ptr
, "Invalid interlace type specified");
865 interlace_type
= PNG_INTERLACE_ADAM7
;
868 interlace_type
=PNG_INTERLACE_NONE
;
871 /* Save the relevent information */
872 png_ptr
->bit_depth
= (png_byte
)bit_depth
;
873 png_ptr
->color_type
= (png_byte
)color_type
;
874 png_ptr
->interlaced
= (png_byte
)interlace_type
;
875 #ifdef PNG_MNG_FEATURES_SUPPORTED
876 png_ptr
->filter_type
= (png_byte
)filter_type
;
878 png_ptr
->compression_type
= (png_byte
)compression_type
;
879 png_ptr
->width
= width
;
880 png_ptr
->height
= height
;
882 png_ptr
->pixel_depth
= (png_byte
)(bit_depth
* png_ptr
->channels
);
883 png_ptr
->rowbytes
= PNG_ROWBYTES(png_ptr
->pixel_depth
, width
);
884 /* Set the usr info, so any transformations can modify it */
885 png_ptr
->usr_width
= png_ptr
->width
;
886 png_ptr
->usr_bit_depth
= png_ptr
->bit_depth
;
887 png_ptr
->usr_channels
= png_ptr
->channels
;
889 /* Pack the header information into the buffer */
890 png_save_uint_32(buf
, width
);
891 png_save_uint_32(buf
+ 4, height
);
892 buf
[8] = (png_byte
)bit_depth
;
893 buf
[9] = (png_byte
)color_type
;
894 buf
[10] = (png_byte
)compression_type
;
895 buf
[11] = (png_byte
)filter_type
;
896 buf
[12] = (png_byte
)interlace_type
;
898 /* Write the chunk */
899 png_write_complete_chunk(png_ptr
, png_IHDR
, buf
, (png_size_t
)13);
901 #ifdef PNG_WRITE_APNG_SUPPORTED
902 png_ptr
->first_frame_width
= width
;
903 png_ptr
->first_frame_height
= height
;
906 if ((png_ptr
->do_filter
) == PNG_NO_FILTERS
)
908 if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
||
909 png_ptr
->bit_depth
< 8)
910 png_ptr
->do_filter
= PNG_FILTER_NONE
;
913 png_ptr
->do_filter
= PNG_ALL_FILTERS
;
916 png_ptr
->mode
= PNG_HAVE_IHDR
; /* not READY_FOR_ZTXT */
919 /* Write the palette. We are careful not to trust png_color to be in the
920 * correct order for PNG, so people can redefine it to any convenient
924 png_write_PLTE(png_structrp png_ptr
, png_const_colorp palette
,
928 png_const_colorp pal_ptr
;
931 png_debug(1, "in png_write_PLTE");
934 #ifdef PNG_MNG_FEATURES_SUPPORTED
935 !(png_ptr
->mng_features_permitted
& PNG_FLAG_MNG_EMPTY_PLTE
) &&
937 num_pal
== 0) || num_pal
> 256)
939 if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
941 png_error(png_ptr
, "Invalid number of colors in palette");
946 png_warning(png_ptr
, "Invalid number of colors in palette");
951 if (!(png_ptr
->color_type
&PNG_COLOR_MASK_COLOR
))
954 "Ignoring request to write a PLTE chunk in grayscale PNG");
959 png_ptr
->num_palette
= (png_uint_16
)num_pal
;
960 png_debug1(3, "num_palette = %d", png_ptr
->num_palette
);
962 png_write_chunk_header(png_ptr
, png_PLTE
, (png_uint_32
)(num_pal
* 3));
963 #ifdef PNG_POINTER_INDEXING_SUPPORTED
965 for (i
= 0, pal_ptr
= palette
; i
< num_pal
; i
++, pal_ptr
++)
967 buf
[0] = pal_ptr
->red
;
968 buf
[1] = pal_ptr
->green
;
969 buf
[2] = pal_ptr
->blue
;
970 png_write_chunk_data(png_ptr
, buf
, (png_size_t
)3);
974 /* This is a little slower but some buggy compilers need to do this
979 for (i
= 0; i
< num_pal
; i
++)
981 buf
[0] = pal_ptr
[i
].red
;
982 buf
[1] = pal_ptr
[i
].green
;
983 buf
[2] = pal_ptr
[i
].blue
;
984 png_write_chunk_data(png_ptr
, buf
, (png_size_t
)3);
988 png_write_chunk_end(png_ptr
);
989 png_ptr
->mode
|= PNG_HAVE_PLTE
;
992 /* This is similar to png_text_compress, above, except that it does not require
993 * all of the data at once and, instead of buffering the compressed result,
994 * writes it as IDAT chunks. Unlike png_text_compress it *can* png_error out
995 * because it calls the write interface. As a result it does its own error
996 * reporting and does not return an error code. In the event of error it will
997 * just call png_error. The input data length may exceed 32-bits. The 'flush'
998 * parameter is exactly the same as that to deflate, with the following
1001 * Z_NO_FLUSH: normal incremental output of compressed data
1002 * Z_SYNC_FLUSH: do a SYNC_FLUSH, used by png_write_flush
1003 * Z_FINISH: this is the end of the input, do a Z_FINISH and clean up
1005 * The routine manages the acquire and release of the png_ptr->zstream by
1006 * checking and (at the end) clearing png_ptr->zowner, it does some sanity
1007 * checks on the 'mode' flags while doing this.
1010 png_compress_IDAT(png_structrp png_ptr
, png_const_bytep input
,
1011 png_alloc_size_t input_len
, int flush
)
1013 if (png_ptr
->zowner
!= png_IDAT
)
1015 /* First time. Ensure we have a temporary buffer for compression and
1016 * trim the buffer list if it has more than one entry to free memory.
1017 * If 'WRITE_COMPRESSED_TEXT' is not set the list will never have been
1018 * created at this point, but the check here is quick and safe.
1020 if (png_ptr
->zbuffer_list
== NULL
)
1022 png_ptr
->zbuffer_list
= png_voidcast(png_compression_bufferp
,
1023 png_malloc(png_ptr
, PNG_COMPRESSION_BUFFER_SIZE(png_ptr
)));
1024 png_ptr
->zbuffer_list
->next
= NULL
;
1028 png_free_buffer_list(png_ptr
, &png_ptr
->zbuffer_list
->next
);
1030 /* It is a terminal error if we can't claim the zstream. */
1031 if (png_deflate_claim(png_ptr
, png_IDAT
, png_image_size(png_ptr
)) != Z_OK
)
1032 png_error(png_ptr
, png_ptr
->zstream
.msg
);
1034 /* The output state is maintained in png_ptr->zstream, so it must be
1035 * initialized here after the claim.
1037 png_ptr
->zstream
.next_out
= png_ptr
->zbuffer_list
->output
;
1038 png_ptr
->zstream
.avail_out
= png_ptr
->zbuffer_size
;
1041 /* Now loop reading and writing until all the input is consumed or an error
1042 * terminates the operation. The _out values are maintained across calls to
1043 * this function, but the input must be reset each time.
1045 png_ptr
->zstream
.next_in
= PNGZ_INPUT_CAST(input
);
1046 png_ptr
->zstream
.avail_in
= 0; /* set below */
1051 /* INPUT: from the row data */
1052 uInt avail
= ZLIB_IO_MAX
;
1054 if (avail
> input_len
)
1055 avail
= (uInt
)input_len
; /* safe because of the check */
1057 png_ptr
->zstream
.avail_in
= avail
;
1060 ret
= deflate(&png_ptr
->zstream
, input_len
> 0 ? Z_NO_FLUSH
: flush
);
1062 /* Include as-yet unconsumed input */
1063 input_len
+= png_ptr
->zstream
.avail_in
;
1064 png_ptr
->zstream
.avail_in
= 0;
1066 /* OUTPUT: write complete IDAT chunks when avail_out drops to zero, note
1067 * that these two zstream fields are preserved across the calls, therefore
1068 * there is no need to set these up on entry to the loop.
1070 if (png_ptr
->zstream
.avail_out
== 0)
1072 png_bytep data
= png_ptr
->zbuffer_list
->output
;
1073 uInt size
= png_ptr
->zbuffer_size
;
1075 /* Write an IDAT containing the data then reset the buffer. The
1076 * first IDAT may need deflate header optimization.
1078 # ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
1079 if (!(png_ptr
->mode
& PNG_HAVE_IDAT
) &&
1080 png_ptr
->compression_type
== PNG_COMPRESSION_TYPE_BASE
)
1081 optimize_cmf(data
, png_image_size(png_ptr
));
1084 # ifdef PNG_WRITE_APNG_SUPPORTED
1085 if (png_ptr
->num_frames_written
== 0)
1087 png_write_complete_chunk(png_ptr
, png_IDAT
, data
, size
);
1088 # ifdef PNG_WRITE_APNG_SUPPORTED
1090 png_write_fdAT(png_ptr
, data
, size
);
1091 # endif /* PNG_WRITE_APNG_SUPPORTED */
1093 png_ptr
->mode
|= PNG_HAVE_IDAT
;
1095 png_ptr
->zstream
.next_out
= data
;
1096 png_ptr
->zstream
.avail_out
= size
;
1098 /* For SYNC_FLUSH or FINISH it is essential to keep calling zlib with
1099 * the same flush parameter until it has finished output, for NO_FLUSH
1100 * it doesn't matter.
1102 if (ret
== Z_OK
&& flush
!= Z_NO_FLUSH
)
1106 /* The order of these checks doesn't matter much; it just effect which
1107 * possible error might be detected if multiple things go wrong at once.
1109 if (ret
== Z_OK
) /* most likely return code! */
1111 /* If all the input has been consumed then just return. If Z_FINISH
1112 * was used as the flush parameter something has gone wrong if we get
1117 if (flush
== Z_FINISH
)
1118 png_error(png_ptr
, "Z_OK on Z_FINISH with output space");
1124 else if (ret
== Z_STREAM_END
&& flush
== Z_FINISH
)
1126 /* This is the end of the IDAT data; any pending output must be
1127 * flushed. For small PNG files we may still be at the beginning.
1129 png_bytep data
= png_ptr
->zbuffer_list
->output
;
1130 uInt size
= png_ptr
->zbuffer_size
- png_ptr
->zstream
.avail_out
;
1132 # ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
1133 if (!(png_ptr
->mode
& PNG_HAVE_IDAT
) &&
1134 png_ptr
->compression_type
== PNG_COMPRESSION_TYPE_BASE
)
1135 optimize_cmf(data
, png_image_size(png_ptr
));
1138 # ifdef PNG_WRITE_APNG_SUPPORTED
1139 if (png_ptr
->num_frames_written
== 0)
1141 png_write_complete_chunk(png_ptr
, png_IDAT
, data
, size
);
1142 # ifdef PNG_WRITE_APNG_SUPPORTED
1144 png_write_fdAT(png_ptr
, data
, size
);
1145 # endif /* PNG_WRITE_APNG_SUPPORTED */
1147 png_ptr
->zstream
.avail_out
= 0;
1148 png_ptr
->zstream
.next_out
= NULL
;
1149 png_ptr
->mode
|= PNG_HAVE_IDAT
| PNG_AFTER_IDAT
;
1151 png_ptr
->zowner
= 0; /* Release the stream */
1157 /* This is an error condition. */
1158 png_zstream_error(png_ptr
, ret
);
1159 png_error(png_ptr
, png_ptr
->zstream
.msg
);
1164 /* Write an IEND chunk */
1166 png_write_IEND(png_structrp png_ptr
)
1168 png_debug(1, "in png_write_IEND");
1170 png_write_complete_chunk(png_ptr
, png_IEND
, NULL
, (png_size_t
)0);
1171 png_ptr
->mode
|= PNG_HAVE_IEND
;
1174 #ifdef PNG_WRITE_gAMA_SUPPORTED
1175 /* Write a gAMA chunk */
1177 png_write_gAMA_fixed(png_structrp png_ptr
, png_fixed_point file_gamma
)
1181 png_debug(1, "in png_write_gAMA");
1183 /* file_gamma is saved in 1/100,000ths */
1184 png_save_uint_32(buf
, (png_uint_32
)file_gamma
);
1185 png_write_complete_chunk(png_ptr
, png_gAMA
, buf
, (png_size_t
)4);
1189 #ifdef PNG_WRITE_sRGB_SUPPORTED
1190 /* Write a sRGB chunk */
1192 png_write_sRGB(png_structrp png_ptr
, int srgb_intent
)
1196 png_debug(1, "in png_write_sRGB");
1198 if (srgb_intent
>= PNG_sRGB_INTENT_LAST
)
1199 png_warning(png_ptr
,
1200 "Invalid sRGB rendering intent specified");
1202 buf
[0]=(png_byte
)srgb_intent
;
1203 png_write_complete_chunk(png_ptr
, png_sRGB
, buf
, (png_size_t
)1);
1207 #ifdef PNG_WRITE_iCCP_SUPPORTED
1208 /* Write an iCCP chunk */
1210 png_write_iCCP(png_structrp png_ptr
, png_const_charp name
,
1211 png_const_bytep profile
)
1213 png_uint_32 name_len
;
1214 png_uint_32 profile_len
;
1215 png_byte new_name
[81]; /* 1 byte for the compression byte */
1216 compression_state comp
;
1219 png_debug(1, "in png_write_iCCP");
1221 /* These are all internal problems: the profile should have been checked
1222 * before when it was stored.
1224 if (profile
== NULL
)
1225 png_error(png_ptr
, "No profile for iCCP chunk"); /* internal error */
1227 profile_len
= png_get_uint_32(profile
);
1229 if (profile_len
< 132)
1230 png_error(png_ptr
, "ICC profile too short");
1232 temp
= (png_uint_32
) (*(profile
+8));
1233 if (temp
> 3 && (profile_len
& 0x03))
1234 png_error(png_ptr
, "ICC profile length invalid (not a multiple of 4)");
1237 png_uint_32 embedded_profile_len
= png_get_uint_32(profile
);
1239 if (profile_len
!= embedded_profile_len
)
1240 png_error(png_ptr
, "Profile length does not match profile");
1243 name_len
= png_check_keyword(png_ptr
, name
, new_name
);
1246 png_error(png_ptr
, "iCCP: invalid keyword");
1248 new_name
[++name_len
] = PNG_COMPRESSION_TYPE_BASE
;
1250 /* Make sure we include the NULL after the name and the compression type */
1253 png_text_compress_init(&comp
, profile
, profile_len
);
1255 /* Allow for keyword terminator and compression byte */
1256 if (png_text_compress(png_ptr
, png_iCCP
, &comp
, name_len
) != Z_OK
)
1257 png_error(png_ptr
, png_ptr
->zstream
.msg
);
1259 png_write_chunk_header(png_ptr
, png_iCCP
, name_len
+ comp
.output_len
);
1261 png_write_chunk_data(png_ptr
, new_name
, name_len
);
1263 png_write_compressed_data_out(png_ptr
, &comp
);
1265 png_write_chunk_end(png_ptr
);
1269 #ifdef PNG_WRITE_sPLT_SUPPORTED
1270 /* Write a sPLT chunk */
1272 png_write_sPLT(png_structrp png_ptr
, png_const_sPLT_tp spalette
)
1274 png_uint_32 name_len
;
1275 png_byte new_name
[80];
1276 png_byte entrybuf
[10];
1277 png_size_t entry_size
= (spalette
->depth
== 8 ? 6 : 10);
1278 png_size_t palette_size
= entry_size
* spalette
->nentries
;
1280 #ifndef PNG_POINTER_INDEXING_SUPPORTED
1284 png_debug(1, "in png_write_sPLT");
1286 name_len
= png_check_keyword(png_ptr
, spalette
->name
, new_name
);
1289 png_error(png_ptr
, "sPLT: invalid keyword");
1291 /* Make sure we include the NULL after the name */
1292 png_write_chunk_header(png_ptr
, png_sPLT
,
1293 (png_uint_32
)(name_len
+ 2 + palette_size
));
1295 png_write_chunk_data(png_ptr
, (png_bytep
)new_name
,
1296 (png_size_t
)(name_len
+ 1));
1298 png_write_chunk_data(png_ptr
, &spalette
->depth
, (png_size_t
)1);
1300 /* Loop through each palette entry, writing appropriately */
1301 #ifdef PNG_POINTER_INDEXING_SUPPORTED
1302 for (ep
= spalette
->entries
; ep
<spalette
->entries
+ spalette
->nentries
; ep
++)
1304 if (spalette
->depth
== 8)
1306 entrybuf
[0] = (png_byte
)ep
->red
;
1307 entrybuf
[1] = (png_byte
)ep
->green
;
1308 entrybuf
[2] = (png_byte
)ep
->blue
;
1309 entrybuf
[3] = (png_byte
)ep
->alpha
;
1310 png_save_uint_16(entrybuf
+ 4, ep
->frequency
);
1315 png_save_uint_16(entrybuf
+ 0, ep
->red
);
1316 png_save_uint_16(entrybuf
+ 2, ep
->green
);
1317 png_save_uint_16(entrybuf
+ 4, ep
->blue
);
1318 png_save_uint_16(entrybuf
+ 6, ep
->alpha
);
1319 png_save_uint_16(entrybuf
+ 8, ep
->frequency
);
1322 png_write_chunk_data(png_ptr
, entrybuf
, entry_size
);
1325 ep
=spalette
->entries
;
1326 for (i
= 0; i
>spalette
->nentries
; i
++)
1328 if (spalette
->depth
== 8)
1330 entrybuf
[0] = (png_byte
)ep
[i
].red
;
1331 entrybuf
[1] = (png_byte
)ep
[i
].green
;
1332 entrybuf
[2] = (png_byte
)ep
[i
].blue
;
1333 entrybuf
[3] = (png_byte
)ep
[i
].alpha
;
1334 png_save_uint_16(entrybuf
+ 4, ep
[i
].frequency
);
1339 png_save_uint_16(entrybuf
+ 0, ep
[i
].red
);
1340 png_save_uint_16(entrybuf
+ 2, ep
[i
].green
);
1341 png_save_uint_16(entrybuf
+ 4, ep
[i
].blue
);
1342 png_save_uint_16(entrybuf
+ 6, ep
[i
].alpha
);
1343 png_save_uint_16(entrybuf
+ 8, ep
[i
].frequency
);
1346 png_write_chunk_data(png_ptr
, entrybuf
, entry_size
);
1350 png_write_chunk_end(png_ptr
);
1354 #ifdef PNG_WRITE_sBIT_SUPPORTED
1355 /* Write the sBIT chunk */
1357 png_write_sBIT(png_structrp png_ptr
, png_const_color_8p sbit
, int color_type
)
1362 png_debug(1, "in png_write_sBIT");
1364 /* Make sure we don't depend upon the order of PNG_COLOR_8 */
1365 if (color_type
& PNG_COLOR_MASK_COLOR
)
1369 maxbits
= (png_byte
)(color_type
==PNG_COLOR_TYPE_PALETTE
? 8 :
1370 png_ptr
->usr_bit_depth
);
1372 if (sbit
->red
== 0 || sbit
->red
> maxbits
||
1373 sbit
->green
== 0 || sbit
->green
> maxbits
||
1374 sbit
->blue
== 0 || sbit
->blue
> maxbits
)
1376 png_warning(png_ptr
, "Invalid sBIT depth specified");
1381 buf
[1] = sbit
->green
;
1382 buf
[2] = sbit
->blue
;
1388 if (sbit
->gray
== 0 || sbit
->gray
> png_ptr
->usr_bit_depth
)
1390 png_warning(png_ptr
, "Invalid sBIT depth specified");
1394 buf
[0] = sbit
->gray
;
1398 if (color_type
& PNG_COLOR_MASK_ALPHA
)
1400 if (sbit
->alpha
== 0 || sbit
->alpha
> png_ptr
->usr_bit_depth
)
1402 png_warning(png_ptr
, "Invalid sBIT depth specified");
1406 buf
[size
++] = sbit
->alpha
;
1409 png_write_complete_chunk(png_ptr
, png_sBIT
, buf
, size
);
1413 #ifdef PNG_WRITE_cHRM_SUPPORTED
1414 /* Write the cHRM chunk */
1416 png_write_cHRM_fixed(png_structrp png_ptr
, const png_xy
*xy
)
1420 png_debug(1, "in png_write_cHRM");
1422 /* Each value is saved in 1/100,000ths */
1423 png_save_int_32(buf
, xy
->whitex
);
1424 png_save_int_32(buf
+ 4, xy
->whitey
);
1426 png_save_int_32(buf
+ 8, xy
->redx
);
1427 png_save_int_32(buf
+ 12, xy
->redy
);
1429 png_save_int_32(buf
+ 16, xy
->greenx
);
1430 png_save_int_32(buf
+ 20, xy
->greeny
);
1432 png_save_int_32(buf
+ 24, xy
->bluex
);
1433 png_save_int_32(buf
+ 28, xy
->bluey
);
1435 png_write_complete_chunk(png_ptr
, png_cHRM
, buf
, 32);
1439 #ifdef PNG_WRITE_tRNS_SUPPORTED
1440 /* Write the tRNS chunk */
1442 png_write_tRNS(png_structrp png_ptr
, png_const_bytep trans_alpha
,
1443 png_const_color_16p tran
, int num_trans
, int color_type
)
1447 png_debug(1, "in png_write_tRNS");
1449 if (color_type
== PNG_COLOR_TYPE_PALETTE
)
1451 if (num_trans
<= 0 || num_trans
> (int)png_ptr
->num_palette
)
1453 png_app_warning(png_ptr
,
1454 "Invalid number of transparent colors specified");
1458 /* Write the chunk out as it is */
1459 png_write_complete_chunk(png_ptr
, png_tRNS
, trans_alpha
,
1460 (png_size_t
)num_trans
);
1463 else if (color_type
== PNG_COLOR_TYPE_GRAY
)
1465 /* One 16 bit value */
1466 if (tran
->gray
>= (1 << png_ptr
->bit_depth
))
1468 png_app_warning(png_ptr
,
1469 "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
1474 png_save_uint_16(buf
, tran
->gray
);
1475 png_write_complete_chunk(png_ptr
, png_tRNS
, buf
, (png_size_t
)2);
1478 else if (color_type
== PNG_COLOR_TYPE_RGB
)
1480 /* Three 16 bit values */
1481 png_save_uint_16(buf
, tran
->red
);
1482 png_save_uint_16(buf
+ 2, tran
->green
);
1483 png_save_uint_16(buf
+ 4, tran
->blue
);
1484 #ifdef PNG_WRITE_16BIT_SUPPORTED
1485 if (png_ptr
->bit_depth
== 8 && (buf
[0] | buf
[2] | buf
[4]))
1487 if (buf
[0] | buf
[2] | buf
[4])
1490 png_app_warning(png_ptr
,
1491 "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
1495 png_write_complete_chunk(png_ptr
, png_tRNS
, buf
, (png_size_t
)6);
1500 png_app_warning(png_ptr
, "Can't write tRNS with an alpha channel");
1505 #ifdef PNG_WRITE_bKGD_SUPPORTED
1506 /* Write the background chunk */
1508 png_write_bKGD(png_structrp png_ptr
, png_const_color_16p back
, int color_type
)
1512 png_debug(1, "in png_write_bKGD");
1514 if (color_type
== PNG_COLOR_TYPE_PALETTE
)
1517 #ifdef PNG_MNG_FEATURES_SUPPORTED
1518 (png_ptr
->num_palette
||
1519 (!(png_ptr
->mng_features_permitted
& PNG_FLAG_MNG_EMPTY_PLTE
))) &&
1521 back
->index
>= png_ptr
->num_palette
)
1523 png_warning(png_ptr
, "Invalid background palette index");
1527 buf
[0] = back
->index
;
1528 png_write_complete_chunk(png_ptr
, png_bKGD
, buf
, (png_size_t
)1);
1531 else if (color_type
& PNG_COLOR_MASK_COLOR
)
1533 png_save_uint_16(buf
, back
->red
);
1534 png_save_uint_16(buf
+ 2, back
->green
);
1535 png_save_uint_16(buf
+ 4, back
->blue
);
1536 #ifdef PNG_WRITE_16BIT_SUPPORTED
1537 if (png_ptr
->bit_depth
== 8 && (buf
[0] | buf
[2] | buf
[4]))
1539 if (buf
[0] | buf
[2] | buf
[4])
1542 png_warning(png_ptr
,
1543 "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
1548 png_write_complete_chunk(png_ptr
, png_bKGD
, buf
, (png_size_t
)6);
1553 if (back
->gray
>= (1 << png_ptr
->bit_depth
))
1555 png_warning(png_ptr
,
1556 "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");
1561 png_save_uint_16(buf
, back
->gray
);
1562 png_write_complete_chunk(png_ptr
, png_bKGD
, buf
, (png_size_t
)2);
1567 #ifdef PNG_WRITE_hIST_SUPPORTED
1568 /* Write the histogram */
1570 png_write_hIST(png_structrp png_ptr
, png_const_uint_16p hist
, int num_hist
)
1575 png_debug(1, "in png_write_hIST");
1577 if (num_hist
> (int)png_ptr
->num_palette
)
1579 png_debug2(3, "num_hist = %d, num_palette = %d", num_hist
,
1580 png_ptr
->num_palette
);
1582 png_warning(png_ptr
, "Invalid number of histogram entries specified");
1586 png_write_chunk_header(png_ptr
, png_hIST
, (png_uint_32
)(num_hist
* 2));
1588 for (i
= 0; i
< num_hist
; i
++)
1590 png_save_uint_16(buf
, hist
[i
]);
1591 png_write_chunk_data(png_ptr
, buf
, (png_size_t
)2);
1594 png_write_chunk_end(png_ptr
);
1598 #ifdef PNG_WRITE_tEXt_SUPPORTED
1599 /* Write a tEXt chunk */
1601 png_write_tEXt(png_structrp png_ptr
, png_const_charp key
, png_const_charp text
,
1602 png_size_t text_len
)
1604 png_uint_32 key_len
;
1605 png_byte new_key
[80];
1607 png_debug(1, "in png_write_tEXt");
1609 key_len
= png_check_keyword(png_ptr
, key
, new_key
);
1612 png_error(png_ptr
, "tEXt: invalid keyword");
1614 if (text
== NULL
|| *text
== '\0')
1618 text_len
= strlen(text
);
1620 if (text_len
> PNG_UINT_31_MAX
- (key_len
+1))
1621 png_error(png_ptr
, "tEXt: text too long");
1623 /* Make sure we include the 0 after the key */
1624 png_write_chunk_header(png_ptr
, png_tEXt
,
1625 (png_uint_32
)/*checked above*/(key_len
+ text_len
+ 1));
1627 * We leave it to the application to meet PNG-1.0 requirements on the
1628 * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
1629 * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
1630 * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
1632 png_write_chunk_data(png_ptr
, new_key
, key_len
+ 1);
1635 png_write_chunk_data(png_ptr
, (png_const_bytep
)text
, text_len
);
1637 png_write_chunk_end(png_ptr
);
1641 #ifdef PNG_WRITE_zTXt_SUPPORTED
1642 /* Write a compressed text chunk */
1644 png_write_zTXt(png_structrp png_ptr
, png_const_charp key
, png_const_charp text
,
1645 png_size_t text_len
, int compression
)
1647 png_uint_32 key_len
;
1648 png_byte new_key
[81];
1649 compression_state comp
;
1651 png_debug(1, "in png_write_zTXt");
1652 PNG_UNUSED(text_len
) /* Always use strlen */
1654 if (compression
== PNG_TEXT_COMPRESSION_NONE
)
1656 png_write_tEXt(png_ptr
, key
, text
, 0);
1660 if (compression
!= PNG_TEXT_COMPRESSION_zTXt
)
1661 png_error(png_ptr
, "zTXt: invalid compression type");
1663 key_len
= png_check_keyword(png_ptr
, key
, new_key
);
1666 png_error(png_ptr
, "zTXt: invalid keyword");
1668 /* Add the compression method and 1 for the keyword separator. */
1669 new_key
[++key_len
] = PNG_COMPRESSION_TYPE_BASE
;
1672 /* Compute the compressed data; do it now for the length */
1673 png_text_compress_init(&comp
, (png_const_bytep
)text
,
1674 text
== NULL
? 0 : strlen(text
));
1676 if (png_text_compress(png_ptr
, png_zTXt
, &comp
, key_len
) != Z_OK
)
1677 png_error(png_ptr
, png_ptr
->zstream
.msg
);
1679 /* Write start of chunk */
1680 png_write_chunk_header(png_ptr
, png_zTXt
, key_len
+ comp
.output_len
);
1683 png_write_chunk_data(png_ptr
, new_key
, key_len
);
1685 /* Write the compressed data */
1686 png_write_compressed_data_out(png_ptr
, &comp
);
1688 /* Close the chunk */
1689 png_write_chunk_end(png_ptr
);
1693 #ifdef PNG_WRITE_iTXt_SUPPORTED
1694 /* Write an iTXt chunk */
1696 png_write_iTXt(png_structrp png_ptr
, int compression
, png_const_charp key
,
1697 png_const_charp lang
, png_const_charp lang_key
, png_const_charp text
)
1699 png_uint_32 key_len
, prefix_len
;
1700 png_size_t lang_len
, lang_key_len
;
1701 png_byte new_key
[82];
1702 compression_state comp
;
1704 png_debug(1, "in png_write_iTXt");
1706 key_len
= png_check_keyword(png_ptr
, key
, new_key
);
1709 png_error(png_ptr
, "iTXt: invalid keyword");
1711 /* Set the compression flag */
1712 switch (compression
)
1714 case PNG_ITXT_COMPRESSION_NONE
:
1715 case PNG_TEXT_COMPRESSION_NONE
:
1716 compression
= new_key
[++key_len
] = 0; /* no compression */
1719 case PNG_TEXT_COMPRESSION_zTXt
:
1720 case PNG_ITXT_COMPRESSION_zTXt
:
1721 compression
= new_key
[++key_len
] = 1; /* compressed */
1725 png_error(png_ptr
, "iTXt: invalid compression");
1728 new_key
[++key_len
] = PNG_COMPRESSION_TYPE_BASE
;
1729 ++key_len
; /* for the keywod separator */
1731 /* We leave it to the application to meet PNG-1.0 requirements on the
1732 * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
1733 * any non-Latin-1 characters except for NEWLINE. ISO PNG, however,
1734 * specifies that the text is UTF-8 and this really doesn't require any
1737 * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
1739 * TODO: validate the language tag correctly (see the spec.)
1741 if (lang
== NULL
) lang
= ""; /* empty language is valid */
1742 lang_len
= strlen(lang
)+1;
1743 if (lang_key
== NULL
) lang_key
= ""; /* may be empty */
1744 lang_key_len
= strlen(lang_key
)+1;
1745 if (text
== NULL
) text
= ""; /* may be empty */
1747 prefix_len
= key_len
;
1748 if (lang_len
> PNG_UINT_31_MAX
-prefix_len
)
1749 prefix_len
= PNG_UINT_31_MAX
;
1751 prefix_len
= (png_uint_32
)(prefix_len
+ lang_len
);
1753 if (lang_key_len
> PNG_UINT_31_MAX
-prefix_len
)
1754 prefix_len
= PNG_UINT_31_MAX
;
1756 prefix_len
= (png_uint_32
)(prefix_len
+ lang_key_len
);
1758 png_text_compress_init(&comp
, (png_const_bytep
)text
, strlen(text
));
1760 if (compression
!= 0)
1762 if (png_text_compress(png_ptr
, png_iTXt
, &comp
, prefix_len
) != Z_OK
)
1763 png_error(png_ptr
, png_ptr
->zstream
.msg
);
1768 if (comp
.input_len
> PNG_UINT_31_MAX
-prefix_len
)
1769 png_error(png_ptr
, "iTXt: uncompressed text too long");
1771 /* So the string will fit in a chunk: */
1772 comp
.output_len
= (png_uint_32
)/*SAFE*/comp
.input_len
;
1775 png_write_chunk_header(png_ptr
, png_iTXt
, comp
.output_len
+ prefix_len
);
1777 png_write_chunk_data(png_ptr
, new_key
, key_len
);
1779 png_write_chunk_data(png_ptr
, (png_const_bytep
)lang
, lang_len
);
1781 png_write_chunk_data(png_ptr
, (png_const_bytep
)lang_key
, lang_key_len
);
1783 if (compression
!= 0)
1784 png_write_compressed_data_out(png_ptr
, &comp
);
1787 png_write_chunk_data(png_ptr
, (png_const_bytep
)text
, comp
.input_len
);
1789 png_write_chunk_end(png_ptr
);
1793 #ifdef PNG_WRITE_oFFs_SUPPORTED
1794 /* Write the oFFs chunk */
1796 png_write_oFFs(png_structrp png_ptr
, png_int_32 x_offset
, png_int_32 y_offset
,
1801 png_debug(1, "in png_write_oFFs");
1803 if (unit_type
>= PNG_OFFSET_LAST
)
1804 png_warning(png_ptr
, "Unrecognized unit type for oFFs chunk");
1806 png_save_int_32(buf
, x_offset
);
1807 png_save_int_32(buf
+ 4, y_offset
);
1808 buf
[8] = (png_byte
)unit_type
;
1810 png_write_complete_chunk(png_ptr
, png_oFFs
, buf
, (png_size_t
)9);
1813 #ifdef PNG_WRITE_pCAL_SUPPORTED
1814 /* Write the pCAL chunk (described in the PNG extensions document) */
1816 png_write_pCAL(png_structrp png_ptr
, png_charp purpose
, png_int_32 X0
,
1817 png_int_32 X1
, int type
, int nparams
, png_const_charp units
,
1820 png_uint_32 purpose_len
;
1821 png_size_t units_len
, total_len
;
1822 png_size_tp params_len
;
1824 png_byte new_purpose
[80];
1827 png_debug1(1, "in png_write_pCAL (%d parameters)", nparams
);
1829 if (type
>= PNG_EQUATION_LAST
)
1830 png_error(png_ptr
, "Unrecognized equation type for pCAL chunk");
1832 purpose_len
= png_check_keyword(png_ptr
, purpose
, new_purpose
);
1834 if (purpose_len
== 0)
1835 png_error(png_ptr
, "pCAL: invalid keyword");
1837 ++purpose_len
; /* terminator */
1839 png_debug1(3, "pCAL purpose length = %d", (int)purpose_len
);
1840 units_len
= strlen(units
) + (nparams
== 0 ? 0 : 1);
1841 png_debug1(3, "pCAL units length = %d", (int)units_len
);
1842 total_len
= purpose_len
+ units_len
+ 10;
1844 params_len
= (png_size_tp
)png_malloc(png_ptr
,
1845 (png_alloc_size_t
)(nparams
* (sizeof (png_size_t
))));
1847 /* Find the length of each parameter, making sure we don't count the
1848 * null terminator for the last parameter.
1850 for (i
= 0; i
< nparams
; i
++)
1852 params_len
[i
] = strlen(params
[i
]) + (i
== nparams
- 1 ? 0 : 1);
1853 png_debug2(3, "pCAL parameter %d length = %lu", i
,
1854 (unsigned long)params_len
[i
]);
1855 total_len
+= params_len
[i
];
1858 png_debug1(3, "pCAL total length = %d", (int)total_len
);
1859 png_write_chunk_header(png_ptr
, png_pCAL
, (png_uint_32
)total_len
);
1860 png_write_chunk_data(png_ptr
, new_purpose
, purpose_len
);
1861 png_save_int_32(buf
, X0
);
1862 png_save_int_32(buf
+ 4, X1
);
1863 buf
[8] = (png_byte
)type
;
1864 buf
[9] = (png_byte
)nparams
;
1865 png_write_chunk_data(png_ptr
, buf
, (png_size_t
)10);
1866 png_write_chunk_data(png_ptr
, (png_const_bytep
)units
, (png_size_t
)units_len
);
1868 for (i
= 0; i
< nparams
; i
++)
1870 png_write_chunk_data(png_ptr
, (png_const_bytep
)params
[i
], params_len
[i
]);
1873 png_free(png_ptr
, params_len
);
1874 png_write_chunk_end(png_ptr
);
1878 #ifdef PNG_WRITE_sCAL_SUPPORTED
1879 /* Write the sCAL chunk */
1881 png_write_sCAL_s(png_structrp png_ptr
, int unit
, png_const_charp width
,
1882 png_const_charp height
)
1885 png_size_t wlen
, hlen
, total_len
;
1887 png_debug(1, "in png_write_sCAL_s");
1889 wlen
= strlen(width
);
1890 hlen
= strlen(height
);
1891 total_len
= wlen
+ hlen
+ 2;
1895 png_warning(png_ptr
, "Can't write sCAL (buffer too small)");
1899 buf
[0] = (png_byte
)unit
;
1900 memcpy(buf
+ 1, width
, wlen
+ 1); /* Append the '\0' here */
1901 memcpy(buf
+ wlen
+ 2, height
, hlen
); /* Do NOT append the '\0' here */
1903 png_debug1(3, "sCAL total length = %u", (unsigned int)total_len
);
1904 png_write_complete_chunk(png_ptr
, png_sCAL
, buf
, total_len
);
1908 #ifdef PNG_WRITE_pHYs_SUPPORTED
1909 /* Write the pHYs chunk */
1911 png_write_pHYs(png_structrp png_ptr
, png_uint_32 x_pixels_per_unit
,
1912 png_uint_32 y_pixels_per_unit
,
1917 png_debug(1, "in png_write_pHYs");
1919 if (unit_type
>= PNG_RESOLUTION_LAST
)
1920 png_warning(png_ptr
, "Unrecognized unit type for pHYs chunk");
1922 png_save_uint_32(buf
, x_pixels_per_unit
);
1923 png_save_uint_32(buf
+ 4, y_pixels_per_unit
);
1924 buf
[8] = (png_byte
)unit_type
;
1926 png_write_complete_chunk(png_ptr
, png_pHYs
, buf
, (png_size_t
)9);
1930 #ifdef PNG_WRITE_tIME_SUPPORTED
1931 /* Write the tIME chunk. Use either png_convert_from_struct_tm()
1932 * or png_convert_from_time_t(), or fill in the structure yourself.
1935 png_write_tIME(png_structrp png_ptr
, png_const_timep mod_time
)
1939 png_debug(1, "in png_write_tIME");
1941 if (mod_time
->month
> 12 || mod_time
->month
< 1 ||
1942 mod_time
->day
> 31 || mod_time
->day
< 1 ||
1943 mod_time
->hour
> 23 || mod_time
->second
> 60)
1945 png_warning(png_ptr
, "Invalid time specified for tIME chunk");
1949 png_save_uint_16(buf
, mod_time
->year
);
1950 buf
[2] = mod_time
->month
;
1951 buf
[3] = mod_time
->day
;
1952 buf
[4] = mod_time
->hour
;
1953 buf
[5] = mod_time
->minute
;
1954 buf
[6] = mod_time
->second
;
1956 png_write_complete_chunk(png_ptr
, png_tIME
, buf
, (png_size_t
)7);
1960 #ifdef PNG_WRITE_APNG_SUPPORTED
1962 png_write_acTL(png_structp png_ptr
,
1963 png_uint_32 num_frames
, png_uint_32 num_plays
)
1967 png_debug(1, "in png_write_acTL");
1969 png_ptr
->num_frames_to_write
= num_frames
;
1971 if (png_ptr
->apng_flags
& PNG_FIRST_FRAME_HIDDEN
)
1974 png_save_uint_32(buf
, num_frames
);
1975 png_save_uint_32(buf
+ 4, num_plays
);
1977 png_write_complete_chunk(png_ptr
, png_acTL
, buf
, (png_size_t
)8);
1981 png_write_fcTL(png_structp png_ptr
, png_uint_32 width
, png_uint_32 height
,
1982 png_uint_32 x_offset
, png_uint_32 y_offset
,
1983 png_uint_16 delay_num
, png_uint_16 delay_den
, png_byte dispose_op
,
1988 png_debug(1, "in png_write_fcTL");
1990 if (png_ptr
->num_frames_written
== 0 && (x_offset
!= 0 || y_offset
!= 0))
1991 png_error(png_ptr
, "x and/or y offset for the first frame aren't 0");
1992 if (png_ptr
->num_frames_written
== 0 &&
1993 (width
!= png_ptr
->first_frame_width
||
1994 height
!= png_ptr
->first_frame_height
))
1995 png_error(png_ptr
, "width and/or height in the first frame's fcTL "
1996 "don't match the ones in IHDR");
1998 /* more error checking */
1999 png_ensure_fcTL_is_valid(png_ptr
, width
, height
, x_offset
, y_offset
,
2000 delay_num
, delay_den
, dispose_op
, blend_op
);
2002 png_save_uint_32(buf
, png_ptr
->next_seq_num
);
2003 png_save_uint_32(buf
+ 4, width
);
2004 png_save_uint_32(buf
+ 8, height
);
2005 png_save_uint_32(buf
+ 12, x_offset
);
2006 png_save_uint_32(buf
+ 16, y_offset
);
2007 png_save_uint_16(buf
+ 20, delay_num
);
2008 png_save_uint_16(buf
+ 22, delay_den
);
2009 buf
[24] = dispose_op
;
2012 png_write_complete_chunk(png_ptr
, png_fcTL
, buf
, (png_size_t
)26);
2014 png_ptr
->next_seq_num
++;
2018 png_write_fdAT(png_structp png_ptr
,
2019 png_const_bytep data
, png_size_t length
)
2023 png_write_chunk_header(png_ptr
, png_fdAT
, (png_uint_32
)(4 + length
));
2025 png_save_uint_32(buf
, png_ptr
->next_seq_num
);
2026 png_write_chunk_data(png_ptr
, buf
, 4);
2028 png_write_chunk_data(png_ptr
, data
, length
);
2030 png_write_chunk_end(png_ptr
);
2032 png_ptr
->next_seq_num
++;
2034 #endif /* PNG_WRITE_APNG_SUPPORTED */
2036 /* Initializes the row writing capability of libpng */
2038 png_write_start_row(png_structrp png_ptr
)
2040 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2041 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
2043 /* Start of interlace block */
2044 static PNG_CONST png_byte png_pass_start
[7] = {0, 4, 0, 2, 0, 1, 0};
2046 /* Offset to next interlace block */
2047 static PNG_CONST png_byte png_pass_inc
[7] = {8, 8, 4, 4, 2, 2, 1};
2049 /* Start of interlace block in the y direction */
2050 static PNG_CONST png_byte png_pass_ystart
[7] = {0, 0, 4, 0, 2, 0, 1};
2052 /* Offset to next interlace block in the y direction */
2053 static PNG_CONST png_byte png_pass_yinc
[7] = {8, 8, 8, 4, 4, 2, 2};
2056 png_alloc_size_t buf_size
;
2057 int usr_pixel_depth
;
2059 png_debug(1, "in png_write_start_row");
2061 usr_pixel_depth
= png_ptr
->usr_channels
* png_ptr
->usr_bit_depth
;
2062 buf_size
= PNG_ROWBYTES(usr_pixel_depth
, png_ptr
->width
) + 1;
2064 /* 1.5.6: added to allow checking in the row write code. */
2065 png_ptr
->transformed_pixel_depth
= png_ptr
->pixel_depth
;
2066 png_ptr
->maximum_pixel_depth
= (png_byte
)usr_pixel_depth
;
2068 /* Set up row buffer */
2069 png_ptr
->row_buf
= (png_bytep
)png_malloc(png_ptr
, buf_size
);
2071 png_ptr
->row_buf
[0] = PNG_FILTER_VALUE_NONE
;
2073 #ifdef PNG_WRITE_FILTER_SUPPORTED
2074 /* Set up filtering buffer, if using this filter */
2075 if (png_ptr
->do_filter
& PNG_FILTER_SUB
)
2077 png_ptr
->sub_row
= (png_bytep
)png_malloc(png_ptr
, png_ptr
->rowbytes
+ 1);
2079 png_ptr
->sub_row
[0] = PNG_FILTER_VALUE_SUB
;
2082 /* We only need to keep the previous row if we are using one of these. */
2083 if (png_ptr
->do_filter
& (PNG_FILTER_AVG
| PNG_FILTER_UP
| PNG_FILTER_PAETH
))
2085 /* Set up previous row buffer */
2086 png_ptr
->prev_row
= (png_bytep
)png_calloc(png_ptr
, buf_size
);
2088 if (png_ptr
->do_filter
& PNG_FILTER_UP
)
2090 png_ptr
->up_row
= (png_bytep
)png_malloc(png_ptr
,
2091 png_ptr
->rowbytes
+ 1);
2093 png_ptr
->up_row
[0] = PNG_FILTER_VALUE_UP
;
2096 if (png_ptr
->do_filter
& PNG_FILTER_AVG
)
2098 png_ptr
->avg_row
= (png_bytep
)png_malloc(png_ptr
,
2099 png_ptr
->rowbytes
+ 1);
2101 png_ptr
->avg_row
[0] = PNG_FILTER_VALUE_AVG
;
2104 if (png_ptr
->do_filter
& PNG_FILTER_PAETH
)
2106 png_ptr
->paeth_row
= (png_bytep
)png_malloc(png_ptr
,
2107 png_ptr
->rowbytes
+ 1);
2109 png_ptr
->paeth_row
[0] = PNG_FILTER_VALUE_PAETH
;
2112 #endif /* PNG_WRITE_FILTER_SUPPORTED */
2114 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2115 /* If interlaced, we need to set up width and height of pass */
2116 if (png_ptr
->interlaced
)
2118 if (!(png_ptr
->transformations
& PNG_INTERLACE
))
2120 png_ptr
->num_rows
= (png_ptr
->height
+ png_pass_yinc
[0] - 1 -
2121 png_pass_ystart
[0]) / png_pass_yinc
[0];
2123 png_ptr
->usr_width
= (png_ptr
->width
+ png_pass_inc
[0] - 1 -
2124 png_pass_start
[0]) / png_pass_inc
[0];
2129 png_ptr
->num_rows
= png_ptr
->height
;
2130 png_ptr
->usr_width
= png_ptr
->width
;
2137 png_ptr
->num_rows
= png_ptr
->height
;
2138 png_ptr
->usr_width
= png_ptr
->width
;
2142 /* Internal use only. Called when finished processing a row of data. */
2144 png_write_finish_row(png_structrp png_ptr
)
2146 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2147 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
2149 /* Start of interlace block */
2150 static PNG_CONST png_byte png_pass_start
[7] = {0, 4, 0, 2, 0, 1, 0};
2152 /* Offset to next interlace block */
2153 static PNG_CONST png_byte png_pass_inc
[7] = {8, 8, 4, 4, 2, 2, 1};
2155 /* Start of interlace block in the y direction */
2156 static PNG_CONST png_byte png_pass_ystart
[7] = {0, 0, 4, 0, 2, 0, 1};
2158 /* Offset to next interlace block in the y direction */
2159 static PNG_CONST png_byte png_pass_yinc
[7] = {8, 8, 8, 4, 4, 2, 2};
2162 png_debug(1, "in png_write_finish_row");
2165 png_ptr
->row_number
++;
2167 /* See if we are done */
2168 if (png_ptr
->row_number
< png_ptr
->num_rows
)
2171 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2172 /* If interlaced, go to next pass */
2173 if (png_ptr
->interlaced
)
2175 png_ptr
->row_number
= 0;
2176 if (png_ptr
->transformations
& PNG_INTERLACE
)
2183 /* Loop until we find a non-zero width or height pass */
2188 if (png_ptr
->pass
>= 7)
2191 png_ptr
->usr_width
= (png_ptr
->width
+
2192 png_pass_inc
[png_ptr
->pass
] - 1 -
2193 png_pass_start
[png_ptr
->pass
]) /
2194 png_pass_inc
[png_ptr
->pass
];
2196 png_ptr
->num_rows
= (png_ptr
->height
+
2197 png_pass_yinc
[png_ptr
->pass
] - 1 -
2198 png_pass_ystart
[png_ptr
->pass
]) /
2199 png_pass_yinc
[png_ptr
->pass
];
2201 if (png_ptr
->transformations
& PNG_INTERLACE
)
2204 } while (png_ptr
->usr_width
== 0 || png_ptr
->num_rows
== 0);
2208 /* Reset the row above the image for the next pass */
2209 if (png_ptr
->pass
< 7)
2211 if (png_ptr
->prev_row
!= NULL
)
2212 memset(png_ptr
->prev_row
, 0,
2213 (png_size_t
)(PNG_ROWBYTES(png_ptr
->usr_channels
*
2214 png_ptr
->usr_bit_depth
, png_ptr
->width
)) + 1);
2221 /* If we get here, we've just written the last row, so we need
2222 to flush the compressor */
2223 png_compress_IDAT(png_ptr
, NULL
, 0, Z_FINISH
);
2226 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2227 /* Pick out the correct pixels for the interlace pass.
2228 * The basic idea here is to go through the row with a source
2229 * pointer and a destination pointer (sp and dp), and copy the
2230 * correct pixels for the pass. As the row gets compacted,
2231 * sp will always be >= dp, so we should never overwrite anything.
2232 * See the default: case for the easiest code to understand.
2235 png_do_write_interlace(png_row_infop row_info
, png_bytep row
, int pass
)
2237 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
2239 /* Start of interlace block */
2240 static PNG_CONST png_byte png_pass_start
[7] = {0, 4, 0, 2, 0, 1, 0};
2242 /* Offset to next interlace block */
2243 static PNG_CONST png_byte png_pass_inc
[7] = {8, 8, 4, 4, 2, 2, 1};
2245 png_debug(1, "in png_do_write_interlace");
2247 /* We don't have to do anything on the last pass (6) */
2250 /* Each pixel depth is handled separately */
2251 switch (row_info
->pixel_depth
)
2261 png_uint_32 row_width
= row_info
->width
;
2267 for (i
= png_pass_start
[pass
]; i
< row_width
;
2268 i
+= png_pass_inc
[pass
])
2270 sp
= row
+ (png_size_t
)(i
>> 3);
2271 value
= (int)(*sp
>> (7 - (int)(i
& 0x07))) & 0x01;
2272 d
|= (value
<< shift
);
2277 *dp
++ = (png_byte
)d
;
2299 png_uint_32 row_width
= row_info
->width
;
2305 for (i
= png_pass_start
[pass
]; i
< row_width
;
2306 i
+= png_pass_inc
[pass
])
2308 sp
= row
+ (png_size_t
)(i
>> 2);
2309 value
= (*sp
>> ((3 - (int)(i
& 0x03)) << 1)) & 0x03;
2310 d
|= (value
<< shift
);
2315 *dp
++ = (png_byte
)d
;
2336 png_uint_32 row_width
= row_info
->width
;
2341 for (i
= png_pass_start
[pass
]; i
< row_width
;
2342 i
+= png_pass_inc
[pass
])
2344 sp
= row
+ (png_size_t
)(i
>> 1);
2345 value
= (*sp
>> ((1 - (int)(i
& 0x01)) << 2)) & 0x0f;
2346 d
|= (value
<< shift
);
2351 *dp
++ = (png_byte
)d
;
2369 png_uint_32 row_width
= row_info
->width
;
2370 png_size_t pixel_bytes
;
2372 /* Start at the beginning */
2375 /* Find out how many bytes each pixel takes up */
2376 pixel_bytes
= (row_info
->pixel_depth
>> 3);
2378 /* Loop through the row, only looking at the pixels that matter */
2379 for (i
= png_pass_start
[pass
]; i
< row_width
;
2380 i
+= png_pass_inc
[pass
])
2382 /* Find out where the original pixel is */
2383 sp
= row
+ (png_size_t
)i
* pixel_bytes
;
2385 /* Move the pixel */
2387 memcpy(dp
, sp
, pixel_bytes
);
2395 /* Set new row width */
2396 row_info
->width
= (row_info
->width
+
2397 png_pass_inc
[pass
] - 1 -
2398 png_pass_start
[pass
]) /
2401 row_info
->rowbytes
= PNG_ROWBYTES(row_info
->pixel_depth
,
2407 /* This filters the row, chooses which filter to use, if it has not already
2408 * been specified by the application, and then writes the row out with the
2412 png_write_filtered_row(png_structrp png_ptr
, png_bytep filtered_row
,
2413 png_size_t row_bytes
);
2415 #define PNG_MAXSUM (((png_uint_32)(-1)) >> 1)
2416 #define PNG_HISHIFT 10
2417 #define PNG_LOMASK ((png_uint_32)0xffffL)
2418 #define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))
2420 png_write_find_filter(png_structrp png_ptr
, png_row_infop row_info
)
2423 #ifdef PNG_WRITE_FILTER_SUPPORTED
2424 png_bytep prev_row
, row_buf
;
2425 png_uint_32 mins
, bpp
;
2426 png_byte filter_to_do
= png_ptr
->do_filter
;
2427 png_size_t row_bytes
= row_info
->rowbytes
;
2428 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2429 int num_p_filters
= png_ptr
->num_prev_filters
;
2432 png_debug(1, "in png_write_find_filter");
2434 #ifndef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2435 if (png_ptr
->row_number
== 0 && filter_to_do
== PNG_ALL_FILTERS
)
2437 /* These will never be selected so we need not test them. */
2438 filter_to_do
&= ~(PNG_FILTER_UP
| PNG_FILTER_PAETH
);
2442 /* Find out how many bytes offset each pixel is */
2443 bpp
= (row_info
->pixel_depth
+ 7) >> 3;
2445 prev_row
= png_ptr
->prev_row
;
2447 best_row
= png_ptr
->row_buf
;
2448 #ifdef PNG_WRITE_FILTER_SUPPORTED
2452 /* The prediction method we use is to find which method provides the
2453 * smallest value when summing the absolute values of the distances
2454 * from zero, using anything >= 128 as negative numbers. This is known
2455 * as the "minimum sum of absolute differences" heuristic. Other
2456 * heuristics are the "weighted minimum sum of absolute differences"
2457 * (experimental and can in theory improve compression), and the "zlib
2458 * predictive" method (not implemented yet), which does test compressions
2459 * of lines using different filter methods, and then chooses the
2460 * (series of) filter(s) that give minimum compressed data size (VERY
2461 * computationally expensive).
2463 * GRR 980525: consider also
2465 * (1) minimum sum of absolute differences from running average (i.e.,
2466 * keep running sum of non-absolute differences & count of bytes)
2467 * [track dispersion, too? restart average if dispersion too large?]
2469 * (1b) minimum sum of absolute differences from sliding average, probably
2470 * with window size <= deflate window (usually 32K)
2472 * (2) minimum sum of squared differences from zero or running average
2473 * (i.e., ~ root-mean-square approach)
2477 /* We don't need to test the 'no filter' case if this is the only filter
2478 * that has been chosen, as it doesn't actually do anything to the data.
2480 if ((filter_to_do
& PNG_FILTER_NONE
) && filter_to_do
!= PNG_FILTER_NONE
)
2483 png_uint_32 sum
= 0;
2487 for (i
= 0, rp
= row_buf
+ 1; i
< row_bytes
; i
++, rp
++)
2490 sum
+= (v
< 128) ? v
: 256 - v
;
2493 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2494 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2496 png_uint_32 sumhi
, sumlo
;
2498 sumlo
= sum
& PNG_LOMASK
;
2499 sumhi
= (sum
>> PNG_HISHIFT
) & PNG_HIMASK
; /* Gives us some footroom */
2501 /* Reduce the sum if we match any of the previous rows */
2502 for (j
= 0; j
< num_p_filters
; j
++)
2504 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_NONE
)
2506 sumlo
= (sumlo
* png_ptr
->filter_weights
[j
]) >>
2509 sumhi
= (sumhi
* png_ptr
->filter_weights
[j
]) >>
2514 /* Factor in the cost of this filter (this is here for completeness,
2515 * but it makes no sense to have a "cost" for the NONE filter, as
2516 * it has the minimum possible computational cost - none).
2518 sumlo
= (sumlo
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_NONE
]) >>
2521 sumhi
= (sumhi
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_NONE
]) >>
2524 if (sumhi
> PNG_HIMASK
)
2528 sum
= (sumhi
<< PNG_HISHIFT
) + sumlo
;
2535 if (filter_to_do
== PNG_FILTER_SUB
)
2536 /* It's the only filter so no testing is needed */
2538 png_bytep rp
, lp
, dp
;
2541 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->sub_row
+ 1; i
< bpp
;
2547 for (lp
= row_buf
+ 1; i
< row_bytes
;
2548 i
++, rp
++, lp
++, dp
++)
2550 *dp
= (png_byte
)(((int)*rp
- (int)*lp
) & 0xff);
2553 best_row
= png_ptr
->sub_row
;
2556 else if (filter_to_do
& PNG_FILTER_SUB
)
2558 png_bytep rp
, dp
, lp
;
2559 png_uint_32 sum
= 0, lmins
= mins
;
2563 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2564 /* We temporarily increase the "minimum sum" by the factor we
2565 * would reduce the sum of this filter, so that we can do the
2566 * early exit comparison without scaling the sum each time.
2568 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2571 png_uint_32 lmhi
, lmlo
;
2572 lmlo
= lmins
& PNG_LOMASK
;
2573 lmhi
= (lmins
>> PNG_HISHIFT
) & PNG_HIMASK
;
2575 for (j
= 0; j
< num_p_filters
; j
++)
2577 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_SUB
)
2579 lmlo
= (lmlo
* png_ptr
->inv_filter_weights
[j
]) >>
2582 lmhi
= (lmhi
* png_ptr
->inv_filter_weights
[j
]) >>
2587 lmlo
= (lmlo
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_SUB
]) >>
2590 lmhi
= (lmhi
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_SUB
]) >>
2593 if (lmhi
> PNG_HIMASK
)
2597 lmins
= (lmhi
<< PNG_HISHIFT
) + lmlo
;
2601 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->sub_row
+ 1; i
< bpp
;
2606 sum
+= (v
< 128) ? v
: 256 - v
;
2609 for (lp
= row_buf
+ 1; i
< row_bytes
;
2610 i
++, rp
++, lp
++, dp
++)
2612 v
= *dp
= (png_byte
)(((int)*rp
- (int)*lp
) & 0xff);
2614 sum
+= (v
< 128) ? v
: 256 - v
;
2616 if (sum
> lmins
) /* We are already worse, don't continue. */
2620 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2621 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2624 png_uint_32 sumhi
, sumlo
;
2625 sumlo
= sum
& PNG_LOMASK
;
2626 sumhi
= (sum
>> PNG_HISHIFT
) & PNG_HIMASK
;
2628 for (j
= 0; j
< num_p_filters
; j
++)
2630 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_SUB
)
2632 sumlo
= (sumlo
* png_ptr
->inv_filter_weights
[j
]) >>
2635 sumhi
= (sumhi
* png_ptr
->inv_filter_weights
[j
]) >>
2640 sumlo
= (sumlo
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_SUB
]) >>
2643 sumhi
= (sumhi
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_SUB
]) >>
2646 if (sumhi
> PNG_HIMASK
)
2650 sum
= (sumhi
<< PNG_HISHIFT
) + sumlo
;
2657 best_row
= png_ptr
->sub_row
;
2662 if (filter_to_do
== PNG_FILTER_UP
)
2664 png_bytep rp
, dp
, pp
;
2667 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->up_row
+ 1,
2668 pp
= prev_row
+ 1; i
< row_bytes
;
2669 i
++, rp
++, pp
++, dp
++)
2671 *dp
= (png_byte
)(((int)*rp
- (int)*pp
) & 0xff);
2674 best_row
= png_ptr
->up_row
;
2677 else if (filter_to_do
& PNG_FILTER_UP
)
2679 png_bytep rp
, dp
, pp
;
2680 png_uint_32 sum
= 0, lmins
= mins
;
2685 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2686 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2689 png_uint_32 lmhi
, lmlo
;
2690 lmlo
= lmins
& PNG_LOMASK
;
2691 lmhi
= (lmins
>> PNG_HISHIFT
) & PNG_HIMASK
;
2693 for (j
= 0; j
< num_p_filters
; j
++)
2695 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_UP
)
2697 lmlo
= (lmlo
* png_ptr
->inv_filter_weights
[j
]) >>
2700 lmhi
= (lmhi
* png_ptr
->inv_filter_weights
[j
]) >>
2705 lmlo
= (lmlo
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_UP
]) >>
2708 lmhi
= (lmhi
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_UP
]) >>
2711 if (lmhi
> PNG_HIMASK
)
2715 lmins
= (lmhi
<< PNG_HISHIFT
) + lmlo
;
2719 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->up_row
+ 1,
2720 pp
= prev_row
+ 1; i
< row_bytes
; i
++)
2722 v
= *dp
++ = (png_byte
)(((int)*rp
++ - (int)*pp
++) & 0xff);
2724 sum
+= (v
< 128) ? v
: 256 - v
;
2726 if (sum
> lmins
) /* We are already worse, don't continue. */
2730 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2731 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2734 png_uint_32 sumhi
, sumlo
;
2735 sumlo
= sum
& PNG_LOMASK
;
2736 sumhi
= (sum
>> PNG_HISHIFT
) & PNG_HIMASK
;
2738 for (j
= 0; j
< num_p_filters
; j
++)
2740 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_UP
)
2742 sumlo
= (sumlo
* png_ptr
->filter_weights
[j
]) >>
2745 sumhi
= (sumhi
* png_ptr
->filter_weights
[j
]) >>
2750 sumlo
= (sumlo
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_UP
]) >>
2753 sumhi
= (sumhi
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_UP
]) >>
2756 if (sumhi
> PNG_HIMASK
)
2760 sum
= (sumhi
<< PNG_HISHIFT
) + sumlo
;
2767 best_row
= png_ptr
->up_row
;
2772 if (filter_to_do
== PNG_FILTER_AVG
)
2774 png_bytep rp
, dp
, pp
, lp
;
2777 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->avg_row
+ 1,
2778 pp
= prev_row
+ 1; i
< bpp
; i
++)
2780 *dp
++ = (png_byte
)(((int)*rp
++ - ((int)*pp
++ / 2)) & 0xff);
2783 for (lp
= row_buf
+ 1; i
< row_bytes
; i
++)
2785 *dp
++ = (png_byte
)(((int)*rp
++ - (((int)*pp
++ + (int)*lp
++) / 2))
2788 best_row
= png_ptr
->avg_row
;
2791 else if (filter_to_do
& PNG_FILTER_AVG
)
2793 png_bytep rp
, dp
, pp
, lp
;
2794 png_uint_32 sum
= 0, lmins
= mins
;
2798 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2799 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2802 png_uint_32 lmhi
, lmlo
;
2803 lmlo
= lmins
& PNG_LOMASK
;
2804 lmhi
= (lmins
>> PNG_HISHIFT
) & PNG_HIMASK
;
2806 for (j
= 0; j
< num_p_filters
; j
++)
2808 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_AVG
)
2810 lmlo
= (lmlo
* png_ptr
->inv_filter_weights
[j
]) >>
2813 lmhi
= (lmhi
* png_ptr
->inv_filter_weights
[j
]) >>
2818 lmlo
= (lmlo
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_AVG
]) >>
2821 lmhi
= (lmhi
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_AVG
]) >>
2824 if (lmhi
> PNG_HIMASK
)
2828 lmins
= (lmhi
<< PNG_HISHIFT
) + lmlo
;
2832 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->avg_row
+ 1,
2833 pp
= prev_row
+ 1; i
< bpp
; i
++)
2835 v
= *dp
++ = (png_byte
)(((int)*rp
++ - ((int)*pp
++ / 2)) & 0xff);
2837 sum
+= (v
< 128) ? v
: 256 - v
;
2840 for (lp
= row_buf
+ 1; i
< row_bytes
; i
++)
2843 (png_byte
)(((int)*rp
++ - (((int)*pp
++ + (int)*lp
++) / 2)) & 0xff);
2845 sum
+= (v
< 128) ? v
: 256 - v
;
2847 if (sum
> lmins
) /* We are already worse, don't continue. */
2851 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2852 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2855 png_uint_32 sumhi
, sumlo
;
2856 sumlo
= sum
& PNG_LOMASK
;
2857 sumhi
= (sum
>> PNG_HISHIFT
) & PNG_HIMASK
;
2859 for (j
= 0; j
< num_p_filters
; j
++)
2861 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_NONE
)
2863 sumlo
= (sumlo
* png_ptr
->filter_weights
[j
]) >>
2866 sumhi
= (sumhi
* png_ptr
->filter_weights
[j
]) >>
2871 sumlo
= (sumlo
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_AVG
]) >>
2874 sumhi
= (sumhi
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_AVG
]) >>
2877 if (sumhi
> PNG_HIMASK
)
2881 sum
= (sumhi
<< PNG_HISHIFT
) + sumlo
;
2888 best_row
= png_ptr
->avg_row
;
2893 if (filter_to_do
== PNG_FILTER_PAETH
)
2895 png_bytep rp
, dp
, pp
, cp
, lp
;
2898 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->paeth_row
+ 1,
2899 pp
= prev_row
+ 1; i
< bpp
; i
++)
2901 *dp
++ = (png_byte
)(((int)*rp
++ - (int)*pp
++) & 0xff);
2904 for (lp
= row_buf
+ 1, cp
= prev_row
+ 1; i
< row_bytes
; i
++)
2906 int a
, b
, c
, pa
, pb
, pc
, p
;
2920 pa
= p
< 0 ? -p
: p
;
2921 pb
= pc
< 0 ? -pc
: pc
;
2922 pc
= (p
+ pc
) < 0 ? -(p
+ pc
) : p
+ pc
;
2925 p
= (pa
<= pb
&& pa
<=pc
) ? a
: (pb
<= pc
) ? b
: c
;
2927 *dp
++ = (png_byte
)(((int)*rp
++ - p
) & 0xff);
2929 best_row
= png_ptr
->paeth_row
;
2932 else if (filter_to_do
& PNG_FILTER_PAETH
)
2934 png_bytep rp
, dp
, pp
, cp
, lp
;
2935 png_uint_32 sum
= 0, lmins
= mins
;
2939 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2940 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2943 png_uint_32 lmhi
, lmlo
;
2944 lmlo
= lmins
& PNG_LOMASK
;
2945 lmhi
= (lmins
>> PNG_HISHIFT
) & PNG_HIMASK
;
2947 for (j
= 0; j
< num_p_filters
; j
++)
2949 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_PAETH
)
2951 lmlo
= (lmlo
* png_ptr
->inv_filter_weights
[j
]) >>
2954 lmhi
= (lmhi
* png_ptr
->inv_filter_weights
[j
]) >>
2959 lmlo
= (lmlo
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_PAETH
]) >>
2962 lmhi
= (lmhi
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_PAETH
]) >>
2965 if (lmhi
> PNG_HIMASK
)
2969 lmins
= (lmhi
<< PNG_HISHIFT
) + lmlo
;
2973 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->paeth_row
+ 1,
2974 pp
= prev_row
+ 1; i
< bpp
; i
++)
2976 v
= *dp
++ = (png_byte
)(((int)*rp
++ - (int)*pp
++) & 0xff);
2978 sum
+= (v
< 128) ? v
: 256 - v
;
2981 for (lp
= row_buf
+ 1, cp
= prev_row
+ 1; i
< row_bytes
; i
++)
2983 int a
, b
, c
, pa
, pb
, pc
, p
;
2989 #ifndef PNG_SLOW_PAETH
2997 pa
= p
< 0 ? -p
: p
;
2998 pb
= pc
< 0 ? -pc
: pc
;
2999 pc
= (p
+ pc
) < 0 ? -(p
+ pc
) : p
+ pc
;
3001 p
= (pa
<= pb
&& pa
<=pc
) ? a
: (pb
<= pc
) ? b
: c
;
3002 #else /* PNG_SLOW_PAETH */
3008 if (pa
<= pb
&& pa
<= pc
)
3016 #endif /* PNG_SLOW_PAETH */
3018 v
= *dp
++ = (png_byte
)(((int)*rp
++ - p
) & 0xff);
3020 sum
+= (v
< 128) ? v
: 256 - v
;
3022 if (sum
> lmins
) /* We are already worse, don't continue. */
3026 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
3027 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
3030 png_uint_32 sumhi
, sumlo
;
3031 sumlo
= sum
& PNG_LOMASK
;
3032 sumhi
= (sum
>> PNG_HISHIFT
) & PNG_HIMASK
;
3034 for (j
= 0; j
< num_p_filters
; j
++)
3036 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_PAETH
)
3038 sumlo
= (sumlo
* png_ptr
->filter_weights
[j
]) >>
3041 sumhi
= (sumhi
* png_ptr
->filter_weights
[j
]) >>
3046 sumlo
= (sumlo
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_PAETH
]) >>
3049 sumhi
= (sumhi
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_PAETH
]) >>
3052 if (sumhi
> PNG_HIMASK
)
3056 sum
= (sumhi
<< PNG_HISHIFT
) + sumlo
;
3062 best_row
= png_ptr
->paeth_row
;
3065 #endif /* PNG_WRITE_FILTER_SUPPORTED */
3067 /* Do the actual writing of the filtered row data from the chosen filter. */
3068 png_write_filtered_row(png_ptr
, best_row
, row_info
->rowbytes
+1);
3070 #ifdef PNG_WRITE_FILTER_SUPPORTED
3071 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
3072 /* Save the type of filter we picked this time for future calculations */
3073 if (png_ptr
->num_prev_filters
> 0)
3077 for (j
= 1; j
< num_p_filters
; j
++)
3079 png_ptr
->prev_filters
[j
] = png_ptr
->prev_filters
[j
- 1];
3082 png_ptr
->prev_filters
[j
] = best_row
[0];
3085 #endif /* PNG_WRITE_FILTER_SUPPORTED */
3089 /* Do the actual writing of a previously filtered row. */
3091 png_write_filtered_row(png_structrp png_ptr
, png_bytep filtered_row
,
3092 png_size_t full_row_length
/*includes filter byte*/)
3094 png_debug(1, "in png_write_filtered_row");
3096 png_debug1(2, "filter = %d", filtered_row
[0]);
3098 png_compress_IDAT(png_ptr
, filtered_row
, full_row_length
, Z_NO_FLUSH
);
3100 /* Swap the current and previous rows */
3101 if (png_ptr
->prev_row
!= NULL
)
3105 tptr
= png_ptr
->prev_row
;
3106 png_ptr
->prev_row
= png_ptr
->row_buf
;
3107 png_ptr
->row_buf
= tptr
;
3110 /* Finish row - updates counters and flushes zlib if last row */
3111 png_write_finish_row(png_ptr
);
3113 #ifdef PNG_WRITE_FLUSH_SUPPORTED
3114 png_ptr
->flush_rows
++;
3116 if (png_ptr
->flush_dist
> 0 &&
3117 png_ptr
->flush_rows
>= png_ptr
->flush_dist
)
3119 png_write_flush(png_ptr
);
3124 #ifdef PNG_WRITE_APNG_SUPPORTED
3126 png_write_reset(png_structp png_ptr
)
3128 png_ptr
->row_number
= 0;
3130 png_ptr
->mode
&= ~PNG_HAVE_IDAT
;
3134 png_write_reinit(png_structp png_ptr
, png_infop info_ptr
,
3135 png_uint_32 width
, png_uint_32 height
)
3137 if (png_ptr
->num_frames_written
== 0 &&
3138 (width
!= png_ptr
->first_frame_width
||
3139 height
!= png_ptr
->first_frame_height
))
3140 png_error(png_ptr
, "width and/or height in the first frame's fcTL "
3141 "don't match the ones in IHDR");
3142 if (width
> png_ptr
->first_frame_width
||
3143 height
> png_ptr
->first_frame_height
)
3144 png_error(png_ptr
, "width and/or height for a frame greater than"
3145 "the ones in IHDR");
3147 png_set_IHDR(png_ptr
, info_ptr
, width
, height
,
3148 info_ptr
->bit_depth
, info_ptr
->color_type
,
3149 info_ptr
->interlace_type
, info_ptr
->compression_type
,
3150 info_ptr
->filter_type
);
3152 png_ptr
->width
= width
;
3153 png_ptr
->height
= height
;
3154 png_ptr
->rowbytes
= PNG_ROWBYTES(png_ptr
->pixel_depth
, width
);
3155 png_ptr
->usr_width
= png_ptr
->width
;
3157 #endif /* PNG_WRITE_APNG_SUPPORTED */
3158 #endif /* PNG_WRITE_SUPPORTED */