Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtsp.c @ c07c6f81

History | View | Annotate | Download (65.8 KB)

1 1617ad97 Fabrice Bellard
/*
2 93ced3e8 Fabrice Bellard
 * RTSP/SDP client
3 406792e7 Diego Biurrun
 * Copyright (c) 2002 Fabrice Bellard
4 1617ad97 Fabrice Bellard
 *
5 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 1617ad97 Fabrice Bellard
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 1617ad97 Fabrice Bellard
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 1617ad97 Fabrice Bellard
 * 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 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 1617ad97 Fabrice Bellard
 */
21 245976da Diego Biurrun
22 f9337897 Ronald S. Bultje
#include "libavutil/base64.h"
23 245976da Diego Biurrun
#include "libavutil/avstring.h"
24 6a5d31ac Diego Biurrun
#include "libavutil/intreadwrite.h"
25 1617ad97 Fabrice Bellard
#include "avformat.h"
26
27 db0ed93e Marc Hoffman
#include <sys/time.h>
28 b250f9c6 Aurelien Jacobs
#if HAVE_SYS_SELECT_H
29 933bd8e2 Baptiste Coudurier
#include <sys/select.h>
30 6ad1c9c9 Baptiste Coudurier
#endif
31 ea452b54 Aurelien Jacobs
#include <strings.h>
32 e4a9e3cc Aurelien Jacobs
#include "internal.h"
33 42572ef5 Ramiro Polla
#include "network.h"
34 cbfa66d0 Dave Yeo
#include "os_support.h"
35 c971ff19 Luca Abeni
#include "rtsp.h"
36 1617ad97 Fabrice Bellard
37 302879cb Luca Abeni
#include "rtpdec.h"
38 e9dea59f Ronald S. Bultje
#include "rdt.h"
39 f65919af Martin Storsjö
#include "rtpdec_asf.h"
40
#include "rtpdec_vorbis.h"
41 4934884a Ryan Martell
42 1617ad97 Fabrice Bellard
//#define DEBUG
43 b6892136 Fabrice Bellard
//#define DEBUG_RTP_TCP
44 1617ad97 Fabrice Bellard
45 c482500f Ronald S. Bultje
#if LIBAVFORMAT_VERSION_INT < (53 << 16)
46 90abbdba Ronald S. Bultje
int rtsp_default_protocols = (1 << RTSP_LOWER_TRANSPORT_UDP);
47 c482500f Ronald S. Bultje
#endif
48 85fb7b34 Fabrice Bellard
49 1ef36a70 Ronald S. Bultje
#define SPACE_CHARS " \t\r\n"
50 da1e126e Ronald S. Bultje
/* 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 1617ad97 Fabrice Bellard
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 1ef36a70 Ronald S. Bultje
static void get_word_until_chars(char *buf, int buf_size,
63
                                 const char *sep, const char **pp)
64 1617ad97 Fabrice Bellard
{
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 1ef36a70 Ronald S. Bultje
static void get_word_sep(char *buf, int buf_size, const char *sep,
82
                         const char **pp)
83 1617ad97 Fabrice Bellard
{
84 1ef36a70 Ronald S. Bultje
    if (**pp == '/') (*pp)++;
85
    get_word_until_chars(buf, buf_size, sep, pp);
86
}
87 1617ad97 Fabrice Bellard
88 1ef36a70 Ronald S. Bultje
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 1617ad97 Fabrice Bellard
}
92
93 c8965800 Ronald S. Bultje
/* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
94 8f3c87f3 Ronald S. Bultje
static int sdp_parse_rtpmap(AVFormatContext *s,
95
                            AVCodecContext *codec, RTSPStream *rtsp_st,
96 c8965800 Ronald S. Bultje
                            int payload_type, const char *p)
97 93ced3e8 Fabrice Bellard
{
98
    char buf[256];
99 d1ccf0e0 Romain Degez
    int i;
100
    AVCodec *c;
101 7b49ce2e Stefan Huehner
    const char *c_name;
102 93ced3e8 Fabrice Bellard
103 d1ccf0e0 Romain Degez
    /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and
104 9d50d396 Ronald S. Bultje
     * 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 d1ccf0e0 Romain Degez
    if (payload_type >= RTP_PT_PRIVATE) {
110 c8965800 Ronald S. Bultje
        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 d1ccf0e0 Romain Degez
                break;
120
            }
121 4934884a Ryan Martell
        }
122 93ced3e8 Fabrice Bellard
    } else {
123 c8965800 Ronald S. Bultje
        /* We are in a standard case
124
         * (from http://www.iana.org/assignments/rtp-parameters). */
125 d1ccf0e0 Romain Degez
        /* search into AVRtpPayloadTypes[] */
126 7ed19d7f Luca Abeni
        codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
127 d1ccf0e0 Romain Degez
    }
128
129
    c = avcodec_find_decoder(codec->codec_id);
130
    if (c && c->name)
131 7b49ce2e Stefan Huehner
        c_name = c->name;
132 d1ccf0e0 Romain Degez
    else
133 170870b7 Ronald S. Bultje
        c_name = "(null)";
134 d1ccf0e0 Romain Degez
135 7515ed0c Ronald S. Bultje
    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 d1ccf0e0 Romain Degez
        }
153 7515ed0c Ronald S. Bultje
        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 93ced3e8 Fabrice Bellard
}
166
167 c8965800 Ronald S. Bultje
/* return the length and optionally the data */
168 93ced3e8 Fabrice Bellard
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 c8965800 Ronald S. Bultje
    for (;;) {
175 93ced3e8 Fabrice Bellard
        skip_spaces(&p);
176 6a8c8b36 Ronald S. Bultje
        if (*p == '\0')
177 93ced3e8 Fabrice Bellard
            break;
178 c8965800 Ronald S. Bultje
        c = toupper((unsigned char) *p++);
179 93ced3e8 Fabrice Bellard
        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 e6327fba Ronald S. Bultje
static void sdp_parse_fmtp_config(AVCodecContext * codec, void *ctx,
197
                                  char *attr, char *value)
198 d1ccf0e0 Romain Degez
{
199
    switch (codec->codec_id) {
200 c8965800 Ronald S. Bultje
    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 d1ccf0e0 Romain Degez
    }
220
    return;
221
}
222
223 644e7acb Luca Barbato
typedef struct {
224 7b49ce2e Stefan Huehner
    const char *str;
225 c8965800 Ronald S. Bultje
    uint16_t    type;
226
    uint32_t    offset;
227 644e7acb Luca Barbato
} AttrNameMap;
228 d1ccf0e0 Romain Degez
229
/* All known fmtp parmeters and the corresping RTPAttrTypeEnum */
230
#define ATTR_NAME_TYPE_INT 0
231
#define ATTR_NAME_TYPE_STR 1
232 644e7acb Luca Barbato
static const AttrNameMap attr_names[]=
233 d1ccf0e0 Romain Degez
{
234 c8965800 Ronald S. Bultje
    { "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 d1ccf0e0 Romain Degez
};
248
249 c8965800 Ronald S. Bultje
/* 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 3307e6ea Ronald S. Bultje
int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
253 93993933 Martin Storsjö
                                char *value, int value_size)
254 d0deedcb Ryan Martell
{
255
    skip_spaces(p);
256 c8965800 Ronald S. Bultje
    if (**p) {
257 d0deedcb Ryan Martell
        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 d1ccf0e0 Romain Degez
/* parse a SDP line and save stream attributes */
269
static void sdp_parse_fmtp(AVStream *st, const char *p)
270 93ced3e8 Fabrice Bellard
{
271
    char attr[256];
272 373afbaf Ronald S. Bultje
    /* 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 d1ccf0e0 Romain Degez
    int i;
276
    RTSPStream *rtsp_st = st->priv_data;
277 01f4895c Michael Niedermayer
    AVCodecContext *codec = st->codec;
278 be73a544 Luca Abeni
    RTPPayloadData *rtp_payload_data = &rtsp_st->rtp_payload_data;
279 93ced3e8 Fabrice Bellard
280
    /* loop on each attribute */
281 3307e6ea Ronald S. Bultje
    while (ff_rtsp_next_attr_and_value(&p, attr, sizeof(attr),
282 93993933 Martin Storsjö
                                       value, sizeof(value))) {
283 c8965800 Ronald S. Bultje
        /* grab the codec extra_data from the config parameter of the fmtp
284
         * line */
285 e6327fba Ronald S. Bultje
        sdp_parse_fmtp_config(codec, rtsp_st->dynamic_protocol_context,
286
                              attr, value);
287 d1ccf0e0 Romain Degez
        /* Looking for a known attribute */
288
        for (i = 0; attr_names[i].str; ++i) {
289
            if (!strcasecmp(attr, attr_names[i].str)) {
290 c8965800 Ronald S. Bultje
                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 bb270c08 Diego Biurrun
            }
297 93ced3e8 Fabrice Bellard
        }
298
    }
299
}
300
301 debe86bf Stefano Sabatini
/** Parse a string p in the form of Range:npt=xx-xx, and determine the start
302 31693e00 Ryan Martell
 *  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 f7d78f36 Måns Rullgård
    if (!av_stristart(p, "npt=", &p))
311 31693e00 Ryan Martell
        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 93ced3e8 Fabrice Bellard
typedef struct SDPParseState {
328
    /* SDP only */
329
    struct in_addr default_ip;
330 c8965800 Ronald S. Bultje
    int            default_ttl;
331
    int            skip_media;  ///< set if an unknown m= line occurs
332 93ced3e8 Fabrice Bellard
} SDPParseState;
333
334
static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
335 1617ad97 Fabrice Bellard
                           int letter, const char *buf)
