fix: debug acq_mode to data product parsing function in pff.h

nraultwang · nraultwang · commit c20eada5260e · 2025-08-18T19:30:20.000-07:00
diff --git a/net_thread.c b/net_thread.c
@@ -26,7 +26,7 @@
 
 
 static int group_ph_frames;
-static module_snapshot_buffer_t *snapshot_buffers;
+static module_snapshot_buffer *snapshot_buffers;
 
 // Initialization function for Hashpipe.
 // This function is called once when the thread is created
@@ -119,7 +119,7 @@ static int init(hashpipe_thread_args_t *args)
 
     // Initialize snapshot buffers
     snapshot_buffers = NULL;
-    init_module_snapshot_buffers(module_config, snapshot_buffers);
+    init_module_snapshot_buffers(module_config, &snapshot_buffers);
     if (snapshot_buffers == NULL) {
         hashpipe_error("net_thread", "Failed to initialize snapshot buffers\n");
         pthread_exit(NULL);
@@ -250,15 +250,6 @@ static void *run(hashpipe_thread_args_t *args)
     {
         hashpipe_pktsock_release_frame(p_frame);
     }
-    // let's create snapshot files here
-    // char ssmovie[128];
-    // char ssph[128];
-    // snprintf(ssmovie, sizeof(ssmovie), "%s/module_0/obs_snapshot/start_0.img16.seqno_0.pff", ssdir);
-    // snprintf(ssph, sizeof(ssph), "%s/module_0/obs_snapshot/start_0.ph256.seqno_0.pff", ssdir);
-    // hashpipe_info(__FUNCTION__, "Movie snapshot: %s", ssmovie);
-    // hashpipe_info(__FUNCTION__, "PH snapshot: %s", ssph);
-    // FILE *mov16_fp = fopen(ssmovie, "w");
-    // FILE *ph_fp = fopen(ssph, "w");
 
     // track last successful grpc snapshot send time
     struct timeval last_idle_check_time;
@@ -371,57 +362,15 @@ static void *run(hashpipe_thread_args_t *args)
             }
 
             // Fetch the snapshot buffer for the current module
-            module_snapshot_buffer_t *snapshot_buffer = get_snapshot_buffer(blockHeader->pkt_head[i].mod_num, snapshot_buffers);
+            module_snapshot_buffer *snapshot_buffer = get_snapshot_buffer(blockHeader->pkt_head[i].mod_num, snapshot_buffers);
             if (snapshot_buffer) {
                 snapshot_buffer->update_snapshot(
                     &blockHeader->pkt_head[i],
                     pkt_data + BYTE_PKT_HEADER,
                     &nowTime,
-                    ssint
+                    ssint,
+                    group_ph_frames
                 );
-                // PACKET_HEADER pkt_head = blockHeader->pkt_head[i];
-
-                // // char acq_mode = pkt_head.acq_mode; 
-                // // DATA_PRODUCT dp = acq_mode_to_dp(acq_mode, group_ph_frames);
-                // if (dp == DP_PH_256_IMG || dp == DP_PH_1024_IMG)
-                // {
-                //     snapshot_buffer->update_snapshot(&blockHeader->pkt_head[i], pkt_data + BYTE_PKT_HEADER);
-                //     // for PH snapshots
-                //     tdiff = timeval_diff(&lastPHTime, &nowTime);
-                //     if (tdiff > ssint * 1000)
-                //     {
-                //         // WritePHSnapshots(ph_fp, &blockHeader->pkt_head[i], pkt_data + BYTE_PKT_HEADER);
-                //         WritePHSnapshotsToUds(DP_PH_256_IMG, &blockHeader->pkt_head[i], pkt_data + BYTE_PKT_HEADER);
-                //         lastPHTime.tv_sec = nowTime.tv_sec;
-                //         lastPHTime.tv_usec = nowTime.tv_usec;
-                //     }
-                // }
-                // else if (dp == DP_BIT16_IMG)
-                // {
-                //     // if we get four packets from four different quabos,
-                //     // imgfull will be 0xf.
-                //     // then we will write the data into the snapshot file.
-                //     quabo_num = blockHeader->pkt_head[i].quabo_num;
-                //     imgfull |= 1 << quabo_num;
-                //     // TODO: group the mov images?
-                //     quabo16_to_module16_copy(pkt_data + BYTE_PKT_HEADER, quabo_num, oimgbuf);
-                //     memcpy(imgbuf + quabo_num * 512, oimgbuf, 512);
-                //     memcpy(&imgheader[quabo_num], &blockHeader->pkt_head[i], sizeof(PACKET_HEADER));
-                //     if (imgfull == 0xf)
-                //     {
-                //         imgfull = 0;
-                //         // for Img16 snapshots
-                //         tdiff = timeval_diff(&lastImg16Time, &nowTime);
-                //         if (tdiff > ssint * 1000)
-                //         {
-                //             // DATA_PRODUCT img_dp = (imgheader[0].acq_mode == 0x03) ? DP_BIT8_IMG : DP_BIT16_IMG;
-                //             // WriteImgSnapshots(mov16_fp, imgheader, imgbuf);
-                //             WriteImgSnapshotsToUds(dp, imgheader, imgbuf);
-                //             lastImg16Time.tv_sec = nowTime.tv_sec;
-                //             lastImg16Time.tv_usec = nowTime.tv_usec;
-                //         }
-                //     }
-                // }
             }
 
             // ==== End snapshot code ====
