Lines Matching refs:png_ptr
30 png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
45 png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
49 if (png_ptr != NULL)
51 png_ptr->mode = PNG_IS_READ_STRUCT;
59 png_ptr->IDAT_read_size = PNG_INFLATE_MAX_SIZE;
61 png_ptr->IDAT_read_size = PNG_IDAT_READ_SIZE;
66 png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
72 png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;
80 png_set_read_fn(png_ptr, NULL, NULL);
83 return png_ptr;
97 png_read_info(png_structrp png_ptr, png_inforp info_ptr)
105 if (png_ptr == NULL || info_ptr == NULL)
109 png_read_sig(png_ptr, info_ptr);
113 png_uint_32 length = png_read_chunk_header(png_ptr);
114 png_uint_32 chunk_name = png_ptr->chunk_name;
121 if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
122 png_chunk_error(png_ptr, "Missing IHDR before IDAT");
124 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
125 (png_ptr->mode & PNG_HAVE_PLTE) == 0)
126 png_chunk_error(png_ptr, "Missing PLTE before IDAT");
128 else if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
129 png_chunk_benign_error(png_ptr, "Too many IDATs found");
131 png_ptr->mode |= PNG_HAVE_IDAT;
134 else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
136 png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
137 png_ptr->mode |= PNG_AFTER_IDAT;
144 png_handle_IHDR(png_ptr, info_ptr, length);
147 png_handle_IEND(png_ptr, info_ptr, length);
150 else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
152 png_handle_unknown(png_ptr, info_ptr, length, keep);
155 png_ptr->mode |= PNG_HAVE_PLTE;
159 png_ptr->idat_size = 0; /* It has been consumed */
165 png_handle_PLTE(png_ptr, info_ptr, length);
169 png_ptr->idat_size = length;
175 png_handle_bKGD(png_ptr, info_ptr, length);
180 png_handle_cHRM(png_ptr, info_ptr, length);
185 png_handle_eXIf(png_ptr, info_ptr, length);
190 png_handle_gAMA(png_ptr, info_ptr, length);
195 png_handle_hIST(png_ptr, info_ptr, length);
200 png_handle_oFFs(png_ptr, info_ptr, length);
205 png_handle_pCAL(png_ptr, info_ptr, length);
210 png_handle_sCAL(png_ptr, info_ptr, length);
215 png_handle_pHYs(png_ptr, info_ptr, length);
220 png_handle_sBIT(png_ptr, info_ptr, length);
225 png_handle_sRGB(png_ptr, info_ptr, length);
230 png_handle_iCCP(png_ptr, info_ptr, length);
235 png_handle_sPLT(png_ptr, info_ptr, length);
240 png_handle_tEXt(png_ptr, info_ptr, length);
245 png_handle_tIME(png_ptr, info_ptr, length);
250 png_handle_tRNS(png_ptr, info_ptr, length);
255 png_handle_zTXt(png_ptr, info_ptr, length);
260 png_handle_iTXt(png_ptr, info_ptr, length);
264 png_handle_unknown(png_ptr, info_ptr, length,
272 png_read_update_info(png_structrp png_ptr, png_inforp info_ptr)
276 if (png_ptr != NULL)
278 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
280 png_read_start_row(png_ptr);
283 png_read_transform_info(png_ptr, info_ptr);
291 png_app_error(png_ptr,
303 png_start_read_image(png_structrp png_ptr)
307 if (png_ptr != NULL)
309 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
310 png_read_start_row(png_ptr);
314 png_app_error(png_ptr,
388 png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
392 if (png_ptr == NULL)
396 (unsigned long)png_ptr->row_number, png_ptr->pass);
401 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
402 png_read_start_row(png_ptr);
405 row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */
406 row_info.color_type = png_ptr->color_type;
407 row_info.bit_depth = png_ptr->bit_depth;
408 row_info.channels = png_ptr->channels;
409 row_info.pixel_depth = png_ptr->pixel_depth;
413 if (png_ptr->row_number == 0 && png_ptr->pass == 0)
417 if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
418 png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");
422 if ((png_ptr->transformations & PNG_FILLER) != 0)
423 png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");
428 if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
429 png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");
433 if ((png_ptr->transformations & PNG_PACK) != 0)
434 png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");
438 if ((png_ptr->transformations & PNG_SHIFT) != 0)
439 png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");
443 if ((png_ptr->transformations & PNG_BGR) != 0)
444 png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");
448 if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
449 png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");
461 if (png_ptr->interlaced != 0 &&
462 (png_ptr->transformations & PNG_INTERLACE) != 0)
464 switch (png_ptr->pass)
467 if (png_ptr->row_number & 0x07)
470 png_combine_row(png_ptr, dsp_row, 1/*display*/);
471 png_read_finish_row(png_ptr);
477 if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
480 png_combine_row(png_ptr, dsp_row, 1/*display*/);
482 png_read_finish_row(png_ptr);
488 if ((png_ptr->row_number & 0x07) != 4)
490 if (dsp_row != NULL && (png_ptr->row_number & 4))
491 png_combine_row(png_ptr, dsp_row, 1/*display*/);
493 png_read_finish_row(png_ptr);
499 if ((png_ptr->row_number & 3) || png_ptr->width < 3)
502 png_combine_row(png_ptr, dsp_row, 1/*display*/);
504 png_read_finish_row(png_ptr);
510 if ((png_ptr->row_number & 3) != 2)
512 if (dsp_row != NULL && (png_ptr->row_number & 2))
513 png_combine_row(png_ptr, dsp_row, 1/*display*/);
515 png_read_finish_row(png_ptr);
521 if ((png_ptr->row_number & 1) || png_ptr->width < 2)
524 png_combine_row(png_ptr, dsp_row, 1/*display*/);
526 png_read_finish_row(png_ptr);
533 if ((png_ptr->row_number & 1) == 0)
535 png_read_finish_row(png_ptr);
543 if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
544 png_error(png_ptr, "Invalid attempt to read row data");
547 png_ptr->row_buf[0]=255; /* to force error if no data was found */
548 png_read_IDAT_data(png_ptr, png_ptr->row_buf, row_info.rowbytes + 1);
550 if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
552 if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
553 png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
554 png_ptr->prev_row + 1, png_ptr->row_buf[0]);
556 png_error(png_ptr, "bad adaptive filter value");
559 /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before
564 memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
567 if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
568 (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
571 png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);
576 if (png_ptr->transformations)
577 png_do_read_transformations(png_ptr, &row_info);
581 if (png_ptr->transformed_pixel_depth == 0)
583 png_ptr->transformed_pixel_depth = row_info.pixel_depth;
584 if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
585 png_error(png_ptr, "sequential row overflow");
588 else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
589 png_error(png_ptr, "internal sequential row size calculation error");
593 if (png_ptr->interlaced != 0 &&
594 (png_ptr->transformations & PNG_INTERLACE) != 0)
596 if (png_ptr->pass < 6)
597 png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
598 png_ptr->transformations);
601 png_combine_row(png_ptr, dsp_row, 1/*display*/);
604 png_combine_row(png_ptr, row, 0/*row*/);
611 png_combine_row(png_ptr, row, -1/*ignored*/);
614 png_combine_row(png_ptr, dsp_row, -1/*ignored*/);
616 png_read_finish_row(png_ptr);
618 if (png_ptr->read_row_fn != NULL)
619 (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
650 png_read_rows(png_structrp png_ptr, png_bytepp row,
659 if (png_ptr == NULL)
670 png_read_row(png_ptr, rptr, dptr);
677 png_read_row(png_ptr, rptr, NULL);
685 png_read_row(png_ptr, NULL, dptr);
695 static void png_read_two_rows(png_structrp png_ptr, png_bytepp rows, png_uint_32 i,
698 png_debug1(1, "in png_read_two_rows %d", png_ptr->row_buf[0]);
699 png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
700 png_ptr->prev_row + 1, png_ptr->row_buf[0] + 4); // 4 is the increment of x2_filter
703 if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
704 (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
707 png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);
712 if (png_ptr->transformations
714 || png_ptr->num_palette_max >= 0
717 png_do_read_transformations(png_ptr, &row_info);
721 if (png_ptr->transformed_pixel_depth == 0)
723 png_ptr->transformed_pixel_depth = row_info.pixel_depth;
724 if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
725 png_error(png_ptr, "sequential row overflow");
728 else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
729 png_error(png_ptr, "internal sequential row size calculation error");
732 png_combine_row(png_ptr, rows[i], -1);
734 png_read_finish_row(png_ptr);
736 if (png_ptr->read_row_fn != NULL)
737 (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
739 png_ptr->row_buf = png_ptr->row_buf + row_info.rowbytes + 1;
742 memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
745 if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
746 (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
749 png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);
754 if (png_ptr->transformations
756 || png_ptr->num_palette_max >= 0
759 png_do_read_transformations(png_ptr, &row_info);
763 if (png_ptr->transformed_pixel_depth == 0)
765 png_ptr->transformed_pixel_depth = row_info.pixel_depth;
766 if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
767 png_error(png_ptr, "sequential row overflow");
770 else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
771 png_error(png_ptr, "internal sequential row size calculation error");
774 png_combine_row(png_ptr, rows[i+1], -1);
776 png_read_finish_row(png_ptr);
778 if (png_ptr->read_row_fn != NULL)
779 (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
781 png_ptr->row_buf = png_ptr->row_buf + row_info.rowbytes + 1;
784 static void png_read_muilty_rows(png_structrp png_ptr, png_bytepp rows,
787 if (png_ptr == NULL)
791 (unsigned long)png_ptr->row_number, png_ptr->pass);
793 if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
794 png_error(png_ptr, "Invalid attempt to read row data");
798 png_ptr->row_buf[0]=255; /* 255 to force error if no data was found */
799 png_read_IDAT_data(png_ptr, png_ptr->row_buf, (row_bytes + 1) * row_num);
800 png_bytep temp_row = png_ptr->row_buf;
806 i < row_num -1 && png_ptr->row_buf[0] > PNG_FILTER_VALUE_SUB &&
807 png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST &&
808 png_ptr->row_buf[0] == png_ptr->row_buf[row_info_in.rowbytes + 1])
810 png_read_two_rows(png_ptr, rows, i, row_info);
814 if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
816 if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
817 png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
818 png_ptr->prev_row + 1, png_ptr->row_buf[0]);
820 png_debug1(1, "bad adaptive filter value %d", png_ptr->row_buf[0]);
823 memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info_in.rowbytes + 1);
826 if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
827 (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
830 png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);
835 if (png_ptr->transformations
837 || png_ptr->num_palette_max >= 0
840 png_do_read_transformations(png_ptr, &row_info);
844 if (png_ptr->transformed_pixel_depth == 0)
846 png_ptr->transformed_pixel_depth = row_info.pixel_depth;
847 if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
848 png_error(png_ptr, "sequential row overflow");
851 else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
852 png_error(png_ptr, "internal sequential row size calculation error");
855 png_combine_row(png_ptr, rows[i], -1);
857 png_read_finish_row(png_ptr);
859 if (png_ptr->read_row_fn != NULL)
860 (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
862 png_ptr->row_buf = png_ptr->row_buf + row_bytes + 1;
864 png_ptr->row_buf = temp_row;
867 static void png_warn_check(png_structrp png_ptr)
872 if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
873 png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");
877 if ((png_ptr->transformations & PNG_FILLER) != 0)
878 png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");
883 if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
884 png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");
888 if ((png_ptr->transformations & PNG_PACK) != 0)
889 png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");
893 if ((png_ptr->transformations & PNG_SHIFT) != 0)
894 png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");
898 if ((png_ptr->transformations & PNG_BGR) != 0)
899 png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");
903 if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
904 png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");
923 png_read_image(png_structrp png_ptr, png_bytepp image)
931 if (png_ptr == NULL)
935 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
937 pass = png_set_interlace_handling(png_ptr);
939 png_start_read_image(png_ptr);
943 if (png_ptr->interlaced != 0 &&
944 (png_ptr->transformations & PNG_INTERLACE) == 0)
950 png_warning(png_ptr, "Interlace handling should be turned on when "
953 png_ptr->num_rows = png_ptr->height;
959 pass = png_set_interlace_handling(png_ptr);
962 if (png_ptr->interlaced)
963 png_error(png_ptr,
969 image_height=png_ptr->height;
973 if (png_ptr->interlaced == 0 && png_ptr->bit_depth == 8 && // 8 is 1 pixel 8 bytes
974 (png_ptr->transformations & PNG_CHECK) == 0) {
975 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
976 png_read_start_row(png_ptr);
978 png_warn_check(png_ptr);
980 row_info.width = png_ptr->iwidth;
981 row_info.color_type = png_ptr->color_type;
982 row_info.bit_depth = png_ptr->bit_depth;
983 row_info.channels = png_ptr->channels;
984 row_info.pixel_depth = png_ptr->pixel_depth;
985 row_info.rowbytes = png_ptr->rowbytes;
995 png_read_muilty_rows(png_ptr, rp, row_num, row_info);
1007 png_read_row(png_ptr, *rp, NULL);
1021 png_read_end(png_structrp png_ptr, png_inforp info_ptr)
1029 if (png_ptr == NULL)
1036 if (png_chunk_unknown_handling(png_ptr, png_IDAT) == 0)
1038 png_read_finish_IDAT(png_ptr);
1042 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
1043 png_ptr->num_palette_max > png_ptr->num_palette)
1044 png_benign_error(png_ptr, "Read palette index exceeding num_palette");
1049 png_uint_32 length = png_read_chunk_header(png_ptr);
1050 png_uint_32 chunk_name = png_ptr->chunk_name;
1053 png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
1056 png_handle_IEND(png_ptr, info_ptr, length);
1059 png_handle_IHDR(png_ptr, info_ptr, length);
1062 png_crc_finish(png_ptr, length);
1065 else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
1069 if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
1070 || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
1071 png_benign_error(png_ptr, ".Too many IDATs found");
1073 png_handle_unknown(png_ptr, info_ptr, length, keep);
1075 png_ptr->mode |= PNG_HAVE_PLTE;
1087 if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
1088 || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
1089 png_benign_error(png_ptr, "..Too many IDATs found");
1091 png_crc_finish(png_ptr, length);
1094 png_handle_PLTE(png_ptr, info_ptr, length);
1098 png_handle_bKGD(png_ptr, info_ptr, length);
1103 png_handle_cHRM(png_ptr, info_ptr, length);
1108 png_handle_eXIf(png_ptr, info_ptr, length);
1113 png_handle_gAMA(png_ptr, info_ptr, length);
1118 png_handle_hIST(png_ptr, info_ptr, length);
1123 png_handle_oFFs(png_ptr, info_ptr, length);
1128 png_handle_pCAL(png_ptr, info_ptr, length);
1133 png_handle_sCAL(png_ptr, info_ptr, length);
1138 png_handle_pHYs(png_ptr, info_ptr, length);
1143 png_handle_sBIT(png_ptr, info_ptr, length);
1148 png_handle_sRGB(png_ptr, info_ptr, length);
1153 png_handle_iCCP(png_ptr, info_ptr, length);
1158 png_handle_sPLT(png_ptr, info_ptr, length);
1163 png_handle_tEXt(png_ptr, info_ptr, length);
1168 png_handle_tIME(png_ptr, info_ptr, length);
1173 png_handle_tRNS(png_ptr, info_ptr, length);
1178 png_handle_zTXt(png_ptr, info_ptr, length);
1183 png_handle_iTXt(png_ptr, info_ptr, length);
1187 png_handle_unknown(png_ptr, info_ptr, length,
1189 } while ((png_ptr->mode & PNG_HAVE_IEND) == 0);
1195 png_read_destroy(png_structrp png_ptr)
1200 png_destroy_gamma_table(png_ptr);
1203 png_free(png_ptr, png_ptr->big_row_buf);
1204 png_ptr->big_row_buf = NULL;
1205 png_free(png_ptr, png_ptr->big_prev_row);
1206 png_ptr->big_prev_row = NULL;
1207 png_free(png_ptr, png_ptr->read_buffer);
1208 png_ptr->read_buffer = NULL;
1211 png_free(png_ptr, png_ptr->palette_lookup);
1212 png_ptr->palette_lookup = NULL;
1213 png_free(png_ptr, png_ptr->quantize_index);
1214 png_ptr->quantize_index = NULL;
1217 if ((png_ptr->free_me & PNG_FREE_PLTE) != 0)
1219 png_zfree(png_ptr, png_ptr->palette);
1220 png_ptr->palette = NULL;
1222 png_ptr->free_me &= ~PNG_FREE_PLTE;
1226 if ((png_ptr->free_me & PNG_FREE_TRNS) != 0)
1228 png_free(png_ptr, png_ptr->trans_alpha);
1229 png_ptr->trans_alpha = NULL;
1231 png_ptr->free_me &= ~PNG_FREE_TRNS;
1234 inflateEnd(&png_ptr->zstream);
1237 png_free(png_ptr, png_ptr->save_buffer);
1238 png_ptr->save_buffer = NULL;
1243 png_free(png_ptr, png_ptr->unknown_chunk.data);
1244 png_ptr->unknown_chunk.data = NULL;
1248 png_free(png_ptr, png_ptr->chunk_list);
1249 png_ptr->chunk_list = NULL;
1254 png_free(png_ptr, png_ptr->riffled_palette);
1255 png_ptr->riffled_palette = NULL;
1269 png_structrp png_ptr = NULL;
1274 png_ptr = *png_ptr_ptr;
1276 if (png_ptr == NULL)
1283 png_destroy_info_struct(png_ptr, end_info_ptr_ptr);
1284 png_destroy_info_struct(png_ptr, info_ptr_ptr);
1287 png_read_destroy(png_ptr);
1288 png_destroy_png_struct(png_ptr);
1292 png_set_read_status_fn(png_structrp png_ptr, png_read_status_ptr read_row_fn)
1294 if (png_ptr == NULL)
1297 png_ptr->read_row_fn = read_row_fn;
1304 png_read_png(png_structrp png_ptr, png_inforp info_ptr,
1307 if (png_ptr == NULL || info_ptr == NULL)
1313 png_read_info(png_ptr, info_ptr);
1315 png_error(png_ptr, "Image is too high to process with png_read_png()");
1331 png_set_scale_16(png_ptr);
1333 png_app_error(png_ptr, "PNG_TRANSFORM_SCALE_16 not supported");
1342 png_set_strip_16(png_ptr);
1344 png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_16 not supported");
1352 png_set_strip_alpha(png_ptr);
1354 png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_ALPHA not supported");
1362 png_set_packing(png_ptr);
1364 png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported");
1372 png_set_packswap(png_ptr);
1374 png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported");
1384 png_set_expand(png_ptr);
1386 png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND not supported");
1396 png_set_invert_mono(png_ptr);
1398 png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_MONO not supported");
1408 png_set_shift(png_ptr, &info_ptr->sig_bit);
1410 png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
1416 png_set_bgr(png_ptr);
1418 png_app_error(png_ptr, "PNG_TRANSFORM_BGR not supported");
1424 png_set_swap_alpha(png_ptr);
1426 png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ALPHA not supported");
1432 png_set_swap(png_ptr);
1434 png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ENDIAN not supported");
1441 png_set_invert_alpha(png_ptr);
1443 png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_ALPHA not supported");
1450 png_set_gray_to_rgb(png_ptr);
1452 png_app_error(png_ptr, "PNG_TRANSFORM_GRAY_TO_RGB not supported");
1458 png_set_expand_16(png_ptr);
1460 png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND_16 not supported");
1468 (void)png_set_interlace_handling(png_ptr);
1474 png_read_update_info(png_ptr, info_ptr);
1478 png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
1483 info_ptr->row_pointers = png_voidcast(png_bytepp, png_malloc(png_ptr,
1493 png_malloc(png_ptr, info_ptr->rowbytes));
1496 png_read_image(png_ptr, info_ptr->row_pointers);
1500 png_read_end(png_ptr, info_ptr);
1565 png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, image,
1574 if (png_ptr != NULL)
1576 png_infop info_ptr = png_create_info_struct(png_ptr);
1581 png_malloc_warn(png_ptr, (sizeof *control)));
1587 control->png_ptr = png_ptr;
1596 png_destroy_info_struct(png_ptr, &info_ptr);
1599 png_destroy_read_struct(&png_ptr, NULL, NULL);
1610 png_image_format(png_structrp png_ptr)
1614 if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
1617 if ((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
1620 /* Use png_ptr here, not info_ptr, because by examination png_handle_tRNS
1625 else if (png_ptr->num_trans > 0)
1628 if (png_ptr->bit_depth == 16)
1631 if ((png_ptr->color_type & PNG_COLOR_MASK_PALETTE) != 0)
1665 png_structrp png_ptr = image->opaque->png_ptr;
1669 png_set_benign_errors(png_ptr, 1/*warn*/);
1671 png_read_info(png_ptr, info_ptr);
1674 image->width = png_ptr->width;
1675 image->height = png_ptr->height;
1678 png_uint_32 format = png_image_format(png_ptr);
1688 if ((format & PNG_FORMAT_FLAG_COLOR) != 0 && ((png_ptr->colorspace.flags
1701 switch (png_ptr->color_type)
1704 cmap_entries = 1U << png_ptr->bit_depth;
1708 cmap_entries = (png_uint_32)png_ptr->num_palette;
1739 image->opaque->png_ptr->io_ptr = file;
1769 image->opaque->png_ptr->io_ptr = fp;
1796 png_image_memory_read(png_structp png_ptr, png_bytep out, size_t need)
1798 if (png_ptr != NULL)
1800 png_imagep image = png_voidcast(png_imagep, png_ptr->io_ptr);
1817 png_error(png_ptr, "read beyond end of data");
1821 png_error(png_ptr, "invalid memory read");
1840 image->opaque->png_ptr->io_ptr = image;
1841 image->opaque->png_ptr->read_data_fn = png_image_memory_read;
1864 png_image_skip_unused_chunks(png_structrp png_ptr)
1899 png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_NEVER,
1903 png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT,
1923 png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma;
1971 png_error(display->image->opaque->png_ptr,
2028 png_error(image->opaque->png_ptr, "color-map index out of range");
2128 png_error(image->opaque->png_ptr, "bad encoding (internal error)");
2351 png_structrp png_ptr = image->opaque->png_ptr;
2374 if (((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0 ||
2375 png_ptr->num_trans > 0) /* alpha in input */ &&
2382 png_error(png_ptr,
2413 if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) == 0)
2420 if (png_ptr->bit_depth == 16 &&
2422 png_ptr->colorspace.gamma = PNG_GAMMA_LINEAR;
2425 png_ptr->colorspace.gamma = PNG_GAMMA_sRGB_INVERSE;
2427 png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
2435 switch (png_ptr->color_type)
2438 if (png_ptr->bit_depth <= 8)
2445 cmap_entries = 1U << png_ptr->bit_depth;
2447 png_error(png_ptr, "gray[8] color-map: too few entries");
2455 if (png_ptr->num_trans > 0)
2457 trans = png_ptr->trans_color.gray;
2501 if (png_ptr->bit_depth < 8)
2502 png_set_packing(png_ptr);
2526 png_error(png_ptr, "gray[16] color-map: too few entries");
2530 if (png_ptr->num_trans > 0)
2568 png_set_background_fixed(png_ptr, &c,
2624 png_error(png_ptr, "gray+alpha color-map: too few entries");
2658 png_error(png_ptr, "gray-alpha color-map: too few entries");
2677 png_set_background_fixed(png_ptr, &c,
2692 png_error(png_ptr, "ga-alpha color-map: too few entries");
2779 png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1,
2786 if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2787 png_ptr->num_trans > 0) &&
2797 png_error(png_ptr, "rgb[ga] color-map: too few entries");
2811 png_error(png_ptr, "rgb[gray] color-map: too few entries");
2821 if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2822 png_ptr->num_trans > 0) &&
2823 png_gamma_not_sRGB(png_ptr->colorspace.gamma) != 0)
2834 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2835 png_ptr->num_trans > 0)
2856 png_ptr->colorspace.gamma)); /* now P_FILE */
2886 png_set_background_fixed(png_ptr, &c,
2905 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2906 png_ptr->num_trans > 0)
2916 png_error(png_ptr, "rgb+alpha color-map: too few entries");
2965 png_error(png_ptr, "rgb-alpha color-map: too few entries");
3035 png_set_background_fixed(png_ptr, &c,
3050 png_error(png_ptr, "rgb color-map: too few entries");
3063 unsigned int num_trans = png_ptr->num_trans;
3064 png_const_bytep trans = num_trans > 0 ? png_ptr->trans_alpha : NULL;
3065 png_const_colorp colormap = png_ptr->palette;
3076 cmap_entries = (unsigned int)png_ptr->num_palette;
3081 png_error(png_ptr, "palette color-map: too few entries");
3118 if (png_ptr->bit_depth < 8)
3119 png_set_packing(png_ptr);
3124 png_error(png_ptr, "invalid PNG color type");
3129 if (expand_tRNS != 0 && png_ptr->num_trans > 0 &&
3130 (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) == 0)
3131 png_set_tRNS_to_alpha(png_ptr);
3137 png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_sRGB);
3141 if (png_ptr->bit_depth > 8)
3142 png_set_scale_16(png_ptr);
3147 png_error(png_ptr, "bad data option (internal error)");
3152 png_error(png_ptr, "color map overflow (BAD internal error)");
3186 png_error(png_ptr, "bad processing option (internal error)");
3189 png_error(png_ptr, "bad background index (internal error)");
3204 png_structrp png_ptr = image->opaque->png_ptr;
3211 switch (png_ptr->interlaced)
3222 png_error(png_ptr, "unknown interlace type");
3238 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
3264 png_read_row(png_ptr, inrow, NULL);
3394 png_structrp png_ptr = control->png_ptr;
3399 PNG_SKIP_CHUNKS(png_ptr);
3406 passes = png_set_interlace_handling(png_ptr);
3408 png_read_update_info(png_ptr, info_ptr);
3432 png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
3442 png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
3452 png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
3460 png_error(png_ptr, "bad color-map processing (internal error)");
3488 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
3493 png_free(png_ptr, row);
3509 png_read_row(png_ptr, row, NULL);
3525 png_structrp png_ptr = image->opaque->png_ptr;
3528 switch (png_ptr->interlaced)
3539 png_error(png_ptr, "unknown interlace type");
3555 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
3582 png_read_row(png_ptr, inrow, NULL);
3652 png_structrp png_ptr = image->opaque->png_ptr;
3663 if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
3664 png_error(png_ptr, "lost rgb to gray");
3666 if ((png_ptr->transformations & PNG_COMPOSE) != 0)
3667 png_error(png_ptr, "unexpected compose");
3669 if (png_get_channels(png_ptr, info_ptr) != 2)
3670 png_error(png_ptr, "lost/gained channels");
3675 png_error(png_ptr, "unexpected 8-bit transformation");
3677 switch (png_ptr->interlaced)
3688 png_error(png_ptr, "unknown interlace type");
3714 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
3743 png_read_row(png_ptr, inrow, NULL);
3788 png_read_row(png_ptr, inrow, NULL);
3853 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
3880 png_read_row(png_ptr, png_voidcast(png_bytep,
3918 png_error(png_ptr, "unexpected bit depth");
3932 png_structrp png_ptr = image->opaque->png_ptr;
3945 png_set_expand(png_ptr);
3949 png_uint_32 base_format = png_image_format(png_ptr) &
3960 png_set_gray_to_rgb(png_ptr);
3980 png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE,
4001 png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, input_gamma_default);
4045 if (png_muldiv(>est, output_gamma, png_ptr->colorspace.gamma,
4062 png_set_expand_16(png_ptr);
4065 png_set_scale_16(png_ptr);
4089 png_set_strip_alpha(png_ptr);
4108 png_set_background_fixed(png_ptr, &c,
4152 png_set_add_alpha(png_ptr, filler, where);
4163 png_set_alpha_mode_fixed(png_ptr, mode, output_gamma);
4172 png_set_bgr(png_ptr);
4195 png_set_swap_alpha(png_ptr);
4213 png_set_swap(png_ptr);
4218 png_error(png_ptr, "png_read_image: unsupported transformation");
4221 PNG_SKIP_CHUNKS(png_ptr);
4230 passes = png_set_interlace_handling(png_ptr);
4232 png_read_update_info(png_ptr, info_ptr);
4253 png_error(png_ptr, "png_image_read: alpha channel lost");
4263 if ((png_ptr->transformations & PNG_BGR) != 0)
4274 if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0 ||
4275 ((png_ptr->transformations & PNG_ADD_ALPHA) != 0 &&
4276 (png_ptr->flags & PNG_FLAG_FILLER_AFTER) == 0))
4279 png_error(png_ptr, "unexpected alpha swap transformation");
4287 png_error(png_ptr, "png_read_image: invalid transformations");
4319 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
4324 png_free(png_ptr, row);
4332 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
4337 png_free(png_ptr, row);
4353 png_read_row(png_ptr, row, NULL);