How to do memory implementation of Huffman Agorithm?

Question

I have a Huffman code algorithm that compresses characters into sequences of bits of arbitrary length, smaller than the default size of a char (8 bits on most modern platforms)

If the Huffman Code compresses an 8-bit character into 3 bits, how do I represent that 3-bit value in memory? To take this further, how do I combine multiple compressed characters into a compressed representation?

For example consider l which is "00000" (5x8 bits since 0 is also character). How do I represent l with 00000 (5 bits) instead of a character sequence?

A C or C++ implementation is preferred.

Answer 1

Now that this question is re-opened...

To make a variable that holds a variable number of bits, we just use use the lower bits of one unsigned int to store the bits, and use another unsigned int to remember how many bits we have stored.

When writing out a Huffman-compressed file, we wait until we have at least 8 bits stored. Then we write out a char using the top 8 bits and subtract 8 from the stored bit count.

Finally, at the end if you have any bits left to write out, you round up to an even multiple of 8 and write chars.

In C++, it's useful to encapsulate the output in some kind of BitOutputStream class, like:

class BitOutputStream
{
    std::ostream m_out;
    unsigned m_bitsPending;
    unsigned m_numPending;

    public:
    BitOutputStream(const char *fileName)
        :m_out(... /* you can do this part */)
    {
        m_bitsPending = 0;
        m_numPending = 0;
    }

    // write out the lower <count> bits of <bits>
    void write(unsigned bits, unsigned count)
    {
       if (count > 16)
       {
           //do it in two steps to prevent overflow
           write(bits>>16, count-16);
           count=16;
       }
       //make space for new bits
       m_numPending += count;
       m_bitsPending <<= count;

       //store new bits
       m_bitsPending |= (bits & ((1<<count)-1));

       //write out any complete bytes
       while(m_numPending >= 8)
       {
           m_numPending-=8;
           m_out.put((char)(m_bitsPending >> m_numPending));
       }
    }

    //write out any remaining bits
    void flush()
    {
        if (m_numPending > 0)
        {
            m_out.put((char)(m_bitsPending << (8-m_numPending)));
        }
        m_bitsPending = m_numPending = 0;
        m_out.flush();
    }
}

Answer 2

If your Huffman coder returns an array of 1s and 0s representing the bits that should and should not be set in the output, you can shift these bits onto an unsigned char. Every eight shifts, you start writing to the next character, ultimately outputting an array of unsigned char. The number of these compressed characters that you will output is equal to the number of bits divided by eight, rounded up to the nearest natural number.

In C, this is a relatively simple function, consisting of a left shift (<<) and a bitwise OR (|). Here is the function, with an example to make it runnable. To see it with more extensive comments, please refer to this GitHub gist.

#include <stdlib.h>
#include <stdio.h>

#define BYTE_SIZE 8

size_t compress_code(const int *code, const size_t code_length, unsigned char **compressed)
{
    if (code == NULL || code_length == 0 || compressed == NULL) {
        return 0;
    }
    size_t compressed_length = (code_length + BYTE_SIZE - 1) / BYTE_SIZE;
    *compressed = calloc(compressed_length, sizeof(char));
    for (size_t char_counter = 0, i = 0; char_counter < compressed_length && i < code_length; ++i) {
        if (i > 0 && (i % BYTE_SIZE) == 0) {
            ++char_counter;
        }
        // Shift the last bit to be set left by one
        (*compressed)[char_counter] <<= 1;
        // Put the next bit onto the end of the unsigned char
        (*compressed)[char_counter] |= (code[i] & 1);
    }
    // Pad the remaining space with 0s on the right-hand-side
    (*compressed)[compressed_length - 1] <<= compressed_length * BYTE_SIZE - code_length;
    return compressed_length;
}

int main(void)
{
    const int code[] = { 0, 1, 0, 0, 0, 0, 0, 1,   // 65: A
                         0, 1, 0, 0, 0, 0, 1, 0 }; // 66: B
    const size_t code_length = 16;
    unsigned char *compressed = NULL;
    size_t compressed_length = compress_code(code, code_length, &compressed);
    for (size_t i = 0; i < compressed_length; ++i) {
        printf("%c\n", compressed[i]);
    }
    return 0;
}

You can then just write the characters in the array to a file, or even copy the array's memory directly to a file, to write the compressed output.

Reading the compressed characters into bits, which will allow you to traverse your Huffman tree for decoding, is done with right shifts (>>) and checking the rightmost bit with bitwise AND (&).