third_party/libpng/pngread.c

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