Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtpproto.c @ f35ff97f

History | View | Annotate | Download (10.1 KB)

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

    
22
/**
23
 * @file
24
 * RTP protocol
25
 */
26

    
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 <unistd.h>
35
#include <stdarg.h>
36
#include "internal.h"
37
#include "network.h"
38
#include "os_support.h"
39
#include <fcntl.h>
40
#if HAVE_POLL_H
41
#include <sys/poll.h>
42
#endif
43
#include <sys/time.h>
44

    
45
#define RTP_TX_BUF_SIZE  (64 * 1024)
46
#define RTP_RX_BUF_SIZE  (128 * 1024)
47

    
48
typedef struct RTPContext {
49
    URLContext *rtp_hd, *rtcp_hd;
50
    int rtp_fd, rtcp_fd;
51
} RTPContext;
52

    
53
/**
54
 * If no filename is given to av_open_input_file because you want to
55
 * get the local port first, then you must call this function to set
56
 * the remote server address.
57
 *
58
 * @param h media file context
59
 * @param uri of the remote server
60
 * @return zero if no error.
61
 */
62

    
63
int rtp_set_remote_url(URLContext *h, const char *uri)
64
{
65
    RTPContext *s = h->priv_data;
66
    char hostname[256];
67
    int port;
68

    
69
    char buf[1024];
70
    char path[1024];
71

    
72
    av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port,
73
                 path, sizeof(path), uri);
74

    
75
    ff_url_join(buf, sizeof(buf), "udp", NULL, hostname, port, "%s", path);
76
    ff_udp_set_remote_url(s->rtp_hd, buf);
77

    
78
    ff_url_join(buf, sizeof(buf), "udp", NULL, hostname, port + 1, "%s", path);
79
    ff_udp_set_remote_url(s->rtcp_hd, buf);
80
    return 0;
81
}
82

    
83

    
84
/**
85
 * add option to url of the form:
86
 * "http://host:port/path?option1=val1&option2=val2...
87
 */
88

    
89
static void url_add_option(char *buf, int buf_size, const char *fmt, ...)
90
{
91
    char buf1[1024];
92
    va_list ap;
93

    
94
    va_start(ap, fmt);
95
    if (strchr(buf, '?'))
96
        av_strlcat(buf, "&", buf_size);
97
    else
98
        av_strlcat(buf, "?", buf_size);
99
    vsnprintf(buf1, sizeof(buf1), fmt, ap);
100
    av_strlcat(buf, buf1, buf_size);
101
    va_end(ap);
102
}
103

    
104
static void build_udp_url(char *buf, int buf_size,
105
                          const char *hostname, int port,
106
                          int local_port, int ttl,
107
                          int max_packet_size, int connect)
108
{
109
    ff_url_join(buf, buf_size, "udp", NULL, hostname, port, NULL);
110
    if (local_port >= 0)
111
        url_add_option(buf, buf_size, "localport=%d", local_port);
112
    if (ttl >= 0)
113
        url_add_option(buf, buf_size, "ttl=%d", ttl);
114
    if (max_packet_size >=0)
115
        url_add_option(buf, buf_size, "pkt_size=%d", max_packet_size);
116
    if (connect)
117
        url_add_option(buf, buf_size, "connect=1");
118
}
119

    
120
/**
121
 * url syntax: rtp://host:port[?option=val...]
122
 * option: 'ttl=n'            : set the ttl value (for multicast only)
123
 *         'rtcpport=n'       : set the remote rtcp port to n
124
 *         'localrtpport=n'   : set the local rtp port to n
125
 *         'localrtcpport=n'  : set the local rtcp port to n
126
 *         'pkt_size=n'       : set max packet size
127
 *         'connect=0/1'      : do a connect() on the UDP socket
128
 * deprecated option:
129
 *         'localport=n'      : set the local port to n
130
 *
131
 * if rtcpport isn't set the rtcp port will be the rtp port + 1
132
 * if local rtp port isn't set any available port will be used for the local
133
 * rtp and rtcp ports
134
 * if the local rtcp port is not set it will be the local rtp port + 1
135
 */
