rtsp.c 60.9 KB
Newer Older
1
/*
2
 * RTSP/SDP client
3
 * Copyright (c) 2002 Fabrice Bellard
4
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

22 23 24
/* needed by inet_aton() */
#define _SVID_SOURCE

25
#include "libavutil/base64.h"
26
#include "libavutil/avstring.h"
27
#include "libavutil/intreadwrite.h"
28 29
#include "avformat.h"

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

38
#include "rtpdec.h"
39
#include "rdt.h"
40
#include "rtp_asf.h"
41
#include "rtp_vorbis.h"
Ryan Martell's avatar
Ryan Martell committed
42

43
//#define DEBUG
Fabrice Bellard's avatar
Fabrice Bellard committed
44
//#define DEBUG_RTP_TCP
45

Ronald S. Bultje's avatar
Ronald S. Bultje committed
46
#if LIBAVFORMAT_VERSION_INT < (53 << 16)
47
int rtsp_default_protocols = (1 << RTSP_LOWER_TRANSPORT_UDP);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
48
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
49

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

63 64
static void get_word_until_chars(char *buf, int buf_size,
                                 const char *sep, const char **pp)
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
{
    const char *p;
    char *q;

    p = *pp;
    skip_spaces(&p);
    q = buf;
    while (!strchr(sep, *p) && *p != '\0') {
        if ((q - buf) < buf_size - 1)
            *q++ = *p;
        p++;
    }
    if (buf_size > 0)
        *q = '\0';
    *pp = p;
}

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

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

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

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

    c = avcodec_find_decoder(codec->codec_id);
    if (c && c->name)
132
        c_name = c->name;
Romain Degez's avatar
Romain Degez committed
133
    else
134
        c_name = "(null)";
Romain Degez's avatar
Romain Degez committed
135

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

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

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

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

Luca Barbato's avatar
Luca Barbato committed
224
typedef struct {
225
    const char *str;
226 227
    uint16_t    type;
    uint32_t    offset;
Luca Barbato's avatar
Luca Barbato committed
228
} AttrNameMap;
Romain Degez's avatar
Romain Degez committed
229 230 231 232

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

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

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

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

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

    skip_spaces(&p);
311
    if (!av_stristart(p, "npt=", &p))
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
        return;

    *start = AV_NOPTS_VALUE;
    *end = AV_NOPTS_VALUE;

    get_word_sep(buf, sizeof(buf), "-", &p);
    *start = parse_date(buf, 1);
    if (*p == '-') {
        p++;
        get_word_sep(buf, sizeof(buf), "-", &p);
        *end = parse_date(buf, 1);
    }
//    av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
//    av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
}

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

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

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

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

        rtsp_st->sdp_ip = s1->default_ip;
        rtsp_st->sdp_ttl = s1->default_ttl;

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

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

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

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

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

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

                rtsp_st = s->streams[s->nb_streams - 1]->priv_data;
                if (rtsp_st->dynamic_handler &&
                    rtsp_st->dynamic_handler->parse_sdp_a_line)
522 523
                    rtsp_st->dynamic_handler->parse_sdp_a_line(s,
                        s->nb_streams - 1,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
524
                        rtsp_st->dynamic_protocol_context, buf);
525
            }
526 527 528 529 530
        }
        break;
    }
}

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

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

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

581
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
582 583 584 585 586 587 588 589 590 591 592
        rtsp_st = rt->rtsp_streams[i];
        if (rtsp_st) {
            if (rtsp_st->transport_priv) {
                if (rt->transport == RTSP_TRANSPORT_RDT)
                    ff_rdt_parse_close(rtsp_st->transport_priv);
                else
                    rtp_parse_close(rtsp_st->transport_priv);
            }
            if (rtsp_st->rtp_handle)
                url_close(rtsp_st->rtp_handle);
            if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
593 594
                rtsp_st->dynamic_handler->close(
                    rtsp_st->dynamic_protocol_context);
595 596 597 598 599 600 601 602 603 604
        }
    }
    av_free(rt->rtsp_streams);
    if (rt->asf_ctx) {
        av_close_input_stream (rt->asf_ctx);
        rt->asf_ctx = NULL;
    }
    av_freep(&rt->auth_b64);
}

605
static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627
{
    RTSPState *rt = s->priv_data;
    AVStream *st = NULL;

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

    if (rt->transport == RTSP_TRANSPORT_RDT)
        rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
                                            rtsp_st->dynamic_protocol_context,
                                            rtsp_st->dynamic_handler);
    else
        rtsp_st->transport_priv = rtp_parse_open(s, st, rtsp_st->rtp_handle,
                                         rtsp_st->sdp_payload_type,
                                         &rtsp_st->rtp_payload_data);

    if (!rtsp_st->transport_priv) {
         return AVERROR(ENOMEM);
    } else if (rt->transport != RTSP_TRANSPORT_RDT) {
628
        if (rtsp_st->dynamic_handler) {
629 630 631 632 633 634 635 636 637
            rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
                                           rtsp_st->dynamic_protocol_context,
                                           rtsp_st->dynamic_handler);
        }
    }

    return 0;
}

638
#if CONFIG_RTSP_DEMUXER
639 640 641 642 643 644 645
static int rtsp_probe(AVProbeData *p)
{
    if (av_strstart(p->filename, "rtsp:", NULL))
        return AVPROBE_SCORE_MAX;
    return 0;
}

646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
{
    const char *p;
    int v;

    p = *pp;
    skip_spaces(&p);
    v = strtol(p, (char **)&p, 10);
    if (*p == '-') {
        p++;
        *min_ptr = v;
        v = strtol(p, (char **)&p, 10);
        *max_ptr = v;
    } else {
        *min_ptr = v;
        *max_ptr = v;
    }
    *pp = p;
}

/* XXX: only one transport specification is parsed */
667
static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
668 669 670 671 672 673 674
{
    char transport_protocol[16];
    char profile[16];
    char lower_transport[16];
    char parameter[16];
    RTSPTransportField *th;
    char buf[256];
675

676
    reply->nb_transports = 0;
677

678
    for (;;) {
679 680 681 682 683 684
        skip_spaces(&p);
        if (*p == '\0')
            break;

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

685
        get_word_sep(transport_protocol, sizeof(transport_protocol),
686
                     "/", &p);
687
        if (!strcasecmp (transport_protocol, "rtp")) {
688 689 690 691 692 693
            get_word_sep(profile, sizeof(profile), "/;,", &p);
            lower_transport[0] = '\0';
            /* rtp/avp/<protocol> */
            if (*p == '/') {
                get_word_sep(lower_transport, sizeof(lower_transport),
                             ";,", &p);
694 695 696 697
            }
            th->transport = RTSP_TRANSPORT_RTP;
        } else if (!strcasecmp (transport_protocol, "x-pn-tng") ||
                   !strcasecmp (transport_protocol, "x-real-rdt")) {
698
            /* x-pn-tng/<protocol> */
699 700
            get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
            profile[0] = '\0';
701
            th->transport = RTSP_TRANSPORT_RDT;
702
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
703
        if (!strcasecmp(lower_transport, "TCP"))
704
            th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
705
        else
706
            th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
707

708 709 710 711 712 713 714 715 716 717 718 719 720
        if (*p == ';')
            p++;
        /* get each parameter */
        while (*p != '\0' && *p != ',') {
            get_word_sep(parameter, sizeof(parameter), "=;,", &p);
            if (!strcmp(parameter, "port")) {
                if (*p == '=') {
                    p++;
                    rtsp_parse_range(&th->port_min, &th->port_max, &p);
                }
            } else if (!strcmp(parameter, "client_port")) {
                if (*p == '=') {
                    p++;
721
                    rtsp_parse_range(&th->client_port_min,
722 723 724 725 726
                                     &th->client_port_max, &p);
                }
            } else if (!strcmp(parameter, "server_port")) {
                if (*p == '=') {
                    p++;
727
                    rtsp_parse_range(&th->server_port_min,
728 729 730 731 732
                                     &th->server_port_max, &p);
                }
            } else if (!strcmp(parameter, "interleaved")) {
                if (*p == '=') {
                    p++;
733
                    rtsp_parse_range(&th->interleaved_min,
734 735 736
                                     &th->interleaved_max, &p);
                }
            } else if (!strcmp(parameter, "multicast")) {
737 738
                if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
                    th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
739 740 741 742 743 744 745 746 747 748 749
            } else if (!strcmp(parameter, "ttl")) {
                if (*p == '=') {
                    p++;
                    th->ttl = strtol(p, (char **)&p, 10);
                }
            } else if (!strcmp(parameter, "destination")) {
                struct in_addr ipaddr;

                if (*p == '=') {
                    p++;
                    get_word_sep(buf, sizeof(buf), ";,", &p);
750
                    if (inet_aton(buf, &ipaddr))
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
                        th->destination = ntohl(ipaddr.s_addr);
                }
            }
            while (*p != ';' && *p != '\0' && *p != ',')
                p++;
            if (*p == ';')
                p++;
        }
        if (*p == ',')
            p++;

        reply->nb_transports++;
    }
}

766
void rtsp_parse_line(RTSPMessageHeader *reply, const char *buf)
767 768 769 770 771
{
    const char *p;

    /* NOTE: we do case independent match for broken servers */
    p = buf;
772
    if (av_stristart(p, "Session:", &p)) {
773
        int t;
774
        get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
775 776 777 778
        if (av_stristart(p, ";timeout=", &p) &&
            (t = strtol(p, NULL, 10)) > 0) {
            reply->timeout = t;
        }
779
    } else if (av_stristart(p, "Content-Length:", &p)) {
780
        reply->content_length = strtol(p, NULL, 10);
781
    } else if (av_stristart(p, "Transport:", &p)) {
782
        rtsp_parse_transport(reply, p);
783
    } else if (av_stristart(p, "CSeq:", &p)) {
784
        reply->seq = strtol(p, NULL, 10);
785
    } else if (av_stristart(p, "Range:", &p)) {
786
        rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
787 788 789
    } else if (av_stristart(p, "RealChallenge1:", &p)) {
        skip_spaces(&p);
        av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
790 791 792
    } else if (av_stristart(p, "Server:", &p)) {
        skip_spaces(&p);
        av_strlcpy(reply->server, p, sizeof(reply->server));
793 794 795
    } else if (av_stristart(p, "Notice:", &p) ||
               av_stristart(p, "X-Notice:", &p)) {
        reply->notice = strtol(p, NULL, 10);
Luca Barbato's avatar
Luca Barbato committed
796 797 798
    } else if (av_stristart(p, "Location:", &p)) {
        skip_spaces(&p);
        av_strlcpy(reply->location, p , sizeof(reply->location));
799 800 801
    }
}

802 803 804 805 806 807 808
/* skip a RTP/TCP interleaved packet */
static void rtsp_skip_packet(AVFormatContext *s)
{
    RTSPState *rt = s->priv_data;
    int ret, len, len1;
    uint8_t buf[1024];

809
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
810 811
    if (ret != 3)
        return;
812
    len = AV_RB16(buf + 1);
813 814 815

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

816 817 818 819 820
    /* skip payload */
    while (len > 0) {
        len1 = len;
        if (len1 > sizeof(buf))
            len1 = sizeof(buf);
821
        ret = url_read_complete(rt->rtsp_hd, buf, len1);
822 823 824 825 826
        if (ret != len1)
            return;
        len -= len1;
    }
}
827

828 829 830 831 832 833 834 835
/**
 * Read a RTSP message from the server, or prepare to read data
 * packets if we're reading data interleaved over the TCP/RTSP
 * connection as well.
 *
 * @param s RTSP demuxer context
 * @param reply pointer where the RTSP message header will be stored
 * @param content_ptr pointer where the RTSP message body, if any, will
836
 *                    be stored (length is in reply)
837 838 839 840 841 842 843 844 845 846 847 848
 * @param return_on_interleaved_data whether the function may return if we
 *                   encounter a data marker ('$'), which precedes data
 *                   packets over interleaved TCP/RTSP connections. If this
 *                   is set, this function will return 1 after encountering
 *                   a '$'. If it is not set, the function will skip any
 *                   data packets (if they are encountered), until a reply
 *                   has been fully parsed. If no more data is available
 *                   without parsing a reply, it will return an error.
 *
 * @returns 1 if a data packets is ready to be received, -1 on error,
 *          and 0 on success.
 */
849 850 851
static int rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
                           unsigned char **content_ptr,
                           int return_on_interleaved_data)
852 853 854 855 856
{
    RTSPState *rt = s->priv_data;
    char buf[4096], buf1[1024], *q;
    unsigned char ch;
    const char *p;
857
    int ret, content_length, line_count = 0;
858 859
    unsigned char *content = NULL;

860
    memset(reply, 0, sizeof(*reply));
861 862 863

    /* parse reply (XXX: use buffers) */
    rt->last_reply[0] = '\0';
864
    for (;;) {
865
        q = buf;
866
        for (;;) {
867
            ret = url_read_complete(rt->rtsp_hd, &ch, 1);
868
#ifdef DEBUG_RTP_TCP
869
            dprintf(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
870 871 872
#endif
            if (ret != 1)
                return -1;
873 874
            if (ch == '\n')
                break;
875 876
            if (ch == '$') {
                /* XXX: only parse it if first char on line ? */
877 878 879
                if (return_on_interleaved_data) {
                    return 1;
                } else
880 881
                rtsp_skip_packet(s);
            } else if (ch != '\r') {
882 883 884 885 886
                if ((q - buf) < sizeof(buf) - 1)
                    *q++ = ch;
            }
        }
        *q = '\0';
887 888 889

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

890 891 892 893 894 895 896 897 898 899 900
        /* test if last line */
        if (buf[0] == '\0')
            break;
        p = buf;
        if (line_count == 0) {
            /* get reply code */
            get_word(buf1, sizeof(buf1), &p);
            get_word(buf1, sizeof(buf1), &p);
            reply->status_code = atoi(buf1);
        } else {
            rtsp_parse_line(reply, p);
Måns Rullgård's avatar
Måns Rullgård committed
901 902
            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
903 904 905
        }
        line_count++;
    }
906

907
    if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
Måns Rullgård's avatar
Måns Rullgård committed
908
        av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
909

910 911 912 913
    content_length = reply->content_length;
    if (content_length > 0) {
        /* leave some room for a trailing '\0' (useful for simple parsing) */
        content = av_malloc(content_length + 1);
914
        (void)url_read_complete(rt->rtsp_hd, content, content_length);
915 916 917 918
        content[content_length] = '\0';
    }
    if (content_ptr)
        *content_ptr = content;
919 920
    else
        av_free(content);
921

922 923 924
    /* EOS */
    if (reply->notice == 2101 /* End-of-Stream Reached */      ||
        reply->notice == 2104 /* Start-of-Stream Reached */    ||
925
        reply->notice == 2306 /* Continuous Feed Terminated */) {
926
        rt->state = RTSP_STATE_IDLE;
927
    } else if (reply->notice >= 4400 && reply->notice < 5500) {
928
        return AVERROR(EIO); /* data or server error */
929
    } else if (reply->notice == 2401 /* Ticket Expired */ ||
930 931 932
             (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
        return AVERROR(EPERM);

933
    return 0;
934 935
}

936 937 938 939
static void rtsp_send_cmd_with_content_async(AVFormatContext *s,
                                             const char *cmd,
                                             const unsigned char *send_content,
                                             int send_content_length)
940 941 942 943 944 945 946 947 948 949 950 951
{
    RTSPState *rt = s->priv_data;
    char buf[4096], buf1[1024];

    rt->seq++;
    av_strlcpy(buf, cmd, sizeof(buf));
    snprintf(buf1, sizeof(buf1), "CSeq: %d\r\n", rt->seq);
    av_strlcat(buf, buf1, sizeof(buf));
    if (rt->session_id[0] != '\0' && !strstr(cmd, "\nIf-Match:")) {
        snprintf(buf1, sizeof(buf1), "Session: %s\r\n", rt->session_id);
        av_strlcat(buf, buf1, sizeof(buf));
    }
952