Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtsp.c @ cbfa66d0

History | View | Annotate | Download (64.7 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 "network.h"
33
#include "os_support.h"
34
#include "rtsp.h"
35

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

    
41
//#define DEBUG
42
//#define DEBUG_RTP_TCP
43

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
611
static void *rtsp_rtp_mux_open(AVFormatContext *s, AVStream *st, URLContext *handle) {
612
    AVFormatContext *rtpctx;
613
    int ret;
614
    AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
615

    
616
    if (!rtp_format)
617
        return NULL;
618

    
619
    /* Allocate an AVFormatContext for each output stream */
620
    rtpctx = avformat_alloc_context();
621
    if (!rtpctx)
622
        return NULL;
623

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

    
634
    /* Remove the local codec, link to the original codec
635
     * context instead, to give the rtp muxer access to
636
     * codec parameters. */
637
    av_free(rtpctx->streams[0]->codec);
638
    rtpctx->streams[0]->codec = st->codec;
639

    
640
    url_fdopen(&rtpctx->pb, handle);
641
    ret = av_write_header(rtpctx);
642

    
643
    if (ret) {
644
        url_fclose(rtpctx->pb);
645
        av_free(rtpctx->streams[0]);
646
        av_free(rtpctx);
647
        return NULL;
648
    }
649

    
650
    /* Copy the RTP AVStream timebase back to the original AVStream */
651
    st->time_base = rtpctx->streams[0]->time_base;
652
    return rtpctx;
653
}
654

    
655
static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
656
{
657
    RTSPState *rt = s->priv_data;
658
    AVStream *st = NULL;
659

    
660
    /* open the RTP context */
661
    if (rtsp_st->stream_index >= 0)
662
        st = s->streams[rtsp_st->stream_index];
663
    if (!st)
664
        s->ctx_flags |= AVFMTCTX_NOHEADER;
665

    
666
    if (s->oformat) {
667
        rtsp_st->transport_priv = rtsp_rtp_mux_open(s, st, rtsp_st->rtp_handle);
668
        /* Ownage of rtp_handle is passed to the rtp mux context */
669
        rtsp_st->rtp_handle = NULL;
670
    } else if (rt->transport == RTSP_TRANSPORT_RDT)
671
        rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
672
                                            rtsp_st->dynamic_protocol_context,
673
                                            rtsp_st->dynamic_handler);
674
    else
675
        rtsp_st->transport_priv = rtp_parse_open(s, st, rtsp_st->rtp_handle,
676
                                         rtsp_st->sdp_payload_type,
677
                                         &rtsp_st->rtp_payload_data);
678

    
679
    if (!rtsp_st->transport_priv) {
680
         return AVERROR(ENOMEM);
681
    } else if (rt->transport != RTSP_TRANSPORT_RDT) {
682
        if (rtsp_st->dynamic_handler) {
683
            rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
684
                                           rtsp_st->dynamic_protocol_context,
685
                                           rtsp_st->dynamic_handler);
686
        }
687
    }
688

    
689
    return 0;
690
}
691

    
692
#if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
693
static int rtsp_probe(AVProbeData *p)
694
{
695
    if (av_strstart(p->filename, "rtsp:", NULL))
696
        return AVPROBE_SCORE_MAX;
697
    return 0;
698
}
699

    
700
static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
701
{
702
    const char *p;
703
    int v;
704

    
705
    p = *pp;
706
    skip_spaces(&p);
707
    v = strtol(p, (char **)&p, 10);
708
    if (*p == '-') {
709
        p++;
710
        *min_ptr = v;
711
        v = strtol(p, (char **)&p, 10);
712
        *max_ptr = v;
713
    } else {
714
        *min_ptr = v;
715
        *max_ptr = v;
716
    }
717
    *pp = p;
718
}
719

    
720
/* XXX: only one transport specification is parsed */
721
static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
722
{
723
    char transport_protocol[16];
724
    char profile[16];
725
    char lower_transport[16];
726
    char parameter[16];
727
    RTSPTransportField *th;
728
    char buf[256];
729

    
730
    reply->nb_transports = 0;
731

    
732
    for (;;) {
733
        skip_spaces(&p);
734
        if (*p == '\0')
735
            break;
736

    
737
        th = &reply->transports[reply->nb_transports];
738

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

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

    
801
                if (*p == '=') {
802
                    p++;
803
                    get_word_sep(buf, sizeof(buf), ";,", &p);
804
                    if (ff_inet_aton(buf, &ipaddr))
805
                        th->destination = ntohl(ipaddr.s_addr);
806
                }
807
            }
808
            while (*p != ';' && *p != '\0' && *p != ',')
809
                p++;
810
            if (*p == ';')
811
                p++;
812
        }
