← Back to branch summary

~ubuntu-branches/ubuntu/wily/qtbase-opensource-src/wily

« back to all changes in this revision

Viewing changes to src/3rdparty/libpng/pngread.c

  • Committer: Package Import Robot
  • Author(s): Timo Jyrinki
  • Date: 2013-02-05 12:46:17 UTC
  • Revision ID: package-import@ubuntu.com-20130205124617-c8jouts182j002fx
Tags: upstream-5.0.1+dfsg
Import upstream version 5.0.1+dfsg

Show diffs side-by-side

added added

removed removed

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