Toward first png.

src/compression/CyclicRedundancyChecker.cpp

@@ -0,0 +1,42 @@
+#include "CyclicRedundancyChecker.h"
+
+void CyclicRedundancyChecker::createTable()
+{
+    unsigned long c{0};
+    for (int n = 0; n < 256; n++)
+    {
+        c = (unsigned long) n;
+        for (int k = 0; k < 8; k++)
+        {
+            if (c & 1)
+            {
+                c = 0xedb88320L ^ (c >> 1);
+            }
+            else
+            {
+                c = c >> 1;
+            }
+        }
+        mTable[n] = c;
+    }
+    mTableComputed = true;
+}
+
+void CyclicRedundancyChecker::addValue(unsigned char val)
+{
+    if (!mTableComputed)
+    {
+        createTable();
+    }
+    mLastValue = mTable[(mLastValue ^ val) & 0xff] ^ (mLastValue >> 8);
+}
+
+uint32_t CyclicRedundancyChecker::getChecksum() const
+{
+    return mLastValue ^ 0xffffffffL;
+}
+
+void CyclicRedundancyChecker::reset()
+{
+    mLastValue = 0xffffffffL;
+}

src/compression/CyclicRedundancyChecker.h

@@ -1,52 +1,20 @@
 #pragma once
 
-class CyclicRedundancyChecker
+#include "AbstractChecksumCalculator.h"
+
+class CyclicRedundancyChecker : public AbstractChecksumCalculator
 {
 public:
+    void addValue(unsigned char val) override;
 
-    void createTable()
-    {
-        unsigned long c{0};
-        for (int n = 0; n < 256; n++)
-        {
-            c = (unsigned long) n;
-            for (int k = 0; k < 8; k++)
-            {
-                if (c & 1)
-                {
-                    c = 0xedb88320L ^ (c >> 1);
-                }
-                else
-                {
-                    c = c >> 1;
-                }
-            }
-            mTable[n] = c;
-        }
-        mTableComputed = true;
-        mTableComputed = 1;
-    }
+    uint32_t getChecksum() const override;
 
-    unsigned long updateCrc(unsigned long crc, unsigned char *buf, int len)
-    {
-        unsigned long c = crc;
-        if (!mTableComputed)
-        {
-            createTable();
-        }
-        for (int n = 0; n < len; n++)
-        {
-            c = mTable[(c ^ buf[n]) & 0xff] ^ (c >> 8);
-        }
-        return c;
-    }
-
-    unsigned long doCrc(unsigned char *buf, int len)
-    {
-        return updateCrc(0xffffffffL, buf, len) ^ 0xffffffffL;
-    }
+    void reset() override;
 
 private:
+    void createTable();
     bool mTableComputed{false};
+
+    uint32_t mLastValue{0xffffffffL};
     unsigned long mTable[256];
 };

src/compression/ZlibEncoder.cpp

@@ -61,10 +61,16 @@ void ZlibEncoder::parseCompressionMethod(unsigned char method)
     }
 }
 
-void ZlibEncoder::parseExtraFlags(unsigned char extraFlags)
+void ZlibEncoder::parseExtraFlags(unsigned char extraFlags, unsigned char compression_byte)
 {
     std::cout << "Got flags  " << static_cast<int>(extraFlags) << std::endl;
 
+    auto mod = ((static_cast<unsigned>(compression_byte) << 8) | extraFlags) % 31;
+    if (mod != 0)
+    {
+        std::cout << "Invalid header. Mod is " << mod << std::endl;
+    }
+
     mFlagCheck = ByteUtils::getLowerNBits(extraFlags, 5);
     mUseDictionary = bool(ByteUtils::getBitN(extraFlags, 5));
     mFlagLevel = static_cast<CompressionLevel>(ByteUtils::getHigherNBits(extraFlags, 2));
@@ -76,11 +82,10 @@ std::string ZlibEncoder::getData() const
     sstream << "ZlibEncoder data \n";
     sstream << "Compression method: " << toString(mCompressionMethod) << '\n';
     sstream << "Window size: " << mWindowSize << '\n';
-    sstream << "Flag check: " << mFlagCheck << '\n';
+    sstream << "Flag check: " << static_cast<int>(mFlagCheck) << '\n';
     sstream << "Use dictionary: " << mUseDictionary << '\n';
     sstream << "Flag level: " << toString(mFlagLevel) << '\n';
     return sstream.str();
-
 }
 
 bool ZlibEncoder::encode()