336
{
337 8b1ab7bf Fabrice Bellard
    RTSPState *rt = s->priv_data;
338 1617ad97 Fabrice Bellard
    char buf1[64], st_type[64];
339
    const char *p;
340 fb65d2ca Diego Pettenò
    enum CodecType codec_type;
341
    int payload_type, i;
342 1617ad97 Fabrice Bellard
    AVStream *st;
343
    RTSPStream *rtsp_st;
344 93ced3e8 Fabrice Bellard
    struct in_addr sdp_ip;
345
    int ttl;
346
347 67c9cd69 Baptiste Coudurier
    dprintf(s, "sdp: %c='%s'\n", letter, buf);
348 1617ad97 Fabrice Bellard
349
    p = buf;
350 cb760a47 Ronald S. Bultje
    if (s1->skip_media && letter != 'm')
351
        return;
352 c8965800 Ronald S. Bultje
    switch (letter) {
353 93ced3e8 Fabrice Bellard
    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 ac11d562 David Conrad
        if (ff_inet_aton(buf1, &sdp_ip) == 0)
362 93ced3e8 Fabrice Bellard
            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 1617ad97 Fabrice Bellard
    case 's':
380 da61e413 Aurelien Jacobs
        av_metadata_set(&s->metadata, "title", p);
381 1617ad97 Fabrice Bellard
        break;
382
    case 'i':
383
        if (s->nb_streams == 0) {
384 da61e413 Aurelien Jacobs
            av_metadata_set(&s->metadata, "comment", p);
385 1617ad97 Fabrice Bellard
            break;
386
        }
387
        break;
388
    case 'm':
389
        /* new stream */
390 cb760a47 Ronald S. Bultje
        s1->skip_media = 0;
391 1617ad97 Fabrice Bellard
        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 090438cc Ronald S. Bultje
        } else if (!strcmp(st_type, "application")) {
397
            codec_type = CODEC_TYPE_DATA;
398 1617ad97 Fabrice Bellard
        } else {
399 cb760a47 Ronald S. Bultje
            s1->skip_media = 1;
400 1617ad97 Fabrice Bellard
            return;
401
        }
402
        rtsp_st = av_mallocz(sizeof(RTSPStream));
403
        if (!rtsp_st)
404
            return;
405 8b1ab7bf Fabrice Bellard
        rtsp_st->stream_index = -1;
406
        dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
407 93ced3e8 Fabrice Bellard
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 115329f1 Diego Biurrun
416 93ced3e8 Fabrice Bellard
        /* XXX: handle list of formats */
417
        get_word(buf1, sizeof(buf1), &p); /* format list */
418
        rtsp_st->sdp_payload_type = atoi(buf1);
419
420 7ed19d7f Luca Abeni
        if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
421 8b1ab7bf Fabrice Bellard
            /* 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 01f4895c Michael Niedermayer
            st->codec->codec_type = codec_type;
429 d1ccf0e0 Romain Degez
            if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
430 8b1ab7bf Fabrice Bellard
                /* if standard payload type, we can find the codec right now */
431 bf6d9818 Luca Abeni
                ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
432 8b1ab7bf Fabrice Bellard
            }
433
        }
434 1617ad97 Fabrice Bellard
        /* put a default control url */
435 00eb13e0 Alan Steremberg
        av_strlcpy(rtsp_st->control_url, rt->control_uri,
436 c8965800 Ronald S. Bultje
                   sizeof(rtsp_st->control_url));
437 1617ad97 Fabrice Bellard
        break;
438
    case 'a':
439 00eb13e0 Alan Steremberg
        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 1617ad97 Fabrice Bellard
            char proto[32];
446
            /* get the control url */
447
            st = s->streams[s->nb_streams - 1];
448
            rtsp_st = st->priv_data;
449 115329f1 Diego Biurrun
450 1617ad97 Fabrice Bellard
            /* XXX: may need to add full url resolution */
451 c5c6e67c Martin Storsjö
            ff_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
452 f984dcf6 Martin Storsjö
                         NULL, NULL, 0, p);
453 1617ad97 Fabrice Bellard
            if (proto[0] == '\0') {
454
                /* relative control URL */
455 00eb13e0 Alan Steremberg
                if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
456 c8965800 Ronald S. Bultje
                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 00eb13e0 Alan Steremberg
            }
464 83d14c85 Ronald S. Bultje
        } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
465 93ced3e8 Fabrice Bellard
            /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
466 115329f1 Diego Biurrun
            get_word(buf1, sizeof(buf1), &p);
467 93ced3e8 Fabrice Bellard
            payload_type = atoi(buf1);
468 83d14c85 Ronald S. Bultje
            st = s->streams[s->nb_streams - 1];
469 ff16f551 Ronald S. Bultje
            rtsp_st = st->priv_data;
470 8f3c87f3 Ronald S. Bultje
            sdp_parse_rtpmap(s, st->codec, rtsp_st, payload_type, p);
471 f7d78f36 Måns Rullgård
        } else if (av_strstart(p, "fmtp:", &p)) {
472 93ced3e8 Fabrice Bellard
            /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
473 115329f1 Diego Biurrun
            get_word(buf1, sizeof(buf1), &p);
474 93ced3e8 Fabrice Bellard
            payload_type = atoi(buf1);
475 c8965800 Ronald S. Bultje
            for (i = 0; i < s->nb_streams; i++) {
476
                st      = s->streams[i];
477 93ced3e8 Fabrice Bellard
                rtsp_st = st->priv_data;
478
                if (rtsp_st->sdp_payload_type == payload_type) {
479 c8965800 Ronald S. Bultje
                    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 ed787542 Ryan Martell
                        sdp_parse_fmtp(st, p);
484 93ced3e8 Fabrice Bellard
                }
485
            }
486 c8965800 Ronald S. Bultje
        } else if (av_strstart(p, "framesize:", &p)) {
487 d0deedcb Ryan Martell
            // let dynamic protocol handlers have a stab at the line.
488
            get_word(buf1, sizeof(buf1), &p);
489
            payload_type = atoi(buf1);
490 c8965800 Ronald S. Bultje
            for (i = 0; i < s->nb_streams; i++) {
491
                st      = s->streams[i];
492 d0deedcb Ryan Martell
                rtsp_st = st->priv_data;
493 c8965800 Ronald S. Bultje
                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 d0deedcb Ryan Martell
            }
499 c8965800 Ronald S. Bultje
        } else if (av_strstart(p, "range:", &p)) {
500 31693e00 Ryan Martell
            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 c8965800 Ronald S. Bultje
            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 119b4668 Ronald S. Bultje
        } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
509
            if (atoi(p) == 1)
510
                rt->transport = RTSP_TRANSPORT_RDT;
511 1a30d541 Ronald S. Bultje
        } 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 c4a3d032 Ronald S. Bultje
                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 c8965800 Ronald S. Bultje
                    rtsp_st->dynamic_handler->parse_sdp_a_line(s,
522
                        s->nb_streams - 1,
523 c4a3d032 Ronald S. Bultje
                        rtsp_st->dynamic_protocol_context, buf);
524 1a30d541 Ronald S. Bultje
            }
525 1617ad97 Fabrice Bellard
        }
526
        break;
527
    }
528
}
529
530 5c91a675 Zdenek Kabelac
static int sdp_parse(AVFormatContext *s, const char *content)
531 1617ad97 Fabrice Bellard
{
532
    const char *p;
533
    int letter;
534 9211bcdd Ronald S. Bultje
    /* 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 373afbaf Ronald S. Bultje
     * buffer is large.
539
     *
540
     * The Vorbis FMTP line can be up to 16KB - see sdp_parse_fmtp. */
541
    char buf[16384], *q;
542 93ced3e8 Fabrice Bellard
    SDPParseState sdp_parse_state, *s1 = &sdp_parse_state;
543 115329f1 Diego Biurrun
544 93ced3e8 Fabrice Bellard
    memset(s1, 0, sizeof(SDPParseState));
545 1617ad97 Fabrice Bellard
    p = content;
546 c8965800 Ronald S. Bultje
    for (;;) {
547 1617ad97 Fabrice Bellard
        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 b6892136 Fabrice Bellard
        while (*p != '\n' && *p != '\r' && *p != '\0') {
558 1617ad97 Fabrice Bellard
            if ((q - buf) < sizeof(buf) - 1)
559
                *q++ = *p;
560
            p++;
561
        }
562
        *q = '\0';
563 93ced3e8 Fabrice Bellard
        sdp_parse_line(s, s1, letter, buf);
564 1617ad97 Fabrice Bellard
    next_line:
565
        while (*p != '\n' && *p != '\0')
566
            p++;
567
        if (*p == '\n')
568
            p++;
569
    }
570
    return 0;
571
}
572
573 1ced9da3 Luca Abeni
/* close and free RTSP streams */
574 3307e6ea Ronald S. Bultje
void ff_rtsp_close_streams(AVFormatContext *s)
575 1ced9da3 Luca Abeni
{
576 52aa4338 Martin Storsjö
    RTSPState *rt = s->priv_data;
577 1ced9da3 Luca Abeni
    int i;
578
    RTSPStream *rtsp_st;
579
580 c8965800 Ronald S. Bultje
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
581 1ced9da3 Luca Abeni
        rtsp_st = rt->rtsp_streams[i];
582
        if (rtsp_st) {
583
            if (rtsp_st->transport_priv) {
584 fd450a51 Martin Storsjö
                if (s->oformat) {
585
                    AVFormatContext *rtpctx = rtsp_st->transport_priv;
586
                    av_write_trailer(rtpctx);
587
                    url_fclose(rtpctx->pb);
588 f86f6656 Martin Storsjö
                    av_metadata_free(&rtpctx->streams[0]->metadata);
589
                    av_metadata_free(&rtpctx->metadata);
590 fd450a51 Martin Storsjö
                    av_free(rtpctx->streams[0]);
591
                    av_free(rtpctx);
592
                } else if (rt->transport == RTSP_TRANSPORT_RDT)
593 1ced9da3 Luca Abeni
                    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 c8965800 Ronald S. Bultje
                rtsp_st->dynamic_handler->close(
601
                    rtsp_st->dynamic_protocol_context);
602 1ced9da3 Luca Abeni
        }
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 5c7fd910 Martin Storsjö
static void *rtsp_rtp_mux_open(AVFormatContext *s, AVStream *st,
613
                               URLContext *handle)
614
{
615 c07c6f81 Martin Storsjö
    RTSPState *rt = s->priv_data;
616 fd450a51 Martin Storsjö
    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 c07c6f81 Martin Storsjö
    /* Set the synchronized start time. */
639
    rtpctx->start_time_realtime = rt->start_time;
640
641 fd450a51 Martin Storsjö
    /* 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 c8965800 Ronald S. Bultje
static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
663 1ced9da3 Luca Abeni
{
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 fd450a51 Martin Storsjö
    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 1ced9da3 Luca Abeni
        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 c8965800 Ronald S. Bultje
        if (rtsp_st->dynamic_handler) {
690 1ced9da3 Luca Abeni
            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 6f5a3d0a Martin Storsjö
#if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
700 1ced9da3 Luca Abeni
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 1617ad97 Fabrice Bellard
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 a9e534d5 Ronald S. Bultje
static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
729 1617ad97 Fabrice Bellard
{
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 115329f1 Diego Biurrun
737 1617ad97 Fabrice Bellard
    reply->nb_transports = 0;
738 115329f1 Diego Biurrun
739 c8965800 Ronald S. Bultje
    for (;;) {
740 1617ad97 Fabrice Bellard
        skip_spaces(&p);
741
        if (*p == '\0')
742
            break;
743
744
        th = &reply->transports[reply->nb_transports];
745
746 115329f1 Diego Biurrun
        get_word_sep(transport_protocol, sizeof(transport_protocol),
747 1617ad97 Fabrice Bellard
                     "/", &p);
748 e1502118 Luca Barbato
        if (!strcasecmp (transport_protocol, "rtp")) {
749 7ecc634e Luca Barbato
            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 119b4668 Ronald S. Bultje
            }
756
            th->transport = RTSP_TRANSPORT_RTP;
757
        } else if (!strcasecmp (transport_protocol, "x-pn-tng") ||
758
                   !strcasecmp (transport_protocol, "x-real-rdt")) {
759 7ecc634e Luca Barbato
            /* x-pn-tng/<protocol> */
760 e1502118 Luca Barbato
            get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
761
            profile[0] = '\0';
762 119b4668 Ronald S. Bultje
            th->transport = RTSP_TRANSPORT_RDT;
763 1617ad97 Fabrice Bellard
        }
764 b6892136 Fabrice Bellard
        if (!strcasecmp(lower_transport, "TCP"))
765 90abbdba Ronald S. Bultje
            th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
766 1617ad97 Fabrice Bellard
        else
767 90abbdba Ronald S. Bultje
            th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
768 115329f1 Diego Biurrun
769 1617ad97 Fabrice Bellard
        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 115329f1 Diego Biurrun
                    rtsp_parse_range(&th->client_port_min,
783 1617ad97 Fabrice Bellard
                                     &th->client_port_max, &p);
784
                }
785
            } else if (!strcmp(parameter, "server_port")) {
786
                if (*p == '=') {
787
                    p++;
788 115329f1 Diego Biurrun
                    rtsp_parse_range(&th->server_port_min,
789 1617ad97 Fabrice Bellard
                                     &th->server_port_max, &p);
790
                }
791
            } else if (!strcmp(parameter, "interleaved")) {
792
                if (*p == '=') {
793
                    p++;
794 115329f1 Diego Biurrun
                    rtsp_parse_range(&th->interleaved_min,
795 1617ad97 Fabrice Bellard
                                     &th->interleaved_max, &p);
796
                }
797
            } else if (!strcmp(parameter, "multicast")) {
798 90abbdba Ronald S. Bultje
                if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
799
                    th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
800 1617ad97 Fabrice Bellard
            } 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 ac11d562 David Conrad
                    if (ff_inet_aton(buf, &ipaddr))
