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