Lines Matching refs:png_ptr
22 png_get_uint_31(png_const_structrp png_ptr, png_const_bytep buf)
27 png_error(png_ptr, "PNG unsigned integer out of range");
41 png_get_fixed_point(png_structrp png_ptr, png_const_bytep buf)
49 if (png_ptr != NULL)
50 png_warning(png_ptr, "PNG fixed point integer out of range");
115 png_read_sig(png_structrp png_ptr, png_inforp info_ptr)
120 if (png_ptr->sig_bytes >= 8)
123 num_checked = png_ptr->sig_bytes;
127 png_ptr->io_state = PNG_IO_READING | PNG_IO_SIGNATURE;
131 png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
132 png_ptr->sig_bytes = 8;
138 png_error(png_ptr, "Not a PNG file");
140 png_error(png_ptr, "PNG file corrupted by ASCII conversion");
143 png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
147 * Put the type name into png_ptr->chunk_name, and return the length.
150 png_read_chunk_header(png_structrp png_ptr)
156 png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR;
162 png_read_data(png_ptr, buf, 8);
163 length = png_get_uint_31(png_ptr, buf);
165 /* Put the chunk name into png_ptr->chunk_name. */
166 png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(buf+4);
169 (unsigned long)png_ptr->chunk_name, (unsigned long)length);
172 png_reset_crc(png_ptr);
173 png_calculate_crc(png_ptr, buf + 4, 4);
176 png_check_chunk_name(png_ptr, png_ptr->chunk_name);
179 png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_DATA;
187 png_crc_read(png_structrp png_ptr, png_bytep buf, png_uint_32 length)
189 if (png_ptr == NULL)
192 png_read_data(png_ptr, buf, length);
193 png_calculate_crc(png_ptr, buf, length);
202 png_crc_finish(png_structrp png_ptr, png_uint_32 skip)
217 png_crc_read(png_ptr, tmpbuf, len);
220 if (png_crc_error(png_ptr))
222 if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) ?
223 !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) :
224 (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE))
226 png_chunk_warning(png_ptr, "CRC error");
230 png_chunk_error(png_ptr, "CRC error");
240 png_opt_crc_finish(png_structrp png_ptr, png_uint_32 skip)
252 png_crc_read(png_ptr, tmpbuf, len);
255 if (png_crc_error(png_ptr))
257 png_chunk_warning(png_ptr, "CRC error");
269 png_crc_error(png_structrp png_ptr)
275 if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name))
277 if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
284 if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
289 png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_CRC;
293 png_read_data(png_ptr, crc_bytes, 4);
298 return ((int)(crc != png_ptr->crc));
316 png_read_buffer(png_structrp png_ptr, png_alloc_size_t new_size, int warn)
318 png_bytep buffer = png_ptr->read_buffer;
320 if (buffer != NULL && new_size > png_ptr->read_buffer_size)
322 png_ptr->read_buffer = NULL;
323 png_ptr->read_buffer = NULL;
324 png_ptr->read_buffer_size = 0;
325 png_free(png_ptr, buffer);
331 buffer = png_voidcast(png_bytep, png_malloc_base(png_ptr, new_size));
335 png_ptr->read_buffer = buffer;
336 png_ptr->read_buffer_size = new_size;
342 png_chunk_warning(png_ptr, "insufficient memory to read chunk");
345 png_chunk_error(png_ptr, "insufficient memory to read chunk");
359 png_inflate_claim(png_structrp png_ptr, png_uint_32 owner)
361 if (png_ptr->zowner != 0)
365 PNG_STRING_FROM_CHUNK(msg, png_ptr->zowner);
372 png_chunk_warning(png_ptr, msg);
373 png_ptr->zowner = 0;
375 png_chunk_error(png_ptr, msg);
400 if (((png_ptr->options >> PNG_MAXIMUM_INFLATE_WINDOW) & 3) ==
414 png_ptr->zstream.next_in = NULL;
415 png_ptr->zstream.avail_in = 0;
416 png_ptr->zstream.next_out = NULL;
417 png_ptr->zstream.avail_out = 0;
419 if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED)
422 ret = inflateReset(&png_ptr->zstream);
424 ret = inflateReset2(&png_ptr->zstream, window_bits);
431 ret = inflateInit(&png_ptr->zstream);
433 ret = inflateInit2(&png_ptr->zstream, window_bits);
437 png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;
441 png_ptr->zowner = owner;
444 png_zstream_error(png_ptr, ret);
467 png_inflate(png_structrp png_ptr, png_uint_32 owner, int finish,
471 if (png_ptr->zowner == owner) /* Else not claimed */
486 png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input);
488 png_ptr->zstream.avail_in = 0;
489 png_ptr->zstream.avail_out = 0;
495 png_ptr->zstream.next_out = output;
510 avail_in += png_ptr->zstream.avail_in; /* not consumed last time */
518 png_ptr->zstream.avail_in = avail;
521 avail_out += png_ptr
530 png_ptr->zstream.next_out = local_buffer;
538 png_ptr->zstream.avail_out = avail;
547 ret = inflate(&png_ptr->zstream, avail_out > 0 ? Z_NO_FLUSH :
553 png_ptr->zstream.next_out = NULL;
556 avail_in += png_ptr->zstream.avail_in;
557 avail_out += png_ptr->zstream.avail_out;
568 /* Ensure png_ptr->zstream.msg is set (even in the success case!) */
569 png_zstream_error(png_ptr, ret);
579 png_ptr->zstream.msg = PNGZ_MSG_CAST("zstream unclaimed");
592 png_decompress_chunk(png_structrp png_ptr,
607 if (png_ptr->user_chunk_malloc_max > 0 &&
608 png_ptr->user_chunk_malloc_max < limit)
609 limit = png_ptr->user_chunk_malloc_max;
625 ret = png_inflate_claim(png_ptr, png_ptr->chunk_name);
631 ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/,
632 /* input: */ png_ptr->read_buffer + prefix_size, &lzsize,
644 if (inflateReset(&png_ptr->zstream) == Z_OK)
654 png_bytep text = png_voidcast(png_bytep, png_malloc_base(png_ptr,
659 ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/,
660 png_ptr->read_buffer + prefix_size, &lzsize,
671 memcpy(text, png_ptr->read_buffer, prefix_size);
674 png_bytep old_ptr = png_ptr->read_buffer;
676 png_ptr->read_buffer = text;
677 png_ptr->read_buffer_size = buffer_size;
700 png_free(png_ptr, text);
707 png_chunk_benign_error(png_ptr, "extra compressed data");
714 png_zstream_error(png_ptr, Z_MEM_ERROR);
721 png_zstream_error(png_ptr, ret);
732 png_ptr->zowner = 0;
744 png_zstream_error(png_ptr, Z_MEM_ERROR);
755 png_inflate_read(png_structrp png_ptr, png_bytep read_buffer, uInt read_size,
759 if (png_ptr->zowner == png_ptr->chunk_name)
764 png_ptr->zstream.next_out = next_out;
765 png_ptr->zstream.avail_out = 0; /* set in the loop */
769 if (png_ptr->zstream.avail_in == 0)
776 png_crc_read(png_ptr, read_buffer, read_size);
778 png_ptr->zstream.next_in = read_buffer;
779 png_ptr->zstream.avail_in = read_size;
782 if (png_ptr->zstream.avail_out == 0)
789 png_ptr->zstream.avail_out = avail;
796 ret = inflate(&png_ptr->zstream,
799 while (ret == Z_OK && (*out_size > 0 || png_ptr->zstream.avail_out > 0));
801 *out_size += png_ptr->zstream.avail_out;
802 png_ptr->zstream.avail_out = 0; /* Should not be required, but is safe */
805 png_zstream_error(png_ptr, ret);
811 png_ptr->zstream.msg = PNGZ_MSG_CAST("zstream unclaimed");
819 png_handle_IHDR(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
828 if (png_ptr->mode & PNG_HAVE_IHDR)
829 png_chunk_error(png_ptr, "out of place");
833 png_chunk_error(png_ptr, "invalid");
835 png_ptr->mode |= PNG_HAVE_IHDR;
837 png_crc_read(png_ptr, buf, 13);
838 png_crc_finish(png_ptr, 0);
840 width = png_get_uint_31(png_ptr, buf);
841 height = png_get_uint_31(png_ptr, buf + 4);
849 png_ptr->width = width;
850 png_ptr->height = height;
851 png_ptr->bit_depth = (png_byte)bit_depth;
852 png_ptr->interlaced = (png_byte)interlace_type;
853 png_ptr->color_type = (png_byte)color_type;
855 png_ptr->filter_type = (png_byte)filter_type;
857 png_ptr->compression_type = (png_byte)compression_type;
860 switch (png_ptr->color_type)
865 png_ptr->channels = 1;
869 png_ptr->channels = 3;
873 png_ptr->channels = 2;
877 png_ptr->channels = 4;
882 png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
883 png_ptr->channels);
884 png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
885 png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
886 png_debug1(3, "channels = %d", png_ptr->channels);
887 png_debug1(3, "rowbytes = %lu", (unsigned long)png_ptr->rowbytes);
888 png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
894 png_handle_PLTE(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
904 if (!(png_ptr->mode & PNG_HAVE_IHDR))
905 png_chunk_error(png_ptr, "missing IHDR");
912 else if (png_ptr->mode & PNG_HAVE_PLTE)
913 png_chunk_error(png_ptr, "duplicate");
915 else if (png_ptr->mode & PNG_HAVE_IDAT)
920 png_crc_finish(png_ptr, length);
921 png_chunk_benign_error(png_ptr, "out of place");
925 png_ptr->mode |= PNG_HAVE_PLTE;
927 if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR))
929 png_crc_finish(png_ptr, length);
930 png_chunk_benign_error(png_ptr, "ignored in grayscale PNG");
935 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
937 png_crc_finish(png_ptr, length);
944 png_crc_finish(png_ptr, length);
946 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
947 png_chunk_benign_error(png_ptr, "invalid");
950 png_chunk_error(png_ptr, "invalid");
963 png_crc_read(png_ptr, buf, 3);
973 png_crc_read(png_ptr, buf, 3);
987 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
990 png_crc_finish(png_ptr, 0);
994 else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */
1005 if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))
1007 if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)
1011 png_chunk_error(png_ptr, "CRC error");
1015 else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))
1016 png_chunk_warning(png_ptr, "CRC error");
1020 /* TODO: png_set_PLTE has the side effect of setting png_ptr->palette to its
1028 png_set_PLTE(png_ptr, info_ptr, palette, num);
1040 if (png_ptr->num_trans > 0 ||
1047 png_ptr->num_trans = 0;
1052 png_chunk_benign_error(png_ptr, "tRNS must be after");
1058 png_chunk_benign_error(png_ptr, "hIST must be after");
1063 png_chunk_benign_error(png_ptr, "bKGD must be after");
1068 png_handle_IEND(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
1072 if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
1073 png_chunk_error(png_ptr, "out of place");
1075 png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
1077 png_crc_finish(png_ptr, length);
1080 png_chunk_benign_error(png_ptr, "invalid");
1087 png_handle_gAMA(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
1094 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1095 png_chunk_error(png_ptr, "missing IHDR");
1097 else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE))
1099 png_crc_finish(png_ptr, length);
1100 png_chunk_benign_error(png_ptr, "out of place");
1106 png_crc_finish(png_ptr, length);
1107 png_chunk_benign_error(png_ptr, "invalid");
1111 png_crc_read(png_ptr, buf, 4);
1113 if (png_crc_finish(png_ptr, 0))
1118 png_colorspace_set_gamma(png_ptr, &png_ptr->colorspace, igamma);
1119 png_colorspace_sync(png_ptr, info_ptr);
1125 png_handle_sBIT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
1133 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1134 png_chunk_error(png_ptr, "missing IHDR");
1136 else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE))
1138 png_crc_finish(png_ptr, length);
1139 png_chunk_benign_error(png_ptr, "out of place");
1145 png_crc_finish(png_ptr, length);
1146 png_chunk_benign_error(png_ptr, "duplicate");
1150 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1158 truelen = png_ptr->channels;
1159 sample_depth = png_ptr->bit_depth;
1164 png_chunk_benign_error(png_ptr, "invalid");
1165 png_crc_finish(png_ptr, length);
1170 png_crc_read(png_ptr, buf, truelen);
1172 if (png_crc_finish(png_ptr, 0))
1178 png_chunk_benign_error(png_ptr, "invalid");
1182 if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
1184 png_ptr->sig_bit.red = buf[0];
1185 png_ptr->sig_bit.green = buf[1];
1186 png_ptr->sig_bit.blue = buf[2];
1187 png_ptr->sig_bit.alpha = buf[3];
1192 png_ptr->sig_bit.gray = buf[0];
1193 png_ptr->sig_bit.red = buf[0];
1194 png_ptr->sig_bit.green = buf[0];
1195 png_ptr->sig_bit.blue = buf[0];
1196 png_ptr->sig_bit.alpha = buf[1];
1199 png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));
1205 png_handle_cHRM(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
1212 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1213 png_chunk_error(png_ptr, "missing IHDR");
1215 else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE))
1217 png_crc_finish(png_ptr, length);
1218 png_chunk_benign_error(png_ptr, "out of place");
1224 png_crc_finish(png_ptr, length);
1225 png_chunk_benign_error(png_ptr, "invalid");
1229 png_crc_read(png_ptr, buf, 32);
1231 if (png_crc_finish(png_ptr, 0))
1252 png_chunk_benign_error(png_ptr, "invalid values");
1257 if (png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID)
1260 if (png_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM)
1262 png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
1263 png_colorspace_sync(png_ptr, info_ptr);
1264 png_chunk_benign_error(png_ptr, "duplicate");
1268 png_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;
1269 (void)png_colorspace_set_chromaticities(png_ptr, &png_ptr->colorspace, &xy,
1271 png_colorspace_sync(png_ptr, info_ptr);
1277 png_handle_sRGB(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
1283 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1284 png_chunk_error(png_ptr, "missing IHDR");
1286 else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE))
1288 png_crc_finish(png_ptr, length);
1289 png_chunk_benign_error(png_ptr, "out of place");
1295 png_crc_finish(png_ptr, length);
1296 png_chunk_benign_error(png_ptr, "invalid");
1300 png_crc_read(png_ptr, &intent, 1);
1302 if (png_crc_finish(png_ptr, 0))
1306 if (png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID)
1312 if (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_INTENT)
1314 png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
1315 png_colorspace_sync(png_ptr, info_ptr);
1316 png_chunk_benign_error(png_ptr, "too many profiles");
1320 (void)png_colorspace_set_sRGB(png_ptr, &png_ptr->colorspace, intent);
1321 png_colorspace_sync(png_ptr, info_ptr);
1327 png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
1335 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1336 png_chunk_error(png_ptr, "missing IHDR");
1338 else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE))
1340 png_crc_finish(png_ptr, length);
1341 png_chunk_benign_error(png_ptr, "out of place");
1355 png_crc_finish(png_ptr, length);
1356 png_chunk_benign_error(png_ptr, "too short");
1361 if (png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID)
1363 png_crc_finish(png_ptr, length);
1370 if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_INTENT) == 0)
1382 png_crc_read(png_ptr, (png_bytep)keyword, read_length);
1401 if (png_inflate_claim(png_ptr, png_iCCP) == Z_OK)
1407 png_ptr->zstream.next_in = (Bytef*)keyword + (keyword_length+2);
1408 png_ptr->zstream.avail_in = read_length;
1409 (void)png_inflate_read(png_ptr, local_buffer,
1420 if (png_icc_check_length(png_ptr, &png_ptr->colorspace,
1426 if (png_icc_check_header(png_ptr, &png_ptr->colorspace,
1428 png_ptr->color_type))
1437 png_bytep profile = png_read_buffer(png_ptr,
1447 (void)png_inflate_read(png_ptr, local_buffer,
1456 if (png_icc_check_tag_table(png_ptr,
1457 &png_ptr->colorspace, keyword, profile_length,
1466 (void)png_inflate_read(png_ptr, local_buffer,
1471 if (length > 0 && !(png_ptr->flags &
1483 png_chunk_warning(png_ptr,
1487 png_crc_finish(png_ptr, length);
1492 png_icc_set_sRGB(png_ptr,
1493 &png_ptr->colorspace, profile,
1494 png_ptr->zstream.adler);
1500 png_free_data(png_ptr, info_ptr,
1504 png_malloc_base(png_ptr,
1513 png_ptr->read_buffer = NULL; /*steal*/
1520 png_ptr->colorspace.flags |=
1532 png_colorspace_sync(png_ptr, info_ptr);
1536 png_ptr->zowner = 0;
1545 errmsg = png_ptr->zstream.msg;
1552 errmsg = png_ptr->zstream.msg;
1566 errmsg = png_ptr->zstream.msg;
1569 png_ptr->zowner = 0;
1573 errmsg = png_ptr->zstream.msg;
1589 png_crc_finish(png_ptr, length);
1591 png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
1592 png_colorspace_sync(png_ptr, info_ptr);
1594 png_chunk_benign_error(png_ptr, errmsg);
1600 png_handle_sPLT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
1615 if (png_ptr->user_chunk_cache_max != 0)
1617 if (png_ptr->user_chunk_cache_max == 1)
1619 png_crc_finish(png_ptr, length);
1623 if (--png_ptr->user_chunk_cache_max == 1)
1625 png_warning(png_ptr, "No space in chunk cache for sPLT");
1626 png_crc_finish(png_ptr, length);
1632 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1633 png_chunk_error(png_ptr, "missing IHDR");
1635 else if (png_ptr->mode & PNG_HAVE_IDAT)
1637 png_crc_finish(png_ptr, length);
1638 png_chunk_benign_error(png_ptr, "out of place");
1645 png_crc_finish(png_ptr, length);
1646 png_chunk_benign_error(png_ptr, "too large to fit in memory");
1651 buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
1654 png_crc_finish(png_ptr, length);
1655 png_chunk_benign_error(png_ptr, "out of memory");
1664 png_crc_read(png_ptr, buffer, length);
1666 if (png_crc_finish(png_ptr, skip))
1679 png_warning(png_ptr, "malformed sPLT chunk");
1693 png_warning(png_ptr, "sPLT chunk has bad length");
1702 png_warning(png_ptr, "sPLT chunk too long");
1709 png_ptr, new_palette.nentries * (sizeof (png_sPLT_entry)));
1713 png_warning(png_ptr, "sPLT chunk requires too much memory");
1769 png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
1771 png_free(png_ptr, new_palette.entries);
1777 png_handle_tRNS(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
1783 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1784 png_chunk_error(png_ptr, "missing IHDR");
1786 else if (png_ptr->mode & PNG_HAVE_IDAT)
1788 png_crc_finish(png_ptr, length);
1789 png_chunk_benign_error(png_ptr, "out of place");
1795 png_crc_finish(png_ptr, length);
1796 png_chunk_benign_error(png_ptr, "duplicate");
1800 if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
1806 png_crc_finish(png_ptr, length);
1807 png_chunk_benign_error(png_ptr, "invalid");
1811 png_crc_read(png_ptr, buf, 2);
1812 png_ptr->num_trans = 1;
1813 png_ptr->trans_color.gray = png_get_uint_16(buf);
1816 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
1822 png_crc_finish(png_ptr, length);
1823 png_chunk_benign_error(png_ptr, "invalid");
1827 png_crc_read(png_ptr, buf, length);
1828 png_ptr->num_trans = 1;
1829 png_ptr->trans_color.red = png_get_uint_16(buf);
1830 png_ptr->trans_color.green = png_get_uint_16(buf + 2);
1831 png_ptr->trans_color.blue = png_get_uint_16(buf + 4);
1834 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1836 if (!(png_ptr->mode & PNG_HAVE_PLTE))
1839 png_crc_finish(png_ptr, length);
1840 png_chunk_benign_error(png_ptr, "out of place");
1844 if (length > png_ptr->num_palette || length > PNG_MAX_PALETTE_LENGTH ||
1847 png_crc_finish(png_ptr, length);
1848 png_chunk_benign_error(png_ptr, "invalid");
1852 png_crc_read(png_ptr, readbuf, length);
1853 png_ptr->num_trans = (png_uint_16)length;
1858 png_crc_finish(png_ptr, length);
1859 png_chunk_benign_error(png_ptr, "invalid with alpha channel");
1863 if (png_crc_finish(png_ptr, 0))
1865 png_ptr->num_trans = 0;
1873 png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,
1874 &(png_ptr->trans_color));
1880 png_handle_bKGD(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
1888 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1889 png_chunk_error(png_ptr, "missing IHDR");
1891 else if ((png_ptr->mode & PNG_HAVE_IDAT) ||
1892 (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
1893 !(png_ptr->mode & PNG_HAVE_PLTE)))
1895 png_crc_finish(png_ptr, length);
1896 png_chunk_benign_error(png_ptr, "out of place");
1902 png_crc_finish(png_ptr, length);
1903 png_chunk_benign_error(png_ptr, "duplicate");
1907 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1910 else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
1918 png_crc_finish(png_ptr, length);
1919 png_chunk_benign_error(png_ptr, "invalid");
1923 png_crc_read(png_ptr, buf, truelen);
1925 if (png_crc_finish(png_ptr, 0))
1933 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1941 png_chunk_benign_error(png_ptr, "invalid index");
1945 background.red = (png_uint_16)png_ptr->palette[buf[0]].red;
1946 background.green = (png_uint_16)png_ptr->palette[buf[0]].green;
1947 background.blue = (png_uint_16)png_ptr->palette[buf[0]].blue;
1956 else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */
1974 png_set_bKGD(png_ptr, info_ptr, &background);
1980 png_handle_hIST(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
1987 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1988 png_chunk_error(png_ptr, "missing IHDR");
1990 else if ((png_ptr->mode & PNG_HAVE_IDAT) || !(png_ptr->mode & PNG_HAVE_PLTE))
1992 png_crc_finish(png_ptr, length);
1993 png_chunk_benign_error(png_ptr, "out of place");
1999 png_crc_finish(png_ptr, length);
2000 png_chunk_benign_error(png_ptr, "duplicate");
2006 if (num != png_ptr->num_palette || num > PNG_MAX_PALETTE_LENGTH)
2008 png_crc_finish(png_ptr, length);
2009 png_chunk_benign_error(png_ptr, "invalid");
2017 png_crc_read(png_ptr, buf, 2);
2021 if (png_crc_finish(png_ptr, 0))
2024 png_set_hIST(png_ptr, info_ptr, readbuf);
2030 png_handle_pHYs(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
2038 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2039 png_chunk_error(png_ptr, "missing IHDR");
2041 else if (png_ptr->mode & PNG_HAVE_IDAT)
2043 png_crc_finish(png_ptr, length);
2044 png_chunk_benign_error(png_ptr, "out of place");
2050 png_crc_finish(png_ptr, length);
2051 png_chunk_benign_error(png_ptr, "duplicate");
2057 png_crc_finish(png_ptr, length);
2058 png_chunk_benign_error(png_ptr, "invalid");
2062 png_crc_read(png_ptr, buf, 9);
2064 if (png_crc_finish(png_ptr, 0))
2070 png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);
2076 png_handle_oFFs(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
2084 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2085 png_chunk_error(png_ptr, "missing IHDR");
2087 else if (png_ptr->mode & PNG_HAVE_IDAT)
2089 png_crc_finish(png_ptr, length);
2090 png_chunk_benign_error(png_ptr, "out of place");
2096 png_crc_finish(png_ptr, length);
2097 png_chunk_benign_error(png_ptr, "duplicate");
2103 png_crc_finish(png_ptr, length);
2104 png_chunk_benign_error(png_ptr, "invalid");
2108 png_crc_read(png_ptr, buf, 9);
2110 if (png_crc_finish(png_ptr, 0))
2116 png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);
2123 png_handle_pCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
2133 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2134 png_chunk_error(png_ptr, "missing IHDR");
2136 else if (png_ptr->mode & PNG_HAVE_IDAT)
2138 png_crc_finish(png_ptr, length);
2139 png_chunk_benign_error(png_ptr, "out of place");
2145 png_crc_finish(png_ptr, length);
2146 png_chunk_benign_error(png_ptr, "duplicate");
2153 buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
2157 png_crc_finish(png_ptr, length);
2158 png_chunk_benign_error(png_ptr, "out of memory");
2162 png_crc_read(png_ptr, buffer, length);
2164 if (png_crc_finish(png_ptr, 0))
2180 png_chunk_benign_error(png_ptr, "invalid");
2200 png_chunk_benign_error(png_ptr, "invalid parameter count");
2206 png_chunk_benign_error(png_ptr, "unrecognized equation type");
2214 params = png_voidcast(png_charpp, png_malloc_warn(png_ptr,
2219 png_chunk_benign_error(png_ptr, "out of memory");
2236 png_free(png_ptr, params);
2237 png_chunk_benign_error(png_ptr, "invalid data");
2242 png_set_pCAL(png_ptr, info_ptr, (png_charp)buffer, X0, X1, type, nparams,
2245 png_free(png_ptr, params);
2252 png_handle_sCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
2260 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2261 png_chunk_error(png_ptr, "missing IHDR");
2263 else if (png_ptr->mode & PNG_HAVE_IDAT)
2265 png_crc_finish(png_ptr, length);
2266 png_chunk_benign_error(png_ptr, "out of place");
2272 png_crc_finish(png_ptr, length);
2273 png_chunk_benign_error(png_ptr, "duplicate");
2280 png_crc_finish(png_ptr, length);
2281 png_chunk_benign_error(png_ptr, "invalid");
2288 buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
2292 png_chunk_benign_error(png_ptr, "out of memory");
2293 png_crc_finish(png_ptr, length);
2297 png_crc_read(png_ptr, buffer, length);
2300 if (png_crc_finish(png_ptr, 0))
2306 png_chunk_benign_error(png_ptr, "invalid unit");
2318 png_chunk_benign_error(png_ptr, "bad width format");
2321 png_chunk_benign_error(png_ptr, "non-positive width");
2330 png_chunk_benign_error(png_ptr, "bad height format");
2333 png_chunk_benign_error(png_ptr, "non-positive height");
2337 png_set_sCAL_s(png_ptr, info_ptr, buffer[0],
2345 png_handle_tIME(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
2352 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2353 png_chunk_error(png_ptr, "missing IHDR");
2357 png_crc_finish(png_ptr, length);
2358 png_chunk_benign_error(png_ptr, "duplicate");
2362 if (png_ptr->mode & PNG_HAVE_IDAT)
2363 png_ptr->mode |= PNG_AFTER_IDAT;
2367 png_crc_finish(png_ptr, length);
2368 png_chunk_benign_error(png_ptr, "invalid");
2372 png_crc_read(png_ptr, buf, 7);
2374 if (png_crc_finish(png_ptr, 0))
2384 png_set_tIME(png_ptr, info_ptr, &mod_time);
2391 png_handle_tEXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
2402 if (png_ptr->user_chunk_cache_max != 0)
2404 if (png_ptr->user_chunk_cache_max == 1)
2406 png_crc_finish(png_ptr, length);
2410 if (--png_ptr->user_chunk_cache_max == 1)
2412 png_crc_finish(png_ptr, length);
2413 png_chunk_benign_error(png_ptr, "no space in chunk cache");
2419 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2420 png_chunk_error(png_ptr, "missing IHDR");
2422 if (png_ptr->mode & PNG_HAVE_IDAT)
2423 png_ptr->mode |= PNG_AFTER_IDAT;
2428 png_crc_finish(png_ptr, length);
2429 png_chunk_benign_error(png_ptr, "too large to fit in memory");
2434 buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/);
2438 png_chunk_benign_error(png_ptr, "out of memory");
2442 png_crc_read(png_ptr, buffer, length);
2444 if (png_crc_finish(png_ptr, skip))
2464 if (png_set_text_2(png_ptr, info_ptr, &text_info, 1))
2465 png_warning(png_ptr, "Insufficient memory to process text chunk");
2472 png_handle_zTXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
2481 if (png_ptr->user_chunk_cache_max != 0)
2483 if (png_ptr->user_chunk_cache_max == 1)
2485 png_crc_finish(png_ptr, length);
2489 if (--png_ptr->user_chunk_cache_max == 1)
2491 png_crc_finish(png_ptr, length);
2492 png_chunk_benign_error(png_ptr, "no space in chunk cache");
2498 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2499 png_chunk_error(png_ptr, "missing IHDR");
2501 if (png_ptr->mode & PNG_HAVE_IDAT)
2502 png_ptr->mode |= PNG_AFTER_IDAT;
2504 buffer = png_read_buffer(png_ptr, length, 2/*silent*/);
2508 png_crc_finish(png_ptr, length);
2509 png_chunk_benign_error(png_ptr, "out of memory");
2513 png_crc_read(png_ptr, buffer, length);
2515 if (png_crc_finish(png_ptr, 0))
2545 if (png_decompress_chunk(png_ptr, length, keyword_length+2,
2550 /* It worked; png_ptr->read_buffer now looks like a tEXt chunk except
2554 buffer = png_ptr->read_buffer;
2565 if (png_set_text_2(png_ptr, info_ptr, &text, 1))
2570 errmsg = png_ptr->zstream.msg;
2574 png_chunk_benign_error(png_ptr, errmsg);
2581 png_handle_iTXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
2590 if (png_ptr->user_chunk_cache_max != 0)
2592 if (png_ptr->user_chunk_cache_max == 1)
2594 png_crc_finish(png_ptr, length);
2598 if (--png_ptr->user_chunk_cache_max == 1)
2600 png_crc_finish(png_ptr, length);
2601 png_chunk_benign_error(png_ptr, "no space in chunk cache");
2607 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2608 png_chunk_error(png_ptr, "missing IHDR");
2610 if (png_ptr->mode & PNG_HAVE_IDAT)
2611 png_ptr->mode |= PNG_AFTER_IDAT;
2613 buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/);
2617 png_crc_finish(png_ptr, length);
2618 png_chunk_benign_error(png_ptr, "out of memory");
2622 png_crc_read(png_ptr, buffer, length);
2624 if (png_crc_finish(png_ptr, 0))
2685 if (png_decompress_chunk(png_ptr, length, prefix_length,
2687 buffer = png_ptr->read_buffer;
2690 errmsg = png_ptr->zstream.msg;
2715 if (png_set_text_2(png_ptr, info_ptr, &text, 1))
2724 png_chunk_benign_error(png_ptr, errmsg);
2729 /* Utility function for png_handle_unknown; set up png_ptr::unknown_chunk */
2731 png_cache_unknown_chunk(png_structrp png_ptr, png_uint_32 length)
2735 if (png_ptr->unknown_chunk.data != NULL)
2737 png_free(png_ptr, png_ptr->unknown_chunk.data);
2738 png_ptr->unknown_chunk.data = NULL;
2742 if (png_ptr->user_chunk_malloc_max > 0 &&
2743 png_ptr->user_chunk_malloc_max < limit)
2744 limit = png_ptr->user_chunk_malloc_max;
2753 PNG_CSTRING_FROM_CHUNK(png_ptr->unknown_chunk.name, png_ptr->chunk_name);
2755 png_ptr->unknown_chunk.size = (png_size_t)length/*SAFE*/;
2757 png_ptr->unknown_chunk.location = (png_byte)png_ptr->mode/*SAFE*/;
2760 png_ptr->unknown_chunk.data = NULL;
2765 png_ptr->unknown_chunk.data = png_voidcast(png_bytep,
2766 png_malloc_warn(png_ptr, length));
2770 if (png_ptr->unknown_chunk.data == NULL && length > 0)
2773 png_crc_finish(png_ptr, length);
2774 png_chunk_benign_error(png_ptr, "unknown chunk exceeds memory limits");
2781 png_crc_read(png_ptr, png_ptr->unknown_chunk.data, length);
2782 png_crc_finish(png_ptr, 0);
2790 png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr,
2811 keep = png_chunk_unknown_handling(png_ptr, png_ptr->chunk_name);
2823 if (png_ptr->read_user_chunk_fn != NULL)
2825 if (png_cache_unknown_chunk(png_ptr, length))
2828 int ret = (*(png_ptr->read_user_chunk_fn))(png_ptr,
2829 &png_ptr->unknown_chunk);
2841 png_chunk_error(png_ptr, "error in user chunk");
2859 if (png_ptr->unknown_default < PNG_HANDLE_CHUNK_IF_SAFE)
2861 png_chunk_warning(png_ptr, "Saving unknown chunk:");
2862 png_app_warning(png_ptr,
2896 keep = png_ptr->unknown_default;
2900 PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)))
2902 if (!png_cache_unknown_chunk(png_ptr, length))
2907 png_crc_finish(png_ptr, length);
2922 png_app_error(png_ptr, "no unknown chunk support available");
2924 png_crc_finish(png_ptr, length);
2934 PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)))
2937 switch (png_ptr->user_chunk_cache_max)
2940 png_ptr->user_chunk_cache_max = 1;
2941 png_chunk_benign_error(png_ptr, "no space in chunk cache");
2950 --(png_ptr->user_chunk_cache_max);
2957 png_set_unknown_chunks(png_ptr, info_ptr,
2958 &png_ptr->unknown_chunk, 1);
2973 if (png_ptr->unknown_chunk.data != NULL)
2974 png_free(png_ptr, png_ptr->unknown_chunk.data);
2975 png_ptr->unknown_chunk.data = NULL;
2979 png_crc_finish(png_ptr, length);
2985 if (!handled && PNG_CHUNK_CRITICAL(png_ptr->chunk_name))
2986 png_chunk_error(png_ptr, "unhandled critical chunk");
3002 png_check_chunk_name(png_structrp png_ptr, png_uint_32 chunk_name)
3013 png_chunk_error(png_ptr, "invalid chunk type");
3027 png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
3029 unsigned int pixel_depth = png_ptr->transformed_pixel_depth;
3030 png_const_bytep sp = png_ptr->row_buf + 1;
3031 png_uint_32 row_width = png_ptr->width;
3032 unsigned int pass = png_ptr->pass;
3043 png_error(png_ptr, "internal row logic error");
3049 if (png_ptr->info_rowbytes != 0 && png_ptr->info_rowbytes !=
3051 png_error(png_ptr, "internal row size calculation error");
3055 png_error(png_ptr, "internal row width error");
3068 if (png_ptr->transformations & PNG_PACKSWAP) /* little-endian byte */
3084 if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE) &&
3230 if (png_ptr->transformations & PNG_PACKSWAP)
3276 png_error(png_ptr, "invalid user transform pixel depth");
3965 png_read_IDAT_data(png_structrp png_ptr, png_bytep output,
3969 png_ptr->zstream.next_out = output;
3970 png_ptr->zstream.avail_out = 0; /* safety: set below */
3980 if (png_ptr->zstream.avail_in == 0)
3985 while (png_ptr->idat_size == 0)
3988 if (png_ptr->index) {
3989 png_opt_crc_finish(png_ptr, 0);
3990 png_ptr->index->stream_idat_position = png_ptr->total_data_read;
3993 png_crc_finish(png_ptr, 0);
3995 png_ptr->idat_size = png_read_chunk_header(png_ptr);
3999 if (png_ptr->chunk_name != png_IDAT)
4000 png_error(png_ptr, "Not enough image data");
4003 avail_in = png_ptr->IDAT_read_size;
4005 if (avail_in > png_ptr->idat_size)
4006 avail_in = (uInt)png_ptr->idat_size;
4013 buffer = png_read_buffer(png_ptr, avail_in, 0/*error*/);
4015 png_crc_read(png_ptr, buffer, avail_in);
4016 png_ptr->idat_size -= avail_in;
4018 png_ptr->zstream.next_in = buffer;
4019 png_ptr->zstream.avail_in = avail_in;
4031 png_ptr->zstream.avail_out = out;
4036 png_ptr->zstream.next_out = tmpbuf;
4037 png_ptr->zstream.avail_out = (sizeof tmpbuf);
4047 ret = inflate(&png_ptr->zstream, Z_NO_FLUSH);
4051 avail_out += png_ptr->zstream.avail_out;
4054 avail_out += (sizeof tmpbuf) - png_ptr->zstream.avail_out;
4056 png_ptr->zstream.avail_out = 0;
4061 png_ptr->zstream.next_out = NULL;
4063 png_ptr->mode |= PNG_AFTER_IDAT;
4064 png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
4066 if (png_ptr->zstream.avail_in > 0 || png_ptr->idat_size > 0)
4067 png_chunk_benign_error(png_ptr, "Extra compressed data");
4073 if (png_ptr->index && png_ptr->row_number != png_ptr->height - 1)
4076 png_zstream_error(png_ptr, ret);
4079 png_chunk_error(png_ptr, png_ptr->zstream.msg);
4083 png_chunk_benign_error(png_ptr, png_ptr->zstream.msg);
4095 png_error(png_ptr, "Not enough image data");
4098 png_chunk_benign_error(png_ptr, "Too much image data");
4103 png_read_finish_IDAT(png_structrp png_ptr)
4110 if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
4116 png_read_IDAT_data(png_ptr, NULL, 0);
4117 png_ptr->zstream.next_out = NULL; /* safety */
4122 if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
4124 png_ptr->mode |= PNG_AFTER_IDAT;
4125 png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
4132 if (png_ptr->zowner == png_IDAT)
4135 png_ptr->zstream.next_in = NULL;
4136 png_ptr->zstream.avail_in = 0;
4139 png_ptr->zowner = 0;
4146 (void)png_crc_finish(png_ptr, png_ptr->idat_size);
4152 png_ptr, int pass)
4163 png_ptr->pass = pass;
4164 png_ptr->iwidth = (png_ptr->width +
4165 png_pass_inc[png_ptr->pass] - 1 -
4166 png_pass_start[png_ptr->pass]) /
4167 png_pass_inc[png_ptr->pass];
4172 png_read_finish_row(png_structrp png_ptr)
4191 png_ptr->row_number++;
4192 if (png_ptr->row_number < png_ptr->num_rows)
4196 if (png_ptr->interlaced)
4198 png_ptr->row_number = 0;
4203 memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
4207 png_ptr->pass++;
4209 if (png_ptr->pass >= 7)
4212 png_ptr->iwidth = (png_ptr->width +
4213 png_pass_inc[png_ptr->pass] - 1 -
4214 png_pass_start[png_ptr->pass]) /
4215 png_pass_inc[png_ptr->pass];
4217 if (!(png_ptr->transformations & PNG_INTERLACE))
4219 png_ptr->num_rows = (png_ptr->height +
4220 png_pass_yinc[png_ptr->pass] - 1 -
4221 png_pass_ystart[png_ptr->pass]) /
4222 png_pass_yinc[png_ptr->pass];
4225 else /* if (png_ptr->transformations & PNG_INTERLACE) */
4228 } while (png_ptr->num_rows == 0 || png_ptr->iwidth == 0);
4230 if (png_ptr->pass < 7)
4236 png_read_finish_IDAT(png_ptr);
4241 png_read_start_row(png_structrp png_ptr)
4265 png_init_read_transformations(png_ptr);
4268 if (png_ptr->interlaced)
4270 if (!(png_ptr->transformations & PNG_INTERLACE))
4271 png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
4275 png_ptr->num_rows = png_ptr->height;
4277 png_ptr->iwidth = (png_ptr->width +
4278 png_pass_inc[png_ptr->pass] - 1 -
4279 png_pass_start[png_ptr->pass]) /
4280 png_pass_inc[png_ptr->pass];
4286 png_ptr->num_rows = png_ptr->height;
4287 png_ptr->iwidth = png_ptr->width;
4290 max_pixel_depth = png_ptr->pixel_depth;
4303 if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
4308 if (png_ptr->transformations & PNG_EXPAND)
4310 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
4312 if (png_ptr->num_trans)
4319 else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
4324 if (png_ptr->num_trans)
4328 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
4330 if (png_ptr->num_trans)
4340 if (png_ptr->transformations & PNG_EXPAND_16)
4346 if (png_ptr->transformations & PNG_EXPAND)
4348 if (png_ptr->bit_depth < 16)
4353 png_ptr->transformations &= ~PNG_EXPAND_16;
4358 if (png_ptr->transformations & (PNG_FILLER))
4360 if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
4369 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB ||
4370 png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
4382 if (png_ptr->transformations & PNG_GRAY_TO_RGB)
4386 (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
4389 (png_ptr->transformations & (PNG_FILLER)) ||
4391 png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
4404 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
4411 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
4422 if (png_ptr->transformations & PNG_USER_TRANSFORM)
4424 int user_pixel_depth = png_ptr->user_transform_depth *
4425 png_ptr->user_transform_channels;
4435 png_ptr->maximum_pixel_depth = (png_byte)max_pixel_depth;
4436 png_ptr->transformed_pixel_depth = 0; /* calculated on demand */
4441 row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
4450 png_error(png_ptr, "This image requires a row greater than 64KB");
4453 if (row_bytes + 48 > png_ptr->old_big_row_buf_size)
4455 png_free(png_ptr, png_ptr->big_row_buf);
4456 png_free(png_ptr, png_ptr->big_prev_row);
4458 if (png_ptr->interlaced)
4459 png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,
4463 png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes + 48);
4465 png_ptr->big_prev_row = (png_bytep)png_malloc(png_ptr, row_bytes + 48);
4476 png_bytep temp = png_ptr->big_row_buf + 32;
4478 png_ptr->row_buf = temp - extra - 1/*filter byte*/;
4480 temp = png_ptr->big_prev_row + 32;
4482 png_ptr->prev_row = temp - extra - 1/*filter byte*/;
4487 png_ptr->row_buf = png_ptr->big_row_buf + 31;
4488 png_ptr->prev_row = png_ptr->big_prev_row + 31;
4490 png_ptr->old_big_row_buf_size = row_bytes + 48;
4494 if (png_ptr->rowbytes > 65535)
4495 png_error(png_ptr, "This image requires a row greater than 64KB");
4498 if (png_ptr->rowbytes > (PNG_SIZE_MAX - 1))
4499 png_error(png_ptr, "Row has too many bytes to allocate in memory");
4501 memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
4503 png_debug1(3, "width = %u,", png_ptr->width);
4504 png_debug1(3, "height = %u,", png_ptr->height);
4505 png_debug1(3, "iwidth = %u,", png_ptr->iwidth);
4506 png_debug1(3, "num_rows = %u,", png_ptr->num_rows);
4507 png_debug1(3, "rowbytes = %lu,", (unsigned long)png_ptr->rowbytes);
4509 (unsigned long)PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1);
4515 if (png_ptr->read_buffer)
4517 png_bytep buffer = png_ptr->read_buffer;
4519 png_ptr->read_buffer_size = 0;
4520 png_ptr->read_buffer = NULL;
4521 png_free(png_ptr, buffer);
4529 if (png_inflate_claim(png_ptr, png_IDAT) != Z_OK)
4530 png_error(png_ptr, png_ptr->zstream.msg);
4532 png_ptr->flags |= PNG_FLAG_ROW_INIT;
