git.sesse.net Git - ffmpeg/blob - libavformat/libsrt.c

   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/avassert.h"
  27 #include "libavutil/opt.h"
  28 #include "libavutil/parseutils.h"
  29 #include "libavutil/time.h"
  30
  31 #include "avformat.h"
  32 #include "internal.h"
  33 #include "network.h"
  34 #include "os_support.h"
  35 #include "url.h"
  36
  37 enum SRTMode {
  38     SRT_MODE_CALLER = 0,
  39     SRT_MODE_LISTENER = 1,
  40     SRT_MODE_RENDEZVOUS = 2
  41 };
  42
  43 typedef struct SRTContext {
  44     const AVClass *class;
  45     int fd;
  46     int eid;
  47     int64_t rw_timeout;
  48     int64_t listen_timeout;
  49     int recv_buffer_size;
  50     int send_buffer_size;
  51
  52     int64_t maxbw;
  53     int pbkeylen;
  54     char *passphrase;
  55     int mss;
  56     int ffs;
  57     int ipttl;
  58     int iptos;
  59     int64_t inputbw;
  60     int oheadbw;
  61     int64_t tsbpddelay;
  62     int tlpktdrop;
  63     int nakreport;
  64     int64_t connect_timeout;
  65     enum SRTMode mode;
  66 } SRTContext;
  67
  68 #define D AV_OPT_FLAG_DECODING_PARAM
  69 #define E AV_OPT_FLAG_ENCODING_PARAM
  70 #define OFFSET(x) offsetof(SRTContext, x)
  71 static const AVOption libsrt_options[] = {
  72     { "rw_timeout",     "Timeout of socket I/O operations",                                     OFFSET(rw_timeout),       AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
  73     { "listen_timeout", "Connection awaiting timeout",                                          OFFSET(listen_timeout),   AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
  74     { "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 },
  75     { "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 },
  76     { "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 },
  77     { "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 },
  78     { "passphrase",     "Crypto PBKDF2 Passphrase size[0,10..64] 0:disable crypto",             OFFSET(passphrase),       AV_OPT_TYPE_STRING,   { .str = NULL },              .flags = D|E },
  79     { "mss",            "The Maximum Segment Size",                                             OFFSET(mss),              AV_OPT_TYPE_INT,      { .i64 = -1 }, -1, 1500,      .flags = D|E },
  80     { "ffs",            "Flight flag size (window size) (in bytes)",                            OFFSET(ffs),              AV_OPT_TYPE_INT,      { .i64 = -1 }, -1, INT_MAX,   .flags = D|E },
  81     { "ipttl",          "IP Time To Live",                                                      OFFSET(ipttl),            AV_OPT_TYPE_INT,      { .i64 = -1 }, -1, 255,       .flags = D|E },
  82     { "iptos",          "IP Type of Service",                                                   OFFSET(iptos),            AV_OPT_TYPE_INT,      { .i64 = -1 }, -1, 255,       .flags = D|E },
  83     { "inputbw",        "Estimated input stream rate",                                          OFFSET(inputbw),          AV_OPT_TYPE_INT64,    { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
  84     { "oheadbw",        "MaxBW ceiling based on % over input stream rate",                      OFFSET(oheadbw),          AV_OPT_TYPE_INT,      { .i64 = -1 }, -1, 100,       .flags = D|E },
  85     { "tsbpddelay",     "TsbPd receiver delay to absorb burst of missed packet retransmission", OFFSET(tsbpddelay),       AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
  86     { "tlpktdrop",      "Enable receiver pkt drop",                                             OFFSET(tlpktdrop),        AV_OPT_TYPE_INT,      { .i64 = -1 }, -1, 1,         .flags = D|E },
  87     { "nakreport",      "Enable receiver to send periodic NAK reports",                         OFFSET(nakreport),        AV_OPT_TYPE_INT,      { .i64 = -1 }, -1, 1,         .flags = D|E },
  88     { "connect_timeout", "Connect timeout. Caller default: 3000, rendezvous (x 10)",            OFFSET(connect_timeout),  AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
  89     { "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" },
  90     { "caller",         NULL, 0, AV_OPT_TYPE_CONST,  { .i64 = SRT_MODE_CALLER },     INT_MIN, INT_MAX, .flags = D|E, "mode" },
  91     { "listener",       NULL, 0, AV_OPT_TYPE_CONST,  { .i64 = SRT_MODE_LISTENER },   INT_MIN, INT_MAX, .flags = D|E, "mode" },
  92     { "rendezvous",     NULL, 0, AV_OPT_TYPE_CONST,  { .i64 = SRT_MODE_RENDEZVOUS }, INT_MIN, INT_MAX, .flags = D|E, "mode" },
  93     { NULL }
  94 };
  95
  96 static int libsrt_neterrno(URLContext *h)
  97 {
  98     int err = srt_getlasterror(NULL);
  99     av_log(h, AV_LOG_ERROR, "%s\n", srt_getlasterror_str());
 100     if (err == SRT_EASYNCRCV)
 101         return AVERROR(EAGAIN);
 102     return AVERROR_UNKNOWN;
 103 }
 104
 105 static int libsrt_socket_nonblock(int socket, int enable)
 106 {
 107     int ret = srt_setsockopt(socket, 0, SRTO_SNDSYN, &enable, sizeof(enable));
 108     if (ret < 0)
 109         return ret;
 110     return srt_setsockopt(socket, 0, SRTO_RCVSYN, &enable, sizeof(enable));
 111 }
 112
 113 static int libsrt_network_wait_fd(URLContext *h, int eid, int fd, int write)
 114 {
 115     int ret, len = 1;
 116     int modes = write ? SRT_EPOLL_OUT : SRT_EPOLL_IN;
 117     SRTSOCKET ready[1];
 118
 119     if (srt_epoll_add_usock(eid, fd, &modes) < 0)
 120         return libsrt_neterrno(h);
 121     if (write) {
 122         ret = srt_epoll_wait(eid, 0, 0, ready, &len, POLLING_TIME, 0, 0, 0, 0);
 123     } else {
 124         ret = srt_epoll_wait(eid, ready, &len, 0, 0, POLLING_TIME, 0, 0, 0, 0);
 125     }
 126     if (ret < 0) {
 127         if (srt_getlasterror(NULL) == SRT_ETIMEOUT)
 128             ret = AVERROR(EAGAIN);
 129         else
 130             ret = libsrt_neterrno(h);
 131     } else {
 132         ret = 0;
 133     }
 134     if (srt_epoll_remove_usock(eid, fd) < 0)
 135         return libsrt_neterrno(h);
 136     return ret;
 137 }
 138
 139 /* TODO de-duplicate code from ff_network_wait_fd_timeout() */
 140
 141 static int libsrt_network_wait_fd_timeout(URLContext *h, int eid, int fd, int write, int64_t timeout, AVIOInterruptCB *int_cb)
 142 {
 143     int ret;
 144     int64_t wait_start = 0;
 145
 146     while (1) {
 147         if (ff_check_interrupt(int_cb))
 148             return AVERROR_EXIT;
 149         ret = libsrt_network_wait_fd(h, eid, fd, write);
 150         if (ret != AVERROR(EAGAIN))
 151             return ret;
 152         if (timeout > 0) {
 153             if (!wait_start)
 154                 wait_start = av_gettime_relative();
 155             else if (av_gettime_relative() - wait_start > timeout)
 156                 return AVERROR(ETIMEDOUT);
 157         }
 158     }
 159 }
 160
 161 static int libsrt_listen(int eid, int fd, const struct sockaddr *addr, socklen_t addrlen, URLContext *h, int timeout)
 162 {
 163     int ret;
 164     int reuse = 1;
 165     if (srt_setsockopt(fd, SOL_SOCKET, SRTO_REUSEADDR, &reuse, sizeof(reuse))) {
 166         av_log(h, AV_LOG_WARNING, "setsockopt(SRTO_REUSEADDR) failed\n");
 167     }
 168     ret = srt_bind(fd, addr, addrlen);
 169     if (ret)
 170         return libsrt_neterrno(h);
 171
 172     ret = srt_listen(fd, 1);
 173     if (ret)
 174         return libsrt_neterrno(h);
 175
 176     while ((ret = libsrt_network_wait_fd_timeout(h, eid, fd, 1, timeout, &h->interrupt_callback))) {
 177         switch (ret) {
 178         case AVERROR(ETIMEDOUT):
 179             continue;
 180         default:
 181             return ret;
 182         }
 183     }
 184
 185     ret = srt_accept(fd, NULL, NULL);
 186     if (ret < 0)
 187         return libsrt_neterrno(h);
 188     if (libsrt_socket_nonblock(ret, 1) < 0)
 189         av_log(h, AV_LOG_DEBUG, "libsrt_socket_nonblock failed\n");
 190
 191     return ret;
 192 }
 193
 194 static int libsrt_listen_connect(int eid, int fd, const struct sockaddr *addr, socklen_t addrlen, int timeout, URLContext *h, int will_try_next)
 195 {
 196     int ret;
 197
 198     if (libsrt_socket_nonblock(fd, 1) < 0)
 199         av_log(h, AV_LOG_DEBUG, "ff_socket_nonblock failed\n");
 200
 201     while ((ret = srt_connect(fd, addr, addrlen))) {
 202         ret = libsrt_neterrno(h);
 203         switch (ret) {
 204         case AVERROR(EINTR):
 205             if (ff_check_interrupt(&h->interrupt_callback))
 206                 return AVERROR_EXIT;
 207             continue;
 208         case AVERROR(EINPROGRESS):
 209         case AVERROR(EAGAIN):
 210             ret = libsrt_network_wait_fd_timeout(h, eid, fd, 1, timeout, &h->interrupt_callback);
 211             if (ret < 0)
 212                 return ret;
 213             ret = srt_getlasterror(NULL);
 214             srt_clearlasterror();
 215             if (ret != 0) {
 216                 char buf[128];
 217                 ret = AVERROR(ret);
 218                 av_strerror(ret, buf, sizeof(buf));
 219                 if (will_try_next)
 220                     av_log(h, AV_LOG_WARNING,
 221                            "Connection to %s failed (%s), trying next address\n",
 222                            h->filename, buf);
 223                 else
 224                     av_log(h, AV_LOG_ERROR, "Connection to %s failed: %s\n",
 225                            h->filename, buf);
 226             }
 227         default:
 228             return ret;
 229         }
 230     }
 231     return ret;
 232 }
 233
 234 static int libsrt_setsockopt(URLContext *h, int fd, SRT_SOCKOPT optname, const char * optnamestr, const void * optval, int optlen)
 235 {
 236     if (srt_setsockopt(fd, 0, optname, optval, optlen) < 0) {
 237         av_log(h, AV_LOG_ERROR, "failed to set option %s on socket: %s\n", optnamestr, srt_getlasterror_str());
 238         return AVERROR(EIO);
 239     }
 240     return 0;
 241 }
 242
 243 /* - The "POST" options can be altered any time on a connected socket.
 244      They MAY have also some meaning when set prior to connecting; such
 245      option is SRTO_RCVSYN, which makes connect/accept call asynchronous.
 246      Because of that this option is treated special way in this app. */
 247 static int libsrt_set_options_post(URLContext *h, int fd)
 248 {
 249     SRTContext *s = h->priv_data;
 250
 251     if ((s->inputbw >= 0 && libsrt_setsockopt(h, fd, SRTO_INPUTBW, "SRTO_INPUTBW", &s->inputbw, sizeof(s->inputbw)) < 0) ||
 252         (s->oheadbw >= 0 && libsrt_setsockopt(h, fd, SRTO_OHEADBW, "SRTO_OHEADBW", &s->oheadbw, sizeof(s->oheadbw)) < 0)) {
 253         return AVERROR(EIO);
 254     }
 255     return 0;
 256 }
 257
 258 /* - The "PRE" options must be set prior to connecting and can't be altered
 259      on a connected socket, however if set on a listening socket, they are
 260      derived by accept-ed socket. */
 261 static int libsrt_set_options_pre(URLContext *h, int fd)
 262 {
 263     SRTContext *s = h->priv_data;
 264     int yes = 1;
 265     int tsbpddelay = s->tsbpddelay / 1000;
 266     int connect_timeout = s->connect_timeout;
 267
 268     if ((s->mode == SRT_MODE_RENDEZVOUS && libsrt_setsockopt(h, fd, SRTO_RENDEZVOUS, "SRTO_RENDEZVOUS", &yes, sizeof(yes)) < 0) ||
 269         (s->maxbw >= 0 && libsrt_setsockopt(h, fd, SRTO_MAXBW, "SRTO_MAXBW", &s->maxbw, sizeof(s->maxbw)) < 0) ||
 270         (s->pbkeylen >= 0 && libsrt_setsockopt(h, fd, SRTO_PBKEYLEN, "SRTO_PBKEYLEN", &s->pbkeylen, sizeof(s->pbkeylen)) < 0) ||
 271         (s->passphrase && libsrt_setsockopt(h, fd, SRTO_PASSPHRASE, "SRTO_PASSPHRASE", &s->passphrase, sizeof(s->passphrase)) < 0) ||
 272         (s->mss >= 0 && libsrt_setsockopt(h, fd, SRTO_MSS, "SRTO_MMS", &s->mss, sizeof(s->mss)) < 0) ||
 273         (s->ffs >= 0 && libsrt_setsockopt(h, fd, SRTO_FC, "SRTO_FC", &s->ffs, sizeof(s->ffs)) < 0) ||
 274         (s->ipttl >= 0 && libsrt_setsockopt(h, fd, SRTO_IPTTL, "SRTO_UPTTL", &s->ipttl, sizeof(s->ipttl)) < 0) ||
 275         (s->iptos >= 0 && libsrt_setsockopt(h, fd, SRTO_IPTOS, "SRTO_IPTOS", &s->iptos, sizeof(s->iptos)) < 0) ||
 276         (tsbpddelay >= 0 && libsrt_setsockopt(h, fd, SRTO_TSBPDDELAY, "SRTO_TSBPDELAY", &tsbpddelay, sizeof(tsbpddelay)) < 0) ||
 277         (s->tlpktdrop >= 0 && libsrt_setsockopt(h, fd, SRTO_TLPKTDROP, "SRTO_TLPKDROP", &s->tlpktdrop, sizeof(s->tlpktdrop)) < 0) ||
 278         (s->nakreport >= 0 && libsrt_setsockopt(h, fd, SRTO_NAKREPORT, "SRTO_NAKREPORT", &s->nakreport, sizeof(s->nakreport)) < 0) ||
 279         (connect_timeout >= 0 && libsrt_setsockopt(h, fd, SRTO_CONNTIMEO, "SRTO_CONNTIMEO", &connect_timeout, sizeof(connect_timeout)) <0 )) {
 280         return AVERROR(EIO);
 281     }
 282     return 0;
 283 }
 284
 285
 286 static int libsrt_setup(URLContext *h, const char *uri, int flags)
 287 {
 288     struct addrinfo hints = { 0 }, *ai, *cur_ai;
 289     int port, fd = -1;
 290     SRTContext *s = h->priv_data;
 291     const char *p;
 292     char buf[256];
 293     int ret;
 294     char hostname[1024],proto[1024],path[1024];
 295     char portstr[10];
 296     int open_timeout = 5000000;
 297     int eid;
 298
 299     eid = srt_epoll_create();
 300     if (eid < 0)
 301         return libsrt_neterrno(h);
 302     s->eid = eid;
 303
 304     av_url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname),
 305         &port, path, sizeof(path), uri);
 306     if (strcmp(proto, "srt"))
 307         return AVERROR(EINVAL);
 308     if (port <= 0 || port >= 65536) {
 309         av_log(h, AV_LOG_ERROR, "Port missing in uri\n");
 310         return AVERROR(EINVAL);
 311     }
 312     p = strchr(uri, '?');
 313     if (p) {
 314         if (av_find_info_tag(buf, sizeof(buf), "timeout", p)) {
 315             s->rw_timeout = strtol(buf, NULL, 10);
 316         }
 317         if (av_find_info_tag(buf, sizeof(buf), "listen_timeout", p)) {
 318             s->listen_timeout = strtol(buf, NULL, 10);
 319         }
 320     }
 321     if (s->rw_timeout >= 0) {
 322         open_timeout = h->rw_timeout = s->rw_timeout;
 323     }
 324     hints.ai_family = AF_UNSPEC;
 325     hints.ai_socktype = SOCK_DGRAM;
 326     snprintf(portstr, sizeof(portstr), "%d", port);
 327     if (s->mode == SRT_MODE_LISTENER)
 328         hints.ai_flags |= AI_PASSIVE;
 329     ret = getaddrinfo(hostname[0] ? hostname : NULL, portstr, &hints, &ai);
 330     if (ret) {
 331         av_log(h, AV_LOG_ERROR,
 332                "Failed to resolve hostname %s: %s\n",
 333                hostname, gai_strerror(ret));
 334         return AVERROR(EIO);
 335     }
 336
 337     cur_ai = ai;
 338
 339  restart:
 340
 341     fd = srt_socket(cur_ai->ai_family, cur_ai->ai_socktype, 0);
 342     if (fd < 0) {
 343         ret = libsrt_neterrno(h);
 344         goto fail;
 345     }
 346
 347     if ((ret = libsrt_set_options_pre(h, fd)) < 0) {
 348         goto fail;
 349     }
 350
 351     /* Set the socket's send or receive buffer sizes, if specified.
 352        If unspecified or setting fails, system default is used. */
 353     if (s->recv_buffer_size > 0) {
 354         srt_setsockopt(fd, SOL_SOCKET, SRTO_UDP_RCVBUF, &s->recv_buffer_size, sizeof (s->recv_buffer_size));
 355     }
 356     if (s->send_buffer_size > 0) {
 357         srt_setsockopt(fd, SOL_SOCKET, SRTO_UDP_SNDBUF, &s->send_buffer_size, sizeof (s->send_buffer_size));
 358     }
 359     if (s->mode == SRT_MODE_LISTENER) {
 360         // multi-client
 361         if ((ret = libsrt_listen(s->eid, fd, cur_ai->ai_addr, cur_ai->ai_addrlen, h, open_timeout / 1000)) < 0)
 362             goto fail1;
 363         fd = ret;
 364     } else {
 365         if (s->mode == SRT_MODE_RENDEZVOUS) {
 366             ret = srt_bind(fd, cur_ai->ai_addr, cur_ai->ai_addrlen);
 367             if (ret)
 368                 goto fail1;
 369         }
 370
 371         if ((ret = libsrt_listen_connect(s->eid, fd, cur_ai->ai_addr, cur_ai->ai_addrlen,
 372                                           open_timeout / 1000, h, !!cur_ai->ai_next)) < 0) {
 373             if (ret == AVERROR_EXIT)
 374                 goto fail1;
 375             else
 376                 goto fail;
 377         }
 378     }
 379     if ((ret = libsrt_set_options_post(h, fd)) < 0) {
 380         goto fail;
 381     }
 382
 383     h->is_streamed = 1;
 384     s->fd = fd;
 385
 386     freeaddrinfo(ai);
 387     return 0;
 388
 389  fail:
 390     if (cur_ai->ai_next) {
 391         /* Retry with the next sockaddr */
 392         cur_ai = cur_ai->ai_next;
 393         if (fd >= 0)
 394             srt_close(fd);
 395         ret = 0;
 396         goto restart;
 397     }
 398  fail1:
 399     if (fd >= 0)
 400         srt_close(fd);
 401     freeaddrinfo(ai);
 402     return ret;
 403 }
 404
 405 static int libsrt_open(URLContext *h, const char *uri, int flags)
 406 {
 407     SRTContext *s = h->priv_data;
 408     const char * p;
 409     char buf[256];
 410
 411     if (srt_startup() < 0) {
 412         return AVERROR_UNKNOWN;
 413     }
 414
 415     /* SRT options (srt/srt.h) */
 416     p = strchr(uri, '?');
 417     if (p) {
 418         if (av_find_info_tag(buf, sizeof(buf), "maxbw", p)) {
 419             s->maxbw = strtoll(buf, NULL, 0);
 420         }
 421         if (av_find_info_tag(buf, sizeof(buf), "pbkeylen", p)) {
 422             s->pbkeylen = strtol(buf, NULL, 10);
 423         }
 424         if (av_find_info_tag(buf, sizeof(buf), "passphrase", p)) {
 425             s->passphrase = av_strndup(buf, strlen(buf));
 426         }
 427         if (av_find_info_tag(buf, sizeof(buf), "mss", p)) {
 428             s->mss = strtol(buf, NULL, 10);
 429         }
 430         if (av_find_info_tag(buf, sizeof(buf), "ffs", p)) {
 431             s->ffs = strtol(buf, NULL, 10);
 432         }
 433         if (av_find_info_tag(buf, sizeof(buf), "ipttl", p)) {
 434             s->ipttl = strtol(buf, NULL, 10);
 435         }
 436         if (av_find_info_tag(buf, sizeof(buf), "iptos", p)) {
 437             s->iptos = strtol(buf, NULL, 10);
 438         }
 439         if (av_find_info_tag(buf, sizeof(buf), "inputbw", p)) {
 440             s->inputbw = strtoll(buf, NULL, 10);
 441         }
 442         if (av_find_info_tag(buf, sizeof(buf), "oheadbw", p)) {
 443             s->oheadbw = strtoll(buf, NULL, 10);
 444         }
 445         if (av_find_info_tag(buf, sizeof(buf), "tsbpddelay", p)) {
 446             s->tsbpddelay = strtol(buf, NULL, 10);
 447         }
 448         if (av_find_info_tag(buf, sizeof(buf), "tlpktdrop", p)) {
 449             s->tlpktdrop = strtol(buf, NULL, 10);
 450         }
 451         if (av_find_info_tag(buf, sizeof(buf), "nakreport", p)) {
 452             s->nakreport = strtol(buf, NULL, 10);
 453         }
 454         if (av_find_info_tag(buf, sizeof(buf), "connect_timeout", p)) {
 455             s->connect_timeout = strtol(buf, NULL, 10);
 456         }
 457         if (av_find_info_tag(buf, sizeof(buf), "mode", p)) {
 458             if (!strcmp(buf, "caller")) {
 459                 s->mode = SRT_MODE_CALLER;
 460             } else if (!strcmp(buf, "listener")) {
 461                 s->mode = SRT_MODE_LISTENER;
 462             } else if (!strcmp(buf, "rendezvous")) {
 463                 s->mode = SRT_MODE_RENDEZVOUS;
 464             } else {
 465                 return AVERROR(EIO);
 466             }
 467         }
 468     }
 469     return libsrt_setup(h, uri, flags);
 470 }
 471
 472 static int libsrt_read(URLContext *h, uint8_t *buf, int size)
 473 {
 474     SRTContext *s = h->priv_data;
 475     int ret;
 476
 477     if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
 478         ret = libsrt_network_wait_fd_timeout(h, s->eid, s->fd, 0, h->rw_timeout, &h->interrupt_callback);
 479         if (ret)
 480             return ret;
 481     }
 482
 483     ret = srt_recvmsg(s->fd, buf, size);
 484     if (ret < 0) {
 485         ret = libsrt_neterrno(h);
 486     }
 487
 488     return ret;
 489 }
 490
 491 static int libsrt_write(URLContext *h, const uint8_t *buf, int size)
 492 {
 493     SRTContext *s = h->priv_data;
 494     int ret;
 495
 496     if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
 497         ret = libsrt_network_wait_fd_timeout(h, s->eid, s->fd, 1, h->rw_timeout, &h->interrupt_callback);
 498         if (ret)
 499             return ret;
 500     }
 501
 502     ret = srt_sendmsg(s->fd, buf, size, -1, 0);
 503     if (ret < 0) {
 504         ret = libsrt_neterrno(h);
 505     }
 506
 507     return ret;
 508 }
 509
 510 static int libsrt_close(URLContext *h)
 511 {
 512     SRTContext *s = h->priv_data;
 513
 514     srt_close(s->fd);
 515
 516     srt_epoll_release(s->eid);
 517
 518     srt_cleanup();
 519
 520     return 0;
 521 }
 522
 523 static int libsrt_get_file_handle(URLContext *h)
 524 {
 525     SRTContext *s = h->priv_data;
 526     return s->fd;
 527 }
 528
 529 static const AVClass libsrt_class = {
 530     .class_name = "libsrt",
 531     .item_name  = av_default_item_name,
 532     .option     = libsrt_options,
 533     .version    = LIBAVUTIL_VERSION_INT,
 534 };
 535
 536 const URLProtocol ff_libsrt_protocol = {
 537     .name                = "srt",
 538     .url_open            = libsrt_open,
 539     .url_read            = libsrt_read,
 540     .url_write           = libsrt_write,
 541     .url_close           = libsrt_close,
 542     .url_get_file_handle = libsrt_get_file_handle,
 543     .priv_data_size      = sizeof(SRTContext),
 544     .flags               = URL_PROTOCOL_FLAG_NETWORK,
 545     .priv_data_class     = &libsrt_class,
 546 };