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