Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtsp.c @ b7dc88fc

History | View | Annotate | Download (66.4 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 "avformat.h"
26

    
27
#include <sys/time.h>
28
#if HAVE_SYS_SELECT_H
29
#include <sys/select.h>
30
#endif
31
#include <strings.h>
32
#include "internal.h"
33
#include "network.h"
34
#include "os_support.h"
35
#include "rtsp.h"
36

    
37
#include "rtpdec.h"
38
#include "rdt.h"
39
#include "rtpdec_asf.h"
40
#include "rtpdec_vorbis.h"
41

    
42
//#define DEBUG
43
//#define DEBUG_RTP_TCP
44

    
45
#if LIBAVFORMAT_VERSION_INT < (53 << 16)
46
int rtsp_default_protocols = (1 << RTSP_LOWER_TRANSPORT_UDP);
47
#endif
48

    
49
#define SPACE_CHARS " \t\r\n"
50
/* we use memchr() instead of strchr() here because strchr() will return
51
 * the terminating '\0' of SPACE_CHARS instead of NULL if c is '\0'. */
52
#define redir_isspace(c) memchr(SPACE_CHARS, c, 4)
53
static void skip_spaces(const char **pp)
54
{
55
    const char *p;
56
    p = *pp;
57
    while (redir_isspace(*p))
58
        p++;
59
    *pp = p;
60
}
61

    
62
static void get_word_until_chars(char *buf, int buf_size,
63
                                 const char *sep, const char **pp)
64
{
65
    const char *p;
66
    char *q;
67

    
68
    p = *pp;
69
    skip_spaces(&p);
70
    q = buf;
71
    while (!strchr(sep, *p) && *p != '\0') {
72
        if ((q - buf) < buf_size - 1)
73
            *q++ = *p;
74
        p++;
75
    }
76
    if (buf_size > 0)
77
        *q = '\0';
78
    *pp = p;
79
}
80

    
81
static void get_word_sep(char *buf, int buf_size, const char *sep,
82
                         const char **pp)
83
{
84
    if (**pp == '/') (*pp)++;
85
    get_word_until_chars(buf, buf_size, sep, pp);
86
}
87

    
88
static void get_word(char *buf, int buf_size, const char **pp)
89
{
90
    get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);
91
}
92

    
93
/* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
94
static int sdp_parse_rtpmap(AVFormatContext *s,
95
                            AVCodecContext *codec, RTSPStream *rtsp_st,
96
                            int payload_type, const char *p)
97
{
98
    char buf[256];
99
    int i;
100
    AVCodec *c;
101
    const char *c_name;
102

    
103
    /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and
104
     * see if we can handle this kind of payload.
105
     * The space should normally not be there but some Real streams or
106
     * particular servers ("RealServer Version 6.1.3.970", see issue 1658)
107
     * have a trailing space. */
108
    get_word_sep(buf, sizeof(buf), "/ ", &p);
109
    if (payload_type >= RTP_PT_PRIVATE) {
110
        RTPDynamicProtocolHandler *handler;
111
        for (handler = RTPFirstDynamicPayloadHandler;
112
             handler; handler = handler->next) {
113
            if (!strcasecmp(buf, handler->enc_name) &&
114
                codec->codec_type == handler->codec_type) {
115
                codec->codec_id          = handler->codec_id;
116
                rtsp_st->dynamic_handler = handler;
117
                if (handler->open)
118
                    rtsp_st->dynamic_protocol_context = handler->open();
119
                break;
120
            }
121
        }
122
    } else {
123
        /* We are in a standard case
124
         * (from http://www.iana.org/assignments/rtp-parameters). */
125
        /* search into AVRtpPayloadTypes[] */
126
        codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
127
    }
128

    
129
    c = avcodec_find_decoder(codec->codec_id);
130
    if (c && c->name)
131
        c_name = c->name;
132
    else
133
        c_name = "(null)";
134

    
135
    get_word_sep(buf, sizeof(buf), "/", &p);
136
    i = atoi(buf);
137
    switch (codec->codec_type) {
138
    case CODEC_TYPE_AUDIO:
139
        av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name);
140
        codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;
141
        codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;
142
        if (i > 0) {
143
            codec->sample_rate = i;
144
            get_word_sep(buf, sizeof(buf), "/", &p);
145
            i = atoi(buf);
146
            if (i > 0)
147
                codec->channels = i;
148
            // TODO: there is a bug here; if it is a mono stream, and
149
            // less than 22000Hz, faad upconverts to stereo and twice
150
            // the frequency.  No problem, but the sample rate is being
151
            // set here by the sdp line. Patch on its way. (rdm)
152
        }
153
        av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n",
154
               codec->sample_rate);
155
        av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n",
156
               codec->channels);
157
        break;
158
    case CODEC_TYPE_VIDEO:
159
        av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
160
        break;
161
    default:
162
        break;
163
    }
164
    return 0;
165
}
166

    
167
/* return the length and optionally the data */
168
static int hex_to_data(uint8_t *data, const char *p)
169
{
170
    int c, len, v;
171

    
172
    len = 0;
173
    v = 1;
174
    for (;;) {
175
        skip_spaces(&p);
176
        if (*p == '\0')
177
            break;
178
        c = toupper((unsigned char) *p++);
179
        if (c >= '0' && c <= '9')
180
            c = c - '0';
181
        else if (c >= 'A' && c <= 'F')
182
            c = c - 'A' + 10;
183
        else
184
            break;
185
        v = (v << 4) | c;
186
        if (v & 0x100) {
187
            if (data)
188
                data[len] = v;
189
            len++;
190
            v = 1;
191
        }
192
    }
193
    return len;
194
}
195

    
196
static void sdp_parse_fmtp_config(AVCodecContext * codec, void *ctx,
197
                                  char *attr, char *value)
198
{
199
    switch (codec->codec_id) {
200
    case CODEC_ID_MPEG4:
201
    case CODEC_ID_AAC:
202
        if (!strcmp(attr, "config")) {
203
            /* decode the hexa encoded parameter */
204
            int len = hex_to_data(NULL, value);
205
            if (codec->extradata)
206
                av_free(codec->extradata);
207
            codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
208
            if (!codec->extradata)
209
                return;
210
            codec->extradata_size = len;
211
            hex_to_data(codec->extradata, value);
212
        }
213
        break;
214
    case CODEC_ID_VORBIS:
215
        ff_vorbis_parse_fmtp_config(codec, ctx, attr, value);
216
        break;
217
    default:
218
        break;
219
    }
220
    return;
221
}
222

    
223
typedef struct {
224
    const char *str;
225
    uint16_t    type;
226
    uint32_t    offset;
227
} AttrNameMap;
228

    
229
/* All known fmtp parmeters and the corresping RTPAttrTypeEnum */
230
#define ATTR_NAME_TYPE_INT 0
231
#define ATTR_NAME_TYPE_STR 1
232
static const AttrNameMap attr_names[]=
233
{
234
    { "SizeLength",       ATTR_NAME_TYPE_INT,
235
      offsetof(RTPPayloadData, sizelength) },
236
    { "IndexLength",      ATTR_NAME_TYPE_INT,
237
      offsetof(RTPPayloadData, indexlength) },
238
    { "IndexDeltaLength", ATTR_NAME_TYPE_INT,
239
      offsetof(RTPPayloadData, indexdeltalength) },
240
    { "profile-level-id", ATTR_NAME_TYPE_INT,
241
      offsetof(RTPPayloadData, profile_level_id) },
242
    { "StreamType",       ATTR_NAME_TYPE_INT,
243
      offsetof(RTPPayloadData, streamtype) },
244
    { "mode",             ATTR_NAME_TYPE_STR,
245
      offsetof(RTPPayloadData, mode) },
246
    { NULL, -1, -1 },
247
};
248

    
249
/* parse the attribute line from the fmtp a line of an sdp resonse. This
250
 * is broken out as a function because it is used in rtp_h264.c, which is
251
 * forthcoming. */
252
int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
253
                                char *value, int value_size)
254
{
255
    skip_spaces(p);
256
    if (**p) {
257
        get_word_sep(attr, attr_size, "=", p);
258
        if (**p == '=')
259
            (*p)++;
260
        get_word_sep(value, value_size, ";", p);
261
        if (**p == ';')
262
            (*p)++;
263
        return 1;
264
    }
265
    return 0;
266
}
267

    
268
/* parse a SDP line and save stream attributes */
269
static void sdp_parse_fmtp(AVStream *st, const char *p)
270
{
271
    char attr[256];
272
    /* Vorbis setup headers can be up to 12KB and are sent base64
273
     * encoded, giving a 12KB * (4/3) = 16KB FMTP line. */
274
    char value[16384];
275
    int i;
276
    RTSPStream *rtsp_st = st->priv_data;
277
    AVCodecContext *codec = st->codec;
278
    RTPPayloadData *rtp_payload_data = &rtsp_st->rtp_payload_data;
279

    
280
    /* loop on each attribute */
281
    while (ff_rtsp_next_attr_and_value(&p, attr, sizeof(attr),
282
                                       value, sizeof(value))) {
283
        /* grab the codec extra_data from the config parameter of the fmtp
284
         * line */
285
        sdp_parse_fmtp_config(codec, rtsp_st->dynamic_protocol_context,
286
                              attr, value);
287
        /* Looking for a known attribute */
288
        for (i = 0; attr_names[i].str; ++i) {
289
            if (!strcasecmp(attr, attr_names[i].str)) {
290
                if (attr_names[i].type == ATTR_NAME_TYPE_INT) {
291
                    *(int *)((char *)rtp_payload_data +
292
                        attr_names[i].offset) = atoi(value);
293
                } else if (attr_names[i].type == ATTR_NAME_TYPE_STR)
294
                    *(char **)((char *)rtp_payload_data +
295
                        attr_names[i].offset) = av_strdup(value);
296
            }
297
        }
298
    }
299
}
300

    
301
/** Parse a string p in the form of Range:npt=xx-xx, and determine the start
302
 *  and end time.
303
 *  Used for seeking in the rtp stream.
304
 */
305
static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
306
{
307
    char buf[256];
308

    
309
    skip_spaces(&p);
310
    if (!av_stristart(p, "npt=", &p))
311
        return;
312

    
313
    *start = AV_NOPTS_VALUE;
314
    *end = AV_NOPTS_VALUE;
315

    
316
    get_word_sep(buf, sizeof(buf), "-", &p);
317
    *start = parse_date(buf, 1);
318
    if (*p == '-') {
319
        p++;
320
        get_word_sep(buf, sizeof(buf), "-", &p);
321
        *end = parse_date(buf, 1);
322
    }
323
//    av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
324
//    av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
325
}
326

    
327
typedef struct SDPParseState {
328
    /* SDP only */
329
    struct in_addr default_ip;
330
    int            default_ttl;
331
    int            skip_media;  ///< set if an unknown m= line occurs
332
} SDPParseState;
333

    
334
static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
335
                           int letter, const char *buf)
336
{
337
    RTSPState *rt = s->priv_data;
338
    char buf1[64], st_type[64];
339
    const char *p;
340
    enum CodecType codec_type;
341
    int payload_type, i;
342
    AVStream *st;
343
    RTSPStream *rtsp_st;
344
    struct in_addr sdp_ip;
345
    int ttl;
346

    
347
    dprintf(s, "sdp: %c='%s'\n", letter, buf);
348

    
349
    p = buf;
350
    if (s1->skip_media && letter != 'm')
351
        return;
352
    switch (letter) {
353
    case 'c':
354
        get_word(buf1, sizeof(buf1), &p);
355
        if (strcmp(buf1, "IN") != 0)
356
            return;
357
        get_word(buf1, sizeof(buf1), &p);
358
        if (strcmp(buf1, "IP4") != 0)
359
            return;
360
        get_word_sep(buf1, sizeof(buf1), "/", &p);
361
        if (ff_inet_aton(buf1, &sdp_ip) == 0)
362
            return;
363
        ttl = 16;
364
        if (*p == '/') {
365
            p++;
366
            get_word_sep(buf1, sizeof(buf1), "/", &p);
367
            ttl = atoi(buf1);
368
        }
369
        if (s->nb_streams == 0) {
370
            s1->default_ip = sdp_ip;
371
            s1->default_ttl = ttl;
372
        } else {
373
            st = s->streams[s->nb_streams - 1];
374
            rtsp_st = st->priv_data;
375
            rtsp_st->sdp_ip = sdp_ip;
376
            rtsp_st->sdp_ttl = ttl;
377
        }
378
        break;
379
    case 's':
380
        av_metadata_set(&s->metadata, "title", p);
381
        break;
382
    case 'i':
383
        if (s->nb_streams == 0) {
384
            av_metadata_set(&s->metadata, "comment", p);
385
            break;
386
        }
387
        break;
388
    case 'm':
389
        /* new stream */
390
        s1->skip_media = 0;
391
        get_word(st_type, sizeof(st_type), &p);
392
        if (!strcmp(st_type, "audio")) {
393
            codec_type = CODEC_TYPE_AUDIO;
394
        } else if (!strcmp(st_type, "video")) {
395
            codec_type = CODEC_TYPE_VIDEO;
396
        } else if (!strcmp(st_type, "application")) {
397
            codec_type = CODEC_TYPE_DATA;
398
        } else {
399
            s1->skip_media = 1;
400
            return;
401
        }
402
        rtsp_st = av_mallocz(sizeof(RTSPStream));
403
        if (!rtsp_st)
404
            return;
405
        rtsp_st->stream_index = -1;
406
        dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
407

    
408
        rtsp_st->sdp_ip = s1->default_ip;
409
        rtsp_st->sdp_ttl = s1->default_ttl;
410

    
411
        get_word(buf1, sizeof(buf1), &p); /* port */
412
        rtsp_st->sdp_port = atoi(buf1);
413

    
414
        get_word(buf1, sizeof(buf1), &p); /* protocol (ignored) */
415

    
416
        /* XXX: handle list of formats */
417
        get_word(buf1, sizeof(buf1), &p); /* format list */
418
        rtsp_st->sdp_payload_type = atoi(buf1);
419

    
420
        if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
421
            /* no corresponding stream */
422
        } else {
423
            st = av_new_stream(s, 0);
424
            if (!st)
425
                return;
426
            st->priv_data = rtsp_st;
427
            rtsp_st->stream_index = st->index;
428
            st->codec->codec_type = codec_type;
429
            if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
430
                /* if standard payload type, we can find the codec right now */
431
                ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
432
            }
433
        }
434
        /* put a default control url */
435
        av_strlcpy(rtsp_st->control_url, rt->control_uri,
436
                   sizeof(rtsp_st->control_url));
437
        break;
438
    case 'a':
439
        if (av_strstart(p, "control:", &p)) {
440
            if (s->nb_streams == 0) {
441
                if (!strncmp(p, "rtsp://", 7))
442
                    av_strlcpy(rt->control_uri, p,
443
                               sizeof(rt->control_uri));
444
            } else {
445
            char proto[32];
446
            /* get the control url */
447
            st = s->streams[s->nb_streams - 1];
448
            rtsp_st = st->priv_data;
449

    
450
            /* XXX: may need to add full url resolution */
451
            ff_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
452
                         NULL, NULL, 0, p);
453
            if (proto[0] == '\0') {
454
                /* relative control URL */
455
                if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
456
                av_strlcat(rtsp_st->control_url, "/",
457
                           sizeof(rtsp_st->control_url));
458
                av_strlcat(rtsp_st->control_url, p,
459
                           sizeof(rtsp_st->control_url));
460
            } else
461
                av_strlcpy(rtsp_st->control_url, p,
462
                           sizeof(rtsp_st->control_url));
463
            }
464
        } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
465
            /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
466
            get_word(buf1, sizeof(buf1), &p);
467
            payload_type = atoi(buf1);
468
            st = s->streams[s->nb_streams - 1];
469
            rtsp_st = st->priv_data;
470
            sdp_parse_rtpmap(s, st->codec, rtsp_st, payload_type, p);
471
        } else if (av_strstart(p, "fmtp:", &p)) {
472
            /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
473
            get_word(buf1, sizeof(buf1), &p);
474
            payload_type = atoi(buf1);
475
            for (i = 0; i < s->nb_streams; i++) {
476
                st      = s->streams[i];
477
                rtsp_st = st->priv_data;
478
                if (rtsp_st->sdp_payload_type == payload_type) {
479
                    if (!(rtsp_st->dynamic_handler &&
480
                          rtsp_st->dynamic_handler->parse_sdp_a_line &&
481
                          rtsp_st->dynamic_handler->parse_sdp_a_line(s,
482
                              i, rtsp_st->dynamic_protocol_context, buf)))
483
                        sdp_parse_fmtp(st, p);
484
                }
485
            }
486
        } else if (av_strstart(p, "framesize:", &p)) {
487
            // let dynamic protocol handlers have a stab at the line.
488
            get_word(buf1, sizeof(buf1), &p);
489
            payload_type = atoi(buf1);
490
            for (i = 0; i < s->nb_streams; i++) {
491
                st      = s->streams[i];
492
                rtsp_st = st->priv_data;
493
                if (rtsp_st->sdp_payload_type == payload_type &&
494
                    rtsp_st->dynamic_handler &&
495
                    rtsp_st->dynamic_handler->parse_sdp_a_line)
496
                    rtsp_st->dynamic_handler->parse_sdp_a_line(s, i,
497
                        rtsp_st->dynamic_protocol_context, buf);
498
            }
499
        } else if (av_strstart(p, "range:", &p)) {
500
            int64_t start, end;
501

    
502
            // this is so that seeking on a streamed file can work.
503
            rtsp_parse_range_npt(p, &start, &end);
504
            s->start_time = start;
505
            /* AV_NOPTS_VALUE means live broadcast (and can't seek) */
506
            s->duration   = (end == AV_NOPTS_VALUE) ?
507
                            AV_NOPTS_VALUE : end - start;
508
        } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
509
            if (atoi(p) == 1)
510
                rt->transport = RTSP_TRANSPORT_RDT;
511
        } else {
512
            if (rt->server_type == RTSP_SERVER_WMS)
513
                ff_wms_parse_sdp_a_line(s, p);
514
            if (s->nb_streams > 0) {
515
                if (rt->server_type == RTSP_SERVER_REAL)
516
                    ff_real_parse_sdp_a_line(s, s->nb_streams - 1, p);
517

    
518
                rtsp_st = s->streams[s->nb_streams - 1]->priv_data;
519
                if (rtsp_st->dynamic_handler &&
520
                    rtsp_st->dynamic_handler->parse_sdp_a_line)
521
                    rtsp_st->dynamic_handler->parse_sdp_a_line(s,
522
                        s->nb_streams - 1,
523
                        rtsp_st->dynamic_protocol_context, buf);
524
            }
525
        }
526
        break;
527
    }
528
}
529

    
530
static int sdp_parse(AVFormatContext *s, const char *content)
531
{
532
    const char *p;
533
    int letter;
534
    /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
535
     * contain long SDP lines containing complete ASF Headers (several
536
     * kB) or arrays of MDPR (RM stream descriptor) headers plus
537
     * "rulebooks" describing their properties. Therefore, the SDP line
538
     * buffer is large.
539
     *
540
     * The Vorbis FMTP line can be up to 16KB - see sdp_parse_fmtp. */
541
    char buf[16384], *q;
542
    SDPParseState sdp_parse_state, *s1 = &sdp_parse_state;
543

    
544
    memset(s1, 0, sizeof(SDPParseState));
545
    p = content;
546
    for (;;) {
547
        skip_spaces(&p);
548
        letter = *p;
549
        if (letter == '\0')
550
            break;
551
        p++;
552
        if (*p != '=')
553
            goto next_line;
554
        p++;
555
        /* get the content */
556
        q = buf;
557
        while (*p != '\n' && *p != '\r' && *p != '\0') {
558
            if ((q - buf) < sizeof(buf) - 1)
559
                *q++ = *p;
560
            p++;
561
        }
562
        *q = '\0';
563
        sdp_parse_line(s, s1, letter, buf);
564
    next_line:
565
        while (*p != '\n' && *p != '\0')
566
            p++;
567
        if (*p == '\n')
568
            p++;
569
    }
570
    return 0;
571
}
572

    
573
/* close and free RTSP streams */
574
void ff_rtsp_close_streams(AVFormatContext *s)
575
{
576
    RTSPState *rt = s->priv_data;
577
    int i;
578
    RTSPStream *rtsp_st;
579

    
580
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
581
        rtsp_st = rt->rtsp_streams[i];
582
        if (rtsp_st) {
583
            if (rtsp_st->transport_priv) {
584
                if (s->oformat) {
585
                    AVFormatContext *rtpctx = rtsp_st->transport_priv;
586
                    av_write_trailer(rtpctx);
587
                    if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
588
                        uint8_t *ptr;
589
                        url_close_dyn_buf(rtpctx->pb, &ptr);
590
                        av_free(ptr);
591
                    } else {
592
                    url_fclose(rtpctx->pb);
593
                    }
594
                    av_metadata_free(&rtpctx->streams[0]->metadata);
595
                    av_metadata_free(&rtpctx->metadata);
596
                    av_free(rtpctx->streams[0]);
597
                    av_free(rtpctx);
598
                } else if (rt->transport == RTSP_TRANSPORT_RDT)
599
                    ff_rdt_parse_close(rtsp_st->transport_priv);
600
                else
601
                    rtp_parse_close(rtsp_st->transport_priv);
602
            }
603
            if (rtsp_st->rtp_handle)
604
                url_close(rtsp_st->rtp_handle);
605
            if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
606
                rtsp_st->dynamic_handler->close(
607
                    rtsp_st->dynamic_protocol_context);
608
        }
609
    }
610
    av_free(rt->rtsp_streams);
611
    if (rt->asf_ctx) {
612
        av_close_input_stream (rt->asf_ctx);
613
        rt->asf_ctx = NULL;
614
    }
615
    av_freep(&rt->auth_b64);
616
}
617

    
618
static void *rtsp_rtp_mux_open(AVFormatContext *s, AVStream *st,
619
                               URLContext *handle)
620
{
621
    RTSPState *rt = s->priv_data;
622
    AVFormatContext *rtpctx;
623
    int ret;
624
    AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
625

    
626
    if (!rtp_format)
627
        return NULL;
628

    
629
    /* Allocate an AVFormatContext for each output stream */
630
    rtpctx = avformat_alloc_context();
631
    if (!rtpctx)
632
        return NULL;
633

    
634
    rtpctx->oformat = rtp_format;
635
    if (!av_new_stream(rtpctx, 0)) {
636
        av_free(rtpctx);
637
        return NULL;
638
    }
639
    /* Copy the max delay setting; the rtp muxer reads this. */
640
    rtpctx->max_delay = s->max_delay;
641
    /* Copy other stream parameters. */
642
    rtpctx->streams[0]->sample_aspect_ratio = st->sample_aspect_ratio;
643

    
644
    /* Set the synchronized start time. */
645
    rtpctx->start_time_realtime = rt->start_time;
646

    
647
    /* Remove the local codec, link to the original codec
648
     * context instead, to give the rtp muxer access to
649
     * codec parameters. */
650
    av_free(rtpctx->streams[0]->codec);
651
    rtpctx->streams[0]->codec = st->codec;
652

    
653
    if (handle) {
654
    url_fdopen(&rtpctx->pb, handle);
655
    } else
656
        url_open_dyn_packet_buf(&rtpctx->pb, RTSP_TCP_MAX_PACKET_SIZE);
657
    ret = av_write_header(rtpctx);
658

    
659
    if (ret) {
660
        if (handle) {
661
        url_fclose(rtpctx->pb);
662
        } else {
663
            uint8_t *ptr;
664
            url_close_dyn_buf(rtpctx->pb, &ptr);
665
            av_free(ptr);
666
        }
667
        av_free(rtpctx->streams[0]);
668
        av_free(rtpctx);
669
        return NULL;
670
    }
671

    
672
    /* Copy the RTP AVStream timebase back to the original AVStream */
673
    st->time_base = rtpctx->streams[0]->time_base;
674
    return rtpctx;
675
}
676

    
677
static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
678
{
679
    RTSPState *rt = s->priv_data;
680
    AVStream *st = NULL;
681

    
682
    /* open the RTP context */
683
    if (rtsp_st->stream_index >= 0)
684
        st = s->streams[rtsp_st->stream_index];
685
    if (!st)
686
        s->ctx_flags |= AVFMTCTX_NOHEADER;
687

    
688
    if (s->oformat) {
689
        rtsp_st->transport_priv = rtsp_rtp_mux_open(s, st, rtsp_st->rtp_handle);
690
        /* Ownage of rtp_handle is passed to the rtp mux context */
691
        rtsp_st->rtp_handle = NULL;
692
    } else if (rt->transport == RTSP_TRANSPORT_RDT)
693
        rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
694
                                            rtsp_st->dynamic_protocol_context,
695
                                            rtsp_st->dynamic_handler);
696
    else
697
        rtsp_st->transport_priv = rtp_parse_open(s, st, rtsp_st->rtp_handle,
698
                                         rtsp_st->sdp_payload_type,
699
                                         &rtsp_st->rtp_payload_data);
700

    
701
    if (!rtsp_st->transport_priv) {
702
         return AVERROR(ENOMEM);
703
    } else if (rt->transport != RTSP_TRANSPORT_RDT) {
704
        if (rtsp_st->dynamic_handler) {
705
            rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
706
                                           rtsp_st->dynamic_protocol_context,
707
                                           rtsp_st->dynamic_handler);
708
        }
709
    }
710

    
711
    return 0;
712
}
713

    
714
#if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
715
static int rtsp_probe(AVProbeData *p)
716
{
717
    if (av_strstart(p->filename, "rtsp:", NULL))
718
        return AVPROBE_SCORE_MAX;
719
    return 0;
720
}
721

    
722
static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
723
{
724
    const char *p;
725
    int v;
726

    
727
    p = *pp;
728
    skip_spaces(&p);
729
    v = strtol(p, (char **)&p, 10);
730
    if (*p == '-') {
731
        p++;
732
        *min_ptr = v;
733
        v = strtol(p, (char **)&p, 10);
734
        *max_ptr = v;
735
    } else {
736
        *min_ptr = v;
737
        *max_ptr = v;
738
    }
739
    *pp = p;
740
}
741

    
742
/* XXX: only one transport specification is parsed */
743
static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
744
{
745
    char transport_protocol[16];
746
    char profile[16];
747
    char lower_transport[16];
748
    char parameter[16];
749
    RTSPTransportField *th;
750
    char buf[256];
751

    
752
    reply->nb_transports = 0;
753

    
754
    for (;;) {
755
        skip_spaces(&p);
756
        if (*p == '\0')
757
            break;
758

    
759
        th = &reply->transports[reply->nb_transports];
760

    
761
        get_word_sep(transport_protocol, sizeof(transport_protocol),
762
                     "/", &p);
763
        if (!strcasecmp (transport_protocol, "rtp")) {
764
            get_word_sep(profile, sizeof(profile), "/;,", &p);
765
            lower_transport[0] = '\0';
766
            /* rtp/avp/<protocol> */
767
            if (*p == '/') {
768
                get_word_sep(lower_transport, sizeof(lower_transport),
769
                             ";,", &p);
770
            }
771
            th->transport = RTSP_TRANSPORT_RTP;
772
        } else if (!strcasecmp (transport_protocol, "x-pn-tng") ||
773
                   !strcasecmp (transport_protocol, "x-real-rdt")) {
774
            /* x-pn-tng/<protocol> */
775
            get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
776
            profile[0] = '\0';
777
            th->transport = RTSP_TRANSPORT_RDT;
778
        }
779
        if (!strcasecmp(lower_transport, "TCP"))
780
            th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
781
        else
782
            th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
783

    
784
        if (*p == ';')
785
            p++;
786
        /* get each parameter */
787
        while (*p != '\0' && *p != ',') {
788
            get_word_sep(parameter, sizeof(parameter), "=;,", &p);
789
            if (!strcmp(parameter, "port")) {
790
                if (*p == '=') {
791
                    p++;
792
                    rtsp_parse_range(&th->port_min, &th->port_max, &p);
793
                }
794
            } else if (!strcmp(parameter, "client_port")) {
795
                if (*p == '=') {
796
                    p++;
797
                    rtsp_parse_range(&th->client_port_min,
798
                                     &th->client_port_max, &p);
799
                }
800
            } else if (!strcmp(parameter, "server_port")) {
801
                if (*p == '=') {
802
                    p++;
803
                    rtsp_parse_range(&th->server_port_min,
804
                                     &th->server_port_max, &p);
805
                }
806
            } else if (!strcmp(parameter, "interleaved")) {
807
                if (*p == '=') {
808
                    p++;
809
                    rtsp_parse_range(&th->interleaved_min,
810
                                     &th->interleaved_max, &p);
811
                }
812
            } else if (!strcmp(parameter, "multicast")) {
813
                if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
814
                    th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
815
            } else if (!strcmp(parameter, "ttl")) {
816
                if (*p == '=') {
817
                    p++;
818
                    th->ttl = strtol(p, (char **)&p, 10);
819
                }
820
            } else if (!strcmp(parameter, "destination")) {
821
                struct in_addr ipaddr;
822

    
823
                if (*p == '=') {
824
                    p++;
825
                    get_word_sep(buf, sizeof(buf), ";,", &p);
826
                    if (ff_inet_aton(buf, &ipaddr))
827
                        th->destination = ntohl(ipaddr.s_addr);
828
                }
829
            }
830
            while (*p != ';' && *p != '\0' && *p != ',')
831
                p++;
832
            if (*p == ';')
833
                p++;
834
        }
835
        if (*p == ',')
836
            p++;
837

    
838
        reply->nb_transports++;
839
    }
840
}
841

    
842
void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf)
843
{
844
    const char *p;
845

    
846
    /* NOTE: we do case independent match for broken servers */
847
    p = buf;
848
    if (av_stristart(p, "Session:", &p)) {
849
        int t;
850
        get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
851
        if (av_stristart(p, ";timeout=", &p) &&
852
            (t = strtol(p, NULL, 10)) > 0) {
853
            reply->timeout = t;
854
        }
855
    } else if (av_stristart(p, "Content-Length:", &p)) {
856
        reply->content_length = strtol(p, NULL, 10);
857
    } else if (av_stristart(p, "Transport:", &p)) {
858
        rtsp_parse_transport(reply, p);
859
    } else if (av_stristart(p, "CSeq:", &p)) {
860
        reply->seq = strtol(p, NULL, 10);
861
    } else if (av_stristart(p, "Range:", &p)) {
862
        rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
863
    } else if (av_stristart(p, "RealChallenge1:", &p)) {
864
        skip_spaces(&p);
865
        av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
866
    } else if (av_stristart(p, "Server:", &p)) {
867
        skip_spaces(&p);
868
        av_strlcpy(reply->server, p, sizeof(reply->server));
869
    } else if (av_stristart(p, "Notice:", &p) ||
870
               av_stristart(p, "X-Notice:", &p)) {
871
        reply->notice = strtol(p, NULL, 10);
872
    } else if (av_stristart(p, "Location:", &p)) {
873
        skip_spaces(&p);
874
        av_strlcpy(reply->location, p , sizeof(reply->location));
875
    }
876
}
877

    
878
/* skip a RTP/TCP interleaved packet */
879
void ff_rtsp_skip_packet(AVFormatContext *s)
880
{
881
    RTSPState *rt = s->priv_data;
882
    int ret, len, len1;
883
    uint8_t buf[1024];
884

    
885
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
886
    if (ret != 3)
887
        return;
888
    len = AV_RB16(buf + 1);
889

    
890
    dprintf(s, "skipping RTP packet len=%d\n", len);
891

    
892
    /* skip payload */
893
    while (len > 0) {
894
        len1 = len;
895
        if (len1 > sizeof(buf))
896
            len1 = sizeof(buf);
897
        ret = url_read_complete(rt->rtsp_hd, buf, len1);
898
        if (ret != len1)
899
            return;
900
        len -= len1;
901
    }
902
}
903

    
904
int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
905
                       unsigned char **content_ptr,
906
                       int return_on_interleaved_data)
