Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtsp.c @ 6a5d31ac

History | View | Annotate | Download (51.7 KB)

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

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

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

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

    
37
#include "rtp_internal.h"
38
#include "rdt.h"
39

    
40
//#define DEBUG
41
//#define DEBUG_RTP_TCP
42

    
43
static int rtsp_read_play(AVFormatContext *s);
44

    
45
/* XXX: currently, the only way to change the protocols consists in
46
   changing this variable */
47

    
48
#if LIBAVFORMAT_VERSION_INT < (53 << 16)
49
int rtsp_default_protocols = (1 << RTSP_LOWER_TRANSPORT_UDP);
50
#endif
51

    
52
static int rtsp_probe(AVProbeData *p)
53
{
54
    if (av_strstart(p->filename, "rtsp:", NULL))
55
        return AVPROBE_SCORE_MAX;
56
    return 0;
57
}
58

    
59
static int redir_isspace(int c)
60
{
61
    return c == ' ' || c == '\t' || c == '\n' || c == '\r';
62
}
63

    
64
static void skip_spaces(const char **pp)
65
{
66
    const char *p;
67
    p = *pp;
68
    while (redir_isspace(*p))
69
        p++;
70
    *pp = p;
71
}
72

    
73
static void get_word_sep(char *buf, int buf_size, const char *sep,
74
                         const char **pp)
75
{
76
    const char *p;
77
    char *q;
78

    
79
    p = *pp;
80
    if (*p == '/')
81
        p++;
82
    skip_spaces(&p);
83
    q = buf;
84
    while (!strchr(sep, *p) && *p != '\0') {
85
        if ((q - buf) < buf_size - 1)
86
            *q++ = *p;
87
        p++;
88
    }
89
    if (buf_size > 0)
90
        *q = '\0';
91
    *pp = p;
92
}
93

    
94
static void get_word(char *buf, int buf_size, const char **pp)
95
{
96
    const char *p;
97
    char *q;
98

    
99
    p = *pp;
100
    skip_spaces(&p);
101
    q = buf;
102
    while (!redir_isspace(*p) && *p != '\0') {
103
        if ((q - buf) < buf_size - 1)
104
            *q++ = *p;
105
        p++;
106
    }
107
    if (buf_size > 0)
108
        *q = '\0';
109
    *pp = p;
110
}
111

    
112
/* parse the rtpmap description: <codec_name>/<clock_rate>[/<other
113
   params>] */
114
static int sdp_parse_rtpmap(AVCodecContext *codec, RTSPStream *rtsp_st, int payload_type, const char *p)
115
{
116
    char buf[256];
117
    int i;
118
    AVCodec *c;
119
    const char *c_name;
120

    
121
    /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and
122
       see if we can handle this kind of payload */
123
    get_word_sep(buf, sizeof(buf), "/", &p);
124
    if (payload_type >= RTP_PT_PRIVATE) {
125
        RTPDynamicProtocolHandler *handler= RTPFirstDynamicPayloadHandler;
126
        while(handler) {
127
            if (!strcmp(buf, handler->enc_name) && (codec->codec_type == handler->codec_type)) {
128
                codec->codec_id = handler->codec_id;
129
                rtsp_st->dynamic_handler= handler;
130
                if(handler->open) {
131
                    rtsp_st->dynamic_protocol_context= handler->open();
132
                }
133
                break;
134
            }
135
            handler= handler->next;
136
        }
137
    } else {
138
        /* We are in a standard case ( from http://www.iana.org/assignments/rtp-parameters) */
139
        /* search into AVRtpPayloadTypes[] */
140
        codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
141
    }
142

    
143
    c = avcodec_find_decoder(codec->codec_id);
144
    if (c && c->name)
145
        c_name = c->name;
146
    else
147
        c_name = (char *)NULL;
148

    
149
    if (c_name) {
150
        get_word_sep(buf, sizeof(buf), "/", &p);
151
        i = atoi(buf);
152
        switch (codec->codec_type) {
153
            case CODEC_TYPE_AUDIO:
154
                av_log(codec, AV_LOG_DEBUG, " audio codec set to : %s\n", c_name);
155
                codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;
156
                codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;
157
                if (i > 0) {
158
                    codec->sample_rate = i;
159
                    get_word_sep(buf, sizeof(buf), "/", &p);
160
                    i = atoi(buf);
161
                    if (i > 0)
162
                        codec->channels = i;
163
                    // TODO: there is a bug here; if it is a mono stream, and less than 22000Hz, faad upconverts to stereo and twice the
164
                    //  frequency.  No problem, but the sample rate is being set here by the sdp line.  Upcoming patch forthcoming. (rdm)
165
                }
166
                av_log(codec, AV_LOG_DEBUG, " audio samplerate set to : %i\n", codec->sample_rate);
167
                av_log(codec, AV_LOG_DEBUG, " audio channels set to : %i\n", codec->channels);
168
                break;
169
            case CODEC_TYPE_VIDEO:
170
                av_log(codec, AV_LOG_DEBUG, " video codec set to : %s\n", c_name);
171
                break;
172
            default:
173
                break;
174
        }
175
        return 0;
176
    }
177

    
178
    return -1;
179
}
180

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

    
186
    len = 0;
187
    v = 1;
188
    for(;;) {
189
        skip_spaces(&p);
190
        if (p == '\0')
191
            break;
192
        c = toupper((unsigned char)*p++);
193
        if (c >= '0' && c <= '9')
194
            c = c - '0';
195
        else if (c >= 'A' && c <= 'F')
196
            c = c - 'A' + 10;
197
        else
198
            break;
199
        v = (v << 4) | c;
200
        if (v & 0x100) {
201
            if (data)
202
                data[len] = v;
203
            len++;
204
            v = 1;
205
        }
206
    }
207
    return len;
208
}
209

    
210
static void sdp_parse_fmtp_config(AVCodecContext *codec, char *attr, char *value)
211
{
212
    switch (codec->codec_id) {
213
        case CODEC_ID_MPEG4:
214
        case CODEC_ID_AAC:
215
            if (!strcmp(attr, "config")) {
216
                /* decode the hexa encoded parameter */
217
                int len = hex_to_data(NULL, value);
218
                codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
219
                if (!codec->extradata)
220
                    return;
221
                codec->extradata_size = len;
222
                hex_to_data(codec->extradata, value);
223
            }
224
            break;
225
        default:
226
            break;
227
    }
228
    return;
229
}
230

    
231
typedef struct {
232
    const char *str;
233
    uint16_t type;
234
    uint32_t offset;
235
} AttrNameMap;
236

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

    
251
/** parse the attribute line from the fmtp a line of an sdp resonse.  This is broken out as a function
252
* because it is used in rtp_h264.c, which is forthcoming.
253
*/
254
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
        get_word_sep(attr, attr_size, "=", p);
260
        if (**p == '=')
261
            (*p)++;
262
        get_word_sep(value, value_size, ";", p);
263
        if (**p == ';')
264
            (*p)++;
265
        return 1;
266
    }
267
    return 0;
