Fix: User pacing test

Signed-off-by: Kasiewicz, Marek <[email protected]>

Author: Sakoram

include/st20_api.h

@@ -480,6 +480,8 @@ struct st20_rx_tp_meta {
   enum st_rx_tp_compliant compliant;
   /** the failed cause if compliant is not ST_RX_TP_COMPLIANT_NARROW */
   char failed_cause[64];
+  /** TAI timestamp measured right after first packet of the frame was received */
+  uint64_t receive_timestamp;
 
   /* packets count in current report meta */
   uint32_t pkts_cnt;
@@ -1876,6 +1878,24 @@ int st20_tx_put_mbuf(st20_tx_handle handle, void* mbuf, uint16_t len);
  */
 int st20_tx_get_sch_idx(st20_tx_handle handle);
 
+/**
+ * Retrieve pacing parameters for a tx st2110-20 session.
+ *
+ * @param handle
+ *   The handle to the tx st2110-20(video) session.
+ * @param tr_offset_ns
+ *   Optional output for the tr offset value in nanoseconds.
+ * @param trs_ns
+ *   Optional output for the packet spacing (TRS) value in nanoseconds.
+ * @param vrx_pkts
+ *   Optional output for the VRX packet count.
+ *
+ * @return
+ *    0 on success, negative value otherwise.
+ */
+int st20_tx_get_pacing_params(st20_tx_handle handle, double* tr_offset_ns, double* trs_ns,
+                              uint32_t* vrx_pkts);
+
 /**
  * Retrieve the general statistics(I/O) for one tx st2110-20(video) session.
  *

include/st_pipeline_api.h

@@ -319,6 +319,8 @@ struct st_frame {
   /** timing parser meta for st20p_rx_get_frame, only active if
    * ST20P_RX_FLAG_TIMING_PARSER_META */
   struct st20_rx_tp_meta* tp[MTL_SESSION_PORT_MAX];
+  /** TAI timestamp measured right after first packet of the frame was received */
+  uint64_t receive_timestamp;
 };
 
 /** Device type of st plugin */
@@ -1761,6 +1763,23 @@ size_t st20p_tx_frame_size(st20p_tx_handle handle);
  */
 int st20p_tx_get_sch_idx(st20p_tx_handle handle);
 