812 1617ad97 Fabrice Bellard
                        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 3307e6ea Ronald S. Bultje
void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf)
828 1617ad97 Fabrice Bellard
{
829
    const char *p;
830
831
    /* NOTE: we do case independent match for broken servers */
832
    p = buf;
833 f7d78f36 Måns Rullgård
    if (av_stristart(p, "Session:", &p)) {
834 30e79845 Ronald S. Bultje
        int t;
835 1617ad97 Fabrice Bellard
        get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
836 30e79845 Ronald S. Bultje
        if (av_stristart(p, ";timeout=", &p) &&
837
            (t = strtol(p, NULL, 10)) > 0) {
838
            reply->timeout = t;
839
        }
840 f7d78f36 Måns Rullgård
    } else if (av_stristart(p, "Content-Length:", &p)) {
841 1617ad97 Fabrice Bellard
        reply->content_length = strtol(p, NULL, 10);
842 f7d78f36 Måns Rullgård
    } else if (av_stristart(p, "Transport:", &p)) {
843 1617ad97 Fabrice Bellard
        rtsp_parse_transport(reply, p);
844 f7d78f36 Måns Rullgård
    } else if (av_stristart(p, "CSeq:", &p)) {
845 1617ad97 Fabrice Bellard
        reply->seq = strtol(p, NULL, 10);
846 f7d78f36 Måns Rullgård
    } else if (av_stristart(p, "Range:", &p)) {
847 31693e00 Ryan Martell
        rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
848 30aa6aed Ronald S. Bultje
    } else if (av_stristart(p, "RealChallenge1:", &p)) {
849
        skip_spaces(&p);
850
        av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
851 7a86bafa Ronald S. Bultje
    } else if (av_stristart(p, "Server:", &p)) {
852
        skip_spaces(&p);
853
        av_strlcpy(reply->server, p, sizeof(reply->server));
854 fccb1770 Ronald S. Bultje
    } else if (av_stristart(p, "Notice:", &p) ||
855
               av_stristart(p, "X-Notice:", &p)) {
856
        reply->notice = strtol(p, NULL, 10);
857 d243ba30 Luca Barbato
    } else if (av_stristart(p, "Location:", &p)) {
858
        skip_spaces(&p);
859
        av_strlcpy(reply->location, p , sizeof(reply->location));
860 1617ad97 Fabrice Bellard
    }
861
}
862
863 b7b8fc34 Fabrice Bellard
/* skip a RTP/TCP interleaved packet */
864
static void rtsp_skip_packet(AVFormatContext *s)
865
{
866
    RTSPState *rt = s->priv_data;
867
    int ret, len, len1;
868
    uint8_t buf[1024];
869
870 0e848977 Kostya Shishkov
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
871 b7b8fc34 Fabrice Bellard
    if (ret != 3)
872
        return;
873 80fb8234 Ronald S. Bultje
    len = AV_RB16(buf + 1);
874 67c9cd69 Baptiste Coudurier
875
    dprintf(s, "skipping RTP packet len=%d\n", len);
876
877 b7b8fc34 Fabrice Bellard
    /* skip payload */
878
    while (len > 0) {
879
        len1 = len;
880
        if (len1 > sizeof(buf))
881
            len1 = sizeof(buf);
882 0e848977 Kostya Shishkov
        ret = url_read_complete(rt->rtsp_hd, buf, len1);
883 b7b8fc34 Fabrice Bellard
        if (ret != len1)
884
            return;
885
        len -= len1;
886
    }
887
}
888 1617ad97 Fabrice Bellard
889 3307e6ea Ronald S. Bultje
int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
890 93993933 Martin Storsjö
                       unsigned char **content_ptr,
891
                       int return_on_interleaved_data)
