SIYI_tools: added compression code

Author: tridge

SIYI_tools/thermal_socket/Makefile

@@ -1,6 +1,13 @@
-CFLAGS = -static
+CFLAGS = -static -Wall -Wextra -g3
 
 CC=arm-linux-gnueabihf-gcc
+#CC=gcc
+LIBS = -lz
+
+all: thermal_socket
 
 thermal_socket: thermal_socket.c
-	$(CC) $(CFLAGS) -o thermal_socket thermal_socket.c
+	$(CC) $(CFLAGS) -o thermal_socket thermal_socket.c $(LIBS)
+
+clean:
+	/bin/rm -f  thermal_socket

SIYI_tools/thermal_socket/fetch_thermal.py

@@ -14,10 +14,12 @@
 import threading
 import datetime
 import math
+import zlib
 
 from MAVProxy.modules.lib.mp_image import MPImage
 
 TCP_THERMAL=("192.168.144.25", 7345)
+#TCP_THERMAL=("127.0.0.1", 7345)
 
 last_data = None
 WIN_NAME = "Thermal"
@@ -72,6 +74,18 @@ def display_file(fname, data):
     cv2.setMouseCallback(WIN_NAME, click_callback)
     update_title()
 
+    import zlib
+
+def decompress_zlib_buffer(compressed_buffer):
+    try:
+        # Decompress the buffer using zlib
+        uncompressed_buffer = zlib.decompress(compressed_buffer)
+        return uncompressed_buffer
+    except zlib.error as e:
+        # Handle any errors during decompression
+        print(f"Decompression error: {e}")
+        return None
+
 def fetch_latest():
     tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     tcp.connect(TCP_THERMAL)
@@ -84,15 +98,30 @@ def fetch_latest():
         buf += b
 
     print(len(buf))
-    if len(buf) != 128 + 8 + EXPECTED_DATA_SIZE:
+    header_len = 128 + 12
+    if len(buf) < header_len:
+        print("Invalid data size %u" % len(buf))
         return None
 
     print("Got %u bytes" % len(buf))
+
     fname = buf[:128].decode("utf-8").strip('\x00')
-    tstamp, = struct.unpack("<d", buf[128:128+8])
+    compressed_size,tstamp = struct.unpack("<Id", buf[128:128+12])
+
+    compressed_data = buf[header_len:]
+
+    if compressed_size != len(compressed_data):
+        print("Invalid compressed_size %u expected %u" % (compressed_size, len(compressed_data)))
+        return None
+
+    uncompressed_data = decompress_zlib_buffer(compressed_data)
+
+    print("uncompressed_size=%u" % len(uncompressed_data))
+    if len(uncompressed_data) != EXPECTED_DATA_SIZE:
+        print("Bad uncompressed length %u" % len(uncompressed_data))
+
     print(fname, tstamp)
-    data = buf[128+8:]
-    return fname, tstamp, data
+    return fname, tstamp, uncompressed_data
 
 def save_file(fname, tstamp, data):
     fname = os.path.basename(fname)[:-4]

SIYI_tools/thermal_socket/thermal_socket.c

@@ -18,17 +18,26 @@
 #include <stdlib.h>
 #include <sys/wait.h>
 #include <dirent.h>
+#include <zlib.h>
 
 #define LISTEN_PORT 7345
 #define THERMAL_DIR "/mnt/DCIM/102SIYI_TEM"
-#define EXPECTED_SIZE 655360
+//#define THERMAL_DIR "/mnt/Photo/B"
+//#define THERMAL_DIR "test_images"
 
-struct header {
+#define EXPECTED_SIZE (640 * 512 * 2)
+
+#define FORK_PER_CONNECTION 1
+
+#define PACKED __attribute__((__packed__))
+
+struct PACKED header {
     char fname[128];
+    uint32_t compressed_size;
     double timestamp;
 };
 
-static int open_socket_in(int type, int port)
+static int open_socket_in(int port)
 {
     struct sockaddr_in sock;
     int res;
@@ -99,6 +108,46 @@ char *find_latest_file(int fd, struct stat *st_latest)
     return newest_fname;
 }
 
+// Function to handle errors
+static void zlib_error(const char *msg) {
+    perror(msg);
+    exit(1);
+}
+
+/*
+  compress a buffer, returning the compressed size
+  exit via zlib_error() on any error
+*/
+static uint32_t compress_buffer(uint8_t *in_buffer, uint32_t in_size, uint8_t *out_buffer, uint32_t out_buf_size, uint8_t compression_level)
+{
+    z_stream strm;
+    memset(&strm, 0, sizeof(strm)); // Initialize the z_stream structure
+
+    // Initialize the zlib stream for compression
+    if (deflateInit(&strm, compression_level) != Z_OK) {
+        zlib_error("deflateInit failed");
+    }
+
+    // Set up the zlib stream for compression
+    strm.avail_in = in_size;
+    strm.next_in = in_buffer;
+
+    strm.avail_out = out_buf_size;
+    strm.next_out = out_buffer;
+
+    // Compress with zlib
+    int ret = deflate(&strm, Z_FINISH);
+    if (ret == Z_STREAM_ERROR) {
+	deflateEnd(&strm);
+	zlib_error("deflate failed");
+    }
+
+    // Clean up the zlib stream
+    deflateEnd(&strm);
+    
+    // Calculate how many bytes were compressed into out_buffer
+    return out_buf_size - strm.avail_out;
+}
 
 
 static void serve_connection(int fd)
@@ -129,25 +178,31 @@ static void serve_connection(int fd)
     if (read(dfd, buf, sizeof(buf)) != sizeof(buf)) {
 	return;
     }
+    uint8_t compressed_buf[EXPECTED_SIZE*2];
+    h.compressed_size = compress_buffer(buf, sizeof(buf), compressed_buf, sizeof(compressed_buf), 1);
+    if (h.compressed_size == 0) {
+	printf("compression failed %s\n", h.fname);
+	exit(1);
+    }
 
     write(fd, &h, sizeof(h));
-    write(fd, buf, sizeof(buf));
+    write(fd, compressed_buf, h.compressed_size);
 
-    printf("Sent %s\n", h.fname);
+    printf("Sent %s compression %.1f%% compressed_size=%u\n", h.fname, (100.0 * h.compressed_size) / sizeof(buf), (unsigned)h.compressed_size);
 }
 
 static void listener(void)
 {
     int sock;
 
-    sock = open_socket_in(SOCK_STREAM, LISTEN_PORT);
+    sock = open_socket_in(LISTEN_PORT);
 
-    if (listen(sock, 20) == -1) {
+    if (listen(sock, 200) == -1) {
 	fprintf(stderr,"listen failed\n");
 	exit(1);
     }
 
-    printf("waiting for connections\n");
+    printf("waiting for connections on port %u\n", (unsigned)LISTEN_PORT);
 
     while (1) {
 	struct sockaddr addr;
@@ -159,16 +214,20 @@ static void listener(void)
 	fd = accept(sock, &addr, &in_addrlen);
 
 	if (fd != -1) {
+#if FORK_PER_CONNECTION
 	    if (fork() == 0) {
 		serve_connection(fd);
 		exit(0);
 	    }
+#else
+	    serve_connection(fd);
+#endif
 	    close(fd);
 	}
     }
 }
 
-int main(int argc, const char *argv[])
+int main(void)
 {
     listener();
     return 0;