Google Git
Sign in
fuchsia / third_party / libpng / 780d38b87d0c630edf852d079e43d0177dcc9c29 / . / pngpread.c
blob: c7e5425aaf3be29170964dda86060a584591e150 [file] [log] [blame]
/* pngpread.c - read a png file in push mode
*
* Last changed in libpng 1.7.0 [(PENDING RELEASE)]
* Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
* This code is released under the libpng license.
* For conditions of distribution and use, see the disclaimer
* and license in png.h
*/
#include "pngpriv.h"
#define PNG_SRC_FILE PNG_SRC_FILE_pngpread
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
/* Standard callbacks */
static void PNGCBAPI
png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
{
png_bytep ptr;
if (png_ptr == NULL)
return;
ptr = buffer;
debug(length > 0);
if (length > 0 && png_ptr->save_buffer_size > 0)
{
png_size_t save_size;
if (length < png_ptr->save_buffer_size)
save_size = length;
else
save_size = png_ptr->save_buffer_size;
memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
length -= save_size;
ptr += save_size;
png_ptr->buffer_size -= save_size;
png_ptr->save_buffer_size -= save_size;
png_ptr->save_buffer_ptr += save_size;
}
if (length > 0 && png_ptr->current_buffer_size > 0)
{
png_size_t save_size;
if (length < png_ptr->current_buffer_size)
save_size = length;
else
save_size = png_ptr->current_buffer_size;
memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
png_ptr->buffer_size -= save_size;
png_ptr->current_buffer_size -= save_size;
png_ptr->current_buffer_ptr += save_size;
}
}
/* Push model modes: png_chunk_op plus extras */
typedef enum
{
/* all the png_chunk_op codes, plus: */
png_read_signature = 0, /* starting value */
png_read_chunk_header,
png_read_end_IDAT,
png_read_done,
png_read_chunk, /* Not a state, use these derived from png_chunk_op: */
png_read_chunk_skip = png_read_chunk+png_chunk_skip,
png_read_chunk_unknown = png_read_chunk+png_chunk_unknown,
png_read_chunk_process_all = png_read_chunk+png_chunk_process_all,
png_read_chunk_process_part = png_read_chunk+png_chunk_process_part
} png_read_mode;
static void
png_push_save_buffer_partial(png_structrp png_ptr, size_t amount)
{
/* Copy 'amount' bytes to the end of the save buffer from the current
* buffer.
*/
png_bytep buffer;
size_t save_size = png_ptr->save_buffer_size;
if (save_size > PNG_SIZE_MAX - amount)
png_error(png_ptr, "save buffer overflow");
if (png_ptr->save_buffer_max < save_size + amount)
{
/* Reallocate the save buffer. */
buffer = png_voidcast(png_bytep, png_malloc(png_ptr, save_size + amount));
memcpy(buffer, png_ptr->save_buffer_ptr, save_size);
png_free(png_ptr, png_ptr->save_buffer);
png_ptr->save_buffer_ptr = png_ptr->save_buffer = buffer;
}
else if (png_ptr->save_buffer_max -
(png_ptr->save_buffer_ptr - png_ptr->save_buffer) < save_size + amount)
{
/* Move the existing saved data */
buffer = png_ptr->save_buffer;
memmove(buffer, png_ptr->save_buffer_ptr, save_size);
png_ptr->save_buffer_ptr = buffer;
}
else /* Just copy the data */
buffer = png_ptr->save_buffer_ptr;
memcpy(buffer+save_size, png_ptr->current_buffer_ptr, amount);
png_ptr->save_buffer_size = save_size + amount;
png_ptr->current_buffer_ptr += amount;
png_ptr->current_buffer_size -= amount;
png_ptr->buffer_size -= amount;
}
static void
png_push_save_buffer(png_structrp png_ptr)
{
png_push_save_buffer_partial(png_ptr, png_ptr->current_buffer_size);
/* This terminates the process loop. */
png_ptr->buffer_size = 0;
}
#define PNG_PUSH_SAVE_BUFFER_IF_FULL \
if (png_ptr->chunk_length + 4 > png_ptr->buffer_size) \
{ png_push_save_buffer(png_ptr); return; }
#define PNG_PUSH_SAVE_BUFFER_IF_LT(N) \
if (png_ptr->buffer_size < N) \
{ png_push_save_buffer(png_ptr); return; }
png_size_t PNGAPI
png_process_data_pause(png_structrp png_ptr, int save)
{
if (png_ptr != NULL)
{
/* It's easiest for the caller if we do the save; then the caller doesn't
* have to supply the same data again:
*/
if (save != 0)
png_push_save_buffer(png_ptr);
else
{
/* This includes any pending saved bytes: */
png_size_t remaining = png_ptr->buffer_size;
png_ptr->buffer_size = 0; /* Terminate the process loop */
/* So subtract the saved buffer size, unless all the data
* is actually 'saved', in which case we just return 0
*/
if (png_ptr->save_buffer_size < remaining)
return remaining - png_ptr->save_buffer_size;
}
}
return 0;
}
png_uint_32 PNGAPI
png_process_data_skip(png_structrp png_ptr)
{
if (png_ptr != NULL && png_ptr->process_mode == png_read_chunk_skip)
{
/* At the end of png_process_data the buffer size must be 0 (see the loop
* above) so we can detect a broken call here:
*/
if (png_ptr->buffer_size != 0)
png_app_error(png_ptr,
"png_process_data_skip called inside png_process_data");
/* If is impossible for there to be a saved buffer at this point -
* otherwise we could not be in SKIP mode. This will also happen if
* png_process_skip is called inside png_process_data (but only very
* rarely.)
*/
else if (png_ptr->save_buffer_size != 0)
png_app_error(png_ptr, "png_process_data_skip called with saved data");
else
{
/* Skipping png_ptr->chunk_length of data then checking the CRC, after
* that a new chunk header will be read.
*/
png_ptr->process_mode = png_read_chunk_header;
return png_ptr->chunk_length + 4;
}
}
return 0;
}
static void
png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,
png_size_t buffer_length)
{
png_ptr->current_buffer_size = buffer_length;
png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
png_ptr->current_buffer_ptr = buffer;
}
/* Read any remaining signature bytes from the stream and compare them with
* the correct PNG signature. It is possible that this routine is called
* with bytes already read from the signature, either because they have been
* checked by the calling application, or because of multiple calls to this
* routine.
*/
static void
png_push_read_signature(png_structrp png_ptr, png_inforp info_ptr)
{
unsigned int num_checked = png_ptr->sig_bytes;
unsigned int num_to_check = 8 - num_checked;
if (png_ptr->buffer_size < num_to_check)
num_to_check = (int)/*SAFE*/png_ptr->buffer_size;
png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
num_to_check);
png_ptr->sig_bytes = png_check_byte(png_ptr,
png_ptr->sig_bytes + num_to_check);
if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
{
if (num_checked < 4 &&
png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
png_error(png_ptr, "Not a PNG file");
else
png_error(png_ptr, "PNG file corrupted by ASCII conversion");
}
else if (png_ptr->sig_bytes >= 8)
png_ptr->process_mode = png_read_chunk_header;
}
static void
png_push_crc_finish(png_structrp png_ptr)
/* CRC the remainder of the chunk data; png_struct::chunk_length must be the
* amount of data left to read excluding the CRC.
*/
{
if (png_ptr->chunk_length != 0 && png_ptr->save_buffer_size != 0)
{
png_size_t save_size = png_ptr->save_buffer_size;
png_uint_32 skip_length = png_ptr->chunk_length;
/* We want the smaller of 'skip_length' and 'save_buffer_size', but
* they are of different types and we don't know which variable has the
* fewest bits. Carefully select the smaller and cast it to the type of
* the larger - this cannot overflow. Do not cast in the following test
* - it will break on either 16 or 64 bit platforms.
*/
if (skip_length < save_size)
save_size = (png_size_t)/*SAFE*/skip_length;
else
skip_length = (png_uint_32)/*SAFE*/save_size;
png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
png_ptr->chunk_length -= skip_length;
png_ptr->buffer_size -= save_size;
png_ptr->save_buffer_size -= save_size;
png_ptr->save_buffer_ptr += save_size;
}
if (png_ptr->chunk_length != 0 && png_ptr->current_buffer_size != 0)
{
png_size_t save_size = png_ptr->current_buffer_size;
png_uint_32 skip_length = png_ptr->chunk_length;
/* We want the smaller of 'skip_length' and 'current_buffer_size', here,
* the same problem exists as above and the same solution.
*/
if (skip_length < save_size)
save_size = (png_size_t)/*SAFE*/skip_length;
else
skip_length = (png_uint_32)/*SAFE*/save_size;
png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
png_ptr->chunk_length -= skip_length;
png_ptr->buffer_size -= save_size;
png_ptr->current_buffer_size -= save_size;
png_ptr->current_buffer_ptr += save_size;
}
if (png_ptr->chunk_length == 0)
{
PNG_PUSH_SAVE_BUFFER_IF_LT(4)
png_crc_finish(png_ptr, 0);
png_ptr->process_mode = png_read_chunk_header;
}
}
static void
png_push_read_unknown(png_structrp png_ptr, png_inforp info_ptr)
{
/* Handle an unknown chunk. All the data is available but it may not
* all be in the same buffer. png_handle_unknown needs the chunk data in
* just one buffer.
*/
png_bytep buffer;
png_uint_32 chunk_length = png_ptr->chunk_length;
if (png_ptr->save_buffer_size > 0)
{
png_size_t save_size = png_ptr->save_buffer_size;
if (save_size < chunk_length)
{
/* Copy the current_buffer_ptr data into the save buffer. */
png_push_save_buffer_partial(png_ptr, chunk_length - save_size);
save_size = chunk_length;
}
buffer = png_ptr->save_buffer_ptr;
png_ptr->save_buffer_ptr = buffer+chunk_length;
png_ptr->save_buffer_size = save_size-chunk_length;
png_ptr->buffer_size -= chunk_length;
affirm(png_ptr->buffer_size >= 4);
}
else
{
affirm(png_ptr->current_buffer_size >= chunk_length+4);
buffer = png_ptr->current_buffer_ptr;
png_ptr->current_buffer_ptr = buffer+chunk_length;
png_ptr->current_buffer_size -= chunk_length;
png_ptr->buffer_size -= chunk_length;
}
/* Now check the CRC, before attempting the unknown handling. */
png_calculate_crc(png_ptr, buffer, chunk_length);
png_crc_finish(png_ptr, 0);
# ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
png_handle_unknown(png_ptr, info_ptr, buffer);
# else /* !READ_UNKNOWN_CHUNKS */
PNG_UNUSED(info_ptr)
# endif /* !READ_UNKNOWN_CHUNKS */
png_ptr->process_mode = png_read_chunk_header;
}
static void
png_push_have_row(png_structrp png_ptr, png_bytep row)
{
if (png_ptr->row_fn != NULL)
{
png_uint_32 row_number = png_ptr->row_number;
png_byte pass = png_ptr->pass;
if (png_ptr->interlaced)
{
/* If the row de-interlace is not being done by PNG this wacky API
* delivers the row number in the pass to the caller. We know that
* if we get here the row exists, so the number is just one less than
* the height of an interlaced image with just the rows up to this
* one:
*/
# ifdef PNG_READ_INTERLACING_SUPPORTED
if (!png_ptr->do_interlace)
# endif /* READ_INTERLACING */
{
affirm(PNG_ROW_IN_INTERLACE_PASS(row_number, pass) && row != NULL);
row_number = PNG_PASS_ROWS(row_number+1, pass);
affirm(row_number > 0);
--row_number;
}
}
(*(png_ptr->row_fn))(png_ptr, row, row_number, pass);
}
}
static void
png_push_read_sync_zstream(png_structp png_ptr, png_bytep *bufferp,
size_t *buffer_lengthp)
/* Synchronize the png_struct progressive read buffer
* {*bufferp,*buffer_lengthp} with png_struct::zstream.next_in, on the
* assumption that the zstream had previously been set up with *bufferp.
*/
{
png_bytep original_start = *bufferp;
png_alloc_size_t bytes_consumed = png_ptr->zstream.next_in - original_start;
affirm(buffer_lengthp != NULL);
/* Calculate the CRC for the consumed data: */
png_calculate_crc(png_ptr, original_start, bytes_consumed);
/* Update the buffer pointers and the various lengths: */
*bufferp = original_start + bytes_consumed; /* == png_ptr->zstream.next_in */
affirm(bytes_consumed <= *buffer_lengthp);
*buffer_lengthp -= (size_t)/*SAFE*/bytes_consumed;
affirm(bytes_consumed <= png_ptr->chunk_length);
png_ptr->chunk_length -= (png_uint_32)/*SAFE*/bytes_consumed;
affirm(bytes_consumed <= png_ptr->buffer_size);
png_ptr->buffer_size -= (size_t)/*SAFE*/bytes_consumed;
}
static void
png_push_read_process_IDAT(png_structp png_ptr, png_bytep *bufferp,
size_t *buffer_lengthp)
/* If the the *buffer_lengthp parameter is NULL there is no more input,
* png_struct::mode & PNG_AFTER_IDAT must be set at this point.
*/
{
png_alloc_size_t buffer_length;
if (buffer_lengthp != NULL)
buffer_length = *buffer_lengthp;
else /* end of IDAT */
{
/* SECURITY: if this affirm fails the code would go into an infinite loop;
* see the handling of avail_in == 0 in png_inflate_IDAT.
*/
affirm(png_ptr->mode & PNG_AFTER_IDAT);
buffer_length = 0;
}
/* This routine attempts to process all the data it has been given before
* returning, calling the row callback as required to handle the
* uncompressed results.
*
* If a pause happens during processing (png_ptr->buffer_size is set to 0)
* or the end of the chunk is encountered the routine may return without
* handling all the input data.
*/
if (buffer_length > png_ptr->chunk_length)
{
buffer_length = png_ptr->chunk_length;
/* This works because the last part of a 'skip' is to read and check the
* CRC, then the process mode is set to png_read_chunk_header.
*/
if (buffer_length == 0)
png_ptr->process_mode = png_read_chunk_skip;
}
/* It is possble for buffer_length to be zero at this point if the stream
* caontains a zero length IDAT. This is handled below.
*/
png_ptr->zstream.next_in = *bufferp;
while (buffer_length > 0 || buffer_lengthp == NULL)
{
if (buffer_length >= ZLIB_IO_MAX)
{
png_ptr->zstream.avail_in = ZLIB_IO_MAX;
buffer_length -= ZLIB_IO_MAX;
}
else
{
png_ptr->zstream.avail_in = (uInt)/*SAFE*/buffer_length;
buffer_length = 0;
}
/* The last row may already have been processed.
*
* row_number is the *current* row number in the range 0..height-1. It is
* updated only by the call to png_read_process_IDAT that follows the call
* which returns something other than png_row_incomplete.
*
* At the end of the image that call must *NOT* be made; png_process_IDAT
* must not be called after the last row. png_struct::zstream_eod is set
* below to allow this condition to be detected.
*
* Note that png_read_process_IDAT handles errors in the LZ compressed
* data (i.e. the cases where png_struct::zstream_error is set) by filling
* the rows in with 0, which is a safe value, so keep calling it until we
* reach the end of the image.
*/
if (!png_ptr->zstream_eod)
{
png_bytep row_buffer = NULL;
png_row_op row_op =
png_read_process_IDAT(png_ptr, NULL, NULL, 1/*save row*/);
if (row_op != png_row_incomplete)
{
/* Have a complete row, so check for end-of-image; do this here
* because interlaced images can end on earlier rows or passes but
* we keep calling png_read_process_IDAT until it updates row_number
* to the last row of the actual image:
*/
if (png_ptr->row_number+1 >= png_ptr->height &&
(!png_ptr->interlaced || png_ptr->pass == 6))
png_ptr->zstream_eod = 1; /* end of image */
}
switch (row_op)
{
case png_row_incomplete:
/* more IDAT data needed for row */
debug(png_ptr->zstream.avail_in == 0);
/* png_inflate_IDAT is supposed to handle this and recognize a
* call with 0 avail_in as end of stream:
*/
affirm(buffer_lengthp != NULL);
continue;
case png_row_process:
/* If a row was obtained after the end of the IDAT this was done
* by fabricating data, ensure this is reported, else there is a
* security issue; normally libpng does a png_error in this
* case, even if the error is ignored png_struct::zstream_error
* should be set so somehow the error wasn't noticed!
*/
affirm(buffer_lengthp != NULL || png_ptr->zstream_error);
/* png_struct::transformed_row contains a complete, transformed,
* row; this is processed in both 'sparkle' and 'block' mode.
*/
# ifdef PNG_TRANSFORM_MECH_SUPPORTED
row_buffer = png_ptr->transformed_row;
if (row_buffer == NULL)
# endif /* TRANSFORM_MECH */
row_buffer = png_ptr->row_buffer;
break;
case png_row_repeat:
/* row not in this pass, but the existing row in
* png_struct::transformed_row may be used, this is only required
* if the 'block' or 'rectangle' mode of display is done and
* libpng is handling the de-interlace; when the app does it it
* only see the real rows.
*/
# ifdef PNG_READ_INTERLACING_SUPPORTED
if (png_ptr->do_interlace)
{
# ifdef PNG_TRANSFORM_MECH_SUPPORTED
row_buffer = png_ptr->transformed_row;
if (row_buffer == NULL)
# endif /* TRANSFORM_MECH */
row_buffer = png_ptr->row_buffer;
break;
}
# endif /* READ_INTERLACING */
continue;
case png_row_skip:
/* row not in pass and no appropriate data; skip this row,
* nothing more need be done, except the read_row_fn. The use
* of 'NULL' to mean this row doesn't contribute to the output
* is historical and not documented;
*/
# ifdef PNG_READ_INTERLACING_SUPPORTED
if (png_ptr->do_interlace)
break;
# endif /* READ_INTERLACING */
continue;
default:
impossible("not reached");
}
/* Here if there is a row to process. */
/* Now adjust the buffer pointers before calling png_push_have_row
* because the callback might call png_process_data_pause and that
* calls png_push_save_row. (Yes, this is insane; it was forced on
* libpng by writers of an external app that ignored the instructions
* not to fiddle with the insides of png_struct in version 1.4. It
* will probably be fixed here before 1.7.0 is released by removing
* the need for the save buffer entirely.)
*/
if (buffer_lengthp != NULL)
png_push_read_sync_zstream(png_ptr, bufferp, buffer_lengthp);
/* Process one row: */
png_push_have_row(png_ptr, row_buffer);
/* The buffer pointer and size may have changed at this point,
* so everything needs to be reloaded if we can continue reading.
*/
if (buffer_lengthp != NULL) /* not at end of IDATs */
{
if (png_ptr->chunk_length == 0)
png_ptr->process_mode = png_read_chunk_skip;
/* If the buffer_size has been set to zero more input is required,
* this may be a 'pause', and if the specific input buffer being
* processed has been exhaused then more input is also required.
* Otherwise we can keep going, however the input buffer may have
* been changed by the app callback, so do a complete reload:
*/
else if (png_ptr->buffer_size > 0 && *buffer_lengthp > 0)
png_push_read_process_IDAT(png_ptr, bufferp, buffer_lengthp);
return;
}
/* If we can't continue reading because there is no more IDAT data this
* may still be a pause.
*/
if (png_ptr->buffer_size == 0)
return;
/* Else continue, with zero data: */
continue;
}
affirm(png_ptr->zstream_eod);
if (png_ptr->zowner == 0 || png_read_finish_IDAT(png_ptr))
{
/* The zlib stream has ended, there may still be input data in
* png_ptr->zstream.next_in, restore this.
*/
debug(png_ptr->zowner == 0 && png_ptr->zstream_ended);
if (buffer_lengthp != NULL)
{
png_push_read_sync_zstream(png_ptr, bufferp, buffer_lengthp);
/* If the chunk_length is greater than 0 then there is extra data,
* report this once. Notice that for IDAT after the end of the
* stream we keep coming to this point and doing the skip.
*/
if (png_ptr->chunk_length > 0)
{
if (!png_ptr->zstream_error)
{
png_chunk_benign_error(png_ptr,
"too much IDAT data (progressive read)");
png_ptr->zstream_error = 1;
}
}
/* In any case CRC the chunk, skipping any unneeded data: */
png_ptr->process_mode = png_read_chunk_skip;
}
return;
}
/* else more input is required */
/* NOTE: this test only fires on a small (less than 5 byte) IDAT chunk
* which just contains the LZ EOF and the Adler32 CRC.
*/
affirm(png_ptr->zowner == png_IDAT && !png_ptr->zstream_ended);
}
/* At this point all the input has been consumed, however the CRC has not
* been done and the three length fields in png_struct, *buffer_lengthp,
* buffer_size and chunk_length, all need updating.
*/
png_push_read_sync_zstream(png_ptr, bufferp, buffer_lengthp);
}
static void
png_push_read_IDAT(png_structrp png_ptr)
{
if (png_ptr->save_buffer_size > 0)
{
png_push_read_process_IDAT(png_ptr, &png_ptr->save_buffer_ptr,
&png_ptr->save_buffer_size);
/* This is a slight optimization; normally when the process mode changes
* there will still be something in the buffer:
*/
if (png_ptr->save_buffer_size > 0)
return;
/* Check for a change in process mode or an application pause before
* checking the current input buffer. This is only rarely reached.
*/
if (png_ptr->process_mode != png_read_chunk_process_part ||
png_ptr->buffer_size == 0)
return;
}
if (png_ptr->current_buffer_size > 0)
png_push_read_process_IDAT(png_ptr, &png_ptr->current_buffer_ptr,
&png_ptr->current_buffer_size);
}
static void
png_push_finish_IDAT(png_structrp png_ptr)
/* Called once when the first chunk after IDAT is seen. */
{
/* All of the IDAT data has been processed, however the stream may have
* been truncated and the image rows may not all have been processed.
* Clean up here (this doesn't read anything.)
*
* 1.7.0: this attempts some measure of compatibility with the sequential
* API, if the IDAT is truncated and the resultant error reporting doesn't
* abort the read the image is filled in using zeros of pixel data. This
* actually happens inside png_inflate_IDAT (pngrutil.c) when called with
* z_stream::avail_in == 0.
*/
while (png_ptr->zowner == png_IDAT)
{
png_byte b = 0, *pb = &b;
png_push_read_process_IDAT(png_ptr, &pb, NULL/*end of IDAT*/);
if (png_ptr->zowner == 0)
break;
if (png_ptr->buffer_size == 0) /* pause */
return;
}
png_ptr->process_mode = png_check_bits(png_ptr, png_ptr->process_mode >> 4,
4);
}
static void
png_push_have_info(png_structrp png_ptr, png_inforp info_ptr)
{
if (png_ptr->info_fn != NULL)
(*(png_ptr->info_fn))(png_ptr, info_ptr);
}
static void
png_push_have_end(png_structrp png_ptr, png_inforp info_ptr)
{
if (png_ptr->end_fn != NULL)
(*(png_ptr->end_fn))(png_ptr, info_ptr);
}
static void
png_push_read_chunk_header(png_structrp png_ptr, png_infop info_ptr)
{
/* Called to read a new chunk header and work out how to handle the remainder
* of the data.
*/
unsigned int mode; /* mode prior to the header */
png_byte chunk_header[8];
PNG_PUSH_SAVE_BUFFER_IF_LT(8)
png_push_fill_buffer(png_ptr, chunk_header, 8);
png_ptr->chunk_length = png_get_uint_31(png_ptr, chunk_header);
png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_header+4);
png_reset_crc(png_ptr, chunk_header+4);
png_check_chunk_name(png_ptr, png_ptr->chunk_name);
png_check_chunk_length(png_ptr, png_ptr->chunk_length);
mode = png_ptr->mode;
png_ptr->process_mode = png_check_bits(png_ptr,
png_read_chunk+png_find_chunk_op(png_ptr), 4);
/* Is this the first IDAT chunk? */
if ((mode ^ png_ptr->mode) & PNG_HAVE_IDAT)
png_push_have_info(png_ptr, info_ptr);
/* Is it the chunk after the last IDAT chunk? */
else if (((mode ^ png_ptr->mode) & PNG_AFTER_IDAT) != 0)
png_ptr->process_mode = png_check_bits(png_ptr,
(png_ptr->process_mode << 4) + png_read_end_IDAT, 8);
}
/* What we do with the incoming data depends on what we were previously
* doing before we ran out of data...
*/
static void
png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)
{
if (png_ptr == NULL)
return;
switch (png_ptr->process_mode & 0xf)
{
case png_read_signature:
png_push_read_signature(png_ptr, info_ptr);
return;
case png_read_chunk_header:
png_push_read_chunk_header(png_ptr, info_ptr);
return;
case png_read_chunk_skip:
png_push_crc_finish(png_ptr);
return;
case png_read_chunk_unknown:
PNG_PUSH_SAVE_BUFFER_IF_FULL
png_push_read_unknown(png_ptr, info_ptr);
return;
case png_read_chunk_process_all:
PNG_PUSH_SAVE_BUFFER_IF_FULL
png_handle_chunk(png_ptr, info_ptr);
if (png_ptr->mode & PNG_HAVE_IEND)
{
png_ptr->process_mode = png_read_done;
png_push_have_end(png_ptr, info_ptr);
png_ptr->buffer_size = 0;
}
else
png_ptr->process_mode = png_read_chunk_header;
return;
case png_read_chunk_process_part:
debug(png_ptr->chunk_name == png_IDAT &&
(png_ptr->mode & PNG_HAVE_IDAT) &&
!(png_ptr->mode & PNG_AFTER_IDAT));
if (png_ptr->zowner == 0 && !png_ptr->zstream_ended) /* first time */
png_read_start_IDAT(png_ptr);
png_push_read_IDAT(png_ptr);
return;
case png_read_end_IDAT:
png_push_finish_IDAT(png_ptr);
return;
case png_read_done:
png_app_error(png_ptr, "read beyond end of stream");
png_ptr->buffer_size = 0;
return;
default:
impossible("invalid process mode");
}
}
void PNGAPI
png_process_data(png_structrp png_ptr, png_inforp info_ptr,
png_bytep buffer, png_size_t buffer_size)
{
if (png_ptr == NULL || info_ptr == NULL)
return;
png_push_restore_buffer(png_ptr, buffer, buffer_size);
while (png_ptr->buffer_size)
png_process_some_data(png_ptr, info_ptr);
}
void PNGAPI
png_set_progressive_read_fn(png_structrp png_ptr, png_voidp progressive_ptr,
png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
png_progressive_end_ptr end_fn)
{
if (png_ptr == NULL)
return;
png_ptr->info_fn = info_fn;
png_ptr->row_fn = row_fn;
png_ptr->end_fn = end_fn;
png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
}
png_voidp PNGAPI
png_get_progressive_ptr(png_const_structrp png_ptr)
{
if (png_ptr == NULL)
return (NULL);
return png_ptr->io_ptr;
}
#endif /* PROGRESSIVE_READ */