1 module libpng.png; 2 3 import libpng.conf; 4 import libpng.libconf; 5 6 extern(C) nothrow @nogc: 7 8 static if (PNG_STDIO_SUPPORTED) { 9 import core.stdc.stdio : FILE; 10 } 11 static if (PNG_SETJMP_SUPPORTED) { 12 version(Posix) { 13 import core.sys.posix.setjmp : jmp_buf; 14 enum pngSetJmpSupported = true; 15 } 16 else { 17 // setjmp bindings on Windows ? 18 enum pngSetJmpSupported = false; 19 } 20 } 21 else { 22 enum pngSetJmpSupported = false; 23 } 24 static if (PNG_tIME_SUPPORTED) { 25 import core.stdc.time : time_t, tm; 26 } 27 28 enum PNG_LIBPNG_VER_STRING = "1.6.35"; 29 enum PNG_HEADER_VERSION_STRING = " libpng version 1.6.35 - July 15, 2018\n"; 30 31 enum PNG_LIBPNG_VER_SONUM = 16; 32 enum PNG_LIBPNG_VER_DLLNUM = 16; 33 34 enum PNG_LIBPNG_VER_MAJOR = 1; 35 enum PNG_LIBPNG_VER_MINOR = 6; 36 enum PNG_LIBPNG_VER_RELEASE = 35; 37 38 enum PNG_LIBPNG_VER = 10635; // 1.6.35 39 40 extern(D) 41 auto png_libpng_ver() 42 { 43 return png_get_header_ver(null); 44 } 45 46 struct png_struct; 47 alias png_const_structp = const(png_struct)*; 48 alias png_structp = png_struct*; 49 alias png_structpp = png_struct**; 50 51 alias png_structrp = png_structp; 52 alias png_const_structrp = png_const_structp; 53 54 struct png_info; 55 alias png_const_infop = const(png_info)*; 56 alias png_infop = png_info*; 57 alias png_infopp = png_info**; 58 59 alias png_inforp = png_infop; 60 alias png_const_inforp = png_const_infop; 61 62 struct png_color 63 { 64 png_byte red; 65 png_byte green; 66 png_byte blue; 67 } 68 alias png_colorp = png_color*; 69 alias png_const_colorp = const(png_color)*; 70 alias png_colorpp = png_color**; 71 72 struct png_color_16 73 { 74 png_byte index; /* used for palette files */ 75 png_uint_16 red; /* for use in red green blue files */ 76 png_uint_16 green; 77 png_uint_16 blue; 78 png_uint_16 gray; /* for use in grayscale files */ 79 } 80 alias png_color_16p = png_color_16*; 81 alias png_const_color_16p = const(png_color_16)*; 82 alias png_color_16pp = png_color_16**; 83 84 struct png_color_8 85 { 86 png_byte red; /* for use in red green blue files */ 87 png_byte green; 88 png_byte blue; 89 png_byte gray; /* for use in grayscale files */ 90 png_byte alpha; /* for alpha channel files */ 91 } 92 alias png_color_8p = png_color_8*; 93 alias png_const_color_8p = const(png_color_8)*; 94 alias png_color_8pp = png_color_8**; 95 96 struct png_sPLT_entry 97 { 98 png_uint_16 red; 99 png_uint_16 green; 100 png_uint_16 blue; 101 png_uint_16 alpha; 102 png_uint_16 frequency; 103 } 104 alias png_sPLT_entryp = png_sPLT_entry*; 105 alias png_const_sPLT_entryp = const(png_sPLT_entry)*; 106 alias png_sPLT_entrypp = png_sPLT_entry**; 107 108 struct png_sPLT_t 109 { 110 png_charp name; /* palette name */ 111 png_byte depth; /* depth of palette samples */ 112 png_sPLT_entryp entries; /* palette entries */ 113 png_int_32 nentries; /* number of palette entries */ 114 } 115 alias png_sPLT_tp = png_sPLT_t*; 116 alias png_const_sPLT_tp = const(png_sPLT_t)*; 117 alias png_sPLT_tpp = png_sPLT_t**; 118 119 static if (PNG_TEXT_SUPPORTED) { 120 121 struct png_text 122 { 123 int compression; /* compression value: 124 -1: tEXt, none 125 0: zTXt, deflate 126 1: iTXt, none 127 2: iTXt, deflate */ 128 png_charp key; /* keyword, 1-79 character description of "text" */ 129 png_charp text; /* comment, may be an empty string (ie "") 130 or a NULL pointer */ 131 size_t text_length; /* length of the text string */ 132 size_t itxt_length; /* length of the itxt string */ 133 png_charp lang; /* language code, 0-79 characters 134 or a NULL pointer */ 135 png_charp lang_key; /* keyword translated UTF-8 string, 0 or more 136 chars or a NULL pointer */ 137 } 138 alias png_textp = png_text*; 139 alias png_const_textp = const(png_text)*; 140 alias png_textpp = png_text**; 141 } 142 143 enum PNG_TEXT_COMPRESSION_NONE_WR = -3; 144 enum PNG_TEXT_COMPRESSION_zTXt_WR = -2; 145 enum PNG_TEXT_COMPRESSION_NONE = -1; 146 enum PNG_TEXT_COMPRESSION_zTXt = 0; 147 enum PNG_ITXT_COMPRESSION_NONE = 1; 148 enum PNG_ITXT_COMPRESSION_zTXt = 2; 149 enum PNG_TEXT_COMPRESSION_LAST = 3; 150 151 struct png_time 152 { 153 png_uint_16 year; /* full year, as in, 1995 */ 154 png_byte month; /* month of year, 1 - 12 */ 155 png_byte day; /* day of month, 1 - 31 */ 156 png_byte hour; /* hour of day, 0 - 23 */ 157 png_byte minute; /* minute of hour, 0 - 59 */ 158 png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ 159 } 160 alias png_timep = png_time*; 161 alias png_const_timep = const(png_time)*; 162 alias png_timepp = png_time**; 163 164 static if (PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED || PNG_USER_CHUNKS_SUPPORTED) { 165 166 struct png_unknown_chunk 167 { 168 png_byte[5] name; /* Textual chunk name with '\0' terminator */ 169 png_byte *data; /* Data, should not be modified on read! */ 170 size_t size; 171 172 png_byte location; /* mode of operation at read time */ 173 } 174 alias png_unknown_chunkp = png_unknown_chunk*; 175 alias png_const_unknown_chunkp = const(png_unknown_chunk)*; 176 alias png_unknown_chunkpp = png_unknown_chunk**; 177 178 } 179 180 enum PNG_HAVE_IHDR = 0x01; 181 enum PNG_HAVE_PLTE = 0x02; 182 enum PNG_AFTER_IDAT = 0x08; 183 184 enum uint PNG_UINT_31_MAX = 0x7fffffffL; 185 enum uint PNG_UINT_32_MAX = uint.max; 186 enum size_t PNG_SIZE_MAX = size_t.max; 187 188 enum png_fixed_point PNG_FP_1 = 100000; 189 enum png_fixed_point PNG_FP_HALF = 50000; 190 enum png_fixed_point PNG_FP_MAX = 0x7fffffff; 191 enum png_fixed_point PNG_FP_MIN = -PNG_FP_MAX; 192 193 enum PNG_COLOR_MASK_PALETTE = 1; 194 enum PNG_COLOR_MASK_COLOR = 2; 195 enum PNG_COLOR_MASK_ALPHA = 4; 196 197 enum PNG_COLOR_TYPE_GRAY = 0; 198 enum PNG_COLOR_TYPE_PALETTE = PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE; 199 enum PNG_COLOR_TYPE_RGB = PNG_COLOR_MASK_COLOR; 200 enum PNG_COLOR_TYPE_RGB_ALPHA = PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA; 201 enum PNG_COLOR_TYPE_GRAY_ALPHA = PNG_COLOR_MASK_ALPHA; 202 203 enum PNG_COLOR_TYPE_RGBA = PNG_COLOR_TYPE_RGB_ALPHA; 204 enum PNG_COLOR_TYPE_GA = PNG_COLOR_TYPE_GRAY_ALPHA; 205 206 enum PNG_COMPRESSION_TYPE_BASE = 0; 207 enum PNG_COMPRESSION_TYPE_DEFAULT = PNG_COMPRESSION_TYPE_BASE; 208 209 enum PNG_FILTER_TYPE_BASE = 0; 210 enum PNG_INTRAPIXEL_DIFFERENCING = 64; 211 enum PNG_FILTER_TYPE_DEFAULT = PNG_FILTER_TYPE_BASE; 212 213 enum PNG_INTERLACE_NONE = 0; 214 enum PNG_INTERLACE_ADAM7 = 1; 215 enum PNG_INTERLACE_LAST = 2; 216 217 enum PNG_OFFSET_PIXEL = 0; 218 enum PNG_OFFSET_MICROMETER = 1; 219 enum PNG_OFFSET_LAST = 2; 220 221 enum PNG_EQUATION_LINEAR = 0; 222 enum PNG_EQUATION_BASE_E = 1; 223 enum PNG_EQUATION_ARBITRARY = 2; 224 enum PNG_EQUATION_HYPERBOLIC = 3; 225 enum PNG_EQUATION_LAST = 4; 226 227 enum PNG_SCALE_UNKNOWN = 0; 228 enum PNG_SCALE_METER = 1; 229 enum PNG_SCALE_RADIAN = 2; 230 enum PNG_SCALE_LAST = 3; 231 232 enum PNG_RESOLUTION_UNKNOWN = 0; 233 enum PNG_RESOLUTION_METER = 1; 234 enum PNG_RESOLUTION_LAST = 2; 235 236 enum PNG_sRGB_INTENT_PERCEPTUAL = 0; 237 enum PNG_sRGB_INTENT_RELATIVE = 1; 238 enum PNG_sRGB_INTENT_SATURATION = 2; 239 enum PNG_sRGB_INTENT_ABSOLUTE = 3; 240 enum PNG_sRGB_INTENT_LAST = 4; 241 242 enum PNG_KEYWORD_MAX_LENGTH = 79; 243 244 enum PNG_MAX_PALETTE_LENGTH = 256; 245 246 enum PNG_INFO_gAMA = 0x0001U; 247 enum PNG_INFO_sBIT = 0x0002U; 248 enum PNG_INFO_cHRM = 0x0004U; 249 enum PNG_INFO_PLTE = 0x0008U; 250 enum PNG_INFO_tRNS = 0x0010U; 251 enum PNG_INFO_bKGD = 0x0020U; 252 enum PNG_INFO_hIST = 0x0040U; 253 enum PNG_INFO_pHYs = 0x0080U; 254 enum PNG_INFO_oFFs = 0x0100U; 255 enum PNG_INFO_tIME = 0x0200U; 256 enum PNG_INFO_pCAL = 0x0400U; 257 enum PNG_INFO_sRGB = 0x0800U; 258 enum PNG_INFO_iCCP = 0x1000U; 259 enum PNG_INFO_sPLT = 0x2000U; 260 enum PNG_INFO_sCAL = 0x4000U; 261 enum PNG_INFO_IDAT = 0x8000U; 262 enum PNG_INFO_eXIf = 0x10000U; 263 264 struct png_row_info 265 { 266 png_uint_32 width; /* width of row */ 267 size_t rowbytes; /* number of bytes in row */ 268 png_byte color_type; /* color type of row */ 269 png_byte bit_depth; /* bit depth of row */ 270 png_byte channels; /* number of channels (1, 2, 3, or 4) */ 271 png_byte pixel_depth; /* bits per pixel (depth * channels) */ 272 } 273 alias png_row_infop = png_row_info*; 274 alias png_row_infopp = png_row_info**; 275 276 alias png_error_ptr = void function (png_structp, png_const_charp); 277 alias png_rw_ptr = void function (png_structp, png_bytep, size_t); 278 alias png_flush_ptr = void function (png_structp); 279 alias png_read_status_ptr = void function (png_structp, png_uint_32, int); 280 alias png_write_status_ptr = void function (png_structp, png_uint_32, int); 281 282 static if (PNG_PROGRESSIVE_READ_SUPPORTED) { 283 alias png_progressive_info_ptr = void function (png_structp, png_infop); 284 alias png_progressive_end_ptr = void function (png_structp, png_infop); 285 alias png_progressive_row_ptr = void function (png_structp, png_bytep, png_uint_32, int); 286 } 287 288 static if (PNG_READ_USER_TRANSFORM_SUPPORTED || PNG_WRITE_USER_TRANSFORM_SUPPORTED) { 289 alias png_user_transform_ptr = void function (png_structp, png_row_infop, png_bytep); 290 } 291 292 static if (PNG_USER_CHUNKS_SUPPORTED) { 293 alias png_user_chunk_ptr = int function (png_structp, png_unknown_chunkp); 294 } 295 296 static if (pngSetJmpSupported) { 297 // note, following is signature of longjmp 298 alias png_longjmp_ptr = void function(ref jmp_buf, int); 299 // PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef); 300 } 301 302 enum PNG_TRANSFORM_IDENTITY = 0x0000; 303 enum PNG_TRANSFORM_STRIP_16 = 0x0001; 304 enum PNG_TRANSFORM_STRIP_ALPHA = 0x0002; 305 enum PNG_TRANSFORM_PACKING = 0x0004; 306 enum PNG_TRANSFORM_PACKSWAP = 0x0008; 307 enum PNG_TRANSFORM_EXPAND = 0x0010; 308 enum PNG_TRANSFORM_INVERT_MONO = 0x0020; 309 enum PNG_TRANSFORM_SHIFT = 0x0040; 310 enum PNG_TRANSFORM_BGR = 0x0080; 311 enum PNG_TRANSFORM_SWAP_ALPHA = 0x0100; 312 enum PNG_TRANSFORM_SWAP_ENDIAN = 0x0200; 313 enum PNG_TRANSFORM_INVERT_ALPHA = 0x0400; 314 enum PNG_TRANSFORM_STRIP_FILLER = 0x0800; 315 enum PNG_TRANSFORM_STRIP_FILLER_BEFORE = PNG_TRANSFORM_STRIP_FILLER; 316 enum PNG_TRANSFORM_STRIP_FILLER_AFTER = 0x1000; 317 enum PNG_TRANSFORM_GRAY_TO_RGB = 0x2000; 318 enum PNG_TRANSFORM_EXPAND_16 = 0x4000; 319 enum PNG_TRANSFORM_SCALE_16 = 0x8000; 320 321 enum PNG_FLAG_MNG_EMPTY_PLTE = 0x01; 322 enum PNG_FLAG_MNG_FILTER_64 = 0x04; 323 enum PNG_ALL_MNG_FEATURES = 0x05; 324 325 alias png_malloc_ptr = png_voidp function (png_structp, png_alloc_size_t); 326 alias png_free_ptr = void function (png_structp, png_voidp); 327 328 png_uint_32 png_access_version_number (); 329 330 void png_set_sig_bytes (png_structrp png_ptr, int num_bytes); 331 332 int png_sig_cmp (png_const_bytep sig, size_t start, size_t num_to_check); 333 334 extern(D) 335 bool png_check_sig(png_const_bytep sig, size_t n) 336 { 337 return !png_sig_cmp(sig, 0, n); 338 } 339 340 png_structp png_create_read_struct (png_const_charp user_png_ver, 341 png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn); 342 343 png_structp png_create_write_struct (png_const_charp user_png_ver, 344 png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn); 345 346 size_t png_get_compression_buffer_size (png_const_structrp png_ptr); 347 348 void png_set_compression_buffer_size (png_structrp png_ptr, size_t size); 349 350 static if (pngSetJmpSupported) { 351 jmp_buf* png_set_longjmp_fn (png_structrp png_ptr, 352 png_longjmp_ptr longjmp_fn, size_t jmp_buf_size); 353 } 354 355 extern(D) 356 auto png_jmpbuf(PNG)(PNG png_ptr) 357 { 358 static assert (PNG_SETJMP_SUPPORTED, "libpng compiled without SETJMP support"); 359 return png_set_longjmp_fn(png_ptr, longjmp, jmp_buf.sizeof); 360 } 361 362 void png_longjmp (png_const_structrp png_ptr, int val); 363 364 static if (PNG_USER_MEM_SUPPORTED) { 365 png_structp png_create_read_struct_2 (png_const_charp user_png_ver, 366 png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn, 367 png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn); 368 369 png_structp png_create_write_struct_2 (png_const_charp user_png_ver, 370 png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn, 371 png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn); 372 } 373 374 void png_write_sig (png_structrp png_ptr); 375 376 void png_write_chunk (png_structrp png_ptr, png_const_bytep 377 chunk_name, png_const_bytep data, size_t length); 378 379 void png_write_chunk_start (png_structrp png_ptr, 380 png_const_bytep chunk_name, png_uint_32 length); 381 382 void png_write_chunk_data (png_structrp png_ptr, 383 png_const_bytep data, size_t length); 384 385 void png_write_chunk_end (png_structrp png_ptr); 386 387 png_infop png_create_info_struct (png_const_structrp png_ptr); 388 389 void png_write_info_before_PLTE (png_structrp png_ptr, png_const_inforp info_ptr); 390 void png_write_info (png_structrp png_ptr, png_const_inforp info_ptr); 391 392 static if (PNG_SEQUENTIAL_READ_SUPPORTED) { 393 void png_read_info (png_structrp png_ptr, png_inforp info_ptr); 394 } 395 396 static if (PNG_TIME_RFC1123_SUPPORTED) { 397 int png_convert_to_rfc1123_buffer (ref char[29] out_, png_const_timep ptime); 398 } 399 400 static if (PNG_CONVERT_tIME_SUPPORTED) { 401 void png_convert_from_struct_tm (png_timep ptime, const(tm)* ttime); 402 403 void png_convert_from_time_t (png_timep ptime, time_t ttime); 404 } 405 406 static if (PNG_READ_EXPAND_SUPPORTED) { 407 void png_set_expand (png_structrp png_ptr); 408 void png_set_expand_gray_1_2_4_to_8 (png_structrp png_ptr); 409 void png_set_palette_to_rgb (png_structrp png_ptr); 410 void png_set_tRNS_to_alpha (png_structrp png_ptr); 411 } 412 413 static if (PNG_READ_EXPAND_16_SUPPORTED) { 414 void png_set_expand_16 (png_structrp png_ptr); 415 } 416 417 static if (PNG_READ_BGR_SUPPORTED || PNG_WRITE_BGR_SUPPORTED) { 418 void png_set_bgr (png_structrp png_ptr); 419 } 420 421 static if (PNG_READ_GRAY_TO_RGB_SUPPORTED) { 422 void png_set_gray_to_rgb (png_structrp png_ptr); 423 } 424 425 static if (PNG_READ_RGB_TO_GRAY_SUPPORTED) { 426 enum PNG_ERROR_ACTION_NONE = 1; 427 enum PNG_ERROR_ACTION_WARN = 2; 428 enum PNG_ERROR_ACTION_ERROR = 3; 429 enum PNG_RGB_TO_GRAY_DEFAULT = -1; 430 431 void png_set_rgb_to_gray (png_structrp png_ptr, int error_action, 432 double red, double green); 433 void png_set_rgb_to_gray_fixed (png_structrp png_ptr, 434 int error_action, png_fixed_point red, png_fixed_point green); 435 436 png_byte png_get_rgb_to_gray_status (png_const_structrp png_ptr); 437 } 438 439 static if (PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED) { 440 void png_build_grayscale_palette (int bit_depth, png_colorp palette); 441 } 442 443 static if (PNG_READ_ALPHA_MODE_SUPPORTED) { 444 enum PNG_ALPHA_PNG = 0; 445 enum PNG_ALPHA_STANDARD = 1; 446 enum PNG_ALPHA_ASSOCIATED = 1; 447 enum PNG_ALPHA_PREMULTIPLIED = 1; 448 enum PNG_ALPHA_OPTIMIZED = 2; 449 enum PNG_ALPHA_BROKEN = 3; 450 451 void png_set_alpha_mode (png_structrp png_ptr, int mode, double output_gamma); 452 void png_set_alpha_mode_fixed (png_structrp png_ptr, int mode, png_fixed_point output_gamma); 453 } 454 455 static if (PNG_GAMMA_SUPPORTED || PNG_READ_ALPHA_MODE_SUPPORTED) { 456 enum PNG_DEFAULT_sRGB = -1; 457 enum PNG_GAMMA_MAC_18 = -2; 458 enum PNG_GAMMA_sRGB = 220000; 459 enum PNG_GAMMA_LINEAR = PNG_FP_1; 460 } 461 462 static if (PNG_READ_STRIP_ALPHA_SUPPORTED) { 463 void png_set_strip_alpha (png_structrp png_ptr); 464 } 465 466 static if (PNG_READ_SWAP_ALPHA_SUPPORTED || PNG_WRITE_SWAP_ALPHA_SUPPORTED) { 467 void png_set_swap_alpha (png_structrp png_ptr); 468 } 469 470 static if (PNG_READ_INVERT_ALPHA_SUPPORTED || PNG_WRITE_INVERT_ALPHA_SUPPORTED) { 471 void png_set_invert_alpha (png_structrp png_ptr); 472 } 473 474 static if (PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED) { 475 void png_set_filler (png_structrp png_ptr, png_uint_32 filler, int flags); 476 enum PNG_FILLER_BEFORE = 0; 477 enum PNG_FILLER_AFTER = 1; 478 void png_set_add_alpha (png_structrp png_ptr, png_uint_32 filler, int flags); 479 } 480 481 static if (PNG_READ_SWAP_SUPPORTED || PNG_WRITE_SWAP_SUPPORTED) { 482 void png_set_swap (png_structrp png_ptr); 483 } 484 485 static if (PNG_READ_PACK_SUPPORTED || PNG_WRITE_PACK_SUPPORTED) { 486 void png_set_packing (png_structrp png_ptr); 487 } 488 489 static if (PNG_READ_PACKSWAP_SUPPORTED || PNG_WRITE_PACKSWAP_SUPPORTED) { 490 void png_set_packswap (png_structrp png_ptr); 491 } 492 493 static if (PNG_READ_SHIFT_SUPPORTED || PNG_WRITE_SHIFT_SUPPORTED) { 494 void png_set_shift (png_structrp png_ptr, png_const_color_8p true_bits); 495 } 496 497 static if (PNG_READ_INTERLACING_SUPPORTED || PNG_WRITE_INTERLACING_SUPPORTED) { 498 int png_set_interlace_handling (png_structrp png_ptr); 499 } 500 501 static if (PNG_READ_INVERT_SUPPORTED || PNG_WRITE_INVERT_SUPPORTED) { 502 void png_set_invert_mono (png_structrp png_ptr); 503 } 504 505 static if (PNG_READ_BACKGROUND_SUPPORTED) { 506 void png_set_background (png_structrp png_ptr, 507 png_const_color_16p background_color, int background_gamma_code, 508 int need_expand, double background_gamma); 509 void png_set_background_fixed (png_structrp png_ptr, 510 png_const_color_16p background_color, int background_gamma_code, 511 int need_expand, png_fixed_point background_gamma); 512 513 enum PNG_BACKGROUND_GAMMA_UNKNOWN = 0; 514 enum PNG_BACKGROUND_GAMMA_SCREEN = 1; 515 enum PNG_BACKGROUND_GAMMA_FILE = 2; 516 enum PNG_BACKGROUND_GAMMA_UNIQUE = 3; 517 } 518 519 static if (PNG_READ_SCALE_16_TO_8_SUPPORTED) { 520 void png_set_scale_16 (png_structrp png_ptr); 521 } 522 523 static if (PNG_READ_STRIP_16_TO_8_SUPPORTED) { 524 void png_set_strip_16 (png_structrp png_ptr); 525 } 526 527 static if (PNG_READ_QUANTIZE_SUPPORTED) { 528 void png_set_quantize (png_structrp png_ptr, 529 png_colorp palette, int num_palette, int maximum_colors, 530 png_const_uint_16p histogram, int full_quantize); 531 } 532 533 static if (PNG_READ_GAMMA_SUPPORTED) { 534 enum PNG_GAMMA_THRESHOLD = PNG_GAMMA_THRESHOLD_FIXED*.00001; 535 536 void png_set_gamma (png_structrp png_ptr, double screen_gamma, double override_file_gamma); 537 void png_set_gamma_fixed (png_structrp png_ptr, 538 png_fixed_point screen_gamma, png_fixed_point override_file_gamma); 539 } 540 541 static if (PNG_WRITE_FLUSH_SUPPORTED) { 542 void png_set_flush (png_structrp png_ptr, int nrows); 543 void png_write_flush (png_structrp png_ptr); 544 } 545 546 /* Optional update palette with requested transformations */ 547 void png_start_read_image (png_structrp png_ptr); 548 549 /* Optional call to update the users info structure */ 550 void png_read_update_info (png_structrp png_ptr, 551 png_inforp info_ptr); 552 553 static if (PNG_SEQUENTIAL_READ_SUPPORTED) { 554 /* Read one or more rows of image data. */ 555 void png_read_rows (png_structrp png_ptr, png_bytepp row, 556 png_bytepp display_row, png_uint_32 num_rows); 557 } 558 559 static if (PNG_SEQUENTIAL_READ_SUPPORTED) { 560 void png_read_row (png_structrp png_ptr, png_bytep row, png_bytep display_row); 561 } 562 563 static if (PNG_SEQUENTIAL_READ_SUPPORTED) { 564 void png_read_image (png_structrp png_ptr, png_bytepp image); 565 } 566 567 void png_write_row (png_structrp png_ptr, png_const_bytep row); 568 569 void png_write_rows (png_structrp png_ptr, png_bytepp row, png_uint_32 num_rows); 570 571 void png_write_image (png_structrp png_ptr, png_bytepp image); 572 573 void png_write_end (png_structrp png_ptr, png_inforp info_ptr); 574 575 static if (PNG_SEQUENTIAL_READ_SUPPORTED) { 576 void png_read_end (png_structrp png_ptr, png_inforp info_ptr); 577 } 578 579 void png_destroy_info_struct (png_const_structrp png_ptr, png_infopp info_ptr_ptr); 580 581 void png_destroy_read_struct (png_structpp png_ptr_ptr, 582 png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr); 583 584 void png_destroy_write_struct (png_structpp png_ptr_ptr, png_infopp info_ptr_ptr); 585 586 void png_set_crc_action (png_structrp png_ptr, int crit_action, int ancil_action); 587 588 enum PNG_CRC_DEFAULT = 0; 589 enum PNG_CRC_ERROR_QUIT = 1; 590 enum PNG_CRC_WARN_DISCARD = 2; 591 enum PNG_CRC_WARN_USE = 3; 592 enum PNG_CRC_QUIET_USE = 4; 593 enum PNG_CRC_NO_CHANGE = 5; 594 595 static if (PNG_WRITE_SUPPORTED) { 596 void png_set_filter (png_structrp png_ptr, int method, int filters); 597 } 598 599 enum PNG_NO_FILTERS = 0x00; 600 enum PNG_FILTER_NONE = 0x08; 601 enum PNG_FILTER_SUB = 0x10; 602 enum PNG_FILTER_UP = 0x20; 603 enum PNG_FILTER_AVG = 0x40; 604 enum PNG_FILTER_PAETH = 0x80; 605 enum PNG_FAST_FILTERS = (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP); 606 enum PNG_ALL_FILTERS = (PNG_FAST_FILTERS | PNG_FILTER_AVG | PNG_FILTER_PAETH); 607 608 enum PNG_FILTER_VALUE_NONE = 0; 609 enum PNG_FILTER_VALUE_SUB = 1; 610 enum PNG_FILTER_VALUE_UP = 2; 611 enum PNG_FILTER_VALUE_AVG = 3; 612 enum PNG_FILTER_VALUE_PAETH = 4; 613 enum PNG_FILTER_VALUE_LAST = 5; 614 615 static if (PNG_WRITE_SUPPORTED) { 616 static if (PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) { 617 void png_set_filter_heuristics (png_structrp png_ptr, 618 int heuristic_method, int num_weights, png_const_doublep filter_weights, 619 png_const_doublep filter_costs); 620 void png_set_filter_heuristics_fixed (png_structrp png_ptr, 621 int heuristic_method, int num_weights, 622 png_const_fixed_point_p filter_weights, 623 png_const_fixed_point_p filter_costs); 624 } 625 626 enum PNG_FILTER_HEURISTIC_DEFAULT = 0; 627 enum PNG_FILTER_HEURISTIC_UNWEIGHTED = 1; 628 enum PNG_FILTER_HEURISTIC_WEIGHTED = 2; 629 enum PNG_FILTER_HEURISTIC_LAST = 3; 630 631 static if (PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED) { 632 void png_set_compression_level (png_structrp png_ptr, int level); 633 634 void png_set_compression_mem_level (png_structrp png_ptr, int mem_level); 635 636 void png_set_compression_strategy (png_structrp png_ptr, int strategy); 637 638 void png_set_compression_window_bits (png_structrp png_ptr, int window_bits); 639 640 void png_set_compression_method (png_structrp png_ptr, int method); 641 } 642 643 static if (PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED) { 644 void png_set_text_compression_level (png_structrp png_ptr, int level); 645 646 void png_set_text_compression_mem_level (png_structrp png_ptr, int mem_level); 647 648 void png_set_text_compression_strategy (png_structrp png_ptr, int strategy); 649 650 void png_set_text_compression_window_bits (png_structrp png_ptr, int window_bits); 651 652 void png_set_text_compression_method (png_structrp png_ptr, int method); 653 } 654 } 655 656 static if (PNG_STDIO_SUPPORTED) { 657 void png_init_io (png_structrp png_ptr, png_FILE_p fp); 658 } 659 660 void png_set_error_fn (png_structrp png_ptr, png_voidp error_ptr, 661 png_error_ptr error_fn, png_error_ptr warning_fn); 662 663 png_voidp png_get_error_ptr (png_const_structrp png_ptr); 664 665 void png_set_write_fn (png_structrp png_ptr, png_voidp io_ptr, 666 png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn); 667 668 void png_set_read_fn (png_structrp png_ptr, png_voidp io_ptr, 669 png_rw_ptr read_data_fn); 670 671 png_voidp png_get_io_ptr (png_const_structrp png_ptr); 672 673 void png_set_read_status_fn (png_structrp png_ptr, png_read_status_ptr read_row_fn); 674 675 void png_set_write_status_fn (png_structrp png_ptr, png_write_status_ptr write_row_fn); 676 677 static if (PNG_USER_MEM_SUPPORTED) { 678 void png_set_mem_fn (png_structrp png_ptr, png_voidp mem_ptr, 679 png_malloc_ptr malloc_fn, png_free_ptr free_fn); 680 png_voidp png_get_mem_ptr (png_const_structrp png_ptr); 681 } 682 683 static if (PNG_READ_USER_TRANSFORM_SUPPORTED) { 684 void png_set_read_user_transform_fn (png_structrp png_ptr, 685 png_user_transform_ptr read_user_transform_fn); 686 } 687 688 static if (PNG_WRITE_USER_TRANSFORM_SUPPORTED) { 689 void png_set_write_user_transform_fn (png_structrp png_ptr, 690 png_user_transform_ptr write_user_transform_fn); 691 } 692 693 static if (PNG_USER_TRANSFORM_PTR_SUPPORTED) { 694 void png_set_user_transform_info (png_structrp png_ptr, 695 png_voidp user_transform_ptr, int user_transform_depth, 696 int user_transform_channels); 697 png_voidp png_get_user_transform_ptr (png_const_structrp png_ptr); 698 } 699 700 static if (PNG_USER_TRANSFORM_INFO_SUPPORTED) { 701 png_uint_32 png_get_current_row_number (png_const_structrp); 702 png_byte png_get_current_pass_number (png_const_structrp); 703 } 704 705 static if (PNG_READ_USER_CHUNKS_SUPPORTED) { 706 void png_set_read_user_chunk_fn (png_structrp png_ptr, 707 png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn); 708 } 709 710 static if (PNG_USER_CHUNKS_SUPPORTED) { 711 png_voidp png_get_user_chunk_ptr (png_const_structrp png_ptr); 712 } 713 714 static if (PNG_PROGRESSIVE_READ_SUPPORTED) { 715 void png_set_progressive_read_fn (png_structrp png_ptr, 716 png_voidp progressive_ptr, png_progressive_info_ptr info_fn, 717 png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn); 718 719 png_voidp png_get_progressive_ptr (png_const_structrp png_ptr); 720 721 void png_process_data (png_structrp png_ptr, 722 png_inforp info_ptr, png_bytep buffer, size_t buffer_size); 723 724 size_t png_process_data_pause (png_structrp, int save); 725 726 png_uint_32 png_process_data_skip (png_structrp); 727 728 void png_progressive_combine_row (png_const_structrp png_ptr, 729 png_bytep old_row, png_const_bytep new_row); 730 } 731 732 png_voidp png_malloc (png_const_structrp png_ptr, png_alloc_size_t size); 733 734 png_voidp png_calloc (png_const_structrp png_ptr, png_alloc_size_t size); 735 736 png_voidp png_malloc_warn (png_const_structrp png_ptr, png_alloc_size_t size); 737 738 void png_free (png_const_structrp png_ptr, png_voidp ptr); 739 740 void png_free_data (png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 free_me, int num); 741 742 void png_data_freer (png_const_structrp png_ptr, png_inforp info_ptr, int freer, png_uint_32 mask); 743 744 enum PNG_DESTROY_WILL_FREE_DATA = 1; 745 enum PNG_SET_WILL_FREE_DATA = 1; 746 enum PNG_USER_WILL_FREE_DATA = 2; 747 748 enum PNG_FREE_HIST = 0x0008U; 749 enum PNG_FREE_ICCP = 0x0010U; 750 enum PNG_FREE_SPLT = 0x0020U; 751 enum PNG_FREE_ROWS = 0x0040U; 752 enum PNG_FREE_PCAL = 0x0080U; 753 enum PNG_FREE_SCAL = 0x0100U; 754 static if (PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) { 755 enum PNG_FREE_UNKN = 0x0200U; 756 } 757 enum PNG_FREE_PLTE = 0x1000U; 758 enum PNG_FREE_TRNS = 0x2000U; 759 enum PNG_FREE_TEXT = 0x4000U; 760 enum PNG_FREE_EXIF = 0x8000U; 761 enum PNG_FREE_ALL = 0xffffU; 762 enum PNG_FREE_MUL = 0x4220U; 763 764 static if (PNG_ERROR_TEXT_SUPPORTED) { 765 void png_error (png_const_structrp png_ptr, png_const_charp error_message); 766 767 void png_chunk_error (png_const_structrp png_ptr, png_const_charp error_message); 768 } else { 769 void png_err (png_const_structrp png_ptr); 770 extern(D) void png_error(S1, S2)(S1 s1, S2 s2) { 771 png_err(s1); 772 } 773 extern(D) void png_chunk_error(S1, S2)(S1 s1, S2 s2) { 774 png_err(s1); 775 } 776 } 777 778 static if (PNG_WARNINGS_SUPPORTED) { 779 void png_warning (png_const_structrp png_ptr, 780 png_const_charp warning_message); 781 782 void png_chunk_warning (png_const_structrp png_ptr, 783 png_const_charp warning_message); 784 } else { 785 extern(D) void png_warning(S1, S2)(S1 s1, S2 s2) {} 786 extern(D) void png_chunk_warning(S1, S2)(S1 s1, S2 s2) {} 787 } 788 789 static if (PNG_BENIGN_ERRORS_SUPPORTED) { 790 void png_benign_error (png_const_structrp png_ptr, 791 png_const_charp warning_message); 792 793 static if (PNG_READ_SUPPORTED) { 794 void png_chunk_benign_error (png_const_structrp png_ptr, 795 png_const_charp warning_message); 796 } 797 798 void png_set_benign_errors (png_structrp png_ptr, int allowed); 799 } else { 800 static if (PNG_ALLOW_BENIGN_ERRORS) { 801 alias png_benign_error = png_warning; 802 alias png_chunk_benign_error = png_chunk_warning; 803 } else { 804 alias png_benign_error = png_error; 805 alias png_chunk_benign_error = png_chunk_error; 806 } 807 } 808 809 png_uint_32 png_get_valid (png_const_structrp png_ptr, png_const_inforp info_ptr, png_uint_32 flag); 810 811 size_t png_get_rowbytes (png_const_structrp png_ptr, png_const_inforp info_ptr); 812 813 static if (PNG_INFO_IMAGE_SUPPORTED) { 814 png_bytepp png_get_rows (png_const_structrp png_ptr, 815 png_const_inforp info_ptr); 816 void png_set_rows (png_const_structrp png_ptr, 817 png_inforp info_ptr, png_bytepp row_pointers); 818 } 819 820 png_byte png_get_channels (png_const_structrp png_ptr, png_const_inforp info_ptr); 821 822 static if (PNG_EASY_ACCESS_SUPPORTED) { 823 png_uint_32 png_get_image_width (png_const_structrp png_ptr, png_const_inforp info_ptr); 824 825 png_uint_32 png_get_image_height (png_const_structrp png_ptr, png_const_inforp info_ptr); 826 827 png_byte png_get_bit_depth (png_const_structrp png_ptr, png_const_inforp info_ptr); 828 829 png_byte png_get_color_type (png_const_structrp png_ptr, png_const_inforp info_ptr); 830 831 png_byte png_get_filter_type (png_const_structrp png_ptr, png_const_inforp info_ptr); 832 833 png_byte png_get_interlace_type (png_const_structrp png_ptr, png_const_inforp info_ptr); 834 835 png_byte png_get_compression_type (png_const_structrp png_ptr, png_const_inforp info_ptr); 836 837 png_uint_32 png_get_pixels_per_meter (png_const_structrp png_ptr, png_const_inforp info_ptr); 838 png_uint_32 png_get_x_pixels_per_meter (png_const_structrp png_ptr, png_const_inforp info_ptr); 839 png_uint_32 png_get_y_pixels_per_meter (png_const_structrp png_ptr, png_const_inforp info_ptr); 840 841 float png_get_pixel_aspect_ratio (png_const_structrp png_ptr, png_const_inforp info_ptr); 842 png_fixed_point png_get_pixel_aspect_ratio_fixed (png_const_structrp png_ptr, 843 png_const_inforp info_ptr); 844 845 png_int_32 png_get_x_offset_pixels (png_const_structrp png_ptr, png_const_inforp info_ptr); 846 png_int_32 png_get_y_offset_pixels (png_const_structrp png_ptr, png_const_inforp info_ptr); 847 png_int_32 png_get_x_offset_microns (png_const_structrp png_ptr, png_const_inforp info_ptr); 848 png_int_32 png_get_y_offset_microns (png_const_structrp png_ptr, png_const_inforp info_ptr); 849 } 850 851 static if (PNG_READ_SUPPORTED) { 852 png_const_bytep png_get_signature (png_const_structrp png_ptr, 853 png_const_inforp info_ptr); 854 } 855 856 static if (PNG_bKGD_SUPPORTED) { 857 png_uint_32 png_get_bKGD (png_const_structrp png_ptr, png_inforp info_ptr, 858 png_color_16p *background); 859 } 860 861 static if (PNG_bKGD_SUPPORTED) { 862 void png_set_bKGD (png_const_structrp png_ptr, png_inforp info_ptr, 863 png_const_color_16p background); 864 } 865 866 static if (PNG_cHRM_SUPPORTED) { 867 png_uint_32 png_get_cHRM (png_const_structrp png_ptr, 868 png_const_inforp info_ptr, double *white_x, double *white_y, double *red_x, 869 double *red_y, double *green_x, double *green_y, double *blue_x, 870 double *blue_y); 871 png_uint_32 png_get_cHRM_XYZ (png_const_structrp png_ptr, 872 png_const_inforp info_ptr, double *red_X, double *red_Y, double *red_Z, 873 double *green_X, double *green_Y, double *green_Z, double *blue_X, 874 double *blue_Y, double *blue_Z); 875 png_uint_32 png_get_cHRM_fixed (png_const_structrp png_ptr, 876 png_const_inforp info_ptr, 877 png_fixed_point *int_white_x, png_fixed_point *int_white_y, 878 png_fixed_point *int_red_x, png_fixed_point *int_red_y, 879 png_fixed_point *int_green_x, png_fixed_point *int_green_y, 880 png_fixed_point *int_blue_x, png_fixed_point *int_blue_y); 881 png_uint_32 png_get_cHRM_XYZ_fixed (png_const_structrp png_ptr, 882 png_const_inforp info_ptr, 883 png_fixed_point *int_red_X, png_fixed_point *int_red_Y, 884 png_fixed_point *int_red_Z, png_fixed_point *int_green_X, 885 png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, 886 png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, 887 png_fixed_point *int_blue_Z); 888 } 889 890 static if (PNG_cHRM_SUPPORTED) { 891 void png_set_cHRM (png_const_structrp png_ptr, 892 png_inforp info_ptr, 893 double white_x, double white_y, double red_x, double red_y, double green_x, 894 double green_y, double blue_x, double blue_y); 895 void png_set_cHRM_XYZ (png_const_structrp png_ptr, 896 png_inforp info_ptr, double red_X, double red_Y, double red_Z, 897 double green_X, double green_Y, double green_Z, double blue_X, 898 double blue_Y, double blue_Z); 899 void png_set_cHRM_fixed (png_const_structrp png_ptr, 900 png_inforp info_ptr, png_fixed_point int_white_x, 901 png_fixed_point int_white_y, png_fixed_point int_red_x, 902 png_fixed_point int_red_y, png_fixed_point int_green_x, 903 png_fixed_point int_green_y, png_fixed_point int_blue_x, 904 png_fixed_point int_blue_y); 905 void png_set_cHRM_XYZ_fixed (png_const_structrp png_ptr, 906 png_inforp info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y, 907 png_fixed_point int_red_Z, png_fixed_point int_green_X, 908 png_fixed_point int_green_Y, png_fixed_point int_green_Z, 909 png_fixed_point int_blue_X, png_fixed_point int_blue_Y, 910 png_fixed_point int_blue_Z); 911 } 912 913 static if (PNG_eXIf_SUPPORTED) { 914 png_uint_32 png_get_eXIf (png_const_structrp png_ptr, png_inforp info_ptr, 915 png_bytep *exif); 916 void png_set_eXIf (png_const_structrp png_ptr, png_inforp info_ptr, 917 const png_bytep exif); 918 919 png_uint_32 png_get_eXIf_1 (png_const_structrp png_ptr, 920 png_const_inforp info_ptr, png_uint_32 *num_exif, png_bytep *exif); 921 void png_set_eXIf_1 (png_const_structrp png_ptr, png_inforp info_ptr, 922 const png_uint_32 num_exif, const png_bytep exif); 923 } 924 925 static if (PNG_gAMA_SUPPORTED) { 926 png_uint_32 png_get_gAMA (png_const_structrp png_ptr, 927 png_const_inforp info_ptr, double *file_gamma); 928 png_uint_32 png_get_gAMA_fixed (png_const_structrp png_ptr, 929 png_const_inforp info_ptr, png_fixed_point *int_file_gamma); 930 } 931 932 static if (PNG_gAMA_SUPPORTED) { 933 void png_set_gAMA (png_const_structrp png_ptr, png_inforp info_ptr, 934 double file_gamma); 935 void png_set_gAMA_fixed (png_const_structrp png_ptr, png_inforp info_ptr, 936 png_fixed_point int_file_gamma); 937 } 938 939 static if (PNG_hIST_SUPPORTED) { 940 png_uint_32 png_get_hIST (png_const_structrp png_ptr, 941 png_inforp info_ptr, png_uint_16p *hist); 942 void png_set_hIST (png_const_structrp png_ptr, 943 png_inforp info_ptr, png_const_uint_16p hist); 944 } 945 946 png_uint_32 png_get_IHDR (png_const_structrp png_ptr, 947 png_const_inforp info_ptr, png_uint_32 *width, png_uint_32 *height, 948 int *bit_depth, int *color_type, int *interlace_method, 949 int *compression_method, int *filter_method); 950 951 void png_set_IHDR (png_const_structrp png_ptr, 952 png_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, 953 int color_type, int interlace_method, int compression_method, 954 int filter_method); 955 956 static if (PNG_oFFs_SUPPORTED) { 957 png_uint_32 png_get_oFFs (png_const_structrp png_ptr, 958 png_const_inforp info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, 959 int *unit_type); 960 } 961 962 static if (PNG_oFFs_SUPPORTED) { 963 void png_set_oFFs (png_const_structrp png_ptr, 964 png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y, 965 int unit_type); 966 } 967 968 static if (PNG_pCAL_SUPPORTED) { 969 png_uint_32 png_get_pCAL (png_const_structrp png_ptr, 970 png_inforp info_ptr, png_charp *purpose, png_int_32 *X0, 971 png_int_32 *X1, int *type, int *nparams, png_charp *units, 972 png_charpp *params); 973 } 974 975 static if (PNG_pCAL_SUPPORTED) { 976 void png_set_pCAL (png_const_structrp png_ptr, 977 png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1, 978 int type, int nparams, png_const_charp units, png_charpp params); 979 } 980 981 static if (PNG_pHYs_SUPPORTED) { 982 png_uint_32 png_get_pHYs (png_const_structrp png_ptr, 983 png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, 984 int *unit_type); 985 } 986 987 static if (PNG_pHYs_SUPPORTED) { 988 void png_set_pHYs (png_const_structrp png_ptr, 989 png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type); 990 } 991 992 png_uint_32 png_get_PLTE (png_const_structrp png_ptr, 993 png_inforp info_ptr, png_colorp *palette, int *num_palette); 994 995 void png_set_PLTE (png_structrp png_ptr, 996 png_inforp info_ptr, png_const_colorp palette, int num_palette); 997 998 static if (PNG_sBIT_SUPPORTED) { 999 png_uint_32 png_get_sBIT (png_const_structrp png_ptr, 1000 png_inforp info_ptr, png_color_8p *sig_bit); 1001 } 1002 1003 static if (PNG_sBIT_SUPPORTED) { 1004 void png_set_sBIT (png_const_structrp png_ptr, 1005 png_inforp info_ptr, png_const_color_8p sig_bit); 1006 } 1007 1008 static if (PNG_sRGB_SUPPORTED) { 1009 png_uint_32 png_get_sRGB (png_const_structrp png_ptr, 1010 png_const_inforp info_ptr, int *file_srgb_intent); 1011 } 1012 1013 static if (PNG_sRGB_SUPPORTED) { 1014 void png_set_sRGB (png_const_structrp png_ptr, 1015 png_inforp info_ptr, int srgb_intent); 1016 void png_set_sRGB_gAMA_and_cHRM (png_const_structrp png_ptr, 1017 png_inforp info_ptr, int srgb_intent); 1018 } 1019 1020 static if (PNG_iCCP_SUPPORTED) { 1021 png_uint_32 png_get_iCCP (png_const_structrp png_ptr, 1022 png_inforp info_ptr, png_charpp name, int *compression_type, 1023 png_bytepp profile, png_uint_32 *proflen); 1024 } 1025 1026 static if (PNG_iCCP_SUPPORTED) { 1027 void png_set_iCCP (png_const_structrp png_ptr, 1028 png_inforp info_ptr, png_const_charp name, int compression_type, 1029 png_const_bytep profile, png_uint_32 proflen); 1030 } 1031 1032 static if (PNG_sPLT_SUPPORTED) { 1033 int png_get_sPLT (png_const_structrp png_ptr, 1034 png_inforp info_ptr, png_sPLT_tpp entries); 1035 } 1036 1037 static if (PNG_sPLT_SUPPORTED) { 1038 void png_set_sPLT (png_const_structrp png_ptr, 1039 png_inforp info_ptr, png_const_sPLT_tp entries, int nentries); 1040 } 1041 1042 static if (PNG_TEXT_SUPPORTED) { 1043 /* png_get_text also returns the number of text chunks in *num_text */ 1044 int png_get_text (png_const_structrp png_ptr, 1045 png_inforp info_ptr, png_textp *text_ptr, int *num_text); 1046 } 1047 1048 /* Note while png_set_text() will accept a structure whose text, 1049 * language, and translated keywords are NULL pointers, the structure 1050 * returned by png_get_text will always contain regular 1051 * zero-terminated C strings. They might be empty strings but 1052 * they will never be NULL pointers. 1053 */ 1054 1055 static if (PNG_TEXT_SUPPORTED) { 1056 void png_set_text (png_const_structrp png_ptr, 1057 png_inforp info_ptr, png_const_textp text_ptr, int num_text); 1058 } 1059 1060 static if (PNG_tIME_SUPPORTED) { 1061 png_uint_32 png_get_tIME (png_const_structrp png_ptr, 1062 png_inforp info_ptr, png_timep *mod_time); 1063 } 1064 1065 static if (PNG_tIME_SUPPORTED) { 1066 void png_set_tIME (png_const_structrp png_ptr, 1067 png_inforp info_ptr, png_const_timep mod_time); 1068 } 1069 1070 static if (PNG_tRNS_SUPPORTED) { 1071 png_uint_32 png_get_tRNS (png_const_structrp png_ptr, 1072 png_inforp info_ptr, png_bytep *trans_alpha, int *num_trans, 1073 png_color_16p *trans_color); 1074 } 1075 1076 static if (PNG_tRNS_SUPPORTED) { 1077 void png_set_tRNS (png_structrp png_ptr, 1078 png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans, 1079 png_const_color_16p trans_color); 1080 } 1081 1082 static if (PNG_sCAL_SUPPORTED) { 1083 1084 png_uint_32 png_get_sCAL (png_const_structrp png_ptr, 1085 png_const_inforp info_ptr, int *unit, double *width, double *height); 1086 1087 static if (PNG_FLOATING_ARITHMETIC_SUPPORTED || PNG_FLOATING_POINT_SUPPORTED) { 1088 png_uint_32 png_get_sCAL_fixed (png_const_structrp png_ptr, 1089 png_const_inforp info_ptr, int *unit, png_fixed_point *width, 1090 png_fixed_point *height); 1091 } 1092 1093 png_uint_32 png_get_sCAL_s (png_const_structrp png_ptr, 1094 png_const_inforp info_ptr, int *unit, png_charpp swidth, png_charpp sheight); 1095 1096 void png_set_sCAL (png_const_structrp png_ptr, 1097 png_inforp info_ptr, int unit, double width, double height); 1098 void png_set_sCAL_fixed (png_const_structrp png_ptr, 1099 png_inforp info_ptr, int unit, png_fixed_point width, 1100 png_fixed_point height); 1101 void png_set_sCAL_s (png_const_structrp png_ptr, 1102 png_inforp info_ptr, int unit, 1103 png_const_charp swidth, png_const_charp sheight); 1104 } 1105 1106 static if (PNG_SET_UNKNOWN_CHUNKS_SUPPORTED) { 1107 static if (PNG_HANDLE_AS_UNKNOWN_SUPPORTED) { 1108 void png_set_keep_unknown_chunks (png_structrp png_ptr, int keep, 1109 png_const_bytep chunk_list, int num_chunks); 1110 } 1111 1112 int png_handle_as_unknown (png_const_structrp png_ptr, 1113 png_const_bytep chunk_name); 1114 } 1115 1116 static if (PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) { 1117 void png_set_unknown_chunks (png_const_structrp png_ptr, 1118 png_inforp info_ptr, png_const_unknown_chunkp unknowns, 1119 int num_unknowns); 1120 1121 void png_set_unknown_chunk_location (png_const_structrp png_ptr, 1122 png_inforp info_ptr, int chunk, int location); 1123 1124 int png_get_unknown_chunks (png_const_structrp png_ptr, 1125 png_inforp info_ptr, png_unknown_chunkpp entries); 1126 } 1127 1128 void png_set_invalid (png_const_structrp png_ptr, png_inforp info_ptr, int mask); 1129 1130 static if (PNG_INFO_IMAGE_SUPPORTED) { 1131 static if (PNG_SEQUENTIAL_READ_SUPPORTED) { 1132 void png_read_png (png_structrp png_ptr, png_inforp info_ptr, 1133 int transforms, png_voidp params); 1134 } 1135 static if (PNG_WRITE_SUPPORTED) { 1136 void png_write_png (png_structrp png_ptr, png_inforp info_ptr, 1137 int transforms, png_voidp params); 1138 } 1139 } 1140 1141 png_const_charp png_get_copyright (png_const_structrp png_ptr); 1142 png_const_charp png_get_header_ver (png_const_structrp png_ptr); 1143 png_const_charp png_get_header_version (png_const_structrp png_ptr); 1144 png_const_charp png_get_libpng_ver (png_const_structrp png_ptr); 1145 1146 static if (PNG_MNG_FEATURES_SUPPORTED) { 1147 png_uint_32 png_permit_mng_features (png_structrp png_ptr, 1148 png_uint_32 mng_features_permitted); 1149 } 1150 1151 enum PNG_HANDLE_CHUNK_AS_DEFAULT = 0; 1152 enum PNG_HANDLE_CHUNK_NEVER = 1; 1153 enum PNG_HANDLE_CHUNK_IF_SAFE = 2; 1154 enum PNG_HANDLE_CHUNK_ALWAYS = 3; 1155 enum PNG_HANDLE_CHUNK_LAST = 4; 1156 1157 static if (PNG_ERROR_NUMBERS_SUPPORTED) { 1158 void png_set_strip_error_numbers (png_structrp png_ptr, png_uint_32 strip_mode); 1159 } 1160 1161 static if (PNG_SET_USER_LIMITS_SUPPORTED) { 1162 void png_set_user_limits (png_structrp png_ptr, png_uint_32 user_width_max, 1163 png_uint_32 user_height_max); 1164 png_uint_32 png_get_user_width_max (png_const_structrp png_ptr); 1165 png_uint_32 png_get_user_height_max (png_const_structrp png_ptr); 1166 void png_set_chunk_cache_max (png_structrp png_ptr, 1167 png_uint_32 user_chunk_cache_max); 1168 png_uint_32 png_get_chunk_cache_max (png_const_structrp png_ptr); 1169 void png_set_chunk_malloc_max (png_structrp png_ptr, 1170 png_alloc_size_t user_chunk_cache_max); 1171 png_alloc_size_t png_get_chunk_malloc_max (png_const_structrp png_ptr); 1172 } 1173 1174 static if (PNG_INCH_CONVERSIONS_SUPPORTED) { 1175 png_uint_32 png_get_pixels_per_inch (png_const_structrp png_ptr, 1176 png_const_inforp info_ptr); 1177 1178 png_uint_32 png_get_x_pixels_per_inch (png_const_structrp png_ptr, 1179 png_const_inforp info_ptr); 1180 1181 png_uint_32 png_get_y_pixels_per_inch (png_const_structrp png_ptr, 1182 png_const_inforp info_ptr); 1183 1184 float png_get_x_offset_inches (png_const_structrp png_ptr, 1185 png_const_inforp info_ptr); 1186 1187 static if (PNG_FIXED_POINT_SUPPORTED) { 1188 png_fixed_point png_get_x_offset_inches_fixed (png_const_structrp png_ptr, 1189 png_const_inforp info_ptr); 1190 } 1191 1192 float png_get_y_offset_inches (png_const_structrp png_ptr, png_const_inforp info_ptr); 1193 1194 static if (PNG_FIXED_POINT_SUPPORTED) { 1195 png_fixed_point png_get_y_offset_inches_fixed (png_const_structrp png_ptr, 1196 png_const_inforp info_ptr); 1197 } 1198 1199 static if (PNG_pHYs_SUPPORTED) { 1200 png_uint_32 png_get_pHYs_dpi (png_const_structrp png_ptr, 1201 png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, 1202 int *unit_type); 1203 } 1204 } 1205 1206 static if (PNG_IO_STATE_SUPPORTED) { 1207 png_uint_32 png_get_io_state (png_const_structrp png_ptr); 1208 1209 png_uint_32 png_get_io_chunk_type (png_const_structrp png_ptr); 1210 1211 enum PNG_IO_NONE = 0x0000; /* no I/O at this moment */ 1212 enum PNG_IO_READING = 0x0001; /* currently reading */ 1213 enum PNG_IO_WRITING = 0x0002; /* currently writing */ 1214 enum PNG_IO_SIGNATURE = 0x0010; /* currently at the file signature */ 1215 enum PNG_IO_CHUNK_HDR = 0x0020; /* currently at the chunk header */ 1216 enum PNG_IO_CHUNK_DATA = 0x0040; /* currently at the chunk data */ 1217 enum PNG_IO_CHUNK_CRC = 0x0080; /* currently at the chunk crc */ 1218 enum PNG_IO_MASK_OP = 0x000f; /* current operation: reading/writing */ 1219 enum PNG_IO_MASK_LOC = 0x00f0; /* current location: sig/hdr/data/crc */ 1220 } 1221 1222 enum PNG_INTERLACE_ADAM7_PASSES = 7; 1223 1224 1225 extern(D) { 1226 1227 auto PNG_PASS_START_ROW(P)(in P pass) 1228 { 1229 return (((1&~(pass))<<(3-((pass)>>1)))&7); 1230 } 1231 1232 auto PNG_PASS_START_COL(P)(in P pass) 1233 { 1234 return (((1& (pass))<<(3-(((pass)+1)>>1)))&7); 1235 } 1236 1237 auto PNG_PASS_ROW_OFFSET(P)(in P pass) 1238 { 1239 return ((pass)>2?(8>>(((pass)-1)>>1)):8); 1240 } 1241 1242 auto PNG_PASS_COL_OFFSET(P)(in P pass) 1243 { 1244 return (1<<((7-(pass))>>1)); 1245 } 1246 1247 auto PNG_PASS_ROW_SHIFT(P)(in P pass) 1248 { 1249 return ((pass)>2?(8-(pass))>>1:3); 1250 } 1251 1252 auto PNG_PASS_COL_SHIFT(P)(in P pass) 1253 { 1254 return ((pass)>1?(7-(pass))>>1:3); 1255 } 1256 1257 auto PNG_PASS_ROWS(H, P)(in H height, in P pass) 1258 { 1259 return (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))-1)- 1260 PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass)); 1261 } 1262 1263 auto PNG_PASS_COLS(W, P)(in W width, in P pass) 1264 { 1265 return (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))-1) 1266 -PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass)); 1267 } 1268 1269 auto PNG_FROM_PASS_ROWS(Y, P)(in Y y_in, in P pass) 1270 { 1271 return (((y_in)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass)); 1272 } 1273 1274 auto PNG_FROM_PASS_COLS(X, P)(in X x_in, in P pass) 1275 { 1276 return (((x_in)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass)); 1277 } 1278 1279 auto PNG_PASS_MASK(P, O)(in P pass, in O off) 1280 { 1281 return ((0x110145AF>>(((7-(off))-(pass))<<2)) & 0xF) | 1282 ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0); 1283 } 1284 1285 auto PNG_ROW_IN_INTERLACE_PASS(Y, P)(in Y y, in P pass) 1286 { 1287 return ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1); 1288 } 1289 1290 auto PNG_COL_IN_INTERLACE_PASS(Y, P)(in X x, in P pass) 1291 { 1292 return ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1); 1293 } 1294 1295 static if (PNG_READ_COMPOSITE_NODIV_SUPPORTED) { 1296 1297 png_byte png_composite(in png_uint_16 fg, in png_uint_16 alpha, in png_uint_16 bg) 1298 { 1299 const temp = fg * alpha + bg * (255 - alpha) + 128; 1300 return ((temp + (temp >> 8)) >> 8) & 0xff; 1301 } 1302 1303 png_uint_16 png_composite(in png_uint_32 fg, in png_uint_32 alpha, in png_uint_32 bg) 1304 { 1305 const temp = fg * alpha + bg * (65535 - alpha) + 32768; 1306 return ((temp + (temp >> 16)) >> 16) & 0xffff; 1307 } 1308 1309 } else { 1310 1311 png_byte png_composite(in png_uint_16 fg, in png_uint_16 alpha, in png_uint_16 bg) 1312 { 1313 return 0xff & ((fg * alpha + bg * (255 - alpha) + 127) / 255); 1314 } 1315 1316 png_uint_16 png_composite_16(in png_uint_32 fg, in png_uint_32 alpha, in png_uint_32 bg) 1317 { 1318 return 0xffff & ((fg * alpha + bg * (65535 - alpha) + 32767) / 65535); 1319 } 1320 } 1321 } 1322 1323 static if (PNG_READ_INT_FUNCTIONS_SUPPORTED) { 1324 png_uint_32 png_get_uint_32 (png_const_bytep buf); 1325 png_uint_16 png_get_uint_16 (png_const_bytep buf); 1326 png_int_32 png_get_int_32 (png_const_bytep buf); 1327 } 1328 else { 1329 extern(D) 1330 png_uint_32 png_get_uint_32(png_const_bytep buf) 1331 { 1332 return (buf[0] << 24) + (buf[1] << 16) + (buf[2] << 8) + buf[3]; 1333 } 1334 1335 extern(D) 1336 png_uint_16 png_get_uint_16(png_const_bytep buf) 1337 { 1338 return (buf[0] << 8) + buf[1]; 1339 } 1340 1341 extern(D) 1342 png_int_32 png_get_int_32(png_const_bytep buf) 1343 { 1344 return (buf[0] & 0x80) ? 1345 -((( png_get_uint_32(buf) ^ 0xfffffffU) + 1) & 0x7fff_ffffU ) : 1346 png_get_uint_32(buf); 1347 } 1348 } 1349 1350 png_uint_32 png_get_uint_31 (png_const_structrp png_ptr, png_const_bytep buf); 1351 1352 static if (PNG_WRITE_INT_FUNCTIONS_SUPPORTED) { 1353 void png_save_uint_32 (png_bytep buf, png_uint_32 i); 1354 } 1355 static if (PNG_SAVE_INT_32_SUPPORTED) { 1356 void png_save_int_32 (png_bytep buf, png_int_32 i); 1357 } 1358 1359 static if (PNG_WRITE_INT_FUNCTIONS_SUPPORTED) { 1360 void png_save_uint_16 (png_bytep buf, uint i); 1361 } 1362 1363 1364 static if (PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED) { 1365 1366 void png_set_check_for_invalid_index (png_structrp png_ptr, int allowed); 1367 1368 static if (PNG_GET_PALETTE_MAX_SUPPORTED) { 1369 int png_get_palette_max (png_const_structp png_ptr, png_const_infop info_ptr); 1370 } 1371 } 1372 1373 static if (PNG_SIMPLIFIED_READ_SUPPORTED || PNG_SIMPLIFIED_WRITE_SUPPORTED) { 1374 1375 enum PNG_IMAGE_VERSION = 1; 1376 1377 struct png_control; 1378 alias png_controlp = png_control*; 1379 1380 struct png_image 1381 { 1382 png_controlp opaque; /* Initialize to NULL, free with png_image_free */ 1383 png_uint_32 version_; /* Set to PNG_IMAGE_VERSION */ 1384 png_uint_32 width; /* Image width in pixels (columns) */ 1385 png_uint_32 height; /* Image height in pixels (rows) */ 1386 png_uint_32 format; /* Image format as defined below */ 1387 png_uint_32 flags; /* A bit mask containing informational flags */ 1388 png_uint_32 colormap_entries; 1389 /* Number of entries in the color-map */ 1390 1391 png_uint_32 warning_or_error; 1392 1393 char[64] message; 1394 } 1395 1396 alias png_imagep = png_image*; 1397 1398 enum PNG_IMAGE_WARNING = 1; 1399 enum PNG_IMAGE_ERROR = 2; 1400 1401 1402 extern(D) bool PNG_IMAGE_FAILED(const png_imagep img) { 1403 return (img.warning_or_error & 0x03) > 1; 1404 } 1405 1406 enum PNG_FORMAT_FLAG_ALPHA = 0x01U; 1407 enum PNG_FORMAT_FLAG_COLOR = 0x02U; 1408 enum PNG_FORMAT_FLAG_LINEAR = 0x04U; 1409 enum PNG_FORMAT_FLAG_COLORMAP = 0x08U; 1410 1411 static if (PNG_FORMAT_BGR_SUPPORTED) { 1412 enum PNG_FORMAT_FLAG_BGR = 0x10U; 1413 } 1414 1415 static if (PNG_FORMAT_AFIRST_SUPPORTED) { 1416 enum PNG_FORMAT_FLAG_AFIRST = 0x20U; 1417 } 1418 1419 enum PNG_FORMAT_FLAG_ASSOCIATED_ALPHA = 0x40U; 1420 1421 enum PNG_FORMAT_GRAY = 0; 1422 enum PNG_FORMAT_GA = PNG_FORMAT_FLAG_ALPHA; 1423 enum PNG_FORMAT_AG = (PNG_FORMAT_GA|PNG_FORMAT_FLAG_AFIRST); 1424 enum PNG_FORMAT_RGB = PNG_FORMAT_FLAG_COLOR; 1425 enum PNG_FORMAT_BGR = (PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_BGR); 1426 enum PNG_FORMAT_RGBA = (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_ALPHA); 1427 enum PNG_FORMAT_ARGB = (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_AFIRST); 1428 enum PNG_FORMAT_BGRA = (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_ALPHA); 1429 enum PNG_FORMAT_ABGR = (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_AFIRST); 1430 1431 enum PNG_FORMAT_LINEAR_Y = PNG_FORMAT_FLAG_LINEAR; 1432 enum PNG_FORMAT_LINEAR_Y_ALPHA = (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_ALPHA); 1433 enum PNG_FORMAT_LINEAR_RGB = PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR; 1434 enum PNG_FORMAT_LINEAR_RGB_ALPHA = PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA; 1435 1436 enum PNG_FORMAT_RGB_COLORMAP = (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_COLORMAP); 1437 enum PNG_FORMAT_BGR_COLORMAP = (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_COLORMAP); 1438 enum PNG_FORMAT_RGBA_COLORMAP = (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_COLORMAP); 1439 enum PNG_FORMAT_ARGB_COLORMAP = (PNG_FORMAT_ARGB|PNG_FORMAT_FLAG_COLORMAP); 1440 enum PNG_FORMAT_BGRA_COLORMAP = (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_COLORMAP); 1441 enum PNG_FORMAT_ABGR_COLORMAP = (PNG_FORMAT_ABGR|PNG_FORMAT_FLAG_COLORMAP); 1442 1443 extern(D) 1444 auto PNG_IMAGE_SAMPLE_CHANNELS(in png_uint_32 fmt) 1445 { 1446 return (((fmt)&(PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA))+1); 1447 } 1448 1449 extern(D) 1450 auto PNG_IMAGE_SAMPLE_COMPONENT_SIZE(in png_uint_32 fmt) 1451 { 1452 return ((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1); 1453 } 1454 1455 extern(D) 1456 auto PNG_IMAGE_SAMPLE_SIZE(in png_uint_32 fmt) 1457 { 1458 return (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)); 1459 } 1460 1461 extern(D) 1462 auto PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(in png_uint_32 fmt) 1463 { 1464 return PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256; 1465 } 1466 1467 extern(D) private 1468 auto PNG_IMAGE_PIXEL_(alias test)(in png_uint_32 fmt) 1469 { 1470 return (((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt)); 1471 } 1472 1473 extern(D) 1474 auto PNG_IMAGE_PIXEL_CHANNELS(in png_uint_32 fmt) 1475 { 1476 return PNG_IMAGE_PIXEL_!(PNG_IMAGE_SAMPLE_CHANNELS)(fmt); 1477 } 1478 1479 extern(D) 1480 auto PNG_IMAGE_PIXEL_COMPONENT_SIZE(in png_uint_32 fmt) 1481 { 1482 return PNG_IMAGE_PIXEL_!(PNG_IMAGE_SAMPLE_COMPONENT_SIZE)(fmt); 1483 } 1484 1485 extern(D) 1486 auto PNG_IMAGE_PIXEL_SIZE(in png_uint_32 fmt) 1487 { 1488 return PNG_IMAGE_PIXEL_!(PNG_IMAGE_SAMPLE_SIZE)(fmt); 1489 } 1490 1491 extern(D) 1492 auto PNG_IMAGE_ROW_STRIDE(in png_imagep image) 1493 { 1494 return PNG_IMAGE_PIXEL_CHANNELS(image.format) * image.width; 1495 } 1496 1497 extern(D) 1498 auto PNG_IMAGE_BUFFER_SIZE(in png_imagep image, in png_uint_32 row_stride) 1499 { 1500 return PNG_IMAGE_PIXEL_COMPONENT_SIZE(image.format) * image.height*(row_stride); 1501 } 1502 1503 extern(D) 1504 auto PNG_IMAGE_SIZE(in png_imagep image) 1505 { 1506 return PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image)); 1507 } 1508 1509 extern(D) 1510 auto PNG_IMAGE_COLORMAP_SIZE(in png_imagep image) 1511 { 1512 return PNG_IMAGE_SAMPLE_SIZE(image.format) * image.colormap_entries; 1513 } 1514 1515 enum PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB = 0x01; 1516 enum PNG_IMAGE_FLAG_FAST = 0x02; 1517 enum PNG_IMAGE_FLAG_16BIT_sRGB = 0x04; 1518 1519 static if (PNG_SIMPLIFIED_READ_SUPPORTED) { 1520 1521 static if (PNG_STDIO_SUPPORTED) { 1522 int png_image_begin_read_from_file (png_imagep image, const char *file_name); 1523 1524 int png_image_begin_read_from_stdio (png_imagep image, FILE* file); 1525 } 1526 1527 int png_image_begin_read_from_memory (png_imagep image, 1528 png_const_voidp memory, size_t size); 1529 1530 int png_image_finish_read (png_imagep image, png_const_colorp background, 1531 void *buffer, png_int_32 row_stride, void *colormap); 1532 1533 void png_image_free (png_imagep image); 1534 1535 } 1536 1537 static if (PNG_SIMPLIFIED_WRITE_SUPPORTED) { 1538 1539 static if (PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED) { 1540 int png_image_write_to_file (png_imagep image, const char *file, 1541 int convert_to_8bit, const void *buffer, png_int_32 row_stride, 1542 const void *colormap); 1543 1544 int png_image_write_to_stdio (png_imagep image, FILE *file, 1545 int convert_to_8_bit, const void *buffer, png_int_32 row_stride, 1546 const void *colormap); 1547 } 1548 1549 int png_image_write_to_memory (png_imagep image, void *memory, 1550 png_alloc_size_t * memory_bytes, int convert_to_8_bit, const void *buffer, 1551 png_int_32 row_stride, const void *colormap); 1552 1553 extern(D) 1554 int png_image_write_get_memory_size(png_imagep image, png_alloc_size_t size, 1555 int convert_to_8_bit, const void* buffer, png_int_32 row_stride, 1556 const void* colormap) 1557 { 1558 return png_image_write_to_memory(image, null, &size, convert_to_8_bit, buffer, row_stride, colormap); 1559 } 1560 1561 extern(D) 1562 auto PNG_IMAGE_DATA_SIZE(png_imagep image) 1563 { 1564 return PNG_IMAGE_SIZE(image) + image.height; 1565 } 1566 1567 extern(D) 1568 auto PNG_ZLIB_MAX_SIZE(B)(in B b) 1569 { 1570 return ((b)+(((b)+7U)>>3)+(((b)+63U)>>6)+11U); 1571 } 1572 1573 extern(D) 1574 auto PNG_IMAGE_COMPRESSED_SIZE_MAX(png_imagep image) 1575 { 1576 return PNG_ZLIB_MAX_SIZE(PNG_IMAGE_DATA_SIZE(image)); 1577 } 1578 1579 extern(D) 1580 auto PNG_IMAGE_PNG_SIZE_MAX_(IS)(png_imagep image, IS image_size) 1581 { 1582 return ((8U/*sig*/+25U/*IHDR*/+16U/*gAMA*/+44U/*cHRM*/+12U/*IEND*/+ 1583 ((image.format&PNG_FORMAT_FLAG_COLORMAP)?/*colormap: PLTE, tRNS*/ 1584 12U+3U*image.colormap_entries/*PLTE data*/+ 1585 ((image.format&PNG_FORMAT_FLAG_ALPHA)? 1586 12U/*tRNS*/+image.colormap_entries:0U):0U)+ 1587 12U)+(12U*(image_size/PNG_ZBUF_SIZE))/*IDAT*/+image_size); 1588 } 1589 1590 extern(D) 1591 auto PNG_IMAGE_PNG_SIZE_MAX(png_imagep image) 1592 { 1593 return PNG_IMAGE_PNG_SIZE_MAX_(image, PNG_IMAGE_COMPRESSED_SIZE_MAX(image)); 1594 } 1595 } 1596 1597 } 1598 1599 static if (PNG_SET_OPTION_SUPPORTED) { 1600 static if (PNG_ARM_NEON_API_SUPPORTED) { 1601 enum PNG_ARM_NEON = 0; 1602 } 1603 enum PNG_MAXIMUM_INFLATE_WINDOW = 2; 1604 enum PNG_SKIP_sRGB_CHECK_PROFILE = 4; 1605 // static if (PNG_MIPS_MSA_API_SUPPORTED) { 1606 // enum PNG_MIPS_MSA = 6; 1607 // } 1608 enum PNG_IGNORE_ADLER32 = 8; 1609 static if (PNG_POWERPC_VSX_API_SUPPORTED) { 1610 enum PNG_POWERPC_VSX = 10; 1611 } 1612 enum PNG_OPTION_NEXT = 12; 1613 1614 enum PNG_OPTION_UNSET = 0; 1615 enum PNG_OPTION_INVALID = 1; 1616 enum PNG_OPTION_OFF = 2; 1617 enum PNG_OPTION_ON = 3; 1618 1619 int png_set_option (png_structrp png_ptr, int option, int onoff); 1620 }