Fix: User pacing test

- Split noctx code into more files
- Simplify testcases by adding HandlerBundle
- Use pacing info to better check receive time

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

Author: Sakoram

.gitignore

@@ -70,7 +70,6 @@ tests/validation/logs
 html/
 test.*
 build/
-core*
 out*
 assets/
 *.pkg

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

@@ -218,6 +218,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

@@ -4314,6 +4314,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/meson.build

@@ -8,6 +8,7 @@ sources = files('tests.cpp', 'st_test.cpp', 'st20_test.cpp', 'st22_test.cpp',
 
 subdir('noctx')
 sources += noctx_sources
+test_inc = include_directories('.', 'noctx')
 
 ufd_sources = files('ufd_test.cpp', 'ufd_loop_test.cpp', 'test_util.cpp')
 

tests/integration_tests/noctx/core/constants.hpp

@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2025 Intel Corporation
+ */
+
+#pragma once
+
+#ifndef SESSION_SKIP_PORT
+#define SESSION_SKIP_PORT -1
+#endif
+
+#ifndef VIDEO_CLOCK_HZ
+#define VIDEO_CLOCK_HZ 90000
+#endif

tests/integration_tests/noctx/core/handler_base.cpp

@@ -0,0 +1,76 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2025 Intel Corporation
+ */
+
+#include "handler_base.hpp"
+
+#include <cstdio>
+#include <stdexcept>
+
+Handlers::Handlers(st_tests_context* ctx, FrameTestStrategy* frameTestStrategy)
+    : ctx(ctx), frameTestStrategy(frameTestStrategy) {
+}
+
+Handlers::~Handlers() {
+  session.stop();
+}
+
+void Handlers::startSession(
+    std::vector<std::function<void(std::atomic<bool>&)>> threadFunctions, bool isRx) {
+  for (auto& func : threadFunctions) {
+    session.addThread(func, isRx);
+  }
+}
+
+void Handlers::stopSession() {
+  session.stop();
+}
+
+void Handlers::setSessionPortsTx(struct st_tx_port* port, int txPortIdx,
+                                 int txPortRedundantIdx) {
+  if (!ctx) {
+    throw std::runtime_error("setSessionPortsTx no ctx (ctx is null)");
+  } else if (txPortIdx >= (int)ctx->para.num_ports) {
+    throw std::runtime_error("setSessionPortsTx txPortIdx out of range");
+  } else if (txPortRedundantIdx >= (int)ctx->para.num_ports) {
+    throw std::runtime_error("setSessionPortsTx txPortRedundantIdx out of range");
+  }
+
+  if (txPortIdx >= 0) {
+    snprintf(port->port[MTL_SESSION_PORT_P], MTL_PORT_MAX_LEN, "%s",
+             ctx->para.port[txPortIdx]);
+    int num_ports = 1;
+
+    if (txPortRedundantIdx >= 0) {
+      snprintf(port->port[MTL_SESSION_PORT_R], MTL_PORT_MAX_LEN, "%s",
+               ctx->para.port[txPortRedundantIdx]);
+      num_ports = 2;
+    }
+
+    port->num_port = num_ports;
+  }
+}
+
+void Handlers::setSessionPortsRx(struct st_rx_port* port, int rxPortIdx,
+                                 int rxPortRedundantIdx) {
+  if (!ctx) {
+    throw std::runtime_error("setSessionPortsRx no ctx (ctx is null)");
+  } else if (rxPortIdx >= (int)ctx->para.num_ports) {
+    throw std::runtime_error("setSessionPortsRx rxPortIdx out of range");
+  } else if (rxPortRedundantIdx >= (int)ctx->para.num_ports) {
+    throw std::runtime_error("setSessionPortsRx rxPortRedundantIdx out of range");
+  }
+
+  if (rxPortIdx >= 0) {
+    snprintf(port->port[MTL_SESSION_PORT_P], MTL_PORT_MAX_LEN, "%s",
+             ctx->para.port[rxPortIdx]);
+    int num_ports = 1;
+
+    if (rxPortRedundantIdx >= 0) {
+      snprintf(port->port[MTL_SESSION_PORT_R], MTL_PORT_MAX_LEN, "%s",
+               ctx->para.port[rxPortRedundantIdx]);
+      num_ports = 2;
+    }
+    port->num_port = num_ports;
+  }
+}