136

    
137
static int rtp_open(URLContext *h, const char *uri, int flags)
138
{
139
    RTPContext *s;
140
    int rtp_port, rtcp_port,
141
        is_output, ttl, connect,
142
        local_rtp_port, local_rtcp_port, max_packet_size;
143
    char hostname[256];
144
    char buf[1024];
145
    char path[1024];
146
    const char *p;
147

    
148
    is_output = (flags & AVIO_WRONLY);
149

    
150
    s = av_mallocz(sizeof(RTPContext));
151
    if (!s)
152
        return AVERROR(ENOMEM);
153
    h->priv_data = s;
154

    
155
    av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &rtp_port,
156
                 path, sizeof(path), uri);
157
    /* extract parameters */
158
    ttl = -1;
159
    rtcp_port = rtp_port+1;
160
    local_rtp_port = -1;
161
    local_rtcp_port = -1;
162
    max_packet_size = -1;
163
    connect = 0;
164

    
165
    p = strchr(uri, '?');
166
    if (p) {
167
        if (av_find_info_tag(buf, sizeof(buf), "ttl", p)) {
168
            ttl = strtol(buf, NULL, 10);
169
        }
170
        if (av_find_info_tag(buf, sizeof(buf), "rtcpport", p)) {
171
            rtcp_port = strtol(buf, NULL, 10);
172
        }
173
        if (av_find_info_tag(buf, sizeof(buf), "localport", p)) {
174
            local_rtp_port = strtol(buf, NULL, 10);
175
        }
176
        if (av_find_info_tag(buf, sizeof(buf), "localrtpport", p)) {
177
            local_rtp_port = strtol(buf, NULL, 10);
178
        }
179
        if (av_find_info_tag(buf, sizeof(buf), "localrtcpport", p)) {
180
            local_rtcp_port = strtol(buf, NULL, 10);
181
        }
182
        if (av_find_info_tag(buf, sizeof(buf), "pkt_size", p)) {
183
            max_packet_size = strtol(buf, NULL, 10);
184
        }
185
        if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {
186
            connect = strtol(buf, NULL, 10);
187
        }
188
    }
189

    
190
    build_udp_url(buf, sizeof(buf),
191
                  hostname, rtp_port, local_rtp_port, ttl, max_packet_size,
192
                  connect);
193
    if (ffurl_open(&s->rtp_hd, buf, flags) < 0)
194
        goto fail;
195
    if (local_rtp_port>=0 && local_rtcp_port<0)
196
        local_rtcp_port = ff_udp_get_local_port(s->rtp_hd) + 1;
197

    
198
    build_udp_url(buf, sizeof(buf),
199
                  hostname, rtcp_port, local_rtcp_port, ttl, max_packet_size,
200
                  connect);
201
    if (ffurl_open(&s->rtcp_hd, buf, flags) < 0)
202
        goto fail;
203

    
204
    /* just to ease handle access. XXX: need to suppress direct handle
205
       access */
206
    s->rtp_fd = ffurl_get_file_handle(s->rtp_hd);
207
    s->rtcp_fd = ffurl_get_file_handle(s->rtcp_hd);
208

    
209
    h->max_packet_size = s->rtp_hd->max_packet_size;
210
    h->is_streamed = 1;
211
    return 0;
212

    
213
 fail:
214
    if (s->rtp_hd)
215
        ffurl_close(s->rtp_hd);
216
    if (s->rtcp_hd)
217
        ffurl_close(s->rtcp_hd);
218
    av_free(s);
219
    return AVERROR(EIO);
220
}
221

    
222
static int rtp_read(URLContext *h, uint8_t *buf, int size)
223
{
224
    RTPContext *s = h->priv_data;
225
    struct sockaddr_storage from;
226
    socklen_t from_len;
227
    int len, n;
228
    struct pollfd p[2] = {{s->rtp_fd, POLLIN, 0}, {s->rtcp_fd, POLLIN, 0}};
229

    
230
#if 0
231
    for(;;) {
232
        from_len = sizeof(from);
233
        len = recvfrom (s->rtp_fd, buf, size, 0,
234
                        (struct sockaddr *)&from, &from_len);
235
        if (len < 0) {
236
            if (ff_neterrno() == AVERROR(EAGAIN) ||
237
                ff_neterrno() == AVERROR(EINTR))
238
                continue;
239
            return AVERROR(EIO);
240
        }
241
        break;
242
    }
243
#else
244
    for(;;) {
245
        if (url_interrupt_cb())
246
            return AVERROR_EXIT;
247
        /* build fdset to listen to RTP and RTCP packets */
248
        n = poll(p, 2, 100);
249
        if (n > 0) {
250
            /* first try RTCP */
251
            if (p[1].revents & POLLIN) {
252
                from_len = sizeof(from);
253
                len = recvfrom (s->rtcp_fd, buf, size, 0,
254
                                (struct sockaddr *)&from, &from_len);
255
                if (len < 0) {
256
                    if (ff_neterrno() == AVERROR(EAGAIN) ||
257
                        ff_neterrno() == AVERROR(EINTR))
258
                        continue;
259
                    return AVERROR(EIO);
260
                }
261
                break;
262
            }
263
            /* then RTP */
264
            if (p[0].revents & POLLIN) {
265
                from_len = sizeof(from);
266
                len = recvfrom (s->rtp_fd, buf, size, 0,
267
                                (struct sockaddr *)&from, &from_len);
268
                if (len < 0) {
269
                    if (ff_neterrno() == AVERROR(EAGAIN) ||
270
                        ff_neterrno() == AVERROR(EINTR))
271
                        continue;
272
                    return AVERROR(EIO);
273
                }
274
                break;
275
            }
276
        } else if (n < 0) {
277
            if (ff_neterrno() == AVERROR(EINTR))
278
                continue;
279
            return AVERROR(EIO);
280
        }
281
    }
282
#endif
283
    return len;
284
}
285

    
286
static int rtp_write(URLContext *h, const uint8_t *buf, int size)
287
{
288
    RTPContext *s = h->priv_data;
289
    int ret;
290
    URLContext *hd;
291

    
292
    if (buf[1] >= RTCP_SR && buf[1] <= RTCP_APP) {
293
        /* RTCP payload type */
294
        hd = s->rtcp_hd;
295
    } else {
296
        /* RTP payload type */
297
        hd = s->rtp_hd;
298
    }
299

    
300
    ret = ffurl_write(hd, buf, size);
301
#if 0
302
    {
303
        struct timespec ts;
304
        ts.tv_sec = 0;
305
        ts.tv_nsec = 10 * 1000000;
306
        nanosleep(&ts, NULL);
307
    }
308
#endif
309
    return ret;
310
}
311

    
312
static int rtp_close(URLContext *h)
313
{
314
    RTPContext *s = h->priv_data;
315

    
316
    ffurl_close(s->rtp_hd);
317
    ffurl_close(s->rtcp_hd);
318
    av_free(s);
319
    return 0;
320
}
321

    
322
/**
323
 * Return the local rtp port used by the RTP connection
324
 * @param h media file context
325
 * @return the local port number
326
 */
327

    
328
int rtp_get_local_rtp_port(URLContext *h)
329
{
330
    RTPContext *s = h->priv_data;
331
    return ff_udp_get_local_port(s->rtp_hd);
332
}
333

    
334
/**
335
 * Return the local rtcp port used by the RTP connection
336
 * @param h media file context
337
 * @return the local port number
338
 */
339

    
340
int rtp_get_local_rtcp_port(URLContext *h)
341
{
342
    RTPContext *s = h->priv_data;
343
    return ff_udp_get_local_port(s->rtcp_hd);
344
}
345

    
346
static int rtp_get_file_handle(URLContext *h)
347
{
348
    RTPContext *s = h->priv_data;
349
    return s->rtp_fd;
350
}
351

    
352
int rtp_get_rtcp_file_handle(URLContext *h) {
353
    RTPContext *s = h->priv_data;
354
    return s->rtcp_fd;
355
}
356

    
357
URLProtocol ff_rtp_protocol = {
358
    .name                = "rtp",
359
    .url_open            = rtp_open,
360
    .url_read            = rtp_read,
361
    .url_write           = rtp_write,
362
    .url_close           = rtp_close,
363
    .url_get_file_handle = rtp_get_file_handle,
364
};