← Back to branch summary

~thomas-voss/glmark2/build-for-mir

« back to all changes in this revision

Viewing changes to src/libpng/pngread.c

  • Committer: Package Import Robot
  • Author(s): Alexandros Frantzis
  • Date: 2011-09-22 11:32:17 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: package-import@ubuntu.com-20110922113217-wvok1qgruexari8d
Tags: 2011.09-0ubuntu1
* New upstream release 2011.09.
* debian/control:
  - Start the description of the glmark2-data package with
    a lowercase letter.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libpng/pngread.c
 
1
 
 
2
/* pngread.c - read a PNG file
 
3
 *
 
4
 * Last changed in libpng 1.2.44 [June 26, 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
 * This file contains routines that an application calls directly to
 
14
 * read a PNG file or stream.
 
15
 */
 
16
 
 
17
#define PNG_INTERNAL
 
18
#define PNG_NO_PEDANTIC_WARNINGS
 
19
#include "png.h"
 
20
#ifdef PNG_READ_SUPPORTED
 
21
 
 
22
 
 
23
/* Create a PNG structure for reading, and allocate any memory needed. */
 
24
png_structp PNGAPI
 
25
png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
 
26
   png_error_ptr error_fn, png_error_ptr warn_fn)
 
27
{
 
28
 
 
29
#ifdef PNG_USER_MEM_SUPPORTED
 
30
   return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
 
31
      warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));
 
32
}
 
33
 
 
34
/* Alternate create PNG structure for reading, and allocate any memory
 
35
 * needed.
 
36
 */
 
37
png_structp PNGAPI
 
38
png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
 
39
   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
 
40
   png_malloc_ptr malloc_fn, png_free_ptr free_fn)
 
41
{
 
42
#endif /* PNG_USER_MEM_SUPPORTED */
 
43
 
 
44
#ifdef PNG_SETJMP_SUPPORTED
 
45
   volatile
 
46
#endif
 
47
   png_structp png_ptr;
 
48
 
 
49
#ifdef PNG_SETJMP_SUPPORTED
 
50
#ifdef USE_FAR_KEYWORD
 
51
   jmp_buf jmpbuf;
 
52
#endif
 
53
#endif
 
54
 
 
55
   int i;
 
56
 
 
57
   png_debug(1, "in png_create_read_struct");
 
58
 
 
59
#ifdef PNG_USER_MEM_SUPPORTED
 
60
   png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
 
61
      (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
 
62
#else
 
63
   png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
 
64
#endif
 
65
   if (png_ptr == NULL)
 
66
      return (NULL);
 
67
 
 
68
   /* Added at libpng-1.2.6 */
 
69
#ifdef PNG_USER_LIMITS_SUPPORTED
 
70
   png_ptr->user_width_max = PNG_USER_WIDTH_MAX;
 
71
   png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;
 
72
#  ifdef PNG_USER_CHUNK_CACHE_MAX
 
73
   /* Added at libpng-1.2.43 and 1.4.0 */
 
74
   png_ptr->user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;
 
75
#  endif
 
76
#  ifdef PNG_SET_USER_CHUNK_MALLOC_MAX
 
77
   /* Added at libpng-1.2.43 and 1.4.1 */
 
78
   png_ptr->user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;
 
79
#  endif
 
80
#endif
 
81
 
 
82
#ifdef PNG_SETJMP_SUPPORTED
 
83
#ifdef USE_FAR_KEYWORD
 
84
   if (setjmp(jmpbuf))
 
85
#else
 
86
   if (setjmp(png_ptr->jmpbuf))
 
87
#endif
 
88
   {
 
89
      png_free(png_ptr, png_ptr->zbuf);
 
90
      png_ptr->zbuf = NULL;
 
91
#ifdef PNG_USER_MEM_SUPPORTED
 
92
      png_destroy_struct_2((png_voidp)png_ptr,
 
93
         (png_free_ptr)free_fn, (png_voidp)mem_ptr);
 
94
#else
 
95
      png_destroy_struct((png_voidp)png_ptr);
 
96
#endif
 
97
      return (NULL);
 
98
   }
 
99
#ifdef USE_FAR_KEYWORD
 
100
   png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));
 
101
#endif
 
102
#endif /* PNG_SETJMP_SUPPORTED */
 
103
 
 
104
#ifdef PNG_USER_MEM_SUPPORTED
 
105
   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
 
106
#endif
 
107
 
 
108
   png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
 
109
 
 
110
   if (user_png_ver)
 
111
   {
 
112
      i = 0;
 
113
      do
 
114
      {
 
115
         if (user_png_ver[i] != png_libpng_ver[i])
 
116
            png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
 
117
      } while (png_libpng_ver[i++]);
 
118
    }
 
119
    else
 
120
         png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
 
121
 
 
122
 
 
123
    if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
 
124
    {
 
125
       /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
 
126
       * we must recompile any applications that use any older library version.
 
127
       * For versions after libpng 1.0, we will be compatible, so we need
 
128
       * only check the first digit.
 
129
       */
 
130
      if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
 
131
          (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
 
132
          (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
 
133
      {
 
134
#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE)
 
135
         char msg[80];
 
136
         if (user_png_ver)
 
137
         {
 
138
           png_snprintf(msg, 80,
 
139
              "Application was compiled with png.h from libpng-%.20s",
 
140
              user_png_ver);
 
141
           png_warning(png_ptr, msg);
 
142
         }
 
143
         png_snprintf(msg, 80,
 
144
             "Application  is  running with png.c from libpng-%.20s",
 
145
             png_libpng_ver);
 
146
         png_warning(png_ptr, msg);
 
147
#endif
 
148
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
 
149
         png_ptr->flags = 0;
 
150
#endif
 
151
         png_error(png_ptr,
 
152
            "Incompatible libpng version in application and library");
 
153
      }
 
154
   }
 
155
 
 
156
   /* Initialize zbuf - compression buffer */
 
157
   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
 
158
   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
 
159
     (png_uint_32)png_ptr->zbuf_size);
 
160
   png_ptr->zstream.zalloc = png_zalloc;
 
161
   png_ptr->zstream.zfree = png_zfree;
 
162
   png_ptr->zstream.opaque = (voidpf)png_ptr;
 
163
 
 
164
      switch (inflateInit(&png_ptr->zstream))
 
165
      {
 
166
         case Z_OK: /* Do nothing */ break;
 
167
         case Z_MEM_ERROR:
 
168
         case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error");
 
169
            break;
 
170
         case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error");
 
171
            break;
 
172
         default: png_error(png_ptr, "Unknown zlib error");
 
173
      }
 
174
 
 
175
 
 
176
   png_ptr->zstream.next_out = png_ptr->zbuf;
 
177
   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
 
178
 
 
179
   png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);
 
180
 
 
181
#ifdef PNG_SETJMP_SUPPORTED
 
182
/* Applications that neglect to set up their own setjmp() and then
 
183
   encounter a png_error() will longjmp here.  Since the jmpbuf is
 
184
   then meaningless we abort instead of returning. */
 
185
#ifdef USE_FAR_KEYWORD
 
186
   if (setjmp(jmpbuf))
 
187
       PNG_ABORT();
 
188
   png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));
 
189
#else
 
190
   if (setjmp(png_ptr->jmpbuf))
 
191
       PNG_ABORT();
 
192
#endif
 
193
#endif /* PNG_SETJMP_SUPPORTED */
 
194
 
 
195
   return (png_ptr);
 
196
}
 
197
 
 
198
#if defined(PNG_1_0_X) || defined(PNG_1_2_X)
 
199
/* Initialize PNG structure for reading, and allocate any memory needed.
 
200
 * This interface is deprecated in favour of the png_create_read_struct(),
 
201
 * and it will disappear as of libpng-1.3.0.
 
202
 */
 
203
#undef png_read_init
 
204
void PNGAPI
 
205
png_read_init(png_structp png_ptr)
 
206
{
 
207
   /* We only come here via pre-1.0.7-compiled applications */
 
208
   png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0);
 
209
}
 
210
 
 
211
void PNGAPI
 
212
png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,
 
213
   png_size_t png_struct_size, png_size_t png_info_size)
 