268
}
269

    
270
/* parse a SDP line and save stream attributes */
271
static void sdp_parse_fmtp(AVStream *st, const char *p)
272
{
273
    char attr[256];
274
    char value[4096];
275
    int i;
276

    
277
    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
    while(rtsp_next_attr_and_value(&p, attr, sizeof(attr), value, sizeof(value)))
283
    {
284
        /* grab the codec extra_data from the config parameter of the fmtp line */
285
        sdp_parse_fmtp_config(codec, attr, value);
286
        /* Looking for a known attribute */
287
        for (i = 0; attr_names[i].str; ++i) {
288
            if (!strcasecmp(attr, attr_names[i].str)) {
289
                if (attr_names[i].type == ATTR_NAME_TYPE_INT)
290
                    *(int *)((char *)rtp_payload_data + attr_names[i].offset) = atoi(value);
291
                else if (attr_names[i].type == ATTR_NAME_TYPE_STR)
292
                    *(char **)((char *)rtp_payload_data + attr_names[i].offset) = av_strdup(value);
293
            }
294
        }
295
    }
296
}
297

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

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

    
310
    *start = AV_NOPTS_VALUE;
311
    *end = AV_NOPTS_VALUE;
312

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

    
324
typedef struct SDPParseState {
325
    /* SDP only */
326
    struct in_addr default_ip;
327
    int default_ttl;
328
} SDPParseState;
329

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

    
343
#ifdef DEBUG
344
    printf("sdp: %c='%s'\n", letter, buf);
345
#endif
346

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

    
400
        rtsp_st->sdp_ip = s1->default_ip;
401
        rtsp_st->sdp_ttl = s1->default_ttl;
402

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

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

    
408
        /* XXX: handle list of formats */
409
        get_word(buf1, sizeof(buf1), &p); /* format list */
410
        rtsp_st->sdp_payload_type = atoi(buf1);
411

    
412
        if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
413
            /* no corresponding stream */
414
        } else {
415
            st = av_new_stream(s, 0);
416
            if (!st)
417
                return;
418
            st->priv_data = rtsp_st;
419
            rtsp_st->stream_index = st->index;
420
            st->codec->codec_type = codec_type;
421
            if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
422
                /* if standard payload type, we can find the codec right now */
423
                rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
424
            }
425
        }
426
        /* put a default control url */
427
        av_strlcpy(rtsp_st->control_url, s->filename, sizeof(rtsp_st->control_url));
428
        break;
429
    case 'a':
430
        if (av_strstart(p, "control:", &p) && s->nb_streams > 0) {
431
            char proto[32];
432
            /* get the control url */
433
            st = s->streams[s->nb_streams - 1];
434
            rtsp_st = st->priv_data;
435

    
436
            /* XXX: may need to add full url resolution */
437
            url_split(proto, sizeof(proto), NULL, 0, NULL, 0, NULL, NULL, 0, p);
438
            if (proto[0] == '\0') {
439
                /* relative control URL */
440
                av_strlcat(rtsp_st->control_url, "/", sizeof(rtsp_st->control_url));
441
                av_strlcat(rtsp_st->control_url, p,   sizeof(rtsp_st->control_url));
442
            } else {
443
                av_strlcpy(rtsp_st->control_url, p,   sizeof(rtsp_st->control_url));
444
            }
445
        } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
446
            /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
447
            get_word(buf1, sizeof(buf1), &p);
448
            payload_type = atoi(buf1);
449
            st = s->streams[s->nb_streams - 1];
450
            rtsp_st = st->priv_data;
451
            sdp_parse_rtpmap(st->codec, rtsp_st, payload_type, p);
452
        } else if (av_strstart(p, "fmtp:", &p)) {
453
            /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
454
            get_word(buf1, sizeof(buf1), &p);
455
            payload_type = atoi(buf1);
456
            for(i = 0; i < s->nb_streams;i++) {
457
                st = s->streams[i];
458
                rtsp_st = st->priv_data;
459
                if (rtsp_st->sdp_payload_type == payload_type) {
460
                    if(rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->parse_sdp_a_line) {
461
                        if(!rtsp_st->dynamic_handler->parse_sdp_a_line(s, i, rtsp_st->dynamic_protocol_context, buf)) {
462
                            sdp_parse_fmtp(st, p);
463
                        }
464
                    } else {
465
                        sdp_parse_fmtp(st, p);
466
                    }
467
                }
468
            }
469
        } else if(av_strstart(p, "framesize:", &p)) {
470
            // let dynamic protocol handlers have a stab at the line.
471
            get_word(buf1, sizeof(buf1), &p);
472
            payload_type = atoi(buf1);
473
            for(i = 0; i < s->nb_streams;i++) {
474
                st = s->streams[i];
475
                rtsp_st = st->priv_data;
476
                if (rtsp_st->sdp_payload_type == payload_type) {
477
                    if(rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->parse_sdp_a_line) {
478
                        rtsp_st->dynamic_handler->parse_sdp_a_line(s, i, rtsp_st->dynamic_protocol_context, buf);
479
                    }
480
                }
481
            }
482
        } else if(av_strstart(p, "range:", &p)) {
483
            int64_t start, end;
484

    
485
            // this is so that seeking on a streamed file can work.
486
            rtsp_parse_range_npt(p, &start, &end);
487
            s->start_time= start;
488
            s->duration= (end==AV_NOPTS_VALUE)?AV_NOPTS_VALUE:end-start; // AV_NOPTS_VALUE means live broadcast (and can't seek)
489
        } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
490
            if (atoi(p) == 1)
491
                rt->transport = RTSP_TRANSPORT_RDT;
492
        } else if (s->nb_streams > 0) {
493
            if (rt->server_type == RTSP_SERVER_REAL)
494
                ff_real_parse_sdp_a_line(s, s->nb_streams - 1, p);
495

    
496
            rtsp_st = s->streams[s->nb_streams - 1]->priv_data;
497
            if (rtsp_st->dynamic_handler &&
498
                rtsp_st->dynamic_handler->parse_sdp_a_line)
499
                rtsp_st->dynamic_handler->parse_sdp_a_line(s, s->nb_streams - 1,
500
                    rtsp_st->dynamic_protocol_context, buf);
501
        }
502
        break;
503
    }
504
}
505

    
506
static int sdp_parse(AVFormatContext *s, const char *content)
507
{
508
    const char *p;
509
    int letter;
510
    /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
511
     * contain long SDP lines containing complete ASF Headers (several
512
     * kB) or arrays of MDPR (RM stream descriptor) headers plus
513
     * "rulebooks" describing their properties. Therefore, the SDP line
514
     * buffer is large. */
515
    char buf[8192], *q;
516
    SDPParseState sdp_parse_state, *s1 = &sdp_parse_state;
517

    
518
    memset(s1, 0, sizeof(SDPParseState));
519
    p = content;
520
    for(;;) {
521
        skip_spaces(&p);
522
        letter = *p;
523
        if (letter == '\0')
524
            break;
525
        p++;
526
        if (*p != '=')
527
            goto next_line;
528
        p++;
529
        /* get the content */
530
        q = buf;
531
        while (*p != '\n' && *p != '\r' && *p != '\0') {
532
            if ((q - buf) < sizeof(buf) - 1)
533
                *q++ = *p;
534
            p++;
535
        }
536
        *q = '\0';
537
        sdp_parse_line(s, s1, letter, buf);
538
    next_line:
539
        while (*p != '\n' && *p != '\0')
540
            p++;
541
        if (*p == '\n')
542
            p++;
543
    }
544
    return 0;
545
}
546

    
547
static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
548
{
549
    const char *p;
550
    int v;
551

    
552
    p = *pp;
553
    skip_spaces(&p);
554
    v = strtol(p, (char **)&p, 10);
555
    if (*p == '-') {
556
        p++;
557
        *min_ptr = v;
558
        v = strtol(p, (char **)&p, 10);
559
        *max_ptr = v;
560
    } else {
561
        *min_ptr = v;
562
        *max_ptr = v;
563
    }
564
    *pp = p;
565
}
566

    
567
/* XXX: only one transport specification is parsed */
568
static void rtsp_parse_transport(RTSPHeader *reply, const char *p)
569
{
570
    char transport_protocol[16];
571
    char profile[16];
572
    char lower_transport[16];
573
    char parameter[16];
574
    RTSPTransportField *th;
575
    char buf[256];
576

    
577
    reply->nb_transports = 0;
578

    
579
    for(;;) {
580
        skip_spaces(&p);
581
        if (*p == '\0')
582
            break;
583

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

    
586
        get_word_sep(transport_protocol, sizeof(transport_protocol),
587
                     "/", &p);
588
        if (*p == '/')
589
            p++;
590
        if (!strcasecmp (transport_protocol, "rtp")) {
591
            get_word_sep(profile, sizeof(profile), "/;,", &p);
592
            lower_transport[0] = '\0';
593
            /* rtp/avp/<protocol> */
594
            if (*p == '/') {
595
                p++;
596
                get_word_sep(lower_transport, sizeof(lower_transport),
597
                             ";,", &p);
598
            }
599
            th->transport = RTSP_TRANSPORT_RTP;
600
        } else if (!strcasecmp (transport_protocol, "x-pn-tng") ||
601
                   !strcasecmp (transport_protocol, "x-real-rdt")) {
602
            /* x-pn-tng/<protocol> */
603
            get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
604
            profile[0] = '\0';
605
            th->transport = RTSP_TRANSPORT_RDT;
606
        }
607
        if (!strcasecmp(lower_transport, "TCP"))
608
            th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
609
        else
610
            th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
611

    
612
        if (*p == ';')
613
            p++;
614
        /* get each parameter */
615
        while (*p != '\0' && *p != ',') {
616
            get_word_sep(parameter, sizeof(parameter), "=;,", &p);
617
            if (!strcmp(parameter, "port")) {
618
                if (*p == '=') {
619
                    p++;
620
                    rtsp_parse_range(&th->port_min, &th->port_max, &p);
621
                }
622
            } else if (!strcmp(parameter, "client_port")) {
623
                if (*p == '=') {
624
                    p++;
625
                    rtsp_parse_range(&th->client_port_min,
626
                                     &th->client_port_max, &p);
627
                }
628
            } else if (!strcmp(parameter, "server_port")) {
629
                if (*p == '=') {
630
                    p++;
631
                    rtsp_parse_range(&th->server_port_min,
632
                                     &th->server_port_max, &p);
633
                }
634
            } else if (!strcmp(parameter, "interleaved")) {
635
                if (*p == '=') {
636
                    p++;
637
                    rtsp_parse_range(&th->interleaved_min,
638
                                     &th->interleaved_max, &p);
639
                }
640
            } else if (!strcmp(parameter, "multicast")) {
641
                if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
642
                    th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
643
            } else if (!strcmp(parameter, "ttl")) {
644
                if (*p == '=') {
645
                    p++;
646
                    th->ttl = strtol(p, (char **)&p, 10);
647
                }
648
            } else if (!strcmp(parameter, "destination")) {
649
                struct in_addr ipaddr;
650

    
651
                if (*p == '=') {
652
                    p++;
653
                    get_word_sep(buf, sizeof(buf), ";,", &p);
654
                    if (inet_aton(buf, &ipaddr))
655
                        th->destination = ntohl(ipaddr.s_addr);
656
                }
657
            }
658
            while (*p != ';' && *p != '\0' && *p != ',')
659
                p++;
660
            if (*p == ';')
661
                p++;
662
        }
663
        if (*p == ',')
664
            p++;
665

    
666
        reply->nb_transports++;
667
    }
668
}
669

    
670
void rtsp_parse_line(RTSPHeader *reply, const char *buf)
671
{
672
    const char *p;
673

    
674
    /* NOTE: we do case independent match for broken servers */
675
    p = buf;
676
    if (av_stristart(p, "Session:", &p)) {
677
        get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
678
    } else if (av_stristart(p, "Content-Length:", &p)) {
679
        reply->content_length = strtol(p, NULL, 10);
680
    } else if (av_stristart(p, "Transport:", &p)) {
681
        rtsp_parse_transport(reply, p);
682
    } else if (av_stristart(p, "CSeq:", &p)) {
683
        reply->seq = strtol(p, NULL, 10);
684
    } else if (av_stristart(p, "Range:", &p)) {
685
        rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
686
    } else if (av_stristart(p, "RealChallenge1:", &p)) {
687
        skip_spaces(&p);
688
        av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
689
    } else if (av_stristart(p, "Server:", &p)) {
690
        skip_spaces(&p);
691
        av_strlcpy(reply->server, p, sizeof(reply->server));
692
    }
693
}
694

    
695
static int url_readbuf(URLContext *h, unsigned char *buf, int size)
696
{
697
    int ret, len;
698

    
699
    len = 0;
700
    while (len < size) {
701
        ret = url_read(h, buf+len, size-len);
702
        if (ret < 1)
703
            return ret;
704
        len += ret;
705
    }
706
    return len;
707
}
708

    
709
/* skip a RTP/TCP interleaved packet */
710
static void rtsp_skip_packet(AVFormatContext *s)
711
{
712
    RTSPState *rt = s->priv_data;
713
    int ret, len, len1;
714
    uint8_t buf[1024];
715

    
716
    ret = url_readbuf(rt->rtsp_hd, buf, 3);
717
    if (ret != 3)
718
        return;
719
    len = AV_RB16(buf + 1);
720
#ifdef DEBUG
721
    printf("skipping RTP packet len=%d\n", len);
722
#endif
723
    /* skip payload */
724
    while (len > 0) {
725
        len1 = len;
726
        if (len1 > sizeof(buf))
727
            len1 = sizeof(buf);
728
        ret = url_readbuf(rt->rtsp_hd, buf, len1);
729
        if (ret != len1)
730
            return;
731
        len -= len1;
732
    }
733
}
734

    
735
static void rtsp_send_cmd(AVFormatContext *s,
736
                          const char *cmd, RTSPHeader *reply,
737
                          unsigned char **content_ptr)
