pngpread.c

   1
   2 /* pngpread.c - read a png file in push mode
   3  *
   4  * Last changed in libpng 1.6.11 [June 5, 2014]
   5  * Copyright (c) 1998-2014 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 #include "pngpriv.h"
  15
  16 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  17
  18 /* Push model modes */
  19 #define PNG_READ_SIG_MODE   0
  20 #define PNG_READ_CHUNK_MODE 1
  21 #define PNG_READ_IDAT_MODE  2
  22 #define PNG_SKIP_MODE       3
  23 #define PNG_READ_tEXt_MODE  4
  24 #define PNG_READ_zTXt_MODE  5
  25 #define PNG_READ_DONE_MODE  6
  26 #define PNG_READ_iTXt_MODE  7
  27 #define PNG_ERROR_MODE      8
  28
  29 void PNGAPI
  30 png_process_data(png_structrp png_ptr, png_inforp info_ptr,
  31     png_bytep buffer, png_size_t buffer_size)
  32 {
  33    if (png_ptr == NULL || info_ptr == NULL)
  34       return;
  35
  36    png_push_restore_buffer(png_ptr, buffer, buffer_size);
  37
  38    while (png_ptr->buffer_size)
  39    {
  40       png_process_some_data(png_ptr, info_ptr);
  41    }
  42 }
  43
  44 png_size_t PNGAPI
  45 png_process_data_pause(png_structrp png_ptr, int save)
  46 {
  47    if (png_ptr != NULL)
  48    {
  49       /* It's easiest for the caller if we do the save, then the caller doesn't
  50        * have to supply the same data again:
  51        */
  52       if (save != 0)
  53          png_push_save_buffer(png_ptr);
  54       else
  55       {
  56          /* This includes any pending saved bytes: */
  57          png_size_t remaining = png_ptr->buffer_size;
  58          png_ptr->buffer_size = 0;
  59
  60          /* So subtract the saved buffer size, unless all the data
  61           * is actually 'saved', in which case we just return 0
  62           */
  63          if (png_ptr->save_buffer_size < remaining)
  64             return remaining - png_ptr->save_buffer_size;
  65       }
  66    }
  67
  68    return 0;
  69 }
  70
  71 png_uint_32 PNGAPI
  72 png_process_data_skip(png_structrp png_ptr)
  73 {
  74    png_uint_32 remaining = 0;
  75
  76    if (png_ptr != NULL && png_ptr->process_mode == PNG_SKIP_MODE &&
  77       png_ptr->skip_length > 0)
  78    {
  79       /* At the end of png_process_data the buffer size must be 0 (see the loop
  80        * above) so we can detect a broken call here:
  81        */
  82       if (png_ptr->buffer_size != 0)
  83          png_error(png_ptr,
  84             "png_process_data_skip called inside png_process_data");
  85
  86       /* If is impossible for there to be a saved buffer at this point -
  87        * otherwise we could not be in SKIP mode.  This will also happen if
  88        * png_process_skip is called inside png_process_data (but only very
  89        * rarely.)
  90        */
  91       if (png_ptr->save_buffer_size != 0)
  92          png_error(png_ptr, "png_process_data_skip called with saved data");
  93
  94       remaining = png_ptr->skip_length;
  95       png_ptr->skip_length = 0;
  96       png_ptr->process_mode = PNG_READ_CHUNK_MODE;
  97    }
  98
  99    return remaining;
 100 }
 101
 102 /* What we do with the incoming data depends on what we were previously
 103  * doing before we ran out of data...
 104  */
 105 void /* PRIVATE */
 106 png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)
 107 {
 108    if (png_ptr == NULL)
 109       return;
 110
 111    switch (png_ptr->process_mode)
 112    {
 113       case PNG_READ_SIG_MODE:
 114       {
 115          png_push_read_sig(png_ptr, info_ptr);
 116          break;
 117       }
 118
 119       case PNG_READ_CHUNK_MODE:
 120       {
 121          png_push_read_chunk(png_ptr, info_ptr);
 122          break;
 123       }
 124
 125       case PNG_READ_IDAT_MODE:
 126       {
 127          png_push_read_IDAT(png_ptr);
 128          break;
 129       }
 130
 131       case PNG_SKIP_MODE:
 132       {
 133          png_push_crc_finish(png_ptr);
 134          break;
 135       }
 136
 137       default:
 138       {
 139          png_ptr->buffer_size = 0;
 140          break;
 141       }
 142    }
 143 }
 144
 145 /* Read any remaining signature bytes from the stream and compare them with
 146  * the correct PNG signature.  It is possible that this routine is called
 147  * with bytes already read from the signature, either because they have been
 148  * checked by the calling application, or because of multiple calls to this
 149  * routine.
 150  */
 151 void /* PRIVATE */
 152 png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
 153 {
 154    png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */
 155              num_to_check = 8 - num_checked;
 156
 157    if (png_ptr->buffer_size < num_to_check)
 158    {
 159       num_to_check = png_ptr->buffer_size;
 160    }
 161
 162    png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
 163        num_to_check);
 164    png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);
 165
 166    if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
 167    {
 168       if (num_checked < 4 &&
 169           png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
 170          png_error(png_ptr, "Not a PNG file");
 171
 172       else
 173          png_error(png_ptr, "PNG file corrupted by ASCII conversion");
 174    }
 175    else
 176    {
 177       if (png_ptr->sig_bytes >= 8)
 178       {
 179          png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 180       }
 181    }
 182 }
 183
 184 void /* PRIVATE */
 185 png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 186 {
 187    png_uint_32 chunk_name;
 188 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 189    int keep; /* unknown handling method */
 190 #endif
 191
 192    /* First we make sure we have enough data for the 4 byte chunk name
 193     * and the 4 byte chunk length before proceeding with decoding the
 194     * chunk data.  To fully decode each of these chunks, we also make
 195     * sure we have enough data in the buffer for the 4 byte CRC at the
 196     * end of every chunk (except IDAT, which is handled separately).
 197     */
 198    if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
 199    {
 200       png_byte chunk_length[4];
 201       png_byte chunk_tag[4];
 202
 203       if (png_ptr->buffer_size < 8)
 204       {
 205          png_push_save_buffer(png_ptr);
 206          return;
 207       }
 208
 209       png_push_fill_buffer(png_ptr, chunk_length, 4);
 210       png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
 211       png_reset_crc(png_ptr);
 212       png_crc_read(png_ptr, chunk_tag, 4);
 213       png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);
 214       png_check_chunk_name(png_ptr, png_ptr->chunk_name);
 215       png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
 216    }
 217
 218    chunk_name = png_ptr->chunk_name;
 219
 220    if (chunk_name == png_IDAT)
 221    {
 222       if (png_ptr->mode & PNG_AFTER_IDAT)
 223          png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
 224
 225       /* If we reach an IDAT chunk, this means we have read all of the
 226        * header chunks, and we can start reading the image (or if this
 227        * is called after the image has been read - we have an error).
 228        */
 229       if (!(png_ptr->mode & PNG_HAVE_IHDR))
 230          png_error(png_ptr, "Missing IHDR before IDAT");
 231
 232       else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
 233           !(png_ptr->mode & PNG_HAVE_PLTE))
 234          png_error(png_ptr, "Missing PLTE before IDAT");
 235
 236       png_ptr->mode |= PNG_HAVE_IDAT;
 237       png_ptr->process_mode = PNG_READ_IDAT_MODE;
 238
 239       if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
 240          if (png_ptr->push_length == 0)
 241             return;
 242
 243       if (png_ptr->mode & PNG_AFTER_IDAT)
 244          png_benign_error(png_ptr, "Too many IDATs found");
 245    }
 246
 247    if (chunk_name == png_IHDR)
 248    {
 249       if (png_ptr->push_length != 13)
 250          png_error(png_ptr, "Invalid IHDR length");
 251
 252       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 253       {
 254          png_push_save_buffer(png_ptr);
 255          return;
 256       }
 257
 258       png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
 259    }
 260
 261    else if (chunk_name == png_IEND)
 262    {
 263       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 264       {
 265          png_push_save_buffer(png_ptr);
 266          return;
 267       }
 268
 269       png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
 270
 271       png_ptr->process_mode = PNG_READ_DONE_MODE;
 272       png_push_have_end(png_ptr, info_ptr);
 273    }
 274
 275 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 276    else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
 277    {
 278       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 279       {
 280          png_push_save_buffer(png_ptr);
 281          return;
 282       }
 283
 284       png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length, keep);
 285
 286       if (chunk_name == png_PLTE)
 287          png_ptr->mode |= PNG_HAVE_PLTE;
 288    }
 289 #endif
 290
 291    else if (chunk_name == png_PLTE)
 292    {
 293       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 294       {
 295          png_push_save_buffer(png_ptr);
 296          return;
 297       }
 298       png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
 299    }
 300
 301    else if (chunk_name == png_IDAT)
 302    {
 303       png_ptr->idat_size = png_ptr->push_length;
 304       png_ptr->process_mode = PNG_READ_IDAT_MODE;
 305       png_push_have_info(png_ptr, info_ptr);
 306       png_ptr->zstream.avail_out =
 307           (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,
 308           png_ptr->iwidth) + 1;
 309       png_ptr->zstream.next_out = png_ptr->row_buf;
 310       return;
 311    }
 312
 313 #ifdef PNG_READ_gAMA_SUPPORTED
 314    else if (png_ptr->chunk_name == png_gAMA)
 315    {
 316       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 317       {
 318          png_push_save_buffer(png_ptr);
 319          return;
 320       }
 321
 322       png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
 323    }
 324
 325 #endif
 326 #ifdef PNG_READ_sBIT_SUPPORTED
 327    else if (png_ptr->chunk_name == png_sBIT)
 328    {
 329       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 330       {
 331          png_push_save_buffer(png_ptr);
 332          return;
 333       }
 334
 335       png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
 336    }
 337
 338 #endif
 339 #ifdef PNG_READ_cHRM_SUPPORTED
 340    else if (png_ptr->chunk_name == png_cHRM)
 341    {
 342       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 343       {
 344          png_push_save_buffer(png_ptr);
 345          return;
 346       }
 347
 348       png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
 349    }
 350
 351 #endif
 352 #ifdef PNG_READ_sRGB_SUPPORTED
 353    else if (chunk_name == png_sRGB)
 354    {
 355       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 356       {
 357          png_push_save_buffer(png_ptr);
 358          return;
 359       }
 360
 361       png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
 362    }
 363
 364 #endif
 365 #ifdef PNG_READ_iCCP_SUPPORTED
 366    else if (png_ptr->chunk_name == png_iCCP)
 367    {
 368       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 369       {
 370          png_push_save_buffer(png_ptr);
 371          return;
 372       }
 373
 374       png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
 375    }
 376
 377 #endif
 378 #ifdef PNG_READ_sPLT_SUPPORTED
 379    else if (chunk_name == png_sPLT)
 380    {
 381       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 382       {
 383          png_push_save_buffer(png_ptr);
 384          return;
 385       }
 386
 387       png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
 388    }
 389
 390 #endif
 391 #ifdef PNG_READ_tRNS_SUPPORTED
 392    else if (chunk_name == png_tRNS)
 393    {
 394       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 395       {
 396          png_push_save_buffer(png_ptr);
 397          return;
 398       }
 399
 400       png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
 401    }
 402
 403 #endif
 404 #ifdef PNG_READ_bKGD_SUPPORTED
 405    else if (chunk_name == png_bKGD)
 406    {
 407       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 408       {
 409          png_push_save_buffer(png_ptr);
 410          return;
 411       }
 412
 413       png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
 414    }
 415
 416 #endif
 417 #ifdef PNG_READ_hIST_SUPPORTED
 418    else if (chunk_name == png_hIST)
 419    {
 420       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 421       {
 422          png_push_save_buffer(png_ptr);
 423          return;
 424       }
 425
 426       png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
 427    }
 428
 429 #endif
 430 #ifdef PNG_READ_pHYs_SUPPORTED
 431    else if (chunk_name == png_pHYs)
 432    {
 433       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 434       {
 435          png_push_save_buffer(png_ptr);
 436          return;
 437       }
 438
 439       png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
 440    }
 441
 442 #endif
 443 #ifdef PNG_READ_oFFs_SUPPORTED
 444    else if (chunk_name == png_oFFs)
 445    {
 446       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 447       {
 448          png_push_save_buffer(png_ptr);
 449          return;
 450       }
 451
 452       png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
 453    }
 454 #endif
 455
 456 #ifdef PNG_READ_pCAL_SUPPORTED
 457    else if (chunk_name == png_pCAL)
 458    {
 459       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 460       {
 461          png_push_save_buffer(png_ptr);
 462          return;
 463       }
 464
 465       png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
 466    }
 467
 468 #endif
 469 #ifdef PNG_READ_sCAL_SUPPORTED
 470    else if (chunk_name == png_sCAL)
 471    {
 472       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 473       {
 474          png_push_save_buffer(png_ptr);
 475          return;
 476       }
 477
 478       png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
 479    }
 480
 481 #endif
 482 #ifdef PNG_READ_tIME_SUPPORTED
 483    else if (chunk_name == png_tIME)
 484    {
 485       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 486       {
 487          png_push_save_buffer(png_ptr);
 488          return;
 489       }
 490
 491       png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
 492    }
 493
 494 #endif
 495 #ifdef PNG_READ_tEXt_SUPPORTED
 496    else if (chunk_name == png_tEXt)
 497    {
 498       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 499       {
 500          png_push_save_buffer(png_ptr);
 501          return;
 502       }
 503
 504       png_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
 505    }
 506
 507 #endif
 508 #ifdef PNG_READ_zTXt_SUPPORTED
 509    else if (chunk_name == png_zTXt)
 510    {
 511       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 512       {
 513          png_push_save_buffer(png_ptr);
 514          return;
 515       }
 516
 517       png_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
 518    }
 519
 520 #endif
 521 #ifdef PNG_READ_iTXt_SUPPORTED
 522    else if (chunk_name == png_iTXt)
 523    {
 524       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 525       {
 526          png_push_save_buffer(png_ptr);
 527          return;
 528       }
 529
 530       png_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
 531    }
 532 #endif
 533
 534    else
 535    {
 536       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 537       {
 538          png_push_save_buffer(png_ptr);
 539          return;
 540       }
 541       png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length,
 542          PNG_HANDLE_CHUNK_AS_DEFAULT);
 543    }
 544
 545    png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
 546 }
 547
 548 void /* PRIVATE */
 549 png_push_crc_skip(png_structrp png_ptr, png_uint_32 skip)
 550 {
 551    png_ptr->process_mode = PNG_SKIP_MODE;
 552    png_ptr->skip_length = skip;
 553 }
 554
 555 void /* PRIVATE */
 556 png_push_crc_finish(png_structrp png_ptr)
 557 {
 558    if (png_ptr->skip_length && png_ptr->save_buffer_size)
 559    {
 560       png_size_t save_size = png_ptr->save_buffer_size;
 561       png_uint_32 skip_length = png_ptr->skip_length;
 562
 563       /* We want the smaller of 'skip_length' and 'save_buffer_size', but
 564        * they are of different types and we don't know which variable has the
 565        * fewest bits.  Carefully select the smaller and cast it to the type of
 566        * the larger - this cannot overflow.  Do not cast in the following test
 567        * - it will break on either 16 or 64 bit platforms.
 568        */
 569       if (skip_length < save_size)
 570          save_size = (png_size_t)skip_length;
 571
 572       else
 573          skip_length = (png_uint_32)save_size;
 574
 575       png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
 576
 577       png_ptr->skip_length -= skip_length;
 578       png_ptr->buffer_size -= save_size;
 579       png_ptr->save_buffer_size -= save_size;
 580       png_ptr->save_buffer_ptr += save_size;
 581    }
 582    if (png_ptr->skip_length && png_ptr->current_buffer_size)
 583    {
 584       png_size_t save_size = png_ptr->current_buffer_size;
 585       png_uint_32 skip_length = png_ptr->skip_length;
 586
 587       /* We want the smaller of 'skip_length' and 'current_buffer_size', here,
 588        * the same problem exists as above and the same solution.
 589        */
 590       if (skip_length < save_size)
 591          save_size = (png_size_t)skip_length;
 592
 593       else
 594          skip_length = (png_uint_32)save_size;
 595
 596       png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
 597
 598       png_ptr->skip_length -= skip_length;
 599       png_ptr->buffer_size -= save_size;
 600       png_ptr->current_buffer_size -= save_size;
 601       png_ptr->current_buffer_ptr += save_size;
 602    }
 603    if (!png_ptr->skip_length)
 604    {
 605       if (png_ptr->buffer_size < 4)
 606       {
 607          png_push_save_buffer(png_ptr);
 608          return;
 609       }
 610
 611       png_crc_finish(png_ptr, 0);
 612       png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 613    }
 614 }
 615
 616 void PNGCBAPI
 617 png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
 618 {
 619    png_bytep ptr;
 620
 621    if (png_ptr == NULL)
 622       return;
 623
 624    ptr = buffer;
 625    if (png_ptr->save_buffer_size)
 626    {
 627       png_size_t save_size;
 628
 629       if (length < png_ptr->save_buffer_size)
 630          save_size = length;
 631
 632       else
 633          save_size = png_ptr->save_buffer_size;
 634
 635       memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
 636       length -= save_size;
 637       ptr += save_size;
 638       png_ptr->buffer_size -= save_size;
 639       png_ptr->save_buffer_size -= save_size;
 640       png_ptr->save_buffer_ptr += save_size;
 641    }
 642    if (length && png_ptr->current_buffer_size)
 643    {
 644       png_size_t save_size;
 645
 646       if (length < png_ptr->current_buffer_size)
 647          save_size = length;
 648
 649       else
 650          save_size = png_ptr->current_buffer_size;
 651
 652       memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
 653       png_ptr->buffer_size -= save_size;
 654       png_ptr->current_buffer_size -= save_size;
 655       png_ptr->current_buffer_ptr += save_size;
 656    }
 657 }
 658
 659 void /* PRIVATE */
 660 png_push_save_buffer(png_structrp png_ptr)
 661 {
 662    if (png_ptr->save_buffer_size)
 663    {
 664       if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
 665       {
 666          png_size_t i, istop;
 667          png_bytep sp;
 668          png_bytep dp;
 669
 670          istop = png_ptr->save_buffer_size;
 671          for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
 672              i < istop; i++, sp++, dp++)
 673          {
 674             *dp = *sp;
 675          }
 676       }
 677    }
 678    if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
 679        png_ptr->save_buffer_max)
 680    {
 681       png_size_t new_max;
 682       png_bytep old_buffer;
 683
 684       if (png_ptr->save_buffer_size > PNG_SIZE_MAX -
 685           (png_ptr->current_buffer_size + 256))
 686       {
 687          png_error(png_ptr, "Potential overflow of save_buffer");
 688       }
 689
 690       new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
 691       old_buffer = png_ptr->save_buffer;
 692       png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr,
 693           (png_size_t)new_max);
 694
 695       if (png_ptr->save_buffer == NULL)
 696       {
 697          png_free(png_ptr, old_buffer);
 698          png_error(png_ptr, "Insufficient memory for save_buffer");
 699       }
 700
 701       memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
 702       png_free(png_ptr, old_buffer);
 703       png_ptr->save_buffer_max = new_max;
 704    }
 705    if (png_ptr->current_buffer_size)
 706    {
 707       memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
 708          png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);
 709       png_ptr->save_buffer_size += png_ptr->current_buffer_size;
 710       png_ptr->current_buffer_size = 0;
 711    }
 712    png_ptr->save_buffer_ptr = png_ptr->save_buffer;
 713    png_ptr->buffer_size = 0;
 714 }
 715
 716 void /* PRIVATE */
 717 png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,
 718    png_size_t buffer_length)
 719 {
 720    png_ptr->current_buffer = buffer;
 721    png_ptr->current_buffer_size = buffer_length;
 722    png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
 723    png_ptr->current_buffer_ptr = png_ptr->current_buffer;
 724 }
 725
 726 void /* PRIVATE */
 727 png_push_read_IDAT(png_structrp png_ptr)
 728 {
 729    if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
 730    {
 731       png_byte chunk_length[4];
 732       png_byte chunk_tag[4];
 733
 734       /* TODO: this code can be commoned up with the same code in push_read */
 735       if (png_ptr->buffer_size < 8)
 736       {
 737          png_push_save_buffer(png_ptr);
 738          return;
 739       }
 740
 741       png_push_fill_buffer(png_ptr, chunk_length, 4);
 742       png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
 743       png_reset_crc(png_ptr);
 744       png_crc_read(png_ptr, chunk_tag, 4);
 745       png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);
 746       png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
 747
 748       if (png_ptr->chunk_name != png_IDAT)
 749       {
 750          png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 751
 752          if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
 753             png_error(png_ptr, "Not enough compressed data");
 754
 755          return;
 756       }
 757
 758       png_ptr->idat_size = png_ptr->push_length;
 759    }
 760
 761    if (png_ptr->idat_size && png_ptr->save_buffer_size)
 762    {
 763       png_size_t save_size = png_ptr->save_buffer_size;
 764       png_uint_32 idat_size = png_ptr->idat_size;
 765
 766       /* We want the smaller of 'idat_size' and 'current_buffer_size', but they
 767        * are of different types and we don't know which variable has the fewest
 768        * bits.  Carefully select the smaller and cast it to the type of the
 769        * larger - this cannot overflow.  Do not cast in the following test - it
 770        * will break on either 16 or 64 bit platforms.
 771        */
 772       if (idat_size < save_size)
 773          save_size = (png_size_t)idat_size;
 774
 775       else
 776          idat_size = (png_uint_32)save_size;
 777
 778       png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
 779
 780       png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
 781
 782       png_ptr->idat_size -= idat_size;
 783       png_ptr->buffer_size -= save_size;
 784       png_ptr->save_buffer_size -= save_size;
 785       png_ptr->save_buffer_ptr += save_size;
 786    }
 787
 788    if (png_ptr->idat_size && png_ptr->current_buffer_size)
 789    {
 790       png_size_t save_size = png_ptr->current_buffer_size;
 791       png_uint_32 idat_size = png_ptr->idat_size;
 792
 793       /* We want the smaller of 'idat_size' and 'current_buffer_size', but they
 794        * are of different types and we don't know which variable has the fewest
 795        * bits.  Carefully select the smaller and cast it to the type of the
 796        * larger - this cannot overflow.
 797        */
 798       if (idat_size < save_size)
 799          save_size = (png_size_t)idat_size;
 800
 801       else
 802          idat_size = (png_uint_32)save_size;
 803
 804       png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
 805
 806       png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);
 807
 808       png_ptr->idat_size -= idat_size;
 809       png_ptr->buffer_size -= save_size;
 810       png_ptr->current_buffer_size -= save_size;
 811       png_ptr->current_buffer_ptr += save_size;
 812    }
 813    if (!png_ptr->idat_size)
 814    {
 815       if (png_ptr->buffer_size < 4)
 816       {
 817          png_push_save_buffer(png_ptr);
 818          return;
 819       }
 820
 821       png_crc_finish(png_ptr, 0);
 822       png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
 823       png_ptr->mode |= PNG_AFTER_IDAT;
 824       png_ptr->zowner = 0;
 825    }
 826 }
 827
 828 void /* PRIVATE */
 829 png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
 830    png_size_t buffer_length)
 831 {
 832    /* The caller checks for a non-zero buffer length. */
 833    if (!(buffer_length > 0) || buffer == NULL)
 834       png_error(png_ptr, "No IDAT data (internal error)");
 835
 836    /* This routine must process all the data it has been given
 837     * before returning, calling the row callback as required to
 838     * handle the uncompressed results.
 839     */
 840    png_ptr->zstream.next_in = buffer;
 841    /* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */
 842    png_ptr->zstream.avail_in = (uInt)buffer_length;
 843
 844    /* Keep going until the decompressed data is all processed
 845     * or the stream marked as finished.
 846     */
 847    while (png_ptr->zstream.avail_in > 0 &&
 848       !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
 849    {
 850       int ret;
 851
 852       /* We have data for zlib, but we must check that zlib
 853        * has someplace to put the results.  It doesn't matter
 854        * if we don't expect any results -- it may be the input
 855        * data is just the LZ end code.
 856        */
 857       if (!(png_ptr->zstream.avail_out > 0))
 858       {
 859          /* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */
 860          png_ptr->zstream.avail_out = (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,
 861              png_ptr->iwidth) + 1);
 862
 863          png_ptr->zstream.next_out = png_ptr->row_buf;
 864       }
 865
 866       /* Using Z_SYNC_FLUSH here means that an unterminated
 867        * LZ stream (a stream with a missing end code) can still
 868        * be handled, otherwise (Z_NO_FLUSH) a future zlib
 869        * implementation might defer output and therefore
 870        * change the current behavior (see comments in inflate.c
 871        * for why this doesn't happen at present with zlib 1.2.5).
 872        */
 873       ret = inflate(&png_ptr->zstream, Z_SYNC_FLUSH);
 874
 875       /* Check for any failure before proceeding. */
 876       if (ret != Z_OK && ret != Z_STREAM_END)
 877       {
 878          /* Terminate the decompression. */
 879          png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
 880          png_ptr->zowner = 0;
 881
 882          /* This may be a truncated stream (missing or
 883           * damaged end code).  Treat that as a warning.
 884           */
 885          if (png_ptr->row_number >= png_ptr->num_rows ||
 886              png_ptr->pass > 6)
 887             png_warning(png_ptr, "Truncated compressed data in IDAT");
 888
 889          else
 890             png_error(png_ptr, "Decompression error in IDAT");
 891
 892          /* Skip the check on unprocessed input */
 893          return;
 894       }
 895
 896       /* Did inflate output any data? */
 897       if (png_ptr->zstream.next_out != png_ptr->row_buf)
 898       {
 899          /* Is this unexpected data after the last row?
 900           * If it is, artificially terminate the LZ output
 901           * here.
 902           */
 903          if (png_ptr->row_number >= png_ptr->num_rows ||
 904              png_ptr->pass > 6)
 905          {
 906             /* Extra data. */
 907             png_warning(png_ptr, "Extra compressed data in IDAT");
 908             png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
 909             png_ptr->zowner = 0;
 910
 911             /* Do no more processing; skip the unprocessed
 912              * input check below.
 913              */
 914             return;
 915          }
 916
 917          /* Do we have a complete row? */
 918          if (png_ptr->zstream.avail_out == 0)
 919             png_push_process_row(png_ptr);
 920       }
 921
 922       /* And check for the end of the stream. */
 923       if (ret == Z_STREAM_END)
 924          png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
 925    }
 926
 927    /* All the data should have been processed, if anything
 928     * is left at this point we have bytes of IDAT data
 929     * after the zlib end code.
 930     */
 931    if (png_ptr->zstream.avail_in > 0)
 932       png_warning(png_ptr, "Extra compression data in IDAT");
 933 }
 934
 935 void /* PRIVATE */
 936 png_push_process_row(png_structrp png_ptr)
 937 {
 938    /* 1.5.6: row_info moved out of png_struct to a local here. */
 939    png_row_info row_info;
 940
 941    row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */
 942    row_info.color_type = png_ptr->color_type;
 943    row_info.bit_depth = png_ptr->bit_depth;
 944    row_info.channels = png_ptr->channels;
 945    row_info.pixel_depth = png_ptr->pixel_depth;
 946    row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
 947
 948    if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
 949    {
 950       if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
 951          png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
 952             png_ptr->prev_row + 1, png_ptr->row_buf[0]);
 953       else
 954          png_error(png_ptr, "bad adaptive filter value");
 955    }
 956
 957    /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before
 958     * 1.5.6, while the buffer really is this big in current versions of libpng
 959     * it may not be in the future, so this was changed just to copy the
 960     * interlaced row count:
 961     */
 962    memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
 963
 964 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
 965    if (png_ptr->transformations)
 966       png_do_read_transformations(png_ptr, &row_info);
 967 #endif
 968
 969    /* The transformed pixel depth should match the depth now in row_info. */
 970    if (png_ptr->transformed_pixel_depth == 0)
 971    {
 972       png_ptr->transformed_pixel_depth = row_info.pixel_depth;
 973       if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
 974          png_error(png_ptr, "progressive row overflow");
 975    }
 976
 977    else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
 978       png_error(png_ptr, "internal progressive row size calculation error");
 979
 980
 981 #ifdef PNG_READ_INTERLACING_SUPPORTED
 982    /* Expand interlaced rows to full size */
 983    if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
 984    {
 985       if (png_ptr->pass < 6)
 986          png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
 987             png_ptr->transformations);
 988
 989       switch (png_ptr->pass)
 990       {
 991          case 0:
 992          {
 993             int i;
 994             for (i = 0; i < 8 && png_ptr->pass == 0; i++)
 995             {
 996                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 997                png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */
 998             }
 999
1000             if (png_ptr->pass == 2) /* Pass 1 might be empty */
1001             {
1002                for (i = 0; i < 4 && png_ptr->pass == 2; i++)
1003                {
1004                   png_push_have_row(png_ptr, NULL);
1005                   png_read_push_finish_row(png_ptr);
1006                }
1007             }
1008
1009             if (png_ptr->pass == 4 && png_ptr->height <= 4)
1010             {
1011                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
1012                {
1013                   png_push_have_row(png_ptr, NULL);
1014                   png_read_push_finish_row(png_ptr);
1015                }
1016             }
1017
1018             if (png_ptr->pass == 6 && png_ptr->height <= 4)
1019             {
1020                 png_push_have_row(png_ptr, NULL);
1021                 png_read_push_finish_row(png_ptr);
1022             }
1023
1024             break;
1025          }
1026
1027          case 1:
1028          {
1029             int i;
1030             for (i = 0; i < 8 && png_ptr->pass == 1; i++)
1031             {
1032                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
1033                png_read_push_finish_row(png_ptr);
1034             }
1035
1036             if (png_ptr->pass == 2) /* Skip top 4 generated rows */
1037             {
1038                for (i = 0; i < 4 && png_ptr->pass == 2; i++)
1039                {
1040                   png_push_have_row(png_ptr, NULL);
1041                   png_read_push_finish_row(png_ptr);
1042                }
1043             }
1044
1045             break;
1046          }
1047
1048          case 2:
1049          {
1050             int i;
1051
1052             for (i = 0; i < 4 && png_ptr->pass == 2; i++)
1053             {
1054                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
1055                png_read_push_finish_row(png_ptr);
1056             }
1057
1058             for (i = 0; i < 4 && png_ptr->pass == 2; i++)
1059             {
1060                png_push_have_row(png_ptr, NULL);
1061                png_read_push_finish_row(png_ptr);
1062             }
1063
1064             if (png_ptr->pass == 4) /* Pass 3 might be empty */
1065             {
1066                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
1067                {
1068                   png_push_have_row(png_ptr, NULL);
1069                   png_read_push_finish_row(png_ptr);
1070                }
1071             }
1072
1073             break;
1074          }
1075
1076          case 3:
1077          {
1078             int i;
1079
1080             for (i = 0; i < 4 && png_ptr->pass == 3; i++)
1081             {
1082                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
1083                png_read_push_finish_row(png_ptr);
1084             }
1085
1086             if (png_ptr->pass == 4) /* Skip top two generated rows */
1087             {
1088                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
1089                {
1090                   png_push_have_row(png_ptr, NULL);
1091                   png_read_push_finish_row(png_ptr);
1092                }
1093             }
1094
1095             break;
1096          }
1097
1098          case 4:
1099          {
1100             int i;
1101
1102             for (i = 0; i < 2 && png_ptr->pass == 4; i++)
1103             {
1104                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
1105                png_read_push_finish_row(png_ptr);
1106             }
1107
1108             for (i = 0; i < 2 && png_ptr->pass == 4; i++)
1109             {
1110                png_push_have_row(png_ptr, NULL);
1111                png_read_push_finish_row(png_ptr);
1112             }
1113
1114             if (png_ptr->pass == 6) /* Pass 5 might be empty */
1115             {
1116                png_push_have_row(png_ptr, NULL);
1117                png_read_push_finish_row(png_ptr);
1118             }
1119
1120             break;
1121          }
1122
1123          case 5:
1124          {
1125             int i;
1126
1127             for (i = 0; i < 2 && png_ptr->pass == 5; i++)
1128             {
1129                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
1130                png_read_push_finish_row(png_ptr);
1131             }
1132
1133             if (png_ptr->pass == 6) /* Skip top generated row */
1134             {
1135                png_push_have_row(png_ptr, NULL);
1136                png_read_push_finish_row(png_ptr);
1137             }
1138
1139             break;
1140          }
1141
1142          default:
1143          case 6:
1144          {
1145             png_push_have_row(png_ptr, png_ptr->row_buf + 1);
1146             png_read_push_finish_row(png_ptr);
1147
1148             if (png_ptr->pass != 6)
1149                break;
1150
1151             png_push_have_row(png_ptr, NULL);
1152             png_read_push_finish_row(png_ptr);
1153          }
1154       }
1155    }
1156    else
1157    {
1158       png_push_have_row(png_ptr, png_ptr->row_buf + 1);
1159       png_read_push_finish_row(png_ptr);
1160    }
1161 }
1162
1163 void /* PRIVATE */
1164 png_read_push_finish_row(png_structrp png_ptr)
1165 {
1166    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
1167
1168    /* Start of interlace block */
1169    static PNG_CONST png_byte png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
1170
1171    /* Offset to next interlace block */
1172    static PNG_CONST png_byte png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
1173
1174    /* Start of interlace block in the y direction */
1175    static PNG_CONST png_byte png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
1176
1177    /* Offset to next interlace block in the y direction */
1178    static PNG_CONST png_byte png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
1179
1180    /* Height of interlace block.  This is not currently used - if you need
1181     * it, uncomment it here and in png.h
1182    static PNG_CONST png_byte png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
1183    */
1184 #endif
1185
1186    png_ptr->row_number++;
1187    if (png_ptr->row_number < png_ptr->num_rows)
1188       return;
1189
1190    if (png_ptr->interlaced)
1191    {
1192       png_ptr->row_number = 0;
1193       memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
1194
1195       do
1196       {
1197          png_ptr->pass++;
1198          if ((png_ptr->pass == 1 && png_ptr->width < 5) ||
1199              (png_ptr->pass == 3 && png_ptr->width < 3) ||
1200              (png_ptr->pass == 5 && png_ptr->width < 2))
1201             png_ptr->pass++;
1202
1203          if (png_ptr->pass > 7)
1204             png_ptr->pass--;
1205
1206          if (png_ptr->pass >= 7)
1207             break;
1208
1209          png_ptr->iwidth = (png_ptr->width +
1210              png_pass_inc[png_ptr->pass] - 1 -
1211              png_pass_start[png_ptr->pass]) /
1212              png_pass_inc[png_ptr->pass];
1213
1214          if (png_ptr->transformations & PNG_INTERLACE)
1215             break;
1216
1217          png_ptr->num_rows = (png_ptr->height +
1218              png_pass_yinc[png_ptr->pass] - 1 -
1219              png_pass_ystart[png_ptr->pass]) /
1220              png_pass_yinc[png_ptr->pass];
1221
1222       } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
1223    }
1224 }
1225
1226 void /* PRIVATE */
1227 png_push_have_info(png_structrp png_ptr, png_inforp info_ptr)
1228 {
1229    if (png_ptr->info_fn != NULL)
1230       (*(png_ptr->info_fn))(png_ptr, info_ptr);
1231 }
1232
1233 void /* PRIVATE */
1234 png_push_have_end(png_structrp png_ptr, png_inforp info_ptr)
1235 {
1236    if (png_ptr->end_fn != NULL)
1237       (*(png_ptr->end_fn))(png_ptr, info_ptr);
1238 }
1239
1240 void /* PRIVATE */
1241 png_push_have_row(png_structrp png_ptr, png_bytep row)
1242 {
1243    if (png_ptr->row_fn != NULL)
1244       (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
1245          (int)png_ptr->pass);
1246 }
1247
1248 void PNGAPI
1249 png_progressive_combine_row(png_const_structrp png_ptr, png_bytep old_row,
1250     png_const_bytep new_row)
1251 {
1252    if (png_ptr == NULL)
1253       return;
1254
1255    /* new_row is a flag here - if it is NULL then the app callback was called
1256     * from an empty row (see the calls to png_struct::row_fn below), otherwise
1257     * it must be png_ptr->row_buf+1
1258     */
1259    if (new_row != NULL)
1260       png_combine_row(png_ptr, old_row, 1/*blocky display*/);
1261 }
1262
1263 void PNGAPI
1264 png_set_progressive_read_fn(png_structrp png_ptr, png_voidp progressive_ptr,
1265     png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
1266     png_progressive_end_ptr end_fn)
1267 {
1268    if (png_ptr == NULL)
1269       return;
1270
1271    png_ptr->info_fn = info_fn;
1272    png_ptr->row_fn = row_fn;
1273    png_ptr->end_fn = end_fn;
1274
1275    png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
1276 }
1277
1278 png_voidp PNGAPI
1279 png_get_progressive_ptr(png_const_structrp png_ptr)
1280 {
1281    if (png_ptr == NULL)
1282       return (NULL);
1283
1284    return png_ptr->io_ptr;
1285 }
1286 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */