FFmpeg
libsrt.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 /**
20  * @file
21  * Haivision Open SRT (Secure Reliable Transport) protocol
22  */
23 
24 #include <srt/srt.h>
25 
26 #include "libavutil/opt.h"
27 #include "libavutil/parseutils.h"
28 #include "libavutil/time.h"
29 
30 #include "avformat.h"
31 #include "internal.h"
32 #include "network.h"
33 #include "os_support.h"
34 #include "url.h"
35 
36 /* This is for MPEG-TS and it's a default SRTO_PAYLOADSIZE for SRTT_LIVE (8 TS packets) */
37 #ifndef SRT_LIVE_DEFAULT_PAYLOAD_SIZE
38 #define SRT_LIVE_DEFAULT_PAYLOAD_SIZE 1316
39 #endif
40 
41 /* This is the maximum payload size for Live mode, should you have a different payload type than MPEG-TS */
42 #ifndef SRT_LIVE_MAX_PAYLOAD_SIZE
43 #define SRT_LIVE_MAX_PAYLOAD_SIZE 1456
44 #endif
45 
46 enum SRTMode {
50 };
51 
52 typedef struct SRTContext {
53  const AVClass *class;
54  int fd;
55  int eid;
56  int64_t rw_timeout;
57  int64_t listen_timeout;
60 
61  int64_t maxbw;
62  int pbkeylen;
63  char *passphrase;
64 #if SRT_VERSION_VALUE >= 0x010302
65  int enforced_encryption;
66  int kmrefreshrate;
67  int kmpreannounce;
68  int64_t snddropdelay;
69 #endif
70  int mss;
71  int ffs;
72  int ipttl;
73  int iptos;
74  int64_t inputbw;
75  int oheadbw;
76  int64_t latency;
77  int tlpktdrop;
78  int nakreport;
79  int64_t connect_timeout;
81  int64_t rcvlatency;
82  int64_t peerlatency;
83  enum SRTMode mode;
84  int sndbuf;
85  int rcvbuf;
88  char *streamid;
89  char *smoother;
91  SRT_TRANSTYPE transtype;
92  int linger;
93  int tsbpd;
94 } SRTContext;
95 
96 #define D AV_OPT_FLAG_DECODING_PARAM
97 #define E AV_OPT_FLAG_ENCODING_PARAM
98 #define OFFSET(x) offsetof(SRTContext, x)
99 static const AVOption libsrt_options[] = {
100  { "timeout", "Timeout of socket I/O operations (in microseconds)", OFFSET(rw_timeout), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
101  { "listen_timeout", "Connection awaiting timeout (in microseconds)" , OFFSET(listen_timeout), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
102  { "send_buffer_size", "Socket send buffer size (in bytes)", OFFSET(send_buffer_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
103  { "recv_buffer_size", "Socket receive buffer size (in bytes)", OFFSET(recv_buffer_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
104  { "pkt_size", "Maximum SRT packet size", OFFSET(payload_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, SRT_LIVE_MAX_PAYLOAD_SIZE, .flags = D|E, "payload_size" },
105  { "payload_size", "Maximum SRT packet size", OFFSET(payload_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, SRT_LIVE_MAX_PAYLOAD_SIZE, .flags = D|E, "payload_size" },
106  { "ts_size", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = SRT_LIVE_DEFAULT_PAYLOAD_SIZE }, INT_MIN, INT_MAX, .flags = D|E, "payload_size" },
107  { "max_size", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = SRT_LIVE_MAX_PAYLOAD_SIZE }, INT_MIN, INT_MAX, .flags = D|E, "payload_size" },
108  { "maxbw", "Maximum bandwidth (bytes per second) that the connection can use", OFFSET(maxbw), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
109  { "pbkeylen", "Crypto key len in bytes {16,24,32} Default: 16 (128-bit)", OFFSET(pbkeylen), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 32, .flags = D|E },
110  { "passphrase", "Crypto PBKDF2 Passphrase size[0,10..64] 0:disable crypto", OFFSET(passphrase), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
111 #if SRT_VERSION_VALUE >= 0x010302
112  { "enforced_encryption", "Enforces that both connection parties have the same passphrase set", OFFSET(enforced_encryption), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, .flags = D|E },
113  { "kmrefreshrate", "The number of packets to be transmitted after which the encryption key is switched to a new key", OFFSET(kmrefreshrate), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
114  { "kmpreannounce", "The interval between when a new encryption key is sent and when switchover occurs", OFFSET(kmpreannounce), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
115  { "snddropdelay", "The sender's extra delay(in microseconds) before dropping packets", OFFSET(snddropdelay), AV_OPT_TYPE_INT64, { .i64 = -2 }, -2, INT64_MAX, .flags = D|E },
116 #endif
117  { "mss", "The Maximum Segment Size", OFFSET(mss), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1500, .flags = D|E },
118  { "ffs", "Flight flag size (window size) (in bytes)", OFFSET(ffs), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
119  { "ipttl", "IP Time To Live", OFFSET(ipttl), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 255, .flags = D|E },
120  { "iptos", "IP Type of Service", OFFSET(iptos), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 255, .flags = D|E },
121  { "inputbw", "Estimated input stream rate", OFFSET(inputbw), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
122  { "oheadbw", "MaxBW ceiling based on % over input stream rate", OFFSET(oheadbw), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 100, .flags = D|E },
123  { "latency", "receiver delay (in microseconds) to absorb bursts of missed packet retransmissions", OFFSET(latency), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
124  { "tsbpddelay", "deprecated, same effect as latency option", OFFSET(latency), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
125  { "rcvlatency", "receive latency (in microseconds)", OFFSET(rcvlatency), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
126  { "peerlatency", "peer latency (in microseconds)", OFFSET(peerlatency), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
127  { "tlpktdrop", "Enable too-late pkt drop", OFFSET(tlpktdrop), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, .flags = D|E },
128  { "nakreport", "Enable receiver to send periodic NAK reports", OFFSET(nakreport), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, .flags = D|E },
129  { "connect_timeout", "Connect timeout(in milliseconds). Caller default: 3000, rendezvous (x 10)", OFFSET(connect_timeout), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
130  { "mode", "Connection mode (caller, listener, rendezvous)", OFFSET(mode), AV_OPT_TYPE_INT, { .i64 = SRT_MODE_CALLER }, SRT_MODE_CALLER, SRT_MODE_RENDEZVOUS, .flags = D|E, "mode" },
131  { "caller", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = SRT_MODE_CALLER }, INT_MIN, INT_MAX, .flags = D|E, "mode" },
132  { "listener", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = SRT_MODE_LISTENER }, INT_MIN, INT_MAX, .flags = D|E, "mode" },
133  { "rendezvous", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = SRT_MODE_RENDEZVOUS }, INT_MIN, INT_MAX, .flags = D|E, "mode" },
134  { "sndbuf", "Send buffer size (in bytes)", OFFSET(sndbuf), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
135  { "rcvbuf", "Receive buffer size (in bytes)", OFFSET(rcvbuf), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
136  { "lossmaxttl", "Maximum possible packet reorder tolerance", OFFSET(lossmaxttl), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
137  { "minversion", "The minimum SRT version that is required from the peer", OFFSET(minversion), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
138  { "streamid", "A string of up to 512 characters that an Initiator can pass to a Responder", OFFSET(streamid), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
139  { "srt_streamid", "A string of up to 512 characters that an Initiator can pass to a Responder", OFFSET(streamid), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
140  { "smoother", "The type of Smoother used for the transmission for that socket", OFFSET(smoother), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
141  { "messageapi", "Enable message API", OFFSET(messageapi), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, .flags = D|E },
142  { "transtype", "The transmission type for the socket", OFFSET(transtype), AV_OPT_TYPE_INT, { .i64 = SRTT_INVALID }, SRTT_LIVE, SRTT_INVALID, .flags = D|E, "transtype" },
143  { "live", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = SRTT_LIVE }, INT_MIN, INT_MAX, .flags = D|E, "transtype" },
144  { "file", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = SRTT_FILE }, INT_MIN, INT_MAX, .flags = D|E, "transtype" },
145  { "linger", "Number of seconds that the socket waits for unsent data when closing", OFFSET(linger), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
146  { "tsbpd", "Timestamp-based packet delivery", OFFSET(tsbpd), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, .flags = D|E },
147  { NULL }
148 };
149 
151 {
152  int os_errno;
153  int err = srt_getlasterror(&os_errno);
154  if (err == SRT_EASYNCRCV || err == SRT_EASYNCSND)
155  return AVERROR(EAGAIN);
156  av_log(h, AV_LOG_ERROR, "%s\n", srt_getlasterror_str());
157  return os_errno ? AVERROR(os_errno) : AVERROR_UNKNOWN;
158 }
159 
160 static int libsrt_getsockopt(URLContext *h, int fd, SRT_SOCKOPT optname, const char * optnamestr, void * optval, int * optlen)
161 {
162  if (srt_getsockopt(fd, 0, optname, optval, optlen) < 0) {
163  av_log(h, AV_LOG_ERROR, "failed to get option %s on socket: %s\n", optnamestr, srt_getlasterror_str());
164  return AVERROR(EIO);
165  }
166  return 0;
167 }
168 
169 static int libsrt_socket_nonblock(int socket, int enable)
170 {
171  int ret, blocking = enable ? 0 : 1;
172  /* Setting SRTO_{SND,RCV}SYN options to 1 enable blocking mode, setting them to 0 enable non-blocking mode. */
173  ret = srt_setsockopt(socket, 0, SRTO_SNDSYN, &blocking, sizeof(blocking));
174  if (ret < 0)
175  return ret;
176  return srt_setsockopt(socket, 0, SRTO_RCVSYN, &blocking, sizeof(blocking));
177 }
178 
179 static int libsrt_epoll_create(URLContext *h, int fd, int write)
180 {
181  int modes = SRT_EPOLL_ERR | (write ? SRT_EPOLL_OUT : SRT_EPOLL_IN);
182  int eid = srt_epoll_create();
183  if (eid < 0)
184  return libsrt_neterrno(h);
185  if (srt_epoll_add_usock(eid, fd, &modes) < 0) {
186  srt_epoll_release(eid);
187  return libsrt_neterrno(h);
188  }
189  return eid;
190 }
191 
192 static int libsrt_network_wait_fd(URLContext *h, int eid, int write)
193 {
194  int ret, len = 1, errlen = 1;
195  SRTSOCKET ready[1];
196  SRTSOCKET error[1];
197 
198  if (write) {
199  ret = srt_epoll_wait(eid, error, &errlen, ready, &len, POLLING_TIME, 0, 0, 0, 0);
200  } else {
201  ret = srt_epoll_wait(eid, ready, &len, error, &errlen, POLLING_TIME, 0, 0, 0, 0);
202  }
203  if (ret < 0) {
204  if (srt_getlasterror(NULL) == SRT_ETIMEOUT)
205  ret = AVERROR(EAGAIN);
206  else
207  ret = libsrt_neterrno(h);
208  } else {
209  ret = errlen ? AVERROR(EIO) : 0;
210  }
211  return ret;
212 }
213 
214 /* TODO de-duplicate code from ff_network_wait_fd_timeout() */
215 
216 static int libsrt_network_wait_fd_timeout(URLContext *h, int eid, int write, int64_t timeout, AVIOInterruptCB *int_cb)
217 {
218  int ret;
219  int64_t wait_start = 0;
220 
221  while (1) {
223  return AVERROR_EXIT;
224  ret = libsrt_network_wait_fd(h, eid, write);
225  if (ret != AVERROR(EAGAIN))
226  return ret;
227  if (timeout > 0) {
228  if (!wait_start)
229  wait_start = av_gettime_relative();
230  else if (av_gettime_relative() - wait_start > timeout)
231  return AVERROR(ETIMEDOUT);
232  }
233  }
234 }
235 
236 static int libsrt_listen(int eid, int fd, const struct sockaddr *addr, socklen_t addrlen, URLContext *h, int64_t timeout)
237 {
238  int ret;
239  int reuse = 1;
240  /* Max streamid length plus an extra space for the terminating null character */
241  char streamid[513];
242  int streamid_len = sizeof(streamid);
243  if (srt_setsockopt(fd, SOL_SOCKET, SRTO_REUSEADDR, &reuse, sizeof(reuse))) {
244  av_log(h, AV_LOG_WARNING, "setsockopt(SRTO_REUSEADDR) failed\n");
245  }
246  if (srt_bind(fd, addr, addrlen))
247  return libsrt_neterrno(h);
248 
249  if (srt_listen(fd, 1))
250  return libsrt_neterrno(h);
251 
252  ret = libsrt_network_wait_fd_timeout(h, eid, 1, timeout, &h->interrupt_callback);
253  if (ret < 0)
254  return ret;
255 
256  ret = srt_accept(fd, NULL, NULL);
257  if (ret < 0)
258  return libsrt_neterrno(h);
259  if (libsrt_socket_nonblock(ret, 1) < 0)
260  av_log(h, AV_LOG_DEBUG, "libsrt_socket_nonblock failed\n");
261  if (!libsrt_getsockopt(h, ret, SRTO_STREAMID, "SRTO_STREAMID", streamid, &streamid_len))
262  /* Note: returned streamid_len doesn't count the terminating null character */
263  av_log(h, AV_LOG_VERBOSE, "accept streamid [%s], length %d\n", streamid, streamid_len);
264 
265  return ret;
266 }
267 
268 static int libsrt_listen_connect(int eid, int fd, const struct sockaddr *addr, socklen_t addrlen, int64_t timeout, URLContext *h, int will_try_next)
269 {
270  int ret;
271 
272  if (srt_connect(fd, addr, addrlen) < 0)
273  return libsrt_neterrno(h);
274 
275  ret = libsrt_network_wait_fd_timeout(h, eid, 1, timeout, &h->interrupt_callback);
276  if (ret < 0) {
277  if (will_try_next) {
279  "Connection to %s failed (%s), trying next address\n",
280  h->filename, av_err2str(ret));
281  } else {
282  av_log(h, AV_LOG_ERROR, "Connection to %s failed: %s\n",
283  h->filename, av_err2str(ret));
284  }
285  }
286  return ret;
287 }
288 
289 static int libsrt_setsockopt(URLContext *h, int fd, SRT_SOCKOPT optname, const char * optnamestr, const void * optval, int optlen)
290 {
291  if (srt_setsockopt(fd, 0, optname, optval, optlen) < 0) {
292  av_log(h, AV_LOG_ERROR, "failed to set option %s on socket: %s\n", optnamestr, srt_getlasterror_str());
293  return AVERROR(EIO);
294  }
295  return 0;
296 }
297 
298 /* - The "POST" options can be altered any time on a connected socket.
299  They MAY have also some meaning when set prior to connecting; such
300  option is SRTO_RCVSYN, which makes connect/accept call asynchronous.
301  Because of that this option is treated special way in this app. */
303 {
304  SRTContext *s = h->priv_data;
305 
306  if ((s->inputbw >= 0 && libsrt_setsockopt(h, fd, SRTO_INPUTBW, "SRTO_INPUTBW", &s->inputbw, sizeof(s->inputbw)) < 0) ||
307  (s->oheadbw >= 0 && libsrt_setsockopt(h, fd, SRTO_OHEADBW, "SRTO_OHEADBW", &s->oheadbw, sizeof(s->oheadbw)) < 0)) {
308  return AVERROR(EIO);
309  }
310  return 0;
311 }
312 
313 /* - The "PRE" options must be set prior to connecting and can't be altered
314  on a connected socket, however if set on a listening socket, they are
315  derived by accept-ed socket. */
316 static int libsrt_set_options_pre(URLContext *h, int fd)
317 {
318  SRTContext *s = h->priv_data;
319  int yes = 1;
320  int latency = s->latency / 1000;
321  int rcvlatency = s->rcvlatency / 1000;
322  int peerlatency = s->peerlatency / 1000;
323  int snddropdelay = s->snddropdelay > 0 ? s->snddropdelay / 1000 : s->snddropdelay;
324  int connect_timeout = s->connect_timeout;
325 
326  if ((s->mode == SRT_MODE_RENDEZVOUS && libsrt_setsockopt(h, fd, SRTO_RENDEZVOUS, "SRTO_RENDEZVOUS", &yes, sizeof(yes)) < 0) ||
327  (s->transtype != SRTT_INVALID && libsrt_setsockopt(h, fd, SRTO_TRANSTYPE, "SRTO_TRANSTYPE", &s->transtype, sizeof(s->transtype)) < 0) ||
328  (s->maxbw >= 0 && libsrt_setsockopt(h, fd, SRTO_MAXBW, "SRTO_MAXBW", &s->maxbw, sizeof(s->maxbw)) < 0) ||
329  (s->pbkeylen >= 0 && libsrt_setsockopt(h, fd, SRTO_PBKEYLEN, "SRTO_PBKEYLEN", &s->pbkeylen, sizeof(s->pbkeylen)) < 0) ||
330  (s->passphrase && libsrt_setsockopt(h, fd, SRTO_PASSPHRASE, "SRTO_PASSPHRASE", s->passphrase, strlen(s->passphrase)) < 0) ||
331 #if SRT_VERSION_VALUE >= 0x010302
332 #if SRT_VERSION_VALUE >= 0x010401
333  (s->enforced_encryption >= 0 && libsrt_setsockopt(h, fd, SRTO_ENFORCEDENCRYPTION, "SRTO_ENFORCEDENCRYPTION", &s->enforced_encryption, sizeof(s->enforced_encryption)) < 0) ||
334 #else
335  /* SRTO_STRICTENC == SRTO_ENFORCEDENCRYPTION (53), but for compatibility, we used SRTO_STRICTENC */
336  (s->enforced_encryption >= 0 && libsrt_setsockopt(h, fd, SRTO_STRICTENC, "SRTO_STRICTENC", &s->enforced_encryption, sizeof(s->enforced_encryption)) < 0) ||
337 #endif
338  (s->kmrefreshrate >= 0 && libsrt_setsockopt(h, fd, SRTO_KMREFRESHRATE, "SRTO_KMREFRESHRATE", &s->kmrefreshrate, sizeof(s->kmrefreshrate)) < 0) ||
339  (s->kmpreannounce >= 0 && libsrt_setsockopt(h, fd, SRTO_KMPREANNOUNCE, "SRTO_KMPREANNOUNCE", &s->kmpreannounce, sizeof(s->kmpreannounce)) < 0) ||
340  (s->snddropdelay >=-1 && libsrt_setsockopt(h, fd, SRTO_SNDDROPDELAY, "SRTO_SNDDROPDELAY", &snddropdelay, sizeof(snddropdelay)) < 0) ||
341 #endif
342  (s->mss >= 0 && libsrt_setsockopt(h, fd, SRTO_MSS, "SRTO_MSS", &s->mss, sizeof(s->mss)) < 0) ||
343  (s->ffs >= 0 && libsrt_setsockopt(h, fd, SRTO_FC, "SRTO_FC", &s->ffs, sizeof(s->ffs)) < 0) ||
344  (s->ipttl >= 0 && libsrt_setsockopt(h, fd, SRTO_IPTTL, "SRTO_IPTTL", &s->ipttl, sizeof(s->ipttl)) < 0) ||
345  (s->iptos >= 0 && libsrt_setsockopt(h, fd, SRTO_IPTOS, "SRTO_IPTOS", &s->iptos, sizeof(s->iptos)) < 0) ||
346  (s->latency >= 0 && libsrt_setsockopt(h, fd, SRTO_LATENCY, "SRTO_LATENCY", &latency, sizeof(latency)) < 0) ||
347  (s->rcvlatency >= 0 && libsrt_setsockopt(h, fd, SRTO_RCVLATENCY, "SRTO_RCVLATENCY", &rcvlatency, sizeof(rcvlatency)) < 0) ||
348  (s->peerlatency >= 0 && libsrt_setsockopt(h, fd, SRTO_PEERLATENCY, "SRTO_PEERLATENCY", &peerlatency, sizeof(peerlatency)) < 0) ||
349  (s->tlpktdrop >= 0 && libsrt_setsockopt(h, fd, SRTO_TLPKTDROP, "SRTO_TLPKTDROP", &s->tlpktdrop, sizeof(s->tlpktdrop)) < 0) ||
350  (s->nakreport >= 0 && libsrt_setsockopt(h, fd, SRTO_NAKREPORT, "SRTO_NAKREPORT", &s->nakreport, sizeof(s->nakreport)) < 0) ||
351  (connect_timeout >= 0 && libsrt_setsockopt(h, fd, SRTO_CONNTIMEO, "SRTO_CONNTIMEO", &connect_timeout, sizeof(connect_timeout)) <0 ) ||
352  (s->sndbuf >= 0 && libsrt_setsockopt(h, fd, SRTO_SNDBUF, "SRTO_SNDBUF", &s->sndbuf, sizeof(s->sndbuf)) < 0) ||
353  (s->rcvbuf >= 0 && libsrt_setsockopt(h, fd, SRTO_RCVBUF, "SRTO_RCVBUF", &s->rcvbuf, sizeof(s->rcvbuf)) < 0) ||
354  (s->lossmaxttl >= 0 && libsrt_setsockopt(h, fd, SRTO_LOSSMAXTTL, "SRTO_LOSSMAXTTL", &s->lossmaxttl, sizeof(s->lossmaxttl)) < 0) ||
355  (s->minversion >= 0 && libsrt_setsockopt(h, fd, SRTO_MINVERSION, "SRTO_MINVERSION", &s->minversion, sizeof(s->minversion)) < 0) ||
356  (s->streamid && libsrt_setsockopt(h, fd, SRTO_STREAMID, "SRTO_STREAMID", s->streamid, strlen(s->streamid)) < 0) ||
357 #if SRT_VERSION_VALUE >= 0x010401
358  (s->smoother && libsrt_setsockopt(h, fd, SRTO_CONGESTION, "SRTO_CONGESTION", s->smoother, strlen(s->smoother)) < 0) ||
359 #else
360  (s->smoother && libsrt_setsockopt(h, fd, SRTO_SMOOTHER, "SRTO_SMOOTHER", s->smoother, strlen(s->smoother)) < 0) ||
361 #endif
362  (s->messageapi >= 0 && libsrt_setsockopt(h, fd, SRTO_MESSAGEAPI, "SRTO_MESSAGEAPI", &s->messageapi, sizeof(s->messageapi)) < 0) ||
363  (s->payload_size >= 0 && libsrt_setsockopt(h, fd, SRTO_PAYLOADSIZE, "SRTO_PAYLOADSIZE", &s->payload_size, sizeof(s->payload_size)) < 0) ||
364  ((h->flags & AVIO_FLAG_WRITE) && libsrt_setsockopt(h, fd, SRTO_SENDER, "SRTO_SENDER", &yes, sizeof(yes)) < 0) ||
365  (s->tsbpd >= 0 && libsrt_setsockopt(h, fd, SRTO_TSBPDMODE, "SRTO_TSBPDMODE", &s->tsbpd, sizeof(s->tsbpd)) < 0)) {
366  return AVERROR(EIO);
367  }
368 
369  if (s->linger >= 0) {
370  struct linger lin;
371  lin.l_linger = s->linger;
372  lin.l_onoff = lin.l_linger > 0 ? 1 : 0;
373  if (libsrt_setsockopt(h, fd, SRTO_LINGER, "SRTO_LINGER", &lin, sizeof(lin)) < 0)
374  return AVERROR(EIO);
375  }
376  return 0;
377 }
378 
379 
380 static int libsrt_setup(URLContext *h, const char *uri, int flags)
381 {
382  struct addrinfo hints = { 0 }, *ai, *cur_ai;
383  int port, fd;
384  SRTContext *s = h->priv_data;
385  const char *p;
386  char buf[256];
387  int ret;
388  char hostname[1024],proto[1024],path[1024];
389  char portstr[10];
390  int64_t open_timeout = 0;
391  int eid, write_eid;
392 
393  av_url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname),
394  &port, path, sizeof(path), uri);
395  if (strcmp(proto, "srt"))
396  return AVERROR(EINVAL);
397  if (port <= 0 || port >= 65536) {
398  av_log(h, AV_LOG_ERROR, "Port missing in uri\n");
399  return AVERROR(EINVAL);
400  }
401  p = strchr(uri, '?');
402  if (p) {
403  if (av_find_info_tag(buf, sizeof(buf), "timeout", p)) {
404  s->rw_timeout = strtoll(buf, NULL, 10);
405  }
406  if (av_find_info_tag(buf, sizeof(buf), "listen_timeout", p)) {
407  s->listen_timeout = strtoll(buf, NULL, 10);
408  }
409  }
410  if (s->rw_timeout >= 0) {
411  open_timeout = h->rw_timeout = s->rw_timeout;
412  }
413  hints.ai_family = AF_UNSPEC;
414  hints.ai_socktype = SOCK_DGRAM;
415  snprintf(portstr, sizeof(portstr), "%d", port);
416  if (s->mode == SRT_MODE_LISTENER)
417  hints.ai_flags |= AI_PASSIVE;
418  ret = getaddrinfo(hostname[0] ? hostname : NULL, portstr, &hints, &ai);
419  if (ret) {
421  "Failed to resolve hostname %s: %s\n",
422  hostname, gai_strerror(ret));
423  return AVERROR(EIO);
424  }
425 
426  cur_ai = ai;
427 
428  restart:
429 
430  fd = srt_socket(cur_ai->ai_family, cur_ai->ai_socktype, 0);
431  if (fd < 0) {
432  ret = libsrt_neterrno(h);
433  goto fail;
434  }
435 
436  if ((ret = libsrt_set_options_pre(h, fd)) < 0) {
437  goto fail;
438  }
439 
440  /* Set the socket's send or receive buffer sizes, if specified.
441  If unspecified or setting fails, system default is used. */
442  if (s->recv_buffer_size > 0) {
443  srt_setsockopt(fd, SOL_SOCKET, SRTO_UDP_RCVBUF, &s->recv_buffer_size, sizeof (s->recv_buffer_size));
444  }
445  if (s->send_buffer_size > 0) {
446  srt_setsockopt(fd, SOL_SOCKET, SRTO_UDP_SNDBUF, &s->send_buffer_size, sizeof (s->send_buffer_size));
447  }
448  if (libsrt_socket_nonblock(fd, 1) < 0)
449  av_log(h, AV_LOG_DEBUG, "libsrt_socket_nonblock failed\n");
450 
451  ret = write_eid = libsrt_epoll_create(h, fd, 1);
452  if (ret < 0)
453  goto fail1;
454  if (s->mode == SRT_MODE_LISTENER) {
455  // multi-client
456  ret = libsrt_listen(write_eid, fd, cur_ai->ai_addr, cur_ai->ai_addrlen, h, s->listen_timeout);
457  srt_epoll_release(write_eid);
458  if (ret < 0)
459  goto fail1;
460  srt_close(fd);
461  fd = ret;
462  } else {
463  if (s->mode == SRT_MODE_RENDEZVOUS) {
464  if (srt_bind(fd, cur_ai->ai_addr, cur_ai->ai_addrlen)) {
465  ret = libsrt_neterrno(h);
466  srt_epoll_release(write_eid);
467  goto fail1;
468  }
469  }
470 
471  ret = libsrt_listen_connect(write_eid, fd, cur_ai->ai_addr, cur_ai->ai_addrlen,
472  open_timeout, h, !!cur_ai->ai_next);
473  srt_epoll_release(write_eid);
474  if (ret < 0) {
475  if (ret == AVERROR_EXIT)
476  goto fail1;
477  else
478  goto fail;
479  }
480  }
481  if ((ret = libsrt_set_options_post(h, fd)) < 0) {
482  goto fail;
483  }
484 
485  if (flags & AVIO_FLAG_WRITE) {
486  int packet_size = 0;
487  int optlen = sizeof(packet_size);
488  ret = libsrt_getsockopt(h, fd, SRTO_PAYLOADSIZE, "SRTO_PAYLOADSIZE", &packet_size, &optlen);
489  if (ret < 0)
490  goto fail1;
491  if (packet_size > 0)
492  h->max_packet_size = packet_size;
493  }
494 
496  if (eid < 0)
497  goto fail1;
498 
499  h->is_streamed = 1;
500  s->fd = fd;
501  s->eid = eid;
502 
503  freeaddrinfo(ai);
504  return 0;
505 
506  fail:
507  if (cur_ai->ai_next) {
508  /* Retry with the next sockaddr */
509  cur_ai = cur_ai->ai_next;
510  if (fd >= 0)
511  srt_close(fd);
512  ret = 0;
513  goto restart;
514  }
515  fail1:
516  if (fd >= 0)
517  srt_close(fd);
518  freeaddrinfo(ai);
519  return ret;
520 }
521 
522 static int libsrt_open(URLContext *h, const char *uri, int flags)
523 {
524  SRTContext *s = h->priv_data;
525  const char * p;
526  char buf[256];
527  int ret = 0;
528 
529  if (srt_startup() < 0) {
530  return AVERROR_UNKNOWN;
531  }
532 
533  /* SRT options (srt/srt.h) */
534  p = strchr(uri, '?');
535  if (p) {
536  if (av_find_info_tag(buf, sizeof(buf), "maxbw", p)) {
537  s->maxbw = strtoll(buf, NULL, 10);
538  }
539  if (av_find_info_tag(buf, sizeof(buf), "pbkeylen", p)) {
540  s->pbkeylen = strtol(buf, NULL, 10);
541  }
542  if (av_find_info_tag(buf, sizeof(buf), "passphrase", p)) {
543  av_freep(&s->passphrase);
544  s->passphrase = av_strndup(buf, strlen(buf));
545  }
546 #if SRT_VERSION_VALUE >= 0x010302
547  if (av_find_info_tag(buf, sizeof(buf), "enforced_encryption", p)) {
548  s->enforced_encryption = strtol(buf, NULL, 10);
549  }
550  if (av_find_info_tag(buf, sizeof(buf), "kmrefreshrate", p)) {
551  s->kmrefreshrate = strtol(buf, NULL, 10);
552  }
553  if (av_find_info_tag(buf, sizeof(buf), "kmpreannounce", p)) {
554  s->kmpreannounce = strtol(buf, NULL, 10);
555  }
556  if (av_find_info_tag(buf, sizeof(buf), "snddropdelay", p)) {
557  s->snddropdelay = strtoll(buf, NULL, 10);
558  }
559 #endif
560  if (av_find_info_tag(buf, sizeof(buf), "mss", p)) {
561  s->mss = strtol(buf, NULL, 10);
562  }
563  if (av_find_info_tag(buf, sizeof(buf), "ffs", p)) {
564  s->ffs = strtol(buf, NULL, 10);
565  }
566  if (av_find_info_tag(buf, sizeof(buf), "ipttl", p)) {
567  s->ipttl = strtol(buf, NULL, 10);
568  }
569  if (av_find_info_tag(buf, sizeof(buf), "iptos", p)) {
570  s->iptos = strtol(buf, NULL, 10);
571  }
572  if (av_find_info_tag(buf, sizeof(buf), "inputbw", p)) {
573  s->inputbw = strtoll(buf, NULL, 10);
574  }
575  if (av_find_info_tag(buf, sizeof(buf), "oheadbw", p)) {
576  s->oheadbw = strtol(buf, NULL, 10);
577  }
578  if (av_find_info_tag(buf, sizeof(buf), "latency", p)) {
579  s->latency = strtoll(buf, NULL, 10);
580  }
581  if (av_find_info_tag(buf, sizeof(buf), "tsbpddelay", p)) {
582  s->latency = strtoll(buf, NULL, 10);
583  }
584  if (av_find_info_tag(buf, sizeof(buf), "rcvlatency", p)) {
585  s->rcvlatency = strtoll(buf, NULL, 10);
586  }
587  if (av_find_info_tag(buf, sizeof(buf), "peerlatency", p)) {
588  s->peerlatency = strtoll(buf, NULL, 10);
589  }
590  if (av_find_info_tag(buf, sizeof(buf), "tlpktdrop", p)) {
591  s->tlpktdrop = strtol(buf, NULL, 10);
592  }
593  if (av_find_info_tag(buf, sizeof(buf), "nakreport", p)) {
594  s->nakreport = strtol(buf, NULL, 10);
595  }
596  if (av_find_info_tag(buf, sizeof(buf), "connect_timeout", p)) {
597  s->connect_timeout = strtoll(buf, NULL, 10);
598  }
599  if (av_find_info_tag(buf, sizeof(buf), "payload_size", p) ||
600  av_find_info_tag(buf, sizeof(buf), "pkt_size", p)) {
601  s->payload_size = strtol(buf, NULL, 10);
602  }
603  if (av_find_info_tag(buf, sizeof(buf), "mode", p)) {
604  if (!strcmp(buf, "caller")) {
605  s->mode = SRT_MODE_CALLER;
606  } else if (!strcmp(buf, "listener")) {
607  s->mode = SRT_MODE_LISTENER;
608  } else if (!strcmp(buf, "rendezvous")) {
609  s->mode = SRT_MODE_RENDEZVOUS;
610  } else {
611  ret = AVERROR(EINVAL);
612  goto err;
613  }
614  }
615  if (av_find_info_tag(buf, sizeof(buf), "sndbuf", p)) {
616  s->sndbuf = strtol(buf, NULL, 10);
617  }
618  if (av_find_info_tag(buf, sizeof(buf), "rcvbuf", p)) {
619  s->rcvbuf = strtol(buf, NULL, 10);
620  }
621  if (av_find_info_tag(buf, sizeof(buf), "lossmaxttl", p)) {
622  s->lossmaxttl = strtol(buf, NULL, 10);
623  }
624  if (av_find_info_tag(buf, sizeof(buf), "minversion", p)) {
625  s->minversion = strtol(buf, NULL, 0);
626  }
627  if (av_find_info_tag(buf, sizeof(buf), "streamid", p)) {
628  av_freep(&s->streamid);
629  s->streamid = av_strdup(buf);
630  if (!s->streamid) {
631  ret = AVERROR(ENOMEM);
632  goto err;
633  }
634  }
635  if (av_find_info_tag(buf, sizeof(buf), "smoother", p)) {
636  av_freep(&s->smoother);
637  s->smoother = av_strdup(buf);
638  if(!s->smoother) {
639  ret = AVERROR(ENOMEM);
640  goto err;
641  }
642  }
643  if (av_find_info_tag(buf, sizeof(buf), "messageapi", p)) {
644  s->messageapi = strtol(buf, NULL, 10);
645  }
646  if (av_find_info_tag(buf, sizeof(buf), "transtype", p)) {
647  if (!strcmp(buf, "live")) {
648  s->transtype = SRTT_LIVE;
649  } else if (!strcmp(buf, "file")) {
650  s->transtype = SRTT_FILE;
651  } else {
652  ret = AVERROR(EINVAL);
653  goto err;
654  }
655  }
656  if (av_find_info_tag(buf, sizeof(buf), "linger", p)) {
657  s->linger = strtol(buf, NULL, 10);
658  }
659  }
660  ret = libsrt_setup(h, uri, flags);
661  if (ret < 0)
662  goto err;
663  return 0;
664 
665 err:
666  av_freep(&s->smoother);
667  av_freep(&s->streamid);
668  srt_cleanup();
669  return ret;
670 }
671 
672 static int libsrt_read(URLContext *h, uint8_t *buf, int size)
673 {
674  SRTContext *s = h->priv_data;
675  int ret;
676 
677  if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
678  ret = libsrt_network_wait_fd_timeout(h, s->eid, 0, h->rw_timeout, &h->interrupt_callback);
679  if (ret)
680  return ret;
681  }
682 
683  ret = srt_recvmsg(s->fd, buf, size);
684  if (ret < 0) {
685  ret = libsrt_neterrno(h);
686  }
687 
688  return ret;
689 }
690 
691 static int libsrt_write(URLContext *h, const uint8_t *buf, int size)
692 {
693  SRTContext *s = h->priv_data;
694  int ret;
695 
696  if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
697  ret = libsrt_network_wait_fd_timeout(h, s->eid, 1, h->rw_timeout, &h->interrupt_callback);
698  if (ret)
699  return ret;
700  }
701 
702  ret = srt_sendmsg(s->fd, buf, size, -1, 1);
703  if (ret < 0) {
704  ret = libsrt_neterrno(h);
705  }
706 
707  return ret;
708 }
709 
711 {
712  SRTContext *s = h->priv_data;
713 
714  srt_epoll_release(s->eid);
715  srt_close(s->fd);
716 
717  srt_cleanup();
718 
719  return 0;
720 }
721 
722 static const AVClass libsrt_class = {
723  .class_name = "libsrt",
724  .item_name = av_default_item_name,
725  .option = libsrt_options,
726  .version = LIBAVUTIL_VERSION_INT,
727 };
728 
730  .name = "srt",
731  .url_open = libsrt_open,
732  .url_read = libsrt_read,
733  .url_write = libsrt_write,
734  .url_close = libsrt_close,
735  .priv_data_size = sizeof(SRTContext),
737  .priv_data_class = &libsrt_class,
738 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
av_find_info_tag
int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
Attempt to find a specific tag in a URL.
Definition: parseutils.c:751
SRTContext::ffs
int ffs
Definition: libsrt.c:71
URL_PROTOCOL_FLAG_NETWORK
#define URL_PROTOCOL_FLAG_NETWORK
Definition: url.h:34
SRTContext::mode
enum SRTMode mode
Definition: libsrt.c:83
SRT_LIVE_DEFAULT_PAYLOAD_SIZE
#define SRT_LIVE_DEFAULT_PAYLOAD_SIZE
Definition: libsrt.c:38
libsrt_network_wait_fd_timeout
static int libsrt_network_wait_fd_timeout(URLContext *h, int eid, int write, int64_t timeout, AVIOInterruptCB *int_cb)
Definition: libsrt.c:216
SRTContext::sndbuf
int sndbuf
Definition: libsrt.c:84
SRTContext
Definition: srtenc.c:33
AVOption
AVOption.
Definition: opt.h:247
SRTContext::pbkeylen
int pbkeylen
Definition: libsrt.c:62
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
libsrt_getsockopt
static int libsrt_getsockopt(URLContext *h, int fd, SRT_SOCKOPT optname, const char *optnamestr, void *optval, int *optlen)
Definition: libsrt.c:160
SRT_MODE_CALLER
@ SRT_MODE_CALLER
Definition: libsrt.c:47
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
SRTContext::fd
int fd
Definition: libsrt.c:54
URLProtocol
Definition: url.h:54
D
#define D
Definition: libsrt.c:96
os_support.h
OFFSET
#define OFFSET(x)
Definition: libsrt.c:98
AVIOInterruptCB
Callback for checking whether to abort blocking functions.
Definition: avio.h:58
SRTContext::smoother
char * smoother
Definition: libsrt.c:89
SRT_MODE_LISTENER
@ SRT_MODE_LISTENER
Definition: libsrt.c:48
SRTContext::streamid
char * streamid
Definition: libsrt.c:88
freeaddrinfo
#define freeaddrinfo
Definition: network.h:218
SRTContext::listen_timeout
int64_t listen_timeout
Definition: libsrt.c:57
SRTContext::eid
int eid
Definition: libsrt.c:55
fail
#define fail()
Definition: checkasm.h:127
SRTContext::ipttl
int ipttl
Definition: libsrt.c:72
SRTContext::recv_buffer_size
int recv_buffer_size
Definition: libsrt.c:58
libsrt_network_wait_fd
static int libsrt_network_wait_fd(URLContext *h, int eid, int write)
Definition: libsrt.c:192
ff_check_interrupt
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:658
SRTContext::oheadbw
int oheadbw
Definition: libsrt.c:75
libsrt_open
static int libsrt_open(URLContext *h, const char *uri, int flags)
Definition: libsrt.c:522
SRTContext::minversion
int minversion
Definition: libsrt.c:87
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ff_libsrt_protocol
const URLProtocol ff_libsrt_protocol
Definition: libsrt.c:729
s
#define s(width, name)
Definition: cbs_vp9.c:257
libsrt_epoll_create
static int libsrt_epoll_create(URLContext *h, int fd, int write)
Definition: libsrt.c:179
libsrt_setsockopt
static int libsrt_setsockopt(URLContext *h, int fd, SRT_SOCKOPT optname, const char *optnamestr, const void *optval, int optlen)
Definition: libsrt.c:289
SRTContext::maxbw
int64_t maxbw
Definition: libsrt.c:61
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Definition: opt.h:225
SRTContext::rcvlatency
int64_t rcvlatency
Definition: libsrt.c:81
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:604
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
libsrt_options
static const AVOption libsrt_options[]
Definition: libsrt.c:99
libsrt_listen
static int libsrt_listen(int eid, int fd, const struct sockaddr *addr, socklen_t addrlen, URLContext *h, int64_t timeout)
Definition: libsrt.c:236
libsrt_set_options_pre
static int libsrt_set_options_pre(URLContext *h, int fd)
Definition: libsrt.c:316
internal.h
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
libsrt_socket_nonblock
static int libsrt_socket_nonblock(int socket, int enable)
Definition: libsrt.c:169
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
SRTContext::lossmaxttl
int lossmaxttl
Definition: libsrt.c:86
SRTContext::transtype
SRT_TRANSTYPE transtype
Definition: libsrt.c:91
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
parseutils.h
libsrt_set_options_post
static int libsrt_set_options_post(URLContext *h, int fd)
Definition: libsrt.c:302
time.h
addrinfo::ai_family
int ai_family
Definition: network.h:139
SRTContext::payload_size
int payload_size
Definition: libsrt.c:80
SRTContext::inputbw
int64_t inputbw
Definition: libsrt.c:74
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
size
int size
Definition: twinvq_data.h:10344
SRTContext::linger
int linger
Definition: libsrt.c:92
E
#define E
Definition: libsrt.c:97
URLProtocol::name
const char * name
Definition: url.h:55
libsrt_write
static int libsrt_write(URLContext *h, const uint8_t *buf, int size)
Definition: libsrt.c:691
SRT_LIVE_MAX_PAYLOAD_SIZE
#define SRT_LIVE_MAX_PAYLOAD_SIZE
Definition: libsrt.c:43
gai_strerror
#define gai_strerror
Definition: network.h:225
getaddrinfo
#define getaddrinfo
Definition: network.h:217
SRT_MODE_RENDEZVOUS
@ SRT_MODE_RENDEZVOUS
Definition: libsrt.c:49
SRTContext::rw_timeout
int64_t rw_timeout
Definition: libsrt.c:56
URLContext
Definition: url.h:38
modes
static const SiprModeParam modes[MODE_COUNT]
Definition: sipr.c:69
else
else
Definition: snow.txt:125
av_url_split
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
Definition: utils.c:1001
url.h
SRTContext::send_buffer_size
int send_buffer_size
Definition: libsrt.c:59
len
int len
Definition: vorbis_enc_data.h:426
int_cb
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:513
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
addrinfo::ai_socktype
int ai_socktype
Definition: network.h:140
SRTContext::peerlatency
int64_t peerlatency
Definition: libsrt.c:82
SRTContext::passphrase
char * passphrase
Definition: libsrt.c:63
avformat.h
network.h
SRTContext::messageapi
int messageapi
Definition: libsrt.c:90
addrinfo::ai_flags
int ai_flags
Definition: network.h:138
mode
mode
Definition: ebur128.h:83
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
libsrt_class
static const AVClass libsrt_class
Definition: libsrt.c:722
SRTContext::connect_timeout
int64_t connect_timeout
Definition: libsrt.c:79
libsrt_read
static int libsrt_read(URLContext *h, uint8_t *buf, int size)
Definition: libsrt.c:672
libsrt_setup
static int libsrt_setup(URLContext *h, const char *uri, int flags)
Definition: libsrt.c:380
libsrt_listen_connect
static int libsrt_listen_connect(int eid, int fd, const struct sockaddr *addr, socklen_t addrlen, int64_t timeout, URLContext *h, int will_try_next)
Definition: libsrt.c:268
libsrt_close
static int libsrt_close(URLContext *h)
Definition: libsrt.c:710
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:279
SRTContext::iptos
int iptos
Definition: libsrt.c:73
SRTContext::rcvbuf
int rcvbuf
Definition: libsrt.c:85
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
SRTContext::latency
int64_t latency
Definition: libsrt.c:76
AVIO_FLAG_NONBLOCK
#define AVIO_FLAG_NONBLOCK
Use non-blocking mode.
Definition: avio.h:622
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
ready
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already ready
Definition: filter_design.txt:258
POLLING_TIME
#define POLLING_TIME
Definition: network.h:249
SRTContext::nakreport
int nakreport
Definition: libsrt.c:78
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
h
h
Definition: vp9dsp_template.c:2038
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
addrinfo
Definition: network.h:137
av_strndup
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
Definition: mem.c:291
libsrt_neterrno
static int libsrt_neterrno(URLContext *h)
Definition: libsrt.c:150
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
snprintf
#define snprintf
Definition: snprintf.h:34
SRTMode
SRTMode
Definition: libsrt.c:46
SRTContext::mss
int mss
Definition: libsrt.c:70
AI_PASSIVE
#define AI_PASSIVE
Definition: network.h:179
SRTContext::tlpktdrop
int tlpktdrop
Definition: libsrt.c:77
SRTContext::tsbpd
int tsbpd
Definition: libsrt.c:93