Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtsp.c @ c07c6f81

History | View | Annotate | Download (65.8 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
                    url_fclose(rtpctx->pb);
588
                    av_metadata_free(&rtpctx->streams[0]->metadata);
589
                    av_metadata_free(&rtpctx->metadata);
590
                    av_free(rtpctx->streams[0]);
591
                    av_free(rtpctx);
592
                } else if (rt->transport == RTSP_TRANSPORT_RDT)
593
                    ff_rdt_parse_close(rtsp_st->transport_priv);
594
                else
595
                    rtp_parse_close(rtsp_st->transport_priv);
596
            }
597
            if (rtsp_st->rtp_handle)
598
                url_close(rtsp_st->rtp_handle);
599
            if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
600
                rtsp_st->dynamic_handler->close(
601
                    rtsp_st->dynamic_protocol_context);
602
        }
603
    }
604
    av_free(rt->rtsp_streams);
605
    if (rt->asf_ctx) {
606
        av_close_input_stream (rt->asf_ctx);
607
        rt->asf_ctx = NULL;
608
    }
609
    av_freep(&rt->auth_b64);
610
}
611

    
612
static void *rtsp_rtp_mux_open(AVFormatContext *s, AVStream *st,
613
                               URLContext *handle)
614
{
615
    RTSPState *rt = s->priv_data;
616
    AVFormatContext *rtpctx;
617
    int ret;
618
    AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
619

    
620
    if (!rtp_format)
621
        return NULL;
622

    
623
    /* Allocate an AVFormatContext for each output stream */
624
    rtpctx = avformat_alloc_context();
625
    if (!rtpctx)
626
        return NULL;
627

    
628
    rtpctx->oformat = rtp_format;
629
    if (!av_new_stream(rtpctx, 0)) {
630
        av_free(rtpctx);
631
        return NULL;
632
    }
633
    /* Copy the max delay setting; the rtp muxer reads this. */
634
    rtpctx->max_delay = s->max_delay;
635
    /* Copy other stream parameters. */
636
    rtpctx->streams[0]->sample_aspect_ratio = st->sample_aspect_ratio;
637

    
638
    /* Set the synchronized start time. */
639
    rtpctx->start_time_realtime = rt->start_time;
640

    
641
    /* Remove the local codec, link to the original codec
642
     * context instead, to give the rtp muxer access to
643
     * codec parameters. */
644
    av_free(rtpctx->streams[0]->codec);
645
    rtpctx->streams[0]->codec = st->codec;
646

    
647
    url_fdopen(&rtpctx->pb, handle);
648
    ret = av_write_header(rtpctx);
649

    
650
    if (ret) {
651
        url_fclose(rtpctx->pb);
652
        av_free(rtpctx->streams[0]);
653
        av_free(rtpctx);
654
        return NULL;
655
    }
656

    
657
    /* Copy the RTP AVStream timebase back to the original AVStream */
658
    st->time_base = rtpctx->streams[0]->time_base;
659
    return rtpctx;
660
}
661

    
662
static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
663
{
664
    RTSPState *rt = s->priv_data;
665
    AVStream *st = NULL;
666

    
667
    /* open the RTP context */
668
    if (rtsp_st->stream_index >= 0)
669
        st = s->streams[rtsp_st->stream_index];
670
    if (!st)
671
        s->ctx_flags |= AVFMTCTX_NOHEADER;
672

    
673
    if (s->oformat) {
674
        rtsp_st->transport_priv = rtsp_rtp_mux_open(s, st, rtsp_st->rtp_handle);
675
        /* Ownage of rtp_handle is passed to the rtp mux context */
676
        rtsp_st->rtp_handle = NULL;
677
    } else if (rt->transport == RTSP_TRANSPORT_RDT)
678
        rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
679
                                            rtsp_st->dynamic_protocol_context,
680
                                            rtsp_st->dynamic_handler);
681
    else
682
        rtsp_st->transport_priv = rtp_parse_open(s, st, rtsp_st->rtp_handle,
683
                                         rtsp_st->sdp_payload_type,
684
                                         &rtsp_st->rtp_payload_data);
685

    
686
    if (!rtsp_st->transport_priv) {
687
         return AVERROR(ENOMEM);
688
    } else if (rt->transport != RTSP_TRANSPORT_RDT) {
689
        if (rtsp_st->dynamic_handler) {
690
            rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
691
                                           rtsp_st->dynamic_protocol_context,
692
                                           rtsp_st->dynamic_handler);
693
        }
694
    }
695

    
696
    return 0;