214
{
 
215
   /* We only come here via pre-1.0.12-compiled applications */
 
216
   if (png_ptr == NULL)
 
217
      return;
 
218
#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE)
 
219
   if (png_sizeof(png_struct) > png_struct_size ||
 
220
      png_sizeof(png_info) > png_info_size)
 
221
   {
 
222
      char msg[80];
 
223
      png_ptr->warning_fn = NULL;
 
224
      if (user_png_ver)
 
225
      {
 
226
        png_snprintf(msg, 80,
 
227
           "Application was compiled with png.h from libpng-%.20s",
 
228
           user_png_ver);
 
229
        png_warning(png_ptr, msg);
 
230
      }
 
231
      png_snprintf(msg, 80,
 
232
         "Application  is  running with png.c from libpng-%.20s",
 
233
         png_libpng_ver);
 
234
      png_warning(png_ptr, msg);
 
235
   }
 
236
#endif
 
237
   if (png_sizeof(png_struct) > png_struct_size)
 
238
   {
 
239
      png_ptr->error_fn = NULL;
 
240
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
 
241
      png_ptr->flags = 0;
 
242
#endif
 
243
      png_error(png_ptr,
 
244
      "The png struct allocated by the application for reading is"
 
245
      " too small.");
 
246
   }
 
247
   if (png_sizeof(png_info) > png_info_size)
 
248
   {
 
249
      png_ptr->error_fn = NULL;
 
250
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
 
251
      png_ptr->flags = 0;
 
252
#endif
 
253
      png_error(png_ptr,
 
254
        "The info struct allocated by application for reading is"
 
255
        " too small.");
 
256
   }
 
257
   png_read_init_3(&png_ptr, user_png_ver, png_struct_size);
 
258
}
 
259
#endif /* PNG_1_0_X || PNG_1_2_X */
 
260
 
 
261
void PNGAPI
 
262
png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
 
263
   png_size_t png_struct_size)
 
264
{
 
265
#ifdef PNG_SETJMP_SUPPORTED
 
266
   jmp_buf tmp_jmp;  /* to save current jump buffer */
 
267
#endif
 
268
 
 
269
   int i = 0;
 
270
 
 
271
   png_structp png_ptr=*ptr_ptr;
 
272
 
 
273
   if (png_ptr == NULL)
 
274
      return;
 
275
 
 
276
   do
 
277
   {
 
278
      if (user_png_ver[i] != png_libpng_ver[i])
 
279
      {
 
280
#ifdef PNG_LEGACY_SUPPORTED
 
281
        png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
 
282
#else
 
283
        png_ptr->warning_fn = NULL;
 
284
        png_warning(png_ptr,
 
285
         "Application uses deprecated png_read_init() and should be"
 
286
         " recompiled.");
 
287
        break;
 
288
#endif
 
289
      }
 
290
   } while (png_libpng_ver[i++]);
 
291
 
 
292
   png_debug(1, "in png_read_init_3");
 
293
 
 
294
#ifdef PNG_SETJMP_SUPPORTED
 
295
   /* Save jump buffer and error functions */
 
296
   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
 
297
#endif
 
298
 
 
299
   if (png_sizeof(png_struct) > png_struct_size)
 
300
   {
 
301
      png_destroy_struct(png_ptr);
 
302
      *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
 
303
      png_ptr = *ptr_ptr;
 
304
   }
 
305
 
 
306
   /* Reset all variables to 0 */
 
307
   png_memset(png_ptr, 0, png_sizeof(png_struct));
 
308
 
 
309
#ifdef PNG_SETJMP_SUPPORTED
 
310
   /* Restore jump buffer */
 
311
   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
 
312
#endif
 
313
 
 
314
   /* Added at libpng-1.2.6 */
 
315
#ifdef PNG_SET_USER_LIMITS_SUPPORTED
 
316
   png_ptr->user_width_max = PNG_USER_WIDTH_MAX;
 
317
   png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;
 
318
#endif
 
319
 
 
320
   /* Initialize zbuf - compression buffer */
 
321
   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
 
322
   png_ptr->zstream.zalloc = png_zalloc;
 
323
   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
 
324
     (png_uint_32)png_ptr->zbuf_size);
 
325
   png_ptr->zstream.zalloc = png_zalloc;
 
326
   png_ptr->zstream.zfree = png_zfree;
 
327
   png_ptr->zstream.opaque = (voidpf)png_ptr;
 
328
 
 
329
   switch (inflateInit(&png_ptr->zstream))
 
330
   {
 
331
      case Z_OK: /* Do nothing */ break;
 
332
      case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;
 
333
      case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error");
 
334
          break;
 
335
      default: png_error(png_ptr, "Unknown zlib error");
 
336
   }
 
337
 
 
338
   png_ptr->zstream.next_out = png_ptr->zbuf;
 
339
   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
 
340
 
 
341
   png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);
 
342
}
 
343
 
 
344
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 
345
/* Read the information before the actual image data.  This has been
 
346
 * changed in v0.90 to allow reading a file that already has the magic
 
347
 * bytes read from the stream.  You can tell libpng how many bytes have
 
348
 * been read from the beginning of the stream (up to the maximum of 8)
 
349
 * via png_set_sig_bytes(), and we will only check the remaining bytes
 
350
 * here.  The application can then have access to the signature bytes we
 
351
 * read if it is determined that this isn't a valid PNG file.
 
352
 */
 
353
void PNGAPI
 
354
png_read_info(png_structp png_ptr, png_infop info_ptr)
 
355
{
 
356
   png_debug(1, "in png_read_info");
 
357
 
 
358
   if (png_ptr == NULL || info_ptr == NULL)
 
359
      return;
 
360
 
 
361
   /* If we haven't checked all of the PNG signature bytes, do so now. */
 
362
   if (png_ptr->sig_bytes < 8)
 
363
   {
 
364
      png_size_t num_checked = png_ptr->sig_bytes,
 
365
                 num_to_check = 8 - num_checked;
 
366
 
 
367
      png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
 
368
      png_ptr->sig_bytes = 8;
 
369
 
 
370
      if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
 
371
      {
 
372
         if (num_checked < 4 &&
 
373
             png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
 
374
            png_error(png_ptr, "Not a PNG file");
 
375
         else
 
376
            png_error(png_ptr, "PNG file corrupted by ASCII conversion");
 
377
      }
 
378
      if (num_checked < 3)
 
379
         png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
 
380
   }
 
381
 
 
382
   for (;;)
 
383
   {
 
384
#ifdef PNG_USE_LOCAL_ARRAYS
 
385
      PNG_CONST PNG_IHDR;
 
386
      PNG_CONST PNG_IDAT;
 
387
      PNG_CONST PNG_IEND;
 
388
      PNG_CONST PNG_PLTE;
 
389
#ifdef PNG_READ_bKGD_SUPPORTED
 
390
      PNG_CONST PNG_bKGD;
 
391
#endif
 
392
#ifdef PNG_READ_cHRM_SUPPORTED
 
393
      PNG_CONST PNG_cHRM;
 
394
#endif
 
395
#ifdef PNG_READ_gAMA_SUPPORTED
 
396
      PNG_CONST PNG_gAMA;
 
397
#endif
 
398
#ifdef PNG_READ_hIST_SUPPORTED
 
399
      PNG_CONST PNG_hIST;
 
400
#endif
 
401
#ifdef PNG_READ_iCCP_SUPPORTED
 
402
      PNG_CONST PNG_iCCP;
 
403
#endif
 
404
#ifdef PNG_READ_iTXt_SUPPORTED
 
405
      PNG_CONST PNG_iTXt;
 
406
#endif
 
407
#ifdef PNG_READ_oFFs_SUPPORTED
 
408
      PNG_CONST PNG_oFFs;
 
409
#endif
 
410
#ifdef PNG_READ_pCAL_SUPPORTED
 
411
      PNG_CONST PNG_pCAL;
 
412
#endif
 
413
#ifdef PNG_READ_pHYs_SUPPORTED
 
414
      PNG_CONST PNG_pHYs;
 
415
#endif
 
416
#ifdef PNG_READ_sBIT_SUPPORTED
 
417
      PNG_CONST PNG_sBIT;
 
418
#endif
 
419
#ifdef PNG_READ_sCAL_SUPPORTED
 
420
      PNG_CONST PNG_sCAL;
 
421
#endif
 
422
#ifdef PNG_READ_sPLT_SUPPORTED
 
423
      PNG_CONST PNG_sPLT;
 
424
#endif
 
425
#ifdef PNG_READ_sRGB_SUPPORTED
 
426
      PNG_CONST PNG_sRGB;
 
427
#endif
 
428
#ifdef PNG_READ_tEXt_SUPPORTED
 
429
      PNG_CONST PNG_tEXt;
 
430
#endif
 
431
#ifdef PNG_READ_tIME_SUPPORTED
 
432
      PNG_CONST PNG_tIME;
 
433
#endif
 
434
#ifdef PNG_READ_tRNS_SUPPORTED
 
435
      PNG_CONST PNG_tRNS;
 
436
#endif
 
437
#ifdef PNG_READ_zTXt_SUPPORTED
 
438
      PNG_CONST PNG_zTXt;
 
439
#endif
 
440
#endif /* PNG_USE_LOCAL_ARRAYS */
 
441
      png_uint_32 length = png_read_chunk_header(png_ptr);
 
442
      PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;
 
443
 
 
444
      /* This should be a binary subdivision search or a hash for
 
445
       * matching the chunk name rather than a linear search.
 
446
       */
 
447
      if (!png_memcmp(chunk_name, png_IDAT, 4))
 
448
        if (png_ptr->mode & PNG_AFTER_IDAT)
 
449
          png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
 
450
 
 
451
      if (!png_memcmp(chunk_name, png_IHDR, 4))
 
452
         png_handle_IHDR(png_ptr, info_ptr, length);
 
453
      else if (!png_memcmp(chunk_name, png_IEND, 4))
 
454
         png_handle_IEND(png_ptr, info_ptr, length);
 
455
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 
456
      else if (png_handle_as_unknown(png_ptr, chunk_name))
 
457
      {
 
458
         if (!png_memcmp(chunk_name, png_IDAT, 4))
 
459
            png_ptr->mode |= PNG_HAVE_IDAT;
 
460
         png_handle_unknown(png_ptr, info_ptr, length);
 
461
         if (!png_memcmp(chunk_name, png_PLTE, 4))
 
462
            png_ptr->mode |= PNG_HAVE_PLTE;
 
463
         else if (!png_memcmp(chunk_name, png_IDAT, 4))
 
464
         {
 
465
            if (!(png_ptr->mode & PNG_HAVE_IHDR))
 
466
               png_error(png_ptr, "Missing IHDR before IDAT");
 
467
            else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
 
468
                     !(png_ptr->mode & PNG_HAVE_PLTE))
 
469
               png_error(png_ptr, "Missing PLTE before IDAT");
 
470
            break;
 
471
         }
 
472
      }
 
473
#endif
 
474
      else if (!png_memcmp(chunk_name, png_PLTE, 4))
 
475
         png_handle_PLTE(png_ptr, info_ptr, length);
 
476
      else if (!png_memcmp(chunk_name, png_IDAT, 4))
 
477
      {
 
478
         if (!(png_ptr->mode & PNG_HAVE_IHDR))
 
479
            png_error(png_ptr, "Missing IHDR before IDAT");
 
480
         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
 
481
                  !(png_ptr->mode & PNG_HAVE_PLTE))
 
482
            png_error(png_ptr, "Missing PLTE before IDAT");
 
483
 
 
484
         png_ptr->idat_size = length;
 
485
         png_ptr->mode |= PNG_HAVE_IDAT;
 
486
         break;
 
487
      }
 
488
#ifdef PNG_READ_bKGD_SUPPORTED
 
489
      else if (!png_memcmp(chunk_name, png_bKGD, 4))
 
490
         png_handle_bKGD(png_ptr, info_ptr, length);
 
491
#endif
 
492
#ifdef PNG_READ_cHRM_SUPPORTED
 
493
      else if (!png_memcmp(chunk_name, png_cHRM, 4))
 
494
         png_handle_cHRM(png_ptr, info_ptr, length);
 
495
#endif
 
496
#ifdef PNG_READ_gAMA_SUPPORTED
 
497
      else if (!png_memcmp(chunk_name, png_gAMA, 4))
 
498
         png_handle_gAMA(png_ptr, info_ptr, length);
 
499
#endif
 
500
#ifdef PNG_READ_hIST_SUPPORTED
 
501
      else if (!png_memcmp(chunk_name, png_hIST, 4))
 
502
         png_handle_hIST(png_ptr, info_ptr, length);
 
503
#endif
 
504
#ifdef PNG_READ_oFFs_SUPPORTED
 
505
      else if (!png_memcmp(chunk_name, png_oFFs, 4))
 
506
         png_handle_oFFs(png_ptr, info_ptr, length);
 
507
#endif
 
508
#ifdef PNG_READ_pCAL_SUPPORTED
 
509
      else if (!png_memcmp(chunk_name, png_pCAL, 4))
 
510
         png_handle_pCAL(png_ptr, info_ptr, length);
 
511
#endif
 
512
#ifdef PNG_READ_sCAL_SUPPORTED
 
513
      else if (!png_memcmp(chunk_name, png_sCAL, 4))
 
514
         png_handle_sCAL(png_ptr, info_ptr, length);
 
515
#endif
 
516
#ifdef PNG_READ_pHYs_SUPPORTED
 
517
      else if (!png_memcmp(chunk_name, png_pHYs, 4))
 
518
         png_handle_pHYs(png_ptr, info_ptr, length);
 
519
#endif
 
520
#ifdef PNG_READ_sBIT_SUPPORTED
 
521
      else if (!png_memcmp(chunk_name, png_sBIT, 4))
 
522
         png_handle_sBIT(png_ptr, info_ptr, length);
 
523
#endif
 
524
#ifdef PNG_READ_sRGB_SUPPORTED
 
525
      else if (!png_memcmp(chunk_name, png_sRGB, 4))
 
526
         png_handle_sRGB(png_ptr, info_ptr, length);
 
527
#endif
 
528
#ifdef PNG_READ_iCCP_SUPPORTED
 
529
      else if (!png_memcmp(chunk_name, png_iCCP, 4))
 
530
         png_handle_iCCP(png_ptr, info_ptr, length);
 
531
#endif
 
532
#ifdef PNG_READ_sPLT_SUPPORTED
 
533
      else if (!png_memcmp(chunk_name, png_sPLT, 4))
 
534
         png_handle_sPLT(png_ptr, info_ptr, length);
 
535
#endif
 
536
#ifdef PNG_READ_tEXt_SUPPORTED
 
537
      else if (!png_memcmp(chunk_name, png_tEXt, 4))
 
538
         png_handle_tEXt(png_ptr, info_ptr, length);
 
539
#endif
 
540
#ifdef PNG_READ_tIME_SUPPORTED
 
541
      else if (!png_memcmp(chunk_name, png_tIME, 4))
 
542
         png_handle_tIME(png_ptr, info_ptr, length);
 
543
#endif
 
544
#ifdef PNG_READ_tRNS_SUPPORTED
 
545
      else if (!png_memcmp(chunk_name, png_tRNS, 4))
 
546
         png_handle_tRNS(png_ptr, info_ptr, length);
 
547
#endif
 
548
#ifdef PNG_READ_zTXt_SUPPORTED
 
549
      else if (!png_memcmp(chunk_name, png_zTXt, 4))
 
550
         png_handle_zTXt(png_ptr, info_ptr, length);
 
551
#endif
 
552
#ifdef PNG_READ_iTXt_SUPPORTED
 
553
      else if (!png_memcmp(chunk_name, png_iTXt, 4))
 
554
         png_handle_iTXt(png_ptr, info_ptr, length);
 
555
#endif
 
556
      else
 
557
         png_handle_unknown(png_ptr, info_ptr, length);
 
558
   }
 
559
}
 
560
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
 
561
 
 
562
/* Optional call to update the users info_ptr structure */
 
563
void PNGAPI
 
564
png_read_update_info(png_structp png_ptr, png_infop info_ptr)
 
565
{
 
566
   png_debug(1, "in png_read_update_info");
 
567
 
 
568
   if (png_ptr == NULL)
 
569
      return;
 
570
   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
 
571
      png_read_start_row(png_ptr);
 
572
   else
 
573
      png_warning(png_ptr,
 
574
      "Ignoring extra png_read_update_info() call; row buffer not reallocated");
 
575
 
 
576
   png_read_transform_info(png_ptr, info_ptr);
 
577
}
 
578
 
 
579
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 
580
/* Initialize palette, background, etc, after transformations
 
581
 * are set, but before any reading takes place.  This allows
 
582
 * the user to obtain a gamma-corrected palette, for example.
 
583
 * If the user doesn't call this, we will do it ourselves.
 
584
 */
 
