rtsp.c 48.1 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 35
#include "rtp_internal.h"

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

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

45 46 47 48 49 50
enum RTSPServerType {
    RTSP_SERVER_RTP, /*< Standard-compliant RTP-server */
    RTSP_SERVER_RDT, /*< Realmedia-style server */
    RTSP_SERVER_LAST
};

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

56 57
    enum RTSPClientState state;
    int64_t seek_timestamp;
58

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

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

73
    int stream_index; /* corresponding stream index, if any. -1 if none (MPEG2TS case) */
74
    int interleaved_min, interleaved_max;  /* interleave ids, if TCP transport */
75 76 77 78 79 80
    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
81
    rtp_payload_data_t rtp_payload_data; /* rtp payload parsing infos from SDP */
Ryan Martell's avatar
Ryan Martell committed
82 83 84

    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)
85 86
} RTSPStream;

87 88
static int rtsp_read_play(AVFormatContext *s);

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

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

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

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

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

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

    p = *pp;
Romain Degez's avatar
Romain Degez committed
124 125
    if (*p == '/')
        p++;
126 127 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
    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;
}

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

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

    c = avcodec_find_decoder(codec->codec_id);
    if (c && c->name)
189
        c_name = c->name;
Romain Degez's avatar
Romain Degez committed
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
    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;
207 208
                    // 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
209 210 211 212 213 214 215 216 217 218 219
                }
                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;
220
    }
Romain Degez's avatar
Romain Degez committed
221 222

    return -1;
223 224 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
}

/* 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
254 255 256 257
static void sdp_parse_fmtp_config(AVCodecContext *codec, char *attr, char *value)
{
    switch (codec->codec_id) {
        case CODEC_ID_MPEG4:
258
        case CODEC_ID_AAC:
Romain Degez's avatar
Romain Degez committed
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
            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
{
277
    const char *str;
Romain Degez's avatar
Romain Degez committed
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
    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},
};

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

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

    /* loop on each attribute */
327 328
    while(rtsp_next_attr_and_value(&p, attr, sizeof(attr), value, sizeof(value)))
    {
329
        /* grab the codec extra_data from the config parameter of the fmtp line */
Romain Degez's avatar
Romain Degez committed
330 331 332 333 334 335 336 337
        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);
338
            }
339 340 341 342
        }
    }
}

343 344 345 346 347 348 349 350 351
/** 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);
352
    if (!av_stristart(p, "npt=", &p))
353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
        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);
}

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

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

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

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

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

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

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

480
            /* XXX: may need to add full url resolution */
481
            url_split(proto, sizeof(proto), NULL, 0, NULL, 0, NULL, NULL, 0, p);
482 483
            if (proto[0] == '\0') {
                /* relative control URL */
Måns Rullgård's avatar
Måns Rullgård committed
484 485
                av_strlcat(rtsp_st->control_url, "/", sizeof(rtsp_st->control_url));
                av_strlcat(rtsp_st->control_url, p,   sizeof(rtsp_st->control_url));
486
            } else {
Måns Rullgård's avatar
Måns Rullgård committed
487
                av_strlcpy(rtsp_st->control_url, p,   sizeof(rtsp_st->control_url));
488
            }
489
        } else if (av_strstart(p, "rtpmap:", &p)) {
490
            /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
491
            get_word(buf1, sizeof(buf1), &p);
492 493 494 495 496
            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
497
                    sdp_parse_rtpmap(st->codec, rtsp_st, payload_type, p);
498 499
                }
            }
500
        } else if (av_strstart(p, "fmtp:", &p)) {
501
            /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
502
            get_word(buf1, sizeof(buf1), &p);
503 504 505 506 507
            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
508 509 510 511 512
                    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 {
513
                        sdp_parse_fmtp(st, p);
Ryan Martell's avatar
Ryan Martell committed
514
                    }
515 516
                }
            }
517
        } else if(av_strstart(p, "framesize:", &p)) {
518 519 520 521 522 523 524 525 526 527 528 529
            // 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);
                    }
                }
            }
530
        } else if(av_strstart(p, "range:", &p)) {
531 532 533 534 535 536
            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)
537 538 539 540 541 542
        } 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);
543 544 545 546 547
        }
        break;
    }
}

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

555
    memset(s1, 0, sizeof(SDPParseState));
556 557 558 559 560 561 562 563 564 565 566 567
    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
568
        while (*p != '\n' && *p != '\r' && *p != '\0') {
569 570 571 572 573
            if ((q - buf) < sizeof(buf) - 1)
                *q++ = *p;
            p++;
        }
        *q = '\0';
