Drop buffered SRT data if the connection is down for too long.

[nageru] / nageru / video_encoder.cpp

diff --git a/nageru/video_encoder.cpp b/nageru/video_encoder.cpp
index 0257d38bbfae3f271a107a936a5f66150ed620bf..3b7028d5b9346a3a9a4e45145b5110e29c600d1d 100644 (file)
--- a/nageru/video_encoder.cpp
+++ b/nageru/video_encoder.cpp
@@ -9,6 +9,7 @@
 #include <netdb.h>
 #include <string>
 #include <thread>
+#include <chrono>
 
 extern "C" {
 #include <libavutil/mem.h>
@@ -30,6 +31,7 @@ extern "C" {
 class RefCountedFrame;
 
 using namespace std;
+using namespace std::chrono;
 using namespace movit;
 
 namespace {
@@ -463,21 +465,52 @@ int VideoEncoder::write_srt_packet(uint8_t *buf, int buf_size)
        if (want_srt_metric_update.exchange(false) && srt_sock != -1) {
                srt_metrics.update_srt_stats(srt_sock);
        }
+
+       bool has_drained = false;
+       bool trying_reconnect = false;
+       steady_clock::time_point first_connect_start;
+
        while (buf_size > 0 && !should_quit.load()) {
                if (srt_sock == -1) {
+                       if (!trying_reconnect) {
+                               first_connect_start = steady_clock::now();
+                               trying_reconnect = true;
+                       }
                        srt_sock = connect_to_srt();
                        if (srt_sock == -1) {
                                usleep(100000);
+                               if (!has_drained && duration<double>(steady_clock::now() - first_connect_start).count() >= global_flags.srt_output_latency_ms * 1e-3) {
+                                       // The entire concept for SRT is to have fixed, low latency.
+                                       // If we've been out for more than a latency period, we shouldn't
+                                       // try to send the entire backlog. (But we should be tolerant
+                                       // of a quick disconnect and reconnect.) Maybe it would be better
+                                       // to have a sliding window of how much we remove, but it quickly
+                                       // starts getting esoteric, so juts drop it all.
+                                       fprintf(stderr, "WARNING: No SRT connection for more than %d ms, dropping data.\n",
+                                               global_flags.srt_output_latency_ms);
+                                       srt_mux->drain();
+                                       has_drained = true;
+                               }
                                continue;
                        }
                        srt_metrics.update_srt_stats(srt_sock);
                }
+               if (has_drained) {
+                       // Now that we're reconnected, we can start accepting data again,
+                       // but discard the rest of this write (it is very old by now).
+                       srt_mux->undrain();
+                       break;
+               }
                int to_send = min(buf_size, SRT_LIVE_DEF_PLSIZE);
                int ret = srt_send(srt_sock, (char *)buf, to_send);
                if (ret < 0)  {
                        fprintf(stderr, "srt_send(): %s\n", srt_getlasterror_str());
                        srt_close(srt_sock);
                        srt_metrics.metric_srt_uptime_seconds = 0.0 / 0.0;
+                       if (!trying_reconnect) {
+                               first_connect_start = steady_clock::now();
+                               trying_reconnect = true;
+                       }
                        srt_sock = connect_to_srt();
                        continue;
                }