Lines Matching refs:png_ptr
47 png_structp png_ptr;
60 png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
63 png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
65 if (png_ptr == NULL)
70 png_ptr->user_width_max = PNG_USER_WIDTH_MAX;
71 png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;
74 png_ptr->user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;
78 png_ptr->user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;
86 if (setjmp(png_ptr->jmpbuf))
89 png_free(png_ptr, png_ptr->zbuf);
90 png_ptr->zbuf = NULL;
92 png_destroy_struct_2((png_voidp)png_ptr,
95 png_destroy_struct((png_voidp)png_ptr);
100 png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));
105 png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
108 png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
116 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
120 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
123 if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
141 png_warning(png_ptr, msg);
146 png_warning(png_ptr, msg);
149 png_ptr->flags = 0;
151 png_error(png_ptr,
157 png_ptr->zbuf_size = PNG_ZBUF_SIZE;
158 png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
159 (png_uint_32)png_ptr->zbuf_size);
160 png_ptr->zstream.zalloc = png_zalloc;
161 png_ptr->zstream.zfree = png_zfree;
162 png_ptr->zstream.opaque = (voidpf)png_ptr;
164 switch (inflateInit(&png_ptr->zstream))
168 case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error");
170 case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error");
172 default: png_error(png_ptr, "Unknown zlib error");
176 png_ptr->zstream.next_out = png_ptr->zbuf;
177 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
179 png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);
188 png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));
190 if (setjmp(png_ptr->jmpbuf))
196 png_ptr->index = NULL;
199 return (png_ptr);
209 png_read_init(png_structp png_ptr)
212 png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0);
216 png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,
220 if (png_ptr == NULL)
227 png_ptr->warning_fn = NULL;
233 png_warning(png_ptr, msg);
238 png_warning(png_ptr, msg);
243 png_ptr->error_fn = NULL;
245 png_ptr->flags = 0;
247 png_error(png_ptr,
253 png_ptr->error_fn = NULL;
255 png_ptr->flags = 0;
257 png_error(png_ptr,
261 png_read_init_3(&png_ptr, user_png_ver, png_struct_size);
275 png_structp png_ptr=*ptr_ptr;
277 if (png_ptr == NULL)
285 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
287 png_ptr->warning_fn = NULL;
288 png_warning(png_ptr,
300 png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
305 png_destroy_struct(png_ptr);
307 png_ptr = *ptr_ptr;
311 png_memset(png_ptr, 0, png_sizeof(png_struct));
315 png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
320 png_ptr->user_width_max = PNG_USER_WIDTH_MAX;
321 png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;
325 png_ptr->zbuf_size = PNG_ZBUF_SIZE;
326 png_ptr->zstream.zalloc = png_zalloc;
327 png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
328 (png_uint_32)png_ptr->zbuf_size);
329 png_ptr->zstream.zalloc = png_zalloc;
330 png_ptr->zstream.zfree = png_zfree;
331 png_ptr->zstream.opaque = (voidpf)png_ptr;
333 switch (inflateInit(&png_ptr->zstream))
336 case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;
337 case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error");
339 default: png_error(png_ptr, "Unknown zlib error");
342 png_ptr->zstream.next_out = png_ptr->zbuf;
343 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
345 png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);
358 png_read_info(png_structp png_ptr, png_infop info_ptr)
362 if (png_ptr == NULL || info_ptr == NULL)
366 if (png_ptr->sig_bytes < 8)
368 png_size_t num_checked = png_ptr->sig_bytes,
371 png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
372 png_ptr->sig_bytes = 8;
378 png_error(png_ptr, "Not a PNG file");
380 png_error(png_ptr, "PNG file corrupted by ASCII conversion");
383 png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
445 png_uint_32 length = png_read_chunk_header(png_ptr);
446 PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;
452 if (png_ptr->mode & PNG_AFTER_IDAT)
453 png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
456 png_handle_IHDR(png_ptr, info_ptr, length);
458 png_handle_IEND(png_ptr, info_ptr, length);
460 else if (png_handle_as_unknown(png_ptr, chunk_name))
463 png_ptr->mode |= PNG_HAVE_IDAT;
464 png_handle_unknown(png_ptr, info_ptr, length);
466 png_ptr->mode |= PNG_HAVE_PLTE;
469 if (!(png_ptr->mode & PNG_HAVE_IHDR))
470 png_error(png_ptr, "Missing IHDR before IDAT");
471 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
472 !(png_ptr->mode & PNG_HAVE_PLTE))
473 png_error(png_ptr, "Missing PLTE before IDAT");
479 png_handle_PLTE(png_ptr, info_ptr, length);
482 if (!(png_ptr->mode & PNG_HAVE_IHDR))
483 png_error(png_ptr, "Missing IHDR before IDAT");
484 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
485 !(png_ptr->mode & PNG_HAVE_PLTE))
486 png_error(png_ptr, "Missing PLTE before IDAT");
488 png_ptr->idat_size = length;
489 png_ptr->mode |= PNG_HAVE_IDAT;
494 png_handle_bKGD(png_ptr, info_ptr, length);
498 png_handle_cHRM(png_ptr, info_ptr, length);
502 png_handle_gAMA(png_ptr, info_ptr, length);
506 png_handle_hIST(png_ptr, info_ptr, length);
510 png_handle_oFFs(png_ptr, info_ptr, length);
514 png_handle_pCAL(png_ptr, info_ptr, length);
518 png_handle_sCAL(png_ptr, info_ptr, length);
522 png_handle_pHYs(png_ptr, info_ptr, length);
526 png_handle_sBIT(png_ptr, info_ptr, length);
530 png_handle_sRGB(png_ptr, info_ptr, length);
534 png_handle_iCCP(png_ptr, info_ptr, length);
538 png_handle_sPLT(png_ptr, info_ptr, length);
542 png_handle_tEXt(png_ptr, info_ptr, length);
546 png_handle_tIME(png_ptr, info_ptr, length);
550 png_handle_tRNS(png_ptr, info_ptr, length);
554 png_handle_zTXt(png_ptr, info_ptr, length);
558 png_handle_iTXt(png_ptr, info_ptr, length);
561 png_handle_unknown(png_ptr, info_ptr, length);
568 png_read_update_info(png_structp png_ptr, png_infop info_ptr)
572 if (png_ptr == NULL)
575 if (png_ptr->index) {
576 png_read_start_row(png_ptr);
579 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
580 png_read_start_row(png_ptr);
582 png_warning(png_ptr,
585 png_read_transform_info(png_ptr, info_ptr);
595 png_start_read_image(png_structp png_ptr)
599 if (png_ptr == NULL)
601 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
602 png_read_start_row(png_ptr);
608 png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
616 if (png_ptr == NULL)
620 png_ptr->row_number, png_ptr->pass);
622 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
623 png_read_start_row(png_ptr);
624 if (png_ptr->row_number == 0 && png_ptr->pass == 0)
628 if (png_ptr->transformations & PNG_INVERT_MONO)
629 png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");
632 if (png_ptr->transformations & PNG_FILLER)
633 png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined.");
637 if (png_ptr->transformations & PNG_PACKSWAP)
638 png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined.");
641 if (png_ptr->transformations & PNG_PACK)
642 png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined.");
645 if (png_ptr->transformations & PNG_SHIFT)
646 png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined.");
649 if (png_ptr->transformations & PNG_BGR)
650 png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined.");
653 if (png_ptr->transformations & PNG_SWAP_BYTES)
654 png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");
660 if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
662 switch (png_ptr->pass)
665 if (png_ptr->row_number & 0x07)
668 png_combine_row(png_ptr, dsp_row,
669 png_pass_dsp_mask[png_ptr->pass]);
670 png_read_finish_row(png_ptr);
675 if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
678 png_combine_row(png_ptr, dsp_row,
679 png_pass_dsp_mask[png_ptr->pass]);
680 png_read_finish_row(png_ptr);
685 if ((png_ptr->row_number & 0x07) != 4)
687 if (dsp_row != NULL && (png_ptr->row_number & 4))
688 png_combine_row(png_ptr, dsp_row,
689 png_pass_dsp_mask[png_ptr->pass]);
690 png_read_finish_row(png_ptr);
695 if ((png_ptr->row_number & 3) || png_ptr->width < 3)
698 png_combine_row(png_ptr, dsp_row,
699 png_pass_dsp_mask[png_ptr->pass]);
700 png_read_finish_row(png_ptr);
705 if ((png_ptr->row_number & 3) != 2)
707 if (dsp_row != NULL && (png_ptr->row_number & 2))
708 png_combine_row(png_ptr, dsp_row,
709 png_pass_dsp_mask[png_ptr->pass]);
710 png_read_finish_row(png_ptr);
715 if ((png_ptr->row_number & 1) || png_ptr->width < 2)
718 png_combine_row(png_ptr, dsp_row,
719 png_pass_dsp_mask[png_ptr->pass]);
720 png_read_finish_row(png_ptr);
725 if (!(png_ptr->row_number & 1))
727 png_read_finish_row(png_ptr);
735 if (!(png_ptr->mode & PNG_HAVE_IDAT))
736 png_error(png_ptr, "Invalid attempt to read row data");
738 png_ptr->zstream.next_out = png_ptr->row_buf;
739 png_ptr->zstream.avail_out =
740 (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,
741 png_ptr->iwidth) + 1);
744 if (!(png_ptr->zstream.avail_in))
746 while (!png_ptr->idat_size)
749 if (png_ptr->index) {
750 png_opt_crc_finish(png_ptr, 0, 0);
751 png_ptr->index->stream_idat_position = png_ptr->total_data_read;
754 png_crc_finish(png_ptr, 0);
757 png_ptr->idat_size = png_read_chunk_header(png_ptr);
758 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
759 png_error(png_ptr, "Not enough image data");
761 png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
762 png_ptr->zstream.next_in = png_ptr->zbuf;
763 if (png_ptr->zbuf_size > png_ptr->idat_size)
764 png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
765 png_crc_read(png_ptr, png_ptr->zbuf,
766 (png_size_t)png_ptr->zstream.avail_in);
767 png_ptr->idat_size -= png_ptr->zstream.avail_in;
769 ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
772 if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||
773 png_ptr->idat_size)
774 png_error(png_ptr, "Extra compressed data");
775 png_ptr->mode |= PNG_AFTER_IDAT;
776 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
781 if (png_ptr->index) {
782 if (png_ptr->row_number != png_ptr->height - 1) {
783 png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
788 png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
791 } while (png_ptr->zstream.avail_out);
793 png_ptr->row_info.color_type = png_ptr->color_type;
794 png_ptr->row_info.width = png_ptr->iwidth;
795 png_ptr->row_info.channels = png_ptr->channels;
796 png_ptr->row_info.bit_depth = png_ptr->bit_depth;
797 png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
798 png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
799 png_ptr->row_info.width);
801 if (png_ptr->row_buf[0])
802 png_read_filter_row(png_ptr, &(png_ptr->row_info),
803 png_ptr->row_buf + 1, png_ptr->prev_row + 1,
804 (int)(png_ptr->row_buf[0]));
806 png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
807 png_ptr->rowbytes + 1);
810 if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
811 (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
814 png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
819 if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
820 png_do_read_transformations(png_ptr);
824 if (png_ptr->interlaced &&
825 (png_ptr->transformations & PNG_INTERLACE))
827 if (png_ptr->pass < 6)
829 * png_do_read_interlace(&(png_ptr->row_info),
830 * png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
832 png_do_read_interlace(png_ptr);
835 png_combine_row(png_ptr, dsp_row,
836 png_pass_dsp_mask[png_ptr->pass]);
838 png_combine_row(png_ptr, row,
839 png_pass_mask[png_ptr->pass]);
845 png_combine_row(png_ptr, row, 0xff);
847 png_combine_row(png_ptr, dsp_row, 0xff);
849 png_read_finish_row(png_ptr);
851 if (png_ptr->read_row_fn != NULL)
852 (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
882 png_read_rows(png_structp png_ptr, png_bytepp row,
891 if (png_ptr == NULL)
901 png_read_row(png_ptr, rptr, dptr);
907 png_read_row(png_ptr, rptr, png_bytep_NULL);
914 png_read_row(png_ptr, png_bytep_NULL, dptr);
927 png_set_read_offset(png_structp png_ptr,
930 png_seek_data(png_ptr, idat_position);
931 png_ptr->idat_size = png_read_chunk_header(png_ptr);
935 png_seek_data(png_ptr, idat_position + IDAT_HEADER_SIZE + png_ptr->idat_size - bytes_left);
936 png_ptr->idat_size = bytes_left;
945 png_configure_decoder(png_structp png_ptr, int *row, int pass)
947 png_indexp index = png_ptr->index;
953 png_ptr->row_number = *row;
956 if (png_ptr->interlaced)
957 png_set_interlaced_pass(png_ptr, pass);
961 PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1;
963 inflateEnd(&png_ptr->zstream);
964 inflateCopy(&png_ptr->zstream, line_index->z_state);
967 png_set_read_offset(png_ptr, line_index->stream_idat_position,
969 png_memcpy_check(png_ptr,
970 png_ptr->prev_row, line_index->prev_row, row_byte_length);
971 png_ptr->zstream.avail_in = 0;
974 /* Build the line index and store the index in png_ptr->index.
977 png_build_index(png_structp png_ptr)
988 pass_number = png_set_interlace_handling(png_ptr);
991 if (png_ptr == NULL)
994 png_read_start_row(png_ptr);
997 if (!png_ptr->interlaced)
1003 rp = png_malloc(png_ptr, png_ptr->rowbytes);
1005 png_indexp index = png_malloc(png_ptr, sizeof(png_index));
1006 png_ptr->index = index;
1008 index->stream_idat_position = png_ptr->total_data_read - IDAT_HEADER_SIZE;
1022 (png_ptr->height + index->step[p] - 1) / index->step[p];
1024 png_malloc(png_ptr, index->size[p] * sizeof(png_line_indexp));
1030 png_ptr->pixel_depth, png_ptr->iwidth) + 1;
1035 png_line_indexp line_index = png_malloc(png_ptr, sizeof(png_line_index));
1038 line_index->z_state = png_malloc(png_ptr, sizeof(z_stream));
1039 inflateCopy(line_index->z_state, &png_ptr->zstream);
1040 line_index->prev_row = png_malloc(png_ptr, row_byte_length);
1041 png_memcpy_check(png_ptr,
1042 line_index->prev_row, png_ptr->prev_row, row_byte_length);
1044 line_index->bytes_left_in_idat = png_ptr->idat_size + png_ptr->zstream.avail_in;
1048 i * index->step[p] + j < png_ptr->height; j++)
1050 png_read_row(png_ptr, rp, png_bytep_NULL);
1054 png_free(png_ptr, rp);
1072 png_read_image(png_structp png_ptr, png_bytepp image)
1080 if (png_ptr == NULL)
1084 pass = png_set_interlace_handling(png_ptr);
1086 if (png_ptr->interlaced)
1087 png_error(png_ptr,
1093 image_height=png_ptr->height;
1094 png_ptr->num_rows = image_height; /* Make sure this is set correctly */
1101 png_read_row(png_ptr, *rp, png_bytep_NULL);
1114 png_read_end(png_structp png_ptr, png_infop info_ptr)
1118 if (png_ptr == NULL)
1120 png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
1181 png_uint_32 length = png_read_chunk_header(png_ptr);
1182 PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;
1185 png_handle_IHDR(png_ptr, info_ptr, length);
1187 png_handle_IEND(png_ptr, info_ptr, length);
1189 else if (png_handle_as_unknown(png_ptr, chunk_name))
1193 if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
1194 png_error(png_ptr, "Too many IDAT's found");
1196 png_handle_unknown(png_ptr, info_ptr, length);
1198 png_ptr->mode |= PNG_HAVE_PLTE;
1206 if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
1207 png_error(png_ptr, "Too many IDAT's found");
1208 png_crc_finish(png_ptr, length);
1211 png_handle_PLTE(png_ptr, info_ptr, length);
1214 png_handle_bKGD(png_ptr, info_ptr, length);
1218 png_handle_cHRM(png_ptr, info_ptr, length);
1222 png_handle_gAMA(png_ptr, info_ptr, length);
1226 png_handle_hIST(png_ptr, info_ptr, length);
1230 png_handle_oFFs(png_ptr, info_ptr, length);
1234 png_handle_pCAL(png_ptr, info_ptr, length);
1238 png_handle_sCAL(png_ptr, info_ptr, length);
1242 png_handle_pHYs(png_ptr, info_ptr, length);
1246 png_handle_sBIT(png_ptr, info_ptr, length);
1250 png_handle_sRGB(png_ptr, info_ptr, length);
1254 png_handle_iCCP(png_ptr, info_ptr, length);
1258 png_handle_sPLT(png_ptr, info_ptr, length);
1262 png_handle_tEXt(png_ptr, info_ptr, length);
1266 png_handle_tIME(png_ptr, info_ptr, length);
1270 png_handle_tRNS(png_ptr, info_ptr, length);
1274 png_handle_zTXt(png_ptr, info_ptr, length);
1278 png_handle_iTXt(png_ptr, info_ptr, length);
1281 png_handle_unknown(png_ptr, info_ptr, length);
1282 } while (!(png_ptr->mode & PNG_HAVE_IEND));
1291 png_structp png_ptr = NULL;
1301 png_ptr = *png_ptr_ptr;
1302 if (png_ptr == NULL)
1306 free_fn = png_ptr->free_fn;
1307 mem_ptr = png_ptr->mem_ptr;
1316 png_read_destroy(png_ptr, info_ptr, end_info_ptr);
1321 png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);
1336 png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);
1347 if (png_ptr != NULL)
1350 if (png_ptr->index) {
1352 png_indexp index = png_ptr->index;
1356 png_free(png_ptr, index->pass_line_index[p][i]->z_state);
1357 png_free(png_ptr, index->pass_line_index[p][i]->prev_row);
1358 png_free(png_ptr, index->pass_line_index[p][i]);
1361 png_free(png_ptr, index->pass_line_index[p]);
1364 png_free(png_ptr, index);
1368 png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
1371 png_destroy_struct((png_voidp)png_ptr);
1379 png_read_destroy(png_structp png_ptr, png_infop info_ptr,
1395 png_info_destroy(png_ptr, info_ptr);
1398 png_info_destroy(png_ptr, end_info_ptr);
1400 png_free(png_ptr, png_ptr->zbuf);
1401 png_free(png_ptr, png_ptr->big_row_buf);
1402 png_free(png_ptr, png_ptr->prev_row);
1403 png_free(png_ptr, png_ptr->chunkdata);
1405 png_free(png_ptr, png_ptr->palette_lookup);
1406 png_free(png_ptr, png_ptr->dither_index);
1409 png_free(png_ptr, png_ptr->gamma_table);
1412 png_free(png_ptr, png_ptr->gamma_from_1);
1413 png_free(png_ptr, png_ptr->gamma_to_1);
1416 if (png_ptr->free_me & PNG_FREE_PLTE)
1417 png_zfree(png_ptr, png_ptr->palette);
1418 png_ptr->free_me &= ~PNG_FREE_PLTE;
1420 if (png_ptr->flags & PNG_FLAG_FREE_PLTE)
1421 png_zfree(png_ptr, png_ptr->palette);
1422 png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
1427 if (png_ptr->free_me & PNG_FREE_TRNS)
1428 png_free(png_ptr, png_ptr->trans);
1429 png_ptr->free_me &= ~PNG_FREE_TRNS;
1431 if (png_ptr->flags & PNG_FLAG_FREE_TRNS)
1432 png_free(png_ptr, png_ptr->trans);
1433 png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
1438 if (png_ptr->free_me & PNG_FREE_HIST)
1439 png_free(png_ptr, png_ptr->hist);
1440 png_ptr->free_me &= ~PNG_FREE_HIST;
1442 if (png_ptr->flags & PNG_FLAG_FREE_HIST)
1443 png_free(png_ptr, png_ptr->hist);
1444 png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
1448 if (png_ptr->gamma_16_table != NULL)
1451 int istop = (1 << (8 - png_ptr->gamma_shift));
1454 png_free(png_ptr, png_ptr->gamma_16_table[i]);
1456 png_free(png_ptr, png_ptr->gamma_16_table);
1459 if (png_ptr->gamma_16_from_1 != NULL)
1462 int istop = (1 << (8 - png_ptr->gamma_shift));
1465 png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
1467 png_free(png_ptr, png_ptr->gamma_16_from_1);
1469 if (png_ptr->gamma_16_to_1 != NULL)
1472 int istop = (1 << (8 - png_ptr->gamma_shift));
1475 png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
1477 png_free(png_ptr, png_ptr->gamma_16_to_1);
1482 png_free(png_ptr, png_ptr->time_buffer);
1485 inflateEnd(&png_ptr->zstream);
1487 png_free(png_ptr, png_ptr->save_buffer);
1492 png_free(png_ptr, png_ptr->current_text);
1500 png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
1503 error_fn = png_ptr->error_fn;
1504 warning_fn = png_ptr->warning_fn;
1505 error_ptr = png_ptr->error_ptr;
1507 free_fn = png_ptr->free_fn;
1510 png_memset(png_ptr, 0, png_sizeof(png_struct));
1512 png_ptr->error_fn = error_fn;
1513 png_ptr->warning_fn = warning_fn;
1514 png_ptr->error_ptr = error_ptr;
1516 png_ptr->free_fn = free_fn;
1520 png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
1526 png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
1528 if (png_ptr == NULL)
1530 png_ptr->read_row_fn = read_row_fn;
1537 png_read_png(png_structp png_ptr, png_infop info_ptr,
1543 if (png_ptr == NULL)
1549 png_set_invert_alpha(png_ptr);
1555 png_read_info(png_ptr, info_ptr);
1557 png_error(png_ptr, "Image is too high to process with png_read_png()");
1565 png_set_strip_16(png_ptr);
1573 png_set_strip_alpha(png_ptr);
1581 png_set_packing(png_ptr);
1589 png_set_packswap(png_ptr);
1599 if ((png_ptr->bit_depth < 8) ||
1600 (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||
1601 (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
1602 png_set_expand(png_ptr);
1612 png_set_invert_mono(png_ptr);
1621 && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
1625 png_get_sBIT(png_ptr, info_ptr, &sig_bit);
1626 png_set_shift(png_ptr, sig_bit);
1634 png_set_bgr(png_ptr);
1641 png_set_swap_alpha(png_ptr);
1648 png_set_swap(png_ptr);
1656 png_set_invert_alpha(png_ptr);
1664 png_set_gray_to_rgb(png_ptr);
1673 png_read_update_info(png_ptr, info_ptr);
1678 png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
1682 info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
1692 info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
1693 png_get_rowbytes(png_ptr, info_ptr));
1696 png_read_image(png_ptr, info_ptr->row_pointers);
1700 png_read_end(png_ptr, info_ptr);
