Lines Matching refs:png_ptr
41 png_get_uint_31(png_structp png_ptr, png_bytep buf)
45 png_error(png_ptr, "PNG unsigned integer out of range.\n");
90 png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
92 png_read_data(png_ptr, buf, length);
93 png_calculate_crc(png_ptr, buf, length);
101 png_crc_finish(png_structp png_ptr, png_uint_32 skip)
104 png_size_t istop = png_ptr->zbuf_size;
108 png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
112 png_crc_read(png_ptr, png_ptr->zbuf, i);
115 if (png_crc_error(png_ptr))
117 if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */
118 !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||
119 (!(png_ptr->chunk_name[0] & 0x20) && /* Critical */
120 (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))
122 png_chunk_warning(png_ptr, "CRC error");
126 png_chunk_error(png_ptr, "CRC error");
137 png_crc_error(png_structp png_ptr)
143 if (png_ptr->chunk_name[0] & 0x20) /* ancillary */
145 if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
151 if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
155 png_read_data(png_ptr, crc_bytes, 4);
160 return ((int)(crc != png_ptr->crc));
176 png_decompress_chunk(png_structp png_ptr, int comp_type,
187 png_ptr->zstream.next_in = (png_bytep)(chunkdata + prefix_size);
188 png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size);
189 png_ptr->zstream.next_out = png_ptr->zbuf;
190 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
195 while (png_ptr->zstream.avail_in)
197 ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
200 if (png_ptr->zstream.msg != NULL)
201 png_warning(png_ptr, png_ptr->zstream.msg);
203 png_warning(png_ptr, msg);
204 inflateReset(&png_ptr->zstream);
205 png_ptr->zstream.avail_in = 0;
210 text = (png_charp)png_malloc_warn(png_ptr, text_size);
213 png_free(png_ptr,chunkdata);
214 png_error(png_ptr,"Not enough memory to decompress chunk");
228 if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END)
233 png_ptr->zbuf_size - png_ptr->zstream.avail_out;
234 text = (png_charp)png_malloc_warn(png_ptr, text_size + 1);
237 png_free(png_ptr,chunkdata);
238 png_error(png_ptr,"Not enough memory to decompress chunk.");
240 png_memcpy(text + prefix_size, png_ptr->zbuf,
250 text = (png_charp)png_malloc_warn(png_ptr,
252 png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1));
255 png_free(png_ptr, tmp);
256 png_free(png_ptr, chunkdata);
257 png_error(png_ptr,"Not enough memory to decompress chunk..");
260 png_free(png_ptr, tmp);
261 png_memcpy(text + text_size, png_ptr->zbuf,
262 (png_ptr->zbuf_size - png_ptr->zstream.avail_out));
263 text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
270 png_ptr->zstream.next_out = png_ptr->zbuf;
271 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
282 (char *)png_ptr->chunk_name);
285 (char *)png_ptr->chunk_name);
288 (char *)png_ptr->chunk_name);
289 png_warning(png_ptr, umsg);
291 png_warning(png_ptr,
297 text = (png_charp)png_malloc_warn(png_ptr, text_size+1);
300 png_free(png_ptr, chunkdata);
301 png_error(png_ptr,"Not enough memory for text.");
308 inflateReset(&png_ptr->zstream);
309 png_ptr->zstream.avail_in = 0;
311 png_free(png_ptr, chunkdata);
321 png_warning(png_ptr, umsg);
323 png_warning(png_ptr, "Unknown zTXt compression type");
336 png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
345 if (png_ptr->mode & PNG_HAVE_IHDR)
346 png_error(png_ptr, "Out of place IHDR");
350 png_error(png_ptr, "Invalid IHDR chunk");
352 png_ptr->mode |= PNG_HAVE_IHDR;
354 png_crc_read(png_ptr, buf, 13);
355 png_crc_finish(png_ptr, 0);
357 width = png_get_uint_31(png_ptr, buf);
358 height = png_get_uint_31(png_ptr, buf + 4);
366 png_ptr->width = width;
367 png_ptr->height = height;
368 png_ptr->bit_depth = (png_byte)bit_depth;
369 png_ptr->interlaced = (png_byte)interlace_type;
370 png_ptr->color_type = (png_byte)color_type;
372 png_ptr->filter_type = (png_byte)filter_type;
374 png_ptr->compression_type = (png_byte)compression_type;
377 switch (png_ptr->color_type)
381 png_ptr->channels = 1;
384 png_ptr->channels = 3;
387 png_ptr->channels = 2;
390 png_ptr->channels = 4;
395 png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
396 png_ptr->channels);
397 png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,png_ptr->width);
398 png_debug1(3,"bit_depth = %d\n", png_ptr->bit_depth);
399 png_debug1(3,"channels = %d\n", png_ptr->channels);
400 png_debug1(3,"rowbytes = %lu\n", png_ptr->rowbytes);
401 png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
407 png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
417 if (!(png_ptr->mode & PNG_HAVE_IHDR))
418 png_error(png_ptr, "Missing IHDR before PLTE");
419 else if (png_ptr->mode & PNG_HAVE_IDAT)
421 png_warning(png_ptr, "Invalid PLTE after IDAT");
422 png_crc_finish(png_ptr, length);
425 else if (png_ptr->mode & PNG_HAVE_PLTE)
426 png_error(png_ptr, "Duplicate PLTE chunk");
428 png_ptr->mode |= PNG_HAVE_PLTE;
430 if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
432 png_warning(png_ptr,
434 png_crc_finish(png_ptr, length);
438 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
440 png_crc_finish(png_ptr, length);
447 if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
449 png_warning(png_ptr, "Invalid palette chunk");
450 png_crc_finish(png_ptr, length);
455 png_error(png_ptr, "Invalid palette chunk");
466 png_crc_read(png_ptr, buf, 3);
476 png_crc_read(png_ptr, buf, 3);
489 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
492 png_crc_finish(png_ptr, 0);
495 else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */
501 if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))
503 if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)
505 png_chunk_error(png_ptr, "CRC error");
509 png_chunk_warning(png_ptr, "CRC error");
514 else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))
516 png_chunk_warning(png_ptr, "CRC error");
521 png_set_PLTE(png_ptr, info_ptr, palette, num);
524 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
528 if (png_ptr->num_trans > (png_uint_16)num)
530 png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
531 png_ptr->num_trans = (png_uint_16)num;
535 png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");
545 png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
549 if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
551 png_error(png_ptr, "No image in file");
554 png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
558 png_warning(png_ptr, "Incorrect IEND chunk length");
560 png_crc_finish(png_ptr, length);
568 png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
578 if (!(png_ptr->mode & PNG_HAVE_IHDR))
579 png_error(png_ptr, "Missing IHDR before gAMA");
580 else if (png_ptr->mode & PNG_HAVE_IDAT)
582 png_warning(png_ptr, "Invalid gAMA after IDAT");
583 png_crc_finish(png_ptr, length);
586 else if (png_ptr->mode & PNG_HAVE_PLTE)
588 png_warning(png_ptr, "Out of place gAMA chunk");
596 png_warning(png_ptr, "Duplicate gAMA chunk");
597 png_crc_finish(png_ptr, length);
603 png_warning(png_ptr, "Incorrect gAMA chunk length");
604 png_crc_finish(png_ptr, length);
608 png_crc_read(png_ptr, buf, 4);
609 if (png_crc_finish(png_ptr, 0))
616 png_warning(png_ptr,
625 png_warning(png_ptr,
637 png_ptr->gamma = file_gamma;
639 png_set_gAMA(png_ptr, info_ptr, file_gamma);
642 png_set_gAMA_fixed(png_ptr, info_ptr, igamma);
649 png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
658 if (!(png_ptr->mode & PNG_HAVE_IHDR))
659 png_error(png_ptr, "Missing IHDR before sBIT");
660 else if (png_ptr->mode & PNG_HAVE_IDAT)
662 png_warning(png_ptr, "Invalid sBIT after IDAT");
663 png_crc_finish(png_ptr, length);
666 else if (png_ptr->mode & PNG_HAVE_PLTE)
669 png_warning(png_ptr, "Out of place sBIT chunk");
673 png_warning(png_ptr, "Duplicate sBIT chunk");
674 png_crc_finish(png_ptr, length);
678 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
681 truelen = (png_size_t)png_ptr->channels;
685 png_warning(png_ptr, "Incorrect sBIT chunk length");
686 png_crc_finish(png_ptr, length);
690 png_crc_read(png_ptr, buf, truelen);
691 if (png_crc_finish(png_ptr, 0))
694 if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
696 png_ptr->sig_bit.red = buf[0];
697 png_ptr->sig_bit.green = buf[1];
698 png_ptr->sig_bit.blue = buf[2];
699 png_ptr->sig_bit.alpha = buf[3];
703 png_ptr->sig_bit.gray = buf[0];
704 png_ptr->sig_bit.red = buf[0];
705 png_ptr->sig_bit.green = buf[0];
706 png_ptr->sig_bit.blue = buf[0];
707 png_ptr->sig_bit.alpha = buf[1];
709 png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));
715 png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
728 if (!(png_ptr->mode & PNG_HAVE_IHDR))
729 png_error(png_ptr, "Missing IHDR before cHRM");
730 else if (png_ptr->mode & PNG_HAVE_IDAT)
732 png_warning(png_ptr, "Invalid cHRM after IDAT");
733 png_crc_finish(png_ptr, length);
736 else if (png_ptr->mode & PNG_HAVE_PLTE)
738 png_warning(png_ptr, "Missing PLTE before cHRM");
746 png_warning(png_ptr, "Duplicate cHRM chunk");
747 png_crc_finish(png_ptr, length);
753 png_warning(png_ptr, "Incorrect cHRM chunk length");
754 png_crc_finish(png_ptr, length);
758 png_crc_read(png_ptr, buf, 4);
761 png_crc_read(png_ptr, buf, 4);
767 png_warning(png_ptr, "Invalid cHRM white point");
768 png_crc_finish(png_ptr, 24);
774 png_crc_read(png_ptr, buf, 4);
777 png_crc_read(png_ptr, buf, 4);
783 png_warning(png_ptr, "Invalid cHRM red point");
784 png_crc_finish(png_ptr, 16);
790 png_crc_read(png_ptr, buf, 4);
793 png_crc_read(png_ptr, buf, 4);
799 png_warning(png_ptr, "Invalid cHRM green point");
800 png_crc_finish(png_ptr, 8);
806 png_crc_read(png_ptr, buf, 4);
809 png_crc_read(png_ptr, buf, 4);
815 png_warning(png_ptr, "Invalid cHRM blue point");
816 png_crc_finish(png_ptr, 0);
846 png_warning(png_ptr,
862 png_crc_finish(png_ptr, 0);
868 png_set_cHRM(png_ptr, info_ptr,
872 png_set_cHRM_fixed(png_ptr, info_ptr,
876 if (png_crc_finish(png_ptr, 0))
883 png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
890 if (!(png_ptr->mode & PNG_HAVE_IHDR))
891 png_error(png_ptr, "Missing IHDR before sRGB");
892 else if (png_ptr->mode & PNG_HAVE_IDAT)
894 png_warning(png_ptr, "Invalid sRGB after IDAT");
895 png_crc_finish(png_ptr, length);
898 else if (png_ptr->mode & PNG_HAVE_PLTE)
900 png_warning(png_ptr, "Out of place sRGB chunk");
904 png_warning(png_ptr, "Duplicate sRGB chunk");
905 png_crc_finish(png_ptr, length);
911 png_warning(png_ptr, "Incorrect sRGB chunk length");
912 png_crc_finish(png_ptr, length);
916 png_crc_read(png_ptr, buf, 1);
917 if (png_crc_finish(png_ptr, 0))
924 png_warning(png_ptr, "Unknown sRGB intent");
941 png_warning(png_ptr,
945 fprintf(stderr,"incorrect gamma=(%d/100000)\n",(int)png_ptr->int_gamma);
948 fprintf(stderr,"incorrect gamma=%f\n",png_ptr->gamma);
968 png_warning(png_ptr,
974 png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);
980 png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
993 if (!(png_ptr->mode & PNG_HAVE_IHDR))
994 png_error(png_ptr, "Missing IHDR before iCCP");
995 else if (png_ptr->mode & PNG_HAVE_IDAT)
997 png_warning(png_ptr, "Invalid iCCP after IDAT");
998 png_crc_finish(png_ptr, length);
1001 else if (png_ptr->mode & PNG_HAVE_PLTE)
1003 png_warning(png_ptr, "Out of place iCCP chunk");
1007 png_warning(png_ptr, "Duplicate iCCP chunk");
1008 png_crc_finish(png_ptr, length);
1015 png_warning(png_ptr, "iCCP chunk too large to fit in memory");
1021 chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
1023 png_crc_read(png_ptr, (png_bytep)chunkdata, slength);
1025 if (png_crc_finish(png_ptr, skip))
1027 png_free(png_ptr, chunkdata);
1042 png_free(png_ptr, chunkdata);
1043 png_warning(png_ptr, "Malformed iCCP chunk");
1051 png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");
1057 chunkdata = png_decompress_chunk(png_ptr, compression_type, chunkdata,
1064 png_free(png_ptr, chunkdata);
1065 png_warning(png_ptr, "Profile size field missing from iCCP chunk");
1081 png_free(png_ptr, chunkdata);
1082 png_warning(png_ptr, "Ignoring truncated iCCP profile.\n");
1086 png_set_iCCP(png_ptr, info_ptr, chunkdata, compression_type,
1088 png_free(png_ptr, chunkdata);
1094 png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1109 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1110 png_error(png_ptr, "Missing IHDR before sPLT");
1111 else if (png_ptr->mode & PNG_HAVE_IDAT)
1113 png_warning(png_ptr, "Invalid sPLT after IDAT");
1114 png_crc_finish(png_ptr, length);
1121 png_warning(png_ptr, "sPLT chunk too large to fit in memory");
1127 chunkdata = (png_bytep)png_malloc(png_ptr, length + 1);
1129 png_crc_read(png_ptr, (png_bytep)chunkdata, slength);
1131 if (png_crc_finish(png_ptr, skip))
1133 png_free(png_ptr, chunkdata);
1146 png_free(png_ptr, chunkdata);
1147 png_warning(png_ptr, "malformed sPLT chunk");
1158 png_free(png_ptr, chunkdata);
1159 png_warning(png_ptr, "sPLT chunk has bad length");
1167 png_warning(png_ptr, "sPLT chunk too long");
1171 png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));
1174 png_warning(png_ptr, "sPLT chunk requires too much memory");
1225 png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
1227 png_free(png_ptr, chunkdata);
1228 png_free(png_ptr, new_palette.entries);
1234 png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1240 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1241 png_error(png_ptr, "Missing IHDR before tRNS");
1242 else if (png_ptr->mode & PNG_HAVE_IDAT)
1244 png_warning(png_ptr, "Invalid tRNS after IDAT");
1245 png_crc_finish(png_ptr, length);
1250 png_warning(png_ptr, "Duplicate tRNS chunk");
1251 png_crc_finish(png_ptr, length);
1255 if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
1261 png_warning(png_ptr, "Incorrect tRNS chunk length");
1262 png_crc_finish(png_ptr, length);
1266 png_crc_read(png_ptr, buf, 2);
1267 png_ptr->num_trans = 1;
1268 png_ptr->trans_values.gray = png_get_uint_16(buf);
1270 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
1276 png_warning(png_ptr, "Incorrect tRNS chunk length");
1277 png_crc_finish(png_ptr, length);
1280 png_crc_read(png_ptr, buf, (png_size_t)length);
1281 png_ptr->num_trans = 1;
1282 png_ptr->trans_values.red = png_get_uint_16(buf);
1283 png_ptr->trans_values.green = png_get_uint_16(buf + 2);
1284 png_ptr->trans_values.blue = png_get_uint_16(buf + 4);
1286 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1288 if (!(png_ptr->mode & PNG_HAVE_PLTE))
1291 png_warning(png_ptr, "Missing PLTE before tRNS");
1293 if (length > (png_uint_32)png_ptr->num_palette ||
1296 png_warning(png_ptr, "Incorrect tRNS chunk length");
1297 png_crc_finish(png_ptr, length);
1302 png_warning(png_ptr, "Zero length tRNS chunk");
1303 png_crc_finish(png_ptr, length);
1306 png_crc_read(png_ptr, readbuf, (png_size_t)length);
1307 png_ptr->num_trans = (png_uint_16)length;
1311 png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");
1312 png_crc_finish(png_ptr, length);
1316 if (png_crc_finish(png_ptr, 0))
1319 png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,
1320 &(png_ptr->trans_values));
1326 png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1333 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1334 png_error(png_ptr, "Missing IHDR before bKGD");
1335 else if (png_ptr->mode & PNG_HAVE_IDAT)
1337 png_warning(png_ptr, "Invalid bKGD after IDAT");
1338 png_crc_finish(png_ptr, length);
1341 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
1342 !(png_ptr->mode & PNG_HAVE_PLTE))
1344 png_warning(png_ptr, "Missing PLTE before bKGD");
1345 png_crc_finish(png_ptr, length);
1350 png_warning(png_ptr, "Duplicate bKGD chunk");
1351 png_crc_finish(png_ptr, length);
1355 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1357 else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
1364 png_warning(png_ptr, "Incorrect bKGD chunk length");
1365 png_crc_finish(png_ptr, length);
1369 png_crc_read(png_ptr, buf, truelen);
1370 if (png_crc_finish(png_ptr, 0))
1377 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1379 png_ptr->background.index = buf[0];
1384 png_warning(png_ptr, "Incorrect bKGD chunk index value");
1387 png_ptr->background.red =
1388 (png_uint_16)png_ptr->palette[buf[0]].red;
1389 png_ptr->background.green =
1390 (png_uint_16)png_ptr->palette[buf[0]].green;
1391 png_ptr->background.blue =
1392 (png_uint_16)png_ptr->palette[buf[0]].blue;
1395 else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */
1397 png_ptr->background.red =
1398 png_ptr->background.green =
1399 png_ptr->background.blue =
1400 png_ptr->background.gray = png_get_uint_16(buf);
1404 png_ptr->background.red = png_get_uint_16(buf);
1405 png_ptr->background.green = png_get_uint_16(buf + 2);
1406 png_ptr->background.blue = png_get_uint_16(buf + 4);
1409 png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));
1415 png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1422 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1423 png_error(png_ptr, "Missing IHDR before hIST");
1424 else if (png_ptr->mode & PNG_HAVE_IDAT)
1426 png_warning(png_ptr, "Invalid hIST after IDAT");
1427 png_crc_finish(png_ptr, length);
1430 else if (!(png_ptr->mode & PNG_HAVE_PLTE))
1432 png_warning(png_ptr, "Missing PLTE before hIST");
1433 png_crc_finish(png_ptr, length);
1438 png_warning(png_ptr, "Duplicate hIST chunk");
1439 png_crc_finish(png_ptr, length);
1444 if (num != (unsigned int) png_ptr->num_palette || num >
1447 png_warning(png_ptr, "Incorrect hIST chunk length");
1448 png_crc_finish(png_ptr, length);
1456 png_crc_read(png_ptr, buf, 2);
1460 if (png_crc_finish(png_ptr, 0))
1463 png_set_hIST(png_ptr, info_ptr, readbuf);
1469 png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1477 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1478 png_error(png_ptr, "Missing IHDR before pHYs");
1479 else if (png_ptr->mode & PNG_HAVE_IDAT)
1481 png_warning(png_ptr, "Invalid pHYs after IDAT");
1482 png_crc_finish(png_ptr, length);
1487 png_warning(png_ptr, "Duplicate pHYs chunk");
1488 png_crc_finish(png_ptr, length);
1494 png_warning(png_ptr, "Incorrect pHYs chunk length");
1495 png_crc_finish(png_ptr, length);
1499 png_crc_read(png_ptr, buf, 9);
1500 if (png_crc_finish(png_ptr, 0))
1506 png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);
1512 png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1520 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1521 png_error(png_ptr, "Missing IHDR before oFFs");
1522 else if (png_ptr->mode & PNG_HAVE_IDAT)
1524 png_warning(png_ptr, "Invalid oFFs after IDAT");
1525 png_crc_finish(png_ptr, length);
1530 png_warning(png_ptr, "Duplicate oFFs chunk");
1531 png_crc_finish(png_ptr, length);
1537 png_warning(png_ptr, "Incorrect oFFs chunk length");
1538 png_crc_finish(png_ptr, length);
1542 png_crc_read(png_ptr, buf, 9);
1543 if (png_crc_finish(png_ptr, 0))
1549 png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);
1556 png_handle_pCAL(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 pCAL");
1570 else if (png_ptr->mode & PNG_HAVE_IDAT)
1572 png_warning(png_ptr, "Invalid pCAL after IDAT");
1573 png_crc_finish(png_ptr, length);
1578 png_warning(png_ptr, "Duplicate pCAL chunk");
1579 png_crc_finish(png_ptr, length);
1585 purpose = (png_charp)png_malloc_warn(png_ptr, length + 1);
1588 png_warning(png_ptr, "No memory for pCAL purpose.");
1592 png_crc_read(png_ptr, (png_bytep)purpose, slength);
1594 if (png_crc_finish(png_ptr, 0))
1596 png_free(png_ptr, purpose);
1612 png_warning(png_ptr, "Invalid pCAL data");
1613 png_free(png_ptr, purpose);
1632 png_warning(png_ptr, "Invalid pCAL parameters for equation type");
1633 png_free(png_ptr, purpose);
1638 png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
1645 params = (png_charpp)png_malloc_warn(png_ptr, (png_uint_32)(nparams
1649 png_free(png_ptr, purpose);
1650 png_warning(png_ptr, "No memory for pCAL params.");
1666 png_warning(png_ptr, "Invalid pCAL data");
1667 png_free(png_ptr, purpose);
1668 png_free(png_ptr, params);
1673 png_set_pCAL(png_ptr, info_ptr, purpose, X0, X1, type, nparams,
1676 png_free(png_ptr, purpose);
1677 png_free(png_ptr, params);
1684 png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1699 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1700 png_error(png_ptr, "Missing IHDR before sCAL");
1701 else if (png_ptr->mode & PNG_HAVE_IDAT)
1703 png_warning(png_ptr, "Invalid sCAL after IDAT");
1704 png_crc_finish(png_ptr, length);
1709 png_warning(png_ptr, "Duplicate sCAL chunk");
1710 png_crc_finish(png_ptr, length);
1716 buffer = (png_charp)png_malloc_warn(png_ptr, length + 1);
1719 png_warning(png_ptr, "Out of memory while processing sCAL chunk");
1723 png_crc_read(png_ptr, (png_bytep)buffer, slength);
1725 if (png_crc_finish(png_ptr, 0))
1727 png_free(png_ptr, buffer);
1739 png_warning(png_ptr, "malformed width string in sCAL chunk");
1744 swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
1747 png_warning(png_ptr, "Out of memory while processing sCAL chunk width");
1762 png_warning(png_ptr, "malformed height string in sCAL chunk");
1767 sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
1770 png_warning(png_ptr, "Out of memory while processing sCAL chunk height");
1783 png_warning(png_ptr, "Invalid sCAL data");
1784 png_free(png_ptr, buffer);
1786 png_free(png_ptr, swidth);
1787 png_free(png_ptr, sheight);
1794 png_set_sCAL(png_ptr, info_ptr, buffer[0], width, height);
1797 png_set_sCAL_s(png_ptr, info_ptr, buffer[0], swidth, sheight);
1801 png_free(png_ptr, buffer);
1803 png_free(png_ptr, swidth);
1804 png_free(png_ptr, sheight);
1811 png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1818 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1819 png_error(png_ptr, "Out of place tIME chunk");
1822 png_warning(png_ptr, "Duplicate tIME chunk");
1823 png_crc_finish(png_ptr, length);
1827 if (png_ptr->mode & PNG_HAVE_IDAT)
1828 png_ptr->mode |= PNG_AFTER_IDAT;
1832 png_warning(png_ptr, "Incorrect tIME chunk length");
1833 png_crc_finish(png_ptr, length);
1837 png_crc_read(png_ptr, buf, 7);
1838 if (png_crc_finish(png_ptr, 0))
1848 png_set_tIME(png_ptr, info_ptr, &mod_time);
1855 png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1866 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1867 png_error(png_ptr, "Missing IHDR before tEXt");
1869 if (png_ptr->mode & PNG_HAVE_IDAT)
1870 png_ptr->mode |= PNG_AFTER_IDAT;
1875 png_warning(png_ptr, "tEXt chunk too large to fit in memory");
1881 key = (png_charp)png_malloc_warn(png_ptr, length + 1);
1884 png_warning(png_ptr, "No memory to process text chunk.");
1888 png_crc_read(png_ptr, (png_bytep)key, slength);
1890 if (png_crc_finish(png_ptr, skip))
1892 png_free(png_ptr, key);
1904 text_ptr = (png_textp)png_malloc_warn(png_ptr,
1908 png_warning(png_ptr, "Not enough memory to process text chunk.");
1909 png_free(png_ptr, key);
1922 ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
1924 png_free(png_ptr, key);
1925 png_free(png_ptr, text_ptr);
1927 png_warning(png_ptr, "Insufficient memory to process text chunk.");
1934 png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
1944 if (!(png_ptr->mode & PNG_HAVE_IHDR))
1945 png_error(png_ptr, "Missing IHDR before zTXt");
1947 if (png_ptr->mode & PNG_HAVE_IDAT)
1948 png_ptr->mode |= PNG_AFTER_IDAT;
1955 png_warning(png_ptr,"zTXt chunk too large to fit in memory");
1956 png_crc_finish(png_ptr, length);
1961 chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
1964 png_warning(png_ptr,"Out of memory processing zTXt chunk.");
1968 png_crc_read(png_ptr, (png_bytep)chunkdata, slength);
1969 if (png_crc_finish(png_ptr, 0))
1971 png_free(png_ptr, chunkdata);
1984 png_warning(png_ptr, "Zero length zTXt chunk");
1991 png_warning(png_ptr, "Unknown compression type in zTXt chunk");
1998 chunkdata = (png_charp)png_decompress_chunk(png_ptr, comp_type, chunkdata,
2001 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2005 png_warning(png_ptr,"Not enough memory to process zTXt chunk.");
2006 png_free(png_ptr, chunkdata);
2019 ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2021 png_free(png_ptr, text_ptr);
2022 png_free(png_ptr, chunkdata);
2024 png_error(png_ptr, "Insufficient memory to store zTXt chunk.");
2031 png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2043 if (!(png_ptr->mode & PNG_HAVE_IHDR))
2044 png_error(png_ptr, "Missing IHDR before iTXt");
2046 if (png_ptr->mode & PNG_HAVE_IDAT)
2047 png_ptr->mode |= PNG_AFTER_IDAT;
2054 png_warning(png_ptr,"iTXt chunk too large to fit in memory");
2055 png_crc_finish(png_ptr, length);
2060 chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
2063 png_warning(png_ptr, "No memory to process iTXt chunk.");
2067 png_crc_read(png_ptr, (png_bytep)chunkdata, slength);
2068 if (png_crc_finish(png_ptr, 0))
2070 png_free(png_ptr, chunkdata);
2087 png_warning(png_ptr, "Zero length iTXt chunk");
2107 chunkdata = png_decompress_chunk(png_ptr, comp_type, chunkdata,
2111 text_ptr = (png_textp)png_malloc_warn(png_ptr,
2115 png_warning(png_ptr,"Not enough memory to process iTXt chunk.");
2116 png_free(png_ptr, chunkdata);
2127 ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
2129 png_free(png_ptr, text_ptr);
2130 png_free(png_ptr, chunkdata);
2132 png_error(png_ptr, "Insufficient memory to store iTXt chunk.");
2142 png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
2148 if (png_ptr->mode & PNG_HAVE_IDAT)
2153 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* not an IDAT */
2154 png_ptr->mode |= PNG_AFTER_IDAT;
2157 png_check_chunk_name(png_ptr, png_ptr->chunk_name);
2159 if (!(png_ptr->chunk_name[0] & 0x20))
2162 if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
2165 && png_ptr->read_user_chunk_fn == NULL
2169 png_chunk_error(png_ptr, "unknown critical chunk");
2173 if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
2180 png_warning(png_ptr, "unknown chunk too large to fit in memory");
2185 png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name);
2186 chunk.data = (png_bytep)png_malloc(png_ptr, length);
2188 png_crc_read(png_ptr, (png_bytep)chunk.data, length);
2190 if(png_ptr->read_user_chunk_fn != NULL)
2193 if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0)
2195 if (!(png_ptr->chunk_name[0] & 0x20))
2196 if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
2199 png_free(png_ptr, chunk.data);
2200 png_chunk_error(png_ptr, "unknown critical chunk");
2202 png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1);
2207 png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1);
2208 png_free(png_ptr, chunk.data);
2214 png_crc_finish(png_ptr, skip);
2231 png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
2237 png_chunk_error(png_ptr, "invalid chunk type");
2253 png_combine_row(png_structp png_ptr, png_bytep row, int mask)
2258 png_memcpy(row, png_ptr->row_buf + 1,
2259 PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));
2263 switch (png_ptr->row_info.pixel_depth)
2267 png_bytep sp = png_ptr->row_buf + 1;
2273 png_uint_32 row_width = png_ptr->width;
2276 if (png_ptr->transformations & PNG_PACKSWAP)
2321 png_bytep sp = png_ptr->row_buf + 1;
2327 png_uint_32 row_width = png_ptr->width;
2331 if (png_ptr->transformations & PNG_PACKSWAP)
2373 png_bytep sp = png_ptr->row_buf + 1;
2379 png_uint_32 row_width = png_ptr->width;
2383 if (png_ptr->transformations & PNG_PACKSWAP)
2424 png_bytep sp = png_ptr->row_buf + 1;
2426 png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
2428 png_uint_32 row_width = png_ptr->width;
2461 png_do_read_interlace(png_structp png_ptr)
2463 png_row_infop row_info = &(png_ptr->row_info);
2464 png_bytep row = png_ptr->row_buf + 1;
2465 int pass = png_ptr->pass;
2466 png_uint_32 transformations = png_ptr->transformations;
2686 png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
2690 png_debug2(2,"row = %lu, filter = %d\n", png_ptr->row_number, filter);
2802 png_warning(png_ptr, "Ignoring bad adaptive filter type");
2810 png_read_finish_row(png_structp png_ptr)
2829 png_ptr->row_number++;
2830 if (png_ptr->row_number < png_ptr->num_rows)
2833 if (png_ptr->interlaced)
2835 png_ptr->row_number = 0;
2836 png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
2839 png_ptr->pass++;
2840 if (png_ptr->pass >= 7)
2842 png_ptr->iwidth = (png_ptr->width +
2843 png_pass_inc[png_ptr->pass] - 1 -
2844 png_pass_start[png_ptr->pass]) /
2845 png_pass_inc[png_ptr->pass];
2847 png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,
2848 png_ptr->iwidth) + 1;
2850 if (!(png_ptr->transformations & PNG_INTERLACE))
2852 png_ptr->num_rows = (png_ptr->height +
2853 png_pass_yinc[png_ptr->pass] - 1 -
2854 png_pass_ystart[png_ptr->pass]) /
2855 png_pass_yinc[png_ptr->pass];
2856 if (!(png_ptr->num_rows))
2859 else /* if (png_ptr->transformations & PNG_INTERLACE) */
2861 } while (png_ptr->iwidth == 0);
2863 if (png_ptr->pass < 7)
2867 if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
2875 png_ptr->zstream.next_out = (Byte *)&extra;
2876 png_ptr->zstream.avail_out = (uInt)1;
2879 if (!(png_ptr->zstream.avail_in))
2881 while (!png_ptr->idat_size)
2885 png_crc_finish(png_ptr, 0);
2887 png_read_data(png_ptr, chunk_length, 4);
2888 png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length);
2889 png_reset_crc(png_ptr);
2890 png_crc_read(png_ptr, png_ptr->chunk_name, 4);
2891 if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4))
2892 png_error(png_ptr, "Not enough image data");
2895 png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
2896 png_ptr->zstream.next_in = png_ptr->zbuf;
2897 if (png_ptr->zbuf_size > png_ptr->idat_size)
2898 png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
2899 png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);
2900 png_ptr->idat_size -= png_ptr->zstream.avail_in;
2902 ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
2905 if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||
2906 png_ptr->idat_size)
2907 png_warning(png_ptr, "Extra compressed data");
2908 png_ptr->mode |= PNG_AFTER_IDAT;
2909 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
2913 png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
2916 if (!(png_ptr->zstream.avail_out))
2918 png_warning(png_ptr, "Extra compressed data.");
2919 png_ptr->mode |= PNG_AFTER_IDAT;
2920 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
2925 png_ptr->zstream.avail_out = 0;
2928 if (png_ptr->idat_size || png_ptr->zstream.avail_in)
2929 png_warning(png_ptr, "Extra compression data");
2931 inflateReset(&png_ptr->zstream);
2933 png_ptr->mode |= PNG_AFTER_IDAT;
2937 png_read_start_row(png_structp png_ptr)
2959 png_ptr->zstream.avail_in = 0;
2960 png_init_read_transformations(png_ptr);
2961 if (png_ptr->interlaced)
2963 if (!(png_ptr->transformations & PNG_INTERLACE))
2964 png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
2967 png_ptr->num_rows = png_ptr->height;
2969 png_ptr->iwidth = (png_ptr->width +
2970 png_pass_inc[png_ptr->pass] - 1 -
2971 png_pass_start[png_ptr->pass]) /
2972 png_pass_inc[png_ptr->pass];
2974 row_bytes = PNG_ROWBYTES(png_ptr->pixel_depth,png_ptr->iwidth) + 1;
2976 png_ptr->irowbytes = (png_size_t)row_bytes;
2977 if((png_uint_32)png_ptr->irowbytes != row_bytes)
2978 png_error(png_ptr, "Rowbytes overflow in png_read_start_row");
2982 png_ptr->num_rows = png_ptr->height;
2983 png_ptr->iwidth = png_ptr->width;
2984 png_ptr->irowbytes = png_ptr->rowbytes + 1;
2986 max_pixel_depth = png_ptr->pixel_depth;
2989 if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
2994 if (png_ptr->transformations & PNG_EXPAND)
2996 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
2998 if (png_ptr->num_trans)
3003 else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
3007 if (png_ptr->num_trans)
3010 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
3012 if (png_ptr->num_trans)
3022 if (png_ptr->transformations & (PNG_FILLER))
3024 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
3026 else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
3033 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
3044 if (png_ptr->transformations & PNG_GRAY_TO_RGB)
3048 (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
3051 (png_ptr->transformations & (PNG_FILLER)) ||
3053 png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
3064 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
3069 else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
3079 if(png_ptr->transformations & PNG_USER_TRANSFORM)
3081 int user_pixel_depth=png_ptr->user_transform_depth*
3082 png_ptr->user_transform_channels;
3090 row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
3097 png_error(png_ptr, "This image requires a row greater than 64KB");
3099 png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64);
3100 png_ptr->row_buf = png_ptr->big_row_buf+32;
3102 png_ptr->row_buf_size = row_bytes;
3106 if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)
3107 png_error(png_ptr, "This image requires a row greater than 64KB");
3109 if ((png_uint_32)png_ptr->rowbytes + 1 > PNG_SIZE_MAX)
3110 png_error(png_ptr, "Row has too many bytes to allocate in memory.");
3111 png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(
3112 png_ptr->rowbytes + 1));
3114 png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
3116 png_debug1(3, "width = %lu,\n", png_ptr->width);
3117 png_debug1(3, "height = %lu,\n", png_ptr->height);
3118 png_debug1(3, "iwidth = %lu,\n", png_ptr->iwidth);
3119 png_debug1(3, "num_rows = %lu\n", png_ptr->num_rows);
3120 png_debug1(3, "rowbytes = %lu,\n", png_ptr->rowbytes);
3121 png_debug1(3, "irowbytes = %lu,\n", png_ptr->irowbytes);
3123 png_ptr->flags |= PNG_FLAG_ROW_INIT;