738
{
739
    RTSPState *rt = s->priv_data;
740
    char buf[4096], buf1[1024], *q;
741
    unsigned char ch;
742
    const char *p;
743
    int content_length, line_count;
744
    unsigned char *content = NULL;
745

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

    
748
    rt->seq++;
749
    av_strlcpy(buf, cmd, sizeof(buf));
750
    snprintf(buf1, sizeof(buf1), "CSeq: %d\r\n", rt->seq);
751
    av_strlcat(buf, buf1, sizeof(buf));
752
    if (rt->session_id[0] != '\0' && !strstr(cmd, "\nIf-Match:")) {
753
        snprintf(buf1, sizeof(buf1), "Session: %s\r\n", rt->session_id);
754
        av_strlcat(buf, buf1, sizeof(buf));
755
    }
756
    av_strlcat(buf, "\r\n", sizeof(buf));
757
#ifdef DEBUG
758
    printf("Sending:\n%s--\n", buf);
759
#endif
760
    url_write(rt->rtsp_hd, buf, strlen(buf));
761

    
762
    /* parse reply (XXX: use buffers) */
763
    line_count = 0;
764
    rt->last_reply[0] = '\0';
765
    for(;;) {
766
        q = buf;
767
        for(;;) {
768
            if (url_readbuf(rt->rtsp_hd, &ch, 1) != 1)
769
                break;
770
            if (ch == '\n')
771
                break;
772
            if (ch == '$') {
773
                /* XXX: only parse it if first char on line ? */
774
                rtsp_skip_packet(s);
775
            } else if (ch != '\r') {
776
                if ((q - buf) < sizeof(buf) - 1)
777
                    *q++ = ch;
778
            }
779
        }
780
        *q = '\0';
781
#ifdef DEBUG
782
        printf("line='%s'\n", buf);
783
#endif
784
        /* test if last line */
785
        if (buf[0] == '\0')
786
            break;
787
        p = buf;
788
        if (line_count == 0) {
789
            /* get reply code */
790
            get_word(buf1, sizeof(buf1), &p);
791
            get_word(buf1, sizeof(buf1), &p);
792
            reply->status_code = atoi(buf1);
793
        } else {
794
            rtsp_parse_line(reply, p);
795
            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
796
            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
797
        }
798
        line_count++;
799
    }
800

    
801
    if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
802
        av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
803

    
804
    content_length = reply->content_length;
805
    if (content_length > 0) {
806
        /* leave some room for a trailing '\0' (useful for simple parsing) */
807
        content = av_malloc(content_length + 1);
808
        (void)url_readbuf(rt->rtsp_hd, content, content_length);
809
        content[content_length] = '\0';
810
    }
811
    if (content_ptr)
812
        *content_ptr = content;
813
    else
814
        av_free(content);
815
}
816

    
817

    
818
/* close and free RTSP streams */
819
static void rtsp_close_streams(RTSPState *rt)
820
{
821
    int i;
822
    RTSPStream *rtsp_st;
823

    
824
    for(i=0;i<rt->nb_rtsp_streams;i++) {
825
        rtsp_st = rt->rtsp_streams[i];
826
        if (rtsp_st) {
827
            if (rtsp_st->tx_ctx) {
828
                if (rt->transport == RTSP_TRANSPORT_RDT)
829
                    ff_rdt_parse_close(rtsp_st->tx_ctx);
830
                else
831
                    rtp_parse_close(rtsp_st->tx_ctx);
832
            }
833
            if (rtsp_st->rtp_handle)
834
                url_close(rtsp_st->rtp_handle);
835
            if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
836
                rtsp_st->dynamic_handler->close(rtsp_st->dynamic_protocol_context);
837
        }
838
    }
839
    av_free(rt->rtsp_streams);
840
}
841

    
842
static int
843
rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
844
{
845
    RTSPState *rt = s->priv_data;
846
    AVStream *st = NULL;
847

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

    
854
    if (rt->transport == RTSP_TRANSPORT_RDT)
855
        rtsp_st->tx_ctx = ff_rdt_parse_open(s, st->index,
856
                                            rtsp_st->dynamic_protocol_context,
857
                                            rtsp_st->dynamic_handler);
858
    else
859
        rtsp_st->tx_ctx = rtp_parse_open(s, st, rtsp_st->rtp_handle,
860
                                         rtsp_st->sdp_payload_type,
861
                                         &rtsp_st->rtp_payload_data);
862

    
863
    if (!rtsp_st->tx_ctx) {
864
         return AVERROR(ENOMEM);
865
    } else if (rt->transport != RTSP_TRANSPORT_RDT) {
866
        if(rtsp_st->dynamic_handler) {
867
            rtp_parse_set_dynamic_protocol(rtsp_st->tx_ctx,
868
                                           rtsp_st->dynamic_protocol_context,
869
                                           rtsp_st->dynamic_handler);
870
        }
871
    }
872

    
873
    return 0;
874
}
875

    
876
/**
877
 * @returns 0 on success, <0 on error, 1 if protocol is unavailable.
878
 */
879
static int
880
make_setup_request (AVFormatContext *s, const char *host, int port,
881
                    int lower_transport, const char *real_challenge)
882
{
883
    RTSPState *rt = s->priv_data;
884
    int j, i, err;
885
    RTSPStream *rtsp_st;
886
    RTSPHeader reply1, *reply = &reply1;
887
    char cmd[2048];
888
    const char *trans_pref;
889

    
890
    if (rt->transport == RTSP_TRANSPORT_RDT)
891
        trans_pref = "x-pn-tng";
892
    else
893
        trans_pref = "RTP/AVP";
894

    
895
    /* for each stream, make the setup request */
896
    /* XXX: we assume the same server is used for the control of each
897
       RTSP stream */
898

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

    
902
        rtsp_st = rt->rtsp_streams[i];
903

    
904
        /* RTP/UDP */
905
        if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
906
            char buf[256];
907

    
908
            /* first try in specified port range */
909
            if (RTSP_RTP_PORT_MIN != 0) {
910
                while(j <= RTSP_RTP_PORT_MAX) {
911
                    snprintf(buf, sizeof(buf), "rtp://%s?localport=%d", host, j);
912
                    j += 2; /* we will use two port by rtp stream (rtp and rtcp) */
913
                    if (url_open(&rtsp_st->rtp_handle, buf, URL_RDWR) == 0) {
914
                        goto rtp_opened;
915
                    }
916
                }
917
            }
918

    
919
/*            then try on any port
920
**            if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
921
**                err = AVERROR_INVALIDDATA;
922
**                goto fail;
923
**            }
924
*/
925

    
926
        rtp_opened:
927
            port = rtp_get_local_port(rtsp_st->rtp_handle);
928
            snprintf(transport, sizeof(transport) - 1,
929
                     "%s/UDP;", trans_pref);
930
            if (rt->server_type != RTSP_SERVER_REAL)
931
                av_strlcat(transport, "unicast;", sizeof(transport));
932
            av_strlcatf(transport, sizeof(transport),
933
                     "client_port=%d", port);
934
            if (rt->transport == RTSP_TRANSPORT_RTP)
935
                av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
936
        }
