Style: adhere to linter

DawidWesierski4 · DawidWesierski4 · commit a5f19a87d79c · 2025-10-24T02:49:56.000-04:00
diff --git a/lib/src/mt_util.h b/lib/src/mt_util.h
@@ -109,7 +109,8 @@ static inline bool mt_seq64_greater(uint64_t a, uint64_t b) {
   return ((int64_t)(a - b)) > 0;
 }
 
-static inline bool st_rx_seq_redundant_drop(uint16_t new_id, int* sessions_redundant, enum mtl_session_port s_port, int num_port) {
+static inline bool st_rx_seq_redundant_drop(uint16_t new_id, int* sessions_redundant,
+                                            enum mtl_session_port s_port, int num_port) {
   for (int i = MTL_SESSION_PORT_P; i < num_port; i++) {
     if (i == s_port) continue;
 
@@ -118,7 +119,7 @@ static inline bool st_rx_seq_redundant_drop(uint16_t new_id, int* sessions_redun
       return true;
     }
   }
-  
+
   return false;
 }
 
diff --git a/lib/src/st2110/st_header.h b/lib/src/st2110/st_header.h
@@ -1016,7 +1016,7 @@ struct st_rx_audio_session_impl {
   uint32_t st30_pkt_size; /* size for each pkt which include the header */
   int st30_total_pkts;    /* total pkts in one frame */
   int st30_pkt_idx;       /* pkt index in current frame */
-  int latest_seq_id[MTL_SESSION_PORT_MAX];      /* latest seq id */
+  int latest_seq_id[MTL_SESSION_PORT_MAX]; /* latest seq id */
 
   uint32_t first_pkt_rtp_ts; /* rtp time stamp for the first pkt */
   int64_t tmstamp;
diff --git a/lib/src/st2110/st_rx_ancillary_session.c b/lib/src/st2110/st_rx_ancillary_session.c
@@ -131,8 +131,10 @@ static int rx_ancillary_session_handle_pkt(struct mtl_main_impl* impl,
   }
   /* 0b00: progressive or not specified, do nothing */
 
-  if (unlikely(s->latest_seq_id[MTL_PORT_P] == -1)) s->latest_seq_id[MTL_PORT_P] = seq_id - 1;
-  if (unlikely(s->latest_seq_id[MTL_PORT_R] == -1)) s->latest_seq_id[MTL_PORT_R] = seq_id - 1;
+  if (unlikely(s->latest_seq_id[MTL_PORT_P] == -1))
+    s->latest_seq_id[MTL_PORT_P] = seq_id - 1;
+  if (unlikely(s->latest_seq_id[MTL_PORT_R] == -1))
+    s->latest_seq_id[MTL_PORT_R] = seq_id - 1;
   if (unlikely(s->tmstamp == -1)) s->tmstamp = tmstamp - 1;
 
   if (seq_id != (uint16_t)(s->latest_seq_id[s_port] + 1)) {
@@ -141,12 +143,13 @@ static int rx_ancillary_session_handle_pkt(struct mtl_main_impl* impl,
     ST_SESSION_STAT_INC(s, port_user_stats.common, stat_pkts_out_of_order);
   }
 
-  /* in ancillary we assume packet is redundant when the seq_id is old (it's possible to get 
-  multiple packets with the same timestamp)) */
-  if ((mt_seq32_greater(s->tmstamp, tmstamp)) || st_rx_seq_redundant_drop(seq_id, s->latest_seq_id, s_port, s->ops.num_port)) {
-
-    if (mt_seq32_greater(s->tmstamp, tmstamp)){
-      dbg ("%s(%d,%d), drop as pkt tmstamp %u is old\n", __func__, s->idx, s_port, tmstamp);
+  /* in ancillary we assume packet is redundant when the seq_id is old (it's possible to
+  get multiple packets with the same timestamp)) */
+  if ((mt_seq32_greater(s->tmstamp, tmstamp)) ||
+      st_rx_seq_redundant_drop(seq_id, s->latest_seq_id, s_port, s->ops.num_port)) {
+    if (mt_seq32_greater(s->tmstamp, tmstamp)) {
+      dbg("%s(%d,%d), drop as pkt tmstamp %u is old\n", __func__, s->idx, s_port,
+          tmstamp);
     } else {
       dbg("%s(%d,%d), drop as pkt seq %d is old\n", __func__, s->idx, s_port, seq_id);
     }
diff --git a/lib/src/st2110/st_rx_audio_session.c b/lib/src/st2110/st_rx_audio_session.c
@@ -296,15 +296,18 @@ static int rx_audio_session_handle_frame_pkt(struct mtl_main_impl* impl,
 
   /* all packets need to have increasing tmstamp */
   if (!mt_seq32_greater(tmstamp, s->tmstamp)) {
-    dbg ("%s(%d,%d), drop as pkt seq_id %u (%u) or tmstamp %u (%ld) is old\n", __func__, s->idx, s_port, seq_id, s->latest_seq_id[s_port], tmstamp, s->tmstamp);
+    dbg("%s(%d,%d), drop as pkt seq_id %u (%u) or tmstamp %u (%ld) is old\n", __func__,
+        s->idx, s_port, seq_id, s->latest_seq_id[s_port], tmstamp, s->tmstamp);
     ST_SESSION_STAT_INC(s, port_user_stats, stat_pkts_redundant);
     s->latest_seq_id[s_port] = seq_id;
     return -EIO;
   }
   s->tmstamp = tmstamp;
 
-  if (unlikely(s->latest_seq_id[MTL_PORT_P] == -1)) s->latest_seq_id[MTL_PORT_P] = seq_id - 1;
-  if (unlikely(s->latest_seq_id[MTL_PORT_R] == -1)) s->latest_seq_id[MTL_PORT_R] = seq_id - 1;
+  if (unlikely(s->latest_seq_id[MTL_PORT_P] == -1))
+    s->latest_seq_id[MTL_PORT_P] = seq_id - 1;
+  if (unlikely(s->latest_seq_id[MTL_PORT_R] == -1))
+    s->latest_seq_id[MTL_PORT_R] = seq_id - 1;
 
   if (seq_id != (uint16_t)(s->latest_seq_id[s_port] + 1)) {
     dbg("%s(%d,%d), non-continuous seq now %u last %d\n", __func__, s->idx, s_port,
@@ -414,7 +417,7 @@ static int rx_audio_session_handle_rtp_pkt(struct mtl_main_impl* impl,
   size_t hdr_offset =
       sizeof(struct st_rfc3550_audio_hdr) - sizeof(struct st_rfc3550_rtp_hdr);
   struct st_rfc3550_rtp_hdr* rtp =
-     rte_pktmbuf_mtod_offset(mbuf, struct st_rfc3550_rtp_hdr*, hdr_offset);
+      rte_pktmbuf_mtod_offset(mbuf, struct st_rfc3550_rtp_hdr*, hdr_offset);
   MTL_MAY_UNUSED(impl);
   MTL_MAY_UNUSED(s_port);
 
@@ -492,7 +495,7 @@ static int rv_stop_pcap_dump(struct st_rx_audio_session_impl* s) {
   for (int s_port = 0; s_port < s->ops.num_port; s_port++) {
     ra_stop_pcap(s, s_port);
   }
-    return 0;
+  return 0;
 }
 
 static int ra_start_pcap(struct st_rx_audio_session_impl* s, enum mtl_session_port s_port,
@@ -517,7 +520,7 @@ static int ra_start_pcap(struct st_rx_audio_session_impl* s, enum mtl_session_po
   pcap->pcap = mt_pcap_open(s->mgr->parent, port, fd);
   if (!pcap->pcap) {
     err("%s(%d,%d), failed to open pcap file %s\n", __func__, idx, s_port,
-          pcap->file_name);
+        pcap->file_name);
     close(fd);
     return -EIO;
   }
diff --git a/lib/src/st2110/st_rx_fastmetadata_session.c b/lib/src/st2110/st_rx_fastmetadata_session.c
@@ -114,8 +114,10 @@ static int rx_fastmetadata_session_handle_pkt(struct mtl_main_impl* impl,
     }
   }
 
-  if (unlikely(s->latest_seq_id[MTL_PORT_P] == -1)) s->latest_seq_id[MTL_PORT_P] = seq_id - 1;
-  if (unlikely(s->latest_seq_id[MTL_PORT_R] == -1)) s->latest_seq_id[MTL_PORT_R] = seq_id - 1;
+  if (unlikely(s->latest_seq_id[MTL_PORT_P] == -1))
+    s->latest_seq_id[MTL_PORT_P] = seq_id - 1;
+  if (unlikely(s->latest_seq_id[MTL_PORT_R] == -1))
+    s->latest_seq_id[MTL_PORT_R] = seq_id - 1;
   if (unlikely(s->tmstamp == -1)) s->tmstamp = tmstamp - 1;
 
   if (seq_id != (uint16_t)(s->latest_seq_id[s_port] + 1)) {
@@ -124,12 +126,13 @@ static int rx_fastmetadata_session_handle_pkt(struct mtl_main_impl* impl,
     ST_SESSION_STAT_INC(s, port_user_stats.common, stat_pkts_out_of_order);
   }
 
-  /* in fastmetadata we assume packet is redundant when the seq_id is old (it's possible to get 
-  multiple packets with the same timestamp)) */
-  if ((mt_seq32_greater(s->tmstamp, tmstamp)) || st_rx_seq_redundant_drop(seq_id, s->latest_seq_id, s_port, s->ops.num_port)) {
-
-    if (mt_seq32_greater(s->tmstamp, tmstamp)){
-      dbg ("%s(%d,%d), drop as pkt tmstamp %u is old\n", __func__, s->idx, s_port, tmstamp);
+  /* in fastmetadata we assume packet is redundant when the seq_id is old (it's possible
+  to get multiple packets with the same timestamp)) */
+  if ((mt_seq32_greater(s->tmstamp, tmstamp)) ||
+      st_rx_seq_redundant_drop(seq_id, s->latest_seq_id, s_port, s->ops.num_port)) {
+    if (mt_seq32_greater(s->tmstamp, tmstamp)) {
+      dbg("%s(%d,%d), drop as pkt tmstamp %u is old\n", __func__, s->idx, s_port,
+          tmstamp);
     } else {
       dbg("%s(%d,%d), drop as pkt seq %d is old\n", __func__, s->idx, s_port, seq_id);
     }
diff --git a/lib/src/st2110/st_rx_video_session.c b/lib/src/st2110/st_rx_video_session.c
@@ -1109,7 +1109,6 @@ static struct st_rx_video_slot_impl* rv_slot_by_tmstamp(
     }
   }
 
-
   /* if the slot timestamp is in the past just drop it */
   bool timestamp_is_in_the_past = true;
   for (i = 0; i < s->slot_max; i++) {
@@ -1128,7 +1127,6 @@ static struct st_rx_video_slot_impl* rv_slot_by_tmstamp(
 
   dbg("%s(%d): new tmstamp %u\n", __func__, s->idx, tmstamp);
 
-
   if (s->dma_dev && !mt_dma_empty(s->dma_dev)) {
     /* still in progress of previous frame, drop current pkt */
     rte_atomic32_inc(&s->dma_previous_busy_cnt);
diff --git a/lib/src/st2110/st_tx_video_session.c b/lib/src/st2110/st_tx_video_session.c
@@ -2308,7 +2308,8 @@ static int tv_tasklet_st22(struct mtl_main_impl* impl,
       tv_sync_pacing_st22(impl, s, required_tai, st22_info->st22_total_pkts);
       if (ops->flags & ST20_TX_FLAG_USER_TIMESTAMP) {
         pacing->rtp_time_stamp =
-            st10_get_media_clk(meta.tfmt + (s->ops.rtp_timestamp_delta_us * NS_PER_US), meta.timestamp, s->fps_tm.sampling_clock_rate);
+            st10_get_media_clk(meta.tfmt + (s->ops.rtp_timestamp_delta_us * NS_PER_US),
+                               meta.timestamp, s->fps_tm.sampling_clock_rate);
       } else {
         uint64_t tai_for_rtp_ts;
         if (s->ops.flags & ST20_TX_FLAG_RTP_TIMESTAMP_EPOCH) {
diff --git a/lib/src/st2110/st_video_transmitter.c b/lib/src/st2110/st_video_transmitter.c
@@ -88,7 +88,7 @@ static uint16_t video_trs_burst(struct mtl_main_impl* impl,
   for (uint16_t i = 0; i < tx; i++) {
     s->stat_bytes_tx[s_port] += tx_pkts[i]->pkt_len;
     s->port_user_stats.common.port[s_port].bytes += tx_pkts[i]->pkt_len;
-    s->port_user_stats.common.port[s_port].packets ++;
+    s->port_user_stats.common.port[s_port].packets++;
   }
 
   s->last_burst_succ_time_tsc[s_port] = mt_get_tsc(impl);
diff --git a/tests/integration_tests/noctx/St20pHandler.cpp b/tests/integration_tests/noctx/St20pHandler.cpp
@@ -5,7 +5,8 @@
 #include "noctx.hpp"
 
 St20pHandler::St20pHandler(st_tests_context* ctx, FrameTestStrategy* sessionUserData,
-                         st20p_tx_ops ops_tx, st20p_rx_ops ops_rx, bool create, bool start)
+                           st20p_tx_ops ops_tx, st20p_rx_ops ops_rx, bool create,
+                           bool start)
     : Handlers(ctx, sessionUserData) {
   if (ops_tx.name == nullptr && ops_rx.name == nullptr) {
     fillSt20Ops();
@@ -27,7 +28,8 @@ St20pHandler::St20pHandler(st_tests_context* ctx, FrameTestStrategy* sessionUser
   }
 }
 
-St20pHandler::St20pHandler(st_tests_context* ctx, st20p_tx_ops ops_tx, st20p_rx_ops ops_rx)
+St20pHandler::St20pHandler(st_tests_context* ctx, st20p_tx_ops ops_tx,
+                           st20p_rx_ops ops_rx)
     : Handlers(ctx) {
   if (ops_tx.name == nullptr && ops_rx.name == nullptr) {
     fillSt20Ops();
@@ -49,9 +51,9 @@ St20pHandler::~St20pHandler() {
 }
 
 void St20pHandler::fillSt20Ops(uint transmissionPort, uint framebufferQueueSize,
-                              enum st20_fmt fmt, uint width, uint height,
-                              uint payloadType, enum st_fps fps, bool interlaced,
-                              enum st20_packing packing) {
+                               enum st20_fmt fmt, uint width, uint height,
+                               uint payloadType, enum st_fps fps, bool interlaced,
+                               enum st20_packing packing) {
   memset(&sessionsOpsTx, 0, sizeof(sessionsOpsTx));
   sessionsOpsTx.name = "st20p_noctx_test_tx";
   sessionsOpsTx.priv = ctx;
@@ -98,9 +100,9 @@ void St20pHandler::fillSt20Ops(uint transmissionPort, uint framebufferQueueSize,
   sessionsOpsRx.interlaced = interlaced;
   sessionsOpsRx.framebuff_cnt = framebufferQueueSize;
 
-
   nsFrameTime = st_frame_rate(fps);
-  if (nsFrameTime == 0) nsFrameTime = NS_PER_S / 25;
+  if (nsFrameTime == 0)
+    nsFrameTime = NS_PER_S / 25;
   else
     nsFrameTime = NS_PER_S / nsFrameTime;
 }
@@ -246,7 +248,7 @@ void St20pHandler::startSession(
  * SESSION_SKIP_PORT to skip.
  */
 void St20pHandler::setSessionPorts(int txPortIdx, int rxPortIdx, int txPortRedundantIdx,
-                                  int rxPortRedundantIdx) {
+                                   int rxPortRedundantIdx) {
   setSessionPortsTx(&(this->sessionsOpsTx.port), txPortIdx, txPortRedundantIdx);
   setSessionPortsRx(&(this->sessionsOpsRx.port), rxPortIdx, rxPortRedundantIdx);
 }
diff --git a/tests/integration_tests/noctx/noctx.cpp b/tests/integration_tests/noctx/noctx.cpp
@@ -18,9 +18,10 @@ void NoCtxTest::SetUp() {
 
   if (ctx->handle) {
     throw std::runtime_error(
-      "NoCtxTest::SetUp: ctx->handle is already initialized!\n"
-      "This likely means the global context was not properly reset between tests.\n"
-      "To run NOCTX tests, please use the '--no_ctx_tests' option to ensure a clean context.");
+        "NoCtxTest::SetUp: ctx->handle is already initialized!\n"
+        "This likely means the global context was not properly reset between tests.\n"
+        "To run NOCTX tests, please use the '--no_ctx_tests' option to ensure a clean "
+        "context.");
   }
 
   ctx->level = ST_TEST_LEVEL_MANDATORY;
@@ -88,7 +89,7 @@ uint64_t NoCtxTest::TestPtpSourceSinceEpoch(void* priv) {
     uint64_t temp_adjustment = (uint64_t)spec_adjustment_to_epoch.tv_sec * NS_PER_S +
                                spec_adjustment_to_epoch.tv_nsec;
 
-      adjustment_ns.store(temp_adjustment);
+    adjustment_ns.store(temp_adjustment);
   }
 
   clock_gettime(CLOCK_MONOTONIC, &spec);
diff --git a/tests/integration_tests/noctx/noctx.hpp b/tests/integration_tests/noctx/noctx.hpp
@@ -176,8 +176,8 @@ class St20pHandler : public Handlers {
  public:
   uint64_t nsFrameTime;
   St20pHandler(st_tests_context* ctx, FrameTestStrategy* sessionUserData,
-              st20p_tx_ops ops_tx = {}, st20p_rx_ops ops_rx = {},
-              bool create = true, bool start = true);
+               st20p_tx_ops ops_tx = {}, st20p_rx_ops ops_rx = {}, bool create = true,
+               bool start = true);
 
   St20pHandler(st_tests_context* ctx, st20p_tx_ops ops_tx = {}, st20p_rx_ops ops_rx = {});
   ~St20pHandler();
@@ -188,9 +188,10 @@ class St20pHandler : public Handlers {
   st20p_rx_handle sessionsHandleRx = nullptr;
 
   void fillSt20Ops(uint transmissionPort = 20000, uint framebufferQueueSize = 3,
-                    enum st20_fmt fmt = ST20_FMT_YUV_422_10BIT, uint width = 1920,
-                    uint height = 1080, uint payloadType = 112, enum st_fps fps = ST_FPS_P25,
-                   bool interlaced = false, enum st20_packing packing = ST20_PACKING_BPM);
+                   enum st20_fmt fmt = ST20_FMT_YUV_422_10BIT, uint width = 1920,
+                   uint height = 1080, uint payloadType = 112,
+                   enum st_fps fps = ST_FPS_P25, bool interlaced = false,
+                   enum st20_packing packing = ST20_PACKING_BPM);
 
   void setModifiers(FrameTestStrategy* sessionUserData) {
     this->sessionUserData = sessionUserData;
diff --git a/tests/integration_tests/noctx/noctxSt20pTests.cpp b/tests/integration_tests/noctx/noctxSt20pTests.cpp
@@ -18,12 +18,11 @@ class St20pDefaultTimestamp : public FrameTestStrategy {
   void rxTestFrameModifier(void* frame, size_t frame_size) {
     st_frame* f = (st_frame*)frame;  // Changed from st30_frame to st_frame
     St20pHandler* st20pParent = static_cast<St20pHandler*>(parent);
-    uint64_t framebuffTime = st10_tai_to_media_clk(st20pParent->nsFrameTime, VIDEO_CLOCK_HZ);
+    uint64_t framebuffTime =
+        st10_tai_to_media_clk(st20pParent->nsFrameTime, VIDEO_CLOCK_HZ);
     uint64_t diff;
 
-    EXPECT_NEAR(f->timestamp,
-                framebuffTime * (idx_rx + 1),
-                framebuffTime / 20)
+    EXPECT_NEAR(f->timestamp, framebuffTime * (idx_rx + 1), framebuffTime / 20)
         << " idx_rx: " << idx_rx;
 
     if (lastTimestamp != 0) {
@@ -79,13 +78,14 @@ class St20pUserTimestamp : public St20pDefaultTimestamp {
     St20pHandler* st20pParent = static_cast<St20pHandler*>(parent);
     idx_rx++;
 
-    uint64_t expectedTimestamp =
-        startingTime + (st20pParent->nsFrameTime * (idx_rx - 1));
-    uint64_t expected_media_clk = st10_tai_to_media_clk(expectedTimestamp, VIDEO_CLOCK_HZ);
+    uint64_t expectedTimestamp = startingTime + (st20pParent->nsFrameTime * (idx_rx - 1));
+    uint64_t expected_media_clk =
+        st10_tai_to_media_clk(expectedTimestamp, VIDEO_CLOCK_HZ);
 
     EXPECT_EQ(f->timestamp, expected_media_clk)
         << " idx_rx: " << idx_rx << " tai difference: "
-        << (int64_t)(st10_media_clk_to_ns(f->timestamp, VIDEO_CLOCK_HZ) - expectedTimestamp);
+        << (int64_t)(st10_media_clk_to_ns(f->timestamp, VIDEO_CLOCK_HZ) -
+                     expectedTimestamp);
 
     if (lastTimestamp != 0) {
       uint64_t diff = f->timestamp - lastTimestamp;
@@ -107,7 +107,8 @@ TEST_F(NoCtxTest, st20p_user_pacing) {
 
   St20pUserTimestamp* userData = new St20pUserTimestamp();
   St20pHandler* handler = new St20pHandler(ctx);
-  handler->sessionsOpsTx.flags |= ST20P_TX_FLAG_USER_PACING;  // Changed from ST30P to ST20P
+  handler->sessionsOpsTx.flags |=
+      ST20P_TX_FLAG_USER_PACING;  // Changed from ST30P to ST20P
   handler->setModifiers(userData);
   handler->createSession(true);
 
@@ -166,7 +167,8 @@ TEST_F(NoCtxTest, st20p_redundant_latency) {
       new St20pHandler(ctx, sessionUserData, {}, {}, false, false));
 
   st20pHandlers[sessionTxPrimarySideId]->sessionsOpsTx.flags |= ST20P_TX_FLAG_USER_PACING;
-  st20pHandlers[sessionTxPrimarySideId]->sessionsOpsTx.flags |= ST20P_TX_FLAG_USER_TIMESTAMP;
+  st20pHandlers[sessionTxPrimarySideId]->sessionsOpsTx.flags |=
+      ST20P_TX_FLAG_USER_TIMESTAMP;
   st20pHandlers[sessionTxPrimarySideId]->setSessionPorts(
       2, SESSION_SKIP_PORT, SESSION_SKIP_PORT, SESSION_SKIP_PORT);
   st20pHandlers[sessionTxPrimarySideId]->createSessionTx();
diff --git a/tests/integration_tests/noctx/noctxSt30pTests.cpp b/tests/integration_tests/noctx/noctxSt30pTests.cpp
@@ -116,8 +116,11 @@ class St30pRedundantLatency : public St30pUserTimestamp {
   uint startingTimeInMs;
 
  public:
-  St30pRedundantLatency(uint latency = 30, St30pHandler* parentHandler = nullptr, int startingTime = 100)
-      : St30pUserTimestamp(parentHandler), latencyInMs(latency), startingTimeInMs(startingTime) {
+  St30pRedundantLatency(uint latency = 30, St30pHandler* parentHandler = nullptr,
+                        int startingTime = 100)
+      : St30pUserTimestamp(parentHandler),
+        latencyInMs(latency),
+        startingTimeInMs(startingTime) {
     enable_tx_modifier = true;
     enable_rx_modifier = true;
 
@@ -312,8 +315,9 @@ TEST_F(NoCtxTest, st30p_redundant_latency2) {
   st30_rx_user_stats stats;
   st30p_rx_get_session_stats(st30pHandlers[sessionRxSideId]->sessionsHandleRx, &stats);
   st30_tx_user_stats statsTxRedundant;
-  st30p_tx_get_session_stats(st30pHandlers[sessionTxRedundantLatencySideId]->sessionsHandleTx,
-                             &statsTxRedundant);
+  st30p_tx_get_session_stats(
+      st30pHandlers[sessionTxRedundantLatencySideId]->sessionsHandleTx,
+      &statsTxRedundant);
 
   uint64_t packetsSend = statsTxRedundant.common.port[0].packets;
   uint64_t packetsRecieved = stats.common.port[0].packets + stats.common.port[1].packets;

Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,8 @@ static inline bool mt_seq64_greater(uint64_t a, uint64_t b) {`
`109`	`109`	`return ((int64_t)(a - b)) > 0;`
`110`	`110`	`}`
`111`	`111`
`112`		`-static inline bool st_rx_seq_redundant_drop(uint16_t new_id, int* sessions_redundant, enum mtl_session_port s_port, int num_port) {`
	`112`	`+static inline bool st_rx_seq_redundant_drop(uint16_t new_id, int* sessions_redundant,`
	`113`	`+ enum mtl_session_port s_port, int num_port) {`
`113`	`114`	`for (int i = MTL_SESSION_PORT_P; i < num_port; i++) {`
`114`	`115`	`if (i == s_port) continue;`
`115`	`116`
`@@ -118,7 +119,7 @@ static inline bool st_rx_seq_redundant_drop(uint16_t new_id, int* sessions_redun`
`118`	`119`	`return true;`
`119`	`120`	`}`
`120`	`121`	`}`
`121`		`-`
	`122`	`+`
`122`	`123`	`return false;`
`123`	`124`	`}`
`124`	`125`
Original file line number	Diff line number	Diff line change
`@@ -1109,7 +1109,6 @@ static struct st_rx_video_slot_impl* rv_slot_by_tmstamp(`
`1109`	`1109`	`}`
`1110`	`1110`	`}`
`1111`	`1111`
`1112`		`-`
`1113`	`1112`	`/* if the slot timestamp is in the past just drop it */`
`1114`	`1113`	`bool timestamp_is_in_the_past = true;`
`1115`	`1114`	`for (i = 0; i < s->slot_max; i++) {`
`@@ -1128,7 +1127,6 @@ static struct st_rx_video_slot_impl* rv_slot_by_tmstamp(`
`1128`	`1127`
`1129`	`1128`	`dbg("%s(%d): new tmstamp %u\n", __func__, s->idx, tmstamp);`
`1130`	`1129`
`1131`		`-`
`1132`	`1130`	`if (s->dma_dev && !mt_dma_empty(s->dma_dev)) {`
`1133`	`1131`	`/* still in progress of previous frame, drop current pkt */`
`1134`	`1132`	`rte_atomic32_inc(&s->dma_previous_busy_cnt);`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ static uint16_t video_trs_burst(struct mtl_main_impl* impl,`
`88`	`88`	`for (uint16_t i = 0; i < tx; i++) {`
`89`	`89`	`s->stat_bytes_tx[s_port] += tx_pkts[i]->pkt_len;`
`90`	`90`	`s->port_user_stats.common.port[s_port].bytes += tx_pkts[i]->pkt_len;`
`91`		`- s->port_user_stats.common.port[s_port].packets ++;`
	`91`	`+ s->port_user_stats.common.port[s_port].packets++;`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`s->last_burst_succ_time_tsc[s_port] = mt_get_tsc(impl);`