574
        sdp_parse_line(s, s1, letter, buf);
575 576 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
    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];
613

614
    reply->nb_transports = 0;
615

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

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

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

646 647 648 649 650 651 652 653 654 655 656 657 658
        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++;
659
                    rtsp_parse_range(&th->client_port_min,
660 661 662 663 664
                                     &th->client_port_max, &p);
                }
            } else if (!strcmp(parameter, "server_port")) {
                if (*p == '=') {
                    p++;
665
                    rtsp_parse_range(&th->server_port_min,
666 667 668 669 670
                                     &th->server_port_max, &p);
                }
            } else if (!strcmp(parameter, "interleaved")) {
                if (*p == '=') {
                    p++;
671
                    rtsp_parse_range(&th->interleaved_min,
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
                                     &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);
688
                    if (inet_aton(buf, &ipaddr))
689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
                        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;
710
    if (av_stristart(p, "Session:", &p)) {
711
        get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
712
    } else if (av_stristart(p, "Content-Length:", &p)) {
713
        reply->content_length = strtol(p, NULL, 10);
714
    } else if (av_stristart(p, "Transport:", &p)) {
715
        rtsp_parse_transport(reply, p);
716
    } else if (av_stristart(p, "CSeq:", &p)) {
717
        reply->seq = strtol(p, NULL, 10);
718
    } else if (av_stristart(p, "Range:", &p)) {
719
        rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
720 721 722
    } else if (av_stristart(p, "RealChallenge1:", &p)) {
        skip_spaces(&p);
        av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
723 724 725
    }
}

726 727 728 729 730 731 732 733 734 735 736 737 738 739
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;
}

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

747
    ret = url_readbuf(rt->rtsp_hd, buf, 3);
748 749
    if (ret != 3)
        return;
750
    len = AV_RB16(buf + 1);
751 752 753 754 755 756 757 758
#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);
759
        ret = url_readbuf(rt->rtsp_hd, buf, len1);
760 761 762 763 764
        if (ret != len1)
            return;
        len -= len1;
    }
}
765

766 767
static void rtsp_send_cmd(AVFormatContext *s,
                          const char *cmd, RTSPHeader *reply,
768 769 770 771 772 773 774 775 776 777 778 779
                          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
780
    av_strlcpy(buf, cmd, sizeof(buf));
Fabrice Bellard's avatar
Fabrice Bellard committed
781
    snprintf(buf1, sizeof(buf1), "CSeq: %d\r\n", rt->seq);
Måns Rullgård's avatar
Måns Rullgård committed
782
    av_strlcat(buf, buf1, sizeof(buf));
783
    if (rt->session_id[0] != '\0' && !strstr(cmd, "\nIf-Match:")) {
Fabrice Bellard's avatar
Fabrice Bellard committed
784
        snprintf(buf1, sizeof(buf1), "Session: %s\r\n", rt->session_id);
Måns Rullgård's avatar
Måns Rullgård committed
785
        av_strlcat(buf, buf1, sizeof(buf));
786
    }
Måns Rullgård's avatar
Måns Rullgård committed
787
    av_strlcat(buf, "\r\n", sizeof(buf));
788 789 790 791 792 793 794 795 796 797 798
#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(;;) {
799
            if (url_readbuf(rt->rtsp_hd, &ch, 1) != 1)
800 801 802
                break;
            if (ch == '\n')
                break;
803 804 805 806
            if (ch == '$') {
                /* XXX: only parse it if first char on line ? */
                rtsp_skip_packet(s);
            } else if (ch != '\r') {
807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825
                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
826 827
            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
828 829 830
        }
        line_count++;
    }
831

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

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


849 850 851 852 853 854 855 856 857 858 859 860 861
/* 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
862 863
            if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
                rtsp_st->dynamic_handler->close(rtsp_st->dynamic_protocol_context);
864 865 866 867 868
        }
    }
    av_free(rt->rtsp_streams);
}

869 870 871 872
/**
 * @returns 0 on success, <0 on error, 1 if protocol is unavailable.
 */