697
}
698

    
699
#if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
700
static int rtsp_probe(AVProbeData *p)
701
{
702
    if (av_strstart(p->filename, "rtsp:", NULL))
703
        return AVPROBE_SCORE_MAX;
704
    return 0;
705
}
706

    
707
static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
708
{
709
    const char *p;
710
    int v;
711

    
712
    p = *pp;
713
    skip_spaces(&p);
714
    v = strtol(p, (char **)&p, 10);
715
    if (*p == '-') {
716
        p++;
717
        *min_ptr = v;
718
        v = strtol(p, (char **)&p, 10);
719
        *max_ptr = v;
720
    } else {
721
        *min_ptr = v;
722
        *max_ptr = v;
723
    }
724
    *pp = p;
725
}
726

    
727
/* XXX: only one transport specification is parsed */
728
static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
729
{
730
    char transport_protocol[16];
731
    char profile[16];
732
    char lower_transport[16];
733
    char parameter[16];
734
    RTSPTransportField *th;
735
    char buf[256];
736

    
737
    reply->nb_transports = 0;
738

    
739
    for (;;) {
740
        skip_spaces(&p);
741
        if (*p == '\0')
742
            break;
743

    
744
        th = &reply->transports[reply->nb_transports];
745

    
746
        get_word_sep(transport_protocol, sizeof(transport_protocol),
747
                     "/", &p);
748
        if (!strcasecmp (transport_protocol, "rtp")) {
749
            get_word_sep(profile, sizeof(profile), "/;,", &p);
750
            lower_transport[0] = '\0';
751
            /* rtp/avp/<protocol> */
752
            if (*p == '/') {
753
                get_word_sep(lower_transport, sizeof(lower_transport),
754
                             ";,", &p);
755
            }
756
            th->transport = RTSP_TRANSPORT_RTP;
757
        } else if (!strcasecmp (transport_protocol, "x-pn-tng") ||
758
                   !strcasecmp (transport_protocol, "x-real-rdt")) {
759
            /* x-pn-tng/<protocol> */
760
            get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
761
            profile[0] = '\0';
762
            th->transport = RTSP_TRANSPORT_RDT;
763
        }
764
        if (!strcasecmp(lower_transport, "TCP"))
765
            th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
766
        else
767
            th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
768

    
769
        if (*p == ';')
770
            p++;
771
        /* get each parameter */
772
        while (*p != '\0' && *p != ',') {
773
            get_word_sep(parameter, sizeof(parameter), "=;,", &p);
774
            if (!strcmp(parameter, "port")) {
775
                if (*p == '=') {
776
                    p++;
777
                    rtsp_parse_range(&th->port_min, &th->port_max, &p);
778
                }
779
            } else if (!strcmp(parameter, "client_port")) {
780
                if (*p == '=') {
781
                    p++;
782
                    rtsp_parse_range(&th->client_port_min,
783
                                     &th->client_port_max, &p);
784
                }
785
            } else if (!strcmp(parameter, "server_port")) {
786
                if (*p == '=') {
787
                    p++;
788
                    rtsp_parse_range(&th->server_port_min,
789
                                     &th->server_port_max, &p);
790
                }
791
            } else if (!strcmp(parameter, "interleaved")) {
792
                if (*p == '=') {
793
                    p++;
794
                    rtsp_parse_range(&th->interleaved_min,
795
                                     &th->interleaved_max, &p);
796
                }
797
            } else if (!strcmp(parameter, "multicast")) {
798
                if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
799
                    th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
800
            } else if (!strcmp(parameter, "ttl")) {
801
                if (*p == '=') {
802
                    p++;
803
                    th->ttl = strtol(p, (char **)&p, 10);
804
                }
805
            } else if (!strcmp(parameter, "destination")) {
806
                struct in_addr ipaddr;
807

    
808
                if (*p == '=') {
809
                    p++;
810
                    get_word_sep(buf, sizeof(buf), ";,", &p);
811
                    if (ff_inet_aton(buf, &ipaddr))
812
                        th->destination = ntohl(ipaddr.s_addr);
813
                }
814
            }
815
            while (*p != ';' && *p != '\0' && *p != ',')
816
                p++;
817
            if (*p == ';')
818
                p++;
819
        }
820
        if (*p == ',')
821
            p++;
822

    
823
        reply->nb_transports++;
824
    }
825
}
826

    
827
void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf)
828
{
829
    const char *p;
830

    
831
    /* NOTE: we do case independent match for broken servers */
832
    p = buf;
833
    if (av_stristart(p, "Session:", &p)) {
834
        int t;
835
        get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
836
        if (av_stristart(p, ";timeout=", &p) &&
837
            (t = strtol(p, NULL, 10)) > 0) {
838
            reply->timeout = t;
839
        }
840
    } else if (av_stristart(p, "Content-Length:", &p)) {
841
        reply->content_length = strtol(p, NULL, 10);
842
    } else if (av_stristart(p, "Transport:", &p)) {
843
        rtsp_parse_transport(reply, p);
844
    } else if (av_stristart(p, "CSeq:", &p)) {
845
        reply->seq = strtol(p, NULL, 10);
846
    } else if (av_stristart(p, "Range:", &p)) {
847
        rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
848
    } else if (av_stristart(p, "RealChallenge1:", &p)) {
849
        skip_spaces(&p);
850
        av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
851
    } else if (av_stristart(p, "Server:", &p)) {
852
        skip_spaces(&p);
853
        av_strlcpy(reply->server, p, sizeof(reply->server));
854
    } else if (av_stristart(p, "Notice:", &p) ||
855
               av_stristart(p, "X-Notice:", &p)) {
856
        reply->notice = strtol(p, NULL, 10);
857
    } else if (av_stristart(p, "Location:", &p)) {
858
        skip_spaces(&p);
859
        av_strlcpy(reply->location, p , sizeof(reply->location));
860
    }
861
}
862

    
863
/* skip a RTP/TCP interleaved packet */
864
static void rtsp_skip_packet(AVFormatContext *s)
865
{
866
    RTSPState *rt = s->priv_data;
867
    int ret, len, len1;
868
    uint8_t buf[1024];
869

    
870
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
871
    if (ret != 3)
872
        return;
873
    len = AV_RB16(buf + 1);
874

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

    
877
    /* skip payload */
878
    while (len > 0) {
879
        len1 = len;
880
        if (len1 > sizeof(buf))
881
            len1 = sizeof(buf);
882
        ret = url_read_complete(rt->rtsp_hd, buf, len1);
883
        if (ret != len1)
884
            return;
885
        len -= len1;
886
    }
887
}
888

    
889
int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
890
                       unsigned char **content_ptr,
891
                       int return_on_interleaved_data)
