libpng.png source code

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 }