| /* |
| LodePNG Utils |
| |
| Copyright (c) 2005-2012 Lode Vandevenne |
| |
| This software is provided 'as-is', without any express or implied |
| warranty. In no event will the authors be held liable for any damages |
| arising from the use of this software. |
| |
| Permission is granted to anyone to use this software for any purpose, |
| including commercial applications, and to alter it and redistribute it |
| freely, subject to the following restrictions: |
| |
| 1. The origin of this software must not be misrepresented; you must not |
| claim that you wrote the original software. If you use this software |
| in a product, an acknowledgment in the product documentation would be |
| appreciated but is not required. |
| |
| 2. Altered source versions must be plainly marked as such, and must not be |
| misrepresented as being the original software. |
| |
| 3. This notice may not be removed or altered from any source |
| distribution. |
| */ |
| |
| #include "lodepng_util.h" |
| #include <iostream> |
| |
| namespace lodepng |
| { |
| |
| LodePNGInfo getPNGHeaderInfo(const std::vector<unsigned char>& png) |
| { |
| unsigned w, h; |
| lodepng::State state; |
| lodepng_inspect(&w, &h, &state, &png[0], png.size()); |
| return state.info_png; |
| } |
| |
| unsigned getChunkInfo(std::vector<std::string>& names, std::vector<size_t>& sizes, |
| const std::vector<unsigned char>& png) |
| { |
| // Listing chunks is based on the original file, not the decoded png info. |
| const unsigned char *chunk, *begin, *end; |
| end = &png.back() + 1; |
| begin = chunk = &png.front() + 8; |
| |
| while(chunk + 8 < end && chunk >= begin) |
| { |
| char type[5]; |
| lodepng_chunk_type(type, chunk); |
| if(std::string(type).size() != 4) return 1; |
| |
| names.push_back(type); |
| sizes.push_back(lodepng_chunk_length(chunk)); |
| |
| chunk = lodepng_chunk_next_const(chunk); |
| } |
| return 0; |
| } |
| |
| unsigned getChunks(std::vector<std::string> names[3], |
| std::vector<std::vector<unsigned char> > chunks[3], |
| const std::vector<unsigned char>& png) |
| { |
| const unsigned char *chunk, *next, *begin, *end; |
| end = &png.back() + 1; |
| begin = chunk = &png.front() + 8; |
| |
| int location = 0; |
| |
| while(chunk + 8 < end && chunk >= begin) |
| { |
| char type[5]; |
| lodepng_chunk_type(type, chunk); |
| std::string name(type); |
| if(name.size() != 4) return 1; |
| |
| next = lodepng_chunk_next_const(chunk); |
| |
| if(name == "IHDR") |
| { |
| location = 0; |
| } |
| else if(name == "PLTE") |
| { |
| location = 1; |
| } |
| else if(name == "IDAT") |
| { |
| location = 2; |
| } |
| else if(name != "IEND") |
| { |
| names[location].push_back(name); |
| chunks[location].push_back(std::vector<unsigned char>(chunk, next)); |
| } |
| |
| chunk = next; |
| } |
| return 0; |
| } |
| |
| |
| unsigned insertChunks(std::vector<unsigned char>& png, |
| const std::vector<std::vector<unsigned char> > chunks[3]) |
| { |
| const unsigned char *chunk, *next, *begin, *end; |
| end = &png.back() + 1; |
| begin = chunk = &png.front() + 8; |
| |
| size_t l0 = 0; //location 0: IHDR-l0-PLTE (or IHDR-l0-l1-IDAT) |
| size_t l1 = 0; //location 1: PLTE-l1-IDAT (or IHDR-l0-l1-IDAT) |
| size_t l2 = 0; //location 2: IDAT-l2-IEND |
| |
| while(chunk + 8 < end && chunk >= begin) |
| { |
| char type[5]; |
| lodepng_chunk_type(type, chunk); |
| std::string name(type); |
| if(name.size() != 4) return 1; |
| |
| next = lodepng_chunk_next_const(chunk); |
| |
| if(name == "PLTE") |
| { |
| if(l0 == 0) l0 = chunk - begin + 8; |
| } |
| else if(name == "IDAT") |
| { |
| if(l0 == 0) l0 = chunk - begin + 8; |
| if(l1 == 0) l1 = chunk - begin + 8; |
| } |
| else if(name == "IEND") |
| { |
| if(l2 == 0) l2 = chunk - begin + 8; |
| } |
| |
| chunk = next; |
| } |
| |
| std::vector<unsigned char> result; |
| result.insert(result.end(), png.begin(), png.begin() + l0); |
| for(size_t i = 0; i < chunks[0].size(); i++) result.insert(result.end(), chunks[0][i].begin(), chunks[0][i].end()); |
| result.insert(result.end(), png.begin() + l0, png.begin() + l1); |
| for(size_t i = 0; i < chunks[1].size(); i++) result.insert(result.end(), chunks[1][i].begin(), chunks[1][i].end()); |
| result.insert(result.end(), png.begin() + l1, png.begin() + l2); |
| for(size_t i = 0; i < chunks[2].size(); i++) result.insert(result.end(), chunks[2][i].begin(), chunks[2][i].end()); |
| result.insert(result.end(), png.begin() + l2, png.end()); |
| |
| png = result; |
| return 0; |
| } |
| |
| unsigned getFilterTypesInterlaced(std::vector<std::vector<unsigned char> >& filterTypes, |
| const std::vector<unsigned char>& png) |
| { |
| //Get color type and interlace type |
| lodepng::State state; |
| unsigned w, h; |
| unsigned error; |
| error = lodepng_inspect(&w, &h, &state, &png[0], png.size()); |
| |
| if(error) return 1; |
| |
| //Read literal data from all IDAT chunks |
| const unsigned char *chunk, *begin, *end; |
| end = &png.back() + 1; |
| begin = chunk = &png.front() + 8; |
| |
| std::vector<unsigned char> zdata; |
| |
| while(chunk + 8 < end && chunk >= begin) |
| { |
| char type[5]; |
| lodepng_chunk_type(type, chunk); |
| if(std::string(type).size() != 4) return 1; //Probably not a PNG file |
| |
| if(std::string(type) == "IDAT") |
| { |
| const unsigned char* cdata = lodepng_chunk_data_const(chunk); |
| unsigned clength = lodepng_chunk_length(chunk); |
| |
| for(unsigned i = 0; i < clength; i++) |
| { |
| zdata.push_back(cdata[i]); |
| } |
| } |
| |
| chunk = lodepng_chunk_next_const(chunk); |
| } |
| |
| //Decompress all IDAT data |
| std::vector<unsigned char> data; |
| error = lodepng::decompress(data, &zdata[0], zdata.size()); |
| |
| if(error) return 1; |
| |
| if(state.info_png.interlace_method == 0) |
| { |
| filterTypes.resize(1); |
| |
| //A line is 1 filter byte + all pixels |
| size_t linebytes = 1 + lodepng_get_raw_size(w, 1, &state.info_png.color); |
| |
| for(size_t i = 0; i < data.size(); i += linebytes) |
| { |
| filterTypes[0].push_back(data[i]); |
| } |
| } |
| else |
| { |
| //Interlaced |
| filterTypes.resize(7); |
| static const unsigned ADAM7_IX[7] = { 0, 4, 0, 2, 0, 1, 0 }; /*x start values*/ |
| static const unsigned ADAM7_IY[7] = { 0, 0, 4, 0, 2, 0, 1 }; /*y start values*/ |
| static const unsigned ADAM7_DX[7] = { 8, 8, 4, 4, 2, 2, 1 }; /*x delta values*/ |
| static const unsigned ADAM7_DY[7] = { 8, 8, 8, 4, 4, 2, 2 }; /*y delta values*/ |
| size_t pos = 0; |
| for(int j = 0; j < 7; j++) |
| { |
| unsigned w2 = (w - ADAM7_IX[j] + ADAM7_DX[j] - 1) / ADAM7_DX[j]; |
| unsigned h2 = (h - ADAM7_IY[j] + ADAM7_DY[j] - 1) / ADAM7_DY[j]; |
| if(ADAM7_IX[j] >= w || ADAM7_IY[j] >= h) w2 = h2 = 0; |
| size_t linebytes = 1 + lodepng_get_raw_size(w2, 1, &state.info_png.color); |
| for(size_t i = 0; i < h2; i++) |
| { |
| filterTypes[j].push_back(data[pos]); |
| pos += linebytes; |
| } |
| } |
| } |
| return 0; /* OK */ |
| } |
| |
| |
| unsigned getFilterTypes(std::vector<unsigned char>& filterTypes, const std::vector<unsigned char>& png) |
| { |
| std::vector<std::vector<unsigned char> > passes; |
| unsigned error = getFilterTypesInterlaced(passes, png); |
| if(error) return error; |
| |
| if(passes.size() == 1) |
| { |
| filterTypes.swap(passes[0]); |
| } |
| else |
| { |
| lodepng::State state; |
| unsigned w, h; |
| lodepng_inspect(&w, &h, &state, &png[0], png.size()); |
| /* |
| Interlaced. Simplify it: put pass 6 and 7 alternating in the one vector so |
| that one filter per scanline of the uninterlaced image is given, with that |
| filter corresponding the closest to what it would be for non-interlaced |
| image. |
| */ |
| for(size_t i = 0; i < h; i++) |
| { |
| filterTypes.push_back(i % 2 == 0 ? passes[5][i / 2] : passes[6][i / 2]); |
| } |
| } |
| return 0; /* OK */ |
| } |
| |
| int getPaletteValue(const unsigned char* data, size_t i, int bits) |
| { |
| if(bits == 8) return data[i]; |
| else if(bits == 4) return (data[i / 2] >> ((i % 2) * 4)) & 15; |
| else if(bits == 2) return (data[i / 4] >> ((i % 4) * 2)) & 3; |
| else if(bits == 1) return (data[i / 8] >> (i % 8)) & 1; |
| else return 0; |
| } |
| |
| //This uses a stripped down version of picoPNG to extract detailed zlib information while decompressing. |
| static const unsigned long LENBASE[29] = |
| {3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258}; |
| static const unsigned long LENEXTRA[29] = |
| {0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0}; |
| static const unsigned long DISTBASE[30] = |
| {1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577}; |
| static const unsigned long DISTEXTRA[30] = |
| {0,0,0,0,1,1,2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13}; |
| static const unsigned long CLCL[19] = |
| {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; //code length code lengths |
| |
| struct ExtractZlib // Zlib decompression and information extraction |
| { |
| std::vector<ZlibBlockInfo>* zlibinfo; |
| int error; |
| |
| ExtractZlib(std::vector<ZlibBlockInfo>* output) : zlibinfo(output) {}; |
| |
| unsigned long readBitFromStream(size_t& bitp, const unsigned char* bits) |
| { |
| unsigned long result = (bits[bitp >> 3] >> (bitp & 0x7)) & 1; |
| bitp++; |
| return result; |
| } |
| |
| unsigned long readBitsFromStream(size_t& bitp, const unsigned char* bits, size_t nbits) |
| { |
| unsigned long result = 0; |
| for(size_t i = 0; i < nbits; i++) result += (readBitFromStream(bitp, bits)) << i; |
| return result; |
| } |
| |
| struct HuffmanTree |
| { |
| int makeFromLengths(const std::vector<unsigned long>& bitlen, unsigned long maxbitlen) |
| { //make tree given the lengths |
| unsigned long numcodes = (unsigned long)(bitlen.size()), treepos = 0, nodefilled = 0; |
| std::vector<unsigned long> tree1d(numcodes), blcount(maxbitlen + 1, 0), nextcode(maxbitlen + 1, 0); |
| //count number of instances of each code length |
| for(unsigned long bits = 0; bits < numcodes; bits++) blcount[bitlen[bits]]++; |
| for(unsigned long bits = 1; bits <= maxbitlen; bits++) |
| { |
| nextcode[bits] = (nextcode[bits - 1] + blcount[bits - 1]) << 1; |
| } |
| //generate all the codes |
| for(unsigned long n = 0; n < numcodes; n++) if(bitlen[n] != 0) tree1d[n] = nextcode[bitlen[n]]++; |
| tree2d.clear(); tree2d.resize(numcodes * 2, 32767); //32767 here means the tree2d isn't filled there yet |
| for(unsigned long n = 0; n < numcodes; n++) //the codes |
| for(unsigned long i = 0; i < bitlen[n]; i++) //the bits for this code |
| { |
| unsigned long bit = (tree1d[n] >> (bitlen[n] - i - 1)) & 1; |
| if(treepos > numcodes - 2) return 55; |
| if(tree2d[2 * treepos + bit] == 32767) //not yet filled in |
| { |
| if(i + 1 == bitlen[n]) |
| { |
| //last bit |
| tree2d[2 * treepos + bit] = n; |
| treepos = 0; |
| } |
| else |
| { |
| //addresses are encoded as values > numcodes |
| tree2d[2 * treepos + bit] = ++nodefilled + numcodes; |
| treepos = nodefilled; |
| } |
| } |
| else treepos = tree2d[2 * treepos + bit] - numcodes; //subtract numcodes from address to get address value |
| } |
| return 0; |
| } |
| int decode(bool& decoded, unsigned long& result, size_t& treepos, unsigned long bit) const |
| { //Decodes a symbol from the tree |
| unsigned long numcodes = (unsigned long)tree2d.size() / 2; |
| if(treepos >= numcodes) return 11; //error: you appeared outside the codetree |
| result = tree2d[2 * treepos + bit]; |
| decoded = (result < numcodes); |
| treepos = decoded ? 0 : result - numcodes; |
| return 0; |
| } |
| //2D representation of a huffman tree: one dimension is "0" or "1", the other contains all nodes and leaves. |
| std::vector<unsigned long> tree2d; |
| }; |
| |
| void inflate(std::vector<unsigned char>& out, const std::vector<unsigned char>& in, size_t inpos = 0) |
| { |
| size_t bp = 0, pos = 0; //bit pointer and byte pointer |
| error = 0; |
| unsigned long BFINAL = 0; |
| while(!BFINAL && !error) |
| { |
| size_t uncomprblockstart = pos; |
| size_t bpstart = bp; |
| if(bp >> 3 >= in.size()) { error = 52; return; } //error, bit pointer will jump past memory |
| BFINAL = readBitFromStream(bp, &in[inpos]); |
| unsigned long BTYPE = readBitFromStream(bp, &in[inpos]); BTYPE += 2 * readBitFromStream(bp, &in[inpos]); |
| zlibinfo->resize(zlibinfo->size() + 1); |
| zlibinfo->back().btype = BTYPE; |
| if(BTYPE == 3) { error = 20; return; } //error: invalid BTYPE |
| else if(BTYPE == 0) inflateNoCompression(out, &in[inpos], bp, pos, in.size()); |
| else inflateHuffmanBlock(out, &in[inpos], bp, pos, in.size(), BTYPE); |
| size_t uncomprblocksize = pos - uncomprblockstart; |
| zlibinfo->back().compressedbits = bp - bpstart; |
| zlibinfo->back().uncompressedbytes = uncomprblocksize; |
| } |
| } |
| |
| void generateFixedTrees(HuffmanTree& tree, HuffmanTree& treeD) //get the tree of a deflated block with fixed tree |
| { |
| std::vector<unsigned long> bitlen(288, 8), bitlenD(32, 5);; |
| for(size_t i = 144; i <= 255; i++) bitlen[i] = 9; |
| for(size_t i = 256; i <= 279; i++) bitlen[i] = 7; |
| tree.makeFromLengths(bitlen, 15); |
| treeD.makeFromLengths(bitlenD, 15); |
| } |
| |
| //the code tree for Huffman codes, dist codes, and code length codes |
| HuffmanTree codetree, codetreeD, codelengthcodetree; |
| unsigned long huffmanDecodeSymbol(const unsigned char* in, size_t& bp, const HuffmanTree& codetree, size_t inlength) |
| { |
| //decode a single symbol from given list of bits with given code tree. return value is the symbol |
| bool decoded; unsigned long ct; |
| for(size_t treepos = 0;;) |
| { |
| if((bp & 0x07) == 0 && (bp >> 3) > inlength) { error = 10; return 0; } //error: end reached without endcode |
| error = codetree.decode(decoded, ct, treepos, readBitFromStream(bp, in)); |
| if(error) return 0; //stop, an error happened |
| if(decoded) return ct; |
| } |
| } |
| |
| void getTreeInflateDynamic(HuffmanTree& tree, HuffmanTree& treeD, |
| const unsigned char* in, size_t& bp, size_t inlength) |
| { |
| size_t bpstart = bp; |
| //get the tree of a deflated block with dynamic tree, the tree itself is also Huffman compressed with a known tree |
| std::vector<unsigned long> bitlen(288, 0), bitlenD(32, 0); |
| if(bp >> 3 >= inlength - 2) { error = 49; return; } //the bit pointer is or will go past the memory |
| size_t HLIT = readBitsFromStream(bp, in, 5) + 257; //number of literal/length codes + 257 |
| size_t HDIST = readBitsFromStream(bp, in, 5) + 1; //number of dist codes + 1 |
| size_t HCLEN = readBitsFromStream(bp, in, 4) + 4; //number of code length codes + 4 |
| zlibinfo->back().hlit = HLIT - 257; |
| zlibinfo->back().hdist = HDIST - 1; |
| zlibinfo->back().hclen = HCLEN - 4; |
| std::vector<unsigned long> codelengthcode(19); //lengths of tree to decode the lengths of the dynamic tree |
| for(size_t i = 0; i < 19; i++) codelengthcode[CLCL[i]] = (i < HCLEN) ? readBitsFromStream(bp, in, 3) : 0; |
| //code length code lengths |
| for(size_t i = 0; i < codelengthcode.size(); i++) zlibinfo->back().clcl.push_back(codelengthcode[i]); |
| error = codelengthcodetree.makeFromLengths(codelengthcode, 7); if(error) return; |
| size_t i = 0, replength; |
| while(i < HLIT + HDIST) |
| { |
| unsigned long code = huffmanDecodeSymbol(in, bp, codelengthcodetree, inlength); if(error) return; |
| zlibinfo->back().treecodes.push_back(code); //tree symbol code |
| if(code <= 15) { if(i < HLIT) bitlen[i++] = code; else bitlenD[i++ - HLIT] = code; } //a length code |
| else if(code == 16) //repeat previous |
| { |
| if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory |
| replength = 3 + readBitsFromStream(bp, in, 2); |
| unsigned long value; //set value to the previous code |
| if((i - 1) < HLIT) value = bitlen[i - 1]; |
| else value = bitlenD[i - HLIT - 1]; |
| for(size_t n = 0; n < replength; n++) //repeat this value in the next lengths |
| { |
| if(i >= HLIT + HDIST) { error = 13; return; } //error: i is larger than the amount of codes |
| if(i < HLIT) bitlen[i++] = value; else bitlenD[i++ - HLIT] = value; |
| } |
| } |
| else if(code == 17) //repeat "0" 3-10 times |
| { |
| if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory |
| replength = 3 + readBitsFromStream(bp, in, 3); |
| zlibinfo->back().treecodes.push_back(replength); //tree symbol code repetitions |
| for(size_t n = 0; n < replength; n++) //repeat this value in the next lengths |
| { |
| if(i >= HLIT + HDIST) { error = 14; return; } //error: i is larger than the amount of codes |
| if(i < HLIT) bitlen[i++] = 0; else bitlenD[i++ - HLIT] = 0; |
| } |
| } |
| else if(code == 18) //repeat "0" 11-138 times |
| { |
| if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory |
| replength = 11 + readBitsFromStream(bp, in, 7); |
| zlibinfo->back().treecodes.push_back(replength); //tree symbol code repetitions |
| for(size_t n = 0; n < replength; n++) //repeat this value in the next lengths |
| { |
| if(i >= HLIT + HDIST) { error = 15; return; } //error: i is larger than the amount of codes |
| if(i < HLIT) bitlen[i++] = 0; else bitlenD[i++ - HLIT] = 0; |
| } |
| } |
| else { error = 16; return; } //error: somehow an unexisting code appeared. This can never happen. |
| } |
| if(bitlen[256] == 0) { error = 64; return; } //the length of the end code 256 must be larger than 0 |
| error = tree.makeFromLengths(bitlen, 15); |
| if(error) return; //now we've finally got HLIT and HDIST, so generate the code trees, and the function is done |
| error = treeD.makeFromLengths(bitlenD, 15); |
| if(error) return; |
| zlibinfo->back().treebits = bp - bpstart; |
| //lit/len/end symbol lengths |
| for(size_t i = 0; i < bitlen.size(); i++) zlibinfo->back().litlenlengths.push_back(bitlen[i]); |
| //dist lengths |
| for(size_t i = 0; i < bitlenD.size(); i++) zlibinfo->back().distlengths.push_back(bitlenD[i]); |
| } |
| |
| void inflateHuffmanBlock(std::vector<unsigned char>& out, |
| const unsigned char* in, size_t& bp, size_t& pos, size_t inlength, unsigned long btype) |
| { |
| size_t numcodes = 0, numlit = 0, numlen = 0; //for logging |
| if(btype == 1) { generateFixedTrees(codetree, codetreeD); } |
| else if(btype == 2) { getTreeInflateDynamic(codetree, codetreeD, in, bp, inlength); if(error) return; } |
| for(;;) |
| { |
| unsigned long code = huffmanDecodeSymbol(in, bp, codetree, inlength); if(error) return; |
| numcodes++; |
| zlibinfo->back().lz77_lcode.push_back(code); //output code |
| zlibinfo->back().lz77_dcode.push_back(0); |
| zlibinfo->back().lz77_lbits.push_back(0); |
| zlibinfo->back().lz77_dbits.push_back(0); |
| zlibinfo->back().lz77_lvalue.push_back(0); |
| zlibinfo->back().lz77_dvalue.push_back(0); |
| |
| if(code == 256) break; //end code |
| else if(code <= 255) //literal symbol |
| { |
| out.push_back((unsigned char)(code)); |
| pos++; |
| numlit++; |
| } |
| else if(code >= 257 && code <= 285) //length code |
| { |
| size_t length = LENBASE[code - 257], numextrabits = LENEXTRA[code - 257]; |
| if((bp >> 3) >= inlength) { error = 51; return; } //error, bit pointer will jump past memory |
| length += readBitsFromStream(bp, in, numextrabits); |
| unsigned long codeD = huffmanDecodeSymbol(in, bp, codetreeD, inlength); if(error) return; |
| if(codeD > 29) { error = 18; return; } //error: invalid dist code (30-31 are never used) |
| unsigned long dist = DISTBASE[codeD], numextrabitsD = DISTEXTRA[codeD]; |
| if((bp >> 3) >= inlength) { error = 51; return; } //error, bit pointer will jump past memory |
| dist += readBitsFromStream(bp, in, numextrabitsD); |
| size_t start = pos, back = start - dist; //backwards |
| for(size_t i = 0; i < length; i++) |
| { |
| out.push_back(out[back++]); |
| pos++; |
| if(back >= start) back = start - dist; |
| } |
| numlen++; |
| zlibinfo->back().lz77_dcode.back() = codeD; //output distance code |
| zlibinfo->back().lz77_lbits.back() = numextrabits; //output length extra bits |
| zlibinfo->back().lz77_dbits.back() = numextrabitsD; //output dist extra bits |
| zlibinfo->back().lz77_lvalue.back() = length; //output length |
| zlibinfo->back().lz77_dvalue.back() = dist; //output dist |
| } |
| } |
| zlibinfo->back().numlit = numlit; //output number of literal symbols |
| zlibinfo->back().numlen = numlen; //output number of length symbols |
| } |
| |
| void inflateNoCompression(std::vector<unsigned char>& out, |
| const unsigned char* in, size_t& bp, size_t& pos, size_t inlength) |
| { |
| while((bp & 0x7) != 0) bp++; //go to first boundary of byte |
| size_t p = bp / 8; |
| if(p >= inlength - 4) { error = 52; return; } //error, bit pointer will jump past memory |
| unsigned long LEN = in[p] + 256 * in[p + 1], NLEN = in[p + 2] + 256 * in[p + 3]; p += 4; |
| if(LEN + NLEN != 65535) { error = 21; return; } //error: NLEN is not one's complement of LEN |
| if(p + LEN > inlength) { error = 23; return; } //error: reading outside of in buffer |
| for(unsigned long n = 0; n < LEN; n++) |
| { |
| out.push_back(in[p++]); //read LEN bytes of literal data |
| pos++; |
| } |
| bp = p * 8; |
| } |
| |
| int decompress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in) //returns error value |
| { |
| if(in.size() < 2) { return 53; } //error, size of zlib data too small |
| //error: 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is supposed to be made that way |
| if((in[0] * 256 + in[1]) % 31 != 0) { return 24; } |
| unsigned long CM = in[0] & 15, CINFO = (in[0] >> 4) & 15, FDICT = (in[1] >> 5) & 1; |
| //error: only compression method 8: inflate with sliding window of 32k is supported by the PNG spec |
| if(CM != 8 || CINFO > 7) { return 25; } |
| //error: the PNG spec says about the zlib stream: "The additional flags shall not specify a preset dictionary." |
| if(FDICT != 0) { return 26; } |
| inflate(out, in, 2); |
| return error; //note: adler32 checksum was skipped and ignored |
| } |
| }; |
| |
| struct ExtractPNG //PNG decoding and information extraction |
| { |
| std::vector<ZlibBlockInfo>* zlibinfo; |
| int error; |
| |
| ExtractPNG(std::vector<ZlibBlockInfo>* output) : zlibinfo(output) {}; |
| |
| void decode(const unsigned char* in, size_t size) |
| { |
| error = 0; |
| if(size == 0 || in == 0) { error = 48; return; } //the given data is empty |
| readPngHeader(&in[0], size); if(error) return; |
| size_t pos = 33; //first byte of the first chunk after the header |
| std::vector<unsigned char> idat; //the data from idat chunks |
| bool IEND = false; |
| //loop through the chunks, ignoring unknown chunks and stopping at IEND chunk. |
| //IDAT data is put at the start of the in buffer |
| while(!IEND) |
| { |
| //error: size of the in buffer too small to contain next chunk |
| if(pos + 8 >= size) { error = 30; return; } |
| size_t chunkLength = read32bitInt(&in[pos]); pos += 4; |
| if(chunkLength > 2147483647) { error = 63; return; } |
| //error: size of the in buffer too small to contain next chunk |
| if(pos + chunkLength >= size) { error = 35; return; } |
| //IDAT chunk, containing compressed image data |
| if(in[pos + 0] == 'I' && in[pos + 1] == 'D' && in[pos + 2] == 'A' && in[pos + 3] == 'T') |
| { |
| idat.insert(idat.end(), &in[pos + 4], &in[pos + 4 + chunkLength]); |
| pos += (4 + chunkLength); |
| } |
| else if(in[pos + 0] == 'I' && in[pos + 1] == 'E' && in[pos + 2] == 'N' && in[pos + 3] == 'D') |
| { |
| pos += 4; |
| IEND = true; |
| } |
| else //it's not an implemented chunk type, so ignore it: skip over the data |
| { |
| pos += (chunkLength + 4); //skip 4 letters and uninterpreted data of unimplemented chunk |
| } |
| pos += 4; //step over CRC (which is ignored) |
| } |
| std::vector<unsigned char> out; //now the out buffer will be filled |
| ExtractZlib zlib(zlibinfo); //decompress with the Zlib decompressor |
| error = zlib.decompress(out, idat); |
| if(error) return; //stop if the zlib decompressor returned an error |
| } |
| |
| //read the information from the header and store it in the Info |
| void readPngHeader(const unsigned char* in, size_t inlength) |
| { |
| if(inlength < 29) { error = 27; return; } //error: the data length is smaller than the length of the header |
| if(in[0] != 137 || in[1] != 80 || in[2] != 78 || in[3] != 71 |
| || in[4] != 13 || in[5] != 10 || in[6] != 26 || in[7] != 10) { error = 28; return; } //no PNG signature |
| //error: it doesn't start with a IHDR chunk! |
| if(in[12] != 'I' || in[13] != 'H' || in[14] != 'D' || in[15] != 'R') { error = 29; return; } |
| } |
| |
| unsigned long readBitFromReversedStream(size_t& bitp, const unsigned char* bits) |
| { |
| unsigned long result = (bits[bitp >> 3] >> (7 - (bitp & 0x7))) & 1; |
| bitp++; |
| return result; |
| } |
| |
| unsigned long readBitsFromReversedStream(size_t& bitp, const unsigned char* bits, unsigned long nbits) |
| { |
| unsigned long result = 0; |
| for(size_t i = nbits - 1; i < nbits; i--) result += ((readBitFromReversedStream(bitp, bits)) << i); |
| return result; |
| } |
| |
| void setBitOfReversedStream(size_t& bitp, unsigned char* bits, unsigned long bit) |
| { |
| bits[bitp >> 3] |= (bit << (7 - (bitp & 0x7))); bitp++; |
| } |
| |
| unsigned long read32bitInt(const unsigned char* buffer) |
| { |
| return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3]; |
| } |
| }; |
| |
| void extractZlibInfo(std::vector<ZlibBlockInfo>& zlibinfo, const std::vector<unsigned char>& in) |
| { |
| ExtractPNG decoder(&zlibinfo); |
| decoder.decode(&in[0], in.size()); |
| |
| if(decoder.error) std::cout << "extract error: " << decoder.error << std::endl; |
| } |
| |
| } // namespace lodepng |
