Added initial test

siliconwitch · siliconwitch · commit 9eae8d15806e · 2025-01-30T18:34:58.000+01:00
Added header length calc code to compression core file
diff --git a/source/application/compression.c b/source/application/compression.c
@@ -25,6 +25,45 @@
 #include <stdlib.h>
 #include "compression.h"
 #include "lz4.h"
+#include "nrfx_log.h"
+
+#define LZ4F_MAGICNUMBER 0x184D2204U
+#define LZ4F_MAGIC_SKIPPABLE_START 0x184D2A50U
+#define LZ4F_MIN_SIZE_TO_KNOW_HEADER_LENGTH 5
+#define LZ4F_HEADER_SIZE_MIN 7
+
+static uint32_t LZ4F_readLE32(const void *src)
+{
+    const uint8_t *const srcPtr = (const uint8_t *)src;
+    uint32_t value32 = srcPtr[0];
+    value32 |= ((uint32_t)srcPtr[1]) << 8;
+    value32 |= ((uint32_t)srcPtr[2]) << 16;
+    value32 |= ((uint32_t)srcPtr[3]) << 24;
+    return value32;
+}
+
+size_t LZ4F_headerSize(const void *src, size_t srcSize)
+{
+    /* minimal srcSize to determine header size */
+    if (srcSize < LZ4F_MIN_SIZE_TO_KNOW_HEADER_LENGTH)
+        return -20;
+
+    /* special case : skippable frames */
+    if ((LZ4F_readLE32(src) & 0xFFFFFFF0U) == LZ4F_MAGIC_SKIPPABLE_START)
+        return 8;
+
+    /* control magic number */
+    if (LZ4F_readLE32(src) != LZ4F_MAGICNUMBER)
+        return -21;
+
+    /* Frame Header Size */
+    {
+        uint8_t const FLG = ((const uint8_t *)src)[4];
+        uint32_t const contentSizeFlag = (FLG >> 3) & 0x01;
+        uint32_t const dictIDFlag = FLG & 0x01;
+        return LZ4F_HEADER_SIZE_MIN + (contentSizeFlag ? 8 : 0) + (dictIDFlag ? 4 : 0);
+    }
+}
 
 int compression_decompress(size_t destination_size,
                            const void *source,
@@ -34,18 +73,24 @@ int compression_decompress(size_t destination_size,
 {
     int status = 0;
 
+    size_t header_size = LZ4F_headerSize(source, source_size);
+
+    if (header_size < 0)
+    {
+        return header_size;
+    }
+
     char *output_buffer = malloc(destination_size);
+
     if (output_buffer == NULL)
     {
         return -1;
     }
 
-    // TODO the frame header might not be 7
-    char *block_pointer = (char *)source + 7;
+    char *block_pointer = (char *)source + header_size;
 
     while (1)
     {
-
         int current_block_size = ((uint8_t)block_pointer[0]) +
                                  ((uint8_t)block_pointer[1] << 8) +
                                  ((uint8_t)block_pointer[2] << 16) +
diff --git a/source/application/lua_libraries/compression.c b/source/application/lua_libraries/compression.c
@@ -22,13 +22,82 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
+#include <string.h>
 #include "compression.h"
 #include "frame_lua_libraries.h"
 #include "lauxlib.h"
 #include "lua.h"
 #include "watchdog.h"
 
+/*
+ * Test steps:
+ *
+ * 1. Create a test file with some text
+ *
+ * 2. Compress the file
+ *
+ *    lz4 -9 -B32 test.txt test.lz4
+ *
+ * 3. Convert to header data
+ *
+ *    xxd -include test.lz4 test.h
+ *
+ * 4. Copy the header data to the test buffer below
+ */
+
+const unsigned char test_data[] = {
+    0x04, 0x22, 0x4d, 0x18, 0x64, 0x40, 0xa7, 0x24, 0x02, 0x00, 0x00, 0xf0,
+    0x30, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20,
+    0x69, 0x73, 0x20, 0x61, 0x20, 0x74, 0x65, 0x73, 0x74, 0x20, 0x66, 0x69,
+    0x6c, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74,
+    0x61, 0x69, 0x6e, 0x73, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x74, 0x65,
+    0x78, 0x74, 0x2e, 0x0a, 0x0a, 0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x49,
+    0x70, 0x73, 0x75, 0x6d, 0x35, 0x00, 0xc1, 0x73, 0x69, 0x6d, 0x70, 0x6c,
+    0x79, 0x20, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x23, 0x00, 0xf1, 0x0d, 0x20,
+    0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
+    0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x79, 0x70, 0x65,
+    0x73, 0x65, 0x74, 0x10, 0x00, 0xa8, 0x69, 0x6e, 0x64, 0x75, 0x73, 0x74,
+    0x72, 0x79, 0x2e, 0x20, 0x4b, 0x00, 0x81, 0x68, 0x61, 0x73, 0x20, 0x62,
+    0x65, 0x65, 0x6e, 0x3c, 0x00, 0x04, 0x23, 0x00, 0xb8, 0x27, 0x73, 0x20,
+    0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x62, 0x00, 0xa1, 0x65,
+    0x76, 0x65, 0x72, 0x20, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x2e, 0x00, 0xf2,
+    0x07, 0x31, 0x35, 0x30, 0x30, 0x73, 0x2c, 0x20, 0x77, 0x68, 0x65, 0x6e,
+    0x20, 0x61, 0x6e, 0x20, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x81,
+    0x00, 0xf1, 0x01, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x6f, 0x6b, 0x20, 0x61,
+    0x20, 0x67, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x9e, 0x00, 0x31, 0x79, 0x70,
+    0x65, 0x96, 0x00, 0xf2, 0x07, 0x73, 0x63, 0x72, 0x61, 0x6d, 0x62, 0x6c,
+    0x65, 0x64, 0x20, 0x69, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x6b,
+    0x65, 0x20, 0x61, 0x20, 0x00, 0xf1, 0x02, 0x73, 0x70, 0x65, 0x63, 0x69,
+    0x6d, 0x65, 0x6e, 0x20, 0x62, 0x6f, 0x6f, 0x6b, 0x2e, 0x20, 0x49, 0x74,
+    0xa2, 0x00, 0xf1, 0x1b, 0x73, 0x75, 0x72, 0x76, 0x69, 0x76, 0x65, 0x64,
+    0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x66, 0x69,
+    0x76, 0x65, 0x20, 0x63, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x69, 0x65, 0x73,
+    0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x9a, 0x00,
+    0xf8, 0x05, 0x6c, 0x65, 0x61, 0x70, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20,
+    0x65, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x0c, 0x01,
+    0x80, 0x2c, 0x20, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x17, 0x01, 0xf1,
+    0x06, 0x65, 0x73, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79,
+    0x20, 0x75, 0x6e, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x79, 0x00,
+    0xd0, 0x77, 0x61, 0x73, 0x20, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72,
+    0x69, 0x73, 0xad, 0x00, 0x02, 0x25, 0x01, 0xa1, 0x31, 0x39, 0x36, 0x30,
+    0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x0f, 0x00, 0x70, 0x72, 0x65, 0x6c,
+    0x65, 0x61, 0x73, 0x65, 0xe1, 0x00, 0xf4, 0x00, 0x4c, 0x65, 0x74, 0x72,
+    0x61, 0x73, 0x65, 0x74, 0x20, 0x73, 0x68, 0x65, 0x65, 0x74, 0x73, 0xc8,
+    0x01, 0x00, 0x66, 0x00, 0x08, 0x73, 0x01, 0x60, 0x70, 0x61, 0x73, 0x73,
+    0x61, 0x67, 0xb5, 0x00, 0x00, 0x0d, 0x01, 0x30, 0x6d, 0x6f, 0x72, 0x45,
+    0x00, 0x00, 0xcb, 0x00, 0x22, 0x6c, 0x79, 0x57, 0x00, 0xf0, 0x00, 0x64,
+    0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69,
+    0x73, 0x68, 0x40, 0x00, 0xf0, 0x15, 0x73, 0x6f, 0x66, 0x74, 0x77, 0x61,
+    0x72, 0x65, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x41, 0x6c, 0x64, 0x75,
+    0x73, 0x20, 0x50, 0x61, 0x67, 0x65, 0x4d, 0x61, 0x6b, 0x65, 0x72, 0x20,
+    0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x28, 0x00, 0x81, 0x76, 0x65, 0x72,
+    0x73, 0x69, 0x6f, 0x6e, 0x73, 0x8f, 0x00, 0xb0, 0x6f, 0x72, 0x65, 0x6d,
+    0x20, 0x49, 0x70, 0x73, 0x75, 0x6d, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x31,
+    0xb8, 0x0d, 0xa8};
+
 static int registered_function = 0;
+static uint8_t decompression_buffer[4096];
+static size_t decompression_buffer_size = 0;
 
 static void decompression_lua_handler(lua_State *L, lua_Debug *ar)
 {
@@ -38,9 +107,11 @@ static void decompression_lua_handler(lua_State *L, lua_Debug *ar)
     {
         lua_rawgeti(L, LUA_REGISTRYINDEX, registered_function);
 
-        // TODO: Add the data to the function call if it's not already added
+        lua_pushlstring(L,
+                        (char *)decompression_buffer,
+                        decompression_buffer_size);
 
-        if (lua_pcall(L, 0, 0, 0) != LUA_OK)
+        if (lua_pcall(L, 1, 0, 0) != LUA_OK)
         {
             luaL_error(L, "%s", lua_tostring(L, -1));
         }
@@ -51,7 +122,10 @@ static void process_function_callback(void *context,
                                       void *data,
                                       size_t data_size)
 {
-    // TODO copy the data to a buffer
+    decompression_buffer_size = data_size;
+    memcpy(decompression_buffer, data, data_size);
+
+    LOG("decompression_buffer_size: %d", decompression_buffer_size);
 
     lua_sethook(L_global,
                 decompression_lua_handler,
@@ -80,14 +154,22 @@ static int lua_compression_register_process_function(lua_State *L)
 
 static int lua_compression_decompress(lua_State *L)
 {
-    int status = compression_decompress(4096,      // TODO figure out destination size
-                                        NULL,      // TODO pass the source data to the decompression function
-                                        sizeof(0), // TODO set the source data size
+    lua_Integer block_size = luaL_checkinteger(L, 1);
+
+    if (block_size <= 0)
+    {
+        luaL_error(L, "bytes must be greater than 0");
+    }
+
+    int status = compression_decompress(block_size,
+                                        test_data,         // TODO pass the source data to the decompression function
+                                        sizeof(test_data), // TODO set the source data size
                                         process_function_callback,
                                         NULL);
 
-    if (status != 0)
+    if (status)
     {
+        LOG("%d", status);
         luaL_error(L, "decompression failed");
     }
 
diff --git a/tests/test_compression.py b/tests/test_compression.py
@@ -0,0 +1,20 @@
+import asyncio
+from frameutils import Bluetooth
+
+
+async def main():
+    b = Bluetooth()
+
+    await b.connect(print_response_handler=lambda s: print(s))
+
+    await b.send_lua("function process_function(data) print(data) end")
+    await b.send_lua("frame.compression.process_function(process_function)")
+    await b.send_lua("frame.compression.decompress(1024)")
+    await b.send_lua("process_function(1)")
+
+    await asyncio.sleep(1)
+
+    await b.disconnect()
+
+
+asyncio.run(main())
