rtsp.c 49.8 KB
Newer Older
1
/*
2
 * RTSP/SDP client
3 4
 * Copyright (c) 2002 Fabrice Bellard.
 *
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/avstring.h"
26 27
#include "avformat.h"

28
#include <sys/time.h>
29
#include <unistd.h> /* for select() prototype */
30
#include <strings.h>
31
#include "network.h"
32
#include "rtsp.h"
33

Ryan Martell's avatar
Ryan Martell committed
34
#include "rtp_internal.h"
35
#include "rdt.h"
Ryan Martell's avatar
Ryan Martell committed
36

37
//#define DEBUG
Fabrice Bellard's avatar
Fabrice Bellard committed
38
//#define DEBUG_RTP_TCP
39

40 41 42 43 44 45
enum RTSPClientState {
    RTSP_STATE_IDLE,
    RTSP_STATE_PLAYING,
    RTSP_STATE_PAUSED,
};

46
enum RTSPServerType {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
47
    RTSP_SERVER_RTP,  /*< Standard-compliant RTP-server */
48
    RTSP_SERVER_REAL, /*< Realmedia-style server */
49 50 51
    RTSP_SERVER_LAST
};

52 53
typedef struct RTSPState {
    URLContext *rtsp_hd; /* RTSP TCP connexion handle */
54 55
    int nb_rtsp_streams;
    struct RTSPStream **rtsp_streams;
56

57 58
    enum RTSPClientState state;
    int64_t seek_timestamp;
59

Fabrice Bellard's avatar
Fabrice Bellard committed
60 61
    /* XXX: currently we use unbuffered input */
    //    ByteIOContext rtsp_gb;
62 63 64
    int seq;        /* RTSP command sequence number */
    char session_id[512];
    enum RTSPProtocol protocol;
65
    enum RTSPServerType server_type;
66
    char last_reply[2048]; /* XXX: allocate ? */
67
    RTPDemuxContext *cur_rtp;
68
    int need_subscription;
69 70 71
} RTSPState;

typedef struct RTSPStream {
72 73
    URLContext *rtp_handle; /* RTP stream handle */
    RTPDemuxContext *rtp_ctx; /* RTP parse context */
74

75
    int stream_index; /* corresponding stream index, if any. -1 if none (MPEG2TS case) */
76
    int interleaved_min, interleaved_max;  /* interleave ids, if TCP transport */
77 78 79 80 81 82
    char control_url[1024]; /* url for this stream (from SDP) */

    int sdp_port; /* port (from SDP content - not used in RTSP) */
    struct in_addr sdp_ip; /* IP address  (from SDP content - not used in RTSP) */
    int sdp_ttl;  /* IP TTL (from SDP content - not used in RTSP) */
    int sdp_payload_type; /* payload type - only used in SDP */
Romain Degez's avatar
Romain Degez committed
83
    rtp_payload_data_t rtp_payload_data; /* rtp payload parsing infos from SDP */
Ryan Martell's avatar
Ryan Martell committed
84 85 86

    RTPDynamicProtocolHandler *dynamic_handler; ///< Only valid if it's a dynamic protocol. (This is the handler structure)
    void *dynamic_protocol_context; ///< Only valid if it's a dynamic protocol. (This is any private data associated with the dynamic protocol)
87 88
} RTSPStream;

89 90
static int rtsp_read_play(AVFormatContext *s);

91 92 93
/* XXX: currently, the only way to change the protocols consists in
   changing this variable */

Ronald S. Bultje's avatar
Ronald S. Bultje committed
94
#if LIBAVFORMAT_VERSION_INT < (53 << 16)
Romain Degez's avatar
Romain Degez committed
95
int rtsp_default_protocols = (1 << RTSP_PROTOCOL_RTP_UDP);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
96
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
97

98 99
static int rtsp_probe(AVProbeData *p)
{
100
    if (av_strstart(p->filename, "rtsp:", NULL))
101 102 103 104 105 106
        return AVPROBE_SCORE_MAX;
    return 0;
}

