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 | */
|
---|
23 | void PNGAPI
|
---|
24 | png_save_uint_32(png_bytep buf, png_uint_32 i)
|
---|
25 | {
|
---|
26 | buf[0] = (png_byte)((i >> 24) & 0xff);
|
---|
27 | buf[1] = (png_byte)((i >> 16) & 0xff);
|
---|
28 | buf[2] = (png_byte)((i >> 8) & 0xff);
|
---|
29 | buf[3] = (png_byte)(i & 0xff);
|
---|
30 | }
|
---|
31 |
|
---|
32 | /* 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 | */
|
---|
36 | void PNGAPI
|
---|
37 | png_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 | */
|
---|
49 | void PNGAPI
|
---|
50 | png_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 | */
|
---|
62 | void /* PRIVATE */
|
---|
63 | png_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 | */
|
---|
83 | void PNGAPI
|
---|
84 | png_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 | */
|
---|
98 | void PNGAPI
|
---|
99 | png_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 | */
|
---|
127 | void PNGAPI
|
---|
128 | png_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(). */
|
---|
144 | void PNGAPI
|
---|
145 | png_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 |
|
---|
164 | typedef 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 */
|
---|
174 | static int /* PRIVATE */
|
---|
175 | png_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 */
|
---|
352 | static void /* PRIVATE */
|
---|
353 | png_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 | */
|
---|
391 | void /* PRIVATE */
|
---|
392 | png_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 | */
|
---|
572 | void /* PRIVATE */
|
---|
573 | png_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 */
|
---|
639 | void /* PRIVATE */
|
---|
640 | png_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 */
|
---|
694 | void /* PRIVATE */
|
---|
695 | png_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
|
---|
711 | void /* PRIVATE */
|
---|
712 | png_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
|
---|
729 | void /* PRIVATE */
|
---|
730 | png_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 */
|
---|
748 | void /* PRIVATE */
|
---|
749 | png_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 */
|
---|
768 | void /* PRIVATE */
|
---|
769 | png_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 */
|
---|
849 | void /* PRIVATE */
|
---|
850 | png_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 */
|
---|
930 | void /* PRIVATE */
|
---|
931 | png_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
|
---|
988 | void /* PRIVATE */
|
---|
989 | png_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
|
---|
1036 | void /* PRIVATE */
|
---|
1037 | png_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 */
|
---|
1075 | void /* PRIVATE */
|
---|
1076 | png_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 */
|
---|
1132 | void /* PRIVATE */
|
---|
1133 | png_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 */
|
---|
1186 | void /* PRIVATE */
|
---|
1187 | png_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 | */
|
---|
1228 | png_size_t /* PRIVATE */
|
---|
1229 | png_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 */
|
---|
1350 | void /* PRIVATE */
|
---|
1351 | png_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 */
|
---|
1391 | void /* PRIVATE */
|
---|
1392 | png_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 */
|
---|
1451 | void /* PRIVATE */
|
---|
1452 | png_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 */
|
---|
1540 | void /* PRIVATE */
|
---|
1541 | png_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) */
|
---|
1563 | void /* PRIVATE */
|
---|
1564 | png_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)
|
---|
1627 | void /* PRIVATE */
|
---|
1628 | png_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
|
---|
1667 | void /* PRIVATE */
|
---|
1668 | png_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 */
|
---|
1701 | void /* PRIVATE */
|
---|
1702 | png_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 | */
|
---|
1728 | void /* PRIVATE */
|
---|
1729 | png_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 */
|
---|
1758 | void /* PRIVATE */
|
---|
1759 | png_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. */
|
---|
1858 | void /* PRIVATE */
|
---|
1859 | png_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 | */
|
---|
1978 | void /* PRIVATE */
|
---|
1979 | png_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))
|
---|
2150 | void /* PRIVATE */
|
---|
2151 | png_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. */
|
---|
2778 | void /* PRIVATE */
|
---|
2779 | png_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 */
|
---|