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