813
        if (*p == ',')
814
            p++;
815

    
816
        reply->nb_transports++;
817
    }
818
}
819

    
820
void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf)
821
{
822
    const char *p;
823

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

    
856
/* skip a RTP/TCP interleaved packet */
857
static void rtsp_skip_packet(AVFormatContext *s)
858
{
859
    RTSPState *rt = s->priv_data;
860
    int ret, len, len1;
861
    uint8_t buf[1024];
862

    
863
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
864
    if (ret != 3)
865
        return;
866
    len = AV_RB16(buf + 1);
867

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

    
870
    /* skip payload */
871
    while (len > 0) {
872
        len1 = len;
873
        if (len1 > sizeof(buf))
874
            len1 = sizeof(buf);
875
        ret = url_read_complete(rt->rtsp_hd, buf, len1);
876
        if (ret != len1)
877
            return;
878
        len -= len1;
879
    }
880
}
881

    
882
int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
883
                       unsigned char **content_ptr,
884
                       int return_on_interleaved_data)
885
{
886
    RTSPState *rt = s->priv_data;
887
    char buf[4096], buf1[1024], *q;
888
    unsigned char ch;
889
    const char *p;
890
    int ret, content_length, line_count = 0;
891
    unsigned char *content = NULL;
892

    
893
    memset(reply, 0, sizeof(*reply));
894

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

    
921
        dprintf(s, "line='%s'\n", buf);
922

    
923
        /* test if last line */
924
        if (buf[0] == '\0')
925
            break;
926
        p = buf;
927
        if (line_count == 0) {
928
            /* get reply code */
929
            get_word(buf1, sizeof(buf1), &p);
930
            get_word(buf1, sizeof(buf1), &p);
931
            reply->status_code = atoi(buf1);
932
        } else {
933
            ff_rtsp_parse_line(reply, p);
934
            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
935
            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
936
        }
937
        line_count++;
938
    }
939

    
940
    if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
941
        av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
942

    
943
    content_length = reply->content_length;
944
    if (content_length > 0) {
945
        /* leave some room for a trailing '\0' (useful for simple parsing) */
946
        content = av_malloc(content_length + 1);
947
        (void)url_read_complete(rt->rtsp_hd, content, content_length);
948
        content[content_length] = '\0';
949
    }
950
    if (content_ptr)
951
        *content_ptr = content;
952
    else
953
        av_free(content);
954

    
955
    /* EOS */
956
    if (reply->notice == 2101 /* End-of-Stream Reached */      ||
957
        reply->notice == 2104 /* Start-of-Stream Reached */    ||
958
        reply->notice == 2306 /* Continuous Feed Terminated */) {
959
        rt->state = RTSP_STATE_IDLE;
960
    } else if (reply->notice >= 4400 && reply->notice < 5500) {
961
        return AVERROR(EIO); /* data or server error */
962
    } else if (reply->notice == 2401 /* Ticket Expired */ ||
963
             (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
964
        return AVERROR(EPERM);
965

    
966
    return 0;
967
}
968

    
969
void ff_rtsp_send_cmd_with_content_async(AVFormatContext *s,
970
                                         const char *cmd,
971
                                         const unsigned char *send_content,
972
                                         int send_content_length)
973
{
974
    RTSPState *rt = s->priv_data;
975
    char buf[4096], buf1[1024];
976

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

    
993
    dprintf(s, "Sending:\n%s--\n", buf);
994

    
995
    url_write(rt->rtsp_hd, buf, strlen(buf));
996
    if (send_content_length > 0 && send_content)
997
        url_write(rt->rtsp_hd, send_content, send_content_length);
998
    rt->last_cmd_time = av_gettime();
999
}
1000

    
1001
void ff_rtsp_send_cmd_async(AVFormatContext *s, const char *cmd)
1002
{
1003
    ff_rtsp_send_cmd_with_content_async(s, cmd, NULL, 0);
1004
}
1005

    
1006
void ff_rtsp_send_cmd(AVFormatContext *s,
1007
                      const char *cmd, RTSPMessageHeader *reply,
1008
                      unsigned char **content_ptr)
1009
{
1010
    ff_rtsp_send_cmd_async(s, cmd);
1011

    
1012
    ff_rtsp_read_reply(s, reply, content_ptr, 0);
1013
}
1014

    
1015
void ff_rtsp_send_cmd_with_content(AVFormatContext *s,
1016
                                const char *cmd,
1017
                                RTSPMessageHeader *reply,
1018
                                unsigned char **content_ptr,
1019
                                const unsigned char *send_content,
1020
                                int send_content_length)
1021
{
1022
    ff_rtsp_send_cmd_with_content_async(s, cmd, send_content, send_content_length);
1023

    
1024
    ff_rtsp_read_reply(s, reply, content_ptr, 0);
1025
}
1026

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

    
1040
    if (rt->transport == RTSP_TRANSPORT_RDT)
1041
        trans_pref = "x-pn-tng";
1042
    else
1043
        trans_pref = "RTP/AVP";
1044

    
1045
    /* default timeout: 1 minute */
1046
    rt->timeout = 60;
1047

    
1048
    /* for each stream, make the setup request */
1049
    /* XXX: we assume the same server is used for the control of each
1050
     * RTSP stream */
1051

    
1052
    for (j = RTSP_RTP_PORT_MIN, i = 0; i < rt->nb_rtsp_streams; ++i) {
1053
        char transport[2048];
1054

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

    
1079
        /* RTP/UDP */
1080
        if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1081
            char buf[256];
1082

    
1083
            if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1084
                port = reply->transports[0].client_port_min;
1085
                goto have_port;
1086
            }
1087

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

    
1100
#if 0
1101
            /* then try on any port */
1102
            if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
1103
                err = AVERROR_INVALIDDATA;
1104
                goto fail;
1105
            }
1106
#endif
1107

    
1108
        rtp_opened:
1109
            port = rtp_get_local_port(rtsp_st->rtp_handle);
1110
        have_port:
1111
            snprintf(transport, sizeof(transport) - 1,
1112
                     "%s/UDP;", trans_pref);
1113
            if (rt->server_type != RTSP_SERVER_REAL)
1114
                av_strlcat(transport, "unicast;", sizeof(transport));
1115
            av_strlcatf(transport, sizeof(transport),
1116
                     "client_port=%d", port);
1117
            if (rt->transport == RTSP_TRANSPORT_RTP &&
1118
                !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1119
                av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1120
        }
1121

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

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

    
1173
        /* XXX: same protocol for all streams is required */
1174
        if (i > 0) {
1175
            if (reply->transports[0].lower_transport != rt->lower_transport ||
1176
                reply->transports[0].transport != rt->transport) {
1177
                err = AVERROR_INVALIDDATA;
1178
                goto fail;
1179
            }
1180
        } else {
1181
            rt->lower_transport = reply->transports[0].lower_transport;
1182
            rt->transport = reply->transports[0].transport;
1183
        }
1184

    
1185
        /* close RTP connection if not choosen */
1186
        if (reply->transports[0].lower_transport != RTSP_LOWER_TRANSPORT_UDP &&
1187
            (lower_transport == RTSP_LOWER_TRANSPORT_UDP)) {
1188
            url_close(rtsp_st->rtp_handle);
1189
            rtsp_st->rtp_handle = NULL;
1190
        }
1191

    
1192
        switch(reply->transports[0].lower_transport) {
1193
        case RTSP_LOWER_TRANSPORT_TCP:
1194
            rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1195
            rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1196
            break;
1197

    
1198
        case RTSP_LOWER_TRANSPORT_UDP: {
1199
            char url[1024];
1200

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

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

    
1241
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1242
            goto fail;
1243
    }
1244

    
1245
    if (reply->timeout > 0)
1246
        rt->timeout = reply->timeout;
1247

    
1248
    if (rt->server_type == RTSP_SERVER_REAL)
1249
        rt->need_subscription = 1;
1250

    
1251
    return 0;
1252

    
1253
fail:
1254
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1255
        if (rt->rtsp_streams[i]->rtp_handle) {
1256
            url_close(rt->rtsp_streams[i]->rtp_handle);
1257
            rt->rtsp_streams[i]->rtp_handle = NULL;
1258
        }
1259
    }
1260
    return err;