937

    
938
        /* RTP/TCP */
939
        else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
940
            snprintf(transport, sizeof(transport) - 1,
941
                     "%s/TCP", trans_pref);
942
        }
943

    
944
        else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
945
            snprintf(transport, sizeof(transport) - 1,
946
                     "%s/UDP;multicast", trans_pref);
947
        }
948
        if (rt->server_type == RTSP_SERVER_REAL)
949
            av_strlcat(transport, ";mode=play", sizeof(transport));
950
        snprintf(cmd, sizeof(cmd),
951
                 "SETUP %s RTSP/1.0\r\n"
952
                 "Transport: %s\r\n",
953
                 rtsp_st->control_url, transport);
954
        if (i == 0 && rt->server_type == RTSP_SERVER_REAL) {
955
            char real_res[41], real_csum[9];
956
            ff_rdt_calc_response_and_checksum(real_res, real_csum,
957
                                              real_challenge);
958
            av_strlcatf(cmd, sizeof(cmd),
959
                        "If-Match: %s\r\n"
960
                        "RealChallenge2: %s, sd=%s\r\n",
961
                        rt->session_id, real_res, real_csum);
962
        }
963
        rtsp_send_cmd(s, cmd, reply, NULL);
964
        if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
965
            err = 1;
966
            goto fail;
967
        } else if (reply->status_code != RTSP_STATUS_OK ||
968
                   reply->nb_transports != 1) {
969
            err = AVERROR_INVALIDDATA;
970
            goto fail;
971
        }
972

    
973
        /* XXX: same protocol for all streams is required */
974
        if (i > 0) {
975
            if (reply->transports[0].lower_transport != rt->lower_transport ||
976
                reply->transports[0].transport != rt->transport) {
977
                err = AVERROR_INVALIDDATA;
978
                goto fail;
979
            }
980
        } else {
981
            rt->lower_transport = reply->transports[0].lower_transport;
982
            rt->transport = reply->transports[0].transport;
983
        }
984

    
985
        /* close RTP connection if not choosen */
986
        if (reply->transports[0].lower_transport != RTSP_LOWER_TRANSPORT_UDP &&
987
            (lower_transport == RTSP_LOWER_TRANSPORT_UDP)) {
988
            url_close(rtsp_st->rtp_handle);
989
            rtsp_st->rtp_handle = NULL;
990
        }
991

    
992
        switch(reply->transports[0].lower_transport) {
993
        case RTSP_LOWER_TRANSPORT_TCP:
994
            rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
995
            rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
996
            break;
997

    
998
        case RTSP_LOWER_TRANSPORT_UDP:
999
            {
1000
                char url[1024];
1001

    
1002
                /* XXX: also use address if specified */
1003
                snprintf(url, sizeof(url), "rtp://%s:%d",
1004
                         host, reply->transports[0].server_port_min);
1005
                if (rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1006
                    err = AVERROR_INVALIDDATA;
1007
                    goto fail;
1008
                }
1009
            }
1010
            break;
1011
        case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1012
            {
1013
                char url[1024];
1014
                struct in_addr in;
1015

    
1016
                in.s_addr = htonl(reply->transports[0].destination);
1017
                snprintf(url, sizeof(url), "rtp://%s:%d?ttl=%d",
1018
                         inet_ntoa(in),
1019
                         reply->transports[0].port_min,
1020
                         reply->transports[0].ttl);
1021
                if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1022
                    err = AVERROR_INVALIDDATA;
1023
                    goto fail;
1024
                }
1025
            }
1026
            break;
1027
        }
1028

    
1029
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1030
            goto fail;
1031
    }
1032

    
1033
    if (rt->server_type == RTSP_SERVER_REAL)
1034
        rt->need_subscription = 1;
1035

    
1036
    return 0;
1037

    
1038
fail:
1039
    for (i=0; i<rt->nb_rtsp_streams; i++) {
1040
        if (rt->rtsp_streams[i]->rtp_handle) {
1041
            url_close(rt->rtsp_streams[i]->rtp_handle);
1042
            rt->rtsp_streams[i]->rtp_handle = NULL;
1043
        }
1044
    }
1045
    return err;
1046
}
1047

    
1048
static int rtsp_read_header(AVFormatContext *s,
1049
                            AVFormatParameters *ap)
1050
{
1051
    RTSPState *rt = s->priv_data;
1052
    char host[1024], path[1024], tcpname[1024], cmd[2048], *option_list, *option;
1053
    URLContext *rtsp_hd;
1054
    int port, ret, err;
1055
    RTSPHeader reply1, *reply = &reply1;
1056
    unsigned char *content = NULL;
1057
    int lower_transport_mask = 0;
1058
    char real_challenge[64];
1059

    
1060
    /* extract hostname and port */
1061
    url_split(NULL, 0, NULL, 0,
1062
              host, sizeof(host), &port, path, sizeof(path), s->filename);
1063
    if (port < 0)
1064
        port = RTSP_DEFAULT_PORT;
1065

    
1066
    /* search for options */
1067
    option_list = strchr(path, '?');
1068
    if (option_list) {
1069
        /* remove the options from the path */
1070
        *option_list++ = 0;
1071
        while(option_list) {
1072
            /* move the option pointer */
1073
            option = option_list;
1074
            option_list = strchr(option_list, '&');
1075
            if (option_list)
1076
                *(option_list++) = 0;
1077
            /* handle the options */
1078
            if (strcmp(option, "udp") == 0)
1079
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP);
1080
            else if (strcmp(option, "multicast") == 0)
1081
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
1082
            else if (strcmp(option, "tcp") == 0)
1083
                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_TCP);
1084
        }
1085
    }
1086

    
1087
    if (!lower_transport_mask)
1088
        lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_LAST) - 1;
1089

    
1090
    /* open the tcp connexion */
1091
    snprintf(tcpname, sizeof(tcpname), "tcp://%s:%d", host, port);
1092
    if (url_open(&rtsp_hd, tcpname, URL_RDWR) < 0)
1093
        return AVERROR(EIO);
1094
    rt->rtsp_hd = rtsp_hd;
1095
    rt->seq = 0;
1096

    
1097
    /* request options supported by the server; this also detects server type */
1098
    for (rt->server_type = RTSP_SERVER_RTP;;) {
1099
        snprintf(cmd, sizeof(cmd),
1100
                 "OPTIONS %s RTSP/1.0\r\n", s->filename);
1101
        if (rt->server_type == RTSP_SERVER_REAL)
1102
            av_strlcat(cmd,
1103
                       /**
1104
                        * The following entries are required for proper
1105
                        * streaming from a Realmedia server. They are
1106
                        * interdependent in some way although we currently
1107
                        * don't quite understand how. Values were copied
1108
                        * from mplayer SVN r23589.
1109
                        * @param CompanyID is a 16-byte ID in base64
1110
                        * @param ClientChallenge is a 16-byte ID in hex
1111
                        */
1112
                       "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1113
                       "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1114
                       "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1115
                       "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1116
                       sizeof(cmd));
1117
        rtsp_send_cmd(s, cmd, reply, NULL);
1118
        if (reply->status_code != RTSP_STATUS_OK) {
1119
            err = AVERROR_INVALIDDATA;
1120
            goto fail;
1121
        }
1122

    
1123
        /* detect server type if not standard-compliant RTP */
1124
        if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1125
            rt->server_type = RTSP_SERVER_REAL;
1126
            continue;
1127
        } else if (!strncasecmp(reply->server, "WMServer/", 9)) {
1128
            rt->server_type = RTSP_SERVER_WMS;
1129
        } else if (rt->server_type == RTSP_SERVER_REAL) {
1130
            strcpy(real_challenge, reply->real_challenge);
1131
        }
