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