1
2 /* pngset.c - storage of image information into info struct
3 *
4 * Last changed in libpng 1.2.43 [February 25, 2010]
5 * Copyright (c) 1998-2010 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 * The functions here are used during reads to store data from the file
14 * into the info struct, and during writes to store application data
15 * into the info struct for writing into the file. This abstracts the
16 * info struct and allows us to change the structure in the future.
17 */
18
19 #define PNG_INTERNAL
20 #define PNG_NO_PEDANTIC_WARNINGS
21 #include "png.h"
22 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
23
24 #ifdef PNG_bKGD_SUPPORTED
25 void PNGAPI
png_set_bKGD(png_structp png_ptr,png_infop info_ptr,png_color_16p background)26 png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
27 {
28 png_debug1(1, "in %s storage function", "bKGD");
29
30 if (png_ptr == NULL || info_ptr == NULL)
31 return;
32
33 png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));
34 info_ptr->valid |= PNG_INFO_bKGD;
35 }
36 #endif
37
38 #ifdef PNG_cHRM_SUPPORTED
39 #ifdef PNG_FLOATING_POINT_SUPPORTED
40 void PNGAPI
png_set_cHRM(png_structp png_ptr,png_infop info_ptr,double white_x,double white_y,double red_x,double red_y,double green_x,double green_y,double blue_x,double blue_y)41 png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
42 double white_x, double white_y, double red_x, double red_y,
43 double green_x, double green_y, double blue_x, double blue_y)
44 {
45 png_debug1(1, "in %s storage function", "cHRM");
46
47 if (png_ptr == NULL || info_ptr == NULL)
48 return;
49
50 info_ptr->x_white = (float)white_x;
51 info_ptr->y_white = (float)white_y;
52 info_ptr->x_red = (float)red_x;
53 info_ptr->y_red = (float)red_y;
54 info_ptr->x_green = (float)green_x;
55 info_ptr->y_green = (float)green_y;
56 info_ptr->x_blue = (float)blue_x;
57 info_ptr->y_blue = (float)blue_y;
58 #ifdef PNG_FIXED_POINT_SUPPORTED
59 info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5);
60 info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5);
61 info_ptr->int_x_red = (png_fixed_point)( red_x*100000.+0.5);
62 info_ptr->int_y_red = (png_fixed_point)( red_y*100000.+0.5);
63 info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5);
64 info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5);
65 info_ptr->int_x_blue = (png_fixed_point)( blue_x*100000.+0.5);
66 info_ptr->int_y_blue = (png_fixed_point)( blue_y*100000.+0.5);
67 #endif
68 info_ptr->valid |= PNG_INFO_cHRM;
69 }
70 #endif /* PNG_FLOATING_POINT_SUPPORTED */
71
72 #ifdef PNG_FIXED_POINT_SUPPORTED
73 void PNGAPI
png_set_cHRM_fixed(png_structp png_ptr,png_infop info_ptr,png_fixed_point white_x,png_fixed_point white_y,png_fixed_point red_x,png_fixed_point red_y,png_fixed_point green_x,png_fixed_point green_y,png_fixed_point blue_x,png_fixed_point blue_y)74 png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
75 png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
76 png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
77 png_fixed_point blue_x, png_fixed_point blue_y)
78 {
79 png_debug1(1, "in %s storage function", "cHRM fixed");
80
81 if (png_ptr == NULL || info_ptr == NULL)
82 return;
83
84 #ifdef PNG_CHECK_cHRM_SUPPORTED
85 if (png_check_cHRM_fixed(png_ptr,
86 white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y))
87 #endif
88 {
89 info_ptr->int_x_white = white_x;
90 info_ptr->int_y_white = white_y;
91 info_ptr->int_x_red = red_x;
92 info_ptr->int_y_red = red_y;
93 info_ptr->int_x_green = green_x;
94 info_ptr->int_y_green = green_y;
95 info_ptr->int_x_blue = blue_x;
96 info_ptr->int_y_blue = blue_y;
97 #ifdef PNG_FLOATING_POINT_SUPPORTED
98 info_ptr->x_white = (float)(white_x/100000.);
99 info_ptr->y_white = (float)(white_y/100000.);
100 info_ptr->x_red = (float)( red_x/100000.);
101 info_ptr->y_red = (float)( red_y/100000.);
102 info_ptr->x_green = (float)(green_x/100000.);
103 info_ptr->y_green = (float)(green_y/100000.);
104 info_ptr->x_blue = (float)( blue_x/100000.);
105 info_ptr->y_blue = (float)( blue_y/100000.);
106 #endif
107 info_ptr->valid |= PNG_INFO_cHRM;
108 }
109 }
110 #endif /* PNG_FIXED_POINT_SUPPORTED */
111 #endif /* PNG_cHRM_SUPPORTED */
112
113 #ifdef PNG_gAMA_SUPPORTED
114 #ifdef PNG_FLOATING_POINT_SUPPORTED
115 void PNGAPI
png_set_gAMA(png_structp png_ptr,png_infop info_ptr,double file_gamma)116 png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
117 {
118 double png_gamma;
119
120 png_debug1(1, "in %s storage function", "gAMA");
121
122 if (png_ptr == NULL || info_ptr == NULL)
123 return;
124
125 /* Check for overflow */
126 if (file_gamma > 21474.83)
127 {
128 png_warning(png_ptr, "Limiting gamma to 21474.83");
129 png_gamma=21474.83;
130 }
131 else
132 png_gamma = file_gamma;
133 info_ptr->gamma = (float)png_gamma;
134 #ifdef PNG_FIXED_POINT_SUPPORTED
135 info_ptr->int_gamma = (int)(png_gamma*100000.+.5);
136 #endif
137 info_ptr->valid |= PNG_INFO_gAMA;
138 if (png_gamma == 0.0)
139 png_warning(png_ptr, "Setting gamma=0");
140 }
141 #endif
142 void PNGAPI
png_set_gAMA_fixed(png_structp png_ptr,png_infop info_ptr,png_fixed_point int_gamma)143 png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
144 int_gamma)
145 {
146 png_fixed_point png_gamma;
147
148 png_debug1(1, "in %s storage function", "gAMA");
149
150 if (png_ptr == NULL || info_ptr == NULL)
151 return;
152
153 if (int_gamma > (png_fixed_point)PNG_UINT_31_MAX)
154 {
155 png_warning(png_ptr, "Limiting gamma to 21474.83");
156 png_gamma=PNG_UINT_31_MAX;
157 }
158 else
159 {
160 if (int_gamma < 0)
161 {
162 png_warning(png_ptr, "Setting negative gamma to zero");
163 png_gamma = 0;
164 }
165 else
166 png_gamma = int_gamma;
167 }
168 #ifdef PNG_FLOATING_POINT_SUPPORTED
169 info_ptr->gamma = (float)(png_gamma/100000.);
170 #endif
171 #ifdef PNG_FIXED_POINT_SUPPORTED
172 info_ptr->int_gamma = png_gamma;
173 #endif
174 info_ptr->valid |= PNG_INFO_gAMA;
175 if (png_gamma == 0)
176 png_warning(png_ptr, "Setting gamma=0");
177 }
178 #endif
179
180 #ifdef PNG_hIST_SUPPORTED
181 void PNGAPI
png_set_hIST(png_structp png_ptr,png_infop info_ptr,png_uint_16p hist)182 png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
183 {
184 int i;
185
186 png_debug1(1, "in %s storage function", "hIST");
187
188 if (png_ptr == NULL || info_ptr == NULL)
189 return;
190
191 if (info_ptr->num_palette == 0 || info_ptr->num_palette
192 > PNG_MAX_PALETTE_LENGTH)
193 {
194 png_warning(png_ptr,
195 "Invalid palette size, hIST allocation skipped.");
196 return;
197 }
198
199 #ifdef PNG_FREE_ME_SUPPORTED
200 png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
201 #endif
202 /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
203 * version 1.2.1
204 */
205 png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
206 (png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16)));
207 if (png_ptr->hist == NULL)
208 {
209 png_warning(png_ptr, "Insufficient memory for hIST chunk data.");
210 return;
211 }
212
213 for (i = 0; i < info_ptr->num_palette; i++)
214 png_ptr->hist[i] = hist[i];
215 info_ptr->hist = png_ptr->hist;
216 info_ptr->valid |= PNG_INFO_hIST;
217
218 #ifdef PNG_FREE_ME_SUPPORTED
219 info_ptr->free_me |= PNG_FREE_HIST;
220 #else
221 png_ptr->flags |= PNG_FLAG_FREE_HIST;
222 #endif
223 }
224 #endif
225
226 void PNGAPI
png_set_IHDR(png_structp png_ptr,png_infop info_ptr,png_uint_32 width,png_uint_32 height,int bit_depth,int color_type,int interlace_type,int compression_type,int filter_type)227 png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
228 png_uint_32 width, png_uint_32 height, int bit_depth,
229 int color_type, int interlace_type, int compression_type,
230 int filter_type)
231 {
232 png_debug1(1, "in %s storage function", "IHDR");
233
234 if (png_ptr == NULL || info_ptr == NULL)
235 return;
236
237 info_ptr->width = width;
238 info_ptr->height = height;
239 info_ptr->bit_depth = (png_byte)bit_depth;
240 info_ptr->color_type = (png_byte)color_type;
241 info_ptr->compression_type = (png_byte)compression_type;
242 info_ptr->filter_type = (png_byte)filter_type;
243 info_ptr->interlace_type = (png_byte)interlace_type;
244
245 png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
246 info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
247 info_ptr->compression_type, info_ptr->filter_type);
248
249 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
250 info_ptr->channels = 1;
251 else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
252 info_ptr->channels = 3;
253 else
254 info_ptr->channels = 1;
255 if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
256 info_ptr->channels++;
257 info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
258
259 /* Check for potential overflow */
260 if (width > (PNG_UINT_32_MAX
261 >> 3) /* 8-byte RGBA pixels */
262 - 64 /* bigrowbuf hack */
263 - 1 /* filter byte */
264 - 7*8 /* rounding of width to multiple of 8 pixels */
265 - 8) /* extra max_pixel_depth pad */
266 info_ptr->rowbytes = (png_size_t)0;
267 else
268 info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);
269 }
270
271 #ifdef PNG_oFFs_SUPPORTED
272 void PNGAPI
png_set_oFFs(png_structp png_ptr,png_infop info_ptr,png_int_32 offset_x,png_int_32 offset_y,int unit_type)273 png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
274 png_int_32 offset_x, png_int_32 offset_y, int unit_type)
275 {
276 png_debug1(1, "in %s storage function", "oFFs");
277
278 if (png_ptr == NULL || info_ptr == NULL)
279 return;
280
281 info_ptr->x_offset = offset_x;
282 info_ptr->y_offset = offset_y;
283 info_ptr->offset_unit_type = (png_byte)unit_type;
284 info_ptr->valid |= PNG_INFO_oFFs;
285 }
286 #endif
287
288 #ifdef PNG_pCAL_SUPPORTED
289 void PNGAPI
png_set_pCAL(png_structp png_ptr,png_infop info_ptr,png_charp purpose,png_int_32 X0,png_int_32 X1,int type,int nparams,png_charp units,png_charpp params)290 png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
291 png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
292 png_charp units, png_charpp params)
293 {
294 png_uint_32 length;
295 int i;
296
297 png_debug1(1, "in %s storage function", "pCAL");
298
299 if (png_ptr == NULL || info_ptr == NULL)
300 return;
301
302 length = png_strlen(purpose) + 1;
303 png_debug1(3, "allocating purpose for info (%lu bytes)",
304 (unsigned long)length);
305 info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);
306 if (info_ptr->pcal_purpose == NULL)
307 {
308 png_warning(png_ptr, "Insufficient memory for pCAL purpose.");
309 return;
310 }
311 png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);
312
313 png_debug(3, "storing X0, X1, type, and nparams in info");
314 info_ptr->pcal_X0 = X0;
315 info_ptr->pcal_X1 = X1;
316 info_ptr->pcal_type = (png_byte)type;
317 info_ptr->pcal_nparams = (png_byte)nparams;
318
319 length = png_strlen(units) + 1;
320 png_debug1(3, "allocating units for info (%lu bytes)",
321 (unsigned long)length);
322 info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);
323 if (info_ptr->pcal_units == NULL)
324 {
325 png_warning(png_ptr, "Insufficient memory for pCAL units.");
326 return;
327 }
328 png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);
329
330 info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,
331 (png_uint_32)((nparams + 1) * png_sizeof(png_charp)));
332 if (info_ptr->pcal_params == NULL)
333 {
334 png_warning(png_ptr, "Insufficient memory for pCAL params.");
335 return;
336 }
337
338 png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp));
339
340 for (i = 0; i < nparams; i++)
341 {
342 length = png_strlen(params[i]) + 1;
343 png_debug2(3, "allocating parameter %d for info (%lu bytes)", i,
344 (unsigned long)length);
345 info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);
346 if (info_ptr->pcal_params[i] == NULL)
347 {
348 png_warning(png_ptr, "Insufficient memory for pCAL parameter.");
349 return;
350 }
351 png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);
352 }
353
354 info_ptr->valid |= PNG_INFO_pCAL;
355 #ifdef PNG_FREE_ME_SUPPORTED
356 info_ptr->free_me |= PNG_FREE_PCAL;
357 #endif
358 }
359 #endif
360
361 #if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)
362 #ifdef PNG_FLOATING_POINT_SUPPORTED
363 void PNGAPI
png_set_sCAL(png_structp png_ptr,png_infop info_ptr,int unit,double width,double height)364 png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
365 int unit, double width, double height)
366 {
367 png_debug1(1, "in %s storage function", "sCAL");
368
369 if (png_ptr == NULL || info_ptr == NULL)
370 return;
371
372 info_ptr->scal_unit = (png_byte)unit;
373 info_ptr->scal_pixel_width = width;
374 info_ptr->scal_pixel_height = height;
375
376 info_ptr->valid |= PNG_INFO_sCAL;
377 }
378 #else
379 #ifdef PNG_FIXED_POINT_SUPPORTED
380 void PNGAPI
png_set_sCAL_s(png_structp png_ptr,png_infop info_ptr,int unit,png_charp swidth,png_charp sheight)381 png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
382 int unit, png_charp swidth, png_charp sheight)
383 {
384 png_uint_32 length;
385
386 png_debug1(1, "in %s storage function", "sCAL");
387
388 if (png_ptr == NULL || info_ptr == NULL)
389 return;
390
391 info_ptr->scal_unit = (png_byte)unit;
392
393 length = png_strlen(swidth) + 1;
394 png_debug1(3, "allocating unit for info (%u bytes)",
395 (unsigned int)length);
396 info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);
397 if (info_ptr->scal_s_width == NULL)
398 {
399 png_warning(png_ptr,
400 "Memory allocation failed while processing sCAL.");
401 return;
402 }
403 png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);
404
405 length = png_strlen(sheight) + 1;
406 png_debug1(3, "allocating unit for info (%u bytes)",
407 (unsigned int)length);
408 info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);
409 if (info_ptr->scal_s_height == NULL)
410 {
411 png_free (png_ptr, info_ptr->scal_s_width);
412 info_ptr->scal_s_width = NULL;
413 png_warning(png_ptr,
414 "Memory allocation failed while processing sCAL.");
415 return;
416 }
417 png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);
418 info_ptr->valid |= PNG_INFO_sCAL;
419 #ifdef PNG_FREE_ME_SUPPORTED
420 info_ptr->free_me |= PNG_FREE_SCAL;
421 #endif
422 }
423 #endif
424 #endif
425 #endif
426
427 #ifdef PNG_pHYs_SUPPORTED
428 void PNGAPI
png_set_pHYs(png_structp png_ptr,png_infop info_ptr,png_uint_32 res_x,png_uint_32 res_y,int unit_type)429 png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
430 png_uint_32 res_x, png_uint_32 res_y, int unit_type)
431 {
432 png_debug1(1, "in %s storage function", "pHYs");
433
434 if (png_ptr == NULL || info_ptr == NULL)
435 return;
436
437 info_ptr->x_pixels_per_unit = res_x;
438 info_ptr->y_pixels_per_unit = res_y;
439 info_ptr->phys_unit_type = (png_byte)unit_type;
440 info_ptr->valid |= PNG_INFO_pHYs;
441 }
442 #endif
443
444 void PNGAPI
png_set_PLTE(png_structp png_ptr,png_infop info_ptr,png_colorp palette,int num_palette)445 png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
446 png_colorp palette, int num_palette)
447 {
448
449 png_debug1(1, "in %s storage function", "PLTE");
450
451 if (png_ptr == NULL || info_ptr == NULL)
452 return;
453
454 if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
455 {
456 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
457 png_error(png_ptr, "Invalid palette length");
458 else
459 {
460 png_warning(png_ptr, "Invalid palette length");
461 return;
462 }
463 }
464
465 /* It may not actually be necessary to set png_ptr->palette here;
466 * we do it for backward compatibility with the way the png_handle_tRNS
467 * function used to do the allocation.
468 */
469 #ifdef PNG_FREE_ME_SUPPORTED
470 png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
471 #endif
472
473 /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
474 * of num_palette entries, in case of an invalid PNG file that has
475 * too-large sample values.
476 */
477 png_ptr->palette = (png_colorp)png_calloc(png_ptr,
478 PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
479 png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));
480 info_ptr->palette = png_ptr->palette;
481 info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
482
483 #ifdef PNG_FREE_ME_SUPPORTED
484 info_ptr->free_me |= PNG_FREE_PLTE;
485 #else
486 png_ptr->flags |= PNG_FLAG_FREE_PLTE;
487 #endif
488
489 info_ptr->valid |= PNG_INFO_PLTE;
490 }
491
492 #ifdef PNG_sBIT_SUPPORTED
493 void PNGAPI
png_set_sBIT(png_structp png_ptr,png_infop info_ptr,png_color_8p sig_bit)494 png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
495 png_color_8p sig_bit)
496 {
497 png_debug1(1, "in %s storage function", "sBIT");
498
499 if (png_ptr == NULL || info_ptr == NULL)
500 return;
501
502 png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8));
503 info_ptr->valid |= PNG_INFO_sBIT;
504 }
505 #endif
506
507 #ifdef PNG_sRGB_SUPPORTED
508 void PNGAPI
png_set_sRGB(png_structp png_ptr,png_infop info_ptr,int intent)509 png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
510 {
511 png_debug1(1, "in %s storage function", "sRGB");
512
513 if (png_ptr == NULL || info_ptr == NULL)
514 return;
515
516 info_ptr->srgb_intent = (png_byte)intent;
517 info_ptr->valid |= PNG_INFO_sRGB;
518 }
519
520 void PNGAPI
png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr,png_infop info_ptr,int intent)521 png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
522 int intent)
523 {
524 #ifdef PNG_gAMA_SUPPORTED
525 #ifdef PNG_FLOATING_POINT_SUPPORTED
526 float file_gamma;
527 #endif
528 #ifdef PNG_FIXED_POINT_SUPPORTED
529 png_fixed_point int_file_gamma;
530 #endif
531 #endif
532 #ifdef PNG_cHRM_SUPPORTED
533 #ifdef PNG_FLOATING_POINT_SUPPORTED
534 float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
535 #endif
536 png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
537 int_green_y, int_blue_x, int_blue_y;
538 #endif
539 png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");
540
541 if (png_ptr == NULL || info_ptr == NULL)
542 return;
543
544 png_set_sRGB(png_ptr, info_ptr, intent);
545
546 #ifdef PNG_gAMA_SUPPORTED
547 #ifdef PNG_FLOATING_POINT_SUPPORTED
548 file_gamma = (float).45455;
549 png_set_gAMA(png_ptr, info_ptr, file_gamma);
550 #endif
551 #ifdef PNG_FIXED_POINT_SUPPORTED
552 int_file_gamma = 45455L;
553 png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);
554 #endif
555 #endif
556
557 #ifdef PNG_cHRM_SUPPORTED
558 int_white_x = 31270L;
559 int_white_y = 32900L;
560 int_red_x = 64000L;
561 int_red_y = 33000L;
562 int_green_x = 30000L;
563 int_green_y = 60000L;
564 int_blue_x = 15000L;
565 int_blue_y = 6000L;
566
567 #ifdef PNG_FLOATING_POINT_SUPPORTED
568 white_x = (float).3127;
569 white_y = (float).3290;
570 red_x = (float).64;
571 red_y = (float).33;
572 green_x = (float).30;
573 green_y = (float).60;
574 blue_x = (float).15;
575 blue_y = (float).06;
576 #endif
577
578 #ifdef PNG_FIXED_POINT_SUPPORTED
579 png_set_cHRM_fixed(png_ptr, info_ptr,
580 int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
581 int_green_y, int_blue_x, int_blue_y);
582 #endif
583 #ifdef PNG_FLOATING_POINT_SUPPORTED
584 png_set_cHRM(png_ptr, info_ptr,
585 white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
586 #endif
587 #endif /* cHRM */
588 }
589 #endif /* sRGB */
590
591
592 #ifdef PNG_iCCP_SUPPORTED
593 void PNGAPI
png_set_iCCP(png_structp png_ptr,png_infop info_ptr,png_charp name,int compression_type,png_charp profile,png_uint_32 proflen)594 png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
595 png_charp name, int compression_type,
596 png_charp profile, png_uint_32 proflen)
597 {
598 png_charp new_iccp_name;
599 png_charp new_iccp_profile;
600 png_uint_32 length;
601
602 png_debug1(1, "in %s storage function", "iCCP");
603
604 if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
605 return;
606
607 length = png_strlen(name)+1;
608 new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);
609 if (new_iccp_name == NULL)
610 {
611 png_warning(png_ptr, "Insufficient memory to process iCCP chunk.");
612 return;
613 }
614 png_memcpy(new_iccp_name, name, length);
615 new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);
616 if (new_iccp_profile == NULL)
617 {
618 png_free (png_ptr, new_iccp_name);
619 png_warning(png_ptr,
620 "Insufficient memory to process iCCP profile.");
621 return;
622 }
623 png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);
624
625 png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
626
627 info_ptr->iccp_proflen = proflen;
628 info_ptr->iccp_name = new_iccp_name;
629 info_ptr->iccp_profile = new_iccp_profile;
630 /* Compression is always zero but is here so the API and info structure
631 * does not have to change if we introduce multiple compression types
632 */
633 info_ptr->iccp_compression = (png_byte)compression_type;
634 #ifdef PNG_FREE_ME_SUPPORTED
635 info_ptr->free_me |= PNG_FREE_ICCP;
636 #endif
637 info_ptr->valid |= PNG_INFO_iCCP;
638 }
639 #endif
640
641 #ifdef PNG_TEXT_SUPPORTED
642 void PNGAPI
png_set_text(png_structp png_ptr,png_infop info_ptr,png_textp text_ptr,int num_text)643 png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
644 int num_text)
645 {
646 int ret;
647 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
648 if (ret)
649 png_error(png_ptr, "Insufficient memory to store text");
650 }
651
652 int /* PRIVATE */
png_set_text_2(png_structp png_ptr,png_infop info_ptr,png_textp text_ptr,int num_text)653 png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
654 int num_text)
655 {
656 int i;
657
658 png_debug1(1, "in %s storage function", ((png_ptr == NULL ||
659 png_ptr->chunk_name[0] == '\0') ?
660 "text" : (png_const_charp)png_ptr->chunk_name));
661
662 if (png_ptr == NULL || info_ptr == NULL || num_text == 0)
663 return(0);
664
665 /* Make sure we have enough space in the "text" array in info_struct
666 * to hold all of the incoming text_ptr objects.
667 */
668 if (info_ptr->num_text + num_text > info_ptr->max_text)
669 {
670 if (info_ptr->text != NULL)
671 {
672 png_textp old_text;
673 int old_max;
674
675 old_max = info_ptr->max_text;
676 info_ptr->max_text = info_ptr->num_text + num_text + 8;
677 old_text = info_ptr->text;
678 info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
679 (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));
680 if (info_ptr->text == NULL)
681 {
682 png_free(png_ptr, old_text);
683 return(1);
684 }
685 png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
686 png_sizeof(png_text)));
687 png_free(png_ptr, old_text);
688 }
689 else
690 {
691 info_ptr->max_text = num_text + 8;
692 info_ptr->num_text = 0;
693 info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
694 (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));
695 if (info_ptr->text == NULL)
696 return(1);
697 #ifdef PNG_FREE_ME_SUPPORTED
698 info_ptr->free_me |= PNG_FREE_TEXT;
699 #endif
700 }
701 png_debug1(3, "allocated %d entries for info_ptr->text",
702 info_ptr->max_text);
703 }
704 for (i = 0; i < num_text; i++)
705 {
706 png_size_t text_length, key_len;
707 png_size_t lang_len, lang_key_len;
708 png_textp textp = &(info_ptr->text[info_ptr->num_text]);
709
710 if (text_ptr[i].key == NULL)
711 continue;
712
713 key_len = png_strlen(text_ptr[i].key);
714
715 if (text_ptr[i].compression <= 0)
716 {
717 lang_len = 0;
718 lang_key_len = 0;
719 }
720
721 else
722 #ifdef PNG_iTXt_SUPPORTED
723 {
724 /* Set iTXt data */
725
726 if (text_ptr[i].lang != NULL)
727 lang_len = png_strlen(text_ptr[i].lang);
728 else
729 lang_len = 0;
730 if (text_ptr[i].lang_key != NULL)
731 lang_key_len = png_strlen(text_ptr[i].lang_key);
732 else
733 lang_key_len = 0;
734 }
735 #else /* PNG_iTXt_SUPPORTED */
736 {
737 png_warning(png_ptr, "iTXt chunk not supported.");
738 continue;
739 }
740 #endif
741
742 if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')
743 {
744 text_length = 0;
745 #ifdef PNG_iTXt_SUPPORTED
746 if (text_ptr[i].compression > 0)
747 textp->compression = PNG_ITXT_COMPRESSION_NONE;
748 else
749 #endif
750 textp->compression = PNG_TEXT_COMPRESSION_NONE;
751 }
752
753 else
754 {
755 text_length = png_strlen(text_ptr[i].text);
756 textp->compression = text_ptr[i].compression;
757 }
758
759 textp->key = (png_charp)png_malloc_warn(png_ptr,
760 (png_uint_32)
761 (key_len + text_length + lang_len + lang_key_len + 4));
762 if (textp->key == NULL)
763 return(1);
764 png_debug2(2, "Allocated %lu bytes at %x in png_set_text",
765 (png_uint_32)
766 (key_len + lang_len + lang_key_len + text_length + 4),
767 (int)textp->key);
768
769 png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len));
770 *(textp->key + key_len) = '\0';
771 #ifdef PNG_iTXt_SUPPORTED
772 if (text_ptr[i].compression > 0)
773 {
774 textp->lang = textp->key + key_len + 1;
775 png_memcpy(textp->lang, text_ptr[i].lang, lang_len);
776 *(textp->lang + lang_len) = '\0';
777 textp->lang_key = textp->lang + lang_len + 1;
778 png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);
779 *(textp->lang_key + lang_key_len) = '\0';
780 textp->text = textp->lang_key + lang_key_len + 1;
781 }
782 else
783 #endif
784 {
785 #ifdef PNG_iTXt_SUPPORTED
786 textp->lang=NULL;
787 textp->lang_key=NULL;
788 #endif
789 textp->text = textp->key + key_len + 1;
790 }
791 if (text_length)
792 png_memcpy(textp->text, text_ptr[i].text,
793 (png_size_t)(text_length));
794 *(textp->text + text_length) = '\0';
795
796 #ifdef PNG_iTXt_SUPPORTED
797 if (textp->compression > 0)
798 {
799 textp->text_length = 0;
800 textp->itxt_length = text_length;
801 }
802 else
803 #endif
804
805 {
806 textp->text_length = text_length;
807 #ifdef PNG_iTXt_SUPPORTED
808 textp->itxt_length = 0;
809 #endif
810 }
811 info_ptr->num_text++;
812 png_debug1(3, "transferred text chunk %d", info_ptr->num_text);
813 }
814 return(0);
815 }
816 #endif
817
818 #ifdef PNG_tIME_SUPPORTED
819 void PNGAPI
png_set_tIME(png_structp png_ptr,png_infop info_ptr,png_timep mod_time)820 png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
821 {
822 png_debug1(1, "in %s storage function", "tIME");
823
824 if (png_ptr == NULL || info_ptr == NULL ||
825 (png_ptr->mode & PNG_WROTE_tIME))
826 return;
827
828 png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time));
829 info_ptr->valid |= PNG_INFO_tIME;
830 }
831 #endif
832
833 #ifdef PNG_tRNS_SUPPORTED
834 void PNGAPI
png_set_tRNS(png_structp png_ptr,png_infop info_ptr,png_bytep trans,int num_trans,png_color_16p trans_values)835 png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
836 png_bytep trans, int num_trans, png_color_16p trans_values)
837 {
838 png_debug1(1, "in %s storage function", "tRNS");
839
840 if (png_ptr == NULL || info_ptr == NULL)
841 return;
842
843 if (trans != NULL)
844 {
845 /* It may not actually be necessary to set png_ptr->trans here;
846 * we do it for backward compatibility with the way the png_handle_tRNS
847 * function used to do the allocation.
848 */
849
850 #ifdef PNG_FREE_ME_SUPPORTED
851 png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
852 #endif
853
854 /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
855 png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,
856 (png_uint_32)PNG_MAX_PALETTE_LENGTH);
857 if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
858 png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);
859 }
860
861 if (trans_values != NULL)
862 {
863 int sample_max = (1 << info_ptr->bit_depth);
864 if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
865 (int)trans_values->gray > sample_max) ||
866 (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
867 ((int)trans_values->red > sample_max ||
868 (int)trans_values->green > sample_max ||
869 (int)trans_values->blue > sample_max)))
870 png_warning(png_ptr,
871 "tRNS chunk has out-of-range samples for bit_depth");
872 png_memcpy(&(info_ptr->trans_values), trans_values,
873 png_sizeof(png_color_16));
874 if (num_trans == 0)
875 num_trans = 1;
876 }
877
878 info_ptr->num_trans = (png_uint_16)num_trans;
879 if (num_trans != 0)
880 {
881 info_ptr->valid |= PNG_INFO_tRNS;
882 #ifdef PNG_FREE_ME_SUPPORTED
883 info_ptr->free_me |= PNG_FREE_TRNS;
884 #else
885 png_ptr->flags |= PNG_FLAG_FREE_TRNS;
886 #endif
887 }
888 }
889 #endif
890
891 #ifdef PNG_sPLT_SUPPORTED
892 void PNGAPI
png_set_sPLT(png_structp png_ptr,png_infop info_ptr,png_sPLT_tp entries,int nentries)893 png_set_sPLT(png_structp png_ptr,
894 png_infop info_ptr, png_sPLT_tp entries, int nentries)
895 /*
896 * entries - array of png_sPLT_t structures
897 * to be added to the list of palettes
898 * in the info structure.
899 * nentries - number of palette structures to be
900 * added.
901 */
902 {
903 png_sPLT_tp np;
904 int i;
905
906 if (png_ptr == NULL || info_ptr == NULL)
907 return;
908
909 np = (png_sPLT_tp)png_malloc_warn(png_ptr,
910 (info_ptr->splt_palettes_num + nentries) *
911 (png_uint_32)png_sizeof(png_sPLT_t));
912 if (np == NULL)
913 {
914 png_warning(png_ptr, "No memory for sPLT palettes.");
915 return;
916 }
917
918 png_memcpy(np, info_ptr->splt_palettes,
919 info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
920 png_free(png_ptr, info_ptr->splt_palettes);
921 info_ptr->splt_palettes=NULL;
922
923 for (i = 0; i < nentries; i++)
924 {
925 png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
926 png_sPLT_tp from = entries + i;
927 png_uint_32 length;
928
929 length = png_strlen(from->name) + 1;
930 to->name = (png_charp)png_malloc_warn(png_ptr, length);
931 if (to->name == NULL)
932 {
933 png_warning(png_ptr,
934 "Out of memory while processing sPLT chunk");
935 continue;
936 }
937 png_memcpy(to->name, from->name, length);
938 to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,
939 (png_uint_32)(from->nentries * png_sizeof(png_sPLT_entry)));
940 if (to->entries == NULL)
941 {
942 png_warning(png_ptr,
943 "Out of memory while processing sPLT chunk");
944 png_free(png_ptr, to->name);
945 to->name = NULL;
946 continue;
947 }
948 png_memcpy(to->entries, from->entries,
949 from->nentries * png_sizeof(png_sPLT_entry));
950 to->nentries = from->nentries;
951 to->depth = from->depth;
952 }
953
954 info_ptr->splt_palettes = np;
955 info_ptr->splt_palettes_num += nentries;
956 info_ptr->valid |= PNG_INFO_sPLT;
957 #ifdef PNG_FREE_ME_SUPPORTED
958 info_ptr->free_me |= PNG_FREE_SPLT;
959 #endif
960 }
961 #endif /* PNG_sPLT_SUPPORTED */
962
963 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
964 void PNGAPI
png_set_unknown_chunks(png_structp png_ptr,png_infop info_ptr,png_unknown_chunkp unknowns,int num_unknowns)965 png_set_unknown_chunks(png_structp png_ptr,
966 png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
967 {
968 png_unknown_chunkp np;
969 int i;
970
971 if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)
972 return;
973
974 np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
975 (png_uint_32)((info_ptr->unknown_chunks_num + num_unknowns) *
976 png_sizeof(png_unknown_chunk)));
977 if (np == NULL)
978 {
979 png_warning(png_ptr,
980 "Out of memory while processing unknown chunk.");
981 return;
982 }
983
984 png_memcpy(np, info_ptr->unknown_chunks,
985 info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));
986 png_free(png_ptr, info_ptr->unknown_chunks);
987 info_ptr->unknown_chunks = NULL;
988
989 for (i = 0; i < num_unknowns; i++)
990 {
991 png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
992 png_unknown_chunkp from = unknowns + i;
993
994 png_memcpy((png_charp)to->name, (png_charp)from->name,
995 png_sizeof(from->name));
996 to->name[png_sizeof(to->name)-1] = '\0';
997 to->size = from->size;
998 /* Note our location in the read or write sequence */
999 to->location = (png_byte)(png_ptr->mode & 0xff);
1000
1001 if (from->size == 0)
1002 to->data=NULL;
1003 else
1004 {
1005 to->data = (png_bytep)png_malloc_warn(png_ptr,
1006 (png_uint_32)from->size);
1007 if (to->data == NULL)
1008 {
1009 png_warning(png_ptr,
1010 "Out of memory while processing unknown chunk.");
1011 to->size = 0;
1012 }
1013 else
1014 png_memcpy(to->data, from->data, from->size);
1015 }
1016 }
1017
1018 info_ptr->unknown_chunks = np;
1019 info_ptr->unknown_chunks_num += num_unknowns;
1020 #ifdef PNG_FREE_ME_SUPPORTED
1021 info_ptr->free_me |= PNG_FREE_UNKN;
1022 #endif
1023 }
1024 void PNGAPI
png_set_unknown_chunk_location(png_structp png_ptr,png_infop info_ptr,int chunk,int location)1025 png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,
1026 int chunk, int location)
1027 {
1028 if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <
1029 (int)info_ptr->unknown_chunks_num)
1030 info_ptr->unknown_chunks[chunk].location = (png_byte)location;
1031 }
1032 #endif
1033
1034 #if defined(PNG_1_0_X) || defined(PNG_1_2_X)
1035 #if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \
1036 defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
1037 void PNGAPI
png_permit_empty_plte(png_structp png_ptr,int empty_plte_permitted)1038 png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)
1039 {
1040 /* This function is deprecated in favor of png_permit_mng_features()
1041 and will be removed from libpng-1.3.0 */
1042
1043 png_debug(1, "in png_permit_empty_plte, DEPRECATED.");
1044
1045 if (png_ptr == NULL)
1046 return;
1047 png_ptr->mng_features_permitted = (png_byte)
1048 ((png_ptr->mng_features_permitted & (~PNG_FLAG_MNG_EMPTY_PLTE)) |
1049 ((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE)));
1050 }
1051 #endif
1052 #endif
1053
1054 #ifdef PNG_MNG_FEATURES_SUPPORTED
1055 png_uint_32 PNGAPI
png_permit_mng_features(png_structp png_ptr,png_uint_32 mng_features)1056 png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)
1057 {
1058 png_debug(1, "in png_permit_mng_features");
1059
1060 if (png_ptr == NULL)
1061 return (png_uint_32)0;
1062 png_ptr->mng_features_permitted =
1063 (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);
1064 return (png_uint_32)png_ptr->mng_features_permitted;
1065 }
1066 #endif
1067
1068 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
1069 void PNGAPI
png_set_keep_unknown_chunks(png_structp png_ptr,int keep,png_bytep chunk_list,int num_chunks)1070 png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
1071 chunk_list, int num_chunks)
1072 {
1073 png_bytep new_list, p;
1074 int i, old_num_chunks;
1075 if (png_ptr == NULL)
1076 return;
1077 if (num_chunks == 0)
1078 {
1079 if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)
1080 png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
1081 else
1082 png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
1083
1084 if (keep == PNG_HANDLE_CHUNK_ALWAYS)
1085 png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
1086 else
1087 png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
1088 return;
1089 }
1090 if (chunk_list == NULL)
1091 return;
1092 old_num_chunks = png_ptr->num_chunk_list;
1093 new_list=(png_bytep)png_malloc(png_ptr,
1094 (png_uint_32)
1095 (5*(num_chunks + old_num_chunks)));
1096 if (png_ptr->chunk_list != NULL)
1097 {
1098 png_memcpy(new_list, png_ptr->chunk_list,
1099 (png_size_t)(5*old_num_chunks));
1100 png_free(png_ptr, png_ptr->chunk_list);
1101 png_ptr->chunk_list=NULL;
1102 }
1103 png_memcpy(new_list + 5*old_num_chunks, chunk_list,
1104 (png_size_t)(5*num_chunks));
1105 for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5)
1106 *p=(png_byte)keep;
1107 png_ptr->num_chunk_list = old_num_chunks + num_chunks;
1108 png_ptr->chunk_list = new_list;
1109 #ifdef PNG_FREE_ME_SUPPORTED
1110 png_ptr->free_me |= PNG_FREE_LIST;
1111 #endif
1112 }
1113 #endif
1114
1115 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1116 void PNGAPI
png_set_read_user_chunk_fn(png_structp png_ptr,png_voidp user_chunk_ptr,png_user_chunk_ptr read_user_chunk_fn)1117 png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
1118 png_user_chunk_ptr read_user_chunk_fn)
1119 {
1120 png_debug(1, "in png_set_read_user_chunk_fn");
1121
1122 if (png_ptr == NULL)
1123 return;
1124
1125 png_ptr->read_user_chunk_fn = read_user_chunk_fn;
1126 png_ptr->user_chunk_ptr = user_chunk_ptr;
1127 }
1128 #endif
1129
1130 #ifdef PNG_INFO_IMAGE_SUPPORTED
1131 void PNGAPI
png_set_rows(png_structp png_ptr,png_infop info_ptr,png_bytepp row_pointers)1132 png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)
1133 {
1134 png_debug1(1, "in %s storage function", "rows");
1135
1136 if (png_ptr == NULL || info_ptr == NULL)
1137 return;
1138
1139 if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))
1140 png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
1141 info_ptr->row_pointers = row_pointers;
1142 if (row_pointers)
1143 info_ptr->valid |= PNG_INFO_IDAT;
1144 }
1145 #endif
1146
1147 void PNGAPI
png_set_compression_buffer_size(png_structp png_ptr,png_uint_32 size)1148 png_set_compression_buffer_size(png_structp png_ptr,
1149 png_uint_32 size)
1150 {
1151 if (png_ptr == NULL)
1152 return;
1153 png_free(png_ptr, png_ptr->zbuf);
1154 png_ptr->zbuf_size = (png_size_t)size;
1155 png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);
1156 png_ptr->zstream.next_out = png_ptr->zbuf;
1157 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1158 }
1159
1160 void PNGAPI
png_set_invalid(png_structp png_ptr,png_infop info_ptr,int mask)1161 png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
1162 {
1163 if (png_ptr && info_ptr)
1164 info_ptr->valid &= ~mask;
1165 }
1166
1167
1168 #ifndef PNG_1_0_X
1169 #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
1170 /* Function was added to libpng 1.2.0 and should always exist by default */
1171 void PNGAPI
png_set_asm_flags(png_structp png_ptr,png_uint_32 asm_flags)1172 png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)
1173 {
1174 /* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */
1175 if (png_ptr != NULL)
1176 png_ptr->asm_flags = 0;
1177 asm_flags = asm_flags; /* Quiet the compiler */
1178 }
1179
1180 /* This function was added to libpng 1.2.0 */
1181 void PNGAPI
png_set_mmx_thresholds(png_structp png_ptr,png_byte mmx_bitdepth_threshold,png_uint_32 mmx_rowbytes_threshold)1182 png_set_mmx_thresholds (png_structp png_ptr,
1183 png_byte mmx_bitdepth_threshold,
1184 png_uint_32 mmx_rowbytes_threshold)
1185 {
1186 /* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */
1187 if (png_ptr == NULL)
1188 return;
1189 /* Quiet the compiler */
1190 mmx_bitdepth_threshold = mmx_bitdepth_threshold;
1191 mmx_rowbytes_threshold = mmx_rowbytes_threshold;
1192 }
1193 #endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
1194
1195 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
1196 /* This function was added to libpng 1.2.6 */
1197 void PNGAPI
png_set_user_limits(png_structp png_ptr,png_uint_32 user_width_max,png_uint_32 user_height_max)1198 png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
1199 png_uint_32 user_height_max)
1200 {
1201 /* Images with dimensions larger than these limits will be
1202 * rejected by png_set_IHDR(). To accept any PNG datastream
1203 * regardless of dimensions, set both limits to 0x7ffffffL.
1204 */
1205 if (png_ptr == NULL)
1206 return;
1207 png_ptr->user_width_max = user_width_max;
1208 png_ptr->user_height_max = user_height_max;
1209 }
1210 #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
1211
1212
1213 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
1214 void PNGAPI
png_set_benign_errors(png_structp png_ptr,int allowed)1215 png_set_benign_errors(png_structp png_ptr, int allowed)
1216 {
1217 png_debug(1, "in png_set_benign_errors");
1218
1219 if (allowed)
1220 png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
1221 else
1222 png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN;
1223 }
1224 #endif /* PNG_BENIGN_ERRORS_SUPPORTED */
1225 #endif /* ?PNG_1_0_X */
1226 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
1227