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