Huffman and OpenMP

+ Completed Huffman integration
+ Added Bitstream realloc
+ Added progress bar when handling Blocks
+ Added Block parallelisation witrh OpenMP
+ Added class diagram

Author: ThenTech

.gitignore

@@ -35,4 +35,5 @@
 /bin/*.png
 /bin/ex*.txt
 /bin/*.enc
+/bin/*_dec.raw
 *.qbs.user*

BitStream.cpp

@@ -8,17 +8,23 @@ namespace util {
     BitStreamReader::~BitStreamReader() {}
 
     void BitStreamReader::flush() {
-        if (this->position % 8 != 0) {
-            this->position += 8 - (this->position % 8);
-        }
+        this->position = this->get_last_byte_position();
     }
 
     uint8_t BitStreamReader::get_bit() {
-        const size_t bits_taken = this->position % 8;
-        uint8_t value = this->buffer[this->position / 8];
-        value &= (1 << (7 - bits_taken));
+        const size_t current_start_byte = this->position / 8u;
+
+        if (current_start_byte >= this->get_size()) {
+            // Prevent reading byte outside of array (-> Valgrind flagged)
+            return 0u;
+        }
+
+        const size_t  bits_taken = this->position % 8;
+        const uint8_t value      = this->buffer[current_start_byte];
+
         this->position++;
-        return value != 0;
+
+        return (value & (1 << (7 - bits_taken))) != 0;
     }
 
     uint32_t BitStreamReader::get(size_t l) {

BitStream.hpp

@@ -22,7 +22,7 @@ namespace util {
 
             ~BitStream(void) {
                 if (this->managed) {
-                    this->clear();
+                    util::deallocArray(this->buffer);
                 }
             }
 
@@ -38,6 +38,10 @@ namespace util {
                 return this->size;
             }
 
+            inline size_t get_size_bits(void) const {
+                return this->size * 8u;
+            }
+
             inline void set_managed(bool m) {
                 this->managed = m;
             }
@@ -50,20 +54,34 @@ namespace util {
                 return this->position;
             }
 
+            inline size_t get_last_byte_position(void) const {
+                return util::round_to_byte(this->position);
+            }
+
             inline void reset(void) {
                 this->set_position(0);
             }
 
             /**
-             * Deallocate the buffer and reset all fields
+             *  @brief  Resize the internal buffer if needed.
+             *          Default resize is by 50% increase.
+             *  @param  new_size
+             *      The new size for the buffer.
+             *  @return Returns the size after resizing.
              */
-            void clear(void) {
-                if (this->buffer != nullptr) {
-                    util::deallocArray(this->buffer);
+            size_t resize(size_t new_size=0u) {
+                if (this->managed /*&& this->malloc*/) {
+                    if (new_size == 0) {
+                        // Resize by 50%
+                        new_size = this->size + this->size / 2u;
+                    } else if (new_size <= this->get_size()) {
+                        return this->get_size();
+                    }
+
+                    util::reallocArray(this->buffer, this->size, new_size);
                 }
 
-                this->position = 0;
-                this->size = 0;
+                return this->get_size();
             }
     };
 
@@ -150,15 +168,13 @@ namespace util {
              * Byte-align: Move the bitwise position pointer to the next byte boundary
              */
             void flush();
-
     };
 
     /**
      * Write the contents of the bitstream to the specified file
      */
     void write(FILE *f, const BitStreamWriter &b);
     void write(std::ofstream &fs, const BitStreamWriter &b);
-
 }
 #endif /* UTIL_BITSTREAM_H */
 

Debug/Debug.bg

@@ -16,7 +16,7 @@ dc::Decoder::Decoder(const std::string &source_file, const std::string &dest_fil
     : ImageProcessor(source_file, dest_file)
 {
     // Decoding info like (this->quant_m, this->use_rle, width, height)
-    // is gathered in the ImageProcessor ctor.
+    // is gathered in the ImageProcessor ctor after Huffman decompress.
 
     // Verify settings
     assert(this->width  % dc::BlockSize == 0);
@@ -26,9 +26,9 @@ dc::Decoder::Decoder(const std::string &source_file, const std::string &dest_fil
     const float hdrlen = float(this->reader->get_position()) / 8.0f;
     const float datlen = float(this->reader->get_size()) - hdrlen;
 
-    util::Logger::WriteLn(std::string_format("[Decoder] Loaded image with "
+    util::Logger::WriteLn(std::string_format("[Decoder] Loaded %dx%d image with "
                                              "%.1f bytes header and %.1f bytes data.",
-                                             hdrlen, datlen));
+                                             this->width, this->height, hdrlen, datlen));
 
     // Create the output buffer
     this->writer = util::allocVar<util::BitStreamWriter>(this->width * this->height);
@@ -59,7 +59,11 @@ bool dc::Decoder::process(void) {
 
     success = ImageProcessor::process(this->writer->get_buffer());
 
+    const size_t block_count = this->blocks->size();
+    size_t blockid = 0u;
+
     util::Logger::WriteLn("[Decoder] Processing Blocks...");
+    util::Logger::WriteProgress(0, block_count);
 
     #ifdef LOG_LOCAL
         size_t blockid = 0u;
@@ -83,15 +87,38 @@ bool dc::Decoder::process(void) {
             util::Logger::WriteLn("", false);
         }
     #else
-        for (Block<>* b : *this->blocks) {
-            b->loadFromStream(*this->reader, this->use_rle);
-            b->processIDCTMulQ(this->quant_m.getData());
-            b->expand();
-        }
+        #ifdef ENABLE_OPENMP
+            // Reading raw must happen in sequence
+            for (Block<>* b : *this->blocks) {
+                b->loadFromStream(*this->reader, this->use_rle);
+            }
+
+            #pragma omp parallel for shared(blockid) schedule(dynamic)
+            for (auto it = this->blocks->begin(); it < this->blocks->end(); it++) {
+                Block<> *b = *it;
+                b->processIDCTMulQ(this->quant_m.getData());
+                b->expand();
+
+                #pragma omp atomic
+                ++blockid;
+
+                #pragma omp critical
+                util::Logger::WriteProgress(blockid, block_count);
+            }
+        #else
+            for (Block<>* b : *this->blocks) {
+                b->loadFromStream(*this->reader, this->use_rle);
+                b->processIDCTMulQ(this->quant_m.getData());
+                b->expand();
+                util::Logger::WriteProgress(++blockid, block_count);
+            }
+        #endif
     #endif
 
+    util::Logger::WriteLn("", false);
+
     // Buffer is written implicitly
-    this->writer->set_position(this->writer->get_size() * 8u);
+    this->writer->set_position(this->writer->get_size_bits());
 
     return success;
 }

Decoder.cpp

@@ -72,11 +72,19 @@ bool dc::Encoder::process(void) {
                                              float(output_length) / 8.f));
 
     output_length += this->blocks->size() * this->blocks->front()->streamSize();
-    output_length += (8 - (output_length % 8u)) % 8u;         // Padding to next whole byte
-    output_length /= 8u;
+    #ifndef ENABLE_HUFFMAN
+        output_length++;    // Add one bit to signal Huffman is not enabled.
+    #endif
+
+    output_length = util::round_to_byte(output_length);     // Padding to next whole byte
+
 
     this->writer = util::allocVar<util::BitStreamWriter>(output_length);
 
+    #ifndef ENABLE_HUFFMAN
+        this->writer->put_bit(0); // '0': No Huffman sequence present.
+    #endif
+
     // Write matrix data first
     this->quant_m.write(*this->writer);
 
@@ -85,11 +93,13 @@ bool dc::Encoder::process(void) {
     this->writer->put(dc::ImageProcessor::DIM_BITS, this->width);
     this->writer->put(dc::ImageProcessor::DIM_BITS, this->height);
 
+    const size_t block_count = this->blocks->size();
+    size_t blockid = 0u;
+
     util::Logger::WriteLn("[Encoder] Processing Blocks...");
+    util::Logger::WriteProgress(0, block_count);
 
     #ifdef LOG_LOCAL
-        size_t blockid = 0u;
-
         for (Block<>* b : *this->blocks) {
             util::Logger::WriteLn(std::string_format("Block % 3d:", blockid++));
             b->printExpanded();
@@ -108,38 +118,63 @@ bool dc::Encoder::process(void) {
             util::Logger::WriteLn("", false);
         }
     #else
-        for (Block<>* b : *this->blocks) {
-            b->processDCTDivQ(this->quant_m.getData());
-            b->createRLESequence();
-            b->streamEncoded(*this->writer, this->use_rle);
-        }
+        #ifdef ENABLE_OPENMP
+            #pragma omp parallel for shared(blockid) schedule(dynamic)
+            for (auto it = this->blocks->begin(); it < this->blocks->end(); it++) {
+                Block<> *b = *it;
+                b->processDCTDivQ(this->quant_m.getData());
+                b->createRLESequence();
+
+                #pragma omp atomic
+                ++blockid;
+
+                #pragma omp critical
+                util::Logger::WriteProgress(blockid, block_count);
+            }
+
+            // Writing results must happen in sequence
+            for (Block<>* b : *this->blocks) {
+                b->streamEncoded(*this->writer, this->use_rle);
+            }
+        #else
+            for (Block<>* b : *this->blocks) {
+                b->processDCTDivQ(this->quant_m.getData());
+                b->createRLESequence();
+                b->streamEncoded(*this->writer, this->use_rle);
+                util::Logger::WriteProgress(++blockid, block_count);
+            }
+        #endif
     #endif
 
-    return success;
-}
-
-/**
- *  @brief  Save the resulting stream to the destination.
- */
-void dc::Encoder::saveResult(void) const {
+    util::Logger::WriteLn("", false);
 
-    util::Logger::WriteLn("\n", false);
+    #ifdef ENABLE_HUFFMAN
+        util::BitStreamReader hm_input(this->writer->get_buffer(),
+                                       this->writer->get_last_byte_position());
 
-    util::Logger::WriteLn("[Encoder] Huffman:");
-    algo::Huffman<> h;
+        algo::Huffman<> hm;
+        util::BitStreamWriter *hm_output = hm.encode(hm_input);
 
-    this->writer->flush();
-    util::BitStreamReader h_input(this->writer->get_buffer(), this->writer->get_position() / 8u);
+        #ifdef LOG_LOCAL
+            util::Logger::WriteLn("\n", false);
+            hm.printDict();
+            util::Logger::WriteLn("\n", false);
+        #endif
 
-    util::BitStreamWriter* h_stream = h.encode(h_input);
+        if (hm_output != nullptr) {
+            util::deallocVar(this->writer);
+            this->writer = hm_output;
+        }
 
-    #ifdef LOG_LOCAL
-        h.printDict();
+        util::Logger::WriteLn("", false);
     #endif
 
-    delete h_stream;
-
-    util::Logger::WriteLn("\n", false);
+    return success;
+}
 
+/**
+ *  @brief  Save the resulting stream to the destination.
+ */
+void dc::Encoder::saveResult(void) const {
     ImageProcessor::saveResult(true);
 }