892
{
893
    RTSPState *rt = s->priv_data;
894
    char buf[4096], buf1[1024], *q;
895
    unsigned char ch;
896
    const char *p;
897
    int ret, content_length, line_count = 0;
898
    unsigned char *content = NULL;
899

    
900
    memset(reply, 0, sizeof(*reply));
901

    
902
    /* parse reply (XXX: use buffers) */
903
    rt->last_reply[0] = '\0';
904
    for (;;) {
905
        q = buf;
906
        for (;;) {
907
            ret = url_read_complete(rt->rtsp_hd, &ch, 1);
908
#ifdef DEBUG_RTP_TCP
909
            dprintf(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
910
#endif
911
            if (ret != 1)
912
                return -1;
913
            if (ch == '\n')
914
                break;
915
            if (ch == '$') {
916
                /* XXX: only parse it if first char on line ? */
917
                if (return_on_interleaved_data) {
918
                    return 1;
919
                } else
920
                rtsp_skip_packet(s);
921
            } else if (ch != '\r') {
922
                if ((q - buf) < sizeof(buf) - 1)
923
                    *q++ = ch;
924
            }
925
        }
926
        *q = '\0';
927

    
928
        dprintf(s, "line='%s'\n", buf);
929

    
930
        /* test if last line */
931
        if (buf[0] == '\0')
932
            break;
933
        p = buf;
934
        if (line_count == 0) {
935
            /* get reply code */
936
            get_word(buf1, sizeof(buf1), &p);
937
            get_word(buf1, sizeof(buf1), &p);
938
            reply->status_code = atoi(buf1);
939
        } else {
940
            ff_rtsp_parse_line(reply, p);
941
            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
942
            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
943
        }
944
        line_count++;
945
    }
946

    
947
    if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
948
        av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
949

    
950
    content_length = reply->content_length;
951
    if (content_length > 0) {
952
        /* leave some room for a trailing '\0' (useful for simple parsing) */
953
        content = av_malloc(content_length + 1);
954
        (void)url_read_complete(rt->rtsp_hd, content, content_length);
955
        content[content_length] = '\0';
956
    }
957
    if (content_ptr)
958
        *content_ptr = content;
959
    else
960
        av_free(content);
961

    
962
    /* EOS */
963
    if (reply->notice == 2101 /* End-of-Stream Reached */      ||
964
        reply->notice == 2104 /* Start-of-Stream Reached */    ||
965
        reply->notice == 2306 /* Continuous Feed Terminated */) {
966
        rt->state = RTSP_STATE_IDLE;
967
    } else if (reply->notice >= 4400 && reply->notice < 5500) {
968
        return AVERROR(EIO); /* data or server error */
969
    } else if (reply->notice == 2401 /* Ticket Expired */ ||
970
             (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
971
        return AVERROR(EPERM);
972

    
973
    return 0;
974
}
975

    
976
void ff_rtsp_send_cmd_with_content_async(AVFormatContext *s,
977
                                         const char *cmd,
978
                                         const unsigned char *send_content,
979
                                         int send_content_length)
980
{
981
    RTSPState *rt = s->priv_data;
982
    char buf[4096], buf1[1024];
983

    
984
    rt->seq++;
985
    av_strlcpy(buf, cmd, sizeof(buf));
986
    snprintf(buf1, sizeof(buf1), "CSeq: %d\r\n", rt->seq);
987
    av_strlcat(buf, buf1, sizeof(buf));
988
    if (rt->session_id[0] != '\0' && !strstr(cmd, "\nIf-Match:")) {
989
        snprintf(buf1, sizeof(buf1), "Session: %s\r\n", rt->session_id);
990
        av_strlcat(buf, buf1, sizeof(buf));
991
    }
992
    if (rt->auth_b64)
993
        av_strlcatf(buf, sizeof(buf),
994
                    "Authorization: Basic %s\r\n",
995
                    rt->auth_b64);
996
    if (send_content_length > 0 && send_content)
997
        av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
998
    av_strlcat(buf, "\r\n", sizeof(buf));
999

    
1000
    dprintf(s, "Sending:\n%s--\n", buf);
1001

    
1002
    url_write(rt->rtsp_hd, buf, strlen(buf));
1003
    if (send_content_length > 0 && send_content)
1004
        url_write(rt->rtsp_hd, send_content, send_content_length);
1005
    rt->last_cmd_time = av_gettime();
1006
}
1007

    
1008
void ff_rtsp_send_cmd_async(AVFormatContext *s, const char *cmd)
1009
{
1010
    ff_rtsp_send_cmd_with_content_async(s, cmd, NULL, 0);
1011
}
1012

    
1013
void ff_rtsp_send_cmd(AVFormatContext *s,
1014
                      const char *cmd, RTSPMessageHeader *reply,
1015
                      unsigned char **content_ptr)
1016
{
1017
    ff_rtsp_send_cmd_async(s, cmd);
1018

    
1019
    ff_rtsp_read_reply(s, reply, content_ptr, 0);
1020
}
1021

    
1022
void ff_rtsp_send_cmd_with_content(AVFormatContext *s,
1023
                                const char *cmd,
1024
                                RTSPMessageHeader *reply,
1025
                                unsigned char **content_ptr,
1026
                                const unsigned char *send_content,
1027
                                int send_content_length)
1028
{
1029
    ff_rtsp_send_cmd_with_content_async(s, cmd, send_content, send_content_length);
1030

    
1031
    ff_rtsp_read_reply(s, reply, content_ptr, 0);
1032
}
1033

    
1034
/**
1035
 * @returns 0 on success, <0 on error, 1 if protocol is unavailable.
1036
 */
1037
static int make_setup_request(AVFormatContext *s, const char *host, int port,
1038
                              int lower_transport, const char *real_challenge)
1039
{
1040
    RTSPState *rt = s->priv_data;
1041
    int rtx, j, i, err, interleave = 0;
1042
    RTSPStream *rtsp_st;
1043
    RTSPMessageHeader reply1, *reply = &reply1;
1044
    char cmd[2048];
1045
    const char *trans_pref;
1046

    
1047
    if (rt->transport == RTSP_TRANSPORT_RDT)
1048
        trans_pref = "x-pn-tng";
1049
    else
1050
        trans_pref = "RTP/AVP";
1051

    
1052
    /* default timeout: 1 minute */
1053
    rt->timeout = 60;
1054

    
1055
    /* for each stream, make the setup request */
1056
    /* XXX: we assume the same server is used for the control of each
1057
     * RTSP stream */
1058

    
1059
    for (j = RTSP_RTP_PORT_MIN, i = 0; i < rt->nb_rtsp_streams; ++i) {
1060
        char transport[2048];
1061

    
1062
        /**
1063
         * WMS serves all UDP data over a single connection, the RTX, which
1064
         * isn't necessarily the first in the SDP but has to be the first
1065
         * to be set up, else the second/third SETUP will fail with a 461.
1066
         */
1067
        if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1068
             rt->server_type == RTSP_SERVER_WMS) {
1069
            if (i == 0) {
1070
                /* rtx first */
1071
                for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1072
                    int len = strlen(rt->rtsp_streams[rtx]->control_url);
1073
                    if (len >= 4 &&
1074
                        !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1075
                                "/rtx"))
1076
                        break;
1077
                }
1078
                if (rtx == rt->nb_rtsp_streams)
1079
                    return -1; /* no RTX found */
1080
                rtsp_st = rt->rtsp_streams[rtx];
1081
            } else
1082
                rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1083
        } else
1084
            rtsp_st = rt->rtsp_streams[i];
1085

    
1086
        /* RTP/UDP */
1087
        if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1088
            char buf[256];
1089

    
1090
            if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1091
                port = reply->transports[0].client_port_min;
1092
                goto have_port;
1093
            }
1094

    
1095
            /* first try in specified port range */
1096
            if (RTSP_RTP_PORT_MIN != 0) {
1097
                while (j <= RTSP_RTP_PORT_MAX) {
1098
                    ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1099
                                "?localport=%d", j);
1100
                    /* we will use two ports per rtp stream (rtp and rtcp) */
1101
                    j += 2;
1102
                    if (url_open(&rtsp_st->rtp_handle, buf, URL_RDWR) == 0)
1103
                        goto rtp_opened;
1104
                }
1105
            }
