The Ecere SDK - sdk/blob - deps/libpng-1.4.0/pngpread.c

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