2 /* pngset.c - storage of image information into info struct
4 * Last changed in libpng 1.6.15 [November 20, 2014]
5 * Copyright (c) 1998-2014 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.)
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
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.
21 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
23 #ifdef PNG_bKGD_SUPPORTED
25 png_set_bKGD(png_const_structrp png_ptr
, png_inforp info_ptr
,
26 png_const_color_16p background
)
28 png_debug1(1, "in %s storage function", "bKGD");
30 if (png_ptr
== NULL
|| info_ptr
== NULL
|| background
== NULL
)
33 info_ptr
->background
= *background
;
34 info_ptr
->valid
|= PNG_INFO_bKGD
;
38 #ifdef PNG_cHRM_SUPPORTED
40 png_set_cHRM_fixed(png_const_structrp png_ptr
, png_inforp info_ptr
,
41 png_fixed_point white_x
, png_fixed_point white_y
, png_fixed_point red_x
,
42 png_fixed_point red_y
, png_fixed_point green_x
, png_fixed_point green_y
,
43 png_fixed_point blue_x
, png_fixed_point blue_y
)
47 png_debug1(1, "in %s storage function", "cHRM fixed");
49 if (png_ptr
== NULL
|| info_ptr
== NULL
)
61 if (png_colorspace_set_chromaticities(png_ptr
, &info_ptr
->colorspace
, &xy
,
62 2/* override with app values*/) != 0)
63 info_ptr
->colorspace
.flags
|= PNG_COLORSPACE_FROM_cHRM
;
65 png_colorspace_sync_info(png_ptr
, info_ptr
);
69 png_set_cHRM_XYZ_fixed(png_const_structrp png_ptr
, png_inforp info_ptr
,
70 png_fixed_point int_red_X
, png_fixed_point int_red_Y
,
71 png_fixed_point int_red_Z
, png_fixed_point int_green_X
,
72 png_fixed_point int_green_Y
, png_fixed_point int_green_Z
,
73 png_fixed_point int_blue_X
, png_fixed_point int_blue_Y
,
74 png_fixed_point int_blue_Z
)
78 png_debug1(1, "in %s storage function", "cHRM XYZ fixed");
80 if (png_ptr
== NULL
|| info_ptr
== NULL
)
83 XYZ
.red_X
= int_red_X
;
84 XYZ
.red_Y
= int_red_Y
;
85 XYZ
.red_Z
= int_red_Z
;
86 XYZ
.green_X
= int_green_X
;
87 XYZ
.green_Y
= int_green_Y
;
88 XYZ
.green_Z
= int_green_Z
;
89 XYZ
.blue_X
= int_blue_X
;
90 XYZ
.blue_Y
= int_blue_Y
;
91 XYZ
.blue_Z
= int_blue_Z
;
93 if (png_colorspace_set_endpoints(png_ptr
, &info_ptr
->colorspace
,
95 info_ptr
->colorspace
.flags
|= PNG_COLORSPACE_FROM_cHRM
;
97 png_colorspace_sync_info(png_ptr
, info_ptr
);
100 # ifdef PNG_FLOATING_POINT_SUPPORTED
102 png_set_cHRM(png_const_structrp png_ptr
, png_inforp info_ptr
,
103 double white_x
, double white_y
, double red_x
, double red_y
,
104 double green_x
, double green_y
, double blue_x
, double blue_y
)
106 png_set_cHRM_fixed(png_ptr
, info_ptr
,
107 png_fixed(png_ptr
, white_x
, "cHRM White X"),
108 png_fixed(png_ptr
, white_y
, "cHRM White Y"),
109 png_fixed(png_ptr
, red_x
, "cHRM Red X"),
110 png_fixed(png_ptr
, red_y
, "cHRM Red Y"),
111 png_fixed(png_ptr
, green_x
, "cHRM Green X"),
112 png_fixed(png_ptr
, green_y
, "cHRM Green Y"),
113 png_fixed(png_ptr
, blue_x
, "cHRM Blue X"),
114 png_fixed(png_ptr
, blue_y
, "cHRM Blue Y"));
118 png_set_cHRM_XYZ(png_const_structrp png_ptr
, png_inforp info_ptr
, double red_X
,
119 double red_Y
, double red_Z
, double green_X
, double green_Y
, double green_Z
,
120 double blue_X
, double blue_Y
, double blue_Z
)
122 png_set_cHRM_XYZ_fixed(png_ptr
, info_ptr
,
123 png_fixed(png_ptr
, red_X
, "cHRM Red X"),
124 png_fixed(png_ptr
, red_Y
, "cHRM Red Y"),
125 png_fixed(png_ptr
, red_Z
, "cHRM Red Z"),
126 png_fixed(png_ptr
, green_X
, "cHRM Red X"),
127 png_fixed(png_ptr
, green_Y
, "cHRM Red Y"),
128 png_fixed(png_ptr
, green_Z
, "cHRM Red Z"),
129 png_fixed(png_ptr
, blue_X
, "cHRM Red X"),
130 png_fixed(png_ptr
, blue_Y
, "cHRM Red Y"),
131 png_fixed(png_ptr
, blue_Z
, "cHRM Red Z"));
133 # endif /* FLOATING_POINT */
137 #ifdef PNG_gAMA_SUPPORTED
139 png_set_gAMA_fixed(png_const_structrp png_ptr
, png_inforp info_ptr
,
140 png_fixed_point file_gamma
)
142 png_debug1(1, "in %s storage function", "gAMA");
144 if (png_ptr
== NULL
|| info_ptr
== NULL
)
147 png_colorspace_set_gamma(png_ptr
, &info_ptr
->colorspace
, file_gamma
);
148 png_colorspace_sync_info(png_ptr
, info_ptr
);
151 # ifdef PNG_FLOATING_POINT_SUPPORTED
153 png_set_gAMA(png_const_structrp png_ptr
, png_inforp info_ptr
, double file_gamma
)
155 png_set_gAMA_fixed(png_ptr
, info_ptr
, png_fixed(png_ptr
, file_gamma
,
161 #ifdef PNG_hIST_SUPPORTED
163 png_set_hIST(png_const_structrp png_ptr
, png_inforp info_ptr
,
164 png_const_uint_16p hist
)
168 png_debug1(1, "in %s storage function", "hIST");
170 if (png_ptr
== NULL
|| info_ptr
== NULL
)
173 if (info_ptr
->num_palette
== 0 || info_ptr
->num_palette
174 > PNG_MAX_PALETTE_LENGTH
)
177 "Invalid palette size, hIST allocation skipped");
182 png_free_data(png_ptr
, info_ptr
, PNG_FREE_HIST
, 0);
184 /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
187 info_ptr
->hist
= png_voidcast(png_uint_16p
, png_malloc_warn(png_ptr
,
188 PNG_MAX_PALETTE_LENGTH
* (sizeof (png_uint_16
))));
190 if (info_ptr
->hist
== NULL
)
192 png_warning(png_ptr
, "Insufficient memory for hIST chunk data");
196 info_ptr
->free_me
|= PNG_FREE_HIST
;
198 for (i
= 0; i
< info_ptr
->num_palette
; i
++)
199 info_ptr
->hist
[i
] = hist
[i
];
201 info_ptr
->valid
|= PNG_INFO_hIST
;
206 png_set_IHDR(png_const_structrp png_ptr
, png_inforp info_ptr
,
207 png_uint_32 width
, png_uint_32 height
, int bit_depth
,
208 int color_type
, int interlace_type
, int compression_type
,
211 png_debug1(1, "in %s storage function", "IHDR");
213 if (png_ptr
== NULL
|| info_ptr
== NULL
)
216 info_ptr
->width
= width
;
217 info_ptr
->height
= height
;
218 info_ptr
->bit_depth
= (png_byte
)bit_depth
;
219 info_ptr
->color_type
= (png_byte
)color_type
;
220 info_ptr
->compression_type
= (png_byte
)compression_type
;
221 info_ptr
->filter_type
= (png_byte
)filter_type
;
222 info_ptr
->interlace_type
= (png_byte
)interlace_type
;
224 png_check_IHDR (png_ptr
, info_ptr
->width
, info_ptr
->height
,
225 info_ptr
->bit_depth
, info_ptr
->color_type
, info_ptr
->interlace_type
,
226 info_ptr
->compression_type
, info_ptr
->filter_type
);
228 if (info_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
229 info_ptr
->channels
= 1;
231 else if ((info_ptr
->color_type
& PNG_COLOR_MASK_COLOR
) != 0)
232 info_ptr
->channels
= 3;
235 info_ptr
->channels
= 1;
237 if ((info_ptr
->color_type
& PNG_COLOR_MASK_ALPHA
) != 0)
238 info_ptr
->channels
++;
240 info_ptr
->pixel_depth
= (png_byte
)(info_ptr
->channels
* info_ptr
->bit_depth
);
242 info_ptr
->rowbytes
= PNG_ROWBYTES(info_ptr
->pixel_depth
, width
);
244 #ifdef PNG_APNG_SUPPORTED
245 /* for non-animated png. this may be overwritten from an acTL chunk later */
246 info_ptr
->num_frames
= 1;
250 #ifdef PNG_oFFs_SUPPORTED
252 png_set_oFFs(png_const_structrp png_ptr
, png_inforp info_ptr
,
253 png_int_32 offset_x
, png_int_32 offset_y
, int unit_type
)
255 png_debug1(1, "in %s storage function", "oFFs");
257 if (png_ptr
== NULL
|| info_ptr
== NULL
)
260 info_ptr
->x_offset
= offset_x
;
261 info_ptr
->y_offset
= offset_y
;
262 info_ptr
->offset_unit_type
= (png_byte
)unit_type
;
263 info_ptr
->valid
|= PNG_INFO_oFFs
;
267 #ifdef PNG_pCAL_SUPPORTED
269 png_set_pCAL(png_const_structrp png_ptr
, png_inforp info_ptr
,
270 png_const_charp purpose
, png_int_32 X0
, png_int_32 X1
, int type
,
271 int nparams
, png_const_charp units
, png_charpp params
)
276 png_debug1(1, "in %s storage function", "pCAL");
278 if (png_ptr
== NULL
|| info_ptr
== NULL
|| purpose
== NULL
|| units
== NULL
279 || (nparams
> 0 && params
== NULL
))
282 length
= strlen(purpose
) + 1;
283 png_debug1(3, "allocating purpose for info (%lu bytes)",
284 (unsigned long)length
);
286 /* TODO: validate format of calibration name and unit name */
288 /* Check that the type matches the specification. */
289 if (type
< 0 || type
> 3)
290 png_error(png_ptr
, "Invalid pCAL equation type");
292 if (nparams
< 0 || nparams
> 255)
293 png_error(png_ptr
, "Invalid pCAL parameter count");
295 /* Validate params[nparams] */
296 for (i
=0; i
<nparams
; ++i
)
298 if (params
[i
] == NULL
||
299 !png_check_fp_string(params
[i
], strlen(params
[i
])))
300 png_error(png_ptr
, "Invalid format for pCAL parameter");
303 info_ptr
->pcal_purpose
= png_voidcast(png_charp
,
304 png_malloc_warn(png_ptr
, length
));
306 if (info_ptr
->pcal_purpose
== NULL
)
308 png_warning(png_ptr
, "Insufficient memory for pCAL purpose");
312 memcpy(info_ptr
->pcal_purpose
, purpose
, length
);
314 png_debug(3, "storing X0, X1, type, and nparams in info");
315 info_ptr
->pcal_X0
= X0
;
316 info_ptr
->pcal_X1
= X1
;
317 info_ptr
->pcal_type
= (png_byte
)type
;
318 info_ptr
->pcal_nparams
= (png_byte
)nparams
;
320 length
= strlen(units
) + 1;
321 png_debug1(3, "allocating units for info (%lu bytes)",
322 (unsigned long)length
);
324 info_ptr
->pcal_units
= png_voidcast(png_charp
,
325 png_malloc_warn(png_ptr
, length
));
327 if (info_ptr
->pcal_units
== NULL
)
329 png_warning(png_ptr
, "Insufficient memory for pCAL units");
333 memcpy(info_ptr
->pcal_units
, units
, length
);
335 info_ptr
->pcal_params
= png_voidcast(png_charpp
, png_malloc_warn(png_ptr
,
336 (png_size_t
)((nparams
+ 1) * (sizeof (png_charp
)))));
338 if (info_ptr
->pcal_params
== NULL
)
340 png_warning(png_ptr
, "Insufficient memory for pCAL params");
344 memset(info_ptr
->pcal_params
, 0, (nparams
+ 1) * (sizeof (png_charp
)));
346 for (i
= 0; i
< nparams
; i
++)
348 length
= strlen(params
[i
]) + 1;
349 png_debug2(3, "allocating parameter %d for info (%lu bytes)", i
,
350 (unsigned long)length
);
352 info_ptr
->pcal_params
[i
] = (png_charp
)png_malloc_warn(png_ptr
, length
);
354 if (info_ptr
->pcal_params
[i
] == NULL
)
356 png_warning(png_ptr
, "Insufficient memory for pCAL parameter");
360 memcpy(info_ptr
->pcal_params
[i
], params
[i
], length
);
363 info_ptr
->valid
|= PNG_INFO_pCAL
;
364 info_ptr
->free_me
|= PNG_FREE_PCAL
;
368 #ifdef PNG_sCAL_SUPPORTED
370 png_set_sCAL_s(png_const_structrp png_ptr
, png_inforp info_ptr
,
371 int unit
, png_const_charp swidth
, png_const_charp sheight
)
373 png_size_t lengthw
= 0, lengthh
= 0;
375 png_debug1(1, "in %s storage function", "sCAL");
377 if (png_ptr
== NULL
|| info_ptr
== NULL
)
380 /* Double check the unit (should never get here with an invalid
381 * unit unless this is an API call.)
383 if (unit
!= 1 && unit
!= 2)
384 png_error(png_ptr
, "Invalid sCAL unit");
386 if (swidth
== NULL
|| (lengthw
= strlen(swidth
)) == 0 ||
387 swidth
[0] == 45 /* '-' */ || !png_check_fp_string(swidth
, lengthw
))
388 png_error(png_ptr
, "Invalid sCAL width");
390 if (sheight
== NULL
|| (lengthh
= strlen(sheight
)) == 0 ||
391 sheight
[0] == 45 /* '-' */ || !png_check_fp_string(sheight
, lengthh
))
392 png_error(png_ptr
, "Invalid sCAL height");
394 info_ptr
->scal_unit
= (png_byte
)unit
;
398 png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw
);
400 info_ptr
->scal_s_width
= png_voidcast(png_charp
,
401 png_malloc_warn(png_ptr
, lengthw
));
403 if (info_ptr
->scal_s_width
== NULL
)
405 png_warning(png_ptr
, "Memory allocation failed while processing sCAL");
409 memcpy(info_ptr
->scal_s_width
, swidth
, lengthw
);
413 png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthh
);
415 info_ptr
->scal_s_height
= png_voidcast(png_charp
,
416 png_malloc_warn(png_ptr
, lengthh
));
418 if (info_ptr
->scal_s_height
== NULL
)
420 png_free (png_ptr
, info_ptr
->scal_s_width
);
421 info_ptr
->scal_s_width
= NULL
;
423 png_warning(png_ptr
, "Memory allocation failed while processing sCAL");
427 memcpy(info_ptr
->scal_s_height
, sheight
, lengthh
);
429 info_ptr
->valid
|= PNG_INFO_sCAL
;
430 info_ptr
->free_me
|= PNG_FREE_SCAL
;
433 # ifdef PNG_FLOATING_POINT_SUPPORTED
435 png_set_sCAL(png_const_structrp png_ptr
, png_inforp info_ptr
, int unit
,
436 double width
, double height
)
438 png_debug1(1, "in %s storage function", "sCAL");
440 /* Check the arguments. */
442 png_warning(png_ptr
, "Invalid sCAL width ignored");
444 else if (height
<= 0)
445 png_warning(png_ptr
, "Invalid sCAL height ignored");
449 /* Convert 'width' and 'height' to ASCII. */
450 char swidth
[PNG_sCAL_MAX_DIGITS
+1];
451 char sheight
[PNG_sCAL_MAX_DIGITS
+1];
453 png_ascii_from_fp(png_ptr
, swidth
, (sizeof swidth
), width
,
455 png_ascii_from_fp(png_ptr
, sheight
, (sizeof sheight
), height
,
458 png_set_sCAL_s(png_ptr
, info_ptr
, unit
, swidth
, sheight
);
463 # ifdef PNG_FIXED_POINT_SUPPORTED
465 png_set_sCAL_fixed(png_const_structrp png_ptr
, png_inforp info_ptr
, int unit
,
466 png_fixed_point width
, png_fixed_point height
)
468 png_debug1(1, "in %s storage function", "sCAL");
470 /* Check the arguments. */
472 png_warning(png_ptr
, "Invalid sCAL width ignored");
474 else if (height
<= 0)
475 png_warning(png_ptr
, "Invalid sCAL height ignored");
479 /* Convert 'width' and 'height' to ASCII. */
480 char swidth
[PNG_sCAL_MAX_DIGITS
+1];
481 char sheight
[PNG_sCAL_MAX_DIGITS
+1];
483 png_ascii_from_fixed(png_ptr
, swidth
, (sizeof swidth
), width
);
484 png_ascii_from_fixed(png_ptr
, sheight
, (sizeof sheight
), height
);
486 png_set_sCAL_s(png_ptr
, info_ptr
, unit
, swidth
, sheight
);
492 #ifdef PNG_pHYs_SUPPORTED
494 png_set_pHYs(png_const_structrp png_ptr
, png_inforp info_ptr
,
495 png_uint_32 res_x
, png_uint_32 res_y
, int unit_type
)
497 png_debug1(1, "in %s storage function", "pHYs");
499 if (png_ptr
== NULL
|| info_ptr
== NULL
)
502 info_ptr
->x_pixels_per_unit
= res_x
;
503 info_ptr
->y_pixels_per_unit
= res_y
;
504 info_ptr
->phys_unit_type
= (png_byte
)unit_type
;
505 info_ptr
->valid
|= PNG_INFO_pHYs
;
510 png_set_PLTE(png_structrp png_ptr
, png_inforp info_ptr
,
511 png_const_colorp palette
, int num_palette
)
514 png_debug1(1, "in %s storage function", "PLTE");
516 if (png_ptr
== NULL
|| info_ptr
== NULL
)
519 if (num_palette
< 0 || num_palette
> PNG_MAX_PALETTE_LENGTH
)
521 if (info_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
522 png_error(png_ptr
, "Invalid palette length");
526 png_warning(png_ptr
, "Invalid palette length");
531 if ((num_palette
> 0 && palette
== NULL
) ||
533 # ifdef PNG_MNG_FEATURES_SUPPORTED
534 && (png_ptr
->mng_features_permitted
& PNG_FLAG_MNG_EMPTY_PLTE
) == 0
538 png_error(png_ptr
, "Invalid palette");
542 /* It may not actually be necessary to set png_ptr->palette here;
543 * we do it for backward compatibility with the way the png_handle_tRNS
544 * function used to do the allocation.
546 * 1.6.0: the above statement appears to be incorrect; something has to set
547 * the palette inside png_struct on read.
549 png_free_data(png_ptr
, info_ptr
, PNG_FREE_PLTE
, 0);
551 /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
552 * of num_palette entries, in case of an invalid PNG file that has
553 * too-large sample values.
555 png_ptr
->palette
= png_voidcast(png_colorp
, png_calloc(png_ptr
,
556 PNG_MAX_PALETTE_LENGTH
* (sizeof (png_color
))));
559 memcpy(png_ptr
->palette
, palette
, num_palette
* (sizeof (png_color
)));
560 info_ptr
->palette
= png_ptr
->palette
;
561 info_ptr
->num_palette
= png_ptr
->num_palette
= (png_uint_16
)num_palette
;
563 info_ptr
->free_me
|= PNG_FREE_PLTE
;
565 info_ptr
->valid
|= PNG_INFO_PLTE
;
568 #ifdef PNG_sBIT_SUPPORTED
570 png_set_sBIT(png_const_structrp png_ptr
, png_inforp info_ptr
,
571 png_const_color_8p sig_bit
)
573 png_debug1(1, "in %s storage function", "sBIT");
575 if (png_ptr
== NULL
|| info_ptr
== NULL
|| sig_bit
== NULL
)
578 info_ptr
->sig_bit
= *sig_bit
;
579 info_ptr
->valid
|= PNG_INFO_sBIT
;
583 #ifdef PNG_sRGB_SUPPORTED
585 png_set_sRGB(png_const_structrp png_ptr
, png_inforp info_ptr
, int srgb_intent
)
587 png_debug1(1, "in %s storage function", "sRGB");
589 if (png_ptr
== NULL
|| info_ptr
== NULL
)
592 (void)png_colorspace_set_sRGB(png_ptr
, &info_ptr
->colorspace
, srgb_intent
);
593 png_colorspace_sync_info(png_ptr
, info_ptr
);
597 png_set_sRGB_gAMA_and_cHRM(png_const_structrp png_ptr
, png_inforp info_ptr
,
600 png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");
602 if (png_ptr
== NULL
|| info_ptr
== NULL
)
605 if (png_colorspace_set_sRGB(png_ptr
, &info_ptr
->colorspace
,
608 /* This causes the gAMA and cHRM to be written too */
609 info_ptr
->colorspace
.flags
|=
610 PNG_COLORSPACE_FROM_gAMA
|PNG_COLORSPACE_FROM_cHRM
;
613 png_colorspace_sync_info(png_ptr
, info_ptr
);
618 #ifdef PNG_iCCP_SUPPORTED
620 png_set_iCCP(png_const_structrp png_ptr
, png_inforp info_ptr
,
621 png_const_charp name
, int compression_type
,
622 png_const_bytep profile
, png_uint_32 proflen
)
624 png_charp new_iccp_name
;
625 png_bytep new_iccp_profile
;
628 png_debug1(1, "in %s storage function", "iCCP");
630 if (png_ptr
== NULL
|| info_ptr
== NULL
|| name
== NULL
|| profile
== NULL
)
633 if (compression_type
!= PNG_COMPRESSION_TYPE_BASE
)
634 png_app_error(png_ptr
, "Invalid iCCP compression method");
636 /* Set the colorspace first because this validates the profile; do not
637 * override previously set app cHRM or gAMA here (because likely as not the
638 * application knows better than libpng what the correct values are.) Pass
639 * the info_ptr color_type field to png_colorspace_set_ICC because in the
640 * write case it has not yet been stored in png_ptr.
643 int result
= png_colorspace_set_ICC(png_ptr
, &info_ptr
->colorspace
, name
,
644 proflen
, profile
, info_ptr
->color_type
);
646 png_colorspace_sync_info(png_ptr
, info_ptr
);
648 /* Don't do any of the copying if the profile was bad, or inconsistent. */
652 /* But do write the gAMA and cHRM chunks from the profile. */
653 info_ptr
->colorspace
.flags
|=
654 PNG_COLORSPACE_FROM_gAMA
|PNG_COLORSPACE_FROM_cHRM
;
657 length
= strlen(name
)+1;
658 new_iccp_name
= png_voidcast(png_charp
, png_malloc_warn(png_ptr
, length
));
660 if (new_iccp_name
== NULL
)
662 png_benign_error(png_ptr
, "Insufficient memory to process iCCP chunk");
666 memcpy(new_iccp_name
, name
, length
);
667 new_iccp_profile
= png_voidcast(png_bytep
,
668 png_malloc_warn(png_ptr
, proflen
));
670 if (new_iccp_profile
== NULL
)
672 png_free(png_ptr
, new_iccp_name
);
673 new_iccp_name
= NULL
;
674 png_benign_error(png_ptr
,
675 "Insufficient memory to process iCCP profile");
679 memcpy(new_iccp_profile
, profile
, proflen
);
681 png_free_data(png_ptr
, info_ptr
, PNG_FREE_ICCP
, 0);
683 info_ptr
->iccp_proflen
= proflen
;
684 info_ptr
->iccp_name
= new_iccp_name
;
685 info_ptr
->iccp_profile
= new_iccp_profile
;
686 info_ptr
->free_me
|= PNG_FREE_ICCP
;
687 info_ptr
->valid
|= PNG_INFO_iCCP
;
691 #ifdef PNG_TEXT_SUPPORTED
693 png_set_text(png_const_structrp png_ptr
, png_inforp info_ptr
,
694 png_const_textp text_ptr
, int num_text
)
697 ret
= png_set_text_2(png_ptr
, info_ptr
, text_ptr
, num_text
);
700 png_error(png_ptr
, "Insufficient memory to store text");
704 png_set_text_2(png_const_structrp png_ptr
, png_inforp info_ptr
,
705 png_const_textp text_ptr
, int num_text
)
709 png_debug1(1, "in %lx storage function", png_ptr
== NULL
? "unexpected" :
710 (unsigned long)png_ptr
->chunk_name
);
712 if (png_ptr
== NULL
|| info_ptr
== NULL
|| num_text
<= 0 || text_ptr
== NULL
)
715 /* Make sure we have enough space in the "text" array in info_struct
716 * to hold all of the incoming text_ptr objects. This compare can't overflow
717 * because max_text >= num_text (anyway, subtract of two positive integers
718 * can't overflow in any case.)
720 if (num_text
> info_ptr
->max_text
- info_ptr
->num_text
)
722 int old_num_text
= info_ptr
->num_text
;
724 png_textp new_text
= NULL
;
726 /* Calculate an appropriate max_text, checking for overflow. */
727 max_text
= old_num_text
;
728 if (num_text
<= INT_MAX
- max_text
)
730 max_text
+= num_text
;
732 /* Round up to a multiple of 8 */
733 if (max_text
< INT_MAX
-8)
734 max_text
= (max_text
+ 8) & ~0x7;
739 /* Now allocate a new array and copy the old members in; this does all
740 * the overflow checks.
742 new_text
= png_voidcast(png_textp
,png_realloc_array(png_ptr
,
743 info_ptr
->text
, old_num_text
, max_text
-old_num_text
,
747 if (new_text
== NULL
)
749 png_chunk_report(png_ptr
, "too many text chunks",
750 PNG_CHUNK_WRITE_ERROR
);
754 png_free(png_ptr
, info_ptr
->text
);
756 info_ptr
->text
= new_text
;
757 info_ptr
->free_me
|= PNG_FREE_TEXT
;
758 info_ptr
->max_text
= max_text
;
759 /* num_text is adjusted below as the entries are copied in */
761 png_debug1(3, "allocated %d entries for info_ptr->text", max_text
);
764 for (i
= 0; i
< num_text
; i
++)
766 size_t text_length
, key_len
;
767 size_t lang_len
, lang_key_len
;
768 png_textp textp
= &(info_ptr
->text
[info_ptr
->num_text
]);
770 if (text_ptr
[i
].key
== NULL
)
773 if (text_ptr
[i
].compression
< PNG_TEXT_COMPRESSION_NONE
||
774 text_ptr
[i
].compression
>= PNG_TEXT_COMPRESSION_LAST
)
776 png_chunk_report(png_ptr
, "text compression mode is out of range",
777 PNG_CHUNK_WRITE_ERROR
);
781 key_len
= strlen(text_ptr
[i
].key
);
783 if (text_ptr
[i
].compression
<= 0)
790 # ifdef PNG_iTXt_SUPPORTED
794 if (text_ptr
[i
].lang
!= NULL
)
795 lang_len
= strlen(text_ptr
[i
].lang
);
800 if (text_ptr
[i
].lang_key
!= NULL
)
801 lang_key_len
= strlen(text_ptr
[i
].lang_key
);
806 # else /* PNG_iTXt_SUPPORTED */
808 png_chunk_report(png_ptr
, "iTXt chunk not supported",
809 PNG_CHUNK_WRITE_ERROR
);
814 if (text_ptr
[i
].text
== NULL
|| text_ptr
[i
].text
[0] == '\0')
817 # ifdef PNG_iTXt_SUPPORTED
818 if (text_ptr
[i
].compression
> 0)
819 textp
->compression
= PNG_ITXT_COMPRESSION_NONE
;
823 textp
->compression
= PNG_TEXT_COMPRESSION_NONE
;
828 text_length
= strlen(text_ptr
[i
].text
);
829 textp
->compression
= text_ptr
[i
].compression
;
832 textp
->key
= png_voidcast(png_charp
,png_malloc_base(png_ptr
,
833 key_len
+ text_length
+ lang_len
+ lang_key_len
+ 4));
835 if (textp
->key
== NULL
)
837 png_chunk_report(png_ptr
, "text chunk: out of memory",
838 PNG_CHUNK_WRITE_ERROR
);
842 png_debug2(2, "Allocated %lu bytes at %p in png_set_text",
843 (unsigned long)(png_uint_32
)
844 (key_len
+ lang_len
+ lang_key_len
+ text_length
+ 4),
847 memcpy(textp
->key
, text_ptr
[i
].key
, key_len
);
848 *(textp
->key
+ key_len
) = '\0';
850 if (text_ptr
[i
].compression
> 0)
852 textp
->lang
= textp
->key
+ key_len
+ 1;
853 memcpy(textp
->lang
, text_ptr
[i
].lang
, lang_len
);
854 *(textp
->lang
+ lang_len
) = '\0';
855 textp
->lang_key
= textp
->lang
+ lang_len
+ 1;
856 memcpy(textp
->lang_key
, text_ptr
[i
].lang_key
, lang_key_len
);
857 *(textp
->lang_key
+ lang_key_len
) = '\0';
858 textp
->text
= textp
->lang_key
+ lang_key_len
+ 1;
864 textp
->lang_key
=NULL
;
865 textp
->text
= textp
->key
+ key_len
+ 1;
868 if (text_length
!= 0)
869 memcpy(textp
->text
, text_ptr
[i
].text
, text_length
);
871 *(textp
->text
+ text_length
) = '\0';
873 # ifdef PNG_iTXt_SUPPORTED
874 if (textp
->compression
> 0)
876 textp
->text_length
= 0;
877 textp
->itxt_length
= text_length
;
883 textp
->text_length
= text_length
;
884 textp
->itxt_length
= 0;
887 info_ptr
->num_text
++;
888 png_debug1(3, "transferred text chunk %d", info_ptr
->num_text
);
895 #ifdef PNG_tIME_SUPPORTED
897 png_set_tIME(png_const_structrp png_ptr
, png_inforp info_ptr
,
898 png_const_timep mod_time
)
900 png_debug1(1, "in %s storage function", "tIME");
902 if (png_ptr
== NULL
|| info_ptr
== NULL
|| mod_time
== NULL
||
903 (png_ptr
->mode
& PNG_WROTE_tIME
) != 0)
906 if (mod_time
->month
== 0 || mod_time
->month
> 12 ||
907 mod_time
->day
== 0 || mod_time
->day
> 31 ||
908 mod_time
->hour
> 23 || mod_time
->minute
> 59 ||
909 mod_time
->second
> 60)
911 png_warning(png_ptr
, "Ignoring invalid time value");
915 info_ptr
->mod_time
= *mod_time
;
916 info_ptr
->valid
|= PNG_INFO_tIME
;
920 #ifdef PNG_tRNS_SUPPORTED
922 png_set_tRNS(png_structrp png_ptr
, png_inforp info_ptr
,
923 png_const_bytep trans_alpha
, int num_trans
, png_const_color_16p trans_color
)
925 png_debug1(1, "in %s storage function", "tRNS");
927 if (png_ptr
== NULL
|| info_ptr
== NULL
)
930 if (trans_alpha
!= NULL
)
932 /* It may not actually be necessary to set png_ptr->trans_alpha here;
933 * we do it for backward compatibility with the way the png_handle_tRNS
934 * function used to do the allocation.
936 * 1.6.0: The above statement is incorrect; png_handle_tRNS effectively
937 * relies on png_set_tRNS storing the information in png_struct
938 * (otherwise it won't be there for the code in pngrtran.c).
941 png_free_data(png_ptr
, info_ptr
, PNG_FREE_TRNS
, 0);
943 /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
944 png_ptr
->trans_alpha
= info_ptr
->trans_alpha
= png_voidcast(png_bytep
,
945 png_malloc(png_ptr
, PNG_MAX_PALETTE_LENGTH
));
947 if (num_trans
> 0 && num_trans
<= PNG_MAX_PALETTE_LENGTH
)
948 memcpy(info_ptr
->trans_alpha
, trans_alpha
, (png_size_t
)num_trans
);
951 if (trans_color
!= NULL
)
953 int sample_max
= (1 << info_ptr
->bit_depth
);
955 if ((info_ptr
->color_type
== PNG_COLOR_TYPE_GRAY
&&
956 trans_color
->gray
> sample_max
) ||
957 (info_ptr
->color_type
== PNG_COLOR_TYPE_RGB
&&
958 (trans_color
->red
> sample_max
||
959 trans_color
->green
> sample_max
||
960 trans_color
->blue
> sample_max
)))
962 "tRNS chunk has out-of-range samples for bit_depth");
964 info_ptr
->trans_color
= *trans_color
;
970 info_ptr
->num_trans
= (png_uint_16
)num_trans
;
974 info_ptr
->valid
|= PNG_INFO_tRNS
;
975 info_ptr
->free_me
|= PNG_FREE_TRNS
;
980 #ifdef PNG_sPLT_SUPPORTED
982 png_set_sPLT(png_const_structrp png_ptr
,
983 png_inforp info_ptr
, png_const_sPLT_tp entries
, int nentries
)
985 * entries - array of png_sPLT_t structures
986 * to be added to the list of palettes
987 * in the info structure.
989 * nentries - number of palette structures to be
995 if (png_ptr
== NULL
|| info_ptr
== NULL
|| nentries
<= 0 || entries
== NULL
)
998 /* Use the internal realloc function, which checks for all the possible
999 * overflows. Notice that the parameters are (int) and (size_t)
1001 np
= png_voidcast(png_sPLT_tp
,png_realloc_array(png_ptr
,
1002 info_ptr
->splt_palettes
, info_ptr
->splt_palettes_num
, nentries
,
1007 /* Out of memory or too many chunks */
1008 png_chunk_report(png_ptr
, "too many sPLT chunks", PNG_CHUNK_WRITE_ERROR
);
1012 png_free(png_ptr
, info_ptr
->splt_palettes
);
1013 info_ptr
->splt_palettes
= np
;
1014 info_ptr
->free_me
|= PNG_FREE_SPLT
;
1016 np
+= info_ptr
->splt_palettes_num
;
1022 /* Skip invalid input entries */
1023 if (entries
->name
== NULL
|| entries
->entries
== NULL
)
1025 /* png_handle_sPLT doesn't do this, so this is an app error */
1026 png_app_error(png_ptr
, "png_set_sPLT: invalid sPLT");
1027 /* Just skip the invalid entry */
1031 np
->depth
= entries
->depth
;
1033 /* In the event of out-of-memory just return - there's no point keeping
1034 * on trying to add sPLT chunks.
1036 length
= strlen(entries
->name
) + 1;
1037 np
->name
= png_voidcast(png_charp
, png_malloc_base(png_ptr
, length
));
1039 if (np
->name
== NULL
)
1042 memcpy(np
->name
, entries
->name
, length
);
1044 /* IMPORTANT: we have memory now that won't get freed if something else
1045 * goes wrong; this code must free it. png_malloc_array produces no
1046 * warnings; use a png_chunk_report (below) if there is an error.
1048 np
->entries
= png_voidcast(png_sPLT_entryp
, png_malloc_array(png_ptr
,
1049 entries
->nentries
, sizeof (png_sPLT_entry
)));
1051 if (np
->entries
== NULL
)
1053 png_free(png_ptr
, np
->name
);
1058 np
->nentries
= entries
->nentries
;
1059 /* This multiply can't overflow because png_malloc_array has already
1060 * checked it when doing the allocation.
1062 memcpy(np
->entries
, entries
->entries
,
1063 entries
->nentries
* sizeof (png_sPLT_entry
));
1065 /* Note that 'continue' skips the advance of the out pointer and out
1066 * count, so an invalid entry is not added.
1068 info_ptr
->valid
|= PNG_INFO_sPLT
;
1069 ++(info_ptr
->splt_palettes_num
);
1072 while (++entries
, --nentries
);
1075 png_chunk_report(png_ptr
, "sPLT out of memory", PNG_CHUNK_WRITE_ERROR
);
1079 #ifdef PNG_APNG_SUPPORTED
1081 png_set_acTL(png_structp png_ptr
, png_infop info_ptr
,
1082 png_uint_32 num_frames
, png_uint_32 num_plays
)
1084 png_debug1(1, "in %s storage function", "acTL");
1086 if (png_ptr
== NULL
|| info_ptr
== NULL
)
1088 png_warning(png_ptr
,
1089 "Call to png_set_acTL() with NULL png_ptr "
1090 "or info_ptr ignored");
1093 if (num_frames
== 0)
1095 png_warning(png_ptr
,
1096 "Ignoring attempt to set acTL with num_frames zero");
1099 if (num_frames
> PNG_UINT_31_MAX
)
1101 png_warning(png_ptr
,
1102 "Ignoring attempt to set acTL with num_frames > 2^31-1");
1105 if (num_plays
> PNG_UINT_31_MAX
)
1107 png_warning(png_ptr
,
1108 "Ignoring attempt to set acTL with num_plays "
1113 info_ptr
->num_frames
= num_frames
;
1114 info_ptr
->num_plays
= num_plays
;
1116 info_ptr
->valid
|= PNG_INFO_acTL
;
1121 /* delay_num and delay_den can hold any 16-bit values including zero */
1123 png_set_next_frame_fcTL(png_structp png_ptr
, png_infop info_ptr
,
1124 png_uint_32 width
, png_uint_32 height
,
1125 png_uint_32 x_offset
, png_uint_32 y_offset
,
1126 png_uint_16 delay_num
, png_uint_16 delay_den
,
1127 png_byte dispose_op
, png_byte blend_op
)
1129 png_debug1(1, "in %s storage function", "fcTL");
1131 if (png_ptr
== NULL
|| info_ptr
== NULL
)
1133 png_warning(png_ptr
,
1134 "Call to png_set_fcTL() with NULL png_ptr or info_ptr "
1139 png_ensure_fcTL_is_valid(png_ptr
, width
, height
, x_offset
, y_offset
,
1140 delay_num
, delay_den
, dispose_op
, blend_op
);
1142 if (blend_op
== PNG_BLEND_OP_OVER
)
1144 if ((png_ptr
->color_type
& PNG_COLOR_MASK_ALPHA
) == 0 &&
1145 png_get_valid(png_ptr
, info_ptr
, PNG_INFO_tRNS
) == 0)
1147 png_warning(png_ptr
, "PNG_BLEND_OP_OVER is meaningless "
1148 "and wasteful for opaque images, ignored");
1149 blend_op
= PNG_BLEND_OP_SOURCE
;
1153 info_ptr
->next_frame_width
= width
;
1154 info_ptr
->next_frame_height
= height
;
1155 info_ptr
->next_frame_x_offset
= x_offset
;
1156 info_ptr
->next_frame_y_offset
= y_offset
;
1157 info_ptr
->next_frame_delay_num
= delay_num
;
1158 info_ptr
->next_frame_delay_den
= delay_den
;
1159 info_ptr
->next_frame_dispose_op
= dispose_op
;
1160 info_ptr
->next_frame_blend_op
= blend_op
;
1162 info_ptr
->valid
|= PNG_INFO_fcTL
;
1168 png_ensure_fcTL_is_valid(png_structp png_ptr
,
1169 png_uint_32 width
, png_uint_32 height
,
1170 png_uint_32 x_offset
, png_uint_32 y_offset
,
1171 png_uint_16 delay_num
, png_uint_16 delay_den
,
1172 png_byte dispose_op
, png_byte blend_op
)
1174 if (width
> PNG_UINT_31_MAX
)
1175 png_error(png_ptr
, "invalid width in fcTL (> 2^31-1)");
1176 if (height
> PNG_UINT_31_MAX
)
1177 png_error(png_ptr
, "invalid height in fcTL (> 2^31-1)");
1178 if (x_offset
> PNG_UINT_31_MAX
)
1179 png_error(png_ptr
, "invalid x_offset in fcTL (> 2^31-1)");
1180 if (y_offset
> PNG_UINT_31_MAX
)
1181 png_error(png_ptr
, "invalid y_offset in fcTL (> 2^31-1)");
1182 if (width
+ x_offset
> png_ptr
->first_frame_width
||
1183 height
+ y_offset
> png_ptr
->first_frame_height
)
1184 png_error(png_ptr
, "dimensions of a frame are greater than"
1185 "the ones in IHDR");
1187 if (dispose_op
!= PNG_DISPOSE_OP_NONE
&&
1188 dispose_op
!= PNG_DISPOSE_OP_BACKGROUND
&&
1189 dispose_op
!= PNG_DISPOSE_OP_PREVIOUS
)
1190 png_error(png_ptr
, "invalid dispose_op in fcTL");
1192 if (blend_op
!= PNG_BLEND_OP_SOURCE
&&
1193 blend_op
!= PNG_BLEND_OP_OVER
)
1194 png_error(png_ptr
, "invalid blend_op in fcTL");
1196 PNG_UNUSED(delay_num
)
1197 PNG_UNUSED(delay_den
)
1201 png_set_first_frame_is_hidden(png_structp png_ptr
, png_infop info_ptr
,
1204 png_debug(1, "in png_first_frame_is_hidden()");
1206 if (png_ptr
== NULL
)
1210 png_ptr
->apng_flags
|= PNG_FIRST_FRAME_HIDDEN
;
1212 png_ptr
->apng_flags
&= ~PNG_FIRST_FRAME_HIDDEN
;
1214 PNG_UNUSED(info_ptr
)
1220 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
1222 check_location(png_const_structrp png_ptr
, int location
)
1224 location
&= (PNG_HAVE_IHDR
|PNG_HAVE_PLTE
|PNG_AFTER_IDAT
);
1226 /* New in 1.6.0; copy the location and check it. This is an API
1227 * change; previously the app had to use the
1228 * png_set_unknown_chunk_location API below for each chunk.
1230 if (location
== 0 && (png_ptr
->mode
& PNG_IS_READ_STRUCT
) == 0)
1232 /* Write struct, so unknown chunks come from the app */
1233 png_app_warning(png_ptr
,
1234 "png_set_unknown_chunks now expects a valid location");
1235 /* Use the old behavior */
1236 location
= (png_byte
)(png_ptr
->mode
&
1237 (PNG_HAVE_IHDR
|PNG_HAVE_PLTE
|PNG_AFTER_IDAT
));
1240 /* This need not be an internal error - if the app calls
1241 * png_set_unknown_chunks on a read pointer it must get the location right.
1244 png_error(png_ptr
, "invalid location in png_set_unknown_chunks");
1246 /* Now reduce the location to the top-most set bit by removing each least
1247 * significant bit in turn.
1249 while (location
!= (location
& -location
))
1250 location
&= ~(location
& -location
);
1252 /* The cast is safe because 'location' is a bit mask and only the low four
1253 * bits are significant.
1255 return (png_byte
)location
;
1259 png_set_unknown_chunks(png_const_structrp png_ptr
,
1260 png_inforp info_ptr
, png_const_unknown_chunkp unknowns
, int num_unknowns
)
1262 png_unknown_chunkp np
;
1264 if (png_ptr
== NULL
|| info_ptr
== NULL
|| num_unknowns
<= 0 ||
1268 /* Check for the failure cases where support has been disabled at compile
1269 * time. This code is hardly ever compiled - it's here because
1270 * STORE_UNKNOWN_CHUNKS is set by both read and write code (compiling in this
1271 * code) but may be meaningless if the read or write handling of unknown
1272 * chunks is not compiled in.
1274 # if !defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) && \
1275 defined(PNG_READ_SUPPORTED)
1276 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) != 0)
1278 png_app_error(png_ptr
, "no unknown chunk support on read");
1282 # if !defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) && \
1283 defined(PNG_WRITE_SUPPORTED)
1284 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) == 0)
1286 png_app_error(png_ptr
, "no unknown chunk support on write");
1291 /* Prior to 1.6.0 this code used png_malloc_warn; however, this meant that
1292 * unknown critical chunks could be lost with just a warning resulting in
1293 * undefined behavior. Now png_chunk_report is used to provide behavior
1294 * appropriate to read or write.
1296 np
= png_voidcast(png_unknown_chunkp
, png_realloc_array(png_ptr
,
1297 info_ptr
->unknown_chunks
, info_ptr
->unknown_chunks_num
, num_unknowns
,
1302 png_chunk_report(png_ptr
, "too many unknown chunks",
1303 PNG_CHUNK_WRITE_ERROR
);
1307 png_free(png_ptr
, info_ptr
->unknown_chunks
);
1308 info_ptr
->unknown_chunks
= np
; /* safe because it is initialized */
1309 info_ptr
->free_me
|= PNG_FREE_UNKN
;
1311 np
+= info_ptr
->unknown_chunks_num
;
1313 /* Increment unknown_chunks_num each time round the loop to protect the
1314 * just-allocated chunk data.
1316 for (; num_unknowns
> 0; --num_unknowns
, ++unknowns
)
1318 memcpy(np
->name
, unknowns
->name
, (sizeof np
->name
));
1319 np
->name
[(sizeof np
->name
)-1] = '\0';
1320 np
->location
= check_location(png_ptr
, unknowns
->location
);
1322 if (unknowns
->size
== 0)
1330 np
->data
= png_voidcast(png_bytep
,
1331 png_malloc_base(png_ptr
, unknowns
->size
));
1333 if (np
->data
== NULL
)
1335 png_chunk_report(png_ptr
, "unknown chunk: out of memory",
1336 PNG_CHUNK_WRITE_ERROR
);
1337 /* But just skip storing the unknown chunk */
1341 memcpy(np
->data
, unknowns
->data
, unknowns
->size
);
1342 np
->size
= unknowns
->size
;
1345 /* These increments are skipped on out-of-memory for the data - the
1346 * unknown chunk entry gets overwritten if the png_chunk_report returns.
1347 * This is correct in the read case (the chunk is just dropped.)
1350 ++(info_ptr
->unknown_chunks_num
);
1355 png_set_unknown_chunk_location(png_const_structrp png_ptr
, png_inforp info_ptr
,
1356 int chunk
, int location
)
1358 /* This API is pretty pointless in 1.6.0 because the location can be set
1359 * before the call to png_set_unknown_chunks.
1361 * TODO: add a png_app_warning in 1.7
1363 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&& chunk
>= 0 &&
1364 chunk
< info_ptr
->unknown_chunks_num
)
1366 if ((location
& (PNG_HAVE_IHDR
|PNG_HAVE_PLTE
|PNG_AFTER_IDAT
)) == 0)
1368 png_app_error(png_ptr
, "invalid unknown chunk location");
1369 /* Fake out the pre 1.6.0 behavior: */
1370 if ((location
& PNG_HAVE_IDAT
) != 0) /* undocumented! */
1371 location
= PNG_AFTER_IDAT
;
1374 location
= PNG_HAVE_IHDR
; /* also undocumented */
1377 info_ptr
->unknown_chunks
[chunk
].location
=
1378 check_location(png_ptr
, location
);
1384 #ifdef PNG_MNG_FEATURES_SUPPORTED
1386 png_permit_mng_features (png_structrp png_ptr
, png_uint_32 mng_features
)
1388 png_debug(1, "in png_permit_mng_features");
1390 if (png_ptr
== NULL
)
1393 png_ptr
->mng_features_permitted
= mng_features
& PNG_ALL_MNG_FEATURES
;
1395 return png_ptr
->mng_features_permitted
;
1399 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
1401 add_one_chunk(png_bytep list
, unsigned int count
, png_const_bytep add
, int keep
)
1405 /* Utility function: update the 'keep' state of a chunk if it is already in
1406 * the list, otherwise add it to the list.
1408 for (i
=0; i
<count
; ++i
, list
+= 5)
1410 if (memcmp(list
, add
, 4) == 0)
1412 list
[4] = (png_byte
)keep
;
1417 if (keep
!= PNG_HANDLE_CHUNK_AS_DEFAULT
)
1420 memcpy(list
, add
, 4);
1421 list
[4] = (png_byte
)keep
;
1428 png_set_keep_unknown_chunks(png_structrp png_ptr
, int keep
,
1429 png_const_bytep chunk_list
, int num_chunks_in
)
1432 unsigned int num_chunks
, old_num_chunks
;
1434 if (png_ptr
== NULL
)
1437 if (keep
< 0 || keep
>= PNG_HANDLE_CHUNK_LAST
)
1439 png_app_error(png_ptr
, "png_set_keep_unknown_chunks: invalid keep");
1443 if (num_chunks_in
<= 0)
1445 png_ptr
->unknown_default
= keep
;
1447 /* '0' means just set the flags, so stop here */
1448 if (num_chunks_in
== 0)
1452 if (num_chunks_in
< 0)
1454 /* Ignore all unknown chunks and all chunks recognized by
1455 * libpng except for IHDR, PLTE, tRNS, IDAT, and IEND
1457 static PNG_CONST png_byte chunks_to_ignore
[] = {
1458 98, 75, 71, 68, '\0', /* bKGD */
1459 99, 72, 82, 77, '\0', /* cHRM */
1460 103, 65, 77, 65, '\0', /* gAMA */
1461 104, 73, 83, 84, '\0', /* hIST */
1462 105, 67, 67, 80, '\0', /* iCCP */
1463 105, 84, 88, 116, '\0', /* iTXt */
1464 111, 70, 70, 115, '\0', /* oFFs */
1465 112, 67, 65, 76, '\0', /* pCAL */
1466 112, 72, 89, 115, '\0', /* pHYs */
1467 115, 66, 73, 84, '\0', /* sBIT */
1468 115, 67, 65, 76, '\0', /* sCAL */
1469 115, 80, 76, 84, '\0', /* sPLT */
1470 115, 84, 69, 82, '\0', /* sTER */
1471 115, 82, 71, 66, '\0', /* sRGB */
1472 116, 69, 88, 116, '\0', /* tEXt */
1473 116, 73, 77, 69, '\0', /* tIME */
1474 122, 84, 88, 116, '\0' /* zTXt */
1477 chunk_list
= chunks_to_ignore
;
1478 num_chunks
= (unsigned int)/*SAFE*/(sizeof chunks_to_ignore
)/5U;
1481 else /* num_chunks_in > 0 */
1483 if (chunk_list
== NULL
)
1485 /* Prior to 1.6.0 this was silently ignored, now it is an app_error
1486 * which can be switched off.
1488 png_app_error(png_ptr
, "png_set_keep_unknown_chunks: no chunk list");
1492 num_chunks
= num_chunks_in
;
1495 old_num_chunks
= png_ptr
->num_chunk_list
;
1496 if (png_ptr
->chunk_list
== NULL
)
1499 /* Since num_chunks is always restricted to UINT_MAX/5 this can't overflow.
1501 if (num_chunks
+ old_num_chunks
> UINT_MAX
/5)
1503 png_app_error(png_ptr
, "png_set_keep_unknown_chunks: too many chunks");
1507 /* If these chunks are being reset to the default then no more memory is
1508 * required because add_one_chunk above doesn't extend the list if the 'keep'
1509 * parameter is the default.
1513 new_list
= png_voidcast(png_bytep
, png_malloc(png_ptr
,
1514 5 * (num_chunks
+ old_num_chunks
)));
1516 if (old_num_chunks
> 0)
1517 memcpy(new_list
, png_ptr
->chunk_list
, 5*old_num_chunks
);
1520 else if (old_num_chunks
> 0)
1521 new_list
= png_ptr
->chunk_list
;
1526 /* Add the new chunks together with each one's handling code. If the chunk
1527 * already exists the code is updated, otherwise the chunk is added to the
1528 * end. (In libpng 1.6.0 order no longer matters because this code enforces
1529 * the earlier convention that the last setting is the one that is used.)
1531 if (new_list
!= NULL
)
1533 png_const_bytep inlist
;
1537 for (i
=0; i
<num_chunks
; ++i
)
1539 old_num_chunks
= add_one_chunk(new_list
, old_num_chunks
,
1540 chunk_list
+5*i
, keep
);
1543 /* Now remove any spurious 'default' entries. */
1545 for (i
=0, inlist
=outlist
=new_list
; i
<old_num_chunks
; ++i
, inlist
+= 5)
1549 if (outlist
!= inlist
)
1550 memcpy(outlist
, inlist
, 5);
1556 /* This means the application has removed all the specialized handling. */
1557 if (num_chunks
== 0)
1559 if (png_ptr
->chunk_list
!= new_list
)
1560 png_free(png_ptr
, new_list
);
1569 png_ptr
->num_chunk_list
= num_chunks
;
1571 if (png_ptr
->chunk_list
!= new_list
)
1573 if (png_ptr
->chunk_list
!= NULL
)
1574 png_free(png_ptr
, png_ptr
->chunk_list
);
1576 png_ptr
->chunk_list
= new_list
;
1581 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1583 png_set_read_user_chunk_fn(png_structrp png_ptr
, png_voidp user_chunk_ptr
,
1584 png_user_chunk_ptr read_user_chunk_fn
)
1586 png_debug(1, "in png_set_read_user_chunk_fn");
1588 if (png_ptr
== NULL
)
1591 png_ptr
->read_user_chunk_fn
= read_user_chunk_fn
;
1592 png_ptr
->user_chunk_ptr
= user_chunk_ptr
;
1596 #ifdef PNG_INFO_IMAGE_SUPPORTED
1598 png_set_rows(png_const_structrp png_ptr
, png_inforp info_ptr
,
1599 png_bytepp row_pointers
)
1601 png_debug1(1, "in %s storage function", "rows");
1603 if (png_ptr
== NULL
|| info_ptr
== NULL
)
1606 if (info_ptr
->row_pointers
!= NULL
&&
1607 (info_ptr
->row_pointers
!= row_pointers
))
1608 png_free_data(png_ptr
, info_ptr
, PNG_FREE_ROWS
, 0);
1610 info_ptr
->row_pointers
= row_pointers
;
1612 if (row_pointers
!= NULL
)
1613 info_ptr
->valid
|= PNG_INFO_IDAT
;
1618 png_set_compression_buffer_size(png_structrp png_ptr
, png_size_t size
)
1620 if (png_ptr
== NULL
)
1623 if (size
== 0 || size
> PNG_UINT_31_MAX
)
1624 png_error(png_ptr
, "invalid compression buffer size");
1626 # ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1627 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) != 0)
1629 png_ptr
->IDAT_read_size
= (png_uint_32
)size
; /* checked above */
1634 # ifdef PNG_WRITE_SUPPORTED
1635 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) == 0)
1637 if (png_ptr
->zowner
!= 0)
1639 png_warning(png_ptr
,
1640 "Compression buffer size cannot be changed because it is in use");
1644 if (size
> ZLIB_IO_MAX
)
1646 png_warning(png_ptr
,
1647 "Compression buffer size limited to system maximum");
1648 size
= ZLIB_IO_MAX
; /* must fit */
1653 /* Deflate will potentially go into an infinite loop on a SYNC_FLUSH
1654 * if this is permitted.
1656 png_warning(png_ptr
,
1657 "Compression buffer size cannot be reduced below 6");
1661 if (png_ptr
->zbuffer_size
!= size
)
1663 png_free_buffer_list(png_ptr
, &png_ptr
->zbuffer_list
);
1664 png_ptr
->zbuffer_size
= (uInt
)size
;
1671 png_set_invalid(png_const_structrp png_ptr
, png_inforp info_ptr
, int mask
)
1673 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1674 info_ptr
->valid
&= ~mask
;
1678 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
1679 /* This function was added to libpng 1.2.6 */
1681 png_set_user_limits (png_structrp png_ptr
, png_uint_32 user_width_max
,
1682 png_uint_32 user_height_max
)
1684 /* Images with dimensions larger than these limits will be
1685 * rejected by png_set_IHDR(). To accept any PNG datastream
1686 * regardless of dimensions, set both limits to 0x7ffffffL.
1688 if (png_ptr
== NULL
)
1691 png_ptr
->user_width_max
= user_width_max
;
1692 png_ptr
->user_height_max
= user_height_max
;
1695 /* This function was added to libpng 1.4.0 */
1697 png_set_chunk_cache_max (png_structrp png_ptr
, png_uint_32 user_chunk_cache_max
)
1699 if (png_ptr
!= NULL
)
1700 png_ptr
->user_chunk_cache_max
= user_chunk_cache_max
;
1703 /* This function was added to libpng 1.4.1 */
1705 png_set_chunk_malloc_max (png_structrp png_ptr
,
1706 png_alloc_size_t user_chunk_malloc_max
)
1708 if (png_ptr
!= NULL
)
1709 png_ptr
->user_chunk_malloc_max
= user_chunk_malloc_max
;
1711 #endif /* ?SET_USER_LIMITS */
1714 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
1716 png_set_benign_errors(png_structrp png_ptr
, int allowed
)
1718 png_debug(1, "in png_set_benign_errors");
1720 /* If allowed is 1, png_benign_error() is treated as a warning.
1722 * If allowed is 0, png_benign_error() is treated as an error (which
1723 * is the default behavior if png_set_benign_errors() is not called).
1727 png_ptr
->flags
|= PNG_FLAG_BENIGN_ERRORS_WARN
|
1728 PNG_FLAG_APP_WARNINGS_WARN
| PNG_FLAG_APP_ERRORS_WARN
;
1731 png_ptr
->flags
&= ~(PNG_FLAG_BENIGN_ERRORS_WARN
|
1732 PNG_FLAG_APP_WARNINGS_WARN
| PNG_FLAG_APP_ERRORS_WARN
);
1734 #endif /* BENIGN_ERRORS */
1736 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
1737 /* Whether to report invalid palette index; added at libng-1.5.10.
1738 * It is possible for an indexed (color-type==3) PNG file to contain
1739 * pixels with invalid (out-of-range) indexes if the PLTE chunk has
1740 * fewer entries than the image's bit-depth would allow. We recover
1741 * from this gracefully by filling any incomplete palette with zeros
1742 * (opaque black). By default, when this occurs libpng will issue
1743 * a benign error. This API can be used to override that behavior.
1746 png_set_check_for_invalid_index(png_structrp png_ptr
, int allowed
)
1748 png_debug(1, "in png_set_check_for_invalid_index");
1751 png_ptr
->num_palette_max
= 0;
1754 png_ptr
->num_palette_max
= -1;
1757 #endif /* READ || WRITE */