falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
91733 Commits
32 Branches
390MB
Tree: 1124df0397
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1124df0397'
${ noResults }
FFmpeg/libavformat/libsrt.c

572 lines
21KB
Raw Blame History 

  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. };