1261
}
1262

    
1263
static int rtsp_read_play(AVFormatContext *s)
1264
{
1265
    RTSPState *rt = s->priv_data;
1266
    RTSPMessageHeader reply1, *reply = &reply1;
1267
    char cmd[1024];
1268

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

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

    
1292
static int rtsp_setup_input_streams(AVFormatContext *s)
1293
{
1294
    RTSPState *rt = s->priv_data;
1295
    RTSPMessageHeader reply1, *reply = &reply1;
1296
    char cmd[1024];
1297
    unsigned char *content = NULL;
1298
    int ret;
1299

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

    
1322
    /* now we got the SDP description, we parse it */
1323
    ret = sdp_parse(s, (const char *)content);
1324
    av_freep(&content);
1325
    if (ret < 0)
1326
        return AVERROR_INVALIDDATA;
1327

    
1328
    return 0;
1329
}
1330

    
1331
static int rtsp_setup_output_streams(AVFormatContext *s)
1332
{
1333
    RTSPState *rt = s->priv_data;
1334
    RTSPMessageHeader reply1, *reply = &reply1;
1335
    char cmd[1024];
1336
    int i;
1337
    char *sdp;
1338

    
1339
    /* Announce the stream */
1340
    snprintf(cmd, sizeof(cmd),
1341
             "ANNOUNCE %s RTSP/1.0\r\n"
1342
             "Content-Type: application/sdp\r\n",
1343
             rt->control_uri);
1344
    sdp = av_mallocz(8192);
1345
    if (sdp == NULL)
1346
        return AVERROR(ENOMEM);
1347
    if (avf_sdp_create(&s, 1, sdp, 8192)) {
1348
        av_free(sdp);
1349
        return AVERROR_INVALIDDATA;
1350
    }
1351
    av_log(s, AV_LOG_INFO, "SDP:\n%s\n", sdp);
1352
    ff_rtsp_send_cmd_with_content(s, cmd, reply, NULL, sdp, strlen(sdp));
1353
    av_free(sdp);
1354
    if (reply->status_code != RTSP_STATUS_OK)
1355
        return AVERROR_INVALIDDATA;
1356

    
1357
    /* Set up the RTSPStreams for each AVStream */
1358
    for (i = 0; i < s->nb_streams; i++) {
1359
        RTSPStream *rtsp_st;
1360
        AVStream *st = s->streams[i];
1361

    
1362
        rtsp_st = av_mallocz(sizeof(RTSPStream));
1363
        if (!rtsp_st)
1364
            return AVERROR(ENOMEM);
1365
        dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
1366

    
1367
        st->priv_data = rtsp_st;
1368
        rtsp_st->stream_index = i;
1369

    
1370
        av_strlcpy(rtsp_st->control_url, rt->control_uri, sizeof(rtsp_st->control_url));
1371
        /* Note, this must match the relative uri set in the sdp content */
1372
        av_strlcatf(rtsp_st->control_url, sizeof(rtsp_st->control_url),
1373
                    "/streamid=%d", i);
1374
    }
1375

    
1376
    return 0;
1377
}
1378

    
1379
int ff_rtsp_connect(AVFormatContext *s)
1380
{
1381
    RTSPState *rt = s->priv_data;
1382
    char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1383
    char *option_list, *option, *filename;
1384
    URLContext *rtsp_hd;
1385
    int port, err, tcp_fd;
1386
    RTSPMessageHeader reply1, *reply = &reply1;
1387
    int lower_transport_mask = 0;
1388
    char real_challenge[64];
1389
    struct sockaddr_storage peer;
1390
    socklen_t peer_len = sizeof(peer);
1391

    
1392
    if (!ff_network_init())
1393
        return AVERROR(EIO);
1394
redirect:
1395
    /* extract hostname and port */
1396
    ff_url_split(NULL, 0, auth, sizeof(auth),
1397
                 host, sizeof(host), &port, path, sizeof(path), s->filename);
1398
    if (*auth) {
1399
        int auth_len = strlen(auth), b64_len = ((auth_len + 2) / 3) * 4 + 1;
1400

    
1401
        if (!(rt->auth_b64 = av_malloc(b64_len)))
1402
            return AVERROR(ENOMEM);
1403
        if (!av_base64_encode(rt->auth_b64, b64_len, auth, auth_len)) {
1404
            err = AVERROR(EINVAL);
1405
            goto fail;
1406
        }
1407
    }
1408
    if (port < 0)
1409
        port = RTSP_DEFAULT_PORT;
1410

    
1411
    /* search for options */
1412
    option_list = strchr(path, '?');
1413
    if (option_list) {
1414
        filename = strchr(s->filename, '?');
1415
        while (option_list) {
1416
            /* move the option pointer */
1417
            option = ++option_list;
1418
            option_list = strchr(option_list, '&');
1419
            if (option_list)
1420
                *option_list = 0;
1421

    
1422
            /* handle the options */
1423
            if (!strcmp(option, "udp")) {
1424
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP);
1425
            } else if (!strcmp(option, "multicast")) {
1426
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
1427
            } else if (!strcmp(option, "tcp")) {
1428
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_TCP);
1429
            } else {
1430
                strcpy(++filename, option);
1431
                filename += strlen(option);
1432
                if (option_list) *filename = '&';
1433
            }
1434
        }
1435
        *filename = 0;
1436
    }
1437

    
1438
    if (!lower_transport_mask)
1439
        lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1440

    
1441
    if (s->oformat) {
1442
        /* Only UDP output is supported at the moment. */
1443
        lower_transport_mask &= 1 << RTSP_LOWER_TRANSPORT_UDP;
1444
        if (!lower_transport_mask) {
1445
            av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1446
                                    "only UDP is supported for output.\n");
1447
            err = AVERROR(EINVAL);
1448
            goto fail;
1449
        }