907
{
908
    RTSPState *rt = s->priv_data;
909
    char buf[4096], buf1[1024], *q;
910
    unsigned char ch;
911
    const char *p;
912
    int ret, content_length, line_count = 0;
913
    unsigned char *content = NULL;
914

    
915
    memset(reply, 0, sizeof(*reply));
916

    
917
    /* parse reply (XXX: use buffers) */
918
    rt->last_reply[0] = '\0';
919
    for (;;) {
920
        q = buf;
921
        for (;;) {
922
            ret = url_read_complete(rt->rtsp_hd, &ch, 1);
923
#ifdef DEBUG_RTP_TCP
924
            dprintf(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
925
#endif
926
            if (ret != 1)
927
                return -1;
928
            if (ch == '\n')
929
                break;
930
            if (ch == '$') {
931
                /* XXX: only parse it if first char on line ? */
932
                if (return_on_interleaved_data) {
933
                    return 1;
934
                } else
935
                    ff_rtsp_skip_packet(s);
936
            } else if (ch != '\r') {
937
                if ((q - buf) < sizeof(buf) - 1)
938
                    *q++ = ch;
939
            }
940
        }
941
        *q = '\0';
942

    
943
        dprintf(s, "line='%s'\n", buf);
944

    
945
        /* test if last line */
946
        if (buf[0] == '\0')
947
            break;
948
        p = buf;
949
        if (line_count == 0) {
950
            /* get reply code */
951
            get_word(buf1, sizeof(buf1), &p);
952
            get_word(buf1, sizeof(buf1), &p);
953
            reply->status_code = atoi(buf1);
954
        } else {
955
            ff_rtsp_parse_line(reply, p);
956
            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
957
            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
958
        }
959
        line_count++;
960
    }
961

    
962
    if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
963
        av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
964

    
965
    content_length = reply->content_length;
966
    if (content_length > 0) {
967
        /* leave some room for a trailing '\0' (useful for simple parsing) */
968
        content = av_malloc(content_length + 1);
969
        (void)url_read_complete(rt->rtsp_hd, content, content_length);
970
        content[content_length] = '\0';
971
    }
972
    if (content_ptr)
973
        *content_ptr = content;
974
    else
975
        av_free(content);
976

    
977
    /* EOS */
978
    if (reply->notice == 2101 /* End-of-Stream Reached */      ||
979
        reply->notice == 2104 /* Start-of-Stream Reached */    ||
980
        reply->notice == 2306 /* Continuous Feed Terminated */) {
981
        rt->state = RTSP_STATE_IDLE;
982
    } else if (reply->notice >= 4400 && reply->notice < 5500) {
983
        return AVERROR(EIO); /* data or server error */
984
    } else if (reply->notice == 2401 /* Ticket Expired */ ||
985
             (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
986
        return AVERROR(EPERM);
987

    
988
    return 0;
989
}
990

    
991
void ff_rtsp_send_cmd_with_content_async(AVFormatContext *s,
992
                                         const char *cmd,
993
                                         const unsigned char *send_content,
994
                                         int send_content_length)
995
{
996
    RTSPState *rt = s->priv_data;
997
    char buf[4096], buf1[1024];
998

    
999
    rt->seq++;
1000
    av_strlcpy(buf, cmd, sizeof(buf));
1001
    snprintf(buf1, sizeof(buf1), "CSeq: %d\r\n", rt->seq);
1002
    av_strlcat(buf, buf1, sizeof(buf));
1003
    if (rt->session_id[0] != '\0' && !strstr(cmd, "\nIf-Match:")) {
1004
        snprintf(buf1, sizeof(buf1), "Session: %s\r\n", rt->session_id);
1005
        av_strlcat(buf, buf1, sizeof(buf));
1006
    }
1007
    if (rt->auth_b64)
1008
        av_strlcatf(buf, sizeof(buf),
1009
                    "Authorization: Basic %s\r\n",
1010
                    rt->auth_b64);
1011
    if (send_content_length > 0 && send_content)
1012
        av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
1013
    av_strlcat(buf, "\r\n", sizeof(buf));
1014

    
1015
    dprintf(s, "Sending:\n%s--\n", buf);
1016

    
1017
    url_write(rt->rtsp_hd, buf, strlen(buf));
1018
    if (send_content_length > 0 && send_content)
1019
        url_write(rt->rtsp_hd, send_content, send_content_length);
1020
    rt->last_cmd_time = av_gettime();
1021
}
1022

    
1023
void ff_rtsp_send_cmd_async(AVFormatContext *s, const char *cmd)
1024
{
1025
    ff_rtsp_send_cmd_with_content_async(s, cmd, NULL, 0);
1026
}
1027

    
1028
void ff_rtsp_send_cmd(AVFormatContext *s,
1029
                      const char *cmd, RTSPMessageHeader *reply,
1030
                      unsigned char **content_ptr)
1031
{
1032
    ff_rtsp_send_cmd_async(s, cmd);
1033

    
1034
    ff_rtsp_read_reply(s, reply, content_ptr, 0);
1035
}
1036

    
1037
void ff_rtsp_send_cmd_with_content(AVFormatContext *s,
1038
                                const char *cmd,
1039
                                RTSPMessageHeader *reply,
1040
                                unsigned char **content_ptr,
1041
                                const unsigned char *send_content,
1042
                                int send_content_length)
1043
{
1044
    ff_rtsp_send_cmd_with_content_async(s, cmd, send_content, send_content_length);
1045

    
1046
    ff_rtsp_read_reply(s, reply, content_ptr, 0);
1047
}
1048

    
1049
/**
1050
 * @returns 0 on success, <0 on error, 1 if protocol is unavailable.
1051
 */
1052
static int 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
#endif
1129

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

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

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

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

    
1207
        /* close RTP connection if not choosen */
1208
        if (reply->transports[0].lower_transport != RTSP_LOWER_TRANSPORT_UDP &&
1209
            (lower_transport == RTSP_LOWER_TRANSPORT_UDP)) {
1210
            url_close(rtsp_st->rtp_handle);
1211
            rtsp_st->rtp_handle = NULL;
1212
        }
1213

    
1214
        switch(reply->transports[0].lower_transport) {
1215
        case RTSP_LOWER_TRANSPORT_TCP:
1216
            rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1217
            rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1218
            break;
1219

    
1220
        case RTSP_LOWER_TRANSPORT_UDP: {
1221
            char url[1024];
1222

    
1223
            /* XXX: also use address if specified */
1224
            ff_url_join(url, sizeof(url), "rtp", NULL, host,
1225
                        reply->transports[0].server_port_min, NULL);
1226
            if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1227
                rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1228
                err = AVERROR_INVALIDDATA;
1229
                goto fail;
1230
            }
1231
            /* Try to initialize the connection state in a
1232
             * potential NAT router by sending dummy packets.
1233
             * RTP/RTCP dummy packets are used for RDT, too.
1234
             */
1235
            if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat)
1236
                rtp_send_punch_packets(rtsp_st->rtp_handle);
1237
            break;
1238
        }
1239
        case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1240
            char url[1024];
1241
            struct in_addr in;
1242
            int port, ttl;
1243

    
1244
            if (reply->transports[0].destination) {
1245
                in.s_addr = htonl(reply->transports[0].destination);
1246
                port      = reply->transports[0].port_min;
1247
                ttl       = reply->transports[0].ttl;
1248
            } else {
1249
                in        = rtsp_st->sdp_ip;
1250
                port      = rtsp_st->sdp_port;
1251
                ttl       = rtsp_st->sdp_ttl;
1252
            }
1253
            ff_url_join(url, sizeof(url), "rtp", NULL, inet_ntoa(in),
1254
                        port, "?ttl=%d", ttl);
1255
            if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1256
                err = AVERROR_INVALIDDATA;
1257
                goto fail;
1258
            }
1259
            break;
1260
        }
1261
        }
1262

    
1263
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1264
            goto fail;
1265
    }
1266

    
1267
    if (reply->timeout > 0)
1268
        rt->timeout = reply->timeout;
1269

    
1270
    if (rt->server_type == RTSP_SERVER_REAL)
1271
        rt->need_subscription = 1;
1272

    
1273
    return 0;
1274

    
1275
fail:
1276
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1277
        if (rt->rtsp_streams[i]->rtp_handle) {
1278
            url_close(rt->rtsp_streams[i]->rtp_handle);
1279
            rt->rtsp_streams[i]->rtp_handle = NULL;
1280
        }
1281
    }
1282
    return err;
1283
}
1284

    
1285
static int rtsp_read_play(AVFormatContext *s)
1286
{
1287
    RTSPState *rt = s->priv_data;
1288
    RTSPMessageHeader reply1, *reply = &reply1;
1289
    char cmd[1024];
1290

    
1291
    av_log(s, AV_LOG_DEBUG, "hello state=%d\n", rt->state);
1292

    
1293
    if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1294
        if (rt->state == RTSP_STATE_PAUSED) {
1295
            snprintf(cmd, sizeof(cmd),
1296
                     "PLAY %s RTSP/1.0\r\n",
1297
                     rt->control_uri);
1298
        } else {
1299
            snprintf(cmd, sizeof(cmd),
1300
                     "PLAY %s RTSP/1.0\r\n"
1301
                     "Range: npt=%0.3f-\r\n",
1302
                     rt->control_uri,
1303
                     (double)rt->seek_timestamp / AV_TIME_BASE);
1304
        }
1305
        ff_rtsp_send_cmd(s, cmd, reply, NULL);
1306
        if (reply->status_code != RTSP_STATUS_OK) {
1307
            return -1;
1308
        }
1309
    }
1310
    rt->state = RTSP_STATE_STREAMING;
1311
    return 0;
1312
}
1313

    
1314
static int rtsp_setup_input_streams(AVFormatContext *s, RTSPMessageHeader *reply)
1315
{
1316
    RTSPState *rt = s->priv_data;
1317
    char cmd[1024];
1318
    unsigned char *content = NULL;
1319
    int ret;
1320

    
1321
    /* describe the stream */
1322
    snprintf(cmd, sizeof(cmd),
1323
             "DESCRIBE %s RTSP/1.0\r\n"
1324
             "Accept: application/sdp\r\n",
1325
             rt->control_uri);
1326
    if (rt->server_type == RTSP_SERVER_REAL) {
1327
        /**
1328
         * The Require: attribute is needed for proper streaming from
1329
         * Realmedia servers.
1330
         */
1331
        av_strlcat(cmd,
1332
                   "Require: com.real.retain-entity-for-setup\r\n",
1333
                   sizeof(cmd));
1334
    }
1335
    ff_rtsp_send_cmd(s, cmd, reply, &content);
1336
    if (!content)
1337
        return AVERROR_INVALIDDATA;
1338
    if (reply->status_code != RTSP_STATUS_OK) {
1339
        av_freep(&content);
1340
        return AVERROR_INVALIDDATA;
1341
    }
1342

    
1343
    /* now we got the SDP description, we parse it */
1344
    ret = sdp_parse(s, (const char *)content);
1345
    av_freep(&content);
1346
    if (ret < 0)
1347
        return AVERROR_INVALIDDATA;
1348

    
1349
    return 0;
1350
}
1351

    
1352
static int rtsp_setup_output_streams(AVFormatContext *s, const char *addr)
1353
{
1354
    RTSPState *rt = s->priv_data;
1355
    RTSPMessageHeader reply1, *reply = &reply1;
1356
    char cmd[1024];
1357
    int i;
1358
    char *sdp;
1359
    AVFormatContext sdp_ctx, *ctx_array[1];
1360

    
1361
    rt->start_time = av_gettime();
1362

    
1363
    /* Announce the stream */
1364
    snprintf(cmd, sizeof(cmd),
1365
             "ANNOUNCE %s RTSP/1.0\r\n"
1366
             "Content-Type: application/sdp\r\n",
1367
             rt->control_uri);
1368
    sdp = av_mallocz(8192);
1369
    if (sdp == NULL)
1370
        return AVERROR(ENOMEM);
1371
    /* We create the SDP based on the RTSP AVFormatContext where we
1372
     * aren't allowed to change the filename field. (We create the SDP
1373
     * based on the RTSP context since the contexts for the RTP streams
1374
     * don't exist yet.) In order to specify a custom URL with the actual
1375
     * peer IP instead of the originally specified hostname, we create
1376
     * a temporary copy of the AVFormatContext, where the custom URL is set.
1377
     *
1378
     * FIXME: Create the SDP without copying the AVFormatContext.
1379
     * This either requires setting up the RTP stream AVFormatContexts
1380
     * already here (complicating things immensely) or getting a more
1381
     * flexible SDP creation interface.
1382
     */
1383
    sdp_ctx = *s;
1384
    ff_url_join(sdp_ctx.filename, sizeof(sdp_ctx.filename),
1385
                "rtsp", NULL, addr, -1, NULL);
1386
    ctx_array[0] = &sdp_ctx;
1387
    if (avf_sdp_create(ctx_array, 1, sdp, 8192)) {
1388
        av_free(sdp);
1389
        return AVERROR_INVALIDDATA;
1390
    }
1391
    av_log(s, AV_LOG_INFO, "SDP:\n%s\n", sdp);
1392
    ff_rtsp_send_cmd_with_content(s, cmd, reply, NULL, sdp, strlen(sdp));
1393
    av_free(sdp);
1394
    if (reply->status_code != RTSP_STATUS_OK)
1395
        return AVERROR_INVALIDDATA;
1396

    
1397
    /* Set up the RTSPStreams for each AVStream */
1398
    for (i = 0; i < s->nb_streams; i++) {
1399
        RTSPStream *rtsp_st;
1400
        AVStream *st = s->streams[i];
1401

    
1402
        rtsp_st = av_mallocz(sizeof(RTSPStream));
1403
        if (!rtsp_st)
1404
            return AVERROR(ENOMEM);
1405
        dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
1406

    
1407
        st->priv_data = rtsp_st;
1408
        rtsp_st->stream_index = i;
1409

    
1410
        av_strlcpy(rtsp_st->control_url, rt->control_uri, sizeof(rtsp_st->control_url));
1411
        /* Note, this must match the relative uri set in the sdp content */
1412
        av_strlcatf(rtsp_st->control_url, sizeof(rtsp_st->control_url),
1413
                    "/streamid=%d", i);
1414
    }
1415

    
1416
    return 0;
1417
}
1418

    
1419
int ff_rtsp_connect(AVFormatContext *s)
1420
{
1421
    RTSPState *rt = s->priv_data;
1422
    char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1423
    char *option_list, *option, *filename;
1424
    URLContext *rtsp_hd;
1425
    int port, err, tcp_fd;
1426
    RTSPMessageHeader reply1, *reply = &reply1;
1427
    int lower_transport_mask = 0;
1428
    char real_challenge[64];
1429
    struct sockaddr_storage peer;
1430
    socklen_t peer_len = sizeof(peer);
1431

    
1432
    if (!ff_network_init())
1433
        return AVERROR(EIO);
1434
redirect:
1435
    /* extract hostname and port */
1436
    ff_url_split(NULL, 0, auth, sizeof(auth),
1437
                 host, sizeof(host), &port, path, sizeof(path), s->filename);
1438
    if (*auth) {
1439
        int auth_len = strlen(auth), b64_len = ((auth_len + 2) / 3) * 4 + 1;
1440

    
1441
        if (!(rt->auth_b64 = av_malloc(b64_len)))
1442
            return AVERROR(ENOMEM);
1443
        if (!av_base64_encode(rt->auth_b64, b64_len, auth, auth_len)) {
1444
            err = AVERROR(EINVAL);
1445
            goto fail;
1446
        }
1447
    }
1448
    if (port < 0)
1449
        port = RTSP_DEFAULT_PORT;
1450

    
1451
    /* search for options */
1452
    option_list = strchr(path, '?');
1453
    if (option_list) {
1454
        filename = strchr(s->filename, '?');
1455
        while (option_list) {
1456
            /* move the option pointer */
1457
            option = ++option_list;
1458
            option_list = strchr(option_list, '&');
1459
            if (option_list)
1460
                *option_list = 0;
1461

    
1462
            /* handle the options */
1463
            if (!strcmp(option, "udp")) {
1464
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP);
1465
            } else if (!strcmp(option, "multicast")) {
1466
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
1467
            } else if (!strcmp(option, "tcp")) {
1468
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_TCP);
1469
            } else {
1470
                strcpy(++filename, option);
1471
                filename += strlen(option);
1472
                if (option_list) *filename = '&';
1473
            }
1474
        }
1475
        *filename = 0;
1476
    }
1477

    
1478
    if (!lower_transport_mask)
1479
        lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1480

    
1481
    if (s->oformat) {
1482
        /* Only UDP or TCP - UDP multicast isn't supported. */
1483
        lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
1484
                                (1 << RTSP_LOWER_TRANSPORT_TCP);
1485
        if (!lower_transport_mask) {
1486
            av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1487
                                    "only UDP and TCP are supported for output.\n");
1488
            err = AVERROR(EINVAL);
1489
            goto fail;
1490
        }
1491
    }
1492

    
1493
    /* open the tcp connexion */
1494
    ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port, NULL);
1495
    if (url_open(&rtsp_hd, tcpname, URL_RDWR) < 0) {
1496
        err = AVERROR(EIO);
1497
        goto fail;
1498
    }
1499
    rt->rtsp_hd = rtsp_hd;
1500
    rt->seq = 0;
1501

    
1502
    tcp_fd = url_get_file_handle(rtsp_hd);
1503
    if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1504
        getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1505
                    NULL, 0, NI_NUMERICHOST);
1506
    }
1507

    
1508
    /* request options supported by the server; this also detects server
1509
     * type */
1510
    av_strlcpy(rt->control_uri, s->filename,
1511
               sizeof(rt->control_uri));
1512
    for (rt->server_type = RTSP_SERVER_RTP;;) {
1513
        snprintf(cmd, sizeof(cmd),
1514
                 "OPTIONS %s RTSP/1.0\r\n", rt->control_uri);
1515
        if (rt->server_type == RTSP_SERVER_REAL)
1516
            av_strlcat(cmd,
1517
                       /**
1518
                        * The following entries are required for proper
1519
                        * streaming from a Realmedia server. They are
1520
                        * interdependent in some way although we currently
1521
                        * don't quite understand how. Values were copied
1522
                        * from mplayer SVN r23589.
1523
                        * @param CompanyID is a 16-byte ID in base64
1524
                        * @param ClientChallenge is a 16-byte ID in hex
1525
                        */
1526
                       "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1527
                       "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1528
                       "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1529
                       "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1530
                       sizeof(cmd));
1531
        ff_rtsp_send_cmd(s, cmd, reply, NULL);
1532
        if (reply->status_code != RTSP_STATUS_OK) {
1533
            err = AVERROR_INVALIDDATA;
1534
            goto fail;
1535
        }
1536

    
1537
        /* detect server type if not standard-compliant RTP */
1538
        if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1539
            rt->server_type = RTSP_SERVER_REAL;
1540
            continue;
1541
        } else if (!strncasecmp(reply->server, "WMServer/", 9)) {
1542
            rt->server_type = RTSP_SERVER_WMS;
1543
        } else if (rt->server_type == RTSP_SERVER_REAL)
1544
            strcpy(real_challenge, reply->real_challenge);
1545
        break;
1546
    }
1547

    
1548
    if (s->iformat)
1549
        err = rtsp_setup_input_streams(s, reply);
1550
    else
1551
        err = rtsp_setup_output_streams(s, host);
1552
    if (err)
1553
        goto fail;
1554

    
1555
    do {
1556
        int lower_transport = ff_log2_tab[lower_transport_mask &
1557
                                  ~(lower_transport_mask - 1)];
1558

    
1559
        err = make_setup_request(s, host, port, lower_transport,
1560
                                 rt->server_type == RTSP_SERVER_REAL ?
1561
                                     real_challenge : NULL);
1562
        if (err < 0)
1563
            goto fail;
1564
        lower_transport_mask &= ~(1 << lower_transport);
1565
        if (lower_transport_mask == 0 && err == 1) {
1566
            err = AVERROR(FF_NETERROR(EPROTONOSUPPORT));
1567
            goto fail;
1568
        }
1569
    } while (err);
1570

    
1571
    rt->state = RTSP_STATE_IDLE;
1572
    rt->seek_timestamp = 0; /* default is to start stream at position zero */
1573
    return 0;
1574
 fail:
1575
    ff_rtsp_close_streams(s);
1576
    url_close(rt->rtsp_hd);
1577
    if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1578
        av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1579
        av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1580
               reply->status_code,
1581
               s->filename);
1582
        goto redirect;
1583
    }
1584
    ff_network_close();
1585
    return err;
1586
}
1587
#endif
1588

    
1589
#if CONFIG_RTSP_DEMUXER
1590
static int rtsp_read_header(AVFormatContext *s,
1591
                            AVFormatParameters *ap)
1592
{
1593
    RTSPState *rt = s->priv_data;
1594
    int ret;
1595

    
1596
    ret = ff_rtsp_connect(s);
1597
    if (ret)
1598
        return ret;
1599

    
1600
    if (ap->initial_pause) {
1601
         /* do not start immediately */
1602
    } else {
1603
         if (rtsp_read_play(s) < 0) {
1604
            ff_rtsp_close_streams(s);
1605
            url_close(rt->rtsp_hd);
1606
            return AVERROR_INVALIDDATA;
1607
        }
1608
    }
1609

    
1610
    return 0;
1611
}
1612

    
1613
static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1614
                           uint8_t *buf, int buf_size)
1615
{
1616
    RTSPState *rt = s->priv_data;
1617
    RTSPStream *rtsp_st;
1618
    fd_set rfds;
1619
    int fd, fd_max, n, i, ret, tcp_fd;
1620
    struct timeval tv;
1621

    
1622
    for (;;) {
1623
        if (url_interrupt_cb())
1624
            return AVERROR(EINTR);
1625
        FD_ZERO(&rfds);
1626
        if (rt->rtsp_hd) {
1627
            tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd);
1628
            FD_SET(tcp_fd, &rfds);
1629
        } else {
1630
            fd_max = 0;
1631
            tcp_fd = -1;
1632
        }
1633
        for (i = 0; i < rt->nb_rtsp_streams; i++) {
1634
            rtsp_st = rt->rtsp_streams[i];
1635
            if (rtsp_st->rtp_handle) {
1636
                /* currently, we cannot probe RTCP handle because of
1637
                 * blocking restrictions */
1638
                fd = url_get_file_handle(rtsp_st->rtp_handle);
1639
                if (fd > fd_max)
1640
                    fd_max = fd;
1641
                FD_SET(fd, &rfds);
1642
            }
1643
        }
1644
        tv.tv_sec = 0;
1645
        tv.tv_usec = 100 * 1000;
1646
        n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
1647
        if (n > 0) {
1648
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1649
                rtsp_st = rt->rtsp_streams[i];
1650
                if (rtsp_st->rtp_handle) {
1651
                    fd = url_get_file_handle(rtsp_st->rtp_handle);
1652
                    if (FD_ISSET(fd, &rfds)) {
1653
                        ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
1654
                        if (ret > 0) {
1655
                            *prtsp_st = rtsp_st;
1656
                            return ret;
1657
                        }
1658
                    }
1659
                }
1660
            }
1661
#if CONFIG_RTSP_DEMUXER
1662
            if (tcp_fd != -1 && FD_ISSET(tcp_fd, &rfds)) {
1663
                RTSPMessageHeader reply;
1664

    
1665
                ff_rtsp_read_reply(s, &reply, NULL, 0);
1666
                /* XXX: parse message */
1667
                if (rt->state != RTSP_STATE_STREAMING)
1668
                    return 0;
1669
            }
1670
#endif
1671
        }
1672
    }
1673
}
1674

    
1675
static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1676
                           uint8_t *buf, int buf_size)
1677
{
1678
    RTSPState *rt = s->priv_data;
1679
    int id, len, i, ret;
1680
    RTSPStream *rtsp_st;
1681

    
1682
#ifdef DEBUG_RTP_TCP
1683
    dprintf(s, "tcp_read_packet:\n");
1684
#endif
1685
redo:
1686
    for (;;) {
1687
        RTSPMessageHeader reply;
1688

    
1689
        ret = ff_rtsp_read_reply(s, &reply, NULL, 1);
1690
        if (ret == -1)
1691
            return -1;
1692
        if (ret == 1) /* received '$' */
1693
            break;
1694
        /* XXX: parse message */
1695
        if (rt->state != RTSP_STATE_STREAMING)
1696
            return 0;
1697
    }
1698
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
1699
    if (ret != 3)
1700
        return -1;
1701
    id  = buf[0];
1702
    len = AV_RB16(buf + 1);
1703
#ifdef DEBUG_RTP_TCP
1704
    dprintf(s, "id=%d len=%d\n", id, len);
1705
#endif
1706
    if (len > buf_size || len < 12)
1707
        goto redo;
1708
    /* get the data */
1709
    ret = url_read_complete(rt->rtsp_hd, buf, len);
1710
    if (ret != len)
1711
        return -1;
1712
    if (rt->transport == RTSP_TRANSPORT_RDT &&
1713
        ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
1714
        return -1;
1715

    
1716
    /* find the matching stream */
1717
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1718
        rtsp_st = rt->rtsp_streams[i];
1719
        if (id >= rtsp_st->interleaved_min &&
1720
            id <= rtsp_st->interleaved_max)
1721
            goto found;
1722
    }
1723
    goto redo;
1724
found:
1725
    *prtsp_st = rtsp_st;
1726
    return len;
1727
}
1728

    
1729
static int rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
1730
{
1731
    RTSPState *rt = s->priv_data;
1732
    int ret, len;
1733
    uint8_t buf[10 * RTP_MAX_PACKET_LENGTH];
1734
    RTSPStream *rtsp_st;
1735

    
1736
    /* get next frames from the same RTP packet */
1737
    if (rt->cur_transport_priv) {
1738
        if (rt->transport == RTSP_TRANSPORT_RDT) {
1739
            ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1740
        } else
1741
            ret = rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1742
        if (ret == 0) {
1743
            rt->cur_transport_priv = NULL;
1744
            return 0;
1745
        } else if (ret == 1) {
1746
            return 0;
1747
        } else
1748
            rt->cur_transport_priv = NULL;
1749
    }
1750

    
1751
    /* read next RTP packet */
1752
 redo:
1753
    switch(rt->lower_transport) {
1754
    default:
1755
#if CONFIG_RTSP_DEMUXER
1756
    case RTSP_LOWER_TRANSPORT_TCP:
1757
        len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1758
        break;
1759
#endif
1760
    case RTSP_LOWER_TRANSPORT_UDP:
1761
    case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1762
        len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1763
        if (len >=0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
1764
            rtp_check_and_send_back_rr(rtsp_st->transport_priv, len);
1765
        break;
1766
    }
1767
    if (len < 0)
1768
        return len;
1769
    if (len == 0)
1770
        return AVERROR_EOF;
1771
    if (rt->transport == RTSP_TRANSPORT_RDT) {
1772
        ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1773
    } else
1774
        ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1775
    if (ret < 0)
1776
        goto redo;
1777
    if (ret == 1)
1778
        /* more packets may follow, so we save the RTP context */
1779
        rt->cur_transport_priv = rtsp_st->transport_priv;
1780

    
1781
    return ret;
1782
}
1783

    
1784
static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt)
1785
{
1786
    RTSPState *rt = s->priv_data;
1787
    int ret;
1788
    RTSPMessageHeader reply1, *reply = &reply1;
1789
    char cmd[1024];
1790

    
1791
    if (rt->server_type == RTSP_SERVER_REAL) {
1792
        int i;
1793
        enum AVDiscard cache[MAX_STREAMS];
1794

    
1795
        for (i = 0; i < s->nb_streams; i++)
1796
            cache[i] = s->streams[i]->discard;
1797

    
1798
        if (!rt->need_subscription) {
1799
            if (memcmp (cache, rt->real_setup_cache,
1800
                        sizeof(enum AVDiscard) * s->nb_streams)) {
1801
                snprintf(cmd, sizeof(cmd),
1802
                         "SET_PARAMETER %s RTSP/1.0\r\n"
1803
                         "Unsubscribe: %s\r\n",
1804
                         rt->control_uri, rt->last_subscription);
1805
                ff_rtsp_send_cmd(s, cmd, reply, NULL);
1806
                if (reply->status_code != RTSP_STATUS_OK)
1807
                    return AVERROR_INVALIDDATA;
1808
                rt->need_subscription = 1;
1809
            }
1810
        }
1811

    
1812
        if (rt->need_subscription) {
1813
            int r, rule_nr, first = 1;
1814

    
1815
            memcpy(rt->real_setup_cache, cache,
1816
                   sizeof(enum AVDiscard) * s->nb_streams);
1817
            rt->last_subscription[0] = 0;
1818

    
1819
            snprintf(cmd, sizeof(cmd),
1820
                     "SET_PARAMETER %s RTSP/1.0\r\n"
1821
                     "Subscribe: ",
1822
                     rt->control_uri);
1823
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1824
                rule_nr = 0;
1825
                for (r = 0; r < s->nb_streams; r++) {
1826
                    if (s->streams[r]->priv_data == rt->rtsp_streams[i]) {
1827
                        if (s->streams[r]->discard != AVDISCARD_ALL) {
1828
                            if (!first)
1829
                                av_strlcat(rt->last_subscription, ",",
1830
                                           sizeof(rt->last_subscription));
1831
                            ff_rdt_subscribe_rule(
1832
                                rt->last_subscription,
1833
                                sizeof(rt->last_subscription), i, rule_nr);
1834
                            first = 0;
1835
                        }
1836
                        rule_nr++;
1837
                    }
1838
                }
1839
            }
1840
            av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
1841
            ff_rtsp_send_cmd(s, cmd, reply, NULL);
1842
            if (reply->status_code != RTSP_STATUS_OK)
1843
                return AVERROR_INVALIDDATA;
1844
            rt->need_subscription = 0;
1845

    
1846
            if (rt->state == RTSP_STATE_STREAMING)
1847
                rtsp_read_play (s);
1848
        }
1849
    }
