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