@@ -126,15 +131,17 @@ bool ZlibEncoder::encode()
     }
 
     const auto checksum = mChecksumCalculator->getChecksum();
-    std::cout << "ZlibEncoder Writing Checksum " << checksum << std::endl;
+    std::cout << "ZlibEncoder Writing Adler32 Checksum " << checksum << std::endl;
     mOutputStream->write(checksum);
     return true;
 }
 
 bool ZlibEncoder::decode()
 {
-    parseCompressionMethod(*mInputStream->readNextByte());
-    parseExtraFlags(*mInputStream->readNextByte());
+    auto compression_byte = *mInputStream->readNextByte();
+
+    parseCompressionMethod(compression_byte);
+    parseExtraFlags(*mInputStream->readNextByte(), compression_byte);
 
     if (!mWorkingEncoder)
     {
@@ -149,5 +156,15 @@ bool ZlibEncoder::decode()
         }
     }
 
-    return mWorkingEncoder->decode();
+    auto valid = mWorkingEncoder->decode();
+
+    unsigned char byte0 = *mInputStream->readNextByte();
+    unsigned char byte1 = *mInputStream->readNextByte();
+    unsigned char byte2 = *mInputStream->readNextByte();
+    unsigned char byte3 = *mInputStream->readNextByte();
+
+    uint32_t adler32 = (byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3;
+    std::cout << "Got adler 32 checksum " << adler32 << std::endl;
+
+    return valid;
 }

src/compression/ZlibEncoder.h

@@ -40,7 +40,7 @@ public:
 
 private:
     void parseCompressionMethod(unsigned char method);
-    void parseExtraFlags(unsigned char extraFlags);
+    void parseExtraFlags(unsigned char extraFlags, unsigned char compression_byte);
 
     CompressionMethod mCompressionMethod{CompressionMethod::DEFLATE};
     Deflate::CompressionMethod mDeflateCompressionMethod{Deflate::CompressionMethod::NONE};

src/compression/deflate/DeflateBlock.cpp

@@ -261,7 +261,7 @@ void DeflateBlock::write(uint16_t datalength)
 {
     unsigned char working_block{0};
     working_block |= static_cast<unsigned char>(mInFinalBlock);
-    working_block |= static_cast<unsigned char>(mCompressionMethod) << 1;
+    working_block |= (static_cast<unsigned char>(mCompressionMethod) << 1);
 
     if (mCompressionMethod == Deflate::CompressionMethod::NONE)
     {
@@ -277,7 +277,7 @@ void DeflateBlock::write(uint16_t datalength)
         for(unsigned idx=0; idx<datalength;idx++)
         {
             auto byte = *mInputStream->readNextByte();
-            std::cout << "Writing next byte " << static_cast<int>(byte) << std::endl;
+            //std::cout << "Writing next byte " << static_cast<int>(byte) << std::endl;
             mOutputStream->writeByte(byte);
         }
     }

src/compression/deflate/DeflateEncoder.cpp

@@ -66,6 +66,8 @@ bool DeflateEncoder::decode()
     auto working_block = std::make_unique<DeflateBlock>(mInputStream, mOutputStream);
     working_block->readHeader();
 
+    std::cout << working_block->getMetaData() << std::endl;
+
     DeflateBlock* raw_block = working_block.get();
 
     while(!raw_block->isFinalBlock())