892 1617ad97 Fabrice Bellard
{
893
    RTSPState *rt = s->priv_data;
894
    char buf[4096], buf1[1024], *q;
895
    unsigned char ch;
896
    const char *p;
897 7e726132 Ronald S. Bultje
    int ret, content_length, line_count = 0;
898 1617ad97 Fabrice Bellard
    unsigned char *content = NULL;
899
900 d541a7d2 Ronald S. Bultje
    memset(reply, 0, sizeof(*reply));
901 1617ad97 Fabrice Bellard
902
    /* parse reply (XXX: use buffers) */
903
    rt->last_reply[0] = '\0';
904 c8965800 Ronald S. Bultje
    for (;;) {
905 1617ad97 Fabrice Bellard
        q = buf;
906 c8965800 Ronald S. Bultje
        for (;;) {
907 0e848977 Kostya Shishkov
            ret = url_read_complete(rt->rtsp_hd, &ch, 1);
908 7e726132 Ronald S. Bultje
#ifdef DEBUG_RTP_TCP
909 67c9cd69 Baptiste Coudurier
            dprintf(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
910 7e726132 Ronald S. Bultje
#endif
911
            if (ret != 1)
912
                return -1;
913 1617ad97 Fabrice Bellard
            if (ch == '\n')
914
                break;
915 b7b8fc34 Fabrice Bellard
            if (ch == '$') {
916
                /* XXX: only parse it if first char on line ? */
917 7e726132 Ronald S. Bultje
                if (return_on_interleaved_data) {
918
                    return 1;
919
                } else
920 b7b8fc34 Fabrice Bellard
                rtsp_skip_packet(s);
921
            } else if (ch != '\r') {
922 1617ad97 Fabrice Bellard
                if ((q - buf) < sizeof(buf) - 1)
923
                    *q++ = ch;
924
            }
925
        }
926
        *q = '\0';
927 67c9cd69 Baptiste Coudurier
928
        dprintf(s, "line='%s'\n", buf);
929
930 1617ad97 Fabrice Bellard
        /* 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 3307e6ea Ronald S. Bultje
            ff_rtsp_parse_line(reply, p);
941 75e61b0e Måns Rullgård
            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
942
            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
943 1617ad97 Fabrice Bellard
        }
944
        line_count++;
945
    }
946 115329f1 Diego Biurrun
947 1617ad97 Fabrice Bellard
    if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
948 75e61b0e Måns Rullgård
        av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
949 115329f1 Diego Biurrun
950 1617ad97 Fabrice Bellard
    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 0e848977 Kostya Shishkov
        (void)url_read_complete(rt->rtsp_hd, content, content_length);
955 1617ad97 Fabrice Bellard
        content[content_length] = '\0';
956
    }
957
    if (content_ptr)
958
        *content_ptr = content;
959 e2e2e7dd Alex Beregszaszi
    else
960
        av_free(content);
961 7e726132 Ronald S. Bultje
962 fccb1770 Ronald S. Bultje
    /* EOS */
963
    if (reply->notice == 2101 /* End-of-Stream Reached */      ||
964
        reply->notice == 2104 /* Start-of-Stream Reached */    ||
965 c8965800 Ronald S. Bultje
        reply->notice == 2306 /* Continuous Feed Terminated */) {
966 fccb1770 Ronald S. Bultje
        rt->state = RTSP_STATE_IDLE;
967 c8965800 Ronald S. Bultje
    } else if (reply->notice >= 4400 && reply->notice < 5500) {
968 fccb1770 Ronald S. Bultje
        return AVERROR(EIO); /* data or server error */
969 c8965800 Ronald S. Bultje
    } else if (reply->notice == 2401 /* Ticket Expired */ ||
970 fccb1770 Ronald S. Bultje
             (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
971
        return AVERROR(EPERM);
972
973 7e726132 Ronald S. Bultje
    return 0;
974 1617ad97 Fabrice Bellard
}
975
976 3307e6ea Ronald S. Bultje
void ff_rtsp_send_cmd_with_content_async(AVFormatContext *s,
977 93993933 Martin Storsjö
                                         const char *cmd,
978
                                         const unsigned char *send_content,
979
                                         int send_content_length)
980 29b9f58b Ronald S. Bultje
{
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 f9337897 Ronald S. Bultje
    if (rt->auth_b64)
993
        av_strlcatf(buf, sizeof(buf),
994 ba93ea6d Ronald S. Bultje
                    "Authorization: Basic %s\r\n",
995
                    rt->auth_b64);
996 dfd017bf Martin Storsjö
    if (send_content_length > 0 && send_content)
997
        av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
998 29b9f58b Ronald S. Bultje
    av_strlcat(buf, "\r\n", sizeof(buf));
999 67c9cd69 Baptiste Coudurier
1000
    dprintf(s, "Sending:\n%s--\n", buf);
1001
1002 29b9f58b Ronald S. Bultje
    url_write(rt->rtsp_hd, buf, strlen(buf));
1003 dfd017bf Martin Storsjö
    if (send_content_length > 0 && send_content)
1004
        url_write(rt->rtsp_hd, send_content, send_content_length);
1005 30e79845 Ronald S. Bultje
    rt->last_cmd_time = av_gettime();
1006
}
1007
1008 3307e6ea Ronald S. Bultje
void ff_rtsp_send_cmd_async(AVFormatContext *s, const char *cmd)
1009 dfd017bf Martin Storsjö
{
1010 3307e6ea Ronald S. Bultje
    ff_rtsp_send_cmd_with_content_async(s, cmd, NULL, 0);
1011 dfd017bf Martin Storsjö
}
1012
1013 3307e6ea Ronald S. Bultje
void ff_rtsp_send_cmd(AVFormatContext *s,
1014 93993933 Martin Storsjö
                      const char *cmd, RTSPMessageHeader *reply,
1015
                      unsigned char **content_ptr)
1016 30e79845 Ronald S. Bultje
{
1017 3307e6ea Ronald S. Bultje
    ff_rtsp_send_cmd_async(s, cmd);
1018 29b9f58b Ronald S. Bultje
1019 3307e6ea Ronald S. Bultje
    ff_rtsp_read_reply(s, reply, content_ptr, 0);
1020 29b9f58b Ronald S. Bultje
}
1021
1022 3307e6ea Ronald S. Bultje
void ff_rtsp_send_cmd_with_content(AVFormatContext *s,
1023 af037f80 Martin Storsjö
                                const char *cmd,
1024
                                RTSPMessageHeader *reply,
1025
                                unsigned char **content_ptr,
1026
                                const unsigned char *send_content,
1027
                                int send_content_length)
1028 dfd017bf Martin Storsjö
{
1029 3307e6ea Ronald S. Bultje
    ff_rtsp_send_cmd_with_content_async(s, cmd, send_content, send_content_length);
1030 dfd017bf Martin Storsjö
1031 3307e6ea Ronald S. Bultje
    ff_rtsp_read_reply(s, reply, content_ptr, 0);
1032 dfd017bf Martin Storsjö
}
1033
1034 53620bba Ronald S. Bultje
/**
1035
 * @returns 0 on success, <0 on error, 1 if protocol is unavailable.
1036
 */
1037 c8965800 Ronald S. Bultje
static int make_setup_request(AVFormatContext *s, const char *host, int port,
1038
                              int lower_transport, const char *real_challenge)
1039 1617ad97 Fabrice Bellard
{
1040
    RTSPState *rt = s->priv_data;
1041 f830c9a4 Ronald S. Bultje
    int rtx, j, i, err, interleave = 0;
1042 1617ad97 Fabrice Bellard
    RTSPStream *rtsp_st;
1043 a9e534d5 Ronald S. Bultje
    RTSPMessageHeader reply1, *reply = &reply1;
1044 53620bba Ronald S. Bultje
    char cmd[2048];
1045 e9dea59f Ronald S. Bultje
    const char *trans_pref;
1046
1047 119b4668 Ronald S. Bultje
    if (rt->transport == RTSP_TRANSPORT_RDT)
1048 e9dea59f Ronald S. Bultje
        trans_pref = "x-pn-tng";
1049
    else
1050
        trans_pref = "RTP/AVP";
1051 115329f1 Diego Biurrun
1052 30e79845 Ronald S. Bultje
    /* default timeout: 1 minute */
1053
    rt->timeout = 60;
1054
1055 1617ad97 Fabrice Bellard
    /* for each stream, make the setup request */
1056
    /* XXX: we assume the same server is used for the control of each
1057 c8965800 Ronald S. Bultje
     * RTSP stream */
1058 d1ccf0e0 Romain Degez
1059 c8965800 Ronald S. Bultje
    for (j = RTSP_RTP_PORT_MIN, i = 0; i < rt->nb_rtsp_streams; ++i) {
1060 1617ad97 Fabrice Bellard
        char transport[2048];
1061
1062 f830c9a4 Ronald S. Bultje
        /**
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 c8965800 Ronald S. Bultje
                        !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1075
                                "/rtx"))
1076 f830c9a4 Ronald S. Bultje
                        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 2fea9650 Ronald S. Bultje
            rtsp_st = rt->rtsp_streams[i];
1085 1617ad97 Fabrice Bellard
1086
        /* RTP/UDP */
1087 90abbdba Ronald S. Bultje
        if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1088 85fb7b34 Fabrice Bellard
            char buf[256];
1089
1090 f830c9a4 Ronald S. Bultje
            if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1091
                port = reply->transports[0].client_port_min;
1092
                goto have_port;
1093
            }
1094
1095 85fb7b34 Fabrice Bellard
            /* first try in specified port range */
1096 d1ccf0e0 Romain Degez
            if (RTSP_RTP_PORT_MIN != 0) {
1097 c8965800 Ronald S. Bultje
                while (j <= RTSP_RTP_PORT_MAX) {
1098 57b5555c Martin Storsjö
                    ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1099
                                "?localport=%d", j);
1100 c8965800 Ronald S. Bultje
                    /* 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 85fb7b34 Fabrice Bellard
                        goto rtp_opened;
1104
                }
1105 1617ad97 Fabrice Bellard
            }
1106 85fb7b34 Fabrice Bellard
1107 c8965800 Ronald S. Bultje
#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 85fb7b34 Fabrice Bellard
1115
        rtp_opened:
1116 8b1ab7bf Fabrice Bellard
            port = rtp_get_local_port(rtsp_st->rtp_handle);
1117 f830c9a4 Ronald S. Bultje
        have_port:
1118 0ad306bc Ronald S. Bultje
            snprintf(transport, sizeof(transport) - 1,
1119 eee2cbff Ronald S. Bultje
                     "%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 f830c9a4 Ronald S. Bultje
            if (rt->transport == RTSP_TRANSPORT_RTP &&
1125
                !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1126 e9dea59f Ronald S. Bultje
                av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1127 1617ad97 Fabrice Bellard
        }
1128
1129
        /* RTP/TCP */
1130 90abbdba Ronald S. Bultje
        else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1131 090438cc Ronald S. Bultje
            /** 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 c8965800 Ronald S. Bultje
                s->streams[rtsp_st->stream_index]->codec->codec_type ==
1136
                    CODEC_TYPE_DATA)
1137 090438cc Ronald S. Bultje
                continue;
1138 0ad306bc Ronald S. Bultje
            snprintf(transport, sizeof(transport) - 1,
1139 d1c6e47c Ronald S. Bultje
                     "%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 1617ad97 Fabrice Bellard
        }
1147
1148 90abbdba Ronald S. Bultje
        else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1149 0ad306bc Ronald S. Bultje
            snprintf(transport, sizeof(transport) - 1,
1150 e9dea59f Ronald S. Bultje
                     "%s/UDP;multicast", trans_pref);
1151 1617ad97 Fabrice Bellard
        }
1152 69adcc4f Martin Storsjö
        if (s->oformat) {
1153
            av_strlcat(transport, ";mode=receive", sizeof(transport));
1154
        } else if (rt->server_type == RTSP_SERVER_REAL ||
1155 2efc97c2 Martin Storsjö
                   rt->server_type == RTSP_SERVER_WMS)
1156 e9dea59f Ronald S. Bultje
            av_strlcat(transport, ";mode=play", sizeof(transport));
1157 115329f1 Diego Biurrun
        snprintf(cmd, sizeof(cmd),
1158 b6892136 Fabrice Bellard
                 "SETUP %s RTSP/1.0\r\n"
1159
                 "Transport: %s\r\n",
1160 1617ad97 Fabrice Bellard
                 rtsp_st->control_url, transport);
1161 2e889ae4 Ronald S. Bultje
        if (i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1162 e9dea59f Ronald S. Bultje
            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 3307e6ea Ronald S. Bultje
        ff_rtsp_send_cmd(s, cmd, reply, NULL);
1171 8a8754d8 Ronald S. Bultje
        if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1172
            err = 1;
1173
            goto fail;
1174 7e6ca34f Ronald S. Bultje
        } else if (reply->status_code != RTSP_STATUS_OK ||
1175
                   reply->nb_transports != 1) {
1176 1617ad97 Fabrice Bellard
            err = AVERROR_INVALIDDATA;
1177
            goto fail;
1178
        }
1179
1180
        /* XXX: same protocol for all streams is required */
1181
        if (i > 0) {
1182 119b4668 Ronald S. Bultje
            if (reply->transports[0].lower_transport != rt->lower_transport ||
1183
                reply->transports[0].transport != rt->transport) {
1184 1617ad97 Fabrice Bellard
                err = AVERROR_INVALIDDATA;
1185
                goto fail;
1186
            }
1187
        } else {
1188 90abbdba Ronald S. Bultje
            rt->lower_transport = reply->transports[0].lower_transport;
1189 119b4668 Ronald S. Bultje
            rt->transport = reply->transports[0].transport;
1190 1617ad97 Fabrice Bellard
        }
1191
1192
        /* close RTP connection if not choosen */
1193 90abbdba Ronald S. Bultje
        if (reply->transports[0].lower_transport != RTSP_LOWER_TRANSPORT_UDP &&
1194
            (lower_transport == RTSP_LOWER_TRANSPORT_UDP)) {
1195 8b1ab7bf Fabrice Bellard
            url_close(rtsp_st->rtp_handle);
1196
            rtsp_st->rtp_handle = NULL;
1197 1617ad97 Fabrice Bellard
        }
1198
1199 90abbdba Ronald S. Bultje
        switch(reply->transports[0].lower_transport) {
1200
        case RTSP_LOWER_TRANSPORT_TCP:
1201 1617ad97 Fabrice Bellard
            rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1202
            rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1203
            break;
1204 115329f1 Diego Biurrun
1205 c8965800 Ronald S. Bultje
        case RTSP_LOWER_TRANSPORT_UDP: {
1206
            char url[1024];
1207
1208
            /* XXX: also use address if specified */
1209 57b5555c Martin Storsjö
            ff_url_join(url, sizeof(url), "rtp", NULL, host,
1210
                        reply->transports[0].server_port_min, NULL);
1211 c8965800 Ronald S. Bultje
            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 1617ad97 Fabrice Bellard
            }
1216 9c8fa20d Martin Storsjö
            /* 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 30ff7c5c Martin Storsjö
            if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat)
1221 9c8fa20d Martin Storsjö
                rtp_send_punch_packets(rtsp_st->rtp_handle);
1222 1617ad97 Fabrice Bellard
            break;
1223 c8965800 Ronald S. Bultje
        }
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 57b5555c Martin Storsjö
            ff_url_join(url, sizeof(url), "rtp", NULL, inet_ntoa(in),
1239
                        port, "?ttl=%d", ttl);
1240 c8965800 Ronald S. Bultje
            if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1241
                err = AVERROR_INVALIDDATA;
1242
                goto fail;
1243 1617ad97 Fabrice Bellard
            }
1244
            break;
1245
        }
1246 c8965800 Ronald S. Bultje
        }
1247 d1ccf0e0 Romain Degez
1248 ee0cb67f Ronald S. Bultje
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1249 8b1ab7bf Fabrice Bellard
            goto fail;
1250 1617ad97 Fabrice Bellard
    }
1251
1252 30e79845 Ronald S. Bultje
    if (reply->timeout > 0)
1253
        rt->timeout = reply->timeout;
1254
1255 2e889ae4 Ronald S. Bultje
    if (rt->server_type == RTSP_SERVER_REAL)
1256 1256d16b Ronald S. Bultje
        rt->need_subscription = 1;
1257
1258 53620bba Ronald S. Bultje
    return 0;
1259
1260
fail:
1261 c8965800 Ronald S. Bultje
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1262 8a8754d8 Ronald S. Bultje
        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 53620bba Ronald S. Bultje
    return err;
1268
}
1269
1270 1ced9da3 Luca Abeni
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 00eb13e0 Alan Steremberg
                     rt->control_uri);
1283 1ced9da3 Luca Abeni
        } else {
1284
            snprintf(cmd, sizeof(cmd),
1285
                     "PLAY %s RTSP/1.0\r\n"
1286
                     "Range: npt=%0.3f-\r\n",
1287 00eb13e0 Alan Steremberg
                     rt->control_uri,
1288 1ced9da3 Luca Abeni
                     (double)rt->seek_timestamp / AV_TIME_BASE);
1289
        }
1290 3307e6ea Ronald S. Bultje
        ff_rtsp_send_cmd(s, cmd, reply, NULL);
1291 1ced9da3 Luca Abeni
        if (reply->status_code != RTSP_STATUS_OK) {
1292
            return -1;
1293
        }
1294
    }
1295 c02fd3d2 Martin Storsjö
    rt->state = RTSP_STATE_STREAMING;
1296 1ced9da3 Luca Abeni
    return 0;
1297
}
1298
1299 e23d195d Martin Storsjö
static int rtsp_setup_input_streams(AVFormatContext *s)
1300
{
1301
    RTSPState *rt = s->priv_data;
1302
    RTSPMessageHeader reply1, *reply = &reply1;
1303
    char cmd[1024];
1304
    unsigned char *content = NULL;
1305
    int ret;
1306
1307
    /* describe the stream */
1308
    snprintf(cmd, sizeof(cmd),
1309
             "DESCRIBE %s RTSP/1.0\r\n"
1310
             "Accept: application/sdp\r\n",
1311 db76ca7f Martin Storsjö
             rt->control_uri);
1312 e23d195d Martin Storsjö
    if (rt->server_type == RTSP_SERVER_REAL) {
1313
        /**
1314
         * The Require: attribute is needed for proper streaming from
1315
         * Realmedia servers.
1316
         */
1317
        av_strlcat(cmd,
1318
                   "Require: com.real.retain-entity-for-setup\r\n",
1319
                   sizeof(cmd));
1320
    }
1321 3307e6ea Ronald S. Bultje
    ff_rtsp_send_cmd(s, cmd, reply, &content);
1322 e23d195d Martin Storsjö
    if (!content)
1323
        return AVERROR_INVALIDDATA;
1324
    if (reply->status_code != RTSP_STATUS_OK) {
1325
        av_freep(&content);
1326
        return AVERROR_INVALIDDATA;
1327
    }
1328
1329
    /* now we got the SDP description, we parse it */
1330
    ret = sdp_parse(s, (const char *)content);
1331
    av_freep(&content);
1332
    if (ret < 0)
1333
        return AVERROR_INVALIDDATA;
1334
1335
    return 0;
1336
}
1337
1338 26cb700c Martin Storsjö
static int rtsp_setup_output_streams(AVFormatContext *s, const char *addr)
1339 3e24c770 Martin Storsjö
{
1340
    RTSPState *rt = s->priv_data;
1341
    RTSPMessageHeader reply1, *reply = &reply1;
1342
    char cmd[1024];
1343
    int i;
1344
    char *sdp;
1345 26cb700c Martin Storsjö
    AVFormatContext sdp_ctx, *ctx_array[1];
1346 c07c6f81 Martin Storsjö
1347
    rt->start_time = av_gettime();
1348 3e24c770 Martin Storsjö
1349
    /* Announce the stream */
1350
    snprintf(cmd, sizeof(cmd),
1351
             "ANNOUNCE %s RTSP/1.0\r\n"
1352
             "Content-Type: application/sdp\r\n",
1353 db76ca7f Martin Storsjö
             rt->control_uri);
1354 3e24c770 Martin Storsjö
    sdp = av_mallocz(8192);
1355
    if (sdp == NULL)
1356
        return AVERROR(ENOMEM);
1357 26cb700c Martin Storsjö
    /* We create the SDP based on the RTSP AVFormatContext where we
1358
     * aren't allowed to change the filename field. (We create the SDP
1359
     * based on the RTSP context since the contexts for the RTP streams
1360
     * don't exist yet.) In order to specify a custom URL with the actual
1361
     * peer IP instead of the originally specified hostname, we create
1362
     * a temporary copy of the AVFormatContext, where the custom URL is set.
1363
     *
1364
     * FIXME: Create the SDP without copying the AVFormatContext.
1365
     * This either requires setting up the RTP stream AVFormatContexts
1366
     * already here (complicating things immensely) or getting a more
1367
     * flexible SDP creation interface.
1368
     */
1369
    sdp_ctx = *s;
1370
    ff_url_join(sdp_ctx.filename, sizeof(sdp_ctx.filename),
1371
                "rtsp", NULL, addr, -1, NULL);
1372
    ctx_array[0] = &sdp_ctx;
1373
    if (avf_sdp_create(ctx_array, 1, sdp, 8192)) {
1374 3e24c770 Martin Storsjö
        av_free(sdp);
1375
        return AVERROR_INVALIDDATA;
1376
    }
1377
    av_log(s, AV_LOG_INFO, "SDP:\n%s\n", sdp);
1378 3307e6ea Ronald S. Bultje
    ff_rtsp_send_cmd_with_content(s, cmd, reply, NULL, sdp, strlen(sdp));
1379 3e24c770 Martin Storsjö
    av_free(sdp);
1380
    if (reply->status_code != RTSP_STATUS_OK)
1381
        return AVERROR_INVALIDDATA;
1382
1383
    /* Set up the RTSPStreams for each AVStream */
1384
    for (i = 0; i < s->nb_streams; i++) {
1385
        RTSPStream *rtsp_st;
1386
        AVStream *st = s->streams[i];
1387
1388
        rtsp_st = av_mallocz(sizeof(RTSPStream));
1389
        if (!rtsp_st)
1390
            return AVERROR(ENOMEM);
1391
        dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
1392
1393
        st->priv_data = rtsp_st;
1394
        rtsp_st->stream_index = i;
1395
1396 db76ca7f Martin Storsjö
        av_strlcpy(rtsp_st->control_url, rt->control_uri, sizeof(rtsp_st->control_url));
1397 3e24c770 Martin Storsjö
        /* Note, this must match the relative uri set in the sdp content */
1398
        av_strlcatf(rtsp_st->control_url, sizeof(rtsp_st->control_url),
1399
                    "/streamid=%d", i);
1400
    }
1401
1402
    return 0;
1403
}
1404
1405 3307e6ea Ronald S. Bultje
int ff_rtsp_connect(AVFormatContext *s)
1406 53620bba Ronald S. Bultje
{
1407
    RTSPState *rt = s->priv_data;
1408 921da217 Luca Barbato
    char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1409
    char *option_list, *option, *filename;
1410 53620bba Ronald S. Bultje
    URLContext *rtsp_hd;
1411 03f8fc08 Martin Storsjö
    int port, err, tcp_fd;
1412 a9e534d5 Ronald S. Bultje
    RTSPMessageHeader reply1, *reply = &reply1;
1413 90abbdba Ronald S. Bultje
    int lower_transport_mask = 0;
1414 1cf151e9 Ronald S. Bultje
    char real_challenge[64];
1415 03f8fc08 Martin Storsjö
    struct sockaddr_storage peer;
1416
    socklen_t peer_len = sizeof(peer);
1417 57b5555c Martin Storsjö
1418
    if (!ff_network_init())
1419
        return AVERROR(EIO);
1420 c8965800 Ronald S. Bultje
redirect:
1421 53620bba Ronald S. Bultje
    /* extract hostname and port */
1422 c5c6e67c Martin Storsjö
    ff_url_split(NULL, 0, auth, sizeof(auth),
1423 f984dcf6 Martin Storsjö
                 host, sizeof(host), &port, path, sizeof(path), s->filename);
1424 f9337897 Ronald S. Bultje
    if (*auth) {
1425
        int auth_len = strlen(auth), b64_len = ((auth_len + 2) / 3) * 4 + 1;
1426
1427
        if (!(rt->auth_b64 = av_malloc(b64_len)))
1428
            return AVERROR(ENOMEM);
1429
        if (!av_base64_encode(rt->auth_b64, b64_len, auth, auth_len)) {
1430
            err = AVERROR(EINVAL);
1431
            goto fail;
1432
        }
1433
    }
1434 53620bba Ronald S. Bultje
    if (port < 0)
1435
        port = RTSP_DEFAULT_PORT;
1436
1437
    /* search for options */
1438
    option_list = strchr(path, '?');
1439
    if (option_list) {
1440 921da217 Luca Barbato
        filename = strchr(s->filename, '?');
1441 c8965800 Ronald S. Bultje
        while (option_list) {
1442 53620bba Ronald S. Bultje
            /* move the option pointer */
1443 921da217 Luca Barbato
            option = ++option_list;
1444 53620bba Ronald S. Bultje
            option_list = strchr(option_list, '&');
1445
            if (option_list)
1446 921da217 Luca Barbato
                *option_list = 0;
1447
1448 53620bba Ronald S. Bultje
            /* handle the options */
1449 c8965800 Ronald S. Bultje
            if (!strcmp(option, "udp")) {
1450 90abbdba Ronald S. Bultje
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP);
1451 c8965800 Ronald S. Bultje
            } else if (!strcmp(option, "multicast")) {
1452 90abbdba Ronald S. Bultje
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
1453 c8965800 Ronald S. Bultje
            } else if (!strcmp(option, "tcp")) {
1454 90abbdba Ronald S. Bultje
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_TCP);
1455 c8965800 Ronald S. Bultje
            } else {
1456 921da217 Luca Barbato
                strcpy(++filename, option);
1457
                filename += strlen(option);
1458
                if (option_list) *filename = '&';
1459
            }
1460 53620bba Ronald S. Bultje
        }
1461 921da217 Luca Barbato
        *filename = 0;
1462 53620bba Ronald S. Bultje
    }
1463
1464 90abbdba Ronald S. Bultje
    if (!lower_transport_mask)
1465 2a1d51c5 Ronald S. Bultje
        lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1466 53620bba Ronald S. Bultje
1467 3e24c770 Martin Storsjö
    if (s->oformat) {
1468
        /* Only UDP output is supported at the moment. */
1469
        lower_transport_mask &= 1 << RTSP_LOWER_TRANSPORT_UDP;
1470
        if (!lower_transport_mask) {
1471
            av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1472
                                    "only UDP is supported for output.\n");
1473
            err = AVERROR(EINVAL);
1474
            goto fail;
1475
        }
1476
    }
1477
1478 53620bba Ronald S. Bultje
    /* open the tcp connexion */
1479 57b5555c Martin Storsjö
    ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port, NULL);
1480 f9337897 Ronald S. Bultje
    if (url_open(&rtsp_hd, tcpname, URL_RDWR) < 0) {
1481
        err = AVERROR(EIO);
1482
        goto fail;
1483
    }
1484 53620bba Ronald S. Bultje
    rt->rtsp_hd = rtsp_hd;
1485
    rt->seq = 0;
1486
1487 03f8fc08 Martin Storsjö
    tcp_fd = url_get_file_handle(rtsp_hd);
1488
    if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1489
        getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1490
                    NULL, 0, NI_NUMERICHOST);
1491
    }
1492
1493 c8965800 Ronald S. Bultje
    /* request options supported by the server; this also detects server
1494
     * type */
1495 00eb13e0 Alan Steremberg
    av_strlcpy(rt->control_uri, s->filename,
1496
               sizeof(rt->control_uri));
1497 1cf151e9 Ronald S. Bultje
    for (rt->server_type = RTSP_SERVER_RTP;;) {
1498
        snprintf(cmd, sizeof(cmd),
1499 db76ca7f Martin Storsjö
                 "OPTIONS %s RTSP/1.0\r\n", rt->control_uri);
1500 2e889ae4 Ronald S. Bultje
        if (rt->server_type == RTSP_SERVER_REAL)
1501 1cf151e9 Ronald S. Bultje
            av_strlcat(cmd,
1502
                       /**
1503
                        * The following entries are required for proper
1504
                        * streaming from a Realmedia server. They are
1505
                        * interdependent in some way although we currently
1506
                        * don't quite understand how. Values were copied
1507
                        * from mplayer SVN r23589.
1508
                        * @param CompanyID is a 16-byte ID in base64
1509
                        * @param ClientChallenge is a 16-byte ID in hex
1510
                        */
1511
                       "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1512
                       "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1513
                       "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1514
                       "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1515
                       sizeof(cmd));
1516 3307e6ea Ronald S. Bultje
        ff_rtsp_send_cmd(s, cmd, reply, NULL);
1517 1cf151e9 Ronald S. Bultje
        if (reply->status_code != RTSP_STATUS_OK) {
1518
            err = AVERROR_INVALIDDATA;
1519
            goto fail;
1520
        }
1521
1522
        /* detect server type if not standard-compliant RTP */
1523 2e889ae4 Ronald S. Bultje
        if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1524
            rt->server_type = RTSP_SERVER_REAL;
1525 1cf151e9 Ronald S. Bultje
            continue;
1526 7a86bafa Ronald S. Bultje
        } else if (!strncasecmp(reply->server, "WMServer/", 9)) {
1527
            rt->server_type = RTSP_SERVER_WMS;
1528 c8965800 Ronald S. Bultje
        } else if (rt->server_type == RTSP_SERVER_REAL)
1529 1cf151e9 Ronald S. Bultje
            strcpy(real_challenge, reply->real_challenge);
1530
        break;
1531
    }
