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);
154 png_opt_crc_finish(png_structp png_ptr, png_uint_32 skip, int check_crc)
157 png_size_t istop = png_ptr->zbuf_size;
161 png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
165 png_crc_read(png_ptr, png_ptr->zbuf, i);
168 if (png_crc_error(png_ptr))
171 png_chunk_warning(png_ptr, "CRC error");
174 if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */
175 !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||
176 (!(png_ptr->chunk_name[0] & 0x20) && /* Critical */
177 (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))
179 png_chunk_warning(png_ptr, "CRC error");
183 png_chunk_error(png_ptr, "CRC error");
198 png_crc_finish(png_structp png_ptr, png_uint_32 skip)
200 return png_opt_crc_finish(png_ptr, skip, 1);
207 png_crc_error(png_structp png_ptr)
213 if (png_ptr->chunk_name[0] & 0x20) /* ancillary */
215 if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
221 if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
225 png_read_data(png_ptr, crc_bytes, 4);
230 return ((int)(crc != png_ptr->crc));
239 png_inflate(png_structp png_ptr, const png_byte *data, png_size_t size,
244 png_ptr->zstream.next_in = (png_bytep)data; /* const_cast: VALID */
245 png_ptr->zstream.avail_in = size;
254 png_ptr->zstream.next_out = png_ptr->zbuf;
255 png_ptr->zstream.avail_out = png_ptr->zbuf_size;
257 ret = inflate(&png_ptr->zstream, Z_NO_FLUSH);
258 avail = png_ptr->zbuf_size - png_ptr->zstream.avail_out;
269 png_memcpy(output + count, png_ptr->zbuf, copy);
280 png_ptr->zstream.avail_in = 0;
281 inflateReset(&png_ptr->zstream);
292 if (png_ptr->zstream.msg != 0)
293 msg = png_ptr->zstream.msg;
312 png_snprintf(umsg, sizeof umsg, msg, png_ptr->chunk_name);
319 png_warning(png_ptr, msg);
337 png_decompress_chunk(png_structp png_ptr, int comp_type,
345 png_warning(png_ptr, "invalid chunklength");
351 png_size_t expanded_size = png_inflate(png_ptr,
352 (png_bytep)(png_ptr->chunkdata + prefix_size),
360 if (png_ptr->user_chunk_malloc_max &&
361 (prefix_size + expanded_size >= png_ptr->user_chunk_malloc_max - 1))
368 png_warning(png_ptr, "Exceeded size limit while expanding chunk");
389 text = png_malloc_warn(png_ptr, prefix_size + expanded_size + 1);
394 png_memcpy(text, png_ptr->chunkdata, prefix_size);
395 new_size = png_inflate(png_ptr,
396 (png_bytep)(png_ptr->chunkdata + prefix_size),
403 png_free(png_ptr, png_ptr->chunkdata);
404 png_ptr->chunkdata = text;
409 png_warning(png_ptr, "png_inflate logic error");
410 png_free(png_ptr, text);
413 png_warning(png_ptr, "Not enough memory to decompress chunk.");
424 png_warning(png_ptr, umsg);
426 png_warning(png_ptr, "Unknown zTXt compression type");
437 png_charp text = png_malloc_warn(png_ptr, prefix_size + 1);
441 png_memcpy(text, png_ptr->chunkdata, prefix_size);
442 png_free(png_ptr, png_ptr->chunkdata);
443 png_ptr->chunkdata = text;
446 *(png_ptr->chunkdata + prefix_size) = 0x00;
457 png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
466 if (png_ptr->mode & PNG_HAVE_IHDR)
467 png_error(png_ptr, "Out of place IHDR");
471 png_error(png_ptr, "Invalid IHDR chunk");
473 png_ptr->mode |= PNG_HAVE_IHDR;
475 png_crc_read(png_ptr, buf, 13);
476 png_crc_finish(png_ptr, 0);
478 width = png_get_uint_31(png_ptr, buf);
479 height = png_get_uint_31(png_ptr, buf + 4);
487 png_ptr->width = width;
488 png_ptr->height = height;
489 png_ptr->bit_depth = (png_byte)bit_depth;
490 png_ptr->interlaced = (png_byte)interlace_type;
491 png_ptr->color_type = (png_byte)color_type;
493 png_ptr->filter_type = (png_byte)filter_type;
495 png_ptr->compression_type = (png_byte)compression_type;
498 switch (png_ptr->color_type)
502 png_ptr->channels = 1;
506 png_ptr->channels = 3;
510 png_ptr->channels = 2;
514 png_ptr->channels = 4;
519 png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
520 png_ptr->channels);
521 png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
522 png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
523 png_debug1(3, "channels = %d", png_ptr->channels);
524 png_debug1(3, "rowbytes = %lu", png_ptr->rowbytes);
525 png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
531 png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
541 if (!(png_ptr->mode & PNG_HAVE_IHDR))
542 png_error(png_ptr, "Missing IHDR before PLTE");
544 else if (png_ptr->mode & PNG_HAVE_IDAT)
546 png_warning(png_ptr, "Invalid PLTE after IDAT");
547 png_ptr, length);
551 else if (png_ptr->mode & PNG_HAVE_PLTE)
552 png_error(png_ptr, "Duplicate PLTE chunk");
554 png_ptr->mode |= PNG_HAVE_PLTE;
556 if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
558 png_warning(png_ptr,
560 png_crc_finish(png_ptr, length);
564 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
566 png_crc_finish(png_ptr, length);
573 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
575 png_warning(png_ptr, "Invalid palette chunk");
576 png_crc_finish(png_ptr, length);
582 png_error(png_ptr, "Invalid palette chunk");
593 png_crc_read(png_ptr, buf, 3);
603 png_crc_read(png_ptr, buf, 3);
617 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
620 png_crc_finish(png_ptr, 0);
623 else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */
629 if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))
631 if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)
633 png_chunk_error(png_ptr, "CRC error");
637 png_chunk_warning(png_ptr, "CRC error");
642 else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))
644 png_chunk_warning(png_ptr, "CRC error");
649 png_set_PLTE(png_ptr, info_ptr, palette, num);
652 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
656 if (png_ptr->num_trans > (png_uint_16)num)
658 png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
659 png_ptr->num_trans = (png_uint_16)num;
663 png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");
673 png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
677 if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
679 png_error(png_ptr, "No image in file");
682 png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
686 png_warning(png_ptr, "Incorrect IEND chunk length");
688 png_crc_finish(png_ptr, length);
695 png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
705 if (!(png_ptr->mode & PNG_HAVE_IHDR))
706 png_error(png_ptr, "Missing IHDR before gAMA");
707 else if (png_ptr->mode & PNG_HAVE_IDAT)
709 png_warning(png_ptr, "Invalid gAMA after IDAT");
710 png_crc_finish(png_ptr, length);
713 else if (png_ptr->mode & PNG_HAVE_PLTE)
715 png_warning(png_ptr, "Out of place gAMA chunk");
723 png_warning(png_ptr, "Duplicate gAMA chunk");
724 png_crc_finish(png_ptr, length);
730 png_warning(png_ptr, "Incorrect gAMA chunk length");
731 png_crc_finish(png_ptr, length);
735 png_crc_read(png_ptr, buf, 4);
736 if (png_crc_finish(png_ptr, 0))
743 png_warning(png_ptr,
752 png_warning(png_ptr,
764 png_ptr->gamma = file_gamma;
766 png_set_gAMA(png_ptr, info_ptr, file_gamma);
769 png_set_gAMA_fixed(png_ptr, info_ptr, igamma);
776 png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
785 if (!(png_ptr->mode & PNG_HAVE_IHDR))
786 png_error(png_ptr, "Missing IHDR before sBIT");
787 else if (png_ptr->mode & PNG_HAVE_IDAT)
789 png_warning(png_ptr, "Invalid sBIT after IDAT");
790 png_crc_finish(png_ptr, length);
793 else if (png_ptr->mode & PNG_HAVE_PLTE)
796 png_warning(png_ptr, "Out of place sBIT chunk");
800 png_warning(png_ptr, "Duplicate sBIT chunk");
801 png_crc_finish(png_ptr, length);
805 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
808 truelen = (png_size_t)png_ptr->channels;
812 png_warning(png_ptr, "Incorrect sBIT chunk length");
813 png_crc_finish(png_ptr, length);
817 png_crc_read(png_ptr, buf, truelen);
818 if (png_crc_finish(png_ptr, 0))
821 if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
823 png_ptr->sig_bit.red = buf[0];
824 png_ptr->sig_bit.green = buf[1];
825 png_ptr->sig_bit.blue = buf[2];
826 png_ptr->sig_bit.alpha = buf[3];
830 png_ptr->sig_bit.gray = buf[0];
831 png_ptr->sig_bit.red = buf[0];
832 png_ptr->sig_bit.green = buf[0];
833 png_ptr->sig_bit.blue = buf[0];
834 png_ptr->sig_bit.alpha = buf[1];
836 png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));
842 png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
855 if (!(png_ptr->mode & PNG_HAVE_IHDR))
856 png_error(png_ptr, "Missing IHDR before cHRM");
857 else if (png_ptr->mode & PNG_HAVE_IDAT)
859 png_warning(png_ptr, "Invalid cHRM after IDAT");
860 png_crc_finish(png_ptr, length);
863 else if (png_ptr->mode & PNG_HAVE_PLTE)
865 png_warning(png_ptr, "Missing PLTE before cHRM");
873 png_warning(png_ptr, "Duplicate cHRM chunk");
874 png_crc_finish(png_ptr, length);
880 png_warning(png_ptr, "Incorrect cHRM chunk length");
881 png_crc_finish(png_ptr, length);
885 png_crc_read(png_ptr, buf, 32);
886 if (png_crc_finish(png_ptr, 0))
932 png_warning(png_ptr,
955 png_set_cHRM(png_ptr, info_ptr,
959 png_set_cHRM_fixed(png_ptr, info_ptr,
968 png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
975 if (!(png_ptr->mode & PNG_HAVE_IHDR))
976 png_error(png_ptr, "Missing IHDR before sRGB");
977 else if (png_ptr->mode & PNG_HAVE_IDAT)
979 png_warning(png_ptr, "Invalid sRGB after IDAT");
980 png_crc_finish(png_ptr, length);
983 else if (png_ptr->mode & PNG_HAVE_PLTE)
985 png_warning(png_ptr, "Out of place sRGB chunk");
989 png_warning(png_ptr, "Duplicate sRGB chunk");
990 png_crc_finish(png_ptr, length);
996 png_warning(png_ptr, "Incorrect sRGB chunk length");
997 png_crc_finish(png_ptr, length);
1001 png_crc_read(png_ptr, buf, 1);
1002 if (png_crc_finish(png_ptr, 0))
1009 png_warning(png_ptr, "Unknown sRGB intent");
1026 png_warning(png_ptr,
1031 (int)png_ptr->int_gamma);
1034 fprintf(stderr, "incorrect gamma=%f\n", png_ptr->gamma);
1054 png_warning(png_ptr,
1060 png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);
1066 png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1078 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1079 png_error(png_ptr, "Missing IHDR before iCCP");
1080 else if (png_ptr->mode & PNG_HAVE_IDAT)
1082 png_warning(png_ptr, "Invalid iCCP after IDAT");
1083 png_crc_finish(png_ptr, length);
1086 else if (png_ptr->mode & PNG_HAVE_PLTE)
1088 png_warning(png_ptr, "Out of place iCCP chunk");
1092 png_warning(png_ptr, "Duplicate iCCP chunk");
1093 png_crc_finish(png_ptr, length);
1100 png_warning(png_ptr, "iCCP chunk too large to fit in memory");
1106 png_free(png_ptr, png_ptr->chunkdata);
1107 png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
1109 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1111 if (png_crc_finish(png_ptr, skip))
1113 png_free(png_ptr, png_ptr->chunkdata);
1114 png_ptr->chunkdata = NULL;
1118 png_ptr->chunkdata[slength] = 0x00;
1120 for (profile = png_ptr->chunkdata; *profile; profile++)
1128 if ( profile >= png_ptr->chunkdata + slength - 1)
1130 png_free(png_ptr, png_ptr->chunkdata);
1131 png_ptr->chunkdata = NULL;
1132 png_warning(png_ptr, "Malformed iCCP chunk");
1140 png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");
1145 prefix_length = profile - png_ptr->chunkdata;
1146 png_decompress_chunk(png_ptr, compression_type,
1153 png_free(png_ptr, png_ptr->chunkdata);
1154 png_ptr->chunkdata = NULL;
1155 png_warning(png_ptr, "Profile size field missing from iCCP chunk");
1160 pC = (png_bytep)(png_ptr->chunkdata + prefix_length);
1171 png_free(png_ptr, png_ptr->chunkdata);
1172 png_ptr->chunkdata = NULL;
1173 png_warning(png_ptr, "Ignoring truncated iCCP profile.");
1177 png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata,
1178 compression_type, png_ptr->chunkdata + prefix_length, profile_length);
1179 png_free(png_ptr, png_ptr->chunkdata);
1180 png_ptr->chunkdata = NULL;
1186 png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1202 if (png_ptr->user_chunk_cache_max != 0)
1204 if (png_ptr->user_chunk_cache_max == 1)
1206 png_crc_finish(png_ptr, length);
1209 if (--png_ptr->user_chunk_cache_max == 1)
1211 png_warning(png_ptr, "No space in chunk cache for sPLT");
1212 png_crc_finish(png_ptr, length);
1218 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1219 png_error(png_ptr, "Missing IHDR before sPLT");
1220 else if (png_ptr->mode & PNG_HAVE_IDAT)
1222 png_warning(png_ptr, "Invalid sPLT after IDAT");
1223 png_crc_finish(png_ptr, length);
1230 png_warning(png_ptr, "sPLT chunk too large to fit in memory");
1236 png_free(png_ptr, png_ptr->chunkdata);
1237 png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
1239 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1241 if (png_crc_finish(png_ptr, skip))
1243 png_free(png_ptr, png_ptr->chunkdata);
1244 png_ptr->chunkdata = NULL;
1248 png_ptr->chunkdata[slength] = 0x00;
1250 for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start;
1256 if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)
1258 png_free(png_ptr, png_ptr->chunkdata);
1259 png_ptr->chunkdata = NULL;
1260 png_warning(png_ptr, "malformed sPLT chunk");
1266 data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata));
1271 png_free(png_ptr, png_ptr->chunkdata);
1272 png_ptr->chunkdata = NULL;
1273 png_warning(png_ptr, "sPLT chunk has bad length");
1281 png_warning(png_ptr, "sPLT chunk too long");
1285 png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));
1288 png_warning(png_ptr, "sPLT chunk requires too much memory");
1337 new_palette.name = png_ptr->chunkdata;
1339 png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
1341 png_free(png_ptr, png_ptr->chunkdata);
1342 png_ptr->chunkdata = NULL;
1343 png_free(png_ptr, new_palette.entries);
1349 png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1355 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1356 png_error(png_ptr, "Missing IHDR before tRNS");
1357 else if (png_ptr->mode & PNG_HAVE_IDAT)
1359 png_warning(png_ptr, "Invalid tRNS after IDAT");
1360 png_crc_finish(png_ptr, length);
1365 png_warning(png_ptr, "Duplicate tRNS chunk");
1366 png_crc_finish(png_ptr, length);
1370 if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
1376 png_warning(png_ptr, "Incorrect tRNS chunk length");
1377 png_crc_finish(png_ptr, length);
1381 png_crc_read(png_ptr, buf, 2);
1382 png_ptr->num_trans = 1;
1383 png_ptr->trans_values.gray = png_get_uint_16(buf);
1385 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
1391 png_warning(png_ptr, "Incorrect tRNS chunk length");
1392 png_crc_finish(png_ptr, length);
1395 png_crc_read(png_ptr, buf, (png_size_t)length);
1396 png_ptr->num_trans = 1;
1397 png_ptr->trans_values.red = png_get_uint_16(buf);
1398 png_ptr->trans_values.green = png_get_uint_16(buf + 2);
1399 png_ptr->trans_values.blue = png_get_uint_16(buf + 4);
1401 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1403 if (!(png_ptr->mode & PNG_HAVE_PLTE))
1406 png_warning(png_ptr, "Missing PLTE before tRNS");
1408 if (length > (png_uint_32)png_ptr->num_palette ||
1411 png_warning(png_ptr, "Incorrect tRNS chunk length");
1412 png_crc_finish(png_ptr, length);
1417 png_warning(png_ptr, "Zero length tRNS chunk");
1418 png_crc_finish(png_ptr, length);
1421 png_crc_read(png_ptr, readbuf, (png_size_t)length);
1422 png_ptr->num_trans = (png_uint_16)length;
1426 png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");
1427 png_crc_finish(png_ptr, length);
1431 if (png_crc_finish(png_ptr, 0))
1433 png_ptr->num_trans = 0;
1437 png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,
1438 &(png_ptr->trans_values));
1444 png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1451 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1452 png_error(png_ptr, "Missing IHDR before bKGD");
1453 else if (png_ptr->mode & PNG_HAVE_IDAT)
1455 png_warning(png_ptr, "Invalid bKGD after IDAT");
1456 png_crc_finish(png_ptr, length);
1459 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
1460 !(png_ptr->mode & PNG_HAVE_PLTE))
1462 png_warning(png_ptr, "Missing PLTE before bKGD");
1463 png_crc_finish(png_ptr, length);
1468 png_warning(png_ptr, "Duplicate bKGD chunk");
1469 png_crc_finish(png_ptr, length);
1473 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1475 else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
1482 png_warning(png_ptr, "Incorrect bKGD chunk length");
1483 png_crc_finish(png_ptr, length);
1487 png_crc_read(png_ptr, buf, truelen);
1488 if (png_crc_finish(png_ptr, 0))
1495 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1497 png_ptr->background.index = buf[0];
1502 png_warning(png_ptr, "Incorrect bKGD chunk index value");
1505 png_ptr->background.red =
1506 (png_uint_16)png_ptr->palette[buf[0]].red;
1507 png_ptr->background.green =
1508 (png_uint_16)png_ptr->palette[buf[0]].green;
1509 png_ptr->background.blue =
1510 (png_uint_16)png_ptr->palette[buf[0]].blue;
1513 else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */
1515 png_ptr->background.red =
1516 png_ptr->background.green =
1517 png_ptr->background.blue =
1518 png_ptr->background.gray = png_get_uint_16(buf);
1522 png_ptr->background.red = png_get_uint_16(buf);
1523 png_ptr->background.green = png_get_uint_16(buf + 2);
1524 png_ptr->background.blue = png_get_uint_16(buf + 4);
1527 png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));
1533 png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1540 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1541 png_error(png_ptr, "Missing IHDR before hIST");
1542 else if (png_ptr->mode & PNG_HAVE_IDAT)
1544 png_warning(png_ptr, "Invalid hIST after IDAT");
1545 png_crc_finish(png_ptr, length);
1548 else if (!(png_ptr->mode & PNG_HAVE_PLTE))
1550 png_warning(png_ptr, "Missing PLTE before hIST");
1551 png_crc_finish(png_ptr, length);
1556 png_warning(png_ptr, "Duplicate hIST chunk");
1557 png_crc_finish(png_ptr, length);
1562 if (num != (unsigned int) png_ptr->num_palette || num >
1565 png_warning(png_ptr, "Incorrect hIST chunk length");
1566 png_crc_finish(png_ptr, length);
1574 png_crc_read(png_ptr, buf, 2);
1578 if (png_crc_finish(png_ptr, 0))
1581 png_set_hIST(png_ptr, info_ptr, readbuf);
1587 png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1595 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1596 png_error(png_ptr, "Missing IHDR before pHYs");
1597 else if (png_ptr->mode & PNG_HAVE_IDAT)
1599 png_warning(png_ptr, "Invalid pHYs after IDAT");
1600 png_crc_finish(png_ptr, length);
1605 png_warning(png_ptr, "Duplicate pHYs chunk");
1606 png_crc_finish(png_ptr, length);
1612 png_warning(png_ptr, "Incorrect pHYs chunk length");
1613 png_crc_finish(png_ptr, length);
1617 png_crc_read(png_ptr, buf, 9);
1618 if (png_crc_finish(png_ptr, 0))
1624 png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);
1630 png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1638 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1639 png_error(png_ptr, "Missing IHDR before oFFs");
1640 else if (png_ptr->mode & PNG_HAVE_IDAT)
1642 png_warning(png_ptr, "Invalid oFFs after IDAT");
1643 png_crc_finish(png_ptr, length);
1648 png_warning(png_ptr, "Duplicate oFFs chunk");
1649 png_crc_finish(png_ptr, length);
1655 png_warning(png_ptr, "Incorrect oFFs chunk length");
1656 png_crc_finish(png_ptr, length);
1660 png_crc_read(png_ptr, buf, 9);
1661 if (png_crc_finish(png_ptr, 0))
1667 png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);
1674 png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1685 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1686 png_error(png_ptr, "Missing IHDR before pCAL");
1687 else if (png_ptr
1689 png_warning(png_ptr, "Invalid pCAL after IDAT");
1690 png_crc_finish(png_ptr, length);
1695 png_warning(png_ptr, "Duplicate pCAL chunk");
1696 png_crc_finish(png_ptr, length);
1702 png_free(png_ptr, png_ptr->chunkdata);
1703 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
1704 if (png_ptr->chunkdata == NULL)
1706 png_warning(png_ptr, "No memory for pCAL purpose.");
1710 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1712 if (png_crc_finish(png_ptr, 0))
1714 png_free(png_ptr, png_ptr->chunkdata);
1715 png_ptr->chunkdata = NULL;
1719 png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
1722 for (buf = png_ptr->chunkdata; *buf; buf++)
1725 endptr = png_ptr->chunkdata + slength;
1731 png_warning(png_ptr, "Invalid pCAL data");
1732 png_free(png_ptr, png_ptr->chunkdata);
1733 png_ptr->chunkdata = NULL;
1752 png_warning(png_ptr, "Invalid pCAL parameters for equation type");
1753 png_free(png_ptr, png_ptr->chunkdata);
1754 png_ptr->chunkdata = NULL;
1759 png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
1766 params = (png_charpp)png_malloc_warn(png_ptr,
1770 png_free(png_ptr, png_ptr->chunkdata);
1771 png_ptr->chunkdata = NULL;
1772 png_warning(png_ptr, "No memory for pCAL params.");
1788 png_warning(png_ptr, "Invalid pCAL data");
1789 png_free(png_ptr, png_ptr->chunkdata);
1790 png_ptr->chunkdata = NULL;
1791 png_free(png_ptr, params);
1796 png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams,
1799 png_free(png_ptr, png_ptr->chunkdata);
1800 png_ptr->chunkdata = NULL;
1801 png_free(png_ptr, params);
1808 png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1823 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1824 png_error(png_ptr, "Missing IHDR before sCAL");
1825 else if (png_ptr->mode & PNG_HAVE_IDAT)
1827 png_warning(png_ptr, "Invalid sCAL after IDAT");
1828 png_crc_finish(png_ptr, length);
1833 png_warning(png_ptr, "Duplicate sCAL chunk");
1834 png_crc_finish(png_ptr, length);
1841 png_warning(png_ptr, "sCAL chunk too short");
1842 png_crc_finish(png_ptr, length);
1848 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
1849 if (png_ptr->chunkdata == NULL)
1851 png_warning(png_ptr, "Out of memory while processing sCAL chunk");
1852 png_crc_finish(png_ptr, length);
1856 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1858 if (png_crc_finish(png_ptr, 0))
1860 png_free(png_ptr, png_ptr->chunkdata);
1861 png_ptr->chunkdata = NULL;
1865 png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
1867 ep = png_ptr->chunkdata + 1; /* Skip unit byte */
1870 width = png_strtod(png_ptr, ep, &vp);
1873 png_warning(png_ptr, "malformed width string in sCAL chunk");
1874 png_free(png_ptr, png_ptr->chunkdata);
1875 png_ptr->chunkdata = NULL;
1880 swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
1883 png_warning(png_ptr, "Out of memory while processing sCAL chunk width");
1884 png_free(png_ptr, png_ptr->chunkdata);
1885 png_ptr->chunkdata = NULL;
1892 for (ep = png_ptr->chunkdata; *ep; ep++)
1896 if (png_ptr->chunkdata + slength < ep)
1898 png_warning(png_ptr, "Truncated sCAL chunk");
1900 png_free(png_ptr, swidth);
1902 png_free(png_ptr, png_ptr->chunkdata);
1903 png_ptr->chunkdata = NULL;
1908 height = png_strtod(png_ptr, ep, &vp);
1911 png_warning(png_ptr, "malformed height string in sCAL chunk");
1912 png_free(png_ptr, png_ptr->chunkdata);
1913 png_ptr->chunkdata = NULL;
1915 png_free(png_ptr, swidth);
1921 sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
1924 png_warning(png_ptr, "Out of memory while processing sCAL chunk height");
1925 png_free(png_ptr, png_ptr->chunkdata);
1926 png_ptr->chunkdata = NULL;
1928 png_free(png_ptr, swidth);
1936 if (png_ptr->chunkdata + slength < ep
1942 png_warning(png_ptr, "Invalid sCAL data");
1943 png_free(png_ptr, png_ptr->chunkdata);
1944 png_ptr->chunkdata = NULL;
1946 png_free(png_ptr, swidth);
1947 png_free(png_ptr, sheight);
1954 png_set_sCAL(png_ptr, info_ptr, png_ptr->chunkdata[0], width, height);
1957 png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], swidth, sheight);
1961 png_free(png_ptr, png_ptr->chunkdata);
1962 png_ptr->chunkdata = NULL;
1964 png_free(png_ptr, swidth);
1965 png_free(png_ptr, sheight);
1972 png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1979 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1980 png_error(png_ptr, "Out of place tIME chunk");
1983 png_warning(png_ptr, "Duplicate tIME chunk");
1984 png_crc_finish(png_ptr, length);
1988 if (png_ptr->mode & PNG_HAVE_IDAT)
1989 png_ptr->mode |= PNG_AFTER_IDAT;
1993 png_warning(png_ptr, "Incorrect tIME chunk length");
1994 png_crc_finish(png_ptr, length);
1998 png_crc_read(png_ptr, buf, 7);
1999 if (png_crc_finish(png_ptr, 0))
2009 png_set_tIME(png_ptr, info_ptr, &mod_time);
2016 png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2028 if (png_ptr->user_chunk_cache_max != 0)
2030 if (png_ptr->user_chunk_cache_max == 1)
2032 png_crc_finish(png_ptr, length);
2035 if (--png_ptr->user_chunk_cache_max == 1)
2037 png_warning(png_ptr, "No space in chunk cache for tEXt");
2038 png_crc_finish(png_ptr, length);
2044 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2045 png_error(png_ptr, "Missing IHDR before tEXt");
2047 if (png_ptr->mode & PNG_HAVE_IDAT)
2048 png_ptr->mode |= PNG_AFTER_IDAT;
2053 png_warning(png_ptr, "tEXt chunk too large to fit in memory");
2059 png_free(png_ptr, png_ptr->chunkdata);
2061 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2062 if (png_ptr->chunkdata == NULL)
2064 png_warning(png_ptr, "No memory to process text chunk.");
2068 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2070 if (png_crc_finish(png_ptr, skip))
2072 png_free(png_ptr, png_ptr->chunkdata);
2073 png_ptr->chunkdata = NULL;
2077 key = png_ptr->chunkdata;
2087 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2091 png_warning(png_ptr, "Not enough memory to process text chunk.");
2092 png_free(png_ptr, png_ptr->chunkdata);
2093 png_ptr->chunkdata = NULL;
2106 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2108 png_free(png_ptr, png_ptr->chunkdata);
2109 png_ptr->chunkdata = NULL;
2110 png_free(png_ptr, text_ptr);
2112 png_warning(png_ptr, "Insufficient memory to process text chunk.");
2119 png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2130 if (png_ptr->user_chunk_cache_max != 0)
2132 if (png_ptr->user_chunk_cache_max == 1)
2134 png_crc_finish(png_ptr, length);
2137 if (--png_ptr->user_chunk_cache_max == 1)
2139 png_warning(png_ptr, "No space in chunk cache for zTXt");
2140 png_crc_finish(png_ptr, length);
2146 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2147 png_error(png_ptr, "Missing IHDR before zTXt");
2149 if (png_ptr->mode & PNG_HAVE_IDAT)
2150 png_ptr->mode |= PNG_AFTER_IDAT;
2157 png_warning(png_ptr, "zTXt chunk too large to fit in memory");
2158 png_crc_finish(png_ptr, length);
2163 png_free(png_ptr, png_ptr->chunkdata);
2164 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2165 if (png_ptr->chunkdata == NULL)
2167 png_warning(png_ptr, "Out of memory processing zTXt chunk.");
2171 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2172 if (png_crc_finish(png_ptr, 0))
2174 png_free(png_ptr, png_ptr->chunkdata);
2175 png_ptr->chunkdata = NULL;
2179 png_ptr->chunkdata[slength] = 0x00;
2181 for (text = png_ptr->chunkdata; *text; text++)
2185 if (text >= png_ptr->chunkdata + slength - 2)
2187 png_warning(png_ptr, "Truncated zTXt chunk");
2188 png_free(png_ptr, png_ptr->chunkdata);
2189 png_ptr->chunkdata = NULL;
2197 png_warning(png_ptr, "Unknown compression type in zTXt chunk");
2202 prefix_len = text - png_ptr->chunkdata;
2204 png_decompress_chunk(png_ptr, comp_type,
2207 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2211 png_warning(png_ptr, "Not enough memory to process zTXt chunk.");
2212 png_free(png_ptr, png_ptr->chunkdata);
2213 png_ptr->chunkdata = NULL;
2217 text_ptr->key = png_ptr->chunkdata;
2223 text_ptr->text = png_ptr->chunkdata + prefix_len;
2226 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2228 png_free(png_ptr, text_ptr);
2229 png_free(png_ptr, png_ptr->chunkdata);
2230 png_ptr->chunkdata = NULL;
2232 png_error(png_ptr, "Insufficient memory to store zTXt chunk.");
2239 png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2251 if (png_ptr->user_chunk_cache_max != 0)
2253 if (png_ptr->user_chunk_cache_max == 1)
2255 png_crc_finish(png_ptr, length);
2258 if (--png_ptr->user_chunk_cache_max == 1)
2260 png_warning(png_ptr, "No space in chunk cache for iTXt");
2261 png_crc_finish(png_ptr, length);
2267 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2268 png_error(png_ptr, "Missing IHDR before iTXt");
2270 if (png_ptr->mode & PNG_HAVE_IDAT)
2271 png_ptr->mode |= PNG_AFTER_IDAT;
2278 png_warning(png_ptr, "iTXt chunk too large to fit in memory");
2279 png_crc_finish(png_ptr, length);
2284 png_free(png_ptr, png_ptr->chunkdata);
2285 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2286 if (png_ptr->chunkdata == NULL)
2288 png_warning(png_ptr, "No memory to process iTXt chunk.");
2292 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2293 if (png_crc_finish(png_ptr, 0))
2295 png_free(png_ptr, png_ptr->chunkdata);
2296 png_ptr->chunkdata = NULL;
2300 png_ptr->chunkdata[slength] = 0x00;
2302 for (lang = png_ptr->chunkdata; *lang; lang++)
2311 if (lang >= png_ptr->chunkdata + slength - 3)
2313 png_warning(png_ptr, "Truncated iTXt chunk");
2314 png_free(png_ptr, png_ptr->chunkdata);
2315 png_ptr->chunkdata = NULL;
2328 if (lang_key >= png_ptr->chunkdata + slength)
2330 png_warning(png_ptr, "Truncated iTXt chunk");
2331 png_free(png_ptr, png_ptr->chunkdata);
2332 png_ptr->chunkdata = NULL;
2339 if (text >= png_ptr->chunkdata + slength)
2341 png_warning(png_ptr, "Malformed iTXt chunk");
2342 png_free(png_ptr, png_ptr->chunkdata);
2343 png_ptr->chunkdata = NULL;
2347 prefix_len = text - png_ptr->chunkdata;
2349 key=png_ptr->chunkdata;
2351 png_decompress_chunk(png_ptr, comp_type,
2354 data_len = png_strlen(png_ptr->chunkdata + prefix_len);
2355 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2359 png_warning(png_ptr, "Not enough memory to process iTXt chunk.");
2360 png_free(png_ptr, png_ptr->chunkdata);
2361 png_ptr->chunkdata = NULL;
2365 text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key);
2366 text_ptr->lang = png_ptr->chunkdata + (lang - key);
2369 text_ptr->key = png_ptr->chunkdata;
2370 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;
2378 png_error(png_ptr, "Insufficient memory to store iTXt chunk.");
2388 png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2395 if (png_ptr->user_chunk_cache_max != 0)
2397 if (png_ptr->user_chunk_cache_max == 1)
2399 png_crc_finish(png_ptr, length);
2402 if (--png_ptr->user_chunk_cache_max == 1)
2404 png_warning(png_ptr, "No space in chunk cache for unknown chunk");
2405 png_crc_finish(png_ptr, length);
2411 if (png_ptr->mode & PNG_HAVE_IDAT)
2416 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* Not an IDAT */
2417 png_ptr->mode |= PNG_AFTER_IDAT;
2420 if (!(png_ptr->chunk_name[0] & 0x20))
2423 if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
2426 && png_ptr->read_user_chunk_fn == NULL
2430 png_chunk_error(png_ptr, "unknown critical chunk");
2434 if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
2436 || (png_ptr->read_user_chunk_fn != NULL)
2443 png_warning(png_ptr, "unknown chunk too large to fit in memory");
2448 png_memcpy((png_charp)png_ptr->unknown_chunk.name,
2449 (png_charp)png_ptr->chunk_name,
2450 png_sizeof(png_ptr->unknown_chunk.name));
2451 png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1]
2453 png_ptr->unknown_chunk.size = (png_size_t)length;
2455 png_ptr->unknown_chunk.data = NULL;
2458 png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);
2459 png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
2462 if (png_ptr->read_user_chunk_fn != NULL)
2466 ret = (*(png_ptr->read_user_chunk_fn))
2467 (png_ptr, &png_ptr->unknown_chunk);
2469 png_chunk_error(png_ptr, "error in user chunk");
2472 if (!(png_ptr->chunk_name[0] & 0x20))
2474 if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
2477 png_chunk_error(png_ptr, "unknown critical chunk");
2478 png_set_unknown_chunks(png_ptr, info_ptr,
2479 &png_ptr->unknown_chunk, 1);
2484 png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
2485 png_free(png_ptr, png_ptr->unknown_chunk.data);
2486 png_ptr->unknown_chunk.data = NULL;
2492 png_crc_finish(png_ptr, skip);
2508 png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
2514 png_chunk_error(png_ptr, "invalid chunk type");
2530 png_combine_row(png_structp png_ptr, png_bytep row, int mask)
2535 png_memcpy(row, png_ptr->row_buf + 1,
2536 PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));
2540 switch (png_ptr->row_info.pixel_depth)
2544 png_bytep sp = png_ptr->row_buf + 1;
2550 png_uint_32 row_width = png_ptr->width;
2553 if (png_ptr->transformations & PNG_PACKSWAP)
2598 png_bytep sp = png_ptr->row_buf + 1;
2604 png_uint_32 row_width = png_ptr->width;
2608 if (png_ptr->transformations & PNG_PACKSWAP)
2650 png_bytep sp = png_ptr->row_buf + 1;
2656 png_uint_32 row_width = png_ptr->width;
2660 if (png_ptr->transformations & PNG_PACKSWAP)
2701 png_bytep sp = png_ptr->row_buf + 1;
2703 png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
2705 png_uint_32 row_width = png_ptr->width;
2736 png_do_read_interlace(png_structp png_ptr)
2738 png_row_infop row_info = &(png_ptr->row_info);
2739 png_bytep row = png_ptr->row_buf + 1;
2740 int pass = png_ptr->pass;
2741 png_uint_32 transformations = png_ptr->transformations;
2957 png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
2961 png_debug2(2, "row = %lu, filter = %d", png_ptr->row_number, filter);
3073 png_warning(png_ptr, "Ignoring bad adaptive filter type");
3081 png_set_interlaced_pass(png_structp png_ptr, int pass)
3097 png_ptr->pass = pass;
3098 png_ptr->iwidth = (png_ptr->width +
3099 png_pass_inc[png_ptr->pass] - 1 -
3100 png_pass_start[png_ptr->pass]) /
3101 png_pass_inc[png_ptr->pass];
3107 png_read_finish_row(png_structp png_ptr)
3126 png_ptr->row_number++;
3127 if (png_ptr->row_number < png_ptr->num_rows)
3131 if (png_ptr->interlaced)
3133 png_ptr->row_number = 0;
3134 png_memset_check(png_ptr, png_ptr->prev_row, 0,
3135 png_ptr->rowbytes + 1);
3138 png_ptr->pass++;
3139 if (png_ptr->pass >= 7)
3141 png_ptr->iwidth = (png_ptr->width +
3142 png_pass_inc[png_ptr->pass] - 1 -
3143 png_pass_start[png_ptr->pass]) /
3144 png_pass_inc[png_ptr->pass];
3146 if (!(png_ptr->transformations & PNG_INTERLACE))
3148 png_ptr->num_rows = (png_ptr->height +
3149 png_pass_yinc[png_ptr->pass] - 1 -
3150 png_pass_ystart[png_ptr->pass]) /
3151 png_pass_yinc[png_ptr->pass];
3152 if (!(png_ptr->num_rows))
3155 else /* if (png_ptr->transformations & PNG_INTERLACE) */
3157 } while (png_ptr->iwidth == 0);
3159 if (png_ptr->pass < 7)
3164 if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
3172 png_ptr->zstream.next_out = (Byte *)&extra;
3173 png_ptr->zstream.avail_out = (uInt)1;
3176 if (!(png_ptr->zstream.avail_in))
3178 while (!png_ptr->idat_size)
3182 png_crc_finish(png_ptr, 0);
3184 png_read_data(png_ptr, chunk_length, 4);
3185 png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length);
3186 png_reset_crc(png_ptr);
3187 png_crc_read(png_ptr, png_ptr->chunk_name, 4);
3188 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
3189 png_error(png_ptr, "Not enough image data");
3192 png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
3193 png_ptr->zstream.next_in = png_ptr->zbuf;
3194 if (png_ptr->zbuf_size > png_ptr->idat_size)
3195 png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
3196 png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);
3197 png_ptr->idat_size -= png_ptr->zstream.avail_in;
3199 ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
3202 if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||
3203 png_ptr->idat_size)
3204 png_warning(png_ptr, "Extra compressed data.");
3205 png_ptr->mode |= PNG_AFTER_IDAT;
3206 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
3210 png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
3213 if (!(png_ptr->zstream.avail_out))
3215 png_warning(png_ptr, "Extra compressed data.");
3216 png_ptr->mode |= PNG_AFTER_IDAT;
3217 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
3222 png_ptr->zstream.avail_out = 0;
3225 if (png_ptr->idat_size || png_ptr->zstream.avail_in)
3226 png_warning(png_ptr, "Extra compression data.");
3228 inflateReset(&png_ptr->zstream);
3230 png_ptr->mode |= PNG_AFTER_IDAT;
3235 png_read_start_row(png_structp png_ptr)
3257 png_ptr->zstream.avail_in = 0;
3258 png_init_read_transformations(png_ptr);
3260 if (png_ptr->interlaced)
3262 if (!(png_ptr->transformations & PNG_INTERLACE))
3263 png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
3266 png_ptr->num_rows = png_ptr->height;
3268 png_ptr->iwidth = (png_ptr->width +
3269 png_pass_inc[png_ptr->pass] - 1 -
3270 png_pass_start[png_ptr->pass]) /
3271 png_pass_inc[png_ptr->pass];
3276 png_ptr->num_rows = png_ptr->height;
3277 png_ptr->iwidth = png_ptr->width;
3279 max_pixel_depth = png_ptr->pixel_depth;
3282 if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
3287 if (png_ptr->transformations & PNG_EXPAND)
3289 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
3291 if (png_ptr->num_trans)
3296 else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
3300 if (png_ptr->num_trans)
3303 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
3305 if (png_ptr->num_trans)
3315 if (png_ptr->transformations & (PNG_FILLER))
3317 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
3319 else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
3326 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
3337 if (png_ptr->transformations & PNG_GRAY_TO_RGB)
3341 (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
3344 (png_ptr->transformations & (PNG_FILLER)) ||
3346 png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
3357 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
3362 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
3372 if (png_ptr->transformations & PNG_USER_TRANSFORM)
3374 int user_pixel_depth = png_ptr->user_transform_depth*
3375 png_ptr->user_transform_channels;
3384 row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
3392 png_error(png_ptr, "This image requires a row greater than 64KB");
3395 if (row_bytes + 64 > png_ptr->old_big_row_buf_size)
3397 png_free(png_ptr, png_ptr->big_row_buf);
3398 if (png_ptr->interlaced)
3399 png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,
3402 png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr,
3404 png_ptr->old_big_row_buf_size = row_bytes + 64;
3407 png_ptr->row_buf = png_ptr->big_row_buf + 32;
3408 png_ptr->old_big_row_buf_size = row_bytes + 64;
3413 png_error(png_ptr, "This image requires a row greater than 64KB");
3416 png_error(png_ptr, "Row has too many bytes to allocate in memory.");
3418 if (row_bytes + 1 > png_ptr->old_prev_row_size)
3420 png_free(png_ptr, png_ptr->prev_row);
3421 png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(
3423 png_memset_check(png_ptr, png_ptr->prev_row, 0, row_bytes + 1);
3424 png_ptr->old_prev_row_size = row_bytes + 1;
3427 png_ptr->rowbytes = row_bytes;
3429 png_debug1(3, "width = %lu,", png_ptr->width);
3430 png_debug1(3, "height = %lu,", png_ptr->height);
3431 png_debug1(3, "iwidth = %lu,", png_ptr->iwidth);
3432 png_debug1(3, "num_rows = %lu,", png_ptr->num_rows);
3433 png_debug1(3, "rowbytes = %lu,", png_ptr->rowbytes);
3435 PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1);
3437 png_ptr->flags |= PNG_FLAG_ROW_INIT;
