git.mutantstargoat.com Git - vrlugburz/blob - libs/imago/libpng/pngpread.c

   1
   2 /* pngpread.c - read a png file in push mode
   3  *
   4  * Last changed in libpng 1.2.32 [September 18, 2008]
   5  * For conditions of distribution and use, see copyright notice in png.h
   6  * Copyright (c) 1998-2008 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
  11 #define PNG_INTERNAL
  12 #include "png.h"
  13 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  14
  15 /* push model modes */
  16 #define PNG_READ_SIG_MODE   0
  17 #define PNG_READ_CHUNK_MODE 1
  18 #define PNG_READ_IDAT_MODE  2
  19 #define PNG_SKIP_MODE       3
  20 #define PNG_READ_tEXt_MODE  4
  21 #define PNG_READ_zTXt_MODE  5
  22 #define PNG_READ_DONE_MODE  6
  23 #define PNG_READ_iTXt_MODE  7
  24 #define PNG_ERROR_MODE      8
  25
  26 void PNGAPI
  27 png_process_data(png_structp png_ptr, png_infop info_ptr,
  28    png_bytep buffer, png_size_t buffer_size)
  29 {
  30    if (png_ptr == NULL || info_ptr == NULL) return;
  31    png_push_restore_buffer(png_ptr, buffer, buffer_size);
  32
  33    while (png_ptr->buffer_size)
  34    {
  35       png_process_some_data(png_ptr, info_ptr);
  36    }
  37 }
  38
  39 /* What we do with the incoming data depends on what we were previously
  40  * doing before we ran out of data...
  41  */
  42 void /* PRIVATE */
  43 png_process_some_data(png_structp png_ptr, png_infop info_ptr)
  44 {
  45    if (png_ptr == NULL) return;
  46    switch (png_ptr->process_mode)
  47    {
  48       case PNG_READ_SIG_MODE:
  49       {
  50          png_push_read_sig(png_ptr, info_ptr);
  51          break;
  52       }
  53       case PNG_READ_CHUNK_MODE:
  54       {
  55          png_push_read_chunk(png_ptr, info_ptr);
  56          break;
  57       }
  58       case PNG_READ_IDAT_MODE:
  59       {
  60          png_push_read_IDAT(png_ptr);
  61          break;
  62       }
  63 #if defined(PNG_READ_tEXt_SUPPORTED)
  64       case PNG_READ_tEXt_MODE:
  65       {
  66          png_push_read_tEXt(png_ptr, info_ptr);
  67          break;
  68       }
  69 #endif
  70 #if defined(PNG_READ_zTXt_SUPPORTED)
  71       case PNG_READ_zTXt_MODE:
  72       {
  73          png_push_read_zTXt(png_ptr, info_ptr);
  74          break;
  75       }
  76 #endif
  77 #if defined(PNG_READ_iTXt_SUPPORTED)
  78       case PNG_READ_iTXt_MODE:
  79       {
  80          png_push_read_iTXt(png_ptr, info_ptr);
  81          break;
  82       }
  83 #endif
  84       case PNG_SKIP_MODE:
  85       {
  86          png_push_crc_finish(png_ptr);
  87          break;
  88       }
  89       default:
  90       {
  91          png_ptr->buffer_size = 0;
  92          break;
  93       }
  94    }
  95 }
  96
  97 /* Read any remaining signature bytes from the stream and compare them with
  98  * the correct PNG signature.  It is possible that this routine is called
  99  * with bytes already read from the signature, either because they have been
 100  * checked by the calling application, or because of multiple calls to this
 101  * routine.
 102  */
 103 void /* PRIVATE */
 104 png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
 105 {
 106    png_size_t num_checked = png_ptr->sig_bytes,
 107              num_to_check = 8 - num_checked;
 108
 109    if (png_ptr->buffer_size < num_to_check)
 110    {
 111       num_to_check = png_ptr->buffer_size;
 112    }
 113
 114    png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
 115       num_to_check);
 116    png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);
 117
 118    if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
 119    {
 120       if (num_checked < 4 &&
 121           png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
 122          png_error(png_ptr, "Not a PNG file");
 123       else
 124          png_error(png_ptr, "PNG file corrupted by ASCII conversion");
 125    }
 126    else
 127    {
 128       if (png_ptr->sig_bytes >= 8)
 129       {
 130          png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 131       }
 132    }
 133 }
 134
 135 void /* PRIVATE */
 136 png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
 137 {
 138 #ifdef PNG_USE_LOCAL_ARRAYS
 139       PNG_CONST PNG_IHDR;
 140       PNG_CONST PNG_IDAT;
 141       PNG_CONST PNG_IEND;
 142       PNG_CONST PNG_PLTE;
 143 #if defined(PNG_READ_bKGD_SUPPORTED)
 144       PNG_CONST PNG_bKGD;
 145 #endif
 146 #if defined(PNG_READ_cHRM_SUPPORTED)
 147       PNG_CONST PNG_cHRM;
 148 #endif
 149 #if defined(PNG_READ_gAMA_SUPPORTED)
 150       PNG_CONST PNG_gAMA;
 151 #endif
 152 #if defined(PNG_READ_hIST_SUPPORTED)
 153       PNG_CONST PNG_hIST;
 154 #endif
 155 #if defined(PNG_READ_iCCP_SUPPORTED)
 156       PNG_CONST PNG_iCCP;
 157 #endif
 158 #if defined(PNG_READ_iTXt_SUPPORTED)
 159       PNG_CONST PNG_iTXt;
 160 #endif
 161 #if defined(PNG_READ_oFFs_SUPPORTED)
 162       PNG_CONST PNG_oFFs;
 163 #endif
 164 #if defined(PNG_READ_pCAL_SUPPORTED)
 165       PNG_CONST PNG_pCAL;
 166 #endif
 167 #if defined(PNG_READ_pHYs_SUPPORTED)
 168       PNG_CONST PNG_pHYs;
 169 #endif
 170 #if defined(PNG_READ_sBIT_SUPPORTED)
 171       PNG_CONST PNG_sBIT;
 172 #endif
 173 #if defined(PNG_READ_sCAL_SUPPORTED)
 174       PNG_CONST PNG_sCAL;
 175 #endif
 176 #if defined(PNG_READ_sRGB_SUPPORTED)
 177       PNG_CONST PNG_sRGB;
 178 #endif
 179 #if defined(PNG_READ_sPLT_SUPPORTED)
 180       PNG_CONST PNG_sPLT;
 181 #endif
 182 #if defined(PNG_READ_tEXt_SUPPORTED)
 183       PNG_CONST PNG_tEXt;
 184 #endif
 185 #if defined(PNG_READ_tIME_SUPPORTED)
 186       PNG_CONST PNG_tIME;
 187 #endif
 188 #if defined(PNG_READ_tRNS_SUPPORTED)
 189       PNG_CONST PNG_tRNS;
 190 #endif
 191 #if defined(PNG_READ_zTXt_SUPPORTED)
 192       PNG_CONST PNG_zTXt;
 193 #endif
 194 #endif /* PNG_USE_LOCAL_ARRAYS */
 195    /* First we make sure we have enough data for the 4 byte chunk name
 196     * and the 4 byte chunk length before proceeding with decoding the
 197     * chunk data.  To fully decode each of these chunks, we also make
 198     * sure we have enough data in the buffer for the 4 byte CRC at the
 199     * end of every chunk (except IDAT, which is handled separately).
 200     */
 201    if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
 202    {
 203       png_byte chunk_length[4];
 204
 205       if (png_ptr->buffer_size < 8)
 206       {
 207          png_push_save_buffer(png_ptr);
 208          return;
 209       }
 210
 211       png_push_fill_buffer(png_ptr, chunk_length, 4);
 212       png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
 213       png_reset_crc(png_ptr);
 214       png_crc_read(png_ptr, png_ptr->chunk_name, 4);
 215       png_check_chunk_name(png_ptr, png_ptr->chunk_name);
 216       png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
 217    }
 218
 219    if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
 220      if (png_ptr->mode & PNG_AFTER_IDAT)
 221         png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
 222
 223    if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
 224    {
 225       if (png_ptr->push_length != 13)
 226          png_error(png_ptr, "Invalid IHDR length");
 227       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 228       {
 229          png_push_save_buffer(png_ptr);
 230          return;
 231       }
 232       png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
 233    }
 234    else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
 235    {
 236       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 237       {
 238          png_push_save_buffer(png_ptr);
 239          return;
 240       }
 241       png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
 242
 243       png_ptr->process_mode = PNG_READ_DONE_MODE;
 244       png_push_have_end(png_ptr, info_ptr);
 245    }
 246 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 247    else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
 248    {
 249       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 250       {
 251          png_push_save_buffer(png_ptr);
 252          return;
 253       }
 254       if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
 255          png_ptr->mode |= PNG_HAVE_IDAT;
 256       png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
 257       if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
 258          png_ptr->mode |= PNG_HAVE_PLTE;
 259       else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
 260       {
 261          if (!(png_ptr->mode & PNG_HAVE_IHDR))
 262             png_error(png_ptr, "Missing IHDR before IDAT");
 263          else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
 264                   !(png_ptr->mode & PNG_HAVE_PLTE))
 265             png_error(png_ptr, "Missing PLTE before IDAT");
 266       }
 267    }
 268 #endif
 269    else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
 270    {
 271       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 272       {
 273          png_push_save_buffer(png_ptr);
 274          return;
 275       }
 276       png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
 277    }
 278    else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
 279    {
 280       /* If we reach an IDAT chunk, this means we have read all of the
 281        * header chunks, and we can start reading the image (or if this
 282        * is called after the image has been read - we have an error).
 283        */
 284      if (!(png_ptr->mode & PNG_HAVE_IHDR))
 285        png_error(png_ptr, "Missing IHDR before IDAT");
 286      else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
 287          !(png_ptr->mode & PNG_HAVE_PLTE))
 288        png_error(png_ptr, "Missing PLTE before IDAT");
 289
 290       if (png_ptr->mode & PNG_HAVE_IDAT)
 291       {
 292          if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
 293            if (png_ptr->push_length == 0)
 294               return;
 295
 296          if (png_ptr->mode & PNG_AFTER_IDAT)
 297             png_error(png_ptr, "Too many IDAT's found");
 298       }
 299
 300       png_ptr->idat_size = png_ptr->push_length;
 301       png_ptr->mode |= PNG_HAVE_IDAT;
 302       png_ptr->process_mode = PNG_READ_IDAT_MODE;
 303       png_push_have_info(png_ptr, info_ptr);
 304       png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
 305       png_ptr->zstream.next_out = png_ptr->row_buf;
 306       return;
 307    }
 308 #if defined(PNG_READ_gAMA_SUPPORTED)
 309    else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
 310    {
 311       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 312       {
 313          png_push_save_buffer(png_ptr);
 314          return;
 315       }
 316       png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
 317    }
 318 #endif
 319 #if defined(PNG_READ_sBIT_SUPPORTED)
 320    else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
 321    {
 322       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 323       {
 324          png_push_save_buffer(png_ptr);
 325          return;
 326       }
 327       png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
 328    }
 329 #endif
 330 #if defined(PNG_READ_cHRM_SUPPORTED)
 331    else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
 332    {
 333       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 334       {
 335          png_push_save_buffer(png_ptr);
 336          return;
 337       }
 338       png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
 339    }
 340 #endif
 341 #if defined(PNG_READ_sRGB_SUPPORTED)
 342    else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
 343    {
 344       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 345       {
 346          png_push_save_buffer(png_ptr);
 347          return;
 348       }
 349       png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
 350    }
 351 #endif
 352 #if defined(PNG_READ_iCCP_SUPPORTED)
 353    else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
 354    {
 355       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 356       {
 357          png_push_save_buffer(png_ptr);
 358          return;
 359       }
 360       png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
 361    }
 362 #endif
 363 #if defined(PNG_READ_sPLT_SUPPORTED)
 364    else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
 365    {
 366       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 367       {
 368          png_push_save_buffer(png_ptr);
 369          return;
 370       }
 371       png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
 372    }
 373 #endif
 374 #if defined(PNG_READ_tRNS_SUPPORTED)
 375    else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
 376    {
 377       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 378       {
 379          png_push_save_buffer(png_ptr);
 380          return;
 381       }
 382       png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
 383    }
 384 #endif
 385 #if defined(PNG_READ_bKGD_SUPPORTED)
 386    else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
 387    {
 388       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 389       {
 390          png_push_save_buffer(png_ptr);
 391          return;
 392       }
 393       png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
 394    }
 395 #endif
 396 #if defined(PNG_READ_hIST_SUPPORTED)
 397    else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
 398    {
 399       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 400       {
 401          png_push_save_buffer(png_ptr);
 402          return;
 403       }
 404       png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
 405    }
 406 #endif
 407 #if defined(PNG_READ_pHYs_SUPPORTED)
 408    else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
 409    {
 410       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 411       {
 412          png_push_save_buffer(png_ptr);
 413          return;
 414       }
 415       png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
 416    }
 417 #endif
 418 #if defined(PNG_READ_oFFs_SUPPORTED)
 419    else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
 420    {
 421       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 422       {
 423          png_push_save_buffer(png_ptr);
 424          return;
 425       }
 426       png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
 427    }
 428 #endif
 429 #if defined(PNG_READ_pCAL_SUPPORTED)
 430    else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
 431    {
 432       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 433       {
 434          png_push_save_buffer(png_ptr);
 435          return;
 436       }
 437       png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
 438    }
 439 #endif
 440 #if defined(PNG_READ_sCAL_SUPPORTED)
 441    else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
 442    {
 443       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 444       {
 445          png_push_save_buffer(png_ptr);
 446          return;
 447       }
 448       png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
 449    }
 450 #endif
 451 #if defined(PNG_READ_tIME_SUPPORTED)
 452    else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
 453    {
 454       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 455       {
 456          png_push_save_buffer(png_ptr);
 457          return;
 458       }
 459       png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
 460    }
 461 #endif
 462 #if defined(PNG_READ_tEXt_SUPPORTED)
 463    else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
 464    {
 465       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 466       {
 467          png_push_save_buffer(png_ptr);
 468          return;
 469       }
 470       png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
 471    }
 472 #endif
 473 #if defined(PNG_READ_zTXt_SUPPORTED)
 474    else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
 475    {
 476       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 477       {
 478          png_push_save_buffer(png_ptr);
 479          return;
 480       }
 481       png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
 482    }
 483 #endif
 484 #if defined(PNG_READ_iTXt_SUPPORTED)
 485    else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
 486    {
 487       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 488       {
 489          png_push_save_buffer(png_ptr);
 490          return;
 491       }
 492       png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
 493    }
 494 #endif
 495    else
 496    {
 497       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 498       {
 499          png_push_save_buffer(png_ptr);
 500          return;
 501       }
 502       png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
 503    }
 504
 505    png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
 506 }
 507
 508 void /* PRIVATE */
 509 png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)
 510 {
 511    png_ptr->process_mode = PNG_SKIP_MODE;
 512    png_ptr->skip_length = skip;
 513 }
 514
 515 void /* PRIVATE */
 516 png_push_crc_finish(png_structp png_ptr)
 517 {
 518    if (png_ptr->skip_length && png_ptr->save_buffer_size)
 519    {
 520       png_size_t save_size;
 521
 522       if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size)
 523          save_size = (png_size_t)png_ptr->skip_length;
 524       else
 525          save_size = png_ptr->save_buffer_size;
 526
 527       png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
 528
 529       png_ptr->skip_length -= save_size;
 530       png_ptr->buffer_size -= save_size;
 531       png_ptr->save_buffer_size -= save_size;
 532       png_ptr->save_buffer_ptr += save_size;
 533    }
 534    if (png_ptr->skip_length && png_ptr->current_buffer_size)
 535    {
 536       png_size_t save_size;
 537
 538       if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size)
 539          save_size = (png_size_t)png_ptr->skip_length;
 540       else
 541          save_size = png_ptr->current_buffer_size;
 542
 543       png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
 544
 545       png_ptr->skip_length -= save_size;
 546       png_ptr->buffer_size -= save_size;
 547       png_ptr->current_buffer_size -= save_size;
 548       png_ptr->current_buffer_ptr += save_size;
 549    }
 550    if (!png_ptr->skip_length)
 551    {
 552       if (png_ptr->buffer_size < 4)
 553       {
 554          png_push_save_buffer(png_ptr);
 555          return;
 556       }
 557
 558       png_crc_finish(png_ptr, 0);
 559       png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 560    }
 561 }
 562
 563 void PNGAPI
 564 png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
 565 {
 566    png_bytep ptr;
 567
 568    if (png_ptr == NULL) return;
 569    ptr = buffer;
 570    if (png_ptr->save_buffer_size)
 571    {
 572       png_size_t save_size;
 573
 574       if (length < png_ptr->save_buffer_size)
 575          save_size = length;
 576       else
 577          save_size = png_ptr->save_buffer_size;
 578
 579       png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
 580       length -= save_size;
 581       ptr += save_size;
 582       png_ptr->buffer_size -= save_size;
 583       png_ptr->save_buffer_size -= save_size;
 584       png_ptr->save_buffer_ptr += save_size;
 585    }
 586    if (length && png_ptr->current_buffer_size)
 587    {
 588       png_size_t save_size;
 589
 590       if (length < png_ptr->current_buffer_size)
 591          save_size = length;
 592       else
 593          save_size = png_ptr->current_buffer_size;
 594
 595       png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
 596       png_ptr->buffer_size -= save_size;
 597       png_ptr->current_buffer_size -= save_size;
 598       png_ptr->current_buffer_ptr += save_size;
 599    }
 600 }
 601
 602 void /* PRIVATE */
 603 png_push_save_buffer(png_structp png_ptr)
 604 {
 605    if (png_ptr->save_buffer_size)
 606    {
 607       if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
 608       {
 609          png_size_t i, istop;
 610          png_bytep sp;
 611          png_bytep dp;
 612
 613          istop = png_ptr->save_buffer_size;
 614          for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
 615             i < istop; i++, sp++, dp++)
 616          {
 617             *dp = *sp;
 618          }
 619       }
 620    }
 621    if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
 622       png_ptr->save_buffer_max)
 623    {
 624       png_size_t new_max;
 625       png_bytep old_buffer;
 626
 627       if (png_ptr->save_buffer_size > PNG_SIZE_MAX -
 628          (png_ptr->current_buffer_size + 256))
 629       {
 630         png_error(png_ptr, "Potential overflow of save_buffer");
 631       }
 632       new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
 633       old_buffer = png_ptr->save_buffer;
 634       png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,
 635          (png_uint_32)new_max);
 636       png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
 637       png_free(png_ptr, old_buffer);
 638       png_ptr->save_buffer_max = new_max;
 639    }
 640    if (png_ptr->current_buffer_size)
 641    {
 642       png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
 643          png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);
 644       png_ptr->save_buffer_size += png_ptr->current_buffer_size;
 645       png_ptr->current_buffer_size = 0;
 646    }
 647    png_ptr->save_buffer_ptr = png_ptr->save_buffer;
 648    png_ptr->buffer_size = 0;
 649 }
 650
 651 void /* PRIVATE */
 652 png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,
 653    png_size_t buffer_length)
 654 {
 655    png_ptr->current_buffer = buffer;
 656    png_ptr->current_buffer_size = buffer_length;
 657    png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
 658    png_ptr->current_buffer_ptr = png_ptr->current_buffer;
 659 }
 660
 661 void /* PRIVATE */
 662 png_push_read_IDAT(png_structp png_ptr)
 663 {
 664 #ifdef PNG_USE_LOCAL_ARRAYS
 665    PNG_CONST PNG_IDAT;
 666 #endif
 667    if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
 668    {
 669       png_byte chunk_length[4];
 670
 671       if (png_ptr->buffer_size < 8)
 672       {
 673          png_push_save_buffer(png_ptr);
 674          return;
 675       }
 676
 677       png_push_fill_buffer(png_ptr, chunk_length, 4);
 678       png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
 679       png_reset_crc(png_ptr);
 680       png_crc_read(png_ptr, png_ptr->chunk_name, 4);
 681       png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
 682
 683       if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
 684       {
 685          png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 686          if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
 687             png_error(png_ptr, "Not enough compressed data");
 688          return;
 689       }
 690
 691       png_ptr->idat_size = png_ptr->push_length;
 692    }
 693    if (png_ptr->idat_size && png_ptr->save_buffer_size)
 694    {
 695       png_size_t save_size;
 696
 697       if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)
 698       {
 699          save_size = (png_size_t)png_ptr->idat_size;
 700          /* check for overflow */
 701          if ((png_uint_32)save_size != png_ptr->idat_size)
 702             png_error(png_ptr, "save_size overflowed in pngpread");
 703       }
 704       else
 705          save_size = png_ptr->save_buffer_size;
 706
 707       png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
 708       if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
 709          png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
 710       png_ptr->idat_size -= save_size;
 711       png_ptr->buffer_size -= save_size;
 712       png_ptr->save_buffer_size -= save_size;
 713       png_ptr->save_buffer_ptr += save_size;
 714    }
 715    if (png_ptr->idat_size && png_ptr->current_buffer_size)
 716    {
 717       png_size_t save_size;
 718
 719       if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)
 720       {
 721          save_size = (png_size_t)png_ptr->idat_size;
 722          /* check for overflow */
 723          if ((png_uint_32)save_size != png_ptr->idat_size)
 724             png_error(png_ptr, "save_size overflowed in pngpread");
 725       }
 726       else
 727          save_size = png_ptr->current_buffer_size;
 728
 729       png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
 730       if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
 731         png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);
 732
 733       png_ptr->idat_size -= save_size;
 734       png_ptr->buffer_size -= save_size;
 735       png_ptr->current_buffer_size -= save_size;
 736       png_ptr->current_buffer_ptr += save_size;
 737    }
 738    if (!png_ptr->idat_size)
 739    {
 740       if (png_ptr->buffer_size < 4)
 741       {
 742          png_push_save_buffer(png_ptr);
 743          return;
 744       }
 745
 746       png_crc_finish(png_ptr, 0);
 747       png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
 748       png_ptr->mode |= PNG_AFTER_IDAT;
 749    }
 750 }
 751
 752 void /* PRIVATE */
 753 png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
 754    png_size_t buffer_length)
 755 {
 756    int ret;
 757
 758    if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length)
 759       png_error(png_ptr, "Extra compression data");
 760
 761    png_ptr->zstream.next_in = buffer;
 762    png_ptr->zstream.avail_in = (uInt)buffer_length;
 763    for (;;)
 764    {
 765       ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
 766       if (ret != Z_OK)
 767       {
 768          if (ret == Z_STREAM_END)
 769          {
 770             if (png_ptr->zstream.avail_in)
 771                png_error(png_ptr, "Extra compressed data");
 772             if (!(png_ptr->zstream.avail_out))
 773             {
 774                png_push_process_row(png_ptr);
 775             }
 776
 777             png_ptr->mode |= PNG_AFTER_IDAT;
 778             png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
 779             break;
 780          }
 781          else if (ret == Z_BUF_ERROR)
 782             break;
 783          else
 784             png_error(png_ptr, "Decompression Error");
 785       }
 786       if (!(png_ptr->zstream.avail_out))
 787       {
 788          if ((
 789 #if defined(PNG_READ_INTERLACING_SUPPORTED)
 790              png_ptr->interlaced && png_ptr->pass > 6) ||
 791              (!png_ptr->interlaced &&
 792 #endif
 793              png_ptr->row_number == png_ptr->num_rows))
 794          {
 795            if (png_ptr->zstream.avail_in)
 796              png_warning(png_ptr, "Too much data in IDAT chunks");
 797            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
 798            break;
 799          }
 800          png_push_process_row(png_ptr);
 801          png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
 802          png_ptr->zstream.next_out = png_ptr->row_buf;
 803       }
 804       else
 805          break;
 806    }
 807 }
 808
 809 void /* PRIVATE */
 810 png_push_process_row(png_structp png_ptr)
 811 {
 812    png_ptr->row_info.color_type = png_ptr->color_type;
 813    png_ptr->row_info.width = png_ptr->iwidth;
 814    png_ptr->row_info.channels = png_ptr->channels;
 815    png_ptr->row_info.bit_depth = png_ptr->bit_depth;
 816    png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
 817
 818    png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
 819        png_ptr->row_info.width);
 820
 821    png_read_filter_row(png_ptr, &(png_ptr->row_info),
 822       png_ptr->row_buf + 1, png_ptr->prev_row + 1,
 823       (int)(png_ptr->row_buf[0]));
 824
 825    png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
 826       png_ptr->rowbytes + 1);
 827
 828    if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
 829       png_do_read_transformations(png_ptr);
 830
 831 #if defined(PNG_READ_INTERLACING_SUPPORTED)
 832    /* blow up interlaced rows to full size */
 833    if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
 834    {
 835       if (png_ptr->pass < 6)
 836 /*       old interface (pre-1.0.9):
 837          png_do_read_interlace(&(png_ptr->row_info),
 838             png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
 839  */
 840          png_do_read_interlace(png_ptr);
 841
 842     switch (png_ptr->pass)
 843     {
 844          case 0:
 845          {
 846             int i;
 847             for (i = 0; i < 8 && png_ptr->pass == 0; i++)
 848             {
 849                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 850                png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */
 851             }
 852             if (png_ptr->pass == 2) /* pass 1 might be empty */
 853             {
 854                for (i = 0; i < 4 && png_ptr->pass == 2; i++)
 855                {
 856                   png_push_have_row(png_ptr, png_bytep_NULL);
 857                   png_read_push_finish_row(png_ptr);
 858                }
 859             }
 860             if (png_ptr->pass == 4 && png_ptr->height <= 4)
 861             {
 862                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 863                {
 864                   png_push_have_row(png_ptr, png_bytep_NULL);
 865                   png_read_push_finish_row(png_ptr);
 866                }
 867             }
 868             if (png_ptr->pass == 6 && png_ptr->height <= 4)
 869             {
 870                 png_push_have_row(png_ptr, png_bytep_NULL);
 871                 png_read_push_finish_row(png_ptr);
 872             }
 873             break;
 874          }
 875          case 1:
 876          {
 877             int i;
 878             for (i = 0; i < 8 && png_ptr->pass == 1; i++)
 879             {
 880                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 881                png_read_push_finish_row(png_ptr);
 882             }
 883             if (png_ptr->pass == 2) /* skip top 4 generated rows */
 884             {
 885                for (i = 0; i < 4 && png_ptr->pass == 2; i++)
 886                {
 887                   png_push_have_row(png_ptr, png_bytep_NULL);
 888                   png_read_push_finish_row(png_ptr);
 889                }
 890             }
 891             break;
 892          }
 893          case 2:
 894          {
 895             int i;
 896             for (i = 0; i < 4 && png_ptr->pass == 2; i++)
 897             {
 898                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 899                png_read_push_finish_row(png_ptr);
 900             }
 901             for (i = 0; i < 4 && png_ptr->pass == 2; i++)
 902             {
 903                png_push_have_row(png_ptr, png_bytep_NULL);
 904                png_read_push_finish_row(png_ptr);
 905             }
 906             if (png_ptr->pass == 4) /* pass 3 might be empty */
 907             {
 908                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 909                {
 910                   png_push_have_row(png_ptr, png_bytep_NULL);
 911                   png_read_push_finish_row(png_ptr);
 912                }
 913             }
 914             break;
 915          }
 916          case 3:
 917          {
 918             int i;
 919             for (i = 0; i < 4 && png_ptr->pass == 3; i++)
 920             {
 921                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 922                png_read_push_finish_row(png_ptr);
 923             }
 924             if (png_ptr->pass == 4) /* skip top two generated rows */
 925             {
 926                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 927                {
 928                   png_push_have_row(png_ptr, png_bytep_NULL);
 929                   png_read_push_finish_row(png_ptr);
 930                }
 931             }
 932             break;
 933          }
 934          case 4:
 935          {
 936             int i;
 937             for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 938             {
 939                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 940                png_read_push_finish_row(png_ptr);
 941             }
 942             for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 943             {
 944                png_push_have_row(png_ptr, png_bytep_NULL);
 945                png_read_push_finish_row(png_ptr);
 946             }
 947             if (png_ptr->pass == 6) /* pass 5 might be empty */
 948             {
 949                png_push_have_row(png_ptr, png_bytep_NULL);
 950                png_read_push_finish_row(png_ptr);
 951             }
 952             break;
 953          }
 954          case 5:
 955          {
 956             int i;
 957             for (i = 0; i < 2 && png_ptr->pass == 5; i++)
 958             {
 959                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 960                png_read_push_finish_row(png_ptr);
 961             }
 962             if (png_ptr->pass == 6) /* skip top generated row */
 963             {
 964                png_push_have_row(png_ptr, png_bytep_NULL);
 965                png_read_push_finish_row(png_ptr);
 966             }
 967             break;
 968          }
 969          case 6:
 970          {
 971             png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 972             png_read_push_finish_row(png_ptr);
 973             if (png_ptr->pass != 6)
 974                break;
 975             png_push_have_row(png_ptr, png_bytep_NULL);
 976             png_read_push_finish_row(png_ptr);
 977          }
 978       }
 979    }
 980    else
 981 #endif
 982    {
 983       png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 984       png_read_push_finish_row(png_ptr);
 985    }
 986 }
 987
 988 void /* PRIVATE */
 989 png_read_push_finish_row(png_structp png_ptr)
 990 {
 991 #ifdef PNG_USE_LOCAL_ARRAYS
 992    /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 993
 994    /* start of interlace block */
 995    PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
 996
 997    /* offset to next interlace block */
 998    PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
 999
1000    /* start of interlace block in the y direction */
1001    PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
1002
1003    /* offset to next interlace block in the y direction */
1004    PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
1005
1006    /* Height of interlace block.  This is not currently used - if you need
1007     * it, uncomment it here and in png.h
1008    PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
1009    */
1010 #endif
1011
1012    png_ptr->row_number++;
1013    if (png_ptr->row_number < png_ptr->num_rows)
1014       return;
1015
1016    if (png_ptr->interlaced)
1017    {
1018       png_ptr->row_number = 0;
1019       png_memset_check(png_ptr, png_ptr->prev_row, 0,
1020          png_ptr->rowbytes + 1);
1021       do
1022       {
1023          png_ptr->pass++;
1024          if ((png_ptr->pass == 1 && png_ptr->width < 5) ||
1025              (png_ptr->pass == 3 && png_ptr->width < 3) ||
1026              (png_ptr->pass == 5 && png_ptr->width < 2))
1027            png_ptr->pass++;
1028
1029          if (png_ptr->pass > 7)
1030             png_ptr->pass--;
1031          if (png_ptr->pass >= 7)
1032             break;
1033
1034          png_ptr->iwidth = (png_ptr->width +
1035             png_pass_inc[png_ptr->pass] - 1 -
1036             png_pass_start[png_ptr->pass]) /
1037             png_pass_inc[png_ptr->pass];
1038
1039          png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,
1040             png_ptr->iwidth) + 1;
1041
1042          if (png_ptr->transformations & PNG_INTERLACE)
1043             break;
1044
1045          png_ptr->num_rows = (png_ptr->height +
1046             png_pass_yinc[png_ptr->pass] - 1 -
1047             png_pass_ystart[png_ptr->pass]) /
1048             png_pass_yinc[png_ptr->pass];
1049
1050       } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
1051    }
1052 }
1053
1054 #if defined(PNG_READ_tEXt_SUPPORTED)
1055 void /* PRIVATE */
1056 png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
1057    length)
1058 {
1059    if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
1060       {
1061          png_error(png_ptr, "Out of place tEXt");
1062          info_ptr = info_ptr; /* to quiet some compiler warnings */
1063       }
1064
1065 #ifdef PNG_MAX_MALLOC_64K
1066    png_ptr->skip_length = 0;  /* This may not be necessary */
1067
1068    if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
1069    {
1070       png_warning(png_ptr, "tEXt chunk too large to fit in memory");
1071       png_ptr->skip_length = length - (png_uint_32)65535L;
1072       length = (png_uint_32)65535L;
1073    }
1074 #endif
1075
1076    png_ptr->current_text = (png_charp)png_malloc(png_ptr,
1077       (png_uint_32)(length + 1));
1078    png_ptr->current_text[length] = '\0';
1079    png_ptr->current_text_ptr = png_ptr->current_text;
1080    png_ptr->current_text_size = (png_size_t)length;
1081    png_ptr->current_text_left = (png_size_t)length;
1082    png_ptr->process_mode = PNG_READ_tEXt_MODE;
1083 }
1084
1085 void /* PRIVATE */
1086 png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
1087 {
1088    if (png_ptr->buffer_size && png_ptr->current_text_left)
1089    {
1090       png_size_t text_size;
1091
1092       if (png_ptr->buffer_size < png_ptr->current_text_left)
1093          text_size = png_ptr->buffer_size;
1094       else
1095          text_size = png_ptr->current_text_left;
1096       png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
1097       png_ptr->current_text_left -= text_size;
1098       png_ptr->current_text_ptr += text_size;
1099    }
1100    if (!(png_ptr->current_text_left))
1101    {
1102       png_textp text_ptr;
1103       png_charp text;
1104       png_charp key;
1105       int ret;
1106
1107       if (png_ptr->buffer_size < 4)
1108       {
1109          png_push_save_buffer(png_ptr);
1110          return;
1111       }
1112
1113       png_push_crc_finish(png_ptr);
1114
1115 #if defined(PNG_MAX_MALLOC_64K)
1116       if (png_ptr->skip_length)
1117          return;
1118 #endif
1119
1120       key = png_ptr->current_text;
1121
1122       for (text = key; *text; text++)
1123          /* empty loop */ ;
1124
1125       if (text < key + png_ptr->current_text_size)
1126          text++;
1127
1128       text_ptr = (png_textp)png_malloc(png_ptr,
1129          (png_uint_32)png_sizeof(png_text));
1130       text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
1131       text_ptr->key = key;
1132 #ifdef PNG_iTXt_SUPPORTED
1133       text_ptr->lang = NULL;
1134       text_ptr->lang_key = NULL;
1135 #endif
1136       text_ptr->text = text;
1137
1138       ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
1139
1140       png_free(png_ptr, key);
1141       png_free(png_ptr, text_ptr);
1142       png_ptr->current_text = NULL;
1143
1144       if (ret)
1145         png_warning(png_ptr, "Insufficient memory to store text chunk.");
1146    }
1147 }
1148 #endif
1149
1150 #if defined(PNG_READ_zTXt_SUPPORTED)
1151 void /* PRIVATE */
1152 png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
1153    length)
1154 {
1155    if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
1156       {
1157          png_error(png_ptr, "Out of place zTXt");
1158          info_ptr = info_ptr; /* to quiet some compiler warnings */
1159       }
1160
1161 #ifdef PNG_MAX_MALLOC_64K
1162    /* We can't handle zTXt chunks > 64K, since we don't have enough space
1163     * to be able to store the uncompressed data.  Actually, the threshold
1164     * is probably around 32K, but it isn't as definite as 64K is.
1165     */
1166    if (length > (png_uint_32)65535L)
1167    {
1168       png_warning(png_ptr, "zTXt chunk too large to fit in memory");
1169       png_push_crc_skip(png_ptr, length);
1170       return;
1171    }
1172 #endif
1173
1174    png_ptr->current_text = (png_charp)png_malloc(png_ptr,
1175       (png_uint_32)(length + 1));
1176    png_ptr->current_text[length] = '\0';
1177    png_ptr->current_text_ptr = png_ptr->current_text;
1178    png_ptr->current_text_size = (png_size_t)length;
1179    png_ptr->current_text_left = (png_size_t)length;
1180    png_ptr->process_mode = PNG_READ_zTXt_MODE;
1181 }
1182
1183 void /* PRIVATE */
1184 png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
1185 {
1186    if (png_ptr->buffer_size && png_ptr->current_text_left)
1187    {
1188       png_size_t text_size;
1189
1190       if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
1191          text_size = png_ptr->buffer_size;
1192       else
1193          text_size = png_ptr->current_text_left;
1194       png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
1195       png_ptr->current_text_left -= text_size;
1196       png_ptr->current_text_ptr += text_size;
1197    }
1198    if (!(png_ptr->current_text_left))
1199    {
1200       png_textp text_ptr;
1201       png_charp text;
1202       png_charp key;
1203       int ret;
1204       png_size_t text_size, key_size;
1205
1206       if (png_ptr->buffer_size < 4)
1207       {
1208          png_push_save_buffer(png_ptr);
1209          return;
1210       }
1211
1212       png_push_crc_finish(png_ptr);
1213
1214       key = png_ptr->current_text;
1215
1216       for (text = key; *text; text++)
1217          /* empty loop */ ;
1218
1219       /* zTXt can't have zero text */
1220       if (text >= key + png_ptr->current_text_size)
1221       {
1222          png_ptr->current_text = NULL;
1223          png_free(png_ptr, key);
1224          return;
1225       }
1226
1227       text++;
1228
1229       if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */
1230       {
1231          png_ptr->current_text = NULL;
1232          png_free(png_ptr, key);
1233          return;
1234       }
1235
1236       text++;
1237
1238       png_ptr->zstream.next_in = (png_bytep )text;
1239       png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -
1240          (text - key));
1241       png_ptr->zstream.next_out = png_ptr->zbuf;
1242       png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1243
1244       key_size = text - key;
1245       text_size = 0;
1246       text = NULL;
1247       ret = Z_STREAM_END;
1248
1249       while (png_ptr->zstream.avail_in)
1250       {
1251          ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
1252          if (ret != Z_OK && ret != Z_STREAM_END)
1253          {
1254             inflateReset(&png_ptr->zstream);
1255             png_ptr->zstream.avail_in = 0;
1256             png_ptr->current_text = NULL;
1257             png_free(png_ptr, key);
1258             png_free(png_ptr, text);
1259             return;
1260          }
1261          if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)
1262          {
1263             if (text == NULL)
1264             {
1265                text = (png_charp)png_malloc(png_ptr,
1266                      (png_uint_32)(png_ptr->zbuf_size
1267                      - png_ptr->zstream.avail_out + key_size + 1));
1268                png_memcpy(text + key_size, png_ptr->zbuf,
1269                   png_ptr->zbuf_size - png_ptr->zstream.avail_out);
1270                png_memcpy(text, key, key_size);
1271                text_size = key_size + png_ptr->zbuf_size -
1272                   png_ptr->zstream.avail_out;
1273                *(text + text_size) = '\0';
1274             }
1275             else
1276             {
1277                png_charp tmp;
1278
1279                tmp = text;
1280                text = (png_charp)png_malloc(png_ptr, text_size +
1281                   (png_uint_32)(png_ptr->zbuf_size
1282                   - png_ptr->zstream.avail_out + 1));
1283                png_memcpy(text, tmp, text_size);
1284                png_free(png_ptr, tmp);
1285                png_memcpy(text + text_size, png_ptr->zbuf,
1286                   png_ptr->zbuf_size - png_ptr->zstream.avail_out);
1287                text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
1288                *(text + text_size) = '\0';
1289             }
1290             if (ret != Z_STREAM_END)
1291             {
1292                png_ptr->zstream.next_out = png_ptr->zbuf;
1293                png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1294             }
1295          }
1296          else
1297          {
1298             break;
1299          }
1300
1301          if (ret == Z_STREAM_END)
1302             break;
1303       }
1304
1305       inflateReset(&png_ptr->zstream);
1306       png_ptr->zstream.avail_in = 0;
1307
1308       if (ret != Z_STREAM_END)
1309       {
1310          png_ptr->current_text = NULL;
1311          png_free(png_ptr, key);
1312          png_free(png_ptr, text);
1313          return;
1314       }
1315
1316       png_ptr->current_text = NULL;
1317       png_free(png_ptr, key);
1318       key = text;
1319       text += key_size;
1320
1321       text_ptr = (png_textp)png_malloc(png_ptr,
1322           (png_uint_32)png_sizeof(png_text));
1323       text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
1324       text_ptr->key = key;
1325 #ifdef PNG_iTXt_SUPPORTED
1326       text_ptr->lang = NULL;
1327       text_ptr->lang_key = NULL;
1328 #endif
1329       text_ptr->text = text;
1330
1331       ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
1332
1333       png_free(png_ptr, key);
1334       png_free(png_ptr, text_ptr);
1335
1336       if (ret)
1337         png_warning(png_ptr, "Insufficient memory to store text chunk.");
1338    }
1339 }
1340 #endif
1341
1342 #if defined(PNG_READ_iTXt_SUPPORTED)
1343 void /* PRIVATE */
1344 png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
1345    length)
1346 {
1347    if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
1348       {
1349          png_error(png_ptr, "Out of place iTXt");
1350          info_ptr = info_ptr; /* to quiet some compiler warnings */
1351       }
1352
1353 #ifdef PNG_MAX_MALLOC_64K
1354    png_ptr->skip_length = 0;  /* This may not be necessary */
1355
1356    if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
1357    {
1358       png_warning(png_ptr, "iTXt chunk too large to fit in memory");
1359       png_ptr->skip_length = length - (png_uint_32)65535L;
1360       length = (png_uint_32)65535L;
1361    }
1362 #endif
1363
1364    png_ptr->current_text = (png_charp)png_malloc(png_ptr,
1365       (png_uint_32)(length + 1));
1366    png_ptr->current_text[length] = '\0';
1367    png_ptr->current_text_ptr = png_ptr->current_text;
1368    png_ptr->current_text_size = (png_size_t)length;
1369    png_ptr->current_text_left = (png_size_t)length;
1370    png_ptr->process_mode = PNG_READ_iTXt_MODE;
1371 }
1372
1373 void /* PRIVATE */
1374 png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
1375 {
1376
1377    if (png_ptr->buffer_size && png_ptr->current_text_left)
1378    {
1379       png_size_t text_size;
1380
1381       if (png_ptr->buffer_size < png_ptr->current_text_left)
1382          text_size = png_ptr->buffer_size;
1383       else
1384          text_size = png_ptr->current_text_left;
1385       png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
1386       png_ptr->current_text_left -= text_size;
1387       png_ptr->current_text_ptr += text_size;
1388    }
1389    if (!(png_ptr->current_text_left))
1390    {
1391       png_textp text_ptr;
1392       png_charp key;
1393       int comp_flag;
1394       png_charp lang;
1395       png_charp lang_key;
1396       png_charp text;
1397       int ret;
1398
1399       if (png_ptr->buffer_size < 4)
1400       {
1401          png_push_save_buffer(png_ptr);
1402          return;
1403       }
1404
1405       png_push_crc_finish(png_ptr);
1406
1407 #if defined(PNG_MAX_MALLOC_64K)
1408       if (png_ptr->skip_length)
1409          return;
1410 #endif
1411
1412       key = png_ptr->current_text;
1413
1414       for (lang = key; *lang; lang++)
1415          /* empty loop */ ;
1416
1417       if (lang < key + png_ptr->current_text_size - 3)
1418          lang++;
1419
1420       comp_flag = *lang++;
1421       lang++;     /* skip comp_type, always zero */
1422
1423       for (lang_key = lang; *lang_key; lang_key++)
1424          /* empty loop */ ;
1425       lang_key++;        /* skip NUL separator */
1426
1427       text=lang_key;
1428       if (lang_key < key + png_ptr->current_text_size - 1)
1429       {
1430         for (; *text; text++)
1431            /* empty loop */ ;
1432       }
1433
1434       if (text < key + png_ptr->current_text_size)
1435          text++;
1436
1437       text_ptr = (png_textp)png_malloc(png_ptr,
1438          (png_uint_32)png_sizeof(png_text));
1439       text_ptr->compression = comp_flag + 2;
1440       text_ptr->key = key;
1441       text_ptr->lang = lang;
1442       text_ptr->lang_key = lang_key;
1443       text_ptr->text = text;
1444       text_ptr->text_length = 0;
1445       text_ptr->itxt_length = png_strlen(text);
1446
1447       ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
1448
1449       png_ptr->current_text = NULL;
1450
1451       png_free(png_ptr, text_ptr);
1452       if (ret)
1453         png_warning(png_ptr, "Insufficient memory to store iTXt chunk.");
1454    }
1455 }
1456 #endif
1457
1458 /* This function is called when we haven't found a handler for this
1459  * chunk.  If there isn't a problem with the chunk itself (ie a bad chunk
1460  * name or a critical chunk), the chunk is (currently) silently ignored.
1461  */
1462 void /* PRIVATE */
1463 png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
1464    length)
1465 {
1466    png_uint_32 skip = 0;
1467
1468    if (!(png_ptr->chunk_name[0] & 0x20))
1469    {
1470 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
1471       if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
1472          PNG_HANDLE_CHUNK_ALWAYS
1473 #if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
1474          && png_ptr->read_user_chunk_fn == NULL
1475 #endif
1476          )
1477 #endif
1478          png_chunk_error(png_ptr, "unknown critical chunk");
1479
1480       info_ptr = info_ptr; /* to quiet some compiler warnings */
1481    }
1482
1483 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
1484    if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
1485    {
1486 #ifdef PNG_MAX_MALLOC_64K
1487       if (length > (png_uint_32)65535L)
1488       {
1489           png_warning(png_ptr, "unknown chunk too large to fit in memory");
1490           skip = length - (png_uint_32)65535L;
1491           length = (png_uint_32)65535L;
1492       }
1493 #endif
1494       png_memcpy((png_charp)png_ptr->unknown_chunk.name,
1495                  (png_charp)png_ptr->chunk_name,
1496                  png_sizeof(png_ptr->unknown_chunk.name));
1497       png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1]
1498         = '\0';
1499
1500       png_ptr->unknown_chunk.size = (png_size_t)length;
1501       if (length == 0)
1502          png_ptr->unknown_chunk.data = NULL;
1503       else
1504       {
1505          png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,
1506        (png_uint_32)length);
1507          png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
1508       }
1509 #if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
1510       if (png_ptr->read_user_chunk_fn != NULL)
1511       {
1512          /* callback to user unknown chunk handler */
1513          int ret;
1514          ret = (*(png_ptr->read_user_chunk_fn))
1515            (png_ptr, &png_ptr->unknown_chunk);
1516          if (ret < 0)
1517             png_chunk_error(png_ptr, "error in user chunk");
1518          if (ret == 0)
1519          {
1520             if (!(png_ptr->chunk_name[0] & 0x20))
1521                if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
1522                     PNG_HANDLE_CHUNK_ALWAYS)
1523                   png_chunk_error(png_ptr, "unknown critical chunk");
1524             png_set_unknown_chunks(png_ptr, info_ptr,
1525                &png_ptr->unknown_chunk, 1);
1526          }
1527       }
1528       else
1529 #endif
1530         png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
1531       png_free(png_ptr, png_ptr->unknown_chunk.data);
1532       png_ptr->unknown_chunk.data = NULL;
1533    }
1534    else
1535 #endif
1536       skip=length;
1537    png_push_crc_skip(png_ptr, skip);
1538 }
1539
1540 void /* PRIVATE */
1541 png_push_have_info(png_structp png_ptr, png_infop info_ptr)
1542 {
1543    if (png_ptr->info_fn != NULL)
1544       (*(png_ptr->info_fn))(png_ptr, info_ptr);
1545 }
1546
1547 void /* PRIVATE */
1548 png_push_have_end(png_structp png_ptr, png_infop info_ptr)
1549 {
1550    if (png_ptr->end_fn != NULL)
1551       (*(png_ptr->end_fn))(png_ptr, info_ptr);
1552 }
1553
1554 void /* PRIVATE */
1555 png_push_have_row(png_structp png_ptr, png_bytep row)
1556 {
1557    if (png_ptr->row_fn != NULL)
1558       (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
1559          (int)png_ptr->pass);
1560 }
1561
1562 void PNGAPI
1563 png_progressive_combine_row (png_structp png_ptr,
1564    png_bytep old_row, png_bytep new_row)
1565 {
1566 #ifdef PNG_USE_LOCAL_ARRAYS
1567    PNG_CONST int FARDATA png_pass_dsp_mask[7] =
1568       {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
1569 #endif
1570    if (png_ptr == NULL) return;
1571    if (new_row != NULL)    /* new_row must == png_ptr->row_buf here. */
1572       png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
1573 }
1574
1575 void PNGAPI
1576 png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
1577    png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
1578    png_progressive_end_ptr end_fn)
1579 {
1580    if (png_ptr == NULL) return;
1581    png_ptr->info_fn = info_fn;
1582    png_ptr->row_fn = row_fn;
1583    png_ptr->end_fn = end_fn;
1584
1585    png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
1586 }
1587
1588 png_voidp PNGAPI
1589 png_get_progressive_ptr(png_structp png_ptr)
1590 {
1591    if (png_ptr == NULL) return (NULL);
1592    return png_ptr->io_ptr;
1593 }
1594 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */