Rename CompressedModuleFrame into StreamModuleFrame

core-buffer/include/WriterZmqReceiver.hpp

@@ -11,7 +11,7 @@ class WriterZmqReceiver {
     const size_t n_modules_;
     std::vector<void*> sockets_;
 
-    CompressedModuleFrame frame_metadata;
+    StreamModuleFrame frame_metadata;
 
 public:
     WriterZmqReceiver(

core-buffer/include/jungfrau.hpp

@@ -50,9 +50,9 @@ struct ModuleFrame {
 
 #pragma pack(push)
 #pragma pack(1)
-struct CompressedModuleFrame {
-    ModuleFrame module_frame;
-    uint64_t compressed_size;
+struct StreamModuleFrame {
+    ModuleFrame metadata;
+    uint64_t frame_size;
     bool is_frame_present;
 };
 #pragma pack(pop)

core-buffer/src/WriterZmqReceiver.cpp

@@ -73,15 +73,15 @@ void WriterZmqReceiver::get_next_image(
         auto n_bytes_metadata = zmq_recv(
                 sockets_[i_module],
                 &frame_metadata,
-                sizeof(CompressedModuleFrame),
+                sizeof(StreamModuleFrame),
                 0);
 
-        if (n_bytes_metadata != sizeof(CompressedModuleFrame)) {
+        if (n_bytes_metadata != sizeof(StreamModuleFrame)) {
             throw runtime_error("Wrong number of metadata bytes.");
         }
 
         // sf_replay should always send the right pulse_id.
-        if (frame_metadata.module_frame.pulse_id != pulse_id) {
+        if (frame_metadata.metadata.pulse_id != pulse_id) {
             stringstream err_msg;
 
             using namespace date;
@@ -91,7 +91,7 @@ void WriterZmqReceiver::get_next_image(
             err_msg << " Read unexpected pulse_id. ";
             err_msg << " Expected " << pulse_id;
             err_msg << " received ";
-            err_msg << frame_metadata.module_frame.pulse_id;
+            err_msg << frame_metadata.metadata.pulse_id;
             err_msg << " from i_module " << i_module << endl;
 
             throw runtime_error(err_msg.str());
@@ -105,24 +105,24 @@ void WriterZmqReceiver::get_next_image(
             image_metadata_init = true;
 
             image_metadata->frame_index =
-                    frame_metadata.module_frame.frame_index;
+                    frame_metadata.metadata.frame_index;
             image_metadata->daq_rec =
-                    frame_metadata.module_frame.daq_rec;
+                    frame_metadata.metadata.daq_rec;
         }
 
         // Once the image is not good, we don't care to re-flag it.
         if (image_metadata->is_good_frame == 1) {
-            if (frame_metadata.module_frame.frame_index !=
+            if (frame_metadata.metadata.frame_index !=
                 image_metadata->frame_index) {
                 image_metadata->is_good_frame = 0;
             }
 
-            if (frame_metadata.module_frame.daq_rec !=
+            if (frame_metadata.metadata.daq_rec !=
                 image_metadata->daq_rec) {
                 image_metadata->is_good_frame = 0;
             }
 
-            if (frame_metadata.module_frame.n_received_packets !=
+            if (frame_metadata.metadata.n_received_packets !=
                 JUNGFRAU_N_PACKETS_PER_FRAME) {
                 image_metadata->is_good_frame = 0;
             }
@@ -131,10 +131,10 @@ void WriterZmqReceiver::get_next_image(
         auto n_bytes_image = zmq_recv(
                 sockets_[i_module],
                 (image_buffer + image_buffer_offset),
-                frame_metadata.compressed_size,
+                frame_metadata.frame_size,
                 0);
 
-        if (n_bytes_image != frame_metadata.compressed_size) {
+        if (n_bytes_image != frame_metadata.frame_size) {
             throw runtime_error("Wrong number of data bytes.");
         }
 

core-buffer/test/test_WriterZmqReceiver.cpp

@@ -44,18 +44,18 @@ TEST(WriterZmqReceiver, basic_test)
 
     for (size_t i = 0; i < n_modules; i++) {
 
-        CompressedModuleFrame frame_metadata;
-        frame_metadata.module_frame.pulse_id = pulse_id;
-        frame_metadata.module_frame.frame_index = pulse_id+100;
-        frame_metadata.module_frame.n_received_packets = 128;
-        frame_metadata.module_frame.daq_rec = 4;
+        StreamModuleFrame frame_metadata;
+        frame_metadata.metadata.pulse_id = pulse_id;
+        frame_metadata.metadata.frame_index = pulse_id + 100;
+        frame_metadata.metadata.n_received_packets = 128;
+        frame_metadata.metadata.daq_rec = 4;
 
         frame_metadata.is_frame_present = 1;
-        frame_metadata.compressed_size = compressed_frame_size;
+        frame_metadata.frame_size = compressed_frame_size;
 
         zmq_send(sockets[i],
                  &frame_metadata,
-                 sizeof(CompressedModuleFrame),
+                 sizeof(StreamModuleFrame),
                  ZMQ_SNDMORE);
 
         zmq_send(sockets[i],

sf-buffer/src/sf_replay.cpp

@@ -20,7 +20,7 @@ void sf_replay (
         const uint64_t start_pulse_id,
         const uint64_t stop_pulse_id)
 {
-    CompressedModuleFrame metadata_buffer;
+    StreamModuleFrame metadata_buffer;
     auto frame_buffer = make_unique<uint16_t[]>(MODULE_N_PIXELS);
 
     auto compressed_buffer_size = bshuf_compress_lz4_bound(
@@ -52,7 +52,7 @@ void sf_replay (
 
         metadata_buffer.is_frame_present = file_reader.get_frame(
                 curr_pulse_id,
-                &(metadata_buffer.module_frame),
+                &(metadata_buffer.metadata),
                 (char*)(frame_buffer.get()));
 
         auto end_time = chrono::steady_clock::now();
@@ -69,7 +69,7 @@ void sf_replay (
             throw runtime_error("Error while compressing buffer.");
         }
 
-        metadata_buffer.compressed_size = compressed_size;
+        metadata_buffer.frame_size = compressed_size;
 
         end_time = chrono::steady_clock::now();
         auto compress_us_duration = chrono::duration_cast<chrono::microseconds>(
@@ -79,7 +79,7 @@ void sf_replay (
 
         zmq_send(socket,
                  &metadata_buffer,
-                 sizeof(CompressedModuleFrame),
+                 sizeof(StreamModuleFrame),
                  ZMQ_SNDMORE);
         zmq_send(socket,
                  (char*)(frame_buffer.get()),
@@ -102,7 +102,7 @@ void sf_replay (
         max_send_us = max(max_send_us, (uint64_t)send_us_duration);
 
         total_compressed_size += compressed_size;
-        total_original_size += MODULE_N_BYTES + sizeof(CompressedModuleFrame);
+        total_original_size += MODULE_N_BYTES + sizeof(StreamModuleFrame);
 
         if (stats_counter == STATS_MODULO) {
             cout << "sf_replay:avg_read_us " << total_read_us/STATS_MODULO;