585
void PNGAPI
 
586
png_start_read_image(png_structp png_ptr)
 
587
{
 
588
   png_debug(1, "in png_start_read_image");
 
589
 
 
590
   if (png_ptr == NULL)
 
591
      return;
 
592
   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
 
593
      png_read_start_row(png_ptr);
 
594
}
 
595
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
 
596
 
 
597
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 
598
void PNGAPI
 
599
png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
 
600
{
 
601
   PNG_CONST PNG_IDAT;
 
602
   PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,
 
603
      0xff};
 
604
   PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
 
605
   int ret;
 
606
 
 
607
   if (png_ptr == NULL)
 
608
      return;
 
609
 
 
610
   png_debug2(1, "in png_read_row (row %lu, pass %d)",
 
611
      png_ptr->row_number, png_ptr->pass);
 
612
 
 
613
   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
 
614
      png_read_start_row(png_ptr);
 
615
   if (png_ptr->row_number == 0 && png_ptr->pass == 0)
 
616
   {
 
617
   /* Check for transforms that have been set but were defined out */
 
618
#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
 
619
   if (png_ptr->transformations & PNG_INVERT_MONO)
 
620
      png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");
 
621
#endif
 
622
#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
 
623
   if (png_ptr->transformations & PNG_FILLER)
 
624
      png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined.");
 
625
#endif
 
626
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
 
627
    !defined(PNG_READ_PACKSWAP_SUPPORTED)
 
628
   if (png_ptr->transformations & PNG_PACKSWAP)
 
629
      png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined.");
 
630
#endif
 
631
#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
 
632
   if (png_ptr->transformations & PNG_PACK)
 
633
      png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined.");
 
634
#endif
 
635
#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
 
636
   if (png_ptr->transformations & PNG_SHIFT)
 
637
      png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined.");
 
638
#endif
 
639
#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
 
640
   if (png_ptr->transformations & PNG_BGR)
 
641
      png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined.");
 
642
#endif
 
643
#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
 
644
   if (png_ptr->transformations & PNG_SWAP_BYTES)
 
645
      png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");
 
646
#endif
 
647
   }
 
648
 
 
649
#ifdef PNG_READ_INTERLACING_SUPPORTED
 
650
   /* If interlaced and we do not need a new row, combine row and return */
 
651
   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
 
652
   {
 
653
      switch (png_ptr->pass)
 
654
      {
 
655
         case 0:
 
656
            if (png_ptr->row_number & 0x07)
 
657
            {
 
658
               if (dsp_row != NULL)
 
659
                  png_combine_row(png_ptr, dsp_row,
 
660
                     png_pass_dsp_mask[png_ptr->pass]);
 
661
               png_read_finish_row(png_ptr);
 
662
               return;
 
663
            }
 
664
            break;
 
665
         case 1:
 
666
            if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
 
667
            {
 
668
               if (dsp_row != NULL)
 
669
                  png_combine_row(png_ptr, dsp_row,
 
670
                     png_pass_dsp_mask[png_ptr->pass]);
 
671
               png_read_finish_row(png_ptr);
 
672
               return;
 
673
            }
 
674
            break;
 
675
         case 2:
 
676
            if ((png_ptr->row_number & 0x07) != 4)
 
677
            {
 
678
               if (dsp_row != NULL && (png_ptr->row_number & 4))
 
679
                  png_combine_row(png_ptr, dsp_row,
 
680
                     png_pass_dsp_mask[png_ptr->pass]);
 
681
               png_read_finish_row(png_ptr);
 
682
               return;
 
683
            }
 
684
            break;
 
685
         case 3:
 
686
            if ((png_ptr->row_number & 3) || png_ptr->width < 3)
 
687
            {
 
688
               if (dsp_row != NULL)
 
689
                  png_combine_row(png_ptr, dsp_row,
 
690
                     png_pass_dsp_mask[png_ptr->pass]);
 
691
               png_read_finish_row(png_ptr);
 
692
               return;
 
693
            }
 
694
            break;
 
695
         case 4:
 
696
            if ((png_ptr->row_number & 3) != 2)
 
697
            {
 
698
               if (dsp_row != NULL && (png_ptr->row_number & 2))
 
699
                  png_combine_row(png_ptr, dsp_row,
 
700
                     png_pass_dsp_mask[png_ptr->pass]);
 
701
               png_read_finish_row(png_ptr);
 
702
               return;
 
703
            }
 
704
            break;
 
705
         case 5:
 
706
            if ((png_ptr->row_number & 1) || png_ptr->width < 2)
 
707
            {
 
708
               if (dsp_row != NULL)
 
709
                  png_combine_row(png_ptr, dsp_row,
 
710
                     png_pass_dsp_mask[png_ptr->pass]);
 
711
               png_read_finish_row(png_ptr);
 
712
               return;
 
713
            }
 
714
            break;
 
715
         case 6:
 
716
            if (!(png_ptr->row_number & 1))
 
717
            {
 
718
               png_read_finish_row(png_ptr);
 
719
               return;
 
720
            }
 
721
            break;
 
722
      }
 
723
   }
 
724
#endif
 
725
 
 
726
   if (!(png_ptr->mode & PNG_HAVE_IDAT))
 
727
      png_error(png_ptr, "Invalid attempt to read row data");
 
728
 
 
729
   png_ptr->zstream.next_out = png_ptr->row_buf;
 
730
   png_ptr->zstream.avail_out =
 
731
       (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,
 
732
       png_ptr->iwidth) + 1);
 
733
   do
 
734
   {
 
735
      if (!(png_ptr->zstream.avail_in))
 
736
      {
 
737
         while (!png_ptr->idat_size)
 
738
         {
 
739
            png_crc_finish(png_ptr, 0);
 
740
 
 
741
            png_ptr->idat_size = png_read_chunk_header(png_ptr);
 
742
            if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
 
743
               png_error(png_ptr, "Not enough image data");
 
744
         }
 
745
         png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
 
746
         png_ptr->zstream.next_in = png_ptr->zbuf;
 
747
         if (png_ptr->zbuf_size > png_ptr->idat_size)
 
748
            png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
 
749
         png_crc_read(png_ptr, png_ptr->zbuf,
 
750
            (png_size_t)png_ptr->zstream.avail_in);
 
751
         png_ptr->idat_size -= png_ptr->zstream.avail_in;
 
752
      }
 
753
      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
 
754
      if (ret == Z_STREAM_END)
 
755
      {
 
756
         if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||
 
757
            png_ptr->idat_size)
 
758
            png_error(png_ptr, "Extra compressed data");
 
759
         png_ptr->mode |= PNG_AFTER_IDAT;
 
760
         png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
 
761
         break;
 
762
      }
 
763
      if (ret != Z_OK)
 
764
         png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
 
765
                   "Decompression error");
 
766
 
 
767
   } while (png_ptr->zstream.avail_out);
 
768
 
 
769
   png_ptr->row_info.color_type = png_ptr->color_type;
 
770
   png_ptr->row_info.width = png_ptr->iwidth;
 
771
   png_ptr->row_info.channels = png_ptr->channels;
 
772
   png_ptr->row_info.bit_depth = png_ptr->bit_depth;
 
773
   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
 
774
   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
 
775
       png_ptr->row_info.width);
 
776
 
 
777
   if (png_ptr->row_buf[0])
 
778
   png_read_filter_row(png_ptr, &(png_ptr->row_info),
 
779
      png_ptr->row_buf + 1, png_ptr->prev_row + 1,
 
780
      (int)(png_ptr->row_buf[0]));
 
781
 
 
782
   png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
 
783
      png_ptr->rowbytes + 1);
 
784
 
 
785
#ifdef PNG_MNG_FEATURES_SUPPORTED
 
786
   if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
 
787
      (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
 
788
   {
 
789
      /* Intrapixel differencing */
 
790
      png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
 
791
   }
 
792
#endif
 
793
 
 
794
 
 
795
   if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
 
796
      png_do_read_transformations(png_ptr);
 
797
 
 
798
#ifdef PNG_READ_INTERLACING_SUPPORTED
 
799
   /* Blow up interlaced rows to full size */
 
800
   if (png_ptr->interlaced &&
 
801
      (png_ptr->transformations & PNG_INTERLACE))
 
802
   {
 
803
      if (png_ptr->pass < 6)
 
804
         /* Old interface (pre-1.0.9):
 
805
          * png_do_read_interlace(&(png_ptr->row_info),
 
806
          *    png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
 
807
          */
 
808
         png_do_read_interlace(png_ptr);
 
809
 
 
810
      if (dsp_row != NULL)
 
811
         png_combine_row(png_ptr, dsp_row,
 
812
            png_pass_dsp_mask[png_ptr->pass]);
 
813
      if (row != NULL)
 
814
         png_combine_row(png_ptr, row,
 
815
            png_pass_mask[png_ptr->pass]);
 
816
   }
 
817
   else
 
818
#endif
 
819
   {
 
820
      if (row != NULL)
 
821
         png_combine_row(png_ptr, row, 0xff);
 
822
      if (dsp_row != NULL)
 
823
         png_combine_row(png_ptr, dsp_row, 0xff);
 
824
   }
 
825
   png_read_finish_row(png_ptr);
 
826
 
 
827
   if (png_ptr->read_row_fn != NULL)
 
828
      (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
 
829
}
 
830
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
 
831
 
 
832
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 
833
/* Read one or more rows of image data.  If the image is interlaced,
 
834
 * and png_set_interlace_handling() has been called, the rows need to
 
835
 * contain the contents of the rows from the previous pass.  If the
 
836
 * image has alpha or transparency, and png_handle_alpha()[*] has been
 
837
 * called, the rows contents must be initialized to the contents of the
 
838
 * screen.
 
839
 *
 
840
 * "row" holds the actual image, and pixels are placed in it
 
841
 * as they arrive.  If the image is displayed after each pass, it will
 
842
 * appear to "sparkle" in.  "display_row" can be used to display a
 
843
 * "chunky" progressive image, with finer detail added as it becomes
 
844
 * available.  If you do not want this "chunky" display, you may pass
 
845
 * NULL for display_row.  If you do not want the sparkle display, and
 
846
 * you have not called png_handle_alpha(), you may pass NULL for rows.
 
847
 * If you have called png_handle_alpha(), and the image has either an
 
848
 * alpha channel or a transparency chunk, you must provide a buffer for
 
849
 * rows.  In this case, you do not have to provide a display_row buffer
 
850
 * also, but you may.  If the image is not interlaced, or if you have
 
851
 * not called png_set_interlace_handling(), the display_row buffer will
 
852
 * be ignored, so pass NULL to it.
 
853
 *
 
854
 * [*] png_handle_alpha() does not exist yet, as of this version of libpng
 
855
 */
 
856
 
 
857
void PNGAPI
 
858
png_read_rows(png_structp png_ptr, png_bytepp row,
 
859
   png_bytepp display_row, png_uint_32 num_rows)
 
860
{
 
861
   png_uint_32 i;
 
862
   png_bytepp rp;
 
863
   png_bytepp dp;
 
864
 
 
865
   png_debug(1, "in png_read_rows");
 
866
 
 
867
   if (png_ptr == NULL)
 
868
      return;
 
869
   rp = row;
 
870
   dp = display_row;
 
871
   if (rp != NULL && dp != NULL)
 
872
      for (i = 0; i < num_rows; i++)
 
873
      {
 
874
         png_bytep rptr = *rp++;
 
875
         png_bytep dptr = *dp++;
 
876
 
 
877
         png_read_row(png_ptr, rptr, dptr);
 
878
      }
 
879
   else if (rp != NULL)
 
880
      for (i = 0; i < num_rows; i++)
 
881
      {
 
882
         png_bytep rptr = *rp;
 
883
         png_read_row(png_ptr, rptr, png_bytep_NULL);
 
884
         rp++;
 
885
      }
 
886
   else if (dp != NULL)
 
887
      for (i = 0; i < num_rows; i++)
 
888
      {
 
889
         png_bytep dptr = *dp;
 
890
         png_read_row(png_ptr, png_bytep_NULL, dptr);
 
891
         dp++;
 
892
      }
 
893
}
 
894
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
 
895
 
 
896
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 
897
/* Read the entire image.  If the image has an alpha channel or a tRNS
 
898
 * chunk, and you have called png_handle_alpha()[*], you will need to
 
899
 * initialize the image to the current image that PNG will be overlaying.
 
900
 * We set the num_rows again here, in case it was incorrectly set in
 
901
 * png_read_start_row() by a call to png_read_update_info() or
 
902
 * png_start_read_image() if png_set_interlace_handling() wasn't called
 
903
 * prior to either of these functions like it should have been.  You can
 
904
 * only call this function once.  If you desire to have an image for
 
905
 * each pass of a interlaced image, use png_read_rows() instead.
 
906
 *
 
907
 * [*] png_handle_alpha() does not exist yet, as of this version of libpng
 
908
 */
 
909
void PNGAPI
 
910
png_read_image(png_structp png_ptr, png_bytepp image)
 
911
{
 
912
   png_uint_32 i, image_height;
 
913
   int pass, j;
 
914
   png_bytepp rp;
 
915
 
 
916
   png_debug(1, "in png_read_image");
 
917
 
 
918
   if (png_ptr == NULL)
 
919
      return;
 
920
 
 
921
#ifdef PNG_READ_INTERLACING_SUPPORTED
 
922
   pass = png_set_interlace_handling(png_ptr);
 
923
#else
 
924
   if (png_ptr->interlaced)
 
925
      png_error(png_ptr,
 
926
        "Cannot read interlaced image -- interlace handler disabled.");
 
927
   pass = 1;
 
928
#endif
 
929
 
 
930
 
 
931
   image_height=png_ptr->height;
 
932
   png_ptr->num_rows = image_height; /* Make sure this is set correctly */
 
933
 
 
934
   for (j = 0; j < pass; j++)
 
935
   {
 
936
      rp = image;
 
937
      for (i = 0; i < image_height; i++)
 
938
      {
 
939
         png_read_row(png_ptr, *rp, png_bytep_NULL);
 
940
         rp++;
 
941
      }
 
942
   }
 
943
}
 
944
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
 
945
 
 
946
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 
947
/* Read the end of the PNG file.  Will not read past the end of the
 
948
 * file, will verify the end is accurate, and will read any comments
 
949
 * or time information at the end of the file, if info is not NULL.
 
950
 */
 
951
void PNGAPI
 
952
png_read_end(png_structp png_ptr, png_infop info_ptr)
 
953
{
 
954
   png_debug(1, "in png_read_end");
 
955
 
 
956
   if (png_ptr == NULL)
 
957
      return;
 
958
   png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
 
959
 
 
960
   do
 
961
   {
 
962
#ifdef PNG_USE_LOCAL_ARRAYS
 
963
      PNG_CONST PNG_IHDR;
 
964
      PNG_CONST PNG_IDAT;
 
965
      PNG_CONST PNG_IEND;
 
966
      PNG_CONST PNG_PLTE;
 
967
#ifdef PNG_READ_bKGD_SUPPORTED
 
968
      PNG_CONST PNG_bKGD;
 
969
#endif
 
970
#ifdef PNG_READ_cHRM_SUPPORTED
 
971
      PNG_CONST PNG_cHRM;
 
972
#endif
 
973
#ifdef PNG_READ_gAMA_SUPPORTED
 
974
      PNG_CONST PNG_gAMA;
 
975
#endif
 
976
#ifdef PNG_READ_hIST_SUPPORTED
 
977
      PNG_CONST PNG_hIST;
 
978
#endif
 
979
#ifdef PNG_READ_iCCP_SUPPORTED
 
980
      PNG_CONST PNG_iCCP;
 
981
#endif
 
982
#ifdef PNG_READ_iTXt_SUPPORTED
 
983
      PNG_CONST PNG_iTXt;
 
984
#endif
 
985
#ifdef PNG_READ_oFFs_SUPPORTED
 
986
      PNG_CONST PNG_oFFs;
 
987
#endif
 
988
#ifdef PNG_READ_pCAL_SUPPORTED
 
989
      PNG_CONST PNG_pCAL;
 
990
#endif
 
991
#ifdef PNG_READ_pHYs_SUPPORTED
 
992
      PNG_CONST PNG_pHYs;
 
993
#endif
 
994
#ifdef PNG_READ_sBIT_SUPPORTED
 
995
      PNG_CONST PNG_sBIT;
 
996
#endif
 
997
#ifdef PNG_READ_sCAL_SUPPORTED
 
998
      PNG_CONST PNG_sCAL;
 
999
#endif
 
1000
#ifdef PNG_READ_sPLT_SUPPORTED
 
1001
      PNG_CONST PNG_sPLT;
 
1002
#endif
 
1003
#ifdef PNG_READ_sRGB_SUPPORTED
 
1004
      PNG_CONST PNG_sRGB;
 
1005
#endif
 
1006
#ifdef PNG_READ_tEXt_SUPPORTED
 
1007
      PNG_CONST PNG_tEXt;
 
1008
#endif
 
1009
#ifdef PNG_READ_tIME_SUPPORTED
 
1010
      PNG_CONST PNG_tIME;
 
1011
#endif
 
1012
#ifdef PNG_READ_tRNS_SUPPORTED
 
1013
      PNG_CONST PNG_tRNS;
 
1014
#endif
 
1015
#ifdef PNG_READ_zTXt_SUPPORTED
 
1016
      PNG_CONST PNG_zTXt;
 
1017
#endif
 
1018
#endif /* PNG_USE_LOCAL_ARRAYS */
 
1019
      png_uint_32 length = png_read_chunk_header(png_ptr);
 
1020
      PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;
 
1021
 
 
1022
      if (!png_memcmp(chunk_name, png_IHDR, 4))
 
1023
         png_handle_IHDR(png_ptr, info_ptr, length);
 
1024
      else if (!png_memcmp(chunk_name, png_IEND, 4))
 
1025
         png_handle_IEND(png_ptr, info_ptr, length);
 
1026
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 
1027
      else if (png_handle_as_unknown(png_ptr, chunk_name))
 
1028
      {
 
1029
         if (!png_memcmp(chunk_name, png_IDAT, 4))
 
1030
         {
 
1031
            if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
 
1032
               png_error(png_ptr, "Too many IDAT's found");
 
1033
         }
 
1034
         png_handle_unknown(png_ptr, info_ptr, length);
 
1035
         if (!png_memcmp(chunk_name, png_PLTE, 4))
 
1036
            png_ptr->mode |= PNG_HAVE_PLTE;
 
1037
      }
 
1038
#endif
 
1039
      else if (!png_memcmp(chunk_name, png_IDAT, 4))
 
1040
      {
 
1041
         /* Zero length IDATs are legal after the last IDAT has been
 
1042
          * read, but not after other chunks have been read.
 
1043
          */
 
1044
         if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
 
1045
            png_error(png_ptr, "Too many IDAT's found");
 
1046
         png_crc_finish(png_ptr, length);
 
1047
      }
 
1048
      else if (!png_memcmp(chunk_name, png_PLTE, 4))
 
1049
         png_handle_PLTE(png_ptr, info_ptr, length);
 
1050
#ifdef PNG_READ_bKGD_SUPPORTED
 
1051
      else if (!png_memcmp(chunk_name, png_bKGD, 4))
 
1052
         png_handle_bKGD(png_ptr, info_ptr, length);
 
1053
#endif
 
1054
#ifdef PNG_READ_cHRM_SUPPORTED
 
1055
      else if (!png_memcmp(chunk_name, png_cHRM, 4))
 
1056
         png_handle_cHRM(png_ptr, info_ptr, length);
 
1057
#endif
 
1058
#ifdef PNG_READ_gAMA_SUPPORTED
 
1059
      else if (!png_memcmp(chunk_name, png_gAMA, 4))
 
1060
         png_handle_gAMA(png_ptr, info_ptr, length);
 
1061
#endif
 
1062
#ifdef PNG_READ_hIST_SUPPORTED
 
1063
      else if (!png_memcmp(chunk_name, png_hIST, 4))
 
1064
         png_handle_hIST(png_ptr, info_ptr, length);
 
1065
#endif
 
1066
#ifdef PNG_READ_oFFs_SUPPORTED
 
1067
      else if (!png_memcmp(chunk_name, png_oFFs, 4))
 
1068
         png_handle_oFFs(png_ptr, info_ptr, length);
 
1069
#endif
 
1070
#ifdef PNG_READ_pCAL_SUPPORTED
 
1071
      else if (!png_memcmp(chunk_name, png_pCAL, 4))
 
1072
         png_handle_pCAL(png_ptr, info_ptr, length);
 
1073
#endif
 
1074
#ifdef PNG_READ_sCAL_SUPPORTED
 
1075
      else if (!png_memcmp(chunk_name, png_sCAL, 4))
 
1076
         png_handle_sCAL(png_ptr, info_ptr, length);
 
1077
#endif
 
1078
#ifdef PNG_READ_pHYs_SUPPORTED
 
1079
      else if (!png_memcmp(chunk_name, png_pHYs, 4))
 
1080
         png_handle_pHYs(png_ptr, info_ptr, length);
 
1081
#endif
 
1082
#ifdef PNG_READ_sBIT_SUPPORTED
 
1083
      else if (!png_memcmp(chunk_name, png_sBIT, 4))
 
1084
         png_handle_sBIT(png_ptr, info_ptr, length);
 
1085
#endif
 
1086
#ifdef PNG_READ_sRGB_SUPPORTED
 
1087
      else if (!png_memcmp(chunk_name, png_sRGB, 4))
 
1088
         png_handle_sRGB(png_ptr, info_ptr, length);
 
1089
#endif
 
1090
#ifdef PNG_READ_iCCP_SUPPORTED
 
1091
      else if (!png_memcmp(chunk_name, png_iCCP, 4))
 
1092
         png_handle_iCCP(png_ptr, info_ptr, length);
 
1093
#endif
 
1094
#ifdef PNG_READ_sPLT_SUPPORTED
 
1095
      else if (!png_memcmp(chunk_name, png_sPLT, 4))
 
1096
         png_handle_sPLT(png_ptr, info_ptr, length);
 
1097
#endif
 
1098
#ifdef PNG_READ_tEXt_SUPPORTED
 
1099
      else if (!png_memcmp(chunk_name, png_tEXt, 4))
 
1100
         png_handle_tEXt(png_ptr, info_ptr, length);
 
1101
#endif
 
1102
#ifdef PNG_READ_tIME_SUPPORTED
 
1103
      else if (!png_memcmp(chunk_name, png_tIME, 4))
 
1104
         png_handle_tIME(png_ptr, info_ptr, length);
 
1105
#endif
 
1106
#ifdef PNG_READ_tRNS_SUPPORTED
 
1107
      else if (!png_memcmp(chunk_name, png_tRNS, 4))
 
1108
         png_handle_tRNS(png_ptr, info_ptr, length);
 
1109
#endif
 
1110
#ifdef PNG_READ_zTXt_SUPPORTED
 
1111
      else if (!png_memcmp(chunk_name, png_zTXt, 4))
 
1112
         png_handle_zTXt(png_ptr, info_ptr, length);
 
1113
#endif
 
1114
#ifdef PNG_READ_iTXt_SUPPORTED
 
1115
      else if (!png_memcmp(chunk_name, png_iTXt, 4))
 
1116
         png_handle_iTXt(png_ptr, info_ptr, length);
 
1117
#endif
 
1118
      else
 
1119
         png_handle_unknown(png_ptr, info_ptr, length);
 
1120
   } while (!(png_ptr->mode & PNG_HAVE_IEND));
 
1121
}
 
1122
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
 
1123
 
 
1124
/* Free all memory used by the read */
 
1125
void PNGAPI
 
1126
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
 
1127
   png_infopp end_info_ptr_ptr)
 
1128
{
 
1129
   png_structp png_ptr = NULL;
 
1130
   png_infop info_ptr = NULL, end_info_ptr = NULL;
 
1131
#ifdef PNG_USER_MEM_SUPPORTED
 
1132
   png_free_ptr free_fn = NULL;
 
1133
   png_voidp mem_ptr = NULL;
 
1134
#endif
 
1135
 
 
1136
   png_debug(1, "in png_destroy_read_struct");
 
1137
 
 
1138
   if (png_ptr_ptr != NULL)
 
1139
      png_ptr = *png_ptr_ptr;
 
1140
   if (png_ptr == NULL)
 
1141
      return;
 
1142
 
 
1143
#ifdef PNG_USER_MEM_SUPPORTED
 
1144
   free_fn = png_ptr->free_fn;
 
1145
   mem_ptr = png_ptr->mem_ptr;
 
1146
#endif
 
1147
 
 
1148
   if (info_ptr_ptr != NULL)
 
1149
      info_ptr = *info_ptr_ptr;
 
1150
 
 
1151
   if (end_info_ptr_ptr != NULL)
 
1152
      end_info_ptr = *end_info_ptr_ptr;
 
1153
 
 
1154
   png_read_destroy(png_ptr, info_ptr, end_info_ptr);
 
1155
 
 
1156
   if (info_ptr != NULL)
 
1157
   {
 
1158
#ifdef PNG_TEXT_SUPPORTED
 
1159
      png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);
 
1160
#endif
 
1161
 
 
1162
#ifdef PNG_USER_MEM_SUPPORTED
 
1163
      png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
 
1164
          (png_voidp)mem_ptr);
 
