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