VirtualBox

source: vbox/trunk/src/libs/libpng-1.6.36/pngget.c@ 77807

最後變更 在這個檔案從77807是 76030,由 vboxsync 提交於 6 年 前

libpng-1.6.36: properly export to OSE, and while at it fix EOL style for shell scripts
  • 屬性 svn:eol-style 設為 native
檔案大小: 33.2 KB
行 
1
2/* pngget.c - retrieval of values from info struct
3 *
4 * Copyright (c) 2018 Cosmin Truta
5 * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
6 * Copyright (c) 1996-1997 Andreas Dilger
7 * 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 */
14
15#include "pngpriv.h"
16
17#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
18
19png_uint_32 PNGAPI
20png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr,
21 png_uint_32 flag)
22{
23 if (png_ptr != NULL && info_ptr != NULL)
24 return(info_ptr->valid & flag);
25
26 return(0);
27}
28
29size_t PNGAPI
30png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr)
31{
32 if (png_ptr != NULL && info_ptr != NULL)
33 return(info_ptr->rowbytes);
34
35 return(0);
36}
37
38#ifdef PNG_INFO_IMAGE_SUPPORTED
39png_bytepp PNGAPI
40png_get_rows(png_const_structrp png_ptr, png_const_inforp info_ptr)
41{
42 if (png_ptr != NULL && info_ptr != NULL)
43 return(info_ptr->row_pointers);
44
45 return(0);
46}
47#endif
48
49#ifdef PNG_EASY_ACCESS_SUPPORTED
50/* Easy access to info, added in libpng-0.99 */
51png_uint_32 PNGAPI
52png_get_image_width(png_const_structrp png_ptr, png_const_inforp info_ptr)
53{
54 if (png_ptr != NULL && info_ptr != NULL)
55 return info_ptr->width;
56
57 return (0);
58}
59
60png_uint_32 PNGAPI
61png_get_image_height(png_const_structrp png_ptr, png_const_inforp info_ptr)
62{
63 if (png_ptr != NULL && info_ptr != NULL)
64 return info_ptr->height;
65
66 return (0);
67}
68
69png_byte PNGAPI
70png_get_bit_depth(png_const_structrp png_ptr, png_const_inforp info_ptr)
71{
72 if (png_ptr != NULL && info_ptr != NULL)
73 return info_ptr->bit_depth;
74
75 return (0);
76}
77
78png_byte PNGAPI
79png_get_color_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
80{
81 if (png_ptr != NULL && info_ptr != NULL)
82 return info_ptr->color_type;
83
84 return (0);
85}
86
87png_byte PNGAPI
88png_get_filter_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
89{
90 if (png_ptr != NULL && info_ptr != NULL)
91 return info_ptr->filter_type;
92
93 return (0);
94}
95
96png_byte PNGAPI
97png_get_interlace_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
98{
99 if (png_ptr != NULL && info_ptr != NULL)
100 return info_ptr->interlace_type;
101
102 return (0);
103}
104
105png_byte PNGAPI
106png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
107{
108 if (png_ptr != NULL && info_ptr != NULL)
109 return info_ptr->compression_type;
110
111 return (0);
112}
113
114png_uint_32 PNGAPI
115png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
116 info_ptr)
117{
118#ifdef PNG_pHYs_SUPPORTED
119 if (png_ptr != NULL && info_ptr != NULL &&
120 (info_ptr->valid & PNG_INFO_pHYs) != 0)
121 {
122 png_debug1(1, "in %s retrieval function",
123 "png_get_x_pixels_per_meter");
124
125 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
126 return (info_ptr->x_pixels_per_unit);
127 }
128#else
129 PNG_UNUSED(png_ptr)
130 PNG_UNUSED(info_ptr)
131#endif
132
133 return (0);
134}
135
136png_uint_32 PNGAPI
137png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
138 info_ptr)
139{
140#ifdef PNG_pHYs_SUPPORTED
141 if (png_ptr != NULL && info_ptr != NULL &&
142 (info_ptr->valid & PNG_INFO_pHYs) != 0)
143 {
144 png_debug1(1, "in %s retrieval function",
145 "png_get_y_pixels_per_meter");
146
147 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
148 return (info_ptr->y_pixels_per_unit);
149 }
150#else
151 PNG_UNUSED(png_ptr)
152 PNG_UNUSED(info_ptr)
153#endif
154
155 return (0);
156}
157
158png_uint_32 PNGAPI
159png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr)
160{
161#ifdef PNG_pHYs_SUPPORTED
162 if (png_ptr != NULL && info_ptr != NULL &&
163 (info_ptr->valid & PNG_INFO_pHYs) != 0)
164 {
165 png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
166
167 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER &&
168 info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit)
169 return (info_ptr->x_pixels_per_unit);
170 }
171#else
172 PNG_UNUSED(png_ptr)
173 PNG_UNUSED(info_ptr)
174#endif
175
176 return (0);
177}
178
179#ifdef PNG_FLOATING_POINT_SUPPORTED
180float PNGAPI
181png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp
182 info_ptr)
183{
184#ifdef PNG_READ_pHYs_SUPPORTED
185 if (png_ptr != NULL && info_ptr != NULL &&
186 (info_ptr->valid & PNG_INFO_pHYs) != 0)
187 {
188 png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
189
190 if (info_ptr->x_pixels_per_unit != 0)
191 return ((float)((float)info_ptr->y_pixels_per_unit
192 /(float)info_ptr->x_pixels_per_unit));
193 }
194#else
195 PNG_UNUSED(png_ptr)
196 PNG_UNUSED(info_ptr)
197#endif
198
199 return ((float)0.0);
200}
201#endif
202
203#ifdef PNG_FIXED_POINT_SUPPORTED
204png_fixed_point PNGAPI
205png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr,
206 png_const_inforp info_ptr)
207{
208#ifdef PNG_READ_pHYs_SUPPORTED
209 if (png_ptr != NULL && info_ptr != NULL &&
210 (info_ptr->valid & PNG_INFO_pHYs) != 0 &&
211 info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0 &&
212 info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX &&
213 info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX)
214 {
215 png_fixed_point res;
216
217 png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed");
218
219 /* The following casts work because a PNG 4 byte integer only has a valid
220 * range of 0..2^31-1; otherwise the cast might overflow.
221 */
222 if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1,
223 (png_int_32)info_ptr->x_pixels_per_unit) != 0)
224 return res;
225 }
226#else
227 PNG_UNUSED(png_ptr)
228 PNG_UNUSED(info_ptr)
229#endif
230
231 return 0;
232}
233#endif
234
235png_int_32 PNGAPI
236png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
237{
238#ifdef PNG_oFFs_SUPPORTED
239 if (png_ptr != NULL && info_ptr != NULL &&
240 (info_ptr->valid & PNG_INFO_oFFs) != 0)
241 {
242 png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
243
244 if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
245 return (info_ptr->x_offset);
246 }
247#else
248 PNG_UNUSED(png_ptr)
249 PNG_UNUSED(info_ptr)
250#endif
251
252 return (0);
253}
254
255png_int_32 PNGAPI
256png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
257{
258#ifdef PNG_oFFs_SUPPORTED
259 if (png_ptr != NULL && info_ptr != NULL &&
260 (info_ptr->valid & PNG_INFO_oFFs) != 0)
261 {
262 png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
263
264 if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
265 return (info_ptr->y_offset);
266 }
267#else
268 PNG_UNUSED(png_ptr)
269 PNG_UNUSED(info_ptr)
270#endif
271
272 return (0);
273}
274
275png_int_32 PNGAPI
276png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
277{
278#ifdef PNG_oFFs_SUPPORTED
279 if (png_ptr != NULL && info_ptr != NULL &&
280 (info_ptr->valid & PNG_INFO_oFFs) != 0)
281 {
282 png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels");
283
284 if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
285 return (info_ptr->x_offset);
286 }
287#else
288 PNG_UNUSED(png_ptr)
289 PNG_UNUSED(info_ptr)
290#endif
291
292 return (0);
293}
294
295png_int_32 PNGAPI
296png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
297{
298#ifdef PNG_oFFs_SUPPORTED
299 if (png_ptr != NULL && info_ptr != NULL &&
300 (info_ptr->valid & PNG_INFO_oFFs) != 0)
301 {
302 png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels");
303
304 if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
305 return (info_ptr->y_offset);
306 }
307#else
308 PNG_UNUSED(png_ptr)
309 PNG_UNUSED(info_ptr)
310#endif
311
312 return (0);
313}
314
315#ifdef PNG_INCH_CONVERSIONS_SUPPORTED
316static png_uint_32
317ppi_from_ppm(png_uint_32 ppm)
318{
319#if 0
320 /* The conversion is *(2.54/100), in binary (32 digits):
321 * .00000110100000001001110101001001
322 */
323 png_uint_32 t1001, t1101;
324 ppm >>= 1; /* .1 */
325 t1001 = ppm + (ppm >> 3); /* .1001 */
326 t1101 = t1001 + (ppm >> 1); /* .1101 */
327 ppm >>= 20; /* .000000000000000000001 */
328 t1101 += t1101 >> 15; /* .1101000000000001101 */
329 t1001 >>= 11; /* .000000000001001 */
330 t1001 += t1001 >> 12; /* .000000000001001000000001001 */
331 ppm += t1001; /* .000000000001001000001001001 */
332 ppm += t1101; /* .110100000001001110101001001 */
333 return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */
334#else
335 /* The argument is a PNG unsigned integer, so it is not permitted
336 * to be bigger than 2^31.
337 */
338 png_fixed_point result;
339 if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127,
340 5000) != 0)
341 return (png_uint_32)result;
342
343 /* Overflow. */
344 return 0;
345#endif
346}
347
348png_uint_32 PNGAPI
349png_get_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
350{
351 return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));
352}
353
354png_uint_32 PNGAPI
355png_get_x_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
356{
357 return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr));
358}
359
360png_uint_32 PNGAPI
361png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
362{
363 return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr));
364}
365
366#ifdef PNG_FIXED_POINT_SUPPORTED
367static png_fixed_point
368png_fixed_inches_from_microns(png_const_structrp png_ptr, png_int_32 microns)
369{
370 /* Convert from meters * 1,000,000 to inches * 100,000, meters to
371 * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127.
372 * Notice that this can overflow - a warning is output and 0 is
373 * returned.
374 */
375 return png_muldiv_warn(png_ptr, microns, 500, 127);
376}
377
378png_fixed_point PNGAPI
379png_get_x_offset_inches_fixed(png_const_structrp png_ptr,
380 png_const_inforp info_ptr)
381{
382 return png_fixed_inches_from_microns(png_ptr,
383 png_get_x_offset_microns(png_ptr, info_ptr));
384}
385#endif
386
387#ifdef PNG_FIXED_POINT_SUPPORTED
388png_fixed_point PNGAPI
389png_get_y_offset_inches_fixed(png_const_structrp png_ptr,
390 png_const_inforp info_ptr)
391{
392 return png_fixed_inches_from_microns(png_ptr,
393 png_get_y_offset_microns(png_ptr, info_ptr));
394}
395#endif
396
397#ifdef PNG_FLOATING_POINT_SUPPORTED
398float PNGAPI
399png_get_x_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)
400{
401 /* To avoid the overflow do the conversion directly in floating
402 * point.
403 */
404 return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937);
405}
406#endif
407
408#ifdef PNG_FLOATING_POINT_SUPPORTED
409float PNGAPI
410png_get_y_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)
411{
412 /* To avoid the overflow do the conversion directly in floating
413 * point.
414 */
415 return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937);
416}
417#endif
418
419#ifdef PNG_pHYs_SUPPORTED
420png_uint_32 PNGAPI
421png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr,
422 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
423{
424 png_uint_32 retval = 0;
425
426 if (png_ptr != NULL && info_ptr != NULL &&
427 (info_ptr->valid & PNG_INFO_pHYs) != 0)
428 {
429 png_debug1(1, "in %s retrieval function", "pHYs");
430
431 if (res_x != NULL)
432 {
433 *res_x = info_ptr->x_pixels_per_unit;
434 retval |= PNG_INFO_pHYs;
435 }
436
437 if (res_y != NULL)
438 {
439 *res_y = info_ptr->y_pixels_per_unit;
440 retval |= PNG_INFO_pHYs;
441 }
442
443 if (unit_type != NULL)
444 {
445 *unit_type = (int)info_ptr->phys_unit_type;
446 retval |= PNG_INFO_pHYs;
447
448 if (*unit_type == 1)
449 {
450 if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
451 if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
452 }
453 }
454 }
455
456 return (retval);
457}
458#endif /* pHYs */
459#endif /* INCH_CONVERSIONS */
460
461/* png_get_channels really belongs in here, too, but it's been around longer */
462
463#endif /* EASY_ACCESS */
464
465
466png_byte PNGAPI
467png_get_channels(png_const_structrp png_ptr, png_const_inforp info_ptr)
468{
469 if (png_ptr != NULL && info_ptr != NULL)
470 return(info_ptr->channels);
471
472 return (0);
473}
474
475#ifdef PNG_READ_SUPPORTED
476png_const_bytep PNGAPI
477png_get_signature(png_const_structrp png_ptr, png_const_inforp info_ptr)
478{
479 if (png_ptr != NULL && info_ptr != NULL)
480 return(info_ptr->signature);
481
482 return (NULL);
483}
484#endif
485
486#ifdef PNG_bKGD_SUPPORTED
487png_uint_32 PNGAPI
488png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr,
489 png_color_16p *background)
490{
491 if (png_ptr != NULL && info_ptr != NULL &&
492 (info_ptr->valid & PNG_INFO_bKGD) != 0 &&
493 background != NULL)
494 {
495 png_debug1(1, "in %s retrieval function", "bKGD");
496
497 *background = &(info_ptr->background);
498 return (PNG_INFO_bKGD);
499 }
500
501 return (0);
502}
503#endif
504
505#ifdef PNG_cHRM_SUPPORTED
506/* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the
507 * same time to correct the rgb grayscale coefficient defaults obtained from the
508 * cHRM chunk in 1.5.4
509 */
510# ifdef PNG_FLOATING_POINT_SUPPORTED
511png_uint_32 PNGAPI
512png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr,
513 double *white_x, double *white_y, double *red_x, double *red_y,
514 double *green_x, double *green_y, double *blue_x, double *blue_y)
515{
516 /* Quiet API change: this code used to only return the end points if a cHRM
517 * chunk was present, but the end points can also come from iCCP or sRGB
518 * chunks, so in 1.6.0 the png_get_ APIs return the end points regardless and
519 * the png_set_ APIs merely check that set end points are mutually
520 * consistent.
521 */
522 if (png_ptr != NULL && info_ptr != NULL &&
523 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
524 {
525 png_debug1(1, "in %s retrieval function", "cHRM");
526
527 if (white_x != NULL)
528 *white_x = png_float(png_ptr,
529 info_ptr->colorspace.end_points_xy.whitex, "cHRM white X");
530 if (white_y != NULL)
531 *white_y = png_float(png_ptr,
532 info_ptr->colorspace.end_points_xy.whitey, "cHRM white Y");
533 if (red_x != NULL)
534 *red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx,
535 "cHRM red X");
536 if (red_y != NULL)
537 *red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy,
538 "cHRM red Y");
539 if (green_x != NULL)
540 *green_x = png_float(png_ptr,
541 info_ptr->colorspace.end_points_xy.greenx, "cHRM green X");
542 if (green_y != NULL)
543 *green_y = png_float(png_ptr,
544 info_ptr->colorspace.end_points_xy.greeny, "cHRM green Y");
545 if (blue_x != NULL)
546 *blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex,
547 "cHRM blue X");
548 if (blue_y != NULL)
549 *blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey,
550 "cHRM blue Y");
551 return (PNG_INFO_cHRM);
552 }
553
554 return (0);
555}
556
557png_uint_32 PNGAPI
558png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr,
559 double *red_X, double *red_Y, double *red_Z, double *green_X,
560 double *green_Y, double *green_Z, double *blue_X, double *blue_Y,
561 double *blue_Z)
562{
563 if (png_ptr != NULL && info_ptr != NULL &&
564 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
565 {
566 png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)");
567
568 if (red_X != NULL)
569 *red_X = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_X,
570 "cHRM red X");
571 if (red_Y != NULL)
572 *red_Y = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Y,
573 "cHRM red Y");
574 if (red_Z != NULL)
575 *red_Z = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Z,
576 "cHRM red Z");
577 if (green_X != NULL)
578 *green_X = png_float(png_ptr,
579 info_ptr->colorspace.end_points_XYZ.green_X, "cHRM green X");
580 if (green_Y != NULL)
581 *green_Y = png_float(png_ptr,
582 info_ptr->colorspace.end_points_XYZ.green_Y, "cHRM green Y");
583 if (green_Z != NULL)
584 *green_Z = png_float(png_ptr,
585 info_ptr->colorspace.end_points_XYZ.green_Z, "cHRM green Z");
586 if (blue_X != NULL)
587 *blue_X = png_float(png_ptr,
588 info_ptr->colorspace.end_points_XYZ.blue_X, "cHRM blue X");
589 if (blue_Y != NULL)
590 *blue_Y = png_float(png_ptr,
591 info_ptr->colorspace.end_points_XYZ.blue_Y, "cHRM blue Y");
592 if (blue_Z != NULL)
593 *blue_Z = png_float(png_ptr,
594 info_ptr->colorspace.end_points_XYZ.blue_Z, "cHRM blue Z");
595 return (PNG_INFO_cHRM);
596 }
597
598 return (0);
599}
600# endif
601
602# ifdef PNG_FIXED_POINT_SUPPORTED
603png_uint_32 PNGAPI
604png_get_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
605 png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
606 png_fixed_point *int_red_Z, png_fixed_point *int_green_X,
607 png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,
608 png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,
609 png_fixed_point *int_blue_Z)
610{
611 if (png_ptr != NULL && info_ptr != NULL &&
612 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
613 {
614 png_debug1(1, "in %s retrieval function", "cHRM_XYZ");
615
616 if (int_red_X != NULL)
617 *int_red_X = info_ptr->colorspace.end_points_XYZ.red_X;
618 if (int_red_Y != NULL)
619 *int_red_Y = info_ptr->colorspace.end_points_XYZ.red_Y;
620 if (int_red_Z != NULL)
621 *int_red_Z = info_ptr->colorspace.end_points_XYZ.red_Z;
622 if (int_green_X != NULL)
623 *int_green_X = info_ptr->colorspace.end_points_XYZ.green_X;
624 if (int_green_Y != NULL)
625 *int_green_Y = info_ptr->colorspace.end_points_XYZ.green_Y;
626 if (int_green_Z != NULL)
627 *int_green_Z = info_ptr->colorspace.end_points_XYZ.green_Z;
628 if (int_blue_X != NULL)
629 *int_blue_X = info_ptr->colorspace.end_points_XYZ.blue_X;
630 if (int_blue_Y != NULL)
631 *int_blue_Y = info_ptr->colorspace.end_points_XYZ.blue_Y;
632 if (int_blue_Z != NULL)
633 *int_blue_Z = info_ptr->colorspace.end_points_XYZ.blue_Z;
634 return (PNG_INFO_cHRM);
635 }
636
637 return (0);
638}
639
640png_uint_32 PNGAPI
641png_get_cHRM_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
642 png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
643 png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
644 png_fixed_point *blue_x, png_fixed_point *blue_y)
645{
646 png_debug1(1, "in %s retrieval function", "cHRM");
647
648 if (png_ptr != NULL && info_ptr != NULL &&
649 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
650 {
651 if (white_x != NULL)
652 *white_x = info_ptr->colorspace.end_points_xy.whitex;
653 if (white_y != NULL)
654 *white_y = info_ptr->colorspace.end_points_xy.whitey;
655 if (red_x != NULL)
656 *red_x = info_ptr->colorspace.end_points_xy.redx;
657 if (red_y != NULL)
658 *red_y = info_ptr->colorspace.end_points_xy.redy;
659 if (green_x != NULL)
660 *green_x = info_ptr->colorspace.end_points_xy.greenx;
661 if (green_y != NULL)
662 *green_y = info_ptr->colorspace.end_points_xy.greeny;
663 if (blue_x != NULL)
664 *blue_x = info_ptr->colorspace.end_points_xy.bluex;
665 if (blue_y != NULL)
666 *blue_y = info_ptr->colorspace.end_points_xy.bluey;
667 return (PNG_INFO_cHRM);
668 }
669
670 return (0);
671}
672# endif
673#endif
674
675#ifdef PNG_gAMA_SUPPORTED
676# ifdef PNG_FIXED_POINT_SUPPORTED
677png_uint_32 PNGAPI
678png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
679 png_fixed_point *file_gamma)
680{
681 png_debug1(1, "in %s retrieval function", "gAMA");
682
683 if (png_ptr != NULL && info_ptr != NULL &&
684 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
685 file_gamma != NULL)
686 {
687 *file_gamma = info_ptr->colorspace.gamma;
688 return (PNG_INFO_gAMA);
689 }
690
691 return (0);
692}
693# endif
694
695# ifdef PNG_FLOATING_POINT_SUPPORTED
696png_uint_32 PNGAPI
697png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr,
698 double *file_gamma)
699{
700 png_debug1(1, "in %s retrieval function", "gAMA(float)");
701
702 if (png_ptr != NULL && info_ptr != NULL &&
703 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
704 file_gamma != NULL)
705 {
706 *file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma,
707 "png_get_gAMA");
708 return (PNG_INFO_gAMA);
709 }
710
711 return (0);
712}
713# endif
714#endif
715
716#ifdef PNG_sRGB_SUPPORTED
717png_uint_32 PNGAPI
718png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr,
719 int *file_srgb_intent)
720{
721 png_debug1(1, "in %s retrieval function", "sRGB");
722
723 if (png_ptr != NULL && info_ptr != NULL &&
724 (info_ptr->valid & PNG_INFO_sRGB) != 0 && file_srgb_intent != NULL)
725 {
726 *file_srgb_intent = info_ptr->colorspace.rendering_intent;
727 return (PNG_INFO_sRGB);
728 }
729
730 return (0);
731}
732#endif
733
734#ifdef PNG_iCCP_SUPPORTED
735png_uint_32 PNGAPI
736png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
737 png_charpp name, int *compression_type,
738 png_bytepp profile, png_uint_32 *proflen)
739{
740 png_debug1(1, "in %s retrieval function", "iCCP");
741
742 if (png_ptr != NULL && info_ptr != NULL &&
743 (info_ptr->valid & PNG_INFO_iCCP) != 0 &&
744 name != NULL && profile != NULL && proflen != NULL)
745 {
746 *name = info_ptr->iccp_name;
747 *profile = info_ptr->iccp_profile;
748 *proflen = png_get_uint_32(info_ptr->iccp_profile);
749 /* This is somewhat irrelevant since the profile data returned has
750 * actually been uncompressed.
751 */
752 if (compression_type != NULL)
753 *compression_type = PNG_COMPRESSION_TYPE_BASE;
754 return (PNG_INFO_iCCP);
755 }
756
757 return (0);
758
759}
760#endif
761
762#ifdef PNG_sPLT_SUPPORTED
763int PNGAPI
764png_get_sPLT(png_const_structrp png_ptr, png_inforp info_ptr,
765 png_sPLT_tpp spalettes)
766{
767 if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
768 {
769 *spalettes = info_ptr->splt_palettes;
770 return info_ptr->splt_palettes_num;
771 }
772
773 return (0);
774}
775#endif
776
777#ifdef PNG_eXIf_SUPPORTED
778png_uint_32 PNGAPI
779png_get_eXIf(png_const_structrp png_ptr, png_inforp info_ptr,
780 png_bytep *exif)
781{
782 png_warning(png_ptr, "png_get_eXIf does not work; use png_get_eXIf_1");
783 PNG_UNUSED(info_ptr)
784 PNG_UNUSED(exif)
785 return 0;
786}
787
788png_uint_32 PNGAPI
789png_get_eXIf_1(png_const_structrp png_ptr, png_const_inforp info_ptr,
790 png_uint_32 *num_exif, png_bytep *exif)
791{
792 png_debug1(1, "in %s retrieval function", "eXIf");
793
794 if (png_ptr != NULL && info_ptr != NULL &&
795 (info_ptr->valid & PNG_INFO_eXIf) != 0 && exif != NULL)
796 {
797 *num_exif = info_ptr->num_exif;
798 *exif = info_ptr->exif;
799 return (PNG_INFO_eXIf);
800 }
801
802 return (0);
803}
804#endif
805
806#ifdef PNG_hIST_SUPPORTED
807png_uint_32 PNGAPI
808png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr,
809 png_uint_16p *hist)
810{
811 png_debug1(1, "in %s retrieval function", "hIST");
812
813 if (png_ptr != NULL && info_ptr != NULL &&
814 (info_ptr->valid & PNG_INFO_hIST) != 0 && hist != NULL)
815 {
816 *hist = info_ptr->hist;
817 return (PNG_INFO_hIST);
818 }
819
820 return (0);
821}
822#endif
823
824png_uint_32 PNGAPI
825png_get_IHDR(png_const_structrp png_ptr, png_const_inforp info_ptr,
826 png_uint_32 *width, png_uint_32 *height, int *bit_depth,
827 int *color_type, int *interlace_type, int *compression_type,
828 int *filter_type)
829{
830 png_debug1(1, "in %s retrieval function", "IHDR");
831
832 if (png_ptr == NULL || info_ptr == NULL)
833 return (0);
834
835 if (width != NULL)
836 *width = info_ptr->width;
837
838 if (height != NULL)
839 *height = info_ptr->height;
840
841 if (bit_depth != NULL)
842 *bit_depth = info_ptr->bit_depth;
843
844 if (color_type != NULL)
845 *color_type = info_ptr->color_type;
846
847 if (compression_type != NULL)
848 *compression_type = info_ptr->compression_type;
849
850 if (filter_type != NULL)
851 *filter_type = info_ptr->filter_type;
852
853 if (interlace_type != NULL)
854 *interlace_type = info_ptr->interlace_type;
855
856 /* This is redundant if we can be sure that the info_ptr values were all
857 * assigned in png_set_IHDR(). We do the check anyhow in case an
858 * application has ignored our advice not to mess with the members
859 * of info_ptr directly.
860 */
861 png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height,
862 info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
863 info_ptr->compression_type, info_ptr->filter_type);
864
865 return (1);
866}
867
868#ifdef PNG_oFFs_SUPPORTED
869png_uint_32 PNGAPI
870png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr,
871 png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
872{
873 png_debug1(1, "in %s retrieval function", "oFFs");
874
875 if (png_ptr != NULL && info_ptr != NULL &&
876 (info_ptr->valid & PNG_INFO_oFFs) != 0 &&
877 offset_x != NULL && offset_y != NULL && unit_type != NULL)
878 {
879 *offset_x = info_ptr->x_offset;
880 *offset_y = info_ptr->y_offset;
881 *unit_type = (int)info_ptr->offset_unit_type;
882 return (PNG_INFO_oFFs);
883 }
884
885 return (0);
886}
887#endif
888
889#ifdef PNG_pCAL_SUPPORTED
890png_uint_32 PNGAPI
891png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
892 png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
893 png_charp *units, png_charpp *params)
894{
895 png_debug1(1, "in %s retrieval function", "pCAL");
896
897 if (png_ptr != NULL && info_ptr != NULL &&
898 (info_ptr->valid & PNG_INFO_pCAL) != 0 &&
899 purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
900 nparams != NULL && units != NULL && params != NULL)
901 {
902 *purpose = info_ptr->pcal_purpose;
903 *X0 = info_ptr->pcal_X0;
904 *X1 = info_ptr->pcal_X1;
905 *type = (int)info_ptr->pcal_type;
906 *nparams = (int)info_ptr->pcal_nparams;
907 *units = info_ptr->pcal_units;
908 *params = info_ptr->pcal_params;
909 return (PNG_INFO_pCAL);
910 }
911
912 return (0);
913}
914#endif
915
916#ifdef PNG_sCAL_SUPPORTED
917# ifdef PNG_FIXED_POINT_SUPPORTED
918# if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
919 defined(PNG_FLOATING_POINT_SUPPORTED)
920png_uint_32 PNGAPI
921png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
922 int *unit, png_fixed_point *width, png_fixed_point *height)
923{
924 if (png_ptr != NULL && info_ptr != NULL &&
925 (info_ptr->valid & PNG_INFO_sCAL) != 0)
926 {
927 *unit = info_ptr->scal_unit;
928 /*TODO: make this work without FP support; the API is currently eliminated
929 * if neither floating point APIs nor internal floating point arithmetic
930 * are enabled.
931 */
932 *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width");
933 *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height),
934 "sCAL height");
935 return (PNG_INFO_sCAL);
936 }
937
938 return(0);
939}
940# endif /* FLOATING_ARITHMETIC */
941# endif /* FIXED_POINT */
942# ifdef PNG_FLOATING_POINT_SUPPORTED
943png_uint_32 PNGAPI
944png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr,
945 int *unit, double *width, double *height)
946{
947 if (png_ptr != NULL && info_ptr != NULL &&
948 (info_ptr->valid & PNG_INFO_sCAL) != 0)
949 {
950 *unit = info_ptr->scal_unit;
951 *width = atof(info_ptr->scal_s_width);
952 *height = atof(info_ptr->scal_s_height);
953 return (PNG_INFO_sCAL);
954 }
955
956 return(0);
957}
958# endif /* FLOATING POINT */
959png_uint_32 PNGAPI
960png_get_sCAL_s(png_const_structrp png_ptr, png_const_inforp info_ptr,
961 int *unit, png_charpp width, png_charpp height)
962{
963 if (png_ptr != NULL && info_ptr != NULL &&
964 (info_ptr->valid & PNG_INFO_sCAL) != 0)
965 {
966 *unit = info_ptr->scal_unit;
967 *width = info_ptr->scal_s_width;
968 *height = info_ptr->scal_s_height;
969 return (PNG_INFO_sCAL);
970 }
971
972 return(0);
973}
974#endif /* sCAL */
975
976#ifdef PNG_pHYs_SUPPORTED
977png_uint_32 PNGAPI
978png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr,
979 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
980{
981 png_uint_32 retval = 0;
982
983 png_debug1(1, "in %s retrieval function", "pHYs");
984
985 if (png_ptr != NULL && info_ptr != NULL &&
986 (info_ptr->valid & PNG_INFO_pHYs) != 0)
987 {
988 if (res_x != NULL)
989 {
990 *res_x = info_ptr->x_pixels_per_unit;
991 retval |= PNG_INFO_pHYs;
992 }
993
994 if (res_y != NULL)
995 {
996 *res_y = info_ptr->y_pixels_per_unit;
997 retval |= PNG_INFO_pHYs;
998 }
999
1000 if (unit_type != NULL)
1001 {
1002 *unit_type = (int)info_ptr->phys_unit_type;
1003 retval |= PNG_INFO_pHYs;
1004 }
1005 }
1006
1007 return (retval);
1008}
1009#endif /* pHYs */
1010
1011png_uint_32 PNGAPI
1012png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr,
1013 png_colorp *palette, int *num_palette)
1014{
1015 png_debug1(1, "in %s retrieval function", "PLTE");
1016
1017 if (png_ptr != NULL && info_ptr != NULL &&
1018 (info_ptr->valid & PNG_INFO_PLTE) != 0 && palette != NULL)
1019 {
1020 *palette = info_ptr->palette;
1021 *num_palette = info_ptr->num_palette;
1022 png_debug1(3, "num_palette = %d", *num_palette);
1023 return (PNG_INFO_PLTE);
1024 }
1025
1026 return (0);
1027}
1028
1029#ifdef PNG_sBIT_SUPPORTED
1030png_uint_32 PNGAPI
1031png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr,
1032 png_color_8p *sig_bit)
1033{
1034 png_debug1(1, "in %s retrieval function", "sBIT");
1035
1036 if (png_ptr != NULL && info_ptr != NULL &&
1037 (info_ptr->valid & PNG_INFO_sBIT) != 0 && sig_bit != NULL)
1038 {
1039 *sig_bit = &(info_ptr->sig_bit);
1040 return (PNG_INFO_sBIT);
1041 }
1042
1043 return (0);
1044}
1045#endif
1046
1047#ifdef PNG_TEXT_SUPPORTED
1048int PNGAPI
1049png_get_text(png_const_structrp png_ptr, png_inforp info_ptr,
1050 png_textp *text_ptr, int *num_text)
1051{
1052 if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
1053 {
1054 png_debug1(1, "in 0x%lx retrieval function",
1055 (unsigned long)png_ptr->chunk_name);
1056
1057 if (text_ptr != NULL)
1058 *text_ptr = info_ptr->text;
1059
1060 if (num_text != NULL)
1061 *num_text = info_ptr->num_text;
1062
1063 return info_ptr->num_text;
1064 }
1065
1066 if (num_text != NULL)
1067 *num_text = 0;
1068
1069 return(0);
1070}
1071#endif
1072
1073#ifdef PNG_tIME_SUPPORTED
1074png_uint_32 PNGAPI
1075png_get_tIME(png_const_structrp png_ptr, png_inforp info_ptr,
1076 png_timep *mod_time)
1077{
1078 png_debug1(1, "in %s retrieval function", "tIME");
1079
1080 if (png_ptr != NULL && info_ptr != NULL &&
1081 (info_ptr->valid & PNG_INFO_tIME) != 0 && mod_time != NULL)
1082 {
1083 *mod_time = &(info_ptr->mod_time);
1084 return (PNG_INFO_tIME);
1085 }
1086
1087 return (0);
1088}
1089#endif
1090
1091#ifdef PNG_tRNS_SUPPORTED
1092png_uint_32 PNGAPI
1093png_get_tRNS(png_const_structrp png_ptr, png_inforp info_ptr,
1094 png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
1095{
1096 png_uint_32 retval = 0;
1097 if (png_ptr != NULL && info_ptr != NULL &&
1098 (info_ptr->valid & PNG_INFO_tRNS) != 0)
1099 {
1100 png_debug1(1, "in %s retrieval function", "tRNS");
1101
1102 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1103 {
1104 if (trans_alpha != NULL)
1105 {
1106 *trans_alpha = info_ptr->trans_alpha;
1107 retval |= PNG_INFO_tRNS;
1108 }
1109
1110 if (trans_color != NULL)
1111 *trans_color = &(info_ptr->trans_color);
1112 }
1113
1114 else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
1115 {
1116 if (trans_color != NULL)
1117 {
1118 *trans_color = &(info_ptr->trans_color);
1119 retval |= PNG_INFO_tRNS;
1120 }
1121
1122 if (trans_alpha != NULL)
1123 *trans_alpha = NULL;
1124 }
1125
1126 if (num_trans != NULL)
1127 {
1128 *num_trans = info_ptr->num_trans;
1129 retval |= PNG_INFO_tRNS;
1130 }
1131 }
1132
1133 return (retval);
1134}
1135#endif
1136
1137#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
1138int PNGAPI
1139png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr,
1140 png_unknown_chunkpp unknowns)
1141{
1142 if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
1143 {
1144 *unknowns = info_ptr->unknown_chunks;
1145 return info_ptr->unknown_chunks_num;
1146 }
1147
1148 return (0);
1149}
1150#endif
1151
1152#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1153png_byte PNGAPI
1154png_get_rgb_to_gray_status (png_const_structrp png_ptr)
1155{
1156 return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);
1157}
1158#endif
1159
1160#ifdef PNG_USER_CHUNKS_SUPPORTED
1161png_voidp PNGAPI
1162png_get_user_chunk_ptr(png_const_structrp png_ptr)
1163{
1164 return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
1165}
1166#endif
1167
1168size_t PNGAPI
1169png_get_compression_buffer_size(png_const_structrp png_ptr)
1170{
1171 if (png_ptr == NULL)
1172 return 0;
1173
1174#ifdef PNG_WRITE_SUPPORTED
1175 if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
1176#endif
1177 {
1178#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1179 return png_ptr->IDAT_read_size;
1180#else
1181 return PNG_IDAT_READ_SIZE;
1182#endif
1183 }
1184
1185#ifdef PNG_WRITE_SUPPORTED
1186 else
1187 return png_ptr->zbuffer_size;
1188#endif
1189}
1190
1191#ifdef PNG_SET_USER_LIMITS_SUPPORTED
1192/* These functions were added to libpng 1.2.6 and were enabled
1193 * by default in libpng-1.4.0 */
1194png_uint_32 PNGAPI
1195png_get_user_width_max (png_const_structrp png_ptr)
1196{
1197 return (png_ptr ? png_ptr->user_width_max : 0);
1198}
1199
1200png_uint_32 PNGAPI
1201png_get_user_height_max (png_const_structrp png_ptr)
1202{
1203 return (png_ptr ? png_ptr->user_height_max : 0);
1204}
1205
1206/* This function was added to libpng 1.4.0 */
1207png_uint_32 PNGAPI
1208png_get_chunk_cache_max (png_const_structrp png_ptr)
1209{
1210 return (png_ptr ? png_ptr->user_chunk_cache_max : 0);
1211}
1212
1213/* This function was added to libpng 1.4.1 */
1214png_alloc_size_t PNGAPI
1215png_get_chunk_malloc_max (png_const_structrp png_ptr)
1216{
1217 return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);
1218}
1219#endif /* SET_USER_LIMITS */
1220
1221/* These functions were added to libpng 1.4.0 */
1222#ifdef PNG_IO_STATE_SUPPORTED
1223png_uint_32 PNGAPI
1224png_get_io_state (png_const_structrp png_ptr)
1225{
1226 return png_ptr->io_state;
1227}
1228
1229png_uint_32 PNGAPI
1230png_get_io_chunk_type (png_const_structrp png_ptr)
1231{
1232 return png_ptr->chunk_name;
1233}
1234#endif /* IO_STATE */
1235
1236#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
1237# ifdef PNG_GET_PALETTE_MAX_SUPPORTED
1238int PNGAPI
1239png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr)
1240{
1241 if (png_ptr != NULL && info_ptr != NULL)
1242 return png_ptr->num_palette_max;
1243
1244 return (-1);
1245}
1246# endif
1247#endif
1248
1249#endif /* READ || WRITE */
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette