Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtsp.c @ 9fcae973

History | View | Annotate | Download (67.3 KB)

1
/*
2
 * RTSP/SDP client
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
#include "libavutil/base64.h"
23
#include "libavutil/avstring.h"
24
#include "libavutil/intreadwrite.h"
25
#include "libavutil/parseutils.h"
26
#include "libavutil/random_seed.h"
27
#include "avformat.h"
28

    
29
#include <sys/time.h>
30
#if HAVE_POLL_H
31
#include <poll.h>
32
#endif
33
#include <strings.h>
34
#include "internal.h"
35
#include "network.h"
36
#include "os_support.h"
37
#include "http.h"
38
#include "rtsp.h"
39

    
40
#include "rtpdec.h"
41
#include "rdt.h"
42
#include "rtpdec_formats.h"
43
#include "rtpenc_chain.h"
44

    
45
//#define DEBUG
46
//#define DEBUG_RTP_TCP
47

    
48
/* Timeout values for socket poll, in ms,
49
 * and read_packet(), in seconds  */
50
#define POLL_TIMEOUT_MS 100
51
#define READ_PACKET_TIMEOUT_S 10
52
#define MAX_TIMEOUTS READ_PACKET_TIMEOUT_S * 1000 / POLL_TIMEOUT_MS
53
#define SDP_MAX_SIZE 16384
54
#define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH
55

    
56
static void get_word_until_chars(char *buf, int buf_size,
57
                                 const char *sep, const char **pp)
58
{
59
    const char *p;
60
    char *q;
61

    
62
    p = *pp;
63
    p += strspn(p, SPACE_CHARS);
64
    q = buf;
65
    while (!strchr(sep, *p) && *p != '\0') {
66
        if ((q - buf) < buf_size - 1)
67
            *q++ = *p;
68
        p++;
69
    }
70
    if (buf_size > 0)
71
        *q = '\0';
72
    *pp = p;
73
}
74

    
75
static void get_word_sep(char *buf, int buf_size, const char *sep,
76
                         const char **pp)
77
{
78
    if (**pp == '/') (*pp)++;
79
    get_word_until_chars(buf, buf_size, sep, pp);
80
}
81

    
82
static void get_word(char *buf, int buf_size, const char **pp)
83
{
84
    get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);
85
}
86

    
87
/** Parse a string p in the form of Range:npt=xx-xx, and determine the start
88
 *  and end time.
89
 *  Used for seeking in the rtp stream.
90
 */
91
static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
92
{
93
    char buf[256];
94

    
95
    p += strspn(p, SPACE_CHARS);
96
    if (!av_stristart(p, "npt=", &p))
97
        return;
98

    
99
    *start = AV_NOPTS_VALUE;
100
    *end = AV_NOPTS_VALUE;
101

    
102
    get_word_sep(buf, sizeof(buf), "-", &p);
103
    av_parse_time(start, buf, 1);
104
    if (*p == '-') {
105
        p++;
106
        get_word_sep(buf, sizeof(buf), "-", &p);
107
        av_parse_time(end, buf, 1);
108
    }
109
//    av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
110
//    av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
111
}
112

    
113
static int get_sockaddr(const char *buf, struct sockaddr_storage *sock)
114
{
115
    struct addrinfo hints, *ai = NULL;
116
    memset(&hints, 0, sizeof(hints));
117
    hints.ai_flags = AI_NUMERICHOST;
118
    if (getaddrinfo(buf, NULL, &hints, &ai))
119
        return -1;
120
    memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen));
121
    freeaddrinfo(ai);
122
    return 0;
123
}
124

    
125
#if CONFIG_RTPDEC
126
static void init_rtp_handler(RTPDynamicProtocolHandler *handler,
127
                             RTSPStream *rtsp_st, AVCodecContext *codec)
128
{
129
    if (!handler)
130
        return;
131
    codec->codec_id          = handler->codec_id;
132
    rtsp_st->dynamic_handler = handler;
133
    if (handler->open)
134
        rtsp_st->dynamic_protocol_context = handler->open();
135
}
136

    
137
/* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
138
static int sdp_parse_rtpmap(AVFormatContext *s,
139
                            AVStream *st, RTSPStream *rtsp_st,
140
                            int payload_type, const char *p)
141
{
142
    AVCodecContext *codec = st->codec;
143
    char buf[256];
144
    int i;
145
    AVCodec *c;
146
    const char *c_name;
147

    
148
    /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and
149
     * see if we can handle this kind of payload.
150
     * The space should normally not be there but some Real streams or
151
     * particular servers ("RealServer Version 6.1.3.970", see issue 1658)
152
     * have a trailing space. */
153
    get_word_sep(buf, sizeof(buf), "/ ", &p);
154
    if (payload_type >= RTP_PT_PRIVATE) {
155
        RTPDynamicProtocolHandler *handler =
156
            ff_rtp_handler_find_by_name(buf, codec->codec_type);
157
        init_rtp_handler(handler, rtsp_st, codec);
158
        /* If no dynamic handler was found, check with the list of standard
159
         * allocated types, if such a stream for some reason happens to
160
         * use a private payload type. This isn't handled in rtpdec.c, since
161
         * the format name from the rtpmap line never is passed into rtpdec. */
162
        if (!rtsp_st->dynamic_handler)
163
            codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
164
    } else {
165
        /* We are in a standard case
166
         * (from http://www.iana.org/assignments/rtp-parameters). */
167
        /* search into AVRtpPayloadTypes[] */
168
        codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
169
    }
170

    
171
    c = avcodec_find_decoder(codec->codec_id);
172
    if (c && c->name)
173
        c_name = c->name;
174
    else
175
        c_name = "(null)";
176

    
177
    get_word_sep(buf, sizeof(buf), "/", &p);
178
    i = atoi(buf);
179
    switch (codec->codec_type) {
180
    case AVMEDIA_TYPE_AUDIO:
181
        av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name);
182
        codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;
183
        codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;
184
        if (i > 0) {
185
            codec->sample_rate = i;
186
            av_set_pts_info(st, 32, 1, codec->sample_rate);
187
            get_word_sep(buf, sizeof(buf), "/", &p);
188
            i = atoi(buf);
189
            if (i > 0)
190
                codec->channels = i;
191
            // TODO: there is a bug here; if it is a mono stream, and
192
            // less than 22000Hz, faad upconverts to stereo and twice
193
            // the frequency.  No problem, but the sample rate is being
194
            // set here by the sdp line. Patch on its way. (rdm)
195
        }
196
        av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n",
197
               codec->sample_rate);
198
        av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n",
199
               codec->channels);
200
        break;
201
    case AVMEDIA_TYPE_VIDEO:
202
        av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
203
        if (i > 0)
204
            av_set_pts_info(st, 32, 1, i);
205
        break;
206
    default:
207
        break;
208
    }
209
    return 0;
210
}
211

    
212
/* parse the attribute line from the fmtp a line of an sdp response. This
213
 * is broken out as a function because it is used in rtp_h264.c, which is
214
 * forthcoming. */
215
int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
216
                                char *value, int value_size)
217
{
218
    *p += strspn(*p, SPACE_CHARS);
219
    if (**p) {
220
        get_word_sep(attr, attr_size, "=", p);
221
        if (**p == '=')
222
            (*p)++;
223
        get_word_sep(value, value_size, ";", p);
224
        if (**p == ';')
225
            (*p)++;
226
        return 1;
227
    }
228
    return 0;
229
}
230

    
231
typedef struct SDPParseState {
232
    /* SDP only */
233
    struct sockaddr_storage default_ip;
234
    int            default_ttl;
235
    int            skip_media;  ///< set if an unknown m= line occurs
236
} SDPParseState;
237

    
238
static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
239
                           int letter, const char *buf)
240
{
241
    RTSPState *rt = s->priv_data;
242
    char buf1[64], st_type[64];
243
    const char *p;
244
    enum AVMediaType codec_type;
245
    int payload_type, i;
246
    AVStream *st;
247
    RTSPStream *rtsp_st;
248
    struct sockaddr_storage sdp_ip;
249
    int ttl;
250

    
251
    av_dlog(s, "sdp: %c='%s'\n", letter, buf);
252

    
253
    p = buf;
254
    if (s1->skip_media && letter != 'm')
255
        return;
256
    switch (letter) {
257
    case 'c':
258
        get_word(buf1, sizeof(buf1), &p);
259
        if (strcmp(buf1, "IN") != 0)
260
            return;
261
        get_word(buf1, sizeof(buf1), &p);
262
        if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6"))
263
            return;
264
        get_word_sep(buf1, sizeof(buf1), "/", &p);
265
        if (get_sockaddr(buf1, &sdp_ip))
266
            return;
267
        ttl = 16;
268
        if (*p == '/') {
269
            p++;
270
            get_word_sep(buf1, sizeof(buf1), "/", &p);
271
            ttl = atoi(buf1);
272
        }
273
        if (s->nb_streams == 0) {
274
            s1->default_ip = sdp_ip;
275
            s1->default_ttl = ttl;
276
        } else {
277
            rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
278
            rtsp_st->sdp_ip = sdp_ip;
279
            rtsp_st->sdp_ttl = ttl;
280
        }
281
        break;
282
    case 's':
283
        av_metadata_set2(&s->metadata, "title", p, 0);
284
        break;
285
    case 'i':
286
        if (s->nb_streams == 0) {
287
            av_metadata_set2(&s->metadata, "comment", p, 0);
288
            break;
289
        }
290
        break;
291
    case 'm':
292
        /* new stream */
293
        s1->skip_media = 0;
294
        get_word(st_type, sizeof(st_type), &p);
295
        if (!strcmp(st_type, "audio")) {
296
            codec_type = AVMEDIA_TYPE_AUDIO;
297
        } else if (!strcmp(st_type, "video")) {
298
            codec_type = AVMEDIA_TYPE_VIDEO;
299
        } else if (!strcmp(st_type, "application")) {
300
            codec_type = AVMEDIA_TYPE_DATA;
301
        } else {
302
            s1->skip_media = 1;
303
            return;
304
        }
305
        rtsp_st = av_mallocz(sizeof(RTSPStream));
306
        if (!rtsp_st)
307
            return;
308
        rtsp_st->stream_index = -1;
309
        dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
310

    
311
        rtsp_st->sdp_ip = s1->default_ip;
312
        rtsp_st->sdp_ttl = s1->default_ttl;
313

    
314
        get_word(buf1, sizeof(buf1), &p); /* port */
315
        rtsp_st->sdp_port = atoi(buf1);
316

    
317
        get_word(buf1, sizeof(buf1), &p); /* protocol (ignored) */
318

    
319
        /* XXX: handle list of formats */
320
        get_word(buf1, sizeof(buf1), &p); /* format list */
321
        rtsp_st->sdp_payload_type = atoi(buf1);
322

    
323
        if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
324
            /* no corresponding stream */
325
        } else {
326
            st = av_new_stream(s, rt->nb_rtsp_streams - 1);
327
            if (!st)
328
                return;
329
            rtsp_st->stream_index = st->index;
330
            st->codec->codec_type = codec_type;
331
            if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
332
                RTPDynamicProtocolHandler *handler;
333
                /* if standard payload type, we can find the codec right now */
334
                ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
335
                if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
336
                    st->codec->sample_rate > 0)
337
                    av_set_pts_info(st, 32, 1, st->codec->sample_rate);
338
                /* Even static payload types may need a custom depacketizer */
339
                handler = ff_rtp_handler_find_by_id(
340
                              rtsp_st->sdp_payload_type, st->codec->codec_type);
341
                init_rtp_handler(handler, rtsp_st, st->codec);
342
            }
343
        }
344
        /* put a default control url */
345
        av_strlcpy(rtsp_st->control_url, rt->control_uri,
346
                   sizeof(rtsp_st->control_url));
347
        break;
348
    case 'a':
349
        if (av_strstart(p, "control:", &p)) {
350
            if (s->nb_streams == 0) {
351
                if (!strncmp(p, "rtsp://", 7))
352
                    av_strlcpy(rt->control_uri, p,
353
                               sizeof(rt->control_uri));
354
            } else {
355
                char proto[32];
356
                /* get the control url */
357
                rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
358

    
359
                /* XXX: may need to add full url resolution */
360
                av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
361
                             NULL, NULL, 0, p);
362
                if (proto[0] == '\0') {
363
                    /* relative control URL */
364
                    if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
365
                    av_strlcat(rtsp_st->control_url, "/",
366
                               sizeof(rtsp_st->control_url));
367
                    av_strlcat(rtsp_st->control_url, p,
368
                               sizeof(rtsp_st->control_url));
369
                } else
370
                    av_strlcpy(rtsp_st->control_url, p,
371
                               sizeof(rtsp_st->control_url));
372
            }
373
        } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
374
            /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
375
            get_word(buf1, sizeof(buf1), &p);
376
            payload_type = atoi(buf1);
377
            st = s->streams[s->nb_streams - 1];
378
            rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
379
            sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p);
380
        } else if (av_strstart(p, "fmtp:", &p) ||
381
                   av_strstart(p, "framesize:", &p)) {
382
            /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
383
            // let dynamic protocol handlers have a stab at the line.
384
            get_word(buf1, sizeof(buf1), &p);
385
            payload_type = atoi(buf1);
386
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
387
                rtsp_st = rt->rtsp_streams[i];
388
                if (rtsp_st->sdp_payload_type == payload_type &&
389
                    rtsp_st->dynamic_handler &&
390
                    rtsp_st->dynamic_handler->parse_sdp_a_line)
391
                    rtsp_st->dynamic_handler->parse_sdp_a_line(s, i,
392
                        rtsp_st->dynamic_protocol_context, buf);
393
            }
394
        } else if (av_strstart(p, "range:", &p)) {
395
            int64_t start, end;
396

    
397
            // this is so that seeking on a streamed file can work.
398
            rtsp_parse_range_npt(p, &start, &end);
399
            s->start_time = start;
400
            /* AV_NOPTS_VALUE means live broadcast (and can't seek) */
401
            s->duration   = (end == AV_NOPTS_VALUE) ?
402
                            AV_NOPTS_VALUE : end - start;
403
        } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
404
            if (atoi(p) == 1)
405
                rt->transport = RTSP_TRANSPORT_RDT;
406
        } else if (av_strstart(p, "SampleRate:integer;", &p) &&
407
                   s->nb_streams > 0) {
408
            st = s->streams[s->nb_streams - 1];
409
            st->codec->sample_rate = atoi(p);
410
        } else {
411
            if (rt->server_type == RTSP_SERVER_WMS)
412
                ff_wms_parse_sdp_a_line(s, p);
413
            if (s->nb_streams > 0) {
414
                if (rt->server_type == RTSP_SERVER_REAL)
415
                    ff_real_parse_sdp_a_line(s, s->nb_streams - 1, p);
416

    
417
                rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
418
                if (rtsp_st->dynamic_handler &&
419
                    rtsp_st->dynamic_handler->parse_sdp_a_line)
420
                    rtsp_st->dynamic_handler->parse_sdp_a_line(s,
421
                        s->nb_streams - 1,
422
                        rtsp_st->dynamic_protocol_context, buf);
423
            }
424
        }
425
        break;
426
    }
427
}
428

    
429
/**
430
 * Parse the sdp description and allocate the rtp streams and the
431
 * pollfd array used for udp ones.
432
 */
433

    
434
int ff_sdp_parse(AVFormatContext *s, const char *content)
435
{
436
    RTSPState *rt = s->priv_data;
437
    const char *p;
438
    int letter;
439
    /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
440
     * contain long SDP lines containing complete ASF Headers (several
441
     * kB) or arrays of MDPR (RM stream descriptor) headers plus
442
     * "rulebooks" describing their properties. Therefore, the SDP line
443
     * buffer is large.
444
     *
445
     * The Vorbis FMTP line can be up to 16KB - see xiph_parse_sdp_line
446
     * in rtpdec_xiph.c. */
447
    char buf[16384], *q;
448
    SDPParseState sdp_parse_state, *s1 = &sdp_parse_state;
449

    
450
    memset(s1, 0, sizeof(SDPParseState));
451
    p = content;
452
    for (;;) {
453
        p += strspn(p, SPACE_CHARS);
454
        letter = *p;
455
        if (letter == '\0')
456
            break;
457
        p++;
458
        if (*p != '=')
459
            goto next_line;
460
        p++;
461
        /* get the content */
462
        q = buf;
463
        while (*p != '\n' && *p != '\r' && *p != '\0') {
464
            if ((q - buf) < sizeof(buf) - 1)
465
                *q++ = *p;
466
            p++;
467
        }
468
        *q = '\0';
469
        sdp_parse_line(s, s1, letter, buf);
470
    next_line:
471
        while (*p != '\n' && *p != '\0')
472
            p++;
473
        if (*p == '\n')
474
            p++;
475
    }
476
    rt->p = av_malloc(sizeof(struct pollfd)*2*(rt->nb_rtsp_streams+1));
477
    if (!rt->p) return AVERROR(ENOMEM);
478
    return 0;
479
}
480
#endif /* CONFIG_RTPDEC */
481

    
482
void ff_rtsp_undo_setup(AVFormatContext *s)
483
{
484
    RTSPState *rt = s->priv_data;
485
    int i;
486

    
487
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
488
        RTSPStream *rtsp_st = rt->rtsp_streams[i];
489
        if (!rtsp_st)
490
            continue;
491
        if (rtsp_st->transport_priv) {
492
            if (s->oformat) {
493
                AVFormatContext *rtpctx = rtsp_st->transport_priv;
494
                av_write_trailer(rtpctx);
495
                if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
496
                    uint8_t *ptr;
497
                    url_close_dyn_buf(rtpctx->pb, &ptr);
498
                    av_free(ptr);
499
                } else {
500
                    url_fclose(rtpctx->pb);
501
                }
502
                avformat_free_context(rtpctx);
503
            } else if (rt->transport == RTSP_TRANSPORT_RDT && CONFIG_RTPDEC)
504
                ff_rdt_parse_close(rtsp_st->transport_priv);
505
            else if (CONFIG_RTPDEC)
506
                rtp_parse_close(rtsp_st->transport_priv);
507
        }
508
        rtsp_st->transport_priv = NULL;
509
        if (rtsp_st->rtp_handle)
510
            url_close(rtsp_st->rtp_handle);
511
        rtsp_st->rtp_handle = NULL;
512
    }
513
}
514

    
515
/* close and free RTSP streams */
516
void ff_rtsp_close_streams(AVFormatContext *s)
517
{
518
    RTSPState *rt = s->priv_data;
519
    int i;
520
    RTSPStream *rtsp_st;
521

    
522
    ff_rtsp_undo_setup(s);
523
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
524
        rtsp_st = rt->rtsp_streams[i];
525
        if (rtsp_st) {
526
            if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
527
                rtsp_st->dynamic_handler->close(
528
                    rtsp_st->dynamic_protocol_context);
529
            av_free(rtsp_st);
530
        }
531
    }
532
    av_free(rt->rtsp_streams);
533
    if (rt->asf_ctx) {
534
        av_close_input_stream (rt->asf_ctx);
535
        rt->asf_ctx = NULL;
536
    }
537
    av_free(rt->p);
538
    av_free(rt->recvbuf);
539
}
540

    
541
static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
542
{
543
    RTSPState *rt = s->priv_data;
544
    AVStream *st = NULL;
545

    
546
    /* open the RTP context */
547
    if (rtsp_st->stream_index >= 0)
548
        st = s->streams[rtsp_st->stream_index];
549
    if (!st)
550
        s->ctx_flags |= AVFMTCTX_NOHEADER;
551

    
552
    if (s->oformat && CONFIG_RTSP_MUXER) {
553
        rtsp_st->transport_priv = ff_rtp_chain_mux_open(s, st,
554
                                      rtsp_st->rtp_handle,
555
                                      RTSP_TCP_MAX_PACKET_SIZE);
556
        /* Ownership of rtp_handle is passed to the rtp mux context */
557
        rtsp_st->rtp_handle = NULL;
558
    } else if (rt->transport == RTSP_TRANSPORT_RDT && CONFIG_RTPDEC)
559
        rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
560
                                            rtsp_st->dynamic_protocol_context,
561
                                            rtsp_st->dynamic_handler);
562
    else if (CONFIG_RTPDEC)
563
        rtsp_st->transport_priv = rtp_parse_open(s, st, rtsp_st->rtp_handle,
564
                                         rtsp_st->sdp_payload_type,
565
            (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay)
566
            ? 0 : RTP_REORDER_QUEUE_DEFAULT_SIZE);
567

    
568
    if (!rtsp_st->transport_priv) {
569
         return AVERROR(ENOMEM);
570
    } else if (rt->transport != RTSP_TRANSPORT_RDT && CONFIG_RTPDEC) {
571
        if (rtsp_st->dynamic_handler) {
572
            rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
573
                                           rtsp_st->dynamic_protocol_context,
574
                                           rtsp_st->dynamic_handler);
575
        }
576
    }
577

    
578
    return 0;
579
}
580

    
581
#if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
582
static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
583
{
584
    const char *p;
585
    int v;
586

    
587
    p = *pp;
588
    p += strspn(p, SPACE_CHARS);
589
    v = strtol(p, (char **)&p, 10);
590
    if (*p == '-') {
591
        p++;
592
        *min_ptr = v;
593
        v = strtol(p, (char **)&p, 10);
594
        *max_ptr = v;
595
    } else {
596
        *min_ptr = v;
597
        *max_ptr = v;
598
    }
599
    *pp = p;
600
}
601

    
602
/* XXX: only one transport specification is parsed */
603
static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
604
{
605
    char transport_protocol[16];
606
    char profile[16];
607
    char lower_transport[16];
608
    char parameter[16];
609
    RTSPTransportField *th;
610
    char buf[256];
611

    
612
    reply->nb_transports = 0;
613

    
614
    for (;;) {
615
        p += strspn(p, SPACE_CHARS);
616
        if (*p == '\0')
617
            break;
618

    
619
        th = &reply->transports[reply->nb_transports];
620

    
621
        get_word_sep(transport_protocol, sizeof(transport_protocol),
622
                     "/", &p);
623
        if (!strcasecmp (transport_protocol, "rtp")) {
624
            get_word_sep(profile, sizeof(profile), "/;,", &p);
625
            lower_transport[0] = '\0';
626
            /* rtp/avp/<protocol> */
627
            if (*p == '/') {
628
                get_word_sep(lower_transport, sizeof(lower_transport),
629
                             ";,", &p);
630
            }
631
            th->transport = RTSP_TRANSPORT_RTP;
632
        } else if (!strcasecmp (transport_protocol, "x-pn-tng") ||
633
                   !strcasecmp (transport_protocol, "x-real-rdt")) {
634
            /* x-pn-tng/<protocol> */
635
            get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
636
            profile[0] = '\0';
637
            th->transport = RTSP_TRANSPORT_RDT;
638
        }
639
        if (!strcasecmp(lower_transport, "TCP"))
640
            th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
641
        else
642
            th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
643

    
644
        if (*p == ';')
645
            p++;
646
        /* get each parameter */
647
        while (*p != '\0' && *p != ',') {
648
            get_word_sep(parameter, sizeof(parameter), "=;,", &p);
649
            if (!strcmp(parameter, "port")) {
650
                if (*p == '=') {
651
                    p++;
652
                    rtsp_parse_range(&th->port_min, &th->port_max, &p);
653
                }
654
            } else if (!strcmp(parameter, "client_port")) {
655
                if (*p == '=') {
656
                    p++;
657
                    rtsp_parse_range(&th->client_port_min,
658
                                     &th->client_port_max, &p);
659
                }
660
            } else if (!strcmp(parameter, "server_port")) {
661
                if (*p == '=') {
662
                    p++;
663
                    rtsp_parse_range(&th->server_port_min,
664
                                     &th->server_port_max, &p);
665
                }
666
            } else if (!strcmp(parameter, "interleaved")) {
667
                if (*p == '=') {
668
                    p++;
669
                    rtsp_parse_range(&th->interleaved_min,
670
                                     &th->interleaved_max, &p);
671
                }
672
            } else if (!strcmp(parameter, "multicast")) {
673
                if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
674
                    th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
675
            } else if (!strcmp(parameter, "ttl")) {
676
                if (*p == '=') {
677
                    p++;
678
                    th->ttl = strtol(p, (char **)&p, 10);
679
                }
680
            } else if (!strcmp(parameter, "destination")) {
681
                if (*p == '=') {
682
                    p++;
683
                    get_word_sep(buf, sizeof(buf), ";,", &p);
684
                    get_sockaddr(buf, &th->destination);
685
                }
686
            } else if (!strcmp(parameter, "source")) {
687
                if (*p == '=') {
688
                    p++;
689
                    get_word_sep(buf, sizeof(buf), ";,", &p);
690
                    av_strlcpy(th->source, buf, sizeof(th->source));
691
                }
692
            }
693

    
694
            while (*p != ';' && *p != '\0' && *p != ',')
695
                p++;
696
            if (*p == ';')
697
                p++;
698
        }
699
        if (*p == ',')
700
            p++;
701

    
702
        reply->nb_transports++;
703
    }
704
}
705

    
706
static void handle_rtp_info(RTSPState *rt, const char *url,
707
                            uint32_t seq, uint32_t rtptime)
708
{
709
    int i;
710
    if (!rtptime || !url[0])
711
        return;
712
    if (rt->transport != RTSP_TRANSPORT_RTP)
713
        return;
714
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
715
        RTSPStream *rtsp_st = rt->rtsp_streams[i];
716
        RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
717
        if (!rtpctx)
718
            continue;
719
        if (!strcmp(rtsp_st->control_url, url)) {
720
            rtpctx->base_timestamp = rtptime;
721
            break;
722
        }
723
    }
724
}
725

    
726
static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)
727
{
728
    int read = 0;
729
    char key[20], value[1024], url[1024] = "";
730
    uint32_t seq = 0, rtptime = 0;
731

    
732
    for (;;) {
733
        p += strspn(p, SPACE_CHARS);
734
        if (!*p)
735
            break;
736
        get_word_sep(key, sizeof(key), "=", &p);
737
        if (*p != '=')
738
            break;
739
        p++;
740
        get_word_sep(value, sizeof(value), ";, ", &p);
741
        read++;
742
        if (!strcmp(key, "url"))
743
            av_strlcpy(url, value, sizeof(url));
744
        else if (!strcmp(key, "seq"))
745
            seq = strtol(value, NULL, 10);
746
        else if (!strcmp(key, "rtptime"))
747
            rtptime = strtol(value, NULL, 10);
748
        if (*p == ',') {
749
            handle_rtp_info(rt, url, seq, rtptime);
750
            url[0] = '\0';
751
            seq = rtptime = 0;
752
            read = 0;
753
        }
754
        if (*p)
755
            p++;
756
    }
757
    if (read > 0)
758
        handle_rtp_info(rt, url, seq, rtptime);
759
}
760

    
761
void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf,
762
                        RTSPState *rt, const char *method)
