/[zanavi_public1]/navit/navit/support/libpng/pngget.c
ZANavi

Contents of /navit/navit/support/libpng/pngget.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2 - (show annotations) (download)
Fri Oct 28 21:19:04 2011 UTC (12 years, 5 months ago) by zoff99
File MIME type: text/plain
File size: 24738 byte(s) 
import files
1
2 /* pngget.c - retrieval of values from info struct
3 *
4 * Last changed in libpng 1.2.30 [August 15, 2008]
5 * For conditions of distribution and use, see copyright notice in png.h
6 * Copyright (c) 1998-2008 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
11 #define PNG_INTERNAL
12 #include "png.h"
13 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
14
15 png_uint_32 PNGAPI
16 png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
17 {
18 if (png_ptr != NULL && info_ptr != NULL)
19 return(info_ptr->valid & flag);
20 else
21 return(0);
22 }
23
24 png_uint_32 PNGAPI
25 png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
26 {
27 if (png_ptr != NULL && info_ptr != NULL)
28 return(info_ptr->rowbytes);
29 else
30 return(0);
31 }
32
33 #if defined(PNG_INFO_IMAGE_SUPPORTED)
34 png_bytepp PNGAPI
35 png_get_rows(png_structp png_ptr, png_infop info_ptr)
36 {
37 if (png_ptr != NULL && info_ptr != NULL)
38 return(info_ptr->row_pointers);
39 else
40 return(0);
41 }
42 #endif
43
44 #ifdef PNG_EASY_ACCESS_SUPPORTED
45 /* easy access to info, added in libpng-0.99 */
46 png_uint_32 PNGAPI
47 png_get_image_width(png_structp png_ptr, png_infop info_ptr)
48 {
49 if (png_ptr != NULL && info_ptr != NULL)
50 {
51 return info_ptr->width;
52 }
53 return (0);
54 }
55
56 png_uint_32 PNGAPI
57 png_get_image_height(png_structp png_ptr, png_infop info_ptr)
58 {
59 if (png_ptr != NULL && info_ptr != NULL)
60 {
61 return info_ptr->height;
62 }
63 return (0);
64 }
65
66 png_byte PNGAPI
67 png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
68 {
69 if (png_ptr != NULL && info_ptr != NULL)
70 {
71 return info_ptr->bit_depth;
72 }
73 return (0);
74 }
75
76 png_byte PNGAPI
77 png_get_color_type(png_structp png_ptr, png_infop info_ptr)
78 {
79 if (png_ptr != NULL && info_ptr != NULL)
80 {
81 return info_ptr->color_type;
82 }
83 return (0);
84 }
85
86 png_byte PNGAPI
87 png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
88 {
89 if (png_ptr != NULL && info_ptr != NULL)
90 {
91 return info_ptr->filter_type;
92 }
93 return (0);
94 }
95
96 png_byte PNGAPI
97 png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
98 {
99 if (png_ptr != NULL && info_ptr != NULL)
100 {
101 return info_ptr->interlace_type;
102 }
103 return (0);
104 }
105
106 png_byte PNGAPI
107 png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
108 {
109 if (png_ptr != NULL && info_ptr != NULL)
110 {
111 return info_ptr->compression_type;
112 }
113 return (0);
114 }
115
116 png_uint_32 PNGAPI
117 png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
118 {
119 if (png_ptr != NULL && info_ptr != NULL)
120 #if defined(PNG_pHYs_SUPPORTED)
121 if (info_ptr->valid & PNG_INFO_pHYs)
122 {
123 png_debug1(1, "in %s retrieval function", "png_get_x_pixels_per_meter");
124 if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
125 return (0);
126 else return (info_ptr->x_pixels_per_unit);
127 }
128 #else
129 return (0);
130 #endif
131 return (0);
132 }
133
134 png_uint_32 PNGAPI
135 png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
136 {
137 if (png_ptr != NULL && info_ptr != NULL)
138 #if defined(PNG_pHYs_SUPPORTED)
139 if (info_ptr->valid & PNG_INFO_pHYs)
140 {
141 png_debug1(1, "in %s retrieval function", "png_get_y_pixels_per_meter");
142 if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
143 return (0);
144 else return (info_ptr->y_pixels_per_unit);
145 }
146 #else
147 return (0);
148 #endif
149 return (0);
150 }
151
152 png_uint_32 PNGAPI
153 png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
154 {
155 if (png_ptr != NULL && info_ptr != NULL)
156 #if defined(PNG_pHYs_SUPPORTED)
157 if (info_ptr->valid & PNG_INFO_pHYs)
158 {
159 png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
160 if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
161 info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
162 return (0);
163 else return (info_ptr->x_pixels_per_unit);
164 }
165 #else
166 return (0);
167 #endif
168 return (0);
169 }
170
171 #ifdef PNG_FLOATING_POINT_SUPPORTED
172 float PNGAPI
173 png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
174 {
175 if (png_ptr != NULL && info_ptr != NULL)
176 #if defined(PNG_pHYs_SUPPORTED)
177 if (info_ptr->valid & PNG_INFO_pHYs)
178 {
179 png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
180 if (info_ptr->x_pixels_per_unit == 0)
181 return ((float)0.0);
182 else
183 return ((float)((float)info_ptr->y_pixels_per_unit
184 /(float)info_ptr->x_pixels_per_unit));
185 }
186 #else
187 return (0.0);
188 #endif
189 return ((float)0.0);
190 }
191 #endif
192
193 png_int_32 PNGAPI
194 png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
195 {
196 if (png_ptr != NULL && info_ptr != NULL)
197 #if defined(PNG_oFFs_SUPPORTED)
198 if (info_ptr->valid & PNG_INFO_oFFs)
199 {
200 png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
201 if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
202 return (0);
203 else return (info_ptr->x_offset);
204 }
205 #else
206 return (0);
207 #endif
208 return (0);
209 }
210
211 png_int_32 PNGAPI
212 png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
213 {
214 if (png_ptr != NULL && info_ptr != NULL)
215 #if defined(PNG_oFFs_SUPPORTED)
216 if (info_ptr->valid & PNG_INFO_oFFs)
217 {
218 png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
219 if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
220 return (0);
221 else return (info_ptr->y_offset);
222 }
223 #else
224 return (0);
225 #endif
226 return (0);
227 }
228
229 png_int_32 PNGAPI
230 png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
231 {
232 if (png_ptr != NULL && info_ptr != NULL)
233 #if defined(PNG_oFFs_SUPPORTED)
234 if (info_ptr->valid & PNG_INFO_oFFs)
235 {
236 png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
237 if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
238 return (0);
239 else return (info_ptr->x_offset);
240 }
241 #else
242 return (0);
243 #endif
244 return (0);
245 }
246
247 png_int_32 PNGAPI
248 png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
249 {
250 if (png_ptr != NULL && info_ptr != NULL)
251 #if defined(PNG_oFFs_SUPPORTED)
252 if (info_ptr->valid & PNG_INFO_oFFs)
253 {
254 png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
255 if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
256 return (0);
257 else return (info_ptr->y_offset);
258 }
259 #else
260 return (0);
261 #endif
262 return (0);
263 }
264
265 #if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)
266 png_uint_32 PNGAPI
267 png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
268 {
269 return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)
270 *.0254 +.5));
271 }
272
273 png_uint_32 PNGAPI
274 png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
275 {
276 return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)
277 *.0254 +.5));
278 }
279
280 png_uint_32 PNGAPI
281 png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
282 {
283 return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)
284 *.0254 +.5));
285 }
286
287 float PNGAPI
288 png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)
289 {
290 return ((float)png_get_x_offset_microns(png_ptr, info_ptr)
291 *.00003937);
292 }
293
294 float PNGAPI
295 png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)
296 {
297 return ((float)png_get_y_offset_microns(png_ptr, info_ptr)
298 *.00003937);
299 }
300
301 #if defined(PNG_pHYs_SUPPORTED)
302 png_uint_32 PNGAPI
303 png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
304 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
305 {
306 png_uint_32 retval = 0;
307
308 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
309 {
310 png_debug1(1, "in %s retrieval function", "pHYs");
311 if (res_x != NULL)
312 {
313 *res_x = info_ptr->x_pixels_per_unit;
314 retval |= PNG_INFO_pHYs;
315 }
316 if (res_y != NULL)
317 {
318 *res_y = info_ptr->y_pixels_per_unit;
319 retval |= PNG_INFO_pHYs;
320 }
321 if (unit_type != NULL)
322 {
323 *unit_type = (int)info_ptr->phys_unit_type;
324 retval |= PNG_INFO_pHYs;
325 if (*unit_type == 1)
326 {
327 if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
328 if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
329 }
330 }
331 }
332 return (retval);
333 }
334 #endif /* PNG_pHYs_SUPPORTED */
335 #endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */
336
337 /* png_get_channels really belongs in here, too, but it's been around longer */
338
339 #endif /* PNG_EASY_ACCESS_SUPPORTED */
340
341 png_byte PNGAPI
342 png_get_channels(png_structp png_ptr, png_infop info_ptr)
343 {
344 if (png_ptr != NULL && info_ptr != NULL)
345 return(info_ptr->channels);
346 else
347 return (0);
348 }
349
350 png_bytep PNGAPI
351 png_get_signature(png_structp png_ptr, png_infop info_ptr)
352 {
353 if (png_ptr != NULL && info_ptr != NULL)
354 return(info_ptr->signature);
355 else
356 return (NULL);
357 }
358
359 #if defined(PNG_bKGD_SUPPORTED)
360 png_uint_32 PNGAPI
361 png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
362 png_color_16p *background)
363 {
364 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
365 && background != NULL)
366 {
367 png_debug1(1, "in %s retrieval function", "bKGD");
368 *background = &(info_ptr->background);
369 return (PNG_INFO_bKGD);
370 }
371 return (0);
372 }
373 #endif
374
375 #if defined(PNG_cHRM_SUPPORTED)
376 #ifdef PNG_FLOATING_POINT_SUPPORTED
377 png_uint_32 PNGAPI
378 png_get_cHRM(png_structp png_ptr, png_infop info_ptr,
379 double *white_x, double *white_y, double *red_x, double *red_y,
380 double *green_x, double *green_y, double *blue_x, double *blue_y)
381 {
382 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
383 {
384 png_debug1(1, "in %s retrieval function", "cHRM");
385 if (white_x != NULL)
386 *white_x = (double)info_ptr->x_white;
387 if (white_y != NULL)
388 *white_y = (double)info_ptr->y_white;
389 if (red_x != NULL)
390 *red_x = (double)info_ptr->x_red;
391 if (red_y != NULL)
392 *red_y = (double)info_ptr->y_red;
393 if (green_x != NULL)
394 *green_x = (double)info_ptr->x_green;
395 if (green_y != NULL)
396 *green_y = (double)info_ptr->y_green;
397 if (blue_x != NULL)
398 *blue_x = (double)info_ptr->x_blue;
399 if (blue_y != NULL)
400 *blue_y = (double)info_ptr->y_blue;
401 return (PNG_INFO_cHRM);
402 }
403 return (0);
404 }
405 #endif
406 #ifdef PNG_FIXED_POINT_SUPPORTED
407 png_uint_32 PNGAPI
408 png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
409 png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
410 png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
411 png_fixed_point *blue_x, png_fixed_point *blue_y)
412 {
413 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
414 {
415 png_debug1(1, "in %s retrieval function", "cHRM");
416 if (white_x != NULL)
417 *white_x = info_ptr->int_x_white;
418 if (white_y != NULL)
419 *white_y = info_ptr->int_y_white;
420 if (red_x != NULL)
421 *red_x = info_ptr->int_x_red;
422 if (red_y != NULL)
423 *red_y = info_ptr->int_y_red;
424 if (green_x != NULL)
425 *green_x = info_ptr->int_x_green;
426 if (green_y != NULL)
427 *green_y = info_ptr->int_y_green;
428 if (blue_x != NULL)
429 *blue_x = info_ptr->int_x_blue;
430 if (blue_y != NULL)
431 *blue_y = info_ptr->int_y_blue;
432 return (PNG_INFO_cHRM);
433 }
434 return (0);
435 }
436 #endif
437 #endif
438
439 #if defined(PNG_gAMA_SUPPORTED)
440 #ifdef PNG_FLOATING_POINT_SUPPORTED
441 png_uint_32 PNGAPI
442 png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
443 {
444 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
445 && file_gamma != NULL)
446 {
447 png_debug1(1, "in %s retrieval function", "gAMA");
448 *file_gamma = (double)info_ptr->gamma;
449 return (PNG_INFO_gAMA);
450 }
451 return (0);
452 }
453 #endif
454 #ifdef PNG_FIXED_POINT_SUPPORTED
455 png_uint_32 PNGAPI
456 png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,
457 png_fixed_point *int_file_gamma)
458 {
459 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
460 && int_file_gamma != NULL)
461 {
462 png_debug1(1, "in %s retrieval function", "gAMA");
463 *int_file_gamma = info_ptr->int_gamma;
464 return (PNG_INFO_gAMA);
465 }
466 return (0);
467 }
468 #endif
469 #endif
470
471 #if defined(PNG_sRGB_SUPPORTED)
472 png_uint_32 PNGAPI
473 png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
474 {
475 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
476 && file_srgb_intent != NULL)
477 {
478 png_debug1(1, "in %s retrieval function", "sRGB");
479 *file_srgb_intent = (int)info_ptr->srgb_intent;
480 return (PNG_INFO_sRGB);
481 }
482 return (0);
483 }
484 #endif
485
486 #if defined(PNG_iCCP_SUPPORTED)
487 png_uint_32 PNGAPI
488 png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
489 png_charpp name, int *compression_type,
490 png_charpp profile, png_uint_32 *proflen)
491 {
492 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
493 && name != NULL && profile != NULL && proflen != NULL)
494 {
495 png_debug1(1, "in %s retrieval function", "iCCP");
496 *name = info_ptr->iccp_name;
497 *profile = info_ptr->iccp_profile;
498 /* compression_type is a dummy so the API won't have to change
499 if we introduce multiple compression types later. */
500 *proflen = (int)info_ptr->iccp_proflen;
501 *compression_type = (int)info_ptr->iccp_compression;
502 return (PNG_INFO_iCCP);
503 }
504 return (0);
505 }
506 #endif
507
508 #if defined(PNG_sPLT_SUPPORTED)
509 png_uint_32 PNGAPI
510 png_get_sPLT(png_structp png_ptr, png_infop info_ptr,
511 png_sPLT_tpp spalettes)
512 {
513 if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
514 {
515 *spalettes = info_ptr->splt_palettes;
516 return ((png_uint_32)info_ptr->splt_palettes_num);
517 }
518 return (0);
519 }
520 #endif
521
522 #if defined(PNG_hIST_SUPPORTED)
523 png_uint_32 PNGAPI
524 png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
525 {
526 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
527 && hist != NULL)
528 {
529 png_debug1(1, "in %s retrieval function", "hIST");
530 *hist = info_ptr->hist;
531 return (PNG_INFO_hIST);
532 }
533 return (0);
534 }
535 #endif
536
537 png_uint_32 PNGAPI
538 png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
539 png_uint_32 *width, png_uint_32 *height, int *bit_depth,
540 int *color_type, int *interlace_type, int *compression_type,
541 int *filter_type)
542
543 {
544 if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL &&
545 bit_depth != NULL && color_type != NULL)
546 {
547 png_debug1(1, "in %s retrieval function", "IHDR");
548 *width = info_ptr->width;
549 *height = info_ptr->height;
550 *bit_depth = info_ptr->bit_depth;
551 if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16)
552 png_error(png_ptr, "Invalid bit depth");
553 *color_type = info_ptr->color_type;
554 if (info_ptr->color_type > 6)
555 png_error(png_ptr, "Invalid color type");
556 if (compression_type != NULL)
557 *compression_type = info_ptr->compression_type;
558 if (filter_type != NULL)
559 *filter_type = info_ptr->filter_type;
560 if (interlace_type != NULL)
561 *interlace_type = info_ptr->interlace_type;
562
563 /* check for potential overflow of rowbytes */
564 if (*width == 0 || *width > PNG_UINT_31_MAX)
565 png_error(png_ptr, "Invalid image width");
566 if (*height == 0 || *height > PNG_UINT_31_MAX)
567 png_error(png_ptr, "Invalid image height");
568 if (info_ptr->width > (PNG_UINT_32_MAX
569 >> 3) /* 8-byte RGBA pixels */
570 - 64 /* bigrowbuf hack */
571 - 1 /* filter byte */
572 - 7*8 /* rounding of width to multiple of 8 pixels */
573 - 8) /* extra max_pixel_depth pad */
574 {
575 png_warning(png_ptr,
576 "Width too large for libpng to process image data.");
577 }
578 return (1);
579 }
580 return (0);
581 }
582
583 #if defined(PNG_oFFs_SUPPORTED)
584 png_uint_32 PNGAPI
585 png_get_oFFs(png_structp png_ptr, png_infop info_ptr,
586 png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
587 {
588 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
589 && offset_x != NULL && offset_y != NULL && unit_type != NULL)
590 {
591 png_debug1(1, "in %s retrieval function", "oFFs");
592 *offset_x = info_ptr->x_offset;
593 *offset_y = info_ptr->y_offset;
594 *unit_type = (int)info_ptr->offset_unit_type;
595 return (PNG_INFO_oFFs);
596 }
597 return (0);
598 }
599 #endif
600
601 #if defined(PNG_pCAL_SUPPORTED)
602 png_uint_32 PNGAPI
603 png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
604 png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
605 png_charp *units, png_charpp *params)
606 {
607 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
608 && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
609 nparams != NULL && units != NULL && params != NULL)
610 {
611 png_debug1(1, "in %s retrieval function", "pCAL");
612 *purpose = info_ptr->pcal_purpose;
613 *X0 = info_ptr->pcal_X0;
614 *X1 = info_ptr->pcal_X1;
615 *type = (int)info_ptr->pcal_type;
616 *nparams = (int)info_ptr->pcal_nparams;
617 *units = info_ptr->pcal_units;
618 *params = info_ptr->pcal_params;
619 return (PNG_INFO_pCAL);
620 }
621 return (0);
622 }
623 #endif
624
625 #if defined(PNG_sCAL_SUPPORTED)
626 #ifdef PNG_FLOATING_POINT_SUPPORTED
627 png_uint_32 PNGAPI
628 png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
629 int *unit, double *width, double *height)
630 {
631 if (png_ptr != NULL && info_ptr != NULL &&
632 (info_ptr->valid & PNG_INFO_sCAL))
633 {
634 *unit = info_ptr->scal_unit;
635 *width = info_ptr->scal_pixel_width;
636 *height = info_ptr->scal_pixel_height;
637 return (PNG_INFO_sCAL);
638 }
639 return(0);
640 }
641 #else
642 #ifdef PNG_FIXED_POINT_SUPPORTED
643 png_uint_32 PNGAPI
644 png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,
645 int *unit, png_charpp width, png_charpp height)
646 {
647 if (png_ptr != NULL && info_ptr != NULL &&
648 (info_ptr->valid & PNG_INFO_sCAL))
649 {
650 *unit = info_ptr->scal_unit;
651 *width = info_ptr->scal_s_width;
652 *height = info_ptr->scal_s_height;
653 return (PNG_INFO_sCAL);
654 }
655 return(0);
656 }
657 #endif
658 #endif
659 #endif
660
661 #if defined(PNG_pHYs_SUPPORTED)
662 png_uint_32 PNGAPI
663 png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
664 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
665 {
666 png_uint_32 retval = 0;
667
668 if (png_ptr != NULL && info_ptr != NULL &&
669 (info_ptr->valid & PNG_INFO_pHYs))
670 {
671 png_debug1(1, "in %s retrieval function", "pHYs");
672 if (res_x != NULL)
673 {
674 *res_x = info_ptr->x_pixels_per_unit;
675 retval |= PNG_INFO_pHYs;
676 }
677 if (res_y != NULL)
678 {
679 *res_y = info_ptr->y_pixels_per_unit;
680 retval |= PNG_INFO_pHYs;
681 }
682 if (unit_type != NULL)
683 {
684 *unit_type = (int)info_ptr->phys_unit_type;
685 retval |= PNG_INFO_pHYs;
686 }
687 }
688 return (retval);
689 }
690 #endif
691
692 png_uint_32 PNGAPI
693 png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
694 int *num_palette)
695 {
696 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
697 && palette != NULL)
698 {
699 png_debug1(1, "in %s retrieval function", "PLTE");
700 *palette = info_ptr->palette;
701 *num_palette = info_ptr->num_palette;
702 png_debug1(3, "num_palette = %d", *num_palette);
703 return (PNG_INFO_PLTE);
704 }
705 return (0);
706 }
707
708 #if defined(PNG_sBIT_SUPPORTED)
709 png_uint_32 PNGAPI
710 png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
711 {
712 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
713 && sig_bit != NULL)
714 {
715 png_debug1(1, "in %s retrieval function", "sBIT");
716 *sig_bit = &(info_ptr->sig_bit);
717 return (PNG_INFO_sBIT);
718 }
719 return (0);
720 }
721 #endif
722
723 #if defined(PNG_TEXT_SUPPORTED)
724 png_uint_32 PNGAPI
725 png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
726 int *num_text)
727 {
728 if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
729 {
730 png_debug1(1, "in %s retrieval function",
731 (png_ptr->chunk_name[0] == '\0' ? "text"
732 : (png_const_charp)png_ptr->chunk_name));
733 if (text_ptr != NULL)
734 *text_ptr = info_ptr->text;
735 if (num_text != NULL)
736 *num_text = info_ptr->num_text;
737 return ((png_uint_32)info_ptr->num_text);
738 }
739 if (num_text != NULL)
740 *num_text = 0;
741 return(0);
742 }
743 #endif
744
745 #if defined(PNG_tIME_SUPPORTED)
746 png_uint_32 PNGAPI
747 png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
748 {
749 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
750 && mod_time != NULL)
751 {
752 png_debug1(1, "in %s retrieval function", "tIME");
753 *mod_time = &(info_ptr->mod_time);
754 return (PNG_INFO_tIME);
755 }
756 return (0);
757 }
758 #endif
759
760 #if defined(PNG_tRNS_SUPPORTED)
761 png_uint_32 PNGAPI
762 png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
763 png_bytep *trans, int *num_trans, png_color_16p *trans_values)
764 {
765 png_uint_32 retval = 0;
766 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
767 {
768 png_debug1(1, "in %s retrieval function", "tRNS");
769 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
770 {
771 if (trans != NULL)
772 {
773 *trans = info_ptr->trans;
774 retval |= PNG_INFO_tRNS;
775 }
776 if (trans_values != NULL)
777 *trans_values = &(info_ptr->trans_values);
778 }
779 else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
780 {
781 if (trans_values != NULL)
782 {
783 *trans_values = &(info_ptr->trans_values);
784 retval |= PNG_INFO_tRNS;
785 }
786 if (trans != NULL)
787 *trans = NULL;
788 }
789 if (num_trans != NULL)
790 {
791 *num_trans = info_ptr->num_trans;
792 retval |= PNG_INFO_tRNS;
793 }
794 }
795 return (retval);
796 }
797 #endif
798
799 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
800 png_uint_32 PNGAPI
801 png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,
802 png_unknown_chunkpp unknowns)
803 {
804 if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
805 {
806 *unknowns = info_ptr->unknown_chunks;
807 return ((png_uint_32)info_ptr->unknown_chunks_num);
808 }
809 return (0);
810 }
811 #endif
812
813 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
814 png_byte PNGAPI
815 png_get_rgb_to_gray_status (png_structp png_ptr)
816 {
817 return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);
818 }
819 #endif
820
821 #if defined(PNG_USER_CHUNKS_SUPPORTED)
822 png_voidp PNGAPI
823 png_get_user_chunk_ptr(png_structp png_ptr)
824 {
825 return (png_ptr? png_ptr->user_chunk_ptr : NULL);
826 }
827 #endif
828
829 #ifdef PNG_WRITE_SUPPORTED
830 png_uint_32 PNGAPI
831 png_get_compression_buffer_size(png_structp png_ptr)
832 {
833 return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L);
834 }
835 #endif
836
837 #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
838 #ifndef PNG_1_0_X
839 /* this function was added to libpng 1.2.0 and should exist by default */
840 png_uint_32 PNGAPI
841 png_get_asm_flags (png_structp png_ptr)
842 {
843 /* obsolete, to be removed from libpng-1.4.0 */
844 return (png_ptr? 0L: 0L);
845 }
846
847 /* this function was added to libpng 1.2.0 and should exist by default */
848 png_uint_32 PNGAPI
849 png_get_asm_flagmask (int flag_select)
850 {
851 /* obsolete, to be removed from libpng-1.4.0 */
852 flag_select=flag_select;
853 return 0L;
854 }
855
856 /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */
857 /* this function was added to libpng 1.2.0 */
858 png_uint_32 PNGAPI
859 png_get_mmx_flagmask (int flag_select, int *compilerID)
860 {
861 /* obsolete, to be removed from libpng-1.4.0 */
862 flag_select=flag_select;
863 *compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */
864 return 0L;
865 }
866
867 /* this function was added to libpng 1.2.0 */
868 png_byte PNGAPI
869 png_get_mmx_bitdepth_threshold (png_structp png_ptr)
870 {
871 /* obsolete, to be removed from libpng-1.4.0 */
872 return (png_ptr? 0: 0);
873 }
874
875 /* this function was added to libpng 1.2.0 */
876 png_uint_32 PNGAPI
877 png_get_mmx_rowbytes_threshold (png_structp png_ptr)
878 {
879 /* obsolete, to be removed from libpng-1.4.0 */
880 return (png_ptr? 0L: 0L);
881 }
882 #endif /* ?PNG_1_0_X */
883 #endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
884
885 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
886 /* These functions were added to libpng 1.2.6 */
887 png_uint_32 PNGAPI
888 png_get_user_width_max (png_structp png_ptr)
889 {
890 return (png_ptr? png_ptr->user_width_max : 0);
891 }
892 png_uint_32 PNGAPI
893 png_get_user_height_max (png_structp png_ptr)
894 {
895 return (png_ptr? png_ptr->user_height_max : 0);
896 }
897 #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
898
899
900 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
   
Visit the ZANavi Wiki