1532
1533 3e24c770 Martin Storsjö
    if (s->iformat)
1534 2efc97c2 Martin Storsjö
        err = rtsp_setup_input_streams(s);
1535 3e24c770 Martin Storsjö
    else
1536 26cb700c Martin Storsjö
        err = rtsp_setup_output_streams(s, host);
1537 e23d195d Martin Storsjö
    if (err)
1538 53620bba Ronald S. Bultje
        goto fail;
1539
1540 8a8754d8 Ronald S. Bultje
    do {
1541 c8965800 Ronald S. Bultje
        int lower_transport = ff_log2_tab[lower_transport_mask &
1542
                                  ~(lower_transport_mask - 1)];
1543 8a8754d8 Ronald S. Bultje
1544 90abbdba Ronald S. Bultje
        err = make_setup_request(s, host, port, lower_transport,
1545 2e889ae4 Ronald S. Bultje
                                 rt->server_type == RTSP_SERVER_REAL ?
1546 e9dea59f Ronald S. Bultje
                                     real_challenge : NULL);
1547 8a8754d8 Ronald S. Bultje
        if (err < 0)
1548 7e6ca34f Ronald S. Bultje
            goto fail;
1549 90abbdba Ronald S. Bultje
        lower_transport_mask &= ~(1 << lower_transport);
1550
        if (lower_transport_mask == 0 && err == 1) {
1551 5ee0e139 Luca Barbato
            err = AVERROR(FF_NETERROR(EPROTONOSUPPORT));
1552 8a8754d8 Ronald S. Bultje
            goto fail;
1553
        }
1554
    } while (err);
