VirtualBox

source: vbox/trunk/src/libs/libpng-1.2.53/pngwutil.c@ 58639

最後變更 在這個檔案從58639是 58100,由 vboxsync 提交於 9 年 前

libpng 1.2.53 export fix

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette