projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
- Merge aicom-network-fixes up to r36740
[reactos.git] / rosapps / lib / libpng / pngset.c
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)
22 void PNGAPI
23 png_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
36 void PNGAPI
37 png_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
92 void PNGAPI
93 png_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
156 void PNGAPI
157 png_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
181 void PNGAPI
182 png_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)
219 void PNGAPI
220 png_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
261 void PNGAPI
262 png_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)
370 void PNGAPI
371 png_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)
386 void PNGAPI
387 png_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
456 void PNGAPI
457 png_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
472 void PNGAPI
473 png_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)
515 void PNGAPI
516 png_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
530 void PNGAPI
531 png_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)
580 void PNGAPI
581 png_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)
594 void PNGAPI
595 png_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
605 void PNGAPI
606 png_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)
677 void PNGAPI
678 png_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)
723 void PNGAPI
724 png_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
733 int /* PRIVATE */
734 png_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)
894 void PNGAPI
895 png_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)
908 void PNGAPI
909 png_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)
951 void PNGAPI
952 png_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)
1013 void PNGAPI
1014 png_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 }
1070 void PNGAPI
1071 png_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)
1083 void PNGAPI
1084 png_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)
1099 png_uint_32 PNGAPI
1100 png_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)
1112 void PNGAPI
1113 png_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)
1158 void PNGAPI
1159 png_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)
1171 void PNGAPI
1172 png_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
1188 void PNGAPI
1189 png_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
1202 void PNGAPI
1203 png_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 */
1213 void PNGAPI
1214 png_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 */
1222 void PNGAPI
1223 png_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 */
1235 void PNGAPI
1236 png_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 */
A free Windows-compatible Operating System