1106

    
1107
#if 0
1108
            /* then try on any port */
1109
            if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
1110
                err = AVERROR_INVALIDDATA;
1111
                goto fail;
1112
            }
1113
#endif
1114

    
1115
        rtp_opened:
1116
            port = rtp_get_local_port(rtsp_st->rtp_handle);
1117
        have_port:
1118
            snprintf(transport, sizeof(transport) - 1,
1119
                     "%s/UDP;", trans_pref);
1120
            if (rt->server_type != RTSP_SERVER_REAL)
1121
                av_strlcat(transport, "unicast;", sizeof(transport));
1122
            av_strlcatf(transport, sizeof(transport),
1123
                     "client_port=%d", port);
1124
            if (rt->transport == RTSP_TRANSPORT_RTP &&
1125
                !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1126
                av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1127
        }
1128

    
1129
        /* RTP/TCP */
1130
        else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1131
            /** For WMS streams, the application streams are only used for
1132
             * UDP. When trying to set it up for TCP streams, the server
1133
             * will return an error. Therefore, we skip those streams. */
1134
            if (rt->server_type == RTSP_SERVER_WMS &&
1135
                s->streams[rtsp_st->stream_index]->codec->codec_type ==
1136
                    CODEC_TYPE_DATA)
1137
                continue;
1138
            snprintf(transport, sizeof(transport) - 1,
1139
                     "%s/TCP;", trans_pref);
1140
            if (rt->server_type == RTSP_SERVER_WMS)
1141
                av_strlcat(transport, "unicast;", sizeof(transport));
1142
            av_strlcatf(transport, sizeof(transport),
1143
                        "interleaved=%d-%d",
1144
                        interleave, interleave + 1);
1145
            interleave += 2;
1146
        }
1147

    
1148
        else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1149
            snprintf(transport, sizeof(transport) - 1,
1150
                     "%s/UDP;multicast", trans_pref);
1151
        }
1152
        if (s->oformat) {
1153
            av_strlcat(transport, ";mode=receive", sizeof(transport));
1154
        } else if (rt->server_type == RTSP_SERVER_REAL ||
1155
                   rt->server_type == RTSP_SERVER_WMS)
1156
            av_strlcat(transport, ";mode=play", sizeof(transport));
1157
        snprintf(cmd, sizeof(cmd),
1158
                 "SETUP %s RTSP/1.0\r\n"
1159
                 "Transport: %s\r\n",
1160
                 rtsp_st->control_url, transport);
1161
        if (i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1162
            char real_res[41], real_csum[9];
1163
            ff_rdt_calc_response_and_checksum(real_res, real_csum,
1164
                                              real_challenge);
1165
            av_strlcatf(cmd, sizeof(cmd),
1166
                        "If-Match: %s\r\n"
1167
                        "RealChallenge2: %s, sd=%s\r\n",
1168
                        rt->session_id, real_res, real_csum);
1169
        }
1170
        ff_rtsp_send_cmd(s, cmd, reply, NULL);
1171
        if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1172
            err = 1;
1173
            goto fail;
1174
        } else if (reply->status_code != RTSP_STATUS_OK ||
1175
                   reply->nb_transports != 1) {
1176
            err = AVERROR_INVALIDDATA;
1177
            goto fail;
1178
        }
1179

    
1180
        /* XXX: same protocol for all streams is required */
1181
        if (i > 0) {
1182
            if (reply->transports[0].lower_transport != rt->lower_transport ||
1183
                reply->transports[0].transport != rt->transport) {
1184
                err = AVERROR_INVALIDDATA;
1185
                goto fail;
1186
            }
1187
        } else {
1188
            rt->lower_transport = reply->transports[0].lower_transport;
1189
            rt->transport = reply->transports[0].transport;
1190
        }
1191

    
1192
        /* close RTP connection if not choosen */
1193
        if (reply->transports[0].lower_transport != RTSP_LOWER_TRANSPORT_UDP &&
1194
            (lower_transport == RTSP_LOWER_TRANSPORT_UDP)) {
1195
            url_close(rtsp_st->rtp_handle);
1196
            rtsp_st->rtp_handle = NULL;
1197
        }
1198

    
1199
        switch(reply->transports[0].lower_transport) {
1200
        case RTSP_LOWER_TRANSPORT_TCP:
1201
            rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1202
            rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1203
            break;
1204

    
1205
        case RTSP_LOWER_TRANSPORT_UDP: {
1206
            char url[1024];
1207

    
1208
            /* XXX: also use address if specified */
1209
            ff_url_join(url, sizeof(url), "rtp", NULL, host,
1210
                        reply->transports[0].server_port_min, NULL);
1211
            if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1212
                rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1213
                err = AVERROR_INVALIDDATA;
1214
                goto fail;
1215
            }
1216
            /* Try to initialize the connection state in a
1217
             * potential NAT router by sending dummy packets.
1218
             * RTP/RTCP dummy packets are used for RDT, too.
1219
             */
1220
            if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat)
1221
                rtp_send_punch_packets(rtsp_st->rtp_handle);
1222
            break;
1223
        }
1224
        case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1225
            char url[1024];
1226
            struct in_addr in;
1227
            int port, ttl;
1228

    
1229
            if (reply->transports[0].destination) {
1230
                in.s_addr = htonl(reply->transports[0].destination);
1231
                port      = reply->transports[0].port_min;
1232
                ttl       = reply->transports[0].ttl;
1233
            } else {
1234
                in        = rtsp_st->sdp_ip;
1235
                port      = rtsp_st->sdp_port;
1236
                ttl       = rtsp_st->sdp_ttl;
1237
            }
1238
            ff_url_join(url, sizeof(url), "rtp", NULL, inet_ntoa(in),
1239
                        port, "?ttl=%d", ttl);
1240
            if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1241
                err = AVERROR_INVALIDDATA;
1242
                goto fail;
1243
            }
1244
            break;
1245
        }
1246
        }
1247

    
1248
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1249
            goto fail;
1250
    }
1251

    
1252
    if (reply->timeout > 0)
1253
        rt->timeout = reply->timeout;
1254

    
1255
    if (rt->server_type == RTSP_SERVER_REAL)
1256
        rt->need_subscription = 1;
1257

    
1258
    return 0;
1259

    
1260
fail:
1261
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1262
        if (rt->rtsp_streams[i]->rtp_handle) {
1263
            url_close(rt->rtsp_streams[i]->rtp_handle);
1264
            rt->rtsp_streams[i]->rtp_handle = NULL;
1265
        }
1266
    }
1267
    return err;
1268
}
1269

    
1270
static int rtsp_read_play(AVFormatContext *s)
1271
{
1272
    RTSPState *rt = s->priv_data;
1273
    RTSPMessageHeader reply1, *reply = &reply1;
1274
    char cmd[1024];
1275

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

    
1278
    if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1279
        if (rt->state == RTSP_STATE_PAUSED) {
1280
            snprintf(cmd, sizeof(cmd),
1281
                     "PLAY %s RTSP/1.0\r\n",
1282
                     rt->control_uri);
1283
        } else {
1284
            snprintf(cmd, sizeof(cmd),
1285
                     "PLAY %s RTSP/1.0\r\n"
1286
                     "Range: npt=%0.3f-\r\n",
1287
                     rt->control_uri,
1288
                     (double)rt->seek_timestamp / AV_TIME_BASE);
1289
        }
1290
        ff_rtsp_send_cmd(s, cmd, reply, NULL);
1291
        if (reply->status_code != RTSP_STATUS_OK) {
1292
            return -1;
1293
        }
1294
    }
1295
    rt->state = RTSP_STATE_STREAMING;
1296
    return 0;
1297
}
1298

    
1299
static int rtsp_setup_input_streams(AVFormatContext *s)
1300
{
1301
    RTSPState *rt = s->priv_data;
1302
    RTSPMessageHeader reply1, *reply = &reply1;
1303
    char cmd[1024];
1304
    unsigned char *content = NULL;
1305
    int ret;
1306

    
1307
    /* describe the stream */
1308
    snprintf(cmd, sizeof(cmd),
1309
             "DESCRIBE %s RTSP/1.0\r\n"
1310
             "Accept: application/sdp\r\n",
1311
             rt->control_uri);
1312
    if (rt->server_type == RTSP_SERVER_REAL) {
1313
        /**
1314
         * The Require: attribute is needed for proper streaming from
1315
         * Realmedia servers.
1316
         */
1317
        av_strlcat(cmd,
1318
                   "Require: com.real.retain-entity-for-setup\r\n",
1319
                   sizeof(cmd));
1320
    }
1321
    ff_rtsp_send_cmd(s, cmd, reply, &content);
1322
    if (!content)
1323
        return AVERROR_INVALIDDATA;
1324
    if (reply->status_code != RTSP_STATUS_OK) {
1325
        av_freep(&content);
1326
        return AVERROR_INVALIDDATA;
1327
    }
1328

    
1329
    /* now we got the SDP description, we parse it */
1330
    ret = sdp_parse(s, (const char *)content);
1331
    av_freep(&content);
1332
    if (ret < 0)
1333
        return AVERROR_INVALIDDATA;
1334

    
1335
    return 0;
1336
}
1337

    
1338
static int rtsp_setup_output_streams(AVFormatContext *s, const char *addr)
1339
{
1340
    RTSPState *rt = s->priv_data;
1341
    RTSPMessageHeader reply1, *reply = &reply1;
1342
    char cmd[1024];
1343
    int i;
1344
    char *sdp;
1345
    AVFormatContext sdp_ctx, *ctx_array[1];
1346

    
1347
    rt->start_time = av_gettime();
1348

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

    
1383
    /* Set up the RTSPStreams for each AVStream */
1384
    for (i = 0; i < s->nb_streams; i++) {
1385
        RTSPStream *rtsp_st;
1386
        AVStream *st = s->streams[i];
1387

    
1388
        rtsp_st = av_mallocz(sizeof(RTSPStream));
1389
        if (!rtsp_st)
1390
            return AVERROR(ENOMEM);
1391
        dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
1392

    
1393
        st->priv_data = rtsp_st;
1394
        rtsp_st->stream_index = i;
1395

    
1396
        av_strlcpy(rtsp_st->control_url, rt->control_uri, sizeof(rtsp_st->control_url));
1397
        /* Note, this must match the relative uri set in the sdp content */
1398
        av_strlcatf(rtsp_st->control_url, sizeof(rtsp_st->control_url),
1399
                    "/streamid=%d", i);
1400
    }
1401

    
1402
    return 0;
1403
}
1404

    
1405
int ff_rtsp_connect(AVFormatContext *s)
1406
{
1407
    RTSPState *rt = s->priv_data;
1408
    char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1409
    char *option_list, *option, *filename;
1410
    URLContext *rtsp_hd;
1411
    int port, err, tcp_fd;
1412
    RTSPMessageHeader reply1, *reply = &reply1;
1413
    int lower_transport_mask = 0;
1414
    char real_challenge[64];
1415
    struct sockaddr_storage peer;
1416
    socklen_t peer_len = sizeof(peer);
1417

    
1418
    if (!ff_network_init())
1419
        return AVERROR(EIO);
1420
redirect:
1421
    /* extract hostname and port */
1422
    ff_url_split(NULL, 0, auth, sizeof(auth),
1423
                 host, sizeof(host), &port, path, sizeof(path), s->filename);
1424
    if (*auth) {
1425
        int auth_len = strlen(auth), b64_len = ((auth_len + 2) / 3) * 4 + 1;
1426

    
1427
        if (!(rt->auth_b64 = av_malloc(b64_len)))
1428
            return AVERROR(ENOMEM);
1429
        if (!av_base64_encode(rt->auth_b64, b64_len, auth, auth_len)) {
1430
            err = AVERROR(EINVAL);
1431
            goto fail;
1432
        }
1433
    }
1434
    if (port < 0)
1435
        port = RTSP_DEFAULT_PORT;
1436

    
1437
    /* search for options */
1438
    option_list = strchr(path, '?');
1439
    if (option_list) {
1440
        filename = strchr(s->filename, '?');
1441
        while (option_list) {
1442
            /* move the option pointer */
1443
            option = ++option_list;
1444
            option_list = strchr(option_list, '&');
1445
            if (option_list)
1446
                *option_list = 0;
1447

    
1448
            /* handle the options */
1449
            if (!strcmp(option, "udp")) {
1450
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP);
1451
            } else if (!strcmp(option, "multicast")) {
1452
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
1453
            } else if (!strcmp(option, "tcp")) {
1454
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_TCP);
1455
            } else {
1456
                strcpy(++filename, option);
1457
                filename += strlen(option);
1458
                if (option_list) *filename = '&';
1459
            }
1460
        }
1461
        *filename = 0;
1462
    }
1463

    
1464
    if (!lower_transport_mask)
1465
        lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1466

    
