src/png/pngread.c

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