diff --git a/snapshot.c b/snapshot.c
@@ -12,15 +12,12 @@
 #include <sys/stat.h>
 #include <netinet/in.h> 
 #include <poll.h>
-#include <sys/time.h>
 
 #include "snapshot.h"
 #include "hashpipe.h"
-#include "pff.h"
-#include "databuf.h" 
 
-// get the time difference
-static uint64_t timeval_diff(struct timeval *start, struct timeval *end)
+// get the time difference in microseconds (usec)
+uint64_t timeval_diff(struct timeval *start, struct timeval *end)
 {
     struct timeval diff;
     diff.tv_sec = end->tv_sec - start->tv_sec;
@@ -34,8 +31,8 @@ static uint64_t timeval_diff(struct timeval *start, struct timeval *end)
     return diff.tv_sec * 1000000 + diff.tv_usec;
 }
 
-module_snapshot_buffer_t* get_snapshot_buffer(uint16_t module_id, module_snapshot_buffer_t *snapshot_buffers) {
-    module_snapshot_buffer_t *iter = snapshot_buffers;
+module_snapshot_buffer* get_snapshot_buffer(uint16_t module_id, module_snapshot_buffer *snapshot_buffers) {
+    module_snapshot_buffer *iter = snapshot_buffers;
     while (iter != NULL) {
         if (iter->module_id == module_id) {
             return iter;
@@ -46,8 +43,8 @@ module_snapshot_buffer_t* get_snapshot_buffer(uint16_t module_id, module_snapsho
 }
 
 /* Initialize snapshot buffers for each declared module id */
-void init_module_snapshot_buffers(char *module_config, module_snapshot_buffer_t *snapshot_buffers) {
-    snapshot_buffers = NULL;
+void init_module_snapshot_buffers(char *module_config, module_snapshot_buffer **snapshot_buffers) {
+    *snapshot_buffers = NULL;
 
     char fbuf[100];
     signed char cbuf;
@@ -67,14 +64,16 @@ void init_module_snapshot_buffers(char *module_config, module_snapshot_buffer_t
         ungetc(cbuf, module_config_fp);
         if (cbuf != '#')
         {
-            if (fscanf(module_config_fp, "%u\n", &module_id) == 1)
+            if (fscanf(module_config_fp, "%hu\n", &module_id) == 1)
             {
-                if (snapshot_buffers == NULL) {
-                    snapshot_buffers = new module_snapshot_buffer_t(module_id);
+                if (*snapshot_buffers == NULL) {
+                    hashpipe_info(__FUNCTION__, "Creating snapshot buffer for module %hu\n", module_id);
+                    *snapshot_buffers = new module_snapshot_buffer(module_id);
                 } else {
-                    module_snapshot_buffer_t *new_buffer = new module_snapshot_buffer_t(module_id);
-                    new_buffer->next = snapshot_buffers;
-                    snapshot_buffers = new_buffer;
+                    hashpipe_info(__FUNCTION__, "Creating snapshot buffer for module %hu\n", module_id);
+                    module_snapshot_buffer *new_buffer = new module_snapshot_buffer(module_id);
+                    new_buffer->next = *snapshot_buffers;
+                    *snapshot_buffers = new_buffer;
                 }
             }
         }
@@ -158,62 +157,6 @@ static int sprint_img_snapshot_json(char* dest, size_t size, PACKET_HEADER* head
     return (p - dest);
 }
 
-// =====================================================================
-// Filesystem snapshot functions (originally from net_thread.c) 
-// =====================================================================
-
-
-// Writes a single-packet pulse-height snapshot to a file.
-void WritePHSnapshots(FILE *fp, PACKET_HEADER *header, uint8_t *data) {
-    char json_buffer[1024];
-
-    // Create the JSON header in memory using the unified function
-    if (sprint_ph_snapshot_json(json_buffer, sizeof(json_buffer), header) <= 0) {
-        hashpipe_error(__FUNCTION__, "Failed to sprint PH snapshot JSON for filesystem");
-        return;
-    }
-
-    // Write the PFF frame to the file
-    // move the pointer to the beginning,
-    // as we only need one pkt in the snapshot file.
-    fseek(fp, 0, SEEK_SET);
-    pff_start_json(fp);
-    fputs(json_buffer, fp); // Write the generated JSON string
-    pff_end_json(fp);
-    pff_write_image(fp, PIXELS_PER_IMAGE * 2, data);
-    fflush(fp);
-    if (ftruncate(fileno(fp), ftell(fp)) < 0) {
-        hashpipe_error(__FUNCTION__, "Failed to truncate PH snapshot file");
-    }
-    fsync(fileno(fp));
-}
-
-
-// write data into img snapshot file
-void WriteImgSnapshots(FILE *fp, PACKET_HEADER *header, uint8_t *data) {
-    char json_buffer[4096];
-
-    // Create the JSON header in memory using the unified function
-    if (sprint_img_snapshot_json(json_buffer, sizeof(json_buffer), header) <= 0) {
-        hashpipe_error(__FUNCTION__, "Failed to sprint Img snapshot JSON for filesystem");
-        return;
-    }
-
-    // Write the PFF frame to the file
-    // move the pointer to the beginning,
-    // as we only need one pkt in the snapshot file.
-    fseek(fp, 0, SEEK_SET);
-    pff_start_json(fp);
-    fputs(json_buffer, fp); // Write the generated JSON string
-    pff_end_json(fp);
-    pff_write_image(fp, BYTES_PER_MODULE_FRAME, data);
-    fflush(fp);
-    if (ftruncate(fileno(fp), ftell(fp)) < 0) {
-        hashpipe_error(__FUNCTION__, "Failed to truncate Img snapshot file");
-    }
-    fsync(fileno(fp));
-}
-
 
 // =====================================================================
 // UDS snapshot functions
@@ -418,3 +361,59 @@ void write_32x32_to_uds(DATA_PRODUCT dp, PACKET_HEADER *header, uint8_t *data) {
         hashpipe_error(__FUNCTION__, "Failed to sprint Img snapshot JSON for UDS");
     }
 }
+
+// =====================================================================
+// Filesystem snapshot functions (originally from net_thread.c) 
+// =====================================================================
+
+
+// // Writes a single-packet pulse-height snapshot to a file.
+// void WritePHSnapshots(FILE *fp, PACKET_HEADER *header, uint8_t *data) {
+//     char json_buffer[1024];
+
+//     // Create the JSON header in memory using the unified function
+//     if (sprint_ph_snapshot_json(json_buffer, sizeof(json_buffer), header) <= 0) {
+//         hashpipe_error(__FUNCTION__, "Failed to sprint PH snapshot JSON for filesystem");
+//         return;
+//     }
+
+//     // Write the PFF frame to the file
+//     // move the pointer to the beginning,
+//     // as we only need one pkt in the snapshot file.
+//     fseek(fp, 0, SEEK_SET);
+//     pff_start_json(fp);
+//     fputs(json_buffer, fp); // Write the generated JSON string
+//     pff_end_json(fp);
+//     pff_write_image(fp, PIXELS_PER_IMAGE * 2, data);
+//     fflush(fp);
+//     if (ftruncate(fileno(fp), ftell(fp)) < 0) {
+//         hashpipe_error(__FUNCTION__, "Failed to truncate PH snapshot file");
+//     }
+//     fsync(fileno(fp));
+// }
+
+
+// // write data into img snapshot file
+// void WriteImgSnapshots(FILE *fp, PACKET_HEADER *header, uint8_t *data) {
+//     char json_buffer[4096];
+
+//     // Create the JSON header in memory using the unified function
+//     if (sprint_img_snapshot_json(json_buffer, sizeof(json_buffer), header) <= 0) {
+//         hashpipe_error(__FUNCTION__, "Failed to sprint Img snapshot JSON for filesystem");
+//         return;
+//     }
+
+//     // Write the PFF frame to the file
+//     // move the pointer to the beginning,
+//     // as we only need one pkt in the snapshot file.
+//     fseek(fp, 0, SEEK_SET);
+//     pff_start_json(fp);
+//     fputs(json_buffer, fp); // Write the generated JSON string
+//     pff_end_json(fp);
+//     pff_write_image(fp, BYTES_PER_MODULE_FRAME, data);
+//     fflush(fp);
+//     if (ftruncate(fileno(fp), ftell(fp)) < 0) {
+//         hashpipe_error(__FUNCTION__, "Failed to truncate Img snapshot file");
+//     }
+//     fsync(fileno(fp));
+// }
diff --git a/snapshot.h b/snapshot.h
@@ -1,8 +1,10 @@
 #ifndef _SNAPSHOT_H_
 #define _SNAPSHOT_H_
 
-#include <stdio.h>
 #include <stdint.h>
+#include <sys/time.h>
+#include "image.h"
+#include <stdio.h>
 #include "databuf.h" 
 #include "pff.h"
 
@@ -18,7 +20,7 @@ extern "C" {
 #define UDS_PATH_TEMPLATE "/tmp/hashpipe_grpc.dp_%s.sock"
 
 // get the time difference
-static uint64_t timeval_diff(struct timeval *start, struct timeval *end);
+uint64_t timeval_diff(struct timeval *start, struct timeval *end);
 
 // Structure representing a Unix Domain Socket connection.
 typedef struct uds_connection {
@@ -90,7 +92,7 @@ struct module_snapshot_buffer {
     uint16_t module_id;
     snapshot_t *snapshot_head;
     snapshot_t *snapshot_tail;
-    module_snapshot_buffer_t *next;
+    module_snapshot_buffer *next;
 
     module_snapshot_buffer(uint16_t module_id) {
         this->module_id = module_id;
@@ -127,19 +129,17 @@ struct module_snapshot_buffer {
         return NULL; // Not found
     }
 
-    void update_snapshot(PACKET_HEADER *header, uint8_t *data, struct timeval *nowTime, int snapshot_interval_ms) {
+    void update_snapshot(PACKET_HEADER *header, uint8_t *data, struct timeval *nowTime, int snapshot_interval_ms, int group_ph_frames) {
         char acq_mode = header->acq_mode;
-        int quabo_num = header.quabo_num;
+        int quabo_num = header->quabo_num;
         DATA_PRODUCT dp = acq_mode_to_dp(acq_mode, group_ph_frames);
         snapshot_t *s = this->get_snapshot(dp);
 
         // If timestamp difference exceeds snapshot interval, write snapshot to the unix-domain socket for this data product
         bool write_snapshot = false;
-        tdiff = timeval_diff(&s->last_update_time, &nowTime);
+        uint64_t tdiff = timeval_diff(&s->last_update_time, nowTime);
         if ((tdiff > snapshot_interval_ms * 1000))
         {
-            s->last_update_time.tv_sec = nowTime.tv_sec;
-            s->last_update_time.tv_usec = nowTime.tv_usec;
             write_snapshot = true;
         }
 
@@ -152,8 +152,10 @@ struct module_snapshot_buffer {
             if (write_snapshot) {
                 write_16x16_to_uds(dp, header, s->data);
                 // memset(s->headers, 0, sizeof(s->headers));
-                memset(s->data, 0, sizeof(s->data));
+                s->last_update_time.tv_sec = nowTime->tv_sec;
+                s->last_update_time.tv_usec = nowTime->tv_usec;
             }
+            memset(s->data, 0, sizeof(s->data));
         } else {
             // Require 4 quabo images 
             s->quabo_bitmap |= 1 << quabo_num;
@@ -170,6 +172,8 @@ struct module_snapshot_buffer {
             if (s->quabo_bitmap == 0xf) {
                 if (write_snapshot) {
                     write_16x16_to_uds(dp, s->headers, s->data);
+                    s->last_update_time.tv_sec = nowTime->tv_sec;
+                    s->last_update_time.tv_usec = nowTime->tv_usec;
                 }
                 memset(s->headers, 0, sizeof(s->headers));
                 memset(s->data, 0, sizeof(s->data));
@@ -186,11 +190,12 @@ struct module_snapshot_buffer {
             current = next;
         }
     }
- } module_snapshot_buffer_t;
+ };
 
 
-void init_module_snapshot_buffers(char *module_config, module_snapshot_buffer_t *snapshot_buffers);
+void init_module_snapshot_buffers(char *module_config, module_snapshot_buffer **snapshot_buffers);
 
+module_snapshot_buffer* get_snapshot_buffer(uint16_t module_id, module_snapshot_buffer *snapshot_buffers);
 
 
 #ifdef __cplusplus
diff --git a/util/pff.cpp b/util/pff.cpp
@@ -30,6 +30,23 @@ DATA_PRODUCT str_to_dp(const char* s) {
     return DP_NONE;
 }
 
+DATA_PRODUCT acq_mode_to_dp(char acq_mode, int group_ph_frames) {
+    switch (acq_mode) {
+        case 0x01:
+            if (group_ph_frames) {
+                return DP_PH_1024_IMG; // 1024 pulse height
+            }
+            else {
+                return DP_PH_256_IMG; // 256 pulse height
+            }
+        case 0x02: return DP_BIT16_IMG;  // 16 bit imaging
+        case 0x03: return DP_BIT16_IMG;  // 16 bit imaging
+        case 0x06: return DP_BIT8_IMG;   // 8 bit imaging
+        case 0x07: return DP_BIT8_IMG;   // 8 bit imaging
+        default: return DP_NONE;
+    }
+}
+
 void pff_start_json(FILE* f) {
 }
 
diff --git a/util/pff.h b/util/pff.h
