libavformat/rtpproto.c

   1 /*
   2  * RTP network protocol
   3  * Copyright (c) 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file libavformat/rtpproto.c
  24  * RTP protocol
  25  */
  26
  27 #include "libavutil/avstring.h"
  28 #include "avformat.h"
  29
  30 #include <unistd.h>
  31 #include <stdarg.h>
  32 #include "network.h"
  33 #include "os_support.h"
  34 #include <fcntl.h>
  35 #if HAVE_SYS_SELECT_H
  36 #include <sys/select.h>
  37 #endif
  38
  39 #define RTP_TX_BUF_SIZE  (64 * 1024)
  40 #define RTP_RX_BUF_SIZE  (128 * 1024)
  41
  42 typedef struct RTPContext {
  43     URLContext *rtp_hd, *rtcp_hd;
  44     int rtp_fd, rtcp_fd;
  45 } RTPContext;
  46
  47 /**
  48  * If no filename is given to av_open_input_file because you want to
  49  * get the local port first, then you must call this function to set
  50  * the remote server address.
  51  *
  52  * @param s1 media file context
  53  * @param uri of the remote server
  54  * @return zero if no error.
  55  */
  56
  57 int rtp_set_remote_url(URLContext *h, const char *uri)
  58 {
  59     RTPContext *s = h->priv_data;
  60     char hostname[256];
  61     int port;
  62
  63     char buf[1024];
  64     char path[1024];
  65
  66     url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port,
  67               path, sizeof(path), uri);
  68
  69     snprintf(buf, sizeof(buf), "udp://%s:%d%s", hostname, port, path);
  70     udp_set_remote_url(s->rtp_hd, buf);
  71
  72     snprintf(buf, sizeof(buf), "udp://%s:%d%s", hostname, port + 1, path);
  73     udp_set_remote_url(s->rtcp_hd, buf);
  74     return 0;
  75 }
  76
  77
  78 /**
  79  * add option to url of the form:
  80  * "http://host:port/path?option1=val1&option2=val2...
  81  */
  82
  83 static void url_add_option(char *buf, int buf_size, const char *fmt, ...)
  84 {
  85     char buf1[1024];
  86     va_list ap;
  87
  88     va_start(ap, fmt);
  89     if (strchr(buf, '?'))
  90         av_strlcat(buf, "&", buf_size);
  91     else
  92         av_strlcat(buf, "?", buf_size);
  93     vsnprintf(buf1, sizeof(buf1), fmt, ap);
  94     av_strlcat(buf, buf1, buf_size);
  95     va_end(ap);
  96 }
  97
  98 static void build_udp_url(char *buf, int buf_size,
  99                           const char *hostname, int port,
 100                           int local_port, int ttl,
 101                           int max_packet_size)
 102 {
 103     snprintf(buf, buf_size, "udp://%s:%d", hostname, port);
 104     if (local_port >= 0)
 105         url_add_option(buf, buf_size, "localport=%d", local_port);
 106     if (ttl >= 0)
 107         url_add_option(buf, buf_size, "ttl=%d", ttl);
 108     if (max_packet_size >=0)
 109         url_add_option(buf, buf_size, "pkt_size=%d", max_packet_size);
 110 }
 111
 112 /**
 113  * url syntax: rtp://host:port[?option=val...]
 114  * option: 'ttl=n'       : set the ttl value (for multicast only)
 115  *         'localport=n' : set the local port to n
 116  *         'pkt_size=n'  : set max packet size
 117  *
 118  */
 119
 120 static int rtp_open(URLContext *h, const char *uri, int flags)
 121 {
 122     RTPContext *s;
 123     int port, is_output, ttl, local_port, max_packet_size;
 124     char hostname[256];
 125     char buf[1024];
 126     char path[1024];
 127     const char *p;
 128
 129     is_output = (flags & URL_WRONLY);
 130
 131     s = av_mallocz(sizeof(RTPContext));
 132     if (!s)
 133         return AVERROR(ENOMEM);
 134     h->priv_data = s;
 135
 136     url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port,
 137               path, sizeof(path), uri);
 138     /* extract parameters */
 139     ttl = -1;
 140     local_port = -1;
 141     max_packet_size = -1;
 142
 143     p = strchr(uri, '?');
 144     if (p) {
 145         if (find_info_tag(buf, sizeof(buf), "ttl", p)) {
 146             ttl = strtol(buf, NULL, 10);
 147         }
 148         if (find_info_tag(buf, sizeof(buf), "localport", p)) {
 149             local_port = strtol(buf, NULL, 10);
 150         }
 151         if (find_info_tag(buf, sizeof(buf), "pkt_size", p)) {
 152             max_packet_size = strtol(buf, NULL, 10);
 153         }
 154     }
 155
 156     build_udp_url(buf, sizeof(buf),
 157                   hostname, port, local_port, ttl, max_packet_size);
 158     if (url_open(&s->rtp_hd, buf, flags) < 0)
 159         goto fail;
 160     local_port = udp_get_local_port(s->rtp_hd);
 161     /* XXX: need to open another connection if the port is not even */
 162
 163     /* well, should suppress localport in path */
 164
 165     build_udp_url(buf, sizeof(buf),
 166                   hostname, port + 1, local_port + 1, ttl, max_packet_size);
 167     if (url_open(&s->rtcp_hd, buf, flags) < 0)
 168         goto fail;
 169
 170     /* just to ease handle access. XXX: need to suppress direct handle
 171        access */
 172     s->rtp_fd = url_get_file_handle(s->rtp_hd);
 173     s->rtcp_fd = url_get_file_handle(s->rtcp_hd);
 174
 175     h->max_packet_size = url_get_max_packet_size(s->rtp_hd);
 176     h->is_streamed = 1;
 177     return 0;
 178
 179  fail:
 180     if (s->rtp_hd)
 181         url_close(s->rtp_hd);
 182     if (s->rtcp_hd)
 183         url_close(s->rtcp_hd);
 184     av_free(s);
 185     return AVERROR(EIO);
 186 }
 187
 188 static int rtp_read(URLContext *h, uint8_t *buf, int size)
 189 {
 190     RTPContext *s = h->priv_data;
 191     struct sockaddr_in from;
 192     socklen_t from_len;
 193     int len, fd_max, n;
 194     fd_set rfds;
 195 #if 0
 196     for(;;) {
 197         from_len = sizeof(from);
 198         len = recvfrom (s->rtp_fd, buf, size, 0,
 199                         (struct sockaddr *)&from, &from_len);
 200         if (len < 0) {
 201             if (ff_neterrno() == FF_NETERROR(EAGAIN) ||
 202                 ff_neterrno() == FF_NETERROR(EINTR))
 203                 continue;
 204             return AVERROR(EIO);
 205         }
 206         break;
 207     }
 208 #else
 209     for(;;) {
 210         /* build fdset to listen to RTP and RTCP packets */
 211         FD_ZERO(&rfds);
 212         fd_max = s->rtp_fd;
 213         FD_SET(s->rtp_fd, &rfds);
 214         if (s->rtcp_fd > fd_max)
 215             fd_max = s->rtcp_fd;
 216         FD_SET(s->rtcp_fd, &rfds);
 217         n = select(fd_max + 1, &rfds, NULL, NULL, NULL);
 218         if (n > 0) {
 219             /* first try RTCP */
 220             if (FD_ISSET(s->rtcp_fd, &rfds)) {
 221                 from_len = sizeof(from);
 222                 len = recvfrom (s->rtcp_fd, buf, size, 0,
 223                                 (struct sockaddr *)&from, &from_len);
 224                 if (len < 0) {
 225                     if (ff_neterrno() == FF_NETERROR(EAGAIN) ||
 226                         ff_neterrno() == FF_NETERROR(EINTR))
 227                         continue;
 228                     return AVERROR(EIO);
 229                 }
 230                 break;
 231             }
 232             /* then RTP */
 233             if (FD_ISSET(s->rtp_fd, &rfds)) {
 234                 from_len = sizeof(from);
 235                 len = recvfrom (s->rtp_fd, buf, size, 0,
 236                                 (struct sockaddr *)&from, &from_len);
 237                 if (len < 0) {
 238                     if (ff_neterrno() == FF_NETERROR(EAGAIN) ||
 239                         ff_neterrno() == FF_NETERROR(EINTR))
 240                         continue;
 241                     return AVERROR(EIO);
 242                 }
 243                 break;
 244             }
 245         }
 246     }
 247 #endif
 248     return len;
 249 }
 250
 251 static int rtp_write(URLContext *h, uint8_t *buf, int size)
 252 {
 253     RTPContext *s = h->priv_data;
 254     int ret;
 255     URLContext *hd;
 256
 257     if (buf[1] >= 200 && buf[1] <= 204) {
 258         /* RTCP payload type */
 259         hd = s->rtcp_hd;
 260     } else {
 261         /* RTP payload type */
 262         hd = s->rtp_hd;
 263     }
 264
 265     ret = url_write(hd, buf, size);
 266 #if 0
 267     {
 268         struct timespec ts;
 269         ts.tv_sec = 0;
 270         ts.tv_nsec = 10 * 1000000;
 271         nanosleep(&ts, NULL);
 272     }
 273 #endif
 274     return ret;
 275 }
 276
 277 static int rtp_close(URLContext *h)
 278 {
 279     RTPContext *s = h->priv_data;
 280
 281     url_close(s->rtp_hd);
 282     url_close(s->rtcp_hd);
 283     av_free(s);
 284     return 0;
 285 }
 286
 287 /**
 288  * Return the local port used by the RTP connection
 289  * @param s1 media file context
 290  * @return the local port number
 291  */
 292
 293 int rtp_get_local_port(URLContext *h)
 294 {
 295     RTPContext *s = h->priv_data;
 296     return udp_get_local_port(s->rtp_hd);
 297 }
 298
 299 #if (LIBAVFORMAT_VERSION_MAJOR <= 52)
 300 /**
 301  * Return the rtp and rtcp file handles for select() usage to wait for
 302  * several RTP streams at the same time.
 303  * @param h media file context
 304  */
 305
 306 void rtp_get_file_handles(URLContext *h, int *prtp_fd, int *prtcp_fd)
 307 {
 308     RTPContext *s = h->priv_data;
 309
 310     *prtp_fd = s->rtp_fd;
 311     *prtcp_fd = s->rtcp_fd;
 312 }
 313 #endif
 314
 315 static int rtp_get_file_handle(URLContext *h)
 316 {
 317     RTPContext *s = h->priv_data;
 318     return s->rtp_fd;
 319 }
 320
 321 URLProtocol rtp_protocol = {
 322     "rtp",
 323     rtp_open,
 324     rtp_read,
 325     rtp_write,
 326     NULL, /* seek */
 327     rtp_close,
 328     .url_get_file_handle = rtp_get_file_handle,
 329 };