Imported Upstream version 1.6.13
[platform/upstream/libpng.git] / pngwutil.c
1
2 /* pngwutil.c - utilities to write a PNG file
3  *
4  * Last changed in libpng 1.6.11 [June 5, 2014]
5  * Copyright (c) 1998-2014 Glenn Randers-Pehrson
6  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
7  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
8  *
9  * This code is released under the libpng license.
10  * For conditions of distribution and use, see the disclaimer
11  * and license in png.h
12  */
13
14 #include "pngpriv.h"
15
16 #ifdef PNG_WRITE_SUPPORTED
17
18 #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
19 /* Place a 32-bit number into a buffer in PNG byte order.  We work
20  * with unsigned numbers for convenience, although one supported
21  * ancillary chunk uses signed (two's complement) numbers.
22  */
23 void PNGAPI
24 png_save_uint_32(png_bytep buf, png_uint_32 i)
25 {
26    buf[0] = (png_byte)((i >> 24) & 0xff);
27    buf[1] = (png_byte)((i >> 16) & 0xff);
28    buf[2] = (png_byte)((i >> 8) & 0xff);
29    buf[3] = (png_byte)(i & 0xff);
30 }
31
32 /* Place a 16-bit number into a buffer in PNG byte order.
33  * The parameter is declared unsigned int, not png_uint_16,
34  * just to avoid potential problems on pre-ANSI C compilers.
35  */
36 void PNGAPI
37 png_save_uint_16(png_bytep buf, unsigned int i)
38 {
39    buf[0] = (png_byte)((i >> 8) & 0xff);
40    buf[1] = (png_byte)(i & 0xff);
41 }
42 #endif
43
44 /* Simple function to write the signature.  If we have already written
45  * the magic bytes of the signature, or more likely, the PNG stream is
46  * being embedded into another stream and doesn't need its own signature,
47  * we should call png_set_sig_bytes() to tell libpng how many of the
48  * bytes have already been written.
49  */
50 void PNGAPI
51 png_write_sig(png_structrp png_ptr)
52 {
53    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
54
55 #ifdef PNG_IO_STATE_SUPPORTED
56    /* Inform the I/O callback that the signature is being written */
57    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE;
58 #endif
59
60    /* Write the rest of the 8 byte signature */
61    png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
62       (png_size_t)(8 - png_ptr->sig_bytes));
63
64    if (png_ptr->sig_bytes < 3)
65       png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
66 }
67
68 /* Write the start of a PNG chunk.  The type is the chunk type.
69  * The total_length is the sum of the lengths of all the data you will be
70  * passing in png_write_chunk_data().
71  */
72 static void
73 png_write_chunk_header(png_structrp png_ptr, png_uint_32 chunk_name,
74     png_uint_32 length)
75 {
76    png_byte buf[8];
77
78 #if defined(PNG_DEBUG) && (PNG_DEBUG > 0)
79    PNG_CSTRING_FROM_CHUNK(buf, chunk_name);
80    png_debug2(0, "Writing %s chunk, length = %lu", buf, (unsigned long)length);
81 #endif
82
83    if (png_ptr == NULL)
84       return;
85
86 #ifdef PNG_IO_STATE_SUPPORTED
87    /* Inform the I/O callback that the chunk header is being written.
88     * PNG_IO_CHUNK_HDR requires a single I/O call.
89     */
90    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;
91 #endif
92
93    /* Write the length and the chunk name */
94    png_save_uint_32(buf, length);
95    png_save_uint_32(buf + 4, chunk_name);
96    png_write_data(png_ptr, buf, 8);
97
98    /* Put the chunk name into png_ptr->chunk_name */
99    png_ptr->chunk_name = chunk_name;
100
101    /* Reset the crc and run it over the chunk name */
102    png_reset_crc(png_ptr);
103
104    png_calculate_crc(png_ptr, buf + 4, 4);
105
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
112 }
113
114 void PNGAPI
115 png_write_chunk_start(png_structrp png_ptr, png_const_bytep chunk_string,
116     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().
122  * Note that multiple calls to this function are allowed, and that the
123  * sum of the lengths from these calls *must* add up to the total_length
124  * given to png_write_chunk_header().
125  */
126 void PNGAPI
127 png_write_chunk_data(png_structrp png_ptr, png_const_bytep data,
128     png_size_t length)
129 {
130    /* Write the data, and run the CRC over it */
131    if (png_ptr == NULL)
132       return;
133
134    if (data != NULL && length > 0)
135    {
136       png_write_data(png_ptr, data, length);
137
138       /* Update the CRC after writing the data,
139        * in case that the user I/O routine alters it.
140        */
141       png_calculate_crc(png_ptr, data, length);
142    }
143 }
144
145 /* Finish a chunk started with png_write_chunk_header(). */
146 void PNGAPI
147 png_write_chunk_end(png_structrp png_ptr)
148 {
149    png_byte buf[4];
150
151    if (png_ptr == NULL) return;
152
153 #ifdef PNG_IO_STATE_SUPPORTED
154    /* Inform the I/O callback that the chunk CRC is being written.
155     * PNG_IO_CHUNK_CRC requires a single I/O function call.
156     */
157    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;
158 #endif
159
160    /* Write the crc in a single operation */
161    png_save_uint_32(buf, png_ptr->crc);
162
163    png_write_data(png_ptr, buf, (png_size_t)4);
164 }
165
166 /* Write a PNG chunk all at once.  The type is an array of ASCII characters
167  * representing the chunk name.  The array must be at least 4 bytes in
168  * length, and does not need to be null terminated.  To be safe, pass the
169  * pre-defined chunk names here, and if you need a new one, define it
170  * where the others are defined.  The length is the length of the data.
171  * All the data must be present.  If that is not possible, use the
172  * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
173  * functions instead.
174  */
175 static void
176 png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name,
177    png_const_bytep data, png_size_t length)
178 {
179    if (png_ptr == NULL)
180       return;
181
182    /* On 64 bit architectures 'length' may not fit in a png_uint_32. */
183    if (length > PNG_UINT_31_MAX)
184       png_error(png_ptr, "length exceeds PNG maxima");
185
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. */
192 void PNGAPI
193 png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string,
194    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
200 /* This is used below to find the size of an image to pass to png_deflate_claim,
201  * so it only needs to be accurate if the size is less than 16384 bytes (the
202  * point at which a lower LZ window size can be used.)
203  */
204 static png_alloc_size_t
205 png_image_size(png_structrp png_ptr)
206 {
207    /* Only return sizes up to the maximum of a png_uint_32, do this by limiting
208     * the width and height used to 15 bits.
209     */
210    png_uint_32 h = png_ptr->height;
211
212    if (png_ptr->rowbytes < 32768 && h < 32768)
213    {
214       if (png_ptr->interlaced)
215       {
216          /* 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;
223
224          for (cb_base=0, pass=0; pass<=6; ++pass)
225          {
226             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);
230          }
231
232          return cb_base;
233       }
234
235       else
236          return (png_ptr->rowbytes+1) * h;
237    }
238
239    else
240       return 0xffffffffU;
241 }
242
243 #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
244    /* This is the code to hack the first two bytes of the deflate stream (the
245     * deflate header) to correct the windowBits value to match the actual data
246     * size.  Note that the second argument is the *uncompressed* size but the
247     * first argument is the *compressed* data (and it must be deflate
248     * compressed.)
249     */
250 static void
251 optimize_cmf(png_bytep data, png_alloc_size_t data_size)
252 {
253    /* 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 */
257    {
258       unsigned int z_cmf = data[0];  /* zlib compression method and flags */
259
260       if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)
261       {
262          unsigned int z_cinfo;
263          unsigned int half_z_window_size;
264
265          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 */
269          {
270             unsigned int tmp;
271
272             do
273             {
274                half_z_window_size >>= 1;
275                --z_cinfo;
276             }
277             while (z_cinfo > 0 && data_size <= half_z_window_size);
278
279             z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
280
281             data[0] = (png_byte)z_cmf;
282             tmp = data[1] & 0xe0;
283             tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f;
284             data[1] = (png_byte)tmp;
285          }
286       }
287    }
288 }
289 #else
290 #  define optimize_cmf(dp,dl) ((void)0)
291 #endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */
292
293 /* Initialize the compressor for the appropriate type of compression. */
294 static int
295 png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
296    png_alloc_size_t data_size)
297 {
298    if (png_ptr->zowner != 0)
299    {
300       char msg[64];
301
302       PNG_STRING_FROM_CHUNK(msg, owner);
303       msg[4] = ':';
304       msg[5] = ' ';
305       PNG_STRING_FROM_CHUNK(msg+6, png_ptr->zowner);
306       /* So the message that results is "<chunk> using zstream"; this is an
307        * internal error, but is very useful for debugging.  i18n requirements
308        * are minimal.
309        */
310       (void)png_safecat(msg, (sizeof msg), 10, " using zstream");
311 #     if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC
312          png_warning(png_ptr, msg);
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;
322 #     else
323          png_error(png_ptr, msg);
324 #     endif
325    }
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       {
337          if (png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY)
338             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       {
349 #        ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
350             level = png_ptr->zlib_text_level;
351             method = png_ptr->zlib_text_method;
352             windowBits = png_ptr->zlib_text_window_bits;
353             memLevel = png_ptr->zlib_text_mem_level;
354             strategy = png_ptr->zlib_text_strategy;
355 #        else
356             /* If customization is not supported the values all come from the
357              * IDAT values except for the strategy, which is fixed to the
358              * default.  (This is the pre-1.6.0 behavior too, although it was
359              * implemented in a very different way.)
360              */
361             strategy = Z_DEFAULT_STRATEGY;
362 #        endif
363       }
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. */
389       if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) &&
390          (png_ptr->zlib_set_level != level ||
391          png_ptr->zlib_set_method != method ||
392          png_ptr->zlib_set_window_bits != windowBits ||
393          png_ptr->zlib_set_mem_level != memLevel ||
394          png_ptr->zlib_set_strategy != strategy))
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        */
413       if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED)
414          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. */
439 void /* PRIVATE */
440 png_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    }
457 }
458
459 #ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
460 /* This pair of functions encapsulates the operation of (a) compressing a
461  * text string, and (b) issuing it later as a series of chunk data writes.
462  * The compression_state structure is shared context for these functions
463  * set up by the caller to allow access to the relevant local variables.
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.)
469  */
470 typedef struct
471 {
472    png_const_bytep      input;        /* The uncompressed input data */
473    png_alloc_size_t     input_len;    /* Its length */
474    png_uint_32          output_len;   /* Final compressed length */
475    png_byte             output[1024]; /* First block of output */
476 } compression_state;
477
478 static void
479 png_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 */
488 static int
489 png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name,
490    compression_state *comp, png_uint_32 prefix_len)
491 {
492    int ret;
493
494    /* To find the length of the output it is necessary to first compress the
495     * input, the result is buffered rather than using the two-pass algorithm
496     * that is used on the inflate side; deflate is assumed to be slower and a
497     * PNG writer is assumed to have more memory available than a PNG reader.
498     *
499     * IMPLEMENTATION NOTE: the zlib API deflateBound() can be used to find an
500     * upper limit on the output size, but it is always bigger than the input
501     * size so it is likely to be more efficient to use this linked-list
502     * approach.
503     */
504    ret = png_deflate_claim(png_ptr, chunk_name, comp->input_len);
505
506    if (ret != Z_OK)
507       return ret;
508
509    /* Set up the compression buffers, we need a loop here to avoid overflowing a
510     * uInt.  Use ZLIB_IO_MAX to limit the input.  The output is always limited
511     * by the output buffer size, so there is no need to check that.  Since this
512     * is ANSI-C we know that an 'int', hence a uInt, is always at least 16 bits
513     * in size.
514     */
515    {
516       png_compression_bufferp *end = &png_ptr->zbuffer_list;
517       png_alloc_size_t input_len = comp->input_len; /* may be zero! */
518       png_uint_32 output_len;
519
520       /* zlib updates these for us: */
521       png_ptr->zstream.next_in = PNGZ_INPUT_CAST(comp->input);
522       png_ptr->zstream.avail_in = 0; /* Set below */
523       png_ptr->zstream.next_out = comp->output;
524       png_ptr->zstream.avail_out = (sizeof comp->output);
525
526       output_len = png_ptr->zstream.avail_out;
527
528       do
529       {
530          uInt avail_in = ZLIB_IO_MAX;
531
532          if (avail_in > input_len)
533             avail_in = (uInt)input_len;
534
535          input_len -= avail_in;
536
537          png_ptr->zstream.avail_in = avail_in;
538
539          if (png_ptr->zstream.avail_out == 0)
540          {
541             png_compression_buffer *next;
542
543             /* 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)
547             {
548                ret = Z_MEM_ERROR;
549                break;
550             }
551
552             /* Need a new (malloc'ed) buffer, but there may be one present
553              * already.
554              */
555             next = *end;
556             if (next == NULL)
557             {
558                next = png_voidcast(png_compression_bufferp, png_malloc_base
559                   (png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
560
561                if (next == NULL)
562                {
563                   ret = Z_MEM_ERROR;
564                   break;
565                }
566
567                /* Link in this buffer (so that it will be freed later) */
568                next->next = NULL;
569                *end = next;
570             }
571
572             png_ptr->zstream.next_out = next->output;
573             png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
574             output_len += png_ptr->zstream.avail_out;
575
576             /* Move 'end' to the next buffer pointer. */
577             end = &next->next;
578          }
579
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 */
589       }
590       while (ret == Z_OK);
591
592       /* There may be some space left in the last output buffer, this needs to
593        * 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)
604       {
605          png_ptr->zstream.msg = PNGZ_MSG_CAST("compressed data too long");
606          ret = Z_MEM_ERROR;
607       }
608
609       else
610          png_zstream_error(png_ptr, ret);
611
612       /* Reset zlib for another zTXt/iTXt or image data */
613       png_ptr->zowner = 0;
614
615       /* The only success case is Z_STREAM_END, input_len must be 0, if not this
616        * is an internal error.
617        */
618       if (ret == Z_STREAM_END && input_len == 0)
619       {
620          /* Fix up the deflate header, if required */
621          optimize_cmf(comp->output, comp->input_len);
622
623          /* But Z_OK is returned, not Z_STREAM_END; this allows the claim
624           * function above to return Z_STREAM_END on an error (though it never
625           * does in the current versions of zlib.)
626           */
627          return Z_OK;
628       }
629
630       else
631          return ret;
632    }
633 }
634
635 /* Ship the compressed text out via chunk writes */
636 static void
637 png_write_compressed_data_out(png_structrp png_ptr, compression_state *comp)
638 {
639    png_uint_32 output_len = comp->output_len;
640    png_const_bytep output = comp->output;
641    png_uint_32 avail = (sizeof comp->output);
642    png_compression_buffer *next = png_ptr->zbuffer_list;
643
644    for (;;)
645    {
646       if (avail > output_len)
647          avail = output_len;
648
649       png_write_chunk_data(png_ptr, output, avail);
650
651       output_len -= avail;
652
653       if (output_len == 0 || next == NULL)
654          break;
655
656       avail = png_ptr->zbuffer_size;
657       output = next->output;
658       next = next->next;
659    }
660
661    /* This is an internal error; 'next' must have been NULL! */
662    if (output_len > 0)
663       png_error(png_ptr, "error writing ancillary chunked compressed data");
664 }
665 #endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */
666
667 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
668     defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
669 /* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
670  * and if invalid, correct the keyword rather than discarding the entire
671  * chunk.  The PNG 1.0 specification requires keywords 1-79 characters in
672  * length, forbids leading or trailing whitespace, multiple internal spaces,
673  * and the non-break space (0x80) from ISO 8859-1.  Returns keyword length.
674  *
675  * The 'new_key' buffer must be 80 characters in size (for the keyword plus a
676  * trailing '\0').  If this routine returns 0 then there was no keyword, or a
677  * valid one could not be generated, and the caller must png_error.
678  */
679 static png_uint_32
680 png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)
681 {
682    png_const_charp orig_key = key;
683    png_uint_32 key_len = 0;
684    int bad_character = 0;
685    int space = 1;
686
687    png_debug(1, "in png_check_keyword");
688
689    if (key == NULL)
690    {
691       *new_key = 0;
692       return 0;
693    }
694
695    while (*key && key_len < 79)
696    {
697       png_byte ch = (png_byte)(0xff & *key++);
698
699       if ((ch > 32 && ch <= 126) || (ch >= 161 /*&& ch <= 255*/))
700          *new_key++ = ch, ++key_len, space = 0;
701
702       else if (space == 0)
703       {
704          /* A space or an invalid character when one wasn't seen immediately
705           * before; output just a space.
706           */
707          *new_key++ = 32, ++key_len, space = 1;
708
709          /* If the character was not a space then it is invalid. */
710          if (ch != 32)
711             bad_character = ch;
712       }
713
714       else if (bad_character == 0)
715          bad_character = ch; /* just skip it, record the first error */
716    }
717
718    if (key_len > 0 && space) /* trailing space */
719    {
720       --key_len, --new_key;
721       if (bad_character == 0)
722          bad_character = 32;
723    }
724
725    /* Terminate the keyword */
726    *new_key = 0;
727
728    if (key_len == 0)
729       return 0;
730
731    /* Try to only output one warning per keyword: */
732    if (*key) /* keyword too long */
733       png_warning(png_ptr, "keyword truncated");
734
735    else if (bad_character != 0)
736    {
737       PNG_WARNING_PARAMETERS(p)
738
739       png_warning_parameter(p, 1, orig_key);
740       png_warning_parameter_signed(p, 2, PNG_NUMBER_FORMAT_02x, bad_character);
741
742       png_formatted_warning(png_ptr, p, "keyword \"@1\": bad character '0x@2'");
743    }
744
745    return key_len;
746 }
747 #endif
748
749 /* Write the IHDR chunk, and update the png_struct with the necessary
750  * information.  Note that the rest of this code depends upon this
751  * information being correct.
752  */
753 void /* PRIVATE */
754 png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,
755     int bit_depth, int color_type, int compression_type, int filter_type,
756     int interlace_type)
757 {
758    png_byte buf[13]; /* Buffer to store the IHDR info */
759
760    png_debug(1, "in png_write_IHDR");
761
762    /* Check that we have valid input data from the application info */
763    switch (color_type)
764    {
765       case PNG_COLOR_TYPE_GRAY:
766          switch (bit_depth)
767          {
768             case 1:
769             case 2:
770             case 4:
771             case 8:
772 #ifdef PNG_WRITE_16BIT_SUPPORTED
773             case 16:
774 #endif
775                png_ptr->channels = 1; break;
776
777             default:
778                png_error(png_ptr,
779                    "Invalid bit depth for grayscale image");
780          }
781          break;
782
783       case PNG_COLOR_TYPE_RGB:
784 #ifdef PNG_WRITE_16BIT_SUPPORTED
785          if (bit_depth != 8 && bit_depth != 16)
786 #else
787          if (bit_depth != 8)
788 #endif
789             png_error(png_ptr, "Invalid bit depth for RGB image");
790
791          png_ptr->channels = 3;
792          break;
793
794       case PNG_COLOR_TYPE_PALETTE:
795          switch (bit_depth)
796          {
797             case 1:
798             case 2:
799             case 4:
800             case 8:
801                png_ptr->channels = 1;
802                break;
803
804             default:
805                png_error(png_ptr, "Invalid bit depth for paletted image");
806          }
807          break;
808
809       case PNG_COLOR_TYPE_GRAY_ALPHA:
810          if (bit_depth != 8 && bit_depth != 16)
811             png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");
812
813          png_ptr->channels = 2;
814          break;
815
816       case PNG_COLOR_TYPE_RGB_ALPHA:
817 #ifdef PNG_WRITE_16BIT_SUPPORTED
818          if (bit_depth != 8 && bit_depth != 16)
819 #else
820          if (bit_depth != 8)
821 #endif
822             png_error(png_ptr, "Invalid bit depth for RGBA image");
823
824          png_ptr->channels = 4;
825          break;
826
827       default:
828          png_error(png_ptr, "Invalid image color type specified");
829    }
830
831    if (compression_type != PNG_COMPRESSION_TYPE_BASE)
832    {
833       png_warning(png_ptr, "Invalid compression type specified");
834       compression_type = PNG_COMPRESSION_TYPE_BASE;
835    }
836
837    /* Write filter_method 64 (intrapixel differencing) only if
838     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
839     * 2. Libpng did not write a PNG signature (this filter_method is only
840     *    used in PNG datastreams that are embedded in MNG datastreams) and
841     * 3. The application called png_permit_mng_features with a mask that
842     *    included PNG_FLAG_MNG_FILTER_64 and
843     * 4. The filter_method is 64 and
844     * 5. The color_type is RGB or RGBA
845     */
846    if (
847 #ifdef PNG_MNG_FEATURES_SUPPORTED
848        !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
849        ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
850        (color_type == PNG_COLOR_TYPE_RGB ||
851         color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
852        (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&
853 #endif
854        filter_type != PNG_FILTER_TYPE_BASE)
855    {
856       png_warning(png_ptr, "Invalid filter type specified");
857       filter_type = PNG_FILTER_TYPE_BASE;
858    }
859
860 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
861    if (interlace_type != PNG_INTERLACE_NONE &&
862        interlace_type != PNG_INTERLACE_ADAM7)
863    {
864       png_warning(png_ptr, "Invalid interlace type specified");
865       interlace_type = PNG_INTERLACE_ADAM7;
866    }
867 #else
868    interlace_type=PNG_INTERLACE_NONE;
869 #endif
870
871    /* Save the relevent information */
872    png_ptr->bit_depth = (png_byte)bit_depth;
873    png_ptr->color_type = (png_byte)color_type;
874    png_ptr->interlaced = (png_byte)interlace_type;
875 #ifdef PNG_MNG_FEATURES_SUPPORTED
876    png_ptr->filter_type = (png_byte)filter_type;
877 #endif
878    png_ptr->compression_type = (png_byte)compression_type;
879    png_ptr->width = width;
880    png_ptr->height = height;
881
882    png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
883    png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);
884    /* Set the usr info, so any transformations can modify it */
885    png_ptr->usr_width = png_ptr->width;
886    png_ptr->usr_bit_depth = png_ptr->bit_depth;
887    png_ptr->usr_channels = png_ptr->channels;
888
889    /* Pack the header information into the buffer */
890    png_save_uint_32(buf, width);
891    png_save_uint_32(buf + 4, height);
892    buf[8] = (png_byte)bit_depth;
893    buf[9] = (png_byte)color_type;
894    buf[10] = (png_byte)compression_type;
895    buf[11] = (png_byte)filter_type;
896    buf[12] = (png_byte)interlace_type;
897
898    /* Write the chunk */
899    png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
900
901    if ((png_ptr->do_filter) == PNG_NO_FILTERS)
902    {
903       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
904           png_ptr->bit_depth < 8)
905          png_ptr->do_filter = PNG_FILTER_NONE;
906
907       else
908          png_ptr->do_filter = PNG_ALL_FILTERS;
909    }
910
911    png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */
912 }
913
914 /* Write the palette.  We are careful not to trust png_color to be in the
915  * correct order for PNG, so people can redefine it to any convenient
916  * structure.
917  */
918 void /* PRIVATE */
919 png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,
920     png_uint_32 num_pal)
921 {
922    png_uint_32 i;
923    png_const_colorp pal_ptr;
924    png_byte buf[3];
925
926    png_debug(1, "in png_write_PLTE");
927
928    if ((
929 #ifdef PNG_MNG_FEATURES_SUPPORTED
930        !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&
931 #endif
932        num_pal == 0) || num_pal > 256)
933    {
934       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
935       {
936          png_error(png_ptr, "Invalid number of colors in palette");
937       }
938
939       else
940       {
941          png_warning(png_ptr, "Invalid number of colors in palette");
942          return;
943       }
944    }
945
946    if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
947    {
948       png_warning(png_ptr,
949           "Ignoring request to write a PLTE chunk in grayscale PNG");
950
951       return;
952    }
953
954    png_ptr->num_palette = (png_uint_16)num_pal;
955    png_debug1(3, "num_palette = %d", png_ptr->num_palette);
956
957    png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3));
958 #ifdef PNG_POINTER_INDEXING_SUPPORTED
959
960    for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
961    {
962       buf[0] = pal_ptr->red;
963       buf[1] = pal_ptr->green;
964       buf[2] = pal_ptr->blue;
965       png_write_chunk_data(png_ptr, buf, (png_size_t)3);
966    }
967
968 #else
969    /* This is a little slower but some buggy compilers need to do this
970     * instead
971     */
972    pal_ptr=palette;
973
974    for (i = 0; i < num_pal; i++)
975    {
976       buf[0] = pal_ptr[i].red;
977       buf[1] = pal_ptr[i].green;
978       buf[2] = pal_ptr[i].blue;
979       png_write_chunk_data(png_ptr, buf, (png_size_t)3);
980    }
981
982 #endif
983    png_write_chunk_end(png_ptr);
984    png_ptr->mode |= PNG_HAVE_PLTE;
985 }
986
987 /* This is similar to png_text_compress, above, except that it does not require
988  * all of the data at once and, instead of buffering the compressed result,
989  * writes it as IDAT chunks.  Unlike png_text_compress it *can* png_error out
990  * because it calls the write interface.  As a result it does its own error
991  * reporting and does not return an error code.  In the event of error it will
992  * just call png_error.  The input data length may exceed 32-bits.  The 'flush'
993  * parameter is exactly the same as that to deflate, with the following
994  * meanings:
995  *
996  * Z_NO_FLUSH: normal incremental output of compressed data
997  * Z_SYNC_FLUSH: do a SYNC_FLUSH, used by png_write_flush
998  * Z_FINISH: this is the end of the input, do a Z_FINISH and clean up
999  *
1000  * The routine manages the acquire and release of the png_ptr->zstream by
1001  * checking and (at the end) clearing png_ptr->zowner, it does some sanity
1002  * checks on the 'mode' flags while doing this.
1003  */
1004 void /* PRIVATE */
1005 png_compress_IDAT(png_structrp png_ptr, png_const_bytep input,
1006    png_alloc_size_t input_len, int flush)
1007 {
1008    if (png_ptr->zowner != png_IDAT)
1009    {
1010       /* First time.   Ensure we have a temporary buffer for compression and
1011        * trim the buffer list if it has more than one entry to free memory.
1012        * If 'WRITE_COMPRESSED_TEXT' is not set the list will never have been
1013        * created at this point, but the check here is quick and safe.
1014        */
1015       if (png_ptr->zbuffer_list == NULL)
1016       {
1017          png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp,
1018             png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
1019          png_ptr->zbuffer_list->next = NULL;
1020       }
1021
1022       else
1023          png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list->next);
1024
1025       /* It is a terminal error if we can't claim the zstream. */
1026       if (png_deflate_claim(png_ptr, png_IDAT, png_image_size(png_ptr)) != Z_OK)
1027          png_error(png_ptr, png_ptr->zstream.msg);
1028
1029       /* The output state is maintained in png_ptr->zstream, so it must be
1030        * initialized here after the claim.
1031        */
1032       png_ptr->zstream.next_out = png_ptr->zbuffer_list->output;
1033       png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
1034    }
1035
1036    /* Now loop reading and writing until all the input is consumed or an error
1037     * terminates the operation.  The _out values are maintained across calls to
1038     * this function, but the input must be reset each time.
1039     */
1040    png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input);
1041    png_ptr->zstream.avail_in = 0; /* set below */
1042    for (;;)
1043    {
1044       int ret;
1045
1046       /* INPUT: from the row data */
1047       uInt avail = ZLIB_IO_MAX;
1048
1049       if (avail > input_len)
1050          avail = (uInt)input_len; /* safe because of the check */
1051
1052       png_ptr->zstream.avail_in = avail;
1053       input_len -= avail;
1054
1055       ret = deflate(&png_ptr->zstream, input_len > 0 ? Z_NO_FLUSH : flush);
1056
1057       /* Include as-yet unconsumed input */
1058       input_len += png_ptr->zstream.avail_in;
1059       png_ptr->zstream.avail_in = 0;
1060
1061       /* OUTPUT: write complete IDAT chunks when avail_out drops to zero, note
1062        * that these two zstream fields are preserved across the calls, therefore
1063        * there is no need to set these up on entry to the loop.
1064        */
1065       if (png_ptr->zstream.avail_out == 0)
1066       {
1067          png_bytep data = png_ptr->zbuffer_list->output;
1068          uInt size = png_ptr->zbuffer_size;
1069
1070          /* Write an IDAT containing the data then reset the buffer.  The
1071           * first IDAT may need deflate header optimization.
1072           */
1073 #        ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
1074             if (!(png_ptr->mode & PNG_HAVE_IDAT) &&
1075                png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
1076                optimize_cmf(data, png_image_size(png_ptr));
1077 #        endif
1078
1079          png_write_complete_chunk(png_ptr, png_IDAT, data, size);
1080          png_ptr->mode |= PNG_HAVE_IDAT;
1081
1082          png_ptr->zstream.next_out = data;
1083          png_ptr->zstream.avail_out = size;
1084
1085          /* For SYNC_FLUSH or FINISH it is essential to keep calling zlib with
1086           * the same flush parameter until it has finished output, for NO_FLUSH
1087           * it doesn't matter.
1088           */
1089          if (ret == Z_OK && flush != Z_NO_FLUSH)
1090             continue;
1091       }
1092
1093       /* The order of these checks doesn't matter much; it just effect which
1094        * possible error might be detected if multiple things go wrong at once.
1095        */
1096       if (ret == Z_OK) /* most likely return code! */
1097       {
1098          /* If all the input has been consumed then just return.  If Z_FINISH
1099           * was used as the flush parameter something has gone wrong if we get
1100           * here.
1101           */
1102          if (input_len == 0)
1103          {
1104             if (flush == Z_FINISH)
1105                png_error(png_ptr, "Z_OK on Z_FINISH with output space");
1106
1107             return;
1108          }
1109       }
1110
1111       else if (ret == Z_STREAM_END && flush == Z_FINISH)
1112       {
1113          /* This is the end of the IDAT data; any pending output must be
1114           * flushed.  For small PNG files we may still be at the beginning.
1115           */
1116          png_bytep data = png_ptr->zbuffer_list->output;
1117          uInt size = png_ptr->zbuffer_size - png_ptr->zstream.avail_out;
1118
1119 #        ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
1120             if (!(png_ptr->mode & PNG_HAVE_IDAT) &&
1121                png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
1122                optimize_cmf(data, png_image_size(png_ptr));
1123 #        endif
1124
1125          png_write_complete_chunk(png_ptr, png_IDAT, data, size);
1126          png_ptr->zstream.avail_out = 0;
1127          png_ptr->zstream.next_out = NULL;
1128          png_ptr->mode |= PNG_HAVE_IDAT | PNG_AFTER_IDAT;
1129
1130          png_ptr->zowner = 0; /* Release the stream */
1131          return;
1132       }
1133
1134       else
1135       {
1136          /* This is an error condition. */
1137          png_zstream_error(png_ptr, ret);
1138          png_error(png_ptr, png_ptr->zstream.msg);
1139       }
1140    }
1141 }
1142
1143 /* Write an IEND chunk */
1144 void /* PRIVATE */
1145 png_write_IEND(png_structrp png_ptr)
1146 {
1147    png_debug(1, "in png_write_IEND");
1148
1149    png_write_complete_chunk(png_ptr, png_IEND, NULL, (png_size_t)0);
1150    png_ptr->mode |= PNG_HAVE_IEND;
1151 }
1152
1153 #ifdef PNG_WRITE_gAMA_SUPPORTED
1154 /* Write a gAMA chunk */
1155 void /* PRIVATE */
1156 png_write_gAMA_fixed(png_structrp png_ptr, png_fixed_point file_gamma)
1157 {
1158    png_byte buf[4];
1159
1160    png_debug(1, "in png_write_gAMA");
1161
1162    /* file_gamma is saved in 1/100,000ths */
1163    png_save_uint_32(buf, (png_uint_32)file_gamma);
1164    png_write_complete_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
1165 }
1166 #endif
1167
1168 #ifdef PNG_WRITE_sRGB_SUPPORTED
1169 /* Write a sRGB chunk */
1170 void /* PRIVATE */
1171 png_write_sRGB(png_structrp png_ptr, int srgb_intent)
1172 {
1173    png_byte buf[1];
1174
1175    png_debug(1, "in png_write_sRGB");
1176
1177    if (srgb_intent >= PNG_sRGB_INTENT_LAST)
1178       png_warning(png_ptr,
1179           "Invalid sRGB rendering intent specified");
1180
1181    buf[0]=(png_byte)srgb_intent;
1182    png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
1183 }
1184 #endif
1185
1186 #ifdef PNG_WRITE_iCCP_SUPPORTED
1187 /* Write an iCCP chunk */
1188 void /* PRIVATE */
1189 png_write_iCCP(png_structrp png_ptr, png_const_charp name,
1190     png_const_bytep profile)
1191 {
1192    png_uint_32 name_len;
1193    png_uint_32 profile_len;
1194    png_byte new_name[81]; /* 1 byte for the compression byte */
1195    compression_state comp;
1196    png_uint_32 temp;
1197
1198    png_debug(1, "in png_write_iCCP");
1199
1200    /* These are all internal problems: the profile should have been checked
1201     * before when it was stored.
1202     */
1203    if (profile == NULL)
1204       png_error(png_ptr, "No profile for iCCP chunk"); /* internal error */
1205
1206    profile_len = png_get_uint_32(profile);
1207
1208    if (profile_len < 132)
1209       png_error(png_ptr, "ICC profile too short");
1210
1211    temp = (png_uint_32) (*(profile+8));
1212    if (temp > 3 && (profile_len & 0x03))
1213       png_error(png_ptr, "ICC profile length invalid (not a multiple of 4)");
1214
1215    {
1216       png_uint_32 embedded_profile_len = png_get_uint_32(profile);
1217
1218       if (profile_len != embedded_profile_len)
1219          png_error(png_ptr, "Profile length does not match profile");
1220    }
1221
1222    name_len = png_check_keyword(png_ptr, name, new_name);
1223
1224    if (name_len == 0)
1225       png_error(png_ptr, "iCCP: invalid keyword");
1226
1227    new_name[++name_len] = PNG_COMPRESSION_TYPE_BASE;
1228
1229    /* Make sure we include the NULL after the name and the compression type */
1230    ++name_len;
1231
1232    png_text_compress_init(&comp, profile, profile_len);
1233
1234    /* Allow for keyword terminator and compression byte */
1235    if (png_text_compress(png_ptr, png_iCCP, &comp, name_len) != Z_OK)
1236       png_error(png_ptr, png_ptr->zstream.msg);
1237
1238    png_write_chunk_header(png_ptr, png_iCCP, name_len + comp.output_len);
1239
1240    png_write_chunk_data(png_ptr, new_name, name_len);
1241
1242    png_write_compressed_data_out(png_ptr, &comp);
1243
1244    png_write_chunk_end(png_ptr);
1245 }
1246 #endif
1247
1248 #ifdef PNG_WRITE_sPLT_SUPPORTED
1249 /* Write a sPLT chunk */
1250 void /* PRIVATE */
1251 png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
1252 {
1253    png_uint_32 name_len;
1254    png_byte new_name[80];
1255    png_byte entrybuf[10];
1256    png_size_t entry_size = (spalette->depth == 8 ? 6 : 10);
1257    png_size_t palette_size = entry_size * spalette->nentries;
1258    png_sPLT_entryp ep;
1259 #ifndef PNG_POINTER_INDEXING_SUPPORTED
1260    int i;
1261 #endif
1262
1263    png_debug(1, "in png_write_sPLT");
1264
1265    name_len = png_check_keyword(png_ptr, spalette->name, new_name);
1266
1267    if (name_len == 0)
1268       png_error(png_ptr, "sPLT: invalid keyword");
1269
1270    /* Make sure we include the NULL after the name */
1271    png_write_chunk_header(png_ptr, png_sPLT,
1272        (png_uint_32)(name_len + 2 + palette_size));
1273
1274    png_write_chunk_data(png_ptr, (png_bytep)new_name,
1275        (png_size_t)(name_len + 1));
1276
1277    png_write_chunk_data(png_ptr, &spalette->depth, (png_size_t)1);
1278
1279    /* Loop through each palette entry, writing appropriately */
1280 #ifdef PNG_POINTER_INDEXING_SUPPORTED
1281    for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)
1282    {
1283       if (spalette->depth == 8)
1284       {
1285          entrybuf[0] = (png_byte)ep->red;
1286          entrybuf[1] = (png_byte)ep->green;
1287          entrybuf[2] = (png_byte)ep->blue;
1288          entrybuf[3] = (png_byte)ep->alpha;
1289          png_save_uint_16(entrybuf + 4, ep->frequency);
1290       }
1291
1292       else
1293       {
1294          png_save_uint_16(entrybuf + 0, ep->red);
1295          png_save_uint_16(entrybuf + 2, ep->green);
1296          png_save_uint_16(entrybuf + 4, ep->blue);
1297          png_save_uint_16(entrybuf + 6, ep->alpha);
1298          png_save_uint_16(entrybuf + 8, ep->frequency);
1299       }
1300
1301       png_write_chunk_data(png_ptr, entrybuf, entry_size);
1302    }
1303 #else
1304    ep=spalette->entries;
1305    for (i = 0; i>spalette->nentries; i++)
1306    {
1307       if (spalette->depth == 8)
1308       {
1309          entrybuf[0] = (png_byte)ep[i].red;
1310          entrybuf[1] = (png_byte)ep[i].green;
1311          entrybuf[2] = (png_byte)ep[i].blue;
1312          entrybuf[3] = (png_byte)ep[i].alpha;
1313          png_save_uint_16(entrybuf + 4, ep[i].frequency);
1314       }
1315
1316       else
1317       {
1318          png_save_uint_16(entrybuf + 0, ep[i].red);
1319          png_save_uint_16(entrybuf + 2, ep[i].green);
1320          png_save_uint_16(entrybuf + 4, ep[i].blue);
1321          png_save_uint_16(entrybuf + 6, ep[i].alpha);
1322          png_save_uint_16(entrybuf + 8, ep[i].frequency);
1323       }
1324
1325       png_write_chunk_data(png_ptr, entrybuf, entry_size);
1326    }
1327 #endif
1328
1329    png_write_chunk_end(png_ptr);
1330 }
1331 #endif
1332
1333 #ifdef PNG_WRITE_sBIT_SUPPORTED
1334 /* Write the sBIT chunk */
1335 void /* PRIVATE */
1336 png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type)
1337 {
1338    png_byte buf[4];
1339    png_size_t size;
1340
1341    png_debug(1, "in png_write_sBIT");
1342
1343    /* Make sure we don't depend upon the order of PNG_COLOR_8 */
1344    if (color_type & PNG_COLOR_MASK_COLOR)
1345    {
1346       png_byte maxbits;
1347
1348       maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
1349           png_ptr->usr_bit_depth);
1350
1351       if (sbit->red == 0 || sbit->red > maxbits ||
1352           sbit->green == 0 || sbit->green > maxbits ||
1353           sbit->blue == 0 || sbit->blue > maxbits)
1354       {
1355          png_warning(png_ptr, "Invalid sBIT depth specified");
1356          return;
1357       }
1358
1359       buf[0] = sbit->red;
1360       buf[1] = sbit->green;
1361       buf[2] = sbit->blue;
1362       size = 3;
1363    }
1364
1365    else
1366    {
1367       if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)
1368       {
1369          png_warning(png_ptr, "Invalid sBIT depth specified");
1370          return;
1371       }
1372
1373       buf[0] = sbit->gray;
1374       size = 1;
1375    }
1376
1377    if (color_type & PNG_COLOR_MASK_ALPHA)
1378    {
1379       if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
1380       {
1381          png_warning(png_ptr, "Invalid sBIT depth specified");
1382          return;
1383       }
1384
1385       buf[size++] = sbit->alpha;
1386    }
1387
1388    png_write_complete_chunk(png_ptr, png_sBIT, buf, size);
1389 }
1390 #endif
1391
1392 #ifdef PNG_WRITE_cHRM_SUPPORTED
1393 /* Write the cHRM chunk */
1394 void /* PRIVATE */
1395 png_write_cHRM_fixed(png_structrp png_ptr, const png_xy *xy)
1396 {
1397    png_byte buf[32];
1398
1399    png_debug(1, "in png_write_cHRM");
1400
1401    /* Each value is saved in 1/100,000ths */
1402    png_save_int_32(buf,      xy->whitex);
1403    png_save_int_32(buf +  4, xy->whitey);
1404
1405    png_save_int_32(buf +  8, xy->redx);
1406    png_save_int_32(buf + 12, xy->redy);
1407
1408    png_save_int_32(buf + 16, xy->greenx);
1409    png_save_int_32(buf + 20, xy->greeny);
1410
1411    png_save_int_32(buf + 24, xy->bluex);
1412    png_save_int_32(buf + 28, xy->bluey);
1413
1414    png_write_complete_chunk(png_ptr, png_cHRM, buf, 32);
1415 }
1416 #endif
1417
1418 #ifdef PNG_WRITE_tRNS_SUPPORTED
1419 /* Write the tRNS chunk */
1420 void /* PRIVATE */
1421 png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
1422     png_const_color_16p tran, int num_trans, int color_type)
1423 {
1424    png_byte buf[6];
1425
1426    png_debug(1, "in png_write_tRNS");
1427
1428    if (color_type == PNG_COLOR_TYPE_PALETTE)
1429    {
1430       if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
1431       {
1432          png_app_warning(png_ptr,
1433              "Invalid number of transparent colors specified");
1434          return;
1435       }
1436
1437       /* Write the chunk out as it is */
1438       png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha,
1439          (png_size_t)num_trans);
1440    }
1441
1442    else if (color_type == PNG_COLOR_TYPE_GRAY)
1443    {
1444       /* One 16 bit value */
1445       if (tran->gray >= (1 << png_ptr->bit_depth))
1446       {
1447          png_app_warning(png_ptr,
1448              "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
1449
1450          return;
1451       }
1452
1453       png_save_uint_16(buf, tran->gray);
1454       png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)2);
1455    }
1456
1457    else if (color_type == PNG_COLOR_TYPE_RGB)
1458    {
1459       /* Three 16 bit values */
1460       png_save_uint_16(buf, tran->red);
1461       png_save_uint_16(buf + 2, tran->green);
1462       png_save_uint_16(buf + 4, tran->blue);
1463 #ifdef PNG_WRITE_16BIT_SUPPORTED
1464       if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
1465 #else
1466       if (buf[0] | buf[2] | buf[4])
1467 #endif
1468       {
1469          png_app_warning(png_ptr,
1470            "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
1471          return;
1472       }
1473
1474       png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)6);
1475    }
1476
1477    else
1478    {
1479       png_app_warning(png_ptr, "Can't write tRNS with an alpha channel");
1480    }
1481 }
1482 #endif
1483
1484 #ifdef PNG_WRITE_bKGD_SUPPORTED
1485 /* Write the background chunk */
1486 void /* PRIVATE */
1487 png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
1488 {
1489    png_byte buf[6];
1490
1491    png_debug(1, "in png_write_bKGD");
1492
1493    if (color_type == PNG_COLOR_TYPE_PALETTE)
1494    {
1495       if (
1496 #ifdef PNG_MNG_FEATURES_SUPPORTED
1497           (png_ptr->num_palette ||
1498           (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&
1499 #endif
1500          back->index >= png_ptr->num_palette)
1501       {
1502          png_warning(png_ptr, "Invalid background palette index");
1503          return;
1504       }
1505
1506       buf[0] = back->index;
1507       png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)1);
1508    }
1509
1510    else if (color_type & PNG_COLOR_MASK_COLOR)
1511    {
1512       png_save_uint_16(buf, back->red);
1513       png_save_uint_16(buf + 2, back->green);
1514       png_save_uint_16(buf + 4, back->blue);
1515 #ifdef PNG_WRITE_16BIT_SUPPORTED
1516       if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
1517 #else
1518       if (buf[0] | buf[2] | buf[4])
1519 #endif
1520       {
1521          png_warning(png_ptr,
1522              "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
1523
1524          return;
1525       }
1526
1527       png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)6);
1528    }
1529
1530    else
1531    {
1532       if (back->gray >= (1 << png_ptr->bit_depth))
1533       {
1534          png_warning(png_ptr,
1535              "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");
1536
1537          return;
1538       }
1539
1540       png_save_uint_16(buf, back->gray);
1541       png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)2);
1542    }
1543 }
1544 #endif
1545
1546 #ifdef PNG_WRITE_hIST_SUPPORTED
1547 /* Write the histogram */
1548 void /* PRIVATE */
1549 png_write_hIST(png_structrp png_ptr, png_const_uint_16p hist, int num_hist)
1550 {
1551    int i;
1552    png_byte buf[3];
1553
1554    png_debug(1, "in png_write_hIST");
1555
1556    if (num_hist > (int)png_ptr->num_palette)
1557    {
1558       png_debug2(3, "num_hist = %d, num_palette = %d", num_hist,
1559           png_ptr->num_palette);
1560
1561       png_warning(png_ptr, "Invalid number of histogram entries specified");
1562       return;
1563    }
1564
1565    png_write_chunk_header(png_ptr, png_hIST, (png_uint_32)(num_hist * 2));
1566
1567    for (i = 0; i < num_hist; i++)
1568    {
1569       png_save_uint_16(buf, hist[i]);
1570       png_write_chunk_data(png_ptr, buf, (png_size_t)2);
1571    }
1572
1573    png_write_chunk_end(png_ptr);
1574 }
1575 #endif
1576
1577 #ifdef PNG_WRITE_tEXt_SUPPORTED
1578 /* Write a tEXt chunk */
1579 void /* PRIVATE */
1580 png_write_tEXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
1581     png_size_t text_len)
1582 {
1583    png_uint_32 key_len;
1584    png_byte new_key[80];
1585
1586    png_debug(1, "in png_write_tEXt");
1587
1588    key_len = png_check_keyword(png_ptr, key, new_key);
1589
1590    if (key_len == 0)
1591       png_error(png_ptr, "tEXt: invalid keyword");
1592
1593    if (text == NULL || *text == '\0')
1594       text_len = 0;
1595
1596    else
1597       text_len = strlen(text);
1598
1599    if (text_len > PNG_UINT_31_MAX - (key_len+1))
1600       png_error(png_ptr, "tEXt: text too long");
1601
1602    /* Make sure we include the 0 after the key */
1603    png_write_chunk_header(png_ptr, png_tEXt,
1604        (png_uint_32)/*checked above*/(key_len + text_len + 1));
1605    /*
1606     * We leave it to the application to meet PNG-1.0 requirements on the
1607     * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of
1608     * any non-Latin-1 characters except for NEWLINE.  ISO PNG will forbid them.
1609     * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
1610     */
1611    png_write_chunk_data(png_ptr, new_key, key_len + 1);
1612
1613    if (text_len != 0)
1614       png_write_chunk_data(png_ptr, (png_const_bytep)text, text_len);
1615
1616    png_write_chunk_end(png_ptr);
1617 }
1618 #endif
1619
1620 #ifdef PNG_WRITE_zTXt_SUPPORTED
1621 /* Write a compressed text chunk */
1622 void /* PRIVATE */
1623 png_write_zTXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
1624     png_size_t text_len, int compression)
1625 {
1626    png_uint_32 key_len;
1627    png_byte new_key[81];
1628    compression_state comp;
1629
1630    png_debug(1, "in png_write_zTXt");
1631    PNG_UNUSED(text_len) /* Always use strlen */
1632
1633    if (compression == PNG_TEXT_COMPRESSION_NONE)
1634    {
1635       png_write_tEXt(png_ptr, key, text, 0);
1636       return;
1637    }
1638
1639    if (compression != PNG_TEXT_COMPRESSION_zTXt)
1640       png_error(png_ptr, "zTXt: invalid compression type");
1641
1642    key_len = png_check_keyword(png_ptr, key, new_key);
1643
1644    if (key_len == 0)
1645       png_error(png_ptr, "zTXt: invalid keyword");
1646
1647    /* Add the compression method and 1 for the keyword separator. */
1648    new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
1649    ++key_len;
1650
1651    /* Compute the compressed data; do it now for the length */
1652    png_text_compress_init(&comp, (png_const_bytep)text,
1653       text == NULL ? 0 : strlen(text));
1654
1655    if (png_text_compress(png_ptr, png_zTXt, &comp, key_len) != Z_OK)
1656       png_error(png_ptr, png_ptr->zstream.msg);
1657
1658    /* Write start of chunk */
1659    png_write_chunk_header(png_ptr, png_zTXt, key_len + comp.output_len);
1660
1661    /* Write key */
1662    png_write_chunk_data(png_ptr, new_key, key_len);
1663
1664    /* Write the compressed data */
1665    png_write_compressed_data_out(png_ptr, &comp);
1666
1667    /* Close the chunk */
1668    png_write_chunk_end(png_ptr);
1669 }
1670 #endif
1671
1672 #ifdef PNG_WRITE_iTXt_SUPPORTED
1673 /* Write an iTXt chunk */
1674 void /* PRIVATE */
1675 png_write_iTXt(png_structrp png_ptr, int compression, png_const_charp key,
1676     png_const_charp lang, png_const_charp lang_key, png_const_charp text)
1677 {
1678    png_uint_32 key_len, prefix_len;
1679    png_size_t lang_len, lang_key_len;
1680    png_byte new_key[82];
1681    compression_state comp;
1682
1683    png_debug(1, "in png_write_iTXt");
1684
1685    key_len = png_check_keyword(png_ptr, key, new_key);
1686
1687    if (key_len == 0)
1688       png_error(png_ptr, "iTXt: invalid keyword");
1689
1690    /* Set the compression flag */
1691    switch (compression)
1692    {
1693       case PNG_ITXT_COMPRESSION_NONE:
1694       case PNG_TEXT_COMPRESSION_NONE:
1695          compression = new_key[++key_len] = 0; /* no compression */
1696          break;
1697
1698       case PNG_TEXT_COMPRESSION_zTXt:
1699       case PNG_ITXT_COMPRESSION_zTXt:
1700          compression = new_key[++key_len] = 1; /* compressed */
1701          break;
1702
1703       default:
1704          png_error(png_ptr, "iTXt: invalid compression");
1705    }
1706
1707    new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
1708    ++key_len; /* for the keywod separator */
1709
1710    /* We leave it to the application to meet PNG-1.0 requirements on the
1711     * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of
1712     * any non-Latin-1 characters except for NEWLINE.  ISO PNG, however,
1713     * specifies that the text is UTF-8 and this really doesn't require any
1714     * checking.
1715     *
1716     * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
1717     *
1718     * TODO: validate the language tag correctly (see the spec.)
1719     */
1720    if (lang == NULL) lang = ""; /* empty language is valid */
1721    lang_len = strlen(lang)+1;
1722    if (lang_key == NULL) lang_key = ""; /* may be empty */
1723    lang_key_len = strlen(lang_key)+1;
1724    if (text == NULL) text = ""; /* may be empty */
1725
1726    prefix_len = key_len;
1727    if (lang_len > PNG_UINT_31_MAX-prefix_len)
1728       prefix_len = PNG_UINT_31_MAX;
1729    else
1730       prefix_len = (png_uint_32)(prefix_len + lang_len);
1731
1732    if (lang_key_len > PNG_UINT_31_MAX-prefix_len)
1733       prefix_len = PNG_UINT_31_MAX;
1734    else
1735       prefix_len = (png_uint_32)(prefix_len + lang_key_len);
1736
1737    png_text_compress_init(&comp, (png_const_bytep)text, strlen(text));
1738
1739    if (compression != 0)
1740    {
1741       if (png_text_compress(png_ptr, png_iTXt, &comp, prefix_len) != Z_OK)
1742          png_error(png_ptr, png_ptr->zstream.msg);
1743    }
1744
1745    else
1746    {
1747       if (comp.input_len > PNG_UINT_31_MAX-prefix_len)
1748          png_error(png_ptr, "iTXt: uncompressed text too long");
1749
1750       /* So the string will fit in a chunk: */
1751       comp.output_len = (png_uint_32)/*SAFE*/comp.input_len;
1752    }
1753
1754    png_write_chunk_header(png_ptr, png_iTXt, comp.output_len + prefix_len);
1755
1756    png_write_chunk_data(png_ptr, new_key, key_len);
1757
1758    png_write_chunk_data(png_ptr, (png_const_bytep)lang, lang_len);
1759
1760    png_write_chunk_data(png_ptr, (png_const_bytep)lang_key, lang_key_len);
1761
1762    if (compression != 0)
1763       png_write_compressed_data_out(png_ptr, &comp);
1764
1765    else
1766       png_write_chunk_data(png_ptr, (png_const_bytep)text, comp.input_len);
1767
1768    png_write_chunk_end(png_ptr);
1769 }
1770 #endif
1771
1772 #ifdef PNG_WRITE_oFFs_SUPPORTED
1773 /* Write the oFFs chunk */
1774 void /* PRIVATE */
1775 png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
1776     int unit_type)
1777 {
1778    png_byte buf[9];
1779
1780    png_debug(1, "in png_write_oFFs");
1781
1782    if (unit_type >= PNG_OFFSET_LAST)
1783       png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");
1784
1785    png_save_int_32(buf, x_offset);
1786    png_save_int_32(buf + 4, y_offset);
1787    buf[8] = (png_byte)unit_type;
1788
1789    png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
1790 }
1791 #endif
1792 #ifdef PNG_WRITE_pCAL_SUPPORTED
1793 /* Write the pCAL chunk (described in the PNG extensions document) */
1794 void /* PRIVATE */
1795 png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0,
1796     png_int_32 X1, int type, int nparams, png_const_charp units,
1797     png_charpp params)
1798 {
1799    png_uint_32 purpose_len;
1800    png_size_t units_len, total_len;
1801    png_size_tp params_len;
1802    png_byte buf[10];
1803    png_byte new_purpose[80];
1804    int i;
1805
1806    png_debug1(1, "in png_write_pCAL (%d parameters)", nparams);
1807
1808    if (type >= PNG_EQUATION_LAST)
1809       png_error(png_ptr, "Unrecognized equation type for pCAL chunk");
1810
1811    purpose_len = png_check_keyword(png_ptr, purpose, new_purpose);
1812
1813    if (purpose_len == 0)
1814       png_error(png_ptr, "pCAL: invalid keyword");
1815
1816    ++purpose_len; /* terminator */
1817
1818    png_debug1(3, "pCAL purpose length = %d", (int)purpose_len);
1819    units_len = strlen(units) + (nparams == 0 ? 0 : 1);
1820    png_debug1(3, "pCAL units length = %d", (int)units_len);
1821    total_len = purpose_len + units_len + 10;
1822
1823    params_len = (png_size_tp)png_malloc(png_ptr,
1824        (png_alloc_size_t)(nparams * (sizeof (png_size_t))));
1825
1826    /* Find the length of each parameter, making sure we don't count the
1827     * null terminator for the last parameter.
1828     */
1829    for (i = 0; i < nparams; i++)
1830    {
1831       params_len[i] = strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
1832       png_debug2(3, "pCAL parameter %d length = %lu", i,
1833           (unsigned long)params_len[i]);
1834       total_len += params_len[i];
1835    }
1836
1837    png_debug1(3, "pCAL total length = %d", (int)total_len);
1838    png_write_chunk_header(png_ptr, png_pCAL, (png_uint_32)total_len);
1839    png_write_chunk_data(png_ptr, new_purpose, purpose_len);
1840    png_save_int_32(buf, X0);
1841    png_save_int_32(buf + 4, X1);
1842    buf[8] = (png_byte)type;
1843    buf[9] = (png_byte)nparams;
1844    png_write_chunk_data(png_ptr, buf, (png_size_t)10);
1845    png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len);
1846
1847    for (i = 0; i < nparams; i++)
1848    {
1849       png_write_chunk_data(png_ptr, (png_const_bytep)params[i], params_len[i]);
1850    }
1851
1852    png_free(png_ptr, params_len);
1853    png_write_chunk_end(png_ptr);
1854 }
1855 #endif
1856
1857 #ifdef PNG_WRITE_sCAL_SUPPORTED
1858 /* Write the sCAL chunk */
1859 void /* PRIVATE */
1860 png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width,
1861     png_const_charp height)
1862 {
1863    png_byte buf[64];
1864    png_size_t wlen, hlen, total_len;
1865
1866    png_debug(1, "in png_write_sCAL_s");
1867
1868    wlen = strlen(width);
1869    hlen = strlen(height);
1870    total_len = wlen + hlen + 2;
1871
1872    if (total_len > 64)
1873    {
1874       png_warning(png_ptr, "Can't write sCAL (buffer too small)");
1875       return;
1876    }
1877
1878    buf[0] = (png_byte)unit;
1879    memcpy(buf + 1, width, wlen + 1);      /* Append the '\0' here */
1880    memcpy(buf + wlen + 2, height, hlen);  /* Do NOT append the '\0' here */
1881
1882    png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
1883    png_write_complete_chunk(png_ptr, png_sCAL, buf, total_len);
1884 }
1885 #endif
1886
1887 #ifdef PNG_WRITE_pHYs_SUPPORTED
1888 /* Write the pHYs chunk */
1889 void /* PRIVATE */
1890 png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit,
1891     png_uint_32 y_pixels_per_unit,
1892     int unit_type)
1893 {
1894    png_byte buf[9];
1895
1896    png_debug(1, "in png_write_pHYs");
1897
1898    if (unit_type >= PNG_RESOLUTION_LAST)
1899       png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");
1900
1901    png_save_uint_32(buf, x_pixels_per_unit);
1902    png_save_uint_32(buf + 4, y_pixels_per_unit);
1903    buf[8] = (png_byte)unit_type;
1904
1905    png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
1906 }
1907 #endif
1908
1909 #ifdef PNG_WRITE_tIME_SUPPORTED
1910 /* Write the tIME chunk.  Use either png_convert_from_struct_tm()
1911  * or png_convert_from_time_t(), or fill in the structure yourself.
1912  */
1913 void /* PRIVATE */
1914 png_write_tIME(png_structrp png_ptr, png_const_timep mod_time)
1915 {
1916    png_byte buf[7];
1917
1918    png_debug(1, "in png_write_tIME");
1919
1920    if (mod_time->month  > 12 || mod_time->month  < 1 ||
1921        mod_time->day    > 31 || mod_time->day    < 1 ||
1922        mod_time->hour   > 23 || mod_time->second > 60)
1923    {
1924       png_warning(png_ptr, "Invalid time specified for tIME chunk");
1925       return;
1926    }
1927
1928    png_save_uint_16(buf, mod_time->year);
1929    buf[2] = mod_time->month;
1930    buf[3] = mod_time->day;
1931    buf[4] = mod_time->hour;
1932    buf[5] = mod_time->minute;
1933    buf[6] = mod_time->second;
1934
1935    png_write_complete_chunk(png_ptr, png_tIME, buf, (png_size_t)7);
1936 }
1937 #endif
1938
1939 /* Initializes the row writing capability of libpng */
1940 void /* PRIVATE */
1941 png_write_start_row(png_structrp png_ptr)
1942 {
1943 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
1944    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
1945
1946    /* Start of interlace block */
1947    static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
1948
1949    /* Offset to next interlace block */
1950    static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
1951
1952    /* Start of interlace block in the y direction */
1953    static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
1954
1955    /* Offset to next interlace block in the y direction */
1956    static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
1957 #endif
1958
1959    png_alloc_size_t buf_size;
1960    int usr_pixel_depth;
1961
1962    png_debug(1, "in png_write_start_row");
1963
1964    usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth;
1965    buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1;
1966
1967    /* 1.5.6: added to allow checking in the row write code. */
1968    png_ptr->transformed_pixel_depth = png_ptr->pixel_depth;
1969    png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth;
1970
1971    /* Set up row buffer */
1972    png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, buf_size);
1973
1974    png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
1975
1976 #ifdef PNG_WRITE_FILTER_SUPPORTED
1977    /* Set up filtering buffer, if using this filter */
1978    if (png_ptr->do_filter & PNG_FILTER_SUB)
1979    {
1980       png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1);
1981
1982       png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
1983    }
1984
1985    /* We only need to keep the previous row if we are using one of these. */
1986    if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))
1987    {
1988       /* Set up previous row buffer */
1989       png_ptr->prev_row = (png_bytep)png_calloc(png_ptr, buf_size);
1990
1991       if (png_ptr->do_filter & PNG_FILTER_UP)
1992       {
1993          png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
1994             png_ptr->rowbytes + 1);
1995
1996          png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
1997       }
1998
1999       if (png_ptr->do_filter & PNG_FILTER_AVG)
2000       {
2001          png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
2002              png_ptr->rowbytes + 1);
2003
2004          png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
2005       }
2006
2007       if (png_ptr->do_filter & PNG_FILTER_PAETH)
2008       {
2009          png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
2010              png_ptr->rowbytes + 1);
2011
2012          png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
2013       }
2014    }
2015 #endif /* PNG_WRITE_FILTER_SUPPORTED */
2016
2017 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2018    /* If interlaced, we need to set up width and height of pass */
2019    if (png_ptr->interlaced)
2020    {
2021       if (!(png_ptr->transformations & PNG_INTERLACE))
2022       {
2023          png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
2024              png_pass_ystart[0]) / png_pass_yinc[0];
2025
2026          png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -
2027              png_pass_start[0]) / png_pass_inc[0];
2028       }
2029
2030       else
2031       {
2032          png_ptr->num_rows = png_ptr->height;
2033          png_ptr->usr_width = png_ptr->width;
2034       }
2035    }
2036
2037    else
2038 #endif
2039    {
2040       png_ptr->num_rows = png_ptr->height;
2041       png_ptr->usr_width = png_ptr->width;
2042    }
2043 }
2044
2045 /* Internal use only.  Called when finished processing a row of data. */
2046 void /* PRIVATE */
2047 png_write_finish_row(png_structrp png_ptr)
2048 {
2049 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2050    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
2051
2052    /* Start of interlace block */
2053    static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
2054
2055    /* Offset to next interlace block */
2056    static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
2057
2058    /* Start of interlace block in the y direction */
2059    static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
2060
2061    /* Offset to next interlace block in the y direction */
2062    static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
2063 #endif
2064
2065    png_debug(1, "in png_write_finish_row");
2066
2067    /* Next row */
2068    png_ptr->row_number++;
2069
2070    /* See if we are done */
2071    if (png_ptr->row_number < png_ptr->num_rows)
2072       return;
2073
2074 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2075    /* If interlaced, go to next pass */
2076    if (png_ptr->interlaced)
2077    {
2078       png_ptr->row_number = 0;
2079       if (png_ptr->transformations & PNG_INTERLACE)
2080       {
2081          png_ptr->pass++;
2082       }
2083
2084       else
2085       {
2086          /* Loop until we find a non-zero width or height pass */
2087          do
2088          {
2089             png_ptr->pass++;
2090
2091             if (png_ptr->pass >= 7)
2092                break;
2093
2094             png_ptr->usr_width = (png_ptr->width +
2095                 png_pass_inc[png_ptr->pass] - 1 -
2096                 png_pass_start[png_ptr->pass]) /
2097                 png_pass_inc[png_ptr->pass];
2098
2099             png_ptr->num_rows = (png_ptr->height +
2100                 png_pass_yinc[png_ptr->pass] - 1 -
2101                 png_pass_ystart[png_ptr->pass]) /
2102                 png_pass_yinc[png_ptr->pass];
2103
2104             if (png_ptr->transformations & PNG_INTERLACE)
2105                break;
2106
2107          } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
2108
2109       }
2110
2111       /* Reset the row above the image for the next pass */
2112       if (png_ptr->pass < 7)
2113       {
2114          if (png_ptr->prev_row != NULL)
2115             memset(png_ptr->prev_row, 0,
2116                 (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*
2117                 png_ptr->usr_bit_depth, png_ptr->width)) + 1);
2118
2119          return;
2120       }
2121    }
2122 #endif
2123
2124    /* If we get here, we've just written the last row, so we need
2125       to flush the compressor */
2126    png_compress_IDAT(png_ptr, NULL, 0, Z_FINISH);
2127 }
2128
2129 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
2130 /* Pick out the correct pixels for the interlace pass.
2131  * The basic idea here is to go through the row with a source
2132  * pointer and a destination pointer (sp and dp), and copy the
2133  * correct pixels for the pass.  As the row gets compacted,
2134  * sp will always be >= dp, so we should never overwrite anything.
2135  * See the default: case for the easiest code to understand.
2136  */
2137 void /* PRIVATE */
2138 png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
2139 {
2140    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
2141
2142    /* Start of interlace block */
2143    static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
2144
2145    /* Offset to next interlace block */
2146    static PNG_CONST png_byte  png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
2147
2148    png_debug(1, "in png_do_write_interlace");
2149
2150    /* We don't have to do anything on the last pass (6) */
2151    if (pass < 6)
2152    {
2153       /* Each pixel depth is handled separately */
2154       switch (row_info->pixel_depth)
2155       {
2156          case 1:
2157          {
2158             png_bytep sp;
2159             png_bytep dp;
2160             int shift;
2161             int d;
2162             int value;
2163             png_uint_32 i;
2164             png_uint_32 row_width = row_info->width;
2165
2166             dp = row;
2167             d = 0;
2168             shift = 7;
2169
2170             for (i = png_pass_start[pass]; i < row_width;
2171                i += png_pass_inc[pass])
2172             {
2173                sp = row + (png_size_t)(i >> 3);
2174                value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;
2175                d |= (value << shift);
2176
2177                if (shift == 0)
2178                {
2179                   shift = 7;
2180                   *dp++ = (png_byte)d;
2181                   d = 0;
2182                }
2183
2184                else
2185                   shift--;
2186
2187             }
2188             if (shift != 7)
2189                *dp = (png_byte)d;
2190
2191             break;
2192          }
2193
2194          case 2:
2195          {
2196             png_bytep sp;
2197             png_bytep dp;
2198             int shift;
2199             int d;
2200             int value;
2201             png_uint_32 i;
2202             png_uint_32 row_width = row_info->width;
2203
2204             dp = row;
2205             shift = 6;
2206             d = 0;
2207
2208             for (i = png_pass_start[pass]; i < row_width;
2209                i += png_pass_inc[pass])
2210             {
2211                sp = row + (png_size_t)(i >> 2);
2212                value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;
2213                d |= (value << shift);
2214
2215                if (shift == 0)
2216                {
2217                   shift = 6;
2218                   *dp++ = (png_byte)d;
2219                   d = 0;
2220                }
2221
2222                else
2223                   shift -= 2;
2224             }
2225             if (shift != 6)
2226                *dp = (png_byte)d;
2227
2228             break;
2229          }
2230
2231          case 4:
2232          {
2233             png_bytep sp;
2234             png_bytep dp;
2235             int shift;
2236             int d;
2237             int value;
2238             png_uint_32 i;
2239             png_uint_32 row_width = row_info->width;
2240
2241             dp = row;
2242             shift = 4;
2243             d = 0;
2244             for (i = png_pass_start[pass]; i < row_width;
2245                 i += png_pass_inc[pass])
2246             {
2247                sp = row + (png_size_t)(i >> 1);
2248                value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;
2249                d |= (value << shift);
2250
2251                if (shift == 0)
2252                {
2253                   shift = 4;
2254                   *dp++ = (png_byte)d;
2255                   d = 0;
2256                }
2257
2258                else
2259                   shift -= 4;
2260             }
2261             if (shift != 4)
2262                *dp = (png_byte)d;
2263
2264             break;
2265          }
2266
2267          default:
2268          {
2269             png_bytep sp;
2270             png_bytep dp;
2271             png_uint_32 i;
2272             png_uint_32 row_width = row_info->width;
2273             png_size_t pixel_bytes;
2274
2275             /* Start at the beginning */
2276             dp = row;
2277
2278             /* Find out how many bytes each pixel takes up */
2279             pixel_bytes = (row_info->pixel_depth >> 3);
2280
2281             /* Loop through the row, only looking at the pixels that matter */
2282             for (i = png_pass_start[pass]; i < row_width;
2283                i += png_pass_inc[pass])
2284             {
2285                /* Find out where the original pixel is */
2286                sp = row + (png_size_t)i * pixel_bytes;
2287
2288                /* Move the pixel */
2289                if (dp != sp)
2290                   memcpy(dp, sp, pixel_bytes);
2291
2292                /* Next pixel */
2293                dp += pixel_bytes;
2294             }
2295             break;
2296          }
2297       }
2298       /* Set new row width */
2299       row_info->width = (row_info->width +
2300           png_pass_inc[pass] - 1 -
2301           png_pass_start[pass]) /
2302           png_pass_inc[pass];
2303
2304       row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
2305           row_info->width);
2306    }
2307 }
2308 #endif
2309
2310 /* This filters the row, chooses which filter to use, if it has not already
2311  * been specified by the application, and then writes the row out with the
2312  * chosen filter.
2313  */
2314 static void
2315 png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
2316    png_size_t row_bytes);
2317
2318 #define PNG_MAXSUM (((png_uint_32)(-1)) >> 1)
2319 #define PNG_HISHIFT 10
2320 #define PNG_LOMASK ((png_uint_32)0xffffL)
2321 #define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))
2322 void /* PRIVATE */
2323 png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
2324 {
2325    png_bytep best_row;
2326 #ifdef PNG_WRITE_FILTER_SUPPORTED
2327    png_bytep prev_row, row_buf;
2328    png_uint_32 mins, bpp;
2329    png_byte filter_to_do = png_ptr->do_filter;
2330    png_size_t row_bytes = row_info->rowbytes;
2331 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2332    int num_p_filters = png_ptr->num_prev_filters;
2333 #endif
2334
2335    png_debug(1, "in png_write_find_filter");
2336
2337 #ifndef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2338   if (png_ptr->row_number == 0 && filter_to_do == PNG_ALL_FILTERS)
2339   {
2340      /* These will never be selected so we need not test them. */
2341      filter_to_do &= ~(PNG_FILTER_UP | PNG_FILTER_PAETH);
2342   }
2343 #endif
2344
2345    /* Find out how many bytes offset each pixel is */
2346    bpp = (row_info->pixel_depth + 7) >> 3;
2347
2348    prev_row = png_ptr->prev_row;
2349 #endif
2350    best_row = png_ptr->row_buf;
2351 #ifdef PNG_WRITE_FILTER_SUPPORTED
2352    row_buf = best_row;
2353    mins = PNG_MAXSUM;
2354
2355    /* The prediction method we use is to find which method provides the
2356     * smallest value when summing the absolute values of the distances
2357     * from zero, using anything >= 128 as negative numbers.  This is known
2358     * as the "minimum sum of absolute differences" heuristic.  Other
2359     * heuristics are the "weighted minimum sum of absolute differences"
2360     * (experimental and can in theory improve compression), and the "zlib
2361     * predictive" method (not implemented yet), which does test compressions
2362     * of lines using different filter methods, and then chooses the
2363     * (series of) filter(s) that give minimum compressed data size (VERY
2364     * computationally expensive).
2365     *
2366     * GRR 980525:  consider also
2367     *
2368     *   (1) minimum sum of absolute differences from running average (i.e.,
2369     *       keep running sum of non-absolute differences & count of bytes)
2370     *       [track dispersion, too?  restart average if dispersion too large?]
2371     *
2372     *  (1b) minimum sum of absolute differences from sliding average, probably
2373     *       with window size <= deflate window (usually 32K)
2374     *
2375     *   (2) minimum sum of squared differences from zero or running average
2376     *       (i.e., ~ root-mean-square approach)
2377     */
2378
2379
2380    /* We don't need to test the 'no filter' case if this is the only filter
2381     * that has been chosen, as it doesn't actually do anything to the data.
2382     */
2383    if ((filter_to_do & PNG_FILTER_NONE) && filter_to_do != PNG_FILTER_NONE)
2384    {
2385       png_bytep rp;
2386       png_uint_32 sum = 0;
2387       png_size_t i;
2388       int v;
2389
2390       for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
2391       {
2392          v = *rp;
2393          sum += (v < 128) ? v : 256 - v;
2394       }
2395
2396 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2397       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
2398       {
2399          png_uint_32 sumhi, sumlo;
2400          int j;
2401          sumlo = sum & PNG_LOMASK;
2402          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */
2403
2404          /* Reduce the sum if we match any of the previous rows */
2405          for (j = 0; j < num_p_filters; j++)
2406          {
2407             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
2408             {
2409                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
2410                    PNG_WEIGHT_SHIFT;
2411
2412                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
2413                    PNG_WEIGHT_SHIFT;
2414             }
2415          }
2416
2417          /* Factor in the cost of this filter (this is here for completeness,
2418           * but it makes no sense to have a "cost" for the NONE filter, as
2419           * it has the minimum possible computational cost - none).
2420           */
2421          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
2422              PNG_COST_SHIFT;
2423
2424          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
2425              PNG_COST_SHIFT;
2426
2427          if (sumhi > PNG_HIMASK)
2428             sum = PNG_MAXSUM;
2429
2430          else
2431             sum = (sumhi << PNG_HISHIFT) + sumlo;
2432       }
2433 #endif
2434       mins = sum;
2435    }
2436
2437    /* Sub filter */
2438    if (filter_to_do == PNG_FILTER_SUB)
2439    /* It's the only filter so no testing is needed */
2440    {
2441       png_bytep rp, lp, dp;
2442       png_size_t i;
2443
2444       for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
2445            i++, rp++, dp++)
2446       {
2447          *dp = *rp;
2448       }
2449
2450       for (lp = row_buf + 1; i < row_bytes;
2451          i++, rp++, lp++, dp++)
2452       {
2453          *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
2454       }
2455
2456       best_row = png_ptr->sub_row;
2457    }
2458
2459    else if (filter_to_do & PNG_FILTER_SUB)
2460    {
2461       png_bytep rp, dp, lp;
2462       png_uint_32 sum = 0, lmins = mins;
2463       png_size_t i;
2464       int v;
2465
2466 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2467       /* We temporarily increase the "minimum sum" by the factor we
2468        * would reduce the sum of this filter, so that we can do the
2469        * early exit comparison without scaling the sum each time.
2470        */
2471       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
2472       {
2473          int j;
2474          png_uint_32 lmhi, lmlo;
2475          lmlo = lmins & PNG_LOMASK;
2476          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
2477
2478          for (j = 0; j < num_p_filters; j++)
2479          {
2480             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
2481             {
2482                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
2483                    PNG_WEIGHT_SHIFT;
2484
2485                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
2486                    PNG_WEIGHT_SHIFT;
2487             }
2488          }
2489
2490          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
2491              PNG_COST_SHIFT;
2492
2493          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
2494              PNG_COST_SHIFT;
2495
2496          if (lmhi > PNG_HIMASK)
2497             lmins = PNG_MAXSUM;
2498
2499          else
2500             lmins = (lmhi << PNG_HISHIFT) + lmlo;
2501       }
2502 #endif
2503
2504       for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
2505            i++, rp++, dp++)
2506       {
2507          v = *dp = *rp;
2508
2509          sum += (v < 128) ? v : 256 - v;
2510       }
2511
2512       for (lp = row_buf + 1; i < row_bytes;
2513          i++, rp++, lp++, dp++)
2514       {
2515          v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
2516
2517          sum += (v < 128) ? v : 256 - v;
2518
2519          if (sum > lmins)  /* We are already worse, don't continue. */
2520             break;
2521       }
2522
2523 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2524       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
2525       {
2526          int j;
2527          png_uint_32 sumhi, sumlo;
2528          sumlo = sum & PNG_LOMASK;
2529          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
2530
2531          for (j = 0; j < num_p_filters; j++)
2532          {
2533             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
2534             {
2535                sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>
2536                    PNG_WEIGHT_SHIFT;
2537
2538                sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>
2539                    PNG_WEIGHT_SHIFT;
2540             }
2541          }
2542
2543          sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
2544              PNG_COST_SHIFT;
2545
2546          sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
2547              PNG_COST_SHIFT;
2548
2549          if (sumhi > PNG_HIMASK)
2550             sum = PNG_MAXSUM;
2551
2552          else
2553             sum = (sumhi << PNG_HISHIFT) + sumlo;
2554       }
2555 #endif
2556
2557       if (sum < mins)
2558       {
2559          mins = sum;
2560          best_row = png_ptr->sub_row;
2561       }
2562    }
2563
2564    /* Up filter */
2565    if (filter_to_do == PNG_FILTER_UP)
2566    {
2567       png_bytep rp, dp, pp;
2568       png_size_t i;
2569
2570       for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
2571           pp = prev_row + 1; i < row_bytes;
2572           i++, rp++, pp++, dp++)
2573       {
2574          *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
2575       }
2576
2577       best_row = png_ptr->up_row;
2578    }
2579
2580    else if (filter_to_do & PNG_FILTER_UP)
2581    {
2582       png_bytep rp, dp, pp;
2583       png_uint_32 sum = 0, lmins = mins;
2584       png_size_t i;
2585       int v;
2586
2587
2588 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2589       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
2590       {
2591          int j;
2592          png_uint_32 lmhi, lmlo;
2593          lmlo = lmins & PNG_LOMASK;
2594          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
2595
2596          for (j = 0; j < num_p_filters; j++)
2597          {
2598             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
2599             {
2600                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
2601                    PNG_WEIGHT_SHIFT;
2602
2603                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
2604                    PNG_WEIGHT_SHIFT;
2605             }
2606          }
2607
2608          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
2609              PNG_COST_SHIFT;
2610
2611          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
2612              PNG_COST_SHIFT;
2613
2614          if (lmhi > PNG_HIMASK)
2615             lmins = PNG_MAXSUM;
2616
2617          else
2618             lmins = (lmhi << PNG_HISHIFT) + lmlo;
2619       }
2620 #endif
2621
2622       for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
2623           pp = prev_row + 1; i < row_bytes; i++)
2624       {
2625          v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
2626
2627          sum += (v < 128) ? v : 256 - v;
2628
2629          if (sum > lmins)  /* We are already worse, don't continue. */
2630             break;
2631       }
2632
2633 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2634       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
2635       {
2636          int j;
2637          png_uint_32 sumhi, sumlo;
2638          sumlo = sum & PNG_LOMASK;
2639          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
2640
2641          for (j = 0; j < num_p_filters; j++)
2642          {
2643             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
2644             {
2645                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
2646                    PNG_WEIGHT_SHIFT;
2647
2648                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
2649                    PNG_WEIGHT_SHIFT;
2650             }
2651          }
2652
2653          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
2654              PNG_COST_SHIFT;
2655
2656          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
2657              PNG_COST_SHIFT;
2658
2659          if (sumhi > PNG_HIMASK)
2660             sum = PNG_MAXSUM;
2661
2662          else
2663             sum = (sumhi << PNG_HISHIFT) + sumlo;
2664       }
2665 #endif
2666
2667       if (sum < mins)
2668       {
2669          mins = sum;
2670          best_row = png_ptr->up_row;
2671       }
2672    }
2673
2674    /* Avg filter */
2675    if (filter_to_do == PNG_FILTER_AVG)
2676    {
2677       png_bytep rp, dp, pp, lp;
2678       png_uint_32 i;
2679
2680       for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
2681            pp = prev_row + 1; i < bpp; i++)
2682       {
2683          *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
2684       }
2685
2686       for (lp = row_buf + 1; i < row_bytes; i++)
2687       {
2688          *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
2689                  & 0xff);
2690       }
2691       best_row = png_ptr->avg_row;
2692    }
2693
2694    else if (filter_to_do & PNG_FILTER_AVG)
2695    {
2696       png_bytep rp, dp, pp, lp;
2697       png_uint_32 sum = 0, lmins = mins;
2698       png_size_t i;
2699       int v;
2700
2701 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2702       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
2703       {
2704          int j;
2705          png_uint_32 lmhi, lmlo;
2706          lmlo = lmins & PNG_LOMASK;
2707          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
2708
2709          for (j = 0; j < num_p_filters; j++)
2710          {
2711             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)
2712             {
2713                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
2714                    PNG_WEIGHT_SHIFT;
2715
2716                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
2717                    PNG_WEIGHT_SHIFT;
2718             }
2719          }
2720
2721          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
2722              PNG_COST_SHIFT;
2723
2724          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
2725              PNG_COST_SHIFT;
2726
2727          if (lmhi > PNG_HIMASK)
2728             lmins = PNG_MAXSUM;
2729
2730          else
2731             lmins = (lmhi << PNG_HISHIFT) + lmlo;
2732       }
2733 #endif
2734
2735       for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
2736            pp = prev_row + 1; i < bpp; i++)
2737       {
2738          v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
2739
2740          sum += (v < 128) ? v : 256 - v;
2741       }
2742
2743       for (lp = row_buf + 1; i < row_bytes; i++)
2744       {
2745          v = *dp++ =
2746              (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);
2747
2748          sum += (v < 128) ? v : 256 - v;
2749
2750          if (sum > lmins)  /* We are already worse, don't continue. */
2751             break;
2752       }
2753
2754 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2755       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
2756       {
2757          int j;
2758          png_uint_32 sumhi, sumlo;
2759          sumlo = sum & PNG_LOMASK;
2760          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
2761
2762          for (j = 0; j < num_p_filters; j++)
2763          {
2764             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
2765             {
2766                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
2767                    PNG_WEIGHT_SHIFT;
2768
2769                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
2770                    PNG_WEIGHT_SHIFT;
2771             }
2772          }
2773
2774          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
2775              PNG_COST_SHIFT;
2776
2777          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
2778              PNG_COST_SHIFT;
2779
2780          if (sumhi > PNG_HIMASK)
2781             sum = PNG_MAXSUM;
2782
2783          else
2784             sum = (sumhi << PNG_HISHIFT) + sumlo;
2785       }
2786 #endif
2787
2788       if (sum < mins)
2789       {
2790          mins = sum;
2791          best_row = png_ptr->avg_row;
2792       }
2793    }
2794
2795    /* Paeth filter */
2796    if (filter_to_do == PNG_FILTER_PAETH)
2797    {
2798       png_bytep rp, dp, pp, cp, lp;
2799       png_size_t i;
2800
2801       for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
2802           pp = prev_row + 1; i < bpp; i++)
2803       {
2804          *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
2805       }
2806
2807       for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
2808       {
2809          int a, b, c, pa, pb, pc, p;
2810
2811          b = *pp++;
2812          c = *cp++;
2813          a = *lp++;
2814
2815          p = b - c;
2816          pc = a - c;
2817
2818 #ifdef PNG_USE_ABS
2819          pa = abs(p);
2820          pb = abs(pc);
2821          pc = abs(p + pc);
2822 #else
2823          pa = p < 0 ? -p : p;
2824          pb = pc < 0 ? -pc : pc;
2825          pc = (p + pc) < 0 ? -(p + pc) : p + pc;
2826 #endif
2827
2828          p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
2829
2830          *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
2831       }
2832       best_row = png_ptr->paeth_row;
2833    }
2834
2835    else if (filter_to_do & PNG_FILTER_PAETH)
2836    {
2837       png_bytep rp, dp, pp, cp, lp;
2838       png_uint_32 sum = 0, lmins = mins;
2839       png_size_t i;
2840       int v;
2841
2842 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2843       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
2844       {
2845          int j;
2846          png_uint_32 lmhi, lmlo;
2847          lmlo = lmins & PNG_LOMASK;
2848          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
2849
2850          for (j = 0; j < num_p_filters; j++)
2851          {
2852             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
2853             {
2854                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
2855                    PNG_WEIGHT_SHIFT;
2856
2857                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
2858                    PNG_WEIGHT_SHIFT;
2859             }
2860          }
2861
2862          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
2863              PNG_COST_SHIFT;
2864
2865          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
2866              PNG_COST_SHIFT;
2867
2868          if (lmhi > PNG_HIMASK)
2869             lmins = PNG_MAXSUM;
2870
2871          else
2872             lmins = (lmhi << PNG_HISHIFT) + lmlo;
2873       }
2874 #endif
2875
2876       for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
2877           pp = prev_row + 1; i < bpp; i++)
2878       {
2879          v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
2880
2881          sum += (v < 128) ? v : 256 - v;
2882       }
2883
2884       for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
2885       {
2886          int a, b, c, pa, pb, pc, p;
2887
2888          b = *pp++;
2889          c = *cp++;
2890          a = *lp++;
2891
2892 #ifndef PNG_SLOW_PAETH
2893          p = b - c;
2894          pc = a - c;
2895 #ifdef PNG_USE_ABS
2896          pa = abs(p);
2897          pb = abs(pc);
2898          pc = abs(p + pc);
2899 #else
2900          pa = p < 0 ? -p : p;
2901          pb = pc < 0 ? -pc : pc;
2902          pc = (p + pc) < 0 ? -(p + pc) : p + pc;
2903 #endif
2904          p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
2905 #else /* PNG_SLOW_PAETH */
2906          p = a + b - c;
2907          pa = abs(p - a);
2908          pb = abs(p - b);
2909          pc = abs(p - c);
2910
2911          if (pa <= pb && pa <= pc)
2912             p = a;
2913
2914          else if (pb <= pc)
2915             p = b;
2916
2917          else
2918             p = c;
2919 #endif /* PNG_SLOW_PAETH */
2920
2921          v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
2922
2923          sum += (v < 128) ? v : 256 - v;
2924
2925          if (sum > lmins)  /* We are already worse, don't continue. */
2926             break;
2927       }
2928
2929 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2930       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
2931       {
2932          int j;
2933          png_uint_32 sumhi, sumlo;
2934          sumlo = sum & PNG_LOMASK;
2935          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
2936
2937          for (j = 0; j < num_p_filters; j++)
2938          {
2939             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
2940             {
2941                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
2942                    PNG_WEIGHT_SHIFT;
2943
2944                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
2945                    PNG_WEIGHT_SHIFT;
2946             }
2947          }
2948
2949          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
2950              PNG_COST_SHIFT;
2951
2952          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
2953              PNG_COST_SHIFT;
2954
2955          if (sumhi > PNG_HIMASK)
2956             sum = PNG_MAXSUM;
2957
2958          else
2959             sum = (sumhi << PNG_HISHIFT) + sumlo;
2960       }
2961 #endif
2962
2963       if (sum < mins)
2964       {
2965          best_row = png_ptr->paeth_row;
2966       }
2967    }
2968 #endif /* PNG_WRITE_FILTER_SUPPORTED */
2969
2970    /* Do the actual writing of the filtered row data from the chosen filter. */
2971    png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1);
2972
2973 #ifdef PNG_WRITE_FILTER_SUPPORTED
2974 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
2975    /* Save the type of filter we picked this time for future calculations */
2976    if (png_ptr->num_prev_filters > 0)
2977    {
2978       int j;
2979
2980       for (j = 1; j < num_p_filters; j++)
2981       {
2982          png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];
2983       }
2984
2985       png_ptr->prev_filters[j] = best_row[0];
2986    }
2987 #endif
2988 #endif /* PNG_WRITE_FILTER_SUPPORTED */
2989 }
2990
2991
2992 /* Do the actual writing of a previously filtered row. */
2993 static void
2994 png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
2995    png_size_t full_row_length/*includes filter byte*/)
2996 {
2997    png_debug(1, "in png_write_filtered_row");
2998
2999    png_debug1(2, "filter = %d", filtered_row[0]);
3000
3001    png_compress_IDAT(png_ptr, filtered_row, full_row_length, Z_NO_FLUSH);
3002
3003    /* Swap the current and previous rows */
3004    if (png_ptr->prev_row != NULL)
3005    {
3006       png_bytep tptr;
3007
3008       tptr = png_ptr->prev_row;
3009       png_ptr->prev_row = png_ptr->row_buf;
3010       png_ptr->row_buf = tptr;
3011    }
3012
3013    /* Finish row - updates counters and flushes zlib if last row */
3014    png_write_finish_row(png_ptr);
3015
3016 #ifdef PNG_WRITE_FLUSH_SUPPORTED
3017    png_ptr->flush_rows++;
3018
3019    if (png_ptr->flush_dist > 0 &&
3020        png_ptr->flush_rows >= png_ptr->flush_dist)
3021    {
3022       png_write_flush(png_ptr);
3023    }
3024 #endif
3025 }
3026 #endif /* PNG_WRITE_SUPPORTED */