1450
    }
1451

    
1452
    /* open the tcp connexion */
1453
    ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port, NULL);
1454
    if (url_open(&rtsp_hd, tcpname, URL_RDWR) < 0) {
1455
        err = AVERROR(EIO);
1456
        goto fail;
1457
    }
1458
    rt->rtsp_hd = rtsp_hd;
1459
    rt->seq = 0;
1460

    
1461
    tcp_fd = url_get_file_handle(rtsp_hd);
1462
    if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1463
        getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1464
                    NULL, 0, NI_NUMERICHOST);
1465
    }
1466

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

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

    
1507
    if (s->iformat)
1508
        err = rtsp_setup_input_streams(s);
1509
    else
1510
        err = rtsp_setup_output_streams(s);
1511
    if (err)
1512
        goto fail;
1513

    
1514
    do {
1515
        int lower_transport = ff_log2_tab[lower_transport_mask &
1516
                                  ~(lower_transport_mask - 1)];
1517

    
1518
        err = make_setup_request(s, host, port, lower_transport,
1519
                                 rt->server_type == RTSP_SERVER_REAL ?
1520
                                     real_challenge : NULL);
1521
        if (err < 0)
1522
            goto fail;
1523
        lower_transport_mask &= ~(1 << lower_transport);
1524
        if (lower_transport_mask == 0 && err == 1) {
1525
            err = AVERROR(FF_NETERROR(EPROTONOSUPPORT));
1526
            goto fail;
1527
        }
1528
    } while (err);
1529

    
1530
    rt->state = RTSP_STATE_IDLE;
1531
    rt->seek_timestamp = 0; /* default is to start stream at position zero */
1532
    return 0;
1533
 fail:
1534
    ff_rtsp_close_streams(s);
1535
    url_close(rt->rtsp_hd);
1536
    if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1537
        av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1538
        av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1539
               reply->status_code,
1540
               s->filename);
1541
        goto redirect;
1542
    }
1543
    ff_network_close();
1544
    return err;
1545
}
1546
#endif
1547

    
1548
#if CONFIG_RTSP_DEMUXER
1549
static int rtsp_read_header(AVFormatContext *s,
1550
                            AVFormatParameters *ap)
1551
{
1552
    RTSPState *rt = s->priv_data;
1553
    int ret;
1554

    
1555
    ret = ff_rtsp_connect(s);
1556
    if (ret)
1557
        return ret;
1558

    
1559
    if (ap->initial_pause) {
1560
         /* do not start immediately */
1561
    } else {
1562
         if (rtsp_read_play(s) < 0) {
1563
            ff_rtsp_close_streams(s);
1564
            url_close(rt->rtsp_hd);
1565
            return AVERROR_INVALIDDATA;
1566
        }
1567
    }
1568

    
1569
    return 0;
1570
}
1571

    
1572
static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1573
                           uint8_t *buf, int buf_size)
1574
{
1575
    RTSPState *rt = s->priv_data;
1576
    RTSPStream *rtsp_st;
1577
    fd_set rfds;
1578
    int fd, fd_max, n, i, ret, tcp_fd;
1579
    struct timeval tv;
1580

    
1581
    for (;;) {
1582
        if (url_interrupt_cb())
1583
            return AVERROR(EINTR);
1584
        FD_ZERO(&rfds);
1585
        if (rt->rtsp_hd) {
1586
            tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd);
1587
            FD_SET(tcp_fd, &rfds);
1588
        } else {
1589
            fd_max = 0;
1590
            tcp_fd = -1;
1591
        }
1592
        for (i = 0; i < rt->nb_rtsp_streams; i++) {
1593
            rtsp_st = rt->rtsp_streams[i];
1594
            if (rtsp_st->rtp_handle) {
1595
                /* currently, we cannot probe RTCP handle because of
1596
                 * blocking restrictions */
1597
                fd = url_get_file_handle(rtsp_st->rtp_handle);
1598
                if (fd > fd_max)
1599
                    fd_max = fd;
1600
                FD_SET(fd, &rfds);
1601
            }
1602
        }
1603
        tv.tv_sec = 0;
1604
        tv.tv_usec = 100 * 1000;
1605
        n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
1606
        if (n > 0) {
1607
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1608
                rtsp_st = rt->rtsp_streams[i];
1609
                if (rtsp_st->rtp_handle) {
1610
                    fd = url_get_file_handle(rtsp_st->rtp_handle);
1611
                    if (FD_ISSET(fd, &rfds)) {
1612
                        ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
1613
                        if (ret > 0) {
1614
                            *prtsp_st = rtsp_st;
1615
                            return ret;
1616
                        }
1617
                    }
1618
                }
1619
            }
1620
#if CONFIG_RTSP_DEMUXER
1621
            if (tcp_fd != -1 && FD_ISSET(tcp_fd, &rfds)) {
1622
                RTSPMessageHeader reply;
1623

    
1624
                ff_rtsp_read_reply(s, &reply, NULL, 0);
1625
                /* XXX: parse message */
1626
                if (rt->state != RTSP_STATE_STREAMING)
1627
                    return 0;
1628
            }
1629
#endif
1630
        }
