2 /* pngset.c - storage of image information into info struct
4 * Copyright (c) 2018-2024 Cosmin Truta
5 * Copyright (c) 1998-2018 Glenn Randers-Pehrson
6 * Copyright (c) 1996-1997 Andreas Dilger
7 * 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 Green X"),
127 png_fixed(png_ptr
, green_Y
, "cHRM Green Y"),
128 png_fixed(png_ptr
, green_Z
, "cHRM Green Z"),
129 png_fixed(png_ptr
, blue_X
, "cHRM Blue X"),
130 png_fixed(png_ptr
, blue_Y
, "cHRM Blue Y"),
131 png_fixed(png_ptr
, blue_Z
, "cHRM Blue Z"));
133 # endif /* FLOATING_POINT */
137 #ifdef PNG_eXIf_SUPPORTED
139 png_set_eXIf(png_const_structrp png_ptr
, png_inforp info_ptr
,
142 png_warning(png_ptr
, "png_set_eXIf does not work; use png_set_eXIf_1");
148 png_set_eXIf_1(png_const_structrp png_ptr
, png_inforp info_ptr
,
149 png_uint_32 num_exif
, png_bytep exif
)
153 png_debug1(1, "in %s storage function", "eXIf");
155 if (png_ptr
== NULL
|| info_ptr
== NULL
||
156 (png_ptr
->mode
& PNG_WROTE_eXIf
) != 0)
159 new_exif
= png_voidcast(png_bytep
, png_malloc_warn(png_ptr
, num_exif
));
161 if (new_exif
== NULL
)
163 png_warning(png_ptr
, "Insufficient memory for eXIf chunk data");
167 memcpy(new_exif
, exif
, (size_t)num_exif
);
169 png_free_data(png_ptr
, info_ptr
, PNG_FREE_EXIF
, 0);
171 info_ptr
->num_exif
= num_exif
;
172 info_ptr
->exif
= new_exif
;
173 info_ptr
->free_me
|= PNG_FREE_EXIF
;
174 info_ptr
->valid
|= PNG_INFO_eXIf
;
178 #ifdef PNG_gAMA_SUPPORTED
180 png_set_gAMA_fixed(png_const_structrp png_ptr
, png_inforp info_ptr
,
181 png_fixed_point file_gamma
)
183 png_debug1(1, "in %s storage function", "gAMA");
185 if (png_ptr
== NULL
|| info_ptr
== NULL
)
188 png_colorspace_set_gamma(png_ptr
, &info_ptr
->colorspace
, file_gamma
);
189 png_colorspace_sync_info(png_ptr
, info_ptr
);
192 # ifdef PNG_FLOATING_POINT_SUPPORTED
194 png_set_gAMA(png_const_structrp png_ptr
, png_inforp info_ptr
, double file_gamma
)
196 png_set_gAMA_fixed(png_ptr
, info_ptr
, png_fixed(png_ptr
, file_gamma
,
202 #ifdef PNG_hIST_SUPPORTED
204 png_set_hIST(png_const_structrp png_ptr
, png_inforp info_ptr
,
205 png_const_uint_16p hist
)
209 png_debug1(1, "in %s storage function", "hIST");
211 if (png_ptr
== NULL
|| info_ptr
== NULL
)
214 if (info_ptr
->num_palette
== 0 || info_ptr
->num_palette
215 > PNG_MAX_PALETTE_LENGTH
)
218 "Invalid palette size, hIST allocation skipped");
223 png_free_data(png_ptr
, info_ptr
, PNG_FREE_HIST
, 0);
225 /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
228 info_ptr
->hist
= png_voidcast(png_uint_16p
, png_malloc_warn(png_ptr
,
229 PNG_MAX_PALETTE_LENGTH
* (sizeof (png_uint_16
))));
231 if (info_ptr
->hist
== NULL
)
233 png_warning(png_ptr
, "Insufficient memory for hIST chunk data");
237 for (i
= 0; i
< info_ptr
->num_palette
; i
++)
238 info_ptr
->hist
[i
] = hist
[i
];
240 info_ptr
->free_me
|= PNG_FREE_HIST
;
241 info_ptr
->valid
|= PNG_INFO_hIST
;
246 png_set_IHDR(png_const_structrp png_ptr
, png_inforp info_ptr
,
247 png_uint_32 width
, png_uint_32 height
, int bit_depth
,
248 int color_type
, int interlace_type
, int compression_type
,
251 png_debug1(1, "in %s storage function", "IHDR");
253 if (png_ptr
== NULL
|| info_ptr
== NULL
)
256 info_ptr
->width
= width
;
257 info_ptr
->height
= height
;
258 info_ptr
->bit_depth
= (png_byte
)bit_depth
;
259 info_ptr
->color_type
= (png_byte
)color_type
;
260 info_ptr
->compression_type
= (png_byte
)compression_type
;
261 info_ptr
->filter_type
= (png_byte
)filter_type
;
262 info_ptr
->interlace_type
= (png_byte
)interlace_type
;
264 png_check_IHDR (png_ptr
, info_ptr
->width
, info_ptr
->height
,
265 info_ptr
->bit_depth
, info_ptr
->color_type
, info_ptr
->interlace_type
,
266 info_ptr
->compression_type
, info_ptr
->filter_type
);
268 if (info_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
269 info_ptr
->channels
= 1;
271 else if ((info_ptr
->color_type
& PNG_COLOR_MASK_COLOR
) != 0)
272 info_ptr
->channels
= 3;
275 info_ptr
->channels
= 1;
277 if ((info_ptr
->color_type
& PNG_COLOR_MASK_ALPHA
) != 0)
278 info_ptr
->channels
++;
280 info_ptr
->pixel_depth
= (png_byte
)(info_ptr
->channels
* info_ptr
->bit_depth
);
282 info_ptr
->rowbytes
= PNG_ROWBYTES(info_ptr
->pixel_depth
, width
);
284 #ifdef PNG_APNG_SUPPORTED
285 /* for non-animated png. this may be overwritten from an acTL chunk later */
286 info_ptr
->num_frames
= 1;
290 #ifdef PNG_oFFs_SUPPORTED
292 png_set_oFFs(png_const_structrp png_ptr
, png_inforp info_ptr
,
293 png_int_32 offset_x
, png_int_32 offset_y
, int unit_type
)
295 png_debug1(1, "in %s storage function", "oFFs");
297 if (png_ptr
== NULL
|| info_ptr
== NULL
)
300 info_ptr
->x_offset
= offset_x
;
301 info_ptr
->y_offset
= offset_y
;
302 info_ptr
->offset_unit_type
= (png_byte
)unit_type
;
303 info_ptr
->valid
|= PNG_INFO_oFFs
;
307 #ifdef PNG_pCAL_SUPPORTED
309 png_set_pCAL(png_const_structrp png_ptr
, png_inforp info_ptr
,
310 png_const_charp purpose
, png_int_32 X0
, png_int_32 X1
, int type
,
311 int nparams
, png_const_charp units
, png_charpp params
)
316 png_debug1(1, "in %s storage function", "pCAL");
318 if (png_ptr
== NULL
|| info_ptr
== NULL
|| purpose
== NULL
|| units
== NULL
319 || (nparams
> 0 && params
== NULL
))
322 length
= strlen(purpose
) + 1;
323 png_debug1(3, "allocating purpose for info (%lu bytes)",
324 (unsigned long)length
);
326 /* TODO: validate format of calibration name and unit name */
328 /* Check that the type matches the specification. */
329 if (type
< 0 || type
> 3)
331 png_chunk_report(png_ptr
, "Invalid pCAL equation type",
332 PNG_CHUNK_WRITE_ERROR
);
336 if (nparams
< 0 || nparams
> 255)
338 png_chunk_report(png_ptr
, "Invalid pCAL parameter count",
339 PNG_CHUNK_WRITE_ERROR
);
343 /* Validate params[nparams] */
344 for (i
=0; i
<nparams
; ++i
)
346 if (params
[i
] == NULL
||
347 !png_check_fp_string(params
[i
], strlen(params
[i
])))
349 png_chunk_report(png_ptr
, "Invalid format for pCAL parameter",
350 PNG_CHUNK_WRITE_ERROR
);
355 info_ptr
->pcal_purpose
= png_voidcast(png_charp
,
356 png_malloc_warn(png_ptr
, length
));
358 if (info_ptr
->pcal_purpose
== NULL
)
360 png_chunk_report(png_ptr
, "Insufficient memory for pCAL purpose",
361 PNG_CHUNK_WRITE_ERROR
);
365 memcpy(info_ptr
->pcal_purpose
, purpose
, length
);
367 info_ptr
->free_me
|= PNG_FREE_PCAL
;
369 png_debug(3, "storing X0, X1, type, and nparams in info");
370 info_ptr
->pcal_X0
= X0
;
371 info_ptr
->pcal_X1
= X1
;
372 info_ptr
->pcal_type
= (png_byte
)type
;
373 info_ptr
->pcal_nparams
= (png_byte
)nparams
;
375 length
= strlen(units
) + 1;
376 png_debug1(3, "allocating units for info (%lu bytes)",
377 (unsigned long)length
);
379 info_ptr
->pcal_units
= png_voidcast(png_charp
,
380 png_malloc_warn(png_ptr
, length
));
382 if (info_ptr
->pcal_units
== NULL
)
384 png_warning(png_ptr
, "Insufficient memory for pCAL units");
388 memcpy(info_ptr
->pcal_units
, units
, length
);
390 info_ptr
->pcal_params
= png_voidcast(png_charpp
, png_malloc_warn(png_ptr
,
391 (size_t)(((unsigned int)nparams
+ 1) * (sizeof (png_charp
)))));
393 if (info_ptr
->pcal_params
== NULL
)
395 png_warning(png_ptr
, "Insufficient memory for pCAL params");
399 memset(info_ptr
->pcal_params
, 0, ((unsigned int)nparams
+ 1) *
400 (sizeof (png_charp
)));
402 for (i
= 0; i
< nparams
; i
++)
404 length
= strlen(params
[i
]) + 1;
405 png_debug2(3, "allocating parameter %d for info (%lu bytes)", i
,
406 (unsigned long)length
);
408 info_ptr
->pcal_params
[i
] = (png_charp
)png_malloc_warn(png_ptr
, length
);
410 if (info_ptr
->pcal_params
[i
] == NULL
)
412 png_warning(png_ptr
, "Insufficient memory for pCAL parameter");
416 memcpy(info_ptr
->pcal_params
[i
], params
[i
], length
);
419 info_ptr
->valid
|= PNG_INFO_pCAL
;
423 #ifdef PNG_sCAL_SUPPORTED
425 png_set_sCAL_s(png_const_structrp png_ptr
, png_inforp info_ptr
,
426 int unit
, png_const_charp swidth
, png_const_charp sheight
)
428 size_t lengthw
= 0, lengthh
= 0;
430 png_debug1(1, "in %s storage function", "sCAL");
432 if (png_ptr
== NULL
|| info_ptr
== NULL
)
435 /* Double check the unit (should never get here with an invalid
436 * unit unless this is an API call.)
438 if (unit
!= 1 && unit
!= 2)
439 png_error(png_ptr
, "Invalid sCAL unit");
441 if (swidth
== NULL
|| (lengthw
= strlen(swidth
)) == 0 ||
442 swidth
[0] == 45 /* '-' */ || !png_check_fp_string(swidth
, lengthw
))
443 png_error(png_ptr
, "Invalid sCAL width");
445 if (sheight
== NULL
|| (lengthh
= strlen(sheight
)) == 0 ||
446 sheight
[0] == 45 /* '-' */ || !png_check_fp_string(sheight
, lengthh
))
447 png_error(png_ptr
, "Invalid sCAL height");
449 info_ptr
->scal_unit
= (png_byte
)unit
;
453 png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw
);
455 info_ptr
->scal_s_width
= png_voidcast(png_charp
,
456 png_malloc_warn(png_ptr
, lengthw
));
458 if (info_ptr
->scal_s_width
== NULL
)
460 png_warning(png_ptr
, "Memory allocation failed while processing sCAL");
465 memcpy(info_ptr
->scal_s_width
, swidth
, lengthw
);
469 png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthh
);
471 info_ptr
->scal_s_height
= png_voidcast(png_charp
,
472 png_malloc_warn(png_ptr
, lengthh
));
474 if (info_ptr
->scal_s_height
== NULL
)
476 png_free(png_ptr
, info_ptr
->scal_s_width
);
477 info_ptr
->scal_s_width
= NULL
;
479 png_warning(png_ptr
, "Memory allocation failed while processing sCAL");
483 memcpy(info_ptr
->scal_s_height
, sheight
, lengthh
);
485 info_ptr
->free_me
|= PNG_FREE_SCAL
;
486 info_ptr
->valid
|= PNG_INFO_sCAL
;
489 # ifdef PNG_FLOATING_POINT_SUPPORTED
491 png_set_sCAL(png_const_structrp png_ptr
, png_inforp info_ptr
, int unit
,
492 double width
, double height
)
494 png_debug1(1, "in %s storage function", "sCAL");
496 /* Check the arguments. */
498 png_warning(png_ptr
, "Invalid sCAL width ignored");
500 else if (height
<= 0)
501 png_warning(png_ptr
, "Invalid sCAL height ignored");
505 /* Convert 'width' and 'height' to ASCII. */
506 char swidth
[PNG_sCAL_MAX_DIGITS
+1];
507 char sheight
[PNG_sCAL_MAX_DIGITS
+1];
509 png_ascii_from_fp(png_ptr
, swidth
, (sizeof swidth
), width
,
511 png_ascii_from_fp(png_ptr
, sheight
, (sizeof sheight
), height
,
514 png_set_sCAL_s(png_ptr
, info_ptr
, unit
, swidth
, sheight
);
519 # ifdef PNG_FIXED_POINT_SUPPORTED
521 png_set_sCAL_fixed(png_const_structrp png_ptr
, png_inforp info_ptr
, int unit
,
522 png_fixed_point width
, png_fixed_point height
)
524 png_debug1(1, "in %s storage function", "sCAL");
526 /* Check the arguments. */
528 png_warning(png_ptr
, "Invalid sCAL width ignored");
530 else if (height
<= 0)
531 png_warning(png_ptr
, "Invalid sCAL height ignored");
535 /* Convert 'width' and 'height' to ASCII. */
536 char swidth
[PNG_sCAL_MAX_DIGITS
+1];
537 char sheight
[PNG_sCAL_MAX_DIGITS
+1];
539 png_ascii_from_fixed(png_ptr
, swidth
, (sizeof swidth
), width
);
540 png_ascii_from_fixed(png_ptr
, sheight
, (sizeof sheight
), height
);
542 png_set_sCAL_s(png_ptr
, info_ptr
, unit
, swidth
, sheight
);
548 #ifdef PNG_pHYs_SUPPORTED
550 png_set_pHYs(png_const_structrp png_ptr
, png_inforp info_ptr
,
551 png_uint_32 res_x
, png_uint_32 res_y
, int unit_type
)
553 png_debug1(1, "in %s storage function", "pHYs");
555 if (png_ptr
== NULL
|| info_ptr
== NULL
)
558 info_ptr
->x_pixels_per_unit
= res_x
;
559 info_ptr
->y_pixels_per_unit
= res_y
;
560 info_ptr
->phys_unit_type
= (png_byte
)unit_type
;
561 info_ptr
->valid
|= PNG_INFO_pHYs
;
566 png_set_PLTE(png_structrp png_ptr
, png_inforp info_ptr
,
567 png_const_colorp palette
, int num_palette
)
570 png_uint_32 max_palette_length
;
572 png_debug1(1, "in %s storage function", "PLTE");
574 if (png_ptr
== NULL
|| info_ptr
== NULL
)
577 max_palette_length
= (info_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
) ?
578 (1 << info_ptr
->bit_depth
) : PNG_MAX_PALETTE_LENGTH
;
580 if (num_palette
< 0 || num_palette
> (int) max_palette_length
)
582 if (info_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
583 png_error(png_ptr
, "Invalid palette length");
587 png_warning(png_ptr
, "Invalid palette length");
593 if ((num_palette
> 0 && palette
== NULL
) ||
595 # ifdef PNG_MNG_FEATURES_SUPPORTED
596 && (png_ptr
->mng_features_permitted
& PNG_FLAG_MNG_EMPTY_PLTE
) == 0
600 png_error(png_ptr
, "Invalid palette");
603 /* It may not actually be necessary to set png_ptr->palette here;
604 * we do it for backward compatibility with the way the png_handle_tRNS
605 * function used to do the allocation.
607 * 1.6.0: the above statement appears to be incorrect; something has to set
608 * the palette inside png_struct on read.
610 png_free_data(png_ptr
, info_ptr
, PNG_FREE_PLTE
, 0);
612 /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
613 * of num_palette entries, in case of an invalid PNG file or incorrect
614 * call to png_set_PLTE() with too-large sample values.
616 png_ptr
->palette
= png_voidcast(png_colorp
, png_calloc(png_ptr
,
617 PNG_MAX_PALETTE_LENGTH
* (sizeof (png_color
))));
620 memcpy(png_ptr
->palette
, palette
, (unsigned int)num_palette
*
621 (sizeof (png_color
)));
623 info_ptr
->palette
= png_ptr
->palette
;
624 info_ptr
->num_palette
= png_ptr
->num_palette
= (png_uint_16
)num_palette
;
625 info_ptr
->free_me
|= PNG_FREE_PLTE
;
626 info_ptr
->valid
|= PNG_INFO_PLTE
;
629 #ifdef PNG_sBIT_SUPPORTED
631 png_set_sBIT(png_const_structrp png_ptr
, png_inforp info_ptr
,
632 png_const_color_8p sig_bit
)
634 png_debug1(1, "in %s storage function", "sBIT");
636 if (png_ptr
== NULL
|| info_ptr
== NULL
|| sig_bit
== NULL
)
639 info_ptr
->sig_bit
= *sig_bit
;
640 info_ptr
->valid
|= PNG_INFO_sBIT
;
644 #ifdef PNG_sRGB_SUPPORTED
646 png_set_sRGB(png_const_structrp png_ptr
, png_inforp info_ptr
, int srgb_intent
)
648 png_debug1(1, "in %s storage function", "sRGB");
650 if (png_ptr
== NULL
|| info_ptr
== NULL
)
653 (void)png_colorspace_set_sRGB(png_ptr
, &info_ptr
->colorspace
, srgb_intent
);
654 png_colorspace_sync_info(png_ptr
, info_ptr
);
658 png_set_sRGB_gAMA_and_cHRM(png_const_structrp png_ptr
, png_inforp info_ptr
,
661 png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");
663 if (png_ptr
== NULL
|| info_ptr
== NULL
)
666 if (png_colorspace_set_sRGB(png_ptr
, &info_ptr
->colorspace
,
669 /* This causes the gAMA and cHRM to be written too */
670 info_ptr
->colorspace
.flags
|=
671 PNG_COLORSPACE_FROM_gAMA
|PNG_COLORSPACE_FROM_cHRM
;
674 png_colorspace_sync_info(png_ptr
, info_ptr
);
679 #ifdef PNG_iCCP_SUPPORTED
681 png_set_iCCP(png_const_structrp png_ptr
, png_inforp info_ptr
,
682 png_const_charp name
, int compression_type
,
683 png_const_bytep profile
, png_uint_32 proflen
)
685 png_charp new_iccp_name
;
686 png_bytep new_iccp_profile
;
689 png_debug1(1, "in %s storage function", "iCCP");
691 if (png_ptr
== NULL
|| info_ptr
== NULL
|| name
== NULL
|| profile
== NULL
)
694 if (compression_type
!= PNG_COMPRESSION_TYPE_BASE
)
695 png_app_error(png_ptr
, "Invalid iCCP compression method");
697 /* Set the colorspace first because this validates the profile; do not
698 * override previously set app cHRM or gAMA here (because likely as not the
699 * application knows better than libpng what the correct values are.) Pass
700 * the info_ptr color_type field to png_colorspace_set_ICC because in the
701 * write case it has not yet been stored in png_ptr.
704 int result
= png_colorspace_set_ICC(png_ptr
, &info_ptr
->colorspace
, name
,
705 proflen
, profile
, info_ptr
->color_type
);
707 png_colorspace_sync_info(png_ptr
, info_ptr
);
709 /* Don't do any of the copying if the profile was bad, or inconsistent. */
713 /* But do write the gAMA and cHRM chunks from the profile. */
714 info_ptr
->colorspace
.flags
|=
715 PNG_COLORSPACE_FROM_gAMA
|PNG_COLORSPACE_FROM_cHRM
;
718 length
= strlen(name
)+1;
719 new_iccp_name
= png_voidcast(png_charp
, png_malloc_warn(png_ptr
, length
));
721 if (new_iccp_name
== NULL
)
723 png_benign_error(png_ptr
, "Insufficient memory to process iCCP chunk");
728 memcpy(new_iccp_name
, name
, length
);
729 new_iccp_profile
= png_voidcast(png_bytep
,
730 png_malloc_warn(png_ptr
, proflen
));
732 if (new_iccp_profile
== NULL
)
734 png_free(png_ptr
, new_iccp_name
);
735 png_benign_error(png_ptr
,
736 "Insufficient memory to process iCCP profile");
741 memcpy(new_iccp_profile
, profile
, proflen
);
743 png_free_data(png_ptr
, info_ptr
, PNG_FREE_ICCP
, 0);
745 info_ptr
->iccp_proflen
= proflen
;
746 info_ptr
->iccp_name
= new_iccp_name
;
747 info_ptr
->iccp_profile
= new_iccp_profile
;
748 info_ptr
->free_me
|= PNG_FREE_ICCP
;
749 info_ptr
->valid
|= PNG_INFO_iCCP
;
753 #ifdef PNG_TEXT_SUPPORTED
755 png_set_text(png_const_structrp png_ptr
, png_inforp info_ptr
,
756 png_const_textp text_ptr
, int num_text
)
759 ret
= png_set_text_2(png_ptr
, info_ptr
, text_ptr
, num_text
);
762 png_error(png_ptr
, "Insufficient memory to store text");
766 png_set_text_2(png_const_structrp png_ptr
, png_inforp info_ptr
,
767 png_const_textp text_ptr
, int num_text
)
771 png_debug1(1, "in text storage function, chunk typeid = 0x%lx",
772 png_ptr
== NULL
? 0xabadca11UL
: (unsigned long)png_ptr
->chunk_name
);
774 if (png_ptr
== NULL
|| info_ptr
== NULL
|| num_text
<= 0 || text_ptr
== NULL
)
777 /* Make sure we have enough space in the "text" array in info_struct
778 * to hold all of the incoming text_ptr objects. This compare can't overflow
779 * because max_text >= num_text (anyway, subtract of two positive integers
780 * can't overflow in any case.)
782 if (num_text
> info_ptr
->max_text
- info_ptr
->num_text
)
784 int old_num_text
= info_ptr
->num_text
;
786 png_textp new_text
= NULL
;
788 /* Calculate an appropriate max_text, checking for overflow. */
789 max_text
= old_num_text
;
790 if (num_text
<= INT_MAX
- max_text
)
792 max_text
+= num_text
;
794 /* Round up to a multiple of 8 */
795 if (max_text
< INT_MAX
-8)
796 max_text
= (max_text
+ 8) & ~0x7;
801 /* Now allocate a new array and copy the old members in; this does all
802 * the overflow checks.
804 new_text
= png_voidcast(png_textp
,png_realloc_array(png_ptr
,
805 info_ptr
->text
, old_num_text
, max_text
-old_num_text
,
809 if (new_text
== NULL
)
811 png_chunk_report(png_ptr
, "too many text chunks",
812 PNG_CHUNK_WRITE_ERROR
);
817 png_free(png_ptr
, info_ptr
->text
);
819 info_ptr
->text
= new_text
;
820 info_ptr
->free_me
|= PNG_FREE_TEXT
;
821 info_ptr
->max_text
= max_text
;
822 /* num_text is adjusted below as the entries are copied in */
824 png_debug1(3, "allocated %d entries for info_ptr->text", max_text
);
827 for (i
= 0; i
< num_text
; i
++)
829 size_t text_length
, key_len
;
830 size_t lang_len
, lang_key_len
;
831 png_textp textp
= &(info_ptr
->text
[info_ptr
->num_text
]);
833 if (text_ptr
[i
].key
== NULL
)
836 if (text_ptr
[i
].compression
< PNG_TEXT_COMPRESSION_NONE
||
837 text_ptr
[i
].compression
>= PNG_TEXT_COMPRESSION_LAST
)
839 png_chunk_report(png_ptr
, "text compression mode is out of range",
840 PNG_CHUNK_WRITE_ERROR
);
844 key_len
= strlen(text_ptr
[i
].key
);
846 if (text_ptr
[i
].compression
<= 0)
853 # ifdef PNG_iTXt_SUPPORTED
857 if (text_ptr
[i
].lang
!= NULL
)
858 lang_len
= strlen(text_ptr
[i
].lang
);
863 if (text_ptr
[i
].lang_key
!= NULL
)
864 lang_key_len
= strlen(text_ptr
[i
].lang_key
);
871 png_chunk_report(png_ptr
, "iTXt chunk not supported",
872 PNG_CHUNK_WRITE_ERROR
);
877 if (text_ptr
[i
].text
== NULL
|| text_ptr
[i
].text
[0] == '\0')
880 # ifdef PNG_iTXt_SUPPORTED
881 if (text_ptr
[i
].compression
> 0)
882 textp
->compression
= PNG_ITXT_COMPRESSION_NONE
;
886 textp
->compression
= PNG_TEXT_COMPRESSION_NONE
;
891 text_length
= strlen(text_ptr
[i
].text
);
892 textp
->compression
= text_ptr
[i
].compression
;
895 textp
->key
= png_voidcast(png_charp
,png_malloc_base(png_ptr
,
896 key_len
+ text_length
+ lang_len
+ lang_key_len
+ 4));
898 if (textp
->key
== NULL
)
900 png_chunk_report(png_ptr
, "text chunk: out of memory",
901 PNG_CHUNK_WRITE_ERROR
);
906 png_debug2(2, "Allocated %lu bytes at %p in png_set_text",
907 (unsigned long)(png_uint_32
)
908 (key_len
+ lang_len
+ lang_key_len
+ text_length
+ 4),
911 memcpy(textp
->key
, text_ptr
[i
].key
, key_len
);
912 *(textp
->key
+ key_len
) = '\0';
914 if (text_ptr
[i
].compression
> 0)
916 textp
->lang
= textp
->key
+ key_len
+ 1;
917 memcpy(textp
->lang
, text_ptr
[i
].lang
, lang_len
);
918 *(textp
->lang
+ lang_len
) = '\0';
919 textp
->lang_key
= textp
->lang
+ lang_len
+ 1;
920 memcpy(textp
->lang_key
, text_ptr
[i
].lang_key
, lang_key_len
);
921 *(textp
->lang_key
+ lang_key_len
) = '\0';
922 textp
->text
= textp
->lang_key
+ lang_key_len
+ 1;
928 textp
->lang_key
=NULL
;
929 textp
->text
= textp
->key
+ key_len
+ 1;
932 if (text_length
!= 0)
933 memcpy(textp
->text
, text_ptr
[i
].text
, text_length
);
935 *(textp
->text
+ text_length
) = '\0';
937 # ifdef PNG_iTXt_SUPPORTED
938 if (textp
->compression
> 0)
940 textp
->text_length
= 0;
941 textp
->itxt_length
= text_length
;
947 textp
->text_length
= text_length
;
948 textp
->itxt_length
= 0;
951 info_ptr
->num_text
++;
952 png_debug1(3, "transferred text chunk %d", info_ptr
->num_text
);
959 #ifdef PNG_tIME_SUPPORTED
961 png_set_tIME(png_const_structrp png_ptr
, png_inforp info_ptr
,
962 png_const_timep mod_time
)
964 png_debug1(1, "in %s storage function", "tIME");
966 if (png_ptr
== NULL
|| info_ptr
== NULL
|| mod_time
== NULL
||
967 (png_ptr
->mode
& PNG_WROTE_tIME
) != 0)
970 if (mod_time
->month
== 0 || mod_time
->month
> 12 ||
971 mod_time
->day
== 0 || mod_time
->day
> 31 ||
972 mod_time
->hour
> 23 || mod_time
->minute
> 59 ||
973 mod_time
->second
> 60)
975 png_warning(png_ptr
, "Ignoring invalid time value");
980 info_ptr
->mod_time
= *mod_time
;
981 info_ptr
->valid
|= PNG_INFO_tIME
;
985 #ifdef PNG_tRNS_SUPPORTED
987 png_set_tRNS(png_structrp png_ptr
, png_inforp info_ptr
,
988 png_const_bytep trans_alpha
, int num_trans
, png_const_color_16p trans_color
)
990 png_debug1(1, "in %s storage function", "tRNS");
992 if (png_ptr
== NULL
|| info_ptr
== NULL
)
996 if (trans_alpha
!= NULL
)
998 /* It may not actually be necessary to set png_ptr->trans_alpha here;
999 * we do it for backward compatibility with the way the png_handle_tRNS
1000 * function used to do the allocation.
1002 * 1.6.0: The above statement is incorrect; png_handle_tRNS effectively
1003 * relies on png_set_tRNS storing the information in png_struct
1004 * (otherwise it won't be there for the code in pngrtran.c).
1007 png_free_data(png_ptr
, info_ptr
, PNG_FREE_TRNS
, 0);
1009 if (num_trans
> 0 && num_trans
<= PNG_MAX_PALETTE_LENGTH
)
1011 /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
1012 info_ptr
->trans_alpha
= png_voidcast(png_bytep
,
1013 png_malloc(png_ptr
, PNG_MAX_PALETTE_LENGTH
));
1014 memcpy(info_ptr
->trans_alpha
, trans_alpha
, (size_t)num_trans
);
1016 info_ptr
->free_me
|= PNG_FREE_TRNS
;
1017 info_ptr
->valid
|= PNG_INFO_tRNS
;
1019 png_ptr
->trans_alpha
= info_ptr
->trans_alpha
;
1022 if (trans_color
!= NULL
)
1024 #ifdef PNG_WARNINGS_SUPPORTED
1025 if (info_ptr
->bit_depth
< 16)
1027 int sample_max
= (1 << info_ptr
->bit_depth
) - 1;
1029 if ((info_ptr
->color_type
== PNG_COLOR_TYPE_GRAY
&&
1030 trans_color
->gray
> sample_max
) ||
1031 (info_ptr
->color_type
== PNG_COLOR_TYPE_RGB
&&
1032 (trans_color
->red
> sample_max
||
1033 trans_color
->green
> sample_max
||
1034 trans_color
->blue
> sample_max
)))
1035 png_warning(png_ptr
,
1036 "tRNS chunk has out-of-range samples for bit_depth");
1040 info_ptr
->trans_color
= *trans_color
;
1046 info_ptr
->num_trans
= (png_uint_16
)num_trans
;
1050 info_ptr
->free_me
|= PNG_FREE_TRNS
;
1051 info_ptr
->valid
|= PNG_INFO_tRNS
;
1056 #ifdef PNG_sPLT_SUPPORTED
1058 png_set_sPLT(png_const_structrp png_ptr
,
1059 png_inforp info_ptr
, png_const_sPLT_tp entries
, int nentries
)
1061 * entries - array of png_sPLT_t structures
1062 * to be added to the list of palettes
1063 * in the info structure.
1065 * nentries - number of palette structures to be
1071 png_debug1(1, "in %s storage function", "sPLT");
1073 if (png_ptr
== NULL
|| info_ptr
== NULL
|| nentries
<= 0 || entries
== NULL
)
1076 /* Use the internal realloc function, which checks for all the possible
1077 * overflows. Notice that the parameters are (int) and (size_t)
1079 np
= png_voidcast(png_sPLT_tp
,png_realloc_array(png_ptr
,
1080 info_ptr
->splt_palettes
, info_ptr
->splt_palettes_num
, nentries
,
1085 /* Out of memory or too many chunks */
1086 png_chunk_report(png_ptr
, "too many sPLT chunks", PNG_CHUNK_WRITE_ERROR
);
1090 png_free(png_ptr
, info_ptr
->splt_palettes
);
1092 info_ptr
->splt_palettes
= np
;
1093 info_ptr
->free_me
|= PNG_FREE_SPLT
;
1095 np
+= info_ptr
->splt_palettes_num
;
1101 /* Skip invalid input entries */
1102 if (entries
->name
== NULL
|| entries
->entries
== NULL
)
1104 /* png_handle_sPLT doesn't do this, so this is an app error */
1105 png_app_error(png_ptr
, "png_set_sPLT: invalid sPLT");
1106 /* Just skip the invalid entry */
1110 np
->depth
= entries
->depth
;
1112 /* In the event of out-of-memory just return - there's no point keeping
1113 * on trying to add sPLT chunks.
1115 length
= strlen(entries
->name
) + 1;
1116 np
->name
= png_voidcast(png_charp
, png_malloc_base(png_ptr
, length
));
1118 if (np
->name
== NULL
)
1121 memcpy(np
->name
, entries
->name
, length
);
1123 /* IMPORTANT: we have memory now that won't get freed if something else
1124 * goes wrong; this code must free it. png_malloc_array produces no
1125 * warnings; use a png_chunk_report (below) if there is an error.
1127 np
->entries
= png_voidcast(png_sPLT_entryp
, png_malloc_array(png_ptr
,
1128 entries
->nentries
, sizeof (png_sPLT_entry
)));
1130 if (np
->entries
== NULL
)
1132 png_free(png_ptr
, np
->name
);
1137 np
->nentries
= entries
->nentries
;
1138 /* This multiply can't overflow because png_malloc_array has already
1139 * checked it when doing the allocation.
1141 memcpy(np
->entries
, entries
->entries
,
1142 (unsigned int)entries
->nentries
* sizeof (png_sPLT_entry
));
1144 /* Note that 'continue' skips the advance of the out pointer and out
1145 * count, so an invalid entry is not added.
1147 info_ptr
->valid
|= PNG_INFO_sPLT
;
1148 ++(info_ptr
->splt_palettes_num
);
1155 png_chunk_report(png_ptr
, "sPLT out of memory", PNG_CHUNK_WRITE_ERROR
);
1159 #ifdef PNG_APNG_SUPPORTED
1161 png_set_acTL(png_structp png_ptr
, png_infop info_ptr
,
1162 png_uint_32 num_frames
, png_uint_32 num_plays
)
1164 png_debug1(1, "in %s storage function", "acTL");
1166 if (png_ptr
== NULL
|| info_ptr
== NULL
)
1168 png_warning(png_ptr
,
1169 "Call to png_set_acTL() with NULL png_ptr "
1170 "or info_ptr ignored");
1173 if (num_frames
== 0)
1175 png_warning(png_ptr
,
1176 "Ignoring attempt to set acTL with num_frames zero");
1179 if (num_frames
> PNG_UINT_31_MAX
)
1181 png_warning(png_ptr
,
1182 "Ignoring attempt to set acTL with num_frames > 2^31-1");
1185 if (num_plays
> PNG_UINT_31_MAX
)
1187 png_warning(png_ptr
,
1188 "Ignoring attempt to set acTL with num_plays > 2^31-1");
1192 info_ptr
->num_frames
= num_frames
;
1193 info_ptr
->num_plays
= num_plays
;
1195 info_ptr
->valid
|= PNG_INFO_acTL
;
1200 /* delay_num and delay_den can hold any 16-bit values including zero */
1202 png_set_next_frame_fcTL(png_structp png_ptr
, png_infop info_ptr
,
1203 png_uint_32 width
, png_uint_32 height
,
1204 png_uint_32 x_offset
, png_uint_32 y_offset
,
1205 png_uint_16 delay_num
, png_uint_16 delay_den
,
1206 png_byte dispose_op
, png_byte blend_op
)
1208 png_debug1(1, "in %s storage function", "fcTL");
1210 if (png_ptr
== NULL
|| info_ptr
== NULL
)
1212 png_warning(png_ptr
,
1213 "Call to png_set_fcTL() with NULL png_ptr or info_ptr "
1218 png_ensure_fcTL_is_valid(png_ptr
, width
, height
, x_offset
, y_offset
,
1219 delay_num
, delay_den
, dispose_op
, blend_op
);
1221 if (blend_op
== PNG_BLEND_OP_OVER
)
1223 if ((png_ptr
->color_type
& PNG_COLOR_MASK_ALPHA
) == 0 &&
1224 png_get_valid(png_ptr
, info_ptr
, PNG_INFO_tRNS
) == 0)
1226 png_warning(png_ptr
, "PNG_BLEND_OP_OVER is meaningless "
1227 "and wasteful for opaque images, ignored");
1228 blend_op
= PNG_BLEND_OP_SOURCE
;
1232 info_ptr
->next_frame_width
= width
;
1233 info_ptr
->next_frame_height
= height
;
1234 info_ptr
->next_frame_x_offset
= x_offset
;
1235 info_ptr
->next_frame_y_offset
= y_offset
;
1236 info_ptr
->next_frame_delay_num
= delay_num
;
1237 info_ptr
->next_frame_delay_den
= delay_den
;
1238 info_ptr
->next_frame_dispose_op
= dispose_op
;
1239 info_ptr
->next_frame_blend_op
= blend_op
;
1241 info_ptr
->valid
|= PNG_INFO_fcTL
;
1247 png_ensure_fcTL_is_valid(png_structp png_ptr
,
1248 png_uint_32 width
, png_uint_32 height
,
1249 png_uint_32 x_offset
, png_uint_32 y_offset
,
1250 png_uint_16 delay_num
, png_uint_16 delay_den
,
1251 png_byte dispose_op
, png_byte blend_op
)
1253 if (width
== 0 || width
> PNG_UINT_31_MAX
)
1254 png_error(png_ptr
, "invalid width in fcTL (0 or > 2^31-1)");
1255 if (height
== 0 || height
> PNG_UINT_31_MAX
)
1256 png_error(png_ptr
, "invalid height in fcTL (0 or > 2^31-1)");
1257 if (x_offset
> PNG_UINT_31_MAX
)
1258 png_error(png_ptr
, "invalid x_offset in fcTL (> 2^31-1)");
1259 if (y_offset
> PNG_UINT_31_MAX
)
1260 png_error(png_ptr
, "invalid y_offset in fcTL (> 2^31-1)");
1261 if (width
+ x_offset
> png_ptr
->first_frame_width
||
1262 height
+ y_offset
> png_ptr
->first_frame_height
)
1263 png_error(png_ptr
, "dimensions of a frame are greater than "
1264 "the ones in IHDR");
1266 if (dispose_op
!= PNG_DISPOSE_OP_NONE
&&
1267 dispose_op
!= PNG_DISPOSE_OP_BACKGROUND
&&
1268 dispose_op
!= PNG_DISPOSE_OP_PREVIOUS
)
1269 png_error(png_ptr
, "invalid dispose_op in fcTL");
1271 if (blend_op
!= PNG_BLEND_OP_SOURCE
&&
1272 blend_op
!= PNG_BLEND_OP_OVER
)
1273 png_error(png_ptr
, "invalid blend_op in fcTL");
1275 PNG_UNUSED(delay_num
)
1276 PNG_UNUSED(delay_den
)
1280 png_set_first_frame_is_hidden(png_structp png_ptr
, png_infop info_ptr
,
1283 png_debug(1, "in png_first_frame_is_hidden()");
1285 if (png_ptr
== NULL
)
1289 png_ptr
->apng_flags
|= PNG_FIRST_FRAME_HIDDEN
;
1291 png_ptr
->apng_flags
&= ~PNG_FIRST_FRAME_HIDDEN
;
1293 PNG_UNUSED(info_ptr
)
1299 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
1301 check_location(png_const_structrp png_ptr
, int location
)
1303 location
&= (PNG_HAVE_IHDR
|PNG_HAVE_PLTE
|PNG_AFTER_IDAT
);
1305 /* New in 1.6.0; copy the location and check it. This is an API
1306 * change; previously the app had to use the
1307 * png_set_unknown_chunk_location API below for each chunk.
1309 if (location
== 0 && (png_ptr
->mode
& PNG_IS_READ_STRUCT
) == 0)
1311 /* Write struct, so unknown chunks come from the app */
1312 png_app_warning(png_ptr
,
1313 "png_set_unknown_chunks now expects a valid location");
1314 /* Use the old behavior */
1315 location
= (png_byte
)(png_ptr
->mode
&
1316 (PNG_HAVE_IHDR
|PNG_HAVE_PLTE
|PNG_AFTER_IDAT
));
1319 /* This need not be an internal error - if the app calls
1320 * png_set_unknown_chunks on a read pointer it must get the location right.
1323 png_error(png_ptr
, "invalid location in png_set_unknown_chunks");
1325 /* Now reduce the location to the top-most set bit by removing each least
1326 * significant bit in turn.
1328 while (location
!= (location
& -location
))
1329 location
&= ~(location
& -location
);
1331 /* The cast is safe because 'location' is a bit mask and only the low four
1332 * bits are significant.
1334 return (png_byte
)location
;
1338 png_set_unknown_chunks(png_const_structrp png_ptr
,
1339 png_inforp info_ptr
, png_const_unknown_chunkp unknowns
, int num_unknowns
)
1341 png_unknown_chunkp np
;
1343 if (png_ptr
== NULL
|| info_ptr
== NULL
|| num_unknowns
<= 0 ||
1347 /* Check for the failure cases where support has been disabled at compile
1348 * time. This code is hardly ever compiled - it's here because
1349 * STORE_UNKNOWN_CHUNKS is set by both read and write code (compiling in this
1350 * code) but may be meaningless if the read or write handling of unknown
1351 * chunks is not compiled in.
1353 # if !defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) && \
1354 defined(PNG_READ_SUPPORTED)
1355 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) != 0)
1357 png_app_error(png_ptr
, "no unknown chunk support on read");
1362 # if !defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) && \
1363 defined(PNG_WRITE_SUPPORTED)
1364 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) == 0)
1366 png_app_error(png_ptr
, "no unknown chunk support on write");
1372 /* Prior to 1.6.0 this code used png_malloc_warn; however, this meant that
1373 * unknown critical chunks could be lost with just a warning resulting in
1374 * undefined behavior. Now png_chunk_report is used to provide behavior
1375 * appropriate to read or write.
1377 np
= png_voidcast(png_unknown_chunkp
, png_realloc_array(png_ptr
,
1378 info_ptr
->unknown_chunks
, info_ptr
->unknown_chunks_num
, num_unknowns
,
1383 png_chunk_report(png_ptr
, "too many unknown chunks",
1384 PNG_CHUNK_WRITE_ERROR
);
1388 png_free(png_ptr
, info_ptr
->unknown_chunks
);
1390 info_ptr
->unknown_chunks
= np
; /* safe because it is initialized */
1391 info_ptr
->free_me
|= PNG_FREE_UNKN
;
1393 np
+= info_ptr
->unknown_chunks_num
;
1395 /* Increment unknown_chunks_num each time round the loop to protect the
1396 * just-allocated chunk data.
1398 for (; num_unknowns
> 0; --num_unknowns
, ++unknowns
)
1400 memcpy(np
->name
, unknowns
->name
, (sizeof np
->name
));
1401 np
->name
[(sizeof np
->name
)-1] = '\0';
1402 np
->location
= check_location(png_ptr
, unknowns
->location
);
1404 if (unknowns
->size
== 0)
1412 np
->data
= png_voidcast(png_bytep
,
1413 png_malloc_base(png_ptr
, unknowns
->size
));
1415 if (np
->data
== NULL
)
1417 png_chunk_report(png_ptr
, "unknown chunk: out of memory",
1418 PNG_CHUNK_WRITE_ERROR
);
1419 /* But just skip storing the unknown chunk */
1423 memcpy(np
->data
, unknowns
->data
, unknowns
->size
);
1424 np
->size
= unknowns
->size
;
1427 /* These increments are skipped on out-of-memory for the data - the
1428 * unknown chunk entry gets overwritten if the png_chunk_report returns.
1429 * This is correct in the read case (the chunk is just dropped.)
1432 ++(info_ptr
->unknown_chunks_num
);
1437 png_set_unknown_chunk_location(png_const_structrp png_ptr
, png_inforp info_ptr
,
1438 int chunk
, int location
)
1440 /* This API is pretty pointless in 1.6.0 because the location can be set
1441 * before the call to png_set_unknown_chunks.
1443 * TODO: add a png_app_warning in 1.7
1445 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&& chunk
>= 0 &&
1446 chunk
< info_ptr
->unknown_chunks_num
)
1448 if ((location
& (PNG_HAVE_IHDR
|PNG_HAVE_PLTE
|PNG_AFTER_IDAT
)) == 0)
1450 png_app_error(png_ptr
, "invalid unknown chunk location");
1451 /* Fake out the pre 1.6.0 behavior: */
1452 if (((unsigned int)location
& PNG_HAVE_IDAT
) != 0) /* undocumented! */
1453 location
= PNG_AFTER_IDAT
;
1456 location
= PNG_HAVE_IHDR
; /* also undocumented */
1459 info_ptr
->unknown_chunks
[chunk
].location
=
1460 check_location(png_ptr
, location
);
1463 #endif /* STORE_UNKNOWN_CHUNKS */
1465 #ifdef PNG_MNG_FEATURES_SUPPORTED
1467 png_permit_mng_features(png_structrp png_ptr
, png_uint_32 mng_features
)
1469 png_debug(1, "in png_permit_mng_features");
1471 if (png_ptr
== NULL
)
1474 png_ptr
->mng_features_permitted
= mng_features
& PNG_ALL_MNG_FEATURES
;
1476 return png_ptr
->mng_features_permitted
;
1480 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
1482 add_one_chunk(png_bytep list
, unsigned int count
, png_const_bytep add
, int keep
)
1486 /* Utility function: update the 'keep' state of a chunk if it is already in
1487 * the list, otherwise add it to the list.
1489 for (i
=0; i
<count
; ++i
, list
+= 5)
1491 if (memcmp(list
, add
, 4) == 0)
1493 list
[4] = (png_byte
)keep
;
1499 if (keep
!= PNG_HANDLE_CHUNK_AS_DEFAULT
)
1502 memcpy(list
, add
, 4);
1503 list
[4] = (png_byte
)keep
;
1510 png_set_keep_unknown_chunks(png_structrp png_ptr
, int keep
,
1511 png_const_bytep chunk_list
, int num_chunks_in
)
1514 unsigned int num_chunks
, old_num_chunks
;
1516 if (png_ptr
== NULL
)
1519 if (keep
< 0 || keep
>= PNG_HANDLE_CHUNK_LAST
)
1521 png_app_error(png_ptr
, "png_set_keep_unknown_chunks: invalid keep");
1526 if (num_chunks_in
<= 0)
1528 png_ptr
->unknown_default
= keep
;
1530 /* '0' means just set the flags, so stop here */
1531 if (num_chunks_in
== 0)
1535 if (num_chunks_in
< 0)
1537 /* Ignore all unknown chunks and all chunks recognized by
1538 * libpng except for IHDR, PLTE, tRNS, IDAT, and IEND
1540 static const png_byte chunks_to_ignore
[] = {
1541 98, 75, 71, 68, '\0', /* bKGD */
1542 99, 72, 82, 77, '\0', /* cHRM */
1543 101, 88, 73, 102, '\0', /* eXIf */
1544 103, 65, 77, 65, '\0', /* gAMA */
1545 104, 73, 83, 84, '\0', /* hIST */
1546 105, 67, 67, 80, '\0', /* iCCP */
1547 105, 84, 88, 116, '\0', /* iTXt */
1548 111, 70, 70, 115, '\0', /* oFFs */
1549 112, 67, 65, 76, '\0', /* pCAL */
1550 112, 72, 89, 115, '\0', /* pHYs */
1551 115, 66, 73, 84, '\0', /* sBIT */
1552 115, 67, 65, 76, '\0', /* sCAL */
1553 115, 80, 76, 84, '\0', /* sPLT */
1554 115, 84, 69, 82, '\0', /* sTER */
1555 115, 82, 71, 66, '\0', /* sRGB */
1556 116, 69, 88, 116, '\0', /* tEXt */
1557 116, 73, 77, 69, '\0', /* tIME */
1558 122, 84, 88, 116, '\0' /* zTXt */
1561 chunk_list
= chunks_to_ignore
;
1562 num_chunks
= (unsigned int)/*SAFE*/(sizeof chunks_to_ignore
)/5U;
1565 else /* num_chunks_in > 0 */
1567 if (chunk_list
== NULL
)
1569 /* Prior to 1.6.0 this was silently ignored, now it is an app_error
1570 * which can be switched off.
1572 png_app_error(png_ptr
, "png_set_keep_unknown_chunks: no chunk list");
1577 num_chunks
= (unsigned int)num_chunks_in
;
1580 old_num_chunks
= png_ptr
->num_chunk_list
;
1581 if (png_ptr
->chunk_list
== NULL
)
1584 /* Since num_chunks is always restricted to UINT_MAX/5 this can't overflow.
1586 if (num_chunks
+ old_num_chunks
> UINT_MAX
/5)
1588 png_app_error(png_ptr
, "png_set_keep_unknown_chunks: too many chunks");
1593 /* If these chunks are being reset to the default then no more memory is
1594 * required because add_one_chunk above doesn't extend the list if the 'keep'
1595 * parameter is the default.
1599 new_list
= png_voidcast(png_bytep
, png_malloc(png_ptr
,
1600 5 * (num_chunks
+ old_num_chunks
)));
1602 if (old_num_chunks
> 0)
1603 memcpy(new_list
, png_ptr
->chunk_list
, 5*old_num_chunks
);
1606 else if (old_num_chunks
> 0)
1607 new_list
= png_ptr
->chunk_list
;
1612 /* Add the new chunks together with each one's handling code. If the chunk
1613 * already exists the code is updated, otherwise the chunk is added to the
1614 * end. (In libpng 1.6.0 order no longer matters because this code enforces
1615 * the earlier convention that the last setting is the one that is used.)
1617 if (new_list
!= NULL
)
1619 png_const_bytep inlist
;
1623 for (i
=0; i
<num_chunks
; ++i
)
1625 old_num_chunks
= add_one_chunk(new_list
, old_num_chunks
,
1626 chunk_list
+5*i
, keep
);
1629 /* Now remove any spurious 'default' entries. */
1631 for (i
=0, inlist
=outlist
=new_list
; i
<old_num_chunks
; ++i
, inlist
+= 5)
1635 if (outlist
!= inlist
)
1636 memcpy(outlist
, inlist
, 5);
1642 /* This means the application has removed all the specialized handling. */
1643 if (num_chunks
== 0)
1645 if (png_ptr
->chunk_list
!= new_list
)
1646 png_free(png_ptr
, new_list
);
1655 png_ptr
->num_chunk_list
= num_chunks
;
1657 if (png_ptr
->chunk_list
!= new_list
)
1659 if (png_ptr
->chunk_list
!= NULL
)
1660 png_free(png_ptr
, png_ptr
->chunk_list
);
1662 png_ptr
->chunk_list
= new_list
;
1667 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1669 png_set_read_user_chunk_fn(png_structrp png_ptr
, png_voidp user_chunk_ptr
,
1670 png_user_chunk_ptr read_user_chunk_fn
)
1672 png_debug(1, "in png_set_read_user_chunk_fn");
1674 if (png_ptr
== NULL
)
1677 png_ptr
->read_user_chunk_fn
= read_user_chunk_fn
;
1678 png_ptr
->user_chunk_ptr
= user_chunk_ptr
;
1682 #ifdef PNG_INFO_IMAGE_SUPPORTED
1684 png_set_rows(png_const_structrp png_ptr
, png_inforp info_ptr
,
1685 png_bytepp row_pointers
)
1687 png_debug(1, "in png_set_rows");
1689 if (png_ptr
== NULL
|| info_ptr
== NULL
)
1692 if (info_ptr
->row_pointers
!= NULL
&&
1693 (info_ptr
->row_pointers
!= row_pointers
))
1694 png_free_data(png_ptr
, info_ptr
, PNG_FREE_ROWS
, 0);
1696 info_ptr
->row_pointers
= row_pointers
;
1698 if (row_pointers
!= NULL
)
1699 info_ptr
->valid
|= PNG_INFO_IDAT
;
1704 png_set_compression_buffer_size(png_structrp png_ptr
, size_t size
)
1706 png_debug(1, "in png_set_compression_buffer_size");
1708 if (png_ptr
== NULL
)
1711 if (size
== 0 || size
> PNG_UINT_31_MAX
)
1712 png_error(png_ptr
, "invalid compression buffer size");
1714 # ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1715 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) != 0)
1717 png_ptr
->IDAT_read_size
= (png_uint_32
)size
; /* checked above */
1722 # ifdef PNG_WRITE_SUPPORTED
1723 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) == 0)
1725 if (png_ptr
->zowner
!= 0)
1727 png_warning(png_ptr
,
1728 "Compression buffer size cannot be changed because it is in use");
1733 #ifndef __COVERITY__
1734 /* Some compilers complain that this is always false. However, it
1735 * can be true when integer overflow happens.
1737 if (size
> ZLIB_IO_MAX
)
1739 png_warning(png_ptr
,
1740 "Compression buffer size limited to system maximum");
1741 size
= ZLIB_IO_MAX
; /* must fit */
1747 /* Deflate will potentially go into an infinite loop on a SYNC_FLUSH
1748 * if this is permitted.
1750 png_warning(png_ptr
,
1751 "Compression buffer size cannot be reduced below 6");
1756 if (png_ptr
->zbuffer_size
!= size
)
1758 png_free_buffer_list(png_ptr
, &png_ptr
->zbuffer_list
);
1759 png_ptr
->zbuffer_size
= (uInt
)size
;
1766 png_set_invalid(png_const_structrp png_ptr
, png_inforp info_ptr
, int mask
)
1768 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1769 info_ptr
->valid
&= (unsigned int)(~mask
);
1773 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
1774 /* This function was added to libpng 1.2.6 */
1776 png_set_user_limits(png_structrp png_ptr
, png_uint_32 user_width_max
,
1777 png_uint_32 user_height_max
)
1779 png_debug(1, "in png_set_user_limits");
1781 /* Images with dimensions larger than these limits will be
1782 * rejected by png_set_IHDR(). To accept any PNG datastream
1783 * regardless of dimensions, set both limits to 0x7fffffff.
1785 if (png_ptr
== NULL
)
1788 png_ptr
->user_width_max
= user_width_max
;
1789 png_ptr
->user_height_max
= user_height_max
;
1792 /* This function was added to libpng 1.4.0 */
1794 png_set_chunk_cache_max(png_structrp png_ptr
, png_uint_32 user_chunk_cache_max
)
1796 png_debug(1, "in png_set_chunk_cache_max");
1798 if (png_ptr
!= NULL
)
1799 png_ptr
->user_chunk_cache_max
= user_chunk_cache_max
;
1802 /* This function was added to libpng 1.4.1 */
1804 png_set_chunk_malloc_max(png_structrp png_ptr
,
1805 png_alloc_size_t user_chunk_malloc_max
)
1807 png_debug(1, "in png_set_chunk_malloc_max");
1809 if (png_ptr
!= NULL
)
1810 png_ptr
->user_chunk_malloc_max
= user_chunk_malloc_max
;
1812 #endif /* ?SET_USER_LIMITS */
1815 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
1817 png_set_benign_errors(png_structrp png_ptr
, int allowed
)
1819 png_debug(1, "in png_set_benign_errors");
1821 /* If allowed is 1, png_benign_error() is treated as a warning.
1823 * If allowed is 0, png_benign_error() is treated as an error (which
1824 * is the default behavior if png_set_benign_errors() is not called).
1828 png_ptr
->flags
|= PNG_FLAG_BENIGN_ERRORS_WARN
|
1829 PNG_FLAG_APP_WARNINGS_WARN
| PNG_FLAG_APP_ERRORS_WARN
;
1832 png_ptr
->flags
&= ~(PNG_FLAG_BENIGN_ERRORS_WARN
|
1833 PNG_FLAG_APP_WARNINGS_WARN
| PNG_FLAG_APP_ERRORS_WARN
);
1835 #endif /* BENIGN_ERRORS */
1837 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
1838 /* Whether to report invalid palette index; added at libng-1.5.10.
1839 * It is possible for an indexed (color-type==3) PNG file to contain
1840 * pixels with invalid (out-of-range) indexes if the PLTE chunk has
1841 * fewer entries than the image's bit-depth would allow. We recover
1842 * from this gracefully by filling any incomplete palette with zeros
1843 * (opaque black). By default, when this occurs libpng will issue
1844 * a benign error. This API can be used to override that behavior.
1847 png_set_check_for_invalid_index(png_structrp png_ptr
, int allowed
)
1849 png_debug(1, "in png_set_check_for_invalid_index");
1852 png_ptr
->num_palette_max
= 0;
1855 png_ptr
->num_palette_max
= -1;
1859 #if defined(PNG_TEXT_SUPPORTED) || defined(PNG_pCAL_SUPPORTED) || \
1860 defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED)
1861 /* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
1862 * and if invalid, correct the keyword rather than discarding the entire
1863 * chunk. The PNG 1.0 specification requires keywords 1-79 characters in
1864 * length, forbids leading or trailing whitespace, multiple internal spaces,
1865 * and the non-break space (0x80) from ISO 8859-1. Returns keyword length.
1867 * The 'new_key' buffer must be 80 characters in size (for the keyword plus a
1868 * trailing '\0'). If this routine returns 0 then there was no keyword, or a
1869 * valid one could not be generated, and the caller must png_error.
1871 png_uint_32
/* PRIVATE */
1872 png_check_keyword(png_structrp png_ptr
, png_const_charp key
, png_bytep new_key
)
1874 #ifdef PNG_WARNINGS_SUPPORTED
1875 png_const_charp orig_key
= key
;
1877 png_uint_32 key_len
= 0;
1878 int bad_character
= 0;
1881 png_debug(1, "in png_check_keyword");
1889 while (*key
&& key_len
< 79)
1891 png_byte ch
= (png_byte
)*key
++;
1893 if ((ch
> 32 && ch
<= 126) || (ch
>= 161 /*&& ch <= 255*/))
1895 *new_key
++ = ch
; ++key_len
; space
= 0;
1898 else if (space
== 0)
1900 /* A space or an invalid character when one wasn't seen immediately
1901 * before; output just a space.
1903 *new_key
++ = 32; ++key_len
; space
= 1;
1905 /* If the character was not a space then it is invalid. */
1910 else if (bad_character
== 0)
1911 bad_character
= ch
; /* just skip it, record the first error */
1914 if (key_len
> 0 && space
!= 0) /* trailing space */
1916 --key_len
; --new_key
;
1917 if (bad_character
== 0)
1921 /* Terminate the keyword */
1927 #ifdef PNG_WARNINGS_SUPPORTED
1928 /* Try to only output one warning per keyword: */
1929 if (*key
!= 0) /* keyword too long */
1930 png_warning(png_ptr
, "keyword truncated");
1932 else if (bad_character
!= 0)
1934 PNG_WARNING_PARAMETERS(p
)
1936 png_warning_parameter(p
, 1, orig_key
);
1937 png_warning_parameter_signed(p
, 2, PNG_NUMBER_FORMAT_02x
, bad_character
);
1939 png_formatted_warning(png_ptr
, p
, "keyword \"@1\": bad character '0x@2'");
1941 #else /* !WARNINGS */
1943 #endif /* !WARNINGS */
1947 #endif /* TEXT || pCAL || iCCP || sPLT */
1948 #endif /* READ || WRITE */