add lz4hc compression

Author: mateoconlechuga

Makefile

@@ -75,12 +75,13 @@ SOURCES = $(SRCDIR)/appvar.c \
           $(DEPDIR)/zx/zx7/compress.c \
           $(DEPDIR)/zx/zx0/compress.c \
           $(DEPDIR)/libyaml/src/api.c \
-          $(DEPDIR)/lz4/lib/lz4.c \
           $(DEPDIR)/libyaml/src/dumper.c \
           $(DEPDIR)/libyaml/src/loader.c \
           $(DEPDIR)/libyaml/src/parser.c \
           $(DEPDIR)/libyaml/src/reader.c \
           $(DEPDIR)/libyaml/src/scanner.c \
+          $(DEPDIR)/lz4/lib/lz4.c \
+          $(DEPDIR)/lz4/lib/lz4hc.c \
           $(DEPDIR)/tinycthread/source/tinycthread.c
 
 ifeq ($(OS),Windows_NT)

README.md

@@ -343,12 +343,15 @@ It primarily is used for the TI-84+CE and related calculator series, however can
         These different compression modes can be used to achieve different results.
         Some provide better compression ratio at the cost of slower compression,
         and potentially slower decompression as well.
+        The following are ranked from best to worst exprected compression ratio.
 
-           "zx0"                    : Best ratio, slowest (de)compression
+           "zx0"                    : Slowest compression time
 
-           "zx7"                    : Moderate ratio, moderate (de)compression
+           "zx7"                    : Moderate compression time
 
-           "lz4"                    : Worst ratio, fastest (de)compression
+           "lz4hc"                  : Moderate compression time
+
+           "lz4"                    : Fastest compression time
 
     --------------------------------------------------------------------------------
 

src/compress.c

@@ -35,7 +35,9 @@
 #include "deps/zx/zx7/zx7.h"
 #include "deps/zx/zx0/zx0.h"
 #include "deps/lz4/lib/lz4.h"
+#include "deps/lz4/lib/lz4hc.h"
 
+#include <stdbool.h>
 #include <string.h>
 
 #define LZ4_SIZE_PREFIX_BYTES 3
@@ -98,7 +100,7 @@ static uint8_t *compress_zx0(void *data, size_t *size)
     return compressed_data;
 }
 
-static uint8_t *compress_lz4(void *data, size_t *size)
+static uint8_t *compress_lz4_block(void *data, size_t *size, bool high_compression)
 {
     uint8_t *compressed_data;
     const char *input;
@@ -130,8 +132,16 @@ static uint8_t *compress_lz4(void *data, size_t *size)
         return NULL;
     }
 
-    compressed_size = LZ4_compress_default(input, (char *)(compressed_data + LZ4_SIZE_PREFIX_BYTES),
-                                           input_size, max_compressed_size);
+    if (high_compression)
+    {
+        compressed_size = LZ4_compress_HC(input, (char *)(compressed_data + LZ4_SIZE_PREFIX_BYTES),
+                                          input_size, max_compressed_size, LZ4HC_CLEVEL_MAX);
+    }
+    else
+    {
+        compressed_size = LZ4_compress_default(input, (char *)(compressed_data + LZ4_SIZE_PREFIX_BYTES),
+                                               input_size, max_compressed_size);
+    }
 
     if (compressed_size <= 0)
     {
@@ -152,13 +162,24 @@ static uint8_t *compress_lz4(void *data, size_t *size)
     compressed_data[2] = (uint8_t)((compressed_size >> 16) & 0xFF);
 
     total_size = (size_t)compressed_size + LZ4_SIZE_PREFIX_BYTES;
-    LOG_DEBUG("Compressed size: %zu -> %zu (lz4 block)\n", orig_size, total_size);
+    LOG_DEBUG("Compressed size: %zu -> %zu (lz4%s block)\n",
+              orig_size, total_size, high_compression ? "hc" : "");
 
     *size = total_size;
 
     return compressed_data;
 }
 
+static uint8_t *compress_lz4(void *data, size_t *size)
+{
+    return compress_lz4_block(data, size, false);
+}
+
+static uint8_t *compress_lz4hc(void *data, size_t *size)
+{
+    return compress_lz4_block(data, size, true);
+}
+
 uint8_t *compress_array(uint8_t *data, size_t *size, compress_mode_t mode)
 {
     switch (mode)
@@ -172,6 +193,9 @@ uint8_t *compress_array(uint8_t *data, size_t *size, compress_mode_t mode)
         case COMPRESS_LZ4:
             return compress_lz4(data, size);
 
+        case COMPRESS_LZ4HC:
+            return compress_lz4hc(data, size);
+
         default:
             return NULL;
     }

src/compress.h

@@ -44,6 +44,7 @@ typedef enum
     COMPRESS_ZX7,
     COMPRESS_ZX0,
     COMPRESS_LZ4,
+    COMPRESS_LZ4HC,
 } compress_mode_t;
 
 uint8_t *compress_array(uint8_t *data, size_t *size, compress_mode_t mode);

src/options.c

@@ -383,12 +383,15 @@ static void options_show(const char *prgm)
     LOG_PRINT("    These different compression modes can be used to achieve different results.\n");
     LOG_PRINT("    Some provide better compression ratio at the cost of slower compression,\n");
     LOG_PRINT("    and potentially slower decompression as well.\n");
+    LOG_PRINT("    The following are ranked from best to worst exprected compression ratio.\n");
     LOG_PRINT("\n");
-    LOG_PRINT("       \"zx0\"                    : Best ratio, slowest (de)compression\n");
+    LOG_PRINT("       \"zx0\"                    : Slowest compression time\n");
     LOG_PRINT("\n");
-    LOG_PRINT("       \"zx7\"                    : Moderate ratio, moderate (de)compression\n");
+    LOG_PRINT("       \"zx7\"                    : Moderate compression time\n");
     LOG_PRINT("\n");
-    LOG_PRINT("       \"lz4\"                    : Worst ratio, fastest (de)compression\n");
+    LOG_PRINT("       \"lz4hc\"                  : Moderate compression time\n");
+    LOG_PRINT("\n");
+    LOG_PRINT("       \"lz4\"                    : Fastest compression time\n");
     LOG_PRINT("\n");
     LOG_PRINT("--------------------------------------------------------------------------------\n");
     LOG_PRINT("\n");

src/parser.c

@@ -76,6 +76,10 @@ static compress_mode_t parse_compression_mode(void *value)
     {
         return COMPRESS_LZ4;
     }
+    else if (parse_str_cmp("lz4hc", value))
+    {
+        return COMPRESS_LZ4HC;
+    }
 
     return COMPRESS_NONE;
 }