move common huffman code in adhuff_common.c

fix byte to bit transformation

Author: code-mds

.gitignore

@@ -52,3 +52,4 @@ Mkfile.old
 dkms.conf
 cmake-build-debug/*
 .idea/workspace.xml
+.DS_Store

CMakeLists.txt

@@ -3,4 +3,4 @@ project(algo C)
 
 set(CMAKE_C_STANDARD 99)
 
-add_executable(algo main.c node.c node.h test.c test.h bin_io.c bin_io.h adhuff_compress.c adhuff_compress.h adhuff_decompress.c adhuff_decompress.h constants.h adhuff_common.h)
+add_executable(algo main.c test.c test.h bin_io.c bin_io.h adhuff_compress.c adhuff_compress.h adhuff_decompress.c adhuff_decompress.h constants.h adhuff_common.h adhuff_common.c)

README.md

@@ -19,4 +19,9 @@ xxd -b ../test-res/ff_ff_ff
 ```
 
 ### ASCII table
-https://en.wikipedia.org/wiki/ASCII
+https://en.wikipedia.org/wiki/ASCII
+
+```
+'A' = 01000001
+idx = 01234567
+```

node.c renamed to adhuff_common.c

@@ -1,18 +1,26 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "node.h"
+#include "adhuff_common.h"
 #include "bin_io.h"
 
-
-/*
- * module variables
- */
+//
+// module variables
+//
 
 static unsigned short _nextOrder = MAX_ORDER;
 static Node * adh_root_node = NULL;
 static Node * adh_nyt_node = NULL;
 
+//
+// private methods
+//
+Node * createNYT();
+Node * createNode(unsigned short value);
+void destroyNode(Node * node);
+Node * searchCharFromNode(Node * node, unsigned short ch);
+
+
 /*
  * Initialize the tree with a single NYT node
  */

adhuff_common.h

@@ -1,9 +1,11 @@
 #ifndef ALGO_ADHUFF_COMMON_H
 #define ALGO_ADHUFF_COMMON_H
 
-#define HEADER_BITS 3
-#define HEADER_DATA_BITS 5
+#include "constants.h"
 
+/*
+ * Header of compressed file
+ */
 #pragma pack(1)
 typedef struct
 {
@@ -18,5 +20,33 @@ typedef union
 } first_byte_union;
 #pragma pack()
 
+/*
+ * Node struct
+ */
+struct Node {
+    unsigned short value;
+    unsigned int weight;
+    unsigned short order;
+    struct Node *left;
+    struct Node *right;
+    struct Node *parent;
+};
+typedef struct Node Node;
+
+//
+// public methods
+//
+int     initializeTree();
+void    destroyTree();
+
+void    updateTree(Node * node, bool isNewNode);
+
+Node *  searchCharInTree(unsigned short ch);
+
+Node *  createNodeAndAppend(unsigned short ch);
+
+int     getNYTCode(unsigned char bit_array[]);
+int     getSymbolCode(unsigned short ch, unsigned char bit_array[]);
+
 
 #endif //ALGO_ADHUFF_COMMON_H

adhuff_compress.c

@@ -2,21 +2,19 @@
 #include "adhuff_common.h"
 #include "constants.h"
 #include "bin_io.h"
-#include "node.h"
-#include "node.h"
 
-/*
- * modules variables
- */
-static unsigned char output_buffer[BLOCK_SIZE];
+//
+// modules variables
+//
+static unsigned char output_buffer[BUFFER_SIZE];
 static unsigned short buffer_bit_idx;
 
 static FILE * outputFilePtr;
 
-/*
- * Private methods
- */
-void processChar(unsigned char ch);
+//
+// private methods
+//
+void encodeChar(unsigned char ch);
 void outputBitArray(const unsigned char bit_array[], int num_bit);
 void outputChar(unsigned char ch);
 void flushData();
