2 /* pngset.c - storage of image information into info struct
4 * Last changed in libpng 1.5.5 [September 22, 2011]
5 * Copyright (c) 1998-2011 Glenn Randers-Pehrson
6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
9 * This code is released under the libpng license.
10 * For conditions of distribution and use, see the disclaimer
11 * and license in png.h
13 * The functions here are used during reads to store data from the file
14 * into the info struct, and during writes to store application data
15 * into the info struct for writing into the file. This abstracts the
16 * info struct and allows us to change the structure in the future.
21 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
23 #ifdef PNG_bKGD_SUPPORTED
25 png_set_bKGD(png_structp png_ptr
, png_infop 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
)
33 png_memcpy(&(info_ptr
->background
), background
, png_sizeof(png_color_16
));
34 info_ptr
->valid
|= PNG_INFO_bKGD
;
38 #ifdef PNG_cHRM_SUPPORTED
40 png_set_cHRM_fixed(png_structp png_ptr
, png_infop 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
)
45 png_debug1(1, "in %s storage function", "cHRM fixed");
47 if (png_ptr
== NULL
|| info_ptr
== NULL
)
50 # ifdef PNG_CHECK_cHRM_SUPPORTED
51 if (png_check_cHRM_fixed(png_ptr
,
52 white_x
, white_y
, red_x
, red_y
, green_x
, green_y
, blue_x
, blue_y
))
55 info_ptr
->x_white
= white_x
;
56 info_ptr
->y_white
= white_y
;
57 info_ptr
->x_red
= red_x
;
58 info_ptr
->y_red
= red_y
;
59 info_ptr
->x_green
= green_x
;
60 info_ptr
->y_green
= green_y
;
61 info_ptr
->x_blue
= blue_x
;
62 info_ptr
->y_blue
= blue_y
;
63 info_ptr
->valid
|= PNG_INFO_cHRM
;
68 png_set_cHRM_XYZ_fixed(png_structp png_ptr
, png_infop info_ptr
,
69 png_fixed_point int_red_X
, png_fixed_point int_red_Y
,
70 png_fixed_point int_red_Z
, png_fixed_point int_green_X
,
71 png_fixed_point int_green_Y
, png_fixed_point int_green_Z
,
72 png_fixed_point int_blue_X
, png_fixed_point int_blue_Y
,
73 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
)
86 XYZ
.greenX
= int_green_X
;
87 XYZ
.greenY
= int_green_Y
;
88 XYZ
.greenZ
= int_green_Z
;
89 XYZ
.blueX
= int_blue_X
;
90 XYZ
.blueY
= int_blue_Y
;
91 XYZ
.blueZ
= int_blue_Z
;
93 if (png_xy_from_XYZ(&xy
, XYZ
))
94 png_error(png_ptr
, "XYZ values out of representable range");
96 png_set_cHRM_fixed(png_ptr
, info_ptr
, xy
.whitex
, xy
.whitey
, xy
.redx
, xy
.redy
,
97 xy
.greenx
, xy
.greeny
, xy
.bluex
, xy
.bluey
);
100 # ifdef PNG_FLOATING_POINT_SUPPORTED
102 png_set_cHRM(png_structp png_ptr
, png_infop 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_structp png_ptr
, png_infop info_ptr
, double red_X
,
119 double red_Y
, double red_Z
, double green_X
, double green_Y
, double green_Z
,
120 double blue_X
, double blue_Y
, double blue_Z
)
122 png_set_cHRM_XYZ_fixed(png_ptr
, info_ptr
,
123 png_fixed(png_ptr
, red_X
, "cHRM Red X"),
124 png_fixed(png_ptr
, red_Y
, "cHRM Red Y"),
125 png_fixed(png_ptr
, red_Z
, "cHRM Red Z"),
126 png_fixed(png_ptr
, green_X
, "cHRM Red X"),
127 png_fixed(png_ptr
, green_Y
, "cHRM Red Y"),
128 png_fixed(png_ptr
, green_Z
, "cHRM Red Z"),
129 png_fixed(png_ptr
, blue_X
, "cHRM Red X"),
130 png_fixed(png_ptr
, blue_Y
, "cHRM Red Y"),
131 png_fixed(png_ptr
, blue_Z
, "cHRM Red Z"));
133 # endif /* PNG_FLOATING_POINT_SUPPORTED */
135 #endif /* PNG_cHRM_SUPPORTED */
137 #ifdef PNG_gAMA_SUPPORTED
139 png_set_gAMA_fixed(png_structp png_ptr
, png_infop info_ptr
, png_fixed_point
142 png_debug1(1, "in %s storage function", "gAMA");
144 if (png_ptr
== NULL
|| info_ptr
== NULL
)
147 /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't
148 * occur. Since the fixed point representation is assymetrical it is
149 * possible for 1/gamma to overflow the limit of 21474 and this means the
150 * gamma value must be at least 5/100000 and hence at most 20000.0. For
151 * safety the limits here are a little narrower. The values are 0.00016 to
152 * 6250.0, which are truly ridiculous gammma values (and will produce
153 * displays that are all black or all white.)
155 if (file_gamma
< 16 || file_gamma
> 625000000)
156 png_warning(png_ptr
, "Out of range gamma value ignored");
160 info_ptr
->gamma
= file_gamma
;
161 info_ptr
->valid
|= PNG_INFO_gAMA
;
165 # ifdef PNG_FLOATING_POINT_SUPPORTED
167 png_set_gAMA(png_structp png_ptr
, png_infop info_ptr
, double file_gamma
)
169 png_set_gAMA_fixed(png_ptr
, info_ptr
, png_fixed(png_ptr
, file_gamma
,
175 #ifdef PNG_hIST_SUPPORTED
177 png_set_hIST(png_structp png_ptr
, png_infop info_ptr
, png_const_uint_16p hist
)
181 png_debug1(1, "in %s storage function", "hIST");
183 if (png_ptr
== NULL
|| info_ptr
== NULL
)
186 if (info_ptr
->num_palette
== 0 || info_ptr
->num_palette
187 > PNG_MAX_PALETTE_LENGTH
)
190 "Invalid palette size, hIST allocation skipped");
195 png_free_data(png_ptr
, info_ptr
, PNG_FREE_HIST
, 0);
197 /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
200 png_ptr
->hist
= (png_uint_16p
)png_malloc_warn(png_ptr
,
201 PNG_MAX_PALETTE_LENGTH
* png_sizeof(png_uint_16
));
203 if (png_ptr
->hist
== NULL
)
205 png_warning(png_ptr
, "Insufficient memory for hIST chunk data");
209 for (i
= 0; i
< info_ptr
->num_palette
; i
++)
210 png_ptr
->hist
[i
] = hist
[i
];
212 info_ptr
->hist
= png_ptr
->hist
;
213 info_ptr
->valid
|= PNG_INFO_hIST
;
214 info_ptr
->free_me
|= PNG_FREE_HIST
;
219 png_set_IHDR(png_structp png_ptr
, png_infop info_ptr
,
220 png_uint_32 width
, png_uint_32 height
, int bit_depth
,
221 int color_type
, int interlace_type
, int compression_type
,
224 png_debug1(1, "in %s storage function", "IHDR");
226 if (png_ptr
== NULL
|| info_ptr
== NULL
)
229 info_ptr
->width
= width
;
230 info_ptr
->height
= height
;
231 info_ptr
->bit_depth
= (png_byte
)bit_depth
;
232 info_ptr
->color_type
= (png_byte
)color_type
;
233 info_ptr
->compression_type
= (png_byte
)compression_type
;
234 info_ptr
->filter_type
= (png_byte
)filter_type
;
235 info_ptr
->interlace_type
= (png_byte
)interlace_type
;
237 png_check_IHDR (png_ptr
, info_ptr
->width
, info_ptr
->height
,
238 info_ptr
->bit_depth
, info_ptr
->color_type
, info_ptr
->interlace_type
,
239 info_ptr
->compression_type
, info_ptr
->filter_type
);
241 if (info_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
242 info_ptr
->channels
= 1;
244 else if (info_ptr
->color_type
& PNG_COLOR_MASK_COLOR
)
245 info_ptr
->channels
= 3;
248 info_ptr
->channels
= 1;
250 if (info_ptr
->color_type
& PNG_COLOR_MASK_ALPHA
)
251 info_ptr
->channels
++;
253 info_ptr
->pixel_depth
= (png_byte
)(info_ptr
->channels
* info_ptr
->bit_depth
);
255 /* Check for potential overflow */
257 (PNG_UINT_32_MAX
>> 3) /* 8-byte RRGGBBAA pixels */
258 - 48 /* bigrowbuf hack */
259 - 1 /* filter byte */
260 - 7*8 /* rounding of width to multiple of 8 pixels */
261 - 8) /* extra max_pixel_depth pad */
262 info_ptr
->rowbytes
= 0;
264 info_ptr
->rowbytes
= PNG_ROWBYTES(info_ptr
->pixel_depth
, width
);
267 #ifdef PNG_oFFs_SUPPORTED
269 png_set_oFFs(png_structp png_ptr
, png_infop info_ptr
,
270 png_int_32 offset_x
, png_int_32 offset_y
, int unit_type
)
272 png_debug1(1, "in %s storage function", "oFFs");
274 if (png_ptr
== NULL
|| info_ptr
== NULL
)
277 info_ptr
->x_offset
= offset_x
;
278 info_ptr
->y_offset
= offset_y
;
279 info_ptr
->offset_unit_type
= (png_byte
)unit_type
;
280 info_ptr
->valid
|= PNG_INFO_oFFs
;
284 #ifdef PNG_pCAL_SUPPORTED
286 png_set_pCAL(png_structp png_ptr
, png_infop info_ptr
,
287 png_const_charp purpose
, png_int_32 X0
, png_int_32 X1
, int type
,
288 int nparams
, png_const_charp units
, png_charpp params
)
293 png_debug1(1, "in %s storage function", "pCAL");
295 if (png_ptr
== NULL
|| info_ptr
== NULL
)
298 length
= png_strlen(purpose
) + 1;
299 png_debug1(3, "allocating purpose for info (%lu bytes)",
300 (unsigned long)length
);
302 /* TODO: validate format of calibration name and unit name */
304 /* Check that the type matches the specification. */
305 if (type
< 0 || type
> 3)
306 png_error(png_ptr
, "Invalid pCAL equation type");
308 /* Validate params[nparams] */
309 for (i
=0; i
<nparams
; ++i
)
310 if (!png_check_fp_string(params
[i
], png_strlen(params
[i
])))
311 png_error(png_ptr
, "Invalid format for pCAL parameter");
313 info_ptr
->pcal_purpose
= (png_charp
)png_malloc_warn(png_ptr
, length
);
315 if (info_ptr
->pcal_purpose
== NULL
)
317 png_warning(png_ptr
, "Insufficient memory for pCAL purpose");
321 png_memcpy(info_ptr
->pcal_purpose
, purpose
, length
);
323 png_debug(3, "storing X0, X1, type, and nparams in info");
324 info_ptr
->pcal_X0
= X0
;
325 info_ptr
->pcal_X1
= X1
;
326 info_ptr
->pcal_type
= (png_byte
)type
;
327 info_ptr
->pcal_nparams
= (png_byte
)nparams
;
329 length
= png_strlen(units
) + 1;
330 png_debug1(3, "allocating units for info (%lu bytes)",
331 (unsigned long)length
);
333 info_ptr
->pcal_units
= (png_charp
)png_malloc_warn(png_ptr
, length
);
335 if (info_ptr
->pcal_units
== NULL
)
337 png_warning(png_ptr
, "Insufficient memory for pCAL units");
341 png_memcpy(info_ptr
->pcal_units
, units
, length
);
343 info_ptr
->pcal_params
= (png_charpp
)png_malloc_warn(png_ptr
,
344 (png_size_t
)((nparams
+ 1) * png_sizeof(png_charp
)));
346 if (info_ptr
->pcal_params
== NULL
)
348 png_warning(png_ptr
, "Insufficient memory for pCAL params");
352 png_memset(info_ptr
->pcal_params
, 0, (nparams
+ 1) * png_sizeof(png_charp
));
354 for (i
= 0; i
< nparams
; i
++)
356 length
= png_strlen(params
[i
]) + 1;
357 png_debug2(3, "allocating parameter %d for info (%lu bytes)", i
,
358 (unsigned long)length
);
360 info_ptr
->pcal_params
[i
] = (png_charp
)png_malloc_warn(png_ptr
, length
);
362 if (info_ptr
->pcal_params
[i
] == NULL
)
364 png_warning(png_ptr
, "Insufficient memory for pCAL parameter");
368 png_memcpy(info_ptr
->pcal_params
[i
], params
[i
], length
);
371 info_ptr
->valid
|= PNG_INFO_pCAL
;
372 info_ptr
->free_me
|= PNG_FREE_PCAL
;
376 #ifdef PNG_sCAL_SUPPORTED
378 png_set_sCAL_s(png_structp png_ptr
, png_infop info_ptr
,
379 int unit
, png_const_charp swidth
, png_const_charp sheight
)
381 png_size_t lengthw
= 0, lengthh
= 0;
383 png_debug1(1, "in %s storage function", "sCAL");
385 if (png_ptr
== NULL
|| info_ptr
== NULL
)
388 /* Double check the unit (should never get here with an invalid
389 * unit unless this is an API call.)
391 if (unit
!= 1 && unit
!= 2)
392 png_error(png_ptr
, "Invalid sCAL unit");
394 if (swidth
== NULL
|| (lengthw
= png_strlen(swidth
)) == 0 ||
395 swidth
[0] == 45 /* '-' */ || !png_check_fp_string(swidth
, lengthw
))
396 png_error(png_ptr
, "Invalid sCAL width");
398 if (sheight
== NULL
|| (lengthh
= png_strlen(sheight
)) == 0 ||
399 sheight
[0] == 45 /* '-' */ || !png_check_fp_string(sheight
, lengthh
))
400 png_error(png_ptr
, "Invalid sCAL height");
402 info_ptr
->scal_unit
= (png_byte
)unit
;
406 png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw
);
408 info_ptr
->scal_s_width
= (png_charp
)png_malloc_warn(png_ptr
, lengthw
);
410 if (info_ptr
->scal_s_width
== NULL
)
412 png_warning(png_ptr
, "Memory allocation failed while processing sCAL");
416 png_memcpy(info_ptr
->scal_s_width
, swidth
, lengthw
);
420 png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthh
);
422 info_ptr
->scal_s_height
= (png_charp
)png_malloc_warn(png_ptr
, lengthh
);
424 if (info_ptr
->scal_s_height
== NULL
)
426 png_free (png_ptr
, info_ptr
->scal_s_width
);
427 info_ptr
->scal_s_width
= NULL
;
429 png_warning(png_ptr
, "Memory allocation failed while processing sCAL");
433 png_memcpy(info_ptr
->scal_s_height
, sheight
, lengthh
);
435 info_ptr
->valid
|= PNG_INFO_sCAL
;
436 info_ptr
->free_me
|= PNG_FREE_SCAL
;
439 # ifdef PNG_FLOATING_POINT_SUPPORTED
441 png_set_sCAL(png_structp png_ptr
, png_infop info_ptr
, int unit
, double width
,
444 png_debug1(1, "in %s storage function", "sCAL");
446 /* Check the arguments. */
448 png_warning(png_ptr
, "Invalid sCAL width ignored");
450 else if (height
<= 0)
451 png_warning(png_ptr
, "Invalid sCAL height ignored");
455 /* Convert 'width' and 'height' to ASCII. */
456 char swidth
[PNG_sCAL_MAX_DIGITS
+1];
457 char sheight
[PNG_sCAL_MAX_DIGITS
+1];
459 png_ascii_from_fp(png_ptr
, swidth
, sizeof swidth
, width
,
461 png_ascii_from_fp(png_ptr
, sheight
, sizeof sheight
, height
,
464 png_set_sCAL_s(png_ptr
, info_ptr
, unit
, swidth
, sheight
);
469 # ifdef PNG_FIXED_POINT_SUPPORTED
471 png_set_sCAL_fixed(png_structp png_ptr
, png_infop info_ptr
, int unit
,
472 png_fixed_point width
, png_fixed_point height
)
474 png_debug1(1, "in %s storage function", "sCAL");
476 /* Check the arguments. */
478 png_warning(png_ptr
, "Invalid sCAL width ignored");
480 else if (height
<= 0)
481 png_warning(png_ptr
, "Invalid sCAL height ignored");
485 /* Convert 'width' and 'height' to ASCII. */
486 char swidth
[PNG_sCAL_MAX_DIGITS
+1];
487 char sheight
[PNG_sCAL_MAX_DIGITS
+1];
489 png_ascii_from_fixed(png_ptr
, swidth
, sizeof swidth
, width
);
490 png_ascii_from_fixed(png_ptr
, sheight
, sizeof sheight
, height
);
492 png_set_sCAL_s(png_ptr
, info_ptr
, unit
, swidth
, sheight
);
498 #ifdef PNG_pHYs_SUPPORTED
500 png_set_pHYs(png_structp png_ptr
, png_infop info_ptr
,
501 png_uint_32 res_x
, png_uint_32 res_y
, int unit_type
)
503 png_debug1(1, "in %s storage function", "pHYs");
505 if (png_ptr
== NULL
|| info_ptr
== NULL
)
508 info_ptr
->x_pixels_per_unit
= res_x
;
509 info_ptr
->y_pixels_per_unit
= res_y
;
510 info_ptr
->phys_unit_type
= (png_byte
)unit_type
;
511 info_ptr
->valid
|= PNG_INFO_pHYs
;
516 png_set_PLTE(png_structp png_ptr
, png_infop info_ptr
,
517 png_const_colorp palette
, int num_palette
)
520 png_debug1(1, "in %s storage function", "PLTE");
522 if (png_ptr
== NULL
|| info_ptr
== NULL
)
525 if (num_palette
< 0 || num_palette
> PNG_MAX_PALETTE_LENGTH
)
527 if (info_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
528 png_error(png_ptr
, "Invalid palette length");
532 png_warning(png_ptr
, "Invalid palette length");
537 /* It may not actually be necessary to set png_ptr->palette here;
538 * we do it for backward compatibility with the way the png_handle_tRNS
539 * function used to do the allocation.
541 png_free_data(png_ptr
, info_ptr
, PNG_FREE_PLTE
, 0);
543 /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
544 * of num_palette entries, in case of an invalid PNG file that has
545 * too-large sample values.
547 png_ptr
->palette
= (png_colorp
)png_calloc(png_ptr
,
548 PNG_MAX_PALETTE_LENGTH
* png_sizeof(png_color
));
550 png_memcpy(png_ptr
->palette
, palette
, num_palette
* png_sizeof(png_color
));
551 info_ptr
->palette
= png_ptr
->palette
;
552 info_ptr
->num_palette
= png_ptr
->num_palette
= (png_uint_16
)num_palette
;
554 info_ptr
->free_me
|= PNG_FREE_PLTE
;
556 info_ptr
->valid
|= PNG_INFO_PLTE
;
559 #ifdef PNG_sBIT_SUPPORTED
561 png_set_sBIT(png_structp png_ptr
, png_infop info_ptr
,
562 png_const_color_8p sig_bit
)
564 png_debug1(1, "in %s storage function", "sBIT");
566 if (png_ptr
== NULL
|| info_ptr
== NULL
)
569 png_memcpy(&(info_ptr
->sig_bit
), sig_bit
, png_sizeof(png_color_8
));
570 info_ptr
->valid
|= PNG_INFO_sBIT
;
574 #ifdef PNG_sRGB_SUPPORTED
576 png_set_sRGB(png_structp png_ptr
, png_infop info_ptr
, int srgb_intent
)
578 png_debug1(1, "in %s storage function", "sRGB");
580 if (png_ptr
== NULL
|| info_ptr
== NULL
)
583 info_ptr
->srgb_intent
= (png_byte
)srgb_intent
;
584 info_ptr
->valid
|= PNG_INFO_sRGB
;
588 png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr
, png_infop info_ptr
,
591 png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");
593 if (png_ptr
== NULL
|| info_ptr
== NULL
)
596 png_set_sRGB(png_ptr
, info_ptr
, srgb_intent
);
598 # ifdef PNG_gAMA_SUPPORTED
599 png_set_gAMA_fixed(png_ptr
, info_ptr
, PNG_GAMMA_sRGB_INVERSE
);
602 # ifdef PNG_cHRM_SUPPORTED
603 png_set_cHRM_fixed(png_ptr
, info_ptr
,
605 /* white */ 31270, 32900,
606 /* red */ 64000, 33000,
607 /* green */ 30000, 60000,
608 /* blue */ 15000, 6000
615 #ifdef PNG_iCCP_SUPPORTED
617 png_set_iCCP(png_structp png_ptr
, png_infop info_ptr
,
618 png_const_charp name
, int compression_type
,
619 png_const_bytep profile
, png_uint_32 proflen
)
621 png_charp new_iccp_name
;
622 png_bytep new_iccp_profile
;
625 png_debug1(1, "in %s storage function", "iCCP");
627 if (png_ptr
== NULL
|| info_ptr
== NULL
|| name
== NULL
|| profile
== NULL
)
630 length
= png_strlen(name
)+1;
631 new_iccp_name
= (png_charp
)png_malloc_warn(png_ptr
, length
);
633 if (new_iccp_name
== NULL
)
635 png_warning(png_ptr
, "Insufficient memory to process iCCP chunk");
639 png_memcpy(new_iccp_name
, name
, length
);
640 new_iccp_profile
= (png_bytep
)png_malloc_warn(png_ptr
, proflen
);
642 if (new_iccp_profile
== NULL
)
644 png_free (png_ptr
, new_iccp_name
);
646 "Insufficient memory to process iCCP profile");
650 png_memcpy(new_iccp_profile
, profile
, (png_size_t
)proflen
);
652 png_free_data(png_ptr
, info_ptr
, PNG_FREE_ICCP
, 0);
654 info_ptr
->iccp_proflen
= proflen
;
655 info_ptr
->iccp_name
= new_iccp_name
;
656 info_ptr
->iccp_profile
= new_iccp_profile
;
657 /* Compression is always zero but is here so the API and info structure
658 * does not have to change if we introduce multiple compression types
660 info_ptr
->iccp_compression
= (png_byte
)compression_type
;
661 info_ptr
->free_me
|= PNG_FREE_ICCP
;
662 info_ptr
->valid
|= PNG_INFO_iCCP
;
666 #ifdef PNG_TEXT_SUPPORTED
668 png_set_text(png_structp png_ptr
, png_infop info_ptr
, png_const_textp text_ptr
,
672 ret
= png_set_text_2(png_ptr
, info_ptr
, text_ptr
, num_text
);
675 png_error(png_ptr
, "Insufficient memory to store text");
679 png_set_text_2(png_structp png_ptr
, png_infop info_ptr
,
680 png_const_textp text_ptr
, int num_text
)
684 png_debug1(1, "in %s storage function", ((png_ptr
== NULL
||
685 png_ptr
->chunk_name
[0] == '\0') ?
686 "text" : (png_const_charp
)png_ptr
->chunk_name
));
688 if (png_ptr
== NULL
|| info_ptr
== NULL
|| num_text
== 0)
691 /* Make sure we have enough space in the "text" array in info_struct
692 * to hold all of the incoming text_ptr objects.
694 if (info_ptr
->num_text
+ num_text
> info_ptr
->max_text
)
696 if (info_ptr
->text
!= NULL
)
701 old_max
= info_ptr
->max_text
;
702 info_ptr
->max_text
= info_ptr
->num_text
+ num_text
+ 8;
703 old_text
= info_ptr
->text
;
704 info_ptr
->text
= (png_textp
)png_malloc_warn(png_ptr
,
705 (png_size_t
)(info_ptr
->max_text
* png_sizeof(png_text
)));
707 if (info_ptr
->text
== NULL
)
709 png_free(png_ptr
, old_text
);
713 png_memcpy(info_ptr
->text
, old_text
, (png_size_t
)(old_max
*
714 png_sizeof(png_text
)));
715 png_free(png_ptr
, old_text
);
720 info_ptr
->max_text
= num_text
+ 8;
721 info_ptr
->num_text
= 0;
722 info_ptr
->text
= (png_textp
)png_malloc_warn(png_ptr
,
723 (png_size_t
)(info_ptr
->max_text
* png_sizeof(png_text
)));
724 if (info_ptr
->text
== NULL
)
726 info_ptr
->free_me
|= PNG_FREE_TEXT
;
729 png_debug1(3, "allocated %d entries for info_ptr->text",
732 for (i
= 0; i
< num_text
; i
++)
734 png_size_t text_length
, key_len
;
735 png_size_t lang_len
, lang_key_len
;
736 png_textp textp
= &(info_ptr
->text
[info_ptr
->num_text
]);
738 if (text_ptr
[i
].key
== NULL
)
741 if (text_ptr
[i
].compression
< PNG_TEXT_COMPRESSION_NONE
||
742 text_ptr
[i
].compression
>= PNG_TEXT_COMPRESSION_LAST
)
744 png_warning(png_ptr
, "text compression mode is out of range");
748 key_len
= png_strlen(text_ptr
[i
].key
);
750 if (text_ptr
[i
].compression
<= 0)
757 # ifdef PNG_iTXt_SUPPORTED
761 if (text_ptr
[i
].lang
!= NULL
)
762 lang_len
= png_strlen(text_ptr
[i
].lang
);
767 if (text_ptr
[i
].lang_key
!= NULL
)
768 lang_key_len
= png_strlen(text_ptr
[i
].lang_key
);
773 # else /* PNG_iTXt_SUPPORTED */
775 png_warning(png_ptr
, "iTXt chunk not supported");
780 if (text_ptr
[i
].text
== NULL
|| text_ptr
[i
].text
[0] == '\0')
783 # ifdef PNG_iTXt_SUPPORTED
784 if (text_ptr
[i
].compression
> 0)
785 textp
->compression
= PNG_ITXT_COMPRESSION_NONE
;
789 textp
->compression
= PNG_TEXT_COMPRESSION_NONE
;
794 text_length
= png_strlen(text_ptr
[i
].text
);
795 textp
->compression
= text_ptr
[i
].compression
;
798 textp
->key
= (png_charp
)png_malloc_warn(png_ptr
,
800 (key_len
+ text_length
+ lang_len
+ lang_key_len
+ 4));
802 if (textp
->key
== NULL
)
805 png_debug2(2, "Allocated %lu bytes at %p in png_set_text",
806 (unsigned long)(png_uint_32
)
807 (key_len
+ lang_len
+ lang_key_len
+ text_length
+ 4),
810 png_memcpy(textp
->key
, text_ptr
[i
].key
,(png_size_t
)(key_len
));
811 *(textp
->key
+ key_len
) = '\0';
813 if (text_ptr
[i
].compression
> 0)
815 textp
->lang
= textp
->key
+ key_len
+ 1;
816 png_memcpy(textp
->lang
, text_ptr
[i
].lang
, lang_len
);
817 *(textp
->lang
+ lang_len
) = '\0';
818 textp
->lang_key
= textp
->lang
+ lang_len
+ 1;
819 png_memcpy(textp
->lang_key
, text_ptr
[i
].lang_key
, lang_key_len
);
820 *(textp
->lang_key
+ lang_key_len
) = '\0';
821 textp
->text
= textp
->lang_key
+ lang_key_len
+ 1;
827 textp
->lang_key
=NULL
;
828 textp
->text
= textp
->key
+ key_len
+ 1;
832 png_memcpy(textp
->text
, text_ptr
[i
].text
,
833 (png_size_t
)(text_length
));
835 *(textp
->text
+ text_length
) = '\0';
837 # ifdef PNG_iTXt_SUPPORTED
838 if (textp
->compression
> 0)
840 textp
->text_length
= 0;
841 textp
->itxt_length
= text_length
;
847 textp
->text_length
= text_length
;
848 textp
->itxt_length
= 0;
851 info_ptr
->num_text
++;
852 png_debug1(3, "transferred text chunk %d", info_ptr
->num_text
);
858 #ifdef PNG_tIME_SUPPORTED
860 png_set_tIME(png_structp png_ptr
, png_infop info_ptr
, png_const_timep mod_time
)
862 png_debug1(1, "in %s storage function", "tIME");
864 if (png_ptr
== NULL
|| info_ptr
== NULL
||
865 (png_ptr
->mode
& PNG_WROTE_tIME
))
868 png_memcpy(&(info_ptr
->mod_time
), mod_time
, png_sizeof(png_time
));
869 info_ptr
->valid
|= PNG_INFO_tIME
;
873 #ifdef PNG_tRNS_SUPPORTED
875 png_set_tRNS(png_structp png_ptr
, png_infop info_ptr
,
876 png_const_bytep trans_alpha
, int num_trans
, png_const_color_16p trans_color
)
878 png_debug1(1, "in %s storage function", "tRNS");
880 if (png_ptr
== NULL
|| info_ptr
== NULL
)
883 if (trans_alpha
!= NULL
)
885 /* It may not actually be necessary to set png_ptr->trans_alpha here;
886 * we do it for backward compatibility with the way the png_handle_tRNS
887 * function used to do the allocation.
890 png_free_data(png_ptr
, info_ptr
, PNG_FREE_TRNS
, 0);
892 /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
893 png_ptr
->trans_alpha
= info_ptr
->trans_alpha
=
894 (png_bytep
)png_malloc(png_ptr
, (png_size_t
)PNG_MAX_PALETTE_LENGTH
);
896 if (num_trans
> 0 && num_trans
<= PNG_MAX_PALETTE_LENGTH
)
897 png_memcpy(info_ptr
->trans_alpha
, trans_alpha
, (png_size_t
)num_trans
);
900 if (trans_color
!= NULL
)
902 int sample_max
= (1 << info_ptr
->bit_depth
);
904 if ((info_ptr
->color_type
== PNG_COLOR_TYPE_GRAY
&&
905 (int)trans_color
->gray
> sample_max
) ||
906 (info_ptr
->color_type
== PNG_COLOR_TYPE_RGB
&&
907 ((int)trans_color
->red
> sample_max
||
908 (int)trans_color
->green
> sample_max
||
909 (int)trans_color
->blue
> sample_max
)))
911 "tRNS chunk has out-of-range samples for bit_depth");
913 png_memcpy(&(info_ptr
->trans_color
), trans_color
,
914 png_sizeof(png_color_16
));
920 info_ptr
->num_trans
= (png_uint_16
)num_trans
;
924 info_ptr
->valid
|= PNG_INFO_tRNS
;
925 info_ptr
->free_me
|= PNG_FREE_TRNS
;
930 #ifdef PNG_sPLT_SUPPORTED
932 png_set_sPLT(png_structp png_ptr
,
933 png_infop info_ptr
, png_const_sPLT_tp entries
, int nentries
)
935 * entries - array of png_sPLT_t structures
936 * to be added to the list of palettes
937 * in the info structure.
939 * nentries - number of palette structures to be
946 if (png_ptr
== NULL
|| info_ptr
== NULL
)
949 np
= (png_sPLT_tp
)png_malloc_warn(png_ptr
,
950 (info_ptr
->splt_palettes_num
+ nentries
) *
951 (png_size_t
)png_sizeof(png_sPLT_t
));
955 png_warning(png_ptr
, "No memory for sPLT palettes");
959 png_memcpy(np
, info_ptr
->splt_palettes
,
960 info_ptr
->splt_palettes_num
* png_sizeof(png_sPLT_t
));
962 png_free(png_ptr
, info_ptr
->splt_palettes
);
963 info_ptr
->splt_palettes
=NULL
;
965 for (i
= 0; i
< nentries
; i
++)
967 png_sPLT_tp to
= np
+ info_ptr
->splt_palettes_num
+ i
;
968 png_const_sPLT_tp from
= entries
+ i
;
971 length
= png_strlen(from
->name
) + 1;
972 to
->name
= (png_charp
)png_malloc_warn(png_ptr
, length
);
974 if (to
->name
== NULL
)
977 "Out of memory while processing sPLT chunk");
981 png_memcpy(to
->name
, from
->name
, length
);
982 to
->entries
= (png_sPLT_entryp
)png_malloc_warn(png_ptr
,
983 from
->nentries
* png_sizeof(png_sPLT_entry
));
985 if (to
->entries
== NULL
)
988 "Out of memory while processing sPLT chunk");
989 png_free(png_ptr
, to
->name
);
994 png_memcpy(to
->entries
, from
->entries
,
995 from
->nentries
* png_sizeof(png_sPLT_entry
));
997 to
->nentries
= from
->nentries
;
998 to
->depth
= from
->depth
;
1001 info_ptr
->splt_palettes
= np
;
1002 info_ptr
->splt_palettes_num
+= nentries
;
1003 info_ptr
->valid
|= PNG_INFO_sPLT
;
1004 info_ptr
->free_me
|= PNG_FREE_SPLT
;
1006 #endif /* PNG_sPLT_SUPPORTED */
1008 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
1010 png_set_unknown_chunks(png_structp png_ptr
,
1011 png_infop info_ptr
, png_const_unknown_chunkp unknowns
, int num_unknowns
)
1013 png_unknown_chunkp np
;
1016 if (png_ptr
== NULL
|| info_ptr
== NULL
|| num_unknowns
== 0)
1019 np
= (png_unknown_chunkp
)png_malloc_warn(png_ptr
,
1020 (png_size_t
)(info_ptr
->unknown_chunks_num
+ num_unknowns
) *
1021 png_sizeof(png_unknown_chunk
));
1025 png_warning(png_ptr
,
1026 "Out of memory while processing unknown chunk");
1030 png_memcpy(np
, info_ptr
->unknown_chunks
,
1031 (png_size_t
)info_ptr
->unknown_chunks_num
*
1032 png_sizeof(png_unknown_chunk
));
1034 png_free(png_ptr
, info_ptr
->unknown_chunks
);
1035 info_ptr
->unknown_chunks
= NULL
;
1037 for (i
= 0; i
< num_unknowns
; i
++)
1039 png_unknown_chunkp to
= np
+ info_ptr
->unknown_chunks_num
+ i
;
1040 png_const_unknown_chunkp from
= unknowns
+ i
;
1042 png_memcpy(to
->name
, from
->name
, png_sizeof(from
->name
));
1043 to
->name
[png_sizeof(to
->name
)-1] = '\0';
1044 to
->size
= from
->size
;
1046 /* Note our location in the read or write sequence */
1047 to
->location
= (png_byte
)(png_ptr
->mode
& 0xff);
1049 if (from
->size
== 0)
1054 to
->data
= (png_bytep
)png_malloc_warn(png_ptr
,
1055 (png_size_t
)from
->size
);
1057 if (to
->data
== NULL
)
1059 png_warning(png_ptr
,
1060 "Out of memory while processing unknown chunk");
1065 png_memcpy(to
->data
, from
->data
, from
->size
);
1069 info_ptr
->unknown_chunks
= np
;
1070 info_ptr
->unknown_chunks_num
+= num_unknowns
;
1071 info_ptr
->free_me
|= PNG_FREE_UNKN
;
1075 png_set_unknown_chunk_location(png_structp png_ptr
, png_infop info_ptr
,
1076 int chunk
, int location
)
1078 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&& chunk
>= 0 && chunk
<
1079 info_ptr
->unknown_chunks_num
)
1080 info_ptr
->unknown_chunks
[chunk
].location
= (png_byte
)location
;
1085 #ifdef PNG_MNG_FEATURES_SUPPORTED
1087 png_permit_mng_features (png_structp png_ptr
, png_uint_32 mng_features
)
1089 png_debug(1, "in png_permit_mng_features");
1091 if (png_ptr
== NULL
)
1092 return (png_uint_32
)0;
1094 png_ptr
->mng_features_permitted
=
1095 (png_byte
)(mng_features
& PNG_ALL_MNG_FEATURES
);
1097 return (png_uint_32
)png_ptr
->mng_features_permitted
;
1101 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
1103 png_set_keep_unknown_chunks(png_structp png_ptr
, int keep
, png_const_bytep
1104 chunk_list
, int num_chunks
)
1106 png_bytep new_list
, p
;
1107 int i
, old_num_chunks
;
1108 if (png_ptr
== NULL
)
1111 if (num_chunks
== 0)
1113 if (keep
== PNG_HANDLE_CHUNK_ALWAYS
|| keep
== PNG_HANDLE_CHUNK_IF_SAFE
)
1114 png_ptr
->flags
|= PNG_FLAG_KEEP_UNKNOWN_CHUNKS
;
1117 png_ptr
->flags
&= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS
;
1119 if (keep
== PNG_HANDLE_CHUNK_ALWAYS
)
1120 png_ptr
->flags
|= PNG_FLAG_KEEP_UNSAFE_CHUNKS
;
1123 png_ptr
->flags
&= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS
;
1128 if (chunk_list
== NULL
)
1131 old_num_chunks
= png_ptr
->num_chunk_list
;
1132 new_list
=(png_bytep
)png_malloc(png_ptr
,
1133 (png_size_t
)(5*(num_chunks
+ old_num_chunks
)));
1135 if (png_ptr
->chunk_list
!= NULL
)
1137 png_memcpy(new_list
, png_ptr
->chunk_list
,
1138 (png_size_t
)(5*old_num_chunks
));
1139 png_free(png_ptr
, png_ptr
->chunk_list
);
1140 png_ptr
->chunk_list
=NULL
;
1143 png_memcpy(new_list
+ 5*old_num_chunks
, chunk_list
,
1144 (png_size_t
)(5*num_chunks
));
1146 for (p
= new_list
+ 5*old_num_chunks
+ 4, i
= 0; i
<num_chunks
; i
++, p
+= 5)
1149 png_ptr
->num_chunk_list
= old_num_chunks
+ num_chunks
;
1150 png_ptr
->chunk_list
= new_list
;
1151 png_ptr
->free_me
|= PNG_FREE_LIST
;
1155 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1157 png_set_read_user_chunk_fn(png_structp png_ptr
, png_voidp user_chunk_ptr
,
1158 png_user_chunk_ptr read_user_chunk_fn
)
1160 png_debug(1, "in png_set_read_user_chunk_fn");
1162 if (png_ptr
== NULL
)
1165 png_ptr
->read_user_chunk_fn
= read_user_chunk_fn
;
1166 png_ptr
->user_chunk_ptr
= user_chunk_ptr
;
1170 #ifdef PNG_INFO_IMAGE_SUPPORTED
1172 png_set_rows(png_structp png_ptr
, png_infop info_ptr
, png_bytepp row_pointers
)
1174 png_debug1(1, "in %s storage function", "rows");
1176 if (png_ptr
== NULL
|| info_ptr
== NULL
)
1179 if (info_ptr
->row_pointers
&& (info_ptr
->row_pointers
!= row_pointers
))
1180 png_free_data(png_ptr
, info_ptr
, PNG_FREE_ROWS
, 0);
1182 info_ptr
->row_pointers
= row_pointers
;
1185 info_ptr
->valid
|= PNG_INFO_IDAT
;
1190 png_set_compression_buffer_size(png_structp png_ptr
, png_size_t size
)
1192 if (png_ptr
== NULL
)
1195 png_free(png_ptr
, png_ptr
->zbuf
);
1197 if (size
> ZLIB_IO_MAX
)
1199 png_warning(png_ptr
, "Attempt to set buffer size beyond max ignored");
1200 png_ptr
->zbuf_size
= ZLIB_IO_MAX
;
1201 size
= ZLIB_IO_MAX
; /* must fit */
1205 png_ptr
->zbuf_size
= (uInt
)size
;
1207 png_ptr
->zbuf
= (png_bytep
)png_malloc(png_ptr
, size
);
1209 /* The following ensures a relatively safe failure if this gets called while
1210 * the buffer is actually in use.
1212 png_ptr
->zstream
.next_out
= png_ptr
->zbuf
;
1213 png_ptr
->zstream
.avail_out
= 0;
1214 png_ptr
->zstream
.avail_in
= 0;
1218 png_set_invalid(png_structp png_ptr
, png_infop info_ptr
, int mask
)
1220 if (png_ptr
&& info_ptr
)
1221 info_ptr
->valid
&= ~mask
;
1226 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
1227 /* This function was added to libpng 1.2.6 */
1229 png_set_user_limits (png_structp png_ptr
, png_uint_32 user_width_max
,
1230 png_uint_32 user_height_max
)
1232 /* Images with dimensions larger than these limits will be
1233 * rejected by png_set_IHDR(). To accept any PNG datastream
1234 * regardless of dimensions, set both limits to 0x7ffffffL.
1236 if (png_ptr
== NULL
)
1239 png_ptr
->user_width_max
= user_width_max
;
1240 png_ptr
->user_height_max
= user_height_max
;
1243 /* This function was added to libpng 1.4.0 */
1245 png_set_chunk_cache_max (png_structp png_ptr
,
1246 png_uint_32 user_chunk_cache_max
)
1249 png_ptr
->user_chunk_cache_max
= user_chunk_cache_max
;
1252 /* This function was added to libpng 1.4.1 */
1254 png_set_chunk_malloc_max (png_structp png_ptr
,
1255 png_alloc_size_t user_chunk_malloc_max
)
1258 png_ptr
->user_chunk_malloc_max
= user_chunk_malloc_max
;
1260 #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
1263 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
1265 png_set_benign_errors(png_structp png_ptr
, int allowed
)
1267 png_debug(1, "in png_set_benign_errors");
1270 png_ptr
->flags
|= PNG_FLAG_BENIGN_ERRORS_WARN
;
1273 png_ptr
->flags
&= ~PNG_FLAG_BENIGN_ERRORS_WARN
;
1275 #endif /* PNG_BENIGN_ERRORS_SUPPORTED */
1276 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */