rtpproto.c
Go to the documentation of this file.
1 /*
2  * RTP network protocol
3  * Copyright (c) 2002 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
27 #include "libavutil/parseutils.h"
28 #include "libavutil/avstring.h"
29 #include "avformat.h"
30 #include "avio_internal.h"
31 #include "rtpdec.h"
32 #include "url.h"
33 
34 #include <stdarg.h>
35 #include "internal.h"
36 #include "network.h"
37 #include "os_support.h"
38 #include <fcntl.h>
39 #if HAVE_POLL_H
40 #include <sys/poll.h>
41 #endif
42 
43 typedef struct RTPContext {
46 } RTPContext;
47 
58 int ff_rtp_set_remote_url(URLContext *h, const char *uri)
59 {
60  RTPContext *s = h->priv_data;
61  char hostname[256];
62  int port;
63 
64  char buf[1024];
65  char path[1024];
66 
67  av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port,
68  path, sizeof(path), uri);
69 
70  ff_url_join(buf, sizeof(buf), "udp", NULL, hostname, port, "%s", path);
72 
73  ff_url_join(buf, sizeof(buf), "udp", NULL, hostname, port + 1, "%s", path);
75  return 0;
76 }
77 
78 
84 static av_printf_format(3, 4) void url_add_option(char *buf, int buf_size, const char *fmt, ...)
85 {
86  char buf1[1024];
87  va_list ap;
88 
89  va_start(ap, fmt);
90  if (strchr(buf, '?'))
91  av_strlcat(buf, "&", buf_size);
92  else
93  av_strlcat(buf, "?", buf_size);
94  vsnprintf(buf1, sizeof(buf1), fmt, ap);
95  av_strlcat(buf, buf1, buf_size);
96  va_end(ap);
97 }
98 
99 static void build_udp_url(char *buf, int buf_size,
100  const char *hostname, int port,
101  int local_port, int ttl,
102  int max_packet_size, int connect)
103 {
104  ff_url_join(buf, buf_size, "udp", NULL, hostname, port, NULL);
105  if (local_port >= 0)
106  url_add_option(buf, buf_size, "localport=%d", local_port);
107  if (ttl >= 0)
108  url_add_option(buf, buf_size, "ttl=%d", ttl);
109  if (max_packet_size >=0)
110  url_add_option(buf, buf_size, "pkt_size=%d", max_packet_size);
111  if (connect)
112  url_add_option(buf, buf_size, "connect=1");
113 }
114 
132 static int rtp_open(URLContext *h, const char *uri, int flags)
133 {
134  RTPContext *s = h->priv_data;
135  int rtp_port, rtcp_port,
136  ttl, connect,
137  local_rtp_port, local_rtcp_port, max_packet_size;
138  char hostname[256];
139  char buf[1024];
140  char path[1024];
141  const char *p;
142 
143  av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &rtp_port,
144  path, sizeof(path), uri);
145  /* extract parameters */
146  ttl = -1;
147  rtcp_port = rtp_port+1;
148  local_rtp_port = -1;
149  local_rtcp_port = -1;
150  max_packet_size = -1;
151  connect = 0;
152 
153  p = strchr(uri, '?');
154  if (p) {
155  if (av_find_info_tag(buf, sizeof(buf), "ttl", p)) {
156  ttl = strtol(buf, NULL, 10);
157  }
158  if (av_find_info_tag(buf, sizeof(buf), "rtcpport", p)) {
159  rtcp_port = strtol(buf, NULL, 10);
160  }
161  if (av_find_info_tag(buf, sizeof(buf), "localport", p)) {
162  local_rtp_port = strtol(buf, NULL, 10);
163  }
164  if (av_find_info_tag(buf, sizeof(buf), "localrtpport", p)) {
165  local_rtp_port = strtol(buf, NULL, 10);
166  }
167  if (av_find_info_tag(buf, sizeof(buf), "localrtcpport", p)) {
168  local_rtcp_port = strtol(buf, NULL, 10);
169  }
170  if (av_find_info_tag(buf, sizeof(buf), "pkt_size", p)) {
171  max_packet_size = strtol(buf, NULL, 10);
172  }
173  if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {
174  connect = strtol(buf, NULL, 10);
175  }
176  }
177 
178  build_udp_url(buf, sizeof(buf),
179  hostname, rtp_port, local_rtp_port, ttl, max_packet_size,
180  connect);
181  if (ffurl_open(&s->rtp_hd, buf, flags, &h->interrupt_callback, NULL) < 0)
182  goto fail;
183  if (local_rtp_port>=0 && local_rtcp_port<0)
184  local_rtcp_port = ff_udp_get_local_port(s->rtp_hd) + 1;
185 
186  build_udp_url(buf, sizeof(buf),
187  hostname, rtcp_port, local_rtcp_port, ttl, max_packet_size,
188  connect);
189  if (ffurl_open(&s->rtcp_hd, buf, flags, &h->interrupt_callback, NULL) < 0)
190  goto fail;
191 
192  /* just to ease handle access. XXX: need to suppress direct handle
193  access */
196 
198  h->is_streamed = 1;
199  return 0;
200 
201  fail:
202  if (s->rtp_hd)
203  ffurl_close(s->rtp_hd);
204  if (s->rtcp_hd)
205  ffurl_close(s->rtcp_hd);
206  return AVERROR(EIO);
207 }
208 
209 static int rtp_read(URLContext *h, uint8_t *buf, int size)
210 {
211  RTPContext *s = h->priv_data;
212  struct sockaddr_storage from;
213  socklen_t from_len;
214  int len, n;
215  struct pollfd p[2] = {{s->rtp_fd, POLLIN, 0}, {s->rtcp_fd, POLLIN, 0}};
216 
217  for(;;) {
219  return AVERROR_EXIT;
220  /* build fdset to listen to RTP and RTCP packets */
221  n = poll(p, 2, 100);
222  if (n > 0) {
223  /* first try RTCP */
224  if (p[1].revents & POLLIN) {
225  from_len = sizeof(from);
226  len = recvfrom (s->rtcp_fd, buf, size, 0,
227  (struct sockaddr *)&from, &from_len);
228  if (len < 0) {
229  if (ff_neterrno() == AVERROR(EAGAIN) ||
230  ff_neterrno() == AVERROR(EINTR))
231  continue;
232  return AVERROR(EIO);
233  }
234  break;
235  }
236  /* then RTP */
237  if (p[0].revents & POLLIN) {
238  from_len = sizeof(from);
239  len = recvfrom (s->rtp_fd, buf, size, 0,
240  (struct sockaddr *)&from, &from_len);
241  if (len < 0) {
242  if (ff_neterrno() == AVERROR(EAGAIN) ||
243  ff_neterrno() == AVERROR(EINTR))
244  continue;
245  return AVERROR(EIO);
246  }
247  break;
248  }
249  } else if (n < 0) {
250  if (ff_neterrno() == AVERROR(EINTR))
251  continue;
252  return AVERROR(EIO);
253  }
254  }
255  return len;
256 }
257 
258 static int rtp_write(URLContext *h, const uint8_t *buf, int size)
259 {
260  RTPContext *s = h->priv_data;
261  int ret;
262  URLContext *hd;
263 
264  if (RTP_PT_IS_RTCP(buf[1])) {
265  /* RTCP payload type */
266  hd = s->rtcp_hd;
267  } else {
268  /* RTP payload type */
269  hd = s->rtp_hd;
270  }
271 
272  ret = ffurl_write(hd, buf, size);
273  return ret;
274 }
275 
276 static int rtp_close(URLContext *h)
277 {
278  RTPContext *s = h->priv_data;
279 
280  ffurl_close(s->rtp_hd);
281  ffurl_close(s->rtcp_hd);
282  return 0;
283 }
284 
292 {
293  RTPContext *s = h->priv_data;
294  return ff_udp_get_local_port(s->rtp_hd);
295 }
296 
304 {
305  RTPContext *s = h->priv_data;
306  return ff_udp_get_local_port(s->rtcp_hd);
307 }
308 
310 {
311  RTPContext *s = h->priv_data;
312  return s->rtp_fd;
313 }
314 
315 static int rtp_get_multi_file_handle(URLContext *h, int **handles,
316  int *numhandles)
317 {
318  RTPContext *s = h->priv_data;
319  int *hs = *handles = av_malloc(sizeof(**handles) * 2);
320  if (!hs)
321  return AVERROR(ENOMEM);
322  hs[0] = s->rtp_fd;
323  hs[1] = s->rtcp_fd;
324  *numhandles = 2;
325  return 0;
326 }
327 
329  .name = "rtp",
330  .url_open = rtp_open,
331  .url_read = rtp_read,
332  .url_write = rtp_write,
333  .url_close = rtp_close,
334  .url_get_file_handle = rtp_get_file_handle,
335  .url_get_multi_file_handle = rtp_get_multi_file_handle,
336  .priv_data_size = sizeof(RTPContext),
338 };
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:3173
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:61
int ff_rtp_get_local_rtp_port(URLContext *h)
Return the local rtp port used by the RTP connection.
Definition: rtpproto.c:291
int size
#define URL_PROTOCOL_FLAG_NETWORK
Definition: url.h:35
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
Definition: avio.c:265
int is_streamed
true if streamed (no seek possible), default = false
Definition: url.h:48
AVIOInterruptCB interrupt_callback
Definition: url.h:50
static void build_udp_url(char *buf, int buf_size, const char *hostname, int port, int local_port, int ttl, int max_packet_size, int connect)
Definition: rtpproto.c:99
URLContext * rtcp_hd
Definition: rtpproto.c:44
int ff_url_join(char *str, int size, const char *proto, const char *authorization, const char *hostname, int port, const char *fmt,...) av_printf_format(7
Assemble a URL string from components.
static int rtp_write(URLContext *h, const uint8_t *buf, int size)
Definition: rtpproto.c:258
static int rtp_close(URLContext *h)
Definition: rtpproto.c:276
uint8_t
miscellaneous OS support macros and functions.
int ff_udp_get_local_port(URLContext *h)
Return the local port used by the UDP connection.
Definition: udp.c:364
static int flags
Definition: log.c:42
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:604
URLContext * rtp_hd
Definition: rtpproto.c:44
int ff_udp_set_remote_url(URLContext *h, const char *uri)
If no filename is given to av_open_input_file because you want to get the local port first...
Definition: udp.c:325
static int rtp_read(URLContext *h, uint8_t *buf, int size)
Definition: rtpproto.c:209
#define ff_neterrno()
Definition: network.h:62
static int rtp_open(URLContext *h, const char *uri, int flags)
url syntax: rtp://host:port[?option=val...] option: 'ttl=n' : set the ttl value (for multicast only) ...
Definition: rtpproto.c:132
int rtcp_fd
Definition: rtpproto.c:45
static int rtp_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
Definition: rtpproto.c:315
int rtp_fd
Definition: rtpproto.c:45
int ffurl_get_file_handle(URLContext *h)
Return the file descriptor associated with this URL.
Definition: avio.c:340
NULL
Definition: eval.c:52
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrup a blocking function associated with cb.
Definition: avio.c:369
static void(WINAPI *cond_broadcast)(pthread_cond_t *cond)
Definition: url.h:41
static av_printf_format(3, 4)
add option to url of the form: "http://host:port/path?option1=val1&option2=val2...
Definition: rtpproto.c:84
void * priv_data
Definition: url.h:44
misc parsing utilities
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes...
Definition: avstring.c:77
const char * name
Definition: url.h:54
#define RTP_PT_IS_RTCP(x)
Definition: rtp.h:109
int ffurl_close(URLContext *h)
Close the resource accessed by the URLContext h, and free the memory used by it.
Definition: avio.c:286
Main libavformat public API header.
static int rtp_get_file_handle(URLContext *h)
Definition: rtpproto.c:309
int ffurl_open(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create an URLContext for accessing to the resource indicated by url, and open it. ...
Definition: avio.c:203
int ff_rtp_get_local_rtcp_port(URLContext *h)
Return the local rtcp port used by the RTP connection.
Definition: rtpproto.c:303
int len
URLProtocol ff_rtp_protocol
Definition: rtpproto.c:328
int max_packet_size
if non zero, the stream is packetized with this max packet size
Definition: url.h:47
unbuffered private I/O API
int ff_rtp_set_remote_url(URLContext *h, const char *uri)
If no filename is given to av_open_input_file because you want to get the local port first...
Definition: rtpproto.c:58
struct RTPContext RTPContext