Lines Matching full: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;
57 png_ptr->IDAT_read_size = PNG_IDAT_READ_SIZE;
61 png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
67 png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;
75 png_set_read_fn(png_ptr, NULL, NULL);
78 return png_ptr;
92 png_read_info(png_structrp png_ptr, png_inforp info_ptr)
100 if (png_ptr == NULL || info_ptr == NULL)
104 png_read_sig(png_ptr, info_ptr);
108 png_uint_32 length = png_read_chunk_header(png_ptr);
109 png_uint_32 chunk_name = png_ptr->chunk_name;
116 if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
117 png_chunk_error(png_ptr, "Missing IHDR before IDAT");
119 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
120 (png_ptr->mode & PNG_HAVE_PLTE) == 0)
121 png_chunk_error(png_ptr, "Missing PLTE before IDAT");
123 else if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
124 png_chunk_benign_error(png_ptr, "Too many IDATs found");
126 png_ptr->mode |= PNG_HAVE_IDAT;
129 else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
131 png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
132 png_ptr->mode |= PNG_AFTER_IDAT;
139 png_handle_IHDR(png_ptr, info_ptr, length);
142 png_handle_IEND(png_ptr, info_ptr, length);
145 else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
147 png_handle_unknown(png_ptr, info_ptr, length, keep);
150 png_ptr->mode |= PNG_HAVE_PLTE;
154 png_ptr->idat_size = 0; /* It has been consumed */
160 png_handle_PLTE(png_ptr, info_ptr, length);
164 png_ptr->idat_size = length;
170 png_handle_bKGD(png_ptr, info_ptr, length);
175 png_handle_cHRM(png_ptr, info_ptr, length);
180 png_handle_gAMA(png_ptr, info_ptr, length);
185 png_handle_hIST(png_ptr, info_ptr, length);
190 png_handle_oFFs(png_ptr, info_ptr, length);
195 png_handle_pCAL(png_ptr, info_ptr, length);
200 png_handle_sCAL(png_ptr, info_ptr, length);
205 png_handle_pHYs(png_ptr, info_ptr, length);
210 png_handle_sBIT(png_ptr, info_ptr, length);
215 png_handle_sRGB(png_ptr, info_ptr, length);
220 png_handle_iCCP(png_ptr, info_ptr, length);
225 png_handle_sPLT(png_ptr, info_ptr, length);
230 png_handle_tEXt(png_ptr, info_ptr, length);
235 png_handle_tIME(png_ptr, info_ptr, length);
240 png_handle_tRNS(png_ptr, info_ptr, length);
245 png_handle_zTXt(png_ptr, info_ptr, length);
250 png_handle_iTXt(png_ptr, info_ptr, length);
254 png_handle_unknown(png_ptr, info_ptr, length,
262 png_read_update_info(png_structrp png_ptr, png_inforp info_ptr)
266 if (png_ptr != NULL)
268 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
270 png_read_start_row(png_ptr);
273 png_read_transform_info(png_ptr, info_ptr);
281 png_app_error(png_ptr,
293 png_start_read_image(png_structrp png_ptr)
297 if (png_ptr != NULL)
299 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
300 png_read_start_row(png_ptr);
304 png_app_error(png_ptr,
378 png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
382 if (png_ptr == NULL)
386 (unsigned long)png_ptr->row_number, png_ptr->pass);
391 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
392 png_read_start_row(png_ptr);
395 row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */
396 row_info.color_type = png_ptr->color_type;
397 row_info.bit_depth = png_ptr->bit_depth;
398 row_info.channels = png_ptr->channels;
399 row_info.pixel_depth = png_ptr->pixel_depth;
403 if (png_ptr->row_number == 0 && png_ptr->pass == 0)
407 if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
408 png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");
412 if ((png_ptr->transformations & PNG_FILLER) != 0)
413 png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");
418 if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
419 png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");
423 if ((png_ptr->transformations & PNG_PACK) != 0)
424 png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");
428 if ((png_ptr->transformations & PNG_SHIFT) != 0)
429 png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");
433 if ((png_ptr->transformations & PNG_BGR) != 0)
434 png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");
438 if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
439 png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");
451 if (png_ptr->interlaced != 0 &&
452 (png_ptr->transformations & PNG_INTERLACE) != 0)
454 switch (png_ptr->pass)
457 if (png_ptr->row_number & 0x07)
460 png_combine_row(png_ptr, dsp_row, 1/*display*/);
461 png_read_finish_row(png_ptr);
467 if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
470 png_combine_row(png_ptr, dsp_row, 1/*display*/);
472 png_read_finish_row(png_ptr);
478 if ((png_ptr->row_number & 0x07) != 4)
480 if (dsp_row != NULL && (png_ptr->row_number & 4))
481 png_combine_row(png_ptr, dsp_row, 1/*display*/);
483 png_read_finish_row(png_ptr);
489 if ((png_ptr->row_number & 3) || png_ptr->width < 3)
492 png_combine_row(png_ptr, dsp_row, 1/*display*/);
494 png_read_finish_row(png_ptr);
500 if ((png_ptr->row_number & 3) != 2)
502 if (dsp_row != NULL && (png_ptr->row_number & 2))
503 png_combine_row(png_ptr, dsp_row, 1/*display*/);
505 png_read_finish_row(png_ptr);
511 if ((png_ptr->row_number & 1) || png_ptr->width < 2)
514 png_combine_row(png_ptr, dsp_row, 1/*display*/);
516 png_read_finish_row(png_ptr);
523 if ((png_ptr->row_number & 1) == 0)
525 png_read_finish_row(png_ptr);
533 if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
534 png_error(png_ptr, "Invalid attempt to read row data");
537 png_read_IDAT_data(png_ptr, png_ptr
539 if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
541 if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
542 png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
543 png_ptr->prev_row + 1, png_ptr->row_buf[0]);
545 png_error(png_ptr, "bad adaptive filter value");
548 /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before
553 memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
556 if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
557 (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
560 png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);
565 if (png_ptr->transformations)
566 png_do_read_transformations(png_ptr, &row_info);
570 if (png_ptr->transformed_pixel_depth == 0)
572 png_ptr->transformed_pixel_depth = row_info.pixel_depth;
573 if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
574 png_error(png_ptr, "sequential row overflow");
577 else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
578 png_error(png_ptr, "internal sequential row size calculation error");
582 if (png_ptr->interlaced != 0 &&
583 (png_ptr->transformations & PNG_INTERLACE) != 0)
585 if (png_ptr->pass < 6)
586 png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
587 png_ptr->transformations);
590 png_combine_row(png_ptr, dsp_row, 1/*display*/);
593 png_combine_row(png_ptr, row, 0/*row*/);
600 png_combine_row(png_ptr, row, -1/*ignored*/);
603 png_combine_row(png_ptr, dsp_row, -1/*ignored*/);
605 png_read_finish_row(png_ptr);
607 if (png_ptr->read_row_fn != NULL)
608 (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
639 png_read_rows(png_structrp png_ptr, png_bytepp row,
648 if (png_ptr == NULL)
659 png_read_row(png_ptr, rptr, dptr);
666 png_read_row(png_ptr, rptr, NULL);
674 png_read_row(png_ptr, NULL, dptr);
694 png_read_image(png_structrp png_ptr, png_bytepp image)
702 if (png_ptr == NULL)
706 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
708 pass = png_set_interlace_handling(png_ptr);
710 png_start_read_image(png_ptr);
714 if (png_ptr->interlaced != 0 &&
715 (png_ptr->transformations & PNG_INTERLACE) == 0)
721 png_warning(png_ptr, "Interlace handling should be turned on when "
724 png_ptr->num_rows = png_ptr->height;
730 pass = png_set_interlace_handling(png_ptr);
733 if (png_ptr->interlaced)
734 png_error(png_ptr,
740 image_height=png_ptr->height;
747 png_read_row(png_ptr, *rp, NULL);
760 png_read_end(png_structrp png_ptr, png_inforp info_ptr)
768 if (png_ptr == NULL)
775 if (png_chunk_unknown_handling(png_ptr, png_IDAT) == 0)
777 png_read_finish_IDAT(png_ptr);
781 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
782 png_ptr->num_palette_max > png_ptr->num_palette)
783 png_benign_error(png_ptr, "Read palette index exceeding num_palette");
788 png_uint_32 length = png_read_chunk_header(png_ptr);
789 png_uint_32 chunk_name = png_ptr->chunk_name;
792 png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
795 png_handle_IEND(png_ptr, info_ptr, length);
798 png_handle_IHDR(png_ptr, info_ptr, length);
801 png_crc_finish(png_ptr, length);
804 else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
808 if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
809 || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
810 png_benign_error(png_ptr, ".Too many IDATs found");
812 png_handle_unknown(png_ptr, info_ptr, length, keep);
814 png_ptr->mode |= PNG_HAVE_PLTE;
826 if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
827 || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
828 png_benign_error(png_ptr, "..Too many IDATs found");
830 png_crc_finish(png_ptr, length);
833 png_handle_PLTE(png_ptr, info_ptr, length);
837 png_handle_bKGD(png_ptr, info_ptr, length);
842 png_handle_cHRM(png_ptr, info_ptr, length);
847 png_handle_gAMA(png_ptr, info_ptr, length);
852 png_handle_hIST(png_ptr, info_ptr, length);
857 png_handle_oFFs(png_ptr, info_ptr, length);
862 png_handle_pCAL(png_ptr, info_ptr, length);
867 png_handle_sCAL(png_ptr, info_ptr, length);
872 png_handle_pHYs(png_ptr, info_ptr, length);
877 png_handle_sBIT(png_ptr, info_ptr, length);
882 png_handle_sRGB(png_ptr, info_ptr, length);
887 png_handle_iCCP(png_ptr, info_ptr, length);
892 png_handle_sPLT(png_ptr, info_ptr, length);
897 png_handle_tEXt(png_ptr, info_ptr, length);
902 png_handle_tIME(png_ptr, info_ptr, length);
907 png_handle_tRNS(png_ptr, info_ptr, length);
912 png_handle_zTXt(png_ptr, info_ptr, length);
917 png_handle_iTXt(png_ptr, info_ptr, length);
921 png_handle_unknown(png_ptr, info_ptr, length,
923 } while ((png_ptr->mode & PNG_HAVE_IEND) == 0);
929 png_read_destroy(png_structrp png_ptr)
934 png_destroy_gamma_table(png_ptr);
937 png_free(png_ptr, png_ptr->big_row_buf);
938 png_ptr->big_row_buf = NULL;
939 png_free(png_ptr, png_ptr->big_prev_row);
940 png_ptr->big_prev_row = NULL;
941 png_free(png_ptr, png_ptr->read_buffer);
942 png_ptr->read_buffer = NULL;
945 png_free(png_ptr, png_ptr->palette_lookup);
946 png_ptr->palette_lookup = NULL;
947 png_free(png_ptr, png_ptr->quantize_index);
948 png_ptr->quantize_index = NULL;
951 if ((png_ptr->free_me & PNG_FREE_PLTE) != 0)
953 png_zfree(png_ptr, png_ptr->palette);
954 png_ptr->palette = NULL;
956 png_ptr->free_me &= ~PNG_FREE_PLTE;
960 if ((png_ptr->free_me & PNG_FREE_TRNS) != 0)
962 png_free(png_ptr, png_ptr->trans_alpha);
963 png_ptr->trans_alpha = NULL;
965 png_ptr->free_me &= ~PNG_FREE_TRNS;
968 inflateEnd(&png_ptr->zstream);
971 png_free(png_ptr, png_ptr->save_buffer);
972 png_ptr->save_buffer = NULL;
977 png_free(png_ptr, png_ptr->unknown_chunk.data);
978 png_ptr->unknown_chunk.data = NULL;
982 png_free(png_ptr, png_ptr->chunk_list);
983 png_ptr->chunk_list = NULL;
997 png_structrp png_ptr = NULL;
1002 png_ptr = *png_ptr_ptr;
1004 if (png_ptr == NULL)
1011 png_destroy_info_struct(png_ptr, end_info_ptr_ptr);
1012 png_destroy_info_struct(png_ptr, info_ptr_ptr);
1015 png_read_destroy(png_ptr);
1016 png_destroy_png_struct(png_ptr);
1020 png_set_read_status_fn(png_structrp png_ptr, png_read_status_ptr read_row_fn)
1022 if (png_ptr == NULL)
1025 png_ptr->read_row_fn = read_row_fn;
1032 png_read_png(png_structrp png_ptr, png_inforp info_ptr,
1036 if (png_ptr == NULL || info_ptr == NULL)
1042 png_read_info(png_ptr, info_ptr);
1044 png_error(png_ptr, "Image is too high to process with png_read_png()");
1060 png_set_scale_16(png_ptr);
1062 png_app_error(png_ptr
1071 png_set_strip_16(png_ptr);
1073 png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_16 not supported");
1081 png_set_strip_alpha(png_ptr);
1083 png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_ALPHA not supported");
1091 png_set_packing(png_ptr);
1093 png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported");
1101 png_set_packswap(png_ptr);
1103 png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported");
1113 png_set_expand(png_ptr);
1115 png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND not supported");
1125 png_set_invert_mono(png_ptr);
1127 png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_MONO not supported");
1137 png_set_shift(png_ptr, &info_ptr->sig_bit);
1139 png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
1145 png_set_bgr(png_ptr);
1147 png_app_error(png_ptr, "PNG_TRANSFORM_BGR not supported");
1153 png_set_swap_alpha(png_ptr);
1155 png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ALPHA not supported");
1161 png_set_swap(png_ptr);
1163 png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ENDIAN not supported");
1170 png_set_invert_alpha(png_ptr);
1172 png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_ALPHA not supported");
1179 png_set_gray_to_rgb(png_ptr);
1181 png_app_error(png_ptr, "PNG_TRANSFORM_GRAY_TO_RGB not supported");
1187 png_set_expand_16(png_ptr);
1189 png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND_16 not supported");
1197 (void)png_set_interlace_handling(png_ptr);
1203 png_read_update_info(png_ptr, info_ptr);
1207 png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
1212 info_ptr->row_pointers = png_voidcast(png_bytepp, png_malloc(png_ptr,
1222 png_malloc(png_ptr, info_ptr->rowbytes));
1225 png_read_image(png_ptr, info_ptr->row_pointers);
1229 png_read_end(png_ptr, info_ptr);
1294 png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, image,
1303 if (png_ptr != NULL)
1305 png_infop info_ptr = png_create_info_struct(png_ptr);
1310 png_malloc_warn(png_ptr, (sizeof *control)));
1316 control->png_ptr = png_ptr;
1325 png_destroy_info_struct(png_ptr, &info_ptr);
1328 png_destroy_read_struct(&png_ptr, NULL, NULL);
1339 png_image_format(png_structrp png_ptr)
1343 if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
1346 if ((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
1349 /* Use png_ptr here, not info_ptr, because by examination png_handle_tRNS
1354 else if (png_ptr->num_trans > 0)
1357 if (png_ptr->bit_depth == 16)
1360 if ((png_ptr->color_type & PNG_COLOR_MASK_PALETTE) != 0)
1394 png_structrp png_ptr = image->opaque->png_ptr;
1397 png_set_benign_errors(png_ptr, 1/*warn*/);
1398 png_read_info(png_ptr, info_ptr);
1401 image->width = png_ptr->width;
1402 image->height = png_ptr->height;
1405 png_uint_32 format = png_image_format(png_ptr);
1415 if ((format & PNG_FORMAT_FLAG_COLOR) != 0 && ((png_ptr->colorspace.flags
1428 switch (png_ptr->color_type)
1431 cmap_entries = 1U << png_ptr->bit_depth;
1435 cmap_entries = png_ptr->num_palette;
1466 image->opaque->png_ptr->io_ptr = file;
1496 image->opaque->png_ptr->io_ptr = fp;
1523 png_image_memory_read(png_structp png_ptr, png_bytep out, png_size_t need)
1525 if (png_ptr != NULL)
1527 png_imagep image = png_voidcast(png_imagep, png_ptr->io_ptr);
1544 png_error(png_ptr, "read beyond end of data");
1548 png_error(png_ptr, "invalid memory read");
1567 image->opaque->png_ptr->io_ptr = image;
1568 image->opaque->png_ptr->read_data_fn = png_image_memory_read;
1591 png_image_skip_unused_chunks(png_structrp png_ptr)
1626 png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_NEVER,
1630 png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT,
1650 png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma;
1698 png_error(display->image->opaque->png_ptr,
1755 png_error(image->opaque->png_ptr, "color-map index out of range");
1855 png_error(image->opaque->png_ptr, "bad encoding (internal error)");
2076 const png_structrp png_ptr = image->opaque->png_ptr;
2099 if (((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0 ||
2100 png_ptr->num_trans > 0) /* alpha in input */ &&
2107 png_error(png_ptr,
2138 if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) == 0)
2145 if (png_ptr->bit_depth == 16 &&
2147 png_ptr->colorspace.gamma = PNG_GAMMA_LINEAR;
2150 png_ptr->colorspace.gamma = PNG_GAMMA_sRGB_INVERSE;
2152 png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
2160 switch (png_ptr->color_type)
2163 if (png_ptr->bit_depth <= 8)
2170 cmap_entries = 1U << png_ptr->bit_depth;
2172 png_error(png_ptr, "gray[8] color-map: too few entries");
2180 if (png_ptr->num_trans > 0)
2182 trans = png_ptr->trans_color.gray;
2226 if (png_ptr->bit_depth < 8)
2227 png_set_packing(png_ptr);
2251 png_error(png_ptr, "gray[16] color-map: too few entries");
2255 if (png_ptr->num_trans > 0)
2293 png_set_background_fixed(png_ptr, &c,
2349 png_error(png_ptr, "gray+alpha color-map: too few entries");
2383 png_error(png_ptr, "gray-alpha color-map: too few entries");
2402 png_set_background_fixed(png_ptr, &c,
2417 png_error(png_ptr, "ga-alpha color-map: too few entries");
2504 png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1,
2511 if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2512 png_ptr->num_trans > 0) &&
2522 png_error(png_ptr, "rgb[ga] color-map: too few entries");
2536 png_error(png_ptr, "rgb[gray] color-map: too few entries");
2546 if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2547 png_ptr->num_trans > 0) &&
2548 png_gamma_not_sRGB(png_ptr->colorspace.gamma) != 0)
2559 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2560 png_ptr->num_trans > 0)
2581 png_ptr->colorspace.gamma)); /* now P_FILE */
2611 png_set_background_fixed(png_ptr, &c,
2630 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2631 png_ptr->num_trans > 0)
2641 png_error(png_ptr, "rgb+alpha color-map: too few entries");
2690 png_error(png_ptr, "rgb-alpha color-map: too few entries");
2760 png_set_background_fixed(png_ptr, &c,
2775 png_error(png_ptr, "rgb color-map: too few entries");
2788 unsigned int num_trans = png_ptr->num_trans;
2789 png_const_bytep trans = num_trans > 0 ? png_ptr->trans_alpha : NULL;
2790 png_const_colorp colormap = png_ptr->palette;
2801 cmap_entries = png_ptr->num_palette;
2806 png_error(png_ptr, "palette color-map: too few entries");
2843 if (png_ptr->bit_depth < 8)
2844 png_set_packing(png_ptr);
2849 png_error(png_ptr, "invalid PNG color type");
2854 if (expand_tRNS != 0 && png_ptr->num_trans > 0 &&
2855 (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) == 0)
2856 png_set_tRNS_to_alpha(png_ptr);
2862 png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_sRGB);
2866 if (png_ptr->bit_depth > 8)
2867 png_set_scale_16(png_ptr);
2872 png_error(png_ptr, "bad data option (internal error)");
2877 png_error(png_ptr, "color map overflow (BAD internal error)");
2911 png_error(png_ptr, "bad processing option (internal error)");
2914 png_error(png_ptr, "bad background index (internal error)");
2929 png_structrp png_ptr = image->opaque->png_ptr;
2936 switch (png_ptr->interlaced)
2947 png_error(png_ptr, "unknown interlace type");
2963 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
2989 png_read_row(png_ptr, inrow, NULL);
3119 png_structrp png_ptr = control->png_ptr;
3124 PNG_SKIP_CHUNKS(png_ptr);
3131 passes = png_set_interlace_handling(png_ptr);
3133 png_read_update_info(png_ptr, info_ptr);
3157 png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
3167 png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
3177 png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
3186 png_error(png_ptr, "bad color-map processing (internal error)");
3214 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
3219 png_free(png_ptr, row);
3235 png_read_row(png_ptr, row, NULL);
3251 png_structrp png_ptr = image->opaque->png_ptr;
3254 switch (png_ptr->interlaced)
3265 png_error(png_ptr, "unknown interlace type");
3281 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
3308 png_read_row(png_ptr, inrow, NULL);
3378 png_structrp png_ptr = image->opaque->png_ptr;
3389 if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
3390 png_error(png_ptr, "lost rgb to gray");
3392 if ((png_ptr->transformations & PNG_COMPOSE) != 0)
3393 png_error(png_ptr, "unexpected compose");
3395 if (png_get_channels(png_ptr, info_ptr) != 2)
3396 png_error(png_ptr, "lost/gained channels");
3401 png_error(png_ptr, "unexpected 8-bit transformation");
3403 switch (png_ptr->interlaced)
3414 png_error(png_ptr, "unknown interlace type");
3441 png_ptr->interlaced == PNG_INTERLACE_ADAM7)
3470 png_read_row(png_ptr, inrow, NULL);
3515 png_read_row(png_ptr, inrow, NULL);
3579 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
3606 png_read_row(png_ptr, png_voidcast(png_bytep,
3644 png_error(png_ptr, "unexpected bit depth");
3658 png_structrp png_ptr = image->opaque->png_ptr;
3671 png_set_expand(png_ptr);
3675 png_uint_32 base_format = png_image_format(png_ptr) &
3686 png_set_gray_to_rgb(png_ptr);
3706 png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE,
3727 png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, input_gamma_default);
3765 if (png_muldiv(>est, output_gamma, png_ptr->colorspace.gamma,
3782 png_set_expand_16(png_ptr);
3785 png_set_scale_16(png_ptr);
3809 png_set_strip_alpha(png_ptr);
3828 png_set_background_fixed(png_ptr, &c,
3872 png_set_add_alpha(png_ptr, filler, where);
3883 png_set_alpha_mode_fixed(png_ptr, mode, output_gamma);
3892 png_set_bgr(png_ptr);
3915 png_set_swap_alpha(png_ptr);
3933 png_set_swap(png_ptr);
3938 png_error(png_ptr, "png_read_image: unsupported transformation");
3941 PNG_SKIP_CHUNKS(png_ptr);
3950 passes = png_set_interlace_handling(png_ptr);
3952 png_read_update_info(png_ptr, info_ptr);
3973 png_error(png_ptr, "png_image_read: alpha channel lost");
3979 if ((png_ptr->transformations & PNG_BGR) != 0)
3990 if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0 ||
3991 ((png_ptr->transformations & PNG_ADD_ALPHA) != 0 &&
3992 (png_ptr->flags & PNG_FLAG_FILLER_AFTER) == 0))
3995 png_error(png_ptr, "unexpected alpha swap transformation");
4003 png_error(png_ptr, "png_read_image: invalid transformations");
4035 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
4040 png_free(png_ptr, row);
4048 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
4053 png_free(png_ptr, row);
4069 png_read_row(png_ptr, row, NULL);