static int redir_isspace(int c)
{
107
    return c == ' ' || c == '\t' || c == '\n' || c == '\r';
108 109 110 111 112 113 114 115 116 117 118
}

static void skip_spaces(const char **pp)
{
    const char *p;
    p = *pp;
    while (redir_isspace(*p))
        p++;
    *pp = p;
}

119
static void get_word_sep(char *buf, int buf_size, const char *sep,
120 121 122 123 124 125
                         const char **pp)
{
    const char *p;
    char *q;

    p = *pp;
Romain Degez's avatar
Romain Degez committed
126 127
    if (*p == '/')
        p++;
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
    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;
}

static void get_word(char *buf, int buf_size, const char **pp)
{
    const char *p;
    char *q;

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

158 159
/* parse the rtpmap description: <codec_name>/<clock_rate>[/<other
   params>] */
Ryan Martell's avatar
Ryan Martell committed
160
static int sdp_parse_rtpmap(AVCodecContext *codec, RTSPStream *rtsp_st, int payload_type, const char *p)
161 162
{
    char buf[256];
Romain Degez's avatar
Romain Degez committed
163 164
    int i;
    AVCodec *c;
165
    const char *c_name;
166

Romain Degez's avatar
Romain Degez committed
167 168
    /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and
       see if we can handle this kind of payload */
169
    get_word_sep(buf, sizeof(buf), "/", &p);
Romain Degez's avatar
Romain Degez committed
170
    if (payload_type >= RTP_PT_PRIVATE) {
Ryan Martell's avatar
Ryan Martell committed
171 172 173 174 175 176 177 178
        RTPDynamicProtocolHandler *handler= RTPFirstDynamicPayloadHandler;
        while(handler) {
            if (!strcmp(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
179 180
                break;
            }
Ryan Martell's avatar
Ryan Martell committed
181 182
            handler= handler->next;
        }
183
    } else {
Romain Degez's avatar
Romain Degez committed
184 185
        /* We are in a standard case ( from http://www.iana.org/assignments/rtp-parameters) */
        /* search into AVRtpPayloadTypes[] */
186
        codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
Romain Degez's avatar
Romain Degez committed
187 188 189 190
    }

    c = avcodec_find_decoder(codec->codec_id);
    if (c && c->name)
191
        c_name = c->name;
Romain Degez's avatar
Romain Degez committed
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
    else
        c_name = (char *)NULL;

    if (c_name) {
        get_word_sep(buf, sizeof(buf), "/", &p);
        i = atoi(buf);
        switch (codec->codec_type) {
            case CODEC_TYPE_AUDIO:
                av_log(codec, 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;
209 210
                    // 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.  Upcoming patch forthcoming. (rdm)
Romain Degez's avatar
Romain Degez committed
211 212 213 214 215 216 217 218 219 220 221
                }
                av_log(codec, AV_LOG_DEBUG, " audio samplerate set to : %i\n", codec->sample_rate);
                av_log(codec, AV_LOG_DEBUG, " audio channels set to : %i\n", codec->channels);
                break;
            case CODEC_TYPE_VIDEO:
                av_log(codec, AV_LOG_DEBUG, " video codec set to : %s\n", c_name);
                break;
            default:
                break;
        }
        return 0;
222
    }
Romain Degez's avatar
Romain Degez committed
223 224

    return -1;
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
}

/* return the length and optionnaly the data */
static int hex_to_data(uint8_t *data, const char *p)
{
    int c, len, v;

    len = 0;
    v = 1;
    for(;;) {
        skip_spaces(&p);
        if (p == '\0')
            break;
        c = toupper((unsigned char)*p++);
        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;
}

Romain Degez's avatar
Romain Degez committed
256 257 258 259
static void sdp_parse_fmtp_config(AVCodecContext *codec, char *attr, char *value)
{
    switch (codec->codec_id) {
        case CODEC_ID_MPEG4:
260
        case CODEC_ID_AAC:
Romain Degez's avatar
Romain Degez committed
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
            if (!strcmp(attr, "config")) {
                /* decode the hexa encoded parameter */
                int len = hex_to_data(NULL, value);
                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;
        default:
            break;
    }
    return;
}

typedef struct attrname_map
{
279
    const char *str;
Romain Degez's avatar
Romain Degez committed
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
    uint16_t type;
    uint32_t offset;
} attrname_map_t;

/* All known fmtp parmeters and the corresping RTPAttrTypeEnum */
#define ATTR_NAME_TYPE_INT 0
#define ATTR_NAME_TYPE_STR 1
static attrname_map_t attr_names[]=
{
    {"SizeLength",       ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, sizelength)},
    {"IndexLength",      ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, indexlength)},
    {"IndexDeltaLength", ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, indexdeltalength)},
    {"profile-level-id", ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, profile_level_id)},
    {"StreamType",       ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, streamtype)},
    {"mode",             ATTR_NAME_TYPE_STR, offsetof(rtp_payload_data_t, mode)},
    {NULL, -1, -1},
};

298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
/** 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)
{
    skip_spaces(p);
    if(**p)
    {
        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
317 318
/* parse a SDP line and save stream attributes */
static void sdp_parse_fmtp(AVStream *st, const char *p)
319 320 321
{
    char attr[256];
    char value[4096];
Romain Degez's avatar
Romain Degez committed
322 323 324
    int i;

    RTSPStream *rtsp_st = st->priv_data;
325
    AVCodecContext *codec = st->codec;
Romain Degez's avatar
Romain Degez committed
326
    rtp_payload_data_t *rtp_payload_data = &rtsp_st->rtp_payload_data;
327 328

    /* loop on each attribute */
329 330
    while(rtsp_next_attr_and_value(&p, attr, sizeof(attr), value, sizeof(value)))
    {
331
        /* grab the codec extra_data from the config parameter of the fmtp line */
Romain Degez's avatar
Romain Degez committed
332 333 334 335 336 337 338 339
        sdp_parse_fmtp_config(codec, attr, value);
        /* Looking for a known attribute */
        for (i = 0; attr_names[i].str; ++i) {
            if (!strcasecmp(attr, attr_names[i].str)) {
                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);
340
            }
341 342 343 344
        }
    }
}

345 346 347 348 349 350 351 352 353
/** Parse a string \p in the form of Range:npt=xx-xx, and determine the start
 *  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);
354
    if (!av_stristart(p, "npt=", &p))
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
        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);
}

371 372 373 374 375 376 377
typedef struct SDPParseState {
    /* SDP only */
    struct in_addr default_ip;
    int default_ttl;
} SDPParseState;

static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
378 379
                           int letter, const char *buf)
{
380
    RTSPState *rt = s->priv_data;
381 382
    char buf1[64], st_type[64];
    const char *p;
383
    int codec_type, payload_type, i;
384 385
    AVStream *st;
    RTSPStream *rtsp_st;
386 387 388
    struct in_addr sdp_ip;
    int ttl;

389 390 391 392 393 394
#ifdef DEBUG
    printf("sdp: %c='%s'\n", letter, buf);
#endif

    p = buf;
    switch(letter) {
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
    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;
421
    case 's':
Måns Rullgård's avatar
Måns Rullgård committed
422
        av_strlcpy(s->title, p, sizeof(s->title));
423 424 425
        break;
    case 'i':
        if (s->nb_streams == 0) {
Måns Rullgård's avatar
Måns Rullgård committed
426
            av_strlcpy(s->comment, p, sizeof(s->comment));
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
            break;
        }
        break;
    case 'm':
        /* new stream */
        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;
        } else {
            return;
        }
        rtsp_st = av_mallocz(sizeof(RTSPStream));
        if (!rtsp_st)
            return;
443 444
        rtsp_st->stream_index = -1;
        dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
445 446 447 448 449 450 451 452

        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) */
453

454 455 456 457
        /* XXX: handle list of formats */
        get_word(buf1, sizeof(buf1), &p); /* format list */
        rtsp_st->sdp_payload_type = atoi(buf1);

458
        if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
459 460 461 462 463 464 465
            /* no corresponding stream */
        } else {
            st = av_new_stream(s, 0);
            if (!st)
                return;
            st->priv_data = rtsp_st;
            rtsp_st->stream_index = st->index;
466
            st->codec->codec_type = codec_type;
Romain Degez's avatar
Romain Degez committed
467
            if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
468
                /* if standard payload type, we can find the codec right now */
469
                rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
470 471
            }
        }
472
        /* put a default control url */
Måns Rullgård's avatar
Måns Rullgård committed
473
        av_strlcpy(rtsp_st->control_url, s->filename, sizeof(rtsp_st->control_url));
474 475
        break;
    case 'a':
476
        if (av_strstart(p, "control:", &p) && s->nb_streams > 0) {
477 478 479 480
            char proto[32];
            /* get the control url */
            st = s->streams[s->nb_streams - 1];
            rtsp_st = st->priv_data;
481

482
            /* XXX: may need to add full url resolution */
483
            url_split(proto, sizeof(proto), NULL, 0, NULL, 0, NULL, NULL, 0, p);
484 485
            if (proto[0] == '\0') {
                /* relative control URL */
Måns Rullgård's avatar
Måns Rullgård committed
486 487
                av_strlcat(rtsp_st->control_url, "/", sizeof(rtsp_st->control_url));
                av_strlcat(rtsp_st->control_url, p,   sizeof(rtsp_st->control_url));
488
            } else {
Måns Rullgård's avatar
Måns Rullgård committed
489
                av_strlcpy(rtsp_st->control_url, p,   sizeof(rtsp_st->control_url));
490
            }
491
        } else if (av_strstart(p, "rtpmap:", &p)) {
492
            /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
493
            get_word(buf1, sizeof(buf1), &p);
494 495 496 497 498
            payload_type = atoi(buf1);
            for(i = 0; i < s->nb_streams;i++) {
                st = s->streams[i];
                rtsp_st = st->priv_data;
                if (rtsp_st->sdp_payload_type == payload_type) {
Ryan Martell's avatar
Ryan Martell committed
499
                    sdp_parse_rtpmap(st->codec, rtsp_st, payload_type, p);
500 501
                }
            }
502
        } else if (av_strstart(p, "fmtp:", &p)) {
503
            /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
504
            get_word(buf1, sizeof(buf1), &p);
505 506 507 508 509
            payload_type = atoi(buf1);
            for(i = 0; i < s->nb_streams;i++) {
                st = s->streams[i];
                rtsp_st = st->priv_data;
                if (rtsp_st->sdp_payload_type == payload_type) {
Ryan Martell's avatar
Ryan Martell committed
510 511 512 513 514
                    if(rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->parse_sdp_a_line) {
                        if(!rtsp_st->dynamic_handler->parse_sdp_a_line(st, rtsp_st->dynamic_protocol_context, buf)) {
                            sdp_parse_fmtp(st, p);
                        }
                    } else {
515
                        sdp_parse_fmtp(st, p);
Ryan Martell's avatar
Ryan Martell committed
516
                    }
517 518
                }
            }
519
        } else if(av_strstart(p, "framesize:", &p)) {
520 521 522 523 524 525 526 527 528 529 530 531
            // let dynamic protocol handlers have a stab at the line.
            get_word(buf1, sizeof(buf1), &p);
            payload_type = atoi(buf1);
            for(i = 0; i < s->nb_streams;i++) {
                st = s->streams[i];
                rtsp_st = st->priv_data;
                if (rtsp_st->sdp_payload_type == payload_type) {
                    if(rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->parse_sdp_a_line) {
                        rtsp_st->dynamic_handler->parse_sdp_a_line(st, rtsp_st->dynamic_protocol_context, buf);
                    }
                }
            }
532
        } else if(av_strstart(p, "range:", &p)) {
533 534 535 536 537 538
            int64_t start, end;

            // this is so that seeking on a streamed file can work.
            rtsp_parse_range_npt(p, &start, &end);
            s->start_time= start;
            s->duration= (end==AV_NOPTS_VALUE)?AV_NOPTS_VALUE:end-start; // AV_NOPTS_VALUE means live broadcast (and can't seek)
539 540 541 542 543 544
        } else if (s->nb_streams > 0) {
            rtsp_st = s->streams[s->nb_streams - 1]->priv_data;
            if (rtsp_st->dynamic_handler &&
                rtsp_st->dynamic_handler->parse_sdp_a_line)
                rtsp_st->dynamic_handler->parse_sdp_a_line(s->streams[s->nb_streams - 1],
                    rtsp_st->dynamic_protocol_context, buf);
545 546 547 548 549
        }
        break;
    }
}