1555 53620bba Ronald S. Bultje
1556 ff762d6e Fabrice Bellard
    rt->state = RTSP_STATE_IDLE;
1557 c8965800 Ronald S. Bultje
    rt->seek_timestamp = 0; /* default is to start stream at position zero */
1558 1617ad97 Fabrice Bellard
    return 0;
1559
 fail:
1560 3307e6ea Ronald S. Bultje
    ff_rtsp_close_streams(s);
1561 1617ad97 Fabrice Bellard
    url_close(rt->rtsp_hd);
1562 35cfd646 Martin Storsjö
    if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1563 d243ba30 Luca Barbato
        av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1564
        av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1565
               reply->status_code,
1566
               s->filename);
1567
        goto redirect;
1568
    }
1569 57b5555c Martin Storsjö
    ff_network_close();
1570 1617ad97 Fabrice Bellard
    return err;
1571
}
1572 6f5a3d0a Martin Storsjö
#endif
1573 1617ad97 Fabrice Bellard
1574 6f5a3d0a Martin Storsjö
#if CONFIG_RTSP_DEMUXER
1575 4280f9bb Martin Storsjö
static int rtsp_read_header(AVFormatContext *s,
1576
                            AVFormatParameters *ap)
1577
{
1578
    RTSPState *rt = s->priv_data;
1579
    int ret;
1580
1581 3307e6ea Ronald S. Bultje
    ret = ff_rtsp_connect(s);
1582 4280f9bb Martin Storsjö
    if (ret)
1583
        return ret;
1584
1585
    if (ap->initial_pause) {
1586
         /* do not start immediately */
1587
    } else {
1588
         if (rtsp_read_play(s) < 0) {
1589 3307e6ea Ronald S. Bultje
            ff_rtsp_close_streams(s);
1590 4280f9bb Martin Storsjö
            url_close(rt->rtsp_hd);
1591
            return AVERROR_INVALIDDATA;
1592
        }
1593
    }
1594
1595
    return 0;
1596
}
1597
1598 0e59034e Ronald S. Bultje
static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1599
                           uint8_t *buf, int buf_size)
1600
{
1601
    RTSPState *rt = s->priv_data;
1602
    RTSPStream *rtsp_st;
1603
    fd_set rfds;
1604
    int fd, fd_max, n, i, ret, tcp_fd;
1605
    struct timeval tv;
1606
1607 c8965800 Ronald S. Bultje
    for (;;) {
1608 0e59034e Ronald S. Bultje
        if (url_interrupt_cb())
1609
            return AVERROR(EINTR);
1610
        FD_ZERO(&rfds);
1611
        if (rt->rtsp_hd) {
1612
            tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd);
1613
            FD_SET(tcp_fd, &rfds);
1614
        } else {
1615
            fd_max = 0;
1616
            tcp_fd = -1;
1617
        }
1618 c8965800 Ronald S. Bultje
        for (i = 0; i < rt->nb_rtsp_streams; i++) {
1619 0e59034e Ronald S. Bultje
            rtsp_st = rt->rtsp_streams[i];
1620
            if (rtsp_st->rtp_handle) {
1621
                /* currently, we cannot probe RTCP handle because of
1622
                 * blocking restrictions */
1623
                fd = url_get_file_handle(rtsp_st->rtp_handle);
1624
                if (fd > fd_max)
1625
                    fd_max = fd;
1626
                FD_SET(fd, &rfds);
1627
            }
1628
        }
1629
        tv.tv_sec = 0;
1630
        tv.tv_usec = 100 * 1000;
1631
        n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
1632
        if (n > 0) {
1633 c8965800 Ronald S. Bultje
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1634 0e59034e Ronald S. Bultje
                rtsp_st = rt->rtsp_streams[i];
1635
                if (rtsp_st->rtp_handle) {
1636
                    fd = url_get_file_handle(rtsp_st->rtp_handle);
1637
                    if (FD_ISSET(fd, &rfds)) {
1638
                        ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
1639
                        if (ret > 0) {
1640
                            *prtsp_st = rtsp_st;
1641
                            return ret;
1642
                        }
1643
                    }
1644
                }
1645
            }
1646
#if CONFIG_RTSP_DEMUXER
1647 27000636 Jeremy Morton
            if (tcp_fd != -1 && FD_ISSET(tcp_fd, &rfds)) {
1648 0e59034e Ronald S. Bultje
                RTSPMessageHeader reply;
1649
1650 3307e6ea Ronald S. Bultje
                ff_rtsp_read_reply(s, &reply, NULL, 0);
1651 0e59034e Ronald S. Bultje
                /* XXX: parse message */
1652 c02fd3d2 Martin Storsjö
                if (rt->state != RTSP_STATE_STREAMING)
1653 0e59034e Ronald S. Bultje
                    return 0;
1654
            }
1655
#endif
1656
        }
1657
    }
1658
}
1659
1660 8b1ab7bf Fabrice Bellard
static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1661
                           uint8_t *buf, int buf_size)
1662 1617ad97 Fabrice Bellard
{
1663
    RTSPState *rt = s->priv_data;
1664 b6892136 Fabrice Bellard
    int id, len, i, ret;
1665 1617ad97 Fabrice Bellard
    RTSPStream *rtsp_st;
1666
1667 b6892136 Fabrice Bellard
#ifdef DEBUG_RTP_TCP
1668 67c9cd69 Baptiste Coudurier
    dprintf(s, "tcp_read_packet:\n");
1669 b6892136 Fabrice Bellard
#endif
1670 c8965800 Ronald S. Bultje
redo:
1671
    for (;;) {
1672 7e726132 Ronald S. Bultje
        RTSPMessageHeader reply;
1673
1674 3307e6ea Ronald S. Bultje
        ret = ff_rtsp_read_reply(s, &reply, NULL, 1);
1675 7e726132 Ronald S. Bultje
        if (ret == -1)
1676 8b1ab7bf Fabrice Bellard
            return -1;
1677 7e726132 Ronald S. Bultje
        if (ret == 1) /* received '$' */
1678 1617ad97 Fabrice Bellard
            break;
1679 7e726132 Ronald S. Bultje
        /* XXX: parse message */
1680 c02fd3d2 Martin Storsjö
        if (rt->state != RTSP_STATE_STREAMING)
1681 fccb1770 Ronald S. Bultje
            return 0;
1682 1617ad97 Fabrice Bellard
    }
1683 0e848977 Kostya Shishkov
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
1684 b6892136 Fabrice Bellard
    if (ret != 3)
1685 8b1ab7bf Fabrice Bellard
        return -1;
1686 c8965800 Ronald S. Bultje
    id  = buf[0];
1687 80fb8234 Ronald S. Bultje
    len = AV_RB16(buf + 1);
1688 b6892136 Fabrice Bellard
#ifdef DEBUG_RTP_TCP
1689 67c9cd69 Baptiste Coudurier
    dprintf(s, "id=%d len=%d\n", id, len);
1690 b6892136 Fabrice Bellard
#endif
1691 8b1ab7bf Fabrice Bellard
    if (len > buf_size || len < 12)
1692 1617ad97 Fabrice Bellard
        goto redo;
1693
    /* get the data */
1694 0e848977 Kostya Shishkov
    ret = url_read_complete(rt->rtsp_hd, buf, len);
1695 b6892136 Fabrice Bellard
    if (ret != len)
1696 8b1ab7bf Fabrice Bellard
        return -1;
1697 985b05d3 Ronald S. Bultje
    if (rt->transport == RTSP_TRANSPORT_RDT &&
1698 114732f4 Ronald S. Bultje
        ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
1699 985b05d3 Ronald S. Bultje
        return -1;
1700 115329f1 Diego Biurrun
1701 1617ad97 Fabrice Bellard
    /* find the matching stream */
1702 c8965800 Ronald S. Bultje
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1703 8b1ab7bf Fabrice Bellard
        rtsp_st = rt->rtsp_streams[i];
1704 115329f1 Diego Biurrun
        if (id >= rtsp_st->interleaved_min &&
1705
            id <= rtsp_st->interleaved_max)
1706 1617ad97 Fabrice Bellard
            goto found;
1707
    }
1708
    goto redo;
1709 c8965800 Ronald S. Bultje
found:
1710 8b1ab7bf Fabrice Bellard
    *prtsp_st = rtsp_st;
1711
    return len;
1712 1617ad97 Fabrice Bellard
}
1713
1714 0e59034e Ronald S. Bultje
static int rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
1715
{
1716
    RTSPState *rt = s->priv_data;
1717
    int ret, len;
1718
    uint8_t buf[10 * RTP_MAX_PACKET_LENGTH];
1719
    RTSPStream *rtsp_st;
1720
1721
    /* get next frames from the same RTP packet */
1722
    if (rt->cur_transport_priv) {
1723 c8965800 Ronald S. Bultje
        if (rt->transport == RTSP_TRANSPORT_RDT) {
1724 0e59034e Ronald S. Bultje
            ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1725 c8965800 Ronald S. Bultje
        } else
1726 0e59034e Ronald S. Bultje
            ret = rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1727
        if (ret == 0) {
1728
            rt->cur_transport_priv = NULL;
1729
            return 0;
1730
        } else if (ret == 1) {
1731
            return 0;
1732 c8965800 Ronald S. Bultje
        } else
1733 0e59034e Ronald S. Bultje
            rt->cur_transport_priv = NULL;
1734
    }
1735
1736
    /* read next RTP packet */
1737
 redo:
1738
    switch(rt->lower_transport) {
1739
    default:
1740
#if CONFIG_RTSP_DEMUXER
1741
    case RTSP_LOWER_TRANSPORT_TCP:
1742
        len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1743
        break;
1744
#endif
1745
    case RTSP_LOWER_TRANSPORT_UDP:
1746
    case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1747
        len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1748
        if (len >=0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
1749
            rtp_check_and_send_back_rr(rtsp_st->transport_priv, len);
1750
        break;
1751
    }
1752
    if (len < 0)
1753
        return len;
1754
    if (len == 0)
1755
        return AVERROR_EOF;
1756 c8965800 Ronald S. Bultje
    if (rt->transport == RTSP_TRANSPORT_RDT) {
1757 0e59034e Ronald S. Bultje
        ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1758 c8965800 Ronald S. Bultje
    } else
1759 0e59034e Ronald S. Bultje
        ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1760
    if (ret < 0)
1761
        goto redo;
1762 c8965800 Ronald S. Bultje
    if (ret == 1)
1763 0e59034e Ronald S. Bultje
        /* more packets may follow, so we save the RTP context */
1764
        rt->cur_transport_priv = rtsp_st->transport_priv;
1765
1766
    return ret;
1767
}
1768
1769 c8965800 Ronald S. Bultje
static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt)
1770 1617ad97 Fabrice Bellard
{
1771
    RTSPState *rt = s->priv_data;
1772 98713182 Luca Abeni
    int ret;
1773 30e79845 Ronald S. Bultje
    RTSPMessageHeader reply1, *reply = &reply1;
1774
    char cmd[1024];
1775 8b1ab7bf Fabrice Bellard
1776 572c6a38 Ronald S. Bultje
    if (rt->server_type == RTSP_SERVER_REAL) {
1777 1256d16b Ronald S. Bultje
        int i;
1778 572c6a38 Ronald S. Bultje
        enum AVDiscard cache[MAX_STREAMS];
1779 1256d16b Ronald S. Bultje
1780 572c6a38 Ronald S. Bultje
        for (i = 0; i < s->nb_streams; i++)
1781
            cache[i] = s->streams[i]->discard;
1782
1783
        if (!rt->need_subscription) {
1784
            if (memcmp (cache, rt->real_setup_cache,
1785
                        sizeof(enum AVDiscard) * s->nb_streams)) {
1786 8b9457de Ronald S. Bultje
                snprintf(cmd, sizeof(cmd),
1787 7eaa646f Ronald S. Bultje
                         "SET_PARAMETER %s RTSP/1.0\r\n"
1788
                         "Unsubscribe: %s\r\n",
1789 00eb13e0 Alan Steremberg
                         rt->control_uri, rt->last_subscription);
1790 3307e6ea Ronald S. Bultje
                ff_rtsp_send_cmd(s, cmd, reply, NULL);
1791 572c6a38 Ronald S. Bultje
                if (reply->status_code != RTSP_STATUS_OK)
1792
                    return AVERROR_INVALIDDATA;
1793
                rt->need_subscription = 1;
1794
            }
1795 1256d16b Ronald S. Bultje
        }
1796
1797 572c6a38 Ronald S. Bultje
        if (rt->need_subscription) {
1798
            int r, rule_nr, first = 1;
1799
1800
            memcpy(rt->real_setup_cache, cache,
1801
                   sizeof(enum AVDiscard) * s->nb_streams);
1802
            rt->last_subscription[0] = 0;
1803
1804
            snprintf(cmd, sizeof(cmd),
1805
                     "SET_PARAMETER %s RTSP/1.0\r\n"
1806
                     "Subscribe: ",
1807 00eb13e0 Alan Steremberg
                     rt->control_uri);
1808 572c6a38 Ronald S. Bultje
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1809
                rule_nr = 0;
1810
                for (r = 0; r < s->nb_streams; r++) {
1811
                    if (s->streams[r]->priv_data == rt->rtsp_streams[i]) {
1812
                        if (s->streams[r]->discard != AVDISCARD_ALL) {
1813
                            if (!first)
1814
                                av_strlcat(rt->last_subscription, ",",
1815
                                           sizeof(rt->last_subscription));
1816
                            ff_rdt_subscribe_rule(
1817
                                rt->last_subscription,
1818
                                sizeof(rt->last_subscription), i, rule_nr);
1819
                            first = 0;
1820
                        }
1821
                        rule_nr++;
1822
                    }
1823
                }
1824
            }
1825
            av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
1826 3307e6ea Ronald S. Bultje
            ff_rtsp_send_cmd(s, cmd, reply, NULL);
1827 572c6a38 Ronald S. Bultje
            if (reply->status_code != RTSP_STATUS_OK)
1828
                return AVERROR_INVALIDDATA;
1829
            rt->need_subscription = 0;
1830
1831 c02fd3d2 Martin Storsjö
            if (rt->state == RTSP_STATE_STREAMING)
1832 572c6a38 Ronald S. Bultje
                rtsp_read_play (s);
1833
        }
1834 1256d16b Ronald S. Bultje
    }
1835
1836 d7250724 Luca Barbato
    ret = rtsp_fetch_packet(s, pkt);
1837 c8965800 Ronald S. Bultje
    if (ret < 0)
1838 98713182 Luca Abeni
        return ret;
1839 30e79845 Ronald S. Bultje
1840
    /* send dummy request to keep TCP connection alive */