1631
    }
1632
}
1633

    
1634
static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1635
                           uint8_t *buf, int buf_size)
1636
{
1637
    RTSPState *rt = s->priv_data;
1638
    int id, len, i, ret;
1639
    RTSPStream *rtsp_st;
1640

    
1641
#ifdef DEBUG_RTP_TCP
1642
    dprintf(s, "tcp_read_packet:\n");
1643
#endif
1644
redo:
1645
    for (;;) {
1646
        RTSPMessageHeader reply;
1647

    
1648
        ret = ff_rtsp_read_reply(s, &reply, NULL, 1);
1649
        if (ret == -1)
1650
            return -1;
1651
        if (ret == 1) /* received '$' */
1652
            break;
1653
        /* XXX: parse message */
1654
        if (rt->state != RTSP_STATE_STREAMING)
1655
            return 0;
1656
    }
1657
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
1658
    if (ret != 3)
1659
        return -1;
1660
    id  = buf[0];
1661
    len = AV_RB16(buf + 1);
1662
#ifdef DEBUG_RTP_TCP
1663
    dprintf(s, "id=%d len=%d\n", id, len);
1664
#endif
1665
    if (len > buf_size || len < 12)
1666
        goto redo;
1667
    /* get the data */
1668
    ret = url_read_complete(rt->rtsp_hd, buf, len);
1669
    if (ret != len)
1670
        return -1;
1671
    if (rt->transport == RTSP_TRANSPORT_RDT &&
1672
        ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
1673
        return -1;
1674

    
1675
    /* find the matching stream */
1676
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1677
        rtsp_st = rt->rtsp_streams[i];
1678
        if (id >= rtsp_st->interleaved_min &&
1679
            id <= rtsp_st->interleaved_max)
1680
            goto found;
1681
    }
1682
    goto redo;
1683
found:
1684
    *prtsp_st = rtsp_st;
1685
    return len;
1686
}
1687

    
1688
static int rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
1689
{
1690
    RTSPState *rt = s->priv_data;
1691
    int ret, len;
1692
    uint8_t buf[10 * RTP_MAX_PACKET_LENGTH];
1693
    RTSPStream *rtsp_st;
1694

    
1695
    /* get next frames from the same RTP packet */
1696
    if (rt->cur_transport_priv) {
1697
        if (rt->transport == RTSP_TRANSPORT_RDT) {
1698
            ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1699
        } else
1700
            ret = rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1701
        if (ret == 0) {
1702
            rt->cur_transport_priv = NULL;
1703
            return 0;
1704
        } else if (ret == 1) {
1705
            return 0;
1706
        } else
1707
            rt->cur_transport_priv = NULL;
1708
    }
1709

    
1710
    /* read next RTP packet */
1711
 redo:
1712
    switch(rt->lower_transport) {
1713
    default:
1714
#if CONFIG_RTSP_DEMUXER
1715
    case RTSP_LOWER_TRANSPORT_TCP:
1716
        len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1717
        break;
1718
#endif
1719
    case RTSP_LOWER_TRANSPORT_UDP:
1720
    case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1721
        len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1722
        if (len >=0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
1723
            rtp_check_and_send_back_rr(rtsp_st->transport_priv, len);
1724
        break;
1725
    }
1726
    if (len < 0)
1727
        return len;
1728
    if (len == 0)
1729
        return AVERROR_EOF;
1730
    if (rt->transport == RTSP_TRANSPORT_RDT) {
1731
        ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1732
    } else
1733
        ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1734
    if (ret < 0)
1735
        goto redo;
1736
    if (ret == 1)
1737
        /* more packets may follow, so we save the RTP context */
1738
        rt->cur_transport_priv = rtsp_st->transport_priv;
1739

    
1740
    return ret;
1741
}
1742

    
1743
static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt)
1744
{
1745
    RTSPState *rt = s->priv_data;
1746
    int ret;
1747
    RTSPMessageHeader reply1, *reply = &reply1;
1748
    char cmd[1024];
1749

    
1750
    if (rt->server_type == RTSP_SERVER_REAL) {
1751
        int i;
1752
        enum AVDiscard cache[MAX_STREAMS];
1753

    
1754
        for (i = 0; i < s->nb_streams; i++)
1755
            cache[i] = s->streams[i]->discard;
1756

    
1757
        if (!rt->need_subscription) {
1758
            if (memcmp (cache, rt->real_setup_cache,
1759
                        sizeof(enum AVDiscard) * s->nb_streams)) {
1760
                snprintf(cmd, sizeof(cmd),
1761
                         "SET_PARAMETER %s RTSP/1.0\r\n"
1762
                         "Unsubscribe: %s\r\n",
1763
                         rt->control_uri, rt->last_subscription);
1764
                ff_rtsp_send_cmd(s, cmd, reply, NULL);
1765
                if (reply->status_code != RTSP_STATUS_OK)
1766
                    return AVERROR_INVALIDDATA;
1767
                rt->need_subscription = 1;
1768
            }
1769
        }
1770

    
1771
        if (rt->need_subscription) {
1772
            int r, rule_nr, first = 1;
1773

    
1774
            memcpy(rt->real_setup_cache, cache,
1775
                   sizeof(enum AVDiscard) * s->nb_streams);
1776
            rt->last_subscription[0] = 0;
1777

    
1778
            snprintf(cmd, sizeof(cmd),
1779
                     "SET_PARAMETER %s RTSP/1.0\r\n"
1780
                     "Subscribe: ",
1781
                     rt->control_uri);
1782
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1783
                rule_nr = 0;
1784
                for (r = 0; r < s->nb_streams; r++) {
1785
                    if (s->streams[r]->priv_data == rt->rtsp_streams[i]) {
1786
                        if (s->streams[r]->discard != AVDISCARD_ALL) {
1787
                            if (!first)
1788
                                av_strlcat(rt->last_subscription, ",",
1789
                                           sizeof(rt->last_subscription));
1790
                            ff_rdt_subscribe_rule(
1791
                                rt->last_subscription,
1792
                                sizeof(rt->last_subscription), i, rule_nr);
1793
                            first = 0;
1794
                        }
1795
                        rule_nr++;
1796
                    }
1797
                }
1798
            }
1799
            av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
1800
            ff_rtsp_send_cmd(s, cmd, reply, NULL);
1801
            if (reply->status_code != RTSP_STATUS_OK)
1802
                return AVERROR_INVALIDDATA;
1803
            rt->need_subscription = 0;
1804

    
1805
            if (rt->state == RTSP_STATE_STREAMING)
1806
                rtsp_read_play (s);
1807
        }
1808
    }
