#include <netdb.h>
#include <string>
#include <thread>
+#include <chrono>
extern "C" {
#include <libavutil/mem.h>
class RefCountedFrame;
using namespace std;
+using namespace std::chrono;
using namespace movit;
namespace {
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;
}