1841
    if ((rt->server_type == RTSP_SERVER_WMS ||
1842
         rt->server_type == RTSP_SERVER_REAL) &&
1843
        (av_gettime() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2) {
1844
        if (rt->server_type == RTSP_SERVER_WMS) {
1845
            snprintf(cmd, sizeof(cmd) - 1,
1846
                     "GET_PARAMETER %s RTSP/1.0\r\n",
1847 00eb13e0 Alan Steremberg
                     rt->control_uri);
1848 3307e6ea Ronald S. Bultje
            ff_rtsp_send_cmd_async(s, cmd);
1849 30e79845 Ronald S. Bultje
        } else {
1850 3307e6ea Ronald S. Bultje
            ff_rtsp_send_cmd_async(s, "OPTIONS * RTSP/1.0\r\n");
1851 30e79845 Ronald S. Bultje
        }
1852
    }
1853
1854 8b1ab7bf Fabrice Bellard
    return 0;
1855 1617ad97 Fabrice Bellard
}
1856
1857 ff762d6e Fabrice Bellard
/* pause the stream */
1858
static int rtsp_read_pause(AVFormatContext *s)
1859 b7b8fc34 Fabrice Bellard
{
1860 ff762d6e Fabrice Bellard
    RTSPState *rt = s->priv_data;
1861 a9e534d5 Ronald S. Bultje
    RTSPMessageHeader reply1, *reply = &reply1;
1862 b7b8fc34 Fabrice Bellard
    char cmd[1024];
1863
1864
    rt = s->priv_data;
1865 115329f1 Diego Biurrun
1866 c02fd3d2 Martin Storsjö
    if (rt->state != RTSP_STATE_STREAMING)
1867 ff762d6e Fabrice Bellard
        return 0;
1868 2e889ae4 Ronald S. Bultje
    else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1869 99b2ac07 Ronald S. Bultje
        snprintf(cmd, sizeof(cmd),
1870
                 "PAUSE %s RTSP/1.0\r\n",
1871 00eb13e0 Alan Steremberg
                 rt->control_uri);
1872 3307e6ea Ronald S. Bultje
        ff_rtsp_send_cmd(s, cmd, reply, NULL);
1873 99b2ac07 Ronald S. Bultje
        if (reply->status_code != RTSP_STATUS_OK) {
1874
            return -1;
1875
        }
1876 1256d16b Ronald S. Bultje
    }
1877 5f86057f Ronald S. Bultje
    rt->state = RTSP_STATE_PAUSED;
1878
    return 0;
1879 b7b8fc34 Fabrice Bellard
}
1880
1881 115329f1 Diego Biurrun
static int rtsp_read_seek(AVFormatContext *s, int stream_index,
1882 7b3c1382 Michael Niedermayer
                          int64_t timestamp, int flags)
1883 ff762d6e Fabrice Bellard
{
1884
    RTSPState *rt = s->priv_data;
1885 115329f1 Diego Biurrun
1886 c8965800 Ronald S. Bultje
    rt->seek_timestamp = av_rescale_q(timestamp,
1887
                                      s->streams[stream_index]->time_base,
1888
                                      AV_TIME_BASE_Q);
1889 ff762d6e Fabrice Bellard
    switch(rt->state) {
1890
    default:
1891
    case RTSP_STATE_IDLE:
1892
        break;
1893 c02fd3d2 Martin Storsjö
    case RTSP_STATE_STREAMING:
1894 ec606b36 Luca Barbato
        if (rtsp_read_pause(s) != 0)
1895
            return -1;
1896
        rt->state = RTSP_STATE_SEEKING;
1897 ff762d6e Fabrice Bellard
        if (rtsp_read_play(s) != 0)
1898
            return -1;
1899
        break;
1900
    case RTSP_STATE_PAUSED:
1901
        rt->state = RTSP_STATE_IDLE;
1902
        break;
1903
    }
1904
    return 0;
1905
}
1906
1907 1617ad97 Fabrice Bellard
static int rtsp_read_close(AVFormatContext *s)
1908
{
1909
    RTSPState *rt = s->priv_data;
1910
    char cmd[1024];
1911
1912 b6892136 Fabrice Bellard
#if 0
1913 1617ad97 Fabrice Bellard
    /* NOTE: it is valid to flush the buffer here */
1914 90abbdba Ronald S. Bultje
    if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1915 1617ad97 Fabrice Bellard
        url_fclose(&rt->rtsp_gb);
1916
    }
1917 b6892136 Fabrice Bellard
#endif
1918 115329f1 Diego Biurrun
    snprintf(cmd, sizeof(cmd),
1919 b6892136 Fabrice Bellard
             "TEARDOWN %s RTSP/1.0\r\n",
1920 db76ca7f Martin Storsjö
             rt->control_uri);
1921 3307e6ea Ronald S. Bultje
    ff_rtsp_send_cmd_async(s, cmd);
1922 1617ad97 Fabrice Bellard
1923 3307e6ea Ronald S. Bultje
    ff_rtsp_close_streams(s);
1924 1617ad97 Fabrice Bellard
    url_close(rt->rtsp_hd);
1925 57b5555c Martin Storsjö
    ff_network_close();
1926 1617ad97 Fabrice Bellard
    return 0;
1927
}
1928
1929 d2a067d1 Måns Rullgård
AVInputFormat rtsp_demuxer = {
1930 1617ad97 Fabrice Bellard
    "rtsp",
1931 bde15e74 Stefano Sabatini
    NULL_IF_CONFIG_SMALL("RTSP input format"),
1932 1617ad97 Fabrice Bellard
    sizeof(RTSPState),
1933
    rtsp_probe,
1934
    rtsp_read_header,
1935
    rtsp_read_packet,
1936
    rtsp_read_close,
1937 ff762d6e Fabrice Bellard
    rtsp_read_seek,
1938 bb76a117 Måns Rullgård
    .flags = AVFMT_NOFILE,
1939 ff762d6e Fabrice Bellard
    .read_play = rtsp_read_play,
1940
    .read_pause = rtsp_read_pause,
1941 1617ad97 Fabrice Bellard
};
1942 96862926 Alex Beregszaszi
#endif
1943 1617ad97 Fabrice Bellard
1944 cb1fdc61 Fabrice Bellard
static int sdp_probe(AVProbeData *p1)
1945 93ced3e8 Fabrice Bellard
{
1946 0e1ceacd Michael Niedermayer
    const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
1947 cb1fdc61 Fabrice Bellard
1948
    /* we look for a line beginning "c=IN IP4" */
1949 0e1ceacd Michael Niedermayer
    while (p < p_end && *p != '\0') {
1950 c8965800 Ronald S. Bultje
        if (p + sizeof("c=IN IP4") - 1 < p_end &&
1951
            av_strstart(p, "c=IN IP4", NULL))
1952 cb1fdc61 Fabrice Bellard
            return AVPROBE_SCORE_MAX / 2;
1953 0e1ceacd Michael Niedermayer
1954 c8965800 Ronald S. Bultje
        while (p < p_end - 1 && *p != '\n') p++;
1955 0e1ceacd Michael Niedermayer
        if (++p >= p_end)
1956 cb1fdc61 Fabrice Bellard
            break;
1957
        if (*p == '\r')
1958
            p++;
1959
    }
1960 93ced3e8 Fabrice Bellard
    return 0;
1961
}
1962
1963
#define SDP_MAX_SIZE 8192
1964
1965 c8965800 Ronald S. Bultje
static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap)
1966 93ced3e8 Fabrice Bellard
{
1967 8b1ab7bf Fabrice Bellard
    RTSPState *rt = s->priv_data;
1968 93ced3e8 Fabrice Bellard
    RTSPStream *rtsp_st;
1969
    int size, i, err;
1970
    char *content;
1971
    char url[1024];
1972
1973 57b5555c Martin Storsjö
    if (!ff_network_init())
1974
        return AVERROR(EIO);
1975
1976 93ced3e8 Fabrice Bellard
    /* read the whole sdp file */
1977
    /* XXX: better loading */
1978
    content = av_malloc(SDP_MAX_SIZE);
1979 899681cd Björn Axelsson
    size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
1980 93ced3e8 Fabrice Bellard
    if (size <= 0) {
1981
        av_free(content);
1982
        return AVERROR_INVALIDDATA;
1983
    }
1984
    content[size] ='\0';
1985
1986
    sdp_parse(s, content);
1987
    av_free(content);
1988
1989
    /* open each RTP stream */
1990 c8965800 Ronald S. Bultje
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1991 8b1ab7bf Fabrice Bellard
        rtsp_st = rt->rtsp_streams[i];
1992 115329f1 Diego Biurrun
1993 57b5555c Martin Storsjö
        ff_url_join(url, sizeof(url), "rtp", NULL,
1994
                    inet_ntoa(rtsp_st->sdp_ip), rtsp_st->sdp_port,
1995
                    "?localport=%d&ttl=%d", rtsp_st->sdp_port,
1996
                    rtsp_st->sdp_ttl);
1997 dbf30963 Thijs
        if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1998 93ced3e8 Fabrice Bellard
            err = AVERROR_INVALIDDATA;
1999
            goto fail;
2000
        }
2001 ee0cb67f Ronald S. Bultje
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
2002 8b1ab7bf Fabrice Bellard
            goto fail;
2003 93ced3e8 Fabrice Bellard
    }
2004
    return 0;
2005 c8965800 Ronald S. Bultje
fail:
2006 3307e6ea Ronald S. Bultje
    ff_rtsp_close_streams(s);
2007 57b5555c Martin Storsjö
    ff_network_close();
2008 93ced3e8 Fabrice Bellard
    return err;
2009
}
2010
2011
static int sdp_read_close(AVFormatContext *s)
2012
{
2013 3307e6ea Ronald S. Bultje
    ff_rtsp_close_streams(s);
2014 57b5555c Martin Storsjö
    ff_network_close();
2015 93ced3e8 Fabrice Bellard
    return 0;
2016
}
2017
2018 ff70e601 Måns Rullgård
AVInputFormat sdp_demuxer = {
2019 93ced3e8 Fabrice Bellard
    "sdp",
2020 bde15e74 Stefano Sabatini
    NULL_IF_CONFIG_SMALL("SDP"),
2021 93ced3e8 Fabrice Bellard
    sizeof(RTSPState),
2022
    sdp_probe,
2023
    sdp_read_header,
2024 d7250724 Luca Barbato
    rtsp_fetch_packet,
2025 93ced3e8 Fabrice Bellard
    sdp_read_close,
2026
};