1850

    
1851
    ret = rtsp_fetch_packet(s, pkt);
1852
    if (ret < 0)
1853
        return ret;
1854

    
1855
    /* send dummy request to keep TCP connection alive */
1856
    if ((rt->server_type == RTSP_SERVER_WMS ||
1857
         rt->server_type == RTSP_SERVER_REAL) &&
1858
        (av_gettime() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2) {
1859
        if (rt->server_type == RTSP_SERVER_WMS) {
1860
            snprintf(cmd, sizeof(cmd) - 1,
1861
                     "GET_PARAMETER %s RTSP/1.0\r\n",
1862
                     rt->control_uri);
1863
            ff_rtsp_send_cmd_async(s, cmd);
1864
        } else {
1865
            ff_rtsp_send_cmd_async(s, "OPTIONS * RTSP/1.0\r\n");
1866
        }
1867
    }
1868

    
1869
    return 0;
1870
}
1871

    
1872
/* pause the stream */
1873
static int rtsp_read_pause(AVFormatContext *s)
1874
{
1875
    RTSPState *rt = s->priv_data;
1876
    RTSPMessageHeader reply1, *reply = &reply1;
1877
    char cmd[1024];
1878

    
1879
    rt = s->priv_data;
1880

    
1881
    if (rt->state != RTSP_STATE_STREAMING)
1882
        return 0;
1883
    else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1884
        snprintf(cmd, sizeof(cmd),
1885
                 "PAUSE %s RTSP/1.0\r\n",
1886
                 rt->control_uri);
1887
        ff_rtsp_send_cmd(s, cmd, reply, NULL);
1888
        if (reply->status_code != RTSP_STATUS_OK) {
1889
            return -1;
1890
        }
1891
    }
1892
    rt->state = RTSP_STATE_PAUSED;
1893
    return 0;
1894
}
1895

    
1896
static int rtsp_read_seek(AVFormatContext *s, int stream_index,
1897
                          int64_t timestamp, int flags)
1898
{
1899
    RTSPState *rt = s->priv_data;
1900

    
1901
    rt->seek_timestamp = av_rescale_q(timestamp,
1902
                                      s->streams[stream_index]->time_base,
1903
                                      AV_TIME_BASE_Q);
1904
    switch(rt->state) {
1905
    default:
1906
    case RTSP_STATE_IDLE:
1907
        break;
1908
    case RTSP_STATE_STREAMING:
1909
        if (rtsp_read_pause(s) != 0)
1910
            return -1;
1911
        rt->state = RTSP_STATE_SEEKING;
1912
        if (rtsp_read_play(s) != 0)
1913
            return -1;
1914
        break;
1915
    case RTSP_STATE_PAUSED:
1916
        rt->state = RTSP_STATE_IDLE;
1917
        break;
1918
    }
1919
    return 0;
1920
}
1921

    
1922
static int rtsp_read_close(AVFormatContext *s)
1923
{
1924
    RTSPState *rt = s->priv_data;
1925
    char cmd[1024];
1926

    
1927
#if 0
1928
    /* NOTE: it is valid to flush the buffer here */
1929
    if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1930
        url_fclose(&rt->rtsp_gb);
1931
    }
1932
#endif
1933
    snprintf(cmd, sizeof(cmd),
1934
             "TEARDOWN %s RTSP/1.0\r\n",
1935
             rt->control_uri);
1936
    ff_rtsp_send_cmd_async(s, cmd);
1937

    
1938
    ff_rtsp_close_streams(s);
1939
    url_close(rt->rtsp_hd);
1940
    ff_network_close();
1941
    return 0;
1942
}
1943

    
1944
AVInputFormat rtsp_demuxer = {
1945
    "rtsp",
1946
    NULL_IF_CONFIG_SMALL("RTSP input format"),
1947
    sizeof(RTSPState),
1948
    rtsp_probe,
1949
    rtsp_read_header,
1950
    rtsp_read_packet,
1951
    rtsp_read_close,
1952
    rtsp_read_seek,
1953
    .flags = AVFMT_NOFILE,
1954
    .read_play = rtsp_read_play,
1955
    .read_pause = rtsp_read_pause,
1956
};
1957
#endif
1958

    
1959
static int sdp_probe(AVProbeData *p1)
1960
{
1961
    const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
1962

    
1963
    /* we look for a line beginning "c=IN IP4" */
1964
    while (p < p_end && *p != '\0') {
1965
        if (p + sizeof("c=IN IP4") - 1 < p_end &&
1966
            av_strstart(p, "c=IN IP4", NULL))
1967
            return AVPROBE_SCORE_MAX / 2;
1968

    
1969
        while (p < p_end - 1 && *p != '\n') p++;
1970
        if (++p >= p_end)
1971
            break;
1972
        if (*p == '\r')
1973
            p++;
1974
    }
1975
    return 0;
1976
}
1977

    
1978
#define SDP_MAX_SIZE 8192
1979

    
1980
static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap)
1981
{
1982
    RTSPState *rt = s->priv_data;
1983
    RTSPStream *rtsp_st;
1984
    int size, i, err;
1985
    char *content;
1986
    char url[1024];
1987

    
1988
    if (!ff_network_init())
1989
        return AVERROR(EIO);
1990

    
1991
    /* read the whole sdp file */
1992
    /* XXX: better loading */
1993
    content = av_malloc(SDP_MAX_SIZE);
1994
    size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
1995
    if (size <= 0) {
1996
        av_free(content);
1997
        return AVERROR_INVALIDDATA;
1998
    }
1999
    content[size] ='\0';
2000

    
2001
    sdp_parse(s, content);
2002
    av_free(content);
2003

    
2004
    /* open each RTP stream */
2005
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
2006
        rtsp_st = rt->rtsp_streams[i];
2007

    
2008
        ff_url_join(url, sizeof(url), "rtp", NULL,
2009
                    inet_ntoa(rtsp_st->sdp_ip), rtsp_st->sdp_port,
2010
                    "?localport=%d&ttl=%d", rtsp_st->sdp_port,
2011
                    rtsp_st->sdp_ttl);
2012
        if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
2013
            err = AVERROR_INVALIDDATA;
2014
            goto fail;
2015
        }
2016
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
2017
            goto fail;
2018
    }
2019
    return 0;
2020
fail:
2021
    ff_rtsp_close_streams(s);
2022
    ff_network_close();
2023
    return err;
2024
}
2025

    
2026
static int sdp_read_close(AVFormatContext *s)
2027
{
2028
    ff_rtsp_close_streams(s);
2029
    ff_network_close();
2030
    return 0;
2031
}
2032

    
2033
AVInputFormat sdp_demuxer = {
2034
    "sdp",
2035
    NULL_IF_CONFIG_SMALL("SDP"),
2036
    sizeof(RTSPState),
2037
    sdp_probe,
2038
    sdp_read_header,
2039
    rtsp_fetch_packet,
2040
    sdp_read_close,
2041
};