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