src/png/pngread.c

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