1467
    if (s->oformat) {
1468
        /* Only UDP output is supported at the moment. */
1469
        lower_transport_mask &= 1 << RTSP_LOWER_TRANSPORT_UDP;
1470
        if (!lower_transport_mask) {
1471
            av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1472
                                    "only UDP is supported for output.\n");
1473
            err = AVERROR(EINVAL);
1474
            goto fail;
1475
        }
1476
    }
1477

    
1478
    /* open the tcp connexion */
1479
    ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port, NULL);
1480
    if (url_open(&rtsp_hd, tcpname, URL_RDWR) < 0) {
1481
        err = AVERROR(EIO);
1482
        goto fail;
1483
    }
1484
    rt->rtsp_hd = rtsp_hd;
1485
    rt->seq = 0;
1486

    
1487
    tcp_fd = url_get_file_handle(rtsp_hd);
1488
    if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1489
        getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1490
                    NULL, 0, NI_NUMERICHOST);
1491
    }
1492

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

    
1522
        /* detect server type if not standard-compliant RTP */
1523
        if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1524
            rt->server_type = RTSP_SERVER_REAL;
1525
            continue;
1526
        } else if (!strncasecmp(reply->server, "WMServer/", 9)) {
1527
            rt->server_type = RTSP_SERVER_WMS;
1528
        } else if (rt->server_type == RTSP_SERVER_REAL)
1529
            strcpy(real_challenge, reply->real_challenge);
1530
        break;
1531
    }
1532

    
1533
    if (s->iformat)
1534
        err = rtsp_setup_input_streams(s);
1535
    else
1536
        err = rtsp_setup_output_streams(s, host);
1537
    if (err)
1538
        goto fail;
1539

    
1540
    do {
1541
        int lower_transport = ff_log2_tab[lower_transport_mask &
1542
                                  ~(lower_transport_mask - 1)];
1543

    
1544
        err = make_setup_request(s, host, port, lower_transport,
1545
                                 rt->server_type == RTSP_SERVER_REAL ?
1546
                                     real_challenge : NULL);
1547
        if (err < 0)
1548
            goto fail;
1549
        lower_transport_mask &= ~(1 << lower_transport);
1550
        if (lower_transport_mask == 0 && err == 1) {
1551
            err = AVERROR(FF_NETERROR(EPROTONOSUPPORT));
1552
            goto fail;
1553
        }
1554
    } while (err);
1555

    
1556
    rt->state = RTSP_STATE_IDLE;
1557
    rt->seek_timestamp = 0; /* default is to start stream at position zero */
1558
    return 0;
1559
 fail:
1560
    ff_rtsp_close_streams(s);
1561
    url_close(rt->rtsp_hd);
1562
    if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1563
        av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1564
        av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1565
               reply->status_code,
1566
               s->filename);
1567
        goto redirect;
1568
    }
1569
    ff_network_close();
1570
    return err;
1571
}
1572
#endif
1573

    
1574
#if CONFIG_RTSP_DEMUXER
1575
static int rtsp_read_header(AVFormatContext *s,
1576
                            AVFormatParameters *ap)
1577
{
1578
    RTSPState *rt = s->priv_data;
1579
    int ret;
1580

    
1581
    ret = ff_rtsp_connect(s);
1582
    if (ret)
1583
        return ret;
1584

    
1585
    if (ap->initial_pause) {
1586
         /* do not start immediately */
1587
    } else {
1588
         if (rtsp_read_play(s) < 0) {
1589
            ff_rtsp_close_streams(s);
1590
            url_close(rt->rtsp_hd);
1591
            return AVERROR_INVALIDDATA;
1592
        }
1593
    }
1594

    
1595
    return 0;
1596
}
1597

    
1598
static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1599
                           uint8_t *buf, int buf_size)
1600
{
1601
    RTSPState *rt = s->priv_data;
1602
    RTSPStream *rtsp_st;
1603
    fd_set rfds;
1604
    int fd, fd_max, n, i, ret, tcp_fd;
1605
    struct timeval tv;
1606

    
1607
    for (;;) {
1608
        if (url_interrupt_cb())
1609
            return AVERROR(EINTR);
1610
        FD_ZERO(&rfds);
1611
        if (rt->rtsp_hd) {
1612
            tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd);
1613
            FD_SET(tcp_fd, &rfds);
1614
        } else {
1615
            fd_max = 0;
1616
            tcp_fd = -1;
1617
        }
1618
        for (i = 0; i < rt->nb_rtsp_streams; i++) {
1619
            rtsp_st = rt->rtsp_streams[i];
1620
            if (rtsp_st->rtp_handle) {
1621
                /* currently, we cannot probe RTCP handle because of
1622
                 * blocking restrictions */
1623
                fd = url_get_file_handle(rtsp_st->rtp_handle);
1624
                if (fd > fd_max)
1625
                    fd_max = fd;
1626
                FD_SET(fd, &rfds);
1627
            }
1628
        }
1629
        tv.tv_sec = 0;
1630
        tv.tv_usec = 100 * 1000;
1631
        n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
1632
        if (n > 0) {
1633
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1634
                rtsp_st = rt->rtsp_streams[i];
1635
                if (rtsp_st->rtp_handle) {
1636
                    fd = url_get_file_handle(rtsp_st->rtp_handle);
1637
                    if (FD_ISSET(fd, &rfds)) {
1638
                        ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
1639
                        if (ret > 0) {
1640
                            *prtsp_st = rtsp_st;
1641
                            return ret;
1642
                        }
1643
                    }
1644
                }
1645
            }
1646
#if CONFIG_RTSP_DEMUXER
1647
            if (tcp_fd != -1 && FD_ISSET(tcp_fd, &rfds)) {
1648
                RTSPMessageHeader reply;
1649

    
1650
                ff_rtsp_read_reply(s, &reply, NULL, 0);
1651
                /* XXX: parse message */
1652
                if (rt->state != RTSP_STATE_STREAMING)
1653
                    return 0;
1654
            }
1655
#endif
1656
        }
1657
    }
1658
}
1659

    
1660
static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1661
                           uint8_t *buf, int buf_size)
