← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to source/Irrlicht/libpng/pngget.c

  • Committer: Mantas Kriaučiūnas
  • Date: 2011-07-18 13:06:25 UTC
  • Revision ID: mantas@akl.lt-20110718130625-c5pvifp61e7kj1ol
Included whole irrlicht SVN libraries to work around launchpad recipe issue with quilt, see https://answers.launchpad.net/launchpad/+question/165193

Show diffs side-by-side

added added

removed removed

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