16 #ifdef PNG_WRITE_SUPPORTED
30 png_debug(1,
"in png_write_info_before_PLTE");
32 if (png_ptr ==
NULL || info_ptr ==
NULL)
40 #ifdef PNG_MNG_FEATURES_SUPPORTED
42 (png_ptr->mng_features_permitted))
44 png_warning(png_ptr,
"MNG features are not allowed in a PNG datastream");
45 png_ptr->mng_features_permitted = 0;
51 info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
52 info_ptr->filter_type,
54 info_ptr->interlace_type);
61 #ifdef PNG_WRITE_gAMA_SUPPORTED
65 #ifdef PNG_WRITE_sRGB_SUPPORTED
70 #ifdef PNG_WRITE_iCCP_SUPPORTED
73 (
png_charp)info_ptr->iccp_profile, (
int)info_ptr->iccp_proflen);
75 #ifdef PNG_WRITE_sBIT_SUPPORTED
77 png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
79 #ifdef PNG_WRITE_cHRM_SUPPORTED
82 info_ptr->x_white, info_ptr->y_white,
83 info_ptr->x_red, info_ptr->y_red,
84 info_ptr->x_green, info_ptr->y_green,
85 info_ptr->x_blue, info_ptr->y_blue);
88 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
89 if (info_ptr->unknown_chunks_num)
95 for (up = info_ptr->unknown_chunks;
96 up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
110 png_warning(png_ptr,
"Writing zero-length unknown chunk");
124 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
130 if (png_ptr ==
NULL || info_ptr ==
NULL)
140 png_error(png_ptr,
"Valid palette required for paletted images");
142 #ifdef PNG_WRITE_tRNS_SUPPORTED
145 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
151 for (j = 0; j<(
int)info_ptr->num_trans; j++)
152 info_ptr->trans_alpha[
j] =
153 (
png_byte)(255 - info_ptr->trans_alpha[j]);
156 png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),
157 info_ptr->num_trans, info_ptr->color_type);
160 #ifdef PNG_WRITE_bKGD_SUPPORTED
162 png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
165 #ifdef PNG_WRITE_hIST_SUPPORTED
170 #ifdef PNG_WRITE_oFFs_SUPPORTED
173 info_ptr->offset_unit_type);
176 #ifdef PNG_WRITE_pCAL_SUPPORTED
178 png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
179 info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
180 info_ptr->pcal_units, info_ptr->pcal_params);
183 #ifdef PNG_WRITE_sCAL_SUPPORTED
186 info_ptr->scal_s_width, info_ptr->scal_s_height);
189 #ifdef PNG_WRITE_pHYs_SUPPORTED
192 info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
195 #ifdef PNG_WRITE_tIME_SUPPORTED
203 #ifdef PNG_WRITE_sPLT_SUPPORTED
205 for (i = 0; i < (
int)info_ptr->splt_palettes_num; i++)
209 #ifdef PNG_WRITE_TEXT_SUPPORTED
211 for (i = 0; i < info_ptr->num_text; i++)
213 png_debug2(2,
"Writing header text chunk %d, type %d", i,
214 info_ptr->text[i].compression);
216 if (info_ptr->text[i].compression > 0)
218 #ifdef PNG_WRITE_iTXt_SUPPORTED
221 info_ptr->text[i].compression,
222 info_ptr->text[i].key,
223 info_ptr->text[i].lang,
224 info_ptr->text[i].lang_key,
225 info_ptr->text[i].text);
227 png_warning(png_ptr,
"Unable to write international text");
236 #ifdef PNG_WRITE_zTXt_SUPPORTED
239 info_ptr->text[i].text, 0,
240 info_ptr->text[i].compression);
242 png_warning(png_ptr,
"Unable to write compressed text");
250 #ifdef PNG_WRITE_tEXt_SUPPORTED
253 info_ptr->text[i].text,
259 png_warning(png_ptr,
"Unable to write uncompressed text");
265 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
266 if (info_ptr->unknown_chunks_num)
272 for (up = info_ptr->unknown_chunks;
273 up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
306 png_error(png_ptr,
"No IDATs written into file");
309 if (info_ptr !=
NULL)
311 #ifdef PNG_WRITE_TEXT_SUPPORTED
314 #ifdef PNG_WRITE_tIME_SUPPORTED
321 #ifdef PNG_WRITE_TEXT_SUPPORTED
323 for (i = 0; i < info_ptr->num_text; i++)
325 png_debug2(2,
"Writing trailer text chunk %d, type %d", i,
326 info_ptr->text[i].compression);
328 if (info_ptr->text[i].compression > 0)
330 #ifdef PNG_WRITE_iTXt_SUPPORTED
333 info_ptr->text[i].compression,
334 info_ptr->text[i].key,
335 info_ptr->text[i].lang,
336 info_ptr->text[i].lang_key,
337 info_ptr->text[i].text);
339 png_warning(png_ptr,
"Unable to write international text");
347 #ifdef PNG_WRITE_zTXt_SUPPORTED
350 info_ptr->text[i].text, 0,
351 info_ptr->text[i].compression);
353 png_warning(png_ptr,
"Unable to write compressed text");
361 #ifdef PNG_WRITE_tEXt_SUPPORTED
364 info_ptr->text[i].text, 0);
366 png_warning(png_ptr,
"Unable to write uncompressed text");
374 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
375 if (info_ptr->unknown_chunks_num)
381 for (up = info_ptr->unknown_chunks;
382 up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
410 #ifdef PNG_WRITE_FLUSH_SUPPORTED
411 # ifdef PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED
417 #ifdef PNG_CONVERT_tIME_SUPPORTED
422 png_debug(1,
"in png_convert_from_struct_tm");
424 ptime->year = (
png_uint_16)(1900 + ttime->tm_year);
425 ptime->month = (
png_byte)(ttime->tm_mon + 1);
426 ptime->day = (
png_byte)ttime->tm_mday;
427 ptime->hour = (
png_byte)ttime->tm_hour;
428 ptime->minute = (
png_byte)ttime->tm_min;
429 ptime->second = (
png_byte)ttime->tm_sec;
437 png_debug(1,
"in png_convert_from_time_t");
439 tbuf = gmtime(&ttime);
447 png_error_ptr error_fn, png_error_ptr warn_fn),
PNG_ALLOCATED)
449 #ifdef PNG_USER_MEM_SUPPORTED
450 return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,
459 png_error_ptr error_fn, png_error_ptr warn_fn,
png_voidp mem_ptr,
460 png_malloc_ptr malloc_fn, png_free_ptr free_fn),
PNG_ALLOCATED)
463 volatile int png_cleanup_needed = 0;
464 #ifdef PNG_SETJMP_SUPPORTED
468 #ifdef PNG_SETJMP_SUPPORTED
469 #ifdef USE_FAR_KEYWORD
474 png_debug(1,
"in png_create_write_struct");
476 #ifdef PNG_USER_MEM_SUPPORTED
478 (png_malloc_ptr)malloc_fn, (
png_voidp)mem_ptr);
486 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
491 #ifdef PNG_SETJMP_SUPPORTED
496 #ifdef USE_FAR_KEYWORD
497 if (setjmp(tmp_jmpbuf))
501 #ifdef USE_FAR_KEYWORD
507 #ifdef PNG_USER_MEM_SUPPORTED
513 png_cleanup_needed = 1;
518 if (!png_cleanup_needed)
520 png_ptr->zbuf = (
png_bytep)png_malloc_warn(png_ptr,
522 if (png_ptr->zbuf ==
NULL)
523 png_cleanup_needed = 1;
526 if (png_cleanup_needed)
530 png_ptr->zbuf =
NULL;
531 #ifdef PNG_USER_MEM_SUPPORTED
533 (png_free_ptr)free_fn, (
png_voidp)mem_ptr);
542 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
568 for (i = 0, rp = row; i < num_rows; i++, rp++)
589 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
598 for (pass = 0; pass < num_pass; pass++)
601 for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
618 png_debug2(1,
"in png_write_row (row %u, pass %d)",
619 png_ptr->row_number, png_ptr->pass);
622 if (png_ptr->row_number == 0 && png_ptr->pass == 0)
627 "png_write_info was never called before png_write_row");
630 #if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
632 png_warning(png_ptr,
"PNG_WRITE_INVERT_SUPPORTED is not defined");
635 #if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
637 png_warning(png_ptr,
"PNG_WRITE_FILLER_SUPPORTED is not defined");
639 #if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
640 defined(PNG_READ_PACKSWAP_SUPPORTED)
643 "PNG_WRITE_PACKSWAP_SUPPORTED is not defined");
646 #if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
647 if (png_ptr->transformations &
PNG_PACK)
648 png_warning(png_ptr,
"PNG_WRITE_PACK_SUPPORTED is not defined");
651 #if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
652 if (png_ptr->transformations &
PNG_SHIFT)
653 png_warning(png_ptr,
"PNG_WRITE_SHIFT_SUPPORTED is not defined");
656 #if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
657 if (png_ptr->transformations &
PNG_BGR)
658 png_warning(png_ptr,
"PNG_WRITE_BGR_SUPPORTED is not defined");
661 #if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
663 png_warning(png_ptr,
"PNG_WRITE_SWAP_SUPPORTED is not defined");
669 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
671 if (png_ptr->interlaced && (png_ptr->transformations &
PNG_INTERLACE))
673 switch (png_ptr->pass)
676 if (png_ptr->row_number & 0x07)
684 if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
692 if ((png_ptr->row_number & 0x07) != 4)
700 if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)
708 if ((png_ptr->row_number & 0x03) != 2)
716 if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)
724 if (!(png_ptr->row_number & 0x01))
739 row_info.
width = png_ptr->usr_width;
740 row_info.
channels = png_ptr->usr_channels;
741 row_info.
bit_depth = png_ptr->usr_bit_depth;
755 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
757 if (png_ptr->interlaced && png_ptr->pass < 6 &&
762 if (!(row_info.
width))
770 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
772 if (png_ptr->transformations)
779 if (row_info.
pixel_depth != png_ptr->pixel_depth ||
780 row_info.
pixel_depth != png_ptr->transformed_pixel_depth)
781 png_error(png_ptr,
"internal write transform logic error");
783 #ifdef PNG_MNG_FEATURES_SUPPORTED
804 if (png_ptr->write_row_fn !=
NULL)
805 (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
808 #ifdef PNG_WRITE_FLUSH_SUPPORTED
818 png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
833 if (png_ptr->row_number >= png_ptr->num_rows)
847 if (png_ptr->zstream.msg !=
NULL)
848 png_error(png_ptr, png_ptr->zstream.msg);
854 if (!(png_ptr->zstream.avail_out))
860 }
while (wrote_IDAT == 1);
863 if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)
867 png_ptr->zbuf_size - png_ptr->zstream.avail_out);
869 png_ptr->flush_rows = 0;
880 #ifdef PNG_USER_MEM_SUPPORTED
881 png_free_ptr free_fn =
NULL;
885 png_debug(1,
"in png_destroy_write_struct");
887 if (png_ptr_ptr !=
NULL)
888 png_ptr = *png_ptr_ptr;
890 #ifdef PNG_USER_MEM_SUPPORTED
893 free_fn = png_ptr->free_fn;
894 mem_ptr = png_ptr->mem_ptr;
898 if (info_ptr_ptr !=
NULL)
899 info_ptr = *info_ptr_ptr;
901 if (info_ptr !=
NULL)
907 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
908 if (png_ptr->num_chunk_list)
910 png_free(png_ptr, png_ptr->chunk_list);
911 png_ptr->num_chunk_list = 0;
916 #ifdef PNG_USER_MEM_SUPPORTED
922 *info_ptr_ptr =
NULL;
928 #ifdef PNG_USER_MEM_SUPPORTED
943 #ifdef PNG_SETJMP_SUPPORTED
946 png_error_ptr error_fn;
947 #ifdef PNG_WARNINGS_SUPPORTED
948 png_error_ptr warning_fn;
951 #ifdef PNG_USER_MEM_SUPPORTED
952 png_free_ptr free_fn;
958 if (png_ptr->zlib_state != PNG_ZLIB_UNINITIALIZED)
963 png_free(png_ptr, png_ptr->row_buf);
964 #ifdef PNG_WRITE_FILTER_SUPPORTED
965 png_free(png_ptr, png_ptr->prev_row);
966 png_free(png_ptr, png_ptr->sub_row);
968 png_free(png_ptr, png_ptr->avg_row);
969 png_free(png_ptr, png_ptr->paeth_row);
972 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
975 png_free(png_ptr, png_ptr->filter_costs);
976 png_free(png_ptr, png_ptr->inv_filter_costs);
979 #ifdef PNG_SETJMP_SUPPORTED
984 error_fn = png_ptr->error_fn;
985 #ifdef PNG_WARNINGS_SUPPORTED
986 warning_fn = png_ptr->warning_fn;
988 error_ptr = png_ptr->error_ptr;
989 #ifdef PNG_USER_MEM_SUPPORTED
990 free_fn = png_ptr->free_fn;
995 png_ptr->error_fn = error_fn;
996 #ifdef PNG_WARNINGS_SUPPORTED
997 png_ptr->warning_fn = warning_fn;
999 png_ptr->error_ptr = error_ptr;
1000 #ifdef PNG_USER_MEM_SUPPORTED
1001 png_ptr->free_fn = free_fn;
1004 #ifdef PNG_SETJMP_SUPPORTED
1015 if (png_ptr ==
NULL)
1018 #ifdef PNG_MNG_FEATURES_SUPPORTED
1028 #ifdef PNG_WRITE_FILTER_SUPPORTED
1031 case 7:
png_warning(png_ptr,
"Unknown row filter for method 0");
1036 #ifdef PNG_WRITE_FILTER_SUPPORTED
1050 png_ptr->do_filter = (
png_byte)filters;
break;
1053 png_warning(png_ptr,
"Unknown row filter for method 0");
1066 if (png_ptr->row_buf !=
NULL)
1068 #ifdef PNG_WRITE_FILTER_SUPPORTED
1071 png_ptr->sub_row = (
png_bytep)png_malloc(png_ptr,
1072 (png_ptr->rowbytes + 1));
1078 if (png_ptr->prev_row ==
NULL)
1080 png_warning(png_ptr,
"Can't add Up filter after starting");
1081 png_ptr->do_filter = (
png_byte)(png_ptr->do_filter &
1087 png_ptr->up_row = (
png_bytep)png_malloc(png_ptr,
1088 (png_ptr->rowbytes + 1));
1095 if (png_ptr->prev_row ==
NULL)
1097 png_warning(png_ptr,
"Can't add Average filter after starting");
1098 png_ptr->do_filter = (
png_byte)(png_ptr->do_filter &
1104 png_ptr->avg_row = (
png_bytep)png_malloc(png_ptr,
1105 (png_ptr->rowbytes + 1));
1111 png_ptr->paeth_row ==
NULL)
1113 if (png_ptr->prev_row ==
NULL)
1115 png_warning(png_ptr,
"Can't add Paeth filter after starting");
1121 png_ptr->paeth_row = (
png_bytep)png_malloc(png_ptr,
1122 (png_ptr->rowbytes + 1));
1133 png_error(png_ptr,
"Unknown custom filter method");
1143 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
1153 png_ptr->num_prev_filters = 0;
1155 if (png_ptr->prev_filters !=
NULL)
1158 png_ptr->prev_filters =
NULL;
1161 if (png_ptr->filter_weights !=
NULL)
1164 png_ptr->filter_weights =
NULL;
1168 if (png_ptr->inv_filter_weights !=
NULL)
1171 png_ptr->inv_filter_weights =
NULL;
1182 if (png_ptr ==
NULL)
1196 if (num_weights > 0)
1198 png_ptr->prev_filters = (
png_bytep)png_malloc(png_ptr,
1202 for (i = 0; i < num_weights; i++)
1204 png_ptr->prev_filters[
i] = 255;
1207 png_ptr->filter_weights = (
png_uint_16p)png_malloc(png_ptr,
1210 png_ptr->inv_filter_weights = (
png_uint_16p)png_malloc(png_ptr,
1213 for (i = 0; i < num_weights; i++)
1215 png_ptr->inv_filter_weights[
i] =
1220 png_ptr->num_prev_filters = (
png_byte)num_weights;
1226 if (png_ptr->filter_costs ==
NULL)
1228 png_ptr->filter_costs = (
png_uint_16p)png_malloc(png_ptr,
1231 png_ptr->inv_filter_costs = (
png_uint_16p)png_malloc(png_ptr,
1237 png_ptr->inv_filter_costs[
i] =
1254 png_warning(png_ptr,
"Unknown filter heuristic method");
1260 #ifdef PNG_FLOATING_POINT_SUPPORTED
1263 int num_weights, png_const_doublep filter_weights,
1264 png_const_doublep filter_costs)
1266 png_debug(1,
"in png_set_filter_heuristics");
1278 for (i = 0; i < num_weights; i++)
1280 if (filter_weights[i] <= 0.0)
1282 png_ptr->inv_filter_weights[
i] =
1288 png_ptr->inv_filter_weights[
i] =
1291 png_ptr->filter_weights[
i] =
1303 for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) if (filter_costs[i] >= 1.0)
1305 png_ptr->inv_filter_costs[
i] =
1308 png_ptr->filter_costs[
i] =
1315 #ifdef PNG_FIXED_POINT_SUPPORTED
1321 png_debug(1,
"in png_set_filter_heuristics_fixed");
1333 for (i = 0; i < num_weights; i++)
1335 if (filter_weights[i] <= 0)
1337 png_ptr->inv_filter_weights[
i] =
1347 PNG_FP_1+(filter_weights[i]/2))/filter_weights[i]);
1368 tmp /= filter_costs[
i];
1385 png_debug(1,
"in png_set_compression_level");
1387 if (png_ptr ==
NULL)
1391 png_ptr->zlib_level =
level;
1397 png_debug(1,
"in png_set_compression_mem_level");
1399 if (png_ptr ==
NULL)
1403 png_ptr->zlib_mem_level = mem_level;
1409 png_debug(1,
"in png_set_compression_strategy");
1411 if (png_ptr ==
NULL)
1415 png_ptr->zlib_strategy = strategy;
1424 if (png_ptr ==
NULL)
1427 if (window_bits > 15)
1428 png_warning(png_ptr,
"Only compression windows <= 32k supported by PNG");
1430 else if (window_bits < 8)
1431 png_warning(png_ptr,
"Only compression windows >= 256 supported by PNG");
1435 if (window_bits == 8)
1437 png_warning(png_ptr,
"Compression window is being reset to 512");
1443 png_ptr->zlib_window_bits = window_bits;
1449 png_debug(1,
"in png_set_compression_method");
1451 if (png_ptr ==
NULL)
1455 png_warning(png_ptr,
"Only compression method 8 is supported by PNG");
1458 png_ptr->zlib_method = method;
1462 #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
1466 png_debug(1,
"in png_set_text_compression_level");
1468 if (png_ptr ==
NULL)
1472 png_ptr->zlib_text_level =
level;
1478 png_debug(1,
"in png_set_text_compression_mem_level");
1480 if (png_ptr ==
NULL)
1484 png_ptr->zlib_text_mem_level = mem_level;
1490 png_debug(1,
"in png_set_text_compression_strategy");
1492 if (png_ptr ==
NULL)
1496 png_ptr->zlib_text_strategy = strategy;
1505 if (png_ptr ==
NULL)
1508 if (window_bits > 15)
1509 png_warning(png_ptr,
"Only compression windows <= 32k supported by PNG");
1511 else if (window_bits < 8)
1512 png_warning(png_ptr,
"Only compression windows >= 256 supported by PNG");
1516 if (window_bits == 8)
1518 png_warning(png_ptr,
"Text compression window is being reset to 512");
1524 png_ptr->zlib_text_window_bits = window_bits;
1530 png_debug(1,
"in png_set_text_compression_method");
1532 if (png_ptr ==
NULL)
1536 png_warning(png_ptr,
"Only compression method 8 is supported by PNG");
1539 png_ptr->zlib_text_method = method;
1547 if (png_ptr ==
NULL)
1550 png_ptr->write_row_fn = write_row_fn;
1553 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
1556 write_user_transform_fn)
1558 png_debug(1,
"in png_set_write_user_transform_fn");
1560 if (png_ptr ==
NULL)
1564 png_ptr->write_user_transform_fn = write_user_transform_fn;
1569 #ifdef PNG_INFO_IMAGE_SUPPORTED
1574 if (png_ptr ==
NULL || info_ptr ==
NULL)
1582 #ifdef PNG_WRITE_INVERT_SUPPORTED
1588 #ifdef PNG_WRITE_SHIFT_SUPPORTED
1597 #ifdef PNG_WRITE_PACK_SUPPORTED
1603 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
1609 #ifdef PNG_WRITE_FILLER_SUPPORTED
1618 #ifdef PNG_WRITE_BGR_SUPPORTED
1624 #ifdef PNG_WRITE_SWAP_SUPPORTED
1630 #ifdef PNG_WRITE_PACKSWAP_SUPPORTED
1636 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
void png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
#define PNG_FILTER_VALUE_AVG
void PNGAPI png_set_packing(png_structp png_ptr)
#define PNG_TRANSFORM_SWAP_ENDIAN
void png_write_start_row(png_structp png_ptr)
void PNGAPI png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, int num)
void PNGAPI png_write_image(png_structp png_ptr, png_bytepp image)
void PNGAPI png_write_png(png_structp png_ptr, png_infop info_ptr, int transforms, voidp params)
#define PNG_FILTER_VALUE_LAST
void png_write_sPLT(png_structp png_ptr, png_const_sPLT_tp spalette)
#define PNG_FILLER_BEFORE
void PNGAPI png_set_flush(png_structp png_ptr, int nrows)
void png_write_PLTE(png_structp png_ptr, png_const_colorp palette, png_uint_32 num_pal)
#define PNG_UNUSED(param)
int png_user_version_check(png_structp png_ptr, png_const_charp user_png_ver)
void PNGAPI png_set_compression_level(png_structp png_ptr, int level)
#define PNG_FILTER_HEURISTIC_WEIGHTED
void png_write_sBIT(png_structp png_ptr, png_const_color_8p sbit, int color_type)
#define PNG_TRANSFORM_INVERT_MONO
#define PNG_FLAG_ZTXT_CUSTOM_WINDOW_BITS
void PNGAPI png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)
void PNGAPI png_set_filter_heuristics(png_structp png_ptr, int heuristic_method, int num_weights, png_const_doublep filter_weights, png_const_doublep filter_costs)
void PNGAPI png_set_invert_alpha(png_structp png_ptr)
#define PNG_TRANSFORM_PACKSWAP
void png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)
void PNGAPI png_write_rows(png_structp png_ptr, png_bytepp row, png_uint_32 num_rows)
#define PNG_COLOR_TYPE_PALETTE
#define PNG_FILTER_VALUE_PAETH
png_error(png_ptr,"Missing IHDR before iCCP")
void png_write_zTXt(png_structp png_ptr, png_const_charp key, png_const_charp text, png_size_t text_len, int compression)
void PNGAPI png_write_chunk(png_structp png_ptr, png_const_bytep chunk_string, png_const_bytep data, png_size_t length)
#define PNG_TRANSFORM_BGR
PNG_CONST char FAR * png_const_charp
void PNGAPI png_set_text_compression_mem_level(png_structp png_ptr, int mem_level)
void PNGAPI png_set_compression_strategy(png_structp png_ptr, int strategy)
int ZEXPORT deflateEnd(z_streamp strm)
void png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset, int unit_type)
void png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
#define PNG_TRANSFORM_STRIP_FILLER_AFTER
void PNGAPI png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
#define PNG_TEXT_COMPRESSION_NONE_WR
#define png_jmpbuf(png_ptr)
png_struct FAR *FAR * png_structpp
#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL
#define PNG_FLAG_ZTXT_CUSTOM_STRATEGY
void png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, png_const_charp units, png_charpp params)
void png_flush(png_structp png_ptr)
void PNGAPI png_write_row(png_structp png_ptr, png_const_bytep row)
void png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, int unit_type)
void PNGAPI png_set_bgr(png_structp png_ptr)
png_byte FAR *FAR * png_bytepp
#define PNG_TEXT_COMPRESSION_zTXt
void PNGAPI png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr write_user_transform_fn)
#define PNG_FILTER_HEURISTIC_UNWEIGHTED
#define PNG_TEXT_COMPRESSION_NONE
GLenum GLenum GLvoid * row
png_struct FAR * png_structp
void PNGAPI png_write_info(png_structp png_ptr, png_infop info_ptr)
#define PNG_HANDLE_CHUNK_ALWAYS
void png_write_tIME(png_structp png_ptr, png_const_timep mod_time)
void PNGAPI png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
void png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x, png_fixed_point blue_y)
void png_write_tEXt(png_structp png_ptr, png_const_charp key, png_const_charp text, png_size_t text_len)
void PNGAPI png_set_packswap(png_structp png_ptr)
void PNGAPI png_set_text_compression_strategy(png_structp png_ptr, int strategy)
#define PNG_USER_HEIGHT_MAX
#define PNG_TRANSFORM_STRIP_FILLER_BEFORE
void png_destroy_struct(png_voidp struct_ptr)
void PNGAPI png_set_swap(png_structp png_ptr)
void PNGAPI png_write_flush(png_structp png_ptr)
void PNGAPI png_set_text_compression_level(png_structp png_ptr, int level)
void png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
unsigned short png_uint_16
void PNGAPI png_set_compression_mem_level(png_structp png_ptr, int mem_level)
#define PNG_FILTER_VALUE_SUB
void png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int compression_type, int filter_type, int interlace_type)
void PNGAPI png_warning(png_structp png_ptr, png_const_charp warning_message)
#define PNG_WEIGHT_FACTOR
int PNGAPI png_handle_as_unknown(png_structp png_ptr, png_const_bytep chunk_name)
void PNGAPI png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)
png_uint_16 FAR * png_uint_16p
#define PNG_FLAG_ZTXT_CUSTOM_METHOD
void PNGAPI png_write_end(png_structp png_ptr, png_infop info_ptr)
PNG_CONST png_byte FAR * png_const_bytep
PNG_CONST png_fixed_point FAR * png_const_fixed_point_p
void PNGAPI png_set_shift(png_structp png_ptr, png_const_color_8p true_bits)
#define png_debug1(l, m, p1)
#define PNG_FLAG_ZTXT_CUSTOM_LEVEL
#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS
#define PNG_TRANSFORM_PACKING
#define PNG_TRANSFORM_INVERT_ALPHA
void png_write_iCCP(png_structp png_ptr, png_const_charp name, int compression_type, png_const_charp profile, int profile_len)
void PNGAPI png_set_compression_window_bits(png_structp png_ptr, int window_bits)
#define PNG_FILTER_VALUE_UP
int ZEXPORT deflate(z_streamp strm, int flush)
#define PNG_FLAG_ZLIB_CUSTOM_METHOD
void PNGAPI png_set_invert_mono(png_structp png_ptr)
#define PNG_FLAG_MNG_FILTER_64
#define PNG_FLAG_ZLIB_CUSTOM_LEVEL
#define PNG_FILTER_TYPE_BASE
void png_write_destroy(png_structp png_ptr)
void PNGAPI png_set_filter_heuristics_fixed(png_structp png_ptr, int heuristic_method, int num_weights, png_const_fixed_point_p filter_weights, png_const_fixed_point_p filter_costs)
#define PNG_TEXT_COMPRESSION_zTXt_WR
void PNGAPI png_set_text_compression_window_bits(png_structp png_ptr, int window_bits)
#define PNG_COMPRESSION_TYPE_BASE
void png_write_sRGB(png_structp png_ptr, int srgb_intent)
void PNGAPI png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
#define PNG_FILTER_HEURISTIC_DEFAULT
void PNGAPI png_convert_from_time_t(png_timep ptime, time_t ttime)
void PNGAPI png_write_sig(png_structp png_ptr)
void PNGAPI png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
#define PNG_FLAG_ZTXT_CUSTOM_MEM_LEVEL
int PNGAPI png_set_interlace_handling(png_structp png_ptr)
#define PNG_WROTE_INFO_BEFORE_PLTE
void png_write_tRNS(png_structp png_ptr, png_const_bytep trans_alpha, png_const_color_16p tran, int num_trans, int color_type)
void png_write_IEND(png_structp png_ptr)
void png_write_iTXt(png_structp png_ptr, int compression, png_const_charp key, png_const_charp lang, png_const_charp lang_key, png_const_charp text)
#define PNG_TRANSFORM_SWAP_ALPHA
void png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, png_voidp mem_ptr)
#define PNG_FILTER_VALUE_NONE
#define PNG_USER_TRANSFORM
#define PNG_WRITE_INTERLACING_SUPPORTED
#define PNG_INTRAPIXEL_DIFFERENCING
void png_do_write_transformations(png_structp png_ptr, png_row_infop row_info)
#define PNG_FUNCTION(type, name, args, attributes)
void png_write_hIST(png_structp png_ptr, png_const_uint_16p hist, int num_hist)
#define PNG_USER_WIDTH_MAX
void PNGAPI png_set_compression_method(png_structp png_ptr, int method)
void png_write_finish_row(png_structp png_ptr)
#define PNG_FLAG_KEEP_UNSAFE_CHUNKS
png_info FAR *FAR * png_infopp
void PNGAPI png_free(png_structp png_ptr, png_voidp ptr)
void PNGAPI png_set_swap_alpha(png_structp png_ptr)
#define PNG_ROWBYTES(pixel_bits, width)
#define PNG_HAVE_PNG_SIGNATURE
#define PNG_TRANSFORM_SHIFT
void PNGAPI png_set_filter(png_structp png_ptr, int method, int filters)
void png_write_sCAL_s(png_structp png_ptr, int unit, png_const_charp width, png_const_charp height)
void png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
void PNGAPI png_set_error_fn(png_structp png_ptr, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)
#define PNG_HANDLE_CHUNK_NEVER
static int png_init_filter_heuristics(png_structp png_ptr, int heuristic_method, int num_weights)
static void png_reset_filter_heuristics(png_structp png_ptr)
void PNGAPI png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm FAR *ttime)
#define png_debug2(l, m, p1, p2)
void png_write_bKGD(png_structp png_ptr, png_const_color_16p back, int color_type)
void PNGAPI png_set_text_compression_method(png_structp png_ptr, int method)
#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY