feat(srt): add listen_publisher_srtla for SRTLA/bonded connections

Add separate publisher listener port for SRTLA (bonded) connections, allowing both SRTLA and direct SRT publishers on the same server with streams accessible from a single player port.

New config option:
- listen_publisher_srtla: Publisher port with SRTLA patches enabled

Usage:
  server {
      listen_player 4000;             # All streams playable here
      listen_publisher 4001;          # Direct SRT publishers
      listen_publisher_srtla 4002;    # SRTLA publishers (via srtla_rec)
  }

SRTLA patches are automatically enabled on listen_publisher_srtla and disabled on listen_publisher. This prevents glitching that occurs when using the wrong SRT settings for each connection type.

Co-authored-by: datagutt <datagutt@lekanger.no>

Author: servusrene

Dockerfile

@@ -11,7 +11,7 @@ RUN apk update \
     && rm -rf /tmp/cpp-httplib
 
 # Clone, build and install belabox-patched SRT
-RUN git clone https://github.com/onsmith/srt.git srt \
+RUN git clone https://github.com/OpenIRL/srt.git srt \
     && cd srt \
     && ./configure \
     && make -j$(nproc) \

sls.conf

@@ -19,6 +19,7 @@ srt {
     server {
         listen_player 4000;
         listen_publisher 4001;
+        listen_publisher_srtla 4002;
 
         latency_min 200;    # Minimum allowed latency in ms (0 = no enforcement)
         latency_max 5000;   # Maximum allowed latency in ms (0 = no enforcement)

slscore/SLSListener.cpp

@@ -103,6 +103,7 @@ CSLSListener::CSLSListener()
     memset(m_http_url_role, 0, URL_MAX_LEN);
     memset(m_record_hls_path_prefix, 0, URL_MAX_LEN);
     m_is_publisher_listener = false;
+    m_is_srtla_listener = false;
     // Default path, will be overridden by configuration
     strcpy(m_stream_id_json_path, "/etc/sls/streamids.json");
 
@@ -163,6 +164,14 @@ void CSLSListener::set_listener_type(bool is_publisher)
     }
 }
 
+void CSLSListener::set_srtla_mode(bool is_srtla)
+{
+    m_is_srtla_listener = is_srtla;
+    if (is_srtla) {
+        sprintf(m_role_name, "listener-publisher-srtla");
+    }
+}
+
 int CSLSListener::init_conf_app()
 {
     sls_conf_server_t * conf_server;
@@ -247,9 +256,11 @@ int CSLSListener::start()
     if (NULL == m_srt)
         m_srt = new CSLSSrt();
 
-    // Use different ports for publisher and player listeners
+    // Use different ports for publisher, SRTLA publisher, and player listeners
     sls_conf_server_t* server_conf = (sls_conf_server_t*)m_conf;
-    if (m_is_publisher_listener) {
+    if (m_is_srtla_listener) {
+        m_port = server_conf->listen_publisher_srtla;
+    } else if (m_is_publisher_listener) {
         m_port = server_conf->listen_publisher;
     } else {
         m_port = server_conf->listen_player;
@@ -261,13 +272,14 @@ int CSLSListener::start()
         return SLS_ERROR;
     }
 
-    ret = m_srt->libsrt_setup(m_port);
+    ret = m_srt->libsrt_setup(m_port, m_is_srtla_listener);
     if (SLS_OK != ret) {
         sls_log(SLS_LOG_ERROR, "[%p]CSLSListener::start, libsrt_setup failure.", this);
         return ret;
     }
-    sls_log(SLS_LOG_INFO, "[%p]CSLSListener::start, libsrt_setup ok on port %d for %s.", 
-            this, m_port, m_is_publisher_listener ? "publisher" : "player");
+    sls_log(SLS_LOG_INFO, "[%p]CSLSListener::start, libsrt_setup ok on port %d for %s%s.",
+            this, m_port, m_is_publisher_listener ? "publisher" : "player",
+            m_is_srtla_listener ? " (SRTLA)" : "");
 
     // Only publisher listeners handle latency settings
     if (m_is_publisher_listener) {

slscore/SLSListener.hpp

@@ -42,6 +42,7 @@
 SLS_CONF_DYNAMIC_DECLARE_BEGIN(server)
 int              listen_player;        // Port for players
 int              listen_publisher;     // Port for publishers
+int              listen_publisher_srtla; // Port for SRTLA publishers (enables SRTLA patches)
 int              backlog;
 int              latency_min;          // Minimum allowed latency (ms)
 int              latency_max;          // Maximum allowed latency (ms)
@@ -60,6 +61,7 @@ SLS_CONF_DYNAMIC_DECLARE_END
 SLS_CONF_CMD_DYNAMIC_DECLARE_BEGIN(server)
 SLS_SET_CONF(server, int,    listen_player,        "listen port for players", 1, 65535),
 SLS_SET_CONF(server, int,    listen_publisher,     "listen port for publishers", 1, 65535),
+SLS_SET_CONF(server, int,    listen_publisher_srtla, "listen port for SRTLA publishers", 1, 65535),
 SLS_SET_CONF(server, int,    backlog,              "how many sockets may be allowed to wait until they are accepted", 1,    1024),
 SLS_SET_CONF(server, int,    latency_min,          "minimum allowed latency (ms)", 0, 5000),
 SLS_SET_CONF(server, int,    latency_max,          "maximum allowed latency (ms)", 0, 10000),
@@ -97,6 +99,7 @@ public :
     void set_map_pusher(CSLSMapRelay *map_puller);
     void set_record_hls_path_prefix(char *path);
     void set_listener_type(bool is_publisher);
+    void set_srtla_mode(bool is_srtla);
 
     virtual std::string get_stat_info();
 
@@ -113,6 +116,7 @@ public :
     char                m_http_url_role[URL_MAX_LEN];
     char                m_record_hls_path_prefix[URL_MAX_LEN];
     bool                m_is_publisher_listener;
+    bool                m_is_srtla_listener;
     char                m_stream_id_json_path[URL_MAX_LEN];
 
     int  init_conf_app();

slscore/SLSManager.cpp

@@ -133,7 +133,30 @@ int CSLSManager::start()
             return SLS_ERROR;
         }
         m_servers.push_back(p_pub);
-        
+
+        // Create SRTLA publisher listener if configured
+        if (conf->listen_publisher_srtla > 0) {
+            CSLSListener * p_srtla = new CSLSListener();
+            p_srtla->set_role_list(m_list_role);
+            p_srtla->set_conf(conf);
+            p_srtla->set_record_hls_path_prefix(conf_srt->record_hls_path_prefix);
+            p_srtla->set_map_data("", &m_map_data[i]);
+            p_srtla->set_map_publisher(&m_map_publisher[i]);
+            p_srtla->set_map_puller(&m_map_puller[i]);
+            p_srtla->set_map_pusher(&m_map_pusher[i]);
+            p_srtla->set_listener_type(true); // Publisher listener
+            p_srtla->set_srtla_mode(true);    // Enable SRTLA patches
+            if (p_srtla->init() != SLS_OK) {
+                sls_log(SLS_LOG_INFO, "[%p]CSLSManager::start, p_srtla->init failed.", this);
+                return SLS_ERROR;
+            }
+            if (p_srtla->start() != SLS_OK) {
+                sls_log(SLS_LOG_INFO, "[%p]CSLSManager::start, p_srtla->start failed.", this);
+                return SLS_ERROR;
+            }
+            m_servers.push_back(p_srtla);
+        }
+
         // Create player listener
         CSLSListener * p_play = new CSLSListener();//deleted by groups
         p_play->set_role_list(m_list_role);

slscore/SLSSrt.cpp

@@ -144,7 +144,7 @@ void CSLSSrt::libsrt_set_context(SRTContext *sc)
     m_sc = *sc;
 }
 
-int CSLSSrt::libsrt_setup(int port)
+int CSLSSrt::libsrt_setup(int port, bool srtla_patches)
 {
     struct addrinfo hints = { 0 }, *ai;
     int fd = -1;
@@ -205,6 +205,14 @@ int CSLSSrt::libsrt_setup(int port)
             sls_log(SLS_LOG_WARNING, "[%p]CSLSSrt::libsrt_setup, setsockopt(SRTO_REUSEADDR) failed.", this);
     }
 
+    if (srtla_patches) {
+        int srtla_enable = 1;
+        if (srt_setsockopt(fd, SOL_SOCKET, SRTO_SRTLAPATCHES, &srtla_enable, sizeof(srtla_enable)))
+            sls_log(SLS_LOG_WARNING, "[%p]CSLSSrt::libsrt_setup, setsockopt(SRTO_SRTLAPATCHES) failed.", this);
+        else
+            sls_log(SLS_LOG_INFO, "[%p]CSLSSrt::libsrt_setup, SRTLA patches enabled on port %d.", this, port);
+    }
+
     ret = srt_bind(fd, ai->ai_addr, ai->ai_addrlen);
     if (ret) {
         srt_close(fd);

slscore/SLSSrt.hpp

@@ -94,7 +94,7 @@ public :
 
     void libsrt_set_context(SRTContext *sc);
 
-    int  libsrt_setup(int port);
+    int  libsrt_setup(int port, bool srtla_patches = false);
     int  libsrt_close();
 
     int  libsrt_listen(int backlog);