1165
#else
 
1166
      png_destroy_struct((png_voidp)info_ptr);
 
1167
#endif
 
1168
      *info_ptr_ptr = NULL;
 
1169
   }
 
1170
 
 
1171
   if (end_info_ptr != NULL)
 
1172
   {
 
1173
#ifdef PNG_READ_TEXT_SUPPORTED
 
1174
      png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);
 
1175
#endif
 
1176
#ifdef PNG_USER_MEM_SUPPORTED
 
1177
      png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,
 
1178
         (png_voidp)mem_ptr);
 
1179
#else
 
1180
      png_destroy_struct((png_voidp)end_info_ptr);
 
1181
#endif
 
1182
      *end_info_ptr_ptr = NULL;
 
1183
   }
 
1184
 
 
1185
   if (png_ptr != NULL)
 
1186
   {
 
1187
#ifdef PNG_USER_MEM_SUPPORTED
 
1188
      png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
 
1189
          (png_voidp)mem_ptr);
 
1190
#else
 
1191
      png_destroy_struct((png_voidp)png_ptr);
 
1192
#endif
 
1193
      *png_ptr_ptr = NULL;
 
1194
   }
 
1195
}
 
1196
 
 
1197
/* Free all memory used by the read (old method) */
 
1198
void /* PRIVATE */
 
1199
png_read_destroy(png_structp png_ptr, png_infop info_ptr,
 
1200
    png_infop end_info_ptr)
 
1201
{
 
1202
#ifdef PNG_SETJMP_SUPPORTED
 
1203
   jmp_buf tmp_jmp;
 
1204
#endif
 
1205
   png_error_ptr error_fn;
 
1206
   png_error_ptr warning_fn;
 
1207
   png_voidp error_ptr;
 
1208
#ifdef PNG_USER_MEM_SUPPORTED
 
1209
   png_free_ptr free_fn;
 
1210
#endif
 
1211
 
 
1212
   png_debug(1, "in png_read_destroy");
 
1213
 
 
1214
   if (info_ptr != NULL)
 
1215
      png_info_destroy(png_ptr, info_ptr);
 
1216
 
 
1217
   if (end_info_ptr != NULL)
 
1218
      png_info_destroy(png_ptr, end_info_ptr);
 
1219
 
 
1220
   png_free(png_ptr, png_ptr->zbuf);
 
1221
   png_free(png_ptr, png_ptr->big_row_buf);
 
1222
   png_free(png_ptr, png_ptr->prev_row);
 
1223
   png_free(png_ptr, png_ptr->chunkdata);
 
1224
#ifdef PNG_READ_DITHER_SUPPORTED
 
1225
   png_free(png_ptr, png_ptr->palette_lookup);
 
1226
   png_free(png_ptr, png_ptr->dither_index);
 
1227
#endif
 
1228
#ifdef PNG_READ_GAMMA_SUPPORTED
 
1229
   png_free(png_ptr, png_ptr->gamma_table);
 
1230
#endif
 
1231
#ifdef PNG_READ_BACKGROUND_SUPPORTED
 
1232
   png_free(png_ptr, png_ptr->gamma_from_1);
 
1233
   png_free(png_ptr, png_ptr->gamma_to_1);
 
1234
#endif
 
1235
#ifdef PNG_FREE_ME_SUPPORTED
 
1236
   if (png_ptr->free_me & PNG_FREE_PLTE)
 
1237
      png_zfree(png_ptr, png_ptr->palette);
 
1238
   png_ptr->free_me &= ~PNG_FREE_PLTE;
 
1239
#else
 
1240
   if (png_ptr->flags & PNG_FLAG_FREE_PLTE)
 
1241
      png_zfree(png_ptr, png_ptr->palette);
 
1242
   png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
 
1243
#endif
 
1244
#if defined(PNG_tRNS_SUPPORTED) || \
 
1245
    defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
 
1246
#ifdef PNG_FREE_ME_SUPPORTED
 
1247
   if (png_ptr->free_me & PNG_FREE_TRNS)
 
1248
      png_free(png_ptr, png_ptr->trans);
 
1249
   png_ptr->free_me &= ~PNG_FREE_TRNS;
 
1250
#else
 
1251
   if (png_ptr->flags & PNG_FLAG_FREE_TRNS)
 
1252
      png_free(png_ptr, png_ptr->trans);
 
1253
   png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
 
1254
#endif
 
1255
#endif
 
1256
#ifdef PNG_READ_hIST_SUPPORTED
 
1257
#ifdef PNG_FREE_ME_SUPPORTED
 
1258
   if (png_ptr->free_me & PNG_FREE_HIST)
 
1259
      png_free(png_ptr, png_ptr->hist);
 
1260
   png_ptr->free_me &= ~PNG_FREE_HIST;
 
1261
#else
 
1262
   if (png_ptr->flags & PNG_FLAG_FREE_HIST)
 
1263
      png_free(png_ptr, png_ptr->hist);
 
1264
   png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
 
1265
#endif
 
1266
#endif
 
1267
#ifdef PNG_READ_GAMMA_SUPPORTED
 
1268
   if (png_ptr->gamma_16_table != NULL)
 
1269
   {
 
1270
      int i;
 
1271
      int istop = (1 << (8 - png_ptr->gamma_shift));
 
1272
      for (i = 0; i < istop; i++)
 
1273
      {
 
1274
         png_free(png_ptr, png_ptr->gamma_16_table[i]);
 
1275
      }
 
1276
   png_free(png_ptr, png_ptr->gamma_16_table);
 
1277
   }
 
1278
#ifdef PNG_READ_BACKGROUND_SUPPORTED
 
1279
   if (png_ptr->gamma_16_from_1 != NULL)
 
1280
   {
 
1281
      int i;
 
1282
      int istop = (1 << (8 - png_ptr->gamma_shift));
 
1283
      for (i = 0; i < istop; i++)
 
1284
      {
 
1285
         png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
 
1286
      }
 
1287
   png_free(png_ptr, png_ptr->gamma_16_from_1);
 
1288
   }
 
1289
   if (png_ptr->gamma_16_to_1 != NULL)
 
1290
   {
 
1291
      int i;
 
1292
      int istop = (1 << (8 - png_ptr->gamma_shift));
 
1293
      for (i = 0; i < istop; i++)
 
1294
      {
 
1295
         png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
 
1296
      }
 
1297
   png_free(png_ptr, png_ptr->gamma_16_to_1);
 
1298
   }
 
1299
#endif
 
1300
#endif
 
1301
#ifdef PNG_TIME_RFC1123_SUPPORTED
 
1302
   png_free(png_ptr, png_ptr->time_buffer);
 
1303
#endif
 
1304
 
 
1305
   inflateEnd(&png_ptr->zstream);
 
1306
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
 
1307
   png_free(png_ptr, png_ptr->save_buffer);
 
1308
#endif
 
1309
 
 
1310
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
 
1311
#ifdef PNG_TEXT_SUPPORTED
 
1312
   png_free(png_ptr, png_ptr->current_text);
 
1313
#endif /* PNG_TEXT_SUPPORTED */
 
1314
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
 
1315
 
 
1316
   /* Save the important info out of the png_struct, in case it is
 
1317
    * being used again.
 
1318
    */
 
1319
#ifdef PNG_SETJMP_SUPPORTED
 
1320
   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
 
1321
#endif
 
1322
 
 
1323
   error_fn = png_ptr->error_fn;
 
1324
   warning_fn = png_ptr->warning_fn;
 
1325
   error_ptr = png_ptr->error_ptr;
 
1326
#ifdef PNG_USER_MEM_SUPPORTED
 
1327
   free_fn = png_ptr->free_fn;
 
1328
#endif
 
1329
 
 
1330
   png_memset(png_ptr, 0, png_sizeof(png_struct));
 
1331
 
 
1332
   png_ptr->error_fn = error_fn;
 
1333
   png_ptr->warning_fn = warning_fn;
 
1334
   png_ptr->error_ptr = error_ptr;
 
1335
#ifdef PNG_USER_MEM_SUPPORTED
 
1336
   png_ptr->free_fn = free_fn;
 
1337
#endif
 
1338
 
 
1339
#ifdef PNG_SETJMP_SUPPORTED
 
1340
   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
 
1341
#endif
 
1342
 
 
1343
}
 