1809

    
1810
    ret = rtsp_fetch_packet(s, pkt);
1811
    if (ret < 0)
1812
        return ret;
1813

    
1814
    /* send dummy request to keep TCP connection alive */
1815
    if ((rt->server_type == RTSP_SERVER_WMS ||
1816
         rt->server_type == RTSP_SERVER_REAL) &&
1817
        (av_gettime() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2) {
1818
        if (rt->server_type == RTSP_SERVER_WMS) {
1819
            snprintf(cmd, sizeof(cmd) - 1,
1820
                     "GET_PARAMETER %s RTSP/1.0\r\n",
1821
                     rt->control_uri);
1822
            ff_rtsp_send_cmd_async(s, cmd);
1823
        } else {
1824
            ff_rtsp_send_cmd_async(s, "OPTIONS * RTSP/1.0\r\n");
1825
        }
1826
    }
1827

    
1828
    return 0;
1829
}
1830

    
1831
/* pause the stream */
1832
static int rtsp_read_pause(AVFormatContext *s)
1833
{
1834
    RTSPState *rt = s->priv_data;
1835
    RTSPMessageHeader reply1, *reply = &reply1;
1836
    char cmd[1024];
1837

    
1838
    rt = s->priv_data;
1839

    
1840
    if (rt->state != RTSP_STATE_STREAMING)
1841
        return 0;
1842
    else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1843
        snprintf(cmd, sizeof(cmd),
1844
                 "PAUSE %s RTSP/1.0\r\n",
1845
                 rt->control_uri);
1846
        ff_rtsp_send_cmd(s, cmd, reply, NULL);
1847
        if (reply->status_code != RTSP_STATUS_OK) {
1848
            return -1;
1849
        }
1850
    }
1851
    rt->state = RTSP_STATE_PAUSED;
1852
    return 0;
1853
}
1854

    
1855
static int rtsp_read_seek(AVFormatContext *s, int stream_index,
1856
                          int64_t timestamp, int flags)
1857
{
1858
    RTSPState *rt = s->priv_data;
1859

    
1860
    rt->seek_timestamp = av_rescale_q(timestamp,
1861
                                      s->streams[stream_index]->time_base,
1862
                                      AV_TIME_BASE_Q);
1863
    switch(rt->state) {
1864
    default:
1865
    case RTSP_STATE_IDLE:
1866
        break;
1867
    case RTSP_STATE_STREAMING:
1868
        if (rtsp_read_pause(s) != 0)
1869
            return -1;
1870
        rt->state = RTSP_STATE_SEEKING;
1871
        if (rtsp_read_play(s) != 0)
1872
            return -1;
1873
        break;
1874
    case RTSP_STATE_PAUSED:
1875
        rt->state = RTSP_STATE_IDLE;
1876
        break;
1877
    }
1878
    return 0;
1879
}
1880

    
1881
static int rtsp_read_close(AVFormatContext *s)
1882
{
1883
    RTSPState *rt = s->priv_data;
1884
    char cmd[1024];
1885

    
1886
#if 0
1887
    /* NOTE: it is valid to flush the buffer here */
1888
    if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1889
        url_fclose(&rt->rtsp_gb);
1890
    }
1891
#endif
1892
    snprintf(cmd, sizeof(cmd),
1893
             "TEARDOWN %s RTSP/1.0\r\n",
1894
             rt->control_uri);
1895
    ff_rtsp_send_cmd_async(s, cmd);
1896

    
1897
    ff_rtsp_close_streams(s);
1898
    url_close(rt->rtsp_hd);
1899
    ff_network_close();
1900
    return 0;
1901
}
1902

    
1903
AVInputFormat rtsp_demuxer = {
1904
    "rtsp",
1905
    NULL_IF_CONFIG_SMALL("RTSP input format"),
1906
    sizeof(RTSPState),
1907
    rtsp_probe,
1908
    rtsp_read_header,
1909
    rtsp_read_packet,
1910
    rtsp_read_close,
1911
    rtsp_read_seek,
1912
    .flags = AVFMT_NOFILE,
1913
    .read_play = rtsp_read_play,
1914
    .read_pause = rtsp_read_pause,
1915
};
1916
#endif
1917

    
1918
static int sdp_probe(AVProbeData *p1)
1919
{
1920
    const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
1921

    
1922
    /* we look for a line beginning "c=IN IP4" */
1923
    while (p < p_end && *p != '\0') {
1924
        if (p + sizeof("c=IN IP4") - 1 < p_end &&
1925
            av_strstart(p, "c=IN IP4", NULL))
1926
            return AVPROBE_SCORE_MAX / 2;
1927

    
1928
        while (p < p_end - 1 && *p != '\n') p++;
1929
        if (++p >= p_end)
1930
            break;
1931
        if (*p == '\r')
1932
            p++;
1933
    }
1934
    return 0;
1935
}
1936

    
1937
#define SDP_MAX_SIZE 8192
1938

    
1939
static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap)
1940
{
1941
    RTSPState *rt = s->priv_data;
1942
    RTSPStream *rtsp_st;
1943
    int size, i, err;
1944
    char *content;
1945
    char url[1024];
1946

    
1947
    if (!ff_network_init())
1948
        return AVERROR(EIO);
1949

    
1950
    /* read the whole sdp file */
1951
    /* XXX: better loading */
1952
    content = av_malloc(SDP_MAX_SIZE);
1953
    size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
1954
    if (size <= 0) {
1955
        av_free(content);
1956
        return AVERROR_INVALIDDATA;
1957
    }
1958
    content[size] ='\0';
1959

    
1960
    sdp_parse(s, content);
1961
    av_free(content);
1962

    
1963
    /* open each RTP stream */
1964
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1965
        rtsp_st = rt->rtsp_streams[i];
1966

    
1967
        ff_url_join(url, sizeof(url), "rtp", NULL,
1968
                    inet_ntoa(rtsp_st->sdp_ip), rtsp_st->sdp_port,
1969
                    "?localport=%d&ttl=%d", rtsp_st->sdp_port,
1970
                    rtsp_st->sdp_ttl);
1971
        if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1972
            err = AVERROR_INVALIDDATA;
1973
            goto fail;
1974
        }
1975
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1976
            goto fail;
1977
    }
1978
    return 0;
1979
fail:
1980
    ff_rtsp_close_streams(s);
1981
    ff_network_close();
1982
    return err;
1983
}
1984

    
1985
static int sdp_read_close(AVFormatContext *s)
1986
{
1987
    ff_rtsp_close_streams(s);
1988
    ff_network_close();
1989
    return 0;
1990
}
1991

    
1992
AVInputFormat sdp_demuxer = {
1993
    "sdp",
1994
    NULL_IF_CONFIG_SMALL("SDP"),
1995
    sizeof(RTSPState),
1996
    sdp_probe,
1997
    sdp_read_header,
1998
    rtsp_fetch_packet,
1999
    sdp_read_close,
2000
};