@@ -31,15 +29,15 @@ int compressFile(const char * input_file, const char * output_file) {
 
     FILE * inputFilePtr = openReadBinary(input_file);
     if (inputFilePtr == NULL) {
-        return 1;
+        return RC_FAIL;
     }
 
     outputFilePtr = openWriteBinary(output_file);
     if (outputFilePtr == NULL) {
-        return 1;
+        return RC_FAIL;
     }
 
-    unsigned char buffer[BLOCK_SIZE];
+    unsigned char buffer[BUFFER_SIZE];
 
     int rc = initializeTree();
     if (rc == 0) {
@@ -49,7 +47,7 @@ int compressFile(const char * input_file, const char * output_file) {
         while ((bytesRead = fread(buffer, 1, sizeof(buffer), inputFilePtr)) > 0)
         {
             for(int i=0;i<bytesRead;i++)
-                processChar(buffer[i]);
+                encodeChar(buffer[i]);
         }
 
 
@@ -69,26 +67,10 @@ int compressFile(const char * input_file, const char * output_file) {
     return rc;
 }
 
-
-void flushHeader() {
-    rewind(outputFilePtr);
-
-    unsigned char buffer[1];
-    fread(buffer, 1, 1, outputFilePtr);
-
-    first_byte_union first_byte;
-    first_byte.raw = buffer[0];
-    first_byte.split.header = buffer_bit_idx % CHAR_BIT;
-
-    traceCharBinMsg("flushHeader: ", first_byte.raw);
-
-    fwrite(&first_byte.raw, 1, 1, outputFilePtr);
-}
-
 /*
- * Process char
+ * encode char
  */
-void processChar(unsigned char ch) {
+void encodeChar(unsigned char ch) {
     traceCharBinMsg("processChar: ", ch);
     unsigned char bit_array[MAX_CODE_SIZE];
 
@@ -125,7 +107,7 @@ void processChar(unsigned char ch) {
 void outputChar(unsigned char ch) {
     traceCharBinMsg("outputChar: ", ch);
 
-    unsigned char bit_array[CHAR_BIT];
+    unsigned char bit_array[CHAR_BIT+1];
     for (int bitPos = CHAR_BIT-1; bitPos >= 0; --bitPos) {
         char val = bit_check(ch, bitPos);
         bit_array[bitPos] = val;
@@ -140,13 +122,13 @@ void outputChar(unsigned char ch) {
 void outputBitArray(const unsigned char bit_array[], int num_bit) {
     trace("outputBitArray: %d\n", num_bit);
 
-    for(int i = num_bit; i>0; i--) {
+    for(int i = num_bit-1; i>=0; i--) {
 
         // calculate the current position (in byte) of the output_buffer
         unsigned int buffer_byte_idx = buffer_bit_idx / CHAR_BIT;
 
         // calculate which bit to change in the byte
-        int bit_to_change = buffer_bit_idx % CHAR_BIT;
+        unsigned int bit_to_change = CHAR_BIT - 1 - (buffer_bit_idx % CHAR_BIT);
 
         if(bit_array[i] == BIT_1)
             bit_set_one(&output_buffer[buffer_byte_idx], bit_to_change);
@@ -156,7 +138,7 @@ void outputBitArray(const unsigned char bit_array[], int num_bit) {
         buffer_bit_idx++;
 
         // buffer full, flush data to file
-        if(buffer_bit_idx == BLOCK_SIZE * CHAR_BIT) {
+        if(buffer_bit_idx == BUFFER_SIZE * CHAR_BIT) {
             flushData();
 
             // reset buffer index
@@ -183,4 +165,22 @@ void flushData() {
 
     // TODO check error code
     size_t bytesWritten = fwrite(output_buffer, buffer_byte_idx, 1, outputFilePtr);
-}
+}
+
+/*
+ * flush header to file
+ */
+void flushHeader() {
+    rewind(outputFilePtr);
+
+    unsigned char buffer[1];
+    fread(buffer, 1, 1, outputFilePtr);
+
+    first_byte_union first_byte;
+    first_byte.raw = buffer[0];
+    first_byte.split.header = buffer_bit_idx % CHAR_BIT;
+
+    traceCharBinMsg("flushHeader: ", first_byte.raw);
+
+    fwrite(&first_byte.raw, 1, 1, outputFilePtr);
+}

adhuff_compress.h

@@ -1,6 +1,9 @@
 #ifndef ALGO_ADHUFF_COMPRESS_H
 #define ALGO_ADHUFF_COMPRESS_H
 
+//
+// public methods
+//
 int compressFile(const char *input_file, const char *output_file);
 
 #endif //ALGO_ADHUFF_COMPRESS_H

adhuff_decompress.c

@@ -4,14 +4,12 @@
 #include "adhuff_common.h"
 #include "constants.h"
 #include "bin_io.h"
-#include "node.h"
-#include "node.h"
 
 /*
  * modules variables
  */
 static FILE * outputFilePtr;
-static unsigned char output_buffer[BLOCK_SIZE];
+static unsigned char output_buffer[BUFFER_SIZE];
 static unsigned short buffer_bit_idx;
 static unsigned int oddBits;
 
@@ -30,12 +28,12 @@ int decompressFile(const char *input_file, const char *output_file) {
 
     FILE * inputFilePtr = openReadBinary(input_file);
     if (inputFilePtr == NULL) {
-        return 1;
+        return RC_FAIL;
     }
 
     outputFilePtr = openWriteBinary(output_file);
     if (outputFilePtr == NULL) {
-        return 1;
+        return RC_FAIL;
     }
 
     int rc = initializeTree();
@@ -47,7 +45,7 @@ int decompressFile(const char *input_file, const char *output_file) {
         bool firstChar = true;
         int byteToRead = 1;
 
-        unsigned char buffer[BLOCK_SIZE];
+        unsigned char buffer[BUFFER_SIZE];
 
         // read up to sizeof(buffer) bytes
         while ((bytesRead = fread(buffer, byteToRead, 1, inputFilePtr)) > 0)

adhuff_decompress.h

@@ -1,6 +1,9 @@
 #ifndef ALGO_ADHUFF_DECOMPRESS_H
 #define ALGO_ADHUFF_DECOMPRESS_H
 
+//
+// public methods
+//
 int decompressFile(const char *input_file, const char *output_file);
 
 #endif //ALGO_ADHUFF_DECOMPRESS_H

bin_io.c

@@ -32,8 +32,10 @@ FILE* openWriteBinary(const char * filename) {
  */
 int readBinaryFile(const char *filename, void (*processChar)(unsigned char)) {
     FILE * filePtr = openReadBinary(filename);
+    if(filePtr == NULL)
+        return RC_FAIL;
 
-    unsigned char buffer[BLOCK_SIZE];
+    unsigned char buffer[BUFFER_SIZE];
     size_t bytesRead = 0;
     // read up to sizeof(buffer) bytes
     while ((bytesRead = fread(buffer, 1, sizeof(buffer), filePtr)) > 0)
@@ -42,14 +44,14 @@ int readBinaryFile(const char *filename, void (*processChar)(unsigned char)) {
             processChar(buffer[i]);
     }
     fclose(filePtr);
-    return 0;
+    return RC_OK;
 }
 
 /*
  * Diagnostic functions
  */
 void traceCharBin(unsigned char ch) {
-    for (int bitPos = 7; bitPos >= 0; --bitPos) {
+    for (int bitPos = CHAR_BIT-1; bitPos >= 0; --bitPos) {
         char val = bit_check(ch, bitPos);
         putchar(val);
     }
@@ -73,20 +75,20 @@ void trace(const char *msg, ...) {
 /*
  * return '1' if the bit at bit_pos is 1, otherwise '0'
  */
-char bit_check(unsigned char ch, unsigned int bit_pos) {
+char bit_check(unsigned char ch, int bit_pos) {
     unsigned int val = (ch & (1u << bit_pos));
     return val ? BIT_1 : BIT_0;
 }
 
-void bit_set_one(unsigned char * ch, unsigned int bit_pos) {
+void bit_set_one(unsigned char * ch, int bit_pos) {
     *ch |= (1u << bit_pos);
 }
 
-void bit_set_zero(unsigned char * ch, unsigned int bit_pos) {
+void bit_set_zero(unsigned char * ch, int bit_pos) {
     *ch  &= ~(1u << bit_pos);
 }
 
-void bit_copy(unsigned char * byte_to, unsigned char byte_from, unsigned int read_pos, unsigned int write_pos, unsigned int size) {
+void bit_copy(unsigned char * byte_to, unsigned char byte_from, int read_pos, int write_pos, int size) {
     for(unsigned int offset=0; offset < size; offset++) {
 
         unsigned int from = read_pos + offset;