550
static int sdp_parse(AVFormatContext *s, const char *content)
551 552 553
{
    const char *p;
    int letter;
554
    char buf[2048], *q;
555
    SDPParseState sdp_parse_state, *s1 = &sdp_parse_state;
556

557
    memset(s1, 0, sizeof(SDPParseState));
558 559 560 561 562 563 564 565 566 567 568 569
    p = content;
    for(;;) {
        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
570
        while (*p != '\n' && *p != '\r' && *p != '\0') {
571 572 573 574 575
            if ((q - buf) < sizeof(buf) - 1)
                *q++ = *p;
            p++;
        }
        *q = '\0';
576
        sdp_parse_line(s, s1, letter, buf);
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
    next_line:
        while (*p != '\n' && *p != '\0')
            p++;
        if (*p == '\n')
            p++;
    }
    return 0;
}

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 */
static void rtsp_parse_transport(RTSPHeader *reply, const char *p)
{
    char transport_protocol[16];
    char profile[16];
    char lower_transport[16];
    char parameter[16];
    RTSPTransportField *th;
    char buf[256];
615

616
    reply->nb_transports = 0;
617

618 619 620 621 622 623 624
    for(;;) {
        skip_spaces(&p);
        if (*p == '\0')
            break;

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

625
        get_word_sep(transport_protocol, sizeof(transport_protocol),
626 627 628
                     "/", &p);
        if (*p == '/')
            p++;
629
        if (!strcasecmp (transport_protocol, "rtp")) {
630 631 632 633 634 635 636 637 638 639
            get_word_sep(profile, sizeof(profile), "/;,", &p);
            lower_transport[0] = '\0';
            /* rtp/avp/<protocol> */
            if (*p == '/') {
                p++;
                get_word_sep(lower_transport, sizeof(lower_transport),
                             ";,", &p);
                }
        } else if (!strcasecmp (transport_protocol, "x-pn-tng")) {
            /* x-pn-tng/<protocol> */
640 641
            get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
            profile[0] = '\0';
642
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
643
        if (!strcasecmp(lower_transport, "TCP"))
644 645 646
            th->protocol = RTSP_PROTOCOL_RTP_TCP;
        else
            th->protocol = RTSP_PROTOCOL_RTP_UDP;
647

648 649 650 651 652 653 654 655 656 657 658 659 660
        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++;
661
                    rtsp_parse_range(&th->client_port_min,
662 663 664 665 666
                                     &th->client_port_max, &p);
                }
            } else if (!strcmp(parameter, "server_port")) {
                if (*p == '=') {
                    p++;
667
                    rtsp_parse_range(&th->server_port_min,
668 669 670 671 672
                                     &th->server_port_max, &p);
                }
            } else if (!strcmp(parameter, "interleaved")) {
                if (*p == '=') {
                    p++;
673
                    rtsp_parse_range(&th->interleaved_min,
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
                                     &th->interleaved_max, &p);
                }
            } else if (!strcmp(parameter, "multicast")) {
                if (th->protocol == RTSP_PROTOCOL_RTP_UDP)
                    th->protocol = RTSP_PROTOCOL_RTP_UDP_MULTICAST;
            } 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);
