cosmetics: Remove pointless period after copyright statement non-sentences.
[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 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 = udp_get_file_handle(s->rtp_hd);
173     s->rtcp_fd = udp_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 /**
300  * Return the rtp and rtcp file handles for select() usage to wait for
301  * several RTP streams at the same time.
302  * @param h media file context
303  */
304
305 void rtp_get_file_handles(URLContext *h, int *prtp_fd, int *prtcp_fd)
306 {
307     RTPContext *s = h->priv_data;
308
309     *prtp_fd = s->rtp_fd;
310     *prtcp_fd = s->rtcp_fd;
311 }
312
313 URLProtocol rtp_protocol = {
314     "rtp",
315     rtp_open,
316     rtp_read,
317     rtp_write,
318     NULL, /* seek */
319     rtp_close,
320 };