static int
873
make_setup_request (AVFormatContext *s, const char *host, int port, int protocol)
874 875
{
    RTSPState *rt = s->priv_data;
876
    int j, i, err;
877
    RTSPStream *rtsp_st;
878
    AVStream *st;
879 880
    RTSPHeader reply1, *reply = &reply1;
    char cmd[2048];
881

882 883 884
    /* 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
885 886

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

889
        rtsp_st = rt->rtsp_streams[i];
890 891 892 893 894

        /* compute available transports */
        transport[0] = '\0';

        /* RTP/UDP */
895
        if (protocol == RTSP_PROTOCOL_RTP_UDP) {
Fabrice Bellard's avatar
Fabrice Bellard committed
896 897 898
            char buf[256];

            /* first try in specified port range */
Romain Degez's avatar
Romain Degez committed
899 900
            if (RTSP_RTP_PORT_MIN != 0) {
                while(j <= RTSP_RTP_PORT_MAX) {
901
                    snprintf(buf, sizeof(buf), "rtp://%s?localport=%d", host, j);
902
                    j += 2; /* we will use two port by rtp stream (rtp and rtcp) */
903
                    if (url_open(&rtsp_st->rtp_handle, buf, URL_RDWR) == 0) {
Fabrice Bellard's avatar
Fabrice Bellard committed
904
                        goto rtp_opened;
Romain Degez's avatar
Romain Degez committed
905
                    }
Fabrice Bellard's avatar
Fabrice Bellard committed
906
                }
907
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
908

Romain Degez's avatar
Romain Degez committed
909 910 911 912 913 914
/*            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
915 916

        rtp_opened:
917
            port = rtp_get_local_port(rtsp_st->rtp_handle);
918
            if (transport[0] != '\0')
Måns Rullgård's avatar
Måns Rullgård committed
919
                av_strlcat(transport, ",", sizeof(transport));
920 921 922 923 924 925
            snprintf(transport + strlen(transport), sizeof(transport) - strlen(transport) - 1,
                     "RTP/AVP/UDP;unicast;client_port=%d-%d",
                     port, port + 1);
        }

        /* RTP/TCP */
926
        else if (protocol == RTSP_PROTOCOL_RTP_TCP) {
927
            if (transport[0] != '\0')
Måns Rullgård's avatar
Måns Rullgård committed
928
                av_strlcat(transport, ",", sizeof(transport));
929 930 931 932
            snprintf(transport + strlen(transport), sizeof(transport) - strlen(transport) - 1,
                     "RTP/AVP/TCP");
        }

933
        else if (protocol == RTSP_PROTOCOL_RTP_UDP_MULTICAST) {
934
            if (transport[0] != '\0')
Måns Rullgård's avatar
Måns Rullgård committed
935
                av_strlcat(transport, ",", sizeof(transport));
936
            snprintf(transport + strlen(transport),
937 938 939
                     sizeof(transport) - strlen(transport) - 1,
                     "RTP/AVP/UDP;multicast");
        }
940
        snprintf(cmd, sizeof(cmd),
Fabrice Bellard's avatar
Fabrice Bellard committed
941 942
                 "SETUP %s RTSP/1.0\r\n"
                 "Transport: %s\r\n",
943 944
                 rtsp_st->control_url, transport);
        rtsp_send_cmd(s, cmd, reply, NULL);
945 946 947
        if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
            err = 1;
            goto fail;
948 949
        } else if (reply->status_code != RTSP_STATUS_OK ||
                   reply->nb_transports != 1) {
950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965
            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 &&
966
            (protocol == RTSP_PROTOCOL_RTP_UDP)) {
967 968
            url_close(rtsp_st->rtp_handle);
            rtsp_st->rtp_handle = NULL;
969 970 971 972 973 974 975
        }

        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;
976

977 978 979
        case RTSP_PROTOCOL_RTP_UDP:
            {
                char url[1024];
980

981
                /* XXX: also use address if specified */
982
                snprintf(url, sizeof(url), "rtp://%s:%d",
983
                         host, reply->transports[0].server_port_min);
984
                if (rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
985 986 987 988 989 990 991 992
                    err = AVERROR_INVALIDDATA;
                    goto fail;
                }
            }
            break;
        case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
            {
                char url[1024];
993
                struct in_addr in;
994

995
                in.s_addr = htonl(reply->transports[0].destination);
996
                snprintf(url, sizeof(url), "rtp://%s:%d?ttl=%d",
997 998 999
                         inet_ntoa(in),
                         reply->transports[0].port_min,
                         reply->transports[0].ttl);
1000
                if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1001 1002 1003 1004 1005 1006
                    err = AVERROR_INVALIDDATA;
                    goto fail;
                }
            }
            break;
        }
1007 1008 1009 1010 1011 1012
        /* open the RTP context */
        st = NULL;
        if (rtsp_st->stream_index >= 0)
            st = s->streams[rtsp_st->stream_index];
        if (!st)
            s->ctx_flags |= AVFMTCTX_NOHEADER;
1013
        rtsp_st->rtp_ctx = rtp_parse_open(s, st, rtsp_st->rtp_handle, rtsp_st->sdp_payload_type, &rtsp_st->rtp_payload_data);
Romain Degez's avatar