2 /* pngwutil.c - utilities to write a PNG file
4 * Last changed in libpng 1.6.15 [November 20, 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 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 maximum");
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
!= 0)
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
;
289 #endif /* WRITE_OPTIMIZE_CMF */
291 /* Initialize the compressor for the appropriate type of compression. */
293 png_deflate_claim(png_structrp png_ptr
, png_uint_32 owner
,
294 png_alloc_size_t data_size
)
296 if (png_ptr
->zowner
!= 0)
298 #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
301 PNG_STRING_FROM_CHUNK(msg
, owner
);
304 PNG_STRING_FROM_CHUNK(msg
+6, png_ptr
->zowner
);
305 /* So the message that results is "<chunk> using zstream"; this is an
306 * internal error, but is very useful for debugging. i18n requirements
309 (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
) != 0)
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
) != 0 &&
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
) != 0)
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 #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
621 /* Fix up the deflate header, if required */
622 optimize_cmf(comp
->output
, comp
->input_len
);
624 /* But Z_OK is returned, not Z_STREAM_END; this allows the claim
625 * function above to return Z_STREAM_END on an error (though it never
626 * does in the current versions of zlib.)
636 /* Ship the compressed text out via chunk writes */
638 png_write_compressed_data_out(png_structrp png_ptr
, compression_state
*comp
)
640 png_uint_32 output_len
= comp
->output_len
;
641 png_const_bytep output
= comp
->output
;
642 png_uint_32 avail
= (sizeof comp
->output
);
643 png_compression_buffer
*next
= png_ptr
->zbuffer_list
;
647 if (avail
> output_len
)
650 png_write_chunk_data(png_ptr
, output
, avail
);
654 if (output_len
== 0 || next
== NULL
)
657 avail
= png_ptr
->zbuffer_size
;
658 output
= next
->output
;
662 /* This is an internal error; 'next' must have been NULL! */
664 png_error(png_ptr
, "error writing ancillary chunked compressed data");
666 #endif /* WRITE_COMPRESSED_TEXT */
668 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
669 defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
670 /* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
671 * and if invalid, correct the keyword rather than discarding the entire
672 * chunk. The PNG 1.0 specification requires keywords 1-79 characters in
673 * length, forbids leading or trailing whitespace, multiple internal spaces,
674 * and the non-break space (0x80) from ISO 8859-1. Returns keyword length.
676 * The 'new_key' buffer must be 80 characters in size (for the keyword plus a
677 * trailing '\0'). If this routine returns 0 then there was no keyword, or a
678 * valid one could not be generated, and the caller must png_error.
681 png_check_keyword(png_structrp png_ptr
, png_const_charp key
, png_bytep new_key
)
683 png_const_charp orig_key
= key
;
684 png_uint_32 key_len
= 0;
685 int bad_character
= 0;
688 png_debug(1, "in png_check_keyword");
696 while (*key
&& key_len
< 79)
698 png_byte ch
= (png_byte
)(0xff & *key
++);
700 if ((ch
> 32 && ch
<= 126) || (ch
>= 161 /*&& ch <= 255*/))
701 *new_key
++ = ch
, ++key_len
, space
= 0;
705 /* A space or an invalid character when one wasn't seen immediately
706 * before; output just a space.
708 *new_key
++ = 32, ++key_len
, space
= 1;
710 /* If the character was not a space then it is invalid. */
715 else if (bad_character
== 0)
716 bad_character
= ch
; /* just skip it, record the first error */
719 if (key_len
> 0 && space
!= 0) /* trailing space */
721 --key_len
, --new_key
;
722 if (bad_character
== 0)
726 /* Terminate the keyword */
732 #ifdef PNG_WARNINGS_SUPPORTED
733 /* Try to only output one warning per keyword: */
734 if (*key
!= 0) /* keyword too long */
735 png_warning(png_ptr
, "keyword truncated");
737 else if (bad_character
!= 0)
739 PNG_WARNING_PARAMETERS(p
)
741 png_warning_parameter(p
, 1, orig_key
);
742 png_warning_parameter_signed(p
, 2, PNG_NUMBER_FORMAT_02x
, bad_character
);
744 png_formatted_warning(png_ptr
, p
, "keyword \"@1\": bad character '0x@2'");
746 #endif /* WARNINGS */
750 #endif /* WRITE_TEXT || WRITE_pCAL || WRITE_iCCP || WRITE_sPLT */
752 /* Write the IHDR chunk, and update the png_struct with the necessary
753 * information. Note that the rest of this code depends upon this
754 * information being correct.
757 png_write_IHDR(png_structrp png_ptr
, png_uint_32 width
, png_uint_32 height
,
758 int bit_depth
, int color_type
, int compression_type
, int filter_type
,
761 png_byte buf
[13]; /* Buffer to store the IHDR info */
763 png_debug(1, "in png_write_IHDR");
765 /* Check that we have valid input data from the application info */
768 case PNG_COLOR_TYPE_GRAY
:
775 #ifdef PNG_WRITE_16BIT_SUPPORTED
778 png_ptr
->channels
= 1; break;
782 "Invalid bit depth for grayscale image");
786 case PNG_COLOR_TYPE_RGB
:
787 #ifdef PNG_WRITE_16BIT_SUPPORTED
788 if (bit_depth
!= 8 && bit_depth
!= 16)
792 png_error(png_ptr
, "Invalid bit depth for RGB image");
794 png_ptr
->channels
= 3;
797 case PNG_COLOR_TYPE_PALETTE
:
804 png_ptr
->channels
= 1;
808 png_error(png_ptr
, "Invalid bit depth for paletted image");
812 case PNG_COLOR_TYPE_GRAY_ALPHA
:
813 if (bit_depth
!= 8 && bit_depth
!= 16)
814 png_error(png_ptr
, "Invalid bit depth for grayscale+alpha image");
816 png_ptr
->channels
= 2;
819 case PNG_COLOR_TYPE_RGB_ALPHA
:
820 #ifdef PNG_WRITE_16BIT_SUPPORTED
821 if (bit_depth
!= 8 && bit_depth
!= 16)
825 png_error(png_ptr
, "Invalid bit depth for RGBA image");
827 png_ptr
->channels
= 4;
831 png_error(png_ptr
, "Invalid image color type specified");
834 if (compression_type
!= PNG_COMPRESSION_TYPE_BASE
)
836 png_warning(png_ptr
, "Invalid compression type specified");
837 compression_type
= PNG_COMPRESSION_TYPE_BASE
;
840 /* Write filter_method 64 (intrapixel differencing) only if
841 * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
842 * 2. Libpng did not write a PNG signature (this filter_method is only
843 * used in PNG datastreams that are embedded in MNG datastreams) and
844 * 3. The application called png_permit_mng_features with a mask that
845 * included PNG_FLAG_MNG_FILTER_64 and
846 * 4. The filter_method is 64 and
847 * 5. The color_type is RGB or RGBA
850 #ifdef PNG_MNG_FEATURES_SUPPORTED
851 !((png_ptr
->mng_features_permitted
& PNG_FLAG_MNG_FILTER_64
) != 0 &&
852 ((png_ptr
->mode
& PNG_HAVE_PNG_SIGNATURE
) == 0) &&
853 (color_type
== PNG_COLOR_TYPE_RGB
||
854 color_type
== PNG_COLOR_TYPE_RGB_ALPHA
) &&
855 (filter_type
== PNG_INTRAPIXEL_DIFFERENCING
)) &&
857 filter_type
!= PNG_FILTER_TYPE_BASE
)
859 png_warning(png_ptr
, "Invalid filter type specified");
860 filter_type
= PNG_FILTER_TYPE_BASE
;
863 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
864 if (interlace_type
!= PNG_INTERLACE_NONE
&&
865 interlace_type
!= PNG_INTERLACE_ADAM7
)
867 png_warning(png_ptr
, "Invalid interlace type specified");
868 interlace_type
= PNG_INTERLACE_ADAM7
;
871 interlace_type
=PNG_INTERLACE_NONE
;
874 /* Save the relevent information */
875 png_ptr
->bit_depth
= (png_byte
)bit_depth
;
876 png_ptr
->color_type
= (png_byte
)color_type
;
877 png_ptr
->interlaced
= (png_byte
)interlace_type
;
878 #ifdef PNG_MNG_FEATURES_SUPPORTED
879 png_ptr
->filter_type
= (png_byte
)filter_type
;
881 png_ptr
->compression_type
= (png_byte
)compression_type
;
882 png_ptr
->width
= width
;
883 png_ptr
->height
= height
;
885 png_ptr
->pixel_depth
= (png_byte
)(bit_depth
* png_ptr
->channels
);
886 png_ptr
->rowbytes
= PNG_ROWBYTES(png_ptr
->pixel_depth
, width
);
887 /* Set the usr info, so any transformations can modify it */
888 png_ptr
->usr_width
= png_ptr
->width
;
889 png_ptr
->usr_bit_depth
= png_ptr
->bit_depth
;
890 png_ptr
->usr_channels
= png_ptr
->channels
;
892 /* Pack the header information into the buffer */
893 png_save_uint_32(buf
, width
);
894 png_save_uint_32(buf
+ 4, height
);
895 buf
[8] = (png_byte
)bit_depth
;
896 buf
[9] = (png_byte
)color_type
;
897 buf
[10] = (png_byte
)compression_type
;
898 buf
[11] = (png_byte
)filter_type
;
899 buf
[12] = (png_byte
)interlace_type
;
901 /* Write the chunk */
902 png_write_complete_chunk(png_ptr
, png_IHDR
, buf
, (png_size_t
)13);
904 #ifdef PNG_WRITE_APNG_SUPPORTED
905 png_ptr
->first_frame_width
= width
;
906 png_ptr
->first_frame_height
= height
;
909 if ((png_ptr
->do_filter
) == PNG_NO_FILTERS
)
911 if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
||
912 png_ptr
->bit_depth
< 8)
913 png_ptr
->do_filter
= PNG_FILTER_NONE
;
916 png_ptr
->do_filter
= PNG_ALL_FILTERS
;
919 png_ptr
->mode
= PNG_HAVE_IHDR
; /* not READY_FOR_ZTXT */
922 /* Write the palette. We are careful not to trust png_color to be in the
923 * correct order for PNG, so people can redefine it to any convenient
927 png_write_PLTE(png_structrp png_ptr
, png_const_colorp palette
,
931 png_const_colorp pal_ptr
;
934 png_debug(1, "in png_write_PLTE");
937 #ifdef PNG_MNG_FEATURES_SUPPORTED
938 (png_ptr
->mng_features_permitted
& PNG_FLAG_MNG_EMPTY_PLTE
) == 0 &&
940 num_pal
== 0) || num_pal
> 256)
942 if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
944 png_error(png_ptr
, "Invalid number of colors in palette");
949 png_warning(png_ptr
, "Invalid number of colors in palette");
954 if ((png_ptr
->color_type
& PNG_COLOR_MASK_COLOR
) == 0)
957 "Ignoring request to write a PLTE chunk in grayscale PNG");
962 png_ptr
->num_palette
= (png_uint_16
)num_pal
;
963 png_debug1(3, "num_palette = %d", png_ptr
->num_palette
);
965 png_write_chunk_header(png_ptr
, png_PLTE
, (png_uint_32
)(num_pal
* 3));
966 #ifdef PNG_POINTER_INDEXING_SUPPORTED
968 for (i
= 0, pal_ptr
= palette
; i
< num_pal
; i
++, pal_ptr
++)
970 buf
[0] = pal_ptr
->red
;
971 buf
[1] = pal_ptr
->green
;
972 buf
[2] = pal_ptr
->blue
;
973 png_write_chunk_data(png_ptr
, buf
, (png_size_t
)3);
977 /* This is a little slower but some buggy compilers need to do this
982 for (i
= 0; i
< num_pal
; i
++)
984 buf
[0] = pal_ptr
[i
].red
;
985 buf
[1] = pal_ptr
[i
].green
;
986 buf
[2] = pal_ptr
[i
].blue
;
987 png_write_chunk_data(png_ptr
, buf
, (png_size_t
)3);
991 png_write_chunk_end(png_ptr
);
992 png_ptr
->mode
|= PNG_HAVE_PLTE
;
995 /* This is similar to png_text_compress, above, except that it does not require
996 * all of the data at once and, instead of buffering the compressed result,
997 * writes it as IDAT chunks. Unlike png_text_compress it *can* png_error out
998 * because it calls the write interface. As a result it does its own error
999 * reporting and does not return an error code. In the event of error it will
1000 * just call png_error. The input data length may exceed 32-bits. The 'flush'
1001 * parameter is exactly the same as that to deflate, with the following
1004 * Z_NO_FLUSH: normal incremental output of compressed data
1005 * Z_SYNC_FLUSH: do a SYNC_FLUSH, used by png_write_flush
1006 * Z_FINISH: this is the end of the input, do a Z_FINISH and clean up
1008 * The routine manages the acquire and release of the png_ptr->zstream by
1009 * checking and (at the end) clearing png_ptr->zowner; it does some sanity
1010 * checks on the 'mode' flags while doing this.
1013 png_compress_IDAT(png_structrp png_ptr
, png_const_bytep input
,
1014 png_alloc_size_t input_len
, int flush
)
1016 if (png_ptr
->zowner
!= png_IDAT
)
1018 /* First time. Ensure we have a temporary buffer for compression and
1019 * trim the buffer list if it has more than one entry to free memory.
1020 * If 'WRITE_COMPRESSED_TEXT' is not set the list will never have been
1021 * created at this point, but the check here is quick and safe.
1023 if (png_ptr
->zbuffer_list
== NULL
)
1025 png_ptr
->zbuffer_list
= png_voidcast(png_compression_bufferp
,
1026 png_malloc(png_ptr
, PNG_COMPRESSION_BUFFER_SIZE(png_ptr
)));
1027 png_ptr
->zbuffer_list
->next
= NULL
;
1031 png_free_buffer_list(png_ptr
, &png_ptr
->zbuffer_list
->next
);
1033 /* It is a terminal error if we can't claim the zstream. */
1034 if (png_deflate_claim(png_ptr
, png_IDAT
, png_image_size(png_ptr
)) != Z_OK
)
1035 png_error(png_ptr
, png_ptr
->zstream
.msg
);
1037 /* The output state is maintained in png_ptr->zstream, so it must be
1038 * initialized here after the claim.
1040 png_ptr
->zstream
.next_out
= png_ptr
->zbuffer_list
->output
;
1041 png_ptr
->zstream
.avail_out
= png_ptr
->zbuffer_size
;
1044 /* Now loop reading and writing until all the input is consumed or an error
1045 * terminates the operation. The _out values are maintained across calls to
1046 * this function, but the input must be reset each time.
1048 png_ptr
->zstream
.next_in
= PNGZ_INPUT_CAST(input
);
1049 png_ptr
->zstream
.avail_in
= 0; /* set below */
1054 /* INPUT: from the row data */
1055 uInt avail
= ZLIB_IO_MAX
;
1057 if (avail
> input_len
)
1058 avail
= (uInt
)input_len
; /* safe because of the check */
1060 png_ptr
->zstream
.avail_in
= avail
;
1063 ret
= deflate(&png_ptr
->zstream
, input_len
> 0 ? Z_NO_FLUSH
: flush
);
1065 /* Include as-yet unconsumed input */
1066 input_len
+= png_ptr
->zstream
.avail_in
;
1067 png_ptr
->zstream
.avail_in
= 0;
1069 /* OUTPUT: write complete IDAT chunks when avail_out drops to zero. Note
1070 * that these two zstream fields are preserved across the calls, therefore
1071 * there is no need to set these up on entry to the loop.
1073 if (png_ptr
->zstream
.avail_out
== 0)
1075 png_bytep data
= png_ptr
->zbuffer_list
->output
;
1076 uInt size
= png_ptr
->zbuffer_size
;
1078 /* Write an IDAT containing the data then reset the buffer. The
1079 * first IDAT may need deflate header optimization.
1081 #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
1082 if ((png_ptr
->mode
& PNG_HAVE_IDAT
) == 0 &&
1083 png_ptr
->compression_type
== PNG_COMPRESSION_TYPE_BASE
)
1084 optimize_cmf(data
, png_image_size(png_ptr
));
1087 #ifdef PNG_WRITE_APNG_SUPPORTED
1088 if (png_ptr
->num_frames_written
== 0)
1090 png_write_complete_chunk(png_ptr
, png_IDAT
, data
, size
);
1091 #ifdef PNG_WRITE_APNG_SUPPORTED
1093 png_write_fdAT(png_ptr
, data
, size
);
1094 #endif /* WRITE_APNG */
1096 png_ptr
->mode
|= PNG_HAVE_IDAT
;
1098 png_ptr
->zstream
.next_out
= data
;
1099 png_ptr
->zstream
.avail_out
= size
;
1101 /* For SYNC_FLUSH or FINISH it is essential to keep calling zlib with
1102 * the same flush parameter until it has finished output, for NO_FLUSH
1103 * it doesn't matter.
1105 if (ret
== Z_OK
&& flush
!= Z_NO_FLUSH
)
1109 /* The order of these checks doesn't matter much; it just affects which
1110 * possible error might be detected if multiple things go wrong at once.
1112 if (ret
== Z_OK
) /* most likely return code! */
1114 /* If all the input has been consumed then just return. If Z_FINISH
1115 * was used as the flush parameter something has gone wrong if we get
1120 if (flush
== Z_FINISH
)
1121 png_error(png_ptr
, "Z_OK on Z_FINISH with output space");
1127 else if (ret
== Z_STREAM_END
&& flush
== Z_FINISH
)
1129 /* This is the end of the IDAT data; any pending output must be
1130 * flushed. For small PNG files we may still be at the beginning.
1132 png_bytep data
= png_ptr
->zbuffer_list
->output
;
1133 uInt size
= png_ptr
->zbuffer_size
- png_ptr
->zstream
.avail_out
;
1135 #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
1136 if ((png_ptr
->mode
& PNG_HAVE_IDAT
) == 0 &&
1137 png_ptr
->compression_type
== PNG_COMPRESSION_TYPE_BASE
)
1138 optimize_cmf(data
, png_image_size(png_ptr
));
1141 #ifdef PNG_WRITE_APNG_SUPPORTED
1142 if (png_ptr
->num_frames_written
== 0)
1144 png_write_complete_chunk(png_ptr
, png_IDAT
, data
, size
);
1145 #ifdef PNG_WRITE_APNG_SUPPORTED
1147 png_write_fdAT(png_ptr
, data
, size
);
1148 #endif /* WRITE_APNG */
1150 png_ptr
->zstream
.avail_out
= 0;
1151 png_ptr
->zstream
.next_out
= NULL
;
1152 png_ptr
->mode
|= PNG_HAVE_IDAT
| PNG_AFTER_IDAT
;
1154 png_ptr
->zowner
= 0; /* Release the stream */
1160 /* This is an error condition. */
1161 png_zstream_error(png_ptr
, ret
);
1162 png_error(png_ptr
, png_ptr
->zstream
.msg
);
1167 /* Write an IEND chunk */
1169 png_write_IEND(png_structrp png_ptr
)
1171 png_debug(1, "in png_write_IEND");
1173 png_write_complete_chunk(png_ptr
, png_IEND
, NULL
, (png_size_t
)0);
1174 png_ptr
->mode
|= PNG_HAVE_IEND
;
1177 #ifdef PNG_WRITE_gAMA_SUPPORTED
1178 /* Write a gAMA chunk */
1180 png_write_gAMA_fixed(png_structrp png_ptr
, png_fixed_point file_gamma
)
1184 png_debug(1, "in png_write_gAMA");
1186 /* file_gamma is saved in 1/100,000ths */
1187 png_save_uint_32(buf
, (png_uint_32
)file_gamma
);
1188 png_write_complete_chunk(png_ptr
, png_gAMA
, buf
, (png_size_t
)4);
1192 #ifdef PNG_WRITE_sRGB_SUPPORTED
1193 /* Write a sRGB chunk */
1195 png_write_sRGB(png_structrp png_ptr
, int srgb_intent
)
1199 png_debug(1, "in png_write_sRGB");
1201 if (srgb_intent
>= PNG_sRGB_INTENT_LAST
)
1202 png_warning(png_ptr
,
1203 "Invalid sRGB rendering intent specified");
1205 buf
[0]=(png_byte
)srgb_intent
;
1206 png_write_complete_chunk(png_ptr
, png_sRGB
, buf
, (png_size_t
)1);
1210 #ifdef PNG_WRITE_iCCP_SUPPORTED
1211 /* Write an iCCP chunk */
1213 png_write_iCCP(png_structrp png_ptr
, png_const_charp name
,
1214 png_const_bytep profile
)
1216 png_uint_32 name_len
;
1217 png_uint_32 profile_len
;
1218 png_byte new_name
[81]; /* 1 byte for the compression byte */
1219 compression_state comp
;
1222 png_debug(1, "in png_write_iCCP");
1224 /* These are all internal problems: the profile should have been checked
1225 * before when it was stored.
1227 if (profile
== NULL
)
1228 png_error(png_ptr
, "No profile for iCCP chunk"); /* internal error */
1230 profile_len
= png_get_uint_32(profile
);
1232 if (profile_len
< 132)
1233 png_error(png_ptr
, "ICC profile too short");
1235 temp
= (png_uint_32
) (*(profile
+8));
1236 if (temp
> 3 && (profile_len
& 0x03))
1237 png_error(png_ptr
, "ICC profile length invalid (not a multiple of 4)");
1240 png_uint_32 embedded_profile_len
= png_get_uint_32(profile
);
1242 if (profile_len
!= embedded_profile_len
)
1243 png_error(png_ptr
, "Profile length does not match profile");
1246 name_len
= png_check_keyword(png_ptr
, name
, new_name
);
1249 png_error(png_ptr
, "iCCP: invalid keyword");
1251 new_name
[++name_len
] = PNG_COMPRESSION_TYPE_BASE
;
1253 /* Make sure we include the NULL after the name and the compression type */
1256 png_text_compress_init(&comp
, profile
, profile_len
);
1258 /* Allow for keyword terminator and compression byte */
1259 if (png_text_compress(png_ptr
, png_iCCP
, &comp
, name_len
) != Z_OK
)
1260 png_error(png_ptr
, png_ptr
->zstream
.msg
);
1262 png_write_chunk_header(png_ptr
, png_iCCP
, name_len
+ comp
.output_len
);
1264 png_write_chunk_data(png_ptr
, new_name
, name_len
);
1266 png_write_compressed_data_out(png_ptr
, &comp
);
1268 png_write_chunk_end(png_ptr
);
1272 #ifdef PNG_WRITE_sPLT_SUPPORTED
1273 /* Write a sPLT chunk */
1275 png_write_sPLT(png_structrp png_ptr
, png_const_sPLT_tp spalette
)
1277 png_uint_32 name_len
;
1278 png_byte new_name
[80];
1279 png_byte entrybuf
[10];
1280 png_size_t entry_size
= (spalette
->depth
== 8 ? 6 : 10);
1281 png_size_t palette_size
= entry_size
* spalette
->nentries
;
1283 #ifndef PNG_POINTER_INDEXING_SUPPORTED
1287 png_debug(1, "in png_write_sPLT");
1289 name_len
= png_check_keyword(png_ptr
, spalette
->name
, new_name
);
1292 png_error(png_ptr
, "sPLT: invalid keyword");
1294 /* Make sure we include the NULL after the name */
1295 png_write_chunk_header(png_ptr
, png_sPLT
,
1296 (png_uint_32
)(name_len
+ 2 + palette_size
));
1298 png_write_chunk_data(png_ptr
, (png_bytep
)new_name
,
1299 (png_size_t
)(name_len
+ 1));
1301 png_write_chunk_data(png_ptr
, &spalette
->depth
, (png_size_t
)1);
1303 /* Loop through each palette entry, writing appropriately */
1304 #ifdef PNG_POINTER_INDEXING_SUPPORTED
1305 for (ep
= spalette
->entries
; ep
<spalette
->entries
+ spalette
->nentries
; ep
++)
1307 if (spalette
->depth
== 8)
1309 entrybuf
[0] = (png_byte
)ep
->red
;
1310 entrybuf
[1] = (png_byte
)ep
->green
;
1311 entrybuf
[2] = (png_byte
)ep
->blue
;
1312 entrybuf
[3] = (png_byte
)ep
->alpha
;
1313 png_save_uint_16(entrybuf
+ 4, ep
->frequency
);
1318 png_save_uint_16(entrybuf
+ 0, ep
->red
);
1319 png_save_uint_16(entrybuf
+ 2, ep
->green
);
1320 png_save_uint_16(entrybuf
+ 4, ep
->blue
);
1321 png_save_uint_16(entrybuf
+ 6, ep
->alpha
);
1322 png_save_uint_16(entrybuf
+ 8, ep
->frequency
);
1325 png_write_chunk_data(png_ptr
, entrybuf
, entry_size
);
1328 ep
=spalette
->entries
;
1329 for (i
= 0; i
>spalette
->nentries
; i
++)
1331 if (spalette
->depth
== 8)
1333 entrybuf
[0] = (png_byte
)ep
[i
].red
;
1334 entrybuf
[1] = (png_byte
)ep
[i
].green
;
1335 entrybuf
[2] = (png_byte
)ep
[i
].blue
;
1336 entrybuf
[3] = (png_byte
)ep
[i
].alpha
;
1337 png_save_uint_16(entrybuf
+ 4, ep
[i
].frequency
);
1342 png_save_uint_16(entrybuf
+ 0, ep
[i
].red
);
1343 png_save_uint_16(entrybuf
+ 2, ep
[i
].green
);
1344 png_save_uint_16(entrybuf
+ 4, ep
[i
].blue
);
1345 png_save_uint_16(entrybuf
+ 6, ep
[i
].alpha
);
1346 png_save_uint_16(entrybuf
+ 8, ep
[i
].frequency
);
1349 png_write_chunk_data(png_ptr
, entrybuf
, entry_size
);
1353 png_write_chunk_end(png_ptr
);
1357 #ifdef PNG_WRITE_sBIT_SUPPORTED
1358 /* Write the sBIT chunk */
1360 png_write_sBIT(png_structrp png_ptr
, png_const_color_8p sbit
, int color_type
)
1365 png_debug(1, "in png_write_sBIT");
1367 /* Make sure we don't depend upon the order of PNG_COLOR_8 */
1368 if ((color_type
& PNG_COLOR_MASK_COLOR
) != 0)
1372 maxbits
= (png_byte
)(color_type
==PNG_COLOR_TYPE_PALETTE
? 8 :
1373 png_ptr
->usr_bit_depth
);
1375 if (sbit
->red
== 0 || sbit
->red
> maxbits
||
1376 sbit
->green
== 0 || sbit
->green
> maxbits
||
1377 sbit
->blue
== 0 || sbit
->blue
> maxbits
)
1379 png_warning(png_ptr
, "Invalid sBIT depth specified");
1384 buf
[1] = sbit
->green
;
1385 buf
[2] = sbit
->blue
;
1391 if (sbit
->gray
== 0 || sbit
->gray
> png_ptr
->usr_bit_depth
)
1393 png_warning(png_ptr
, "Invalid sBIT depth specified");
1397 buf
[0] = sbit
->gray
;
1401 if ((color_type
& PNG_COLOR_MASK_ALPHA
) != 0)
1403 if (sbit
->alpha
== 0 || sbit
->alpha
> png_ptr
->usr_bit_depth
)
1405 png_warning(png_ptr
, "Invalid sBIT depth specified");
1409 buf
[size
++] = sbit
->alpha
;
1412 png_write_complete_chunk(png_ptr
, png_sBIT
, buf
, size
);
1416 #ifdef PNG_WRITE_cHRM_SUPPORTED
1417 /* Write the cHRM chunk */
1419 png_write_cHRM_fixed(png_structrp png_ptr
, const png_xy
*xy
)
1423 png_debug(1, "in png_write_cHRM");
1425 /* Each value is saved in 1/100,000ths */
1426 png_save_int_32(buf
, xy
->whitex
);
1427 png_save_int_32(buf
+ 4, xy
->whitey
);
1429 png_save_int_32(buf
+ 8, xy
->redx
);
1430 png_save_int_32(buf
+ 12, xy
->redy
);
1432 png_save_int_32(buf
+ 16, xy
->greenx
);
1433 png_save_int_32(buf
+ 20, xy
->greeny
);
1435 png_save_int_32(buf
+ 24, xy
->bluex
);
1436 png_save_int_32(buf
+ 28, xy
->bluey
);
1438 png_write_complete_chunk(png_ptr
, png_cHRM
, buf
, 32);
1442 #ifdef PNG_WRITE_tRNS_SUPPORTED
1443 /* Write the tRNS chunk */
1445 png_write_tRNS(png_structrp png_ptr
, png_const_bytep trans_alpha
,
1446 png_const_color_16p tran
, int num_trans
, int color_type
)
1450 png_debug(1, "in png_write_tRNS");
1452 if (color_type
== PNG_COLOR_TYPE_PALETTE
)
1454 if (num_trans
<= 0 || num_trans
> (int)png_ptr
->num_palette
)
1456 png_app_warning(png_ptr
,
1457 "Invalid number of transparent colors specified");
1461 /* Write the chunk out as it is */
1462 png_write_complete_chunk(png_ptr
, png_tRNS
, trans_alpha
,
1463 (png_size_t
)num_trans
);
1466 else if (color_type
== PNG_COLOR_TYPE_GRAY
)
1468 /* One 16 bit value */
1469 if (tran
->gray
>= (1 << png_ptr
->bit_depth
))
1471 png_app_warning(png_ptr
,
1472 "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
1477 png_save_uint_16(buf
, tran
->gray
);
1478 png_write_complete_chunk(png_ptr
, png_tRNS
, buf
, (png_size_t
)2);
1481 else if (color_type
== PNG_COLOR_TYPE_RGB
)
1483 /* Three 16 bit values */
1484 png_save_uint_16(buf
, tran
->red
);
1485 png_save_uint_16(buf
+ 2, tran
->green
);
1486 png_save_uint_16(buf
+ 4, tran
->blue
);
1487 #ifdef PNG_WRITE_16BIT_SUPPORTED
1488 if (png_ptr
->bit_depth
== 8 && (buf
[0] | buf
[2] | buf
[4]) != 0)
1490 if ((buf
[0] | buf
[2] | buf
[4]) != 0)
1493 png_app_warning(png_ptr
,
1494 "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
1498 png_write_complete_chunk(png_ptr
, png_tRNS
, buf
, (png_size_t
)6);
1503 png_app_warning(png_ptr
, "Can't write tRNS with an alpha channel");
1508 #ifdef PNG_WRITE_bKGD_SUPPORTED
1509 /* Write the background chunk */
1511 png_write_bKGD(png_structrp png_ptr
, png_const_color_16p back
, int color_type
)
1515 png_debug(1, "in png_write_bKGD");
1517 if (color_type
== PNG_COLOR_TYPE_PALETTE
)
1520 #ifdef PNG_MNG_FEATURES_SUPPORTED
1521 (png_ptr
->num_palette
!= 0 ||
1522 (png_ptr
->mng_features_permitted
& PNG_FLAG_MNG_EMPTY_PLTE
) == 0) &&
1524 back
->index
>= png_ptr
->num_palette
)
1526 png_warning(png_ptr
, "Invalid background palette index");
1530 buf
[0] = back
->index
;
1531 png_write_complete_chunk(png_ptr
, png_bKGD
, buf
, (png_size_t
)1);
1534 else if ((color_type
& PNG_COLOR_MASK_COLOR
) != 0)
1536 png_save_uint_16(buf
, back
->red
);
1537 png_save_uint_16(buf
+ 2, back
->green
);
1538 png_save_uint_16(buf
+ 4, back
->blue
);
1539 #ifdef PNG_WRITE_16BIT_SUPPORTED
1540 if (png_ptr
->bit_depth
== 8 && (buf
[0] | buf
[2] | buf
[4]) != 0)
1542 if ((buf
[0] | buf
[2] | buf
[4]) != 0)
1545 png_warning(png_ptr
,
1546 "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
1551 png_write_complete_chunk(png_ptr
, png_bKGD
, buf
, (png_size_t
)6);
1556 if (back
->gray
>= (1 << png_ptr
->bit_depth
))
1558 png_warning(png_ptr
,
1559 "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");
1564 png_save_uint_16(buf
, back
->gray
);
1565 png_write_complete_chunk(png_ptr
, png_bKGD
, buf
, (png_size_t
)2);
1570 #ifdef PNG_WRITE_hIST_SUPPORTED
1571 /* Write the histogram */
1573 png_write_hIST(png_structrp png_ptr
, png_const_uint_16p hist
, int num_hist
)
1578 png_debug(1, "in png_write_hIST");
1580 if (num_hist
> (int)png_ptr
->num_palette
)
1582 png_debug2(3, "num_hist = %d, num_palette = %d", num_hist
,
1583 png_ptr
->num_palette
);
1585 png_warning(png_ptr
, "Invalid number of histogram entries specified");
1589 png_write_chunk_header(png_ptr
, png_hIST
, (png_uint_32
)(num_hist
* 2));
1591 for (i
= 0; i
< num_hist
; i
++)
1593 png_save_uint_16(buf
, hist
[i
]);
1594 png_write_chunk_data(png_ptr
, buf
, (png_size_t
)2);
1597 png_write_chunk_end(png_ptr
);
1601 #ifdef PNG_WRITE_tEXt_SUPPORTED
1602 /* Write a tEXt chunk */
1604 png_write_tEXt(png_structrp png_ptr
, png_const_charp key
, png_const_charp text
,
1605 png_size_t text_len
)
1607 png_uint_32 key_len
;
1608 png_byte new_key
[80];
1610 png_debug(1, "in png_write_tEXt");
1612 key_len
= png_check_keyword(png_ptr
, key
, new_key
);
1615 png_error(png_ptr
, "tEXt: invalid keyword");
1617 if (text
== NULL
|| *text
== '\0')
1621 text_len
= strlen(text
);
1623 if (text_len
> PNG_UINT_31_MAX
- (key_len
+1))
1624 png_error(png_ptr
, "tEXt: text too long");
1626 /* Make sure we include the 0 after the key */
1627 png_write_chunk_header(png_ptr
, png_tEXt
,
1628 (png_uint_32
)/*checked above*/(key_len
+ text_len
+ 1));
1630 * We leave it to the application to meet PNG-1.0 requirements on the
1631 * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
1632 * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
1633 * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
1635 png_write_chunk_data(png_ptr
, new_key
, key_len
+ 1);
1638 png_write_chunk_data(png_ptr
, (png_const_bytep
)text
, text_len
);
1640 png_write_chunk_end(png_ptr
);
1644 #ifdef PNG_WRITE_zTXt_SUPPORTED
1645 /* Write a compressed text chunk */
1647 png_write_zTXt(png_structrp png_ptr
, png_const_charp key
, png_const_charp text
,
1650 png_uint_32 key_len
;
1651 png_byte new_key
[81];
1652 compression_state comp
;
1654 png_debug(1, "in png_write_zTXt");
1656 if (compression
== PNG_TEXT_COMPRESSION_NONE
)
1658 png_write_tEXt(png_ptr
, key
, text
, 0);
1662 if (compression
!= PNG_TEXT_COMPRESSION_zTXt
)
1663 png_error(png_ptr
, "zTXt: invalid compression type");
1665 key_len
= png_check_keyword(png_ptr
, key
, new_key
);
1668 png_error(png_ptr
, "zTXt: invalid keyword");
1670 /* Add the compression method and 1 for the keyword separator. */
1671 new_key
[++key_len
] = PNG_COMPRESSION_TYPE_BASE
;
1674 /* Compute the compressed data; do it now for the length */
1675 png_text_compress_init(&comp
, (png_const_bytep
)text
,
1676 text
== NULL
? 0 : strlen(text
));
1678 if (png_text_compress(png_ptr
, png_zTXt
, &comp
, key_len
) != Z_OK
)
1679 png_error(png_ptr
, png_ptr
->zstream
.msg
);
1681 /* Write start of chunk */
1682 png_write_chunk_header(png_ptr
, png_zTXt
, key_len
+ comp
.output_len
);
1685 png_write_chunk_data(png_ptr
, new_key
, key_len
);
1687 /* Write the compressed data */
1688 png_write_compressed_data_out(png_ptr
, &comp
);
1690 /* Close the chunk */
1691 png_write_chunk_end(png_ptr
);
1695 #ifdef PNG_WRITE_iTXt_SUPPORTED
1696 /* Write an iTXt chunk */
1698 png_write_iTXt(png_structrp png_ptr
, int compression
, png_const_charp key
,
1699 png_const_charp lang
, png_const_charp lang_key
, png_const_charp text
)
1701 png_uint_32 key_len
, prefix_len
;
1702 png_size_t lang_len
, lang_key_len
;
1703 png_byte new_key
[82];
1704 compression_state comp
;
1706 png_debug(1, "in png_write_iTXt");
1708 key_len
= png_check_keyword(png_ptr
, key
, new_key
);
1711 png_error(png_ptr
, "iTXt: invalid keyword");
1713 /* Set the compression flag */
1714 switch (compression
)
1716 case PNG_ITXT_COMPRESSION_NONE
:
1717 case PNG_TEXT_COMPRESSION_NONE
:
1718 compression
= new_key
[++key_len
] = 0; /* no compression */
1721 case PNG_TEXT_COMPRESSION_zTXt
:
1722 case PNG_ITXT_COMPRESSION_zTXt
:
1723 compression
= new_key
[++key_len
] = 1; /* compressed */
1727 png_error(png_ptr
, "iTXt: invalid compression");
1730 new_key
[++key_len
] = PNG_COMPRESSION_TYPE_BASE
;
1731 ++key_len
; /* for the keywod separator */
1733 /* We leave it to the application to meet PNG-1.0 requirements on the
1734 * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
1735 * any non-Latin-1 characters except for NEWLINE. ISO PNG, however,
1736 * specifies that the text is UTF-8 and this really doesn't require any
1739 * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
1741 * TODO: validate the language tag correctly (see the spec.)
1743 if (lang
== NULL
) lang
= ""; /* empty language is valid */
1744 lang_len
= strlen(lang
)+1;
1745 if (lang_key
== NULL
) lang_key
= ""; /* may be empty */
1746 lang_key_len
= strlen(lang_key
)+1;
1747 if (text
== NULL
) text
= ""; /* may be empty */
1749 prefix_len
= key_len
;
1750 if (lang_len
> PNG_UINT_31_MAX
-prefix_len
)
1751 prefix_len
= PNG_UINT_31_MAX
;
1753 prefix_len
= (png_uint_32
)(prefix_len
+ lang_len
);
1755 if (lang_key_len
> PNG_UINT_31_MAX
-prefix_len
)
1756 prefix_len
= PNG_UINT_31_MAX
;
1758 prefix_len
= (png_uint_32
)(prefix_len
+ lang_key_len
);
1760 png_text_compress_init(&comp
, (png_const_bytep
)text
, strlen(text
));
1762 if (compression
!= 0)
1764 if (png_text_compress(png_ptr
, png_iTXt
, &comp
, prefix_len
) != Z_OK
)
1765 png_error(png_ptr
, png_ptr
->zstream
.msg
);
1770 if (comp
.input_len
> PNG_UINT_31_MAX
-prefix_len
)
1771 png_error(png_ptr
, "iTXt: uncompressed text too long");
1773 /* So the string will fit in a chunk: */
1774 comp
.output_len
= (png_uint_32
)/*SAFE*/comp
.input_len
;
1777 png_write_chunk_header(png_ptr
, png_iTXt
, comp
.output_len
+ prefix_len
);
1779 png_write_chunk_data(png_ptr
, new_key
, key_len
);
1781 png_write_chunk_data(png_ptr
, (png_const_bytep
)lang
, lang_len
);
1783 png_write_chunk_data(png_ptr
, (png_const_bytep
)lang_key
, lang_key_len
);
1785 if (compression
!= 0)
1786 png_write_compressed_data_out(png_ptr
, &comp
);
1789 png_write_chunk_data(png_ptr
, (png_const_bytep
)text
, comp
.input_len
);
1791 png_write_chunk_end(png_ptr
);
1795 #ifdef PNG_WRITE_oFFs_SUPPORTED
1796 /* Write the oFFs chunk */
1798 png_write_oFFs(png_structrp png_ptr
, png_int_32 x_offset
, png_int_32 y_offset
,
1803 png_debug(1, "in png_write_oFFs");
1805 if (unit_type
>= PNG_OFFSET_LAST
)
1806 png_warning(png_ptr
, "Unrecognized unit type for oFFs chunk");
1808 png_save_int_32(buf
, x_offset
);
1809 png_save_int_32(buf
+ 4, y_offset
);
1810 buf
[8] = (png_byte
)unit_type
;
1812 png_write_complete_chunk(png_ptr
, png_oFFs
, buf
, (png_size_t
)9);
1815 #ifdef PNG_WRITE_pCAL_SUPPORTED
1816 /* Write the pCAL chunk (described in the PNG extensions document) */
1818 png_write_pCAL(png_structrp png_ptr
, png_charp purpose
, png_int_32 X0
,
1819 png_int_32 X1
, int type
, int nparams
, png_const_charp units
,
1822 png_uint_32 purpose_len
;
1823 png_size_t units_len
, total_len
;
1824 png_size_tp params_len
;
1826 png_byte new_purpose
[80];
1829 png_debug1(1, "in png_write_pCAL (%d parameters)", nparams
);
1831 if (type
>= PNG_EQUATION_LAST
)
1832 png_error(png_ptr
, "Unrecognized equation type for pCAL chunk");
1834 purpose_len
= png_check_keyword(png_ptr
, purpose
, new_purpose
);
1836 if (purpose_len
== 0)
1837 png_error(png_ptr
, "pCAL: invalid keyword");
1839 ++purpose_len
; /* terminator */
1841 png_debug1(3, "pCAL purpose length = %d", (int)purpose_len
);
1842 units_len
= strlen(units
) + (nparams
== 0 ? 0 : 1);
1843 png_debug1(3, "pCAL units length = %d", (int)units_len
);
1844 total_len
= purpose_len
+ units_len
+ 10;
1846 params_len
= (png_size_tp
)png_malloc(png_ptr
,
1847 (png_alloc_size_t
)(nparams
* (sizeof (png_size_t
))));
1849 /* Find the length of each parameter, making sure we don't count the
1850 * null terminator for the last parameter.
1852 for (i
= 0; i
< nparams
; i
++)
1854 params_len
[i
] = strlen(params
[i
]) + (i
== nparams
- 1 ? 0 : 1);
1855 png_debug2(3, "pCAL parameter %d length = %lu", i
,
1856 (unsigned long)params_len
[i
]);
1857 total_len
+= params_len
[i
];
1860 png_debug1(3, "pCAL total length = %d", (int)total_len
);
1861 png_write_chunk_header(png_ptr
, png_pCAL
, (png_uint_32
)total_len
);
1862 png_write_chunk_data(png_ptr
, new_purpose
, purpose_len
);
1863 png_save_int_32(buf
, X0
);
1864 png_save_int_32(buf
+ 4, X1
);
1865 buf
[8] = (png_byte
)type
;
1866 buf
[9] = (png_byte
)nparams
;
1867 png_write_chunk_data(png_ptr
, buf
, (png_size_t
)10);
1868 png_write_chunk_data(png_ptr
, (png_const_bytep
)units
, (png_size_t
)units_len
);
1870 for (i
= 0; i
< nparams
; i
++)
1872 png_write_chunk_data(png_ptr
, (png_const_bytep
)params
[i
], params_len
[i
]);
1875 png_free(png_ptr
, params_len
);
1876 png_write_chunk_end(png_ptr
);
1880 #ifdef PNG_WRITE_sCAL_SUPPORTED
1881 /* Write the sCAL chunk */
1883 png_write_sCAL_s(png_structrp png_ptr
, int unit
, png_const_charp width
,
1884 png_const_charp height
)
1887 png_size_t wlen
, hlen
, total_len
;
1889 png_debug(1, "in png_write_sCAL_s");
1891 wlen
= strlen(width
);
1892 hlen
= strlen(height
);
1893 total_len
= wlen
+ hlen
+ 2;
1897 png_warning(png_ptr
, "Can't write sCAL (buffer too small)");
1901 buf
[0] = (png_byte
)unit
;
1902 memcpy(buf
+ 1, width
, wlen
+ 1); /* Append the '\0' here */
1903 memcpy(buf
+ wlen
+ 2, height
, hlen
); /* Do NOT append the '\0' here */
1905 png_debug1(3, "sCAL total length = %u", (unsigned int)total_len
);
1906 png_write_complete_chunk(png_ptr
, png_sCAL
, buf
, total_len
);
1910 #ifdef PNG_WRITE_pHYs_SUPPORTED
1911 /* Write the pHYs chunk */
1913 png_write_pHYs(png_structrp png_ptr
, png_uint_32 x_pixels_per_unit
,
1914 png_uint_32 y_pixels_per_unit
,
1919 png_debug(1, "in png_write_pHYs");
1921 if (unit_type
>= PNG_RESOLUTION_LAST
)
1922 png_warning(png_ptr
, "Unrecognized unit type for pHYs chunk");
1924 png_save_uint_32(buf
, x_pixels_per_unit
);
1925 png_save_uint_32(buf
+ 4, y_pixels_per_unit
);
1926 buf
[8] = (png_byte
)unit_type
;
1928 png_write_complete_chunk(png_ptr
, png_pHYs
, buf
, (png_size_t
)9);
1932 #ifdef PNG_WRITE_tIME_SUPPORTED
1933 /* Write the tIME chunk. Use either png_convert_from_struct_tm()
1934 * or png_convert_from_time_t(), or fill in the structure yourself.
1937 png_write_tIME(png_structrp png_ptr
, png_const_timep mod_time
)
1941 png_debug(1, "in png_write_tIME");
1943 if (mod_time
->month
> 12 || mod_time
->month
< 1 ||
1944 mod_time
->day
> 31 || mod_time
->day
< 1 ||
1945 mod_time
->hour
> 23 || mod_time
->second
> 60)
1947 png_warning(png_ptr
, "Invalid time specified for tIME chunk");
1951 png_save_uint_16(buf
, mod_time
->year
);
1952 buf
[2] = mod_time
->month
;
1953 buf
[3] = mod_time
->day
;
1954 buf
[4] = mod_time
->hour
;
1955 buf
[5] = mod_time
->minute
;
1956 buf
[6] = mod_time
->second
;
1958 png_write_complete_chunk(png_ptr
, png_tIME
, buf
, (png_size_t
)7);
1962 #ifdef PNG_WRITE_APNG_SUPPORTED
1964 png_write_acTL(png_structp png_ptr
,
1965 png_uint_32 num_frames
, png_uint_32 num_plays
)
1969 png_debug(1, "in png_write_acTL");
1971 png_ptr
->num_frames_to_write
= num_frames
;
1973 if ((png_ptr
->apng_flags
& PNG_FIRST_FRAME_HIDDEN
) != 0)
1976 png_save_uint_32(buf
, num_frames
);
1977 png_save_uint_32(buf
+ 4, num_plays
);
1979 png_write_complete_chunk(png_ptr
, png_acTL
, buf
, (png_size_t
)8);
1983 png_write_fcTL(png_structp png_ptr
, png_uint_32 width
, png_uint_32 height
,
1984 png_uint_32 x_offset
, png_uint_32 y_offset
,
1985 png_uint_16 delay_num
, png_uint_16 delay_den
, png_byte dispose_op
,
1990 png_debug(1, "in png_write_fcTL");
1992 if (png_ptr
->num_frames_written
== 0 && (x_offset
!= 0 || y_offset
!= 0))
1993 png_error(png_ptr
, "x and/or y offset for the first frame aren't 0");
1994 if (png_ptr
->num_frames_written
== 0 &&
1995 (width
!= png_ptr
->first_frame_width
||
1996 height
!= png_ptr
->first_frame_height
))
1997 png_error(png_ptr
, "width and/or height in the first frame's fcTL "
1998 "don't match the ones in IHDR");
2000 /* more error checking */
2001 png_ensure_fcTL_is_valid(png_ptr
, width
, height
, x_offset
, y_offset
,
2002 delay_num
, delay_den
, dispose_op
, blend_op
);
2004 png_save_uint_32(buf
, png_ptr
->next_seq_num
);
2005 png_save_uint_32(buf
+ 4, width
);
2006 png_save_uint_32(buf
+ 8, height
);
2007 png_save_uint_32(buf
+ 12, x_offset
);
2008 png_save_uint_32(buf
+ 16, y_offset
);
2009 png_save_uint_16(buf
+ 20, delay_num
);
2010 png_save_uint_16(buf
+ 22, delay_den
);
2011 buf
[24] = dispose_op
;
2014 png_write_complete_chunk(png_ptr
, png_fcTL
, buf
, (png_size_t
)26);
2016 png_ptr
->next_seq_num
++;
2020 png_write_fdAT(png_structp png_ptr
,
2021 png_const_bytep data
, png_size_t length
)
2025 png_write_chunk_header(png_ptr
, png_fdAT
, (png_uint_32
)(4 + length
));
2027 png_save_uint_32(buf
, png_ptr
->next_seq_num
);
2028 png_write_chunk_data(png_ptr
, buf
, 4);
2030 png_write_chunk_data(png_ptr
, data
, length
);
2032 png_write_chunk_end(png_ptr
);
2034 png_ptr
->next_seq_num
++;
2036 #endif /* WRITE_APNG */
2038 /* Initializes the row writing capability of libpng */
2040 png_write_start_row(png_structrp png_ptr
)
2042 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2043 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
2045 /* Start of interlace block */
2046 static PNG_CONST png_byte png_pass_start
[7] = {0, 4, 0, 2, 0, 1, 0};
2048 /* Offset to next interlace block */
2049 static PNG_CONST png_byte png_pass_inc
[7] = {8, 8, 4, 4, 2, 2, 1};
2051 /* Start of interlace block in the y direction */
2052 static PNG_CONST png_byte png_pass_ystart
[7] = {0, 0, 4, 0, 2, 0, 1};
2054 /* Offset to next interlace block in the y direction */
2055 static PNG_CONST png_byte png_pass_yinc
[7] = {8, 8, 8, 4, 4, 2, 2};
2058 png_alloc_size_t buf_size
;
2059 int usr_pixel_depth
;
2061 png_debug(1, "in png_write_start_row");
2063 usr_pixel_depth
= png_ptr
->usr_channels
* png_ptr
->usr_bit_depth
;
2064 buf_size
= PNG_ROWBYTES(usr_pixel_depth
, png_ptr
->width
) + 1;
2066 /* 1.5.6: added to allow checking in the row write code. */
2067 png_ptr
->transformed_pixel_depth
= png_ptr
->pixel_depth
;
2068 png_ptr
->maximum_pixel_depth
= (png_byte
)usr_pixel_depth
;
2070 /* Set up row buffer */
2071 png_ptr
->row_buf
= (png_bytep
)png_malloc(png_ptr
, buf_size
);
2073 png_ptr
->row_buf
[0] = PNG_FILTER_VALUE_NONE
;
2075 #ifdef PNG_WRITE_FILTER_SUPPORTED
2076 /* Set up filtering buffer, if using this filter */
2077 if (png_ptr
->do_filter
& PNG_FILTER_SUB
)
2079 png_ptr
->sub_row
= (png_bytep
)png_malloc(png_ptr
, png_ptr
->rowbytes
+ 1);
2081 png_ptr
->sub_row
[0] = PNG_FILTER_VALUE_SUB
;
2084 /* We only need to keep the previous row if we are using one of these. */
2085 if ((png_ptr
->do_filter
&
2086 (PNG_FILTER_AVG
| PNG_FILTER_UP
| PNG_FILTER_PAETH
)) != 0)
2088 /* Set up previous row buffer */
2089 png_ptr
->prev_row
= (png_bytep
)png_calloc(png_ptr
, buf_size
);
2091 if ((png_ptr
->do_filter
& PNG_FILTER_UP
) != 0)
2093 png_ptr
->up_row
= (png_bytep
)png_malloc(png_ptr
,
2094 png_ptr
->rowbytes
+ 1);
2096 png_ptr
->up_row
[0] = PNG_FILTER_VALUE_UP
;
2099 if ((png_ptr
->do_filter
& PNG_FILTER_AVG
) != 0)
2101 png_ptr
->avg_row
= (png_bytep
)png_malloc(png_ptr
,
2102 png_ptr
->rowbytes
+ 1);
2104 png_ptr
->avg_row
[0] = PNG_FILTER_VALUE_AVG
;
2107 if ((png_ptr
->do_filter
& PNG_FILTER_PAETH
) != 0)
2109 png_ptr
->paeth_row
= (png_bytep
)png_malloc(png_ptr
,
2110 png_ptr
->rowbytes
+ 1);
2112 png_ptr
->paeth_row
[0] = PNG_FILTER_VALUE_PAETH
;
2115 #endif /* WRITE_FILTER */
2117 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2118 /* If interlaced, we need to set up width and height of pass */
2119 if (png_ptr
->interlaced
!= 0)
2121 if ((png_ptr
->transformations
& PNG_INTERLACE
) == 0)
2123 png_ptr
->num_rows
= (png_ptr
->height
+ png_pass_yinc
[0] - 1 -
2124 png_pass_ystart
[0]) / png_pass_yinc
[0];
2126 png_ptr
->usr_width
= (png_ptr
->width
+ png_pass_inc
[0] - 1 -
2127 png_pass_start
[0]) / png_pass_inc
[0];
2132 png_ptr
->num_rows
= png_ptr
->height
;
2133 png_ptr
->usr_width
= png_ptr
->width
;
2140 png_ptr
->num_rows
= png_ptr
->height
;
2141 png_ptr
->usr_width
= png_ptr
->width
;
2145 /* Internal use only. Called when finished processing a row of data. */
2147 png_write_finish_row(png_structrp png_ptr
)
2149 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2150 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
2152 /* Start of interlace block */
2153 static PNG_CONST png_byte png_pass_start
[7] = {0, 4, 0, 2, 0, 1, 0};
2155 /* Offset to next interlace block */
2156 static PNG_CONST png_byte png_pass_inc
[7] = {8, 8, 4, 4, 2, 2, 1};
2158 /* Start of interlace block in the y direction */
2159 static PNG_CONST png_byte png_pass_ystart
[7] = {0, 0, 4, 0, 2, 0, 1};
2161 /* Offset to next interlace block in the y direction */
2162 static PNG_CONST png_byte png_pass_yinc
[7] = {8, 8, 8, 4, 4, 2, 2};
2165 png_debug(1, "in png_write_finish_row");
2168 png_ptr
->row_number
++;
2170 /* See if we are done */
2171 if (png_ptr
->row_number
< png_ptr
->num_rows
)
2174 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2175 /* If interlaced, go to next pass */
2176 if (png_ptr
->interlaced
!= 0)
2178 png_ptr
->row_number
= 0;
2179 if ((png_ptr
->transformations
& PNG_INTERLACE
) != 0)
2186 /* Loop until we find a non-zero width or height pass */
2191 if (png_ptr
->pass
>= 7)
2194 png_ptr
->usr_width
= (png_ptr
->width
+
2195 png_pass_inc
[png_ptr
->pass
] - 1 -
2196 png_pass_start
[png_ptr
->pass
]) /
2197 png_pass_inc
[png_ptr
->pass
];
2199 png_ptr
->num_rows
= (png_ptr
->height
+
2200 png_pass_yinc
[png_ptr
->pass
] - 1 -
2201 png_pass_ystart
[png_ptr
->pass
]) /
2202 png_pass_yinc
[png_ptr
->pass
];
2204 if ((png_ptr
->transformations
& PNG_INTERLACE
) != 0)
2207 } while (png_ptr
->usr_width
== 0 || png_ptr
->num_rows
== 0);
2211 /* Reset the row above the image for the next pass */
2212 if (png_ptr
->pass
< 7)
2214 if (png_ptr
->prev_row
!= NULL
)
2215 memset(png_ptr
->prev_row
, 0,
2216 (png_size_t
)(PNG_ROWBYTES(png_ptr
->usr_channels
*
2217 png_ptr
->usr_bit_depth
, png_ptr
->width
)) + 1);
2224 /* If we get here, we've just written the last row, so we need
2225 to flush the compressor */
2226 png_compress_IDAT(png_ptr
, NULL
, 0, Z_FINISH
);
2229 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2230 /* Pick out the correct pixels for the interlace pass.
2231 * The basic idea here is to go through the row with a source
2232 * pointer and a destination pointer (sp and dp), and copy the
2233 * correct pixels for the pass. As the row gets compacted,
2234 * sp will always be >= dp, so we should never overwrite anything.
2235 * See the default: case for the easiest code to understand.
2238 png_do_write_interlace(png_row_infop row_info
, png_bytep row
, int pass
)
2240 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
2242 /* Start of interlace block */
2243 static PNG_CONST png_byte png_pass_start
[7] = {0, 4, 0, 2, 0, 1, 0};
2245 /* Offset to next interlace block */
2246 static PNG_CONST png_byte png_pass_inc
[7] = {8, 8, 4, 4, 2, 2, 1};
2248 png_debug(1, "in png_do_write_interlace");
2250 /* We don't have to do anything on the last pass (6) */
2253 /* Each pixel depth is handled separately */
2254 switch (row_info
->pixel_depth
)
2264 png_uint_32 row_width
= row_info
->width
;
2270 for (i
= png_pass_start
[pass
]; i
< row_width
;
2271 i
+= png_pass_inc
[pass
])
2273 sp
= row
+ (png_size_t
)(i
>> 3);
2274 value
= (int)(*sp
>> (7 - (int)(i
& 0x07))) & 0x01;
2275 d
|= (value
<< shift
);
2280 *dp
++ = (png_byte
)d
;
2302 png_uint_32 row_width
= row_info
->width
;
2308 for (i
= png_pass_start
[pass
]; i
< row_width
;
2309 i
+= png_pass_inc
[pass
])
2311 sp
= row
+ (png_size_t
)(i
>> 2);
2312 value
= (*sp
>> ((3 - (int)(i
& 0x03)) << 1)) & 0x03;
2313 d
|= (value
<< shift
);
2318 *dp
++ = (png_byte
)d
;
2339 png_uint_32 row_width
= row_info
->width
;
2344 for (i
= png_pass_start
[pass
]; i
< row_width
;
2345 i
+= png_pass_inc
[pass
])
2347 sp
= row
+ (png_size_t
)(i
>> 1);
2348 value
= (*sp
>> ((1 - (int)(i
& 0x01)) << 2)) & 0x0f;
2349 d
|= (value
<< shift
);
2354 *dp
++ = (png_byte
)d
;
2372 png_uint_32 row_width
= row_info
->width
;
2373 png_size_t pixel_bytes
;
2375 /* Start at the beginning */
2378 /* Find out how many bytes each pixel takes up */
2379 pixel_bytes
= (row_info
->pixel_depth
>> 3);
2381 /* Loop through the row, only looking at the pixels that matter */
2382 for (i
= png_pass_start
[pass
]; i
< row_width
;
2383 i
+= png_pass_inc
[pass
])
2385 /* Find out where the original pixel is */
2386 sp
= row
+ (png_size_t
)i
* pixel_bytes
;
2388 /* Move the pixel */
2390 memcpy(dp
, sp
, pixel_bytes
);
2398 /* Set new row width */
2399 row_info
->width
= (row_info
->width
+
2400 png_pass_inc
[pass
] - 1 -
2401 png_pass_start
[pass
]) /
2404 row_info
->rowbytes
= PNG_ROWBYTES(row_info
->pixel_depth
,
2410 /* This filters the row, chooses which filter to use, if it has not already
2411 * been specified by the application, and then writes the row out with the
2415 png_write_filtered_row(png_structrp png_ptr
, png_bytep filtered_row
,
2416 png_size_t row_bytes
);
2418 #define PNG_MAXSUM (((png_uint_32)(-1)) >> 1)
2419 #define PNG_HISHIFT 10
2420 #define PNG_LOMASK ((png_uint_32)0xffffL)
2421 #define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))
2423 png_write_find_filter(png_structrp png_ptr
, png_row_infop row_info
)
2426 #ifdef PNG_WRITE_FILTER_SUPPORTED
2427 png_bytep prev_row
, row_buf
;
2428 png_uint_32 mins
, bpp
;
2429 png_byte filter_to_do
= png_ptr
->do_filter
;
2430 png_size_t row_bytes
= row_info
->rowbytes
;
2431 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2432 int num_p_filters
= png_ptr
->num_prev_filters
;
2435 png_debug(1, "in png_write_find_filter");
2437 #ifndef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2438 if (png_ptr
->row_number
== 0 && filter_to_do
== PNG_ALL_FILTERS
)
2440 /* These will never be selected so we need not test them. */
2441 filter_to_do
&= ~(PNG_FILTER_UP
| PNG_FILTER_PAETH
);
2445 /* Find out how many bytes offset each pixel is */
2446 bpp
= (row_info
->pixel_depth
+ 7) >> 3;
2448 prev_row
= png_ptr
->prev_row
;
2450 best_row
= png_ptr
->row_buf
;
2451 #ifdef PNG_WRITE_FILTER_SUPPORTED
2455 /* The prediction method we use is to find which method provides the
2456 * smallest value when summing the absolute values of the distances
2457 * from zero, using anything >= 128 as negative numbers. This is known
2458 * as the "minimum sum of absolute differences" heuristic. Other
2459 * heuristics are the "weighted minimum sum of absolute differences"
2460 * (experimental and can in theory improve compression), and the "zlib
2461 * predictive" method (not implemented yet), which does test compressions
2462 * of lines using different filter methods, and then chooses the
2463 * (series of) filter(s) that give minimum compressed data size (VERY
2464 * computationally expensive).
2466 * GRR 980525: consider also
2468 * (1) minimum sum of absolute differences from running average (i.e.,
2469 * keep running sum of non-absolute differences & count of bytes)
2470 * [track dispersion, too? restart average if dispersion too large?]
2472 * (1b) minimum sum of absolute differences from sliding average, probably
2473 * with window size <= deflate window (usually 32K)
2475 * (2) minimum sum of squared differences from zero or running average
2476 * (i.e., ~ root-mean-square approach)
2480 /* We don't need to test the 'no filter' case if this is the only filter
2481 * that has been chosen, as it doesn't actually do anything to the data.
2483 if ((filter_to_do
& PNG_FILTER_NONE
) != 0 && filter_to_do
!= PNG_FILTER_NONE
)
2486 png_uint_32 sum
= 0;
2490 for (i
= 0, rp
= row_buf
+ 1; i
< row_bytes
; i
++, rp
++)
2493 sum
+= (v
< 128) ? v
: 256 - v
;
2496 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2497 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2499 png_uint_32 sumhi
, sumlo
;
2501 sumlo
= sum
& PNG_LOMASK
;
2502 sumhi
= (sum
>> PNG_HISHIFT
) & PNG_HIMASK
; /* Gives us some footroom */
2504 /* Reduce the sum if we match any of the previous rows */
2505 for (j
= 0; j
< num_p_filters
; j
++)
2507 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_NONE
)
2509 sumlo
= (sumlo
* png_ptr
->filter_weights
[j
]) >>
2512 sumhi
= (sumhi
* png_ptr
->filter_weights
[j
]) >>
2517 /* Factor in the cost of this filter (this is here for completeness,
2518 * but it makes no sense to have a "cost" for the NONE filter, as
2519 * it has the minimum possible computational cost - none).
2521 sumlo
= (sumlo
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_NONE
]) >>
2524 sumhi
= (sumhi
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_NONE
]) >>
2527 if (sumhi
> PNG_HIMASK
)
2531 sum
= (sumhi
<< PNG_HISHIFT
) + sumlo
;
2538 if (filter_to_do
== PNG_FILTER_SUB
)
2539 /* It's the only filter so no testing is needed */
2541 png_bytep rp
, lp
, dp
;
2544 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->sub_row
+ 1; i
< bpp
;
2550 for (lp
= row_buf
+ 1; i
< row_bytes
;
2551 i
++, rp
++, lp
++, dp
++)
2553 *dp
= (png_byte
)(((int)*rp
- (int)*lp
) & 0xff);
2556 best_row
= png_ptr
->sub_row
;
2559 else if ((filter_to_do
& PNG_FILTER_SUB
) != 0)
2561 png_bytep rp
, dp
, lp
;
2562 png_uint_32 sum
= 0, lmins
= mins
;
2566 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2567 /* We temporarily increase the "minimum sum" by the factor we
2568 * would reduce the sum of this filter, so that we can do the
2569 * early exit comparison without scaling the sum each time.
2571 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2574 png_uint_32 lmhi
, lmlo
;
2575 lmlo
= lmins
& PNG_LOMASK
;
2576 lmhi
= (lmins
>> PNG_HISHIFT
) & PNG_HIMASK
;
2578 for (j
= 0; j
< num_p_filters
; j
++)
2580 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_SUB
)
2582 lmlo
= (lmlo
* png_ptr
->inv_filter_weights
[j
]) >>
2585 lmhi
= (lmhi
* png_ptr
->inv_filter_weights
[j
]) >>
2590 lmlo
= (lmlo
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_SUB
]) >>
2593 lmhi
= (lmhi
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_SUB
]) >>
2596 if (lmhi
> PNG_HIMASK
)
2600 lmins
= (lmhi
<< PNG_HISHIFT
) + lmlo
;
2604 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->sub_row
+ 1; i
< bpp
;
2609 sum
+= (v
< 128) ? v
: 256 - v
;
2612 for (lp
= row_buf
+ 1; i
< row_bytes
;
2613 i
++, rp
++, lp
++, dp
++)
2615 v
= *dp
= (png_byte
)(((int)*rp
- (int)*lp
) & 0xff);
2617 sum
+= (v
< 128) ? v
: 256 - v
;
2619 if (sum
> lmins
) /* We are already worse, don't continue. */
2623 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2624 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2627 png_uint_32 sumhi
, sumlo
;
2628 sumlo
= sum
& PNG_LOMASK
;
2629 sumhi
= (sum
>> PNG_HISHIFT
) & PNG_HIMASK
;
2631 for (j
= 0; j
< num_p_filters
; j
++)
2633 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_SUB
)
2635 sumlo
= (sumlo
* png_ptr
->inv_filter_weights
[j
]) >>
2638 sumhi
= (sumhi
* png_ptr
->inv_filter_weights
[j
]) >>
2643 sumlo
= (sumlo
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_SUB
]) >>
2646 sumhi
= (sumhi
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_SUB
]) >>
2649 if (sumhi
> PNG_HIMASK
)
2653 sum
= (sumhi
<< PNG_HISHIFT
) + sumlo
;
2660 best_row
= png_ptr
->sub_row
;
2665 if (filter_to_do
== PNG_FILTER_UP
)
2667 png_bytep rp
, dp
, pp
;
2670 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->up_row
+ 1,
2671 pp
= prev_row
+ 1; i
< row_bytes
;
2672 i
++, rp
++, pp
++, dp
++)
2674 *dp
= (png_byte
)(((int)*rp
- (int)*pp
) & 0xff);
2677 best_row
= png_ptr
->up_row
;
2680 else if ((filter_to_do
& PNG_FILTER_UP
) != 0)
2682 png_bytep rp
, dp
, pp
;
2683 png_uint_32 sum
= 0, lmins
= mins
;
2688 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2689 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2692 png_uint_32 lmhi
, lmlo
;
2693 lmlo
= lmins
& PNG_LOMASK
;
2694 lmhi
= (lmins
>> PNG_HISHIFT
) & PNG_HIMASK
;
2696 for (j
= 0; j
< num_p_filters
; j
++)
2698 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_UP
)
2700 lmlo
= (lmlo
* png_ptr
->inv_filter_weights
[j
]) >>
2703 lmhi
= (lmhi
* png_ptr
->inv_filter_weights
[j
]) >>
2708 lmlo
= (lmlo
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_UP
]) >>
2711 lmhi
= (lmhi
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_UP
]) >>
2714 if (lmhi
> PNG_HIMASK
)
2718 lmins
= (lmhi
<< PNG_HISHIFT
) + lmlo
;
2722 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->up_row
+ 1,
2723 pp
= prev_row
+ 1; i
< row_bytes
; i
++)
2725 v
= *dp
++ = (png_byte
)(((int)*rp
++ - (int)*pp
++) & 0xff);
2727 sum
+= (v
< 128) ? v
: 256 - v
;
2729 if (sum
> lmins
) /* We are already worse, don't continue. */
2733 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2734 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2737 png_uint_32 sumhi
, sumlo
;
2738 sumlo
= sum
& PNG_LOMASK
;
2739 sumhi
= (sum
>> PNG_HISHIFT
) & PNG_HIMASK
;
2741 for (j
= 0; j
< num_p_filters
; j
++)
2743 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_UP
)
2745 sumlo
= (sumlo
* png_ptr
->filter_weights
[j
]) >>
2748 sumhi
= (sumhi
* png_ptr
->filter_weights
[j
]) >>
2753 sumlo
= (sumlo
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_UP
]) >>
2756 sumhi
= (sumhi
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_UP
]) >>
2759 if (sumhi
> PNG_HIMASK
)
2763 sum
= (sumhi
<< PNG_HISHIFT
) + sumlo
;
2770 best_row
= png_ptr
->up_row
;
2775 if (filter_to_do
== PNG_FILTER_AVG
)
2777 png_bytep rp
, dp
, pp
, lp
;
2780 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->avg_row
+ 1,
2781 pp
= prev_row
+ 1; i
< bpp
; i
++)
2783 *dp
++ = (png_byte
)(((int)*rp
++ - ((int)*pp
++ / 2)) & 0xff);
2786 for (lp
= row_buf
+ 1; i
< row_bytes
; i
++)
2788 *dp
++ = (png_byte
)(((int)*rp
++ - (((int)*pp
++ + (int)*lp
++) / 2))
2791 best_row
= png_ptr
->avg_row
;
2794 else if ((filter_to_do
& PNG_FILTER_AVG
) != 0)
2796 png_bytep rp
, dp
, pp
, lp
;
2797 png_uint_32 sum
= 0, lmins
= mins
;
2801 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2802 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2805 png_uint_32 lmhi
, lmlo
;
2806 lmlo
= lmins
& PNG_LOMASK
;
2807 lmhi
= (lmins
>> PNG_HISHIFT
) & PNG_HIMASK
;
2809 for (j
= 0; j
< num_p_filters
; j
++)
2811 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_AVG
)
2813 lmlo
= (lmlo
* png_ptr
->inv_filter_weights
[j
]) >>
2816 lmhi
= (lmhi
* png_ptr
->inv_filter_weights
[j
]) >>
2821 lmlo
= (lmlo
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_AVG
]) >>
2824 lmhi
= (lmhi
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_AVG
]) >>
2827 if (lmhi
> PNG_HIMASK
)
2831 lmins
= (lmhi
<< PNG_HISHIFT
) + lmlo
;
2835 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->avg_row
+ 1,
2836 pp
= prev_row
+ 1; i
< bpp
; i
++)
2838 v
= *dp
++ = (png_byte
)(((int)*rp
++ - ((int)*pp
++ / 2)) & 0xff);
2840 sum
+= (v
< 128) ? v
: 256 - v
;
2843 for (lp
= row_buf
+ 1; i
< row_bytes
; i
++)
2846 (png_byte
)(((int)*rp
++ - (((int)*pp
++ + (int)*lp
++) / 2)) & 0xff);
2848 sum
+= (v
< 128) ? v
: 256 - v
;
2850 if (sum
> lmins
) /* We are already worse, don't continue. */
2854 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2855 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2858 png_uint_32 sumhi
, sumlo
;
2859 sumlo
= sum
& PNG_LOMASK
;
2860 sumhi
= (sum
>> PNG_HISHIFT
) & PNG_HIMASK
;
2862 for (j
= 0; j
< num_p_filters
; j
++)
2864 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_NONE
)
2866 sumlo
= (sumlo
* png_ptr
->filter_weights
[j
]) >>
2869 sumhi
= (sumhi
* png_ptr
->filter_weights
[j
]) >>
2874 sumlo
= (sumlo
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_AVG
]) >>
2877 sumhi
= (sumhi
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_AVG
]) >>
2880 if (sumhi
> PNG_HIMASK
)
2884 sum
= (sumhi
<< PNG_HISHIFT
) + sumlo
;
2891 best_row
= png_ptr
->avg_row
;
2896 if ((filter_to_do
== PNG_FILTER_PAETH
) != 0)
2898 png_bytep rp
, dp
, pp
, cp
, lp
;
2901 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->paeth_row
+ 1,
2902 pp
= prev_row
+ 1; i
< bpp
; i
++)
2904 *dp
++ = (png_byte
)(((int)*rp
++ - (int)*pp
++) & 0xff);
2907 for (lp
= row_buf
+ 1, cp
= prev_row
+ 1; i
< row_bytes
; i
++)
2909 int a
, b
, c
, pa
, pb
, pc
, p
;
2923 pa
= p
< 0 ? -p
: p
;
2924 pb
= pc
< 0 ? -pc
: pc
;
2925 pc
= (p
+ pc
) < 0 ? -(p
+ pc
) : p
+ pc
;
2928 p
= (pa
<= pb
&& pa
<=pc
) ? a
: (pb
<= pc
) ? b
: c
;
2930 *dp
++ = (png_byte
)(((int)*rp
++ - p
) & 0xff);
2932 best_row
= png_ptr
->paeth_row
;
2935 else if ((filter_to_do
& PNG_FILTER_PAETH
) != 0)
2937 png_bytep rp
, dp
, pp
, cp
, lp
;
2938 png_uint_32 sum
= 0, lmins
= mins
;
2942 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2943 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
2946 png_uint_32 lmhi
, lmlo
;
2947 lmlo
= lmins
& PNG_LOMASK
;
2948 lmhi
= (lmins
>> PNG_HISHIFT
) & PNG_HIMASK
;
2950 for (j
= 0; j
< num_p_filters
; j
++)
2952 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_PAETH
)
2954 lmlo
= (lmlo
* png_ptr
->inv_filter_weights
[j
]) >>
2957 lmhi
= (lmhi
* png_ptr
->inv_filter_weights
[j
]) >>
2962 lmlo
= (lmlo
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_PAETH
]) >>
2965 lmhi
= (lmhi
* png_ptr
->inv_filter_costs
[PNG_FILTER_VALUE_PAETH
]) >>
2968 if (lmhi
> PNG_HIMASK
)
2972 lmins
= (lmhi
<< PNG_HISHIFT
) + lmlo
;
2976 for (i
= 0, rp
= row_buf
+ 1, dp
= png_ptr
->paeth_row
+ 1,
2977 pp
= prev_row
+ 1; i
< bpp
; i
++)
2979 v
= *dp
++ = (png_byte
)(((int)*rp
++ - (int)*pp
++) & 0xff);
2981 sum
+= (v
< 128) ? v
: 256 - v
;
2984 for (lp
= row_buf
+ 1, cp
= prev_row
+ 1; i
< row_bytes
; i
++)
2986 int a
, b
, c
, pa
, pb
, pc
, p
;
2992 #ifndef PNG_SLOW_PAETH
3000 pa
= p
< 0 ? -p
: p
;
3001 pb
= pc
< 0 ? -pc
: pc
;
3002 pc
= (p
+ pc
) < 0 ? -(p
+ pc
) : p
+ pc
;
3004 p
= (pa
<= pb
&& pa
<=pc
) ? a
: (pb
<= pc
) ? b
: c
;
3005 #else /* SLOW_PAETH */
3011 if (pa
<= pb
&& pa
<= pc
)
3019 #endif /* SLOW_PAETH */
3021 v
= *dp
++ = (png_byte
)(((int)*rp
++ - p
) & 0xff);
3023 sum
+= (v
< 128) ? v
: 256 - v
;
3025 if (sum
> lmins
) /* We are already worse, don't continue. */
3029 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
3030 if (png_ptr
->heuristic_method
== PNG_FILTER_HEURISTIC_WEIGHTED
)
3033 png_uint_32 sumhi
, sumlo
;
3034 sumlo
= sum
& PNG_LOMASK
;
3035 sumhi
= (sum
>> PNG_HISHIFT
) & PNG_HIMASK
;
3037 for (j
= 0; j
< num_p_filters
; j
++)
3039 if (png_ptr
->prev_filters
[j
] == PNG_FILTER_VALUE_PAETH
)
3041 sumlo
= (sumlo
* png_ptr
->filter_weights
[j
]) >>
3044 sumhi
= (sumhi
* png_ptr
->filter_weights
[j
]) >>
3049 sumlo
= (sumlo
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_PAETH
]) >>
3052 sumhi
= (sumhi
* png_ptr
->filter_costs
[PNG_FILTER_VALUE_PAETH
]) >>
3055 if (sumhi
> PNG_HIMASK
)
3059 sum
= (sumhi
<< PNG_HISHIFT
) + sumlo
;
3065 best_row
= png_ptr
->paeth_row
;
3068 #endif /* WRITE_FILTER */
3070 /* Do the actual writing of the filtered row data from the chosen filter. */
3071 png_write_filtered_row(png_ptr
, best_row
, row_info
->rowbytes
+1);
3073 #ifdef PNG_WRITE_FILTER_SUPPORTED
3074 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
3075 /* Save the type of filter we picked this time for future calculations */
3076 if (png_ptr
->num_prev_filters
> 0)
3080 for (j
= 1; j
< num_p_filters
; j
++)
3082 png_ptr
->prev_filters
[j
] = png_ptr
->prev_filters
[j
- 1];
3085 png_ptr
->prev_filters
[j
] = best_row
[0];
3088 #endif /* WRITE_FILTER */
3092 /* Do the actual writing of a previously filtered row. */
3094 png_write_filtered_row(png_structrp png_ptr
, png_bytep filtered_row
,
3095 png_size_t full_row_length
/*includes filter byte*/)
3097 png_debug(1, "in png_write_filtered_row");
3099 png_debug1(2, "filter = %d", filtered_row
[0]);
3101 png_compress_IDAT(png_ptr
, filtered_row
, full_row_length
, Z_NO_FLUSH
);
3103 /* Swap the current and previous rows */
3104 if (png_ptr
->prev_row
!= NULL
)
3108 tptr
= png_ptr
->prev_row
;
3109 png_ptr
->prev_row
= png_ptr
->row_buf
;
3110 png_ptr
->row_buf
= tptr
;
3113 /* Finish row - updates counters and flushes zlib if last row */
3114 png_write_finish_row(png_ptr
);
3116 #ifdef PNG_WRITE_FLUSH_SUPPORTED
3117 png_ptr
->flush_rows
++;
3119 if (png_ptr
->flush_dist
> 0 &&
3120 png_ptr
->flush_rows
>= png_ptr
->flush_dist
)
3122 png_write_flush(png_ptr
);
3124 #endif /* WRITE_FLUSH */
3127 #ifdef PNG_WRITE_APNG_SUPPORTED
3129 png_write_reset(png_structp png_ptr
)
3131 png_ptr
->row_number
= 0;
3133 png_ptr
->mode
&= ~PNG_HAVE_IDAT
;
3137 png_write_reinit(png_structp png_ptr
, png_infop info_ptr
,
3138 png_uint_32 width
, png_uint_32 height
)
3140 if (png_ptr
->num_frames_written
== 0 &&
3141 (width
!= png_ptr
->first_frame_width
||
3142 height
!= png_ptr
->first_frame_height
))
3143 png_error(png_ptr
, "width and/or height in the first frame's fcTL "
3144 "don't match the ones in IHDR");
3145 if (width
> png_ptr
->first_frame_width
||
3146 height
> png_ptr
->first_frame_height
)
3147 png_error(png_ptr
, "width and/or height for a frame greater than"
3148 "the ones in IHDR");
3150 png_set_IHDR(png_ptr
, info_ptr
, width
, height
,
3151 info_ptr
->bit_depth
, info_ptr
->color_type
,
3152 info_ptr
->interlace_type
, info_ptr
->compression_type
,
3153 info_ptr
->filter_type
);
3155 png_ptr
->width
= width
;
3156 png_ptr
->height
= height
;
3157 png_ptr
->rowbytes
= PNG_ROWBYTES(png_ptr
->pixel_depth
, width
);
3158 png_ptr
->usr_width
= png_ptr
->width
;
3160 #endif /* WRITE_APNG */