1132
        break;
1133
    }
1134

    
1135
    /* describe the stream */
1136
    snprintf(cmd, sizeof(cmd),
1137
             "DESCRIBE %s RTSP/1.0\r\n"
1138
             "Accept: application/sdp\r\n",
1139
             s->filename);
1140
    if (rt->server_type == RTSP_SERVER_REAL) {
1141
        /**
1142
         * The Require: attribute is needed for proper streaming from
1143
         * Realmedia servers.
1144
         */
1145
        av_strlcat(cmd,
1146
                   "Require: com.real.retain-entity-for-setup\r\n",
1147
                   sizeof(cmd));
1148
    }
1149
    rtsp_send_cmd(s, cmd, reply, &content);
1150
    if (!content) {
1151
        err = AVERROR_INVALIDDATA;
1152
        goto fail;
1153
    }
1154
    if (reply->status_code != RTSP_STATUS_OK) {
1155
        err = AVERROR_INVALIDDATA;
1156
        goto fail;
1157
    }
1158

    
1159
    /* now we got the SDP description, we parse it */
1160
    ret = sdp_parse(s, (const char *)content);
1161
    av_freep(&content);
1162
    if (ret < 0) {
1163
        err = AVERROR_INVALIDDATA;
1164
        goto fail;
1165
    }
1166

    
1167
    do {
1168
        int lower_transport = ff_log2_tab[lower_transport_mask & ~(lower_transport_mask - 1)];
1169

    
1170
        err = make_setup_request(s, host, port, lower_transport,
1171
                                 rt->server_type == RTSP_SERVER_REAL ?
1172
                                     real_challenge : NULL);
1173
        if (err < 0)
1174
            goto fail;
1175
        lower_transport_mask &= ~(1 << lower_transport);
1176
        if (lower_transport_mask == 0 && err == 1) {
1177
            err = AVERROR(FF_NETERROR(EPROTONOSUPPORT));
1178
            goto fail;
1179
        }
1180
    } while (err);
1181

    
1182
    rt->state = RTSP_STATE_IDLE;
1183
    rt->seek_timestamp = 0; /* default is to start stream at position
1184
                               zero */
1185
    if (ap->initial_pause) {
1186
        /* do not start immediately */
1187
    } else {
1188
        if (rtsp_read_play(s) < 0) {
1189
            err = AVERROR_INVALIDDATA;
1190
            goto fail;
1191
        }
1192
    }
1193
    return 0;
1194
 fail:
1195
    rtsp_close_streams(rt);
1196
    av_freep(&content);
1197
    url_close(rt->rtsp_hd);
1198
    return err;
1199
}
1200

    
1201
static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1202
                           uint8_t *buf, int buf_size)
1203
{
1204
    RTSPState *rt = s->priv_data;
1205
    int id, len, i, ret;
1206
    RTSPStream *rtsp_st;
1207

    
1208
#ifdef DEBUG_RTP_TCP
1209
    printf("tcp_read_packet:\n");
1210
#endif
1211
 redo:
1212
    for(;;) {
1213
        ret = url_readbuf(rt->rtsp_hd, buf, 1);
1214
#ifdef DEBUG_RTP_TCP
1215
        printf("ret=%d c=%02x [%c]\n", ret, buf[0], buf[0]);
1216
#endif
1217
        if (ret != 1)
1218
            return -1;
1219
        if (buf[0] == '$')
1220
            break;
1221
    }
1222
    ret = url_readbuf(rt->rtsp_hd, buf, 3);
1223
    if (ret != 3)
1224
        return -1;
1225
    id = buf[0];
1226
    len = AV_RB16(buf + 1);
1227
#ifdef DEBUG_RTP_TCP
1228
    printf("id=%d len=%d\n", id, len);
1229
#endif
1230
    if (len > buf_size || len < 12)
1231
        goto redo;
1232
    /* get the data */
1233
    ret = url_readbuf(rt->rtsp_hd, buf, len);
1234
    if (ret != len)
1235
        return -1;
1236
    if (rt->transport == RTSP_TRANSPORT_RDT &&
1237
        ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
1238
        return -1;
1239

    
1240
    /* find the matching stream */
1241
    for(i = 0; i < rt->nb_rtsp_streams; i++) {
1242
        rtsp_st = rt->rtsp_streams[i];
1243
        if (id >= rtsp_st->interleaved_min &&
1244
            id <= rtsp_st->interleaved_max)
1245
            goto found;
1246
    }
1247
    goto redo;
1248
 found:
1249
    *prtsp_st = rtsp_st;
1250
    return len;
1251
}
1252

    
1253
static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1254
                           uint8_t *buf, int buf_size)
1255
{
1256
    RTSPState *rt = s->priv_data;
1257
    RTSPStream *rtsp_st;
1258
    fd_set rfds;
1259
    int fd1, fd2, fd_max, n, i, ret;
1260
    struct timeval tv;
1261

    
1262
    for(;;) {
1263
        if (url_interrupt_cb())
1264
            return AVERROR(EINTR);
1265
        FD_ZERO(&rfds);
1266
        fd_max = -1;
1267
        for(i = 0; i < rt->nb_rtsp_streams; i++) {
1268
            rtsp_st = rt->rtsp_streams[i];
1269
            /* currently, we cannot probe RTCP handle because of blocking restrictions */
1270
            rtp_get_file_handles(rtsp_st->rtp_handle, &fd1, &fd2);
1271
            if (fd1 > fd_max)
1272
                fd_max = fd1;
1273
            FD_SET(fd1, &rfds);
1274
        }
1275
        tv.tv_sec = 0;
1276
        tv.tv_usec = 100 * 1000;
1277
        n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
1278
        if (n > 0) {
1279
            for(i = 0; i < rt->nb_rtsp_streams; i++) {
1280
                rtsp_st = rt->rtsp_streams[i];
1281
                rtp_get_file_handles(rtsp_st->rtp_handle, &fd1, &fd2);
1282
                if (FD_ISSET(fd1, &rfds)) {
1283
                    ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
1284
                    if (ret > 0) {
1285
                        *prtsp_st = rtsp_st;
1286
                        return ret;
1287
                    }
1288
                }
1289
            }
1290
        }
1291
    }
1292
}
1293

    
1294
static int rtsp_read_packet(AVFormatContext *s,
1295
                            AVPacket *pkt)