1344
 
 
1345
void PNGAPI
 
1346
png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
 
1347
{
 
1348
   if (png_ptr == NULL)
 
1349
      return;
 
1350
   png_ptr->read_row_fn = read_row_fn;
 
1351
}
 
1352
 
 
1353
 
 
1354
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 
1355
#ifdef PNG_INFO_IMAGE_SUPPORTED
 
1356
void PNGAPI
 
1357
png_read_png(png_structp png_ptr, png_infop info_ptr,
 
1358
                           int transforms,
 
1359
                           voidp params)
 
1360
{
 
1361
   int row;
 
1362
 
 
1363
   if (png_ptr == NULL)
 
1364
      return;
 
1365
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
 
1366
   /* Invert the alpha channel from opacity to transparency
 
1367
    */
 
1368
   if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
 
1369
       png_set_invert_alpha(png_ptr);
 
1370
#endif
 
1371
 
 
1372
   /* png_read_info() gives us all of the information from the
 
1373
    * PNG file before the first IDAT (image data chunk).
 
1374
    */
 
1375
   png_read_info(png_ptr, info_ptr);
 
1376
   if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep))
 
1377
      png_error(png_ptr, "Image is too high to process with png_read_png()");
 
1378
 
 
1379
   /* -------------- image transformations start here ------------------- */
 
1380
 
 
1381
#ifdef PNG_READ_16_TO_8_SUPPORTED
 
1382
   /* Tell libpng to strip 16 bit/color files down to 8 bits per color.
 
1383
    */
 
1384
   if (transforms & PNG_TRANSFORM_STRIP_16)
 
1385
      png_set_strip_16(png_ptr);
 
1386
#endif
 
1387
 
 
1388
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
 
1389
   /* Strip alpha bytes from the input data without combining with
 
1390
    * the background (not recommended).
 
1391
    */
 
1392
   if (transforms & PNG_TRANSFORM_STRIP_ALPHA)
 
1393
      png_set_strip_alpha(png_ptr);
 
1394
#endif
 
1395
 
 
1396
#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)
 
1397
   /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single
 
1398
    * byte into separate bytes (useful for paletted and grayscale images).
 
1399
    */
 
1400
   if (transforms & PNG_TRANSFORM_PACKING)
 
1401
      png_set_packing(png_ptr);
 
1402
#endif
 
1403
 
 
1404
#ifdef PNG_READ_PACKSWAP_SUPPORTED
 
1405
   /* Change the order of packed pixels to least significant bit first
 
1406
    * (not useful if you are using png_set_packing).
 
1407
    */
 
1408
   if (transforms & PNG_TRANSFORM_PACKSWAP)
 
1409
      png_set_packswap(png_ptr);
 
1410
#endif
 
1411
 
 
1412
#ifdef PNG_READ_EXPAND_SUPPORTED
 
1413
   /* Expand paletted colors into true RGB triplets
 
1414
    * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel
 
1415
    * Expand paletted or RGB images with transparency to full alpha
 
1416
    * channels so the data will be available as RGBA quartets.
 
1417
    */
 
1418
   if (transforms & PNG_TRANSFORM_EXPAND)
 
1419
      if ((png_ptr->bit_depth < 8) ||
 
1420
          (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||
 
1421
          (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
 
1422
         png_set_expand(png_ptr);
 
1423
#endif
 
1424
 
 
1425
   /* We don't handle background color or gamma transformation or dithering.
 
1426
    */
 
1427
 
 
1428
#ifdef PNG_READ_INVERT_SUPPORTED
 
1429
   /* Invert monochrome files to have 0 as white and 1 as black
 
1430
    */
 
1431
   if (transforms & PNG_TRANSFORM_INVERT_MONO)
 
1432
      png_set_invert_mono(png_ptr);
 
1433
#endif
 
1434
 
 
1435
#ifdef PNG_READ_SHIFT_SUPPORTED
 
1436
   /* If you want to shift the pixel values from the range [0,255] or
 
1437
    * [0,65535] to the original [0,7] or [0,31], or whatever range the
 
1438
    * colors were originally in:
 
1439
    */
 
1440
   if ((transforms & PNG_TRANSFORM_SHIFT)
 
1441
       && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
 
1442
   {
 
1443
      png_color_8p sig_bit;
 
1444
 
 
1445
      png_get_sBIT(png_ptr, info_ptr, &sig_bit);
 
1446
      png_set_shift(png_ptr, sig_bit);
 
1447
   }
 
1448
#endif
 
1449
 
 
1450
#ifdef PNG_READ_BGR_SUPPORTED
 
1451
   /* Flip the RGB pixels to BGR (or RGBA to BGRA)
 
1452
    */
 
1453
   if (transforms & PNG_TRANSFORM_BGR)
 
1454
      png_set_bgr(png_ptr);
 
1455
#endif
 
1456
 
 
1457
#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
 
1458
   /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)
 
1459
    */
 
1460
   if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
 
1461
       png_set_swap_alpha(png_ptr);
 
1462
#endif
 
1463
 
 
1464
#ifdef PNG_READ_SWAP_SUPPORTED
 
1465
   /* Swap bytes of 16 bit files to least significant byte first
 
1466
    */
 
1467
   if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
 
1468
      png_set_swap(png_ptr);
 
1469
#endif
 
1470
 
 
1471
/* Added at libpng-1.2.41 */
 
1472
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
 
1473
   /* Invert the alpha channel from opacity to transparency
 
1474
    */
 
1475
   if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
 
1476
       png_set_invert_alpha(png_ptr);
 
1477
#endif
 
1478
 
 
1479
/* Added at libpng-1.2.41 */
 
1480
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
 
1481
   /* Expand grayscale image to RGB
 
1482
    */
 
1483
   if (transforms & PNG_TRANSFORM_GRAY_TO_RGB)
 
1484
       png_set_gray_to_rgb(png_ptr);
 
1485
#endif
 
1486
 
 
1487
   /* We don't handle adding filler bytes */
 
1488
 
 
1489
   /* Optional call to gamma correct and add the background to the palette
 
1490
    * and update info structure.  REQUIRED if you are expecting libpng to
 
1491
    * update the palette for you (i.e., you selected such a transform above).
 
1492
    */
 
1493
   png_read_update_info(png_ptr, info_ptr);
 
1494
 
 
1495
   /* -------------- image transformations end here ------------------- */
 
1496
 
 
1497
#ifdef PNG_FREE_ME_SUPPORTED
 
1498
   png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
 
1499
#endif
 
1500
   if (info_ptr->row_pointers == NULL)
 
1501
   {
 
1502
      info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
 
1503
         info_ptr->height * png_sizeof(png_bytep));
 
1504
      png_memset(info_ptr->row_pointers, 0, info_ptr->height
 
1505
         * png_sizeof(png_bytep));
 
1506
 
 
1507
#ifdef PNG_FREE_ME_SUPPORTED
 
1508
      info_ptr->free_me |= PNG_FREE_ROWS;
 
1509
#endif
 
1510
 
 
1511
      for (row = 0; row < (int)info_ptr->height; row++)
 
1512
         info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
 
1513
            png_get_rowbytes(png_ptr, info_ptr));
 
1514
   }
 
1515
 
 
1516
   png_read_image(png_ptr, info_ptr->row_pointers);
 
1517
   info_ptr->valid |= PNG_INFO_IDAT;
 
1518
 
 
1519
   /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */
 
1520
   png_read_end(png_ptr, info_ptr);
 
1521
 
 
1522
   transforms = transforms; /* Quiet compiler warnings */
 
1523
   params = params;
 
1524
 
 
1525
}
 
1526
#endif /* PNG_INFO_IMAGE_SUPPORTED */
 
1527
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
 
1528
#endif /* PNG_READ_SUPPORTED */