lodepng.h source code [LOVE/libraries/lodepng/lodepng.h]

1	/*
2	LodePNG version 20210627
3
4	Copyright (c) 2005-2021 Lode Vandevenne
5
6	This software is provided 'as-is', without any express or implied
7	warranty. In no event will the authors be held liable for any damages
8	arising from the use of this software.
9
10	Permission is granted to anyone to use this software for any purpose,
11	including commercial applications, and to alter it and redistribute it
12	freely, subject to the following restrictions:
13
14	1. The origin of this software must not be misrepresented; you must not
15	claim that you wrote the original software. If you use this software
16	in a product, an acknowledgment in the product documentation would be
17	appreciated but is not required.
18
19	2. Altered source versions must be plainly marked as such, and must not be
20	misrepresented as being the original software.
21
22	3. This notice may not be removed or altered from any source
23	distribution.
24	*/
25
26	#ifndef LODEPNG_H
27	#define LODEPNG_H
28
29	#include <string.h> /for size_t/
30
31	extern const char* LODEPNG_VERSION_STRING;
32
33	/*
34	The following #defines are used to create code sections. They can be disabled
35	to disable code sections, which can give faster compile time and smaller binary.
36	The "NO_COMPILE" defines are designed to be used to pass as defines to the
37	compiler command to disable them without modifying this header, e.g.
38	-DLODEPNG_NO_COMPILE_ZLIB for gcc.
39	In addition to those below, you can also define LODEPNG_NO_COMPILE_CRC to
40	allow implementing a custom lodepng_crc32.
41	*/
42	/deflate & zlib. If disabled, you must specify alternative zlib functions in*
43	the custom_zlib field of the compress and decompress settings/*
44	#ifndef LODEPNG_NO_COMPILE_ZLIB
45	#define LODEPNG_COMPILE_ZLIB
46	#endif
47
48	/png encoder and png decoder/
49	#ifndef LODEPNG_NO_COMPILE_PNG
50	#define LODEPNG_COMPILE_PNG
51	#endif
52
53	/deflate&zlib decoder and png decoder/
54	#ifndef LODEPNG_NO_COMPILE_DECODER
55	#define LODEPNG_COMPILE_DECODER
56	#endif
57
58	/deflate&zlib encoder and png encoder/
59	#ifndef LODEPNG_NO_COMPILE_ENCODER
60	#define LODEPNG_COMPILE_ENCODER
61	#endif
62
63	/the optional built in harddisk file loading and saving functions/
64	#ifndef LODEPNG_NO_COMPILE_DISK
65	#define LODEPNG_COMPILE_DISK
66	#endif
67
68	/support for chunks other than IHDR, IDAT, PLTE, tRNS, IEND: ancillary and unknown chunks/
69	#ifndef LODEPNG_NO_COMPILE_ANCILLARY_CHUNKS
70	#define LODEPNG_COMPILE_ANCILLARY_CHUNKS
71	#endif
72
73	/ability to convert error numerical codes to English text string/
74	#ifndef LODEPNG_NO_COMPILE_ERROR_TEXT
75	#define LODEPNG_COMPILE_ERROR_TEXT
76	#endif
77
78	/Compile the default allocators (C's free, malloc and realloc). If you disable this,*
79	you can define the functions lodepng_free, lodepng_malloc and lodepng_realloc in your
80	source files with custom allocators./*
81	#ifndef LODEPNG_NO_COMPILE_ALLOCATORS
82	#define LODEPNG_COMPILE_ALLOCATORS
83	#endif
84
85	/compile the C++ version (you can disable the C++ wrapper here even when compiling for C++)/
86	#ifdef __cplusplus
87	#ifndef LODEPNG_NO_COMPILE_CPP
88	#define LODEPNG_COMPILE_CPP
89	#endif
90	#endif
91
92	#ifdef LODEPNG_COMPILE_CPP
93	#include <vector>
94	#include <string>
95	#endif /LODEPNG_COMPILE_CPP/
96
97	#ifdef LODEPNG_COMPILE_PNG
98	/The PNG color types (also used for raw image)./
99	typedef enum LodePNGColorType {
100	LCT_GREY = `0`, /grayscale: 1,2,4,8,16 bit/
101	LCT_RGB = `2`, /RGB: 8,16 bit/
102	LCT_PALETTE = `3`, /palette: 1,2,4,8 bit/
103	LCT_GREY_ALPHA = `4`, /grayscale with alpha: 8,16 bit/
104	LCT_RGBA = `6`, /RGB with alpha: 8,16 bit/
105	/LCT_MAX_OCTET_VALUE lets the compiler allow this enum to represent any invalid*
106	byte value from 0 to 255 that could be present in an invalid PNG file header. Do
107	not use, compare with or set the name LCT_MAX_OCTET_VALUE, instead either use
108	the valid color type names above, or numeric values like 1 or 7 when checking for
109	particular disallowed color type byte values, or cast to integer to print it./*
110	LCT_MAX_OCTET_VALUE = `255`
111	} LodePNGColorType;
112
113	#ifdef LODEPNG_COMPILE_DECODER
114	/*
115	Converts PNG data in memory to raw pixel data.
116	out: Output parameter. Pointer to buffer that will contain the raw pixel data.
117	After decoding, its size is w h * (bytes per pixel) bytes larger than*
118	initially. Bytes per pixel depends on colortype and bitdepth.
119	Must be freed after usage with free(out).*
120	Note: for 16-bit per channel colors, uses big endian format like PNG does.
121	w: Output parameter. Pointer to width of pixel data.
122	h: Output parameter. Pointer to height of pixel data.
123	in: Memory buffer with the PNG file.
124	insize: size of the in buffer.
125	colortype: the desired color type for the raw output image. See explanation on PNG color types.
126	bitdepth: the desired bit depth for the raw output image. See explanation on PNG color types.
127	Return value: LodePNG error code (0 means no error).
128	*/
129	unsigned lodepng_decode_memory(unsigned char** out, unsigned* w, unsigned* h,
130	const unsigned char* in, size_t insize,
131	LodePNGColorType colortype, unsigned bitdepth);
132
133	/Same as lodepng_decode_memory, but always decodes to 32-bit RGBA raw image/
134	unsigned lodepng_decode32(unsigned char** out, unsigned* w, unsigned* h,
135	const unsigned char* in, size_t insize);
136
137	/Same as lodepng_decode_memory, but always decodes to 24-bit RGB raw image/
138	unsigned lodepng_decode24(unsigned char** out, unsigned* w, unsigned* h,
139	const unsigned char* in, size_t insize);
140
141	#ifdef LODEPNG_COMPILE_DISK
142	/*
143	Load PNG from disk, from file with given name.
144	Same as the other decode functions, but instead takes a filename as input.
145
146	NOTE: Wide-character filenames are not supported, you can use an external method
147	to handle such files and decode in-memory./*
148	unsigned lodepng_decode_file(unsigned char** out, unsigned* w, unsigned* h,
149	const char* filename,
150	LodePNGColorType colortype, unsigned bitdepth);
151
152	/Same as lodepng_decode_file, but always decodes to 32-bit RGBA raw image.*
153
154	NOTE: Wide-character filenames are not supported, you can use an external method
155	to handle such files and decode in-memory./*
156	unsigned lodepng_decode32_file(unsigned char** out, unsigned* w, unsigned* h,
157	const char* filename);
158
159	/Same as lodepng_decode_file, but always decodes to 24-bit RGB raw image.*
160
161	NOTE: Wide-character filenames are not supported, you can use an external method
162	to handle such files and decode in-memory./*
163	unsigned lodepng_decode24_file(unsigned char** out, unsigned* w, unsigned* h,
164	const char* filename);
165	#endif /LODEPNG_COMPILE_DISK/
166	#endif /LODEPNG_COMPILE_DECODER/
167
168
169	#ifdef LODEPNG_COMPILE_ENCODER
170	/*
171	Converts raw pixel data into a PNG image in memory. The colortype and bitdepth
172	of the output PNG image cannot be chosen, they are automatically determined
173	by the colortype, bitdepth and content of the input pixel data.
174	Note: for 16-bit per channel colors, needs big endian format like PNG does.
175	out: Output parameter. Pointer to buffer that will contain the PNG image data.
176	Must be freed after usage with free(out).*
177	outsize: Output parameter. Pointer to the size in bytes of the out buffer.
178	image: The raw pixel data to encode. The size of this buffer should be
179	w h * (bytes per pixel), bytes per pixel depends on colortype and bitdepth.*
180	w: width of the raw pixel data in pixels.
181	h: height of the raw pixel data in pixels.
182	colortype: the color type of the raw input image. See explanation on PNG color types.
183	bitdepth: the bit depth of the raw input image. See explanation on PNG color types.
184	Return value: LodePNG error code (0 means no error).
185	*/
186	unsigned lodepng_encode_memory(unsigned char** out, size_t* outsize,
187	const unsigned char* image, unsigned w, unsigned h,
188	LodePNGColorType colortype, unsigned bitdepth);
189
190	/Same as lodepng_encode_memory, but always encodes from 32-bit RGBA raw image./
191	unsigned lodepng_encode32(unsigned char** out, size_t* outsize,
192	const unsigned char* image, unsigned w, unsigned h);
193
194	/Same as lodepng_encode_memory, but always encodes from 24-bit RGB raw image./
195	unsigned lodepng_encode24(unsigned char** out, size_t* outsize,
196	const unsigned char* image, unsigned w, unsigned h);
197
198	#ifdef LODEPNG_COMPILE_DISK
199	/*
200	Converts raw pixel data into a PNG file on disk.
201	Same as the other encode functions, but instead takes a filename as output.
202
203	NOTE: This overwrites existing files without warning!
204
205	NOTE: Wide-character filenames are not supported, you can use an external method
206	to handle such files and encode in-memory./*
207	unsigned lodepng_encode_file(const char* filename,
208	const unsigned char* image, unsigned w, unsigned h,
209	LodePNGColorType colortype, unsigned bitdepth);
210
211	/Same as lodepng_encode_file, but always encodes from 32-bit RGBA raw image.*
212
213	NOTE: Wide-character filenames are not supported, you can use an external method
214	to handle such files and encode in-memory./*
215	unsigned lodepng_encode32_file(const char* filename,
216	const unsigned char* image, unsigned w, unsigned h);
217
218	/Same as lodepng_encode_file, but always encodes from 24-bit RGB raw image.*
219
220	NOTE: Wide-character filenames are not supported, you can use an external method
221	to handle such files and encode in-memory./*
222	unsigned lodepng_encode24_file(const char* filename,
223	const unsigned char* image, unsigned w, unsigned h);
224	#endif /LODEPNG_COMPILE_DISK/
225	#endif /LODEPNG_COMPILE_ENCODER/
226
227
228	#ifdef LODEPNG_COMPILE_CPP
229	namespace lodepng {
230	#ifdef LODEPNG_COMPILE_DECODER
231	/Same as lodepng_decode_memory, but decodes to an std::vector. The colortype*
232	is the format to output the pixels to. Default is RGBA 8-bit per channel./*
233	unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
234	const unsigned char* in, size_t insize,
235	LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = `8`);
236	unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
237	const std::vector<unsigned char>& in,
238	LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = `8`);
239	#ifdef LODEPNG_COMPILE_DISK
240	/*
241	Converts PNG file from disk to raw pixel data in memory.
242	Same as the other decode functions, but instead takes a filename as input.
243
244	NOTE: Wide-character filenames are not supported, you can use an external method
245	to handle such files and decode in-memory.
246	*/
247	unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
248	const std::string& filename,
249	LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = `8`);
250	#endif /* LODEPNG_COMPILE_DISK */
251	#endif /* LODEPNG_COMPILE_DECODER */
252
253	#ifdef LODEPNG_COMPILE_ENCODER
254	/Same as lodepng_encode_memory, but encodes to an std::vector. colortype*
255	is that of the raw input data. The output PNG color type will be auto chosen./*
256	unsigned encode(std::vector<unsigned char>& out,
257	const unsigned char* in, unsigned w, unsigned h,
258	LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = `8`);
259	unsigned encode(std::vector<unsigned char>& out,
260	const std::vector<unsigned char>& in, unsigned w, unsigned h,
261	LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = `8`);
262	#ifdef LODEPNG_COMPILE_DISK
263	/*
264	Converts 32-bit RGBA raw pixel data into a PNG file on disk.
265	Same as the other encode functions, but instead takes a filename as output.
266
267	NOTE: This overwrites existing files without warning!
268
269	NOTE: Wide-character filenames are not supported, you can use an external method
270	to handle such files and decode in-memory.
271	*/
272	unsigned encode(const std::string& filename,
273	const unsigned char* in, unsigned w, unsigned h,
274	LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = `8`);
275	unsigned encode(const std::string& filename,
276	const std::vector<unsigned char>& in, unsigned w, unsigned h,
277	LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = `8`);
278	#endif /* LODEPNG_COMPILE_DISK */
279	#endif /* LODEPNG_COMPILE_ENCODER */
280	} / namespace lodepng /
281	#endif /LODEPNG_COMPILE_CPP/
282	#endif /LODEPNG_COMPILE_PNG/
283
284	#ifdef LODEPNG_COMPILE_ERROR_TEXT
285	/Returns an English description of the numerical error code./
286	const char* lodepng_error_text(unsigned code);
287	#endif /LODEPNG_COMPILE_ERROR_TEXT/
288
289	#ifdef LODEPNG_COMPILE_DECODER
290	/Settings for zlib decompression/
291	typedef struct LodePNGDecompressSettings LodePNGDecompressSettings;
292	struct LodePNGDecompressSettings {
293	/ Check LodePNGDecoderSettings for more ignorable errors such as ignore_crc /
294	unsigned ignore_adler32; /if 1, continue and don't give an error message if the Adler32 checksum is corrupted/
295	unsigned ignore_nlen; /ignore complement of len checksum in uncompressed blocks/
296
297	/Maximum decompressed size, beyond this the decoder may (and is encouraged to) stop decoding,*
298	return an error, output a data size > max_output_size and all the data up to that point. This is
299	not hard limit nor a guarantee, but can prevent excessive memory usage. This setting is
300	ignored by the PNG decoder, but is used by the deflate/zlib decoder and can be used by custom ones.
301	Set to 0 to impose no limit (the default)./*
302	size_t max_output_size;
303
304	/use custom zlib decoder instead of built in one (default: null).*
305	Should return 0 if success, any non-0 if error (numeric value not exposed)./*
306	unsigned (custom_zlib)(unsigned* char*, size_t,
307	const unsigned char*, size_t,
308	const LodePNGDecompressSettings*);
309	/use custom deflate decoder instead of built in one (default: null)*
310	if custom_zlib is not null, custom_inflate is ignored (the zlib format uses deflate).
311	Should return 0 if success, any non-0 if error (numeric value not exposed)./*
312	unsigned (custom_inflate)(unsigned* char*, size_t,
313	const unsigned char*, size_t,
314	const LodePNGDecompressSettings*);
315
316	const void* custom_context; /optional custom settings for custom functions/
317	};
318
319	extern const LodePNGDecompressSettings lodepng_default_decompress_settings;
320	void lodepng_decompress_settings_init(LodePNGDecompressSettings* settings);
321	#endif /LODEPNG_COMPILE_DECODER/
322
323	#ifdef LODEPNG_COMPILE_ENCODER
324	/*
325	Settings for zlib compression. Tweaking these settings tweaks the balance
326	between speed and compression ratio.
327	*/
328	typedef struct LodePNGCompressSettings LodePNGCompressSettings;
329	struct LodePNGCompressSettings /deflate = compress/ {
330	/LZ77 related settings/
331	unsigned btype; /the block type for LZ (0, 1, 2 or 3, see zlib standard). Should be 2 for proper compression./
332	unsigned use_lz77; /whether or not to use LZ77. Should be 1 for proper compression./
333	unsigned windowsize; /must be a power of two <= 32768. higher compresses more but is slower. Default value: 2048./
334	unsigned minmatch; /minimum lz77 length. 3 is normally best, 6 can be better for some PNGs. Default: 0/
335	unsigned nicematch; /stop searching if >= this length found. Set to 258 for best compression. Default: 128/
336	unsigned lazymatching; /use lazy matching: better compression but a bit slower. Default: true/
337
338	/use custom zlib encoder instead of built in one (default: null)/
339	unsigned (custom_zlib)(unsigned* char*, size_t,
340	const unsigned char*, size_t,
341	const LodePNGCompressSettings*);
342	/use custom deflate encoder instead of built in one (default: null)*
343	if custom_zlib is used, custom_deflate is ignored since only the built in
344	zlib function will call custom_deflate/*
345	unsigned (custom_deflate)(unsigned* char*, size_t,
346	const unsigned char*, size_t,
347	const LodePNGCompressSettings*);
348
349	const void* custom_context; /optional custom settings for custom functions/
350	};
351
352	extern const LodePNGCompressSettings lodepng_default_compress_settings;
353	void lodepng_compress_settings_init(LodePNGCompressSettings* settings);
354	#endif /LODEPNG_COMPILE_ENCODER/
355
356	#ifdef LODEPNG_COMPILE_PNG
357	/*
358	Color mode of an image. Contains all information required to decode the pixel
359	bits to RGBA colors. This information is the same as used in the PNG file
360	format, and is used both for PNG and raw image data in LodePNG.
361	*/
362	typedef struct LodePNGColorMode {
363	/header (IHDR)/
364	LodePNGColorType colortype; /color type, see PNG standard or documentation further in this header file/
365	unsigned bitdepth; /bits per sample, see PNG standard or documentation further in this header file/
366
367	/*
368	palette (PLTE and tRNS)
369
370	Dynamically allocated with the colors of the palette, including alpha.
371	This field may not be allocated directly, use lodepng_color_mode_init first,
372	then lodepng_palette_add per color to correctly initialize it (to ensure size
373	of exactly 1024 bytes).
374
375	The alpha channels must be set as well, set them to 255 for opaque images.
376
377	When decoding, by default you can ignore this palette, since LodePNG already
378	fills the palette colors in the pixels of the raw RGBA output.
379
380	The palette is only supported for color type 3.
381	*/
382	unsigned char* palette; /palette in RGBARGBA... order. Must be either 0, or when allocated must have 1024 bytes/
383	size_t palettesize; /palette size in number of colors (amount of used bytes is 4 * palettesize)/
384
385	/*
386	transparent color key (tRNS)
387
388	This color uses the same bit depth as the bitdepth value in this struct, which can be 1-bit to 16-bit.
389	For grayscale PNGs, r, g and b will all 3 be set to the same.
390
391	When decoding, by default you can ignore this information, since LodePNG sets
392	pixels with this key to transparent already in the raw RGBA output.
393
394	The color key is only supported for color types 0 and 2.
395	*/
396	unsigned key_defined; /is a transparent color key given? 0 = false, 1 = true/
397	unsigned key_r; /red/grayscale component of color key/
398	unsigned key_g; /green component of color key/
399	unsigned key_b; /blue component of color key/
400	} LodePNGColorMode;
401
402	/init, cleanup and copy functions to use with this struct/
403	void lodepng_color_mode_init(LodePNGColorMode* info);
404	void lodepng_color_mode_cleanup(LodePNGColorMode* info);
405	/return value is error code (0 means no error)/
406	unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source);
407	/ Makes a temporary LodePNGColorMode that does not need cleanup (no palette) /
408	LodePNGColorMode lodepng_color_mode_make(LodePNGColorType colortype, unsigned bitdepth);
409
410	void lodepng_palette_clear(LodePNGColorMode* info);
411	/add 1 color to the palette/
412	unsigned lodepng_palette_add(LodePNGColorMode* info,
413	unsigned char r, unsigned char g, unsigned char b, unsigned char a);
414
415	/get the total amount of bits per pixel, based on colortype and bitdepth in the struct/
416	unsigned lodepng_get_bpp(const LodePNGColorMode* info);
417	/get the amount of color channels used, based on colortype in the struct.*
418	If a palette is used, it counts as 1 channel./*
419	unsigned lodepng_get_channels(const LodePNGColorMode* info);
420	/is it a grayscale type? (only colortype 0 or 4)/
421	unsigned lodepng_is_greyscale_type(const LodePNGColorMode* info);
422	/has it got an alpha channel? (only colortype 2 or 6)/
423	unsigned lodepng_is_alpha_type(const LodePNGColorMode* info);
424	/has it got a palette? (only colortype 3)/
425	unsigned lodepng_is_palette_type(const LodePNGColorMode* info);
426	/only returns true if there is a palette and there is a value in the palette with alpha < 255.*
427	Loops through the palette to check this./*
428	unsigned lodepng_has_palette_alpha(const LodePNGColorMode* info);
429	/*
430	Check if the given color info indicates the possibility of having non-opaque pixels in the PNG image.
431	Returns true if the image can have translucent or invisible pixels (it still be opaque if it doesn't use such pixels).
432	Returns false if the image can only have opaque pixels.
433	In detail, it returns true only if it's a color type with alpha, or has a palette with non-opaque values,
434	or if "key_defined" is true.
435	*/
436	unsigned lodepng_can_have_alpha(const LodePNGColorMode* info);
437	/Returns the byte size of a raw image buffer with given width, height and color mode/
438	size_t lodepng_get_raw_size(unsigned w, unsigned h, const LodePNGColorMode* color);
439
440	#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
441	/The information of a Time chunk in PNG./
442	typedef struct LodePNGTime {
443	unsigned year; /2 bytes used (0-65535)/
444	unsigned month; /1-12/
445	unsigned day; /1-31/
446	unsigned hour; /0-23/
447	unsigned minute; /0-59/
448	unsigned second; /0-60 (to allow for leap seconds)/
449	} LodePNGTime;
450	#endif /LODEPNG_COMPILE_ANCILLARY_CHUNKS/
451
452	/Information about the PNG image, except pixels, width and height./
453	typedef struct LodePNGInfo {
454	/header (IHDR), palette (PLTE) and transparency (tRNS) chunks/
455	unsigned compression_method;/compression method of the original file. Always 0./
456	unsigned filter_method; /filter method of the original file/
457	unsigned interlace_method; /interlace method of the original file: 0=none, 1=Adam7/
458	LodePNGColorMode color; /color type and bits, palette and transparency of the PNG file/
459
460	#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
461	/*
462	Suggested background color chunk (bKGD)
463
464	This uses the same color mode and bit depth as the PNG (except no alpha channel),
465	with values truncated to the bit depth in the unsigned integer.
466
467	For grayscale and palette PNGs, the value is stored in background_r. The values
468	in background_g and background_b are then unused.
469
470	So when decoding, you may get these in a different color mode than the one you requested
471	for the raw pixels.
472
473	When encoding with auto_convert, you must use the color model defined in info_png.color for
474	these values. The encoder normally ignores info_png.color when auto_convert is on, but will
475	use it to interpret these values (and convert copies of them to its chosen color model).
476
477	When encoding, avoid setting this to an expensive color, such as a non-gray value
478	when the image is gray, or the compression will be worse since it will be forced to
479	write the PNG with a more expensive color mode (when auto_convert is on).
480
481	The decoder does not use this background color to edit the color of pixels. This is a
482	completely optional metadata feature.
483	*/
484	unsigned background_defined; /is a suggested background color given?/
485	unsigned background_r; /red/gray/palette component of suggested background color/
486	unsigned background_g; /green component of suggested background color/
487	unsigned background_b; /blue component of suggested background color/
488
489	/*
490	Non-international text chunks (tEXt and zTXt)
491
492	The char* arrays each contain num strings. The actual messages are in*
493	text_strings, while text_keys are keywords that give a short description what
494	the actual text represents, e.g. Title, Author, Description, or anything else.
495
496	All the string fields below including strings, keys, names and language tags are null terminated.
497	The PNG specification uses null characters for the keys, names and tags, and forbids null
498	characters to appear in the main text which is why we can use null termination everywhere here.
499
500	A keyword is minimum 1 character and maximum 79 characters long (plus the
501	additional null terminator). It's discouraged to use a single line length
502	longer than 79 characters for texts.
503
504	Don't allocate these text buffers yourself. Use the init/cleanup functions
505	correctly and use lodepng_add_text and lodepng_clear_text.
506
507	Standard text chunk keywords and strings are encoded using Latin-1.
508	*/
509	size_t text_num; /the amount of texts in these char** buffers (there may be more texts in itext)/
510	char** text_keys; /the keyword of a text chunk (e.g. "Comment")/
511	char** text_strings; /the actual text/
512
513	/*
514	International text chunks (iTXt)
515	Similar to the non-international text chunks, but with additional strings
516	"langtags" and "transkeys", and the following text encodings are used:
517	keys: Latin-1, langtags: ASCII, transkeys and strings: UTF-8.
518	keys must be 1-79 characters (plus the additional null terminator), the other
519	strings are any length.
520	*/
521	size_t itext_num; /the amount of international texts in this PNG/
522	char** itext_keys; /the English keyword of the text chunk (e.g. "Comment")/
523	char** itext_langtags; /language tag for this text's language, ISO/IEC 646 string, e.g. ISO 639 language tag/
524	char** itext_transkeys; /keyword translated to the international language - UTF-8 string/
525	char** itext_strings; /the actual international text - UTF-8 string/
526
527	/time chunk (tIME)/
528	unsigned time_defined; /set to 1 to make the encoder generate a tIME chunk/
529	LodePNGTime time;
530
531	/phys chunk (pHYs)/
532	unsigned phys_defined; /if 0, there is no pHYs chunk and the values below are undefined, if 1 else there is one/
533	unsigned phys_x; /pixels per unit in x direction/
534	unsigned phys_y; /pixels per unit in y direction/
535	unsigned phys_unit; /may be 0 (unknown unit) or 1 (metre)/
536
537	/*
538	Color profile related chunks: gAMA, cHRM, sRGB, iCPP
539
540	LodePNG does not apply any color conversions on pixels in the encoder or decoder and does not interpret these color
541	profile values. It merely passes on the information. If you wish to use color profiles and convert colors, please
542	use these values with a color management library.
543
544	See the PNG, ICC and sRGB specifications for more information about the meaning of these values.
545	*/
546
547	/ gAMA chunk: optional, overridden by sRGB or iCCP if those are present. /
548	unsigned gama_defined; / Whether a gAMA chunk is present (0 = not present, 1 = present). /
549	unsigned gama_gamma; / Gamma exponent times 100000 /
550
551	/ cHRM chunk: optional, overridden by sRGB or iCCP if those are present. /
552	unsigned chrm_defined; / Whether a cHRM chunk is present (0 = not present, 1 = present). /
553	unsigned chrm_white_x; / White Point x times 100000 /
554	unsigned chrm_white_y; / White Point y times 100000 /
555	unsigned chrm_red_x; / Red x times 100000 /
556	unsigned chrm_red_y; / Red y times 100000 /
557	unsigned chrm_green_x; / Green x times 100000 /
558	unsigned chrm_green_y; / Green y times 100000 /
559	unsigned chrm_blue_x; / Blue x times 100000 /
560	unsigned chrm_blue_y; / Blue y times 100000 /
561
562	/*
563	sRGB chunk: optional. May not appear at the same time as iCCP.
564	If gAMA is also present gAMA must contain value 45455.
565	If cHRM is also present cHRM must contain respectively 31270,32900,64000,33000,30000,60000,15000,6000.
566	*/
567	unsigned srgb_defined; / Whether an sRGB chunk is present (0 = not present, 1 = present). /
568	unsigned srgb_intent; / Rendering intent: 0=perceptual, 1=rel. colorimetric, 2=saturation, 3=abs. colorimetric /
569
570	/*
571	iCCP chunk: optional. May not appear at the same time as sRGB.
572
573	LodePNG does not parse or use the ICC profile (except its color space header field for an edge case), a
574	separate library to handle the ICC data (not included in LodePNG) format is needed to use it for color
575	management and conversions.
576
577	For encoding, if iCCP is present, gAMA and cHRM are recommended to be added as well with values that match the ICC
578	profile as closely as possible, if you wish to do this you should provide the correct values for gAMA and cHRM and
579	enable their '_defined' flags since LodePNG will not automatically compute them from the ICC profile.
580
581	For encoding, the ICC profile is required by the PNG specification to be an "RGB" profile for non-gray
582	PNG color types and a "GRAY" profile for gray PNG color types. If you disable auto_convert, you must ensure
583	the ICC profile type matches your requested color type, else the encoder gives an error. If auto_convert is
584	enabled (the default), and the ICC profile is not a good match for the pixel data, this will result in an encoder
585	error if the pixel data has non-gray pixels for a GRAY profile, or a silent less-optimal compression of the pixel
586	data if the pixels could be encoded as grayscale but the ICC profile is RGB.
587
588	To avoid this do not set an ICC profile in the image unless there is a good reason for it, and when doing so
589	make sure you compute it carefully to avoid the above problems.
590	*/
591	unsigned iccp_defined; / Whether an iCCP chunk is present (0 = not present, 1 = present). /
592	char* iccp_name; / Null terminated string with profile name, 1-79 bytes /
593	/*
594	The ICC profile in iccp_profile_size bytes.
595	Don't allocate this buffer yourself. Use the init/cleanup functions
596	correctly and use lodepng_set_icc and lodepng_clear_icc.
597	*/
598	unsigned char* iccp_profile;
599	unsigned iccp_profile_size; / The size of iccp_profile in bytes /
600
601	/ End of color profile related chunks /
602
603
604	/*
605	unknown chunks: chunks not known by LodePNG, passed on byte for byte.
606
607	There are 3 buffers, one for each position in the PNG where unknown chunks can appear.
608	Each buffer contains all unknown chunks for that position consecutively.
609	The 3 positions are:
610	0: between IHDR and PLTE, 1: between PLTE and IDAT, 2: between IDAT and IEND.
611
612	For encoding, do not store critical chunks or known chunks that are enabled with a "_defined" flag
613	above in here, since the encoder will blindly follow this and could then encode an invalid PNG file
614	(such as one with two IHDR chunks or the disallowed combination of sRGB with iCCP). But do use
615	this if you wish to store an ancillary chunk that is not supported by LodePNG (such as sPLT or hIST),
616	or any non-standard PNG chunk.
617
618	Do not allocate or traverse this data yourself. Use the chunk traversing functions declared
619	later, such as lodepng_chunk_next and lodepng_chunk_append, to read/write this struct.
620	*/
621	unsigned char* unknown_chunks_data[`3`];
622	size_t unknown_chunks_size[`3`]; /size in bytes of the unknown chunks, given for protection/
623	#endif /LODEPNG_COMPILE_ANCILLARY_CHUNKS/
624	} LodePNGInfo;
625
626	/init, cleanup and copy functions to use with this struct/
627	void lodepng_info_init(LodePNGInfo* info);
628	void lodepng_info_cleanup(LodePNGInfo* info);
629	/return value is error code (0 means no error)/
630	unsigned lodepng_info_copy(LodePNGInfo* dest, const LodePNGInfo* source);
631
632	#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
633	unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str); /push back both texts at once/
634	void lodepng_clear_text(LodePNGInfo* info); /use this to clear the texts again after you filled them in/
635
636	unsigned lodepng_add_itext(LodePNGInfo* info, const char* key, const char* langtag,
637	const char* transkey, const char* str); /push back the 4 texts of 1 chunk at once/
638	void lodepng_clear_itext(LodePNGInfo* info); /use this to clear the itexts again after you filled them in/
639
640	/replaces if exists/
641	unsigned lodepng_set_icc(LodePNGInfo* info, const char* name, const unsigned char* profile, unsigned profile_size);
642	void lodepng_clear_icc(LodePNGInfo* info); /use this to clear the texts again after you filled them in/
643	#endif /LODEPNG_COMPILE_ANCILLARY_CHUNKS/
644
645	/*
646	Converts raw buffer from one color type to another color type, based on
647	LodePNGColorMode structs to describe the input and output color type.
648	See the reference manual at the end of this header file to see which color conversions are supported.
649	return value = LodePNG error code (0 if all went ok, an error if the conversion isn't supported)
650	The out buffer must have size (w h * bpp + 7) / 8, where bpp is the bits per pixel*
651	of the output color type (lodepng_get_bpp).
652	For < 8 bpp images, there should not be padding bits at the end of scanlines.
653	For 16-bit per channel colors, uses big endian format like PNG does.
654	Return value is LodePNG error code
655	*/
656	unsigned lodepng_convert(unsigned char* out, const unsigned char* in,
657	const LodePNGColorMode* mode_out, const LodePNGColorMode* mode_in,
658	unsigned w, unsigned h);
659
660	#ifdef LODEPNG_COMPILE_DECODER
661	/*
662	Settings for the decoder. This contains settings for the PNG and the Zlib
663	decoder, but not the Info settings from the Info structs.
664	*/
665	typedef struct LodePNGDecoderSettings {
666	LodePNGDecompressSettings zlibsettings; /in here is the setting to ignore Adler32 checksums/
667
668	/ Check LodePNGDecompressSettings for more ignorable errors such as ignore_adler32 /
669	unsigned ignore_crc; /ignore CRC checksums/
670	unsigned ignore_critical; /ignore unknown critical chunks/
671	unsigned ignore_end; /ignore issues at end of file if possible (missing IEND chunk, too large chunk, ...)/
672	/ TODO: make a system involving warnings with levels and a strict mode instead. Other potentially recoverable*
673	errors: srgb rendering intent value, size of content of ancillary chunks, more than 79 characters for some
674	strings, placement/combination rules for ancillary chunks, crc of unknown chunks, allowed characters
675	in string keys, etc... /*
676
677	unsigned color_convert; /whether to convert the PNG to the color type you want. Default: yes/
678
679	#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
680	unsigned read_text_chunks; /if false but remember_unknown_chunks is true, they're stored in the unknown chunks/
681
682	/store all bytes from unknown chunks in the LodePNGInfo (off by default, useful for a png editor)/
683	unsigned remember_unknown_chunks;
684
685	/ maximum size for decompressed text chunks. If a text chunk's text is larger than this, an error is returned,*
686	unless reading text chunks is disabled or this limit is set higher or disabled. Set to 0 to allow any size.
687	By default it is a value that prevents unreasonably large strings from hogging memory. /*
688	size_t max_text_size;
689
690	/ maximum size for compressed ICC chunks. If the ICC profile is larger than this, an error will be returned. Set to*
691	0 to allow any size. By default this is a value that prevents ICC profiles that would be much larger than any
692	legitimate profile could be to hog memory. /*
693	size_t max_icc_size;
694	#endif /LODEPNG_COMPILE_ANCILLARY_CHUNKS/
695	} LodePNGDecoderSettings;
696
697	void lodepng_decoder_settings_init(LodePNGDecoderSettings* settings);
698	#endif /LODEPNG_COMPILE_DECODER/
699
700	#ifdef LODEPNG_COMPILE_ENCODER
701	/automatically use color type with less bits per pixel if losslessly possible. Default: AUTO/
702	typedef enum LodePNGFilterStrategy {
703	/every filter at zero/
704	LFS_ZERO = `0`,
705	/every filter at 1, 2, 3 or 4 (paeth), unlike LFS_ZERO not a good choice, but for testing/
706	LFS_ONE = `1`,
707	LFS_TWO = `2`,
708	LFS_THREE = `3`,
709	LFS_FOUR = `4`,
710	/Use filter that gives minimum sum, as described in the official PNG filter heuristic./
711	LFS_MINSUM,
712	/Use the filter type that gives smallest Shannon entropy for this scanline. Depending*
713	on the image, this is better or worse than minsum./*
714	LFS_ENTROPY,
715	/*
716	Brute-force-search PNG filters by compressing each filter for each scanline.
717	Experimental, very slow, and only rarely gives better compression than MINSUM.
718	*/
719	LFS_BRUTE_FORCE,
720	/use predefined_filters buffer: you specify the filter type for each scanline/
721	LFS_PREDEFINED
722	} LodePNGFilterStrategy;
723
724	/Gives characteristics about the integer RGBA colors of the image (count, alpha channel usage, bit depth, ...),*
725	which helps decide which color model to use for encoding.
726	Used internally by default if "auto_convert" is enabled. Public because it's useful for custom algorithms./*
727	typedef struct LodePNGColorStats {
728	unsigned colored; /not grayscale/
729	unsigned key; /image is not opaque and color key is possible instead of full alpha/
730	unsigned short key_r; /key values, always as 16-bit, in 8-bit case the byte is duplicated, e.g. 65535 means 255/
731	unsigned short key_g;
732	unsigned short key_b;
733	unsigned alpha; /image is not opaque and alpha channel or alpha palette required/
734	unsigned numcolors; /amount of colors, up to 257. Not valid if bits == 16 or allow_palette is disabled./
735	unsigned char palette[`1024`]; /Remembers up to the first 256 RGBA colors, in no particular order, only valid when numcolors is valid/
736	unsigned bits; /bits per channel (not for palette). 1,2 or 4 for grayscale only. 16 if 16-bit per channel required./
737	size_t numpixels;
738
739	/user settings for computing/using the stats/
740	unsigned allow_palette; /default 1. if 0, disallow choosing palette colortype in auto_choose_color, and don't count numcolors/
741	unsigned allow_greyscale; /default 1. if 0, choose RGB or RGBA even if the image only has gray colors/
742	} LodePNGColorStats;
743
744	void lodepng_color_stats_init(LodePNGColorStats* stats);
745
746	/Get a LodePNGColorStats of the image. The stats must already have been inited.*
747	Returns error code (e.g. alloc fail) or 0 if ok./*
748	unsigned lodepng_compute_color_stats(LodePNGColorStats* stats,
749	const unsigned char* image, unsigned w, unsigned h,
750	const LodePNGColorMode* mode_in);
751
752	/Settings for the encoder./
753	typedef struct LodePNGEncoderSettings {
754	LodePNGCompressSettings zlibsettings; /settings for the zlib encoder, such as window size, .../
755
756	unsigned auto_convert; /automatically choose output PNG color type. Default: true/
757
758	/If true, follows the official PNG heuristic: if the PNG uses a palette or lower than*
759	8 bit depth, set all filters to zero. Otherwise use the filter_strategy. Note that to
760	completely follow the official PNG heuristic, filter_palette_zero must be true and
761	filter_strategy must be LFS_MINSUM/*
762	unsigned filter_palette_zero;
763	/Which filter strategy to use when not using zeroes due to filter_palette_zero.*
764	Set filter_palette_zero to 0 to ensure always using your chosen strategy. Default: LFS_MINSUM/*
765	LodePNGFilterStrategy filter_strategy;
766	/used if filter_strategy is LFS_PREDEFINED. In that case, this must point to a buffer with*
767	the same length as the amount of scanlines in the image, and each value must <= 5. You
768	have to cleanup this buffer, LodePNG will never free it. Don't forget that filter_palette_zero
769	must be set to 0 to ensure this is also used on palette or low bitdepth images./*
770	const unsigned char* predefined_filters;
771
772	/force creating a PLTE chunk if colortype is 2 or 6 (= a suggested palette).*
773	If colortype is 3, PLTE is _always_ created./*
774	unsigned force_palette;
775	#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
776	/add LodePNG identifier and version as a text chunk, for debugging/
777	unsigned add_id;
778	/encode text chunks as zTXt chunks instead of tEXt chunks, and use compression in iTXt chunks/
779	unsigned text_compression;
780	#endif /LODEPNG_COMPILE_ANCILLARY_CHUNKS/
781	} LodePNGEncoderSettings;
782
783	void lodepng_encoder_settings_init(LodePNGEncoderSettings* settings);
784	#endif /LODEPNG_COMPILE_ENCODER/
785
786
787	#if defined(LODEPNG_COMPILE_DECODER) \|\| defined(LODEPNG_COMPILE_ENCODER)
788	/The settings, state and information for extended encoding and decoding./
789	typedef struct LodePNGState {
790	#ifdef LODEPNG_COMPILE_DECODER
791	LodePNGDecoderSettings decoder; /the decoding settings/
792	#endif /LODEPNG_COMPILE_DECODER/
793	#ifdef LODEPNG_COMPILE_ENCODER
794	LodePNGEncoderSettings encoder; /the encoding settings/
795	#endif /LODEPNG_COMPILE_ENCODER/
796	LodePNGColorMode info_raw; /specifies the format in which you would like to get the raw pixel buffer/
797	LodePNGInfo info_png; /info of the PNG image obtained after decoding/
798	unsigned error;
799	} LodePNGState;
800
801	/init, cleanup and copy functions to use with this struct/
802	void lodepng_state_init(LodePNGState* state);
803	void lodepng_state_cleanup(LodePNGState* state);
804	void lodepng_state_copy(LodePNGState* dest, const LodePNGState* source);
805	#endif /* defined(LODEPNG_COMPILE_DECODER) \|\| defined(LODEPNG_COMPILE_ENCODER) */
806
807	#ifdef LODEPNG_COMPILE_DECODER
808	/*
809	Same as lodepng_decode_memory, but uses a LodePNGState to allow custom settings and
810	getting much more information about the PNG image and color mode.
811	*/
812	unsigned lodepng_decode(unsigned char** out, unsigned* w, unsigned* h,
813	LodePNGState* state,
814	const unsigned char* in, size_t insize);
815
816	/*
817	Read the PNG header, but not the actual data. This returns only the information
818	that is in the IHDR chunk of the PNG, such as width, height and color type. The
819	information is placed in the info_png field of the LodePNGState.
820	*/
821	unsigned lodepng_inspect(unsigned* w, unsigned* h,
822	LodePNGState* state,
823	const unsigned char* in, size_t insize);
824	#endif /LODEPNG_COMPILE_DECODER/
825
826	/*
827	Reads one metadata chunk (other than IHDR) of the PNG file and outputs what it
828	read in the state. Returns error code on failure.
829	Use lodepng_inspect first with a new state, then e.g. lodepng_chunk_find_const
830	to find the desired chunk type, and if non null use lodepng_inspect_chunk (with
831	chunk_pointer - start_of_file as pos).
832	Supports most metadata chunks from the PNG standard (gAMA, bKGD, tEXt, ...).
833	Ignores unsupported, unknown, non-metadata or IHDR chunks (without error).
834	Requirements: &in[pos] must point to start of a chunk, must use regular
835	lodepng_inspect first since format of most other chunks depends on IHDR, and if
836	there is a PLTE chunk, that one must be inspected before tRNS or bKGD.
837	*/
838	unsigned lodepng_inspect_chunk(LodePNGState* state, size_t pos,
839	const unsigned char* in, size_t insize);
840
841	#ifdef LODEPNG_COMPILE_ENCODER
842	/This function allocates the out buffer with standard malloc and stores the size in outsize./*
843	unsigned lodepng_encode(unsigned char** out, size_t* outsize,
844	const unsigned char* image, unsigned w, unsigned h,
845	LodePNGState* state);
846	#endif /LODEPNG_COMPILE_ENCODER/
847
848	/*
849	The lodepng_chunk functions are normally not needed, except to traverse the
850	unknown chunks stored in the LodePNGInfo struct, or add new ones to it.
851	It also allows traversing the chunks of an encoded PNG file yourself.
852
853	The chunk pointer always points to the beginning of the chunk itself, that is
854	the first byte of the 4 length bytes.
855
856	In the PNG file format, chunks have the following format:
857	-4 bytes length: length of the data of the chunk in bytes (chunk itself is 12 bytes longer)
858	-4 bytes chunk type (ASCII a-z,A-Z only, see below)
859	-length bytes of data (may be 0 bytes if length was 0)
860	-4 bytes of CRC, computed on chunk name + data
861
862	The first chunk starts at the 8th byte of the PNG file, the entire rest of the file
863	exists out of concatenated chunks with the above format.
864
865	PNG standard chunk ASCII naming conventions:
866	-First byte: uppercase = critical, lowercase = ancillary
867	-Second byte: uppercase = public, lowercase = private
868	-Third byte: must be uppercase
869	-Fourth byte: uppercase = unsafe to copy, lowercase = safe to copy
870	*/
871
872	/*
873	Gets the length of the data of the chunk. Total chunk length has 12 bytes more.
874	There must be at least 4 bytes to read from. If the result value is too large,
875	it may be corrupt data.
876	*/
877	unsigned lodepng_chunk_length(const unsigned char* chunk);
878
879	/puts the 4-byte type in null terminated string/
880	void lodepng_chunk_type(char type[`5`], const unsigned char* chunk);
881
882	/check if the type is the given type/
883	unsigned char lodepng_chunk_type_equals(const unsigned char* chunk, const char* type);
884
885	/0: it's one of the critical chunk types, 1: it's an ancillary chunk (see PNG standard)/
886	unsigned char lodepng_chunk_ancillary(const unsigned char* chunk);
887
888	/0: public, 1: private (see PNG standard)/
889	unsigned char lodepng_chunk_private(const unsigned char* chunk);
890
891	/0: the chunk is unsafe to copy, 1: the chunk is safe to copy (see PNG standard)/
892	unsigned char lodepng_chunk_safetocopy(const unsigned char* chunk);
893
894	/get pointer to the data of the chunk, where the input points to the header of the chunk/
895	unsigned char* lodepng_chunk_data(unsigned char* chunk);
896	const unsigned char* lodepng_chunk_data_const(const unsigned char* chunk);
897
898	/returns 0 if the crc is correct, 1 if it's incorrect (0 for OK as usual!)/
899	unsigned lodepng_chunk_check_crc(const unsigned char* chunk);
900
901	/generates the correct CRC from the data and puts it in the last 4 bytes of the chunk/
902	void lodepng_chunk_generate_crc(unsigned char* chunk);
903
904	/*
905	Iterate to next chunks, allows iterating through all chunks of the PNG file.
906	Input must be at the beginning of a chunk (result of a previous lodepng_chunk_next call,
907	or the 8th byte of a PNG file which always has the first chunk), or alternatively may
908	point to the first byte of the PNG file (which is not a chunk but the magic header, the
909	function will then skip over it and return the first real chunk).
910	Will output pointer to the start of the next chunk, or at or beyond end of the file if there
911	is no more chunk after this or possibly if the chunk is corrupt.
912	Start this process at the 8th byte of the PNG file.
913	In a non-corrupt PNG file, the last chunk should have name "IEND".
914	*/
915	unsigned char* lodepng_chunk_next(unsigned char* chunk, unsigned char* end);
916	const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk, const unsigned char* end);
917
918	/Finds the first chunk with the given type in the range [chunk, end), or returns NULL if not found./
919	unsigned char* lodepng_chunk_find(unsigned char* chunk, unsigned char* end, const char type[`5`]);
920	const unsigned char* lodepng_chunk_find_const(const unsigned char* chunk, const unsigned char* end, const char type[`5`]);
921
922	/*
923	Appends chunk to the data in out. The given chunk should already have its chunk header.
924	The out variable and outsize are updated to reflect the new reallocated buffer.
925	Returns error code (0 if it went ok)
926	*/
927	unsigned lodepng_chunk_append(unsigned char** out, size_t* outsize, const unsigned char* chunk);
928
929	/*
930	Appends new chunk to out. The chunk to append is given by giving its length, type
931	and data separately. The type is a 4-letter string.
932	The out variable and outsize are updated to reflect the new reallocated buffer.
933	Returne error code (0 if it went ok)
934	*/
935	unsigned lodepng_chunk_create(unsigned char** out, size_t* outsize, unsigned length,
936	const char* type, const unsigned char* data);
937
938
939	/Calculate CRC32 of buffer/
940	unsigned lodepng_crc32(const unsigned char* buf, size_t len);
941	#endif /LODEPNG_COMPILE_PNG/
942
943
944	#ifdef LODEPNG_COMPILE_ZLIB
945	/*
946	This zlib part can be used independently to zlib compress and decompress a
947	buffer. It cannot be used to create gzip files however, and it only supports the
948	part of zlib that is required for PNG, it does not support dictionaries.
949	*/
950
951	#ifdef LODEPNG_COMPILE_DECODER
952	/Inflate a buffer. Inflate is the decompression step of deflate. Out buffer must be freed after use./
953	unsigned lodepng_inflate(unsigned char** out, size_t* outsize,
954	const unsigned char* in, size_t insize,
955	const LodePNGDecompressSettings* settings);
956
957	/*
958	Decompresses Zlib data. Reallocates the out buffer and appends the data. The
959	data must be according to the zlib specification.
960	Either, out must be NULL and outsize must be 0, or, out must be a valid*
961	buffer and outsize its size in bytes. out must be freed by user after usage.*
962	*/
963	unsigned lodepng_zlib_decompress(unsigned char** out, size_t* outsize,
964	const unsigned char* in, size_t insize,
965	const LodePNGDecompressSettings* settings);
966	#endif /LODEPNG_COMPILE_DECODER/
967
968	#ifdef LODEPNG_COMPILE_ENCODER
969	/*
970	Compresses data with Zlib. Reallocates the out buffer and appends the data.
971	Zlib adds a small header and trailer around the deflate data.
972	The data is output in the format of the zlib specification.
973	Either, out must be NULL and outsize must be 0, or, out must be a valid*
974	buffer and outsize its size in bytes. out must be freed by user after usage.*
975	*/
976	unsigned lodepng_zlib_compress(unsigned char** out, size_t* outsize,
977	const unsigned char* in, size_t insize,
978	const LodePNGCompressSettings* settings);
979
980	/*
981	Find length-limited Huffman code for given frequencies. This function is in the
982	public interface only for tests, it's used internally by lodepng_deflate.
983	*/
984	unsigned lodepng_huffman_code_lengths(unsigned* lengths, const unsigned* frequencies,
985	size_t numcodes, unsigned maxbitlen);
986
987	/Compress a buffer with deflate. See RFC 1951. Out buffer must be freed after use./
988	unsigned lodepng_deflate(unsigned char** out, size_t* outsize,
989	const unsigned char* in, size_t insize,
990	const LodePNGCompressSettings* settings);
991
992	#endif /LODEPNG_COMPILE_ENCODER/
993	#endif /LODEPNG_COMPILE_ZLIB/
994
995	#ifdef LODEPNG_COMPILE_DISK
996	/*
997	Load a file from disk into buffer. The function allocates the out buffer, and
998	after usage you should free it.
999	out: output parameter, contains pointer to loaded buffer.
1000	outsize: output parameter, size of the allocated out buffer
1001	filename: the path to the file to load
1002	return value: error code (0 means ok)
1003
1004	NOTE: Wide-character filenames are not supported, you can use an external method
1005	to handle such files and decode in-memory.
1006	*/
1007	unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename);
1008
1009	/*
1010	Save a file from buffer to disk. Warning, if it exists, this function overwrites
1011	the file without warning!
1012	buffer: the buffer to write
1013	buffersize: size of the buffer to write
1014	filename: the path to the file to save to
1015	return value: error code (0 means ok)
1016
1017	NOTE: Wide-character filenames are not supported, you can use an external method
1018	to handle such files and encode in-memory
1019	*/
1020	unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename);
1021	#endif /LODEPNG_COMPILE_DISK/
1022
1023	#ifdef LODEPNG_COMPILE_CPP
1024	/ The LodePNG C++ wrapper uses std::vectors instead of manually allocated memory buffers. /
1025	namespace lodepng {
1026	#ifdef LODEPNG_COMPILE_PNG
1027	class State : public LodePNGState {
1028	public:
1029	State();
1030	State(const State& other);
1031	~State();
1032	State& operator=(const State& other);
1033	};
1034
1035	#ifdef LODEPNG_COMPILE_DECODER
1036	/ Same as other lodepng::decode, but using a State for more settings and information. /
1037	unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
1038	State& state,
1039	const unsigned char* in, size_t insize);
1040	unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
1041	State& state,
1042	const std::vector<unsigned char>& in);
1043	#endif /LODEPNG_COMPILE_DECODER/
1044
1045	#ifdef LODEPNG_COMPILE_ENCODER
1046	/ Same as other lodepng::encode, but using a State for more settings and information. /
1047	unsigned encode(std::vector<unsigned char>& out,
1048	const unsigned char* in, unsigned w, unsigned h,
1049	State& state);
1050	unsigned encode(std::vector<unsigned char>& out,
1051	const std::vector<unsigned char>& in, unsigned w, unsigned h,
1052	State& state);
1053	#endif /LODEPNG_COMPILE_ENCODER/
1054
1055	#ifdef LODEPNG_COMPILE_DISK
1056	/*
1057	Load a file from disk into an std::vector.
1058	return value: error code (0 means ok)
1059
1060	NOTE: Wide-character filenames are not supported, you can use an external method
1061	to handle such files and decode in-memory
1062	*/
1063	unsigned load_file(std::vector<unsigned char>& buffer, const std::string& filename);
1064
1065	/*
1066	Save the binary data in an std::vector to a file on disk. The file is overwritten
1067	without warning.
1068
1069	NOTE: Wide-character filenames are not supported, you can use an external method
1070	to handle such files and encode in-memory
1071	*/
1072	unsigned save_file(const std::vector<unsigned char>& buffer, const std::string& filename);
1073	#endif /* LODEPNG_COMPILE_DISK */
1074	#endif /* LODEPNG_COMPILE_PNG */
1075
1076	#ifdef LODEPNG_COMPILE_ZLIB
1077	#ifdef LODEPNG_COMPILE_DECODER
1078	/ Zlib-decompress an unsigned char buffer /
1079	unsigned decompress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
1080	const LodePNGDecompressSettings& settings = lodepng_default_decompress_settings);
1081
1082	/ Zlib-decompress an std::vector /
1083	unsigned decompress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in,
1084	const LodePNGDecompressSettings& settings = lodepng_default_decompress_settings);
1085	#endif /* LODEPNG_COMPILE_DECODER */
1086
1087	#ifdef LODEPNG_COMPILE_ENCODER
1088	/ Zlib-compress an unsigned char buffer /
1089	unsigned compress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
1090	const LodePNGCompressSettings& settings = lodepng_default_compress_settings);
1091
1092	/ Zlib-compress an std::vector /
1093	unsigned compress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in,
1094	const LodePNGCompressSettings& settings = lodepng_default_compress_settings);
1095	#endif /* LODEPNG_COMPILE_ENCODER */
1096	#endif /* LODEPNG_COMPILE_ZLIB */
1097	} / namespace lodepng /
1098	#endif /LODEPNG_COMPILE_CPP/
1099
1100	/*
1101	TODO:
1102	[.] test if there are no memory leaks or security exploits - done a lot but needs to be checked often
1103	[.] check compatibility with various compilers - done but needs to be redone for every newer version
1104	[X] converting color to 16-bit per channel types
1105	[X] support color profile chunk types (but never let them touch RGB values by default)
1106	[ ] support all public PNG chunk types (almost done except sBIT, sPLT and hIST)
1107	[ ] make sure encoder generates no chunks with size > (2^31)-1
1108	[ ] partial decoding (stream processing)
1109	[X] let the "isFullyOpaque" function check color keys and transparent palettes too
1110	[X] better name for the variables "codes", "codesD", "codelengthcodes", "clcl" and "lldl"
1111	[ ] allow treating some errors like warnings, when image is recoverable (e.g. 69, 57, 58)
1112	[ ] make warnings like: oob palette, checksum fail, data after iend, wrong/unknown crit chunk, no null terminator in text, ...
1113	[ ] error messages with line numbers (and version)
1114	[ ] errors in state instead of as return code?
1115	[ ] new errors/warnings like suspiciously big decompressed ztxt or iccp chunk
1116	[ ] let the C++ wrapper catch exceptions coming from the standard library and return LodePNG error codes
1117	[ ] allow user to provide custom color conversion functions, e.g. for premultiplied alpha, padding bits or not, ...
1118	[ ] allow user to give data (void) to custom allocator*
1119	[X] provide alternatives for C library functions not present on some platforms (memcpy, ...)
1120	*/
1121
1122	#endif /LODEPNG_H inclusion guard/
1123
1124	/*
1125	LodePNG Documentation
1126	---------------------
1127
1128	0. table of contents
1129	--------------------
1130
1131	1. about
1132	1.1. supported features
1133	1.2. features not supported
1134	2. C and C++ version
1135	3. security
1136	4. decoding
1137	5. encoding
1138	6. color conversions
1139	6.1. PNG color types
1140	6.2. color conversions
1141	6.3. padding bits
1142	6.4. A note about 16-bits per channel and endianness
1143	7. error values
1144	8. chunks and PNG editing
1145	9. compiler support
1146	10. examples
1147	10.1. decoder C++ example
1148	10.2. decoder C example
1149	11. state settings reference
1150	12. changes
1151	13. contact information
1152
1153
1154	1. about
1155	--------
1156
1157	PNG is a file format to store raster images losslessly with good compression,
1158	supporting different color types and alpha channel.
1159
1160	LodePNG is a PNG codec according to the Portable Network Graphics (PNG)
1161	Specification (Second Edition) - W3C Recommendation 10 November 2003.
1162
1163	The specifications used are:
1164
1165	*) Portable Network Graphics (PNG) Specification (Second Edition):
1166	http://www.w3.org/TR/2003/REC-PNG-20031110
1167	*) RFC 1950 ZLIB Compressed Data Format version 3.3:
1168	http://www.gzip.org/zlib/rfc-zlib.html
1169	*) RFC 1951 DEFLATE Compressed Data Format Specification ver 1.3:
1170	http://www.gzip.org/zlib/rfc-deflate.html
1171
1172	The most recent version of LodePNG can currently be found at
1173	http://lodev.org/lodepng/
1174
1175	LodePNG works both in C (ISO C90) and C++, with a C++ wrapper that adds
1176	extra functionality.
1177
1178	LodePNG exists out of two files:
1179	-lodepng.h: the header file for both C and C++
1180	-lodepng.c(pp): give it the name lodepng.c or lodepng.cpp (or .cc) depending on your usage
1181
1182	If you want to start using LodePNG right away without reading this doc, get the
1183	examples from the LodePNG website to see how to use it in code, or check the
1184	smaller examples in chapter 13 here.
1185
1186	LodePNG is simple but only supports the basic requirements. To achieve
1187	simplicity, the following design choices were made: There are no dependencies
1188	on any external library. There are functions to decode and encode a PNG with
1189	a single function call, and extended versions of these functions taking a
1190	LodePNGState struct allowing to specify or get more information. By default
1191	the colors of the raw image are always RGB or RGBA, no matter what color type
1192	the PNG file uses. To read and write files, there are simple functions to
1193	convert the files to/from buffers in memory.
1194
1195	This all makes LodePNG suitable for loading textures in games, demos and small
1196	programs, ... It's less suitable for full fledged image editors, loading PNGs
1197	over network (it requires all the image data to be available before decoding can
1198	begin), life-critical systems, ...
1199
1200	1.1. supported features
1201	-----------------------
1202
1203	The following features are supported by the decoder:
1204
1205	*) decoding of PNGs with any color type, bit depth and interlace mode, to a 24- or 32-bit color raw image,
1206	or the same color type as the PNG
1207	*) encoding of PNGs, from any raw image to 24- or 32-bit color, or the same color type as the raw image
1208	*) Adam7 interlace and deinterlace for any color type
1209	*) loading the image from harddisk or decoding it from a buffer from other sources than harddisk
1210	*) support for alpha channels, including RGBA color model, translucent palettes and color keying
1211	*) zlib decompression (inflate)
1212	*) zlib compression (deflate)
1213	*) CRC32 and ADLER32 checksums
1214	*) colorimetric color profile conversions: currently experimentally available in lodepng_util.cpp only,
1215	plus alternatively ability to pass on chroma/gamma/ICC profile information to other color management system.
1216	*) handling of unknown chunks, allowing making a PNG editor that stores custom and unknown chunks.
1217	*) the following chunks are supported by both encoder and decoder:
1218	IHDR: header information
1219	PLTE: color palette
1220	IDAT: pixel data
1221	IEND: the final chunk
1222	tRNS: transparency for palettized images
1223	tEXt: textual information
1224	zTXt: compressed textual information
1225	iTXt: international textual information
1226	bKGD: suggested background color
1227	pHYs: physical dimensions
1228	tIME: modification time
1229	cHRM: RGB chromaticities
1230	gAMA: RGB gamma correction
1231	iCCP: ICC color profile
1232	sRGB: rendering intent
1233
1234	1.2. features not supported
1235	---------------------------
1236
1237	The following features are _not_ supported:
1238
1239	*) some features needed to make a conformant PNG-Editor might be still missing.
1240	*) partial loading/stream processing. All data must be available and is processed in one call.
1241	*) The following public chunks are not (yet) supported but treated as unknown chunks by LodePNG:
1242	sBIT
1243	hIST
1244	sPLT
1245
1246
1247	2. C and C++ version
1248	--------------------
1249
1250	The C version uses buffers allocated with alloc that you need to free()
1251	yourself. You need to use init and cleanup functions for each struct whenever
1252	using a struct from the C version to avoid exploits and memory leaks.
1253
1254	The C++ version has extra functions with std::vectors in the interface and the
1255	lodepng::State class which is a LodePNGState with constructor and destructor.
1256
1257	These files work without modification for both C and C++ compilers because all
1258	the additional C++ code is in "#ifdef __cplusplus" blocks that make C-compilers
1259	ignore it, and the C code is made to compile both with strict ISO C90 and C++.
1260
1261	To use the C++ version, you need to rename the source file to lodepng.cpp
1262	(instead of lodepng.c), and compile it with a C++ compiler.
1263
1264	To use the C version, you need to rename the source file to lodepng.c (instead
1265	of lodepng.cpp), and compile it with a C compiler.
1266
1267
1268	3. Security
1269	-----------
1270
1271	Even if carefully designed, it's always possible that LodePNG contains possible
1272	exploits. If you discover one, please let me know, and it will be fixed.
1273
1274	When using LodePNG, care has to be taken with the C version of LodePNG, as well
1275	as the C-style structs when working with C++. The following conventions are used
1276	for all C-style structs:
1277
1278	-if a struct has a corresponding init function, always call the init function when making a new one
1279	-if a struct has a corresponding cleanup function, call it before the struct disappears to avoid memory leaks
1280	-if a struct has a corresponding copy function, use the copy function instead of "=".
1281	The destination must also be inited already.
1282
1283
1284	4. Decoding
1285	-----------
1286
1287	Decoding converts a PNG compressed image to a raw pixel buffer.
1288
1289	Most documentation on using the decoder is at its declarations in the header
1290	above. For C, simple decoding can be done with functions such as
1291	lodepng_decode32, and more advanced decoding can be done with the struct
1292	LodePNGState and lodepng_decode. For C++, all decoding can be done with the
1293	various lodepng::decode functions, and lodepng::State can be used for advanced
1294	features.
1295
1296	When using the LodePNGState, it uses the following fields for decoding:
1297	*) LodePNGInfo info_png: it stores extra information about the PNG (the input) in here
1298	*) LodePNGColorMode info_raw: here you can say what color mode of the raw image (the output) you want to get
1299	*) LodePNGDecoderSettings decoder: you can specify a few extra settings for the decoder to use
1300
1301	LodePNGInfo info_png
1302	--------------------
1303
1304	After decoding, this contains extra information of the PNG image, except the actual
1305	pixels, width and height because these are already gotten directly from the decoder
1306	functions.
1307
1308	It contains for example the original color type of the PNG image, text comments,
1309	suggested background color, etc... More details about the LodePNGInfo struct are
1310	at its declaration documentation.
1311
1312	LodePNGColorMode info_raw
1313	-------------------------
1314
1315	When decoding, here you can specify which color type you want
1316	the resulting raw image to be. If this is different from the colortype of the
1317	PNG, then the decoder will automatically convert the result. This conversion
1318	always works, except if you want it to convert a color PNG to grayscale or to
1319	a palette with missing colors.
1320
1321	By default, 32-bit color is used for the result.
1322
1323	LodePNGDecoderSettings decoder
1324	------------------------------
1325
1326	The settings can be used to ignore the errors created by invalid CRC and Adler32
1327	chunks, and to disable the decoding of tEXt chunks.
1328
1329	There's also a setting color_convert, true by default. If false, no conversion
1330	is done, the resulting data will be as it was in the PNG (after decompression)
1331	and you'll have to puzzle the colors of the pixels together yourself using the
1332	color type information in the LodePNGInfo.
1333
1334
1335	5. Encoding
1336	-----------
1337
1338	Encoding converts a raw pixel buffer to a PNG compressed image.
1339
1340	Most documentation on using the encoder is at its declarations in the header
1341	above. For C, simple encoding can be done with functions such as
1342	lodepng_encode32, and more advanced decoding can be done with the struct
1343	LodePNGState and lodepng_encode. For C++, all encoding can be done with the
1344	various lodepng::encode functions, and lodepng::State can be used for advanced
1345	features.
1346
1347	Like the decoder, the encoder can also give errors. However it gives less errors
1348	since the encoder input is trusted, the decoder input (a PNG image that could
1349	be forged by anyone) is not trusted.
1350
1351	When using the LodePNGState, it uses the following fields for encoding:
1352	*) LodePNGInfo info_png: here you specify how you want the PNG (the output) to be.
1353	*) LodePNGColorMode info_raw: here you say what color type of the raw image (the input) has
1354	*) LodePNGEncoderSettings encoder: you can specify a few settings for the encoder to use
1355
1356	LodePNGInfo info_png
1357	--------------------
1358
1359	When encoding, you use this the opposite way as when decoding: for encoding,
1360	you fill in the values you want the PNG to have before encoding. By default it's
1361	not needed to specify a color type for the PNG since it's automatically chosen,
1362	but it's possible to choose it yourself given the right settings.
1363
1364	The encoder will not always exactly match the LodePNGInfo struct you give,
1365	it tries as close as possible. Some things are ignored by the encoder. The
1366	encoder uses, for example, the following settings from it when applicable:
1367	colortype and bitdepth, text chunks, time chunk, the color key, the palette, the
1368	background color, the interlace method, unknown chunks, ...
1369
1370	When encoding to a PNG with colortype 3, the encoder will generate a PLTE chunk.
1371	If the palette contains any colors for which the alpha channel is not 255 (so
1372	there are translucent colors in the palette), it'll add a tRNS chunk.
1373
1374	LodePNGColorMode info_raw
1375	-------------------------
1376
1377	You specify the color type of the raw image that you give to the input here,
1378	including a possible transparent color key and palette you happen to be using in
1379	your raw image data.
1380
1381	By default, 32-bit color is assumed, meaning your input has to be in RGBA
1382	format with 4 bytes (unsigned chars) per pixel.
1383
1384	LodePNGEncoderSettings encoder
1385	------------------------------
1386
1387	The following settings are supported (some are in sub-structs):
1388	*) auto_convert: when this option is enabled, the encoder will
1389	automatically choose the smallest possible color mode (including color key) that
1390	can encode the colors of all pixels without information loss.
1391	*) btype: the block type for LZ77. 0 = uncompressed, 1 = fixed huffman tree,
1392	2 = dynamic huffman tree (best compression). Should be 2 for proper
1393	compression.
1394	*) use_lz77: whether or not to use LZ77 for compressed block types. Should be
1395	true for proper compression.
1396	*) windowsize: the window size used by the LZ77 encoder (1 - 32768). Has value
1397	2048 by default, but can be set to 32768 for better, but slow, compression.
1398	*) force_palette: if colortype is 2 or 6, you can make the encoder write a PLTE
1399	chunk if force_palette is true. This can used as suggested palette to convert
1400	to by viewers that don't support more than 256 colors (if those still exist)
1401	*) add_id: add text chunk "Encoder: LodePNG <version>" to the image.
1402	*) text_compression: default 1. If 1, it'll store texts as zTXt instead of tEXt chunks.
1403	zTXt chunks use zlib compression on the text. This gives a smaller result on
1404	large texts but a larger result on small texts (such as a single program name).
1405	It's all tEXt or all zTXt though, there's no separate setting per text yet.
1406
1407
1408	6. color conversions
1409	--------------------
1410
1411	An important thing to note about LodePNG, is that the color type of the PNG, and
1412	the color type of the raw image, are completely independent. By default, when
1413	you decode a PNG, you get the result as a raw image in the color type you want,
1414	no matter whether the PNG was encoded with a palette, grayscale or RGBA color.
1415	And if you encode an image, by default LodePNG will automatically choose the PNG
1416	color type that gives good compression based on the values of colors and amount
1417	of colors in the image. It can be configured to let you control it instead as
1418	well, though.
1419
1420	To be able to do this, LodePNG does conversions from one color mode to another.
1421	It can convert from almost any color type to any other color type, except the
1422	following conversions: RGB to grayscale is not supported, and converting to a
1423	palette when the palette doesn't have a required color is not supported. This is
1424	not supported on purpose: this is information loss which requires a color
1425	reduction algorithm that is beyond the scope of a PNG encoder (yes, RGB to gray
1426	is easy, but there are multiple ways if you want to give some channels more
1427	weight).
1428
1429	By default, when decoding, you get the raw image in 32-bit RGBA or 24-bit RGB
1430	color, no matter what color type the PNG has. And by default when encoding,
1431	LodePNG automatically picks the best color model for the output PNG, and expects
1432	the input image to be 32-bit RGBA or 24-bit RGB. So, unless you want to control
1433	the color format of the images yourself, you can skip this chapter.
1434
1435	6.1. PNG color types
1436	--------------------
1437
1438	A PNG image can have many color types, ranging from 1-bit color to 64-bit color,
1439	as well as palettized color modes. After the zlib decompression and unfiltering
1440	in the PNG image is done, the raw pixel data will have that color type and thus
1441	a certain amount of bits per pixel. If you want the output raw image after
1442	decoding to have another color type, a conversion is done by LodePNG.
1443
1444	The PNG specification gives the following color types:
1445
1446	0: grayscale, bit depths 1, 2, 4, 8, 16
1447	2: RGB, bit depths 8 and 16
1448	3: palette, bit depths 1, 2, 4 and 8
1449	4: grayscale with alpha, bit depths 8 and 16
1450	6: RGBA, bit depths 8 and 16
1451
1452	Bit depth is the amount of bits per pixel per color channel. So the total amount
1453	of bits per pixel is: amount of channels bitdepth.*
1454
1455	6.2. color conversions
1456	----------------------
1457
1458	As explained in the sections about the encoder and decoder, you can specify
1459	color types and bit depths in info_png and info_raw to change the default
1460	behaviour.
1461
1462	If, when decoding, you want the raw image to be something else than the default,
1463	you need to set the color type and bit depth you want in the LodePNGColorMode,
1464	or the parameters colortype and bitdepth of the simple decoding function.
1465
1466	If, when encoding, you use another color type than the default in the raw input
1467	image, you need to specify its color type and bit depth in the LodePNGColorMode
1468	of the raw image, or use the parameters colortype and bitdepth of the simple
1469	encoding function.
1470
1471	If, when encoding, you don't want LodePNG to choose the output PNG color type
1472	but control it yourself, you need to set auto_convert in the encoder settings
1473	to false, and specify the color type you want in the LodePNGInfo of the
1474	encoder (including palette: it can generate a palette if auto_convert is true,
1475	otherwise not).
1476
1477	If the input and output color type differ (whether user chosen or auto chosen),
1478	LodePNG will do a color conversion, which follows the rules below, and may
1479	sometimes result in an error.
1480
1481	To avoid some confusion:
1482	-the decoder converts from PNG to raw image
1483	-the encoder converts from raw image to PNG
1484	-the colortype and bitdepth in LodePNGColorMode info_raw, are those of the raw image
1485	-the colortype and bitdepth in the color field of LodePNGInfo info_png, are those of the PNG
1486	-when encoding, the color type in LodePNGInfo is ignored if auto_convert
1487	is enabled, it is automatically generated instead
1488	-when decoding, the color type in LodePNGInfo is set by the decoder to that of the original
1489	PNG image, but it can be ignored since the raw image has the color type you requested instead
1490	-if the color type of the LodePNGColorMode and PNG image aren't the same, a conversion
1491	between the color types is done if the color types are supported. If it is not
1492	supported, an error is returned. If the types are the same, no conversion is done.
1493	-even though some conversions aren't supported, LodePNG supports loading PNGs from any
1494	colortype and saving PNGs to any colortype, sometimes it just requires preparing
1495	the raw image correctly before encoding.
1496	-both encoder and decoder use the same color converter.
1497
1498	The function lodepng_convert does the color conversion. It is available in the
1499	interface but normally isn't needed since the encoder and decoder already call
1500	it.
1501
1502	Non supported color conversions:
1503	-color to grayscale when non-gray pixels are present: no error is thrown, but
1504	the result will look ugly because only the red channel is taken (it assumes all
1505	three channels are the same in this case so ignores green and blue). The reason
1506	no error is given is to allow converting from three-channel grayscale images to
1507	one-channel even if there are numerical imprecisions.
1508	-anything to palette when the palette does not have an exact match for a from-color
1509	in it: in this case an error is thrown
1510
1511	Supported color conversions:
1512	-anything to 8-bit RGB, 8-bit RGBA, 16-bit RGB, 16-bit RGBA
1513	-any gray or gray+alpha, to gray or gray+alpha
1514	-anything to a palette, as long as the palette has the requested colors in it
1515	-removing alpha channel
1516	-higher to smaller bitdepth, and vice versa
1517
1518	If you want no color conversion to be done (e.g. for speed or control):
1519	-In the encoder, you can make it save a PNG with any color type by giving the
1520	raw color mode and LodePNGInfo the same color mode, and setting auto_convert to
1521	false.
1522	-In the decoder, you can make it store the pixel data in the same color type
1523	as the PNG has, by setting the color_convert setting to false. Settings in
1524	info_raw are then ignored.
1525
1526	6.3. padding bits
1527	-----------------
1528
1529	In the PNG file format, if a less than 8-bit per pixel color type is used and the scanlines
1530	have a bit amount that isn't a multiple of 8, then padding bits are used so that each
1531	scanline starts at a fresh byte. But that is NOT true for the LodePNG raw input and output.
1532	The raw input image you give to the encoder, and the raw output image you get from the decoder
1533	will NOT have these padding bits, e.g. in the case of a 1-bit image with a width
1534	of 7 pixels, the first pixel of the second scanline will the 8th bit of the first byte,
1535	not the first bit of a new byte.
1536
1537	6.4. A note about 16-bits per channel and endianness
1538	----------------------------------------------------
1539
1540	LodePNG uses unsigned char arrays for 16-bit per channel colors too, just like
1541	for any other color format. The 16-bit values are stored in big endian (most
1542	significant byte first) in these arrays. This is the opposite order of the
1543	little endian used by x86 CPU's.
1544
1545	LodePNG always uses big endian because the PNG file format does so internally.
1546	Conversions to other formats than PNG uses internally are not supported by
1547	LodePNG on purpose, there are myriads of formats, including endianness of 16-bit
1548	colors, the order in which you store R, G, B and A, and so on. Supporting and
1549	converting to/from all that is outside the scope of LodePNG.
1550
1551	This may mean that, depending on your use case, you may want to convert the big
1552	endian output of LodePNG to little endian with a for loop. This is certainly not
1553	always needed, many applications and libraries support big endian 16-bit colors
1554	anyway, but it means you cannot simply cast the unsigned char buffer to an*
1555	unsigned short buffer on x86 CPUs.*
1556
1557
1558	7. error values
1559	---------------
1560
1561	All functions in LodePNG that return an error code, return 0 if everything went
1562	OK, or a non-zero code if there was an error.
1563
1564	The meaning of the LodePNG error values can be retrieved with the function
1565	lodepng_error_text: given the numerical error code, it returns a description
1566	of the error in English as a string.
1567
1568	Check the implementation of lodepng_error_text to see the meaning of each code.
1569
1570	It is not recommended to use the numerical values to programmatically make
1571	different decisions based on error types as the numbers are not guaranteed to
1572	stay backwards compatible. They are for human consumption only. Programmatically
1573	only 0 or non-0 matter.
1574
1575
1576	8. chunks and PNG editing
1577	-------------------------
1578
1579	If you want to add extra chunks to a PNG you encode, or use LodePNG for a PNG
1580	editor that should follow the rules about handling of unknown chunks, or if your
1581	program is able to read other types of chunks than the ones handled by LodePNG,
1582	then that's possible with the chunk functions of LodePNG.
1583
1584	A PNG chunk has the following layout:
1585
1586	4 bytes length
1587	4 bytes type name
1588	length bytes data
1589	4 bytes CRC
1590
1591	8.1. iterating through chunks
1592	-----------------------------
1593
1594	If you have a buffer containing the PNG image data, then the first chunk (the
1595	IHDR chunk) starts at byte number 8 of that buffer. The first 8 bytes are the
1596	signature of the PNG and are not part of a chunk. But if you start at byte 8
1597	then you have a chunk, and can check the following things of it.
1598
1599	NOTE: none of these functions check for memory buffer boundaries. To avoid
1600	exploits, always make sure the buffer contains all the data of the chunks.
1601	When using lodepng_chunk_next, make sure the returned value is within the
1602	allocated memory.
1603
1604	unsigned lodepng_chunk_length(const unsigned char chunk):*
1605
1606	Get the length of the chunk's data. The total chunk length is this length + 12.
1607
1608	void lodepng_chunk_type(char type[5], const unsigned char chunk):*
1609	unsigned char lodepng_chunk_type_equals(const unsigned char chunk, const char* type):*
1610
1611	Get the type of the chunk or compare if it's a certain type
1612
1613	unsigned char lodepng_chunk_critical(const unsigned char chunk):*
1614	unsigned char lodepng_chunk_private(const unsigned char chunk):*
1615	unsigned char lodepng_chunk_safetocopy(const unsigned char chunk):*
1616
1617	Check if the chunk is critical in the PNG standard (only IHDR, PLTE, IDAT and IEND are).
1618	Check if the chunk is private (public chunks are part of the standard, private ones not).
1619	Check if the chunk is safe to copy. If it's not, then, when modifying data in a critical
1620	chunk, unsafe to copy chunks of the old image may NOT be saved in the new one if your
1621	program doesn't handle that type of unknown chunk.
1622
1623	unsigned char lodepng_chunk_data(unsigned char* chunk):*
1624	const unsigned char lodepng_chunk_data_const(const unsigned char* chunk):*
1625
1626	Get a pointer to the start of the data of the chunk.
1627
1628	unsigned lodepng_chunk_check_crc(const unsigned char chunk):*
1629	void lodepng_chunk_generate_crc(unsigned char chunk):*
1630
1631	Check if the crc is correct or generate a correct one.
1632
1633	unsigned char lodepng_chunk_next(unsigned char* chunk):*
1634	const unsigned char lodepng_chunk_next_const(const unsigned char* chunk):*
1635
1636	Iterate to the next chunk. This works if you have a buffer with consecutive chunks. Note that these
1637	functions do no boundary checking of the allocated data whatsoever, so make sure there is enough
1638	data available in the buffer to be able to go to the next chunk.
1639
1640	unsigned lodepng_chunk_append(unsigned char* out, size_t* outsize, const unsigned char* chunk):*
1641	unsigned lodepng_chunk_create(unsigned char* out, size_t* outsize, unsigned length,*
1642	const char type, const unsigned char* data):*
1643
1644	These functions are used to create new chunks that are appended to the data in out that has*
1645	length outsize. The append function appends an existing chunk to the new data. The create*
1646	function creates a new chunk with the given parameters and appends it. Type is the 4-letter
1647	name of the chunk.
1648
1649	8.2. chunks in info_png
1650	-----------------------
1651
1652	The LodePNGInfo struct contains fields with the unknown chunk in it. It has 3
1653	buffers (each with size) to contain 3 types of unknown chunks:
1654	the ones that come before the PLTE chunk, the ones that come between the PLTE
1655	and the IDAT chunks, and the ones that come after the IDAT chunks.
1656	It's necessary to make the distinction between these 3 cases because the PNG
1657	standard forces to keep the ordering of unknown chunks compared to the critical
1658	chunks, but does not force any other ordering rules.
1659
1660	info_png.unknown_chunks_data[0] is the chunks before PLTE
1661	info_png.unknown_chunks_data[1] is the chunks after PLTE, before IDAT
1662	info_png.unknown_chunks_data[2] is the chunks after IDAT
1663
1664	The chunks in these 3 buffers can be iterated through and read by using the same
1665	way described in the previous subchapter.
1666
1667	When using the decoder to decode a PNG, you can make it store all unknown chunks
1668	if you set the option settings.remember_unknown_chunks to 1. By default, this
1669	option is off (0).
1670
1671	The encoder will always encode unknown chunks that are stored in the info_png.
1672	If you need it to add a particular chunk that isn't known by LodePNG, you can
1673	use lodepng_chunk_append or lodepng_chunk_create to the chunk data in
1674	info_png.unknown_chunks_data[x].
1675
1676	Chunks that are known by LodePNG should not be added in that way. E.g. to make
1677	LodePNG add a bKGD chunk, set background_defined to true and add the correct
1678	parameters there instead.
1679
1680
1681	9. compiler support
1682	-------------------
1683
1684	No libraries other than the current standard C library are needed to compile
1685	LodePNG. For the C++ version, only the standard C++ library is needed on top.
1686	Add the files lodepng.c(pp) and lodepng.h to your project, include
1687	lodepng.h where needed, and your program can read/write PNG files.
1688
1689	It is compatible with C90 and up, and C++03 and up.
1690
1691	If performance is important, use optimization when compiling! For both the
1692	encoder and decoder, this makes a large difference.
1693
1694	Make sure that LodePNG is compiled with the same compiler of the same version
1695	and with the same settings as the rest of the program, or the interfaces with
1696	std::vectors and std::strings in C++ can be incompatible.
1697
1698	CHAR_BITS must be 8 or higher, because LodePNG uses unsigned chars for octets.
1699
1700	*) gcc and g++
1701
1702	LodePNG is developed in gcc so this compiler is natively supported. It gives no
1703	warnings with compiler options "-Wall -Wextra -pedantic -ansi", with gcc and g++
1704	version 4.7.1 on Linux, 32-bit and 64-bit.
1705
1706	*) Clang
1707
1708	Fully supported and warning-free.
1709
1710	*) Mingw
1711
1712	The Mingw compiler (a port of gcc for Windows) should be fully supported by
1713	LodePNG.
1714
1715	*) Visual Studio and Visual C++ Express Edition
1716
1717	LodePNG should be warning-free with warning level W4. Two warnings were disabled
1718	with pragmas though: warning 4244 about implicit conversions, and warning 4996
1719	where it wants to use a non-standard function fopen_s instead of the standard C
1720	fopen.
1721
1722	Visual Studio may want "stdafx.h" files to be included in each source file and
1723	give an error "unexpected end of file while looking for precompiled header".
1724	This is not standard C++ and will not be added to the stock LodePNG. You can
1725	disable it for lodepng.cpp only by right clicking it, Properties, C/C++,
1726	Precompiled Headers, and set it to Not Using Precompiled Headers there.
1727
1728	NOTE: Modern versions of VS should be fully supported, but old versions, e.g.
1729	VS6, are not guaranteed to work.
1730
1731	*) Compilers on Macintosh
1732
1733	LodePNG has been reported to work both with gcc and LLVM for Macintosh, both for
1734	C and C++.
1735
1736	*) Other Compilers
1737
1738	If you encounter problems on any compilers, feel free to let me know and I may
1739	try to fix it if the compiler is modern and standards compliant.
1740
1741
1742	10. examples
1743	------------
1744
1745	This decoder example shows the most basic usage of LodePNG. More complex
1746	examples can be found on the LodePNG website.
1747
1748	NOTE: these examples do not support wide-character filenames, you can use an
1749	external method to handle such files and encode or decode in-memory
1750
1751	10.1. decoder C++ example
1752	-------------------------
1753
1754	#include "lodepng.h"
1755	#include <iostream>
1756
1757	int main(int argc, char argv[]) {*
1758	const char filename = argc > 1 ? argv[1] : "test.png";*
1759
1760	//load and decode
1761	std::vector<unsigned char> image;
1762	unsigned width, height;
1763	unsigned error = lodepng::decode(image, width, height, filename);
1764
1765	//if there's an error, display it
1766	if(error) std::cout << "decoder error " << error << ": " << lodepng_error_text(error) << std::endl;
1767
1768	//the pixels are now in the vector "image", 4 bytes per pixel, ordered RGBARGBA..., use it as texture, draw it, ...
1769	}
1770
1771	10.2. decoder C example
1772	-----------------------
1773
1774	#include "lodepng.h"
1775
1776	int main(int argc, char argv[]) {*
1777	unsigned error;
1778	unsigned char image;*
1779	size_t width, height;
1780	const char filename = argc > 1 ? argv[1] : "test.png";*
1781
1782	error = lodepng_decode32_file(&image, &width, &height, filename);
1783
1784	if(error) printf("decoder error %u: %s\n", error, lodepng_error_text(error));
1785
1786	/ use image here * /*
1787
1788	free(image);
1789	return 0;
1790	}
1791
1792	11. state settings reference
1793	----------------------------
1794
1795	A quick reference of some settings to set on the LodePNGState
1796
1797	For decoding:
1798
1799	state.decoder.zlibsettings.ignore_adler32: ignore ADLER32 checksums
1800	state.decoder.zlibsettings.custom_...: use custom inflate function
1801	state.decoder.ignore_crc: ignore CRC checksums
1802	state.decoder.ignore_critical: ignore unknown critical chunks
1803	state.decoder.ignore_end: ignore missing IEND chunk. May fail if this corruption causes other errors
1804	state.decoder.color_convert: convert internal PNG color to chosen one
1805	state.decoder.read_text_chunks: whether to read in text metadata chunks
1806	state.decoder.remember_unknown_chunks: whether to read in unknown chunks
1807	state.info_raw.colortype: desired color type for decoded image
1808	state.info_raw.bitdepth: desired bit depth for decoded image
1809	state.info_raw....: more color settings, see struct LodePNGColorMode
1810	state.info_png....: no settings for decoder but ouput, see struct LodePNGInfo
1811
1812	For encoding:
1813
1814	state.encoder.zlibsettings.btype: disable compression by setting it to 0
1815	state.encoder.zlibsettings.use_lz77: use LZ77 in compression
1816	state.encoder.zlibsettings.windowsize: tweak LZ77 windowsize
1817	state.encoder.zlibsettings.minmatch: tweak min LZ77 length to match
1818	state.encoder.zlibsettings.nicematch: tweak LZ77 match where to stop searching
1819	state.encoder.zlibsettings.lazymatching: try one more LZ77 matching
1820	state.encoder.zlibsettings.custom_...: use custom deflate function
1821	state.encoder.auto_convert: choose optimal PNG color type, if 0 uses info_png
1822	state.encoder.filter_palette_zero: PNG filter strategy for palette
1823	state.encoder.filter_strategy: PNG filter strategy to encode with
1824	state.encoder.force_palette: add palette even if not encoding to one
1825	state.encoder.add_id: add LodePNG identifier and version as a text chunk
1826	state.encoder.text_compression: use compressed text chunks for metadata
1827	state.info_raw.colortype: color type of raw input image you provide
1828	state.info_raw.bitdepth: bit depth of raw input image you provide
1829	state.info_raw: more color settings, see struct LodePNGColorMode
1830	state.info_png.color.colortype: desired color type if auto_convert is false
1831	state.info_png.color.bitdepth: desired bit depth if auto_convert is false
1832	state.info_png.color....: more color settings, see struct LodePNGColorMode
1833	state.info_png....: more PNG related settings, see struct LodePNGInfo
1834
1835
1836	12. changes
1837	-----------
1838
1839	The version number of LodePNG is the date of the change given in the format
1840	yyyymmdd.
1841
1842	Some changes aren't backwards compatible. Those are indicated with a (!)
1843	symbol.
1844
1845	Not all changes are listed here, the commit history in github lists more:
1846	https://github.com/lvandeve/lodepng
1847
1848	*) 27 jun 2021: added warnings that file reading/writing functions don't support
1849	wide-character filenames (support for this is not planned, opening files is
1850	not the core part of PNG decoding/decoding and is platform dependent).
1851	*) 17 okt 2020: prevent decoding too large text/icc chunks by default.
1852	*) 06 mar 2020: simplified some of the dynamic memory allocations.
1853	*) 12 jan 2020: (!) added 'end' argument to lodepng_chunk_next to allow correct
1854	overflow checks.
1855	*) 14 aug 2019: around 25% faster decoding thanks to huffman lookup tables.
1856	*) 15 jun 2019: (!) auto_choose_color API changed (for bugfix: don't use palette
1857	if gray ICC profile) and non-ICC LodePNGColorProfile renamed to
1858	LodePNGColorStats.
1859	*) 30 dec 2018: code style changes only: removed newlines before opening braces.
1860	*) 10 sep 2018: added way to inspect metadata chunks without full decoding.
1861	*) 19 aug 2018: (!) fixed color mode bKGD is encoded with and made it use
1862	palette index in case of palette.
1863	*) 10 aug 2018: (!) added support for gAMA, cHRM, sRGB and iCCP chunks. This
1864	change is backwards compatible unless you relied on unknown_chunks for those.
1865	*) 11 jun 2018: less restrictive check for pixel size integer overflow
1866	*) 14 jan 2018: allow optionally ignoring a few more recoverable errors
1867	*) 17 sep 2017: fix memory leak for some encoder input error cases
1868	*) 27 nov 2016: grey+alpha auto color model detection bugfix
1869	*) 18 apr 2016: Changed qsort to custom stable sort (for platforms w/o qsort).
1870	*) 09 apr 2016: Fixed colorkey usage detection, and better file loading (within
1871	the limits of pure C90).
1872	*) 08 dec 2015: Made load_file function return error if file can't be opened.
1873	*) 24 okt 2015: Bugfix with decoding to palette output.
1874	*) 18 apr 2015: Boundary PM instead of just package-merge for faster encoding.
1875	*) 24 aug 2014: Moved to github
1876	*) 23 aug 2014: Reduced needless memory usage of decoder.
1877	*) 28 jun 2014: Removed fix_png setting, always support palette OOB for
1878	simplicity. Made ColorProfile public.
1879	*) 09 jun 2014: Faster encoder by fixing hash bug and more zeros optimization.
1880	*) 22 dec 2013: Power of two windowsize required for optimization.
1881	*) 15 apr 2013: Fixed bug with LAC_ALPHA and color key.
1882	*) 25 mar 2013: Added an optional feature to ignore some PNG errors (fix_png).
1883	*) 11 mar 2013: (!) Bugfix with custom free. Changed from "my" to "lodepng_"
1884	prefix for the custom allocators and made it possible with a new #define to
1885	use custom ones in your project without needing to change lodepng's code.
1886	*) 28 jan 2013: Bugfix with color key.
1887	*) 27 okt 2012: Tweaks in text chunk keyword length error handling.
1888	*) 8 okt 2012: (!) Added new filter strategy (entropy) and new auto color mode.
1889	(no palette). Better deflate tree encoding. New compression tweak settings.
1890	Faster color conversions while decoding. Some internal cleanups.
1891	*) 23 sep 2012: Reduced warnings in Visual Studio a little bit.
1892	*) 1 sep 2012: (!) Removed #define's for giving custom (de)compression functions
1893	and made it work with function pointers instead.
1894	*) 23 jun 2012: Added more filter strategies. Made it easier to use custom alloc
1895	and free functions and toggle #defines from compiler flags. Small fixes.
1896	*) 6 may 2012: (!) Made plugging in custom zlib/deflate functions more flexible.
1897	*) 22 apr 2012: (!) Made interface more consistent, renaming a lot. Removed
1898	redundant C++ codec classes. Reduced amount of structs. Everything changed,
1899	but it is cleaner now imho and functionality remains the same. Also fixed
1900	several bugs and shrunk the implementation code. Made new samples.
1901	*) 6 nov 2011: (!) By default, the encoder now automatically chooses the best
1902	PNG color model and bit depth, based on the amount and type of colors of the
1903	raw image. For this, autoLeaveOutAlphaChannel replaced by auto_choose_color.
1904	*) 9 okt 2011: simpler hash chain implementation for the encoder.
1905	*) 8 sep 2011: lz77 encoder lazy matching instead of greedy matching.
1906	*) 23 aug 2011: tweaked the zlib compression parameters after benchmarking.
1907	A bug with the PNG filtertype heuristic was fixed, so that it chooses much
1908	better ones (it's quite significant). A setting to do an experimental, slow,
1909	brute force search for PNG filter types is added.
1910	*) 17 aug 2011: (!) changed some C zlib related function names.
1911	*) 16 aug 2011: made the code less wide (max 120 characters per line).
1912	*) 17 apr 2011: code cleanup. Bugfixes. Convert low to 16-bit per sample colors.
1913	*) 21 feb 2011: fixed compiling for C90. Fixed compiling with sections disabled.
1914	*) 11 dec 2010: encoding is made faster, based on suggestion by Peter Eastman
1915	to optimize long sequences of zeros.
1916	*) 13 nov 2010: added LodePNG_InfoColor_hasPaletteAlpha and
1917	LodePNG_InfoColor_canHaveAlpha functions for convenience.
1918	*) 7 nov 2010: added LodePNG_error_text function to get error code description.
1919	*) 30 okt 2010: made decoding slightly faster
1920	*) 26 okt 2010: (!) changed some C function and struct names (more consistent).
1921	Reorganized the documentation and the declaration order in the header.
1922	*) 08 aug 2010: only changed some comments and external samples.
1923	*) 05 jul 2010: fixed bug thanks to warnings in the new gcc version.
1924	*) 14 mar 2010: fixed bug where too much memory was allocated for char buffers.
1925	*) 02 sep 2008: fixed bug where it could create empty tree that linux apps could
1926	read by ignoring the problem but windows apps couldn't.
1927	*) 06 jun 2008: added more error checks for out of memory cases.
1928	*) 26 apr 2008: added a few more checks here and there to ensure more safety.
1929	*) 06 mar 2008: crash with encoding of strings fixed
1930	*) 02 feb 2008: support for international text chunks added (iTXt)
1931	*) 23 jan 2008: small cleanups, and #defines to divide code in sections
1932	*) 20 jan 2008: support for unknown chunks allowing using LodePNG for an editor.
1933	*) 18 jan 2008: support for tIME and pHYs chunks added to encoder and decoder.
1934	*) 17 jan 2008: ability to encode and decode compressed zTXt chunks added
1935	Also various fixes, such as in the deflate and the padding bits code.
1936	*) 13 jan 2008: Added ability to encode Adam7-interlaced images. Improved
1937	filtering code of encoder.
1938	*) 07 jan 2008: (!) changed LodePNG to use ISO C90 instead of C++. A
1939	C++ wrapper around this provides an interface almost identical to before.
1940	Having LodePNG be pure ISO C90 makes it more portable. The C and C++ code
1941	are together in these files but it works both for C and C++ compilers.
1942	*) 29 dec 2007: (!) changed most integer types to unsigned int + other tweaks
1943	*) 30 aug 2007: bug fixed which makes this Borland C++ compatible
1944	*) 09 aug 2007: some VS2005 warnings removed again
1945	*) 21 jul 2007: deflate code placed in new namespace separate from zlib code
1946	*) 08 jun 2007: fixed bug with 2- and 4-bit color, and small interlaced images
1947	*) 04 jun 2007: improved support for Visual Studio 2005: crash with accessing
1948	invalid std::vector element [0] fixed, and level 3 and 4 warnings removed
1949	*) 02 jun 2007: made the encoder add a tag with version by default
1950	*) 27 may 2007: zlib and png code separated (but still in the same file),
1951	simple encoder/decoder functions added for more simple usage cases
1952	*) 19 may 2007: minor fixes, some code cleaning, new error added (error 69),
1953	moved some examples from here to lodepng_examples.cpp
1954	*) 12 may 2007: palette decoding bug fixed
1955	*) 24 apr 2007: changed the license from BSD to the zlib license
1956	*) 11 mar 2007: very simple addition: ability to encode bKGD chunks.
1957	*) 04 mar 2007: (!) tEXt chunk related fixes, and support for encoding
1958	palettized PNG images. Plus little interface change with palette and texts.
1959	*) 03 mar 2007: Made it encode dynamic Huffman shorter with repeat codes.
1960	Fixed a bug where the end code of a block had length 0 in the Huffman tree.
1961	*) 26 feb 2007: Huffman compression with dynamic trees (BTYPE 2) now implemented
1962	and supported by the encoder, resulting in smaller PNGs at the output.
1963	*) 27 jan 2007: Made the Adler-32 test faster so that a timewaste is gone.
1964	*) 24 jan 2007: gave encoder an error interface. Added color conversion from any
1965	greyscale type to 8-bit greyscale with or without alpha.
1966	*) 21 jan 2007: (!) Totally changed the interface. It allows more color types
1967	to convert to and is more uniform. See the manual for how it works now.
1968	*) 07 jan 2007: Some cleanup & fixes, and a few changes over the last days:
1969	encode/decode custom tEXt chunks, separate classes for zlib & deflate, and
1970	at last made the decoder give errors for incorrect Adler32 or Crc.
1971	*) 01 jan 2007: Fixed bug with encoding PNGs with less than 8 bits per channel.
1972	*) 29 dec 2006: Added support for encoding images without alpha channel, and
1973	cleaned out code as well as making certain parts faster.
1974	*) 28 dec 2006: Added "Settings" to the encoder.
1975	*) 26 dec 2006: The encoder now does LZ77 encoding and produces much smaller files now.
1976	Removed some code duplication in the decoder. Fixed little bug in an example.
1977	*) 09 dec 2006: (!) Placed output parameters of public functions as first parameter.
1978	Fixed a bug of the decoder with 16-bit per color.
1979	*) 15 okt 2006: Changed documentation structure
1980	*) 09 okt 2006: Encoder class added. It encodes a valid PNG image from the
1981	given image buffer, however for now it's not compressed.
1982	*) 08 sep 2006: (!) Changed to interface with a Decoder class
1983	*) 30 jul 2006: (!) LodePNG_InfoPng , width and height are now retrieved in different
1984	way. Renamed decodePNG to decodePNGGeneric.
1985	*) 29 jul 2006: (!) Changed the interface: image info is now returned as a
1986	struct of type LodePNG::LodePNG_Info, instead of a vector, which was a bit clumsy.
1987	*) 28 jul 2006: Cleaned the code and added new error checks.
1988	Corrected terminology "deflate" into "inflate".
1989	*) 23 jun 2006: Added SDL example in the documentation in the header, this
1990	example allows easy debugging by displaying the PNG and its transparency.
1991	*) 22 jun 2006: (!) Changed way to obtain error value. Added
1992	loadFile function for convenience. Made decodePNG32 faster.
1993	*) 21 jun 2006: (!) Changed type of info vector to unsigned.
1994	Changed position of palette in info vector. Fixed an important bug that
1995	happened on PNGs with an uncompressed block.
1996	*) 16 jun 2006: Internally changed unsigned into unsigned where
1997	needed, and performed some optimizations.
1998	*) 07 jun 2006: (!) Renamed functions to decodePNG and placed them
1999	in LodePNG namespace. Changed the order of the parameters. Rewrote the
2000	documentation in the header. Renamed files to lodepng.cpp and lodepng.h
2001	*) 22 apr 2006: Optimized and improved some code
2002	*) 07 sep 2005: (!) Changed to std::vector interface
2003	*) 12 aug 2005: Initial release (C++, decoder only)
2004
2005
2006	13. contact information
2007	-----------------------
2008
2009	Feel free to contact me with suggestions, problems, comments, ... concerning
2010	LodePNG. If you encounter a PNG image that doesn't work properly with this
2011	decoder, feel free to send it and I'll use it to find and fix the problem.
2012
2013	My email address is (puzzle the account and domain together with an @ symbol):
2014	Domain: gmail dot com.
2015	Account: lode dot vandevenne.
2016
2017
2018	Copyright (c) 2005-2021 Lode Vandevenne
2019	*/
2020

Browse the source code of LOVE/libraries/lodepng/lodepng.h