2 LodePNG version 20130415
4 Copyright (c) 2005-2013 Lode Vandevenne
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.
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:
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.
19 2. Altered source versions must be plainly marked as such, and must not be
20 misrepresented as being the original software.
22 3. This notice may not be removed or altered from any source
29 #include <string.h> /*for size_t*/
31 // Below two lines required for GNU-EFI (program hangs when run without them,
32 // and associated function in lodepng_xtra.c)
33 int MyStrlen(const char *InString
);
34 #define strlen(c) MyStrlen(c)
39 #endif /*__cplusplus*/
42 The following #defines are used to create code sections. They can be disabled
43 to disable code sections, which can give faster compile time and smaller binary.
44 The "NO_COMPILE" defines are designed to be used to pass as defines to the
45 compiler command to disable them without modifying this header, e.g.
46 -DLODEPNG_NO_COMPILE_ZLIB for gcc.
48 /*deflate & zlib. If disabled, you must specify alternative zlib functions in
49 the custom_zlib field of the compress and decompress settings*/
50 #ifndef LODEPNG_NO_COMPILE_ZLIB
51 #define LODEPNG_COMPILE_ZLIB
53 /*png encoder and png decoder*/
54 #ifndef LODEPNG_NO_COMPILE_PNG
55 #define LODEPNG_COMPILE_PNG
57 /*deflate&zlib decoder and png decoder*/
58 #ifndef LODEPNG_NO_COMPILE_DECODER
59 #define LODEPNG_COMPILE_DECODER
61 /*deflate&zlib encoder and png encoder*/
62 // #ifndef LODEPNG_NO_COMPILE_ENCODER
63 // #define LODEPNG_COMPILE_ENCODER
65 /*the optional built in harddisk file loading and saving functions*/
66 // #ifndef LODEPNG_NO_COMPILE_DISK
67 // #define LODEPNG_COMPILE_DISK
69 /*support for chunks other than IHDR, IDAT, PLTE, tRNS, IEND: ancillary and unknown chunks*/
70 // #ifndef LODEPNG_NO_COMPILE_ANCILLARY_CHUNKS
71 // #define LODEPNG_COMPILE_ANCILLARY_CHUNKS
73 /*ability to convert error numerical codes to English text string*/
74 // #ifndef LODEPNG_NO_COMPILE_ERROR_TEXT
75 // #define LODEPNG_COMPILE_ERROR_TEXT
77 /*Compile the default allocators (C's free, malloc and realloc). If you disable this,
78 you can define the functions lodepng_free, lodepng_malloc and lodepng_realloc in your
79 source files with custom allocators.*/
80 // #ifndef LODEPNG_NO_COMPILE_ALLOCATORS
81 // #define LODEPNG_COMPILE_ALLOCATORS
83 /*compile the C++ version (you can disable the C++ wrapper here even when compiling for C++)*/
85 #ifndef LODEPNG_NO_COMPILE_CPP
86 #define LODEPNG_COMPILE_CPP
90 #ifdef LODEPNG_COMPILE_PNG
91 /*The PNG color types (also used for raw).*/
92 typedef enum LodePNGColorType
94 LCT_GREY
= 0, /*greyscale: 1,2,4,8,16 bit*/
95 LCT_RGB
= 2, /*RGB: 8,16 bit*/
96 LCT_PALETTE
= 3, /*palette: 1,2,4,8 bit*/
97 LCT_GREY_ALPHA
= 4, /*greyscale with alpha: 8,16 bit*/
98 LCT_RGBA
= 6 /*RGB with alpha: 8,16 bit*/
101 #ifdef LODEPNG_COMPILE_DECODER
103 Converts PNG data in memory to raw pixel data.
104 out: Output parameter. Pointer to buffer that will contain the raw pixel data.
105 After decoding, its size is w * h * (bytes per pixel) bytes larger than
106 initially. Bytes per pixel depends on colortype and bitdepth.
107 Must be freed after usage with free(*out).
108 Note: for 16-bit per channel colors, uses big endian format like PNG does.
109 w: Output parameter. Pointer to width of pixel data.
110 h: Output parameter. Pointer to height of pixel data.
111 in: Memory buffer with the PNG file.
112 insize: size of the in buffer.
113 colortype: the desired color type for the raw output image. See explanation on PNG color types.
114 bitdepth: the desired bit depth for the raw output image. See explanation on PNG color types.
115 Return value: LodePNG error code (0 means no error).
117 unsigned lodepng_decode_memory(unsigned char** out
, unsigned* w
, unsigned* h
,
118 const unsigned char* in
, size_t insize
,
119 LodePNGColorType colortype
, unsigned bitdepth
);
121 /*Same as lodepng_decode_memory, but always decodes to 32-bit RGBA raw image*/
122 unsigned lodepng_decode32(unsigned char** out
, unsigned* w
, unsigned* h
,
123 const unsigned char* in
, size_t insize
);
125 /*Same as lodepng_decode_memory, but always decodes to 24-bit RGB raw image*/
126 unsigned lodepng_decode24(unsigned char** out
, unsigned* w
, unsigned* h
,
127 const unsigned char* in
, size_t insize
);
129 #ifdef LODEPNG_COMPILE_DISK
131 Load PNG from disk, from file with given name.
132 Same as the other decode functions, but instead takes a filename as input.
134 unsigned lodepng_decode_file(unsigned char** out
, unsigned* w
, unsigned* h
,
135 const char* filename
,
136 LodePNGColorType colortype
, unsigned bitdepth
);
138 /*Same as lodepng_decode_file, but always decodes to 32-bit RGBA raw image.*/
139 unsigned lodepng_decode32_file(unsigned char** out
, unsigned* w
, unsigned* h
,
140 const char* filename
);
142 /*Same as lodepng_decode_file, but always decodes to 24-bit RGB raw image.*/
143 unsigned lodepng_decode24_file(unsigned char** out
, unsigned* w
, unsigned* h
,
144 const char* filename
);
145 #endif /*LODEPNG_COMPILE_DISK*/
146 #endif /*LODEPNG_COMPILE_DECODER*/
149 #ifdef LODEPNG_COMPILE_ENCODER
151 Converts raw pixel data into a PNG image in memory. The colortype and bitdepth
152 of the output PNG image cannot be chosen, they are automatically determined
153 by the colortype, bitdepth and content of the input pixel data.
154 Note: for 16-bit per channel colors, needs big endian format like PNG does.
155 out: Output parameter. Pointer to buffer that will contain the PNG image data.
156 Must be freed after usage with free(*out).
157 outsize: Output parameter. Pointer to the size in bytes of the out buffer.
158 image: The raw pixel data to encode. The size of this buffer should be
159 w * h * (bytes per pixel), bytes per pixel depends on colortype and bitdepth.
160 w: width of the raw pixel data in pixels.
161 h: height of the raw pixel data in pixels.
162 colortype: the color type of the raw input image. See explanation on PNG color types.
163 bitdepth: the bit depth of the raw input image. See explanation on PNG color types.
164 Return value: LodePNG error code (0 means no error).
166 unsigned lodepng_encode_memory(unsigned char** out
, size_t* outsize
,
167 const unsigned char* image
, unsigned w
, unsigned h
,
168 LodePNGColorType colortype
, unsigned bitdepth
);
170 /*Same as lodepng_encode_memory, but always encodes from 32-bit RGBA raw image.*/
171 unsigned lodepng_encode32(unsigned char** out
, size_t* outsize
,
172 const unsigned char* image
, unsigned w
, unsigned h
);
174 /*Same as lodepng_encode_memory, but always encodes from 24-bit RGB raw image.*/
175 unsigned lodepng_encode24(unsigned char** out
, size_t* outsize
,
176 const unsigned char* image
, unsigned w
, unsigned h
);
178 #ifdef LODEPNG_COMPILE_DISK
180 Converts raw pixel data into a PNG file on disk.
181 Same as the other encode functions, but instead takes a filename as output.
182 NOTE: This overwrites existing files without warning!
184 unsigned lodepng_encode_file(const char* filename
,
185 const unsigned char* image
, unsigned w
, unsigned h
,
186 LodePNGColorType colortype
, unsigned bitdepth
);
188 /*Same as lodepng_encode_file, but always encodes from 32-bit RGBA raw image.*/
189 unsigned lodepng_encode32_file(const char* filename
,
190 const unsigned char* image
, unsigned w
, unsigned h
);
192 /*Same as lodepng_encode_file, but always encodes from 24-bit RGB raw image.*/
193 unsigned lodepng_encode24_file(const char* filename
,
194 const unsigned char* image
, unsigned w
, unsigned h
);
195 #endif /*LODEPNG_COMPILE_DISK*/
196 #endif /*LODEPNG_COMPILE_ENCODER*/
199 #ifdef LODEPNG_COMPILE_CPP
202 #ifdef LODEPNG_COMPILE_DECODER
203 /*Same as lodepng_decode_memory, but decodes to an std::vector.*/
204 unsigned decode(std::vector
<unsigned char>& out
, unsigned& w
, unsigned& h
,
205 const unsigned char* in
, size_t insize
,
206 LodePNGColorType colortype
= LCT_RGBA
, unsigned bitdepth
= 8);
207 unsigned decode(std::vector
<unsigned char>& out
, unsigned& w
, unsigned& h
,
208 const std::vector
<unsigned char>& in
,
209 LodePNGColorType colortype
= LCT_RGBA
, unsigned bitdepth
= 8);
210 #ifdef LODEPNG_COMPILE_DISK
212 Converts PNG file from disk to raw pixel data in memory.
213 Same as the other decode functions, but instead takes a filename as input.
215 unsigned decode(std::vector
<unsigned char>& out
, unsigned& w
, unsigned& h
,
216 const std::string
& filename
,
217 LodePNGColorType colortype
= LCT_RGBA
, unsigned bitdepth
= 8);
218 #endif //LODEPNG_COMPILE_DISK
219 #endif //LODEPNG_COMPILE_DECODER
221 #ifdef LODEPNG_COMPILE_ENCODER
222 /*Same as lodepng_encode_memory, but encodes to an std::vector.*/
223 unsigned encode(std::vector
<unsigned char>& out
,
224 const unsigned char* in
, unsigned w
, unsigned h
,
225 LodePNGColorType colortype
= LCT_RGBA
, unsigned bitdepth
= 8);
226 unsigned encode(std::vector
<unsigned char>& out
,
227 const std::vector
<unsigned char>& in
, unsigned w
, unsigned h
,
228 LodePNGColorType colortype
= LCT_RGBA
, unsigned bitdepth
= 8);
229 #ifdef LODEPNG_COMPILE_DISK
231 Converts 32-bit RGBA raw pixel data into a PNG file on disk.
232 Same as the other encode functions, but instead takes a filename as output.
233 NOTE: This overwrites existing files without warning!
235 unsigned encode(const std::string
& filename
,
236 const unsigned char* in
, unsigned w
, unsigned h
,
237 LodePNGColorType colortype
= LCT_RGBA
, unsigned bitdepth
= 8);
238 unsigned encode(const std::string
& filename
,
239 const std::vector
<unsigned char>& in
, unsigned w
, unsigned h
,
240 LodePNGColorType colortype
= LCT_RGBA
, unsigned bitdepth
= 8);
241 #endif //LODEPNG_COMPILE_DISK
242 #endif //LODEPNG_COMPILE_ENCODER
243 } //namespace lodepng
244 #endif /*LODEPNG_COMPILE_CPP*/
245 #endif /*LODEPNG_COMPILE_PNG*/
247 #ifdef LODEPNG_COMPILE_ERROR_TEXT
248 /*Returns an English description of the numerical error code.*/
249 const char* lodepng_error_text(unsigned code
);
250 #endif /*LODEPNG_COMPILE_ERROR_TEXT*/
252 #ifdef LODEPNG_COMPILE_DECODER
253 /*Settings for zlib decompression*/
254 typedef struct LodePNGDecompressSettings LodePNGDecompressSettings
;
255 struct LodePNGDecompressSettings
257 unsigned ignore_adler32
; /*if 1, continue and don't give an error message if the Adler32 checksum is corrupted*/
259 /*use custom zlib decoder instead of built in one (default: null)*/
260 unsigned (*custom_zlib
)(unsigned char**, size_t*,
261 const unsigned char*, size_t,
262 const LodePNGDecompressSettings
*);
263 /*use custom deflate decoder instead of built in one (default: null)
264 if custom_zlib is used, custom_deflate is ignored since only the built in
265 zlib function will call custom_deflate*/
266 unsigned (*custom_inflate
)(unsigned char**, size_t*,
267 const unsigned char*, size_t,
268 const LodePNGDecompressSettings
*);
270 void* custom_context
; /*optional custom settings for custom functions*/
273 extern const LodePNGDecompressSettings lodepng_default_decompress_settings
;
274 void lodepng_decompress_settings_init(LodePNGDecompressSettings
* settings
);
275 #endif /*LODEPNG_COMPILE_DECODER*/
277 #ifdef LODEPNG_COMPILE_ENCODER
279 Settings for zlib compression. Tweaking these settings tweaks the balance
280 between speed and compression ratio.
282 typedef struct LodePNGCompressSettings LodePNGCompressSettings
;
283 struct LodePNGCompressSettings
/*deflate = compress*/
285 /*LZ77 related settings*/
286 unsigned btype
; /*the block type for LZ (0, 1, 2 or 3, see zlib standard). Should be 2 for proper compression.*/
287 unsigned use_lz77
; /*whether or not to use LZ77. Should be 1 for proper compression.*/
288 unsigned windowsize
; /*the maximum is 32768, higher gives more compression but is slower. Typical value: 2048.*/
289 unsigned minmatch
; /*mininum lz77 length. 3 is normally best, 6 can be better for some PNGs. Default: 0*/
290 unsigned nicematch
; /*stop searching if >= this length found. Set to 258 for best compression. Default: 128*/
291 unsigned lazymatching
; /*use lazy matching: better compression but a bit slower. Default: true*/
293 /*use custom zlib encoder instead of built in one (default: null)*/
294 unsigned (*custom_zlib
)(unsigned char**, size_t*,
295 const unsigned char*, size_t,
296 const LodePNGCompressSettings
*);
297 /*use custom deflate encoder instead of built in one (default: null)
298 if custom_zlib is used, custom_deflate is ignored since only the built in
299 zlib function will call custom_deflate*/
300 unsigned (*custom_deflate
)(unsigned char**, size_t*,
301 const unsigned char*, size_t,
302 const LodePNGCompressSettings
*);
304 void* custom_context
; /*optional custom settings for custom functions*/
307 extern const LodePNGCompressSettings lodepng_default_compress_settings
;
308 void lodepng_compress_settings_init(LodePNGCompressSettings
* settings
);
309 #endif /*LODEPNG_COMPILE_ENCODER*/
311 #ifdef LODEPNG_COMPILE_PNG
313 Color mode of an image. Contains all information required to decode the pixel
314 bits to RGBA colors. This information is the same as used in the PNG file
315 format, and is used both for PNG and raw image data in LodePNG.
317 typedef struct LodePNGColorMode
320 LodePNGColorType colortype
; /*color type, see PNG standard or documentation further in this header file*/
321 unsigned bitdepth
; /*bits per sample, see PNG standard or documentation further in this header file*/
324 palette (PLTE and tRNS)
326 Dynamically allocated with the colors of the palette, including alpha.
327 When encoding a PNG, to store your colors in the palette of the LodePNGColorMode, first use
328 lodepng_palette_clear, then for each color use lodepng_palette_add.
329 If you encode an image without alpha with palette, don't forget to put value 255 in each A byte of the palette.
331 When decoding, by default you can ignore this palette, since LodePNG already
332 fills the palette colors in the pixels of the raw RGBA output.
334 The palette is only supported for color type 3.
336 unsigned char* palette
; /*palette in RGBARGBA... order. When allocated, must be either 0, or have size 1024*/
337 size_t palettesize
; /*palette size in number of colors (amount of bytes is 4 * palettesize)*/
340 transparent color key (tRNS)
342 This color uses the same bit depth as the bitdepth value in this struct, which can be 1-bit to 16-bit.
343 For greyscale PNGs, r, g and b will all 3 be set to the same.
345 When decoding, by default you can ignore this information, since LodePNG sets
346 pixels with this key to transparent already in the raw RGBA output.
348 The color key is only supported for color types 0 and 2.
350 unsigned key_defined
; /*is a transparent color key given? 0 = false, 1 = true*/
351 unsigned key_r
; /*red/greyscale component of color key*/
352 unsigned key_g
; /*green component of color key*/
353 unsigned key_b
; /*blue component of color key*/
356 /*init, cleanup and copy functions to use with this struct*/
357 void lodepng_color_mode_init(LodePNGColorMode
* info
);
358 void lodepng_color_mode_cleanup(LodePNGColorMode
* info
);
359 /*return value is error code (0 means no error)*/
360 unsigned lodepng_color_mode_copy(LodePNGColorMode
* dest
, const LodePNGColorMode
* source
);
362 void lodepng_palette_clear(LodePNGColorMode
* info
);
363 /*add 1 color to the palette*/
364 unsigned lodepng_palette_add(LodePNGColorMode
* info
,
365 unsigned char r
, unsigned char g
, unsigned char b
, unsigned char a
);
367 /*get the total amount of bits per pixel, based on colortype and bitdepth in the struct*/
368 unsigned lodepng_get_bpp(const LodePNGColorMode
* info
);
369 /*get the amount of color channels used, based on colortype in the struct.
370 If a palette is used, it counts as 1 channel.*/
371 unsigned lodepng_get_channels(const LodePNGColorMode
* info
);
372 /*is it a greyscale type? (only colortype 0 or 4)*/
373 unsigned lodepng_is_greyscale_type(const LodePNGColorMode
* info
);
374 /*has it got an alpha channel? (only colortype 2 or 6)*/
375 unsigned lodepng_is_alpha_type(const LodePNGColorMode
* info
);
376 /*has it got a palette? (only colortype 3)*/
377 unsigned lodepng_is_palette_type(const LodePNGColorMode
* info
);
378 /*only returns true if there is a palette and there is a value in the palette with alpha < 255.
379 Loops through the palette to check this.*/
380 unsigned lodepng_has_palette_alpha(const LodePNGColorMode
* info
);
382 Check if the given color info indicates the possibility of having non-opaque pixels in the PNG image.
383 Returns true if the image can have translucent or invisible pixels (it still be opaque if it doesn't use such pixels).
384 Returns false if the image can only have opaque pixels.
385 In detail, it returns true only if it's a color type with alpha, or has a palette with non-opaque values,
386 or if "key_defined" is true.
388 unsigned lodepng_can_have_alpha(const LodePNGColorMode
* info
);
389 /*Returns the byte size of a raw image buffer with given width, height and color mode*/
390 size_t lodepng_get_raw_size(unsigned w
, unsigned h
, const LodePNGColorMode
* color
);
392 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
393 /*The information of a Time chunk in PNG.*/
394 typedef struct LodePNGTime
396 unsigned year
; /*2 bytes used (0-65535)*/
397 unsigned month
; /*1-12*/
398 unsigned day
; /*1-31*/
399 unsigned hour
; /*0-23*/
400 unsigned minute
; /*0-59*/
401 unsigned second
; /*0-60 (to allow for leap seconds)*/
403 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
405 /*Information about the PNG image, except pixels, width and height.*/
406 typedef struct LodePNGInfo
408 /*header (IHDR), palette (PLTE) and transparency (tRNS) chunks*/
409 unsigned compression_method
;/*compression method of the original file. Always 0.*/
410 unsigned filter_method
; /*filter method of the original file*/
411 unsigned interlace_method
; /*interlace method of the original file*/
412 LodePNGColorMode color
; /*color type and bits, palette and transparency of the PNG file*/
414 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
416 suggested background color chunk (bKGD)
417 This color uses the same color mode as the PNG (except alpha channel), which can be 1-bit to 16-bit.
419 For greyscale PNGs, r, g and b will all 3 be set to the same. When encoding
420 the encoder writes the red one. For palette PNGs: When decoding, the RGB value
421 will be stored, not a palette index. But when encoding, specify the index of
422 the palette in background_r, the other two are then ignored.
424 The decoder does not use this background color to edit the color of pixels.
426 unsigned background_defined
; /*is a suggested background color given?*/
427 unsigned background_r
; /*red component of suggested background color*/
428 unsigned background_g
; /*green component of suggested background color*/
429 unsigned background_b
; /*blue component of suggested background color*/
432 non-international text chunks (tEXt and zTXt)
434 The char** arrays each contain num strings. The actual messages are in
435 text_strings, while text_keys are keywords that give a short description what
436 the actual text represents, e.g. Title, Author, Description, or anything else.
438 A keyword is minimum 1 character and maximum 79 characters long. It's
439 discouraged to use a single line length longer than 79 characters for texts.
441 Don't allocate these text buffers yourself. Use the init/cleanup functions
442 correctly and use lodepng_add_text and lodepng_clear_text.
444 size_t text_num
; /*the amount of texts in these char** buffers (there may be more texts in itext)*/
445 char** text_keys
; /*the keyword of a text chunk (e.g. "Comment")*/
446 char** text_strings
; /*the actual text*/
449 international text chunks (iTXt)
450 Similar to the non-international text chunks, but with additional strings
451 "langtags" and "transkeys".
453 size_t itext_num
; /*the amount of international texts in this PNG*/
454 char** itext_keys
; /*the English keyword of the text chunk (e.g. "Comment")*/
455 char** itext_langtags
; /*language tag for this text's language, ISO/IEC 646 string, e.g. ISO 639 language tag*/
456 char** itext_transkeys
; /*keyword translated to the international language - UTF-8 string*/
457 char** itext_strings
; /*the actual international text - UTF-8 string*/
459 /*time chunk (tIME)*/
460 unsigned time_defined
; /*set to 1 to make the encoder generate a tIME chunk*/
463 /*phys chunk (pHYs)*/
464 unsigned phys_defined
; /*if 0, there is no pHYs chunk and the values below are undefined, if 1 else there is one*/
465 unsigned phys_x
; /*pixels per unit in x direction*/
466 unsigned phys_y
; /*pixels per unit in y direction*/
467 unsigned phys_unit
; /*may be 0 (unknown unit) or 1 (metre)*/
471 There are 3 buffers, one for each position in the PNG where unknown chunks can appear
472 each buffer contains all unknown chunks for that position consecutively
473 The 3 buffers are the unknown chunks between certain critical chunks:
474 0: IHDR-PLTE, 1: PLTE-IDAT, 2: IDAT-IEND
475 Do not allocate or traverse this data yourself. Use the chunk traversing functions declared
476 later, such as lodepng_chunk_next and lodepng_chunk_append, to read/write this struct.
478 unsigned char* unknown_chunks_data
[3];
479 size_t unknown_chunks_size
[3]; /*size in bytes of the unknown chunks, given for protection*/
480 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
483 /*init, cleanup and copy functions to use with this struct*/
484 void lodepng_info_init(LodePNGInfo
* info
);
485 void lodepng_info_cleanup(LodePNGInfo
* info
);
486 /*return value is error code (0 means no error)*/
487 unsigned lodepng_info_copy(LodePNGInfo
* dest
, const LodePNGInfo
* source
);
489 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
490 void lodepng_clear_text(LodePNGInfo
* info
); /*use this to clear the texts again after you filled them in*/
491 unsigned lodepng_add_text(LodePNGInfo
* info
, const char* key
, const char* str
); /*push back both texts at once*/
493 void lodepng_clear_itext(LodePNGInfo
* info
); /*use this to clear the itexts again after you filled them in*/
494 unsigned lodepng_add_itext(LodePNGInfo
* info
, const char* key
, const char* langtag
,
495 const char* transkey
, const char* str
); /*push back the 4 texts of 1 chunk at once*/
496 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
499 Converts raw buffer from one color type to another color type, based on
500 LodePNGColorMode structs to describe the input and output color type.
501 See the reference manual at the end of this header file to see which color conversions are supported.
502 return value = LodePNG error code (0 if all went ok, an error if the conversion isn't supported)
503 The out buffer must have size (w * h * bpp + 7) / 8, where bpp is the bits per pixel
504 of the output color type (lodepng_get_bpp)
505 The fix_png value makes it ignore out of bound palette indices.
506 Note: for 16-bit per channel colors, uses big endian format like PNG does.
508 unsigned lodepng_convert(unsigned char* out
, const unsigned char* in
,
509 LodePNGColorMode
* mode_out
, LodePNGColorMode
* mode_in
,
510 unsigned w
, unsigned h
, unsigned fix_png
);
513 #ifdef LODEPNG_COMPILE_DECODER
515 Settings for the decoder. This contains settings for the PNG and the Zlib
516 decoder, but not the Info settings from the Info structs.
518 typedef struct LodePNGDecoderSettings
520 LodePNGDecompressSettings zlibsettings
; /*in here is the setting to ignore Adler32 checksums*/
522 unsigned ignore_crc
; /*ignore CRC checksums*/
523 unsigned fix_png
; /*if 1, try to parse some broken PNG images, e.g. with out of bound palette.*/
524 unsigned color_convert
; /*whether to convert the PNG to the color type you want. Default: yes*/
526 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
527 unsigned read_text_chunks
; /*if false but remember_unknown_chunks is true, they're stored in the unknown chunks*/
528 /*store all bytes from unknown chunks in the LodePNGInfo (off by default, useful for a png editor)*/
529 unsigned remember_unknown_chunks
;
530 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
531 } LodePNGDecoderSettings
;
533 void lodepng_decoder_settings_init(LodePNGDecoderSettings
* settings
);
534 #endif /*LODEPNG_COMPILE_DECODER*/
536 #ifdef LODEPNG_COMPILE_ENCODER
537 /*automatically use color type with less bits per pixel if losslessly possible. Default: AUTO*/
538 typedef enum LodePNGFilterStrategy
540 /*every filter at zero*/
542 /*Use filter that gives minumum sum, as described in the official PNG filter heuristic.*/
544 /*Use the filter type that gives smallest Shannon entropy for this scanline. Depending
545 on the image, this is better or worse than minsum.*/
548 Brute-force-search PNG filters by compressing each filter for each scanline.
549 Experimental, very slow, and only rarely gives better compression than MINSUM.
552 /*use predefined_filters buffer: you specify the filter type for each scanline*/
554 } LodePNGFilterStrategy
;
556 /*automatically use color type with less bits per pixel if losslessly possible. Default: LAC_AUTO*/
557 typedef enum LodePNGAutoConvert
559 LAC_NO
, /*use color type user requested*/
560 LAC_ALPHA
, /*use color type user requested, but if only opaque pixels and RGBA or grey+alpha, use RGB or grey*/
561 LAC_AUTO
, /*use PNG color type that can losslessly represent the uncompressed image the smallest possible*/
563 like AUTO, but do not choose 1, 2 or 4 bit per pixel types.
564 sometimes a PNG image compresses worse if less than 8 bits per pixels.
568 like AUTO, but never choose palette color type. For small images, encoding
569 the palette may take more bytes than what is gained. Note that AUTO also
570 already prevents encoding the palette for extremely small images, but that may
571 not be sufficient because due to the compression it cannot predict when to
575 LAC_AUTO_NO_NIBBLES_NO_PALETTE
576 } LodePNGAutoConvert
;
579 /*Settings for the encoder.*/
580 typedef struct LodePNGEncoderSettings
582 LodePNGCompressSettings zlibsettings
; /*settings for the zlib encoder, such as window size, ...*/
584 LodePNGAutoConvert auto_convert
; /*how to automatically choose output PNG color type, if at all*/
586 /*If true, follows the official PNG heuristic: if the PNG uses a palette or lower than
587 8 bit depth, set all filters to zero. Otherwise use the filter_strategy. Note that to
588 completely follow the official PNG heuristic, filter_palette_zero must be true and
589 filter_strategy must be LFS_MINSUM*/
590 unsigned filter_palette_zero
;
591 /*Which filter strategy to use when not using zeroes due to filter_palette_zero.
592 Set filter_palette_zero to 0 to ensure always using your chosen strategy. Default: LFS_MINSUM*/
593 LodePNGFilterStrategy filter_strategy
;
594 /*used if filter_strategy is LFS_PREDEFINED. In that case, this must point to a buffer with
595 the same length as the amount of scanlines in the image, and each value must <= 5. You
596 have to cleanup this buffer, LodePNG will never free it. Don't forget that filter_palette_zero
597 must be set to 0 to ensure this is also used on palette or low bitdepth images.*/
598 unsigned char* predefined_filters
;
600 /*force creating a PLTE chunk if colortype is 2 or 6 (= a suggested palette).
601 If colortype is 3, PLTE is _always_ created.*/
602 unsigned force_palette
;
603 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
604 /*add LodePNG identifier and version as a text chunk, for debugging*/
606 /*encode text chunks as zTXt chunks instead of tEXt chunks, and use compression in iTXt chunks*/
607 unsigned text_compression
;
608 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
609 } LodePNGEncoderSettings
;
611 void lodepng_encoder_settings_init(LodePNGEncoderSettings
* settings
);
612 #endif /*LODEPNG_COMPILE_ENCODER*/
615 #if defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER)
616 /*The settings, state and information for extended encoding and decoding.*/
617 typedef struct LodePNGState
619 #ifdef LODEPNG_COMPILE_DECODER
620 LodePNGDecoderSettings decoder
; /*the decoding settings*/
621 #endif /*LODEPNG_COMPILE_DECODER*/
622 #ifdef LODEPNG_COMPILE_ENCODER
623 LodePNGEncoderSettings encoder
; /*the encoding settings*/
624 #endif /*LODEPNG_COMPILE_ENCODER*/
625 LodePNGColorMode info_raw
; /*specifies the format in which you would like to get the raw pixel buffer*/
626 LodePNGInfo info_png
; /*info of the PNG image obtained after decoding*/
628 #ifdef LODEPNG_COMPILE_CPP
629 //For the lodepng::State subclass.
630 virtual ~LodePNGState(){}
634 /*init, cleanup and copy functions to use with this struct*/
635 void lodepng_state_init(LodePNGState
* state
);
636 void lodepng_state_cleanup(LodePNGState
* state
);
637 void lodepng_state_copy(LodePNGState
* dest
, const LodePNGState
* source
);
638 #endif /* defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER) */
640 #ifdef LODEPNG_COMPILE_DECODER
642 Same as lodepng_decode_memory, but uses a LodePNGState to allow custom settings and
643 getting much more information about the PNG image and color mode.
645 unsigned lodepng_decode(unsigned char** out
, unsigned* w
, unsigned* h
,
647 const unsigned char* in
, size_t insize
);
650 Read the PNG header, but not the actual data. This returns only the information
651 that is in the header chunk of the PNG, such as width, height and color type. The
652 information is placed in the info_png field of the LodePNGState.
654 unsigned lodepng_inspect(unsigned* w
, unsigned* h
,
656 const unsigned char* in
, size_t insize
);
657 #endif /*LODEPNG_COMPILE_DECODER*/
660 #ifdef LODEPNG_COMPILE_ENCODER
661 /*This function allocates the out buffer with standard malloc and stores the size in *outsize.*/
662 unsigned lodepng_encode(unsigned char** out
, size_t* outsize
,
663 const unsigned char* image
, unsigned w
, unsigned h
,
664 LodePNGState
* state
);
665 #endif /*LODEPNG_COMPILE_ENCODER*/
668 The lodepng_chunk functions are normally not needed, except to traverse the
669 unknown chunks stored in the LodePNGInfo struct, or add new ones to it.
670 It also allows traversing the chunks of an encoded PNG file yourself.
672 PNG standard chunk naming conventions:
673 First byte: uppercase = critical, lowercase = ancillary
674 Second byte: uppercase = public, lowercase = private
675 Third byte: must be uppercase
676 Fourth byte: uppercase = unsafe to copy, lowercase = safe to copy
679 /*get the length of the data of the chunk. Total chunk length has 12 bytes more.*/
680 unsigned lodepng_chunk_length(const unsigned char* chunk
);
682 /*puts the 4-byte type in null terminated string*/
683 void lodepng_chunk_type(char type
[5], const unsigned char* chunk
);
685 /*check if the type is the given type*/
686 unsigned char lodepng_chunk_type_equals(const unsigned char* chunk
, const char* type
);
688 /*0: it's one of the critical chunk types, 1: it's an ancillary chunk (see PNG standard)*/
689 unsigned char lodepng_chunk_ancillary(const unsigned char* chunk
);
691 /*0: public, 1: private (see PNG standard)*/
692 unsigned char lodepng_chunk_private(const unsigned char* chunk
);
694 /*0: the chunk is unsafe to copy, 1: the chunk is safe to copy (see PNG standard)*/
695 unsigned char lodepng_chunk_safetocopy(const unsigned char* chunk
);
697 /*get pointer to the data of the chunk, where the input points to the header of the chunk*/
698 unsigned char* lodepng_chunk_data(unsigned char* chunk
);
699 const unsigned char* lodepng_chunk_data_const(const unsigned char* chunk
);
701 /*returns 0 if the crc is correct, 1 if it's incorrect (0 for OK as usual!)*/
702 unsigned lodepng_chunk_check_crc(const unsigned char* chunk
);
704 /*generates the correct CRC from the data and puts it in the last 4 bytes of the chunk*/
705 void lodepng_chunk_generate_crc(unsigned char* chunk
);
707 /*iterate to next chunks. don't use on IEND chunk, as there is no next chunk then*/
708 unsigned char* lodepng_chunk_next(unsigned char* chunk
);
709 const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk
);
712 Appends chunk to the data in out. The given chunk should already have its chunk header.
713 The out variable and outlength are updated to reflect the new reallocated buffer.
714 Returns error code (0 if it went ok)
716 unsigned lodepng_chunk_append(unsigned char** out
, size_t* outlength
, const unsigned char* chunk
);
719 Appends new chunk to out. The chunk to append is given by giving its length, type
720 and data separately. The type is a 4-letter string.
721 The out variable and outlength are updated to reflect the new reallocated buffer.
722 Returne error code (0 if it went ok)
724 unsigned lodepng_chunk_create(unsigned char** out
, size_t* outlength
, unsigned length
,
725 const char* type
, const unsigned char* data
);
728 /*Calculate CRC32 of buffer*/
729 unsigned lodepng_crc32(const unsigned char* buf
, size_t len
);
730 #endif /*LODEPNG_COMPILE_PNG*/
733 #ifdef LODEPNG_COMPILE_ZLIB
735 This zlib part can be used independently to zlib compress and decompress a
736 buffer. It cannot be used to create gzip files however, and it only supports the
737 part of zlib that is required for PNG, it does not support dictionaries.
740 #ifdef LODEPNG_COMPILE_DECODER
741 /*Inflate a buffer. Inflate is the decompression step of deflate. Out buffer must be freed after use.*/
742 unsigned lodepng_inflate(unsigned char** out
, size_t* outsize
,
743 const unsigned char* in
, size_t insize
,
744 const LodePNGDecompressSettings
* settings
);
747 Decompresses Zlib data. Reallocates the out buffer and appends the data. The
748 data must be according to the zlib specification.
749 Either, *out must be NULL and *outsize must be 0, or, *out must be a valid
750 buffer and *outsize its size in bytes. out must be freed by user after usage.
752 unsigned lodepng_zlib_decompress(unsigned char** out
, size_t* outsize
,
753 const unsigned char* in
, size_t insize
,
754 const LodePNGDecompressSettings
* settings
);
755 #endif /*LODEPNG_COMPILE_DECODER*/
757 #ifdef LODEPNG_COMPILE_ENCODER
759 Compresses data with Zlib. Reallocates the out buffer and appends the data.
760 Zlib adds a small header and trailer around the deflate data.
761 The data is output in the format of the zlib specification.
762 Either, *out must be NULL and *outsize must be 0, or, *out must be a valid
763 buffer and *outsize its size in bytes. out must be freed by user after usage.
765 unsigned lodepng_zlib_compress(unsigned char** out
, size_t* outsize
,
766 const unsigned char* in
, size_t insize
,
767 const LodePNGCompressSettings
* settings
);
770 Find length-limited Huffman code for given frequencies. This function is in the
771 public interface only for tests, it's used internally by lodepng_deflate.
773 unsigned lodepng_huffman_code_lengths(unsigned* lengths
, const unsigned* frequencies
,
774 size_t numcodes
, unsigned maxbitlen
);
776 /*Compress a buffer with deflate. See RFC 1951. Out buffer must be freed after use.*/
777 unsigned lodepng_deflate(unsigned char** out
, size_t* outsize
,
778 const unsigned char* in
, size_t insize
,
779 const LodePNGCompressSettings
* settings
);
781 #endif /*LODEPNG_COMPILE_ENCODER*/
782 #endif /*LODEPNG_COMPILE_ZLIB*/
784 #ifdef LODEPNG_COMPILE_DISK
786 Load a file from disk into buffer. The function allocates the out buffer, and
787 after usage you should free it.
788 out: output parameter, contains pointer to loaded buffer.
789 outsize: output parameter, size of the allocated out buffer
790 filename: the path to the file to load
791 return value: error code (0 means ok)
793 unsigned lodepng_load_file(unsigned char** out
, size_t* outsize
, const char* filename
);
796 Save a file from buffer to disk. Warning, if it exists, this function overwrites
797 the file without warning!
798 buffer: the buffer to write
799 buffersize: size of the buffer to write
800 filename: the path to the file to save to
801 return value: error code (0 means ok)
803 unsigned lodepng_save_file(const unsigned char* buffer
, size_t buffersize
, const char* filename
);
804 #endif /*LODEPNG_COMPILE_DISK*/
806 #ifdef LODEPNG_COMPILE_CPP
807 //The LodePNG C++ wrapper uses std::vectors instead of manually allocated memory buffers.
810 #ifdef LODEPNG_COMPILE_PNG
811 class State
: public LodePNGState
815 State(const State
& other
);
817 State
& operator=(const State
& other
);
820 #ifdef LODEPNG_COMPILE_DECODER
821 //Same as other lodepng::decode, but using a State for more settings and information.
822 unsigned decode(std::vector
<unsigned char>& out
, unsigned& w
, unsigned& h
,
824 const unsigned char* in
, size_t insize
);
825 unsigned decode(std::vector
<unsigned char>& out
, unsigned& w
, unsigned& h
,
827 const std::vector
<unsigned char>& in
);
828 #endif /*LODEPNG_COMPILE_DECODER*/
830 #ifdef LODEPNG_COMPILE_ENCODER
831 //Same as other lodepng::encode, but using a State for more settings and information.
832 unsigned encode(std::vector
<unsigned char>& out
,
833 const unsigned char* in
, unsigned w
, unsigned h
,
835 unsigned encode(std::vector
<unsigned char>& out
,
836 const std::vector
<unsigned char>& in
, unsigned w
, unsigned h
,
838 #endif /*LODEPNG_COMPILE_ENCODER*/
840 #ifdef LODEPNG_COMPILE_DISK
842 Load a file from disk into an std::vector. If the vector is empty, then either
843 the file doesn't exist or is an empty file.
845 void load_file(std::vector
<unsigned char>& buffer
, const std::string
& filename
);
848 Save the binary data in an std::vector to a file on disk. The file is overwritten
851 void save_file(const std::vector
<unsigned char>& buffer
, const std::string
& filename
);
852 #endif //LODEPNG_COMPILE_DISK
853 #endif //LODEPNG_COMPILE_PNG
855 #ifdef LODEPNG_COMPILE_ZLIB
856 #ifdef LODEPNG_COMPILE_DECODER
857 //Zlib-decompress an unsigned char buffer
858 unsigned decompress(std::vector
<unsigned char>& out
, const unsigned char* in
, size_t insize
,
859 const LodePNGDecompressSettings
& settings
= lodepng_default_decompress_settings
);
861 //Zlib-decompress an std::vector
862 unsigned decompress(std::vector
<unsigned char>& out
, const std::vector
<unsigned char>& in
,
863 const LodePNGDecompressSettings
& settings
= lodepng_default_decompress_settings
);
864 #endif //LODEPNG_COMPILE_DECODER
866 #ifdef LODEPNG_COMPILE_ENCODER
867 //Zlib-compress an unsigned char buffer
868 unsigned compress(std::vector
<unsigned char>& out
, const unsigned char* in
, size_t insize
,
869 const LodePNGCompressSettings
& settings
= lodepng_default_compress_settings
);
871 //Zlib-compress an std::vector
872 unsigned compress(std::vector
<unsigned char>& out
, const std::vector
<unsigned char>& in
,
873 const LodePNGCompressSettings
& settings
= lodepng_default_compress_settings
);
874 #endif //LODEPNG_COMPILE_ENCODER
875 #endif //LODEPNG_COMPILE_ZLIB
876 } //namespace lodepng
877 #endif /*LODEPNG_COMPILE_CPP*/
881 [.] test if there are no memory leaks or security exploits - done a lot but needs to be checked often
882 [.] check compatibility with vareous compilers - done but needs to be redone for every newer version
883 [X] converting color to 16-bit per channel types
884 [ ] read all public PNG chunk types (but never let the color profile and gamma ones touch RGB values)
885 [ ] make sure encoder generates no chunks with size > (2^31)-1
886 [ ] partial decoding (stream processing)
887 [X] let the "isFullyOpaque" function check color keys and transparent palettes too
888 [X] better name for the variables "codes", "codesD", "codelengthcodes", "clcl" and "lldl"
889 [ ] don't stop decoding on errors like 69, 57, 58 (make warnings)
890 [ ] make option to choose if the raw image with non multiple of 8 bits per scanline should have padding bits or not
891 [ ] let the C++ wrapper catch exceptions coming from the standard library and return LodePNG error codes
894 #endif /*LODEPNG_H inclusion guard*/
897 LodePNG Documentation
898 ---------------------
904 1.1. supported features
905 1.2. features not supported
912 6.2. color conversions
914 6.4. A note about 16-bits per channel and endianness
916 8. chunks and PNG editing
919 10.1. decoder C++ example
920 10.2. decoder C example
922 12. contact information
928 PNG is a file format to store raster images losslessly with good compression,
929 supporting different color types and alpha channel.
931 LodePNG is a PNG codec according to the Portable Network Graphics (PNG)
932 Specification (Second Edition) - W3C Recommendation 10 November 2003.
934 The specifications used are:
936 *) Portable Network Graphics (PNG) Specification (Second Edition):
937 http://www.w3.org/TR/2003/REC-PNG-20031110
938 *) RFC 1950 ZLIB Compressed Data Format version 3.3:
939 http://www.gzip.org/zlib/rfc-zlib.html
940 *) RFC 1951 DEFLATE Compressed Data Format Specification ver 1.3:
941 http://www.gzip.org/zlib/rfc-deflate.html
943 The most recent version of LodePNG can currently be found at
944 http://lodev.org/lodepng/
946 LodePNG works both in C (ISO C90) and C++, with a C++ wrapper that adds
949 LodePNG exists out of two files:
950 -lodepng.h: the header file for both C and C++
951 -lodepng.c(pp): give it the name lodepng.c or lodepng.cpp (or .cc) depending on your usage
953 If you want to start using LodePNG right away without reading this doc, get the
954 examples from the LodePNG website to see how to use it in code, or check the
955 smaller examples in chapter 13 here.
957 LodePNG is simple but only supports the basic requirements. To achieve
958 simplicity, the following design choices were made: There are no dependencies
959 on any external library. There are functions to decode and encode a PNG with
960 a single function call, and extended versions of these functions taking a
961 LodePNGState struct allowing to specify or get more information. By default
962 the colors of the raw image are always RGB or RGBA, no matter what color type
963 the PNG file uses. To read and write files, there are simple functions to
964 convert the files to/from buffers in memory.
966 This all makes LodePNG suitable for loading textures in games, demos and small
967 programs, ... It's less suitable for full fledged image editors, loading PNGs
968 over network (it requires all the image data to be available before decoding can
969 begin), life-critical systems, ...
971 1.1. supported features
972 -----------------------
974 The following features are supported by the decoder:
976 *) decoding of PNGs with any color type, bit depth and interlace mode, to a 24- or 32-bit color raw image,
977 or the same color type as the PNG
978 *) encoding of PNGs, from any raw image to 24- or 32-bit color, or the same color type as the raw image
979 *) Adam7 interlace and deinterlace for any color type
980 *) loading the image from harddisk or decoding it from a buffer from other sources than harddisk
981 *) support for alpha channels, including RGBA color model, translucent palettes and color keying
982 *) zlib decompression (inflate)
983 *) zlib compression (deflate)
984 *) CRC32 and ADLER32 checksums
985 *) handling of unknown chunks, allowing making a PNG editor that stores custom and unknown chunks.
986 *) the following chunks are supported (generated/interpreted) by both encoder and decoder:
987 IHDR: header information
990 IEND: the final chunk
991 tRNS: transparency for palettized images
992 tEXt: textual information
993 zTXt: compressed textual information
994 iTXt: international textual information
995 bKGD: suggested background color
996 pHYs: physical dimensions
997 tIME: modification time
999 1.2. features not supported
1000 ---------------------------
1002 The following features are _not_ supported:
1004 *) some features needed to make a conformant PNG-Editor might be still missing.
1005 *) partial loading/stream processing. All data must be available and is processed in one call.
1006 *) The following public chunks are not supported but treated as unknown chunks by LodePNG
1007 cHRM, gAMA, iCCP, sRGB, sBIT, hIST, sPLT
1008 Some of these are not supported on purpose: LodePNG wants to provide the RGB values
1009 stored in the pixels, not values modified by system dependent gamma or color models.
1012 2. C and C++ version
1013 --------------------
1015 The C version uses buffers allocated with alloc that you need to free()
1016 yourself. You need to use init and cleanup functions for each struct whenever
1017 using a struct from the C version to avoid exploits and memory leaks.
1019 The C++ version has extra functions with std::vectors in the interface and the
1020 lodepng::State class which is a LodePNGState with constructor and destructor.
1022 These files work without modification for both C and C++ compilers because all
1023 the additional C++ code is in "#ifdef __cplusplus" blocks that make C-compilers
1024 ignore it, and the C code is made to compile both with strict ISO C90 and C++.
1026 To use the C++ version, you need to rename the source file to lodepng.cpp
1027 (instead of lodepng.c), and compile it with a C++ compiler.
1029 To use the C version, you need to rename the source file to lodepng.c (instead
1030 of lodepng.cpp), and compile it with a C compiler.
1036 Even if carefully designed, it's always possible that LodePNG contains possible
1037 exploits. If you discover one, please let me know, and it will be fixed.
1039 When using LodePNG, care has to be taken with the C version of LodePNG, as well
1040 as the C-style structs when working with C++. The following conventions are used
1041 for all C-style structs:
1043 -if a struct has a corresponding init function, always call the init function when making a new one
1044 -if a struct has a corresponding cleanup function, call it before the struct disappears to avoid memory leaks
1045 -if a struct has a corresponding copy function, use the copy function instead of "=".
1046 The destination must also be inited already.
1052 Decoding converts a PNG compressed image to a raw pixel buffer.
1054 Most documentation on using the decoder is at its declarations in the header
1055 above. For C, simple decoding can be done with functions such as
1056 lodepng_decode32, and more advanced decoding can be done with the struct
1057 LodePNGState and lodepng_decode. For C++, all decoding can be done with the
1058 various lodepng::decode functions, and lodepng::State can be used for advanced
1061 When using the LodePNGState, it uses the following fields for decoding:
1062 *) LodePNGInfo info_png: it stores extra information about the PNG (the input) in here
1063 *) LodePNGColorMode info_raw: here you can say what color mode of the raw image (the output) you want to get
1064 *) LodePNGDecoderSettings decoder: you can specify a few extra settings for the decoder to use
1066 LodePNGInfo info_png
1067 --------------------
1069 After decoding, this contains extra information of the PNG image, except the actual
1070 pixels, width and height because these are already gotten directly from the decoder
1073 It contains for example the original color type of the PNG image, text comments,
1074 suggested background color, etc... More details about the LodePNGInfo struct are
1075 at its declaration documentation.
1077 LodePNGColorMode info_raw
1078 -------------------------
1080 When decoding, here you can specify which color type you want
1081 the resulting raw image to be. If this is different from the colortype of the
1082 PNG, then the decoder will automatically convert the result. This conversion
1083 always works, except if you want it to convert a color PNG to greyscale or to
1084 a palette with missing colors.
1086 By default, 32-bit color is used for the result.
1088 LodePNGDecoderSettings decoder
1089 ------------------------------
1091 The settings can be used to ignore the errors created by invalid CRC and Adler32
1092 chunks, and to disable the decoding of tEXt chunks.
1094 There's also a setting color_convert, true by default. If false, no conversion
1095 is done, the resulting data will be as it was in the PNG (after decompression)
1096 and you'll have to puzzle the colors of the pixels together yourself using the
1097 color type information in the LodePNGInfo.
1103 Encoding converts a raw pixel buffer to a PNG compressed image.
1105 Most documentation on using the encoder is at its declarations in the header
1106 above. For C, simple encoding can be done with functions such as
1107 lodepng_encode32, and more advanced decoding can be done with the struct
1108 LodePNGState and lodepng_encode. For C++, all encoding can be done with the
1109 various lodepng::encode functions, and lodepng::State can be used for advanced
1112 Like the decoder, the encoder can also give errors. However it gives less errors
1113 since the encoder input is trusted, the decoder input (a PNG image that could
1114 be forged by anyone) is not trusted.
1116 When using the LodePNGState, it uses the following fields for encoding:
1117 *) LodePNGInfo info_png: here you specify how you want the PNG (the output) to be.
1118 *) LodePNGColorMode info_raw: here you say what color type of the raw image (the input) has
1119 *) LodePNGEncoderSettings encoder: you can specify a few settings for the encoder to use
1121 LodePNGInfo info_png
1122 --------------------
1124 When encoding, you use this the opposite way as when decoding: for encoding,
1125 you fill in the values you want the PNG to have before encoding. By default it's
1126 not needed to specify a color type for the PNG since it's automatically chosen,
1127 but it's possible to choose it yourself given the right settings.
1129 The encoder will not always exactly match the LodePNGInfo struct you give,
1130 it tries as close as possible. Some things are ignored by the encoder. The
1131 encoder uses, for example, the following settings from it when applicable:
1132 colortype and bitdepth, text chunks, time chunk, the color key, the palette, the
1133 background color, the interlace method, unknown chunks, ...
1135 When encoding to a PNG with colortype 3, the encoder will generate a PLTE chunk.
1136 If the palette contains any colors for which the alpha channel is not 255 (so
1137 there are translucent colors in the palette), it'll add a tRNS chunk.
1139 LodePNGColorMode info_raw
1140 -------------------------
1142 You specify the color type of the raw image that you give to the input here,
1143 including a possible transparent color key and palette you happen to be using in
1144 your raw image data.
1146 By default, 32-bit color is assumed, meaning your input has to be in RGBA
1147 format with 4 bytes (unsigned chars) per pixel.
1149 LodePNGEncoderSettings encoder
1150 ------------------------------
1152 The following settings are supported (some are in sub-structs):
1153 *) auto_convert: when this option is enabled, the encoder will
1154 automatically choose the smallest possible color mode (including color key) that
1155 can encode the colors of all pixels without information loss.
1156 *) btype: the block type for LZ77. 0 = uncompressed, 1 = fixed huffman tree,
1157 2 = dynamic huffman tree (best compression). Should be 2 for proper
1159 *) use_lz77: whether or not to use LZ77 for compressed block types. Should be
1160 true for proper compression.
1161 *) windowsize: the window size used by the LZ77 encoder (1 - 32768). Has value
1162 2048 by default, but can be set to 32768 for better, but slow, compression.
1163 *) force_palette: if colortype is 2 or 6, you can make the encoder write a PLTE
1164 chunk if force_palette is true. This can used as suggested palette to convert
1165 to by viewers that don't support more than 256 colors (if those still exist)
1166 *) add_id: add text chunk "Encoder: LodePNG <version>" to the image.
1167 *) text_compression: default 1. If 1, it'll store texts as zTXt instead of tEXt chunks.
1168 zTXt chunks use zlib compression on the text. This gives a smaller result on
1169 large texts but a larger result on small texts (such as a single program name).
1170 It's all tEXt or all zTXt though, there's no separate setting per text yet.
1173 6. color conversions
1174 --------------------
1176 An important thing to note about LodePNG, is that the color type of the PNG, and
1177 the color type of the raw image, are completely independent. By default, when
1178 you decode a PNG, you get the result as a raw image in the color type you want,
1179 no matter whether the PNG was encoded with a palette, greyscale or RGBA color.
1180 And if you encode an image, by default LodePNG will automatically choose the PNG
1181 color type that gives good compression based on the values of colors and amount
1182 of colors in the image. It can be configured to let you control it instead as
1185 To be able to do this, LodePNG does conversions from one color mode to another.
1186 It can convert from almost any color type to any other color type, except the
1187 following conversions: RGB to greyscale is not supported, and converting to a
1188 palette when the palette doesn't have a required color is not supported. This is
1189 not supported on purpose: this is information loss which requires a color
1190 reduction algorithm that is beyong the scope of a PNG encoder (yes, RGB to grey
1191 is easy, but there are multiple ways if you want to give some channels more
1194 By default, when decoding, you get the raw image in 32-bit RGBA or 24-bit RGB
1195 color, no matter what color type the PNG has. And by default when encoding,
1196 LodePNG automatically picks the best color model for the output PNG, and expects
1197 the input image to be 32-bit RGBA or 24-bit RGB. So, unless you want to control
1198 the color format of the images yourself, you can skip this chapter.
1200 6.1. PNG color types
1201 --------------------
1203 A PNG image can have many color types, ranging from 1-bit color to 64-bit color,
1204 as well as palettized color modes. After the zlib decompression and unfiltering
1205 in the PNG image is done, the raw pixel data will have that color type and thus
1206 a certain amount of bits per pixel. If you want the output raw image after
1207 decoding to have another color type, a conversion is done by LodePNG.
1209 The PNG specification gives the following color types:
1211 0: greyscale, bit depths 1, 2, 4, 8, 16
1212 2: RGB, bit depths 8 and 16
1213 3: palette, bit depths 1, 2, 4 and 8
1214 4: greyscale with alpha, bit depths 8 and 16
1215 6: RGBA, bit depths 8 and 16
1217 Bit depth is the amount of bits per pixel per color channel. So the total amount
1218 of bits per pixel is: amount of channels * bitdepth.
1220 6.2. color conversions
1221 ----------------------
1223 As explained in the sections about the encoder and decoder, you can specify
1224 color types and bit depths in info_png and info_raw to change the default
1227 If, when decoding, you want the raw image to be something else than the default,
1228 you need to set the color type and bit depth you want in the LodePNGColorMode,
1229 or the parameters of the simple function of LodePNG you're using.
1231 If, when encoding, you use another color type than the default in the input
1232 image, you need to specify its color type and bit depth in the LodePNGColorMode
1233 of the raw image, or use the parameters of the simplefunction of LodePNG you're
1236 If, when encoding, you don't want LodePNG to choose the output PNG color type
1237 but control it yourself, you need to set auto_convert in the encoder settings
1238 to LAC_NONE, and specify the color type you want in the LodePNGInfo of the
1241 If you do any of the above, LodePNG may need to do a color conversion, which
1242 follows the rules below, and may sometimes not be allowed.
1244 To avoid some confusion:
1245 -the decoder converts from PNG to raw image
1246 -the encoder converts from raw image to PNG
1247 -the colortype and bitdepth in LodePNGColorMode info_raw, are those of the raw image
1248 -the colortype and bitdepth in the color field of LodePNGInfo info_png, are those of the PNG
1249 -when encoding, the color type in LodePNGInfo is ignored if auto_convert
1250 is enabled, it is automatically generated instead
1251 -when decoding, the color type in LodePNGInfo is set by the decoder to that of the original
1252 PNG image, but it can be ignored since the raw image has the color type you requested instead
1253 -if the color type of the LodePNGColorMode and PNG image aren't the same, a conversion
1254 between the color types is done if the color types are supported. If it is not
1255 supported, an error is returned. If the types are the same, no conversion is done.
1256 -even though some conversions aren't supported, LodePNG supports loading PNGs from any
1257 colortype and saving PNGs to any colortype, sometimes it just requires preparing
1258 the raw image correctly before encoding.
1259 -both encoder and decoder use the same color converter.
1261 Non supported color conversions:
1262 -color to greyscale: no error is thrown, but the result will look ugly because
1263 only the red channel is taken
1264 -anything, to palette when that palette does not have that color in it: in this
1265 case an error is thrown
1267 Supported color conversions:
1268 -anything to 8-bit RGB, 8-bit RGBA, 16-bit RGB, 16-bit RGBA
1269 -any grey or grey+alpha, to grey or grey+alpha
1270 -anything to a palette, as long as the palette has the requested colors in it
1271 -removing alpha channel
1272 -higher to smaller bitdepth, and vice versa
1274 If you want no color conversion to be done:
1275 -In the encoder, you can make it save a PNG with any color type by giving the
1276 raw color mode and LodePNGInfo the same color mode, and setting auto_convert to
1278 -In the decoder, you can make it store the pixel data in the same color type
1279 as the PNG has, by setting the color_convert setting to false. Settings in
1280 info_raw are then ignored.
1282 The function lodepng_convert does the color conversion. It is available in the
1283 interface but normally isn't needed since the encoder and decoder already call
1289 In the PNG file format, if a less than 8-bit per pixel color type is used and the scanlines
1290 have a bit amount that isn't a multiple of 8, then padding bits are used so that each
1291 scanline starts at a fresh byte. But that is NOT true for the LodePNG raw input and output.
1292 The raw input image you give to the encoder, and the raw output image you get from the decoder
1293 will NOT have these padding bits, e.g. in the case of a 1-bit image with a width
1294 of 7 pixels, the first pixel of the second scanline will the the 8th bit of the first byte,
1295 not the first bit of a new byte.
1297 6.4. A note about 16-bits per channel and endianness
1298 ----------------------------------------------------
1300 LodePNG uses unsigned char arrays for 16-bit per channel colors too, just like
1301 for any other color format. The 16-bit values are stored in big endian (most
1302 significant byte first) in these arrays. This is the opposite order of the
1303 little endian used by x86 CPU's.
1305 LodePNG always uses big endian because the PNG file format does so internally.
1306 Conversions to other formats than PNG uses internally are not supported by
1307 LodePNG on purpose, there are myriads of formats, including endianness of 16-bit
1308 colors, the order in which you store R, G, B and A, and so on. Supporting and
1309 converting to/from all that is outside the scope of LodePNG.
1311 This may mean that, depending on your use case, you may want to convert the big
1312 endian output of LodePNG to little endian with a for loop. This is certainly not
1313 always needed, many applications and libraries support big endian 16-bit colors
1314 anyway, but it means you cannot simply cast the unsigned char* buffer to an
1315 unsigned short* buffer on x86 CPUs.
1321 All functions in LodePNG that return an error code, return 0 if everything went
1322 OK, or a non-zero code if there was an error.
1324 The meaning of the LodePNG error values can be retrieved with the function
1325 lodepng_error_text: given the numerical error code, it returns a description
1326 of the error in English as a string.
1328 Check the implementation of lodepng_error_text to see the meaning of each code.
1331 8. chunks and PNG editing
1332 -------------------------
1334 If you want to add extra chunks to a PNG you encode, or use LodePNG for a PNG
1335 editor that should follow the rules about handling of unknown chunks, or if your
1336 program is able to read other types of chunks than the ones handled by LodePNG,
1337 then that's possible with the chunk functions of LodePNG.
1339 A PNG chunk has the following layout:
1346 8.1. iterating through chunks
1347 -----------------------------
1349 If you have a buffer containing the PNG image data, then the first chunk (the
1350 IHDR chunk) starts at byte number 8 of that buffer. The first 8 bytes are the
1351 signature of the PNG and are not part of a chunk. But if you start at byte 8
1352 then you have a chunk, and can check the following things of it.
1354 NOTE: none of these functions check for memory buffer boundaries. To avoid
1355 exploits, always make sure the buffer contains all the data of the chunks.
1356 When using lodepng_chunk_next, make sure the returned value is within the
1359 unsigned lodepng_chunk_length(const unsigned char* chunk):
1361 Get the length of the chunk's data. The total chunk length is this length + 12.
1363 void lodepng_chunk_type(char type[5], const unsigned char* chunk):
1364 unsigned char lodepng_chunk_type_equals(const unsigned char* chunk, const char* type):
1366 Get the type of the chunk or compare if it's a certain type
1368 unsigned char lodepng_chunk_critical(const unsigned char* chunk):
1369 unsigned char lodepng_chunk_private(const unsigned char* chunk):
1370 unsigned char lodepng_chunk_safetocopy(const unsigned char* chunk):
1372 Check if the chunk is critical in the PNG standard (only IHDR, PLTE, IDAT and IEND are).
1373 Check if the chunk is private (public chunks are part of the standard, private ones not).
1374 Check if the chunk is safe to copy. If it's not, then, when modifying data in a critical
1375 chunk, unsafe to copy chunks of the old image may NOT be saved in the new one if your
1376 program doesn't handle that type of unknown chunk.
1378 unsigned char* lodepng_chunk_data(unsigned char* chunk):
1379 const unsigned char* lodepng_chunk_data_const(const unsigned char* chunk):
1381 Get a pointer to the start of the data of the chunk.
1383 unsigned lodepng_chunk_check_crc(const unsigned char* chunk):
1384 void lodepng_chunk_generate_crc(unsigned char* chunk):
1386 Check if the crc is correct or generate a correct one.
1388 unsigned char* lodepng_chunk_next(unsigned char* chunk):
1389 const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk):
1391 Iterate to the next chunk. This works if you have a buffer with consecutive chunks. Note that these
1392 functions do no boundary checking of the allocated data whatsoever, so make sure there is enough
1393 data available in the buffer to be able to go to the next chunk.
1395 unsigned lodepng_chunk_append(unsigned char** out, size_t* outlength, const unsigned char* chunk):
1396 unsigned lodepng_chunk_create(unsigned char** out, size_t* outlength, unsigned length,
1397 const char* type, const unsigned char* data):
1399 These functions are used to create new chunks that are appended to the data in *out that has
1400 length *outlength. The append function appends an existing chunk to the new data. The create
1401 function creates a new chunk with the given parameters and appends it. Type is the 4-letter
1404 8.2. chunks in info_png
1405 -----------------------
1407 The LodePNGInfo struct contains fields with the unknown chunk in it. It has 3
1408 buffers (each with size) to contain 3 types of unknown chunks:
1409 the ones that come before the PLTE chunk, the ones that come between the PLTE
1410 and the IDAT chunks, and the ones that come after the IDAT chunks.
1411 It's necessary to make the distionction between these 3 cases because the PNG
1412 standard forces to keep the ordering of unknown chunks compared to the critical
1413 chunks, but does not force any other ordering rules.
1415 info_png.unknown_chunks_data[0] is the chunks before PLTE
1416 info_png.unknown_chunks_data[1] is the chunks after PLTE, before IDAT
1417 info_png.unknown_chunks_data[2] is the chunks after IDAT
1419 The chunks in these 3 buffers can be iterated through and read by using the same
1420 way described in the previous subchapter.
1422 When using the decoder to decode a PNG, you can make it store all unknown chunks
1423 if you set the option settings.remember_unknown_chunks to 1. By default, this
1426 The encoder will always encode unknown chunks that are stored in the info_png.
1427 If you need it to add a particular chunk that isn't known by LodePNG, you can
1428 use lodepng_chunk_append or lodepng_chunk_create to the chunk data in
1429 info_png.unknown_chunks_data[x].
1431 Chunks that are known by LodePNG should not be added in that way. E.g. to make
1432 LodePNG add a bKGD chunk, set background_defined to true and add the correct
1433 parameters there instead.
1439 No libraries other than the current standard C library are needed to compile
1440 LodePNG. For the C++ version, only the standard C++ library is needed on top.
1441 Add the files lodepng.c(pp) and lodepng.h to your project, include
1442 lodepng.h where needed, and your program can read/write PNG files.
1444 If performance is important, use optimization when compiling! For both the
1445 encoder and decoder, this makes a large difference.
1447 Make sure that LodePNG is compiled with the same compiler of the same version
1448 and with the same settings as the rest of the program, or the interfaces with
1449 std::vectors and std::strings in C++ can be incompatible.
1451 CHAR_BITS must be 8 or higher, because LodePNG uses unsigned chars for octets.
1455 LodePNG is developed in gcc so this compiler is natively supported. It gives no
1456 warnings with compiler options "-Wall -Wextra -pedantic -ansi", with gcc and g++
1457 version 4.7.1 on Linux, 32-bit and 64-bit.
1461 The Mingw compiler (a port of gcc) for Windows is fully supported by LodePNG.
1463 *) Visual Studio 2005 and up, Visual C++ Express Edition 2005 and up
1465 Visual Studio may give warnings about 'fopen' being deprecated. A multiplatform library
1466 can't support the proposed Visual Studio alternative however, so LodePNG keeps using
1467 fopen. If you don't want to see the deprecated warnings, put this on top of lodepng.h
1468 before the inclusions:
1469 #define _CRT_SECURE_NO_DEPRECATE
1471 Other than the above warnings, LodePNG should be warning-free with warning
1472 level 3 (W3). Warning level 4 (W4) will give warnings about integer conversions.
1473 I'm not planning to resolve these warnings. To get rid of them, let Visual
1474 Studio use warning level W3 for lodepng.cpp only: right click lodepng.cpp,
1475 Properties, C/C++, General, Warning Level: Level 3 (/W3).
1477 Visual Studio may want "stdafx.h" files to be included in each source file and
1478 give an error "unexpected end of file while looking for precompiled header".
1479 That is not standard C++ and will not be added to the stock LodePNG. You can
1480 disable it for lodepng.cpp only by right clicking it, Properties, C/C++,
1481 Precompiled Headers, and set it to Not Using Precompiled Headers there.
1483 *) Visual Studio 6.0
1485 LodePNG support for Visual Studio 6.0 is not guaranteed because VS6 doesn't
1486 follow the C++ standard correctly.
1490 Vesion 20070107 compiles without problems on the Comeau C/C++ Online Test Drive
1491 at http://www.comeaucomputing.com/tryitout in both C90 and C++ mode.
1493 *) Compilers on Macintosh
1495 LodePNG has been reported to work both with the gcc and LLVM for Macintosh, both
1500 If you encounter problems on other compilers, feel free to let me know and I may
1501 try to fix it if the compiler is modern standards complient.
1507 This decoder example shows the most basic usage of LodePNG. More complex
1508 examples can be found on the LodePNG website.
1510 10.1. decoder C++ example
1511 -------------------------
1513 #include "lodepng.h"
1516 int main(int argc, char *argv[])
1518 const char* filename = argc > 1 ? argv[1] : "test.png";
1521 std::vector<unsigned char> image;
1522 unsigned width, height;
1523 unsigned error = lodepng::decode(image, width, height, filename);
1525 //if there's an error, display it
1526 if(error) std::cout << "decoder error " << error << ": " << lodepng_error_text(error) << std::endl;
1528 //the pixels are now in the vector "image", 4 bytes per pixel, ordered RGBARGBA..., use it as texture, draw it, ...
1531 10.2. decoder C example
1532 -----------------------
1534 #include "lodepng.h"
1536 int main(int argc, char *argv[])
1539 unsigned char* image;
1540 size_t width, height;
1541 const char* filename = argc > 1 ? argv[1] : "test.png";
1543 error = lodepng_decode32_file(&image, &width, &height, filename);
1545 if(error) printf("decoder error %u: %s\n", error, lodepng_error_text(error));
1547 / * use image here * /
1557 The version number of LodePNG is the date of the change given in the format
1560 Some changes aren't backwards compatible. Those are indicated with a (!)
1563 *) 15 apr 2013: Fixed bug with LAC_ALPHA and color key.
1564 *) 25 mar 2013: Added an optional feature to ignore some PNG errors (fix_png).
1565 *) 11 mar 2013 (!): Bugfix with custom free. Changed from "my" to "lodepng_"
1566 prefix for the custom allocators and made it possible with a new #define to
1567 use custom ones in your project without needing to change lodepng's code.
1568 *) 28 jan 2013: Bugfix with color key.
1569 *) 27 okt 2012: Tweaks in text chunk keyword length error handling.
1570 *) 8 okt 2012 (!): Added new filter strategy (entropy) and new auto color mode.
1571 (no palette). Better deflate tree encoding. New compression tweak settings.
1572 Faster color conversions while decoding. Some internal cleanups.
1573 *) 23 sep 2012: Reduced warnings in Visual Studio a little bit.
1574 *) 1 sep 2012 (!): Removed #define's for giving custom (de)compression functions
1575 and made it work with function pointers instead.
1576 *) 23 jun 2012: Added more filter strategies. Made it easier to use custom alloc
1577 and free functions and toggle #defines from compiler flags. Small fixes.
1578 *) 6 may 2012 (!): Made plugging in custom zlib/deflate functions more flexible.
1579 *) 22 apr 2012 (!): Made interface more consistent, renaming a lot. Removed
1580 redundant C++ codec classes. Reduced amount of structs. Everything changed,
1581 but it is cleaner now imho and functionality remains the same. Also fixed
1582 several bugs and shrinked the implementation code. Made new samples.
1583 *) 6 nov 2011 (!): By default, the encoder now automatically chooses the best
1584 PNG color model and bit depth, based on the amount and type of colors of the
1585 raw image. For this, autoLeaveOutAlphaChannel replaced by auto_choose_color.
1586 *) 9 okt 2011: simpler hash chain implementation for the encoder.
1587 *) 8 sep 2011: lz77 encoder lazy matching instead of greedy matching.
1588 *) 23 aug 2011: tweaked the zlib compression parameters after benchmarking.
1589 A bug with the PNG filtertype heuristic was fixed, so that it chooses much
1590 better ones (it's quite significant). A setting to do an experimental, slow,
1591 brute force search for PNG filter types is added.
1592 *) 17 aug 2011 (!): changed some C zlib related function names.
1593 *) 16 aug 2011: made the code less wide (max 120 characters per line).
1594 *) 17 apr 2011: code cleanup. Bugfixes. Convert low to 16-bit per sample colors.
1595 *) 21 feb 2011: fixed compiling for C90. Fixed compiling with sections disabled.
1596 *) 11 dec 2010: encoding is made faster, based on suggestion by Peter Eastman
1597 to optimize long sequences of zeros.
1598 *) 13 nov 2010: added LodePNG_InfoColor_hasPaletteAlpha and
1599 LodePNG_InfoColor_canHaveAlpha functions for convenience.
1600 *) 7 nov 2010: added LodePNG_error_text function to get error code description.
1601 *) 30 okt 2010: made decoding slightly faster
1602 *) 26 okt 2010: (!) changed some C function and struct names (more consistent).
1603 Reorganized the documentation and the declaration order in the header.
1604 *) 08 aug 2010: only changed some comments and external samples.
1605 *) 05 jul 2010: fixed bug thanks to warnings in the new gcc version.
1606 *) 14 mar 2010: fixed bug where too much memory was allocated for char buffers.
1607 *) 02 sep 2008: fixed bug where it could create empty tree that linux apps could
1608 read by ignoring the problem but windows apps couldn't.
1609 *) 06 jun 2008: added more error checks for out of memory cases.
1610 *) 26 apr 2008: added a few more checks here and there to ensure more safety.
1611 *) 06 mar 2008: crash with encoding of strings fixed
1612 *) 02 feb 2008: support for international text chunks added (iTXt)
1613 *) 23 jan 2008: small cleanups, and #defines to divide code in sections
1614 *) 20 jan 2008: support for unknown chunks allowing using LodePNG for an editor.
1615 *) 18 jan 2008: support for tIME and pHYs chunks added to encoder and decoder.
1616 *) 17 jan 2008: ability to encode and decode compressed zTXt chunks added
1617 Also vareous fixes, such as in the deflate and the padding bits code.
1618 *) 13 jan 2008: Added ability to encode Adam7-interlaced images. Improved
1619 filtering code of encoder.
1620 *) 07 jan 2008: (!) changed LodePNG to use ISO C90 instead of C++. A
1621 C++ wrapper around this provides an interface almost identical to before.
1622 Having LodePNG be pure ISO C90 makes it more portable. The C and C++ code
1623 are together in these files but it works both for C and C++ compilers.
1624 *) 29 dec 2007: (!) changed most integer types to unsigned int + other tweaks
1625 *) 30 aug 2007: bug fixed which makes this Borland C++ compatible
1626 *) 09 aug 2007: some VS2005 warnings removed again
1627 *) 21 jul 2007: deflate code placed in new namespace separate from zlib code
1628 *) 08 jun 2007: fixed bug with 2- and 4-bit color, and small interlaced images
1629 *) 04 jun 2007: improved support for Visual Studio 2005: crash with accessing
1630 invalid std::vector element [0] fixed, and level 3 and 4 warnings removed
1631 *) 02 jun 2007: made the encoder add a tag with version by default
1632 *) 27 may 2007: zlib and png code separated (but still in the same file),
1633 simple encoder/decoder functions added for more simple usage cases
1634 *) 19 may 2007: minor fixes, some code cleaning, new error added (error 69),
1635 moved some examples from here to lodepng_examples.cpp
1636 *) 12 may 2007: palette decoding bug fixed
1637 *) 24 apr 2007: changed the license from BSD to the zlib license
1638 *) 11 mar 2007: very simple addition: ability to encode bKGD chunks.
1639 *) 04 mar 2007: (!) tEXt chunk related fixes, and support for encoding
1640 palettized PNG images. Plus little interface change with palette and texts.
1641 *) 03 mar 2007: Made it encode dynamic Huffman shorter with repeat codes.
1642 Fixed a bug where the end code of a block had length 0 in the Huffman tree.
1643 *) 26 feb 2007: Huffman compression with dynamic trees (BTYPE 2) now implemented
1644 and supported by the encoder, resulting in smaller PNGs at the output.
1645 *) 27 jan 2007: Made the Adler-32 test faster so that a timewaste is gone.
1646 *) 24 jan 2007: gave encoder an error interface. Added color conversion from any
1647 greyscale type to 8-bit greyscale with or without alpha.
1648 *) 21 jan 2007: (!) Totally changed the interface. It allows more color types
1649 to convert to and is more uniform. See the manual for how it works now.
1650 *) 07 jan 2007: Some cleanup & fixes, and a few changes over the last days:
1651 encode/decode custom tEXt chunks, separate classes for zlib & deflate, and
1652 at last made the decoder give errors for incorrect Adler32 or Crc.
1653 *) 01 jan 2007: Fixed bug with encoding PNGs with less than 8 bits per channel.
1654 *) 29 dec 2006: Added support for encoding images without alpha channel, and
1655 cleaned out code as well as making certain parts faster.
1656 *) 28 dec 2006: Added "Settings" to the encoder.
1657 *) 26 dec 2006: The encoder now does LZ77 encoding and produces much smaller files now.
1658 Removed some code duplication in the decoder. Fixed little bug in an example.
1659 *) 09 dec 2006: (!) Placed output parameters of public functions as first parameter.
1660 Fixed a bug of the decoder with 16-bit per color.
1661 *) 15 okt 2006: Changed documentation structure
1662 *) 09 okt 2006: Encoder class added. It encodes a valid PNG image from the
1663 given image buffer, however for now it's not compressed.
1664 *) 08 sep 2006: (!) Changed to interface with a Decoder class
1665 *) 30 jul 2006: (!) LodePNG_InfoPng , width and height are now retrieved in different
1666 way. Renamed decodePNG to decodePNGGeneric.
1667 *) 29 jul 2006: (!) Changed the interface: image info is now returned as a
1668 struct of type LodePNG::LodePNG_Info, instead of a vector, which was a bit clumsy.
1669 *) 28 jul 2006: Cleaned the code and added new error checks.
1670 Corrected terminology "deflate" into "inflate".
1671 *) 23 jun 2006: Added SDL example in the documentation in the header, this
1672 example allows easy debugging by displaying the PNG and its transparency.
1673 *) 22 jun 2006: (!) Changed way to obtain error value. Added
1674 loadFile function for convenience. Made decodePNG32 faster.
1675 *) 21 jun 2006: (!) Changed type of info vector to unsigned.
1676 Changed position of palette in info vector. Fixed an important bug that
1677 happened on PNGs with an uncompressed block.
1678 *) 16 jun 2006: Internally changed unsigned into unsigned where
1679 needed, and performed some optimizations.
1680 *) 07 jun 2006: (!) Renamed functions to decodePNG and placed them
1681 in LodePNG namespace. Changed the order of the parameters. Rewrote the
1682 documentation in the header. Renamed files to lodepng.cpp and lodepng.h
1683 *) 22 apr 2006: Optimized and improved some code
1684 *) 07 sep 2005: (!) Changed to std::vector interface
1685 *) 12 aug 2005: Initial release (C++, decoder only)
1688 12. contact information
1689 -----------------------
1691 Feel free to contact me with suggestions, problems, comments, ... concerning
1692 LodePNG. If you encounter a PNG image that doesn't work properly with this
1693 decoder, feel free to send it and I'll use it to find and fix the problem.
1695 My email address is (puzzle the account and domain together with an @ symbol):
1696 Domain: gmail dot com.
1697 Account: lode dot vandevenne.
1700 Copyright (c) 2005-2013 Lode Vandevenne