1296
{
1297
    RTSPState *rt = s->priv_data;
1298
    RTSPStream *rtsp_st;
1299
    int ret, len;
1300
    uint8_t buf[10 * RTP_MAX_PACKET_LENGTH];
1301

    
1302
    if (rt->server_type == RTSP_SERVER_REAL) {
1303
        int i;
1304
        RTSPHeader reply1, *reply = &reply1;
1305
        enum AVDiscard cache[MAX_STREAMS];
1306
        char cmd[1024];
1307

    
1308
        for (i = 0; i < s->nb_streams; i++)
1309
            cache[i] = s->streams[i]->discard;
1310

    
1311
        if (!rt->need_subscription) {
1312
            if (memcmp (cache, rt->real_setup_cache,
1313
                        sizeof(enum AVDiscard) * s->nb_streams)) {
1314
                av_strlcatf(cmd, sizeof(cmd),
1315
                            "SET_PARAMETER %s RTSP/1.0\r\n"
1316
                            "Unsubscribe: %s\r\n",
1317
                            s->filename, rt->last_subscription);
1318
                rtsp_send_cmd(s, cmd, reply, NULL);
1319
                if (reply->status_code != RTSP_STATUS_OK)
1320
                    return AVERROR_INVALIDDATA;
1321
                rt->need_subscription = 1;
1322
            }
1323
        }
1324

    
1325
        if (rt->need_subscription) {
1326
            int r, rule_nr, first = 1;
1327

    
1328
            memcpy(rt->real_setup_cache, cache,
1329
                   sizeof(enum AVDiscard) * s->nb_streams);
1330
            rt->last_subscription[0] = 0;
1331

    
1332
            snprintf(cmd, sizeof(cmd),
1333
                     "SET_PARAMETER %s RTSP/1.0\r\n"
1334
                     "Subscribe: ",
1335
                     s->filename);
1336
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1337
                rule_nr = 0;
1338
                for (r = 0; r < s->nb_streams; r++) {
1339
                    if (s->streams[r]->priv_data == rt->rtsp_streams[i]) {
1340
                        if (s->streams[r]->discard != AVDISCARD_ALL) {
1341
                            if (!first)
1342
                                av_strlcat(rt->last_subscription, ",",
1343
                                           sizeof(rt->last_subscription));
1344
                            ff_rdt_subscribe_rule(
1345
                                rt->last_subscription,
1346
                                sizeof(rt->last_subscription), i, rule_nr);
1347
                            first = 0;
1348
                        }
1349
                        rule_nr++;
1350
                    }
1351
                }
1352
            }
1353
            av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
1354
            rtsp_send_cmd(s, cmd, reply, NULL);
1355
            if (reply->status_code != RTSP_STATUS_OK)
1356
                return AVERROR_INVALIDDATA;
1357
            rt->need_subscription = 0;
1358

    
1359
            if (rt->state == RTSP_STATE_PLAYING)
1360
                rtsp_read_play (s);
1361
        }
1362
    }
1363

    
1364
    /* get next frames from the same RTP packet */
1365
    if (rt->cur_tx) {
1366
        if (rt->transport == RTSP_TRANSPORT_RDT)
1367
            ret = ff_rdt_parse_packet(rt->cur_tx, pkt, NULL, 0);
1368
        else
1369
            ret = rtp_parse_packet(rt->cur_tx, pkt, NULL, 0);
1370
        if (ret == 0) {
1371
            rt->cur_tx = NULL;
1372
            return 0;
1373
        } else if (ret == 1) {
1374
            return 0;
1375
        } else {
1376
            rt->cur_tx = NULL;
1377
        }
1378
    }
1379

    
1380
    /* read next RTP packet */
1381
 redo:
1382
    switch(rt->lower_transport) {
1383
    default:
1384
    case RTSP_LOWER_TRANSPORT_TCP:
1385
        len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1386
        break;
1387
    case RTSP_LOWER_TRANSPORT_UDP:
1388
    case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1389
        len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1390
        if (len >=0 && rtsp_st->tx_ctx && rt->transport == RTSP_TRANSPORT_RTP)
1391
            rtp_check_and_send_back_rr(rtsp_st->tx_ctx, len);
1392
        break;
1393
    }
1394
    if (len < 0)
1395
        return len;
1396
    if (rt->transport == RTSP_TRANSPORT_RDT)
1397
        ret = ff_rdt_parse_packet(rtsp_st->tx_ctx, pkt, buf, len);
1398
    else
1399
        ret = rtp_parse_packet(rtsp_st->tx_ctx, pkt, buf, len);
1400
    if (ret < 0)
1401
        goto redo;
1402
    if (ret == 1) {
1403
        /* more packets may follow, so we save the RTP context */
1404
        rt->cur_tx = rtsp_st->tx_ctx;
1405
    }
1406
    return 0;
1407
}
1408

    
1409
static int rtsp_read_play(AVFormatContext *s)
1410
{
1411
    RTSPState *rt = s->priv_data;
1412
    RTSPHeader reply1, *reply = &reply1;
1413
    char cmd[1024];
1414

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

    
1417
    if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1418
        if (rt->state == RTSP_STATE_PAUSED) {
1419
            snprintf(cmd, sizeof(cmd),
1420
                     "PLAY %s RTSP/1.0\r\n",
1421
                     s->filename);
1422
        } else {
1423
            snprintf(cmd, sizeof(cmd),
1424
                     "PLAY %s RTSP/1.0\r\n"
1425
                     "Range: npt=%0.3f-\r\n",
1426
                     s->filename,
1427
                     (double)rt->seek_timestamp / AV_TIME_BASE);
1428
        }
1429
        rtsp_send_cmd(s, cmd, reply, NULL);
1430
        if (reply->status_code != RTSP_STATUS_OK) {
1431
            return -1;
1432
        }
1433
    }
1434
    rt->state = RTSP_STATE_PLAYING;
1435
    return 0;
1436
}
1437

    
1438
/* pause the stream */
1439
static int rtsp_read_pause(AVFormatContext *s)
1440
{
1441
    RTSPState *rt = s->priv_data;
1442
    RTSPHeader reply1, *reply = &reply1;
1443
    char cmd[1024];
1444

    
1445
    rt = s->priv_data;
1446

    
1447
    if (rt->state != RTSP_STATE_PLAYING)
1448
        return 0;
1449
    else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1450
        snprintf(cmd, sizeof(cmd),
1451
                 "PAUSE %s RTSP/1.0\r\n",
1452
                 s->filename);
1453
        rtsp_send_cmd(s, cmd, reply, NULL);
1454
        if (reply->status_code != RTSP_STATUS_OK) {
1455
            return -1;
1456
        }
1457
    }
1458
    rt->state = RTSP_STATE_PAUSED;
1459
    return 0;
1460
}
1461

    
1462
static int rtsp_read_seek(AVFormatContext *s, int stream_index,
1463
                          int64_t timestamp, int flags)
