2 /* pngset.c - storage of image information into info struct
4 * Copyright (c) 2018 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_buf
)
153 png_debug1(1, "in %s storage function", "eXIf");
155 if (png_ptr
== NULL
|| info_ptr
== NULL
)
160 png_free(png_ptr
, info_ptr
->exif
);
161 info_ptr
->exif
= NULL
;
164 info_ptr
->num_exif
= num_exif
;
166 info_ptr
->exif
= png_voidcast(png_bytep
, png_malloc_warn(png_ptr
,
167 info_ptr
->num_exif
));
169 if (info_ptr
->exif
== NULL
)
171 png_warning(png_ptr
, "Insufficient memory for eXIf chunk data");
175 info_ptr
->free_me
|= PNG_FREE_EXIF
;
177 for (i
= 0; i
< (int) info_ptr
->num_exif
; i
++)
178 info_ptr
->exif
[i
] = eXIf_buf
[i
];
180 info_ptr
->valid
|= PNG_INFO_eXIf
;
184 #ifdef PNG_gAMA_SUPPORTED
186 png_set_gAMA_fixed(png_const_structrp png_ptr
, png_inforp info_ptr
,
187 png_fixed_point file_gamma
)
189 png_debug1(1, "in %s storage function", "gAMA");
191 if (png_ptr
== NULL
|| info_ptr
== NULL
)
194 png_colorspace_set_gamma(png_ptr
, &info_ptr
->colorspace
, file_gamma
);
195 png_colorspace_sync_info(png_ptr
, info_ptr
);
198 # ifdef PNG_FLOATING_POINT_SUPPORTED
200 png_set_gAMA(png_const_structrp png_ptr
, png_inforp info_ptr
, double file_gamma
)
202 png_set_gAMA_fixed(png_ptr
, info_ptr
, png_fixed(png_ptr
, file_gamma
,
208 #ifdef PNG_hIST_SUPPORTED
210 png_set_hIST(png_const_structrp png_ptr
, png_inforp info_ptr
,
211 png_const_uint_16p hist
)
215 png_debug1(1, "in %s storage function", "hIST");
217 if (png_ptr
== NULL
|| info_ptr
== NULL
)
220 if (info_ptr
->num_palette
== 0 || info_ptr
->num_palette
221 > PNG_MAX_PALETTE_LENGTH
)
224 "Invalid palette size, hIST allocation skipped");
229 png_free_data(png_ptr
, info_ptr
, PNG_FREE_HIST
, 0);
231 /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
234 info_ptr
->hist
= png_voidcast(png_uint_16p
, png_malloc_warn(png_ptr
,
235 PNG_MAX_PALETTE_LENGTH
* (sizeof (png_uint_16
))));
237 if (info_ptr
->hist
== NULL
)
239 png_warning(png_ptr
, "Insufficient memory for hIST chunk data");
244 info_ptr
->free_me
|= PNG_FREE_HIST
;
246 for (i
= 0; i
< info_ptr
->num_palette
; i
++)
247 info_ptr
->hist
[i
] = hist
[i
];
249 info_ptr
->valid
|= PNG_INFO_hIST
;
254 png_set_IHDR(png_const_structrp png_ptr
, png_inforp info_ptr
,
255 png_uint_32 width
, png_uint_32 height
, int bit_depth
,
256 int color_type
, int interlace_type
, int compression_type
,
259 png_debug1(1, "in %s storage function", "IHDR");
261 if (png_ptr
== NULL
|| info_ptr
== NULL
)
264 info_ptr
->width
= width
;
265 info_ptr
->height
= height
;
266 info_ptr
->bit_depth
= (png_byte
)bit_depth
;
267 info_ptr
->color_type
= (png_byte
)color_type
;
268 info_ptr
->compression_type
= (png_byte
)compression_type
;
269 info_ptr
->filter_type
= (png_byte
)filter_type
;
270 info_ptr
->interlace_type
= (png_byte
)interlace_type
;
272 png_check_IHDR (png_ptr
, info_ptr
->width
, info_ptr
->height
,
273 info_ptr
->bit_depth
, info_ptr
->color_type
, info_ptr
->interlace_type
,
274 info_ptr
->compression_type
, info_ptr
->filter_type
);
276 if (info_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
277 info_ptr
->channels
= 1;
279 else if ((info_ptr
->color_type
& PNG_COLOR_MASK_COLOR
) != 0)
280 info_ptr
->channels
= 3;
283 info_ptr
->channels
= 1;
285 if ((info_ptr
->color_type
& PNG_COLOR_MASK_ALPHA
) != 0)
286 info_ptr
->channels
++;
288 info_ptr
->pixel_depth
= (png_byte
)(info_ptr
->channels
* info_ptr
->bit_depth
);
290 info_ptr
->rowbytes
= PNG_ROWBYTES(info_ptr
->pixel_depth
, width
);
292 #ifdef PNG_APNG_SUPPORTED
293 /* for non-animated png. this may be overwritten from an acTL chunk later */
294 info_ptr
->num_frames
= 1;
298 #ifdef PNG_oFFs_SUPPORTED
300 png_set_oFFs(png_const_structrp png_ptr
, png_inforp info_ptr
,
301 png_int_32 offset_x
, png_int_32 offset_y
, int unit_type
)
303 png_debug1(1, "in %s storage function", "oFFs");
305 if (png_ptr
== NULL
|| info_ptr
== NULL
)
308 info_ptr
->x_offset
= offset_x
;
309 info_ptr
->y_offset
= offset_y
;
310 info_ptr
->offset_unit_type
= (png_byte
)unit_type
;
311 info_ptr
->valid
|= PNG_INFO_oFFs
;
315 #ifdef PNG_pCAL_SUPPORTED
317 png_set_pCAL(png_const_structrp png_ptr
, png_inforp info_ptr
,
318 png_const_charp purpose
, png_int_32 X0
, png_int_32 X1
, int type
,
319 int nparams
, png_const_charp units
, png_charpp params
)
324 png_debug1(1, "in %s storage function", "pCAL");
326 if (png_ptr
== NULL
|| info_ptr
== NULL
|| purpose
== NULL
|| units
== NULL
327 || (nparams
> 0 && params
== NULL
))
330 length
= strlen(purpose
) + 1;
331 png_debug1(3, "allocating purpose for info (%lu bytes)",
332 (unsigned long)length
);
334 /* TODO: validate format of calibration name and unit name */
336 /* Check that the type matches the specification. */
337 if (type
< 0 || type
> 3)
339 png_chunk_report(png_ptr
, "Invalid pCAL equation type",
340 PNG_CHUNK_WRITE_ERROR
);
344 if (nparams
< 0 || nparams
> 255)
346 png_chunk_report(png_ptr
, "Invalid pCAL parameter count",
347 PNG_CHUNK_WRITE_ERROR
);
351 /* Validate params[nparams] */
352 for (i
=0; i
<nparams
; ++i
)
354 if (params
[i
] == NULL
||
355 !png_check_fp_string(params
[i
], strlen(params
[i
])))
357 png_chunk_report(png_ptr
, "Invalid format for pCAL parameter",
358 PNG_CHUNK_WRITE_ERROR
);
363 info_ptr
->pcal_purpose
= png_voidcast(png_charp
,
364 png_malloc_warn(png_ptr
, length
));
366 if (info_ptr
->pcal_purpose
== NULL
)
368 png_chunk_report(png_ptr
, "Insufficient memory for pCAL purpose",
369 PNG_CHUNK_WRITE_ERROR
);
373 memcpy(info_ptr
->pcal_purpose
, purpose
, length
);
375 png_debug(3, "storing X0, X1, type, and nparams in info");
376 info_ptr
->pcal_X0
= X0
;
377 info_ptr
->pcal_X1
= X1
;
378 info_ptr
->pcal_type
= (png_byte
)type
;
379 info_ptr
->pcal_nparams
= (png_byte
)nparams
;
381 length
= strlen(units
) + 1;
382 png_debug1(3, "allocating units for info (%lu bytes)",
383 (unsigned long)length
);
385 info_ptr
->pcal_units
= png_voidcast(png_charp
,
386 png_malloc_warn(png_ptr
, length
));
388 if (info_ptr
->pcal_units
== NULL
)
390 png_warning(png_ptr
, "Insufficient memory for pCAL units");
395 memcpy(info_ptr
->pcal_units
, units
, length
);
397 info_ptr
->pcal_params
= png_voidcast(png_charpp
, png_malloc_warn(png_ptr
,
398 (size_t)(((unsigned int)nparams
+ 1) * (sizeof (png_charp
)))));
400 if (info_ptr
->pcal_params
== NULL
)
402 png_warning(png_ptr
, "Insufficient memory for pCAL params");
407 memset(info_ptr
->pcal_params
, 0, ((unsigned int)nparams
+ 1) *
408 (sizeof (png_charp
)));
410 for (i
= 0; i
< nparams
; i
++)
412 length
= strlen(params
[i
]) + 1;
413 png_debug2(3, "allocating parameter %d for info (%lu bytes)", i
,
414 (unsigned long)length
);
416 info_ptr
->pcal_params
[i
] = (png_charp
)png_malloc_warn(png_ptr
, length
);
418 if (info_ptr
->pcal_params
[i
] == NULL
)
420 png_warning(png_ptr
, "Insufficient memory for pCAL parameter");
425 memcpy(info_ptr
->pcal_params
[i
], params
[i
], length
);
428 info_ptr
->valid
|= PNG_INFO_pCAL
;
429 info_ptr
->free_me
|= PNG_FREE_PCAL
;
433 #ifdef PNG_sCAL_SUPPORTED
435 png_set_sCAL_s(png_const_structrp png_ptr
, png_inforp info_ptr
,
436 int unit
, png_const_charp swidth
, png_const_charp sheight
)
438 size_t lengthw
= 0, lengthh
= 0;
440 png_debug1(1, "in %s storage function", "sCAL");
442 if (png_ptr
== NULL
|| info_ptr
== NULL
)
445 /* Double check the unit (should never get here with an invalid
446 * unit unless this is an API call.)
448 if (unit
!= 1 && unit
!= 2)
449 png_error(png_ptr
, "Invalid sCAL unit");
451 if (swidth
== NULL
|| (lengthw
= strlen(swidth
)) == 0 ||
452 swidth
[0] == 45 /* '-' */ || !png_check_fp_string(swidth
, lengthw
))
453 png_error(png_ptr
, "Invalid sCAL width");
455 if (sheight
== NULL
|| (lengthh
= strlen(sheight
)) == 0 ||
456 sheight
[0] == 45 /* '-' */ || !png_check_fp_string(sheight
, lengthh
))
457 png_error(png_ptr
, "Invalid sCAL height");
459 info_ptr
->scal_unit
= (png_byte
)unit
;
463 png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw
);
465 info_ptr
->scal_s_width
= png_voidcast(png_charp
,
466 png_malloc_warn(png_ptr
, lengthw
));
468 if (info_ptr
->scal_s_width
== NULL
)
470 png_warning(png_ptr
, "Memory allocation failed while processing sCAL");
475 memcpy(info_ptr
->scal_s_width
, swidth
, lengthw
);
479 png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthh
);
481 info_ptr
->scal_s_height
= png_voidcast(png_charp
,
482 png_malloc_warn(png_ptr
, lengthh
));
484 if (info_ptr
->scal_s_height
== NULL
)
486 png_free (png_ptr
, info_ptr
->scal_s_width
);
487 info_ptr
->scal_s_width
= NULL
;
489 png_warning(png_ptr
, "Memory allocation failed while processing sCAL");
494 memcpy(info_ptr
->scal_s_height
, sheight
, lengthh
);
496 info_ptr
->valid
|= PNG_INFO_sCAL
;
497 info_ptr
->free_me
|= PNG_FREE_SCAL
;
500 # ifdef PNG_FLOATING_POINT_SUPPORTED
502 png_set_sCAL(png_const_structrp png_ptr
, png_inforp info_ptr
, int unit
,
503 double width
, double height
)
505 png_debug1(1, "in %s storage function", "sCAL");
507 /* Check the arguments. */
509 png_warning(png_ptr
, "Invalid sCAL width ignored");
511 else if (height
<= 0)
512 png_warning(png_ptr
, "Invalid sCAL height ignored");
516 /* Convert 'width' and 'height' to ASCII. */
517 char swidth
[PNG_sCAL_MAX_DIGITS
+1];
518 char sheight
[PNG_sCAL_MAX_DIGITS
+1];
520 png_ascii_from_fp(png_ptr
, swidth
, (sizeof swidth
), width
,
522 png_ascii_from_fp(png_ptr
, sheight
, (sizeof sheight
), height
,
525 png_set_sCAL_s(png_ptr
, info_ptr
, unit
, swidth
, sheight
);
530 # ifdef PNG_FIXED_POINT_SUPPORTED
532 png_set_sCAL_fixed(png_const_structrp png_ptr
, png_inforp info_ptr
, int unit
,
533 png_fixed_point width
, png_fixed_point height
)
535 png_debug1(1, "in %s storage function", "sCAL");
537 /* Check the arguments. */
539 png_warning(png_ptr
, "Invalid sCAL width ignored");
541 else if (height
<= 0)
542 png_warning(png_ptr
, "Invalid sCAL height ignored");
546 /* Convert 'width' and 'height' to ASCII. */
547 char swidth
[PNG_sCAL_MAX_DIGITS
+1];
548 char sheight
[PNG_sCAL_MAX_DIGITS
+1];
550 png_ascii_from_fixed(png_ptr
, swidth
, (sizeof swidth
), width
);
551 png_ascii_from_fixed(png_ptr
, sheight
, (sizeof sheight
), height
);
553 png_set_sCAL_s(png_ptr
, info_ptr
, unit
, swidth
, sheight
);
559 #ifdef PNG_pHYs_SUPPORTED
561 png_set_pHYs(png_const_structrp png_ptr
, png_inforp info_ptr
,
562 png_uint_32 res_x
, png_uint_32 res_y
, int unit_type
)
564 png_debug1(1, "in %s storage function", "pHYs");
566 if (png_ptr
== NULL
|| info_ptr
== NULL
)
569 info_ptr
->x_pixels_per_unit
= res_x
;
570 info_ptr
->y_pixels_per_unit
= res_y
;
571 info_ptr
->phys_unit_type
= (png_byte
)unit_type
;
572 info_ptr
->valid
|= PNG_INFO_pHYs
;
577 png_set_PLTE(png_structrp png_ptr
, png_inforp info_ptr
,
578 png_const_colorp palette
, int num_palette
)
581 png_uint_32 max_palette_length
;
583 png_debug1(1, "in %s storage function", "PLTE");
585 if (png_ptr
== NULL
|| info_ptr
== NULL
)
588 max_palette_length
= (info_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
) ?
589 (1 << info_ptr
->bit_depth
) : PNG_MAX_PALETTE_LENGTH
;
591 if (num_palette
< 0 || num_palette
> (int) max_palette_length
)
593 if (info_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
594 png_error(png_ptr
, "Invalid palette length");
598 png_warning(png_ptr
, "Invalid palette length");
604 if ((num_palette
> 0 && palette
== NULL
) ||
606 # ifdef PNG_MNG_FEATURES_SUPPORTED
607 && (png_ptr
->mng_features_permitted
& PNG_FLAG_MNG_EMPTY_PLTE
) == 0
611 png_error(png_ptr
, "Invalid palette");
614 /* It may not actually be necessary to set png_ptr->palette here;
615 * we do it for backward compatibility with the way the png_handle_tRNS
616 * function used to do the allocation.
618 * 1.6.0: the above statement appears to be incorrect; something has to set
619 * the palette inside png_struct on read.
621 png_free_data(png_ptr
, info_ptr
, PNG_FREE_PLTE
, 0);
623 /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
624 * of num_palette entries, in case of an invalid PNG file or incorrect
625 * call to png_set_PLTE() with too-large sample values.
627 png_ptr
->palette
= png_voidcast(png_colorp
, png_calloc(png_ptr
,
628 PNG_MAX_PALETTE_LENGTH
* (sizeof (png_color
))));
631 memcpy(png_ptr
->palette
, palette
, (unsigned int)num_palette
*
632 (sizeof (png_color
)));
633 info_ptr
->palette
= png_ptr
->palette
;
634 info_ptr
->num_palette
= png_ptr
->num_palette
= (png_uint_16
)num_palette
;
636 info_ptr
->free_me
|= PNG_FREE_PLTE
;
638 info_ptr
->valid
|= PNG_INFO_PLTE
;
641 #ifdef PNG_sBIT_SUPPORTED
643 png_set_sBIT(png_const_structrp png_ptr
, png_inforp info_ptr
,
644 png_const_color_8p sig_bit
)
646 png_debug1(1, "in %s storage function", "sBIT");
648 if (png_ptr
== NULL
|| info_ptr
== NULL
|| sig_bit
== NULL
)
651 info_ptr
->sig_bit
= *sig_bit
;
652 info_ptr
->valid
|= PNG_INFO_sBIT
;
656 #ifdef PNG_sRGB_SUPPORTED
658 png_set_sRGB(png_const_structrp png_ptr
, png_inforp info_ptr
, int srgb_intent
)
660 png_debug1(1, "in %s storage function", "sRGB");
662 if (png_ptr
== NULL
|| info_ptr
== NULL
)
665 (void)png_colorspace_set_sRGB(png_ptr
, &info_ptr
->colorspace
, srgb_intent
);
666 png_colorspace_sync_info(png_ptr
, info_ptr
);
670 png_set_sRGB_gAMA_and_cHRM(png_const_structrp png_ptr
, png_inforp info_ptr
,
673 png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");
675 if (png_ptr
== NULL
|| info_ptr
== NULL
)
678 if (png_colorspace_set_sRGB(png_ptr
, &info_ptr
->colorspace
,
681 /* This causes the gAMA and cHRM to be written too */
682 info_ptr
->colorspace
.flags
|=
683 PNG_COLORSPACE_FROM_gAMA
|PNG_COLORSPACE_FROM_cHRM
;
686 png_colorspace_sync_info(png_ptr
, info_ptr
);
691 #ifdef PNG_iCCP_SUPPORTED
693 png_set_iCCP(png_const_structrp png_ptr
, png_inforp info_ptr
,
694 png_const_charp name
, int compression_type
,
695 png_const_bytep profile
, png_uint_32 proflen
)
697 png_charp new_iccp_name
;
698 png_bytep new_iccp_profile
;
701 png_debug1(1, "in %s storage function", "iCCP");
703 if (png_ptr
== NULL
|| info_ptr
== NULL
|| name
== NULL
|| profile
== NULL
)
706 if (compression_type
!= PNG_COMPRESSION_TYPE_BASE
)
707 png_app_error(png_ptr
, "Invalid iCCP compression method");
709 /* Set the colorspace first because this validates the profile; do not
710 * override previously set app cHRM or gAMA here (because likely as not the
711 * application knows better than libpng what the correct values are.) Pass
712 * the info_ptr color_type field to png_colorspace_set_ICC because in the
713 * write case it has not yet been stored in png_ptr.
716 int result
= png_colorspace_set_ICC(png_ptr
, &info_ptr
->colorspace
, name
,
717 proflen
, profile
, info_ptr
->color_type
);
719 png_colorspace_sync_info(png_ptr
, info_ptr
);
721 /* Don't do any of the copying if the profile was bad, or inconsistent. */
725 /* But do write the gAMA and cHRM chunks from the profile. */
726 info_ptr
->colorspace
.flags
|=
727 PNG_COLORSPACE_FROM_gAMA
|PNG_COLORSPACE_FROM_cHRM
;
730 length
= strlen(name
)+1;
731 new_iccp_name
= png_voidcast(png_charp
, png_malloc_warn(png_ptr
, length
));
733 if (new_iccp_name
== NULL
)
735 png_benign_error(png_ptr
, "Insufficient memory to process iCCP chunk");
740 memcpy(new_iccp_name
, name
, length
);
741 new_iccp_profile
= png_voidcast(png_bytep
,
742 png_malloc_warn(png_ptr
, proflen
));
744 if (new_iccp_profile
== NULL
)
746 png_free(png_ptr
, new_iccp_name
);
747 png_benign_error(png_ptr
,
748 "Insufficient memory to process iCCP profile");
753 memcpy(new_iccp_profile
, profile
, proflen
);
755 png_free_data(png_ptr
, info_ptr
, PNG_FREE_ICCP
, 0);
757 info_ptr
->iccp_proflen
= proflen
;
758 info_ptr
->iccp_name
= new_iccp_name
;
759 info_ptr
->iccp_profile
= new_iccp_profile
;
760 info_ptr
->free_me
|= PNG_FREE_ICCP
;
761 info_ptr
->valid
|= PNG_INFO_iCCP
;
765 #ifdef PNG_TEXT_SUPPORTED
767 png_set_text(png_const_structrp png_ptr
, png_inforp info_ptr
,
768 png_const_textp text_ptr
, int num_text
)
771 ret
= png_set_text_2(png_ptr
, info_ptr
, text_ptr
, num_text
);
774 png_error(png_ptr
, "Insufficient memory to store text");
778 png_set_text_2(png_const_structrp png_ptr
, png_inforp info_ptr
,
779 png_const_textp text_ptr
, int num_text
)
783 png_debug1(1, "in %lx storage function", png_ptr
== NULL
? 0xabadca11U
:
784 (unsigned long)png_ptr
->chunk_name
);
786 if (png_ptr
== NULL
|| info_ptr
== NULL
|| num_text
<= 0 || text_ptr
== NULL
)
789 /* Make sure we have enough space in the "text" array in info_struct
790 * to hold all of the incoming text_ptr objects. This compare can't overflow
791 * because max_text >= num_text (anyway, subtract of two positive integers
792 * can't overflow in any case.)
794 if (num_text
> info_ptr
->max_text
- info_ptr
->num_text
)
796 int old_num_text
= info_ptr
->num_text
;
798 png_textp new_text
= NULL
;
800 /* Calculate an appropriate max_text, checking for overflow. */
801 max_text
= old_num_text
;
802 if (num_text
<= INT_MAX
- max_text
)
804 max_text
+= num_text
;
806 /* Round up to a multiple of 8 */
807 if (max_text
< INT_MAX
-8)
808 max_text
= (max_text
+ 8) & ~0x7;
813 /* Now allocate a new array and copy the old members in; this does all
814 * the overflow checks.
816 new_text
= png_voidcast(png_textp
,png_realloc_array(png_ptr
,
817 info_ptr
->text
, old_num_text
, max_text
-old_num_text
,
821 if (new_text
== NULL
)
823 png_chunk_report(png_ptr
, "too many text chunks",
824 PNG_CHUNK_WRITE_ERROR
);
829 png_free(png_ptr
, info_ptr
->text
);
831 info_ptr
->text
= new_text
;
832 info_ptr
->free_me
|= PNG_FREE_TEXT
;
833 info_ptr
->max_text
= max_text
;
834 /* num_text is adjusted below as the entries are copied in */
836 png_debug1(3, "allocated %d entries for info_ptr->text", max_text
);
839 for (i
= 0; i
< num_text
; i
++)
841 size_t text_length
, key_len
;
842 size_t lang_len
, lang_key_len
;
843 png_textp textp
= &(info_ptr
->text
[info_ptr
->num_text
]);
845 if (text_ptr
[i
].key
== NULL
)
848 if (text_ptr
[i
].compression
< PNG_TEXT_COMPRESSION_NONE
||
849 text_ptr
[i
].compression
>= PNG_TEXT_COMPRESSION_LAST
)
851 png_chunk_report(png_ptr
, "text compression mode is out of range",
852 PNG_CHUNK_WRITE_ERROR
);
856 key_len
= strlen(text_ptr
[i
].key
);
858 if (text_ptr
[i
].compression
<= 0)
865 # ifdef PNG_iTXt_SUPPORTED
869 if (text_ptr
[i
].lang
!= NULL
)
870 lang_len
= strlen(text_ptr
[i
].lang
);
875 if (text_ptr
[i
].lang_key
!= NULL
)
876 lang_key_len
= strlen(text_ptr
[i
].lang_key
);
883 png_chunk_report(png_ptr
, "iTXt chunk not supported",
884 PNG_CHUNK_WRITE_ERROR
);
889 if (text_ptr
[i
].text
== NULL
|| text_ptr
[i
].text
[0] == '\0')
892 # ifdef PNG_iTXt_SUPPORTED
893 if (text_ptr
[i
].compression
> 0)
894 textp
->compression
= PNG_ITXT_COMPRESSION_NONE
;
898 textp
->compression
= PNG_TEXT_COMPRESSION_NONE
;
903 text_length
= strlen(text_ptr
[i
].text
);
904 textp
->compression
= text_ptr
[i
].compression
;
907 textp
->key
= png_voidcast(png_charp
,png_malloc_base(png_ptr
,
908 key_len
+ text_length
+ lang_len
+ lang_key_len
+ 4));
910 if (textp
->key
== NULL
)
912 png_chunk_report(png_ptr
, "text chunk: out of memory",
913 PNG_CHUNK_WRITE_ERROR
);
918 png_debug2(2, "Allocated %lu bytes at %p in png_set_text",
919 (unsigned long)(png_uint_32
)
920 (key_len
+ lang_len
+ lang_key_len
+ text_length
+ 4),
923 memcpy(textp
->key
, text_ptr
[i
].key
, key_len
);
924 *(textp
->key
+ key_len
) = '\0';
926 if (text_ptr
[i
].compression
> 0)
928 textp
->lang
= textp
->key
+ key_len
+ 1;
929 memcpy(textp
->lang
, text_ptr
[i
].lang
, lang_len
);
930 *(textp
->lang
+ lang_len
) = '\0';
931 textp
->lang_key
= textp
->lang
+ lang_len
+ 1;
932 memcpy(textp
->lang_key
, text_ptr
[i
].lang_key
, lang_key_len
);
933 *(textp
->lang_key
+ lang_key_len
) = '\0';
934 textp
->text
= textp
->lang_key
+ lang_key_len
+ 1;
940 textp
->lang_key
=NULL
;
941 textp
->text
= textp
->key
+ key_len
+ 1;
944 if (text_length
!= 0)
945 memcpy(textp
->text
, text_ptr
[i
].text
, text_length
);
947 *(textp
->text
+ text_length
) = '\0';
949 # ifdef PNG_iTXt_SUPPORTED
950 if (textp
->compression
> 0)
952 textp
->text_length
= 0;
953 textp
->itxt_length
= text_length
;
959 textp
->text_length
= text_length
;
960 textp
->itxt_length
= 0;
963 info_ptr
->num_text
++;
964 png_debug1(3, "transferred text chunk %d", info_ptr
->num_text
);
971 #ifdef PNG_tIME_SUPPORTED
973 png_set_tIME(png_const_structrp png_ptr
, png_inforp info_ptr
,
974 png_const_timep mod_time
)
976 png_debug1(1, "in %s storage function", "tIME");
978 if (png_ptr
== NULL
|| info_ptr
== NULL
|| mod_time
== NULL
||
979 (png_ptr
->mode
& PNG_WROTE_tIME
) != 0)
982 if (mod_time
->month
== 0 || mod_time
->month
> 12 ||
983 mod_time
->day
== 0 || mod_time
->day
> 31 ||
984 mod_time
->hour
> 23 || mod_time
->minute
> 59 ||
985 mod_time
->second
> 60)
987 png_warning(png_ptr
, "Ignoring invalid time value");
992 info_ptr
->mod_time
= *mod_time
;
993 info_ptr
->valid
|= PNG_INFO_tIME
;
997 #ifdef PNG_tRNS_SUPPORTED
999 png_set_tRNS(png_structrp png_ptr
, png_inforp info_ptr
,
1000 png_const_bytep trans_alpha
, int num_trans
, png_const_color_16p trans_color
)
1002 png_debug1(1, "in %s storage function", "tRNS");
1004 if (png_ptr
== NULL
|| info_ptr
== NULL
)
1008 if (trans_alpha
!= NULL
)
1010 /* It may not actually be necessary to set png_ptr->trans_alpha here;
1011 * we do it for backward compatibility with the way the png_handle_tRNS
1012 * function used to do the allocation.
1014 * 1.6.0: The above statement is incorrect; png_handle_tRNS effectively
1015 * relies on png_set_tRNS storing the information in png_struct
1016 * (otherwise it won't be there for the code in pngrtran.c).
1019 png_free_data(png_ptr
, info_ptr
, PNG_FREE_TRNS
, 0);
1021 if (num_trans
> 0 && num_trans
<= PNG_MAX_PALETTE_LENGTH
)
1023 /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
1024 info_ptr
->trans_alpha
= png_voidcast(png_bytep
,
1025 png_malloc(png_ptr
, PNG_MAX_PALETTE_LENGTH
));
1026 memcpy(info_ptr
->trans_alpha
, trans_alpha
, (size_t)num_trans
);
1028 png_ptr
->trans_alpha
= info_ptr
->trans_alpha
;
1031 if (trans_color
!= NULL
)
1033 #ifdef PNG_WARNINGS_SUPPORTED
1034 if (info_ptr
->bit_depth
< 16)
1036 int sample_max
= (1 << info_ptr
->bit_depth
) - 1;
1038 if ((info_ptr
->color_type
== PNG_COLOR_TYPE_GRAY
&&
1039 trans_color
->gray
> sample_max
) ||
1040 (info_ptr
->color_type
== PNG_COLOR_TYPE_RGB
&&
1041 (trans_color
->red
> sample_max
||
1042 trans_color
->green
> sample_max
||
1043 trans_color
->blue
> sample_max
)))
1044 png_warning(png_ptr
,
1045 "tRNS chunk has out-of-range samples for bit_depth");
1049 info_ptr
->trans_color
= *trans_color
;
1055 info_ptr
->num_trans
= (png_uint_16
)num_trans
;
1059 info_ptr
->valid
|= PNG_INFO_tRNS
;
1060 info_ptr
->free_me
|= PNG_FREE_TRNS
;
1065 #ifdef PNG_sPLT_SUPPORTED
1067 png_set_sPLT(png_const_structrp png_ptr
,
1068 png_inforp info_ptr
, png_const_sPLT_tp entries
, int nentries
)
1070 * entries - array of png_sPLT_t structures
1071 * to be added to the list of palettes
1072 * in the info structure.
1074 * nentries - number of palette structures to be
1080 if (png_ptr
== NULL
|| info_ptr
== NULL
|| nentries
<= 0 || entries
== NULL
)
1083 /* Use the internal realloc function, which checks for all the possible
1084 * overflows. Notice that the parameters are (int) and (size_t)
1086 np
= png_voidcast(png_sPLT_tp
,png_realloc_array(png_ptr
,
1087 info_ptr
->splt_palettes
, info_ptr
->splt_palettes_num
, nentries
,
1092 /* Out of memory or too many chunks */
1093 png_chunk_report(png_ptr
, "too many sPLT chunks", PNG_CHUNK_WRITE_ERROR
);
1098 png_free(png_ptr
, info_ptr
->splt_palettes
);
1099 info_ptr
->splt_palettes
= np
;
1100 info_ptr
->free_me
|= PNG_FREE_SPLT
;
1102 np
+= info_ptr
->splt_palettes_num
;
1108 /* Skip invalid input entries */
1109 if (entries
->name
== NULL
|| entries
->entries
== NULL
)
1111 /* png_handle_sPLT doesn't do this, so this is an app error */
1112 png_app_error(png_ptr
, "png_set_sPLT: invalid sPLT");
1113 /* Just skip the invalid entry */
1117 np
->depth
= entries
->depth
;
1119 /* In the event of out-of-memory just return - there's no point keeping
1120 * on trying to add sPLT chunks.
1122 length
= strlen(entries
->name
) + 1;
1123 np
->name
= png_voidcast(png_charp
, png_malloc_base(png_ptr
, length
));
1125 if (np
->name
== NULL
)
1128 memcpy(np
->name
, entries
->name
, length
);
1130 /* IMPORTANT: we have memory now that won't get freed if something else
1131 * goes wrong; this code must free it. png_malloc_array produces no
1132 * warnings; use a png_chunk_report (below) if there is an error.
1134 np
->entries
= png_voidcast(png_sPLT_entryp
, png_malloc_array(png_ptr
,
1135 entries
->nentries
, sizeof (png_sPLT_entry
)));
1137 if (np
->entries
== NULL
)
1139 png_free(png_ptr
, np
->name
);
1144 np
->nentries
= entries
->nentries
;
1145 /* This multiply can't overflow because png_malloc_array has already
1146 * checked it when doing the allocation.
1148 memcpy(np
->entries
, entries
->entries
,
1149 (unsigned int)entries
->nentries
* sizeof (png_sPLT_entry
));
1151 /* Note that 'continue' skips the advance of the out pointer and out
1152 * count, so an invalid entry is not added.
1154 info_ptr
->valid
|= PNG_INFO_sPLT
;
1155 ++(info_ptr
->splt_palettes_num
);
1162 png_chunk_report(png_ptr
, "sPLT out of memory", PNG_CHUNK_WRITE_ERROR
);
1166 #ifdef PNG_APNG_SUPPORTED
1168 png_set_acTL(png_structp png_ptr
, png_infop info_ptr
,
1169 png_uint_32 num_frames
, png_uint_32 num_plays
)
1171 png_debug1(1, "in %s storage function", "acTL");
1173 if (png_ptr
== NULL
|| info_ptr
== NULL
)
1175 png_warning(png_ptr
,
1176 "Call to png_set_acTL() with NULL png_ptr "
1177 "or info_ptr ignored");
1180 if (num_frames
== 0)
1182 png_warning(png_ptr
,
1183 "Ignoring attempt to set acTL with num_frames zero");
1186 if (num_frames
> PNG_UINT_31_MAX
)
1188 png_warning(png_ptr
,
1189 "Ignoring attempt to set acTL with num_frames > 2^31-1");
1192 if (num_plays
> PNG_UINT_31_MAX
)
1194 png_warning(png_ptr
,
1195 "Ignoring attempt to set acTL with num_plays > 2^31-1");
1199 info_ptr
->num_frames
= num_frames
;
1200 info_ptr
->num_plays
= num_plays
;
1202 info_ptr
->valid
|= PNG_INFO_acTL
;
1207 /* delay_num and delay_den can hold any 16-bit values including zero */
1209 png_set_next_frame_fcTL(png_structp png_ptr
, png_infop info_ptr
,
1210 png_uint_32 width
, png_uint_32 height
,
1211 png_uint_32 x_offset
, png_uint_32 y_offset
,
1212 png_uint_16 delay_num
, png_uint_16 delay_den
,
1213 png_byte dispose_op
, png_byte blend_op
)
1215 png_debug1(1, "in %s storage function", "fcTL");
1217 if (png_ptr
== NULL
|| info_ptr
== NULL
)
1219 png_warning(png_ptr
,
1220 "Call to png_set_fcTL() with NULL png_ptr or info_ptr "
1225 png_ensure_fcTL_is_valid(png_ptr
, width
, height
, x_offset
, y_offset
,
1226 delay_num
, delay_den
, dispose_op
, blend_op
);
1228 if (blend_op
== PNG_BLEND_OP_OVER
)
1230 if ((png_ptr
->color_type
& PNG_COLOR_MASK_ALPHA
) == 0 &&
1231 png_get_valid(png_ptr
, info_ptr
, PNG_INFO_tRNS
) == 0)
1233 png_warning(png_ptr
, "PNG_BLEND_OP_OVER is meaningless "
1234 "and wasteful for opaque images, ignored");
1235 blend_op
= PNG_BLEND_OP_SOURCE
;
1239 info_ptr
->next_frame_width
= width
;
1240 info_ptr
->next_frame_height
= height
;
1241 info_ptr
->next_frame_x_offset
= x_offset
;
1242 info_ptr
->next_frame_y_offset
= y_offset
;
1243 info_ptr
->next_frame_delay_num
= delay_num
;
1244 info_ptr
->next_frame_delay_den
= delay_den
;
1245 info_ptr
->next_frame_dispose_op
= dispose_op
;
1246 info_ptr
->next_frame_blend_op
= blend_op
;
1248 info_ptr
->valid
|= PNG_INFO_fcTL
;
1254 png_ensure_fcTL_is_valid(png_structp png_ptr
,
1255 png_uint_32 width
, png_uint_32 height
,
1256 png_uint_32 x_offset
, png_uint_32 y_offset
,
1257 png_uint_16 delay_num
, png_uint_16 delay_den
,
1258 png_byte dispose_op
, png_byte blend_op
)
1260 if (width
== 0 || width
> PNG_UINT_31_MAX
)
1261 png_error(png_ptr
, "invalid width in fcTL (0 or > 2^31-1)");
1262 if (height
== 0 || height
> PNG_UINT_31_MAX
)
1263 png_error(png_ptr
, "invalid height in fcTL (0 or > 2^31-1)");
1264 if (x_offset
> PNG_UINT_31_MAX
)
1265 png_error(png_ptr
, "invalid x_offset in fcTL (> 2^31-1)");
1266 if (y_offset
> PNG_UINT_31_MAX
)
1267 png_error(png_ptr
, "invalid y_offset in fcTL (> 2^31-1)");
1268 if (width
+ x_offset
> png_ptr
->first_frame_width
||
1269 height
+ y_offset
> png_ptr
->first_frame_height
)
1270 png_error(png_ptr
, "dimensions of a frame are greater than "
1271 "the ones in IHDR");
1273 if (dispose_op
!= PNG_DISPOSE_OP_NONE
&&
1274 dispose_op
!= PNG_DISPOSE_OP_BACKGROUND
&&
1275 dispose_op
!= PNG_DISPOSE_OP_PREVIOUS
)
1276 png_error(png_ptr
, "invalid dispose_op in fcTL");
1278 if (blend_op
!= PNG_BLEND_OP_SOURCE
&&
1279 blend_op
!= PNG_BLEND_OP_OVER
)
1280 png_error(png_ptr
, "invalid blend_op in fcTL");
1282 PNG_UNUSED(delay_num
)
1283 PNG_UNUSED(delay_den
)
1287 png_set_first_frame_is_hidden(png_structp png_ptr
, png_infop info_ptr
,
1290 png_debug(1, "in png_first_frame_is_hidden()");
1292 if (png_ptr
== NULL
)
1296 png_ptr
->apng_flags
|= PNG_FIRST_FRAME_HIDDEN
;
1298 png_ptr
->apng_flags
&= ~PNG_FIRST_FRAME_HIDDEN
;
1300 PNG_UNUSED(info_ptr
)
1306 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
1308 check_location(png_const_structrp png_ptr
, int location
)
1310 location
&= (PNG_HAVE_IHDR
|PNG_HAVE_PLTE
|PNG_AFTER_IDAT
);
1312 /* New in 1.6.0; copy the location and check it. This is an API
1313 * change; previously the app had to use the
1314 * png_set_unknown_chunk_location API below for each chunk.
1316 if (location
== 0 && (png_ptr
->mode
& PNG_IS_READ_STRUCT
) == 0)
1318 /* Write struct, so unknown chunks come from the app */
1319 png_app_warning(png_ptr
,
1320 "png_set_unknown_chunks now expects a valid location");
1321 /* Use the old behavior */
1322 location
= (png_byte
)(png_ptr
->mode
&
1323 (PNG_HAVE_IHDR
|PNG_HAVE_PLTE
|PNG_AFTER_IDAT
));
1326 /* This need not be an internal error - if the app calls
1327 * png_set_unknown_chunks on a read pointer it must get the location right.
1330 png_error(png_ptr
, "invalid location in png_set_unknown_chunks");
1332 /* Now reduce the location to the top-most set bit by removing each least
1333 * significant bit in turn.
1335 while (location
!= (location
& -location
))
1336 location
&= ~(location
& -location
);
1338 /* The cast is safe because 'location' is a bit mask and only the low four
1339 * bits are significant.
1341 return (png_byte
)location
;
1345 png_set_unknown_chunks(png_const_structrp png_ptr
,
1346 png_inforp info_ptr
, png_const_unknown_chunkp unknowns
, int num_unknowns
)
1348 png_unknown_chunkp np
;
1350 if (png_ptr
== NULL
|| info_ptr
== NULL
|| num_unknowns
<= 0 ||
1354 /* Check for the failure cases where support has been disabled at compile
1355 * time. This code is hardly ever compiled - it's here because
1356 * STORE_UNKNOWN_CHUNKS is set by both read and write code (compiling in this
1357 * code) but may be meaningless if the read or write handling of unknown
1358 * chunks is not compiled in.
1360 # if !defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) && \
1361 defined(PNG_READ_SUPPORTED)
1362 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) != 0)
1364 png_app_error(png_ptr
, "no unknown chunk support on read");
1369 # if !defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) && \
1370 defined(PNG_WRITE_SUPPORTED)
1371 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) == 0)
1373 png_app_error(png_ptr
, "no unknown chunk support on write");
1379 /* Prior to 1.6.0 this code used png_malloc_warn; however, this meant that
1380 * unknown critical chunks could be lost with just a warning resulting in
1381 * undefined behavior. Now png_chunk_report is used to provide behavior
1382 * appropriate to read or write.
1384 np
= png_voidcast(png_unknown_chunkp
, png_realloc_array(png_ptr
,
1385 info_ptr
->unknown_chunks
, info_ptr
->unknown_chunks_num
, num_unknowns
,
1390 png_chunk_report(png_ptr
, "too many unknown chunks",
1391 PNG_CHUNK_WRITE_ERROR
);
1396 png_free(png_ptr
, info_ptr
->unknown_chunks
);
1397 info_ptr
->unknown_chunks
= np
; /* safe because it is initialized */
1398 info_ptr
->free_me
|= PNG_FREE_UNKN
;
1400 np
+= info_ptr
->unknown_chunks_num
;
1402 /* Increment unknown_chunks_num each time round the loop to protect the
1403 * just-allocated chunk data.
1405 for (; num_unknowns
> 0; --num_unknowns
, ++unknowns
)
1407 memcpy(np
->name
, unknowns
->name
, (sizeof np
->name
));
1408 np
->name
[(sizeof np
->name
)-1] = '\0';
1409 np
->location
= check_location(png_ptr
, unknowns
->location
);
1411 if (unknowns
->size
== 0)
1419 np
->data
= png_voidcast(png_bytep
,
1420 png_malloc_base(png_ptr
, unknowns
->size
));
1422 if (np
->data
== NULL
)
1424 png_chunk_report(png_ptr
, "unknown chunk: out of memory",
1425 PNG_CHUNK_WRITE_ERROR
);
1426 /* But just skip storing the unknown chunk */
1430 memcpy(np
->data
, unknowns
->data
, unknowns
->size
);
1431 np
->size
= unknowns
->size
;
1434 /* These increments are skipped on out-of-memory for the data - the
1435 * unknown chunk entry gets overwritten if the png_chunk_report returns.
1436 * This is correct in the read case (the chunk is just dropped.)
1439 ++(info_ptr
->unknown_chunks_num
);
1444 png_set_unknown_chunk_location(png_const_structrp png_ptr
, png_inforp info_ptr
,
1445 int chunk
, int location
)
1447 /* This API is pretty pointless in 1.6.0 because the location can be set
1448 * before the call to png_set_unknown_chunks.
1450 * TODO: add a png_app_warning in 1.7
1452 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&& chunk
>= 0 &&
1453 chunk
< info_ptr
->unknown_chunks_num
)
1455 if ((location
& (PNG_HAVE_IHDR
|PNG_HAVE_PLTE
|PNG_AFTER_IDAT
)) == 0)
1457 png_app_error(png_ptr
, "invalid unknown chunk location");
1458 /* Fake out the pre 1.6.0 behavior: */
1459 if (((unsigned int)location
& PNG_HAVE_IDAT
) != 0) /* undocumented! */
1460 location
= PNG_AFTER_IDAT
;
1463 location
= PNG_HAVE_IHDR
; /* also undocumented */
1466 info_ptr
->unknown_chunks
[chunk
].location
=
1467 check_location(png_ptr
, location
);
1470 #endif /* STORE_UNKNOWN_CHUNKS */
1472 #ifdef PNG_MNG_FEATURES_SUPPORTED
1474 png_permit_mng_features (png_structrp png_ptr
, png_uint_32 mng_features
)
1476 png_debug(1, "in png_permit_mng_features");
1478 if (png_ptr
== NULL
)
1481 png_ptr
->mng_features_permitted
= mng_features
& PNG_ALL_MNG_FEATURES
;
1483 return png_ptr
->mng_features_permitted
;
1487 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
1489 add_one_chunk(png_bytep list
, unsigned int count
, png_const_bytep add
, int keep
)
1493 /* Utility function: update the 'keep' state of a chunk if it is already in
1494 * the list, otherwise add it to the list.
1496 for (i
=0; i
<count
; ++i
, list
+= 5)
1498 if (memcmp(list
, add
, 4) == 0)
1500 list
[4] = (png_byte
)keep
;
1506 if (keep
!= PNG_HANDLE_CHUNK_AS_DEFAULT
)
1509 memcpy(list
, add
, 4);
1510 list
[4] = (png_byte
)keep
;
1517 png_set_keep_unknown_chunks(png_structrp png_ptr
, int keep
,
1518 png_const_bytep chunk_list
, int num_chunks_in
)
1521 unsigned int num_chunks
, old_num_chunks
;
1523 if (png_ptr
== NULL
)
1526 if (keep
< 0 || keep
>= PNG_HANDLE_CHUNK_LAST
)
1528 png_app_error(png_ptr
, "png_set_keep_unknown_chunks: invalid keep");
1533 if (num_chunks_in
<= 0)
1535 png_ptr
->unknown_default
= keep
;
1537 /* '0' means just set the flags, so stop here */
1538 if (num_chunks_in
== 0)
1542 if (num_chunks_in
< 0)
1544 /* Ignore all unknown chunks and all chunks recognized by
1545 * libpng except for IHDR, PLTE, tRNS, IDAT, and IEND
1547 static const png_byte chunks_to_ignore
[] = {
1548 98, 75, 71, 68, '\0', /* bKGD */
1549 99, 72, 82, 77, '\0', /* cHRM */
1550 101, 88, 73, 102, '\0', /* eXIf */
1551 103, 65, 77, 65, '\0', /* gAMA */
1552 104, 73, 83, 84, '\0', /* hIST */
1553 105, 67, 67, 80, '\0', /* iCCP */
1554 105, 84, 88, 116, '\0', /* iTXt */
1555 111, 70, 70, 115, '\0', /* oFFs */
1556 112, 67, 65, 76, '\0', /* pCAL */
1557 112, 72, 89, 115, '\0', /* pHYs */
1558 115, 66, 73, 84, '\0', /* sBIT */
1559 115, 67, 65, 76, '\0', /* sCAL */
1560 115, 80, 76, 84, '\0', /* sPLT */
1561 115, 84, 69, 82, '\0', /* sTER */
1562 115, 82, 71, 66, '\0', /* sRGB */
1563 116, 69, 88, 116, '\0', /* tEXt */
1564 116, 73, 77, 69, '\0', /* tIME */
1565 122, 84, 88, 116, '\0' /* zTXt */
1568 chunk_list
= chunks_to_ignore
;
1569 num_chunks
= (unsigned int)/*SAFE*/(sizeof chunks_to_ignore
)/5U;
1572 else /* num_chunks_in > 0 */
1574 if (chunk_list
== NULL
)
1576 /* Prior to 1.6.0 this was silently ignored, now it is an app_error
1577 * which can be switched off.
1579 png_app_error(png_ptr
, "png_set_keep_unknown_chunks: no chunk list");
1584 num_chunks
= (unsigned int)num_chunks_in
;
1587 old_num_chunks
= png_ptr
->num_chunk_list
;
1588 if (png_ptr
->chunk_list
== NULL
)
1591 /* Since num_chunks is always restricted to UINT_MAX/5 this can't overflow.
1593 if (num_chunks
+ old_num_chunks
> UINT_MAX
/5)
1595 png_app_error(png_ptr
, "png_set_keep_unknown_chunks: too many chunks");
1600 /* If these chunks are being reset to the default then no more memory is
1601 * required because add_one_chunk above doesn't extend the list if the 'keep'
1602 * parameter is the default.
1606 new_list
= png_voidcast(png_bytep
, png_malloc(png_ptr
,
1607 5 * (num_chunks
+ old_num_chunks
)));
1609 if (old_num_chunks
> 0)
1610 memcpy(new_list
, png_ptr
->chunk_list
, 5*old_num_chunks
);
1613 else if (old_num_chunks
> 0)
1614 new_list
= png_ptr
->chunk_list
;
1619 /* Add the new chunks together with each one's handling code. If the chunk
1620 * already exists the code is updated, otherwise the chunk is added to the
1621 * end. (In libpng 1.6.0 order no longer matters because this code enforces
1622 * the earlier convention that the last setting is the one that is used.)
1624 if (new_list
!= NULL
)
1626 png_const_bytep inlist
;
1630 for (i
=0; i
<num_chunks
; ++i
)
1632 old_num_chunks
= add_one_chunk(new_list
, old_num_chunks
,
1633 chunk_list
+5*i
, keep
);
1636 /* Now remove any spurious 'default' entries. */
1638 for (i
=0, inlist
=outlist
=new_list
; i
<old_num_chunks
; ++i
, inlist
+= 5)
1642 if (outlist
!= inlist
)
1643 memcpy(outlist
, inlist
, 5);
1649 /* This means the application has removed all the specialized handling. */
1650 if (num_chunks
== 0)
1652 if (png_ptr
->chunk_list
!= new_list
)
1653 png_free(png_ptr
, new_list
);
1662 png_ptr
->num_chunk_list
= num_chunks
;
1664 if (png_ptr
->chunk_list
!= new_list
)
1666 if (png_ptr
->chunk_list
!= NULL
)
1667 png_free(png_ptr
, png_ptr
->chunk_list
);
1669 png_ptr
->chunk_list
= new_list
;
1674 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1676 png_set_read_user_chunk_fn(png_structrp png_ptr
, png_voidp user_chunk_ptr
,
1677 png_user_chunk_ptr read_user_chunk_fn
)
1679 png_debug(1, "in png_set_read_user_chunk_fn");
1681 if (png_ptr
== NULL
)
1684 png_ptr
->read_user_chunk_fn
= read_user_chunk_fn
;
1685 png_ptr
->user_chunk_ptr
= user_chunk_ptr
;
1689 #ifdef PNG_INFO_IMAGE_SUPPORTED
1691 png_set_rows(png_const_structrp png_ptr
, png_inforp info_ptr
,
1692 png_bytepp row_pointers
)
1694 png_debug1(1, "in %s storage function", "rows");
1696 if (png_ptr
== NULL
|| info_ptr
== NULL
)
1699 if (info_ptr
->row_pointers
!= NULL
&&
1700 (info_ptr
->row_pointers
!= row_pointers
))
1701 png_free_data(png_ptr
, info_ptr
, PNG_FREE_ROWS
, 0);
1703 info_ptr
->row_pointers
= row_pointers
;
1705 if (row_pointers
!= NULL
)
1706 info_ptr
->valid
|= PNG_INFO_IDAT
;
1711 png_set_compression_buffer_size(png_structrp png_ptr
, size_t size
)
1713 if (png_ptr
== NULL
)
1716 if (size
== 0 || size
> PNG_UINT_31_MAX
)
1717 png_error(png_ptr
, "invalid compression buffer size");
1719 # ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1720 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) != 0)
1722 png_ptr
->IDAT_read_size
= (png_uint_32
)size
; /* checked above */
1727 # ifdef PNG_WRITE_SUPPORTED
1728 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) == 0)
1730 if (png_ptr
->zowner
!= 0)
1732 png_warning(png_ptr
,
1733 "Compression buffer size cannot be changed because it is in use");
1738 #ifndef __COVERITY__
1739 /* Some compilers complain that this is always false. However, it
1740 * can be true when integer overflow happens.
1742 if (size
> ZLIB_IO_MAX
)
1744 png_warning(png_ptr
,
1745 "Compression buffer size limited to system maximum");
1746 size
= ZLIB_IO_MAX
; /* must fit */
1752 /* Deflate will potentially go into an infinite loop on a SYNC_FLUSH
1753 * if this is permitted.
1755 png_warning(png_ptr
,
1756 "Compression buffer size cannot be reduced below 6");
1761 if (png_ptr
->zbuffer_size
!= size
)
1763 png_free_buffer_list(png_ptr
, &png_ptr
->zbuffer_list
);
1764 png_ptr
->zbuffer_size
= (uInt
)size
;
1771 png_set_invalid(png_const_structrp png_ptr
, png_inforp info_ptr
, int mask
)
1773 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1774 info_ptr
->valid
&= (unsigned int)(~mask
);
1778 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
1779 /* This function was added to libpng 1.2.6 */
1781 png_set_user_limits (png_structrp png_ptr
, png_uint_32 user_width_max
,
1782 png_uint_32 user_height_max
)
1784 /* Images with dimensions larger than these limits will be
1785 * rejected by png_set_IHDR(). To accept any PNG datastream
1786 * regardless of dimensions, set both limits to 0x7fffffff.
1788 if (png_ptr
== NULL
)
1791 png_ptr
->user_width_max
= user_width_max
;
1792 png_ptr
->user_height_max
= user_height_max
;
1795 /* This function was added to libpng 1.4.0 */
1797 png_set_chunk_cache_max (png_structrp png_ptr
, png_uint_32 user_chunk_cache_max
)
1799 if (png_ptr
!= NULL
)
1800 png_ptr
->user_chunk_cache_max
= user_chunk_cache_max
;
1803 /* This function was added to libpng 1.4.1 */
1805 png_set_chunk_malloc_max (png_structrp png_ptr
,
1806 png_alloc_size_t user_chunk_malloc_max
)
1808 if (png_ptr
!= NULL
)
1809 png_ptr
->user_chunk_malloc_max
= user_chunk_malloc_max
;
1811 #endif /* ?SET_USER_LIMITS */
1814 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
1816 png_set_benign_errors(png_structrp png_ptr
, int allowed
)
1818 png_debug(1, "in png_set_benign_errors");
1820 /* If allowed is 1, png_benign_error() is treated as a warning.
1822 * If allowed is 0, png_benign_error() is treated as an error (which
1823 * is the default behavior if png_set_benign_errors() is not called).
1827 png_ptr
->flags
|= PNG_FLAG_BENIGN_ERRORS_WARN
|
1828 PNG_FLAG_APP_WARNINGS_WARN
| PNG_FLAG_APP_ERRORS_WARN
;
1831 png_ptr
->flags
&= ~(PNG_FLAG_BENIGN_ERRORS_WARN
|
1832 PNG_FLAG_APP_WARNINGS_WARN
| PNG_FLAG_APP_ERRORS_WARN
);
1834 #endif /* BENIGN_ERRORS */
1836 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
1837 /* Whether to report invalid palette index; added at libng-1.5.10.
1838 * It is possible for an indexed (color-type==3) PNG file to contain
1839 * pixels with invalid (out-of-range) indexes if the PLTE chunk has
1840 * fewer entries than the image's bit-depth would allow. We recover
1841 * from this gracefully by filling any incomplete palette with zeros
1842 * (opaque black). By default, when this occurs libpng will issue
1843 * a benign error. This API can be used to override that behavior.
1846 png_set_check_for_invalid_index(png_structrp png_ptr
, int allowed
)
1848 png_debug(1, "in png_set_check_for_invalid_index");
1851 png_ptr
->num_palette_max
= 0;
1854 png_ptr
->num_palette_max
= -1;
1858 #if defined(PNG_TEXT_SUPPORTED) || defined(PNG_pCAL_SUPPORTED) || \
1859 defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED)
1860 /* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
1861 * and if invalid, correct the keyword rather than discarding the entire
1862 * chunk. The PNG 1.0 specification requires keywords 1-79 characters in
1863 * length, forbids leading or trailing whitespace, multiple internal spaces,
1864 * and the non-break space (0x80) from ISO 8859-1. Returns keyword length.
1866 * The 'new_key' buffer must be 80 characters in size (for the keyword plus a
1867 * trailing '\0'). If this routine returns 0 then there was no keyword, or a
1868 * valid one could not be generated, and the caller must png_error.
1870 png_uint_32
/* PRIVATE */
1871 png_check_keyword(png_structrp png_ptr
, png_const_charp key
, png_bytep new_key
)
1873 #ifdef PNG_WARNINGS_SUPPORTED
1874 png_const_charp orig_key
= key
;
1876 png_uint_32 key_len
= 0;
1877 int bad_character
= 0;
1880 png_debug(1, "in png_check_keyword");
1888 while (*key
&& key_len
< 79)
1890 png_byte ch
= (png_byte
)*key
++;
1892 if ((ch
> 32 && ch
<= 126) || (ch
>= 161 /*&& ch <= 255*/))
1894 *new_key
++ = ch
; ++key_len
; space
= 0;
1897 else if (space
== 0)
1899 /* A space or an invalid character when one wasn't seen immediately
1900 * before; output just a space.
1902 *new_key
++ = 32; ++key_len
; space
= 1;
1904 /* If the character was not a space then it is invalid. */
1909 else if (bad_character
== 0)
1910 bad_character
= ch
; /* just skip it, record the first error */
1913 if (key_len
> 0 && space
!= 0) /* trailing space */
1915 --key_len
; --new_key
;
1916 if (bad_character
== 0)
1920 /* Terminate the keyword */
1926 #ifdef PNG_WARNINGS_SUPPORTED
1927 /* Try to only output one warning per keyword: */
1928 if (*key
!= 0) /* keyword too long */
1929 png_warning(png_ptr
, "keyword truncated");
1931 else if (bad_character
!= 0)
1933 PNG_WARNING_PARAMETERS(p
)
1935 png_warning_parameter(p
, 1, orig_key
);
1936 png_warning_parameter_signed(p
, 2, PNG_NUMBER_FORMAT_02x
, bad_character
);
1938 png_formatted_warning(png_ptr
, p
, "keyword \"@1\": bad character '0x@2'");
1940 #else /* !WARNINGS */
1942 #endif /* !WARNINGS */
1946 #endif /* TEXT || pCAL || iCCP || sPLT */
1947 #endif /* READ || WRITE */