blob: c1751fe5aa5bbd5499f55b22ed1d421008b58ae3 [file] [log] [blame]
Guy Schalnat0d580581995-07-20 02:43:20 -05001
Andreas Dilger47a0c421997-05-16 02:46:07 -05002/* pngwutil.c - utilities to write a PNG file
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -06003 *
John Bowler9c04f572016-06-19 18:01:33 -05004 * Last changed in libpng 1.6.24 [(PENDING RELEASE)]
Glenn Randers-Pehrsonac43a872016-05-25 22:41:46 -05005 * Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson
Glenn Randers-Pehrsond4366722000-06-04 14:29:29 -05006 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
Glenn Randers-Pehrson3e61d792009-06-24 09:31:28 -05008 *
Glenn Randers-Pehrsonbfbf8652009-06-26 21:46:52 -05009 * This code is released under the libpng license.
Glenn Randers-Pehrsonc332bbc2009-06-25 13:43:50 -050010 * For conditions of distribution and use, see the disclaimer
Glenn Randers-Pehrson037023b2009-06-24 10:27:36 -050011 * and license in png.h
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -060012 */
Andreas Dilger47a0c421997-05-16 02:46:07 -050013
Glenn Randers-Pehrson9c90d7f2009-07-19 13:11:25 -050014#include "pngpriv.h"
Guy Schalnat0d580581995-07-20 02:43:20 -050015
Glenn Randers-Pehrsonc3cd22b2010-03-08 21:10:25 -060016#ifdef PNG_WRITE_SUPPORTED
17
Glenn Randers-Pehrson34713ce2010-04-28 07:49:28 -050018#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
Andreas Dilger47a0c421997-05-16 02:46:07 -050019/* 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.
22 */
Glenn Randers-Pehrson9c3ab682006-02-20 22:09:05 -060023void PNGAPI
Guy Schalnat6d764711995-12-19 03:22:19 -060024png_save_uint_32(png_bytep buf, png_uint_32 i)
Guy Schalnat0d580581995-07-20 02:43:20 -050025{
Glenn Randers-Pehrsonbaf301d2016-02-13 12:01:35 -060026 buf[0] = (png_byte)((i >> 24) & 0xffU);
27 buf[1] = (png_byte)((i >> 16) & 0xffU);
28 buf[2] = (png_byte)((i >> 8) & 0xffU);
29 buf[3] = (png_byte)( i & 0xffU);
Guy Schalnat0d580581995-07-20 02:43:20 -050030}
31
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -060032/* 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.
35 */
Glenn Randers-Pehrson9c3ab682006-02-20 22:09:05 -060036void PNGAPI
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -060037png_save_uint_16(png_bytep buf, unsigned int i)
Guy Schalnat0d580581995-07-20 02:43:20 -050038{
Glenn Randers-Pehrsonbaf301d2016-02-13 12:01:35 -060039 buf[0] = (png_byte)((i >> 8) & 0xffU);
40 buf[1] = (png_byte)( i & 0xffU);
Guy Schalnat0d580581995-07-20 02:43:20 -050041}
Glenn Randers-Pehrson34713ce2010-04-28 07:49:28 -050042#endif
Guy Schalnat0d580581995-07-20 02:43:20 -050043
Glenn Randers-Pehrson6bc53be2006-06-16 07:52:03 -050044/* 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.
49 */
Glenn Randers-Pehrson9c90d7f2009-07-19 13:11:25 -050050void PNGAPI
John Bowler5d567862011-12-24 09:12:00 -060051png_write_sig(png_structrp png_ptr)
Glenn Randers-Pehrson6bc53be2006-06-16 07:52:03 -050052{
53 png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -050054
Glenn Randers-Pehrson9c90d7f2009-07-19 13:11:25 -050055#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;
58#endif
59
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -050060 /* Write the rest of the 8 byte signature */
Glenn Randers-Pehrson6bc53be2006-06-16 07:52:03 -050061 png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -050062 (png_size_t)(8 - png_ptr->sig_bytes));
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -050063
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -050064 if (png_ptr->sig_bytes < 3)
Glenn Randers-Pehrson6bc53be2006-06-16 07:52:03 -050065 png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
66}
67
Andreas Dilger47a0c421997-05-16 02:46:07 -050068/* Write the start of a PNG chunk. The type is the chunk type.
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -060069 * The total_length is the sum of the lengths of all the data you will be
70 * passing in png_write_chunk_data().
71 */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -050072static void
John Bowler5d567862011-12-24 09:12:00 -060073png_write_chunk_header(png_structrp png_ptr, png_uint_32 chunk_name,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -060074 png_uint_32 length)
Guy Schalnat0d580581995-07-20 02:43:20 -050075{
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -050076 png_byte buf[8];
Andreas Dilger47a0c421997-05-16 02:46:07 -050077
Glenn Randers-Pehrson5b3b54e2011-10-12 06:36:56 -050078#if defined(PNG_DEBUG) && (PNG_DEBUG > 0)
Glenn Randers-Pehrsonba55c072011-10-11 21:21:37 -050079 PNG_CSTRING_FROM_CHUNK(buf, chunk_name);
80 png_debug2(0, "Writing %s chunk, length = %lu", buf, (unsigned long)length);
81#endif
Glenn Randers-Pehrsonda009802009-08-15 13:25:47 -050082
83 if (png_ptr == NULL)
84 return;
85
Glenn Randers-Pehrson9c90d7f2009-07-19 13:11:25 -050086#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.
89 */
90 png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;
91#endif
92
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -050093 /* Write the length and the chunk name */
Andreas Dilger47a0c421997-05-16 02:46:07 -050094 png_save_uint_32(buf, length);
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -050095 png_save_uint_32(buf + 4, chunk_name);
96 png_write_data(png_ptr, buf, 8);
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -050097
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -050098 /* Put the chunk name into png_ptr->chunk_name */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -050099 png_ptr->chunk_name = chunk_name;
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -0500100
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -0500101 /* Reset the crc and run it over the chunk name */
Guy Schalnat0d580581995-07-20 02:43:20 -0500102 png_reset_crc(png_ptr);
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -0500103
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -0500104 png_calculate_crc(png_ptr, buf + 4, 4);
Glenn Randers-Pehrson9c90d7f2009-07-19 13:11:25 -0500105
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.
109 */
110 png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA;
111#endif
Guy Schalnat0d580581995-07-20 02:43:20 -0500112}
113
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -0500114void PNGAPI
John Bowler5d567862011-12-24 09:12:00 -0600115png_write_chunk_start(png_structrp png_ptr, png_const_bytep chunk_string,
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -0500116 png_uint_32 length)
117{
118 png_write_chunk_header(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), length);
119}
120
121/* Write the data of a PNG chunk started with png_write_chunk_header().
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -0600122 * 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
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -0500124 * given to png_write_chunk_header().
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -0600125 */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -0500126void PNGAPI
John Bowler5d567862011-12-24 09:12:00 -0600127png_write_chunk_data(png_structrp png_ptr, png_const_bytep data,
Glenn Randers-Pehrsone600c512010-08-18 07:25:46 -0500128 png_size_t length)
Guy Schalnat0d580581995-07-20 02:43:20 -0500129{
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -0500130 /* Write the data, and run the CRC over it */
131 if (png_ptr == NULL)
132 return;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500133
Andreas Dilger47a0c421997-05-16 02:46:07 -0500134 if (data != NULL && length > 0)
Guy Schalnat0d580581995-07-20 02:43:20 -0500135 {
Guy Schalnat6d764711995-12-19 03:22:19 -0600136 png_write_data(png_ptr, data, length);
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -0500137
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -0500138 /* Update the CRC after writing the data,
Glenn Randers-Pehrson91e3a7d2014-10-03 17:16:00 -0500139 * in case the user I/O routine alters it.
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -0500140 */
141 png_calculate_crc(png_ptr, data, length);
Guy Schalnat0d580581995-07-20 02:43:20 -0500142 }
143}
144
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -0500145/* Finish a chunk started with png_write_chunk_header(). */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -0500146void PNGAPI
John Bowler5d567862011-12-24 09:12:00 -0600147png_write_chunk_end(png_structrp png_ptr)
Guy Schalnat0d580581995-07-20 02:43:20 -0500148{
Andreas Dilger47a0c421997-05-16 02:46:07 -0500149 png_byte buf[4];
150
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -0500151 if (png_ptr == NULL) return;
152
Glenn Randers-Pehrson9c90d7f2009-07-19 13:11:25 -0500153#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.
156 */
157 png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;
158#endif
159
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -0500160 /* Write the crc in a single operation */
Andreas Dilger47a0c421997-05-16 02:46:07 -0500161 png_save_uint_32(buf, png_ptr->crc);
Andreas Dilger47a0c421997-05-16 02:46:07 -0500162
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -0500163 png_write_data(png_ptr, buf, (png_size_t)4);
Guy Schalnat0d580581995-07-20 02:43:20 -0500164}
165
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -0500166/* 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()
173 * functions instead.
174 */
175static void
John Bowler5d567862011-12-24 09:12:00 -0600176png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name,
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -0500177 png_const_bytep data, png_size_t length)
178{
179 if (png_ptr == NULL)
180 return;
181
Glenn Randers-Pehrson8b83ff32015-08-13 20:57:18 -0500182 /* On 64-bit architectures 'length' may not fit in a png_uint_32. */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600183 if (length > PNG_UINT_31_MAX)
Glenn Randers-Pehrson91e3a7d2014-10-03 17:16:00 -0500184 png_error(png_ptr, "length exceeds PNG maximum");
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -0500185
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);
189}
190
191/* This is the API that calls the internal function above. */
192void PNGAPI
John Bowler5d567862011-12-24 09:12:00 -0600193png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string,
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -0500194 png_const_bytep data, png_size_t length)
195{
196 png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data,
197 length);
198}
199
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600200/* 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.)
203 */
204static png_alloc_size_t
205png_image_size(png_structrp png_ptr)
John Bowlerc5bef942011-05-05 17:35:39 -0500206{
Glenn Randers-Pehrson91e3a7d2014-10-03 17:16:00 -0500207 /* Only return sizes up to the maximum of a png_uint_32; do this by limiting
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600208 * the width and height used to 15 bits.
209 */
210 png_uint_32 h = png_ptr->height;
211
212 if (png_ptr->rowbytes < 32768 && h < 32768)
John Bowlerc5bef942011-05-05 17:35:39 -0500213 {
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500214 if (png_ptr->interlaced != 0)
John Bowlerc5bef942011-05-05 17:35:39 -0500215 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600216 /* Interlacing makes the image larger because of the replication of
217 * both the filter byte and the padding to a byte boundary.
218 */
219 png_uint_32 w = png_ptr->width;
220 unsigned int pd = png_ptr->pixel_depth;
221 png_alloc_size_t cb_base;
222 int pass;
John Bowlerc5bef942011-05-05 17:35:39 -0500223
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600224 for (cb_base=0, pass=0; pass<=6; ++pass)
John Bowlerc5bef942011-05-05 17:35:39 -0500225 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600226 png_uint_32 pw = PNG_PASS_COLS(w, pass);
227
228 if (pw > 0)
229 cb_base += (PNG_ROWBYTES(pd, pw)+1) * PNG_PASS_ROWS(h, pass);
John Bowlerc5bef942011-05-05 17:35:39 -0500230 }
231
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600232 return cb_base;
John Bowlerc5bef942011-05-05 17:35:39 -0500233 }
234
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600235 else
236 return (png_ptr->rowbytes+1) * h;
John Bowler42a2b552012-03-05 20:57:40 -0600237 }
238
239 else
Glenn Randers-Pehrsona8242fe2015-08-17 20:46:27 -0500240 return 0xffffffffU;
John Bowler42a2b552012-03-05 20:57:40 -0600241}
242
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600243#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
248 * compressed.)
249 */
John Bowler42a2b552012-03-05 20:57:40 -0600250static void
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600251optimize_cmf(png_bytep data, png_alloc_size_t data_size)
John Bowlerb5d00512012-03-09 09:15:18 -0600252{
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600253 /* Optimize the CMF field in the zlib stream. The resultant zlib stream is
254 * still compliant to the stream specification.
255 */
256 if (data_size <= 16384) /* else windowBits must be 15 */
John Bowlerb5d00512012-03-09 09:15:18 -0600257 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600258 unsigned int z_cmf = data[0]; /* zlib compression method and flags */
John Bowlerb5d00512012-03-09 09:15:18 -0600259
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600260 if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)
John Bowlerb5d00512012-03-09 09:15:18 -0600261 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600262 unsigned int z_cinfo;
263 unsigned int half_z_window_size;
John Bowlerb5d00512012-03-09 09:15:18 -0600264
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600265 z_cinfo = z_cmf >> 4;
266 half_z_window_size = 1U << (z_cinfo + 7);
267
268 if (data_size <= half_z_window_size) /* else no change */
John Bowlerb5d00512012-03-09 09:15:18 -0600269 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600270 unsigned int tmp;
John Bowlerb5d00512012-03-09 09:15:18 -0600271
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600272 do
273 {
274 half_z_window_size >>= 1;
275 --z_cinfo;
276 }
277 while (z_cinfo > 0 && data_size <= half_z_window_size);
John Bowlerb5d00512012-03-09 09:15:18 -0600278
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600279 z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
John Bowlerb5d00512012-03-09 09:15:18 -0600280
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -0500281 data[0] = (png_byte)z_cmf;
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600282 tmp = data[1] & 0xe0;
283 tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f;
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -0500284 data[1] = (png_byte)tmp;
John Bowlerb5d00512012-03-09 09:15:18 -0600285 }
John Bowler42a2b552012-03-05 20:57:40 -0600286 }
John Bowlerc5bef942011-05-05 17:35:39 -0500287 }
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600288}
Glenn Randers-Pehrsoncda68df2014-11-06 22:11:39 -0600289#endif /* WRITE_OPTIMIZE_CMF */
John Bowlerc5bef942011-05-05 17:35:39 -0500290
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600291/* Initialize the compressor for the appropriate type of compression. */
292static int
293png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
294 png_alloc_size_t data_size)
295{
296 if (png_ptr->zowner != 0)
297 {
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500298#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600299 char msg[64];
300
301 PNG_STRING_FROM_CHUNK(msg, owner);
302 msg[4] = ':';
303 msg[5] = ' ';
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
307 * are minimal.
308 */
309 (void)png_safecat(msg, (sizeof msg), 10, " using zstream");
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500310#endif
John Bowler8ee821e2015-05-06 20:03:14 -0500311#if PNG_RELEASE_BUILD
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600312 png_warning(png_ptr, msg);
313
314 /* Attempt sane error recovery */
315 if (png_ptr->zowner == png_IDAT) /* don't steal from IDAT */
316 {
317 png_ptr->zstream.msg = PNGZ_MSG_CAST("in use by IDAT");
318 return Z_STREAM_ERROR;
319 }
320
321 png_ptr->zowner = 0;
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500322#else
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600323 png_error(png_ptr, msg);
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500324#endif
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600325 }
326
327 {
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 */
334
335 if (owner == png_IDAT)
336 {
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500337 if ((png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY) != 0)
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600338 strategy = png_ptr->zlib_strategy;
339
340 else if (png_ptr->do_filter != PNG_FILTER_NONE)
341 strategy = PNG_Z_DEFAULT_STRATEGY;
342
343 else
344 strategy = PNG_Z_DEFAULT_NOFILTER_STRATEGY;
345 }
346
347 else
348 {
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500349#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600350 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;
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500355#else
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600356 /* 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.)
360 */
361 strategy = Z_DEFAULT_STRATEGY;
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500362#endif
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600363 }
364
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!)
371 */
372 if (data_size <= 16384)
373 {
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.
378 */
379 unsigned int half_window_size = 1U << (windowBits-1);
380
381 while (data_size + 262 <= half_window_size)
382 {
383 half_window_size >>= 1;
384 --windowBits;
385 }
386 }
387
388 /* Check against the previous initialized values, if any. */
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500389 if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0 &&
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600390 (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))
395 {
396 if (deflateEnd(&png_ptr->zstream) != Z_OK)
397 png_warning(png_ptr, "deflateEnd failed (ignored)");
398
399 png_ptr->flags &= ~PNG_FLAG_ZSTREAM_INITIALIZED;
400 }
401
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).
404 */
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;
409
410 /* Now initialize if required, setting the new parameters, otherwise just
411 * to a simple reset to the previous parameters.
412 */
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500413 if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600414 ret = deflateReset(&png_ptr->zstream);
415
416 else
417 {
418 ret = deflateInit2(&png_ptr->zstream, level, method, windowBits,
419 memLevel, strategy);
420
421 if (ret == Z_OK)
422 png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;
423 }
424
425 /* The return code is from either deflateReset or deflateInit2; they have
426 * pretty much the same set of error codes.
427 */
428 if (ret == Z_OK)
429 png_ptr->zowner = owner;
430
431 else
432 png_zstream_error(png_ptr, ret);
433
434 return ret;
435 }
436}
437
438/* Clean up (or trim) a linked list of compression buffers. */
439void /* PRIVATE */
440png_free_buffer_list(png_structrp png_ptr, png_compression_bufferp *listp)
441{
442 png_compression_bufferp list = *listp;
443
444 if (list != NULL)
445 {
446 *listp = NULL;
447
448 do
449 {
450 png_compression_bufferp next = list->next;
451
452 png_free(png_ptr, list);
453 list = next;
454 }
455 while (list != NULL);
456 }
John Bowler134c5762012-08-10 10:46:45 -0500457}
458
Glenn Randers-Pehrson205483d2011-04-01 12:33:42 -0500459#ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -0500460/* This pair of functions encapsulates the operation of (a) compressing a
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -0600461 * 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
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600463 * set up by the caller to allow access to the relevant local variables.
464 *
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.)
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -0600469 */
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -0600470typedef struct
471{
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600472 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 */
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -0600476} compression_state;
477
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600478static void
479png_text_compress_init(compression_state *comp, png_const_bytep input,
480 png_alloc_size_t input_len)
481{
482 comp->input = input;
483 comp->input_len = input_len;
484 comp->output_len = 0;
485}
486
487/* Compress the data in the compression state input */
488static int
489png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name,
490 compression_state *comp, png_uint_32 prefix_len)
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -0600491{
492 int ret;
493
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600494 /* To find the length of the output it is necessary to first compress the
Glenn Randers-Pehrson91e3a7d2014-10-03 17:16:00 -0500495 * input. The result is buffered rather than using the two-pass algorithm
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600496 * 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.
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600498 *
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600499 * 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
502 * approach.
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600503 */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600504 ret = png_deflate_claim(png_ptr, chunk_name, comp->input_len);
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600505
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600506 if (ret != Z_OK)
507 return ret;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600508
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600509 /* 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
513 * in size.
514 */
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600515 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600516 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;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600519
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600520 /* 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);
525
526 output_len = png_ptr->zstream.avail_out;
527
528 do
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600529 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600530 uInt avail_in = ZLIB_IO_MAX;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600531
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600532 if (avail_in > input_len)
533 avail_in = (uInt)input_len;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600534
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600535 input_len -= avail_in;
536
537 png_ptr->zstream.avail_in = avail_in;
538
539 if (png_ptr->zstream.avail_out == 0)
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600540 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600541 png_compression_buffer *next;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600542
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600543 /* Chunk data is limited to 2^31 bytes in length, so the prefix
544 * length must be counted here.
545 */
546 if (output_len + prefix_len > PNG_UINT_31_MAX)
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600547 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600548 ret = Z_MEM_ERROR;
549 break;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600550 }
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600551
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600552 /* Need a new (malloc'ed) buffer, but there may be one present
553 * already.
554 */
555 next = *end;
556 if (next == NULL)
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600557 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600558 next = png_voidcast(png_compression_bufferp, png_malloc_base
559 (png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600560
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600561 if (next == NULL)
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600562 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600563 ret = Z_MEM_ERROR;
564 break;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600565 }
566
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600567 /* Link in this buffer (so that it will be freed later) */
568 next->next = NULL;
569 *end = next;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600570 }
571
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600572 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;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600575
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600576 /* Move 'end' to the next buffer pointer. */
577 end = &next->next;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600578 }
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600579
580 /* Compress the data */
581 ret = deflate(&png_ptr->zstream,
582 input_len > 0 ? Z_NO_FLUSH : Z_FINISH);
583
584 /* Claw back input data that was not consumed (because avail_in is
585 * reset above every time round the loop).
586 */
587 input_len += png_ptr->zstream.avail_in;
588 png_ptr->zstream.avail_in = 0; /* safety */
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600589 }
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600590 while (ret == Z_OK);
591
Glenn Randers-Pehrson91e3a7d2014-10-03 17:16:00 -0500592 /* There may be some space left in the last output buffer. This needs to
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600593 * be subtracted from output_len.
594 */
595 output_len -= png_ptr->zstream.avail_out;
596 png_ptr->zstream.avail_out = 0; /* safety */
597 comp->output_len = output_len;
598
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
601 * something.
602 */
603 if (output_len + prefix_len >= PNG_UINT_31_MAX)
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600604 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600605 png_ptr->zstream.msg = PNGZ_MSG_CAST("compressed data too long");
606 ret = Z_MEM_ERROR;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600607 }
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600608
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600609 else
610 png_zstream_error(png_ptr, ret);
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600611
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600612 /* Reset zlib for another zTXt/iTXt or image data */
613 png_ptr->zowner = 0;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600614
Glenn Randers-Pehrson91e3a7d2014-10-03 17:16:00 -0500615 /* The only success case is Z_STREAM_END, input_len must be 0; if not this
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600616 * is an internal error.
617 */
618 if (ret == Z_STREAM_END && input_len == 0)
619 {
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500620#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600621 /* Fix up the deflate header, if required */
622 optimize_cmf(comp->output, comp->input_len);
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500623#endif
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600624 /* 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.)
627 */
628 return Z_OK;
629 }
630
631 else
632 return ret;
633 }
John Bowlerb5d00512012-03-09 09:15:18 -0600634}
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600635
636/* Ship the compressed text out via chunk writes */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600637static void
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600638png_write_compressed_data_out(png_structrp png_ptr, compression_state *comp)
639{
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600640 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;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600644
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600645 for (;;)
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600646 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600647 if (avail > output_len)
648 avail = output_len;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600649
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600650 png_write_chunk_data(png_ptr, output, avail);
651
652 output_len -= avail;
653
654 if (output_len == 0 || next == NULL)
655 break;
656
657 avail = png_ptr->zbuffer_size;
658 output = next->output;
659 next = next->next;
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600660 }
661
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600662 /* This is an internal error; 'next' must have been NULL! */
663 if (output_len > 0)
664 png_error(png_ptr, "error writing ancillary chunked compressed data");
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600665}
Glenn Randers-Pehrsoncda68df2014-11-06 22:11:39 -0600666#endif /* WRITE_COMPRESSED_TEXT */
John Bowlerb5d00512012-03-09 09:15:18 -0600667
Guy Schalnat0d580581995-07-20 02:43:20 -0500668/* Write the IHDR chunk, and update the png_struct with the necessary
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -0600669 * information. Note that the rest of this code depends upon this
670 * information being correct.
671 */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -0500672void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -0600673png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600674 int bit_depth, int color_type, int compression_type, int filter_type,
675 int interlace_type)
Guy Schalnat0d580581995-07-20 02:43:20 -0500676{
Glenn Randers-Pehrson4bb4d012009-05-20 12:45:29 -0500677 png_byte buf[13]; /* Buffer to store the IHDR info */
Guy Schalnat0d580581995-07-20 02:43:20 -0500678
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -0500679 png_debug(1, "in png_write_IHDR");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -0500680
Guy Schalnate5a37791996-06-05 15:50:50 -0500681 /* Check that we have valid input data from the application info */
682 switch (color_type)
683 {
Andreas Dilger47a0c421997-05-16 02:46:07 -0500684 case PNG_COLOR_TYPE_GRAY:
Guy Schalnate5a37791996-06-05 15:50:50 -0500685 switch (bit_depth)
686 {
687 case 1:
688 case 2:
689 case 4:
690 case 8:
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -0500691#ifdef PNG_WRITE_16BIT_SUPPORTED
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600692 case 16:
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -0500693#endif
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600694 png_ptr->channels = 1; break;
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -0500695
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600696 default:
697 png_error(png_ptr,
698 "Invalid bit depth for grayscale image");
Guy Schalnate5a37791996-06-05 15:50:50 -0500699 }
700 break;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500701
Andreas Dilger47a0c421997-05-16 02:46:07 -0500702 case PNG_COLOR_TYPE_RGB:
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -0500703#ifdef PNG_WRITE_16BIT_SUPPORTED
Guy Schalnate5a37791996-06-05 15:50:50 -0500704 if (bit_depth != 8 && bit_depth != 16)
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -0500705#else
706 if (bit_depth != 8)
707#endif
Guy Schalnate5a37791996-06-05 15:50:50 -0500708 png_error(png_ptr, "Invalid bit depth for RGB image");
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500709
Guy Schalnate5a37791996-06-05 15:50:50 -0500710 png_ptr->channels = 3;
711 break;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500712
Andreas Dilger47a0c421997-05-16 02:46:07 -0500713 case PNG_COLOR_TYPE_PALETTE:
Guy Schalnate5a37791996-06-05 15:50:50 -0500714 switch (bit_depth)
715 {
716 case 1:
717 case 2:
718 case 4:
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600719 case 8:
720 png_ptr->channels = 1;
721 break;
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -0500722
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600723 default:
724 png_error(png_ptr, "Invalid bit depth for paletted image");
Guy Schalnate5a37791996-06-05 15:50:50 -0500725 }
726 break;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500727
Andreas Dilger47a0c421997-05-16 02:46:07 -0500728 case PNG_COLOR_TYPE_GRAY_ALPHA:
Guy Schalnate5a37791996-06-05 15:50:50 -0500729 if (bit_depth != 8 && bit_depth != 16)
730 png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500731
Guy Schalnate5a37791996-06-05 15:50:50 -0500732 png_ptr->channels = 2;
733 break;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500734
Andreas Dilger47a0c421997-05-16 02:46:07 -0500735 case PNG_COLOR_TYPE_RGB_ALPHA:
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -0500736#ifdef PNG_WRITE_16BIT_SUPPORTED
Guy Schalnate5a37791996-06-05 15:50:50 -0500737 if (bit_depth != 8 && bit_depth != 16)
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -0500738#else
739 if (bit_depth != 8)
740#endif
Guy Schalnate5a37791996-06-05 15:50:50 -0500741 png_error(png_ptr, "Invalid bit depth for RGBA image");
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500742
Guy Schalnate5a37791996-06-05 15:50:50 -0500743 png_ptr->channels = 4;
744 break;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500745
Guy Schalnate5a37791996-06-05 15:50:50 -0500746 default:
747 png_error(png_ptr, "Invalid image color type specified");
748 }
749
Andreas Dilger47a0c421997-05-16 02:46:07 -0500750 if (compression_type != PNG_COMPRESSION_TYPE_BASE)
Guy Schalnate5a37791996-06-05 15:50:50 -0500751 {
752 png_warning(png_ptr, "Invalid compression type specified");
Andreas Dilger47a0c421997-05-16 02:46:07 -0500753 compression_type = PNG_COMPRESSION_TYPE_BASE;
Guy Schalnate5a37791996-06-05 15:50:50 -0500754 }
755
Glenn Randers-Pehrson408b4212000-12-18 09:33:57 -0600756 /* Write filter_method 64 (intrapixel differencing) only if
757 * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
758 * 2. Libpng did not write a PNG signature (this filter_method is only
759 * used in PNG datastreams that are embedded in MNG datastreams) and
760 * 3. The application called png_permit_mng_features with a mask that
761 * included PNG_FLAG_MNG_FILTER_64 and
762 * 4. The filter_method is 64 and
763 * 5. The color_type is RGB or RGBA
764 */
Glenn Randers-Pehrson2ad31ae2000-12-15 08:54:42 -0600765 if (
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -0500766#ifdef PNG_MNG_FEATURES_SUPPORTED
Glenn Randers-Pehrsonb963fee2014-11-01 13:18:36 -0500767 !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
768 ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600769 (color_type == PNG_COLOR_TYPE_RGB ||
770 color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
771 (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&
Glenn Randers-Pehrson2ad31ae2000-12-15 08:54:42 -0600772#endif
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600773 filter_type != PNG_FILTER_TYPE_BASE)
Guy Schalnate5a37791996-06-05 15:50:50 -0500774 {
775 png_warning(png_ptr, "Invalid filter type specified");
Andreas Dilger47a0c421997-05-16 02:46:07 -0500776 filter_type = PNG_FILTER_TYPE_BASE;
Guy Schalnate5a37791996-06-05 15:50:50 -0500777 }
778
Glenn Randers-Pehrson46f61e21998-01-30 21:45:12 -0600779#ifdef PNG_WRITE_INTERLACING_SUPPORTED
Andreas Dilger47a0c421997-05-16 02:46:07 -0500780 if (interlace_type != PNG_INTERLACE_NONE &&
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500781 interlace_type != PNG_INTERLACE_ADAM7)
Guy Schalnate5a37791996-06-05 15:50:50 -0500782 {
783 png_warning(png_ptr, "Invalid interlace type specified");
Andreas Dilger47a0c421997-05-16 02:46:07 -0500784 interlace_type = PNG_INTERLACE_ADAM7;
Guy Schalnate5a37791996-06-05 15:50:50 -0500785 }
Glenn Randers-Pehrson46f61e21998-01-30 21:45:12 -0600786#else
787 interlace_type=PNG_INTERLACE_NONE;
788#endif
Guy Schalnate5a37791996-06-05 15:50:50 -0500789
Glenn Randers-Pehrson7011a8c2015-02-27 18:53:44 -0600790 /* Save the relevant information */
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -0500791 png_ptr->bit_depth = (png_byte)bit_depth;
792 png_ptr->color_type = (png_byte)color_type;
793 png_ptr->interlaced = (png_byte)interlace_type;
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -0500794#ifdef PNG_MNG_FEATURES_SUPPORTED
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -0500795 png_ptr->filter_type = (png_byte)filter_type;
Glenn Randers-Pehrson8b6a8892001-05-18 04:54:50 -0500796#endif
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -0500797 png_ptr->compression_type = (png_byte)compression_type;
Guy Schalnate5a37791996-06-05 15:50:50 -0500798 png_ptr->width = width;
799 png_ptr->height = height;
800
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -0500801 png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
Glenn Randers-Pehrson272489d2004-08-04 06:34:52 -0500802 png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);
Glenn Randers-Pehrson4bb4d012009-05-20 12:45:29 -0500803 /* Set the usr info, so any transformations can modify it */
Guy Schalnate5a37791996-06-05 15:50:50 -0500804 png_ptr->usr_width = png_ptr->width;
805 png_ptr->usr_bit_depth = png_ptr->bit_depth;
806 png_ptr->usr_channels = png_ptr->channels;
807
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -0500808 /* Pack the header information into the buffer */
Guy Schalnat0d580581995-07-20 02:43:20 -0500809 png_save_uint_32(buf, width);
810 png_save_uint_32(buf + 4, height);
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -0500811 buf[8] = (png_byte)bit_depth;
812 buf[9] = (png_byte)color_type;
813 buf[10] = (png_byte)compression_type;
814 buf[11] = (png_byte)filter_type;
815 buf[12] = (png_byte)interlace_type;
Guy Schalnat0d580581995-07-20 02:43:20 -0500816
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -0500817 /* Write the chunk */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -0500818 png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
Guy Schalnat51f0eb41995-09-26 05:22:39 -0500819
Glenn Randers-Pehrson05670152014-03-08 12:39:52 -0600820 if ((png_ptr->do_filter) == PNG_NO_FILTERS)
Guy Schalnat51f0eb41995-09-26 05:22:39 -0500821 {
Andreas Dilger47a0c421997-05-16 02:46:07 -0500822 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600823 png_ptr->bit_depth < 8)
Guy Schalnate5a37791996-06-05 15:50:50 -0500824 png_ptr->do_filter = PNG_FILTER_NONE;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500825
Guy Schalnat51f0eb41995-09-26 05:22:39 -0500826 else
Guy Schalnate5a37791996-06-05 15:50:50 -0500827 png_ptr->do_filter = PNG_ALL_FILTERS;
Guy Schalnat51f0eb41995-09-26 05:22:39 -0500828 }
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -0500829
Glenn Randers-Pehrsonf8378312011-03-31 22:06:04 -0500830 png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */
Guy Schalnat0d580581995-07-20 02:43:20 -0500831}
832
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -0500833/* Write the palette. We are careful not to trust png_color to be in the
Glenn Randers-Pehrson345bc271998-06-14 14:43:31 -0500834 * correct order for PNG, so people can redefine it to any convenient
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -0600835 * structure.
836 */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -0500837void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -0600838png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,
Glenn Randers-Pehrsone600c512010-08-18 07:25:46 -0500839 png_uint_32 num_pal)
Guy Schalnat0d580581995-07-20 02:43:20 -0500840{
Glenn Randers-Pehrsona901eb32015-10-30 07:57:49 -0500841 png_uint_32 max_palette_length, i;
Glenn Randers-Pehrsone600c512010-08-18 07:25:46 -0500842 png_const_colorp pal_ptr;
Guy Schalnat0d580581995-07-20 02:43:20 -0500843 png_byte buf[3];
844
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -0500845 png_debug(1, "in png_write_PLTE");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -0500846
Glenn Randers-Pehrsona901eb32015-10-30 07:57:49 -0500847 max_palette_length = (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ?
Glenn Randers-Pehrson81f44662015-10-29 09:26:41 -0500848 (1 << png_ptr->bit_depth) : PNG_MAX_PALETTE_LENGTH;
849
Glenn Randers-Pehrson4393a9a1999-09-17 12:27:26 -0500850 if ((
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -0500851#ifdef PNG_MNG_FEATURES_SUPPORTED
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500852 (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0 &&
Glenn Randers-Pehrson4393a9a1999-09-17 12:27:26 -0500853#endif
Glenn Randers-Pehrsona901eb32015-10-30 07:57:49 -0500854 num_pal == 0) || num_pal > max_palette_length)
Glenn Randers-Pehrson3097f612001-05-07 14:52:45 -0500855 {
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600856 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
857 {
858 png_error(png_ptr, "Invalid number of colors in palette");
859 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500860
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600861 else
862 {
863 png_warning(png_ptr, "Invalid number of colors in palette");
864 return;
865 }
Glenn Randers-Pehrson3097f612001-05-07 14:52:45 -0500866 }
867
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500868 if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
Glenn Randers-Pehrson3097f612001-05-07 14:52:45 -0500869 {
870 png_warning(png_ptr,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -0600871 "Ignoring request to write a PLTE chunk in grayscale PNG");
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500872
Glenn Randers-Pehrson3097f612001-05-07 14:52:45 -0500873 return;
Guy Schalnate5a37791996-06-05 15:50:50 -0500874 }
875
Andreas Dilger47a0c421997-05-16 02:46:07 -0500876 png_ptr->num_palette = (png_uint_16)num_pal;
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -0500877 png_debug1(3, "num_palette = %d", png_ptr->num_palette);
Guy Schalnate5a37791996-06-05 15:50:50 -0500878
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -0500879 png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3));
Glenn Randers-Pehrsondbd40142009-08-31 08:42:02 -0500880#ifdef PNG_POINTER_INDEXING_SUPPORTED
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500881
Andreas Dilger47a0c421997-05-16 02:46:07 -0500882 for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
Guy Schalnat0d580581995-07-20 02:43:20 -0500883 {
884 buf[0] = pal_ptr->red;
885 buf[1] = pal_ptr->green;
886 buf[2] = pal_ptr->blue;
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -0500887 png_write_chunk_data(png_ptr, buf, (png_size_t)3);
Guy Schalnat0d580581995-07-20 02:43:20 -0500888 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500889
Glenn Randers-Pehrsond4366722000-06-04 14:29:29 -0500890#else
Glenn Randers-Pehrsone3f3c4e2010-02-07 18:08:50 -0600891 /* This is a little slower but some buggy compilers need to do this
892 * instead
893 */
Glenn Randers-Pehrsond4366722000-06-04 14:29:29 -0500894 pal_ptr=palette;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500895
Glenn Randers-Pehrsond4366722000-06-04 14:29:29 -0500896 for (i = 0; i < num_pal; i++)
897 {
898 buf[0] = pal_ptr[i].red;
899 buf[1] = pal_ptr[i].green;
900 buf[2] = pal_ptr[i].blue;
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -0500901 png_write_chunk_data(png_ptr, buf, (png_size_t)3);
Glenn Randers-Pehrsond4366722000-06-04 14:29:29 -0500902 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -0500903
Glenn Randers-Pehrsond4366722000-06-04 14:29:29 -0500904#endif
Guy Schalnat0d580581995-07-20 02:43:20 -0500905 png_write_chunk_end(png_ptr);
Guy Schalnate5a37791996-06-05 15:50:50 -0500906 png_ptr->mode |= PNG_HAVE_PLTE;
Guy Schalnat0d580581995-07-20 02:43:20 -0500907}
908
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600909/* This is similar to png_text_compress, above, except that it does not require
910 * all of the data at once and, instead of buffering the compressed result,
911 * writes it as IDAT chunks. Unlike png_text_compress it *can* png_error out
912 * because it calls the write interface. As a result it does its own error
913 * reporting and does not return an error code. In the event of error it will
914 * just call png_error. The input data length may exceed 32-bits. The 'flush'
915 * parameter is exactly the same as that to deflate, with the following
916 * meanings:
917 *
918 * Z_NO_FLUSH: normal incremental output of compressed data
919 * Z_SYNC_FLUSH: do a SYNC_FLUSH, used by png_write_flush
920 * Z_FINISH: this is the end of the input, do a Z_FINISH and clean up
921 *
922 * The routine manages the acquire and release of the png_ptr->zstream by
Glenn Randers-Pehrson91e3a7d2014-10-03 17:16:00 -0500923 * checking and (at the end) clearing png_ptr->zowner; it does some sanity
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600924 * checks on the 'mode' flags while doing this.
925 */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -0500926void /* PRIVATE */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600927png_compress_IDAT(png_structrp png_ptr, png_const_bytep input,
928 png_alloc_size_t input_len, int flush)
Guy Schalnat0d580581995-07-20 02:43:20 -0500929{
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600930 if (png_ptr->zowner != png_IDAT)
Glenn Randers-Pehrson5b779162004-09-04 13:25:08 -0500931 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600932 /* First time. Ensure we have a temporary buffer for compression and
933 * trim the buffer list if it has more than one entry to free memory.
934 * If 'WRITE_COMPRESSED_TEXT' is not set the list will never have been
935 * created at this point, but the check here is quick and safe.
Glenn Randers-Pehrsonec8296a2011-04-01 15:09:05 -0500936 */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600937 if (png_ptr->zbuffer_list == NULL)
Glenn Randers-Pehrson5b779162004-09-04 13:25:08 -0500938 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600939 png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp,
940 png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
941 png_ptr->zbuffer_list->next = NULL;
John Bowlerb5d00512012-03-09 09:15:18 -0600942 }
943
John Bowlerb5d00512012-03-09 09:15:18 -0600944 else
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600945 png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list->next);
946
947 /* It is a terminal error if we can't claim the zstream. */
948 if (png_deflate_claim(png_ptr, png_IDAT, png_image_size(png_ptr)) != Z_OK)
949 png_error(png_ptr, png_ptr->zstream.msg);
950
951 /* The output state is maintained in png_ptr->zstream, so it must be
952 * initialized here after the claim.
953 */
954 png_ptr->zstream.next_out = png_ptr->zbuffer_list->output;
955 png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
John Bowlerb5d00512012-03-09 09:15:18 -0600956 }
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600957
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600958 /* Now loop reading and writing until all the input is consumed or an error
959 * terminates the operation. The _out values are maintained across calls to
960 * this function, but the input must be reset each time.
Glenn Randers-Pehrsonf3af7062012-02-02 23:11:45 -0600961 */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600962 png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input);
963 png_ptr->zstream.avail_in = 0; /* set below */
964 for (;;)
965 {
966 int ret;
967
968 /* INPUT: from the row data */
969 uInt avail = ZLIB_IO_MAX;
970
971 if (avail > input_len)
972 avail = (uInt)input_len; /* safe because of the check */
973
974 png_ptr->zstream.avail_in = avail;
975 input_len -= avail;
976
977 ret = deflate(&png_ptr->zstream, input_len > 0 ? Z_NO_FLUSH : flush);
978
979 /* Include as-yet unconsumed input */
980 input_len += png_ptr->zstream.avail_in;
981 png_ptr->zstream.avail_in = 0;
982
Glenn Randers-Pehrson91e3a7d2014-10-03 17:16:00 -0500983 /* OUTPUT: write complete IDAT chunks when avail_out drops to zero. Note
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600984 * that these two zstream fields are preserved across the calls, therefore
985 * there is no need to set these up on entry to the loop.
986 */
987 if (png_ptr->zstream.avail_out == 0)
988 {
989 png_bytep data = png_ptr->zbuffer_list->output;
990 uInt size = png_ptr->zbuffer_size;
991
992 /* Write an IDAT containing the data then reset the buffer. The
993 * first IDAT may need deflate header optimization.
994 */
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500995#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
996 if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 &&
997 png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -0600998 optimize_cmf(data, png_image_size(png_ptr));
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -0500999#endif
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001000
1001 png_write_complete_chunk(png_ptr, png_IDAT, data, size);
1002 png_ptr->mode |= PNG_HAVE_IDAT;
1003
1004 png_ptr->zstream.next_out = data;
1005 png_ptr->zstream.avail_out = size;
1006
1007 /* For SYNC_FLUSH or FINISH it is essential to keep calling zlib with
1008 * the same flush parameter until it has finished output, for NO_FLUSH
1009 * it doesn't matter.
1010 */
1011 if (ret == Z_OK && flush != Z_NO_FLUSH)
1012 continue;
1013 }
1014
Glenn Randers-Pehrson91e3a7d2014-10-03 17:16:00 -05001015 /* The order of these checks doesn't matter much; it just affects which
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001016 * possible error might be detected if multiple things go wrong at once.
1017 */
1018 if (ret == Z_OK) /* most likely return code! */
1019 {
1020 /* If all the input has been consumed then just return. If Z_FINISH
1021 * was used as the flush parameter something has gone wrong if we get
1022 * here.
1023 */
1024 if (input_len == 0)
1025 {
1026 if (flush == Z_FINISH)
1027 png_error(png_ptr, "Z_OK on Z_FINISH with output space");
1028
1029 return;
1030 }
1031 }
1032
1033 else if (ret == Z_STREAM_END && flush == Z_FINISH)
1034 {
1035 /* This is the end of the IDAT data; any pending output must be
1036 * flushed. For small PNG files we may still be at the beginning.
1037 */
1038 png_bytep data = png_ptr->zbuffer_list->output;
1039 uInt size = png_ptr->zbuffer_size - png_ptr->zstream.avail_out;
1040
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05001041#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
1042 if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 &&
1043 png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
1044 optimize_cmf(data, png_image_size(png_ptr));
1045#endif
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001046
1047 png_write_complete_chunk(png_ptr, png_IDAT, data, size);
1048 png_ptr->zstream.avail_out = 0;
1049 png_ptr->zstream.next_out = NULL;
1050 png_ptr->mode |= PNG_HAVE_IDAT | PNG_AFTER_IDAT;
1051
1052 png_ptr->zowner = 0; /* Release the stream */
1053 return;
1054 }
1055
1056 else
1057 {
1058 /* This is an error condition. */
1059 png_zstream_error(png_ptr, ret);
1060 png_error(png_ptr, png_ptr->zstream.msg);
1061 }
1062 }
Guy Schalnat0d580581995-07-20 02:43:20 -05001063}
1064
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001065/* Write an IEND chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001066void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001067png_write_IEND(png_structrp png_ptr)
Guy Schalnat0d580581995-07-20 02:43:20 -05001068{
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001069 png_debug(1, "in png_write_IEND");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001070
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001071 png_write_complete_chunk(png_ptr, png_IEND, NULL, (png_size_t)0);
Andreas Dilger02ad0ef1997-01-17 01:34:35 -06001072 png_ptr->mode |= PNG_HAVE_IEND;
Guy Schalnat0d580581995-07-20 02:43:20 -05001073}
1074
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001075#ifdef PNG_WRITE_gAMA_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001076/* Write a gAMA chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001077void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001078png_write_gAMA_fixed(png_structrp png_ptr, png_fixed_point file_gamma)
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001079{
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001080 png_byte buf[4];
1081
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001082 png_debug(1, "in png_write_gAMA");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001083
Glenn Randers-Pehrson626afd62009-08-20 22:52:51 -05001084 /* file_gamma is saved in 1/100,000ths */
Glenn Randers-Pehrsonb1828932001-06-23 08:03:17 -05001085 png_save_uint_32(buf, (png_uint_32)file_gamma);
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001086 png_write_complete_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001087}
1088#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05001089
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001090#ifdef PNG_WRITE_sRGB_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001091/* Write a sRGB chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001092void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001093png_write_sRGB(png_structrp png_ptr, int srgb_intent)
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -06001094{
1095 png_byte buf[1];
1096
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001097 png_debug(1, "in png_write_sRGB");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001098
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -05001099 if (srgb_intent >= PNG_sRGB_INTENT_LAST)
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001100 png_warning(png_ptr,
1101 "Invalid sRGB rendering intent specified");
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001102
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05001103 buf[0]=(png_byte)srgb_intent;
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001104 png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -06001105}
1106#endif
1107
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001108#ifdef PNG_WRITE_iCCP_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001109/* Write an iCCP chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001110void /* PRIVATE */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001111png_write_iCCP(png_structrp png_ptr, png_const_charp name,
1112 png_const_bytep profile)
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001113{
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001114 png_uint_32 name_len;
1115 png_uint_32 profile_len;
1116 png_byte new_name[81]; /* 1 byte for the compression byte */
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001117 compression_state comp;
Glenn Randers-Pehrsonab9736a2014-04-25 06:14:50 -05001118 png_uint_32 temp;
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001119
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001120 png_debug(1, "in png_write_iCCP");
Glenn Randers-Pehrson9c3ab682006-02-20 22:09:05 -06001121
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001122 /* These are all internal problems: the profile should have been checked
1123 * before when it was stored.
1124 */
John Bowlercf499192012-03-01 21:54:07 -06001125 if (profile == NULL)
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001126 png_error(png_ptr, "No profile for iCCP chunk"); /* internal error */
John Bowlerb11b31a2012-03-21 07:55:46 -05001127
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001128 profile_len = png_get_uint_32(profile);
John Bowlercf499192012-03-01 21:54:07 -06001129
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001130 if (profile_len < 132)
1131 png_error(png_ptr, "ICC profile too short");
1132
Glenn Randers-Pehrsonab9736a2014-04-25 06:14:50 -05001133 temp = (png_uint_32) (*(profile+8));
1134 if (temp > 3 && (profile_len & 0x03))
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001135 png_error(png_ptr, "ICC profile length invalid (not a multiple of 4)");
1136
John Bowlercf499192012-03-01 21:54:07 -06001137 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001138 png_uint_32 embedded_profile_len = png_get_uint_32(profile);
John Bowlerb5d00512012-03-09 09:15:18 -06001139
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001140 if (profile_len != embedded_profile_len)
1141 png_error(png_ptr, "Profile length does not match profile");
John Bowlercf499192012-03-01 21:54:07 -06001142 }
1143
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001144 name_len = png_check_keyword(png_ptr, name, new_name);
John Bowlercf499192012-03-01 21:54:07 -06001145
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001146 if (name_len == 0)
1147 png_error(png_ptr, "iCCP: invalid keyword");
Glenn Randers-Pehrson9c3ab682006-02-20 22:09:05 -06001148
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001149 new_name[++name_len] = PNG_COMPRESSION_TYPE_BASE;
Glenn Randers-Pehrson3a054e12009-08-01 08:53:23 -05001150
Glenn Randers-Pehrson4bb4d012009-05-20 12:45:29 -05001151 /* Make sure we include the NULL after the name and the compression type */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001152 ++name_len;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001153
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001154 png_text_compress_init(&comp, profile, profile_len);
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001155
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001156 /* Allow for keyword terminator and compression byte */
1157 if (png_text_compress(png_ptr, png_iCCP, &comp, name_len) != Z_OK)
1158 png_error(png_ptr, png_ptr->zstream.msg);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001159
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001160 png_write_chunk_header(png_ptr, png_iCCP, name_len + comp.output_len);
1161
1162 png_write_chunk_data(png_ptr, new_name, name_len);
1163
1164 png_write_compressed_data_out(png_ptr, &comp);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001165
1166 png_write_chunk_end(png_ptr);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001167}
1168#endif
1169
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001170#ifdef PNG_WRITE_sPLT_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001171/* Write a sPLT chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001172void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001173png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001174{
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001175 png_uint_32 name_len;
1176 png_byte new_name[80];
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001177 png_byte entrybuf[10];
Glenn Randers-Pehrson9c90d7f2009-07-19 13:11:25 -05001178 png_size_t entry_size = (spalette->depth == 8 ? 6 : 10);
1179 png_size_t palette_size = entry_size * spalette->nentries;
Glenn Randers-Pehrson520a7642000-03-21 05:13:06 -06001180 png_sPLT_entryp ep;
Glenn Randers-Pehrsondbd40142009-08-31 08:42:02 -05001181#ifndef PNG_POINTER_INDEXING_SUPPORTED
Glenn Randers-Pehrsond4366722000-06-04 14:29:29 -05001182 int i;
1183#endif
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001184
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001185 png_debug(1, "in png_write_sPLT");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001186
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001187 name_len = png_check_keyword(png_ptr, spalette->name, new_name);
1188
1189 if (name_len == 0)
1190 png_error(png_ptr, "sPLT: invalid keyword");
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001191
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001192 /* Make sure we include the NULL after the name */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001193 png_write_chunk_header(png_ptr, png_sPLT,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001194 (png_uint_32)(name_len + 2 + palette_size));
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001195
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -05001196 png_write_chunk_data(png_ptr, (png_bytep)new_name,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001197 (png_size_t)(name_len + 1));
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001198
Glenn Randers-Pehrsone600c512010-08-18 07:25:46 -05001199 png_write_chunk_data(png_ptr, &spalette->depth, (png_size_t)1);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001200
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001201 /* Loop through each palette entry, writing appropriately */
Glenn Randers-Pehrsondbd40142009-08-31 08:42:02 -05001202#ifdef PNG_POINTER_INDEXING_SUPPORTED
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -05001203 for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001204 {
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001205 if (spalette->depth == 8)
1206 {
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05001207 entrybuf[0] = (png_byte)ep->red;
1208 entrybuf[1] = (png_byte)ep->green;
1209 entrybuf[2] = (png_byte)ep->blue;
1210 entrybuf[3] = (png_byte)ep->alpha;
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001211 png_save_uint_16(entrybuf + 4, ep->frequency);
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001212 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001213
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001214 else
1215 {
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001216 png_save_uint_16(entrybuf + 0, ep->red);
1217 png_save_uint_16(entrybuf + 2, ep->green);
1218 png_save_uint_16(entrybuf + 4, ep->blue);
1219 png_save_uint_16(entrybuf + 6, ep->alpha);
1220 png_save_uint_16(entrybuf + 8, ep->frequency);
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001221 }
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001222
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001223 png_write_chunk_data(png_ptr, entrybuf, entry_size);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001224 }
Glenn Randers-Pehrsond4366722000-06-04 14:29:29 -05001225#else
1226 ep=spalette->entries;
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001227 for (i = 0; i>spalette->nentries; i++)
Glenn Randers-Pehrsond4366722000-06-04 14:29:29 -05001228 {
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001229 if (spalette->depth == 8)
1230 {
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05001231 entrybuf[0] = (png_byte)ep[i].red;
1232 entrybuf[1] = (png_byte)ep[i].green;
1233 entrybuf[2] = (png_byte)ep[i].blue;
1234 entrybuf[3] = (png_byte)ep[i].alpha;
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001235 png_save_uint_16(entrybuf + 4, ep[i].frequency);
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001236 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001237
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001238 else
1239 {
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001240 png_save_uint_16(entrybuf + 0, ep[i].red);
1241 png_save_uint_16(entrybuf + 2, ep[i].green);
1242 png_save_uint_16(entrybuf + 4, ep[i].blue);
1243 png_save_uint_16(entrybuf + 6, ep[i].alpha);
1244 png_save_uint_16(entrybuf + 8, ep[i].frequency);
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001245 }
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001246
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001247 png_write_chunk_data(png_ptr, entrybuf, entry_size);
Glenn Randers-Pehrsond4366722000-06-04 14:29:29 -05001248 }
1249#endif
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001250
1251 png_write_chunk_end(png_ptr);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001252}
1253#endif
1254
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001255#ifdef PNG_WRITE_sBIT_SUPPORTED
Glenn Randers-Pehrson4bb4d012009-05-20 12:45:29 -05001256/* Write the sBIT chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001257void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001258png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type)
Guy Schalnat0d580581995-07-20 02:43:20 -05001259{
1260 png_byte buf[4];
Andreas Dilger47a0c421997-05-16 02:46:07 -05001261 png_size_t size;
Guy Schalnat0d580581995-07-20 02:43:20 -05001262
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001263 png_debug(1, "in png_write_sBIT");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001264
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001265 /* Make sure we don't depend upon the order of PNG_COLOR_8 */
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05001266 if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
Guy Schalnat0d580581995-07-20 02:43:20 -05001267 {
Glenn Randers-Pehrson0f881d61998-02-07 10:20:57 -06001268 png_byte maxbits;
Guy Schalnate5a37791996-06-05 15:50:50 -05001269
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05001270 maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
1271 png_ptr->usr_bit_depth);
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001272
Glenn Randers-Pehrson5c6aeb21998-12-29 11:47:59 -06001273 if (sbit->red == 0 || sbit->red > maxbits ||
1274 sbit->green == 0 || sbit->green > maxbits ||
Guy Schalnate5a37791996-06-05 15:50:50 -05001275 sbit->blue == 0 || sbit->blue > maxbits)
1276 {
1277 png_warning(png_ptr, "Invalid sBIT depth specified");
1278 return;
1279 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001280
Guy Schalnat0d580581995-07-20 02:43:20 -05001281 buf[0] = sbit->red;
1282 buf[1] = sbit->green;
1283 buf[2] = sbit->blue;
1284 size = 3;
1285 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001286
Guy Schalnat0d580581995-07-20 02:43:20 -05001287 else
1288 {
Guy Schalnate5a37791996-06-05 15:50:50 -05001289 if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)
1290 {
1291 png_warning(png_ptr, "Invalid sBIT depth specified");
1292 return;
1293 }
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001294
Guy Schalnat0d580581995-07-20 02:43:20 -05001295 buf[0] = sbit->gray;
1296 size = 1;
1297 }
1298
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05001299 if ((color_type & PNG_COLOR_MASK_ALPHA) != 0)
Guy Schalnat0d580581995-07-20 02:43:20 -05001300 {
Guy Schalnate5a37791996-06-05 15:50:50 -05001301 if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
1302 {
1303 png_warning(png_ptr, "Invalid sBIT depth specified");
1304 return;
1305 }
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001306
Guy Schalnat0d580581995-07-20 02:43:20 -05001307 buf[size++] = sbit->alpha;
1308 }
1309
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001310 png_write_complete_chunk(png_ptr, png_sBIT, buf, size);
Guy Schalnat0d580581995-07-20 02:43:20 -05001311}
Guy Schalnat51f0eb41995-09-26 05:22:39 -05001312#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05001313
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001314#ifdef PNG_WRITE_cHRM_SUPPORTED
Glenn Randers-Pehrson4bb4d012009-05-20 12:45:29 -05001315/* Write the cHRM chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001316void /* PRIVATE */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001317png_write_cHRM_fixed(png_structrp png_ptr, const png_xy *xy)
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001318{
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001319 png_byte buf[32];
1320
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001321 png_debug(1, "in png_write_cHRM");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001322
Glenn Randers-Pehrson4bb4d012009-05-20 12:45:29 -05001323 /* Each value is saved in 1/100,000ths */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001324 png_save_int_32(buf, xy->whitex);
1325 png_save_int_32(buf + 4, xy->whitey);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001326
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001327 png_save_int_32(buf + 8, xy->redx);
1328 png_save_int_32(buf + 12, xy->redy);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001329
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001330 png_save_int_32(buf + 16, xy->greenx);
1331 png_save_int_32(buf + 20, xy->greeny);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001332
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001333 png_save_int_32(buf + 24, xy->bluex);
1334 png_save_int_32(buf + 28, xy->bluey);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001335
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001336 png_write_complete_chunk(png_ptr, png_cHRM, buf, 32);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001337}
1338#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05001339
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001340#ifdef PNG_WRITE_tRNS_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001341/* Write the tRNS chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001342void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001343png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
Glenn Randers-Pehrsone600c512010-08-18 07:25:46 -05001344 png_const_color_16p tran, int num_trans, int color_type)
Guy Schalnat0d580581995-07-20 02:43:20 -05001345{
1346 png_byte buf[6];
1347
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001348 png_debug(1, "in png_write_tRNS");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001349
Guy Schalnat0d580581995-07-20 02:43:20 -05001350 if (color_type == PNG_COLOR_TYPE_PALETTE)
1351 {
Glenn Randers-Pehrson0f881d61998-02-07 10:20:57 -06001352 if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
Guy Schalnate5a37791996-06-05 15:50:50 -05001353 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001354 png_app_warning(png_ptr,
1355 "Invalid number of transparent colors specified");
Guy Schalnate5a37791996-06-05 15:50:50 -05001356 return;
1357 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001358
Glenn Randers-Pehrson4bb4d012009-05-20 12:45:29 -05001359 /* Write the chunk out as it is */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001360 png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha,
1361 (png_size_t)num_trans);
Guy Schalnat0d580581995-07-20 02:43:20 -05001362 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001363
Guy Schalnat0d580581995-07-20 02:43:20 -05001364 else if (color_type == PNG_COLOR_TYPE_GRAY)
1365 {
Glenn Randers-Pehrson8b83ff32015-08-13 20:57:18 -05001366 /* One 16-bit value */
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -05001367 if (tran->gray >= (1 << png_ptr->bit_depth))
Glenn Randers-Pehrson1ea0ff32001-08-07 22:25:59 -05001368 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001369 png_app_warning(png_ptr,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001370 "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001371
Glenn Randers-Pehrson1ea0ff32001-08-07 22:25:59 -05001372 return;
1373 }
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001374
Guy Schalnat0d580581995-07-20 02:43:20 -05001375 png_save_uint_16(buf, tran->gray);
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001376 png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)2);
Guy Schalnat0d580581995-07-20 02:43:20 -05001377 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001378
Guy Schalnat0d580581995-07-20 02:43:20 -05001379 else if (color_type == PNG_COLOR_TYPE_RGB)
1380 {
Glenn Randers-Pehrson8b83ff32015-08-13 20:57:18 -05001381 /* Three 16-bit values */
Guy Schalnat0d580581995-07-20 02:43:20 -05001382 png_save_uint_16(buf, tran->red);
1383 png_save_uint_16(buf + 2, tran->green);
1384 png_save_uint_16(buf + 4, tran->blue);
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -05001385#ifdef PNG_WRITE_16BIT_SUPPORTED
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05001386 if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0)
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -05001387#else
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05001388 if ((buf[0] | buf[2] | buf[4]) != 0)
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -05001389#endif
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001390 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001391 png_app_warning(png_ptr,
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -05001392 "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001393 return;
1394 }
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001395
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001396 png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)6);
Guy Schalnat0d580581995-07-20 02:43:20 -05001397 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001398
Guy Schalnate5a37791996-06-05 15:50:50 -05001399 else
1400 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001401 png_app_warning(png_ptr, "Can't write tRNS with an alpha channel");
Guy Schalnate5a37791996-06-05 15:50:50 -05001402 }
Guy Schalnat0d580581995-07-20 02:43:20 -05001403}
Guy Schalnat51f0eb41995-09-26 05:22:39 -05001404#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05001405
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001406#ifdef PNG_WRITE_bKGD_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001407/* Write the background chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001408void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001409png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
Guy Schalnat0d580581995-07-20 02:43:20 -05001410{
1411 png_byte buf[6];
1412
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001413 png_debug(1, "in png_write_bKGD");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001414
Guy Schalnat0d580581995-07-20 02:43:20 -05001415 if (color_type == PNG_COLOR_TYPE_PALETTE)
1416 {
Glenn Randers-Pehrson4393a9a1999-09-17 12:27:26 -05001417 if (
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001418#ifdef PNG_MNG_FEATURES_SUPPORTED
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05001419 (png_ptr->num_palette != 0 ||
1420 (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0) &&
Glenn Randers-Pehrson4393a9a1999-09-17 12:27:26 -05001421#endif
Glenn Randers-Pehrsond6d80752008-12-02 09:49:43 -06001422 back->index >= png_ptr->num_palette)
Guy Schalnate5a37791996-06-05 15:50:50 -05001423 {
1424 png_warning(png_ptr, "Invalid background palette index");
1425 return;
1426 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001427
Guy Schalnat0d580581995-07-20 02:43:20 -05001428 buf[0] = back->index;
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001429 png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)1);
Guy Schalnat0d580581995-07-20 02:43:20 -05001430 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001431
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05001432 else if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
Guy Schalnat0d580581995-07-20 02:43:20 -05001433 {
1434 png_save_uint_16(buf, back->red);
1435 png_save_uint_16(buf + 2, back->green);
1436 png_save_uint_16(buf + 4, back->blue);
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -05001437#ifdef PNG_WRITE_16BIT_SUPPORTED
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05001438 if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0)
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -05001439#else
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05001440 if ((buf[0] | buf[2] | buf[4]) != 0)
Glenn Randers-Pehrson7d3e6732010-08-26 17:14:07 -05001441#endif
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001442 {
1443 png_warning(png_ptr,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001444 "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001445
Glenn Randers-Pehrsonbeb572e2006-08-19 13:59:24 -05001446 return;
1447 }
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001448
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001449 png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)6);
Guy Schalnat0d580581995-07-20 02:43:20 -05001450 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001451
Guy Schalnat0d580581995-07-20 02:43:20 -05001452 else
Guy Schalnatb2e01bd1996-01-26 01:38:47 -06001453 {
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -05001454 if (back->gray >= (1 << png_ptr->bit_depth))
Glenn Randers-Pehrson1ea0ff32001-08-07 22:25:59 -05001455 {
1456 png_warning(png_ptr,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001457 "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001458
Glenn Randers-Pehrson1ea0ff32001-08-07 22:25:59 -05001459 return;
1460 }
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001461
Guy Schalnat0d580581995-07-20 02:43:20 -05001462 png_save_uint_16(buf, back->gray);
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001463 png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)2);
Guy Schalnat0d580581995-07-20 02:43:20 -05001464 }
1465}
Guy Schalnat51f0eb41995-09-26 05:22:39 -05001466#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05001467
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001468#ifdef PNG_WRITE_hIST_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001469/* Write the histogram */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001470void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001471png_write_hIST(png_structrp png_ptr, png_const_uint_16p hist, int num_hist)
Guy Schalnat0d580581995-07-20 02:43:20 -05001472{
Glenn Randers-Pehrson0f881d61998-02-07 10:20:57 -06001473 int i;
Guy Schalnat0d580581995-07-20 02:43:20 -05001474 png_byte buf[3];
1475
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001476 png_debug(1, "in png_write_hIST");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001477
Glenn Randers-Pehrson0f881d61998-02-07 10:20:57 -06001478 if (num_hist > (int)png_ptr->num_palette)
Guy Schalnate5a37791996-06-05 15:50:50 -05001479 {
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001480 png_debug2(3, "num_hist = %d, num_palette = %d", num_hist,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001481 png_ptr->num_palette);
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001482
Guy Schalnate5a37791996-06-05 15:50:50 -05001483 png_warning(png_ptr, "Invalid number of histogram entries specified");
1484 return;
1485 }
1486
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001487 png_write_chunk_header(png_ptr, png_hIST, (png_uint_32)(num_hist * 2));
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001488
Andreas Dilger47a0c421997-05-16 02:46:07 -05001489 for (i = 0; i < num_hist; i++)
Guy Schalnat0d580581995-07-20 02:43:20 -05001490 {
Guy Schalnatb2e01bd1996-01-26 01:38:47 -06001491 png_save_uint_16(buf, hist[i]);
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -05001492 png_write_chunk_data(png_ptr, buf, (png_size_t)2);
Guy Schalnat0d580581995-07-20 02:43:20 -05001493 }
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001494
Guy Schalnat0d580581995-07-20 02:43:20 -05001495 png_write_chunk_end(png_ptr);
1496}
Guy Schalnat51f0eb41995-09-26 05:22:39 -05001497#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05001498
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001499#ifdef PNG_WRITE_tEXt_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001500/* Write a tEXt chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001501void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001502png_write_tEXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001503 png_size_t text_len)
Guy Schalnat0d580581995-07-20 02:43:20 -05001504{
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001505 png_uint_32 key_len;
1506 png_byte new_key[80];
Guy Schalnat0d580581995-07-20 02:43:20 -05001507
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001508 png_debug(1, "in png_write_tEXt");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001509
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001510 key_len = png_check_keyword(png_ptr, key, new_key);
1511
1512 if (key_len == 0)
1513 png_error(png_ptr, "tEXt: invalid keyword");
Guy Schalnate5a37791996-06-05 15:50:50 -05001514
Andreas Dilger47a0c421997-05-16 02:46:07 -05001515 if (text == NULL || *text == '\0')
Andreas Dilger02ad0ef1997-01-17 01:34:35 -06001516 text_len = 0;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001517
Glenn Randers-Pehrson61c32d92000-02-04 23:40:16 -06001518 else
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001519 text_len = strlen(text);
1520
1521 if (text_len > PNG_UINT_31_MAX - (key_len+1))
1522 png_error(png_ptr, "tEXt: text too long");
John Bowlerb5d00512012-03-09 09:15:18 -06001523
Glenn Randers-Pehrson4bb4d012009-05-20 12:45:29 -05001524 /* Make sure we include the 0 after the key */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001525 png_write_chunk_header(png_ptr, png_tEXt,
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001526 (png_uint_32)/*checked above*/(key_len + text_len + 1));
Glenn Randers-Pehrson4393a9a1999-09-17 12:27:26 -05001527 /*
1528 * We leave it to the application to meet PNG-1.0 requirements on the
1529 * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
1530 * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001531 * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
Glenn Randers-Pehrson4393a9a1999-09-17 12:27:26 -05001532 */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001533 png_write_chunk_data(png_ptr, new_key, key_len + 1);
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001534
Glenn Randers-Pehrson05670152014-03-08 12:39:52 -06001535 if (text_len != 0)
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001536 png_write_chunk_data(png_ptr, (png_const_bytep)text, text_len);
Andreas Dilger02ad0ef1997-01-17 01:34:35 -06001537
Guy Schalnat0d580581995-07-20 02:43:20 -05001538 png_write_chunk_end(png_ptr);
1539}
Guy Schalnat51f0eb41995-09-26 05:22:39 -05001540#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05001541
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001542#ifdef PNG_WRITE_zTXt_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001543/* Write a compressed text chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001544void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001545png_write_zTXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
Glenn Randers-Pehrsond7522252014-10-03 17:00:38 -05001546 int compression)
Guy Schalnat0d580581995-07-20 02:43:20 -05001547{
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001548 png_uint_32 key_len;
1549 png_byte new_key[81];
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001550 compression_state comp;
Guy Schalnat0d580581995-07-20 02:43:20 -05001551
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001552 png_debug(1, "in png_write_zTXt");
Andreas Dilger02ad0ef1997-01-17 01:34:35 -06001553
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001554 if (compression == PNG_TEXT_COMPRESSION_NONE)
Guy Schalnate5a37791996-06-05 15:50:50 -05001555 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001556 png_write_tEXt(png_ptr, key, text, 0);
Andreas Dilger47a0c421997-05-16 02:46:07 -05001557 return;
Guy Schalnate5a37791996-06-05 15:50:50 -05001558 }
1559
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001560 if (compression != PNG_TEXT_COMPRESSION_zTXt)
1561 png_error(png_ptr, "zTXt: invalid compression type");
Andreas Dilger47a0c421997-05-16 02:46:07 -05001562
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001563 key_len = png_check_keyword(png_ptr, key, new_key);
1564
1565 if (key_len == 0)
1566 png_error(png_ptr, "zTXt: invalid keyword");
1567
1568 /* Add the compression method and 1 for the keyword separator. */
1569 new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
1570 ++key_len;
Glenn Randers-Pehrson61c32d92000-02-04 23:40:16 -06001571
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001572 /* Compute the compressed data; do it now for the length */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001573 png_text_compress_init(&comp, (png_const_bytep)text,
1574 text == NULL ? 0 : strlen(text));
1575
1576 if (png_text_compress(png_ptr, png_zTXt, &comp, key_len) != Z_OK)
1577 png_error(png_ptr, png_ptr->zstream.msg);
Guy Schalnat0d580581995-07-20 02:43:20 -05001578
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001579 /* Write start of chunk */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001580 png_write_chunk_header(png_ptr, png_zTXt, key_len + comp.output_len);
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001581
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001582 /* Write key */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001583 png_write_chunk_data(png_ptr, new_key, key_len);
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001584
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001585 /* Write the compressed data */
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001586 png_write_compressed_data_out(png_ptr, &comp);
Guy Schalnat0d580581995-07-20 02:43:20 -05001587
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001588 /* Close the chunk */
Guy Schalnat0d580581995-07-20 02:43:20 -05001589 png_write_chunk_end(png_ptr);
Guy Schalnat0d580581995-07-20 02:43:20 -05001590}
Guy Schalnat51f0eb41995-09-26 05:22:39 -05001591#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05001592
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001593#ifdef PNG_WRITE_iTXt_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001594/* Write an iTXt chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001595void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001596png_write_iTXt(png_structrp png_ptr, int compression, png_const_charp key,
Glenn Randers-Pehrsone600c512010-08-18 07:25:46 -05001597 png_const_charp lang, png_const_charp lang_key, png_const_charp text)
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001598{
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001599 png_uint_32 key_len, prefix_len;
1600 png_size_t lang_len, lang_key_len;
1601 png_byte new_key[82];
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001602 compression_state comp;
1603
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001604 png_debug(1, "in png_write_iTXt");
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001605
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001606 key_len = png_check_keyword(png_ptr, key, new_key);
Glenn Randers-Pehrson3744f942012-08-10 19:22:53 -05001607
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001608 if (key_len == 0)
1609 png_error(png_ptr, "iTXt: invalid keyword");
Glenn Randers-Pehrson9c3ab682006-02-20 22:09:05 -06001610
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001611 /* Set the compression flag */
1612 switch (compression)
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001613 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001614 case PNG_ITXT_COMPRESSION_NONE:
1615 case PNG_TEXT_COMPRESSION_NONE:
1616 compression = new_key[++key_len] = 0; /* no compression */
1617 break;
1618
1619 case PNG_TEXT_COMPRESSION_zTXt:
1620 case PNG_ITXT_COMPRESSION_zTXt:
1621 compression = new_key[++key_len] = 1; /* compressed */
1622 break;
1623
1624 default:
1625 png_error(png_ptr, "iTXt: invalid compression");
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001626 }
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001627
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001628 new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
1629 ++key_len; /* for the keywod separator */
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001630
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001631 /* We leave it to the application to meet PNG-1.0 requirements on the
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001632 * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001633 * any non-Latin-1 characters except for NEWLINE. ISO PNG, however,
1634 * specifies that the text is UTF-8 and this really doesn't require any
1635 * checking.
1636 *
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001637 * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001638 *
1639 * TODO: validate the language tag correctly (see the spec.)
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001640 */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001641 if (lang == NULL) lang = ""; /* empty language is valid */
1642 lang_len = strlen(lang)+1;
1643 if (lang_key == NULL) lang_key = ""; /* may be empty */
1644 lang_key_len = strlen(lang_key)+1;
1645 if (text == NULL) text = ""; /* may be empty */
Glenn Randers-Pehrson61c32d92000-02-04 23:40:16 -06001646
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001647 prefix_len = key_len;
1648 if (lang_len > PNG_UINT_31_MAX-prefix_len)
1649 prefix_len = PNG_UINT_31_MAX;
1650 else
1651 prefix_len = (png_uint_32)(prefix_len + lang_len);
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001652
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001653 if (lang_key_len > PNG_UINT_31_MAX-prefix_len)
1654 prefix_len = PNG_UINT_31_MAX;
1655 else
1656 prefix_len = (png_uint_32)(prefix_len + lang_key_len);
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001657
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001658 png_text_compress_init(&comp, (png_const_bytep)text, strlen(text));
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001659
Glenn Randers-Pehrson05670152014-03-08 12:39:52 -06001660 if (compression != 0)
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001661 {
1662 if (png_text_compress(png_ptr, png_iTXt, &comp, prefix_len) != Z_OK)
1663 png_error(png_ptr, png_ptr->zstream.msg);
1664 }
Glenn Randers-Pehrson61c32d92000-02-04 23:40:16 -06001665
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001666 else
1667 {
1668 if (comp.input_len > PNG_UINT_31_MAX-prefix_len)
1669 png_error(png_ptr, "iTXt: uncompressed text too long");
John Bowler70eb0722013-04-13 16:52:09 -05001670
1671 /* So the string will fit in a chunk: */
1672 comp.output_len = (png_uint_32)/*SAFE*/comp.input_len;
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001673 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001674
John Bowler70eb0722013-04-13 16:52:09 -05001675 png_write_chunk_header(png_ptr, png_iTXt, comp.output_len + prefix_len);
1676
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001677 png_write_chunk_data(png_ptr, new_key, key_len);
1678
1679 png_write_chunk_data(png_ptr, (png_const_bytep)lang, lang_len);
1680
1681 png_write_chunk_data(png_ptr, (png_const_bytep)lang_key, lang_key_len);
1682
Glenn Randers-Pehrson05670152014-03-08 12:39:52 -06001683 if (compression != 0)
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001684 png_write_compressed_data_out(png_ptr, &comp);
1685
1686 else
Glenn Randers-Pehrson6ef579d2015-01-27 07:02:46 -06001687 png_write_chunk_data(png_ptr, (png_const_bytep)text, comp.output_len);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001688
1689 png_write_chunk_end(png_ptr);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001690}
1691#endif
Andreas Dilger47a0c421997-05-16 02:46:07 -05001692
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001693#ifdef PNG_WRITE_oFFs_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001694/* Write the oFFs chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001695void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001696png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001697 int unit_type)
Andreas Dilger47a0c421997-05-16 02:46:07 -05001698{
1699 png_byte buf[9];
1700
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001701 png_debug(1, "in png_write_oFFs");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001702
Andreas Dilger47a0c421997-05-16 02:46:07 -05001703 if (unit_type >= PNG_OFFSET_LAST)
1704 png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");
1705
Glenn Randers-Pehrsonb1828932001-06-23 08:03:17 -05001706 png_save_int_32(buf, x_offset);
1707 png_save_int_32(buf + 4, y_offset);
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05001708 buf[8] = (png_byte)unit_type;
Andreas Dilger47a0c421997-05-16 02:46:07 -05001709
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001710 png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
Andreas Dilger47a0c421997-05-16 02:46:07 -05001711}
1712#endif
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001713#ifdef PNG_WRITE_pCAL_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001714/* Write the pCAL chunk (described in the PNG extensions document) */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001715void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001716png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0,
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05001717 png_int_32 X1, int type, int nparams, png_const_charp units,
1718 png_charpp params)
Andreas Dilger47a0c421997-05-16 02:46:07 -05001719{
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001720 png_uint_32 purpose_len;
1721 png_size_t units_len, total_len;
John Bowlerf3f7e142011-09-09 07:32:37 -05001722 png_size_tp params_len;
Andreas Dilger47a0c421997-05-16 02:46:07 -05001723 png_byte buf[10];
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001724 png_byte new_purpose[80];
Andreas Dilger47a0c421997-05-16 02:46:07 -05001725 int i;
1726
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001727 png_debug1(1, "in png_write_pCAL (%d parameters)", nparams);
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001728
Andreas Dilger47a0c421997-05-16 02:46:07 -05001729 if (type >= PNG_EQUATION_LAST)
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001730 png_error(png_ptr, "Unrecognized equation type for pCAL chunk");
Andreas Dilger47a0c421997-05-16 02:46:07 -05001731
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001732 purpose_len = png_check_keyword(png_ptr, purpose, new_purpose);
1733
1734 if (purpose_len == 0)
1735 png_error(png_ptr, "pCAL: invalid keyword");
1736
1737 ++purpose_len; /* terminator */
1738
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001739 png_debug1(3, "pCAL purpose length = %d", (int)purpose_len);
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001740 units_len = strlen(units) + (nparams == 0 ? 0 : 1);
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001741 png_debug1(3, "pCAL units length = %d", (int)units_len);
Andreas Dilger47a0c421997-05-16 02:46:07 -05001742 total_len = purpose_len + units_len + 10;
1743
John Bowlerf3f7e142011-09-09 07:32:37 -05001744 params_len = (png_size_tp)png_malloc(png_ptr,
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001745 (png_alloc_size_t)(nparams * (sizeof (png_size_t))));
Andreas Dilger47a0c421997-05-16 02:46:07 -05001746
1747 /* Find the length of each parameter, making sure we don't count the
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001748 * null terminator for the last parameter.
1749 */
Andreas Dilger47a0c421997-05-16 02:46:07 -05001750 for (i = 0; i < nparams; i++)
1751 {
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001752 params_len[i] = strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001753 png_debug2(3, "pCAL parameter %d length = %lu", i,
Glenn Randers-Pehrsond2332872010-10-12 19:19:28 -05001754 (unsigned long)params_len[i]);
John Bowlerf3f7e142011-09-09 07:32:37 -05001755 total_len += params_len[i];
Andreas Dilger47a0c421997-05-16 02:46:07 -05001756 }
1757
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001758 png_debug1(3, "pCAL total length = %d", (int)total_len);
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001759 png_write_chunk_header(png_ptr, png_pCAL, (png_uint_32)total_len);
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001760 png_write_chunk_data(png_ptr, new_purpose, purpose_len);
Andreas Dilger47a0c421997-05-16 02:46:07 -05001761 png_save_int_32(buf, X0);
1762 png_save_int_32(buf + 4, X1);
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05001763 buf[8] = (png_byte)type;
1764 buf[9] = (png_byte)nparams;
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -05001765 png_write_chunk_data(png_ptr, buf, (png_size_t)10);
Glenn Randers-Pehrsone600c512010-08-18 07:25:46 -05001766 png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len);
Andreas Dilger47a0c421997-05-16 02:46:07 -05001767
Andreas Dilger47a0c421997-05-16 02:46:07 -05001768 for (i = 0; i < nparams; i++)
1769 {
John Bowlerf3f7e142011-09-09 07:32:37 -05001770 png_write_chunk_data(png_ptr, (png_const_bytep)params[i], params_len[i]);
Andreas Dilger47a0c421997-05-16 02:46:07 -05001771 }
1772
Glenn Randers-Pehrsonc4a2ae61998-01-16 22:06:18 -06001773 png_free(png_ptr, params_len);
Andreas Dilger47a0c421997-05-16 02:46:07 -05001774 png_write_chunk_end(png_ptr);
1775}
1776#endif
1777
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001778#ifdef PNG_WRITE_sCAL_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001779/* Write the sCAL chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001780void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001781png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width,
Glenn Randers-Pehrsone600c512010-08-18 07:25:46 -05001782 png_const_charp height)
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001783{
Glenn Randers-Pehrson6bc53be2006-06-16 07:52:03 -05001784 png_byte buf[64];
1785 png_size_t wlen, hlen, total_len;
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001786
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001787 png_debug(1, "in png_write_sCAL_s");
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001788
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001789 wlen = strlen(width);
1790 hlen = strlen(height);
Glenn Randers-Pehrson6bc53be2006-06-16 07:52:03 -05001791 total_len = wlen + hlen + 2;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001792
Glenn Randers-Pehrson6bc53be2006-06-16 07:52:03 -05001793 if (total_len > 64)
1794 {
1795 png_warning(png_ptr, "Can't write sCAL (buffer too small)");
1796 return;
1797 }
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001798
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05001799 buf[0] = (png_byte)unit;
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06001800 memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */
1801 memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001802
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001803 png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001804 png_write_complete_chunk(png_ptr, png_sCAL, buf, total_len);
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001805}
1806#endif
1807
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001808#ifdef PNG_WRITE_pHYs_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001809/* Write the pHYs chunk */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001810void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001811png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001812 png_uint_32 y_pixels_per_unit,
1813 int unit_type)
Guy Schalnat0d580581995-07-20 02:43:20 -05001814{
1815 png_byte buf[9];
1816
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001817 png_debug(1, "in png_write_pHYs");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001818
Guy Schalnate5a37791996-06-05 15:50:50 -05001819 if (unit_type >= PNG_RESOLUTION_LAST)
1820 png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");
1821
Guy Schalnat0d580581995-07-20 02:43:20 -05001822 png_save_uint_32(buf, x_pixels_per_unit);
1823 png_save_uint_32(buf + 4, y_pixels_per_unit);
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05001824 buf[8] = (png_byte)unit_type;
Guy Schalnat0d580581995-07-20 02:43:20 -05001825
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001826 png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
Guy Schalnat0d580581995-07-20 02:43:20 -05001827}
Guy Schalnat51f0eb41995-09-26 05:22:39 -05001828#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05001829
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05001830#ifdef PNG_WRITE_tIME_SUPPORTED
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -06001831/* Write the tIME chunk. Use either png_convert_from_struct_tm()
1832 * or png_convert_from_time_t(), or fill in the structure yourself.
1833 */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001834void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001835png_write_tIME(png_structrp png_ptr, png_const_timep mod_time)
Guy Schalnat0d580581995-07-20 02:43:20 -05001836{
1837 png_byte buf[7];
1838
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001839 png_debug(1, "in png_write_tIME");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001840
Guy Schalnate5a37791996-06-05 15:50:50 -05001841 if (mod_time->month > 12 || mod_time->month < 1 ||
1842 mod_time->day > 31 || mod_time->day < 1 ||
1843 mod_time->hour > 23 || mod_time->second > 60)
1844 {
1845 png_warning(png_ptr, "Invalid time specified for tIME chunk");
1846 return;
1847 }
1848
Guy Schalnat0d580581995-07-20 02:43:20 -05001849 png_save_uint_16(buf, mod_time->year);
1850 buf[2] = mod_time->month;
1851 buf[3] = mod_time->day;
1852 buf[4] = mod_time->hour;
1853 buf[5] = mod_time->minute;
1854 buf[6] = mod_time->second;
1855
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001856 png_write_complete_chunk(png_ptr, png_tIME, buf, (png_size_t)7);
Guy Schalnat0d580581995-07-20 02:43:20 -05001857}
Guy Schalnat51f0eb41995-09-26 05:22:39 -05001858#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05001859
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001860/* Initializes the row writing capability of libpng */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001861void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001862png_write_start_row(png_structrp png_ptr)
Guy Schalnat0d580581995-07-20 02:43:20 -05001863{
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -05001864#ifdef PNG_WRITE_INTERLACING_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001865 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001866
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001867 /* Start of interlace block */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001868 static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001869
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001870 /* Offset to next interlace block */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001871 static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001872
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001873 /* Start of interlace block in the y direction */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001874 static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001875
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001876 /* Offset to next interlace block in the y direction */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001877 static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
Glenn Randers-Pehrson074af5e1999-11-28 23:32:18 -06001878#endif
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001879
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001880 png_alloc_size_t buf_size;
1881 int usr_pixel_depth;
Andreas Dilger47a0c421997-05-16 02:46:07 -05001882
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05001883#ifdef PNG_WRITE_FILTER_SUPPORTED
John Bowler2dfcf652015-06-03 14:58:18 -05001884 png_byte filters;
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05001885#endif
1886
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001887 png_debug(1, "in png_write_start_row");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001888
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001889 usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth;
1890 buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1;
1891
1892 /* 1.5.6: added to allow checking in the row write code. */
1893 png_ptr->transformed_pixel_depth = png_ptr->pixel_depth;
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05001894 png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth;
Andreas Dilger47a0c421997-05-16 02:46:07 -05001895
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001896 /* Set up row buffer */
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05001897 png_ptr->row_buf = png_voidcast(png_bytep, png_malloc(png_ptr, buf_size));
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001898
Andreas Dilger47a0c421997-05-16 02:46:07 -05001899 png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
Guy Schalnate5a37791996-06-05 15:50:50 -05001900
Glenn Randers-Pehrsondbd40142009-08-31 08:42:02 -05001901#ifdef PNG_WRITE_FILTER_SUPPORTED
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05001902 filters = png_ptr->do_filter;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001903
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05001904 if (png_ptr->height == 1)
John Bowler2dfcf652015-06-03 14:58:18 -05001905 filters &= 0xff & ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05001906
1907 if (png_ptr->width == 1)
John Bowler2dfcf652015-06-03 14:58:18 -05001908 filters &= 0xff & ~(PNG_FILTER_SUB|PNG_FILTER_AVG|PNG_FILTER_PAETH);
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05001909
1910 if (filters == 0)
1911 filters = PNG_FILTER_NONE;
1912
1913 png_ptr->do_filter = filters;
1914
1915 if (((filters & (PNG_FILTER_SUB | PNG_FILTER_UP | PNG_FILTER_AVG |
1916 PNG_FILTER_PAETH)) != 0) && png_ptr->try_row == NULL)
1917 {
1918 int num_filters = 0;
1919
1920 png_ptr->try_row = png_voidcast(png_bytep, png_malloc(png_ptr, buf_size));
1921
1922 if (filters & PNG_FILTER_SUB)
1923 num_filters++;
1924
1925 if (filters & PNG_FILTER_UP)
1926 num_filters++;
1927
1928 if (filters & PNG_FILTER_AVG)
1929 num_filters++;
1930
1931 if (filters & PNG_FILTER_PAETH)
1932 num_filters++;
1933
1934 if (num_filters > 1)
1935 png_ptr->tst_row = png_voidcast(png_bytep, png_malloc(png_ptr,
1936 buf_size));
Guy Schalnate5a37791996-06-05 15:50:50 -05001937 }
1938
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05001939 /* We only need to keep the previous row if we are using one of the following
1940 * filters.
1941 */
1942 if ((filters & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) != 0)
John Bowler7023d872015-06-03 15:04:03 -05001943 png_ptr->prev_row = png_voidcast(png_bytep,
1944 png_calloc(png_ptr, buf_size));
Glenn Randers-Pehrsoncda68df2014-11-06 22:11:39 -06001945#endif /* WRITE_FILTER */
Guy Schalnat0d580581995-07-20 02:43:20 -05001946
Glenn Randers-Pehrson46f61e21998-01-30 21:45:12 -06001947#ifdef PNG_WRITE_INTERLACING_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001948 /* If interlaced, we need to set up width and height of pass */
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05001949 if (png_ptr->interlaced != 0)
Guy Schalnat0d580581995-07-20 02:43:20 -05001950 {
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05001951 if ((png_ptr->transformations & PNG_INTERLACE) == 0)
Guy Schalnat0d580581995-07-20 02:43:20 -05001952 {
1953 png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001954 png_pass_ystart[0]) / png_pass_yinc[0];
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001955
Andreas Dilger47a0c421997-05-16 02:46:07 -05001956 png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06001957 png_pass_start[0]) / png_pass_inc[0];
Guy Schalnat0d580581995-07-20 02:43:20 -05001958 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001959
Guy Schalnat0d580581995-07-20 02:43:20 -05001960 else
1961 {
1962 png_ptr->num_rows = png_ptr->height;
1963 png_ptr->usr_width = png_ptr->width;
1964 }
1965 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05001966
Guy Schalnat0d580581995-07-20 02:43:20 -05001967 else
Glenn Randers-Pehrson46f61e21998-01-30 21:45:12 -06001968#endif
Guy Schalnatb2e01bd1996-01-26 01:38:47 -06001969 {
Guy Schalnat0d580581995-07-20 02:43:20 -05001970 png_ptr->num_rows = png_ptr->height;
1971 png_ptr->usr_width = png_ptr->width;
1972 }
Guy Schalnat0d580581995-07-20 02:43:20 -05001973}
1974
Andreas Dilger47a0c421997-05-16 02:46:07 -05001975/* Internal use only. Called when finished processing a row of data. */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05001976void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06001977png_write_finish_row(png_structrp png_ptr)
Guy Schalnat0d580581995-07-20 02:43:20 -05001978{
Glenn Randers-Pehrson145f5c82008-07-10 09:13:13 -05001979#ifdef PNG_WRITE_INTERLACING_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001980 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001981
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001982 /* Start of interlace block */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001983 static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001984
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001985 /* Offset to next interlace block */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001986 static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001987
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001988 /* Start of interlace block in the y direction */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001989 static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001990
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05001991 /* Offset to next interlace block in the y direction */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05001992 static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
Glenn Randers-Pehrson074af5e1999-11-28 23:32:18 -06001993#endif
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06001994
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05001995 png_debug(1, "in png_write_finish_row");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05001996
Glenn Randers-Pehrson4bb4d012009-05-20 12:45:29 -05001997 /* Next row */
Guy Schalnat0d580581995-07-20 02:43:20 -05001998 png_ptr->row_number++;
Guy Schalnatc21f90c1996-06-17 16:24:45 -05001999
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002000 /* See if we are done */
Guy Schalnat6d764711995-12-19 03:22:19 -06002001 if (png_ptr->row_number < png_ptr->num_rows)
Guy Schalnatb2e01bd1996-01-26 01:38:47 -06002002 return;
Guy Schalnat0d580581995-07-20 02:43:20 -05002003
Glenn Randers-Pehrson46f61e21998-01-30 21:45:12 -06002004#ifdef PNG_WRITE_INTERLACING_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002005 /* If interlaced, go to next pass */
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05002006 if (png_ptr->interlaced != 0)
Guy Schalnat0d580581995-07-20 02:43:20 -05002007 {
2008 png_ptr->row_number = 0;
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05002009 if ((png_ptr->transformations & PNG_INTERLACE) != 0)
Guy Schalnat0d580581995-07-20 02:43:20 -05002010 {
2011 png_ptr->pass++;
2012 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002013
Guy Schalnat0d580581995-07-20 02:43:20 -05002014 else
2015 {
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002016 /* Loop until we find a non-zero width or height pass */
Guy Schalnat0d580581995-07-20 02:43:20 -05002017 do
2018 {
2019 png_ptr->pass++;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002020
Guy Schalnat0d580581995-07-20 02:43:20 -05002021 if (png_ptr->pass >= 7)
2022 break;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002023
Guy Schalnatb2e01bd1996-01-26 01:38:47 -06002024 png_ptr->usr_width = (png_ptr->width +
Glenn Randers-Pehrson67439c42010-08-19 07:01:09 -05002025 png_pass_inc[png_ptr->pass] - 1 -
2026 png_pass_start[png_ptr->pass]) /
2027 png_pass_inc[png_ptr->pass];
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002028
Guy Schalnat0d580581995-07-20 02:43:20 -05002029 png_ptr->num_rows = (png_ptr->height +
Glenn Randers-Pehrson67439c42010-08-19 07:01:09 -05002030 png_pass_yinc[png_ptr->pass] - 1 -
2031 png_pass_ystart[png_ptr->pass]) /
2032 png_pass_yinc[png_ptr->pass];
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002033
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05002034 if ((png_ptr->transformations & PNG_INTERLACE) != 0)
Guy Schalnat51f0eb41995-09-26 05:22:39 -05002035 break;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002036
Guy Schalnat0d580581995-07-20 02:43:20 -05002037 } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
2038
2039 }
2040
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002041 /* Reset the row above the image for the next pass */
Guy Schalnatb2e01bd1996-01-26 01:38:47 -06002042 if (png_ptr->pass < 7)
Guy Schalnatc21f90c1996-06-17 16:24:45 -05002043 {
Andreas Dilger47a0c421997-05-16 02:46:07 -05002044 if (png_ptr->prev_row != NULL)
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06002045 memset(png_ptr->prev_row, 0,
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06002046 (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*
2047 png_ptr->usr_bit_depth, png_ptr->width)) + 1);
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002048
Guy Schalnat0d580581995-07-20 02:43:20 -05002049 return;
Guy Schalnatc21f90c1996-06-17 16:24:45 -05002050 }
Guy Schalnat0d580581995-07-20 02:43:20 -05002051 }
Glenn Randers-Pehrson46f61e21998-01-30 21:45:12 -06002052#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05002053
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002054 /* If we get here, we've just written the last row, so we need
Guy Schalnat0d580581995-07-20 02:43:20 -05002055 to flush the compressor */
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06002056 png_compress_IDAT(png_ptr, NULL, 0, Z_FINISH);
Guy Schalnat0d580581995-07-20 02:43:20 -05002057}
2058
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05002059#ifdef PNG_WRITE_INTERLACING_SUPPORTED
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -06002060/* Pick out the correct pixels for the interlace pass.
2061 * The basic idea here is to go through the row with a source
2062 * pointer and a destination pointer (sp and dp), and copy the
2063 * correct pixels for the pass. As the row gets compacted,
2064 * sp will always be >= dp, so we should never overwrite anything.
2065 * See the default: case for the easiest code to understand.
2066 */
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05002067void /* PRIVATE */
Guy Schalnat6d764711995-12-19 03:22:19 -06002068png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
Guy Schalnat0d580581995-07-20 02:43:20 -05002069{
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002070 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06002071
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002072 /* Start of interlace block */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05002073 static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06002074
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002075 /* Offset to next interlace block */
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05002076 static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
Glenn Randers-Pehrson166c5a31999-12-10 09:43:02 -06002077
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05002078 png_debug(1, "in png_do_write_interlace");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05002079
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002080 /* We don't have to do anything on the last pass (6) */
Andreas Dilger47a0c421997-05-16 02:46:07 -05002081 if (pass < 6)
Guy Schalnat0d580581995-07-20 02:43:20 -05002082 {
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002083 /* Each pixel depth is handled separately */
Guy Schalnat0d580581995-07-20 02:43:20 -05002084 switch (row_info->pixel_depth)
Guy Schalnatb2e01bd1996-01-26 01:38:47 -06002085 {
Guy Schalnat0d580581995-07-20 02:43:20 -05002086 case 1:
2087 {
Guy Schalnat6d764711995-12-19 03:22:19 -06002088 png_bytep sp;
2089 png_bytep dp;
John Bowlerb780eba2015-06-03 14:46:34 -05002090 unsigned int shift;
Guy Schalnat0d580581995-07-20 02:43:20 -05002091 int d;
2092 int value;
Glenn Randers-Pehrson1d963611998-05-02 12:52:25 -05002093 png_uint_32 i;
2094 png_uint_32 row_width = row_info->width;
Guy Schalnat0d580581995-07-20 02:43:20 -05002095
2096 dp = row;
2097 d = 0;
2098 shift = 7;
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05002099
Glenn Randers-Pehrson1d963611998-05-02 12:52:25 -05002100 for (i = png_pass_start[pass]; i < row_width;
Guy Schalnat0d580581995-07-20 02:43:20 -05002101 i += png_pass_inc[pass])
2102 {
2103 sp = row + (png_size_t)(i >> 3);
Glenn Randers-Pehrson61c32d92000-02-04 23:40:16 -06002104 value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;
Guy Schalnat0d580581995-07-20 02:43:20 -05002105 d |= (value << shift);
2106
2107 if (shift == 0)
2108 {
2109 shift = 7;
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05002110 *dp++ = (png_byte)d;
Guy Schalnat0d580581995-07-20 02:43:20 -05002111 d = 0;
2112 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002113
Guy Schalnat0d580581995-07-20 02:43:20 -05002114 else
2115 shift--;
2116
2117 }
2118 if (shift != 7)
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05002119 *dp = (png_byte)d;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002120
Guy Schalnat0d580581995-07-20 02:43:20 -05002121 break;
2122 }
Glenn Randers-Pehrson67439c42010-08-19 07:01:09 -05002123
Guy Schalnat0d580581995-07-20 02:43:20 -05002124 case 2:
Guy Schalnatb2e01bd1996-01-26 01:38:47 -06002125 {
Guy Schalnat6d764711995-12-19 03:22:19 -06002126 png_bytep sp;
2127 png_bytep dp;
John Bowlerb780eba2015-06-03 14:46:34 -05002128 unsigned int shift;
Guy Schalnat0d580581995-07-20 02:43:20 -05002129 int d;
2130 int value;
Glenn Randers-Pehrson1d963611998-05-02 12:52:25 -05002131 png_uint_32 i;
2132 png_uint_32 row_width = row_info->width;
Guy Schalnat0d580581995-07-20 02:43:20 -05002133
2134 dp = row;
2135 shift = 6;
2136 d = 0;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002137
Glenn Randers-Pehrson1d963611998-05-02 12:52:25 -05002138 for (i = png_pass_start[pass]; i < row_width;
Guy Schalnat0d580581995-07-20 02:43:20 -05002139 i += png_pass_inc[pass])
2140 {
2141 sp = row + (png_size_t)(i >> 2);
Glenn Randers-Pehrson61c32d92000-02-04 23:40:16 -06002142 value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;
Guy Schalnat0d580581995-07-20 02:43:20 -05002143 d |= (value << shift);
2144
2145 if (shift == 0)
2146 {
2147 shift = 6;
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05002148 *dp++ = (png_byte)d;
Guy Schalnat0d580581995-07-20 02:43:20 -05002149 d = 0;
2150 }
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002151
Guy Schalnat0d580581995-07-20 02:43:20 -05002152 else
2153 shift -= 2;
2154 }
2155 if (shift != 6)
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05002156 *dp = (png_byte)d;
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002157
Guy Schalnat0d580581995-07-20 02:43:20 -05002158 break;
2159 }
Glenn Randers-Pehrson67439c42010-08-19 07:01:09 -05002160
Guy Schalnat0d580581995-07-20 02:43:20 -05002161 case 4:
2162 {
Guy Schalnat6d764711995-12-19 03:22:19 -06002163 png_bytep sp;
2164 png_bytep dp;
John Bowlerb780eba2015-06-03 14:46:34 -05002165 unsigned int shift;
Guy Schalnat0d580581995-07-20 02:43:20 -05002166 int d;
2167 int value;
Glenn Randers-Pehrson1d963611998-05-02 12:52:25 -05002168 png_uint_32 i;
2169 png_uint_32 row_width = row_info->width;
Guy Schalnat0d580581995-07-20 02:43:20 -05002170
2171 dp = row;
2172 shift = 4;
2173 d = 0;
Glenn Randers-Pehrson1d963611998-05-02 12:52:25 -05002174 for (i = png_pass_start[pass]; i < row_width;
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06002175 i += png_pass_inc[pass])
Guy Schalnat0d580581995-07-20 02:43:20 -05002176 {
2177 sp = row + (png_size_t)(i >> 1);
Glenn Randers-Pehrson61c32d92000-02-04 23:40:16 -06002178 value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;
Guy Schalnat0d580581995-07-20 02:43:20 -05002179 d |= (value << shift);
2180
2181 if (shift == 0)
2182 {
Guy Schalnatb2e01bd1996-01-26 01:38:47 -06002183 shift = 4;
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05002184 *dp++ = (png_byte)d;
Guy Schalnat0d580581995-07-20 02:43:20 -05002185 d = 0;
2186 }
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05002187
Guy Schalnat0d580581995-07-20 02:43:20 -05002188 else
2189 shift -= 4;
2190 }
2191 if (shift != 4)
Glenn Randers-Pehrsonc5370ed2015-03-21 11:54:32 -05002192 *dp = (png_byte)d;
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05002193
Guy Schalnat0d580581995-07-20 02:43:20 -05002194 break;
2195 }
Glenn Randers-Pehrson67439c42010-08-19 07:01:09 -05002196
Guy Schalnat0d580581995-07-20 02:43:20 -05002197 default:
2198 {
Guy Schalnat6d764711995-12-19 03:22:19 -06002199 png_bytep sp;
2200 png_bytep dp;
Glenn Randers-Pehrson1d963611998-05-02 12:52:25 -05002201 png_uint_32 i;
2202 png_uint_32 row_width = row_info->width;
Andreas Dilger47a0c421997-05-16 02:46:07 -05002203 png_size_t pixel_bytes;
Guy Schalnat0d580581995-07-20 02:43:20 -05002204
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002205 /* Start at the beginning */
Guy Schalnat0d580581995-07-20 02:43:20 -05002206 dp = row;
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05002207
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002208 /* Find out how many bytes each pixel takes up */
Guy Schalnat0d580581995-07-20 02:43:20 -05002209 pixel_bytes = (row_info->pixel_depth >> 3);
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06002210
2211 /* Loop through the row, only looking at the pixels that matter */
Glenn Randers-Pehrson1d963611998-05-02 12:52:25 -05002212 for (i = png_pass_start[pass]; i < row_width;
Guy Schalnat0d580581995-07-20 02:43:20 -05002213 i += png_pass_inc[pass])
2214 {
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002215 /* Find out where the original pixel is */
Glenn Randers-Pehrsona357b991998-02-08 20:56:40 -06002216 sp = row + (png_size_t)i * pixel_bytes;
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05002217
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002218 /* Move the pixel */
Guy Schalnat0d580581995-07-20 02:43:20 -05002219 if (dp != sp)
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06002220 memcpy(dp, sp, pixel_bytes);
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002221
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002222 /* Next pixel */
Guy Schalnat0d580581995-07-20 02:43:20 -05002223 dp += pixel_bytes;
2224 }
Guy Schalnatb2e01bd1996-01-26 01:38:47 -06002225 break;
Guy Schalnat0d580581995-07-20 02:43:20 -05002226 }
2227 }
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002228 /* Set new row width */
Guy Schalnat0d580581995-07-20 02:43:20 -05002229 row_info->width = (row_info->width +
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06002230 png_pass_inc[pass] - 1 -
2231 png_pass_start[pass]) /
2232 png_pass_inc[pass];
Glenn Randers-Pehrsonf24daf22010-05-06 09:44:04 -05002233
Glenn Randers-Pehrson16908a12010-03-06 07:34:28 -06002234 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
2235 row_info->width);
Guy Schalnat0d580581995-07-20 02:43:20 -05002236 }
2237}
Guy Schalnat51f0eb41995-09-26 05:22:39 -05002238#endif
Guy Schalnat0d580581995-07-20 02:43:20 -05002239
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002240
Andreas Dilger47a0c421997-05-16 02:46:07 -05002241/* This filters the row, chooses which filter to use, if it has not already
2242 * been specified by the application, and then writes the row out with the
Glenn Randers-Pehrsonb6ce43d1998-01-01 07:13:13 -06002243 * chosen filter.
2244 */
Glenn Randers-Pehrson6ef579d2015-01-27 07:02:46 -06002245static void /* PRIVATE */
Glenn Randers-Pehrson24afd072014-03-05 16:55:19 -06002246png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05002247 png_size_t row_bytes);
John Bowlerc5bef942011-05-05 17:35:39 -05002248
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002249#ifdef PNG_WRITE_FILTER_SUPPORTED
2250static png_size_t /* PRIVATE */
2251png_setup_sub_row(png_structrp png_ptr, const png_uint_32 bpp,
2252 const png_size_t row_bytes, const png_size_t lmins)
2253{
2254 png_bytep rp, dp, lp;
2255 png_size_t i;
2256 png_size_t sum = 0;
2257 int v;
2258
2259 png_ptr->try_row[0] = PNG_FILTER_VALUE_SUB;
2260
2261 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1; i < bpp;
2262 i++, rp++, dp++)
2263 {
2264 v = *dp = *rp;
2265 sum += (v < 128) ? v : 256 - v;
2266 }
2267
2268 for (lp = png_ptr->row_buf + 1; i < row_bytes;
2269 i++, rp++, lp++, dp++)
2270 {
2271 v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
2272 sum += (v < 128) ? v : 256 - v;
2273
2274 if (sum > lmins) /* We are already worse, don't continue. */
2275 break;
2276 }
2277
2278 return (sum);
2279}
2280
2281static png_size_t /* PRIVATE */
2282png_setup_up_row(png_structrp png_ptr, const png_size_t row_bytes,
2283 const png_size_t lmins)
2284{
2285 png_bytep rp, dp, pp;
2286 png_size_t i;
2287 png_size_t sum = 0;
2288 int v;
2289
2290 png_ptr->try_row[0] = PNG_FILTER_VALUE_UP;
2291
2292 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
2293 pp = png_ptr->prev_row + 1; i < row_bytes;
2294 i++, rp++, pp++, dp++)
2295 {
2296 v = *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
2297 sum += (v < 128) ? v : 256 - v;
2298
2299 if (sum > lmins) /* We are already worse, don't continue. */
2300 break;
2301 }
2302
2303 return (sum);
2304}
2305
2306static png_size_t /* PRIVATE */
2307png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp,
2308 const png_size_t row_bytes, const png_size_t lmins)
2309{
2310 png_bytep rp, dp, pp, lp;
2311 png_uint_32 i;
2312 png_size_t sum = 0;
2313 int v;
2314
2315 png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG;
2316
2317 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
2318 pp = png_ptr->prev_row + 1; i < bpp; i++)
2319 {
2320 v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
2321
2322 sum += (v < 128) ? v : 256 - v;
2323 }
2324
2325 for (lp = png_ptr->row_buf + 1; i < row_bytes; i++)
2326 {
2327 v = *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
2328 & 0xff);
2329
2330 sum += (v < 128) ? v : 256 - v;
2331
2332 if (sum > lmins) /* We are already worse, don't continue. */
2333 break;
2334 }
2335
2336 return (sum);
2337}
2338
2339static png_size_t /* PRIVATE */
2340png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
2341 const png_size_t row_bytes, const png_size_t lmins)
2342{
2343 png_bytep rp, dp, pp, cp, lp;
2344 png_size_t i;
2345 png_size_t sum = 0;
2346 int v;
2347
2348 png_ptr->try_row[0] = PNG_FILTER_VALUE_PAETH;
2349
2350 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
2351 pp = png_ptr->prev_row + 1; i < bpp; i++)
2352 {
2353 v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
2354
2355 sum += (v < 128) ? v : 256 - v;
2356 }
2357
2358 for (lp = png_ptr->row_buf + 1, cp = png_ptr->prev_row + 1; i < row_bytes;
2359 i++)
2360 {
2361 int a, b, c, pa, pb, pc, p;
2362
2363 b = *pp++;
2364 c = *cp++;
2365 a = *lp++;
2366
2367 p = b - c;
2368 pc = a - c;
2369
2370#ifdef PNG_USE_ABS
2371 pa = abs(p);
2372 pb = abs(pc);
2373 pc = abs(p + pc);
2374#else
2375 pa = p < 0 ? -p : p;
2376 pb = pc < 0 ? -pc : pc;
2377 pc = (p + pc) < 0 ? -(p + pc) : p + pc;
2378#endif
2379
2380 p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
2381
2382 v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
2383
2384 sum += (v < 128) ? v : 256 - v;
2385
2386 if (sum > lmins) /* We are already worse, don't continue. */
2387 break;
2388 }
2389
2390 return (sum);
2391}
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002392#endif /* WRITE_FILTER */
2393
Glenn Randers-Pehrson75294572000-05-06 14:09:57 -05002394void /* PRIVATE */
John Bowler5d567862011-12-24 09:12:00 -06002395png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
Guy Schalnat0d580581995-07-20 02:43:20 -05002396{
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002397#ifndef PNG_WRITE_FILTER_SUPPORTED
2398 png_write_filtered_row(png_ptr, png_ptr->row_buf, row_info->rowbytes+1);
2399#else
John Bowler9c04f572016-06-19 18:01:33 -05002400 unsigned int filter_to_do = png_ptr->do_filter;
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002401 png_bytep row_buf;
2402 png_bytep best_row;
2403 png_uint_32 bpp;
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002404 png_size_t mins;
2405 png_size_t row_bytes = row_info->rowbytes;
Glenn Randers-Pehrson9d8b41e2009-07-19 14:45:43 -05002406
2407 png_debug(1, "in png_write_find_filter");
2408
Glenn Randers-Pehrson4bb4d012009-05-20 12:45:29 -05002409 /* Find out how many bytes offset each pixel is */
Glenn Randers-Pehrson272489d2004-08-04 06:34:52 -05002410 bpp = (row_info->pixel_depth + 7) >> 3;
Guy Schalnate5a37791996-06-05 15:50:50 -05002411
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002412 row_buf = png_ptr->row_buf;
2413 mins = PNG_SIZE_MAX - 256/* so we can detect potential overflow of the
2414 running sum */;
Guy Schalnat0d580581995-07-20 02:43:20 -05002415
Andreas Dilger47a0c421997-05-16 02:46:07 -05002416 /* The prediction method we use is to find which method provides the
2417 * smallest value when summing the absolute values of the distances
Glenn Randers-Pehrson8686fff1998-05-21 09:27:50 -05002418 * from zero, using anything >= 128 as negative numbers. This is known
Andreas Dilger47a0c421997-05-16 02:46:07 -05002419 * as the "minimum sum of absolute differences" heuristic. Other
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002420 * heuristics are the "weighted minimum sum of absolute differences"
Andreas Dilger47a0c421997-05-16 02:46:07 -05002421 * (experimental and can in theory improve compression), and the "zlib
Glenn Randers-Pehrsonf7d1a171998-06-06 15:31:35 -05002422 * predictive" method (not implemented yet), which does test compressions
2423 * of lines using different filter methods, and then chooses the
2424 * (series of) filter(s) that give minimum compressed data size (VERY
Andreas Dilger47a0c421997-05-16 02:46:07 -05002425 * computationally expensive).
Glenn Randers-Pehrsonf7d1a171998-06-06 15:31:35 -05002426 *
2427 * GRR 980525: consider also
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05002428 *
Glenn Randers-Pehrsonf7d1a171998-06-06 15:31:35 -05002429 * (1) minimum sum of absolute differences from running average (i.e.,
2430 * keep running sum of non-absolute differences & count of bytes)
2431 * [track dispersion, too? restart average if dispersion too large?]
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05002432 *
Glenn Randers-Pehrsonf7d1a171998-06-06 15:31:35 -05002433 * (1b) minimum sum of absolute differences from sliding average, probably
2434 * with window size <= deflate window (usually 32K)
Glenn Randers-Pehrsonccadcae2010-10-23 17:29:13 -05002435 *
Glenn Randers-Pehrsonf7d1a171998-06-06 15:31:35 -05002436 * (2) minimum sum of squared differences from zero or running average
2437 * (i.e., ~ root-mean-square approach)
Andreas Dilger47a0c421997-05-16 02:46:07 -05002438 */
Guy Schalnat51f0eb41995-09-26 05:22:39 -05002439
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002440
Guy Schalnate5a37791996-06-05 15:50:50 -05002441 /* We don't need to test the 'no filter' case if this is the only filter
Andreas Dilger47a0c421997-05-16 02:46:07 -05002442 * that has been chosen, as it doesn't actually do anything to the data.
2443 */
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002444 best_row = png_ptr->row_buf;
2445
John Bowler9c04f572016-06-19 18:01:33 -05002446 if (PNG_SIZE_MAX/128 <= row_bytes)
Guy Schalnat0d580581995-07-20 02:43:20 -05002447 {
John Bowler9c04f572016-06-19 18:01:33 -05002448 /* Overflow can occur in the calculation, just select the lowest set
2449 * filter.
2450 */
Glenn Randers-Pehrson4b4a9582016-06-23 10:58:24 -05002451 filter_to_do &= -filter_to_do;
John Bowler9c04f572016-06-19 18:01:33 -05002452 }
2453 else if ((filter_to_do & PNG_FILTER_NONE) != 0 &&
2454 filter_to_do != PNG_FILTER_NONE)
2455 {
2456 /* Overflow not possible and multiple filters in the list, including the
2457 * 'none' filter.
2458 */
Guy Schalnate5a37791996-06-05 15:50:50 -05002459 png_bytep rp;
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002460 png_size_t sum = 0;
Glenn Randers-Pehrsonbcb3aac2010-09-10 22:05:27 -05002461 png_size_t i;
Andreas Dilger47a0c421997-05-16 02:46:07 -05002462 int v;
Guy Schalnat0d580581995-07-20 02:43:20 -05002463
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002464 {
2465 for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
2466 {
2467 v = *rp;
2468 sum += (v < 128) ? v : 256 - v;
2469 }
2470 }
2471
Guy Schalnate5a37791996-06-05 15:50:50 -05002472 mins = sum;
Guy Schalnat0d580581995-07-20 02:43:20 -05002473 }
2474
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002475 /* Sub filter */
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002476 if (filter_to_do == PNG_FILTER_SUB)
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002477 /* It's the only filter so no testing is needed */
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002478 {
Glenn Randers-Pehrson147dc562016-06-19 22:20:52 -05002479 /* Passing PNG_SIZE_MAX here and below prevents the 'setup' function
Glenn Randers-Pehrson4b4a9582016-06-23 10:58:24 -05002480 * breaking out of the loop when lmins is exceeded. Optimizing
2481 * compilers should notice that we don't use the returned sum, and
2482 * therefore 'setup' should refrain from calculating and returning "sum".
Glenn Randers-Pehrson147dc562016-06-19 22:20:52 -05002483 */
2484 (void) png_setup_sub_row(png_ptr, bpp, row_bytes, PNG_SIZE_MAX);
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002485 best_row = png_ptr->try_row;
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002486 }
2487
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05002488 else if ((filter_to_do & PNG_FILTER_SUB) != 0)
Guy Schalnat0d580581995-07-20 02:43:20 -05002489 {
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002490 png_size_t sum;
2491 png_size_t lmins = mins;
Guy Schalnat0d580581995-07-20 02:43:20 -05002492
Glenn Randers-Pehrson92ec30a2015-11-24 07:34:37 -06002493 sum = png_setup_sub_row(png_ptr, bpp, row_bytes, lmins);
Andreas Dilger47a0c421997-05-16 02:46:07 -05002494
Guy Schalnate5a37791996-06-05 15:50:50 -05002495 if (sum < mins)
2496 {
2497 mins = sum;
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002498 best_row = png_ptr->try_row;
2499 if (png_ptr->tst_row != NULL)
2500 {
2501 png_ptr->try_row = png_ptr->tst_row;
2502 png_ptr->tst_row = best_row;
2503 }
Guy Schalnate5a37791996-06-05 15:50:50 -05002504 }
Guy Schalnat0d580581995-07-20 02:43:20 -05002505 }
2506
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002507 /* Up filter */
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002508 if (filter_to_do == PNG_FILTER_UP)
2509 {
Glenn Randers-Pehrson147dc562016-06-19 22:20:52 -05002510 (void) png_setup_up_row(png_ptr, row_bytes, PNG_SIZE_MAX);
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002511 best_row = png_ptr->try_row;
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002512 }
2513
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05002514 else if ((filter_to_do & PNG_FILTER_UP) != 0)
Guy Schalnat0d580581995-07-20 02:43:20 -05002515 {
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002516 png_size_t sum;
2517 png_size_t lmins = mins;
Guy Schalnate5a37791996-06-05 15:50:50 -05002518
Glenn Randers-Pehrson92ec30a2015-11-24 07:34:37 -06002519 sum = png_setup_up_row(png_ptr, row_bytes, lmins);
Andreas Dilger47a0c421997-05-16 02:46:07 -05002520
Guy Schalnate5a37791996-06-05 15:50:50 -05002521 if (sum < mins)
2522 {
2523 mins = sum;
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002524 best_row = png_ptr->try_row;
2525 if (png_ptr->tst_row != NULL)
2526 {
2527 png_ptr->try_row = png_ptr->tst_row;
2528 png_ptr->tst_row = best_row;
2529 }
Guy Schalnate5a37791996-06-05 15:50:50 -05002530 }
Guy Schalnat51f0eb41995-09-26 05:22:39 -05002531 }
2532
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002533 /* Avg filter */
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002534 if (filter_to_do == PNG_FILTER_AVG)
2535 {
Glenn Randers-Pehrson147dc562016-06-19 22:20:52 -05002536 (void) png_setup_avg_row(png_ptr, bpp, row_bytes, PNG_SIZE_MAX);
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002537 best_row = png_ptr->try_row;
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002538 }
2539
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05002540 else if ((filter_to_do & PNG_FILTER_AVG) != 0)
Guy Schalnat51f0eb41995-09-26 05:22:39 -05002541 {
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002542 png_size_t sum;
2543 png_size_t lmins = mins;
Guy Schalnate5a37791996-06-05 15:50:50 -05002544
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002545 sum= png_setup_avg_row(png_ptr, bpp, row_bytes, lmins);
Andreas Dilger47a0c421997-05-16 02:46:07 -05002546
Guy Schalnate5a37791996-06-05 15:50:50 -05002547 if (sum < mins)
2548 {
2549 mins = sum;
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002550 best_row = png_ptr->try_row;
2551 if (png_ptr->tst_row != NULL)
2552 {
2553 png_ptr->try_row = png_ptr->tst_row;
2554 png_ptr->tst_row = best_row;
2555 }
Guy Schalnate5a37791996-06-05 15:50:50 -05002556 }
Guy Schalnat51f0eb41995-09-26 05:22:39 -05002557 }
2558
Andreas Dilger47a0c421997-05-16 02:46:07 -05002559 /* Paeth filter */
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05002560 if ((filter_to_do == PNG_FILTER_PAETH) != 0)
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002561 {
Glenn Randers-Pehrson147dc562016-06-19 22:20:52 -05002562 (void) png_setup_paeth_row(png_ptr, bpp, row_bytes, PNG_SIZE_MAX);
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002563 best_row = png_ptr->try_row;
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002564 }
2565
Glenn Randers-Pehrson5d713fe2014-10-31 20:48:55 -05002566 else if ((filter_to_do & PNG_FILTER_PAETH) != 0)
Guy Schalnat51f0eb41995-09-26 05:22:39 -05002567 {
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002568 png_size_t sum;
2569 png_size_t lmins = mins;
Guy Schalnate5a37791996-06-05 15:50:50 -05002570
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002571 sum = png_setup_paeth_row(png_ptr, bpp, row_bytes, lmins);
Andreas Dilger47a0c421997-05-16 02:46:07 -05002572
Guy Schalnate5a37791996-06-05 15:50:50 -05002573 if (sum < mins)
2574 {
Glenn Randers-Pehrsone6877672015-05-30 11:54:45 -05002575 best_row = png_ptr->try_row;
2576 if (png_ptr->tst_row != NULL)
2577 {
2578 png_ptr->try_row = png_ptr->tst_row;
2579 png_ptr->tst_row = best_row;
2580 }
Guy Schalnate5a37791996-06-05 15:50:50 -05002581 }
Guy Schalnat51f0eb41995-09-26 05:22:39 -05002582 }
Glenn Randers-Pehrson896239b1998-04-21 15:03:57 -05002583
Glenn Randers-Pehrsonbb5cb142011-09-22 12:41:58 -05002584 /* Do the actual writing of the filtered row data from the chosen filter. */
2585 png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1);
Andreas Dilger47a0c421997-05-16 02:46:07 -05002586
Glenn Randers-Pehrsoncda68df2014-11-06 22:11:39 -06002587#endif /* WRITE_FILTER */
Guy Schalnate5a37791996-06-05 15:50:50 -05002588}
2589
2590
Andreas Dilger47a0c421997-05-16 02:46:07 -05002591/* Do the actual writing of a previously filtered row. */
John Bowlerc5bef942011-05-05 17:35:39 -05002592static void
John Bowler5d567862011-12-24 09:12:00 -06002593png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06002594 png_size_t full_row_length/*includes filter byte*/)
Guy Schalnate5a37791996-06-05 15:50:50 -05002595{
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05002596 png_debug(1, "in png_write_filtered_row");
Glenn Randers-Pehrson3358a982009-08-13 18:04:26 -05002597
Glenn Randers-Pehrson51650b82008-08-05 07:44:42 -05002598 png_debug1(2, "filter = %d", filtered_row[0]);
Glenn Randers-Pehrson5e5c1e12000-11-10 12:26:19 -06002599
Glenn Randers-Pehrson871b1d02013-03-02 14:58:22 -06002600 png_compress_IDAT(png_ptr, filtered_row, full_row_length, Z_NO_FLUSH);
Guy Schalnate5a37791996-06-05 15:50:50 -05002601
Glenn Randers-Pehrson6ef579d2015-01-27 07:02:46 -06002602#ifdef PNG_WRITE_FILTER_SUPPORTED
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002603 /* Swap the current and previous rows */
Andreas Dilger47a0c421997-05-16 02:46:07 -05002604 if (png_ptr->prev_row != NULL)
Guy Schalnatc21f90c1996-06-17 16:24:45 -05002605 {
2606 png_bytep tptr;
2607
2608 tptr = png_ptr->prev_row;
2609 png_ptr->prev_row = png_ptr->row_buf;
2610 png_ptr->row_buf = tptr;
2611 }
Glenn Randers-Pehrson6ef579d2015-01-27 07:02:46 -06002612#endif /* WRITE_FILTER */
Guy Schalnatc21f90c1996-06-17 16:24:45 -05002613
Glenn Randers-Pehrson glennrp@comcast.netb1c0d332009-05-15 20:39:34 -05002614 /* Finish row - updates counters and flushes zlib if last row */
Guy Schalnate5a37791996-06-05 15:50:50 -05002615 png_write_finish_row(png_ptr);
2616
Glenn Randers-Pehrsone26c0952009-09-23 11:22:08 -05002617#ifdef PNG_WRITE_FLUSH_SUPPORTED
Guy Schalnate5a37791996-06-05 15:50:50 -05002618 png_ptr->flush_rows++;
2619
2620 if (png_ptr->flush_dist > 0 &&
2621 png_ptr->flush_rows >= png_ptr->flush_dist)
Guy Schalnat0d580581995-07-20 02:43:20 -05002622 {
Guy Schalnate5a37791996-06-05 15:50:50 -05002623 png_write_flush(png_ptr);
Guy Schalnat0d580581995-07-20 02:43:20 -05002624 }
Glenn Randers-Pehrsoncda68df2014-11-06 22:11:39 -06002625#endif /* WRITE_FLUSH */
Guy Schalnat0d580581995-07-20 02:43:20 -05002626}
Glenn Randers-Pehrsoncda68df2014-11-06 22:11:39 -06002627#endif /* WRITE */