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;
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 png_ptr->index = NULL;
82 return png_ptr;
96 png_read_info(png_structrp png_ptr, png_inforp info_ptr)
104 if (png_ptr == NULL || info_ptr == NULL)
108 png_read_sig(png_ptr, info_ptr);
112 png_uint_32 length = png_read_chunk_header(png_ptr);
113 png_uint_32 chunk_name = png_ptr->chunk_name;
120 if (!(png_ptr->mode & PNG_HAVE_IHDR))
121 png_chunk_error(png_ptr, "Missing IHDR before IDAT");
123 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
124 !(png_ptr->mode & PNG_HAVE_PLTE))
125 png_chunk_error(png_ptr, "Missing PLTE before IDAT");
127 else if (png_ptr->mode & PNG_AFTER_IDAT)
128 png_chunk_benign_error(png_ptr, "Too many IDATs found");
130 png_ptr->mode |= PNG_HAVE_IDAT;
133 else if (png_ptr->mode & PNG_HAVE_IDAT)
134 png_ptr->mode |= PNG_AFTER_IDAT;
140 png_handle_IHDR(png_ptr, info_ptr, length);
143 png_handle_IEND(png_ptr, info_ptr, length);
146 else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
148 png_handle_unknown(png_ptr, info_ptr, length, keep);
151 png_ptr->mode |= PNG_HAVE_PLTE;
155 png_ptr->idat_size = 0; /* It has been consumed */
161 png_handle_PLTE(png_ptr, info_ptr, length);
165 png_ptr->idat_size = length;
171 png_handle_bKGD(png_ptr, info_ptr, length);
176 png_handle_cHRM(png_ptr, info_ptr, length);
181 png_handle_gAMA(png_ptr, info_ptr, length);
186 png_handle_hIST(png_ptr, info_ptr, length);
191 png_handle_oFFs(png_ptr, info_ptr, length);
196 png_handle_pCAL(png_ptr, info_ptr, length);
201 png_handle_sCAL(png_ptr, info_ptr, length);
206 png_handle_pHYs(png_ptr, info_ptr, length);
211 png_handle_sBIT(png_ptr, info_ptr, length);
216 png_handle_sRGB(png_ptr, info_ptr, length);
221 png_handle_iCCP(png_ptr, info_ptr, length);
226 png_handle_sPLT(png_ptr, info_ptr, length);
231 png_handle_tEXt(png_ptr, info_ptr, length);
236 png_handle_tIME(png_ptr, info_ptr, length);
241 png_handle_tRNS(png_ptr, info_ptr, length);
246 png_handle_zTXt(png_ptr, info_ptr, length);
251 png_handle_iTXt(png_ptr, info_ptr, length);
255 png_handle_unknown(png_ptr, info_ptr, length,
263 png_read_update_info(png_structrp png_ptr, png_inforp info_ptr)
267 if (png_ptr != NULL)
270 if (png_ptr->index) {
271 png_read_start_row(png_ptr);
274 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
276 png_read_start_row(png_ptr);
279 png_read_transform_info(png_ptr, info_ptr);
287 png_app_error(png_ptr,
300 png_start_read_image(png_structrp png_ptr)
304 if (png_ptr != NULL)
306 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
307 png_read_start_row(png_ptr);
311 png_app_error(png_ptr,
385 png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
389 if (png_ptr == NULL)
393 (unsigned long)png_ptr->row_number, png_ptr->pass);
398 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
399 png_read_start_row(png_ptr);
402 row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */
403 row_info.color_type = png_ptr->color_type;
404 row_info.bit_depth = png_ptr->bit_depth;
405 row_info.channels = png_ptr->channels;
406 row_info.pixel_depth = png_ptr->pixel_depth;
409 if (png_ptr->row_number == 0 && png_ptr->pass == 0)
413 if (png_ptr->transformations & PNG_INVERT_MONO)
414 png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");
418 if (png_ptr->transformations & PNG_FILLER)
419 png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");
424 if (png_ptr->transformations & PNG_PACKSWAP)
425 png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");
429 if (png_ptr->transformations & PNG_PACK)
430 png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");
434 if (png_ptr->transformations & PNG_SHIFT)
435 png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");
439 if (png_ptr->transformations & PNG_BGR)
440 png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");
444 if (png_ptr->transformations & PNG_SWAP_BYTES)
445 png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");
456 if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
458 switch (png_ptr->pass)
461 if (png_ptr->row_number & 0x07)
464 png_combine_row(png_ptr, dsp_row, 1/*display*/);
465 png_read_finish_row(png_ptr);
471 if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
474 png_combine_row(png_ptr, dsp_row, 1/*display*/);
476 png_read_finish_row(png_ptr);
482 if ((png_ptr->row_number & 0x07) != 4)
484 if (dsp_row != NULL && (png_ptr->row_number & 4))
485 png_combine_row(png_ptr, dsp_row, 1/*display*/);
487 png_read_finish_row(png_ptr);
493 if ((png_ptr->row_number & 3) || png_ptr->width < 3)
496 png_combine_row(png_ptr, dsp_row, 1/*display*/);
498 png_read_finish_row(png_ptr);
504 if ((png_ptr->row_number & 3) != 2)
506 if (dsp_row != NULL && (png_ptr->row_number & 2))
507 png_combine_row(png_ptr, dsp_row, 1/*display*/);
509 png_read_finish_row(png_ptr);
515 if ((png_ptr->row_number & 1) || png_ptr->width < 2)
518 png_combine_row(png_ptr, dsp_row, 1/*display*/);
520 png_read_finish_row(png_ptr);
527 if (!(png_ptr->row_number & 1))
529 png_read_finish_row(png_ptr);
537 if (!(png_ptr->mode & PNG_HAVE_IDAT))
538 png_error(png_ptr, "Invalid attempt to read row data");
541 png_ptr, png_ptr->row_buf, row_info.rowbytes + 1);
543 if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
545 if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
546 png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
547 png_ptr->prev_row + 1, png_ptr->row_buf[0]);
549 png_error(png_ptr, "bad adaptive filter value");
552 /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before
557 memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
560 if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
561 (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
564 png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);
569 if (png_ptr->transformations)
570 png_do_read_transformations(png_ptr, &row_info);
574 if (png_ptr->transformed_pixel_depth == 0)
576 png_ptr->transformed_pixel_depth = row_info.pixel_depth;
577 if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
578 png_error(png_ptr, "sequential row overflow");
581 else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
582 png_error(png_ptr, "internal sequential row size calculation error");
586 if (png_ptr->interlaced &&
587 (png_ptr->transformations & PNG_INTERLACE))
589 if (png_ptr->pass < 6)
590 png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
591 png_ptr->transformations);
594 png_combine_row(png_ptr, dsp_row, 1/*display*/);
597 png_combine_row(png_ptr, row, 0/*row*/);
604 png_combine_row(png_ptr, row, -1/*ignored*/);
607 png_combine_row(png_ptr, dsp_row, -1/*ignored*/);
609 png_read_finish_row(png_ptr);
611 if (png_ptr->read_row_fn != NULL)
612 (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
643 png_read_rows(png_structrp png_ptr, png_bytepp row,
652 if (png_ptr == NULL)
663 png_read_row(png_ptr, rptr, dptr);
670 png_read_row(png_ptr, rptr, NULL);
678 png_read_row(png_ptr, NULL, dptr);
691 png_set_read_offset(png_structp png_ptr,
694 png_seek_data(png_ptr, idat_position);
695 png_ptr->idat_size = png_read_chunk_header(png_ptr);
699 png_seek_data(png_ptr, idat_position + IDAT_HEADER_SIZE + png_ptr->idat_size - bytes_left);
700 png_ptr->idat_size = bytes_left;
709 png_configure_decoder(png_structp png_ptr, int *row, int pass)
711 png_indexp index = png_ptr->index;
717 png_ptr->row_number = *row;
720 if (png_ptr->interlaced)
721 png_set_interlaced_pass(png_ptr, pass);
725 PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1;
727 inflateEnd(&png_ptr->zstream);
728 inflateCopy(&png_ptr->zstream, line_index->z_state);
731 png_set_read_offset(png_ptr, line_index->stream_idat_position,
733 memcpy(png_ptr->prev_row, line_index->prev_row, row_byte_length);
734 png_ptr->zstream.avail_in = 0;
737 /* Build the line index and store the index in png_ptr->index.
740 png_build_index(png_structp png_ptr)
751 pass_number = png_set_interlace_handling(png_ptr);
754 if (png_ptr == NULL)
757 png_read_start_row(png_ptr);
760 if (!png_ptr->interlaced)
766 rp = png_malloc(png_ptr, png_ptr->rowbytes);
768 png_indexp index = png_malloc(png_ptr, sizeof(png_index));
769 png_ptr->index = index;
771 index->stream_idat_position = png_ptr->total_data_read - IDAT_HEADER_SIZE;
785 (png_ptr->height + index->step[p] - 1) / index->step[p];
787 png_malloc(png_ptr, temp_size * sizeof(png_line_indexp));
793 PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1;
798 png_line_indexp line_index = png_malloc(png_ptr, sizeof(png_line_index));
801 line_index->z_state = png_malloc(png_ptr, sizeof(z_stream));
802 inflateCopy(line_index->z_state, &png_ptr->zstream);
803 line_index->prev_row = png_malloc(png_ptr, row_byte_length);
804 memcpy(line_index->prev_row, png_ptr->prev_row, row_byte_length);
806 line_index->bytes_left_in_idat = png_ptr->idat_size + png_ptr->zstream.avail_in;
815 i * index->step[p] + j < png_ptr->height; j++)
817 png_read_row(png_ptr, rp, NULL);
821 png_free(png_ptr, rp);
839 png_read_image(png_structrp png_ptr, png_bytepp image)
847 if (png_ptr == NULL)
851 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
853 pass = png_set_interlace_handling(png_ptr);
855 png_start_read_image(png_ptr);
859 if (png_ptr->interlaced && !(png_ptr->transformations & PNG_INTERLACE))
865 png_warning(png_ptr, "Interlace handling should be turned on when "
868 png_ptr->num_rows = png_ptr->height;
874 pass = png_set_interlace_handling(png_ptr);
877 if (png_ptr->interlaced)
878 png_error(png_ptr,
884 image_height=png_ptr->height;
891 png_read_row(png_ptr, *rp, NULL);
904 png_read_end(png_structrp png_ptr, png_inforp info_ptr)
912 if (png_ptr == NULL)
919 if (!png_chunk_unknown_handling(png_ptr, png_IDAT))
921 png_read_finish_IDAT(png_ptr);
925 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
926 png_ptr->num_palette_max > png_ptr->num_palette)
927 png_benign_error(png_ptr, "Read palette index exceeding num_palette");
932 png_uint_32 length = png_read_chunk_header(png_ptr);
933 png_uint_32 chunk_name = png_ptr->chunk_name;
936 png_handle_IEND(png_ptr, info_ptr, length);
939 png_handle_IHDR(png_ptr, info_ptr, length);
942 png_crc_finish(png_ptr, length);
945 else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
949 if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
950 png_benign_error(png_ptr, "Too many IDATs found");
952 png_handle_unknown(png_ptr, info_ptr, length, keep);
954 png_ptr->mode |= PNG_HAVE_PLTE;
963 if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
964 png_benign_error(png_ptr, "Too many IDATs found");
966 png_crc_finish(png_ptr, length);
969 png_handle_PLTE(png_ptr, info_ptr, length);
973 png_handle_bKGD(png_ptr, info_ptr, length);
978 png_handle_cHRM(png_ptr, info_ptr, length);
983 png_handle_gAMA(png_ptr, info_ptr, length);
988 png_handle_hIST(png_ptr, info_ptr, length);
993 png_handle_oFFs(png_ptr, info_ptr, length);
998 png_handle_pCAL(png_ptr, info_ptr, length);
1003 png_handle_sCAL(png_ptr, info_ptr, length);
1008 png_handle_pHYs(png_ptr, info_ptr, length);
1013 png_handle_sBIT(png_ptr, info_ptr, length);
1018 png_handle_sRGB(png_ptr, info_ptr, length);
1023 png_handle_iCCP(png_ptr, info_ptr, length);
1028 png_handle_sPLT(png_ptr, info_ptr, length);
1033 png_handle_tEXt(png_ptr, info_ptr, length);
1038 png_handle_tIME(png_ptr, info_ptr, length);
1043 png_handle_tRNS(png_ptr, info_ptr, length);
1048 png_handle_zTXt(png_ptr, info_ptr, length);
1053 png_handle_iTXt(png_ptr, info_ptr, length);
1057 png_handle_unknown(png_ptr, info_ptr, length,
1059 } while (!(png_ptr->mode & PNG_HAVE_IEND));
1065 png_read_destroy(png_structrp png_ptr)
1070 png_destroy_gamma_table(png_ptr);
1073 png_free(png_ptr, png_ptr->big_row_buf);
1074 png_free(png_ptr, png_ptr->big_prev_row);
1075 png_free(png_ptr, png_ptr->read_buffer);
1078 png_free(png_ptr, png_ptr->palette_lookup);
1079 png_free(png_ptr, png_ptr->quantize_index);
1082 if (png_ptr->free_me & PNG_FREE_PLTE)
1083 png_zfree(png_ptr, png_ptr->palette);
1084 png_ptr->free_me &= ~PNG_FREE_PLTE;
1088 if (png_ptr->free_me & PNG_FREE_TRNS)
1089 png_free(png_ptr, png_ptr->trans_alpha);
1090 png_ptr->free_me &= ~PNG_FREE_TRNS;
1093 inflateEnd(&png_ptr->zstream);
1096 png_free(png_ptr, png_ptr->save_buffer);
1101 png_free(png_ptr, png_ptr->unknown_chunk.data);
1105 png_free(png_ptr, png_ptr->chunk_list);
1109 if (png_ptr->index) {
1111 png_indexp index = png_ptr->index;
1115 png_free(png_ptr, index->pass_line_index[p][i]->z_state);
1116 png_free(png_ptr, index->pass_line_index[p][i]->prev_row);
1117 png_free(png_ptr, index->pass_line_index[p][i]);
1120 png_free(png_ptr, index->pass_line_index[p]);
1123 png_free(png_ptr, index);
1138 png_structrp png_ptr = NULL;
1143 png_ptr = *png_ptr_ptr;
1145 if (png_ptr == NULL)
1152 png_destroy_info_struct(png_ptr, end_info_ptr_ptr);
1153 png_destroy_info_struct(png_ptr, info_ptr_ptr);
1156 png_read_destroy(png_ptr);
1157 png_destroy_png_struct(png_ptr);
1161 png_set_read_status_fn(png_structrp png_ptr, png_read_status_ptr read_row_fn)
1163 if (png_ptr == NULL)
1166 png_ptr->read_row_fn = read_row_fn;
1173 png_read_png(png_structrp png_ptr, png_inforp info_ptr,
1177 if (png_ptr == NULL || info_ptr == NULL)
1183 png_read_info(png_ptr, info_ptr);
1185 png_error(png_ptr, "Image is too high to process with png_read_png()");
1201 png_set_scale_16(png_ptr);
1203 png_app_error(png_ptr, "PNG_TRANSFORM_SCALE_16 not supported");
1212 png_set_strip_16(png_ptr);
1214 png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_16 not supported");
1222 png_set_strip_alpha(png_ptr);
1224 png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_ALPHA not supported");
1232 png_set_packing(png_ptr);
1234 png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported");
1242 png_set_packswap(png_ptr);
1244 png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported");
1254 png_set_expand(png_ptr);
1256 png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND not supported");
1266 png_set_invert_mono(png_ptr);
1268 png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_MONO not supported");
1278 png_set_shift(png_ptr, &info_ptr->sig_bit);
1280 png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
1286 png_set_bgr(png_ptr);
1288 png_app_error(png_ptr, "PNG_TRANSFORM_BGR not supported");
1294 png_set_swap_alpha(png_ptr);
1296 png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ALPHA not supported");
1302 png_set_swap(png_ptr);
1304 png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ENDIAN not supported");
1311 png_set_invert_alpha(png_ptr);
1313 png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_ALPHA not supported");
1320 png_set_gray_to_rgb(png_ptr);
1322 png_app_error(png_ptr, "PNG_TRANSFORM_GRAY_TO_RGB not supported");
1328 png_set_expand_16(png_ptr);
1330 png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND_16 not supported");
1338 (void)png_set_interlace_handling(png_ptr);
1344 png_read_update_info(png_ptr, info_ptr);
1348 png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
1353 info_ptr->row_pointers = png_voidcast(png_bytepp, png_malloc(png_ptr,
1363 png_malloc(png_ptr, info_ptr->rowbytes));
1366 png_read_image(png_ptr, info_ptr->row_pointers);
1370 png_read_end(png_ptr, info_ptr);
1435 png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, image,
1444 if (png_ptr != NULL)
1446 png_infop info_ptr = png_create_info_struct(png_ptr);
1451 png_malloc_warn(png_ptr, (sizeof *control)));
1457 control->png_ptr = png_ptr;
1466 png_destroy_info_struct(png_ptr, &info_ptr);
1469 png_destroy_read_struct(&png_ptr, NULL, NULL);
1480 png_image_format(png_structrp png_ptr)
1484 if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
1487 if (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)
1490 /* Use png_ptr here, not info_ptr, because by examination png_handle_tRNS
1495 else if (png_ptr->num_trans > 0)
1498 if (png_ptr->bit_depth == 16)
1501 if (png_ptr->color_type & PNG_COLOR_MASK_PALETTE)
1535 png_structrp png_ptr = image->opaque->png_ptr;
1538 png_set_benign_errors(png_ptr, 1/*warn*/);
1539 png_read_info(png_ptr, info_ptr);
1542 image->width = png_ptr->width;
1543 image->height = png_ptr->height;
1546 png_uint_32 format = png_image_format(png_ptr);
1556 if ((format & PNG_FORMAT_FLAG_COLOR) != 0 && ((png_ptr->colorspace.flags
1569 switch (png_ptr->color_type)
1572 cmap_entries = 1U << png_ptr->bit_depth;
1576 cmap_entries = png_ptr->num_palette;
1607 image->opaque->png_ptr->io_ptr = file;
1637 image->opaque->png_ptr->io_ptr = fp;
1664 png_image_memory_read(png_structp png_ptr, png_bytep out, png_size_t need)
1666 if (png_ptr != NULL)
1668 png_imagep image = png_voidcast(png_imagep, png_ptr->io_ptr);
1685 png_error(png_ptr, "read beyond end of data");
1689 png_error(png_ptr, "invalid memory read");
1708 image->opaque->png_ptr->io_ptr = image;
1709 image->opaque->png_ptr->read_data_fn = png_image_memory_read;
1732 png_image_skip_unused_chunks(png_structrp png_ptr)
1767 png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_NEVER,
1771 png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT,
1791 png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma;
1838 png_error(display->image->opaque->png_ptr,
1895 png_error(image->opaque->png_ptr, "color-map index out of range");
1993 png_error(image->opaque->png_ptr, "bad encoding (internal error)");
2214 const png_structrp png_ptr = image->opaque->png_ptr;
2237 if (((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0 ||
2238 png_ptr->num_trans > 0) /* alpha in input */ &&
2245 png_error(png_ptr,
2276 if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) == 0)
2283 if (png_ptr->bit_depth == 16 &&
2285 png_ptr->colorspace.gamma = PNG_GAMMA_LINEAR;
2288 png_ptr->colorspace.gamma = PNG_GAMMA_sRGB_INVERSE;
2290 png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
2298 switch (png_ptr->color_type)
2301 if (png_ptr->bit_depth <= 8)
2308 cmap_entries = 1U << png_ptr->bit_depth;
2310 png_error(png_ptr, "gray[8] color-map: too few entries");
2318 if (png_ptr->num_trans > 0)
2320 trans = png_ptr->trans_color.gray;
2364 if (png_ptr->bit_depth < 8)
2365 png_set_packing(png_ptr);
2389 png_error(png_ptr, "gray[16] color-map: too few entries");
2393 if (png_ptr->num_trans > 0)
2431 png_set_background_fixed(png_ptr, &c,
2481 png_error(png_ptr, "gray+alpha color-map: too few entries");
2515 png_error(png_ptr, "gray-alpha color-map: too few entries");
2534 png_set_background_fixed(png_ptr, &c,
2549 png_error(png_ptr, "ga-alpha color-map: too few entries");
2629 png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1,
2636 if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2637 png_ptr->num_trans > 0) &&
2647 png_error(png_ptr, "rgb[ga] color-map: too few entries");
2661 png_error(png_ptr, "rgb[gray] color-map: too few entries");
2671 if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2672 png_ptr->num_trans > 0) &&
2673 png_gamma_not_sRGB(png_ptr->colorspace.gamma))
2684 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2685 png_ptr->num_trans > 0)
2706 png_ptr->colorspace.gamma)); /* now P_FILE */
2736 png_set_background_fixed(png_ptr, &c,
2755 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
2756 png_ptr->num_trans > 0)
2766 png_error(png_ptr, "rgb+alpha color-map: too few entries");
2815 png_error(png_ptr, "rgb-alpha color-map: too few entries");
2885 png_set_background_fixed(png_ptr, &c,
2900 png_error(png_ptr, "rgb color-map: too few entries");
2913 unsigned int num_trans = png_ptr->num_trans;
2914 png_const_bytep trans = num_trans > 0 ? png_ptr->trans_alpha : NULL;
2915 png_const_colorp colormap = png_ptr->palette;
2926 cmap_entries = png_ptr->num_palette;
2931 png_error(png_ptr, "palette color-map: too few entries");
2968 if (png_ptr->bit_depth < 8)
2969 png_set_packing(png_ptr);
2974 png_error(png_ptr, "invalid PNG color type");
2980 if (expand_tRNS && png_ptr->num_trans > 0 &&
2981 (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) == 0)
2982 png_set_tRNS_to_alpha(png_ptr);
2987 png_error(png_ptr, "bad data option (internal error)");
2992 png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_sRGB);
2996 if (png_ptr->bit_depth > 8)
2997 png_set_scale_16(png_ptr);
3002 png_error(png_ptr, "color map overflow (BAD internal error)");
3036 png_error(png_ptr, "bad processing option (internal error)");
3039 png_error(png_ptr, "bad background index (internal error)");
3054 png_structrp png_ptr = image->opaque->png_ptr;
3061 switch (png_ptr->interlaced)
3072 png_error(png_ptr, "unknown interlace type");
3088 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
3114 png_read_row(png_ptr, inrow, NULL);
3244 png_structrp png_ptr = control->png_ptr;
3249 PNG_SKIP_CHUNKS(png_ptr);
3256 passes = png_set_interlace_handling(png_ptr);
3258 png_read_update_info(png_ptr, info_ptr);
3282 png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
3292 png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
3302 png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
3311 png_error(png_ptr, "bad color-map processing (internal error)");
3339 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
3344 png_free(png_ptr, row);
3360 png_read_row(png_ptr, row, NULL);
3376 png_structrp png_ptr = image->opaque->png_ptr;
3379 switch (png_ptr->interlaced)
3390 png_error(png_ptr, "unknown interlace type");
3405 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
3432 png_read_row(png_ptr, inrow, NULL);
3502 png_structrp png_ptr = image->opaque->png_ptr;
3513 if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
3514 png_error(png_ptr, "lost rgb to gray");
3516 if ((png_ptr->transformations & PNG_COMPOSE) != 0)
3517 png_error(png_ptr, "unexpected compose");
3519 if (png_get_channels(png_ptr, info_ptr) != 2)
3520 png_error(png_ptr, "lost/gained channels");
3525 png_error(png_ptr, "unexpected 8-bit transformation");
3527 switch (png_ptr->interlaced)
3538 png_error(png_ptr, "unknown interlace type");
3549 png_error(png_ptr, "unexpected bit depth");
3569 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
3598 png_read_row(png_ptr, inrow, NULL);
3643 png_read_row(png_ptr, inrow, NULL);
3706 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
3733 png_read_row(png_ptr, png_voidcast(png_bytep,
3780 png_structrp png_ptr = image->opaque->png_ptr;
3793 png_set_expand(png_ptr);
3797 png_uint_32 base_format = png_image_format(png_ptr) &
3808 png_set_gray_to_rgb(png_ptr);
3828 png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE,
3849 png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, input_gamma_default);
3887 if (png_muldiv(>est, output_gamma, png_ptr->colorspace.gamma,
3904 png_set_expand_16(png_ptr);
3907 png_ptr);
3931 png_set_strip_alpha(png_ptr);
3950 png_set_background_fixed(png_ptr, &c,
3994 png_set_add_alpha(png_ptr, filler, where);
4005 png_set_alpha_mode_fixed(png_ptr, mode, output_gamma);
4014 png_set_bgr(png_ptr);
4037 png_set_swap_alpha(png_ptr);
4055 png_set_swap(png_ptr);
4060 png_error(png_ptr, "png_read_image: unsupported transformation");
4063 PNG_SKIP_CHUNKS(png_ptr);
4072 passes = png_set_interlace_handling(png_ptr);
4074 png_read_update_info(png_ptr, info_ptr);
4095 png_error(png_ptr, "png_image_read: alpha channel lost");
4101 if (png_ptr->transformations & PNG_BGR)
4112 if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0 ||
4113 ((png_ptr->transformations & PNG_ADD_ALPHA) != 0 &&
4114 (png_ptr->flags & PNG_FLAG_FILLER_AFTER) == 0))
4117 png_error(png_ptr, "unexpected alpha swap transformation");
4125 png_error(png_ptr, "png_read_image: invalid transformations");
4157 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
4162 png_free(png_ptr, row);
4170 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
4175 png_free(png_ptr, row);
4191 png_read_row(png_ptr, row, NULL);
