Initial fixed huffman coding for png.

src/compression/huffman/HuffmanStream.cpp

@@ -0,0 +1,202 @@
+#include "HuffmanStream.h"
+
+#include "ByteUtils.h"
+#include "HuffmanFixedCodes.h"
+
+#include <iostream>
+#include <algorithm>
+#include <unordered_map>
+#include <sstream>
+
+HuffmanStream::HuffmanStream(BitStream* inputStream, BitStream* outputStream)
+    : mInputStream(inputStream),
+      mOutputStream(outputStream)
+{
+
+}
+
+void HuffmanStream::generateFixedCodeMapping()
+{
+    mUsingFixedCodes = true;
+    mCodeLengthTable.setInputLengthSequence(HuffmanFixedCodes::getDeflateFixedHuffmanCodes(), false);
+    mCodeLengthTable.buildPrefixCodes();
+}
+
+bool HuffmanStream::readNextCodeLengthSymbol(unsigned& final_symbol)
+{
+    if (mCodeLengthTable.getNumCodeLengths() == 0)
+    {
+        return false;
+    }
+
+    unsigned working_index{0};
+    auto length = mCodeLengthTable.getCodeLength(working_index);
+    auto delta = length;
+
+    bool found{false};
+    unsigned char buffer{0};
+    uint32_t working_bits{0};
+    unsigned working_symbol{0};
+
+    while(!found)
+    {
+        auto valid = mInputStream->readNextNBits(delta, buffer);
+        //std::cout << "Got buffer " << ByteUtils::toString(buffer) << std::endl;;
+
+        working_bits = working_bits | (buffer << (length - delta));
+        std::cout << "Read " << delta << " bits with length " << length << " and value " << ByteUtils::toString(working_bits) << std::endl;
+
+        if (const auto symbol = mCodeLengthTable.findMatch(working_index, working_bits))
+        {
+            found = true;
+            working_symbol = *symbol;
+        }
+        else
+        {
+            working_index++;
+            if (working_index >= mCodeLengthTable.getNumCodeLengths())
+            {
+                break;
+            }
+
+            auto new_length = mCodeLengthTable.getCodeLength(working_index);
+            delta = new_length - length;
+            length = new_length;
+        }
+    }
+
+    if (found)
+    {
+        final_symbol = working_symbol;
+        std::cout << "Found symbol " << working_symbol << " with bits " << ByteUtils::toString(working_bits) << std::endl;
+        std::cout << "At Byte offset " << mInputStream->getCurrentByteOffset() << " and bit offset " << mInputStream->getCurrentBitOffset() << std::endl;
+        return true;
+    }
+    else
+    {
+        std::cout << "SYMBOL NOT FOUND " << " with bits " << ByteUtils::toString(working_bits) << std::endl;
+        return false;
+    }
+}
+
+void HuffmanStream::readLiteralCodeLengths()
+{
+    std::vector<unsigned> lengths;
+    unsigned symbol{0};
+
+    while(lengths.size() < mNumLiterals)
+    {
+        bool valid = readNextCodeLengthSymbol(symbol);
+
+        if (!valid)
+        {
+            std::cout << "Hit unknown symbol - bailing out" << std::endl;
+            break;
+        }
+
+        if (symbol < 16)
+        {
+            lengths.push_back(symbol);
+        }
+        else if(symbol == 16)
+        {
+            unsigned char num_reps{0};
+            mInputStream->readNextNBits(2, num_reps);
+
+            auto last_val = lengths[lengths.size()-1];
+            std::cout << "Got val 16 doing " << 3 + num_reps << std::endl;
+            for(unsigned idx=0; idx< 3 + num_reps; idx++)
+            {
+                lengths.push_back(last_val);
+            }
+        }
+        else if(symbol == 17)
+        {
+            unsigned char num_reps{0};
+            mInputStream->readNextNBits(3, num_reps);
+
+            std::cout << "Got val 17 doing " << 3 + num_reps << std::endl;
+            for(unsigned idx=0; idx< 3 + num_reps; idx++)
+            {
+                lengths.push_back(0);
+            }
+        }
+        else if(symbol == 18)
+        {
+            unsigned char num_reps{0};
+            mInputStream->readNextNBits(7, num_reps);
+
+            std::cout << "Got val 18 doing " << 11 + num_reps << std::endl;
+            for(unsigned idx=0; idx< 11 + num_reps; idx++)
+            {
+                lengths.push_back(0);
+            }
+        }
+    }
+}
+
+bool HuffmanStream::decode()
+{
+    if (!mUsingFixedCodes)
+    {
+        readCodingsTable();
+    }
+    else
+    {
+        bool found_end_seq{false};
+        unsigned symbol{0};
+        while(!found_end_seq)
+        {
+            bool valid = readNextCodeLengthSymbol(symbol);
+
+            if (!valid)
+            {
+                std::cout << "Hit unknown symbol - bailing out" << std::endl;
+                break;
+            }
+
+            if (symbol == 256)
+            {
+                found_end_seq = true;
+                break;
+            }
+        }
+    }
+
+
+
+    return false;
+}
+
+void HuffmanStream::readCodingsTable()
+{
+    unsigned char h_lit{0};
+    mInputStream->readNextNBits(5, h_lit);
+    mNumLiterals = h_lit + 257;
+    std::cout << "Got HLIT " << mNumLiterals << std::endl;
+
+    unsigned char h_dist{0};
+    mInputStream->readNextNBits(5, h_dist);
+    mNumDistances = h_dist + 1;
+    std::cout << "Got HDIST " << mNumDistances << std::endl;
+
+    unsigned char h_clen{0};
+    mInputStream->readNextNBits(4, h_clen);
+
+    auto num_code_lengths = h_clen + 4;
+    std::cout << "Got HCLEN " << num_code_lengths << std::endl;
+
+    auto sequence = std::vector<unsigned char>(num_code_lengths, 0);
+    unsigned char buffer{0};
+    for(unsigned idx = 0; idx< num_code_lengths; idx++)
+    {
+        std::cout << "After codings " << mInputStream->logLocation();
+        mInputStream->readNextNBits(3, buffer);
+        sequence[idx] = buffer;
+    }
+
+    mCodeLengthTable.setInputLengthSequence(sequence, true);
+    mCodeLengthTable.buildPrefixCodes();
+
+    readLiteralCodeLengths();
+}