Lines Matching defs:png_ptr
52 png_get_uint_31(png_structp png_ptr, png_const_bytep buf)
57 png_error(png_ptr, "PNG unsigned integer out of range");
71 png_get_fixed_point(png_structp png_ptr, png_const_bytep buf)
79 if (png_ptr != NULL)
80 png_warning(png_ptr, "PNG fixed point integer out of range");
145 png_read_sig(png_structp png_ptr, png_infop info_ptr)
150 if (png_ptr->sig_bytes >= 8)
153 num_checked = png_ptr->sig_bytes;
157 png_ptr->io_state = PNG_IO_READING | PNG_IO_SIGNATURE;
161 png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
162 png_ptr->sig_bytes = 8;
168 png_error(png_ptr, "Not a PNG file");
170 png_error(png_ptr, "PNG file corrupted by ASCII conversion");
173 png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
177 * Put the type name into png_ptr->chunk_name, and return the length.
180 png_read_chunk_header(png_structp png_ptr)
186 png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR;
192 png_read_data(png_ptr, buf, 8);
193 length = png_get_uint_31(png_ptr, buf);
195 /* Put the chunk name into png_ptr->chunk_name. */
196 png_memcpy(png_ptr->chunk_name, buf + 4, 4);
199 png_ptr->chunk_name, length);
202 png_reset_crc(png_ptr);
203 png_calculate_crc(png_ptr, png_ptr->chunk_name, 4);
206 png_check_chunk_name(png_ptr, png_ptr->chunk_name);
209 png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_DATA;
217 png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
219 if (png_ptr == NULL)
222 png_read_data(png_ptr, buf, length);
223 png_calculate_crc(png_ptr, buf, length);
232 png_crc_finish(png_structp png_ptr, png_uint_32 skip)
235 png_size_t istop = png_ptr->zbuf_size;
239 png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
244 png_crc_read(png_ptr, png_ptr->zbuf, i);
247 if (png_crc_error(png_ptr))
249 if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */
250 !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||
251 (!(png_ptr->chunk_name[0] & 0x20) && /* Critical */
252 (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))
254 png_chunk_warning(png_ptr, "CRC error");
259 png_chunk_benign_error(png_ptr, "CRC error");
273 png_crc_error(png_structp png_ptr)
279 if (png_ptr->chunk_name[0] & 0x20) /* ancillary */
281 if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
288 if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
293 png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_CRC;
297 png_read_data(png_ptr, crc_bytes, 4);
302 return ((int)(crc != png_ptr->crc));
311 png_inflate(png_structp png_ptr, png_bytep data, png_size_t size,
325 png_ptr->zstream.next_in = data;
327 png_ptr->zstream.avail_in = 0;
340 if (png_ptr->zstream.avail_in == 0 && size > 0)
345 png_ptr->zstream.avail_in = (uInt)size;
351 png_ptr->zstream.avail_in = ZLIB_IO_MAX;
359 png_ptr->zstream.next_out = png_ptr->zbuf;
360 png_ptr->zstream.avail_out = png_ptr->zbuf_size;
362 ret = inflate(&png_ptr->zstream, Z_NO_FLUSH);
363 avail = png_ptr->zbuf_size - png_ptr->zstream.avail_out;
379 png_memcpy(output + count, png_ptr->zbuf, copy);
390 png_ptr->zstream.avail_in = 0;
391 inflateReset(&png_ptr->zstream);
404 if (png_ptr->zstream.msg != 0)
405 msg = png_ptr->zstream.msg;
422 png_chunk_warning(png_ptr, msg);
441 png_decompress_chunk(png_structp png_ptr, int comp_type,
449 png_warning(png_ptr, "invalid chunklength");
455 png_size_t expanded_size = png_inflate(png_ptr,
456 (png_bytep)(png_ptr->chunkdata + prefix_size),
465 if (png_ptr->user_chunk_malloc_max &&
466 (prefix_size + expanded_size >= png_ptr->user_chunk_malloc_max - 1))
473 png_warning(png_ptr, "Exceeded size limit while expanding chunk");
489 png_charp text = png_malloc_warn(png_ptr,
494 png_memcpy(text, png_ptr->chunkdata, prefix_size);
495 new_size = png_inflate(png_ptr,
496 (png_bytep)(png_ptr->chunkdata + prefix_size),
503 png_free(png_ptr, png_ptr->chunkdata);
504 png_ptr->chunkdata = text;
509 png_warning(png_ptr, "png_inflate logic error");
510 png_free(png_ptr, text);
514 png_warning(png_ptr, "Not enough memory to decompress chunk");
522 png_formatted_warning(png_ptr, p, "Unknown zTXt compression type @1");
532 png_charp text = png_malloc_warn(png_ptr, prefix_size + 1);
537 png_memcpy(text, png_ptr->chunkdata, prefix_size);
539 png_free(png_ptr, png_ptr->chunkdata);
540 png_ptr->chunkdata = text;
543 *(png_ptr->chunkdata + prefix_size) = 0x00;
554 png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
563 if (png_ptr->mode & PNG_HAVE_IHDR)
564 png_error(png_ptr, "Out of place IHDR");
568 png_error(png_ptr, "Invalid IHDR chunk");
570 png_ptr->mode |= PNG_HAVE_IHDR;
572 png_crc_read(png_ptr, buf, 13);
573 png_crc_finish(png_ptr, 0);
575 width = png_get_uint_31(png_ptr, buf);
576 height = png_get_uint_31(png_ptr, buf + 4);
584 png_ptr->width = width;
585 png_ptr->height = height;
586 png_ptr->bit_depth = (png_byte)bit_depth;
587 png_ptr->interlaced = (png_byte)interlace_type;
588 png_ptr->color_type = (png_byte)color_type;
590 png_ptr->filter_type = (png_byte)filter_type;
592 png_ptr->compression_type = (png_byte)compression_type;
595 switch (png_ptr->color_type)
600 png_ptr->channels = 1;
604 png_ptr->channels = 3;
608 png_ptr->channels = 2;
612 png_ptr->channels = 4;
617 png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
618 png_ptr->channels);
619 png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
620 png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
621 png_debug1(3, "channels = %d", png_ptr->channels);
622 png_debug1(3, "rowbytes = %lu", (unsigned long)png_ptr->rowbytes);
623 png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
629 png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
639 if (!(png_ptr->mode & PNG_HAVE_IHDR))
640 png_error(png_ptr, "Missing IHDR before PLTE");
642 else if (png_ptr->mode & PNG_HAVE_IDAT)
644 png_warning(png_ptr, "Invalid PLTE after IDAT");
645 png_crc_finish(png_ptr, length);
649 else if (png_ptr->mode & PNG_HAVE_PLTE)
650 png_error(png_ptr, "Duplicate PLTE chunk");
652 png_ptr->mode |= PNG_HAVE_PLTE;
654 if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
656 png_warning(png_ptr,
658 png_crc_finish(png_ptr, length);
663 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
665 png_crc_finish(png_ptr, length);
672 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
674 png_warning(png_ptr, "Invalid palette chunk");
675 png_crc_finish(png_ptr, length);
681 png_error(png_ptr, "Invalid palette chunk");
692 png_crc_read(png_ptr, buf, 3);
702 png_crc_read(png_ptr, buf, 3);
716 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
719 png_crc_finish(png_ptr, 0);
723 else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */
730 if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))
732 if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)
734 png_chunk_benign_error(png_ptr, "CRC error");
739 png_chunk_warning(png_ptr, "CRC error");
745 else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))
747 png_chunk_warning(png_ptr, "CRC error");
752 png_set_PLTE(png_ptr, info_ptr, palette, num);
755 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
759 if (png_ptr->num_trans > (png_uint_16)num)
761 png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
762 png_ptr->num_trans = (png_uint_16)num;
767 png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");
777 png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
781 if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
783 png_error(png_ptr, "No image in file");
786 png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
790 png_warning(png_ptr, "Incorrect IEND chunk length");
793 png_crc_finish(png_ptr, length);
800 png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
807 if (!(png_ptr->mode & PNG_HAVE_IHDR))
808 png_error(png_ptr, "Missing IHDR before gAMA");
810 else if (png_ptr->mode & PNG_HAVE_IDAT)
812 png_warning(png_ptr, "Invalid gAMA after IDAT");
813 png_crc_finish(png_ptr, length);
817 else if (png_ptr->mode & PNG_HAVE_PLTE)
819 png_warning(png_ptr, "Out of place gAMA chunk");
827 png_warning(png_ptr, "Duplicate gAMA chunk");
828 png_crc_finish(png_ptr, length);
834 png_warning(png_ptr, "Incorrect gAMA chunk length");
835 png_crc_finish(png_ptr, length);
839 png_crc_read(png_ptr, buf, 4);
841 if (png_crc_finish(png_ptr, 0))
849 png_warning(png_ptr,
862 png_formatted_warning(png_ptr, p,
871 png_ptr->gamma = igamma;
874 png_set_gAMA_fixed(png_ptr, info_ptr, igamma);
880 png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
889 if (!(png_ptr->mode & PNG_HAVE_IHDR))
890 png_error(png_ptr, "Missing IHDR before sBIT");
892 else if (png_ptr->mode & PNG_HAVE_IDAT)
894 png_warning(png_ptr, "Invalid sBIT after IDAT");
895 png_crc_finish(png_ptr, length);
899 else if (png_ptr->mode & PNG_HAVE_PLTE)
902 png_warning(png_ptr, "Out of place sBIT chunk");
907 png_warning(png_ptr, "Duplicate sBIT chunk");
908 png_crc_finish(png_ptr, length);
912 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
916 truelen = (png_size_t)png_ptr->channels;
920 png_warning(png_ptr, "Incorrect sBIT chunk length");
921 png_crc_finish(png_ptr, length);
925 png_crc_read(png_ptr, buf, truelen);
927 if (png_crc_finish(png_ptr, 0))
930 if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
932 png_ptr->sig_bit.red = buf[0];
933 png_ptr->sig_bit.green = buf[1];
934 png_ptr->sig_bit.blue = buf[2];
935 png_ptr->sig_bit.alpha = buf[3];
940 png_ptr->sig_bit.gray = buf[0];
941 png_ptr->sig_bit.red = buf[0];
942 png_ptr->sig_bit.green = buf[0];
943 png_ptr->sig_bit.blue = buf[0];
944 png_ptr->sig_bit.alpha = buf[1];
947 png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));
953 png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
961 if (!(png_ptr->mode & PNG_HAVE_IHDR))
962 png_error(png_ptr, "Missing IHDR before cHRM");
964 else if (png_ptr->mode & PNG_HAVE_IDAT)
966 png_warning(png_ptr, "Invalid cHRM after IDAT");
967 png_crc_finish(png_ptr, length);
971 else if (png_ptr->mode & PNG_HAVE_PLTE)
973 png_warning(png_ptr, "Missing PLTE before cHRM");
981 png_warning(png_ptr, "Duplicate cHRM chunk");
982 png_crc_finish(png_ptr, length);
988 png_warning(png_ptr, "Incorrect cHRM chunk length");
989 png_crc_finish(png_ptr, length);
993 png_crc_read(png_ptr, buf, 32);
995 if (png_crc_finish(png_ptr, 0))
1016 png_warning(png_ptr, "Ignoring cHRM chunk with negative chromaticities");
1043 png_formatted_warning(png_ptr, p,
1055 if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
1068 png_ptr->rgb_to_gray_red_coeff = (png_uint_16)(((png_uint_32)y_red *
1070 png_ptr->rgb_to_gray_green_coeff = (png_uint_16)(((png_uint_32)y_green
1072 png_ptr->rgb_to_gray_blue_coeff = (png_uint_16)(((png_uint_32)y_blue *
1078 png_set_cHRM_fixed(png_ptr, info_ptr, x_white, y_white, x_red, y_red,
1085 png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1092 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1093 png_error(png_ptr, "Missing IHDR before sRGB");
1095 else if (png_ptr->mode & PNG_HAVE_IDAT)
1097 png_warning(png_ptr, "Invalid sRGB after IDAT");
1098 png_crc_finish(png_ptr, length);
1102 else if (png_ptr->mode & PNG_HAVE_PLTE)
1104 png_warning(png_ptr, "Out of place sRGB chunk");
1108 png_warning(png_ptr, "Duplicate sRGB chunk");
1109 png_crc_finish(png_ptr, length);
1115 png_warning(png_ptr, "Incorrect sRGB chunk length");
1116 png_crc_finish(png_ptr, length);
1120 png_crc_read(png_ptr, buf, 1);
1122 if (png_crc_finish(png_ptr, 0))
1130 png_warning(png_ptr, "Unknown sRGB intent");
1144 png_formatted_warning(png_ptr, p,
1161 png_warning(png_ptr,
1166 png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);
1172 png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1185 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1186 png_error(png_ptr, "Missing IHDR before iCCP");
1188 else if (png_ptr->mode & PNG_HAVE_IDAT)
1190 png_warning(png_ptr, "Invalid iCCP after IDAT");
1191 png_crc_finish(png_ptr, length);
1195 else if (png_ptr->mode & PNG_HAVE_PLTE)
1197 png_warning(png_ptr, "Out of place iCCP chunk");
1201 png_warning(png_ptr, "Duplicate iCCP chunk");
1202 png_crc_finish(png_ptr, length);
1209 png_warning(png_ptr, "iCCP chunk too large to fit in memory");
1215 png_free(png_ptr, png_ptr->chunkdata);
1216 png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
1218 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1220 if (png_crc_finish(png_ptr, skip))
1222 png_free(png_ptr, png_ptr->chunkdata);
1223 png_ptr->chunkdata = NULL;
1227 png_ptr->chunkdata[slength] = 0x00;
1229 for (profile = png_ptr->chunkdata; *profile; profile++)
1237 if (profile >= png_ptr->chunkdata + slength - 1)
1239 png_free(png_ptr, png_ptr->chunkdata);
1240 png_ptr->chunkdata = NULL;
1241 png_warning(png_ptr, "Malformed iCCP chunk");
1250 png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");
1255 prefix_length = profile - png_ptr->chunkdata;
1256 png_decompress_chunk(png_ptr, compression_type,
1263 png_free(png_ptr, png_ptr->chunkdata);
1264 png_ptr->chunkdata = NULL;
1265 png_warning(png_ptr, "Profile size field missing from iCCP chunk");
1270 pC = (png_bytep)(png_ptr->chunkdata + prefix_length);
1287 png_free(png_ptr, png_ptr->chunkdata);
1288 png_ptr->chunkdata = NULL;
1292 png_formatted_warning(png_ptr, p,
1297 png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata,
1298 compression_type, (png_bytep)png_ptr->chunkdata + prefix_length,
1300 png_free(png_ptr, png_ptr->chunkdata);
1301 png_ptr->chunkdata = NULL;
1307 png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1324 if (png_ptr->user_chunk_cache_max != 0)
1326 if (png_ptr->user_chunk_cache_max == 1)
1328 png_crc_finish(png_ptr, length);
1332 if (--png_ptr->user_chunk_cache_max == 1)
1334 png_warning(png_ptr, "No space in chunk cache for sPLT");
1335 png_crc_finish(png_ptr, length);
1341 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1342 png_error(png_ptr, "Missing IHDR before sPLT");
1344 else if (png_ptr->mode & PNG_HAVE_IDAT)
1346 png_warning(png_ptr, "Invalid sPLT after IDAT");
1347 png_crc_finish(png_ptr, length);
1354 png_warning(png_ptr, "sPLT chunk too large to fit in memory");
1360 png_free(png_ptr, png_ptr->chunkdata);
1361 png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
1368 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1370 if (png_crc_finish(png_ptr, skip))
1372 png_free(png_ptr, png_ptr->chunkdata);
1373 png_ptr->chunkdata = NULL;
1377 png_ptr->chunkdata[slength] = 0x00;
1379 for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start;
1386 if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)
1388 png_free(png_ptr, png_ptr->chunkdata);
1389 png_ptr->chunkdata = NULL;
1390 png_warning(png_ptr, "malformed sPLT chunk");
1401 (png_bytep)png_ptr->chunkdata);
1406 png_free(png_ptr, png_ptr->chunkdata);
1407 png_ptr->chunkdata = NULL;
1408 png_warning(png_ptr, "sPLT chunk has bad length");
1417 png_warning(png_ptr, "sPLT chunk too long");
1424 png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));
1428 png_warning(png_ptr, "sPLT chunk requires too much memory");
1482 new_palette.name = png_ptr->chunkdata;
1484 png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
1486 png_free(png_ptr, png_ptr->chunkdata);
1487 png_ptr->chunkdata = NULL;
1488 png_free(png_ptr, new_palette.entries);
1494 png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1500 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1501 png_error(png_ptr, "Missing IHDR before tRNS");
1503 else if (png_ptr->mode & PNG_HAVE_IDAT)
1505 png_warning(png_ptr, "Invalid tRNS after IDAT");
1506 png_crc_finish(png_ptr, length);
1512 png_warning(png_ptr, "Duplicate tRNS chunk");
1513 png_crc_finish(png_ptr, length);
1517 if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
1523 png_warning(png_ptr, "Incorrect tRNS chunk length");
1524 png_crc_finish(png_ptr, length);
1528 png_crc_read(png_ptr, buf, 2);
1529 png_ptr->num_trans = 1;
1530 png_ptr->trans_color.gray = png_get_uint_16(buf);
1533 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
1539 png_warning(png_ptr, "Incorrect tRNS chunk length");
1540 png_crc_finish(png_ptr, length);
1544 png_crc_read(png_ptr, buf, (png_size_t)length);
1545 png_ptr->num_trans = 1;
1546 png_ptr->trans_color.red = png_get_uint_16(buf);
1547 png_ptr->trans_color.green = png_get_uint_16(buf + 2);
1548 png_ptr->trans_color.blue = png_get_uint_16(buf + 4);
1551 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1553 if (!(png_ptr->mode & PNG_HAVE_PLTE))
1556 png_warning(png_ptr, "Missing PLTE before tRNS");
1559 if (length > (png_uint_32)png_ptr->num_palette ||
1562 png_warning(png_ptr, "Incorrect tRNS chunk length");
1563 png_crc_finish(png_ptr, length);
1569 png_warning(png_ptr, "Zero length tRNS chunk");
1570 png_crc_finish(png_ptr, length);
1574 png_crc_read(png_ptr, readbuf, (png_size_t)length);
1575 png_ptr->num_trans = (png_uint_16)length;
1580 png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");
1581 png_crc_finish(png_ptr, length);
1585 if (png_crc_finish(png_ptr, 0))
1587 png_ptr->num_trans = 0;
1591 png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,
1592 &(png_ptr->trans_color));
1598 png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1606 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1607 png_error(png_ptr, "Missing IHDR before bKGD");
1609 else if (png_ptr->mode & PNG_HAVE_IDAT)
1611 png_warning(png_ptr, "Invalid bKGD after IDAT");
1612 png_crc_finish(png_ptr, length);
1616 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
1617 !(png_ptr->mode & PNG_HAVE_PLTE))
1619 png_warning(png_ptr, "Missing PLTE before bKGD");
1620 png_crc_finish(png_ptr, length);
1626 png_warning(png_ptr, "Duplicate bKGD chunk");
1627 png_crc_finish(png_ptr, length);
1631 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1634 else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
1642 png_warning(png_ptr, "Incorrect bKGD chunk length");
1643 png_crc_finish(png_ptr, length);
1647 png_crc_read(png_ptr, buf, truelen);
1649 if (png_crc_finish(png_ptr, 0))
1657 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1665 png_warning(png_ptr, "Incorrect bKGD chunk index value");
1669 background.red = (png_uint_16)png_ptr->palette[buf[0]].red;
1670 background.green = (png_uint_16)png_ptr->palette[buf[0]].green;
1671 background.blue = (png_uint_16)png_ptr->palette[buf[0]].blue;
1680 else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */
1698 png_set_bKGD(png_ptr, info_ptr, &background);
1704 png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1711 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1712 png_error(png_ptr, "Missing IHDR before hIST");
1714 else if (png_ptr->mode & PNG_HAVE_IDAT)
1716 png_warning(png_ptr, "Invalid hIST after IDAT");
1717 png_crc_finish(png_ptr, length);
1721 else if (!(png_ptr->mode & PNG_HAVE_PLTE))
1723 png_warning(png_ptr, "Missing PLTE before hIST");
1724 png_crc_finish(png_ptr, length);
1730 png_warning(png_ptr, "Duplicate hIST chunk");
1731 png_crc_finish(png_ptr, length);
1737 if (num != (unsigned int)png_ptr->num_palette || num >
1740 png_warning(png_ptr, "Incorrect hIST chunk length");
1741 png_crc_finish(png_ptr, length);
1749 png_crc_read(png_ptr, buf, 2);
1753 if (png_crc_finish(png_ptr, 0))
1756 png_set_hIST(png_ptr, info_ptr, readbuf);
1762 png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1770 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1771 png_error(png_ptr, "Missing IHDR before pHYs");
1773 else if (png_ptr->mode & PNG_HAVE_IDAT)
1775 png_warning(png_ptr, "Invalid pHYs after IDAT");
1776 png_crc_finish(png_ptr, length);
1782 png_warning(png_ptr, "Duplicate pHYs chunk");
1783 png_crc_finish(png_ptr, length);
1789 png_warning(png_ptr, "Incorrect pHYs chunk length");
1790 png_crc_finish(png_ptr, length);
1794 png_crc_read(png_ptr, buf, 9);
1796 if (png_crc_finish(png_ptr, 0))
1802 png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);
1808 png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1816 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1817 png_error(png_ptr, "Missing IHDR before oFFs");
1819 else if (png_ptr->mode & PNG_HAVE_IDAT)
1821 png_warning(png_ptr, "Invalid oFFs after IDAT");
1822 png_crc_finish(png_ptr, length);
1828 png_warning(png_ptr, "Duplicate oFFs chunk");
1829 png_crc_finish(png_ptr, length);
1835 png_warning(png_ptr, "Incorrect oFFs chunk length");
1836 png_crc_finish(png_ptr, length);
1840 png_crc_read(png_ptr, buf, 9);
1842 if (png_crc_finish(png_ptr, 0))
1848 png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);
1855 png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1866 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1867 png_error(png_ptr, "Missing IHDR before pCAL");
1869 else if (png_ptr->mode & PNG_HAVE_IDAT)
1871 png_warning(png_ptr, "Invalid pCAL after IDAT");
1872 png_crc_finish(png_ptr, length);
1878 png_warning(png_ptr, "Duplicate pCAL chunk");
1879 png_crc_finish(png_ptr, length);
1885 png_free(png_ptr, png_ptr->chunkdata);
1886 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
1888 if (png_ptr->chunkdata == NULL)
1890 png_warning(png_ptr, "No memory for pCAL purpose");
1895 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1897 if (png_crc_finish(png_ptr, 0))
1899 png_free(png_ptr, png_ptr->chunkdata);
1900 png_ptr->chunkdata = NULL;
1904 png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
1907 for (buf = png_ptr->chunkdata; *buf; buf++)
1910 endptr = png_ptr->chunkdata + slength;
1917 png_warning(png_ptr, "Invalid pCAL data");
1918 png_free(png_ptr, png_ptr->chunkdata);
1919 png_ptr->chunkdata = NULL;
1939 png_warning(png_ptr, "Invalid pCAL parameters for equation type");
1940 png_free(png_ptr, png_ptr->chunkdata);
1941 png_ptr->chunkdata = NULL;
1947 png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
1955 params = (png_charpp)png_malloc_warn(png_ptr,
1960 png_free(png_ptr, png_ptr->chunkdata);
1961 png_ptr->chunkdata = NULL;
1962 png_warning(png_ptr, "No memory for pCAL params");
1979 png_warning(png_ptr, "Invalid pCAL data");
1980 png_free(png_ptr, png_ptr->chunkdata);
1981 png_ptr->chunkdata = NULL;
1982 png_free(png_ptr, params);
1987 png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams,
1990 png_free(png_ptr, png_ptr->chunkdata);
1991 png_ptr->chunkdata = NULL;
1992 png_free(png_ptr, params);
1999 png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2006 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2007 png_error(png_ptr, "Missing IHDR before sCAL");
2009 else if (png_ptr->mode & PNG_HAVE_IDAT)
2011 png_warning(png_ptr, "Invalid sCAL after IDAT");
2012 png_crc_finish(png_ptr, length);
2018 png_warning(png_ptr, "Duplicate sCAL chunk");
2019 png_crc_finish(png_ptr, length);
2026 png_warning(png_ptr, "sCAL chunk too short");
2027 png_crc_finish(png_ptr, length);
2034 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2036 if (png_ptr->chunkdata == NULL)
2038 png_warning(png_ptr, "Out of memory while processing sCAL chunk");
2039 png_crc_finish(png_ptr, length);
2044 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2045 png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
2047 if (png_crc_finish(png_ptr, 0))
2049 png_free(png_ptr, png_ptr->chunkdata);
2050 png_ptr->chunkdata = NULL;
2055 if (png_ptr->chunkdata[0] != 1 && png_ptr->chunkdata[0] != 2)
2057 png_warning(png_ptr, "Invalid sCAL ignored: invalid unit");
2058 png_free(png_ptr, png_ptr->chunkdata);
2059 png_ptr->chunkdata = NULL;
2069 if (!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) ||
2070 i >= slength || png_ptr->chunkdata[i++] != 0)
2071 png_warning(png_ptr, "Invalid sCAL chunk ignored: bad width format");
2074 png_warning(png_ptr, "Invalid sCAL chunk ignored: non-positive width");
2081 if (!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) ||
2083 png_warning(png_ptr, "Invalid sCAL chunk ignored: bad height format");
2086 png_warning(png_ptr,
2091 png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0],
2092 png_ptr->chunkdata+1, png_ptr->chunkdata+heighti);
2096 png_free(png_ptr, png_ptr->chunkdata);
2097 png_ptr->chunkdata = NULL;
2103 png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2110 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2111 png_error(png_ptr, "Out of place tIME chunk");
2115 png_warning(png_ptr, "Duplicate tIME chunk");
2116 png_crc_finish(png_ptr, length);
2120 if (png_ptr->mode & PNG_HAVE_IDAT)
2121 png_ptr->mode |= PNG_AFTER_IDAT;
2125 png_warning(png_ptr, "Incorrect tIME chunk length");
2126 png_crc_finish(png_ptr, length);
2130 png_crc_read(png_ptr, buf, 7);
2132 if (png_crc_finish(png_ptr, 0))
2142 png_set_tIME(png_ptr, info_ptr, &mod_time);
2149 png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2161 if (png_ptr->user_chunk_cache_max != 0)
2163 if (png_ptr->user_chunk_cache_max == 1)
2165 png_crc_finish(png_ptr, length);
2169 if (--png_ptr->user_chunk_cache_max == 1)
2171 png_warning(png_ptr, "No space in chunk cache for tEXt");
2172 png_crc_finish(png_ptr, length);
2178 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2179 png_error(png_ptr, "Missing IHDR before tEXt");
2181 if (png_ptr->mode & PNG_HAVE_IDAT)
2182 png_ptr->mode |= PNG_AFTER_IDAT;
2187 png_warning(png_ptr, "tEXt chunk too large to fit in memory");
2193 png_free(png_ptr, png_ptr->chunkdata);
2195 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2197 if (png_ptr->chunkdata == NULL)
2199 png_warning(png_ptr, "No memory to process text chunk");
2204 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2206 if (png_crc_finish(png_ptr, skip))
2208 png_free(png_ptr, png_ptr->chunkdata);
2209 png_ptr->chunkdata = NULL;
2213 key = png_ptr->chunkdata;
2223 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2228 png_warning(png_ptr, "Not enough memory to process text chunk");
2229 png_free(png_ptr, png_ptr->chunkdata);
2230 png_ptr->chunkdata = NULL;
2242 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2244 png_free(png_ptr, png_ptr->chunkdata);
2245 png_ptr->chunkdata = NULL;
2246 png_free(png_ptr, text_ptr);
2249 png_warning(png_ptr, "Insufficient memory to process text chunk");
2256 png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2267 if (png_ptr->user_chunk_cache_max != 0)
2269 if (png_ptr->user_chunk_cache_max == 1)
2271 png_crc_finish(png_ptr, length);
2275 if (--png_ptr->user_chunk_cache_max == 1)
2277 png_warning(png_ptr, "No space in chunk cache for zTXt");
2278 png_crc_finish(png_ptr, length);
2284 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2285 png_error(png_ptr, "Missing IHDR before zTXt");
2287 if (png_ptr->mode & PNG_HAVE_IDAT)
2288 png_ptr->mode |= PNG_AFTER_IDAT;
2296 png_warning(png_ptr, "zTXt chunk too large to fit in memory");
2297 png_crc_finish(png_ptr, length);
2302 png_free(png_ptr, png_ptr->chunkdata);
2303 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2305 if (png_ptr->chunkdata == NULL)
2307 png_warning(png_ptr, "Out of memory processing zTXt chunk");
2312 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2314 if (png_crc_finish(png_ptr, 0))
2316 png_free(png_ptr, png_ptr->chunkdata);
2317 png_ptr->chunkdata = NULL;
2321 png_ptr->chunkdata[slength] = 0x00;
2323 for (text = png_ptr->chunkdata; *text; text++)
2327 if (text >= png_ptr->chunkdata + slength - 2)
2329 png_warning(png_ptr, "Truncated zTXt chunk");
2330 png_free(png_ptr, png_ptr->chunkdata);
2331 png_ptr->chunkdata = NULL;
2341 png_warning(png_ptr, "Unknown compression type in zTXt chunk");
2348 prefix_len = text - png_ptr->chunkdata;
2350 png_decompress_chunk(png_ptr, comp_type,
2353 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2358 png_warning(png_ptr, "Not enough memory to process zTXt chunk");
2359 png_free(png_ptr, png_ptr->chunkdata);
2360 png_ptr->chunkdata = NULL;
2365 text_ptr->key = png_ptr->chunkdata;
2369 text_ptr->text = png_ptr->chunkdata + prefix_len;
2372 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2374 png_free(png_ptr, text_ptr);
2375 png_free(png_ptr, png_ptr->chunkdata);
2376 png_ptr->chunkdata = NULL;
2379 png_error(png_ptr, "Insufficient memory to store zTXt chunk");
2386 png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2398 if (png_ptr->user_chunk_cache_max != 0)
2400 if (png_ptr->user_chunk_cache_max == 1)
2402 png_crc_finish(png_ptr, length);
2406 if (--png_ptr->user_chunk_cache_max == 1)
2408 png_warning(png_ptr, "No space in chunk cache for iTXt");
2409 png_crc_finish(png_ptr, length);
2415 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2416 png_error(png_ptr, "Missing IHDR before iTXt");
2418 if (png_ptr->mode & PNG_HAVE_IDAT)
2419 png_ptr->mode |= PNG_AFTER_IDAT;
2427 png_warning(png_ptr, "iTXt chunk too large to fit in memory");
2428 png_crc_finish(png_ptr, length);
2433 png_free(png_ptr, png_ptr->chunkdata);
2434 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2436 if (png_ptr->chunkdata == NULL)
2438 png_warning(png_ptr, "No memory to process iTXt chunk");
2443 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2445 if (png_crc_finish(png_ptr, 0))
2447 png_free(png_ptr, png_ptr->chunkdata);
2448 png_ptr->chunkdata = NULL;
2452 png_ptr->chunkdata[slength] = 0x00;
2454 for (lang = png_ptr->chunkdata; *lang; lang++)
2464 if (lang >= png_ptr->chunkdata + slength - 3)
2466 png_warning(png_ptr, "Truncated iTXt chunk");
2467 png_free(png_ptr, png_ptr->chunkdata);
2468 png_ptr->chunkdata = NULL;
2483 if (lang_key >= png_ptr->chunkdata + slength)
2485 png_warning(png_ptr, "Truncated iTXt chunk");
2486 png_free(png_ptr, png_ptr->chunkdata);
2487 png_ptr->chunkdata = NULL;
2496 if (text >= png_ptr->chunkdata + slength)
2498 png_warning(png_ptr, "Malformed iTXt chunk");
2499 png_free(png_ptr, png_ptr->chunkdata);
2500 png_ptr->chunkdata = NULL;
2504 prefix_len = text - png_ptr->chunkdata;
2506 key=png_ptr->chunkdata;
2509 png_decompress_chunk(png_ptr, comp_type,
2513 data_len = png_strlen(png_ptr->chunkdata + prefix_len);
2515 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2520 png_warning(png_ptr, "Not enough memory to process iTXt chunk");
2521 png_free(png_ptr, png_ptr->chunkdata);
2522 png_ptr->chunkdata = NULL;
2527 text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key);
2528 text_ptr->lang = png_ptr->chunkdata + (lang - key);
2531 text_ptr->key = png_ptr->chunkdata;
2532 text_ptr->text = png_ptr->chunkdata + prefix_len;
2534 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2536 png_free(png_ptr, text_ptr);
2537 png_free(png_ptr, png_ptr->chunkdata);
2538 png_ptr->chunkdata = NULL;
2541 png_error(png_ptr, "Insufficient memory to store iTXt chunk");
2552 png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2559 if (png_ptr->user_chunk_cache_max != 0)
2561 if (png_ptr->user_chunk_cache_max == 1)
2563 png_crc_finish(png_ptr, length);
2567 if (--png_ptr->user_chunk_cache_max == 1)
2569 png_warning(png_ptr, "No space in chunk cache for unknown chunk");
2570 png_crc_finish(png_ptr, length);
2576 if (png_ptr->mode & PNG_HAVE_IDAT)
2580 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* Not an IDAT */
2581 png_ptr->mode |= PNG_AFTER_IDAT;
2584 if (!(png_ptr->chunk_name[0] & 0x20))
2587 if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
2590 && png_ptr->read_user_chunk_fn == NULL
2594 png_chunk_error(png_ptr, "unknown critical chunk");
2598 if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
2600 || (png_ptr->read_user_chunk_fn != NULL)
2607 png_warning(png_ptr, "unknown chunk too large to fit in memory");
2613 png_memcpy((png_charp)png_ptr->unknown_chunk.name,
2614 (png_charp)png_ptr->chunk_name,
2615 png_sizeof(png_ptr->unknown_chunk.name));
2617 png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1]
2620 png_ptr->unknown_chunk.size = (png_size_t)length;
2623 png_ptr->unknown_chunk.data = NULL;
2627 png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);
2628 png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
2632 if (png_ptr->read_user_chunk_fn != NULL)
2637 ret = (*(png_ptr->read_user_chunk_fn))
2638 (png_ptr, &png_ptr->unknown_chunk);
2641 png_chunk_error(png_ptr, "error in user chunk");
2645 if (!(png_ptr->chunk_name[0] & 0x20))
2648 if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
2651 png_chunk_error(png_ptr, "unknown critical chunk");
2654 png_set_unknown_chunks(png_ptr, info_ptr,
2655 &png_ptr->unknown_chunk, 1);
2661 png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
2663 png_free(png_ptr, png_ptr->unknown_chunk.data);
2664 png_ptr->unknown_chunk.data = NULL;
2671 png_crc_finish(png_ptr, skip);
2688 png_check_chunk_name(png_structp png_ptr, png_const_bytep chunk_name)
2694 png_chunk_error(png_ptr, "invalid chunk type");
2711 png_combine_row(png_structp png_ptr, png_bytep row, int mask)
2719 if (png_ptr->info_rowbytes != 0 && png_ptr->info_rowbytes !=
2720 PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width))
2721 png_error(png_ptr, "internal row size calculation error");
2725 png_memcpy(row, png_ptr->row_buf + 1,
2726 PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));
2731 switch (png_ptr->row_info.pixel_depth)
2735 png_bytep sp = png_ptr->row_buf + 1;
2741 png_uint_32 row_width = png_ptr->width;
2744 if (png_ptr->transformations & PNG_PACKSWAP)
2793 png_bytep sp = png_ptr->row_buf + 1;
2799 png_uint_32 row_width = png_ptr->width;
2803 if (png_ptr->transformations & PNG_PACKSWAP)
2850 png_bytep sp = png_ptr->row_buf + 1;
2856 png_uint_32 row_width = png_ptr->width;
2860 if (png_ptr->transformations & PNG_PACKSWAP)
2906 png_bytep sp = png_ptr->row_buf + 1;
2908 png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
2910 png_uint_32 row_width = png_ptr->width;
2937 png_do_read_interlace(png_structp png_ptr)
2939 png_row_infop row_info = &(png_ptr->row_info);
2940 png_bytep row = png_ptr->row_buf + 1;
2941 int pass = png_ptr->pass;
2942 png_uint_32 transformations = png_ptr->transformations;
3179 png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
3183 png_debug2(2, "row = %u, filter = %d", png_ptr->row_number, filter);
3300 png_error(png_ptr, "Ignoring bad adaptive filter type");
3308 png_read_finish_row(png_structp png_ptr)
3327 png_ptr->row_number++;
3328 if (png_ptr->row_number < png_ptr->num_rows)
3332 if (png_ptr->interlaced)
3334 png_ptr->row_number = 0;
3336 png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
3340 png_ptr->pass++;
3342 if (png_ptr->pass >= 7)
3345 png_ptr->iwidth = (png_ptr->width +
3346 png_pass_inc[png_ptr->pass] - 1 -
3347 png_pass_start[png_ptr->pass]) /
3348 png_pass_inc[png_ptr->pass];
3350 if (!(png_ptr->transformations & PNG_INTERLACE))
3352 png_ptr->num_rows = (png_ptr->height +
3353 png_pass_yinc[png_ptr->pass] - 1 -
3354 png_pass_ystart[png_ptr->pass]) /
3355 png_pass_yinc[png_ptr->pass];
3358 else /* if (png_ptr->transformations & PNG_INTERLACE) */
3361 } while (png_ptr->num_rows == 0 || png_ptr->iwidth == 0);
3363 if (png_ptr->pass < 7)
3368 if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
3374 png_ptr->zstream.next_out = (Byte *)&extra;
3375 png_ptr->zstream.avail_out = (uInt)1;
3379 if (!(png_ptr->zstream.avail_in))
3381 while (!png_ptr->idat_size)
3383 png_crc_finish(png_ptr, 0);
3384 png_ptr->idat_size = png_read_chunk_header(png_ptr);
3385 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
3386 png_error(png_ptr, "Not enough image data");
3389 png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
3390 png_ptr->zstream.next_in = png_ptr->zbuf;
3392 if (png_ptr->zbuf_size > png_ptr->idat_size)
3393 png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
3395 png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);
3396 png_ptr->idat_size -= png_ptr->zstream.avail_in;
3399 ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
3403 if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||
3404 png_ptr->idat_size)
3405 png_warning(png_ptr, "Extra compressed data");
3407 png_ptr->mode |= PNG_AFTER_IDAT;
3408 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
3413 png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
3416 if (!(png_ptr->zstream.avail_out))
3418 png_warning(png_ptr, "Extra compressed data");
3419 png_ptr->mode |= PNG_AFTER_IDAT;
3420 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
3425 png_ptr->zstream.avail_out = 0;
3428 if (png_ptr->idat_size || png_ptr->zstream.avail_in)
3429 png_warning(png_ptr, "Extra compression data");
3431 inflateReset(&png_ptr->zstream);
3433 png_ptr->mode |= PNG_AFTER_IDAT;
3438 png_read_start_row(png_structp png_ptr)
3460 png_ptr->zstream.avail_in = 0;
3462 png_init_read_transformations(png_ptr);
3465 if (png_ptr->interlaced)
3467 if (!(png_ptr->transformations & PNG_INTERLACE))
3468 png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
3472 png_ptr->num_rows = png_ptr->height;
3474 png_ptr->iwidth = (png_ptr->width +
3475 png_pass_inc[png_ptr->pass] - 1 -
3476 png_pass_start[png_ptr->pass]) /
3477 png_pass_inc[png_ptr->pass];
3483 png_ptr->num_rows = png_ptr->height;
3484 png_ptr->iwidth = png_ptr->width;
3487 max_pixel_depth = png_ptr->pixel_depth;
3490 if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
3495 if (png_ptr->transformations & PNG_EXPAND)
3497 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
3499 if (png_ptr->num_trans)
3506 else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
3511 if (png_ptr->num_trans)
3515 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
3517 if (png_ptr->num_trans)
3527 if (png_ptr->transformations & PNG_EXPAND_16)
3533 if (png_ptr->transformations & PNG_EXPAND)
3535 if (png_ptr->bit_depth < 16)
3540 png_ptr->transformations &= ~PNG_EXPAND_16;
3545 if (png_ptr->transformations & (PNG_FILLER))
3547 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
3550 else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
3559 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
3571 if (png_ptr->transformations & PNG_GRAY_TO_RGB)
3575 (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
3578 (png_ptr->transformations & (PNG_FILLER)) ||
3580 png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
3593 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
3600 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
3611 if (png_ptr->transformations & PNG_USER_TRANSFORM)
3613 int user_pixel_depth = png_ptr->user_transform_depth*
3614 png_ptr->user_transform_channels;
3624 row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
3633 png_error(png_ptr, "This image requires a row greater than 64KB");
3636 if (row_bytes + 48 > png_ptr->old_big_row_buf_size)
3638 png_free(png_ptr, png_ptr->big_row_buf);
3640 if (png_ptr->interlaced)
3641 png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,
3645 png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr,
3648 png_ptr->old_big_row_buf_size = row_bytes + 48;
3654 png_ptr->row_buf = png_ptr->big_row_buf + 32 -
3655 (((png_alloc_size_t)png_ptr->big_row_buf + 15) & 0x0F);
3657 png_ptr->old_big_row_buf_size = row_bytes + 48;
3660 png_ptr->row_buf = png_ptr->big_row_buf + 32;
3662 png_ptr->old_big_row_buf_size = row_bytes + 48;
3666 if (png_ptr->rowbytes > 65535)
3667 png_error(png_ptr, "This image requires a row greater than 64KB");
3670 if (png_ptr->rowbytes > (PNG_SIZE_MAX - 1))
3671 png_error(png_ptr, "Row has too many bytes to allocate in memory");
3673 if (png_ptr->rowbytes + 1 > png_ptr->old_prev_row_size)
3675 png_free(png_ptr, png_ptr->prev_row);
3677 png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1);
3679 png_ptr->old_prev_row_size = png_ptr->rowbytes + 1;
3682 png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
3684 png_debug1(3, "width = %u,", png_ptr->width);
3685 png_debug1(3, "height = %u,", png_ptr->height);
3686 png_debug1(3, "iwidth = %u,", png_ptr->iwidth);
3687 png_debug1(3, "num_rows = %u,", png_ptr->num_rows);
3688 png_debug1(3, "rowbytes = %lu,", (unsigned long)png_ptr->rowbytes);
3690 (unsigned long)PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1);
3692 png_ptr->flags |= PNG_FLAG_ROW_INIT;