Lines Matching full: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),
343 if (png_ptr->user_chunk_malloc_max &&
344 (prefix_size + expanded_size >= png_ptr->user_chunk_malloc_max - 1))
351 png_warning(png_ptr, "Exceeded size limit while expanding chunk");
366 png_charp text = png_malloc_warn(png_ptr,
371 png_memcpy(text, png_ptr->chunkdata, prefix_size);
372 new_size = png_inflate(png_ptr,
373 (png_bytep)(png_ptr->chunkdata + prefix_size),
380 png_free(png_ptr, png_ptr->chunkdata);
381 png_ptr->chunkdata = text;
386 png_warning(png_ptr, "png_inflate logic error");
387 png_free(png_ptr, text);
390 png_warning(png_ptr, "Not enough memory to decompress chunk.");
401 png_warning(png_ptr, umsg);
403 png_warning(png_ptr, "Unknown zTXt compression type");
414 png_charp text = png_malloc_warn(png_ptr, prefix_size + 1);
418 png_memcpy(text, png_ptr->chunkdata, prefix_size);
419 png_free(png_ptr, png_ptr->chunkdata);
420 png_ptr->chunkdata = text;
423 *(png_ptr->chunkdata + prefix_size) = 0x00;
434 png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
443 if (png_ptr->mode & PNG_HAVE_IHDR)
444 png_error(png_ptr, "Out of place IHDR");
448 png_error(png_ptr, "Invalid IHDR chunk");
450 png_ptr->mode |= PNG_HAVE_IHDR;
452 png_crc_read(png_ptr, buf, 13);
453 png_crc_finish(png_ptr, 0);
455 width = png_get_uint_31(png_ptr, buf);
456 height = png_get_uint_31(png_ptr, buf + 4);
464 png_ptr->width = width;
465 png_ptr->height = height;
466 png_ptr->bit_depth = (png_byte)bit_depth;
467 png_ptr->interlaced = (png_byte)interlace_type;
468 png_ptr->color_type = (png_byte)color_type;
470 png_ptr->filter_type = (png_byte)filter_type;
472 png_ptr->compression_type = (png_byte)compression_type;
475 switch (png_ptr->color_type)
479 png_ptr->channels = 1;
483 png_ptr->channels = 3;
487 png_ptr->channels = 2;
491 png_ptr->channels = 4;
496 png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
497 png_ptr->channels);
498 png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
499 png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
500 png_debug1(3, "channels = %d", png_ptr->channels);
501 png_debug1(3, "rowbytes = %lu", png_ptr->rowbytes);
502 png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
508 png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
518 if (!(png_ptr->mode & PNG_HAVE_IHDR))
519 png_error(png_ptr, "Missing IHDR before PLTE");
521 else if (png_ptr->mode & PNG_HAVE_IDAT)
523 png_warning(png_ptr, "Invalid PLTE after IDAT");
524 png_crc_finish(png_ptr, length);
528 else if (png_ptr->mode & PNG_HAVE_PLTE)
529 png_error(png_ptr, "Duplicate PLTE chunk");
531 png_ptr->mode |= PNG_HAVE_PLTE;
533 if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
535 png_warning(png_ptr,
537 png_crc_finish(png_ptr, length);
541 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
543 png_crc_finish(png_ptr, length);
550 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
552 png_warning(png_ptr, "Invalid palette chunk");
553 png_crc_finish(png_ptr, length);
559 png_ptr, "Invalid palette chunk");
570 png_crc_read(png_ptr, buf, 3);
580 png_crc_read(png_ptr, buf, 3);
594 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
597 png_crc_finish(png_ptr, 0);
600 else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */
606 if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))
608 if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)
610 png_chunk_error(png_ptr, "CRC error");
614 png_chunk_warning(png_ptr, "CRC error");
619 else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))
621 png_chunk_warning(png_ptr, "CRC error");
626 png_set_PLTE(png_ptr, info_ptr, palette, num);
629 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
633 if (png_ptr->num_trans > (png_uint_16)num)
635 png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
636 png_ptr->num_trans = (png_uint_16)num;
640 png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");
650 png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
654 if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
656 png_error(png_ptr, "No image in file");
659 png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
663 png_warning(png_ptr, "Incorrect IEND chunk length");
665 png_crc_finish(png_ptr, length);
672 png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
682 if (!(png_ptr->mode & PNG_HAVE_IHDR))
683 png_error(png_ptr, "Missing IHDR before gAMA");
684 else if (png_ptr->mode & PNG_HAVE_IDAT)
686 png_warning(png_ptr, "Invalid gAMA after IDAT");
687 png_crc_finish(png_ptr, length);
690 else if (png_ptr->mode & PNG_HAVE_PLTE)
692 png_warning(png_ptr, "Out of place gAMA chunk");
700 png_warning(png_ptr, "Duplicate gAMA chunk");
701 png_crc_finish(png_ptr, length);
707 png_warning(png_ptr, "Incorrect gAMA chunk length");
708 png_crc_finish(png_ptr, length);
712 png_crc_read(png_ptr, buf, 4);
713 if (png_crc_finish(png_ptr, 0))
720 png_warning(png_ptr,
729 png_warning(png_ptr,
741 png_ptr->gamma = file_gamma;
743 png_set_gAMA(png_ptr, info_ptr, file_gamma);
746 png_set_gAMA_fixed(png_ptr, info_ptr, igamma);
753 png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
762 if (!(png_ptr->mode & PNG_HAVE_IHDR))
763 png_error(png_ptr, "Missing IHDR before sBIT");
764 else if (png_ptr->mode & PNG_HAVE_IDAT)
766 png_warning(png_ptr, "Invalid sBIT after IDAT");
767 png_crc_finish(png_ptr, length);
770 else if (png_ptr->mode & PNG_HAVE_PLTE)
773 png_warning(png_ptr, "Out of place sBIT chunk");
777 png_warning(png_ptr, "Duplicate sBIT chunk");
778 png_crc_finish(png_ptr, length);
782 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
785 truelen = (png_size_t)png_ptr->channels;
789 png_warning(png_ptr, "Incorrect sBIT chunk length");
790 png_crc_finish(png_ptr, length);
794 png_crc_read(png_ptr, buf, truelen);
795 if (png_crc_finish(png_ptr, 0))
798 if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
800 png_ptr->sig_bit.red = buf[0];
801 png_ptr->sig_bit.green = buf[1];
802 png_ptr->sig_bit.blue = buf[2];
803 png_ptr->sig_bit.alpha = buf[3];
807 png_ptr->sig_bit.gray = buf[0];
808 png_ptr->sig_bit.red = buf[0];
809 png_ptr->sig_bit.green = buf[0];
810 png_ptr->sig_bit.blue = buf[0];
811 png_ptr->sig_bit.alpha = buf[1];
813 png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));
819 png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
832 if (!(png_ptr->mode & PNG_HAVE_IHDR))
833 png_error(png_ptr, "Missing IHDR before cHRM");
834 else if (png_ptr->mode & PNG_HAVE_IDAT)
836 png_warning(png_ptr, "Invalid cHRM after IDAT");
837 png_crc_finish(png_ptr, length);
840 else if (png_ptr->mode & PNG_HAVE_PLTE)
842 png_warning(png_ptr, "Missing PLTE before cHRM");
850 png_warning(png_ptr, "Duplicate cHRM chunk");
851 png_crc_finish(png_ptr, length);
857 png_warning(png_ptr, "Incorrect cHRM chunk length");
858 png_crc_finish(png_ptr, length);
862 png_crc_read(png_ptr, buf, 32);
863 if (png_crc_finish(png_ptr, 0))
909 png_warning(png_ptr,
932 png_set_cHRM(png_ptr, info_ptr,
936 png_set_cHRM_fixed(png_ptr, info_ptr,
945 png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
952 if (!(png_ptr->mode & PNG_HAVE_IHDR))
953 png_error(png_ptr, "Missing IHDR before sRGB");
954 else if (png_ptr->mode & PNG_HAVE_IDAT)
956 png_warning(png_ptr, "Invalid sRGB after IDAT");
957 png_crc_finish(png_ptr, length);
960 else if (png_ptr->mode & PNG_HAVE_PLTE)
962 png_warning(png_ptr, "Out of place sRGB chunk");
966 png_warning(png_ptr, "Duplicate sRGB chunk");
967 png_crc_finish(png_ptr, length);
973 png_warning(png_ptr, "Incorrect sRGB chunk length");
974 png_crc_finish(png_ptr, length);
978 png_crc_read(png_ptr, buf, 1);
979 if (png_crc_finish(png_ptr, 0))
986 png_warning(png_ptr, "Unknown sRGB intent");
1003 png_warning(png_ptr,
1008 (int)png_ptr->int_gamma);
1011 fprintf(stderr, "incorrect gamma=%f\n", png_ptr->gamma);
1031 png_warning(png_ptr,
1037 png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);
1043 png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1055 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1056 png_error(png_ptr, "Missing IHDR before iCCP");
1057 else if (png_ptr->mode & PNG_HAVE_IDAT)
1059 png_warning(png_ptr, "Invalid iCCP after IDAT");
1060 png_crc_finish(png_ptr, length);
1063 else if (png_ptr->mode & PNG_HAVE_PLTE)
1065 png_warning(png_ptr, "Out of place iCCP chunk");
1069 png_warning(png_ptr, "Duplicate iCCP chunk");
1070 png_crc_finish(png_ptr, length);
1077 png_warning(png_ptr, "iCCP chunk too large to fit in memory");
1083 png_free(png_ptr, png_ptr->chunkdata);
1084 png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
1086 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1088 if (png_crc_finish(png_ptr, skip))
1090 png_free(png_ptr, png_ptr->chunkdata);
1091 png_ptr->chunkdata = NULL;
1095 png_ptr->chunkdata[slength] = 0x00;
1097 for (profile = png_ptr->chunkdata; *profile; profile++)
1105 if ( profile >= png_ptr->chunkdata + slength - 1)
1107 png_free(png_ptr, png_ptr->chunkdata);
1108 png_ptr->chunkdata = NULL;
1109 png_warning(png_ptr, "Malformed iCCP chunk");
1117 png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");
1122 prefix_length = profile - png_ptr->chunkdata;
1123 png_decompress_chunk(png_ptr, compression_type,
1130 png_free(png_ptr, png_ptr->chunkdata);
1131 png_ptr->chunkdata = NULL;
1132 png_warning(png_ptr, "Profile size field missing from iCCP chunk");
1137 pC = (png_bytep)(png_ptr->chunkdata + prefix_length);
1148 png_free(png_ptr, png_ptr->chunkdata);
1149 png_ptr->chunkdata = NULL;
1150 png_warning(png_ptr, "Ignoring truncated iCCP profile.");
1154 png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata,
1155 compression_type, png_ptr->chunkdata + prefix_length, profile_length);
1156 png_free(png_ptr, png_ptr->chunkdata);
1157 png_ptr->chunkdata = NULL;
1163 png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1179 if (png_ptr->user_chunk_cache_max != 0)
1181 if (png_ptr->user_chunk_cache_max == 1)
1183 png_crc_finish(png_ptr, length);
1186 if (--png_ptr->user_chunk_cache_max == 1)
1188 png_warning(png_ptr, "No space in chunk cache for sPLT");
1189 png_crc_finish(png_ptr, length);
1195 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1196 png_error(png_ptr, "Missing IHDR before sPLT");
1197 else if (png_ptr->mode & PNG_HAVE_IDAT)
1199 png_warning(png_ptr, "Invalid sPLT after IDAT");
1200 png_crc_finish(png_ptr, length);
1207 png_warning(png_ptr, "sPLT chunk too large to fit in memory");
1213 png_free(png_ptr, png_ptr->chunkdata);
1214 png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
1216 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1218 if (png_crc_finish(png_ptr, skip))
1220 png_free(png_ptr, png_ptr->chunkdata);
1221 png_ptr->chunkdata = NULL;
1225 png_ptr->chunkdata[slength] = 0x00;
1227 for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start;
1233 if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)
1235 png_free(png_ptr, png_ptr->chunkdata);
1236 png_ptr->chunkdata = NULL;
1237 png_warning(png_ptr, "malformed sPLT chunk");
1243 data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata));
1248 png_free(png_ptr, png_ptr->chunkdata);
1249 png_ptr->chunkdata = NULL;
1250 png_warning(png_ptr, "sPLT chunk has bad length");
1258 png_warning(png_ptr, "sPLT chunk too long");
1262 png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));
1265 png_warning(png_ptr, "sPLT chunk requires too much memory");
1314 new_palette.name = png_ptr->chunkdata;
1316 png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
1318 png_free(png_ptr, png_ptr->chunkdata);
1319 png_ptr->chunkdata = NULL;
1320 png_free(png_ptr, new_palette.entries);
1326 png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1332 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1333 png_error(png_ptr, "Missing IHDR before tRNS");
1334 else if (png_ptr->mode & PNG_HAVE_IDAT)
1336 png_warning(png_ptr, "Invalid tRNS after IDAT");
1337 png_crc_finish(png_ptr, length);
1342 png_warning(png_ptr, "Duplicate tRNS chunk");
1343 png_crc_finish(png_ptr, length);
1347 if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
1353 png_warning(png_ptr, "Incorrect tRNS chunk length");
1354 png_crc_finish(png_ptr, length);
1358 png_crc_read(png_ptr, buf, 2);
1359 png_ptr->num_trans = 1;
1360 png_ptr->trans_values.gray = png_get_uint_16(buf);
1362 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
1368 png_warning(png_ptr, "Incorrect tRNS chunk length");
1369 png_crc_finish(png_ptr, length);
1372 png_crc_read(png_ptr, buf, (png_size_t)length);
1373 png_ptr->num_trans = 1;
1374 png_ptr->trans_values.red = png_get_uint_16(buf);
1375 png_ptr->trans_values.green = png_get_uint_16(buf + 2);
1376 png_ptr->trans_values.blue = png_get_uint_16(buf + 4);
1378 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1380 if (!(png_ptr->mode & PNG_HAVE_PLTE))
1383 png_warning(png_ptr, "Missing PLTE before tRNS");
1385 if (length > (png_uint_32)png_ptr->num_palette ||
1388 png_warning(png_ptr, "Incorrect tRNS chunk length");
1389 png_crc_finish(png_ptr, length);
1394 png_warning(png_ptr, "Zero length tRNS chunk");
1395 png_crc_finish(png_ptr, length);
1398 png_crc_read(png_ptr, readbuf, (png_size_t)length);
1399 png_ptr->num_trans = (png_uint_16)length;
1403 png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");
1404 png_crc_finish(png_ptr, length);
1408 if (png_crc_finish(png_ptr, 0))
1410 png_ptr->num_trans = 0;
1414 png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,
1415 &(png_ptr->trans_values));
1421 png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1428 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1429 png_error(png_ptr, "Missing IHDR before bKGD");
1430 else if (png_ptr->mode & PNG_HAVE_IDAT)
1432 png_warning(png_ptr, "Invalid bKGD after IDAT");
1433 png_crc_finish(png_ptr, length);
1436 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
1437 !(png_ptr->mode & PNG_HAVE_PLTE))
1439 png_warning(png_ptr, "Missing PLTE before bKGD");
1440 png_crc_finish(png_ptr, length);
1445 png_warning(png_ptr, "Duplicate bKGD chunk");
1446 png_crc_finish(png_ptr, length);
1450 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1452 else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
1459 png_warning(png_ptr, "Incorrect bKGD chunk length");
1460 png_crc_finish(png_ptr, length);
1464 png_crc_read(png_ptr, buf, truelen);
1465 if (png_crc_finish(png_ptr, 0))
1472 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1474 png_ptr->background.index = buf[0];
1479 png_warning(png_ptr, "Incorrect bKGD chunk index value");
1482 png_ptr->background.red =
1483 (png_uint_16)png_ptr->palette[buf[0]].red;
1484 png_ptr->background.green =
1485 (png_uint_16)png_ptr->palette[buf[0]].green;
1486 png_ptr->background.blue =
1487 (png_uint_16)png_ptr->palette[buf[0]].blue;
1490 else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */
1492 png_ptr->background.red =
1493 png_ptr->background.green =
1494 png_ptr->background.blue =
1495 png_ptr->background.gray = png_get_uint_16(buf);
1499 png_ptr->background.red = png_get_uint_16(buf);
1500 png_ptr->background.green = png_get_uint_16(buf + 2);
1501 png_ptr->background.blue = png_get_uint_16(buf + 4);
1504 png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));
1510 png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1517 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1518 png_error(png_ptr, "Missing IHDR before hIST");
1519 else if (png_ptr->mode & PNG_HAVE_IDAT)
1521 png_warning(png_ptr, "Invalid hIST after IDAT");
1522 png_crc_finish(png_ptr, length);
1525 else if (!(png_ptr->mode & PNG_HAVE_PLTE))
1527 png_warning(png_ptr, "Missing PLTE before hIST");
1528 png_crc_finish(png_ptr, length);
1533 png_warning(png_ptr, "Duplicate hIST chunk");
1534 png_crc_finish(png_ptr, length);
1539 if (num != (unsigned int) png_ptr->num_palette || num >
1542 png_warning(png_ptr, "Incorrect hIST chunk length");
1543 png_crc_finish(png_ptr, length);
1551 png_crc_read(png_ptr, buf, 2);
1555 if (png_crc_finish(png_ptr, 0))
1558 png_set_hIST(png_ptr, info_ptr, readbuf);
1564 png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1572 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1573 png_error(png_ptr, "Missing IHDR before pHYs");
1574 else if (png_ptr->mode & PNG_HAVE_IDAT)
1576 png_warning(png_ptr, "Invalid pHYs after IDAT");
1577 png_crc_finish(png_ptr, length);
1582 png_warning(png_ptr, "Duplicate pHYs chunk");
1583 png_crc_finish(png_ptr, length);
1589 png_warning(png_ptr, "Incorrect pHYs chunk length");
1590 png_crc_finish(png_ptr, length);
1594 png_crc_read(png_ptr, buf, 9);
1595 if (png_crc_finish(png_ptr, 0))
1601 png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);
1607 png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1615 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1616 png_error(png_ptr, "Missing IHDR before oFFs");
1617 else if (png_ptr->mode & PNG_HAVE_IDAT)
1619 png_warning(png_ptr, "Invalid oFFs after IDAT");
1620 png_crc_finish(png_ptr, length);
1625 png_warning(png_ptr, "Duplicate oFFs chunk");
1626 png_crc_finish(png_ptr, length);
1632 png_warning(png_ptr, "Incorrect oFFs chunk length");
1633 png_crc_finish(png_ptr, length);
1637 png_crc_read(png_ptr, buf, 9);
1638 if (png_crc_finish(png_ptr, 0))
1644 png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);
1651 png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1662 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1663 png_error(png_ptr, "Missing IHDR before pCAL");
1664 else if (png_ptr->mode & PNG_HAVE_IDAT)
1666 png_warning(png_ptr, "Invalid pCAL after IDAT");
1667 png_crc_finish(png_ptr, length);
1672 png_warning(png_ptr, "Duplicate pCAL chunk");
1673 png_crc_finish(png_ptr, length);
1679 png_free(png_ptr, png_ptr->chunkdata);
1680 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
1681 if (png_ptr->chunkdata == NULL)
1683 png_warning(png_ptr, "No memory for pCAL purpose.");
1687 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1689 if (png_crc_finish(png_ptr, 0))
1691 png_ptr, png_ptr->chunkdata);
1692 png_ptr->chunkdata = NULL;
1696 png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
1699 for (buf = png_ptr->chunkdata; *buf; buf++)
1702 endptr = png_ptr->chunkdata + slength;
1708 png_warning(png_ptr, "Invalid pCAL data");
1709 png_free(png_ptr, png_ptr->chunkdata);
1710 png_ptr->chunkdata = NULL;
1729 png_warning(png_ptr, "Invalid pCAL parameters for equation type");
1730 png_free(png_ptr, png_ptr->chunkdata);
1731 png_ptr->chunkdata = NULL;
1736 png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
1743 params = (png_charpp)png_malloc_warn(png_ptr,
1747 png_free(png_ptr, png_ptr->chunkdata);
1748 png_ptr->chunkdata = NULL;
1749 png_warning(png_ptr, "No memory for pCAL params.");
1765 png_warning(png_ptr, "Invalid pCAL data");
1766 png_free(png_ptr, png_ptr->chunkdata);
1767 png_ptr->chunkdata = NULL;
1768 png_free(png_ptr, params);
1773 png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams,
1776 png_free(png_ptr, png_ptr->chunkdata);
1777 png_ptr->chunkdata = NULL;
1778 png_free(png_ptr, params);
1785 png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1800 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1801 png_error(png_ptr, "Missing IHDR before sCAL");
1802 else if (png_ptr->mode & PNG_HAVE_IDAT)
1804 png_warning(png_ptr, "Invalid sCAL after IDAT");
1805 png_crc_finish(png_ptr, length);
1810 png_warning(png_ptr, "Duplicate sCAL chunk");
1811 png_crc_finish(png_ptr, length);
1817 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
1818 if (png_ptr->chunkdata == NULL)
1820 png_warning(png_ptr, "Out of memory while processing sCAL chunk");
1821 png_crc_finish(png_ptr, length);
1825 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
1827 if (png_crc_finish(png_ptr, 0))
1829 png_free(png_ptr, png_ptr->chunkdata);
1830 png_ptr->chunkdata = NULL;
1834 png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
1836 ep = png_ptr->chunkdata + 1; /* Skip unit byte */
1839 width = png_strtod(png_ptr, ep, &vp);
1842 png_warning(png_ptr, "malformed width string in sCAL chunk");
1843 png_free(png_ptr, png_ptr->chunkdata);
1844 png_ptr->chunkdata = NULL;
1849 swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
1852 png_warning(png_ptr, "Out of memory while processing sCAL chunk width");
1853 png_free(png_ptr, png_ptr->chunkdata);
1854 png_ptr->chunkdata = NULL;
1861 for (ep = png_ptr->chunkdata; *ep; ep++)
1865 if (png_ptr->chunkdata + slength < ep)
1867 png_warning(png_ptr, "Truncated sCAL chunk");
1869 png_free(png_ptr, swidth);
1871 png_free(png_ptr, png_ptr->chunkdata);
1872 png_ptr->chunkdata = NULL;
1877 height = png_strtod(png_ptr, ep, &vp);
1880 png_warning(png_ptr, "malformed height string in sCAL chunk");
1881 png_free(png_ptr, png_ptr->chunkdata);
1882 png_ptr->chunkdata = NULL;
1884 png_free(png_ptr, swidth);
1890 sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
1893 png_warning(png_ptr, "Out of memory while processing sCAL chunk height");
1894 png_free(png_ptr, png_ptr->chunkdata);
1895 png_ptr->chunkdata = NULL;
1897 png_free(png_ptr, swidth);
1905 if (png_ptr->chunkdata + slength < ep
1911 png_warning(png_ptr, "Invalid sCAL data");
1912 png_free(png_ptr, png_ptr->chunkdata);
1913 png_ptr->chunkdata = NULL;
1915 png_free(png_ptr, swidth);
1916 png_free(png_ptr, sheight);
1923 png_set_sCAL(png_ptr, info_ptr, png_ptr->chunkdata[0], width, height);
1926 png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], swidth, sheight);
1930 png_free(png_ptr, png_ptr->chunkdata);
1931 png_ptr->chunkdata = NULL;
1933 png_free(png_ptr, swidth);
1934 png_free(png_ptr, sheight);
1941 png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1948 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1949 png_error(png_ptr, "Out of place tIME chunk");
1952 png_warning(png_ptr, "Duplicate tIME chunk");
1953 png_crc_finish(png_ptr, length);
1957 if (png_ptr->mode & PNG_HAVE_IDAT)
1958 png_ptr->mode |= PNG_AFTER_IDAT;
1962 png_warning(png_ptr, "Incorrect tIME chunk length");
1963 png_crc_finish(png_ptr, length);
1967 png_crc_read(png_ptr, buf, 7);
1968 if (png_crc_finish(png_ptr, 0))
1978 png_set_tIME(png_ptr, info_ptr, &mod_time);
1985 png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1997 if (png_ptr->user_chunk_cache_max != 0)
1999 if (png_ptr->user_chunk_cache_max == 1)
2001 png_crc_finish(png_ptr, length);
2004 if (--png_ptr->user_chunk_cache_max == 1)
2006 png_warning(png_ptr, "No space in chunk cache for tEXt");
2007 png_crc_finish(png_ptr, length);
2013 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2014 png_error(png_ptr, "Missing IHDR before tEXt");
2016 if (png_ptr->mode & PNG_HAVE_IDAT)
2017 png_ptr->mode |= PNG_AFTER_IDAT;
2022 png_warning(png_ptr, "tEXt chunk too large to fit in memory");
2028 png_free(png_ptr, png_ptr->chunkdata);
2030 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2031 if (png_ptr->chunkdata == NULL)
2033 png_warning(png_ptr, "No memory to process text chunk.");
2037 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2039 if (png_crc_finish(png_ptr, skip))
2041 png_free(png_ptr, png_ptr->chunkdata);
2042 png_ptr->chunkdata = NULL;
2046 key = png_ptr->chunkdata;
2056 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2060 png_warning(png_ptr, "Not enough memory to process text chunk.");
2061 png_free(png_ptr, png_ptr->chunkdata);
2062 png_ptr->chunkdata = NULL;
2075 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2077 png_free(png_ptr, png_ptr->chunkdata);
2078 png_ptr->chunkdata = NULL;
2079 png_free(png_ptr, text_ptr);
2081 png_warning(png_ptr, "Insufficient memory to process text chunk.");
2088 png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2099 if (png_ptr->user_chunk_cache_max != 0)
2101 if (png_ptr->user_chunk_cache_max == 1)
2103 png_crc_finish(png_ptr, length);
2106 if (--png_ptr->user_chunk_cache_max == 1)
2108 png_warning(png_ptr, "No space in chunk cache for zTXt");
2109 png_crc_finish(png_ptr, length);
2115 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2116 png_error(png_ptr, "Missing IHDR before zTXt");
2118 if (png_ptr->mode & PNG_HAVE_IDAT)
2119 png_ptr->mode |= PNG_AFTER_IDAT;
2126 png_warning(png_ptr, "zTXt chunk too large to fit in memory");
2127 png_crc_finish(png_ptr, length);
2132 png_free(png_ptr, png_ptr->chunkdata);
2133 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2134 if (png_ptr->chunkdata == NULL)
2136 png_warning(png_ptr, "Out of memory processing zTXt chunk.");
2140 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2141 if (png_crc_finish(png_ptr, 0))
2143 png_free(png_ptr, png_ptr->chunkdata);
2144 png_ptr->chunkdata = NULL;
2148 png_ptr->chunkdata[slength] = 0x00;
2150 for (text = png_ptr->chunkdata; *text; text++)
2154 if (text >= png_ptr->chunkdata + slength - 2)
2156 png_warning(png_ptr, "Truncated zTXt chunk");
2157 png_free(png_ptr, png_ptr->chunkdata);
2158 png_ptr->chunkdata = NULL;
2166 png_warning(png_ptr, "Unknown compression type in zTXt chunk");
2171 prefix_len = text - png_ptr->chunkdata;
2173 png_decompress_chunk(png_ptr, comp_type,
2176 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2180 png_warning(png_ptr, "Not enough memory to process zTXt chunk.");
2181 png_free(png_ptr, png_ptr->chunkdata);
2182 png_ptr->chunkdata = NULL;
2186 text_ptr->key = png_ptr->chunkdata;
2192 text_ptr->text = png_ptr->chunkdata + prefix_len;
2195 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2197 png_free(png_ptr, text_ptr);
2198 png_free(png_ptr, png_ptr->chunkdata);
2199 png_ptr->chunkdata = NULL;
2201 png_error(png_ptr, "Insufficient memory to store zTXt chunk.");
2208 png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2220 if (png_ptr->user_chunk_cache_max != 0)
2222 if (png_ptr->user_chunk_cache_max == 1)
2224 png_crc_finish(png_ptr, length);
2227 if (--png_ptr->user_chunk_cache_max == 1)
2229 png_warning(png_ptr, "No space in chunk cache for iTXt");
2230 png_crc_finish(png_ptr, length);
2236 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2237 png_error(png_ptr, "Missing IHDR before iTXt");
2239 if (png_ptr->mode & PNG_HAVE_IDAT)
2240 png_ptr->mode |= PNG_AFTER_IDAT;
2247 png_warning(png_ptr, "iTXt chunk too large to fit in memory");
2248 png_crc_finish(png_ptr, length);
2253 png_free(png_ptr, png_ptr->chunkdata);
2254 png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2255 if (png_ptr->chunkdata == NULL)
2257 png_warning(png_ptr, "No memory to process iTXt chunk.");
2261 png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
2262 if (png_crc_finish(png_ptr, 0))
2264 png_free(png_ptr, png_ptr->chunkdata);
2265 png_ptr->chunkdata = NULL;
2269 png_ptr->chunkdata[slength] = 0x00;
2271 for (lang = png_ptr->chunkdata; *lang; lang++)
2280 if (lang >= png_ptr->chunkdata + slength - 3)
2282 png_warning(png_ptr, "Truncated iTXt chunk");
2283 png_free(png_ptr, png_ptr->chunkdata);
2284 png_ptr->chunkdata = NULL;
2297 if (lang_key >= png_ptr->chunkdata + slength)
2299 png_warning(png_ptr, "Truncated iTXt chunk");
2300 png_free(png_ptr, png_ptr->chunkdata);
2301 png_ptr->chunkdata = NULL;
2308 if (text >= png_ptr->chunkdata + slength)
2310 png_warning(png_ptr, "Malformed iTXt chunk");
2311 png_free(png_ptr, png_ptr->chunkdata);
2312 png_ptr->chunkdata = NULL;
2316 prefix_len = text - png_ptr->chunkdata;
2318 key=png_ptr->chunkdata;
2320 png_decompress_chunk(png_ptr, comp_type,
2323 data_len = png_strlen(png_ptr->chunkdata + prefix_len);
2324 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2328 png_warning(png_ptr, "Not enough memory to process iTXt chunk.");
2329 png_free(png_ptr, png_ptr->chunkdata);
2330 png_ptr->chunkdata = NULL;
2334 text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key);
2335 text_ptr->lang = png_ptr->chunkdata + (lang - key);
2338 text_ptr->key = png_ptr->chunkdata;
2339 text_ptr->text = png_ptr->chunkdata + prefix_len;
2341 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2343 png_free(png_ptr, text_ptr);
2344 png_free(png_ptr, png_ptr->chunkdata);
2345 png_ptr->chunkdata = NULL;
2347 png_error(png_ptr, "Insufficient memory to store iTXt chunk.");
2357 png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2364 if (png_ptr->user_chunk_cache_max != 0)
2366 if (png_ptr->user_chunk_cache_max == 1)
2368 png_crc_finish(png_ptr, length);
2371 if (--png_ptr->user_chunk_cache_max == 1)
2373 png_warning(png_ptr, "No space in chunk cache for unknown chunk");
2374 png_crc_finish(png_ptr, length);
2380 if (png_ptr->mode & PNG_HAVE_IDAT)
2385 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* Not an IDAT */
2386 png_ptr->mode |= PNG_AFTER_IDAT;
2389 if (!(png_ptr->chunk_name[0] & 0x20))
2392 if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
2395 && png_ptr->read_user_chunk_fn == NULL
2399 png_chunk_error(png_ptr, "unknown critical chunk");
2403 if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
2405 || (png_ptr->read_user_chunk_fn != NULL)
2412 png_warning(png_ptr, "unknown chunk too large to fit in memory");
2417 png_memcpy((png_charp)png_ptr->unknown_chunk.name,
2418 (png_charp)png_ptr->chunk_name,
2419 png_sizeof(png_ptr->unknown_chunk.name));
2420 png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1]
2422 png_ptr->unknown_chunk.size = (png_size_t)length;
2424 png_ptr->unknown_chunk.data = NULL;
2427 png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);
2428 png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
2431 if (png_ptr->read_user_chunk_fn != NULL)
2435 ret = (*(png_ptr->read_user_chunk_fn))
2436 (png_ptr, &png_ptr->unknown_chunk);
2438 png_chunk_error(png_ptr, "error in user chunk");
2441 if (!(png_ptr->chunk_name[0] & 0x20))
2443 if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
2446 png_chunk_error(png_ptr, "unknown critical chunk");
2447 png_set_unknown_chunks(png_ptr, info_ptr,
2448 &png_ptr->unknown_chunk, 1);
2453 png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
2454 png_free(png_ptr, png_ptr->unknown_chunk.data);
2455 png_ptr->unknown_chunk.data = NULL;
2461 png_crc_finish(png_ptr, skip);
2477 png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
2483 png_chunk_error(png_ptr, "invalid chunk type");
2499 png_combine_row(png_structp png_ptr, png_bytep row, int mask)
2504 png_memcpy(row, png_ptr->row_buf + 1,
2505 PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));
2509 switch (png_ptr->row_info.pixel_depth)
2513 png_bytep sp = png_ptr->row_buf + 1;
2519 png_uint_32 row_width = png_ptr->width;
2522 if (png_ptr->transformations & PNG_PACKSWAP)
2567 png_bytep sp = png_ptr->row_buf + 1;
2573 png_uint_32 row_width = png_ptr->width;
2577 if (png_ptr->transformations & PNG_PACKSWAP)
2619 png_bytep sp = png_ptr->row_buf + 1;
2625 png_uint_32 row_width = png_ptr->width;
2629 if (png_ptr->transformations & PNG_PACKSWAP)
2670 png_bytep sp = png_ptr->row_buf + 1;
2672 png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
2674 png_uint_32 row_width = png_ptr->width;
2705 png_do_read_interlace(png_structp png_ptr)
2707 png_row_infop row_info = &(png_ptr->row_info);
2708 png_bytep row = png_ptr->row_buf + 1;
2709 int pass = png_ptr->pass;
2710 png_uint_32 transformations = png_ptr->transformations;
2926 png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
2930 png_debug2(2, "row = %lu, filter = %d", png_ptr->row_number, filter);
3042 png_warning(png_ptr, "Ignoring bad adaptive filter type");
3050 png_read_finish_row(png_structp png_ptr)
3069 png_ptr->row_number++;
3070 if (png_ptr->row_number < png_ptr->num_rows)
3074 if (png_ptr->interlaced)
3076 png_ptr->row_number = 0;
3077 png_memset_check(png_ptr, png_ptr->prev_row, 0,
3078 png_ptr->rowbytes + 1);
3081 png_ptr->pass++;
3082 if (png_ptr->pass >= 7)
3084 png_ptr->iwidth = (png_ptr->width +
3085 png_pass_inc[png_ptr->pass] - 1 -
3086 png_pass_start[png_ptr->pass]) /
3087 png_pass_inc[png_ptr->pass];
3089 if (!(png_ptr->transformations & PNG_INTERLACE))
3091 png_ptr->num_rows = (png_ptr->height +
3092 png_pass_yinc[png_ptr->pass] - 1 -
3093 png_pass_ystart[png_ptr->pass]) /
3094 png_pass_yinc[png_ptr->pass];
3095 if (!(png_ptr->num_rows))
3098 else /* if (png_ptr->transformations & PNG_INTERLACE) */
3100 } while (png_ptr->iwidth == 0);
3102 if (png_ptr->pass < 7)
3107 if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
3115 png_ptr->zstream.next_out = (Byte *)&extra;
3116 png_ptr->zstream.avail_out = (uInt)1;
3119 if (!(png_ptr->zstream.avail_in))
3121 while (!png_ptr->idat_size)
3125 png_crc_finish(png_ptr, 0);
3127 png_read_data(png_ptr, chunk_length, 4);
3128 png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length);
3129 png_reset_crc(png_ptr);
3130 png_crc_read(png_ptr, png_ptr->chunk_name, 4);
3131 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
3132 png_error(png_ptr, "Not enough image data");
3135 png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
3136 png_ptr->zstream.next_in = png_ptr->zbuf;
3137 if (png_ptr->zbuf_size > png_ptr->idat_size)
3138 png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
3139 png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);
3140 png_ptr->idat_size -= png_ptr->zstream.avail_in;
3142 ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
3145 if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||
3146 png_ptr->idat_size)
3147 png_warning(png_ptr, "Extra compressed data.");
3148 png_ptr->mode |= PNG_AFTER_IDAT;
3149 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
3153 png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
3156 if (!(png_ptr->zstream.avail_out))
3158 png_warning(png_ptr, "Extra compressed data.");
3159 png_ptr->mode |= PNG_AFTER_IDAT;
3160 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
3165 png_ptr->zstream.avail_out = 0;
3168 if (png_ptr->idat_size || png_ptr->zstream.avail_in)
3169 png_warning(png_ptr, "Extra compression data.");
3171 inflateReset(&png_ptr->zstream);
3173 png_ptr->mode |= PNG_AFTER_IDAT;
3178 png_read_start_row(png_structp png_ptr)
3200 png_ptr->zstream.avail_in = 0;
3201 png_init_read_transformations(png_ptr);
3203 if (png_ptr->interlaced)
3205 if (!(png_ptr->transformations & PNG_INTERLACE))
3206 png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
3209 png_ptr->num_rows = png_ptr->height;
3211 png_ptr->iwidth = (png_ptr->width +
3212 png_pass_inc[png_ptr->pass] - 1 -
3213 png_pass_start[png_ptr->pass]) /
3214 png_pass_inc[png_ptr->pass];
3219 png_ptr->num_rows = png_ptr->height;
3220 png_ptr->iwidth = png_ptr->width;
3222 max_pixel_depth = png_ptr->pixel_depth;
3225 if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
3230 if (png_ptr->transformations & PNG_EXPAND)
3232 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
3234 if (png_ptr->num_trans)
3239 else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
3243 if (png_ptr->num_trans)
3246 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
3248 if (png_ptr->num_trans)
3258 if (png_ptr->transformations & (PNG_FILLER))
3260 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
3262 else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
3269 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
3280 if (png_ptr->transformations & PNG_GRAY_TO_RGB)
3284 (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
3287 (png_ptr->transformations & (PNG_FILLER)) ||
3289 png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
3300 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
3305 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
3315 if (png_ptr->transformations & PNG_USER_TRANSFORM)
3317 int user_pixel_depth = png_ptr->user_transform_depth*
3318 png_ptr->user_transform_channels;
3327 row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
3335 png_error(png_ptr, "This image requires a row greater than 64KB");
3338 if (row_bytes + 64 > png_ptr->old_big_row_buf_size)
3340 png_free(png_ptr, png_ptr->big_row_buf);
3341 if (png_ptr->interlaced)
3342 png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,
3345 png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr,
3347 png_ptr->old_big_row_buf_size = row_bytes + 64;
3350 png_ptr->row_buf = png_ptr->big_row_buf + 32;
3351 png_ptr->old_big_row_buf_size = row_bytes + 64;
3356 png_error(png_ptr, "This image requires a row greater than 64KB");
3359 png_error(png_ptr, "Row has too many bytes to allocate in memory.");
3361 if (row_bytes + 1 > png_ptr->old_prev_row_size)
3363 png_free(png_ptr, png_ptr->prev_row);
3364 png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(
3366 png_memset_check(png_ptr, png_ptr->prev_row, 0, row_bytes + 1);
3367 png_ptr->old_prev_row_size = row_bytes + 1;
3370 png_ptr->rowbytes = row_bytes;
3372 png_debug1(3, "width = %lu,", png_ptr->width);
3373 png_debug1(3, "height = %lu,", png_ptr->height);
3374 png_debug1(3, "iwidth = %lu,", png_ptr->iwidth);
3375 png_debug1(3, "num_rows = %lu,", png_ptr->num_rows);
3376 png_debug1(3, "rowbytes = %lu,", png_ptr->rowbytes);
3378 PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1);
3380 png_ptr->flags |= PNG_FLAG_ROW_INIT;
