Lines Matching refs:png_ptr
29 __inline double png_strtod(png_structp png_ptr, PNG_CONST char *nptr,
37 str = (wchar_t *)png_malloc(png_ptr, len * png_sizeof(wchar_t));
44 png_free(png_ptr, str);
54 png_get_uint_31(png_structp png_ptr, png_bytep buf)
66 png_error(png_ptr, "PNG unsigned integer out of range.");
109 * Put the type name into png_ptr->chunk_name, and return the length.
112 png_read_chunk_header(png_structp png_ptr)
118 png_read_data(png_ptr, buf, 8);
119 length = png_get_uint_31(png_ptr, buf);
121 /* Put the chunk name into png_ptr->chunk_name */
122 png_memcpy(png_ptr->chunk_name, buf + 4, 4);
125 png_ptr->chunk_name, length);
128 png_reset_crc(png_ptr);
129 png_calculate_crc(png_ptr, png_ptr->chunk_name, 4);
132 png_check_chunk_name(png_ptr, png_ptr->chunk_name);
139 png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
141 if (png_ptr == NULL)
143 png_read_data(png_ptr, buf, length);
144 png_calculate_crc(png_ptr, buf, length);
153 png_crc_finish(png_structp png_ptr, png_uint_32 skip)
156 png_size_t istop = png_ptr->zbuf_size;
160 png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
164 png_crc_read(png_ptr, png_ptr->zbuf, i);
167 if (png_crc_error(png_ptr))
169 if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */
170 !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||
171 (!(png_ptr->chunk_name[0] & 0x20) && /* Critical */
172 (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))
174 png_chunk_warning(png_ptr, "CRC error");
178 png_chunk_error(png_ptr, "CRC error");
190 png_crc_error(png_structp png_ptr)
196 if (png_ptr->chunk_name[0] & 0x20) /* ancillary */
198 if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
204 if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
208 png_read_data(png_ptr, crc_bytes, 4);
213 return ((int)(crc != png_ptr->crc));
222 png_inflate(png_structp png_ptr, const png_byte *data, png_size_t size,
227 png_ptr->zstream.next_in = (png_bytep)data; /* const_cast: VALID */
228 png_ptr->zstream.avail_in = size;
237 png_ptr->zstream.next_out = png_ptr->zbuf;
238 png_ptr->zstream.avail_out = png_ptr->zbuf_size;
240 ret = inflate(&png_ptr->zstream, Z_NO_FLUSH);
241 avail = png_ptr->zbuf_size - png_ptr->zstream.avail_out;
252 png_memcpy(output + count, png_ptr->zbuf, copy);
263 png_ptr->zstream.avail_in = 0;
264 inflateReset(&png_ptr->zstream);
275 if (png_ptr->zstream.msg != 0)
276 msg = png_ptr->zstream.msg;
295 png_snprintf(umsg, sizeof umsg, msg, png_ptr->chunk_name);
302 png_warning(png_ptr, msg);
320 png_decompress_chunk(png_structp png_ptr, int comp_type,
328 png_warning(png_ptr, "invalid chunklength");
334 png_size_t expanded_size = png_inflate(png_ptr,
335 (png_bytep)(png_ptr->chunkdata + prefix_size),
349 png_warning(png_ptr, "Exceeded size limit while expanding chunk");
361 png_charp text = png_malloc_warn(png_ptr,
366 png_memcpy(text, png_ptr->chunkdata, prefix_size);
367 new_size = png_inflate(png_ptr,
368 (png_bytep)(png_ptr->chunkdata + prefix_size),
375 png_free(png_ptr, png_ptr->chunkdata);
376 png_ptr->chunkdata = text;
381 png_warning(png_ptr, "png_inflate logic error");
382 png_free(png_ptr, text);
385 png_warning(png_ptr, "Not enough memory to decompress chunk.");
396 png_warning(png_ptr, umsg);
398 png_warning(png_ptr, "Unknown zTXt compression type");
409 png_charp text = png_malloc_warn(png_ptr, prefix_size + 1);
413 png_memcpy(text, png_ptr->chunkdata, prefix_size);
414 png_free(png_ptr, png_ptr->chunkdata);
415 png_ptr->chunkdata = text;
418 *(png_ptr->chunkdata + prefix_size) = 0x00;
429 png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
438 if (png_ptr->mode & PNG_HAVE_IHDR)
439 png_error(png_ptr, "Out of place IHDR");
443 png_error(png_ptr, "Invalid IHDR chunk");
445 png_ptr->mode |= PNG_HAVE_IHDR;
447 png_crc_read(png_ptr, buf, 13);
448 png_crc_finish(png_ptr, 0);
450 width = png_get_uint_31(png_ptr, buf);
451 height = png_get_uint_31(png_ptr, buf + 4);
459 png_ptr->width = width;
460 png_ptr->height = height;
461 png_ptr->bit_depth = (png_byte)bit_depth;
462 png_ptr->interlaced = (png_byte)interlace_type;
463 png_ptr->color_type = (png_byte)color_type;
465 png_ptr->filter_type = (png_byte)filter_type;
467 png_ptr->compression_type = (png_byte)compression_type;
470 switch (png_ptr->color_type)
474 png_ptr->channels = 1;
478 png_ptr->channels = 3;
482 png_ptr->channels = 2;
486 png_ptr->channels = 4;
491 png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
492 png_ptr->channels);
493 png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
494 png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
495 png_debug1(3, "channels = %d", png_ptr->channels);
496 png_debug1(3, "rowbytes = %lu", png_ptr->rowbytes);
497 png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
503 png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
513 if (!(png_ptr->mode & PNG_HAVE_IHDR))
514 png_error(png_ptr, "Missing IHDR before PLTE");
516 else if (png_ptr->mode & PNG_HAVE_IDAT)
518 png_warning(png_ptr, "Invalid PLTE after IDAT");
519 png_crc_finish(png_ptr, length);
523 else if (png_ptr->mode & PNG_HAVE_PLTE)
524 png_error(png_ptr, "Duplicate PLTE chunk");
526 png_ptr->mode |= PNG_HAVE_PLTE;
528 if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
530 png_warning(png_ptr,
532 png_crc_finish(png_ptr, length);
536 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
538 png_crc_finish(png_ptr, length);
545 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
547 png_warning(png_ptr, "Invalid palette chunk");
548 png_crc_finish(png_ptr, length);
554 png_error(png_ptr, "Invalid palette chunk");
565 png_crc_read(png_ptr, buf, 3);
575 png_crc_read(png_ptr, buf, 3);
589 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
592 png_crc_finish(png_ptr, 0);
595 else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */
601 if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))
603 if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)
605 png_chunk_error(png_ptr, "CRC error");
609 png_chunk_warning(png_ptr, "CRC error");
614 else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))
616 png_chunk_warning(png_ptr, "CRC error");
621 png_set_PLTE(png_ptr, info_ptr, palette, num);
624 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
628 if (png_ptr->num_trans > (png_uint_16)num)
630 png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
631 png_ptr->num_trans = (png_uint_16)num;
635 png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");
645 png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
649 if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
651 png_error(png_ptr, "No image in file");
654 png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
658 png_warning(png_ptr, "Incorrect IEND chunk length");
660 png_crc_finish(png_ptr, length);
667 png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
677 if (!(png_ptr->mode & PNG_HAVE_IHDR))
678 png_error(png_ptr, "Missing IHDR before gAMA");
679 else if (png_ptr->mode & PNG_HAVE_IDAT)
681 png_warning(png_ptr, "Invalid gAMA after IDAT");
682 png_crc_finish(png_ptr, length);
685 else if (png_ptr->mode & PNG_HAVE_PLTE)
687 png_warning(png_ptr, "Out of place gAMA chunk");
695 png_warning(png_ptr, "Duplicate gAMA chunk");
696 png_crc_finish(png_ptr, length);
702 png_warning(png_ptr, "Incorrect gAMA chunk length");
703 png_crc_finish(png_ptr, length);
707 png_crc_read(png_ptr, buf, 4);
708 if (png_crc_finish(png_ptr, 0))
715 png_warning(png_ptr,
724 png_warning(png_ptr,
736 png_ptr->gamma = file_gamma;
738 png_set_gAMA(png_ptr, info_ptr, file_gamma);
741 png_set_gAMA_fixed(png_ptr, info_ptr, igamma);
748 png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
757 if (!(png_ptr->mode & PNG_HAVE_IHDR))
758 png_error(png_ptr, "Missing IHDR before sBIT");
759 else if (png_ptr->mode & PNG_HAVE_IDAT)
761 png_warning(png_ptr, "Invalid sBIT after IDAT");
762 png_crc_finish(png_ptr, length);
765 else if (png_ptr->mode & PNG_HAVE_PLTE)
768 png_warning(png_ptr, "Out of place sBIT chunk");
772 png_warning(png_ptr, "Duplicate sBIT chunk");
773 png_crc_finish(png_ptr, length);
777 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
780 truelen = (png_size_t)png_ptr->channels;
784 png_warning(png_ptr, "Incorrect sBIT chunk length");
785 png_crc_finish(png_ptr, length);
789 png_crc_read(png_ptr, buf, truelen);
790 if (png_crc_finish(png_ptr, 0))
793 if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
795 png_ptr->sig_bit.red = buf[0];
796 png_ptr->sig_bit.green = buf[1];
797 png_ptr->sig_bit.blue = buf[2];
798 png_ptr->sig_bit.alpha = buf[3];
802 png_ptr->sig_bit.gray = buf[0];
803 png_ptr->sig_bit.red = buf[0];
804 png_ptr->sig_bit.green = buf[0];
805 png_ptr->sig_bit.blue = buf[0];
806 png_ptr->sig_bit.alpha = buf[1];
808 png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));
814 png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
827 if (!(png_ptr->mode & PNG_HAVE_IHDR))
828 png_error(png_ptr, "Missing IHDR before cHRM");
829 else if (png_ptr->mode & PNG_HAVE_IDAT)
831 png_warning(png_ptr, "Invalid cHRM after IDAT");
832 png_crc_finish(png_ptr, length);
835 else if (png_ptr->mode & PNG_HAVE_PLTE)
837 png_warning(png_ptr, "Missing PLTE before cHRM");
845 png_warning(png_ptr, "Duplicate cHRM chunk");
846 png_crc_finish(png_ptr, length);
852 png_warning(png_ptr, "Incorrect cHRM chunk length");
853 png_crc_finish(png_ptr, length);
857 png_crc_read(png_ptr, buf, 32);
858 if (png_crc_finish(png_ptr, 0))
904 png_warning(png_ptr,
927 png_set_cHRM(png_ptr, info_ptr,
931 png_set_cHRM_fixed(png_ptr, info_ptr,
940 png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
947 if (!(png_ptr->mode & PNG_HAVE_IHDR))
948 png_error(png_ptr, "Missing IHDR before sRGB");
949 else if (png_ptr->mode & PNG_HAVE_IDAT)
951 png_warning(png_ptr, "Invalid sRGB after IDAT");
952 png_crc_finish(png_ptr, length);
955 else if (png_ptr->mode & PNG_HAVE_PLTE)
957 png_warning(png_ptr, "Out of place sRGB chunk");
961 png_warning(png_ptr, "Duplicate sRGB chunk");
962 png_crc_finish(png_ptr, length);
968 png_warning(png_ptr, "Incorrect sRGB chunk length");
969 png_crc_finish(png_ptr, length);
973 png_crc_read(png_ptr, buf, 1);
974 if (png_crc_finish(png_ptr, 0))
981 png_warning(png_ptr, "Unknown sRGB intent");
998 png_warning(png_ptr,
1003 (int)png_ptr->int_gamma);
1006 fprintf(stderr, "incorrect gamma=%f\n", png_ptr->gamma);
1026 png_warning(png_ptr,
1032 png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);
1038 png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1050 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1051 png_error(png_ptr, "Missing IHDR before iCCP");
1052 else if (png_ptr->mode & PNG_HAVE_IDAT)
1054 png_warning(png_ptr, "Invalid iCCP after IDAT");
1055 png_crc_finish(png_ptr, length);
1058 else if (png_ptr->mode & PNG_HAVE_PLTE)
1060 png_warning(png_ptr, "Out of place iCCP chunk");
1064 png_warning(png_ptr, "Duplicate iCCP chunk");
1065 png_crc_finish(png_ptr, length);
1072 png_warning(png_ptr, "iCCP chunk too large to fit in memory");
1078 png_free(png_ptr, png_ptr->chunkdata);
1079 png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
1081 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1083 if (png_crc_finish(png_ptr, skip))
1085 png_free(png_ptr, png_ptr->chunkdata);
1086 png_ptr->chunkdata = NULL;
1090 png_ptr->chunkdata[slength] = 0x00;
1092 for (profile = png_ptr->chunkdata; *profile; profile++)
1100 if ( profile >= png_ptr->chunkdata + slength - 1)
1102 png_free(png_ptr, png_ptr->chunkdata);
1103 png_ptr->chunkdata = NULL;
1104 png_warning(png_ptr, "Malformed iCCP chunk");
1112 png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");
1117 prefix_length = profile - png_ptr->chunkdata;
1118 png_decompress_chunk(png_ptr, compression_type,
1125 png_free(png_ptr, png_ptr->chunkdata);
1126 png_ptr->chunkdata = NULL;
1127 png_warning(png_ptr, "Profile size field missing from iCCP chunk");
1132 pC = (png_bytep)(png_ptr->chunkdata + prefix_length);
1143 png_free(png_ptr, png_ptr->chunkdata);
1144 png_ptr->chunkdata = NULL;
1145 png_warning(png_ptr, "Ignoring truncated iCCP profile.");
1149 png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata,
1150 compression_type, png_ptr->chunkdata + prefix_length, profile_length);
1151 png_free(png_ptr, png_ptr->chunkdata);
1152 png_ptr->chunkdata = NULL;
1158 png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1174 if (png_ptr->user_chunk_cache_max != 0)
1176 if (png_ptr->user_chunk_cache_max == 1)
1178 png_crc_finish(png_ptr, length);
1181 if (--png_ptr->user_chunk_cache_max == 1)
1183 png_warning(png_ptr, "No space in chunk cache for sPLT");
1184 png_crc_finish(png_ptr, length);
1190 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1191 png_error(png_ptr, "Missing IHDR before sPLT");
1192 else if (png_ptr->mode & PNG_HAVE_IDAT)
1194 png_warning(png_ptr, "Invalid sPLT after IDAT");
1195 png_crc_finish(png_ptr, length);
1202 png_warning(png_ptr, "sPLT chunk too large to fit in memory");
1208 png_free(png_ptr, png_ptr->chunkdata);
1209 png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
1211 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1213 if (png_crc_finish(png_ptr, skip))
1215 png_free(png_ptr, png_ptr->chunkdata);
1216 png_ptr->chunkdata = NULL;
1220 png_ptr->chunkdata[slength] = 0x00;
1222 for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start;
1228 if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)
1230 png_free(png_ptr, png_ptr->chunkdata);
1231 png_ptr->chunkdata = NULL;
1232 png_warning(png_ptr, "malformed sPLT chunk");
1238 data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata));
1243 png_free(png_ptr, png_ptr->chunkdata);
1244 png_ptr->chunkdata = NULL;
1245 png_warning(png_ptr, "sPLT chunk has bad length");
1253 png_warning(png_ptr, "sPLT chunk too long");
1257 png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));
1260 png_warning(png_ptr, "sPLT chunk requires too much memory");
1309 new_palette.name = png_ptr->chunkdata;
1311 png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
1313 png_free(png_ptr, png_ptr->chunkdata);
1314 png_ptr->chunkdata = NULL;
1315 png_free(png_ptr, new_palette.entries);
1321 png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1327 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1328 png_error(png_ptr, "Missing IHDR before tRNS");
1329 else if (png_ptr->mode & PNG_HAVE_IDAT)
1331 png_warning(png_ptr, "Invalid tRNS after IDAT");
1332 png_crc_finish(png_ptr, length);
1337 png_warning(png_ptr, "Duplicate tRNS chunk");
1338 png_crc_finish(png_ptr, length);
1342 if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
1348 png_warning(png_ptr, "Incorrect tRNS chunk length");
1349 png_crc_finish(png_ptr, length);
1353 png_crc_read(png_ptr, buf, 2);
1354 png_ptr->num_trans = 1;
1355 png_ptr->trans_values.gray = png_get_uint_16(buf);
1357 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
1363 png_warning(png_ptr, "Incorrect tRNS chunk length");
1364 png_crc_finish(png_ptr, length);
1367 png_crc_read(png_ptr, buf, (png_size_t)length);
1368 png_ptr->num_trans = 1;
1369 png_ptr->trans_values.red = png_get_uint_16(buf);
1370 png_ptr->trans_values.green = png_get_uint_16(buf + 2);
1371 png_ptr->trans_values.blue = png_get_uint_16(buf + 4);
1373 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1375 if (!(png_ptr->mode & PNG_HAVE_PLTE))
1378 png_warning(png_ptr, "Missing PLTE before tRNS");
1380 if (length > (png_uint_32)png_ptr->num_palette ||
1383 png_warning(png_ptr, "Incorrect tRNS chunk length");
1384 png_crc_finish(png_ptr, length);
1389 png_warning(png_ptr, "Zero length tRNS chunk");
1390 png_crc_finish(png_ptr, length);
1393 png_crc_read(png_ptr, readbuf, (png_size_t)length);
1394 png_ptr->num_trans = (png_uint_16)length;
1398 png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");
1399 png_crc_finish(png_ptr, length);
1403 if (png_crc_finish(png_ptr, 0))
1405 png_ptr->num_trans = 0;
1409 png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,
1410 &(png_ptr->trans_values));
1416 png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1423 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1424 png_error(png_ptr, "Missing IHDR before bKGD");
1425 else if (png_ptr->mode & PNG_HAVE_IDAT)
1427 png_warning(png_ptr, "Invalid bKGD after IDAT");
1428 png_crc_finish(png_ptr, length);
1431 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
1432 !(png_ptr->mode & PNG_HAVE_PLTE))
1434 png_warning(png_ptr, "Missing PLTE before bKGD");
1435 png_crc_finish(png_ptr, length);
1440 png_warning(png_ptr, "Duplicate bKGD chunk");
1441 png_crc_finish(png_ptr, length);
1445 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1447 else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
1454 png_warning(png_ptr, "Incorrect bKGD chunk length");
1455 png_crc_finish(png_ptr, length);
1459 png_crc_read(png_ptr, buf, truelen);
1460 if (png_crc_finish(png_ptr, 0))
1467 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1469 png_ptr->background.index = buf[0];
1474 png_warning(png_ptr, "Incorrect bKGD chunk index value");
1477 png_ptr->background.red =
1478 (png_uint_16)png_ptr->palette[buf[0]].red;
1479 png_ptr->background.green =
1480 (png_uint_16)png_ptr->palette[buf[0]].green;
1481 png_ptr->background.blue =
1482 (png_uint_16)png_ptr->palette[buf[0]].blue;
1485 else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */
1487 png_ptr->background.red =
1488 png_ptr->background.green =
1489 png_ptr->background.blue =
1490 png_ptr->background.gray = png_get_uint_16(buf);
1494 png_ptr->background.red = png_get_uint_16(buf);
1495 png_ptr->background.green = png_get_uint_16(buf + 2);
1496 png_ptr->background.blue = png_get_uint_16(buf + 4);
1499 png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));
1505 png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1512 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1513 png_error(png_ptr, "Missing IHDR before hIST");
1514 else if (png_ptr->mode & PNG_HAVE_IDAT)
1516 png_warning(png_ptr, "Invalid hIST after IDAT");
1517 png_crc_finish(png_ptr, length);
1520 else if (!(png_ptr->mode & PNG_HAVE_PLTE))
1522 png_warning(png_ptr, "Missing PLTE before hIST");
1523 png_crc_finish(png_ptr, length);
1528 png_warning(png_ptr, "Duplicate hIST chunk");
1529 png_crc_finish(png_ptr, length);
1534 length != (unsigned int) (2*png_ptr->num_palette))
1536 png_warning(png_ptr, "Incorrect hIST chunk length");
1537 png_crc_finish(png_ptr, length);
1547 png_crc_read(png_ptr, buf, 2);
1551 if (png_crc_finish(png_ptr, 0))
1554 png_set_hIST(png_ptr, info_ptr, readbuf);
1560 png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1568 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1569 png_error(png_ptr, "Missing IHDR before pHYs");
1570 else if (png_ptr->mode & PNG_HAVE_IDAT)
1572 png_warning(png_ptr, "Invalid pHYs after IDAT");
1573 png_crc_finish(png_ptr, length);
1578 png_warning(png_ptr, "Duplicate pHYs chunk");
1579 png_crc_finish(png_ptr, length);
1585 png_warning(png_ptr, "Incorrect pHYs chunk length");
1586 png_crc_finish(png_ptr, length);
1590 png_crc_read(png_ptr, buf, 9);
1591 if (png_crc_finish(png_ptr, 0))
1597 png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);
1603 png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1611 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1612 png_error(png_ptr, "Missing IHDR before oFFs");
1613 else if (png_ptr->mode & PNG_HAVE_IDAT)
1615 png_warning(png_ptr, "Invalid oFFs after IDAT");
1616 png_crc_finish(png_ptr, length);
1621 png_warning(png_ptr, "Duplicate oFFs chunk");
1622 png_crc_finish(png_ptr, length);
1628 png_warning(png_ptr, "Incorrect oFFs chunk length");
1629 png_crc_finish(png_ptr, length);
1633 png_crc_read(png_ptr, buf, 9);
1634 if (png_crc_finish(png_ptr, 0))
1640 png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);
1647 png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1658 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1659 png_error(png_ptr, "Missing IHDR before pCAL");
1660 else if (png_ptr->mode & PNG_HAVE_IDAT)
1662 png_warning(png_ptr, "Invalid pCAL after IDAT");
1663 png_crc_finish(png_ptr, length);
1668 png_warning(png_ptr, "Duplicate pCAL chunk");
1669 png_crc_finish(png_ptr, length);
1675 png_free(png_ptr, png_ptr->chunkdata);
1676 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
1677 if (png_ptr->chunkdata == NULL)
1679 png_warning(png_ptr, "No memory for pCAL purpose.");
1683 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1685 if (png_crc_finish(png_ptr, 0))
1687 png_free(png_ptr, png_ptr->chunkdata);
1688 png_ptr->chunkdata = NULL;
1692 png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
1695 for (buf = png_ptr->chunkdata; *buf; buf++)
1698 endptr = png_ptr->chunkdata + slength;
1704 png_warning(png_ptr, "Invalid pCAL data");
1705 png_free(png_ptr, png_ptr->chunkdata);
1706 png_ptr->chunkdata = NULL;
1725 png_warning(png_ptr, "Invalid pCAL parameters for equation type");
1726 png_free(png_ptr, png_ptr->chunkdata);
1727 png_ptr->chunkdata = NULL;
1732 png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
1739 params = (png_charpp)png_malloc_warn(png_ptr,
1743 png_free(png_ptr, png_ptr->chunkdata);
1744 png_ptr->chunkdata = NULL;
1745 png_warning(png_ptr, "No memory for pCAL params.");
1761 png_warning(png_ptr, "Invalid pCAL data");
1762 png_free(png_ptr, png_ptr->chunkdata);
1763 png_ptr->chunkdata = NULL;
1764 png_free(png_ptr, params);
1769 png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams,
1772 png_free(png_ptr, png_ptr->chunkdata);
1773 png_ptr->chunkdata = NULL;
1774 png_free(png_ptr, params);
1781 png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1796 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1797 png_error(png_ptr, "Missing IHDR before sCAL");
1798 else if (png_ptr->mode & PNG_HAVE_IDAT)
1800 png_warning(png_ptr, "Invalid sCAL after IDAT");
1801 png_crc_finish(png_ptr, length);
1806 png_warning(png_ptr, "Duplicate sCAL chunk");
1807 png_crc_finish(png_ptr, length);
1814 png_warning(png_ptr, "sCAL chunk too short");
1815 png_crc_finish(png_ptr, length);
1821 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
1822 if (png_ptr->chunkdata == NULL)
1824 png_warning(png_ptr, "Out of memory while processing sCAL chunk");
1825 png_crc_finish(png_ptr, length);
1829 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1831 if (png_crc_finish(png_ptr, 0))
1833 png_free(png_ptr, png_ptr->chunkdata);
1834 png_ptr->chunkdata = NULL;
1838 png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
1840 ep = png_ptr->chunkdata + 1; /* Skip unit byte */
1843 width = png_strtod(png_ptr, ep, &vp);
1846 png_warning(png_ptr, "malformed width string in sCAL chunk");
1847 png_free(png_ptr, png_ptr->chunkdata);
1848 png_ptr->chunkdata = NULL;
1853 swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
1856 png_warning(png_ptr, "Out of memory while processing sCAL chunk width");
1857 png_free(png_ptr, png_ptr->chunkdata);
1858 png_ptr->chunkdata = NULL;
1865 for (ep = png_ptr->chunkdata + 1; *ep; ep++)
1869 if (png_ptr->chunkdata + slength < ep)
1871 png_warning(png_ptr, "Truncated sCAL chunk");
1873 png_free(png_ptr, swidth);
1875 png_free(png_ptr, png_ptr->chunkdata);
1876 png_ptr->chunkdata = NULL;
1881 height = png_strtod(png_ptr, ep, &vp);
1884 png_warning(png_ptr, "malformed height string in sCAL chunk");
1885 png_free(png_ptr, png_ptr->chunkdata);
1886 png_ptr->chunkdata = NULL;
1888 png_free(png_ptr, swidth);
1894 sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
1897 png_warning(png_ptr, "Out of memory while processing sCAL chunk height");
1898 png_free(png_ptr, png_ptr->chunkdata);
1899 png_ptr->chunkdata = NULL;
1901 png_free(png_ptr, swidth);
1909 if (png_ptr->chunkdata + slength < ep
1915 png_warning(png_ptr, "Invalid sCAL data");
1916 png_free(png_ptr, png_ptr->chunkdata);
1917 png_ptr->chunkdata = NULL;
1919 png_free(png_ptr, swidth);
1920 png_free(png_ptr, sheight);
1927 png_set_sCAL(png_ptr, info_ptr, png_ptr->chunkdata[0], width, height);
1930 png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], swidth, sheight);
1934 png_free(png_ptr, png_ptr->chunkdata);
1935 png_ptr->chunkdata = NULL;
1937 png_free(png_ptr, swidth);
1938 png_free(png_ptr, sheight);
1945 png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1952 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1953 png_error(png_ptr, "Out of place tIME chunk");
1956 png_warning(png_ptr, "Duplicate tIME chunk");
1957 png_crc_finish(png_ptr, length);
1961 if (png_ptr->mode & PNG_HAVE_IDAT)
1962 png_ptr->mode |= PNG_AFTER_IDAT;
1966 png_warning(png_ptr, "Incorrect tIME chunk length");
1967 png_crc_finish(png_ptr, length);
1971 png_crc_read(png_ptr, buf, 7);
1972 if (png_crc_finish(png_ptr, 0))
1982 png_set_tIME(png_ptr, info_ptr, &mod_time);
1989 png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2001 if (png_ptr->user_chunk_cache_max != 0)
2003 if (png_ptr->user_chunk_cache_max == 1)
2005 png_crc_finish(png_ptr, length);
2008 if (--png_ptr->user_chunk_cache_max == 1)
2010 png_warning(png_ptr, "No space in chunk cache for tEXt");
2011 png_crc_finish(png_ptr, length);
2017 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2018 png_error(png_ptr, "Missing IHDR before tEXt");
2020 if (png_ptr->mode & PNG_HAVE_IDAT)
2021 png_ptr->mode |= PNG_AFTER_IDAT;
2026 png_warning(png_ptr, "tEXt chunk too large to fit in memory");
2032 png_free(png_ptr, png_ptr->chunkdata);
2034 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2035 if (png_ptr->chunkdata == NULL)
2037 png_warning(png_ptr, "No memory to process text chunk.");
2041 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2043 if (png_crc_finish(png_ptr, skip))
2045 png_free(png_ptr, png_ptr->chunkdata);
2046 png_ptr->chunkdata = NULL;
2050 key = png_ptr->chunkdata;
2060 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2064 png_warning(png_ptr, "Not enough memory to process text chunk.");
2065 png_free(png_ptr, png_ptr->chunkdata);
2066 png_ptr->chunkdata = NULL;
2079 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2081 png_free(png_ptr, png_ptr->chunkdata);
2082 png_ptr->chunkdata = NULL;
2083 png_free(png_ptr, text_ptr);
2085 png_warning(png_ptr, "Insufficient memory to process text chunk.");
2092 png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2103 if (png_ptr->user_chunk_cache_max != 0)
2105 if (png_ptr->user_chunk_cache_max == 1)
2107 png_crc_finish(png_ptr, length);
2110 if (--png_ptr->user_chunk_cache_max == 1)
2112 png_warning(png_ptr, "No space in chunk cache for zTXt");
2113 png_crc_finish(png_ptr, length);
2119 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2120 png_error(png_ptr, "Missing IHDR before zTXt");
2122 if (png_ptr->mode & PNG_HAVE_IDAT)
2123 png_ptr->mode |= PNG_AFTER_IDAT;
2130 png_warning(png_ptr, "zTXt chunk too large to fit in memory");
2131 png_crc_finish(png_ptr, length);
2136 png_free(png_ptr, png_ptr->chunkdata);
2137 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2138 if (png_ptr->chunkdata == NULL)
2140 png_warning(png_ptr, "Out of memory processing zTXt chunk.");
2144 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2145 if (png_crc_finish(png_ptr, 0))
2147 png_free(png_ptr, png_ptr->chunkdata);
2148 png_ptr->chunkdata = NULL;
2152 png_ptr->chunkdata[slength] = 0x00;
2154 for (text = png_ptr->chunkdata; *text; text++)
2158 if (text >= png_ptr->chunkdata + slength - 2)
2160 png_warning(png_ptr, "Truncated zTXt chunk");
2161 png_free(png_ptr, png_ptr->chunkdata);
2162 png_ptr->chunkdata = NULL;
2170 png_warning(png_ptr, "Unknown compression type in zTXt chunk");
2175 prefix_len = text - png_ptr->chunkdata;
2177 png_decompress_chunk(png_ptr, comp_type,
2180 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2184 png_warning(png_ptr, "Not enough memory to process zTXt chunk.");
2185 png_free(png_ptr, png_ptr->chunkdata);
2186 png_ptr->chunkdata = NULL;
2190 text_ptr->key = png_ptr->chunkdata;
2196 text_ptr->text = png_ptr->chunkdata + prefix_len;
2199 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2201 png_free(png_ptr, text_ptr);
2202 png_free(png_ptr, png_ptr->chunkdata);
2203 png_ptr->chunkdata = NULL;
2205 png_error(png_ptr, "Insufficient memory to store zTXt chunk.");
2212 png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2224 if (png_ptr->user_chunk_cache_max != 0)
2226 if (png_ptr->user_chunk_cache_max == 1)
2228 png_crc_finish(png_ptr, length);
2231 if (--png_ptr->user_chunk_cache_max == 1)
2233 png_warning(png_ptr, "No space in chunk cache for iTXt");
2234 png_crc_finish(png_ptr, length);
2240 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2241 png_error(png_ptr, "Missing IHDR before iTXt");
2243 if (png_ptr->mode & PNG_HAVE_IDAT)
2244 png_ptr->mode |= PNG_AFTER_IDAT;
2251 png_warning(png_ptr, "iTXt chunk too large to fit in memory");
2252 png_crc_finish(png_ptr, length);
2257 png_free(png_ptr, png_ptr->chunkdata);
2258 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2259 if (png_ptr->chunkdata == NULL)
2261 png_warning(png_ptr, "No memory to process iTXt chunk.");
2265 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2266 if (png_crc_finish(png_ptr, 0))
2268 png_free(png_ptr, png_ptr->chunkdata);
2269 png_ptr->chunkdata = NULL;
2273 png_ptr->chunkdata[slength] = 0x00;
2275 for (lang = png_ptr->chunkdata; *lang; lang++)
2284 if (lang >= png_ptr->chunkdata + slength - 3)
2286 png_warning(png_ptr, "Truncated iTXt chunk");
2287 png_free(png_ptr, png_ptr->chunkdata);
2288 png_ptr->chunkdata = NULL;
2301 if (lang_key >= png_ptr->chunkdata + slength)
2303 png_warning(png_ptr, "Truncated iTXt chunk");
2304 png_free(png_ptr, png_ptr->chunkdata);
2305 png_ptr->chunkdata = NULL;
2312 if (text >= png_ptr->chunkdata + slength)
2314 png_warning(png_ptr, "Malformed iTXt chunk");
2315 png_free(png_ptr, png_ptr->chunkdata);
2316 png_ptr->chunkdata = NULL;
2320 prefix_len = text - png_ptr->chunkdata;
2322 key=png_ptr->chunkdata;
2324 png_decompress_chunk(png_ptr, comp_type,
2327 data_len = png_strlen(png_ptr->chunkdata + prefix_len);
2328 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2332 png_warning(png_ptr, "Not enough memory to process iTXt chunk.");
2333 png_free(png_ptr, png_ptr->chunkdata);
2334 png_ptr->chunkdata = NULL;
2338 text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key);
2339 text_ptr->lang = png_ptr->chunkdata + (lang - key);
2342 text_ptr->key = png_ptr->chunkdata;
2343 text_ptr->text = png_ptr->chunkdata + prefix_len;
2345 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2347 png_free(png_ptr, text_ptr);
2348 png_free(png_ptr, png_ptr->chunkdata);
2349 png_ptr->chunkdata = NULL;
2351 png_error(png_ptr, "Insufficient memory to store iTXt chunk.");
2361 png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2368 if (png_ptr->user_chunk_cache_max != 0)
2370 if (png_ptr->user_chunk_cache_max == 1)
2372 png_crc_finish(png_ptr, length);
2375 if (--png_ptr->user_chunk_cache_max == 1)
2377 png_warning(png_ptr, "No space in chunk cache for unknown chunk");
2378 png_crc_finish(png_ptr, length);
2384 if (png_ptr->mode & PNG_HAVE_IDAT)
2389 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* Not an IDAT */
2390 png_ptr->mode |= PNG_AFTER_IDAT;
2393 if (!(png_ptr->chunk_name[0] & 0x20))
2396 if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
2399 && png_ptr->read_user_chunk_fn == NULL
2403 png_chunk_error(png_ptr, "unknown critical chunk");
2407 if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
2409 || (png_ptr->read_user_chunk_fn != NULL)
2416 png_warning(png_ptr, "unknown chunk too large to fit in memory");
2421 png_memcpy((png_charp)png_ptr->unknown_chunk.name,
2422 (png_charp)png_ptr->chunk_name,
2423 png_sizeof(png_ptr->unknown_chunk.name));
2424 png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1]
2426 png_ptr->unknown_chunk.size = (png_size_t)length;
2428 png_ptr->unknown_chunk.data = NULL;
2431 png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);
2432 png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
2435 if (png_ptr->read_user_chunk_fn != NULL)
2439 ret = (*(png_ptr->read_user_chunk_fn))
2440 (png_ptr, &png_ptr->unknown_chunk);
2442 png_chunk_error(png_ptr, "error in user chunk");
2445 if (!(png_ptr->chunk_name[0] & 0x20))
2447 if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
2450 png_chunk_error(png_ptr, "unknown critical chunk");
2451 png_set_unknown_chunks(png_ptr, info_ptr,
2452 &png_ptr->unknown_chunk, 1);
2457 png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
2458 png_free(png_ptr, png_ptr->unknown_chunk.data);
2459 png_ptr->unknown_chunk.data = NULL;
2465 png_crc_finish(png_ptr, skip);
2481 png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
2487 png_chunk_error(png_ptr, "invalid chunk type");
2503 png_combine_row(png_structp png_ptr, png_bytep row, int mask)
2508 png_memcpy(row, png_ptr->row_buf + 1,
2509 PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));
2513 switch (png_ptr->row_info.pixel_depth)
2517 png_bytep sp = png_ptr->row_buf + 1;
2523 png_uint_32 row_width = png_ptr->width;
2526 if (png_ptr->transformations & PNG_PACKSWAP)
2571 png_bytep sp = png_ptr->row_buf + 1;
2577 png_uint_32 row_width = png_ptr->width;
2581 if (png_ptr->transformations & PNG_PACKSWAP)
2623 png_bytep sp = png_ptr->row_buf + 1;
2629 png_uint_32 row_width = png_ptr->width;
2633 if (png_ptr->transformations & PNG_PACKSWAP)
2674 png_bytep sp = png_ptr->row_buf + 1;
2676 png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
2678 png_uint_32 row_width = png_ptr->width;
2709 png_do_read_interlace(png_structp png_ptr)
2711 png_row_infop row_info = &(png_ptr->row_info);
2712 png_bytep row = png_ptr->row_buf + 1;
2713 int pass = png_ptr->pass;
2714 png_uint_32 transformations = png_ptr->transformations;
2930 png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
2934 png_debug2(2, "row = %lu, filter = %d", png_ptr->row_number, filter);
3046 png_warning(png_ptr, "Ignoring bad adaptive filter type");
3054 png_read_finish_row(png_structp png_ptr)
3073 png_ptr->row_number++;
3074 if (png_ptr->row_number < png_ptr->num_rows)
3078 if (png_ptr->interlaced)
3080 png_ptr->row_number = 0;
3081 png_memset_check(png_ptr, png_ptr->prev_row, 0,
3082 png_ptr->rowbytes + 1);
3085 png_ptr->pass++;
3086 if (png_ptr->pass >= 7)
3088 png_ptr->iwidth = (png_ptr->width +
3089 png_pass_inc[png_ptr->pass] - 1 -
3090 png_pass_start[png_ptr->pass]) /
3091 png_pass_inc[png_ptr->pass];
3093 if (!(png_ptr->transformations & PNG_INTERLACE))
3095 png_ptr->num_rows = (png_ptr->height +
3096 png_pass_yinc[png_ptr->pass] - 1 -
3097 png_pass_ystart[png_ptr->pass]) /
3098 png_pass_yinc[png_ptr->pass];
3099 if (!(png_ptr->num_rows))
3102 else /* if (png_ptr->transformations & PNG_INTERLACE) */
3104 } while (png_ptr->iwidth == 0);
3106 if (png_ptr->pass < 7)
3111 if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
3119 png_ptr->zstream.next_out = (Byte *)&extra;
3120 png_ptr->zstream.avail_out = (uInt)1;
3123 if (!(png_ptr->zstream.avail_in))
3125 while (!png_ptr->idat_size)
3129 png_crc_finish(png_ptr, 0);
3131 png_read_data(png_ptr, chunk_length, 4);
3132 png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length);
3133 png_reset_crc(png_ptr);
3134 png_crc_read(png_ptr, png_ptr->chunk_name, 4);
3135 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
3136 png_error(png_ptr, "Not enough image data");
3139 png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
3140 png_ptr->zstream.next_in = png_ptr->zbuf;
3141 if (png_ptr->zbuf_size > png_ptr->idat_size)
3142 png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
3143 png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);
3144 png_ptr->idat_size -= png_ptr->zstream.avail_in;
3146 ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
3149 if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||
3150 png_ptr->idat_size)
3151 png_warning(png_ptr, "Extra compressed data.");
3152 png_ptr->mode |= PNG_AFTER_IDAT;
3153 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
3157 png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
3160 if (!(png_ptr->zstream.avail_out))
3162 png_warning(png_ptr, "Extra compressed data.");
3163 png_ptr->mode |= PNG_AFTER_IDAT;
3164 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
3169 png_ptr->zstream.avail_out = 0;
3172 if (png_ptr->idat_size || png_ptr->zstream.avail_in)
3173 png_warning(png_ptr, "Extra compression data.");
3175 inflateReset(&png_ptr->zstream);
3177 png_ptr->mode |= PNG_AFTER_IDAT;
3182 png_read_start_row(png_structp png_ptr)
3204 png_ptr->zstream.avail_in = 0;
3205 png_init_read_transformations(png_ptr);
3207 if (png_ptr->interlaced)
3209 if (!(png_ptr->transformations & PNG_INTERLACE))
3210 png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
3213 png_ptr->num_rows = png_ptr->height;
3215 png_ptr->iwidth = (png_ptr->width +
3216 png_pass_inc[png_ptr->pass] - 1 -
3217 png_pass_start[png_ptr->pass]) /
3218 png_pass_inc[png_ptr->pass];
3223 png_ptr->num_rows = png_ptr->height;
3224 png_ptr->iwidth = png_ptr->width;
3226 max_pixel_depth = png_ptr->pixel_depth;
3229 if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
3234 if (png_ptr->transformations & PNG_EXPAND)
3236 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
3238 if (png_ptr->num_trans)
3243 else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
3247 if (png_ptr->num_trans)
3250 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
3252 if (png_ptr->num_trans)
3262 if (png_ptr->transformations & (PNG_FILLER))
3264 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
3266 else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
3273 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
3284 if (png_ptr->transformations & PNG_GRAY_TO_RGB)
3288 (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
3291 (png_ptr->transformations & (PNG_FILLER)) ||
3293 png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
3304 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
3309 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
3319 if (png_ptr->transformations & PNG_USER_TRANSFORM)
3321 int user_pixel_depth = png_ptr->user_transform_depth*
3322 png_ptr->user_transform_channels;
3331 row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
3339 png_error(png_ptr, "This image requires a row greater than 64KB");
3342 if (row_bytes + 64 > png_ptr->old_big_row_buf_size)
3344 png_free(png_ptr, png_ptr->big_row_buf);
3345 if (png_ptr->interlaced)
3346 png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,
3349 png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr,
3351 png_ptr->old_big_row_buf_size = row_bytes + 64;
3354 png_ptr->row_buf = png_ptr->big_row_buf + 32;
3355 png_ptr->old_big_row_buf_size = row_bytes + 64;
3360 png_error(png_ptr, "This image requires a row greater than 64KB");
3363 png_error(png_ptr, "Row has too many bytes to allocate in memory.");
3365 if (row_bytes + 1 > png_ptr->old_prev_row_size)
3367 png_free(png_ptr, png_ptr->prev_row);
3368 png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(
3370 png_memset_check(png_ptr, png_ptr->prev_row, 0, row_bytes + 1);
3371 png_ptr->old_prev_row_size = row_bytes + 1;
3374 png_ptr->rowbytes = row_bytes;
3376 png_debug1(3, "width = %lu,", png_ptr->width);
3377 png_debug1(3, "height = %lu,", png_ptr->height);
3378 png_debug1(3, "iwidth = %lu,", png_ptr->iwidth);
3379 png_debug1(3, "num_rows = %lu,", png_ptr->num_rows);
3380 png_debug1(3, "rowbytes = %lu,", png_ptr->rowbytes);
3382 PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1);
3384 png_ptr->flags |= PNG_FLAG_ROW_INIT;