]> git.saurik.com Git - wxWidgets.git/blob - src/png/pngwutil.c
Committing in .
[wxWidgets.git] / src / png / pngwutil.c
1
2 /* pngwutil.c - utilities to write a PNG file
3 *
4 * libpng 1.0.3 - January 14, 1999
5 * For conditions of distribution and use, see copyright notice in png.h
6 * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
7 * Copyright (c) 1996, 1997 Andreas Dilger
8 * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
9 */
10
11 #define PNG_INTERNAL
12 #include "png.h"
13
14 /* Place a 32-bit number into a buffer in PNG byte order. We work
15 * with unsigned numbers for convenience, although one supported
16 * ancillary chunk uses signed (two's complement) numbers.
17 */
18 void
19 png_save_uint_32(png_bytep buf, png_uint_32 i)
20 {
21 buf[0] = (png_byte)((i >> 24) & 0xff);
22 buf[1] = (png_byte)((i >> 16) & 0xff);
23 buf[2] = (png_byte)((i >> 8) & 0xff);
24 buf[3] = (png_byte)(i & 0xff);
25 }
26
27 #if defined(PNG_WRITE_pCAL_SUPPORTED)
28 /* The png_save_int_32 function assumes integers are stored in two's
29 * complement format. If this isn't the case, then this routine needs to
30 * be modified to write data in two's complement format.
31 */
32 void
33 png_save_int_32(png_bytep buf, png_int_32 i)
34 {
35 buf[0] = (png_byte)((i >> 24) & 0xff);
36 buf[1] = (png_byte)((i >> 16) & 0xff);
37 buf[2] = (png_byte)((i >> 8) & 0xff);
38 buf[3] = (png_byte)(i & 0xff);
39 }
40 #endif
41
42 /* Place a 16-bit number into a buffer in PNG byte order.
43 * The parameter is declared unsigned int, not png_uint_16,
44 * just to avoid potential problems on pre-ANSI C compilers.
45 */
46 void
47 png_save_uint_16(png_bytep buf, unsigned int i)
48 {
49 buf[0] = (png_byte)((i >> 8) & 0xff);
50 buf[1] = (png_byte)(i & 0xff);
51 }
52
53 /* Write a PNG chunk all at once. The type is an array of ASCII characters
54 * representing the chunk name. The array must be at least 4 bytes in
55 * length, and does not need to be null terminated. To be safe, pass the
56 * pre-defined chunk names here, and if you need a new one, define it
57 * where the others are defined. The length is the length of the data.
58 * All the data must be present. If that is not possible, use the
59 * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
60 * functions instead.
61 */
62 void
63 png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
64 png_bytep data, png_size_t length)
65 {
66 png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length);
67 png_write_chunk_data(png_ptr, data, length);
68 png_write_chunk_end(png_ptr);
69 }
70
71 /* Write the start of a PNG chunk. The type is the chunk type.
72 * The total_length is the sum of the lengths of all the data you will be
73 * passing in png_write_chunk_data().
74 */
75 void
76 png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
77 png_uint_32 length)
78 {
79 png_byte buf[4];
80 png_debug2(0, "Writing %s chunk (%d bytes)\n", chunk_name, length);
81
82 /* write the length */
83 png_save_uint_32(buf, length);
84 png_write_data(png_ptr, buf, (png_size_t)4);
85
86 /* write the chunk name */
87 png_write_data(png_ptr, chunk_name, (png_size_t)4);
88 /* reset the crc and run it over the chunk name */
89 png_reset_crc(png_ptr);
90 png_calculate_crc(png_ptr, chunk_name, (png_size_t)4);
91 }
92
93 /* Write the data of a PNG chunk started with png_write_chunk_start().
94 * Note that multiple calls to this function are allowed, and that the
95 * sum of the lengths from these calls *must* add up to the total_length
96 * given to png_write_chunk_start().
97 */
98 void
99 png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)
100 {
101 /* write the data, and run the CRC over it */
102 if (data != NULL && length > 0)
103 {
104 png_calculate_crc(png_ptr, data, length);
105 png_write_data(png_ptr, data, length);
106 }
107 }
108
109 /* Finish a chunk started with png_write_chunk_start(). */
110 void
111 png_write_chunk_end(png_structp png_ptr)
112 {
113 png_byte buf[4];
114
115 /* write the crc */
116 png_save_uint_32(buf, png_ptr->crc);
117
118 png_write_data(png_ptr, buf, (png_size_t)4);
119 }
120
121 /* Simple function to write the signature. If we have already written
122 * the magic bytes of the signature, or more likely, the PNG stream is
123 * being embedded into another stream and doesn't need its own signature,
124 * we should call png_set_sig_bytes() to tell libpng how many of the
125 * bytes have already been written.
126 */
127 void
128 png_write_sig(png_structp png_ptr)
129 {
130 /* write the rest of the 8 byte signature */
131 png_write_data(png_ptr, &png_sig[png_ptr->sig_bytes],
132 (png_size_t)8 - png_ptr->sig_bytes);
133 }
134
135 /* Write the IHDR chunk, and update the png_struct with the necessary
136 * information. Note that the rest of this code depends upon this
137 * information being correct.
138 */
139 void
140 png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
141 int bit_depth, int color_type, int compression_type, int filter_type,
142 int interlace_type)
143 {
144 png_byte buf[13]; /* buffer to store the IHDR info */
145
146 png_debug(1, "in png_write_IHDR\n");
147 /* Check that we have valid input data from the application info */
148 switch (color_type)
149 {
150 case PNG_COLOR_TYPE_GRAY:
151 switch (bit_depth)
152 {
153 case 1:
154 case 2:
155 case 4:
156 case 8:
157 case 16: png_ptr->channels = 1; break;
158 default: png_error(png_ptr,"Invalid bit depth for grayscale image");
159 }
160 break;
161 case PNG_COLOR_TYPE_RGB:
162 if (bit_depth != 8 && bit_depth != 16)
163 png_error(png_ptr, "Invalid bit depth for RGB image");
164 png_ptr->channels = 3;
165 break;
166 case PNG_COLOR_TYPE_PALETTE:
167 switch (bit_depth)
168 {
169 case 1:
170 case 2:
171 case 4:
172 case 8: png_ptr->channels = 1; break;
173 default: png_error(png_ptr, "Invalid bit depth for paletted image");
174 }
175 break;
176 case PNG_COLOR_TYPE_GRAY_ALPHA:
177 if (bit_depth != 8 && bit_depth != 16)
178 png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");
179 png_ptr->channels = 2;
180 break;
181 case PNG_COLOR_TYPE_RGB_ALPHA:
182 if (bit_depth != 8 && bit_depth != 16)
183 png_error(png_ptr, "Invalid bit depth for RGBA image");
184 png_ptr->channels = 4;
185 break;
186 default:
187 png_error(png_ptr, "Invalid image color type specified");
188 }
189
190 if (compression_type != PNG_COMPRESSION_TYPE_BASE)
191 {
192 png_warning(png_ptr, "Invalid compression type specified");
193 compression_type = PNG_COMPRESSION_TYPE_BASE;
194 }
195
196 if (filter_type != PNG_FILTER_TYPE_BASE)
197 {
198 png_warning(png_ptr, "Invalid filter type specified");
199 filter_type = PNG_FILTER_TYPE_BASE;
200 }
201
202 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
203 if (interlace_type != PNG_INTERLACE_NONE &&
204 interlace_type != PNG_INTERLACE_ADAM7)
205 {
206 png_warning(png_ptr, "Invalid interlace type specified");
207 interlace_type = PNG_INTERLACE_ADAM7;
208 }
209 #else
210 interlace_type=PNG_INTERLACE_NONE;
211 #endif
212
213 /* save off the relevent information */
214 png_ptr->bit_depth = (png_byte)bit_depth;
215 png_ptr->color_type = (png_byte)color_type;
216 png_ptr->interlaced = (png_byte)interlace_type;
217 png_ptr->width = width;
218 png_ptr->height = height;
219
220 png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
221 png_ptr->rowbytes = ((width * (png_size_t)png_ptr->pixel_depth + 7) >> 3);
222 /* set the usr info, so any transformations can modify it */
223 png_ptr->usr_width = png_ptr->width;
224 png_ptr->usr_bit_depth = png_ptr->bit_depth;
225 png_ptr->usr_channels = png_ptr->channels;
226
227 /* pack the header information into the buffer */
228 png_save_uint_32(buf, width);
229 png_save_uint_32(buf + 4, height);
230 buf[8] = (png_byte)bit_depth;
231 buf[9] = (png_byte)color_type;
232 buf[10] = (png_byte)compression_type;
233 buf[11] = (png_byte)filter_type;
234 buf[12] = (png_byte)interlace_type;
235
236 /* write the chunk */
237 png_write_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
238
239 /* initialize zlib with PNG info */
240 png_ptr->zstream.zalloc = png_zalloc;
241 png_ptr->zstream.zfree = png_zfree;
242 png_ptr->zstream.opaque = (voidpf)png_ptr;
243 if (!(png_ptr->do_filter))
244 {
245 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
246 png_ptr->bit_depth < 8)
247 png_ptr->do_filter = PNG_FILTER_NONE;
248 else
249 png_ptr->do_filter = PNG_ALL_FILTERS;
250 }
251 if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY))
252 {
253 if (png_ptr->do_filter != PNG_FILTER_NONE)
254 png_ptr->zlib_strategy = Z_FILTERED;
255 else
256 png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;
257 }
258 if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL))
259 png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;
260 if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL))
261 png_ptr->zlib_mem_level = 8;
262 if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS))
263 png_ptr->zlib_window_bits = 15;
264 if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))
265 png_ptr->zlib_method = 8;
266 deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,
267 png_ptr->zlib_method, png_ptr->zlib_window_bits,
268 png_ptr->zlib_mem_level, png_ptr->zlib_strategy);
269 png_ptr->zstream.next_out = png_ptr->zbuf;
270 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
271
272 png_ptr->mode = PNG_HAVE_IHDR;
273 }
274
275 /* write the palette. We are careful not to trust png_color to be in the
276 * correct order for PNG, so people can redefine it to any convenient
277 * structure.
278 */
279 void
280 png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
281 {
282 png_uint_32 i;
283 png_colorp pal_ptr;
284 png_byte buf[3];
285
286 png_debug(1, "in png_write_PLTE\n");
287 if (num_pal == 0 || num_pal > 256)
288 {
289 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
290 {
291 png_error(png_ptr, "Invalid number of colors in palette");
292 }
293 else
294 {
295 png_warning(png_ptr, "Invalid number of colors in palette");
296 return;
297 }
298 }
299
300 png_ptr->num_palette = (png_uint_16)num_pal;
301 png_debug1(3, "num_palette = %d\n", png_ptr->num_palette);
302
303 png_write_chunk_start(png_ptr, png_PLTE, num_pal * 3);
304 for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
305 {
306 buf[0] = pal_ptr->red;
307 buf[1] = pal_ptr->green;
308 buf[2] = pal_ptr->blue;
309 png_write_chunk_data(png_ptr, buf, (png_size_t)3);
310 }
311 png_write_chunk_end(png_ptr);
312 png_ptr->mode |= PNG_HAVE_PLTE;
313 }
314
315 /* write an IDAT chunk */
316 void
317 png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
318 {
319 png_debug(1, "in png_write_IDAT\n");
320 png_write_chunk(png_ptr, png_IDAT, data, length);
321 png_ptr->mode |= PNG_HAVE_IDAT;
322 }
323
324 /* write an IEND chunk */
325 void
326 png_write_IEND(png_structp png_ptr)
327 {
328 png_debug(1, "in png_write_IEND\n");
329 png_write_chunk(png_ptr, png_IEND, NULL, (png_size_t)0);
330 png_ptr->mode |= PNG_HAVE_IEND;
331 }
332
333 #if defined(PNG_WRITE_gAMA_SUPPORTED)
334 /* write a gAMA chunk */
335 void
336 png_write_gAMA(png_structp png_ptr, double file_gamma)
337 {
338 png_uint_32 igamma;
339 png_byte buf[4];
340
341 png_debug(1, "in png_write_gAMA\n");
342 /* file_gamma is saved in 1/1000000ths */
343 igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);
344 png_save_uint_32(buf, igamma);
345 png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
346 }
347 #endif
348
349 #if defined(PNG_WRITE_sRGB_SUPPORTED)
350 /* write a sRGB chunk */
351 void
352 png_write_sRGB(png_structp png_ptr, int srgb_intent)
353 {
354 png_byte buf[1];
355
356 png_debug(1, "in png_write_sRGB\n");
357 if(srgb_intent >= PNG_sRGB_INTENT_LAST)
358 png_warning(png_ptr,
359 "Invalid sRGB rendering intent specified");
360 buf[0]=(png_byte)srgb_intent;
361 png_write_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
362 }
363 #endif
364
365 #if defined(PNG_WRITE_sBIT_SUPPORTED)
366 /* write the sBIT chunk */
367 void
368 png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
369 {
370 png_byte buf[4];
371 png_size_t size;
372
373 png_debug(1, "in png_write_sBIT\n");
374 /* make sure we don't depend upon the order of PNG_COLOR_8 */
375 if (color_type & PNG_COLOR_MASK_COLOR)
376 {
377 png_byte maxbits;
378
379 maxbits = color_type==PNG_COLOR_TYPE_PALETTE ? 8 : png_ptr->usr_bit_depth;
380 if (sbit->red == 0 || sbit->red > maxbits ||
381 sbit->green == 0 || sbit->green > maxbits ||
382 sbit->blue == 0 || sbit->blue > maxbits)
383 {
384 png_warning(png_ptr, "Invalid sBIT depth specified");
385 return;
386 }
387 buf[0] = sbit->red;
388 buf[1] = sbit->green;
389 buf[2] = sbit->blue;
390 size = 3;
391 }
392 else
393 {
394 if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)
395 {
396 png_warning(png_ptr, "Invalid sBIT depth specified");
397 return;
398 }
399 buf[0] = sbit->gray;
400 size = 1;
401 }
402
403 if (color_type & PNG_COLOR_MASK_ALPHA)
404 {
405 if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
406 {
407 png_warning(png_ptr, "Invalid sBIT depth specified");
408 return;
409 }
410 buf[size++] = sbit->alpha;
411 }
412
413 png_write_chunk(png_ptr, png_sBIT, buf, size);
414 }
415 #endif
416
417 #if defined(PNG_WRITE_cHRM_SUPPORTED)
418 /* write the cHRM chunk */
419 void
420 png_write_cHRM(png_structp png_ptr, double white_x, double white_y,
421 double red_x, double red_y, double green_x, double green_y,
422 double blue_x, double blue_y)
423 {
424 png_uint_32 itemp;
425 png_byte buf[32];
426
427 png_debug(1, "in png_write_cHRM\n");
428 /* each value is saved int 1/1000000ths */
429 if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 ||
430 white_x + white_y > 1.0)
431 {
432 png_warning(png_ptr, "Invalid cHRM white point specified");
433 return;
434 }
435 itemp = (png_uint_32)(white_x * 100000.0 + 0.5);
436 png_save_uint_32(buf, itemp);
437 itemp = (png_uint_32)(white_y * 100000.0 + 0.5);
438 png_save_uint_32(buf + 4, itemp);
439
440 if (red_x < 0 || red_x > 0.8 || red_y < 0 || red_y > 0.8 ||
441 red_x + red_y > 1.0)
442 {
443 png_warning(png_ptr, "Invalid cHRM red point specified");
444 return;
445 }
446 itemp = (png_uint_32)(red_x * 100000.0 + 0.5);
447 png_save_uint_32(buf + 8, itemp);
448 itemp = (png_uint_32)(red_y * 100000.0 + 0.5);
449 png_save_uint_32(buf + 12, itemp);
450
451 if (green_x < 0 || green_x > 0.8 || green_y < 0 || green_y > 0.8 ||
452 green_x + green_y > 1.0)
453 {
454 png_warning(png_ptr, "Invalid cHRM green point specified");
455 return;
456 }
457 itemp = (png_uint_32)(green_x * 100000.0 + 0.5);
458 png_save_uint_32(buf + 16, itemp);
459 itemp = (png_uint_32)(green_y * 100000.0 + 0.5);
460 png_save_uint_32(buf + 20, itemp);
461
462 if (blue_x < 0 || blue_x > 0.8 || blue_y < 0 || blue_y > 0.8 ||
463 blue_x + blue_y > 1.0)
464 {
465 png_warning(png_ptr, "Invalid cHRM blue point specified");
466 return;
467 }
468 itemp = (png_uint_32)(blue_x * 100000.0 + 0.5);
469 png_save_uint_32(buf + 24, itemp);
470 itemp = (png_uint_32)(blue_y * 100000.0 + 0.5);
471 png_save_uint_32(buf + 28, itemp);
472
473 png_write_chunk(png_ptr, png_cHRM, buf, (png_size_t)32);
474 }
475 #endif
476
477 #if defined(PNG_WRITE_tRNS_SUPPORTED)
478 /* write the tRNS chunk */
479 void
480 png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
481 int num_trans, int color_type)
482 {
483 png_byte buf[6];
484
485 png_debug(1, "in png_write_tRNS\n");
486 if (color_type == PNG_COLOR_TYPE_PALETTE)
487 {
488 if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
489 {
490 png_warning(png_ptr,"Invalid number of transparent colors specified");
491 return;
492 }
493 /* write the chunk out as it is */
494 png_write_chunk(png_ptr, png_tRNS, trans, (png_size_t)num_trans);
495 }
496 else if (color_type == PNG_COLOR_TYPE_GRAY)
497 {
498 /* one 16 bit value */
499 png_save_uint_16(buf, tran->gray);
500 png_write_chunk(png_ptr, png_tRNS, buf, (png_size_t)2);
501 }
502 else if (color_type == PNG_COLOR_TYPE_RGB)
503 {
504 /* three 16 bit values */
505 png_save_uint_16(buf, tran->red);
506 png_save_uint_16(buf + 2, tran->green);
507 png_save_uint_16(buf + 4, tran->blue);
508 png_write_chunk(png_ptr, png_tRNS, buf, (png_size_t)6);
509 }
510 else
511 {
512 png_warning(png_ptr, "Can't write tRNS with an alpha channel");
513 }
514 }
515 #endif
516
517 #if defined(PNG_WRITE_bKGD_SUPPORTED)
518 /* write the background chunk */
519 void
520 png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
521 {
522 png_byte buf[6];
523
524 png_debug(1, "in png_write_bKGD\n");
525 if (color_type == PNG_COLOR_TYPE_PALETTE)
526 {
527 if (back->index > png_ptr->num_palette)
528 {
529 png_warning(png_ptr, "Invalid background palette index");
530 return;
531 }
532 buf[0] = back->index;
533 png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)1);
534 }
535 else if (color_type & PNG_COLOR_MASK_COLOR)
536 {
537 png_save_uint_16(buf, back->red);
538 png_save_uint_16(buf + 2, back->green);
539 png_save_uint_16(buf + 4, back->blue);
540 png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)6);
541 }
542 else
543 {
544 png_save_uint_16(buf, back->gray);
545 png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)2);
546 }
547 }
548 #endif
549
550 #if defined(PNG_WRITE_hIST_SUPPORTED)
551 /* write the histogram */
552 void
553 png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
554 {
555 int i;
556 png_byte buf[3];
557
558 png_debug(1, "in png_write_hIST\n");
559 if (num_hist > (int)png_ptr->num_palette)
560 {
561 png_debug2(3, "num_hist = %d, num_palette = %d\n", num_hist,
562 png_ptr->num_palette);
563 png_warning(png_ptr, "Invalid number of histogram entries specified");
564 return;
565 }
566
567 png_write_chunk_start(png_ptr, png_hIST, (png_uint_32)(num_hist * 2));
568 for (i = 0; i < num_hist; i++)
569 {
570 png_save_uint_16(buf, hist[i]);
571 png_write_chunk_data(png_ptr, buf, (png_size_t)2);
572 }
573 png_write_chunk_end(png_ptr);
574 }
575 #endif
576
577 #if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED) || \
578 defined(PNG_WRITE_pCAL_SUPPORTED)
579 /* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
580 * and if invalid, correct the keyword rather than discarding the entire
581 * chunk. The PNG 1.0 specification requires keywords 1-79 characters in
582 * length, forbids leading or trailing whitespace, multiple internal spaces,
583 * and the non-break space (0x80) from ISO 8859-1. Returns keyword length.
584 *
585 * The new_key is allocated to hold the corrected keyword and must be freed
586 * by the calling routine. This avoids problems with trying to write to
587 * static keywords without having to have duplicate copies of the strings.
588 */
589 png_size_t
590 png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
591 {
592 png_size_t key_len;
593 png_charp kp, dp;
594 int kflag;
595
596 png_debug(1, "in png_check_keyword\n");
597 *new_key = NULL;
598
599 if (key == NULL || (key_len = png_strlen(key)) == 0)
600 {
601 png_chunk_warning(png_ptr, "zero length keyword");
602 return ((png_size_t)0);
603 }
604
605 png_debug1(2, "Keyword to be checked is '%s'\n", key);
606
607 *new_key = (png_charp)png_malloc(png_ptr, (png_uint_32)(key_len + 1));
608
609 /* Replace non-printing characters with a blank and print a warning */
610 for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)
611 {
612 if (*kp < 0x20 || (*kp > 0x7E && (png_byte)*kp < 0xA1))
613 {
614 #if !defined(PNG_NO_STDIO)
615 char msg[40];
616
617 sprintf(msg, "invalid keyword character 0x%02X", *kp);
618 png_chunk_warning(png_ptr, msg);
619 #else
620 png_chunk_warning(png_ptr, "invalid character in keyword");
621 #endif
622 *dp = ' ';
623 }
624 else
625 {
626 *dp = *kp;
627 }
628 }
629 *dp = '\0';
630
631 /* Remove any trailing white space. */
632 kp = *new_key + key_len - 1;
633 if (*kp == ' ')
634 {
635 png_chunk_warning(png_ptr, "trailing spaces removed from keyword");
636
637 while (*kp == ' ')
638 {
639 *(kp--) = '\0';
640 key_len--;
641 }
642 }
643
644 /* Remove any leading white space. */
645 kp = *new_key;
646 if (*kp == ' ')
647 {
648 png_chunk_warning(png_ptr, "leading spaces removed from keyword");
649
650 while (*kp == ' ')
651 {
652 kp++;
653 key_len--;
654 }
655 }
656
657 png_debug1(2, "Checking for multiple internal spaces in '%s'\n", kp);
658
659 /* Remove multiple internal spaces. */
660 for (kflag = 0, dp = *new_key; *kp != '\0'; kp++)
661 {
662 if (*kp == ' ' && kflag == 0)
663 {
664 *(dp++) = *kp;
665 kflag = 1;
666 }
667 else if (*kp == ' ')
668 {
669 key_len--;
670 }
671 else
672 {
673 *(dp++) = *kp;
674 kflag = 0;
675 }
676 }
677 *dp = '\0';
678
679 if (key_len == 0)
680 {
681 png_chunk_warning(png_ptr, "zero length keyword");
682 }
683
684 if (key_len > 79)
685 {
686 png_chunk_warning(png_ptr, "keyword length must be 1 - 79 characters");
687 new_key[79] = '\0';
688 key_len = 79;
689 }
690
691 return (key_len);
692 }
693 #endif
694
695 #if defined(PNG_WRITE_tEXt_SUPPORTED)
696 /* write a tEXt chunk */
697 void
698 png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
699 png_size_t text_len)
700 {
701 png_size_t key_len;
702 png_charp new_key;
703
704 png_debug(1, "in png_write_tEXt\n");
705 if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
706 {
707 png_warning(png_ptr, "Empty keyword in tEXt chunk");
708 return;
709 }
710
711 if (text == NULL || *text == '\0')
712 text_len = 0;
713
714 /* make sure we include the 0 after the key */
715 png_write_chunk_start(png_ptr, png_tEXt, (png_uint_32)key_len+text_len+1);
716 png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);
717 if (text_len)
718 png_write_chunk_data(png_ptr, (png_bytep)text, text_len);
719
720 png_write_chunk_end(png_ptr);
721 png_free(png_ptr, new_key);
722 }
723 #endif
724
725 #if defined(PNG_WRITE_zTXt_SUPPORTED)
726 /* write a compressed text chunk */
727 void
728 png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
729 png_size_t text_len, int compression)
730 {
731 png_size_t key_len;
732 char buf[1];
733 png_charp new_key;
734 int i, ret;
735 png_charpp output_ptr = NULL; /* array of pointers to output */
736 int num_output_ptr = 0; /* number of output pointers used */
737 int max_output_ptr = 0; /* size of output_ptr */
738
739 png_debug(1, "in png_write_zTXt\n");
740
741 if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
742 {
743 png_warning(png_ptr, "Empty keyword in zTXt chunk");
744 return;
745 }
746
747 if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE)
748 {
749 png_write_tEXt(png_ptr, new_key, text, (png_size_t)0);
750 png_free(png_ptr, new_key);
751 return;
752 }
753
754 png_free(png_ptr, new_key);
755
756 if (compression >= PNG_TEXT_COMPRESSION_LAST)
757 {
758 #if !defined(PNG_NO_STDIO)
759 char msg[50];
760 sprintf(msg, "Unknown zTXt compression type %d", compression);
761 png_warning(png_ptr, msg);
762 #else
763 png_warning(png_ptr, "Unknown zTXt compression type");
764 #endif
765 compression = PNG_TEXT_COMPRESSION_zTXt;
766 }
767
768 /* We can't write the chunk until we find out how much data we have,
769 * which means we need to run the compressor first and save the
770 * output. This shouldn't be a problem, as the vast majority of
771 * comments should be reasonable, but we will set up an array of
772 * malloc'd pointers to be sure.
773 *
774 * If we knew the application was well behaved, we could simplify this
775 * greatly by assuming we can always malloc an output buffer large
776 * enough to hold the compressed text ((1001 * text_len / 1000) + 12)
777 * and malloc this directly. The only time this would be a bad idea is
778 * if we can't malloc more than 64K and we have 64K of random input
779 * data, or if the input string is incredibly large (although this
780 * wouldn't cause a failure, just a slowdown due to swapping).
781 */
782
783 /* set up the compression buffers */
784 png_ptr->zstream.avail_in = (uInt)text_len;
785 png_ptr->zstream.next_in = (Bytef *)text;
786 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
787 png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf;
788
789 /* this is the same compression loop as in png_write_row() */
790 do
791 {
792 /* compress the data */
793 ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
794 if (ret != Z_OK)
795 {
796 /* error */
797 if (png_ptr->zstream.msg != NULL)
798 png_error(png_ptr, png_ptr->zstream.msg);
799 else
800 png_error(png_ptr, "zlib error");
801 }
802 /* check to see if we need more room */
803 if (!png_ptr->zstream.avail_out && png_ptr->zstream.avail_in)
804 {
805 /* make sure the output array has room */
806 if (num_output_ptr >= max_output_ptr)
807 {
808 int old_max;
809
810 old_max = max_output_ptr;
811 max_output_ptr = num_output_ptr + 4;
812 if (output_ptr != NULL)
813 {
814 png_charpp old_ptr;
815
816 old_ptr = output_ptr;
817 output_ptr = (png_charpp)png_malloc(png_ptr,
818 (png_uint_32)(max_output_ptr * sizeof (png_charpp)));
819 png_memcpy(output_ptr, old_ptr, old_max * sizeof (png_charp));
820 png_free(png_ptr, old_ptr);
821 }
822 else
823 output_ptr = (png_charpp)png_malloc(png_ptr,
824 (png_uint_32)(max_output_ptr * sizeof (png_charp)));
825 }
826
827 /* save the data */
828 output_ptr[num_output_ptr] = (png_charp)png_malloc(png_ptr,
829 (png_uint_32)png_ptr->zbuf_size);
830 png_memcpy(output_ptr[num_output_ptr], png_ptr->zbuf,
831 png_ptr->zbuf_size);
832 num_output_ptr++;
833
834 /* and reset the buffer */
835 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
836 png_ptr->zstream.next_out = png_ptr->zbuf;
837 }
838 /* continue until we don't have any more to compress */
839 } while (png_ptr->zstream.avail_in);
840
841 /* finish the compression */
842 do
843 {
844 /* tell zlib we are finished */
845 ret = deflate(&png_ptr->zstream, Z_FINISH);
846 if (ret != Z_OK && ret != Z_STREAM_END)
847 {
848 /* we got an error */
849 if (png_ptr->zstream.msg != NULL)
850 png_error(png_ptr, png_ptr->zstream.msg);
851 else
852 png_error(png_ptr, "zlib error");
853 }
854
855 /* check to see if we need more room */
856 if (!(png_ptr->zstream.avail_out) && ret == Z_OK)
857 {
858 /* check to make sure our output array has room */
859 if (num_output_ptr >= max_output_ptr)
860 {
861 int old_max;
862
863 old_max = max_output_ptr;
864 max_output_ptr = num_output_ptr + 4;
865 if (output_ptr != NULL)
866 {
867 png_charpp old_ptr;
868
869 old_ptr = output_ptr;
870 /* This could be optimized to realloc() */
871 output_ptr = (png_charpp)png_malloc(png_ptr,
872 (png_uint_32)(max_output_ptr * sizeof (png_charpp)));
873 png_memcpy(output_ptr, old_ptr, old_max * sizeof (png_charp));
874 png_free(png_ptr, old_ptr);
875 }
876 else
877 output_ptr = (png_charpp)png_malloc(png_ptr,
878 (png_uint_32)(max_output_ptr * sizeof (png_charp)));
879 }
880
881 /* save off the data */
882 output_ptr[num_output_ptr] = (png_charp)png_malloc(png_ptr,
883 (png_uint_32)png_ptr->zbuf_size);
884 png_memcpy(output_ptr[num_output_ptr], png_ptr->zbuf,
885 png_ptr->zbuf_size);
886 num_output_ptr++;
887
888 /* and reset the buffer pointers */
889 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
890 png_ptr->zstream.next_out = png_ptr->zbuf;
891 }
892 } while (ret != Z_STREAM_END);
893
894 /* text length is number of buffers plus last buffer */
895 text_len = png_ptr->zbuf_size * num_output_ptr;
896 if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
897 text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;
898
899 /* write start of chunk */
900 png_write_chunk_start(png_ptr, png_zTXt, (png_uint_32)(key_len+text_len+2));
901 /* write key */
902 png_write_chunk_data(png_ptr, (png_bytep)key, key_len + 1);
903 buf[0] = (png_byte)compression;
904 /* write compression */
905 png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);
906
907 /* write saved output buffers, if any */
908 for (i = 0; i < num_output_ptr; i++)
909 {
910 png_write_chunk_data(png_ptr,(png_bytep)output_ptr[i],png_ptr->zbuf_size);
911 png_free(png_ptr, output_ptr[i]);
912 }
913 if (max_output_ptr != 0)
914 png_free(png_ptr, output_ptr);
915 /* write anything left in zbuf */
916 if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)
917 png_write_chunk_data(png_ptr, png_ptr->zbuf,
918 png_ptr->zbuf_size - png_ptr->zstream.avail_out);
919 /* close the chunk */
920 png_write_chunk_end(png_ptr);
921
922 /* reset zlib for another zTXt or the image data */
923 deflateReset(&png_ptr->zstream);
924 }
925 #endif
926
927
928 #if defined(PNG_WRITE_oFFs_SUPPORTED)
929 /* write the oFFs chunk */
930 void
931 png_write_oFFs(png_structp png_ptr, png_uint_32 x_offset,
932 png_uint_32 y_offset,
933 int unit_type)
934 {
935 png_byte buf[9];
936
937 png_debug(1, "in png_write_oFFs\n");
938 if (unit_type >= PNG_OFFSET_LAST)
939 png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");
940
941 png_save_uint_32(buf, x_offset);
942 png_save_uint_32(buf + 4, y_offset);
943 buf[8] = (png_byte)unit_type;
944
945 png_write_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
946 }
947 #endif
948
949 #if defined(PNG_WRITE_pCAL_SUPPORTED)
950 /* write the pCAL chunk (png-scivis-19970203) */
951 void
952 png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
953 png_int_32 X1, int type, int nparams, png_charp units, png_charpp params)
954 {
955 png_size_t purpose_len, units_len, total_len;
956 png_uint_32p params_len;
957 png_byte buf[10];
958 png_charp new_purpose;
959 int i;
960
961 png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams);
962 if (type >= PNG_EQUATION_LAST)
963 png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
964
965 purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1;
966 png_debug1(3, "pCAL purpose length = %d\n", purpose_len);
967 units_len = png_strlen(units) + (nparams == 0 ? 0 : 1);
968 png_debug1(3, "pCAL units length = %d\n", units_len);
969 total_len = purpose_len + units_len + 10;
970
971 params_len = (png_uint_32p)png_malloc(png_ptr, (png_uint_32)(nparams
972 *sizeof(png_uint_32)));
973
974 /* Find the length of each parameter, making sure we don't count the
975 null terminator for the last parameter. */
976 for (i = 0; i < nparams; i++)
977 {
978 params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
979 png_debug2(3, "pCAL parameter %d length = %d\n", i, params_len[i]);
980 total_len += (png_size_t)params_len[i];
981 }
982
983 png_debug1(3, "pCAL total length = %d\n", total_len);
984 png_write_chunk_start(png_ptr, png_pCAL, (png_uint_32)total_len);
985 png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len);
986 png_save_int_32(buf, X0);
987 png_save_int_32(buf + 4, X1);
988 buf[8] = (png_byte)type;
989 buf[9] = (png_byte)nparams;
990 png_write_chunk_data(png_ptr, buf, (png_size_t)10);
991 png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len);
992
993 png_free(png_ptr, new_purpose);
994
995 for (i = 0; i < nparams; i++)
996 {
997 png_write_chunk_data(png_ptr, (png_bytep)params[i],
998 (png_size_t)params_len[i]);
999 }
1000
1001 png_free(png_ptr, params_len);
1002 png_write_chunk_end(png_ptr);
1003 }
1004 #endif
1005
1006 #if defined(PNG_WRITE_pHYs_SUPPORTED)
1007 /* write the pHYs chunk */
1008 void
1009 png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
1010 png_uint_32 y_pixels_per_unit,
1011 int unit_type)
1012 {
1013 png_byte buf[9];
1014
1015 png_debug(1, "in png_write_pHYs\n");
1016 if (unit_type >= PNG_RESOLUTION_LAST)
1017 png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");
1018
1019 png_save_uint_32(buf, x_pixels_per_unit);
1020 png_save_uint_32(buf + 4, y_pixels_per_unit);
1021 buf[8] = (png_byte)unit_type;
1022
1023 png_write_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
1024 }
1025 #endif
1026
1027 #if defined(PNG_WRITE_tIME_SUPPORTED)
1028 /* Write the tIME chunk. Use either png_convert_from_struct_tm()
1029 * or png_convert_from_time_t(), or fill in the structure yourself.
1030 */
1031 void
1032 png_write_tIME(png_structp png_ptr, png_timep mod_time)
1033 {
1034 png_byte buf[7];
1035
1036 png_debug(1, "in png_write_tIME\n");
1037 if (mod_time->month > 12 || mod_time->month < 1 ||
1038 mod_time->day > 31 || mod_time->day < 1 ||
1039 mod_time->hour > 23 || mod_time->second > 60)
1040 {
1041 png_warning(png_ptr, "Invalid time specified for tIME chunk");
1042 return;
1043 }
1044
1045 png_save_uint_16(buf, mod_time->year);
1046 buf[2] = mod_time->month;
1047 buf[3] = mod_time->day;
1048 buf[4] = mod_time->hour;
1049 buf[5] = mod_time->minute;
1050 buf[6] = mod_time->second;
1051
1052 png_write_chunk(png_ptr, png_tIME, buf, (png_size_t)7);
1053 }
1054 #endif
1055
1056 /* initializes the row writing capability of libpng */
1057 void
1058 png_write_start_row(png_structp png_ptr)
1059 {
1060 png_size_t buf_size;
1061
1062 png_debug(1, "in png_write_start_row\n");
1063 buf_size = (png_size_t)(((png_ptr->width * png_ptr->usr_channels *
1064 png_ptr->usr_bit_depth + 7) >> 3) + 1);
1065
1066 /* set up row buffer */
1067 png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size);
1068 png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
1069
1070 /* set up filtering buffer, if using this filter */
1071 if (png_ptr->do_filter & PNG_FILTER_SUB)
1072 {
1073 png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
1074 (png_ptr->rowbytes + 1));
1075 png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
1076 }
1077
1078 /* We only need to keep the previous row if we are using one of these. */
1079 if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))
1080 {
1081 /* set up previous row buffer */
1082 png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size);
1083 png_memset(png_ptr->prev_row, 0, buf_size);
1084
1085 if (png_ptr->do_filter & PNG_FILTER_UP)
1086 {
1087 png_ptr->up_row = (png_bytep )png_malloc(png_ptr,
1088 (png_ptr->rowbytes + 1));
1089 png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
1090 }
1091
1092 if (png_ptr->do_filter & PNG_FILTER_AVG)
1093 {
1094 png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
1095 (png_ptr->rowbytes + 1));
1096 png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
1097 }
1098
1099 if (png_ptr->do_filter & PNG_FILTER_PAETH)
1100 {
1101 png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr,
1102 (png_ptr->rowbytes + 1));
1103 png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
1104 }
1105 }
1106
1107 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
1108 /* if interlaced, we need to set up width and height of pass */
1109 if (png_ptr->interlaced)
1110 {
1111 if (!(png_ptr->transformations & PNG_INTERLACE))
1112 {
1113 png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
1114 png_pass_ystart[0]) / png_pass_yinc[0];
1115 png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -
1116 png_pass_start[0]) / png_pass_inc[0];
1117 }
1118 else
1119 {
1120 png_ptr->num_rows = png_ptr->height;
1121 png_ptr->usr_width = png_ptr->width;
1122 }
1123 }
1124 else
1125 #endif
1126 {
1127 png_ptr->num_rows = png_ptr->height;
1128 png_ptr->usr_width = png_ptr->width;
1129 }
1130 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1131 png_ptr->zstream.next_out = png_ptr->zbuf;
1132 }
1133
1134 /* Internal use only. Called when finished processing a row of data. */
1135 void
1136 png_write_finish_row(png_structp png_ptr)
1137 {
1138 int ret;
1139
1140 png_debug(1, "in png_write_finish_row\n");
1141 /* next row */
1142 png_ptr->row_number++;
1143
1144 /* see if we are done */
1145 if (png_ptr->row_number < png_ptr->num_rows)
1146 return;
1147
1148 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
1149 /* if interlaced, go to next pass */
1150 if (png_ptr->interlaced)
1151 {
1152 png_ptr->row_number = 0;
1153 if (png_ptr->transformations & PNG_INTERLACE)
1154 {
1155 png_ptr->pass++;
1156 }
1157 else
1158 {
1159 /* loop until we find a non-zero width or height pass */
1160 do
1161 {
1162 png_ptr->pass++;
1163 if (png_ptr->pass >= 7)
1164 break;
1165 png_ptr->usr_width = (png_ptr->width +
1166 png_pass_inc[png_ptr->pass] - 1 -
1167 png_pass_start[png_ptr->pass]) /
1168 png_pass_inc[png_ptr->pass];
1169 png_ptr->num_rows = (png_ptr->height +
1170 png_pass_yinc[png_ptr->pass] - 1 -
1171 png_pass_ystart[png_ptr->pass]) /
1172 png_pass_yinc[png_ptr->pass];
1173 if (png_ptr->transformations & PNG_INTERLACE)
1174 break;
1175 } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
1176
1177 }
1178
1179 /* reset the row above the image for the next pass */
1180 if (png_ptr->pass < 7)
1181 {
1182 if (png_ptr->prev_row != NULL)
1183 png_memset(png_ptr->prev_row, 0,
1184 (png_size_t) (((png_uint_32)png_ptr->usr_channels *
1185 (png_uint_32)png_ptr->usr_bit_depth *
1186 png_ptr->width + 7) >> 3) + 1);
1187 return;
1188 }
1189 }
1190 #endif
1191
1192 /* if we get here, we've just written the last row, so we need
1193 to flush the compressor */
1194 do
1195 {
1196 /* tell the compressor we are done */
1197 ret = deflate(&png_ptr->zstream, Z_FINISH);
1198 /* check for an error */
1199 if (ret != Z_OK && ret != Z_STREAM_END)
1200 {
1201 if (png_ptr->zstream.msg != NULL)
1202 png_error(png_ptr, png_ptr->zstream.msg);
1203 else
1204 png_error(png_ptr, "zlib error");
1205 }
1206 /* check to see if we need more room */
1207 if (!(png_ptr->zstream.avail_out) && ret == Z_OK)
1208 {
1209 png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
1210 png_ptr->zstream.next_out = png_ptr->zbuf;
1211 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1212 }
1213 } while (ret != Z_STREAM_END);
1214
1215 /* write any extra space */
1216 if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
1217 {
1218 png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size -
1219 png_ptr->zstream.avail_out);
1220 }
1221
1222 deflateReset(&png_ptr->zstream);
1223 }
1224
1225 #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
1226 /* Pick out the correct pixels for the interlace pass.
1227 * The basic idea here is to go through the row with a source
1228 * pointer and a destination pointer (sp and dp), and copy the
1229 * correct pixels for the pass. As the row gets compacted,
1230 * sp will always be >= dp, so we should never overwrite anything.
1231 * See the default: case for the easiest code to understand.
1232 */
1233 void
1234 png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
1235 {
1236 png_debug(1, "in png_do_write_interlace\n");
1237 /* we don't have to do anything on the last pass (6) */
1238 #if defined(PNG_USELESS_TESTS_SUPPORTED)
1239 if (row != NULL && row_info != NULL && pass < 6)
1240 #else
1241 if (pass < 6)
1242 #endif
1243 {
1244 /* each pixel depth is handled separately */
1245 switch (row_info->pixel_depth)
1246 {
1247 case 1:
1248 {
1249 png_bytep sp;
1250 png_bytep dp;
1251 int shift;
1252 int d;
1253 int value;
1254 png_uint_32 i;
1255 png_uint_32 row_width = row_info->width;
1256
1257 dp = row;
1258 d = 0;
1259 shift = 7;
1260 for (i = png_pass_start[pass]; i < row_width;
1261 i += png_pass_inc[pass])
1262 {
1263 sp = row + (png_size_t)(i >> 3);
1264 value = (int)(*sp >> (7 - (int)(i & 7))) & 0x1;
1265 d |= (value << shift);
1266
1267 if (shift == 0)
1268 {
1269 shift = 7;
1270 *dp++ = (png_byte)d;
1271 d = 0;
1272 }
1273 else
1274 shift--;
1275
1276 }
1277 if (shift != 7)
1278 *dp = (png_byte)d;
1279 break;
1280 }
1281 case 2:
1282 {
1283 png_bytep sp;
1284 png_bytep dp;
1285 int shift;
1286 int d;
1287 int value;
1288 png_uint_32 i;
1289 png_uint_32 row_width = row_info->width;
1290
1291 dp = row;
1292 shift = 6;
1293 d = 0;
1294 for (i = png_pass_start[pass]; i < row_width;
1295 i += png_pass_inc[pass])
1296 {
1297 sp = row + (png_size_t)(i >> 2);
1298 value = (*sp >> ((3 - (int)(i & 3)) << 1)) & 0x3;
1299 d |= (value << shift);
1300
1301 if (shift == 0)
1302 {
1303 shift = 6;
1304 *dp++ = (png_byte)d;
1305 d = 0;
1306 }
1307 else
1308 shift -= 2;
1309 }
1310 if (shift != 6)
1311 *dp = (png_byte)d;
1312 break;
1313 }
1314 case 4:
1315 {
1316 png_bytep sp;
1317 png_bytep dp;
1318 int shift;
1319 int d;
1320 int value;
1321 png_uint_32 i;
1322 png_uint_32 row_width = row_info->width;
1323
1324 dp = row;
1325 shift = 4;
1326 d = 0;
1327 for (i = png_pass_start[pass]; i < row_width;
1328 i += png_pass_inc[pass])
1329 {
1330 sp = row + (png_size_t)(i >> 1);
1331 value = (*sp >> ((1 - (int)(i & 1)) << 2)) & 0xf;
1332 d |= (value << shift);
1333
1334 if (shift == 0)
1335 {
1336 shift = 4;
1337 *dp++ = (png_byte)d;
1338 d = 0;
1339 }
1340 else
1341 shift -= 4;
1342 }
1343 if (shift != 4)
1344 *dp = (png_byte)d;
1345 break;
1346 }
1347 default:
1348 {
1349 png_bytep sp;
1350 png_bytep dp;
1351 png_uint_32 i;
1352 png_uint_32 row_width = row_info->width;
1353 png_size_t pixel_bytes;
1354
1355 /* start at the beginning */
1356 dp = row;
1357 /* find out how many bytes each pixel takes up */
1358 pixel_bytes = (row_info->pixel_depth >> 3);
1359 /* loop through the row, only looking at the pixels that
1360 matter */
1361 for (i = png_pass_start[pass]; i < row_width;
1362 i += png_pass_inc[pass])
1363 {
1364 /* find out where the original pixel is */
1365 sp = row + (png_size_t)i * pixel_bytes;
1366 /* move the pixel */
1367 if (dp != sp)
1368 png_memcpy(dp, sp, pixel_bytes);
1369 /* next pixel */
1370 dp += pixel_bytes;
1371 }
1372 break;
1373 }
1374 }
1375 /* set new row width */
1376 row_info->width = (row_info->width +
1377 png_pass_inc[pass] - 1 -
1378 png_pass_start[pass]) /
1379 png_pass_inc[pass];
1380 row_info->rowbytes = ((row_info->width *
1381 row_info->pixel_depth + 7) >> 3);
1382 }
1383 }
1384 #endif
1385
1386 /* This filters the row, chooses which filter to use, if it has not already
1387 * been specified by the application, and then writes the row out with the
1388 * chosen filter.
1389 */
1390 #define PNG_MAXSUM (~((png_uint_32)0) >> 1)
1391 #define PNG_HISHIFT 10
1392 #define PNG_LOMASK ((png_uint_32)0xffffL)
1393 #define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))
1394 void
1395 png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
1396 {
1397 png_bytep prev_row, best_row, row_buf;
1398 png_uint_32 mins, bpp;
1399 png_byte filter_to_do = png_ptr->do_filter;
1400 png_uint_32 row_bytes = row_info->rowbytes;
1401 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
1402 int num_p_filters = (int)png_ptr->num_prev_filters;
1403 #endif
1404
1405 png_debug(1, "in png_write_find_filter\n");
1406 /* find out how many bytes offset each pixel is */
1407 bpp = (row_info->pixel_depth + 7) / 8;
1408
1409 prev_row = png_ptr->prev_row;
1410 best_row = row_buf = png_ptr->row_buf;
1411 mins = PNG_MAXSUM;
1412
1413 /* The prediction method we use is to find which method provides the
1414 * smallest value when summing the absolute values of the distances
1415 * from zero, using anything >= 128 as negative numbers. This is known
1416 * as the "minimum sum of absolute differences" heuristic. Other
1417 * heuristics are the "weighted minimum sum of absolute differences"
1418 * (experimental and can in theory improve compression), and the "zlib
1419 * predictive" method (not implemented yet), which does test compressions
1420 * of lines using different filter methods, and then chooses the
1421 * (series of) filter(s) that give minimum compressed data size (VERY
1422 * computationally expensive).
1423 *
1424 * GRR 980525: consider also
1425 * (1) minimum sum of absolute differences from running average (i.e.,
1426 * keep running sum of non-absolute differences & count of bytes)
1427 * [track dispersion, too? restart average if dispersion too large?]
1428 * (1b) minimum sum of absolute differences from sliding average, probably
1429 * with window size <= deflate window (usually 32K)
1430 * (2) minimum sum of squared differences from zero or running average
1431 * (i.e., ~ root-mean-square approach)
1432 */
1433
1434
1435 /* We don't need to test the 'no filter' case if this is the only filter
1436 * that has been chosen, as it doesn't actually do anything to the data.
1437 */
1438 if (filter_to_do & PNG_FILTER_NONE &&
1439 filter_to_do != PNG_FILTER_NONE)
1440 {
1441 png_bytep rp;
1442 png_uint_32 sum = 0;
1443 png_uint_32 i;
1444 int v;
1445
1446 for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
1447 {
1448 v = *rp;
1449 sum += (v < 128) ? v : 256 - v;
1450 }
1451
1452 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
1453 if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
1454 {
1455 png_uint_32 sumhi, sumlo;
1456 int j;
1457 sumlo = sum & PNG_LOMASK;
1458 sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */
1459
1460 /* Reduce the sum if we match any of the previous rows */
1461 for (j = 0; j < num_p_filters; j++)
1462 {
1463 if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
1464 {
1465 sumlo = (sumlo * png_ptr->filter_weights[j]) >>
1466 PNG_WEIGHT_SHIFT;
1467 sumhi = (sumhi * png_ptr->filter_weights[j]) >>
1468 PNG_WEIGHT_SHIFT;
1469 }
1470 }
1471
1472 /* Factor in the cost of this filter (this is here for completeness,
1473 * but it makes no sense to have a "cost" for the NONE filter, as
1474 * it has the minimum possible computational cost - none).
1475 */
1476 sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
1477 PNG_COST_SHIFT;
1478 sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
1479 PNG_COST_SHIFT;
1480
1481 if (sumhi > PNG_HIMASK)
1482 sum = PNG_MAXSUM;
1483 else
1484 sum = (sumhi << PNG_HISHIFT) + sumlo;
1485 }
1486 #endif
1487 mins = sum;
1488 }
1489
1490 /* sub filter */
1491 if (filter_to_do == PNG_FILTER_SUB)
1492 /* it's the only filter so no testing is needed */
1493 {
1494 png_bytep rp, lp, dp;
1495 png_uint_32 i;
1496 for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
1497 i++, rp++, dp++)
1498 {
1499 *dp = *rp;
1500 }
1501 for (lp = row_buf + 1; i < row_bytes;
1502 i++, rp++, lp++, dp++)
1503 {
1504 *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
1505 }
1506 best_row = png_ptr->sub_row;
1507 }
1508
1509 else if (filter_to_do & PNG_FILTER_SUB)
1510 {
1511 png_bytep rp, dp, lp;
1512 png_uint_32 sum = 0, lmins = mins;
1513 png_uint_32 i;
1514 int v;
1515
1516 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
1517 /* We temporarily increase the "minimum sum" by the factor we
1518 * would reduce the sum of this filter, so that we can do the
1519 * early exit comparison without scaling the sum each time.
1520 */
1521 if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
1522 {
1523 int j;
1524 png_uint_32 lmhi, lmlo;
1525 lmlo = lmins & PNG_LOMASK;
1526 lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
1527
1528 for (j = 0; j < num_p_filters; j++)
1529 {
1530 if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
1531 {
1532 lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
1533 PNG_WEIGHT_SHIFT;
1534 lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
1535 PNG_WEIGHT_SHIFT;
1536 }
1537 }
1538
1539 lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
1540 PNG_COST_SHIFT;
1541 lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
1542 PNG_COST_SHIFT;
1543
1544 if (lmhi > PNG_HIMASK)
1545 lmins = PNG_MAXSUM;
1546 else
1547 lmins = (lmhi << PNG_HISHIFT) + lmlo;
1548 }
1549 #endif
1550
1551 for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
1552 i++, rp++, dp++)
1553 {
1554 v = *dp = *rp;
1555
1556 sum += (v < 128) ? v : 256 - v;
1557 }
1558 for (lp = row_buf + 1; i < row_info->rowbytes;
1559 i++, rp++, lp++, dp++)
1560 {
1561 v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
1562
1563 sum += (v < 128) ? v : 256 - v;
1564
1565 if (sum > lmins) /* We are already worse, don't continue. */
1566 break;
1567 }
1568
1569 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
1570 if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
1571 {
1572 int j;
1573 png_uint_32 sumhi, sumlo;
1574 sumlo = sum & PNG_LOMASK;
1575 sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
1576
1577 for (j = 0; j < num_p_filters; j++)
1578 {
1579 if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
1580 {
1581 sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>
1582 PNG_WEIGHT_SHIFT;
1583 sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>
1584 PNG_WEIGHT_SHIFT;
1585 }
1586 }
1587
1588 sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
1589 PNG_COST_SHIFT;
1590 sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
1591 PNG_COST_SHIFT;
1592
1593 if (sumhi > PNG_HIMASK)
1594 sum = PNG_MAXSUM;
1595 else
1596 sum = (sumhi << PNG_HISHIFT) + sumlo;
1597 }
1598 #endif
1599
1600 if (sum < mins)
1601 {
1602 mins = sum;
1603 best_row = png_ptr->sub_row;
1604 }
1605 }
1606
1607 /* up filter */
1608 if (filter_to_do == PNG_FILTER_UP)
1609 {
1610 png_bytep rp, dp, pp;
1611 png_uint_32 i;
1612
1613 for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
1614 pp = prev_row + 1; i < row_bytes;
1615 i++, rp++, pp++, dp++)
1616 {
1617 *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
1618 }
1619 best_row = png_ptr->up_row;
1620 }
1621
1622 else if (filter_to_do & PNG_FILTER_UP)
1623 {
1624 png_bytep rp, dp, pp;
1625 png_uint_32 sum = 0, lmins = mins;
1626 png_uint_32 i;
1627 int v;
1628
1629
1630 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
1631 if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
1632 {
1633 int j;
1634 png_uint_32 lmhi, lmlo;
1635 lmlo = lmins & PNG_LOMASK;
1636 lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
1637
1638 for (j = 0; j < num_p_filters; j++)
1639 {
1640 if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
1641 {
1642 lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
1643 PNG_WEIGHT_SHIFT;
1644 lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
1645 PNG_WEIGHT_SHIFT;
1646 }
1647 }
1648
1649 lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
1650 PNG_COST_SHIFT;
1651 lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
1652 PNG_COST_SHIFT;
1653
1654 if (lmhi > PNG_HIMASK)
1655 lmins = PNG_MAXSUM;
1656 else
1657 lmins = (lmhi << PNG_HISHIFT) + lmlo;
1658 }
1659 #endif
1660
1661 for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
1662 pp = prev_row + 1; i < row_bytes; i++)
1663 {
1664 v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
1665
1666 sum += (v < 128) ? v : 256 - v;
1667
1668 if (sum > lmins) /* We are already worse, don't continue. */
1669 break;
1670 }
1671
1672 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
1673 if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
1674 {
1675 int j;
1676 png_uint_32 sumhi, sumlo;
1677 sumlo = sum & PNG_LOMASK;
1678 sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
1679
1680 for (j = 0; j < num_p_filters; j++)
1681 {
1682 if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
1683 {
1684 sumlo = (sumlo * png_ptr->filter_weights[j]) >>
1685 PNG_WEIGHT_SHIFT;
1686 sumhi = (sumhi * png_ptr->filter_weights[j]) >>
1687 PNG_WEIGHT_SHIFT;
1688 }
1689 }
1690
1691 sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
1692 PNG_COST_SHIFT;
1693 sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
1694 PNG_COST_SHIFT;
1695
1696 if (sumhi > PNG_HIMASK)
1697 sum = PNG_MAXSUM;
1698 else
1699 sum = (sumhi << PNG_HISHIFT) + sumlo;
1700 }
1701 #endif
1702
1703 if (sum < mins)
1704 {
1705 mins = sum;
1706 best_row = png_ptr->up_row;
1707 }
1708 }
1709
1710 /* avg filter */
1711 if (filter_to_do == PNG_FILTER_AVG)
1712 {
1713 png_bytep rp, dp, pp, lp;
1714 png_uint_32 i;
1715 for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
1716 pp = prev_row + 1; i < bpp; i++)
1717 {
1718 *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
1719 }
1720 for (lp = row_buf + 1; i < row_bytes; i++)
1721 {
1722 *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
1723 & 0xff);
1724 }
1725 best_row = png_ptr->avg_row;
1726 }
1727
1728 else if (filter_to_do & PNG_FILTER_AVG)
1729 {
1730 png_bytep rp, dp, pp, lp;
1731 png_uint_32 sum = 0, lmins = mins;
1732 png_uint_32 i;
1733 int v;
1734
1735 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
1736 if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
1737 {
1738 int j;
1739 png_uint_32 lmhi, lmlo;
1740 lmlo = lmins & PNG_LOMASK;
1741 lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
1742
1743 for (j = 0; j < num_p_filters; j++)
1744 {
1745 if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)
1746 {
1747 lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
1748 PNG_WEIGHT_SHIFT;
1749 lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
1750 PNG_WEIGHT_SHIFT;
1751 }
1752 }
1753
1754 lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
1755 PNG_COST_SHIFT;
1756 lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
1757 PNG_COST_SHIFT;
1758
1759 if (lmhi > PNG_HIMASK)
1760 lmins = PNG_MAXSUM;
1761 else
1762 lmins = (lmhi << PNG_HISHIFT) + lmlo;
1763 }
1764 #endif
1765
1766 for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
1767 pp = prev_row + 1; i < bpp; i++)
1768 {
1769 v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
1770
1771 sum += (v < 128) ? v : 256 - v;
1772 }
1773 for (lp = row_buf + 1; i < row_bytes; i++)
1774 {
1775 v = *dp++ =
1776 (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);
1777
1778 sum += (v < 128) ? v : 256 - v;
1779
1780 if (sum > lmins) /* We are already worse, don't continue. */
1781 break;
1782 }
1783
1784 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
1785 if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
1786 {
1787 int j;
1788 png_uint_32 sumhi, sumlo;
1789 sumlo = sum & PNG_LOMASK;
1790 sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
1791
1792 for (j = 0; j < num_p_filters; j++)
1793 {
1794 if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
1795 {
1796 sumlo = (sumlo * png_ptr->filter_weights[j]) >>
1797 PNG_WEIGHT_SHIFT;
1798 sumhi = (sumhi * png_ptr->filter_weights[j]) >>
1799 PNG_WEIGHT_SHIFT;
1800 }
1801 }
1802
1803 sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
1804 PNG_COST_SHIFT;
1805 sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
1806 PNG_COST_SHIFT;
1807
1808 if (sumhi > PNG_HIMASK)
1809 sum = PNG_MAXSUM;
1810 else
1811 sum = (sumhi << PNG_HISHIFT) + sumlo;
1812 }
1813 #endif
1814
1815 if (sum < mins)
1816 {
1817 mins = sum;
1818 best_row = png_ptr->avg_row;
1819 }
1820 }
1821
1822 /* Paeth filter */
1823 if (filter_to_do == PNG_FILTER_PAETH)
1824 {
1825 png_bytep rp, dp, pp, cp, lp;
1826 png_uint_32 i;
1827 for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
1828 pp = prev_row + 1; i < bpp; i++)
1829 {
1830 *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
1831 }
1832
1833 for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
1834 {
1835 int a, b, c, pa, pb, pc, p;
1836
1837 b = *pp++;
1838 c = *cp++;
1839 a = *lp++;
1840
1841 p = b - c;
1842 pc = a - c;
1843
1844 #ifdef PNG_USE_ABS
1845 pa = abs(p);
1846 pb = abs(pc);
1847 pc = abs(p + pc);
1848 #else
1849 pa = p < 0 ? -p : p;
1850 pb = pc < 0 ? -pc : pc;
1851 pc = (p + pc) < 0 ? -(p + pc) : p + pc;
1852 #endif
1853
1854 p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
1855
1856 *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
1857 }
1858 best_row = png_ptr->paeth_row;
1859 }
1860
1861 else if (filter_to_do & PNG_FILTER_PAETH)
1862 {
1863 png_bytep rp, dp, pp, cp, lp;
1864 png_uint_32 sum = 0, lmins = mins;
1865 png_uint_32 i;
1866 int v;
1867
1868 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
1869 if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
1870 {
1871 int j;
1872 png_uint_32 lmhi, lmlo;
1873 lmlo = lmins & PNG_LOMASK;
1874 lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
1875
1876 for (j = 0; j < num_p_filters; j++)
1877 {
1878 if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
1879 {
1880 lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
1881 PNG_WEIGHT_SHIFT;
1882 lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
1883 PNG_WEIGHT_SHIFT;
1884 }
1885 }
1886
1887 lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
1888 PNG_COST_SHIFT;
1889 lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
1890 PNG_COST_SHIFT;
1891
1892 if (lmhi > PNG_HIMASK)
1893 lmins = PNG_MAXSUM;
1894 else
1895 lmins = (lmhi << PNG_HISHIFT) + lmlo;
1896 }
1897 #endif
1898
1899 for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
1900 pp = prev_row + 1; i < bpp; i++)
1901 {
1902 v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
1903
1904 sum += (v < 128) ? v : 256 - v;
1905 }
1906
1907 for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
1908 {
1909 int a, b, c, pa, pb, pc, p;
1910
1911 b = *pp++;
1912 c = *cp++;
1913 a = *lp++;
1914
1915 #ifndef PNG_SLOW_PAETH
1916 p = b - c;
1917 pc = a - c;
1918 #ifdef PNG_USE_ABS
1919 pa = abs(p);
1920 pb = abs(pc);
1921 pc = abs(p + pc);
1922 #else
1923 pa = p < 0 ? -p : p;
1924 pb = pc < 0 ? -pc : pc;
1925 pc = (p + pc) < 0 ? -(p + pc) : p + pc;
1926 #endif
1927 p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
1928 #else /* PNG_SLOW_PAETH */
1929 p = a + b - c;
1930 pa = abs(p - a);
1931 pb = abs(p - b);
1932 pc = abs(p - c);
1933 if (pa <= pb && pa <= pc)
1934 p = a;
1935 else if (pb <= pc)
1936 p = b;
1937 else
1938 p = c;
1939 #endif /* PNG_SLOW_PAETH */
1940
1941 v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
1942
1943 sum += (v < 128) ? v : 256 - v;
1944
1945 if (sum > lmins) /* We are already worse, don't continue. */
1946 break;
1947 }
1948
1949 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
1950 if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
1951 {
1952 int j;
1953 png_uint_32 sumhi, sumlo;
1954 sumlo = sum & PNG_LOMASK;
1955 sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
1956
1957 for (j = 0; j < num_p_filters; j++)
1958 {
1959 if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
1960 {
1961 sumlo = (sumlo * png_ptr->filter_weights[j]) >>
1962 PNG_WEIGHT_SHIFT;
1963 sumhi = (sumhi * png_ptr->filter_weights[j]) >>
1964 PNG_WEIGHT_SHIFT;
1965 }
1966 }
1967
1968 sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
1969 PNG_COST_SHIFT;
1970 sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
1971 PNG_COST_SHIFT;
1972
1973 if (sumhi > PNG_HIMASK)
1974 sum = PNG_MAXSUM;
1975 else
1976 sum = (sumhi << PNG_HISHIFT) + sumlo;
1977 }
1978 #endif
1979
1980 if (sum < mins)
1981 {
1982 best_row = png_ptr->paeth_row;
1983 }
1984 }
1985
1986 /* Do the actual writing of the filtered row data from the chosen filter. */
1987
1988 png_write_filtered_row(png_ptr, best_row);
1989
1990 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
1991 /* Save the type of filter we picked this time for future calculations */
1992 if (png_ptr->num_prev_filters > 0)
1993 {
1994 int j;
1995 for (j = 1; j < num_p_filters; j++)
1996 {
1997 png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];
1998 }
1999 png_ptr->prev_filters[j] = best_row[0];
2000 }
2001 #endif
2002 }
2003
2004
2005 /* Do the actual writing of a previously filtered row. */
2006 void
2007 png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
2008 {
2009 png_debug(1, "in png_write_filtered_row\n");
2010 png_debug1(2, "filter = %d\n", filtered_row[0]);
2011 /* set up the zlib input buffer */
2012 png_ptr->zstream.next_in = filtered_row;
2013 png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1;
2014 /* repeat until we have compressed all the data */
2015 do
2016 {
2017 int ret; /* return of zlib */
2018
2019 /* compress the data */
2020 ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
2021 /* check for compression errors */
2022 if (ret != Z_OK)
2023 {
2024 if (png_ptr->zstream.msg != NULL)
2025 png_error(png_ptr, png_ptr->zstream.msg);
2026 else
2027 png_error(png_ptr, "zlib error");
2028 }
2029
2030 /* see if it is time to write another IDAT */
2031 if (!(png_ptr->zstream.avail_out))
2032 {
2033 /* write the IDAT and reset the zlib output buffer */
2034 png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
2035 png_ptr->zstream.next_out = png_ptr->zbuf;
2036 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
2037 }
2038 /* repeat until all data has been compressed */
2039 } while (png_ptr->zstream.avail_in);
2040
2041 /* swap the current and previous rows */
2042 if (png_ptr->prev_row != NULL)
2043 {
2044 png_bytep tptr;
2045
2046 tptr = png_ptr->prev_row;
2047 png_ptr->prev_row = png_ptr->row_buf;
2048 png_ptr->row_buf = tptr;
2049 }
2050
2051 /* finish row - updates counters and flushes zlib if last row */
2052 png_write_finish_row(png_ptr);
2053
2054 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
2055 png_ptr->flush_rows++;
2056
2057 if (png_ptr->flush_dist > 0 &&
2058 png_ptr->flush_rows >= png_ptr->flush_dist)
2059 {
2060 png_write_flush(png_ptr);
2061 }
2062 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
2063 }