1662
{
1663
    RTSPState *rt = s->priv_data;
1664
    int id, len, i, ret;
1665
    RTSPStream *rtsp_st;
1666

    
1667
#ifdef DEBUG_RTP_TCP
1668
    dprintf(s, "tcp_read_packet:\n");
1669
#endif
1670
redo:
1671
    for (;;) {
1672
        RTSPMessageHeader reply;
1673

    
1674
        ret = ff_rtsp_read_reply(s, &reply, NULL, 1);
1675
        if (ret == -1)
1676
            return -1;
1677
        if (ret == 1) /* received '$' */
1678
            break;
1679
        /* XXX: parse message */
1680
        if (rt->state != RTSP_STATE_STREAMING)
1681
            return 0;
1682
    }
1683
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
1684
    if (ret != 3)
1685
        return -1;
1686
    id  = buf[0];
1687
    len = AV_RB16(buf + 1);
1688
#ifdef DEBUG_RTP_TCP
1689
    dprintf(s, "id=%d len=%d\n", id, len);
1690
#endif
1691
    if (len > buf_size || len < 12)
1692
        goto redo;
1693
    /* get the data */
1694
    ret = url_read_complete(rt->rtsp_hd, buf, len);
1695
    if (ret != len)
1696
        return -1;
1697
    if (rt->transport == RTSP_TRANSPORT_RDT &&
1698
        ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
1699
        return -1;
1700

    
1701
    /* find the matching stream */
1702
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1703
        rtsp_st = rt->rtsp_streams[i];
1704
        if (id >= rtsp_st->interleaved_min &&
1705
            id <= rtsp_st->interleaved_max)
1706
            goto found;
1707
    }
1708
    goto redo;
1709
found:
1710
    *prtsp_st = rtsp_st;
1711
    return len;
1712
}
1713

    
1714
static int rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
1715
{
1716
    RTSPState *rt = s->priv_data;
1717
    int ret, len;
1718
    uint8_t buf[10 * RTP_MAX_PACKET_LENGTH];
1719
    RTSPStream *rtsp_st;
1720

    
1721
    /* get next frames from the same RTP packet */
1722
    if (rt->cur_transport_priv) {
1723
        if (rt->transport == RTSP_TRANSPORT_RDT) {
1724
            ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1725
        } else
1726
            ret = rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1727
        if (ret == 0) {
1728
            rt->cur_transport_priv = NULL;
1729
            return 0;
1730
        } else if (ret == 1) {
1731
            return 0;
1732
        } else
1733
            rt->cur_transport_priv = NULL;
1734
    }
1735

    
1736
    /* read next RTP packet */
1737
 redo:
1738
    switch(rt->lower_transport) {
1739
    default:
1740
#if CONFIG_RTSP_DEMUXER
1741
    case RTSP_LOWER_TRANSPORT_TCP:
1742
        len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1743
        break;
1744
#endif
1745
    case RTSP_LOWER_TRANSPORT_UDP:
1746
    case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1747
        len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1748
        if (len >=0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
1749
            rtp_check_and_send_back_rr(rtsp_st->transport_priv, len);
1750
        break;
1751
    }
1752
    if (len < 0)
1753
        return len;
1754
    if (len == 0)
1755
        return AVERROR_EOF;
1756
    if (rt->transport == RTSP_TRANSPORT_RDT) {
1757
        ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1758
    } else
1759
        ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1760
    if (ret < 0)
1761
        goto redo;
1762
    if (ret == 1)
1763
        /* more packets may follow, so we save the RTP context */
1764
        rt->cur_transport_priv = rtsp_st->transport_priv;
1765

    
1766
    return ret;
1767
}
1768

    
1769
static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt)
1770
{
1771
    RTSPState *rt = s->priv_data;
1772
    int ret;
1773
    RTSPMessageHeader reply1, *reply = &reply1;
1774
    char cmd[1024];
1775

    
1776
    if (rt->server_type == RTSP_SERVER_REAL) {
1777
        int i;
1778
        enum AVDiscard cache[MAX_STREAMS];
1779

    
1780
        for (i = 0; i < s->nb_streams; i++)
1781
            cache[i] = s->streams[i]->discard;
1782

    
1783
        if (!rt->need_subscription) {
1784
            if (memcmp (cache, rt->real_setup_cache,
1785
                        sizeof(enum AVDiscard) * s->nb_streams)) {
1786
                snprintf(cmd, sizeof(cmd),
1787
                         "SET_PARAMETER %s RTSP/1.0\r\n"
1788
                         "Unsubscribe: %s\r\n",
1789
                         rt->control_uri, rt->last_subscription);
1790
                ff_rtsp_send_cmd(s, cmd, reply, NULL);
1791
                if (reply->status_code != RTSP_STATUS_OK)
1792
                    return AVERROR_INVALIDDATA;
1793
                rt->need_subscription = 1;
1794
            }
1795
        }
1796

    
1797
        if (rt->need_subscription) {
1798
            int r, rule_nr, first = 1;
1799

    
1800
            memcpy(rt->real_setup_cache, cache,
1801
                   sizeof(enum AVDiscard) * s->nb_streams);
1802
            rt->last_subscription[0] = 0;
1803

    
1804
            snprintf(cmd, sizeof(cmd),
1805
                     "SET_PARAMETER %s RTSP/1.0\r\n"
1806
                     "Subscribe: ",
1807
                     rt->control_uri);
1808
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1809
                rule_nr = 0;
1810
                for (r = 0; r < s->nb_streams; r++) {
1811
                    if (s->streams[r]->priv_data == rt->rtsp_streams[i]) {
1812
                        if (s->streams[r]->discard != AVDISCARD_ALL) {
1813
                            if (!first)
1814
                                av_strlcat(rt->last_subscription, ",",
1815
                                           sizeof(rt->last_subscription));
1816
                            ff_rdt_subscribe_rule(
1817
                                rt->last_subscription,
1818
                                sizeof(rt->last_subscription), i, rule_nr);
1819
                            first = 0;
1820
                        }
1821
                        rule_nr++;
1822
                    }
1823
                }
1824
            }
1825
            av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
1826
            ff_rtsp_send_cmd(s, cmd, reply, NULL);
1827
            if (reply->status_code != RTSP_STATUS_OK)
1828
                return AVERROR_INVALIDDATA;
1829
            rt->need_subscription = 0;
1830

    
1831
            if (rt->state == RTSP_STATE_STREAMING)
1832
                rtsp_read_play (s);
1833
        }
1834
    }
1835

    
1836
    ret = rtsp_fetch_packet(s, pkt);
1837
    if (ret < 0)
1838
        return ret;
1839

    
1840
    /* send dummy request to keep TCP connection alive */
1841
    if ((rt->server_type == RTSP_SERVER_WMS ||
1842
         rt->server_type == RTSP_SERVER_REAL) &&
1843
        (av_gettime() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2) {
1844
        if (rt->server_type == RTSP_SERVER_WMS) {
1845
            snprintf(cmd, sizeof(cmd) - 1,
1846
                     "GET_PARAMETER %s RTSP/1.0\r\n",
1847
                     rt->control_uri);
1848
            ff_rtsp_send_cmd_async(s, cmd);
1849
        } else {
1850
            ff_rtsp_send_cmd_async(s, "OPTIONS * RTSP/1.0\r\n");
1851
        }
1852
    }
1853

    
1854
    return 0;
1855
}
1856

    
1857
/* pause the stream */
1858
static int rtsp_read_pause(AVFormatContext *s)
1859
{
1860
    RTSPState *rt = s->priv_data;
1861
    RTSPMessageHeader reply1, *reply = &reply1;
1862
    char cmd[1024];
1863

    
1864
    rt = s->priv_data;
1865

    
1866
    if (rt->state != RTSP_STATE_STREAMING)
1867
        return 0;
1868
    else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1869
        snprintf(cmd, sizeof(cmd),
1870
                 "PAUSE %s RTSP/1.0\r\n",
1871
                 rt->control_uri);
1872
        ff_rtsp_send_cmd(s, cmd, reply, NULL);
1873
        if (reply->status_code != RTSP_STATUS_OK) {
1874
            return -1;
1875
        }
1876
    }
1877
    rt->state = RTSP_STATE_PAUSED;
1878
    return 0;
1879
}
1880

    
1881
static int rtsp_read_seek(AVFormatContext *s, int stream_index,
1882
                          int64_t timestamp, int flags)
1883
{
1884
    RTSPState *rt = s->priv_data;
1885

    
1886
    rt->seek_timestamp = av_rescale_q(timestamp,
1887
                                      s->streams[stream_index]->time_base,
1888
                                      AV_TIME_BASE_Q);
1889
    switch(rt->state) {
1890
    default:
1891
    case RTSP_STATE_IDLE:
1892
        break;
1893
    case RTSP_STATE_STREAMING:
1894
        if (rtsp_read_pause(s) != 0)
1895
            return -1;
1896
        rt->state = RTSP_STATE_SEEKING;
1897
        if (rtsp_read_play(s) != 0)
1898
            return -1;
1899
        break;
1900
    case RTSP_STATE_PAUSED:
1901
        rt->state = RTSP_STATE_IDLE;
1902
        break;
1903
    }
1904
    return 0;
1905
}
1906

    
1907
static int rtsp_read_close(AVFormatContext *s)
1908
{
1909
    RTSPState *rt = s->priv_data;
1910
    char cmd[1024];
1911

    
1912
#if 0
1913
    /* NOTE: it is valid to flush the buffer here */
1914
    if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1915
        url_fclose(&rt->rtsp_gb);
1916
    }
1917
#endif
1918
    snprintf(cmd, sizeof(cmd),
1919
             "TEARDOWN %s RTSP/1.0\r\n",
1920
             rt->control_uri);
1921
    ff_rtsp_send_cmd_async(s, cmd);
1922

    
1923
    ff_rtsp_close_streams(s);
1924
    url_close(rt->rtsp_hd);
1925
    ff_network_close();
1926
    return 0;
1927
}
1928

    
1929
AVInputFormat rtsp_demuxer = {
1930
    "rtsp",
1931
    NULL_IF_CONFIG_SMALL("RTSP input format"),
1932
    sizeof(RTSPState),
1933
    rtsp_probe,
1934
    rtsp_read_header,
1935
    rtsp_read_packet,
1936
    rtsp_read_close,
1937
    rtsp_read_seek,
1938
    .flags = AVFMT_NOFILE,
1939
    .read_play = rtsp_read_play,
1940
    .read_pause = rtsp_read_pause,
1941
};
1942
#endif
1943

    
1944
static int sdp_probe(AVProbeData *p1)
1945
{
1946
    const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
1947

    
1948
    /* we look for a line beginning "c=IN IP4" */
1949
    while (p < p_end && *p != '\0') {
1950
        if (p + sizeof("c=IN IP4") - 1 < p_end &&
1951
            av_strstart(p, "c=IN IP4", NULL))
1952
            return AVPROBE_SCORE_MAX / 2;
1953

    
1954
        while (p < p_end - 1 && *p != '\n') p++;
1955
        if (++p >= p_end)
1956
            break;
1957
        if (*p == '\r')
1958
            p++;
1959
    }
1960
    return 0;
1961
}
1962

    
1963
#define SDP_MAX_SIZE 8192
1964

    
1965
static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap)
1966
{
1967
    RTSPState *rt = s->priv_data;
1968
    RTSPStream *rtsp_st;
1969
    int size, i, err;
1970
    char *content;
1971
    char url[1024];
1972

    
1973
    if (!ff_network_init())
1974
        return AVERROR(EIO);
1975

    
1976
    /* read the whole sdp file */
1977
    /* XXX: better loading */
1978
    content = av_malloc(SDP_MAX_SIZE);
1979
    size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
1980
    if (size <= 0) {
1981
        av_free(content);
1982
        return AVERROR_INVALIDDATA;
1983
    }
1984
    content[size] ='\0';
1985

    
1986
    sdp_parse(s, content);
1987
    av_free(content);
1988

    
1989
    /* open each RTP stream */
1990
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1991
        rtsp_st = rt->rtsp_streams[i];
1992

    
1993
        ff_url_join(url, sizeof(url), "rtp", NULL,
1994
                    inet_ntoa(rtsp_st->sdp_ip), rtsp_st->sdp_port,
1995
                    "?localport=%d&ttl=%d", rtsp_st->sdp_port,
1996
                    rtsp_st->sdp_ttl);
1997
        if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1998
            err = AVERROR_INVALIDDATA;
1999
            goto fail;
2000
        }
2001
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
2002
            goto fail;
2003
    }
2004
    return 0;
2005
fail:
2006
    ff_rtsp_close_streams(s);
2007
    ff_network_close();
2008
    return err;
2009
}
2010

    
2011
static int sdp_read_close(AVFormatContext *s)
2012
{
2013
    ff_rtsp_close_streams(s);
2014
    ff_network_close();
2015
    return 0;
2016
}
2017

    
2018
AVInputFormat sdp_demuxer = {
2019
    "sdp",
2020
    NULL_IF_CONFIG_SMALL("SDP"),
2021
    sizeof(RTSPState),
2022
    sdp_probe,
2023
    sdp_read_header,
2024
    rtsp_fetch_packet,
2025
    sdp_read_close,
2026
};