1464
{
1465
    RTSPState *rt = s->priv_data;
1466

    
1467
    rt->seek_timestamp = av_rescale_q(timestamp, s->streams[stream_index]->time_base, AV_TIME_BASE_Q);
1468
    switch(rt->state) {
1469
    default:
1470
    case RTSP_STATE_IDLE:
1471
        break;
1472
    case RTSP_STATE_PLAYING:
1473
        if (rtsp_read_play(s) != 0)
1474
            return -1;
1475
        break;
1476
    case RTSP_STATE_PAUSED:
1477
        rt->state = RTSP_STATE_IDLE;
1478
        break;
1479
    }
1480
    return 0;
1481
}
1482

    
1483
static int rtsp_read_close(AVFormatContext *s)
1484
{
1485
    RTSPState *rt = s->priv_data;
1486
    RTSPHeader reply1, *reply = &reply1;
1487
    char cmd[1024];
1488

    
1489
#if 0
1490
    /* NOTE: it is valid to flush the buffer here */
1491
    if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1492
        url_fclose(&rt->rtsp_gb);
1493
    }
1494
#endif
1495
    snprintf(cmd, sizeof(cmd),
1496
             "TEARDOWN %s RTSP/1.0\r\n",
1497
             s->filename);
1498
    rtsp_send_cmd(s, cmd, reply, NULL);
1499

    
1500
    rtsp_close_streams(rt);
1501
    url_close(rt->rtsp_hd);
1502
    return 0;
1503
}
1504

    
1505
#ifdef CONFIG_RTSP_DEMUXER
1506
AVInputFormat rtsp_demuxer = {
1507
    "rtsp",
1508
    NULL_IF_CONFIG_SMALL("RTSP input format"),
1509
    sizeof(RTSPState),
1510
    rtsp_probe,
1511
    rtsp_read_header,
1512
    rtsp_read_packet,
1513
    rtsp_read_close,
1514
    rtsp_read_seek,
1515
    .flags = AVFMT_NOFILE,
1516
    .read_play = rtsp_read_play,
1517
    .read_pause = rtsp_read_pause,
1518
};
1519
#endif
1520

    
1521
static int sdp_probe(AVProbeData *p1)
1522
{
1523
    const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
1524

    
1525
    /* we look for a line beginning "c=IN IP4" */
1526
    while (p < p_end && *p != '\0') {
1527
        if (p + sizeof("c=IN IP4") - 1 < p_end && av_strstart(p, "c=IN IP4", NULL))
1528
            return AVPROBE_SCORE_MAX / 2;
1529

    
1530
        while(p < p_end - 1 && *p != '\n') p++;
1531
        if (++p >= p_end)
1532
            break;
1533
        if (*p == '\r')
1534
            p++;
1535
    }
1536
    return 0;
1537
}
1538

    
1539
#define SDP_MAX_SIZE 8192
1540

    
1541
static int sdp_read_header(AVFormatContext *s,
1542
                           AVFormatParameters *ap)
1543
{
1544
    RTSPState *rt = s->priv_data;
1545
    RTSPStream *rtsp_st;
1546
    int size, i, err;
1547
    char *content;
1548
    char url[1024];
1549

    
1550
    /* read the whole sdp file */
1551
    /* XXX: better loading */
1552
    content = av_malloc(SDP_MAX_SIZE);
1553
    size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
1554
    if (size <= 0) {
1555
        av_free(content);
1556
        return AVERROR_INVALIDDATA;
1557
    }
1558
    content[size] ='\0';
1559

    
1560
    sdp_parse(s, content);
1561
    av_free(content);
1562

    
1563
    /* open each RTP stream */
1564
    for(i=0;i<rt->nb_rtsp_streams;i++) {
1565
        rtsp_st = rt->rtsp_streams[i];
1566

    
1567
        snprintf(url, sizeof(url), "rtp://%s:%d?localport=%d&ttl=%d",
1568
                 inet_ntoa(rtsp_st->sdp_ip),
1569
                 rtsp_st->sdp_port,
1570
                 rtsp_st->sdp_port,
1571
                 rtsp_st->sdp_ttl);
1572
        if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1573
            err = AVERROR_INVALIDDATA;
1574
            goto fail;
1575
        }
1576
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1577
            goto fail;
1578
    }
1579
    return 0;
1580
 fail:
1581
    rtsp_close_streams(rt);
1582
    return err;
1583
}
1584

    
1585
static int sdp_read_packet(AVFormatContext *s,
1586
                            AVPacket *pkt)
1587
{
1588
    return rtsp_read_packet(s, pkt);
1589
}
1590

    
1591
static int sdp_read_close(AVFormatContext *s)
1592
{
1593
    RTSPState *rt = s->priv_data;
1594
    rtsp_close_streams(rt);
1595
    return 0;
1596
}
1597

    
1598
#ifdef CONFIG_SDP_DEMUXER
1599
AVInputFormat sdp_demuxer = {
1600
    "sdp",
1601
    NULL_IF_CONFIG_SMALL("SDP"),
1602
    sizeof(RTSPState),
1603
    sdp_probe,
1604
    sdp_read_header,
1605
    sdp_read_packet,
1606
    sdp_read_close,
1607
};
1608
#endif
1609

    
1610
#ifdef CONFIG_REDIR_DEMUXER
1611
/* dummy redirector format (used directly in av_open_input_file now) */
1612
static int redir_probe(AVProbeData *pd)
1613
{
1614
    const char *p;
1615
    p = pd->buf;
1616
    while (redir_isspace(*p))
1617
        p++;
1618
    if (av_strstart(p, "http://", NULL) ||
1619
        av_strstart(p, "rtsp://", NULL))
1620
        return AVPROBE_SCORE_MAX;
1621
    return 0;
1622
}
1623

    
1624
static int redir_read_header(AVFormatContext *s, AVFormatParameters *ap)
1625
{
1626
    char buf[4096], *q;
1627
    int c;
1628
    AVFormatContext *ic = NULL;
1629
    ByteIOContext *f = s->pb;
1630

    
1631
    /* parse each URL and try to open it */
1632
    c = url_fgetc(f);
1633
    while (c != URL_EOF) {
1634
        /* skip spaces */
1635
        for(;;) {
1636
            if (!redir_isspace(c))
1637
                break;
1638
            c = url_fgetc(f);
1639
        }
1640
        if (c == URL_EOF)
1641
            break;
1642
        /* record url */
1643
        q = buf;
1644
        for(;;) {
1645
            if (c == URL_EOF || redir_isspace(c))
1646
                break;
1647
            if ((q - buf) < sizeof(buf) - 1)
1648
                *q++ = c;
1649
            c = url_fgetc(f);
1650
        }
1651
        *q = '\0';
1652
        //printf("URL='%s'\n", buf);
1653
        /* try to open the media file */
1654
        if (av_open_input_file(&ic, buf, NULL, 0, NULL) == 0)
1655
            break;
1656
    }
1657
    if (!ic)
1658
        return AVERROR(EIO);
1659

    
1660
    *s = *ic;
1661
    url_fclose(f);
1662

    
1663
    return 0;
1664
}
1665

    
1666
AVInputFormat redir_demuxer = {
1667
    "redir",
1668
    NULL_IF_CONFIG_SMALL("Redirector format"),
1669
    0,
1670
    redir_probe,
1671
    redir_read_header,
1672
    NULL,
1673
    NULL,
1674
};
1675
#endif