+/**
+ * Retrieve pacing parameters for a tx st2110-20(pipeline) session.
+ *
+ * @param handle
+ *   The handle to the tx st2110-20(video) session.
+ * @param tr_offset_ns
+ *   Optional output for the tr offset value in nanoseconds.
+ * @param trs_ns
+ *   Optional output for the packet spacing (TRS) value in nanoseconds.
+ * @param vrx_pkts
+ *   Optional output for the VRX packet count.
+ *
+ * @return
+ *    0 on success, negative value otherwise.
+ */
+int st20p_tx_get_pacing_params(st20p_tx_handle handle, double* tr_offset_ns,
+                               double* trs_ns, uint32_t* vrx_pkts);
 /**
  * Retrieve the general statistics(I/O) for one tx st2110-20(pipeline) session.
  *

lib/src/st2110/pipeline/st20_pipeline_rx.c

@@ -217,6 +217,8 @@ static int rx_st20p_frame_ready(void* priv, void* frame,
   framebuff->src.timestamp = framebuff->dst.timestamp = meta->timestamp;
   framebuff->src.rtp_timestamp = framebuff->dst.rtp_timestamp = meta->rtp_timestamp;
   framebuff->src.status = framebuff->dst.status = meta->status;
+  framebuff->src.receive_timestamp = framebuff->dst.receive_timestamp =
+      meta->timestamp_first_pkt;
 
   framebuff->src.pkts_total = framebuff->dst.pkts_total = meta->pkts_total;
   for (enum mtl_session_port s_port = 0; s_port < MTL_SESSION_PORT_MAX; s_port++) {

lib/src/st2110/pipeline/st20_pipeline_tx.c

@@ -984,6 +984,26 @@ int st20p_tx_get_sch_idx(st20p_tx_handle handle) {
   return st20_tx_get_sch_idx(ctx->transport);
 }
 
+int st20p_tx_get_pacing_params(st20p_tx_handle handle, double* tr_offset_ns,
+                               double* trs_ns, uint32_t* vrx_pkts) {
+  struct st20p_tx_ctx* ctx = handle;
+  int cidx;
+
+  if (!handle) {
+    err("%s, invalid handle %p\n", __func__, handle);
+    return -EINVAL;
+  }
+  ctx = handle;
+  cidx = ctx->idx;
+
+  if (ctx->type != MT_ST20_HANDLE_PIPELINE_TX) {
+    err("%s(%d), invalid type %d\n", __func__, cidx, ctx->type);
+    return -EINVAL;
+  }
+
+  return st20_tx_get_pacing_params(ctx->transport, tr_offset_ns, trs_ns, vrx_pkts);
+}
+
 int st20p_tx_get_session_stats(st20p_tx_handle handle, struct st20_tx_user_stats* stats) {
   struct st20p_tx_ctx* ctx = handle;
   int cidx;

lib/src/st2110/st_tx_video_session.c

@@ -4343,6 +4343,27 @@ int st20_tx_get_sch_idx(st20_tx_handle handle) {
   return s_impl->sch->idx;
 }
 
+int st20_tx_get_pacing_params(st20_tx_handle handle, double* tr_offset_ns, double* trs_ns,
+                              uint32_t* vrx_pkts) {
+  struct st_tx_video_session_handle_impl* s_impl = handle;
+
+  if (!handle) {
+    err("%s, invalid handle %p\n", __func__, handle);
+    return -EINVAL;
+  }
+
+  if (s_impl->type != MT_HANDLE_TX_VIDEO) {
+    err("%s, invalid type %d\n", __func__, s_impl->type);
+    return -EINVAL;
+  }
+
+  struct st_tx_video_session_impl* s = s_impl->impl;
+  if (tr_offset_ns) *tr_offset_ns = s->pacing.tr_offset;
+  if (trs_ns) *trs_ns = s->pacing.trs;
+  if (vrx_pkts) *vrx_pkts = s->pacing.vrx;
+  return 0;
+}
+
 int st20_tx_get_session_stats(st20_tx_handle handle, struct st20_tx_user_stats* stats) {
   struct st_tx_video_session_handle_impl* s_impl = handle;
 

lib/src/st2110/st_video_transmitter.c

@@ -17,7 +17,7 @@
  * This adds a superficial difference between the RTP timestamp and the transmission
  * time, which makes it look as if the packets have a slight latency immediately after
  * entering the wire. This prevents negative latency values. */
-#define LATENCY_COMPENSATION 1
+#define LATENCY_COMPENSATION 2
 
 static int video_trs_tasklet_start(void* priv) {
   struct st_video_transmitter_impl* trs = priv;

tests/integration_tests/noctx/St20pHandler.cpp

@@ -4,10 +4,10 @@
 
 #include "noctx.hpp"
 
-St20pHandler::St20pHandler(st_tests_context* ctx, FrameTestStrategy* sessionUserData,
+St20pHandler::St20pHandler(st_tests_context* ctx, FrameTestStrategy* frameTestStrategy,
                            st20p_tx_ops ops_tx, st20p_rx_ops ops_rx, bool create,
                            bool start)
-    : Handlers(ctx, sessionUserData) {
+    : Handlers(ctx, frameTestStrategy) {
   if (ops_tx.name == nullptr && ops_rx.name == nullptr) {
     fillSt20Ops();
     ops_tx = sessionsOpsTx;
@@ -17,11 +17,11 @@ St20pHandler::St20pHandler(st_tests_context* ctx, FrameTestStrategy* sessionUser
     sessionsOpsRx = ops_rx;
   }
 
-  EXPECT_TRUE(sessionUserData != nullptr);
-  if (!sessionUserData) return;
+  EXPECT_TRUE(frameTestStrategy != nullptr);
+  if (!frameTestStrategy) return;
 
-  this->sessionUserData = sessionUserData;
-  sessionUserData->parent = this;
+  this->frameTestStrategy = frameTestStrategy;
+  frameTestStrategy->parent = this;
 
   if (create) {
     createSession(ops_tx, ops_rx, start);
@@ -111,17 +111,17 @@ void St20pHandler::createSession(st20p_tx_ops ops_tx, st20p_rx_ops ops_rx, bool
   sessionsOpsTx = ops_tx;
   sessionsOpsRx = ops_rx;
 
-  createSessionTx();
   createSessionRx();
+  createSessionTx();
 
   if (start) {
     startSession();
   }
 }
 
 void St20pHandler::createSession(bool start) {
-  createSessionTx();
   createSessionRx();
+  createSessionTx();
 
   if (start) {
     startSession();
@@ -168,8 +168,8 @@ void St20pHandler::st20TxDefaultFunction(std::atomic<bool>& stopFlag) {
     ASSERT_EQ(frame->width, width);
     ASSERT_EQ(frame->height, height);
 
-    if (sessionUserData->enable_tx_modifier) {
-      sessionUserData->txTestFrameModifier(frame->addr, frameSize);
+    if (frameTestStrategy->enable_tx_modifier) {
+      frameTestStrategy->txTestFrameModifier(frame->addr, frameSize);
     }
 
     frame->data_size = frameSize;
@@ -201,28 +201,29 @@ void St20pHandler::st20RxDefaultFunction(std::atomic<bool>& stopFlag) {
     ASSERT_EQ(frame->height, height);
     ASSERT_GE(frame->data_size, frameSize);
 
-    if (sessionUserData->enable_rx_modifier) {
-      sessionUserData->rxTestFrameModifier(frame->addr, frame->data_size);
+    if (frameTestStrategy->enable_rx_modifier) {
+      frameTestStrategy->rxTestFrameModifier(frame->addr, frame->data_size);
     }
 
     st20p_rx_put_frame(handle, frame);
   }
 }
 
-void St20pHandler::startSession() {
-  Handlers::startSession(
-      {[this](std::atomic<bool>& stopFlag) { this->st20TxDefaultFunction(stopFlag); },
-       [this](std::atomic<bool>& stopFlag) { this->st20RxDefaultFunction(stopFlag); }});
-}
 
 void St20pHandler::startSessionTx() {
   Handlers::startSession(
-      {[this](std::atomic<bool>& stopFlag) { this->st20TxDefaultFunction(stopFlag); }});
-}
-
+    {[this](std::atomic<bool>& stopFlag) { this->st20TxDefaultFunction(stopFlag); }});
+  }
+  
 void St20pHandler::startSessionRx() {
   Handlers::startSession(
-      {[this](std::atomic<bool>& stopFlag) { this->st20RxDefaultFunction(stopFlag); }});
+    {[this](std::atomic<bool>& stopFlag) { this->st20RxDefaultFunction(stopFlag); }});
+  }
+  
+void St20pHandler::startSession() {
+  startSessionRx();
+  sleep(1);
+  startSessionTx();
 }
 
 void St20pHandler::startSession(

tests/integration_tests/noctx/St30pHandler.cpp

@@ -4,10 +4,10 @@
 
 #include "noctx.hpp"
 
-St30pHandler::St30pHandler(st_tests_context* ctx, FrameTestStrategy* sessionUserData,
+St30pHandler::St30pHandler(st_tests_context* ctx, FrameTestStrategy* frameTestStrategy,
                            st30p_tx_ops ops_tx, st30p_rx_ops ops_rx,
                            uint msPerFramebuffer, bool create, bool start)
-    : Handlers(ctx, sessionUserData), msPerFramebuffer(msPerFramebuffer) {
+    : Handlers(ctx, frameTestStrategy), msPerFramebuffer(msPerFramebuffer) {
   if (ops_tx.name == nullptr && ops_rx.name == nullptr) {
     fillSt30pOps();
     ops_tx = sessionsOpsTx;
@@ -17,10 +17,10 @@ St30pHandler::St30pHandler(st_tests_context* ctx, FrameTestStrategy* sessionUser
     sessionsOpsRx = ops_rx;
   }
 
-  if (!sessionUserData) throw std::runtime_error("St30pHandler no sessionUserData");
+  if (!frameTestStrategy) throw std::runtime_error("St30pHandler no frameTestStrategy");
 
-  this->sessionUserData = sessionUserData;
-  sessionUserData->parent = this;
+  this->frameTestStrategy = frameTestStrategy;
+  frameTestStrategy->parent = this;
 
   if (create) {
     createSession(ops_tx, ops_rx, start);
@@ -177,8 +177,8 @@ void St30pHandler::st30pTxDefaultFunction(std::atomic<bool>& stopFlag) {
     ASSERT_EQ(frame->ptime, sessionsOpsTx.ptime);
     ASSERT_EQ(frame->sampling, sessionsOpsTx.sampling);
 
-    if (sessionUserData->enable_tx_modifier) {
-      sessionUserData->txTestFrameModifier(frame, frame->data_size);
+    if (frameTestStrategy->enable_tx_modifier) {
+      frameTestStrategy->txTestFrameModifier(frame, frame->data_size);
     }
 
     st30p_tx_put_frame((st30p_tx_handle)handle, frame);
@@ -203,8 +203,8 @@ void St30pHandler::st30pRxDefaultFunction(std::atomic<bool>& stopFlag) {
     ASSERT_EQ(frame->ptime, sessionsOpsRx.ptime);
     ASSERT_EQ(frame->sampling, sessionsOpsRx.sampling);
 
-    if (sessionUserData->enable_rx_modifier) {
-      sessionUserData->rxTestFrameModifier(frame, frame->data_size);
+    if (frameTestStrategy->enable_rx_modifier) {
+      frameTestStrategy->rxTestFrameModifier(frame, frame->data_size);
     }
 
     st30p_rx_put_frame((st30p_rx_handle)handle, frame);

tests/integration_tests/noctx/noctx.cpp

@@ -53,13 +53,13 @@ void NoCtxTest::TearDown() {
   }
   st20pHandlers.clear();
 
-  for (auto data : sessionUserDatas) {
+  for (auto data : frameTestStrategys) {
     if (data) {
       delete data;
       data = nullptr;
     }
   }
-  sessionUserDatas.clear();
+  frameTestStrategys.clear();
 
   if (ctx) {
     if (ctx->handle) {
@@ -110,6 +110,46 @@ void NoCtxTest::sleepUntilFailure(int sleep_duration) {
   }
 }
 
+NoCtxTest::St20pHandlerBundle NoCtxTest::createSt20pHandlerBundle(
+    bool createTx, bool createRx,
+    std::function<FrameTestStrategy*(St20pHandler*)> strategyFactory,
+    std::function<void(St20pHandler*)> configure) {
+  if (!ctx) {
+    throw std::runtime_error("createSt20pHandlerBundle expects initialized ctx");
+  }
+
+  auto handler = new St20pHandler(ctx);
+  if (configure) {
+    configure(handler);
+  }
+
+  FrameTestStrategy* strategy = nullptr;
+  if (strategyFactory) {
+    strategy = strategyFactory(handler);
+    handler->setFrameTestStrategy(strategy);
+  }
+
+  if (createRx) {
+    handler->createSessionRx();
+  }
+  if (createTx) {
+    handler->createSessionTx();
+  }
+
+  registerSt20pResources(handler, strategy);
+  return {handler, strategy};
+}
+
+void NoCtxTest::registerSt20pResources(St20pHandler* handler,
+                                       FrameTestStrategy* strategy) {
+  if (handler) {
+    st20pHandlers.emplace_back(handler);
+  }
+  if (strategy) {
+    frameTestStrategys.emplace_back(strategy);
+  }
+}
+
 /**
  * @brief Set the TX session port names, including redundant port if specified.
  *