acid-drop

- Hacking the planet from a LilyGo T-Deck using custom firmware
git clone git://git.acid.vegas/acid-drop.git
Log | Files | Refs | Archive | README | LICENSE

lodepng.h (95629B)

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