690
                    if (inet_aton(buf, &ipaddr))
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711
                        th->destination = ntohl(ipaddr.s_addr);
                }
            }
            while (*p != ';' && *p != '\0' && *p != ',')
                p++;
            if (*p == ';')
                p++;
        }
        if (*p == ',')
            p++;

        reply->nb_transports++;
    }
}

void rtsp_parse_line(RTSPHeader *reply, const char *buf)
{
    const char *p;

    /* NOTE: we do case independent match for broken servers */
    p = buf;
712
    if (av_stristart(p, "Session:", &p)) {
713
        get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
714
    } else if (av_stristart(p, "Content-Length:", &p)) {
715
        reply->content_length = strtol(p, NULL, 10);
716
    } else if (av_stristart(p, "Transport:", &p)) {
717
        rtsp_parse_transport(reply, p);
718
    } else if (av_stristart(p, "CSeq:", &p)) {
719
        reply->seq = strtol(p, NULL, 10);
720
    } else if (av_stristart(p, "Range:", &p)) {
721
        rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
722 723 724
    } else if (av_stristart(p, "RealChallenge1:", &p)) {
        skip_spaces(&p);
        av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
725 726 727
    }
}

728 729 730 731 732 733 734 735 736 737 738 739 740 741
static int url_readbuf(URLContext *h, unsigned char *buf, int size)
{
    int ret, len;

    len = 0;
    while (len < size) {
        ret = url_read(h, buf+len, size-len);
        if (ret < 1)
            return ret;
        len += ret;
    }
    return len;
}

742 743 744 745 746 747 748
/* 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];

749
    ret = url_readbuf(rt->rtsp_hd, buf, 3);
750 751
    if (ret != 3)
        return;
752
    len = AV_RB16(buf + 1);
753 754 755 756 757 758 759 760
#ifdef DEBUG
    printf("skipping RTP packet len=%d\n", len);
#endif
    /* skip payload */
    while (len > 0) {
        len1 = len;
        if (len1 > sizeof(buf))
            len1 = sizeof(buf);
761
        ret = url_readbuf(rt->rtsp_hd, buf, len1);
762 763 764 765 766
        if (ret != len1)
            return;
        len -= len1;
    }
}
767

768 769
static void rtsp_send_cmd(AVFormatContext *s,
                          const char *cmd, RTSPHeader *reply,
770 771 772 773 774 775 776 777 778 779 780 781
                          unsigned char **content_ptr)
{
    RTSPState *rt = s->priv_data;
    char buf[4096], buf1[1024], *q;
    unsigned char ch;
    const char *p;
    int content_length, line_count;
    unsigned char *content = NULL;

    memset(reply, 0, sizeof(RTSPHeader));

    rt->seq++;
Måns Rullgård's avatar
Måns Rullgård committed
782
    av_strlcpy(buf, cmd, sizeof(buf));
Fabrice Bellard's avatar
Fabrice Bellard committed
783
    snprintf(buf1, sizeof(buf1), "CSeq: %d\r\n", rt->seq);
Måns Rullgård's avatar
Måns Rullgård committed
784
    av_strlcat(buf, buf1, sizeof(buf));
785
    if (rt->session_id[0] != '\0' && !strstr(cmd, "\nIf-Match:")) {
Fabrice Bellard's avatar
Fabrice Bellard committed
786
        snprintf(buf1, sizeof(buf1), "Session: %s\r\n", rt->session_id);
Måns Rullgård's avatar
Måns Rullgård committed
787
        av_strlcat(buf, buf1, sizeof(buf));
788
    }
Måns Rullgård's avatar
Måns Rullgård committed
789
    av_strlcat(buf, "\r\n", sizeof(buf));
790 791 792 793 794 795 796 797 798 799 800
#ifdef DEBUG
    printf("Sending:\n%s--\n", buf);
#endif
    url_write(rt->rtsp_hd, buf, strlen(buf));

    /* parse reply (XXX: use buffers) */
    line_count = 0;
    rt->last_reply[0] = '\0';
    for(;;) {
        q = buf;
        for(;;) {
801
            if (url_readbuf(rt->rtsp_hd, &ch, 1) != 1)
802 803 804
                break;
            if (ch == '\n')
                break;
805 806 807 808
            if (ch == '$') {
                /* XXX: only parse it if first char on line ? */
                rtsp_skip_packet(s);
            } else if (ch != '\r') {
809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
                if ((q - buf) < sizeof(buf) - 1)
                    *q++ = ch;
            }
        }
        *q = '\0';
#ifdef DEBUG
        printf("line='%s'\n", buf);
#endif
        /* 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
828 829
            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
830 831 832
        }
        line_count++;
    }
833

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

837 838 839 840
    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);
841
        (void)url_readbuf(rt->rtsp_hd, content, content_length);
842 843 844 845
        content[content_length] = '\0';
    }
    if (content_ptr)
        *content_ptr = content;
846 847
    else
        av_free(content);
848 849 850
}


851 852 853 854 855 856 857 858 859 860 861 862 863
/* close and free RTSP streams */
static void rtsp_close_streams(RTSPState *rt)
{
    int i;
    RTSPStream *rtsp_st;

    for(i=0;i<rt->nb_rtsp_streams;i++) {
        rtsp_st = rt->rtsp_streams[i];
        if (rtsp_st) {
            if (rtsp_st->rtp_ctx)
                rtp_parse_close(rtsp_st->rtp_ctx);
            if (rtsp_st->rtp_handle)
                url_close(rtsp_st->rtp_handle);
Ryan Martell's avatar
Ryan Martell committed
864 865
            if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
                rtsp_st->dynamic_handler->close(rtsp_st->dynamic_protocol_context);
866 867 868 869 870
        }
    }
    av_free(rt->rtsp_streams);
}

871 872 873 874 875
static int
rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
{
    AVStream *st = NULL;

876 877 878 879 880 881 882 883 884 885 886 887 888
    /* open the RTP context */
    if (rtsp_st->stream_index >= 0)
        st = s->streams[rtsp_st->stream_index];
    if (!st)
        s->ctx_flags |= AVFMTCTX_NOHEADER;
    rtsp_st->rtp_ctx = rtp_parse_open(s, st, rtsp_st->rtp_handle, rtsp_st->sdp_payload_type, &rtsp_st->rtp_payload_data);

    if (!rtsp_st->rtp_ctx) {
         return AVERROR(ENOMEM);
    } else {
        if(rtsp_st->dynamic_handler) {
            rtsp_st->rtp_ctx->dynamic_protocol_context= rtsp_st->dynamic_protocol_context;
            rtsp_st->rtp_ctx->parse_packet= rtsp_st->dynamic_handler->parse_packet;
889
        }
890
    }
891 892 893 894

    return 0;
}

895 896 897 898
/**
 * @returns 0 on success, <0 on error, 1 if protocol is unavailable.
 */
static int
899 900
make_setup_request (AVFormatContext *s, const char *host, int port,
                    int protocol, const char *real_challenge)
901 902
{
    RTSPState *rt = s->priv_data;
903
    int j, i, err;
904
    RTSPStream *rtsp_st;
905 906
    RTSPHeader reply1, *reply = &reply1;
    char cmd[2048];
907 908
    const char *trans_pref;

909
    if (rt->server_type == RTSP_SERVER_REAL)
910 911 912
        trans_pref = "x-pn-tng";
    else
        trans_pref = "RTP/AVP";
913

914 915 916
    /* for each stream, make the setup request */
    /* XXX: we assume the same server is used for the control of each
       RTSP stream */
Romain Degez's avatar
Romain Degez committed
917 918

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

921
        rtsp_st = rt->rtsp_streams[i];
922 923

        /* RTP/UDP */
924
        if (protocol == RTSP_PROTOCOL_RTP_UDP) {
Fabrice Bellard's avatar
Fabrice Bellard committed
925 926 927
            char buf[256];

            /* first try in specified port range */
Romain Degez's avatar
Romain Degez committed
928 929
            if (RTSP_RTP_PORT_MIN != 0) {
                while(j <= RTSP_RTP_PORT_MAX) {
930
                    snprintf(buf, sizeof(buf), "rtp://%s?localport=%d", host, j);
931
                    j += 2; /* we will use two port by rtp stream (rtp and rtcp) */
932
                    if (url_open(&rtsp_st->rtp_handle, buf, URL_RDWR) == 0) {
Fabrice Bellard's avatar
Fabrice Bellard committed
933
                        goto rtp_opened;
Romain Degez's avatar
Romain Degez committed
934
                    }
Fabrice Bellard's avatar
Fabrice Bellard committed
935
                }
936
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
937

Romain Degez's avatar
Romain Degez committed
938 939 940 941 942 943
/*            then try on any port
**            if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
**                err = AVERROR_INVALIDDATA;
**                goto fail;
**            }
*/
Fabrice Bellard's avatar
Fabrice Bellard committed
944 945

        rtp_opened:
946
            port = rtp_get_local_port(rtsp_st->rtp_handle);
947
            snprintf(transport, sizeof(transport) - 1,
948 949 950 951
                     "%s/UDP;unicast;client_port=%d",
                     trans_pref, port);
            if (rt->server_type == RTSP_SERVER_RTP)
                av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
952 953 954
        }

        /* RTP/TCP */
955
        else if (protocol == RTSP_PROTOCOL_RTP_TCP) {
956
            snprintf(transport, sizeof(transport) - 1,
957
                     "%s/TCP", trans_pref);
958 959
        }

960
        else if (protocol == RTSP_PROTOCOL_RTP_UDP_MULTICAST) {
961
            snprintf(transport, sizeof(transport) - 1,
962
                     "%s/UDP;multicast", trans_pref);
963
        }
964
        if (rt->server_type == RTSP_SERVER_REAL)
965
            av_strlcat(transport, ";mode=play", sizeof(transport));
966
        snprintf(cmd, sizeof(cmd),
Fabrice Bellard's avatar
Fabrice Bellard committed
967 968
                 "SETUP %s RTSP/1.0\r\n"
                 "Transport: %s\r\n",
969
                 rtsp_st->control_url, transport);
970
        if (i == 0 && rt->server_type == RTSP_SERVER_REAL) {
971 972 973 974 975 976 977 978
            char real_res[41], real_csum[9];
            ff_rdt_calc_response_and_checksum(real_res, real_csum,
                                              real_challenge);
            av_strlcatf(cmd, sizeof(cmd),
                        "If-Match: %s\r\n"
                        "RealChallenge2: %s, sd=%s\r\n",
                        rt->session_id, real_res, real_csum);
        }
979
        rtsp_send_cmd(s, cmd, reply, NULL);
980 981 982
        if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
            err = 1;
            goto fail;
983 984
        } else if (reply->status_code != RTSP_STATUS_OK ||
                   reply->nb_transports != 1) {
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000
            err = AVERROR_INVALIDDATA;
            goto fail;
        }

        /* XXX: same protocol for all streams is required */
        if (i > 0) {
            if (reply->transports[0].protocol != rt->protocol) {
                err = AVERROR_INVALIDDATA;
                goto fail;
            }
        } else {
            rt->protocol = reply->transports[0].protocol;
        }

        /* close RTP connection if not choosen */
        if (reply->transports[0].protocol != RTSP_PROTOCOL_RTP_UDP &&
1001
            (protocol == RTSP_PROTOCOL_RTP_UDP)) {
1002 1003
            url_close(rtsp_st->rtp_handle);
            rtsp_st->rtp_handle = NULL;
1004 1005 1006 1007 1008 1009 1010
        }

        switch(reply->transports[0].protocol) {
        case RTSP_PROTOCOL_RTP_TCP:
            rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
            rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
            break;
1011

1012 1013 1014
        case RTSP_PROTOCOL_RTP_UDP:
            {
                char url[1024];
1015

1016
                /* XXX: also use address if specified */
1017
                snprintf(url, sizeof(url), "rtp://%s:%d",
1018
                         host, reply->transports[0].server_port_min);