← Back to branch summary

~ubuntu-branches/ubuntu/raring/wxwidgets2.8/raring

« back to all changes in this revision

Viewing changes to src/png/pngread.c

  • Committer: Package Import Robot
  • Author(s): Stéphane Graber
  • Date: 2012-01-07 13:59:25 UTC
  • mfrom: (1.1.9) (5.1.10 sid)
  • Revision ID: package-import@ubuntu.com-20120107135925-2601miy9ullcon9j
Tags: 2.8.12.1-6ubuntu1
https://launchpad.net/bugs/632984
* Resync from Debian, changes that were kept:
  - debian/rules: re-enable mediactrl. This allows libwx_gtk2u_media-2.8 to be
    built, as this is required by some applications (LP: #632984)
  - debian/control: Build-dep on libxt-dev for mediactrl.
  - Patches
    + fix-bashism-in-example
* Add conflict on python-wxgtk2.8 (<< 2.8.12.1-6ubuntu1~) to python-wxversion
  to guarantee upgrade ordering when moving from pycentral to dh_python2.

Show diffs side-by-side

added added

removed removed

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