clang format

Author: raphaelscholle

wifibroadcast/executables/unit_test.cpp

@@ -9,12 +9,11 @@
 #include <sys/resource.h>
 #include <unistd.h>
 
+#include <fstream>
 #include <iostream>
 #include <sstream>
 #include <string>
 
-#include <fstream>
-
 namespace SchedulingHelper {
 
 // Only 'low' in comparison to other realtime tasks
@@ -35,27 +34,23 @@ static void set_thread_params_max_realtime(const std::string& tag,
   param.sched_priority = priority;
   auto result = pthread_setschedparam(target, policy, &param);
 
-  
-    std::ifstream file("/usr/share/openhd/debug.txt");
-    if (file.good()) {
-
-  
-
-  if (result != 0) {
-    std::stringstream ss;
-    ss << "Cannot setThreadParamsMaxRealtime " << result;
-    std::cerr << ss.str() << std::endl;
-  } else {
-    std::stringstream ss;
-    ss << "Changed prio ";
-    if (!tag.empty()) {
-      ss << "for " << tag << " ";
+  std::ifstream file("/usr/share/openhd/debug.txt");
+  if (file.good()) {
+    if (result != 0) {
+      std::stringstream ss;
+      ss << "Cannot setThreadParamsMaxRealtime " << result;
+      std::cerr << ss.str() << std::endl;
+    } else {
+      std::stringstream ss;
+      ss << "Changed prio ";
+      if (!tag.empty()) {
+        ss << "for " << tag << " ";
+      }
+      ss << "to SCHED_FIFO:" << param.sched_priority;
+      std::cout << ss.str() << std::endl;
     }
-    ss << "to SCHED_FIFO:" << param.sched_priority;
-    std::cout << ss.str() << std::endl;
   }
 }
-}
 
 static bool check_root() {
   const auto uid = getuid();

wifibroadcast/src/HelperSources/SchedulingHelper.hpp

@@ -14,12 +14,11 @@
 
 // Header structure close to Ruby's implementation but simplified for this task
 struct WBPacketHeader {
-    uint8_t packet_flags;     // Flags (e.g., retransmitted)
-    uint8_t packet_type;      // Type (Video, Telemetry, RC, etc.)
-    uint32_t stream_packet_idx; // Sequence number for the stream
-    uint16_t total_length;      // Total length of the packet including header
-    // Additional fields can be added here to match Ruby's t_packet_header if needed
-    // u16 radio_link_packet_index;
-    // u32 vehicle_id_src;
-    // u32 vehicle_id_dest;
+  uint8_t packet_flags;        // Flags (e.g., retransmitted)
+  uint8_t packet_type;         // Type (Video, Telemetry, RC, etc.)
+  uint32_t stream_packet_idx;  // Sequence number for the stream
+  uint16_t total_length;       // Total length of the packet including header
+  // Additional fields can be added here to match Ruby's t_packet_header if
+  // needed u16 radio_link_packet_index; u32 vehicle_id_src; u32
+  // vehicle_id_dest;
 } __attribute__((packed));

wifibroadcast/src/WBPacketHeader.h

@@ -6,10 +6,10 @@
 
 #include <utility>
 
+#include "../radiotap/RadiotapHeaderTx.hpp"
+#include "../radiotap/RadiotapHeaderTxHolder.hpp"
 #include "SchedulingHelper.hpp"
 #include "WBPacketHeader.h"
-#include "../radiotap/RadiotapHeaderTxHolder.hpp"
-#include "../radiotap/RadiotapHeaderTx.hpp"
 
 WBStreamRx::WBStreamRx(std::shared_ptr<WBTxRx> txrx, Options options1)
     : m_txrx(txrx), m_options(options1) {
@@ -158,28 +158,32 @@ void WBStreamRx::set_on_fec_block_done_cb(WBStreamRx::ON_BLOCK_DONE_CB cb) {
 void WBStreamRx::internal_process_packet(const uint8_t *data, int data_len) {
   // Strip WBPacketHeader if present
   if (data_len < (int)sizeof(WBPacketHeader)) {
-      m_console->debug("Packet too short for header: {}", data_len);
-      return;
+    m_console->debug("Packet too short for header: {}", data_len);
+    return;
   }
 
-  const WBPacketHeader* header = (const WBPacketHeader*)data;
-  const uint8_t* payload = data + sizeof(WBPacketHeader);
+  const WBPacketHeader *header = (const WBPacketHeader *)data;
+  const uint8_t *payload = data + sizeof(WBPacketHeader);
   int payload_len = data_len - sizeof(WBPacketHeader);
 
-  // Handle Retransmission Request (if we are the TX side listening to RX side requests)
-  // NOTE: This logic is usually on the TX side. But if we reuse WBStreamRx for receiving telemetry on AIR, we might see this.
-  // However, WBStreamTx logic added previously handles listening for requests.
+  // Handle Retransmission Request (if we are the TX side listening to RX side
+  // requests) NOTE: This logic is usually on the TX side. But if we reuse
+  // WBStreamRx for receiving telemetry on AIR, we might see this. However,
+  // WBStreamTx logic added previously handles listening for requests.
   // WBStreamRx is primarily for receiving data.
 
   if (header->packet_type == WB_PACKET_TYPE_RETRANSMISSION_REQ) {
-      // This is a request. If we are an RX stream, we shouldn't really receive this unless we are debugging or in a loopback.
-      // Or if this WBStreamRx is used on the Air Unit to receive Uplink data, and the Uplink data contains Retransmission Requests.
-      // But typically Retransmission Requests are handled by the callback registered in WBStreamTx.
-      return;
+    // This is a request. If we are an RX stream, we shouldn't really receive
+    // this unless we are debugging or in a loopback. Or if this WBStreamRx is
+    // used on the Air Unit to receive Uplink data, and the Uplink data contains
+    // Retransmission Requests. But typically Retransmission Requests are
+    // handled by the callback registered in WBStreamTx.
+    return;
   }
 
   if (header->packet_flags & WB_PACKET_FLAG_RETRANSMITTED) {
-      m_console->debug("Received retransmitted packet, seq: {}", header->stream_packet_idx);
+    m_console->debug("Received retransmitted packet, seq: {}",
+                     header->stream_packet_idx);
   }
 
   // Gap detection
@@ -197,61 +201,65 @@ void WBStreamRx::internal_process_packet(const uint8_t *data, int data_len) {
 }
 
 void WBStreamRx::check_gap_and_request(uint32_t current_seq_num) {
-    if (!m_first_packet_received) {
-        m_first_packet_received = true;
-        m_last_seq_num = current_seq_num;
-        return;
-    }
+  if (!m_first_packet_received) {
+    m_first_packet_received = true;
+    m_last_seq_num = current_seq_num;
+    return;
+  }
 
-    // Handle wrap-around using int32_t logic
-    int32_t diff = (int32_t)(current_seq_num - m_last_seq_num);
+  // Handle wrap-around using int32_t logic
+  int32_t diff = (int32_t)(current_seq_num - m_last_seq_num);
 
-    if (diff > 1) {
-        // Gap detected
-        // Limit number of requests or range to avoid flooding
-        uint32_t missing_count = diff - 1;
-        if (missing_count > 10) missing_count = 10; // Cap at 10 to avoid huge bursts
+  if (diff > 1) {
+    // Gap detected
+    // Limit number of requests or range to avoid flooding
+    uint32_t missing_count = diff - 1;
+    if (missing_count > 10)
+      missing_count = 10;  // Cap at 10 to avoid huge bursts
 
-        for (uint32_t i = 1; i <= missing_count; i++) {
-            uint32_t missing_seq = m_last_seq_num + i;
-            m_console->debug("Detected gap. Requesting seq: {}", missing_seq);
-            send_retransmission_request(missing_seq);
-        }
+    for (uint32_t i = 1; i <= missing_count; i++) {
+      uint32_t missing_seq = m_last_seq_num + i;
+      m_console->debug("Detected gap. Requesting seq: {}", missing_seq);
+      send_retransmission_request(missing_seq);
     }
+  }
 
-    // Update last sequence number
-    // Handle reordered packets? If current < last (diff <= 0), we might have received an old packet (or retransmission).
-    if (diff > 0) {
-        m_last_seq_num = current_seq_num;
-    }
+  // Update last sequence number
+  // Handle reordered packets? If current < last (diff <= 0), we might have
+  // received an old packet (or retransmission).
+  if (diff > 0) {
+    m_last_seq_num = current_seq_num;
+  }
 }
 
 void WBStreamRx::send_retransmission_request(uint32_t seq_num) {
-    // Construct packet
-    WBPacketHeader header;
-    header.packet_type = WB_PACKET_TYPE_RETRANSMISSION_REQ;
-    header.packet_flags = 0;
-    header.stream_packet_idx = seq_num; // Use this field to convey the requested sequence number
-    header.total_length = sizeof(WBPacketHeader);
-
-    // Create buffer
-    std::vector<uint8_t> packet(sizeof(WBPacketHeader));
-    memcpy(packet.data(), &header, sizeof(WBPacketHeader));
-
-    // Send using WBTxRx
-    // Need a RadiotapHeaderTx. We can use a default one or create one.
-    // WBTxRx::tx_inject_packet requires a RadiotapHeaderTx.
-    // We can't easily get one here without storing it or creating a default.
-    // Let's create a default one.
-
-    // Need a RadiotapHeaderTx.
-    RadiotapHeaderTx::UserSelectableParams params{};
-    // Default params usually fine for control packets
-    params.bandwidth = 20;
-    params.mcs_index = 0; // Low MCS for reliability
-
-    RadiotapHeaderTx radiotap_header(params);
-
-    // Use m_options.radio_port for sending?
-    m_txrx->tx_inject_packet(m_options.radio_port, packet.data(), packet.size(), radiotap_header, false);
+  // Construct packet
+  WBPacketHeader header;
+  header.packet_type = WB_PACKET_TYPE_RETRANSMISSION_REQ;
+  header.packet_flags = 0;
+  header.stream_packet_idx =
+      seq_num;  // Use this field to convey the requested sequence number
+  header.total_length = sizeof(WBPacketHeader);
+
+  // Create buffer
+  std::vector<uint8_t> packet(sizeof(WBPacketHeader));
+  memcpy(packet.data(), &header, sizeof(WBPacketHeader));
+
+  // Send using WBTxRx
+  // Need a RadiotapHeaderTx. We can use a default one or create one.
+  // WBTxRx::tx_inject_packet requires a RadiotapHeaderTx.
+  // We can't easily get one here without storing it or creating a default.
+  // Let's create a default one.
+
+  // Need a RadiotapHeaderTx.
+  RadiotapHeaderTx::UserSelectableParams params{};
+  // Default params usually fine for control packets
+  params.bandwidth = 20;
+  params.mcs_index = 0;  // Low MCS for reliability
+
+  RadiotapHeaderTx radiotap_header(params);
+
+  // Use m_options.radio_port for sending?
+  m_txrx->tx_inject_packet(m_options.radio_port, packet.data(), packet.size(),
+                           radiotap_header, false);
 }