763
{
764
    const char *p;
765

    
766
    /* NOTE: we do case independent match for broken servers */
767
    p = buf;
768
    if (av_stristart(p, "Session:", &p)) {
769
        int t;
770
        get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
771
        if (av_stristart(p, ";timeout=", &p) &&
772
            (t = strtol(p, NULL, 10)) > 0) {
773
            reply->timeout = t;
774
        }
775
    } else if (av_stristart(p, "Content-Length:", &p)) {
776
        reply->content_length = strtol(p, NULL, 10);
777
    } else if (av_stristart(p, "Transport:", &p)) {
778
        rtsp_parse_transport(reply, p);
779
    } else if (av_stristart(p, "CSeq:", &p)) {
780
        reply->seq = strtol(p, NULL, 10);
781
    } else if (av_stristart(p, "Range:", &p)) {
782
        rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
783
    } else if (av_stristart(p, "RealChallenge1:", &p)) {
784
        p += strspn(p, SPACE_CHARS);
785
        av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
786
    } else if (av_stristart(p, "Server:", &p)) {
787
        p += strspn(p, SPACE_CHARS);
788
        av_strlcpy(reply->server, p, sizeof(reply->server));
789
    } else if (av_stristart(p, "Notice:", &p) ||
790
               av_stristart(p, "X-Notice:", &p)) {
791
        reply->notice = strtol(p, NULL, 10);
792
    } else if (av_stristart(p, "Location:", &p)) {
793
        p += strspn(p, SPACE_CHARS);
794
        av_strlcpy(reply->location, p , sizeof(reply->location));
795
    } else if (av_stristart(p, "WWW-Authenticate:", &p) && rt) {
796
        p += strspn(p, SPACE_CHARS);
797
        ff_http_auth_handle_header(&rt->auth_state, "WWW-Authenticate", p);
798
    } else if (av_stristart(p, "Authentication-Info:", &p) && rt) {
799
        p += strspn(p, SPACE_CHARS);
800
        ff_http_auth_handle_header(&rt->auth_state, "Authentication-Info", p);
801
    } else if (av_stristart(p, "Content-Base:", &p) && rt) {
802
        p += strspn(p, SPACE_CHARS);
803
        if (method && !strcmp(method, "DESCRIBE"))
804
            av_strlcpy(rt->control_uri, p , sizeof(rt->control_uri));
805
    } else if (av_stristart(p, "RTP-Info:", &p) && rt) {
806
        p += strspn(p, SPACE_CHARS);
807
        if (method && !strcmp(method, "PLAY"))
808
            rtsp_parse_rtp_info(rt, p);
809
    }
810
}
811

    
812
/* skip a RTP/TCP interleaved packet */
813
void ff_rtsp_skip_packet(AVFormatContext *s)
814
{
815
    RTSPState *rt = s->priv_data;
816
    int ret, len, len1;
817
    uint8_t buf[1024];
818

    
819
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
820
    if (ret != 3)
821
        return;
822
    len = AV_RB16(buf + 1);
823

    
824
    av_dlog(s, "skipping RTP packet len=%d\n", len);
825

    
826
    /* skip payload */
827
    while (len > 0) {
828
        len1 = len;
829
        if (len1 > sizeof(buf))
830
            len1 = sizeof(buf);
831
        ret = url_read_complete(rt->rtsp_hd, buf, len1);
832
        if (ret != len1)
833
            return;
834
        len -= len1;
835
    }
836
}
837

    
838
int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
839
                       unsigned char **content_ptr,
840
                       int return_on_interleaved_data, const char *method)
841
{
842
    RTSPState *rt = s->priv_data;
843
    char buf[4096], buf1[1024], *q;
844
    unsigned char ch;
845
    const char *p;
846
    int ret, content_length, line_count = 0;
847
    unsigned char *content = NULL;
848

    
849
    memset(reply, 0, sizeof(*reply));
850

    
851
    /* parse reply (XXX: use buffers) */
852
    rt->last_reply[0] = '\0';
853
    for (;;) {
854
        q = buf;
855
        for (;;) {
856
            ret = url_read_complete(rt->rtsp_hd, &ch, 1);
857
#ifdef DEBUG_RTP_TCP
858
            av_dlog(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
859
#endif
860
            if (ret != 1)
861
                return AVERROR_EOF;
862
            if (ch == '\n')
863
                break;
864
            if (ch == '$') {
865
                /* XXX: only parse it if first char on line ? */
866
                if (return_on_interleaved_data) {
867
                    return 1;
868
                } else
869
                    ff_rtsp_skip_packet(s);
870
            } else if (ch != '\r') {
871
                if ((q - buf) < sizeof(buf) - 1)
872
                    *q++ = ch;
873
            }
874
        }
875
        *q = '\0';
876

    
877
        av_dlog(s, "line='%s'\n", buf);
878

    
879
        /* test if last line */
880
        if (buf[0] == '\0')
881
            break;
882
        p = buf;
883
        if (line_count == 0) {
884
            /* get reply code */
885
            get_word(buf1, sizeof(buf1), &p);
886
            get_word(buf1, sizeof(buf1), &p);
887
            reply->status_code = atoi(buf1);
888
            av_strlcpy(reply->reason, p, sizeof(reply->reason));
889
        } else {
890
            ff_rtsp_parse_line(reply, p, rt, method);
891
            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
892
            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
893
        }
894
        line_count++;
895
    }
896

    
897
    if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
898
        av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
899

    
900
    content_length = reply->content_length;
901
    if (content_length > 0) {
902
        /* leave some room for a trailing '\0' (useful for simple parsing) */
903
        content = av_malloc(content_length + 1);
904
        (void)url_read_complete(rt->rtsp_hd, content, content_length);
905
        content[content_length] = '\0';
906
    }
907
    if (content_ptr)
908
        *content_ptr = content;
909
    else
910
        av_free(content);
911

    
912
    if (rt->seq != reply->seq) {
913
        av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
914
            rt->seq, reply->seq);
915
    }
916

    
917
    /* EOS */
918
    if (reply->notice == 2101 /* End-of-Stream Reached */      ||
919
        reply->notice == 2104 /* Start-of-Stream Reached */    ||
920
        reply->notice == 2306 /* Continuous Feed Terminated */) {
921
        rt->state = RTSP_STATE_IDLE;
922
    } else if (reply->notice >= 4400 && reply->notice < 5500) {
923
        return AVERROR(EIO); /* data or server error */
924
    } else if (reply->notice == 2401 /* Ticket Expired */ ||
925
             (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
926
        return AVERROR(EPERM);
927

    
928
    return 0;
929
}
930

    
931
/**
932
 * Send a command to the RTSP server without waiting for the reply.
933
 *
934
 * @param s RTSP (de)muxer context
935
 * @param method the method for the request
936
 * @param url the target url for the request
937
 * @param headers extra header lines to include in the request
938
 * @param send_content if non-null, the data to send as request body content
939
 * @param send_content_length the length of the send_content data, or 0 if
940
 *                            send_content is null
941
 *
942
 * @return zero if success, nonzero otherwise
943
 */
944
static int ff_rtsp_send_cmd_with_content_async(AVFormatContext *s,
945
                                               const char *method, const char *url,
946
                                               const char *headers,
947
                                               const unsigned char *send_content,
948
                                               int send_content_length)
949
{
950
    RTSPState *rt = s->priv_data;
951
    char buf[4096], *out_buf;
952
    char base64buf[AV_BASE64_SIZE(sizeof(buf))];
953

    
954
    /* Add in RTSP headers */
955
    out_buf = buf;
956
    rt->seq++;
957
    snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);
958
    if (headers)
959
        av_strlcat(buf, headers, sizeof(buf));
960
    av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);
961
    if (rt->session_id[0] != '\0' && (!headers ||
962
        !strstr(headers, "\nIf-Match:"))) {
963
        av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);
964
    }
965
    if (rt->auth[0]) {
966
        char *str = ff_http_auth_create_response(&rt->auth_state,
967
                                                 rt->auth, url, method);
968
        if (str)
969
            av_strlcat(buf, str, sizeof(buf));
970
        av_free(str);
971
    }
972
    if (send_content_length > 0 && send_content)
973
        av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
974
    av_strlcat(buf, "\r\n", sizeof(buf));
975

    
976
    /* base64 encode rtsp if tunneling */
977
    if (rt->control_transport == RTSP_MODE_TUNNEL) {
978
        av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
979
        out_buf = base64buf;
980
    }
981

    
982
    av_dlog(s, "Sending:\n%s--\n", buf);
983

    
984
    url_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
985
    if (send_content_length > 0 && send_content) {
986
        if (rt->control_transport == RTSP_MODE_TUNNEL) {
987
            av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "
988
                                    "with content data not supported\n");
989
            return AVERROR_PATCHWELCOME;
990
        }
991
        url_write(rt->rtsp_hd_out, send_content, send_content_length);
992
    }
993
    rt->last_cmd_time = av_gettime();
994

    
995
    return 0;
996
}
997

    
998
int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
999
                           const char *url, const char *headers)
1000
{
1001
    return ff_rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
1002
}
1003

    
1004
int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
1005
                     const char *headers, RTSPMessageHeader *reply,
1006
                     unsigned char **content_ptr)
1007
{
1008
    return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
1009
                                         content_ptr, NULL, 0);
1010
}
1011

    
1012
int ff_rtsp_send_cmd_with_content(AVFormatContext *s,
1013
                                  const char *method, const char *url,
1014
                                  const char *header,
1015
                                  RTSPMessageHeader *reply,
1016
                                  unsigned char **content_ptr,
1017
                                  const unsigned char *send_content,
1018
                                  int send_content_length)
1019
{
1020
    RTSPState *rt = s->priv_data;
1021
    HTTPAuthType cur_auth_type;
1022
    int ret;
1023

    
1024
retry:
1025
    cur_auth_type = rt->auth_state.auth_type;
1026
    if ((ret = ff_rtsp_send_cmd_with_content_async(s, method, url, header,
1027
                                                   send_content,
1028
                                                   send_content_length)))
1029
        return ret;
1030

    
1031
    if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0)
1032
        return ret;
1033

    
1034
    if (reply->status_code == 401 && cur_auth_type == HTTP_AUTH_NONE &&
1035
        rt->auth_state.auth_type != HTTP_AUTH_NONE)
1036
        goto retry;
1037

    
1038
    if (reply->status_code > 400){
1039
        av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",
1040
               method,
1041
               reply->status_code,
1042
               reply->reason);
1043
        av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
1044
    }
1045

    
1046
    return 0;
1047
}
1048

    
1049
/**
1050
 * @return 0 on success, <0 on error, 1 if protocol is unavailable.
1051
 */
1052
int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
1053
                              int lower_transport, const char *real_challenge)
1054
{
1055
    RTSPState *rt = s->priv_data;
1056
    int rtx, j, i, err, interleave = 0;
1057
    RTSPStream *rtsp_st;
1058
    RTSPMessageHeader reply1, *reply = &reply1;
1059
    char cmd[2048];
1060
    const char *trans_pref;
1061

    
1062
    if (rt->transport == RTSP_TRANSPORT_RDT)
1063
        trans_pref = "x-pn-tng";
1064
    else
1065
        trans_pref = "RTP/AVP";
1066

    
1067
    /* default timeout: 1 minute */
1068
    rt->timeout = 60;
1069

    
1070
    /* for each stream, make the setup request */
1071
    /* XXX: we assume the same server is used for the control of each
1072
     * RTSP stream */
1073

    
1074
    for (j = RTSP_RTP_PORT_MIN, i = 0; i < rt->nb_rtsp_streams; ++i) {
1075
        char transport[2048];
1076

    
1077
        /**
1078
         * WMS serves all UDP data over a single connection, the RTX, which
1079
         * isn't necessarily the first in the SDP but has to be the first
1080
         * to be set up, else the second/third SETUP will fail with a 461.
1081
         */
1082
        if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1083
             rt->server_type == RTSP_SERVER_WMS) {
1084
            if (i == 0) {
1085
                /* rtx first */
1086
                for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1087
                    int len = strlen(rt->rtsp_streams[rtx]->control_url);
1088
                    if (len >= 4 &&
1089
                        !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1090
                                "/rtx"))
1091
                        break;
1092
                }
1093
                if (rtx == rt->nb_rtsp_streams)
1094
                    return -1; /* no RTX found */
1095
                rtsp_st = rt->rtsp_streams[rtx];
1096
            } else
1097
                rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1098
        } else
1099
            rtsp_st = rt->rtsp_streams[i];
1100

    
1101
        /* RTP/UDP */
1102
        if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1103
            char buf[256];
1104

    
1105
            if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1106
                port = reply->transports[0].client_port_min;
1107
                goto have_port;
1108
            }
1109

    
1110
            /* first try in specified port range */
1111
            if (RTSP_RTP_PORT_MIN != 0) {
1112
                while (j <= RTSP_RTP_PORT_MAX) {
1113
                    ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1114
                                "?localport=%d", j);
1115
                    /* we will use two ports per rtp stream (rtp and rtcp) */
1116
                    j += 2;
1117
                    if (url_open(&rtsp_st->rtp_handle, buf, URL_RDWR) == 0)
1118
                        goto rtp_opened;
1119
                }
1120
            }
1121

    
1122
#if 0
1123
            /* then try on any port */
1124
            if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
1125
                err = AVERROR_INVALIDDATA;
1126
                goto fail;
1127
            }
1128
#else
1129
            av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n");
1130
            err = AVERROR(EIO);
1131
            goto fail;
1132
#endif
1133

    
1134
        rtp_opened:
1135
            port = rtp_get_local_rtp_port(rtsp_st->rtp_handle);
1136
        have_port:
1137
            snprintf(transport, sizeof(transport) - 1,
1138
                     "%s/UDP;", trans_pref);
1139
            if (rt->server_type != RTSP_SERVER_REAL)
1140
                av_strlcat(transport, "unicast;", sizeof(transport));
1141
            av_strlcatf(transport, sizeof(transport),
1142
                     "client_port=%d", port);
1143
            if (rt->transport == RTSP_TRANSPORT_RTP &&
1144
                !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1145
                av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1146
        }
1147

    
1148
        /* RTP/TCP */
1149
        else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1150
            /** For WMS streams, the application streams are only used for
1151
             * UDP. When trying to set it up for TCP streams, the server
1152
             * will return an error. Therefore, we skip those streams. */
1153
            if (rt->server_type == RTSP_SERVER_WMS &&
1154
                s->streams[rtsp_st->stream_index]->codec->codec_type ==
1155
                    AVMEDIA_TYPE_DATA)
1156
                continue;
1157
            snprintf(transport, sizeof(transport) - 1,
1158
                     "%s/TCP;", trans_pref);
1159
            if (rt->server_type == RTSP_SERVER_WMS)
1160
                av_strlcat(transport, "unicast;", sizeof(transport));
1161
            av_strlcatf(transport, sizeof(transport),
1162
                        "interleaved=%d-%d",
1163
                        interleave, interleave + 1);
1164
            interleave += 2;
1165
        }
1166

    
1167
        else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1168
            snprintf(transport, sizeof(transport) - 1,
1169
                     "%s/UDP;multicast", trans_pref);
1170
        }
1171
        if (s->oformat) {
1172
            av_strlcat(transport, ";mode=receive", sizeof(transport));
1173
        } else if (rt->server_type == RTSP_SERVER_REAL ||
1174
                   rt->server_type == RTSP_SERVER_WMS)
1175
            av_strlcat(transport, ";mode=play", sizeof(transport));
1176
        snprintf(cmd, sizeof(cmd),
1177
                 "Transport: %s\r\n",
1178
                 transport);
1179
        if (i == 0 && rt->server_type == RTSP_SERVER_REAL && CONFIG_RTPDEC) {
1180
            char real_res[41], real_csum[9];
1181
            ff_rdt_calc_response_and_checksum(real_res, real_csum,
1182
                                              real_challenge);
1183
            av_strlcatf(cmd, sizeof(cmd),
1184
                        "If-Match: %s\r\n"
1185
                        "RealChallenge2: %s, sd=%s\r\n",
1186
                        rt->session_id, real_res, real_csum);
1187
        }
1188
        ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);
1189
        if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1190
            err = 1;
1191
            goto fail;
1192
        } else if (reply->status_code != RTSP_STATUS_OK ||
1193
                   reply->nb_transports != 1) {
1194
            err = AVERROR_INVALIDDATA;
1195
            goto fail;
1196
        }
1197

    
1198
        /* XXX: same protocol for all streams is required */
1199
        if (i > 0) {
1200
            if (reply->transports[0].lower_transport != rt->lower_transport ||
1201
                reply->transports[0].transport != rt->transport) {
1202
                err = AVERROR_INVALIDDATA;
1203
                goto fail;
1204
            }
1205
        } else {
1206
            rt->lower_transport = reply->transports[0].lower_transport;
1207
            rt->transport = reply->transports[0].transport;
1208
        }
1209

    
1210
        /* Fail if the server responded with another lower transport mode
1211
         * than what we requested. */
1212
        if (reply->transports[0].lower_transport != lower_transport) {
1213
            av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n");
1214
            err = AVERROR_INVALIDDATA;
1215
            goto fail;
1216
        }
1217

    
1218
        switch(reply->transports[0].lower_transport) {
1219
        case RTSP_LOWER_TRANSPORT_TCP:
1220
            rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1221
            rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1222
            break;
1223

    
1224
        case RTSP_LOWER_TRANSPORT_UDP: {
1225
            char url[1024], options[30] = "";
1226

    
1227
            if (rt->filter_source)
1228
                av_strlcpy(options, "?connect=1", sizeof(options));
1229
            /* Use source address if specified */
1230
            if (reply->transports[0].source[0]) {
1231
                ff_url_join(url, sizeof(url), "rtp", NULL,
1232
                            reply->transports[0].source,
1233
                            reply->transports[0].server_port_min, options);
1234
            } else {
1235
                ff_url_join(url, sizeof(url), "rtp", NULL, host,
1236
                            reply->transports[0].server_port_min, options);
1237
            }
1238
            if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1239
                rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1240
                err = AVERROR_INVALIDDATA;
1241
                goto fail;
1242
            }
1243
            /* Try to initialize the connection state in a
1244
             * potential NAT router by sending dummy packets.
1245
             * RTP/RTCP dummy packets are used for RDT, too.
1246
             */
1247
            if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat &&
1248
                CONFIG_RTPDEC)
1249
                rtp_send_punch_packets(rtsp_st->rtp_handle);
1250
            break;
1251
        }
1252
        case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1253
            char url[1024], namebuf[50];
1254
            struct sockaddr_storage addr;
1255
            int port, ttl;
1256

    
1257
            if (reply->transports[0].destination.ss_family) {
1258
                addr      = reply->transports[0].destination;
1259
                port      = reply->transports[0].port_min;
1260
                ttl       = reply->transports[0].ttl;
1261
            } else {
1262
                addr      = rtsp_st->sdp_ip;
1263
                port      = rtsp_st->sdp_port;
1264
                ttl       = rtsp_st->sdp_ttl;
1265
            }
1266
            getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1267
                        namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1268
            ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1269
                        port, "?ttl=%d", ttl);
1270
            if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1271
                err = AVERROR_INVALIDDATA;
1272
                goto fail;
1273
            }
1274
            break;
1275
        }
1276
        }
1277

    
1278
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1279
            goto fail;
1280
    }
1281

    
1282
    if (reply->timeout > 0)
1283
        rt->timeout = reply->timeout;
1284

    
1285
    if (rt->server_type == RTSP_SERVER_REAL)
1286
        rt->need_subscription = 1;
1287

    
1288
    return 0;
1289

    
1290
fail:
1291
    ff_rtsp_undo_setup(s);
1292
    return err;
1293
}
1294

    
1295
void ff_rtsp_close_connections(AVFormatContext *s)
1296
{
1297
    RTSPState *rt = s->priv_data;
1298
    if (rt->rtsp_hd_out != rt->rtsp_hd) url_close(rt->rtsp_hd_out);
1299
    url_close(rt->rtsp_hd);
1300
    rt->rtsp_hd = rt->rtsp_hd_out = NULL;
1301
}
1302

    
1303
int ff_rtsp_connect(AVFormatContext *s)
1304
{
1305
    RTSPState *rt = s->priv_data;
1306
    char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1307
    char *option_list, *option, *filename;
1308
    int port, err, tcp_fd;
1309
    RTSPMessageHeader reply1 = {0}, *reply = &reply1;
1310
    int lower_transport_mask = 0;
1311
    char real_challenge[64] = "";
1312
    struct sockaddr_storage peer;
1313
    socklen_t peer_len = sizeof(peer);
1314

    
1315
    if (!ff_network_init())
1316
        return AVERROR(EIO);
1317
redirect:
1318
    rt->control_transport = RTSP_MODE_PLAIN;
1319
    /* extract hostname and port */
1320
    av_url_split(NULL, 0, auth, sizeof(auth),
1321
                 host, sizeof(host), &port, path, sizeof(path), s->filename);
1322
    if (*auth) {
1323
        av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1324
    }
1325
    if (port < 0)
1326
        port = RTSP_DEFAULT_PORT;
1327

    
1328
    /* search for options */
1329
    option_list = strrchr(path, '?');
1330
    if (option_list) {
1331
        /* Strip out the RTSP specific options, write out the rest of
1332
         * the options back into the same string. */
1333
        filename = option_list;
1334
        while (option_list) {
1335
            /* move the option pointer */
1336
            option = ++option_list;
1337
            option_list = strchr(option_list, '&');
1338
            if (option_list)
1339
                *option_list = 0;
1340

    
1341
            /* handle the options */
1342
            if (!strcmp(option, "udp")) {
1343
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_UDP);
1344
            } else if (!strcmp(option, "multicast")) {
1345
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
1346
            } else if (!strcmp(option, "tcp")) {
1347
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_TCP);
1348
            } else if(!strcmp(option, "http")) {
1349
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_TCP);
1350
                rt->control_transport = RTSP_MODE_TUNNEL;
1351
            } else if (!strcmp(option, "filter_src")) {
1352
                rt->filter_source = 1;
1353
            } else {
1354
                /* Write options back into the buffer, using memmove instead
1355
                 * of strcpy since the strings may overlap. */
1356
                int len = strlen(option);
1357
                memmove(++filename, option, len);
1358
                filename += len;
1359
                if (option_list) *filename = '&';
1360
            }
1361
        }
1362
        *filename = 0;
1363
    }
1364

    
1365
    if (!lower_transport_mask)
1366
        lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1367

    
1368
    if (s->oformat) {
1369
        /* Only UDP or TCP - UDP multicast isn't supported. */
1370
        lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
1371
                                (1 << RTSP_LOWER_TRANSPORT_TCP);
1372
        if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
1373
            av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1374
                                    "only UDP and TCP are supported for output.\n");
1375
            err = AVERROR(EINVAL);
1376
            goto fail;
1377
        }
1378
    }
1379

    
1380
    /* Construct the URI used in request; this is similar to s->filename,
1381
     * but with authentication credentials removed and RTSP specific options
1382
     * stripped out. */
1383
    ff_url_join(rt->control_uri, sizeof(rt->control_uri), "rtsp", NULL,
1384
                host, port, "%s", path);
1385

    
1386
    if (rt->control_transport == RTSP_MODE_TUNNEL) {
1387
        /* set up initial handshake for tunneling */
1388
        char httpname[1024];
1389
        char sessioncookie[17];
1390
        char headers[1024];
1391

    
1392
        ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path);
1393
        snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
1394
                 av_get_random_seed(), av_get_random_seed());
1395

    
1396
        /* GET requests */
1397
        if (url_alloc(&rt->rtsp_hd, httpname, URL_RDONLY) < 0) {
1398
            err = AVERROR(EIO);
1399
            goto fail;
1400
        }
1401

    
1402
        /* generate GET headers */
1403
        snprintf(headers, sizeof(headers),
1404
                 "x-sessioncookie: %s\r\n"
1405
                 "Accept: application/x-rtsp-tunnelled\r\n"
1406
                 "Pragma: no-cache\r\n"
1407
                 "Cache-Control: no-cache\r\n",
1408
                 sessioncookie);
1409
        ff_http_set_headers(rt->rtsp_hd, headers);
1410

    
1411
        /* complete the connection */
1412
        if (url_connect(rt->rtsp_hd)) {
1413
            err = AVERROR(EIO);
1414
            goto fail;
1415
        }
1416

    
1417
        /* POST requests */
1418
        if (url_alloc(&rt->rtsp_hd_out, httpname, URL_WRONLY) < 0 ) {
1419
            err = AVERROR(EIO);
1420
            goto fail;
1421
        }
1422

    
1423
        /* generate POST headers */
1424
        snprintf(headers, sizeof(headers),
1425
                 "x-sessioncookie: %s\r\n"
1426
                 "Content-Type: application/x-rtsp-tunnelled\r\n"
1427
                 "Pragma: no-cache\r\n"
1428
                 "Cache-Control: no-cache\r\n"
1429
                 "Content-Length: 32767\r\n"
1430
                 "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1431
                 sessioncookie);
1432
        ff_http_set_headers(rt->rtsp_hd_out, headers);
1433
        ff_http_set_chunked_transfer_encoding(rt->rtsp_hd_out, 0);
1434

    
1435
        /* Initialize the authentication state for the POST session. The HTTP
1436
         * protocol implementation doesn't properly handle multi-pass
1437
         * authentication for POST requests, since it would require one of
1438
         * the following:
1439
         * - implementing Expect: 100-continue, which many HTTP servers
1440
         *   don't support anyway, even less the RTSP servers that do HTTP
1441
         *   tunneling
1442
         * - sending the whole POST data until getting a 401 reply specifying
1443
         *   what authentication method to use, then resending all that data
1444
         * - waiting for potential 401 replies directly after sending the
1445
         *   POST header (waiting for some unspecified time)
1446
         * Therefore, we copy the full auth state, which works for both basic
1447
         * and digest. (For digest, we would have to synchronize the nonce
1448
         * count variable between the two sessions, if we'd do more requests
1449
         * with the original session, though.)
1450
         */
1451
        ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
1452

    
1453
        /* complete the connection */
1454
        if (url_connect(rt->rtsp_hd_out)) {
1455
            err = AVERROR(EIO);
1456
            goto fail;
1457
        }
1458
    } else {
1459
        /* open the tcp connection */
1460
        ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port, NULL);
1461
        if (url_open(&rt->rtsp_hd, tcpname, URL_RDWR) < 0) {
1462
            err = AVERROR(EIO);
1463
            goto fail;
1464
        }
1465
        rt->rtsp_hd_out = rt->rtsp_hd;
1466
    }
1467
    rt->seq = 0;
1468

    
1469
    tcp_fd = url_get_file_handle(rt->rtsp_hd);
1470
    if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1471
        getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1472
                    NULL, 0, NI_NUMERICHOST);
1473
    }
1474

    
1475
    /* request options supported by the server; this also detects server
1476
     * type */
1477
    for (rt->server_type = RTSP_SERVER_RTP;;) {
1478
        cmd[0] = 0;
1479
        if (rt->server_type == RTSP_SERVER_REAL)
1480
            av_strlcat(cmd,
1481
                       /**
1482
                        * The following entries are required for proper
1483
                        * streaming from a Realmedia server. They are
1484
                        * interdependent in some way although we currently
1485
                        * don't quite understand how. Values were copied
1486
                        * from mplayer SVN r23589.
1487
                        * @param CompanyID is a 16-byte ID in base64
1488
                        * @param ClientChallenge is a 16-byte ID in hex
1489
                        */
1490
                       "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1491
                       "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1492
                       "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1493
                       "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1494
                       sizeof(cmd));
1495
        ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
1496
        if (reply->status_code != RTSP_STATUS_OK) {
1497
            err = AVERROR_INVALIDDATA;
1498
            goto fail;
1499
        }
1500

    
1501
        /* detect server type if not standard-compliant RTP */
1502
        if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1503
            rt->server_type = RTSP_SERVER_REAL;
1504
            continue;
1505
        } else if (!strncasecmp(reply->server, "WMServer/", 9)) {
1506
            rt->server_type = RTSP_SERVER_WMS;
1507
        } else if (rt->server_type == RTSP_SERVER_REAL)
1508
            strcpy(real_challenge, reply->real_challenge);
1509
        break;
1510
    }
1511

    
1512
    if (s->iformat && CONFIG_RTSP_DEMUXER)
1513
        err = ff_rtsp_setup_input_streams(s, reply);
1514
    else if (CONFIG_RTSP_MUXER)
1515
        err = ff_rtsp_setup_output_streams(s, host);
1516
    if (err)
1517
        goto fail;
1518

    
1519
    do {
1520
        int lower_transport = ff_log2_tab[lower_transport_mask &
1521
                                  ~(lower_transport_mask - 1)];
1522

    
1523
        err = ff_rtsp_make_setup_request(s, host, port, lower_transport,
1524
                                 rt->server_type == RTSP_SERVER_REAL ?
1525
                                     real_challenge : NULL);
1526
        if (err < 0)
1527
            goto fail;
1528
        lower_transport_mask &= ~(1 << lower_transport);
1529
        if (lower_transport_mask == 0 && err == 1) {
1530
            err = FF_NETERROR(EPROTONOSUPPORT);
1531
            goto fail;
1532
        }
1533
    } while (err);
1534

    
1535
    rt->lower_transport_mask = lower_transport_mask;
1536
    av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge));
1537
    rt->state = RTSP_STATE_IDLE;
1538
    rt->seek_timestamp = 0; /* default is to start stream at position zero */
1539
    return 0;
1540
 fail:
1541
    ff_rtsp_close_streams(s);
1542
    ff_rtsp_close_connections(s);
1543
    if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1544
        av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1545
        av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1546
               reply->status_code,
1547
               s->filename);
1548
        goto redirect;
1549
    }
1550
    ff_network_close();
1551
    return err;
1552
}
1553
#endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
1554

    
1555
#if CONFIG_RTPDEC
1556
static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1557
                           uint8_t *buf, int buf_size, int64_t wait_end)
1558
{
1559
    RTSPState *rt = s->priv_data;
1560
    RTSPStream *rtsp_st;
1561
    int n, i, ret, tcp_fd, timeout_cnt = 0;
1562
    int max_p = 0;
1563
    struct pollfd *p = rt->p;
1564

    
1565
    for (;;) {
1566
        if (url_interrupt_cb())
1567
            return AVERROR(EINTR);
1568
        if (wait_end && wait_end - av_gettime() < 0)
1569
            return AVERROR(EAGAIN);
1570
        max_p = 0;
1571
        if (rt->rtsp_hd) {
1572
            tcp_fd = url_get_file_handle(rt->rtsp_hd);
1573
            p[max_p].fd = tcp_fd;
1574
            p[max_p++].events = POLLIN;
1575
        } else {
1576
            tcp_fd = -1;
1577
        }
1578
        for (i = 0; i < rt->nb_rtsp_streams; i++) {
1579
            rtsp_st = rt->rtsp_streams[i];
1580
            if (rtsp_st->rtp_handle) {
1581
                p[max_p].fd = url_get_file_handle(rtsp_st->rtp_handle);
1582
                p[max_p++].events = POLLIN;
1583
                p[max_p].fd = rtp_get_rtcp_file_handle(rtsp_st->rtp_handle);
1584
                p[max_p++].events = POLLIN;
1585
            }
1586
        }
1587
        n = poll(p, max_p, POLL_TIMEOUT_MS);
1588
        if (n > 0) {
1589
            int j = 1 - (tcp_fd == -1);
1590
            timeout_cnt = 0;
1591
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1592
                rtsp_st = rt->rtsp_streams[i];
1593
                if (rtsp_st->rtp_handle) {
1594
                    if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
1595
                        ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
1596
                        if (ret > 0) {
1597
                            *prtsp_st = rtsp_st;
1598
                            return ret;
1599
                        }
1600
                    }
1601
                    j+=2;
1602
                }
1603
            }
1604
#if CONFIG_RTSP_DEMUXER
1605
            if (tcp_fd != -1 && p[0].revents & POLLIN) {
1606
                RTSPMessageHeader reply;
1607

    
1608
                ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
1609
                if (ret < 0)
1610
                    return ret;
1611
                /* XXX: parse message */
1612
                if (rt->state != RTSP_STATE_STREAMING)
1613
                    return 0;
1614
            }
1615
#endif
1616
        } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
1617
            return FF_NETERROR(ETIMEDOUT);
1618
        } else if (n < 0 && errno != EINTR)
1619
            return AVERROR(errno);
1620
    }
1621
}
1622

    
1623
int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
1624
{
1625
    RTSPState *rt = s->priv_data;
1626
    int ret, len;
1627
    RTSPStream *rtsp_st, *first_queue_st = NULL;
1628
    int64_t wait_end = 0;
1629

    
1630
    if (rt->nb_byes == rt->nb_rtsp_streams)
1631
        return AVERROR_EOF;
1632

    
1633
    /* get next frames from the same RTP packet */
1634
    if (rt->cur_transport_priv) {
1635
        if (rt->transport == RTSP_TRANSPORT_RDT) {
1636
            ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1637
        } else
1638
            ret = rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1639
        if (ret == 0) {
1640
            rt->cur_transport_priv = NULL;
1641
            return 0;
1642
        } else if (ret == 1) {
1643
            return 0;
1644
        } else
1645
            rt->cur_transport_priv = NULL;
1646
    }
1647

    
1648
    if (rt->transport == RTSP_TRANSPORT_RTP) {
1649
        int i;
1650
        int64_t first_queue_time = 0;
1651
        for (i = 0; i < rt->nb_rtsp_streams; i++) {
1652
            RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
1653
            int64_t queue_time;
1654
            if (!rtpctx)
1655
                continue;
1656
            queue_time = ff_rtp_queued_packet_time(rtpctx);
1657
            if (queue_time && (queue_time - first_queue_time < 0 ||
1658
                               !first_queue_time)) {
1659
                first_queue_time = queue_time;
1660
                first_queue_st   = rt->rtsp_streams[i];
1661
            }
1662
        }
1663
        if (first_queue_time)
1664
            wait_end = first_queue_time + s->max_delay;
1665
    }
1666

    
1667
    /* read next RTP packet */
1668
 redo:
1669
    if (!rt->recvbuf) {
1670
        rt->recvbuf = av_malloc(RECVBUF_SIZE);
1671
        if (!rt->recvbuf)
1672
            return AVERROR(ENOMEM);
1673
    }
1674

    
1675
    switch(rt->lower_transport) {
1676
    default:
1677
#if CONFIG_RTSP_DEMUXER
1678
    case RTSP_LOWER_TRANSPORT_TCP:
1679
        len = ff_rtsp_tcp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE);
1680
        break;
1681
#endif
1682
    case RTSP_LOWER_TRANSPORT_UDP:
1683
    case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1684
        len = udp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
1685
        if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
1686
            rtp_check_and_send_back_rr(rtsp_st->transport_priv, len);
1687
        break;
1688
    }
1689
    if (len == AVERROR(EAGAIN) && first_queue_st &&
1690
        rt->transport == RTSP_TRANSPORT_RTP) {
1691
        rtsp_st = first_queue_st;
1692
        ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0);
1693
        goto end;
1694
    }
1695
    if (len < 0)
1696
        return len;
1697
    if (len == 0)
1698
        return AVERROR_EOF;
1699
    if (rt->transport == RTSP_TRANSPORT_RDT) {
1700
        ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
1701
    } else {
1702
        ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
1703
        if (ret < 0) {
1704
            /* Either bad packet, or a RTCP packet. Check if the
1705
             * first_rtcp_ntp_time field was initialized. */
1706
            RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
1707
            if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
1708
                /* first_rtcp_ntp_time has been initialized for this stream,
1709
                 * copy the same value to all other uninitialized streams,
1710
                 * in order to map their timestamp origin to the same ntp time
1711
                 * as this one. */
1712
                int i;
1713
                AVStream *st = NULL;
1714
                if (rtsp_st->stream_index >= 0)
1715
                    st = s->streams[rtsp_st->stream_index];
1716
                for (i = 0; i < rt->nb_rtsp_streams; i++) {
1717
                    RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
1718
                    AVStream *st2 = NULL;
1719
                    if (rt->rtsp_streams[i]->stream_index >= 0)
1720
                        st2 = s->streams[rt->rtsp_streams[i]->stream_index];
1721
                    if (rtpctx2 && st && st2 &&
1722
                        rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
1723
                        rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
1724
                        rtpctx2->rtcp_ts_offset = av_rescale_q(
1725
                            rtpctx->rtcp_ts_offset, st->time_base,
1726
                            st2->time_base);
1727
                    }
1728
                }
1729
            }
1730
            if (ret == -RTCP_BYE) {
1731
                rt->nb_byes++;
1732

    
1733
                av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
1734
                       rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
1735

    
1736
                if (rt->nb_byes == rt->nb_rtsp_streams)
1737
                    return AVERROR_EOF;
1738
            }
1739
        }
1740
    }
1741
end:
1742
    if (ret < 0)
1743
        goto redo;
1744
    if (ret == 1)
1745
        /* more packets may follow, so we save the RTP context */
1746
        rt->cur_transport_priv = rtsp_st->transport_priv;
1747

    
1748
    return ret;
1749
}
1750
#endif /* CONFIG_RTPDEC */
1751

    
1752
#if CONFIG_SDP_DEMUXER
1753
static int sdp_probe(AVProbeData *p1)
1754
{
1755
    const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
1756

    
1757
    /* we look for a line beginning "c=IN IP" */
1758
    while (p < p_end && *p != '\0') {
1759
        if (p + sizeof("c=IN IP") - 1 < p_end &&
1760
            av_strstart(p, "c=IN IP", NULL))
1761
            return AVPROBE_SCORE_MAX / 2;
1762

    
1763
        while (p < p_end - 1 && *p != '\n') p++;
1764
        if (++p >= p_end)
1765
            break;
1766
        if (*p == '\r')
1767
            p++;
1768
    }
1769
    return 0;
1770
}
1771

    
1772
static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap)
1773
{
1774
    RTSPState *rt = s->priv_data;
1775
    RTSPStream *rtsp_st;
1776
    int size, i, err;
1777
    char *content;
1778
    char url[1024];
1779

    
1780
    if (!ff_network_init())
1781
        return AVERROR(EIO);
1782

    
1783
    /* read the whole sdp file */
1784
    /* XXX: better loading */
1785
    content = av_malloc(SDP_MAX_SIZE);
1786
    size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
1787
    if (size <= 0) {
1788
        av_free(content);
1789
        return AVERROR_INVALIDDATA;
1790
    }
1791
    content[size] ='\0';
1792

    
1793
    err = ff_sdp_parse(s, content);
1794
    av_free(content);
1795
    if (err) goto fail;
1796

    
1797
    /* open each RTP stream */
1798
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1799
        char namebuf[50];
1800
        rtsp_st = rt->rtsp_streams[i];
1801

    
1802
        getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip),
1803
                    namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1804
        ff_url_join(url, sizeof(url), "rtp", NULL,
1805
                    namebuf, rtsp_st->sdp_port,
1806
                    "?localport=%d&ttl=%d", rtsp_st->sdp_port,
1807
                    rtsp_st->sdp_ttl);
1808
        if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1809
            err = AVERROR_INVALIDDATA;
1810
            goto fail;
1811
        }
1812
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1813
            goto fail;
1814
    }
1815
    return 0;
1816
fail:
1817
    ff_rtsp_close_streams(s);
1818
    ff_network_close();
1819
    return err;
1820
}
1821

    
1822
static int sdp_read_close(AVFormatContext *s)
1823
{
1824
    ff_rtsp_close_streams(s);
1825
    ff_network_close();
1826
    return 0;
1827
}
1828

    
1829
AVInputFormat ff_sdp_demuxer = {
1830
    "sdp",
1831
    NULL_IF_CONFIG_SMALL("SDP"),
1832
    sizeof(RTSPState),
1833
    sdp_probe,
1834
    sdp_read_header,
1835
    ff_rtsp_fetch_packet,
1836
    sdp_read_close,
1837
};
1838
#endif /* CONFIG_SDP_DEMUXER */
1839

    
1840
#if CONFIG_RTP_DEMUXER
1841
static int rtp_probe(AVProbeData *p)
1842
{
1843
    if (av_strstart(p->filename, "rtp:", NULL))
1844
        return AVPROBE_SCORE_MAX;
1845
    return 0;
1846
}
1847

    
1848
static int rtp_read_header(AVFormatContext *s,
1849
                           AVFormatParameters *ap)
1850
{
1851
    uint8_t recvbuf[1500];
1852
    char host[500], sdp[500];
1853
    int ret, port;
1854
    URLContext* in = NULL;
1855
    int payload_type;
1856
    AVCodecContext codec;
1857
    struct sockaddr_storage addr;
1858
    ByteIOContext pb;
1859
    socklen_t addrlen = sizeof(addr);
1860

    
1861
    if (!ff_network_init())
1862
        return AVERROR(EIO);
1863

    
1864
    ret = url_open(&in, s->filename, URL_RDONLY);
1865
    if (ret)
1866
        goto fail;
1867

    
1868
    while (1) {
1869
        ret = url_read(in, recvbuf, sizeof(recvbuf));
1870
        if (ret == AVERROR(EAGAIN))
1871
            continue;
1872
        if (ret < 0)
1873
            goto fail;
1874
        if (ret < 12) {
1875
            av_log(s, AV_LOG_WARNING, "Received too short packet\n");
1876
            continue;
1877
        }
1878

    
1879
        if ((recvbuf[0] & 0xc0) != 0x80) {
1880
            av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet "
1881
                                      "received\n");
1882
            continue;
1883
        }
1884

    
1885
        payload_type = recvbuf[1] & 0x7f;
1886
        break;
1887
    }
1888
    getsockname(url_get_file_handle(in), (struct sockaddr*) &addr, &addrlen);
1889
    url_close(in);
1890
    in = NULL;
1891

    
1892
    memset(&codec, 0, sizeof(codec));
1893
    if (ff_rtp_get_codec_info(&codec, payload_type)) {
1894
        av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d "
1895
                                "without an SDP file describing it\n",
1896
                                 payload_type);
1897
        goto fail;
1898
    }
1899
    if (codec.codec_type != AVMEDIA_TYPE_DATA) {
1900
        av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received "
1901
                                  "properly you need an SDP file "
1902
                                  "describing it\n");
1903
    }
1904

    
1905
    av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port,
1906
                 NULL, 0, s->filename);
1907

    
1908
    snprintf(sdp, sizeof(sdp),
1909
             "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",
1910
             addr.ss_family == AF_INET ? 4 : 6, host,
1911
             codec.codec_type == AVMEDIA_TYPE_DATA  ? "application" :
1912
             codec.codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio",
1913
             port, payload_type);
1914
    av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp);
1915

    
1916
    init_put_byte(&pb, sdp, strlen(sdp), 0, NULL, NULL, NULL, NULL);
1917
    s->pb = &pb;
1918

    
1919
    /* sdp_read_header initializes this again */
1920
    ff_network_close();
1921

    
1922
    ret = sdp_read_header(s, ap);
1923
    s->pb = NULL;
1924
    return ret;
1925

    
1926
fail:
1927
    if (in)
1928
        url_close(in);
1929
    ff_network_close();
1930
    return ret;
1931
}
1932

    
1933
AVInputFormat ff_rtp_demuxer = {
1934
    "rtp",
1935
    NULL_IF_CONFIG_SMALL("RTP input format"),
1936
    sizeof(RTSPState),
1937
    rtp_probe,
1938
    rtp_read_header,
1939
    ff_rtsp_fetch_packet,
1940
    sdp_read_close,
1941
    .flags = AVFMT_NOFILE,
1942
};
1943
#endif /* CONFIG_RTP_DEMUXER */
1944