Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtsp.c @ 6e69f6c4

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
void ff_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
                    ff_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, RTSPMessageHeader *reply)
1300
{
1301
    RTSPState *rt = s->priv_data;
1302
    char cmd[1024];
1303
    unsigned char *content = NULL;
1304
    int ret;
1305

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

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

    
1334
    return 0;
1335
}
1336

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

    
1346
    rt->start_time = av_gettime();
1347

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

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

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

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

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

    
1401
    return 0;
1402
}
1403

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1594
    return 0;
1595
}
1596

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

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

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

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

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

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

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

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

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

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

    
1765
    return ret;
1766
}
1767

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

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

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

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

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

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

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

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

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

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

    
1853
    return 0;
1854
}
1855

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

    
1863
    rt = s->priv_data;
1864

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

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

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

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

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

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

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

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

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

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

    
1962
#define SDP_MAX_SIZE 8192
1963

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

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

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

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

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

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

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

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