Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtsp.c @ 7bac991f

History | View | Annotate | Download (71.6 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
#include "libavutil/base64.h"
23
#include "libavutil/avstring.h"
24
#include "libavutil/intreadwrite.h"
25
#include "libavutil/random_seed.h"
26
#include "avformat.h"
27

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

    
39
#include "rtpdec.h"
40
#include "rdt.h"
41
#include "rtpdec_formats.h"
42

    
43
//#define DEBUG
44
//#define DEBUG_RTP_TCP
45

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

    
50
/* Timeout values for socket select, in ms,
51
 * and read_packet(), in seconds  */
52
#define SELECT_TIMEOUT_MS 100
53
#define READ_PACKET_TIMEOUT_S 10
54
#define MAX_TIMEOUTS READ_PACKET_TIMEOUT_S * 1000 / SELECT_TIMEOUT_MS
55
#define SDP_MAX_SIZE 16384
56

    
57
static void get_word_until_chars(char *buf, int buf_size,
58
                                 const char *sep, const char **pp)
59
{
60
    const char *p;
61
    char *q;
62

    
63
    p = *pp;
64
    p += strspn(p, SPACE_CHARS);
65
    q = buf;
66
    while (!strchr(sep, *p) && *p != '\0') {
67
        if ((q - buf) < buf_size - 1)
68
            *q++ = *p;
69
        p++;
70
    }
71
    if (buf_size > 0)
72
        *q = '\0';
73
    *pp = p;
74
}
75

    
76
static void get_word_sep(char *buf, int buf_size, const char *sep,
77
                         const char **pp)
78
{
79
    if (**pp == '/') (*pp)++;
80
    get_word_until_chars(buf, buf_size, sep, pp);
81
}
82

    
83
static void get_word(char *buf, int buf_size, const char **pp)
84
{
85
    get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);
86
}
87

    
88
/* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
89
static int sdp_parse_rtpmap(AVFormatContext *s,
90
                            AVCodecContext *codec, RTSPStream *rtsp_st,
91
                            int payload_type, const char *p)
92
{
93
    char buf[256];
94
    int i;
95
    AVCodec *c;
96
    const char *c_name;
97

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

    
124
    c = avcodec_find_decoder(codec->codec_id);
125
    if (c && c->name)
126
        c_name = c->name;
127
    else
128
        c_name = "(null)";
129

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

    
162
/* parse the attribute line from the fmtp a line of an sdp response. This
163
 * is broken out as a function because it is used in rtp_h264.c, which is
164
 * forthcoming. */
165
int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
166
                                char *value, int value_size)
167
{
168
    *p += strspn(*p, SPACE_CHARS);
169
    if (**p) {
170
        get_word_sep(attr, attr_size, "=", p);
171
        if (**p == '=')
172
            (*p)++;
173
        get_word_sep(value, value_size, ";", p);
174
        if (**p == ';')
175
            (*p)++;
176
        return 1;
177
    }
178
    return 0;
179
}
180

    
181
/** Parse a string p in the form of Range:npt=xx-xx, and determine the start
182
 *  and end time.
183
 *  Used for seeking in the rtp stream.
184
 */
185
static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
186
{
187
    char buf[256];
188

    
189
    p += strspn(p, SPACE_CHARS);
190
    if (!av_stristart(p, "npt=", &p))
191
        return;
192

    
193
    *start = AV_NOPTS_VALUE;
194
    *end = AV_NOPTS_VALUE;
195

    
196
    get_word_sep(buf, sizeof(buf), "-", &p);
197
    *start = parse_date(buf, 1);
198
    if (*p == '-') {
199
        p++;
200
        get_word_sep(buf, sizeof(buf), "-", &p);
201
        *end = parse_date(buf, 1);
202
    }
203
//    av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
204
//    av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
205
}
206

    
207
static int get_sockaddr(const char *buf, struct sockaddr_storage *sock)
208
{
209
    struct addrinfo hints, *ai = NULL;
210
    memset(&hints, 0, sizeof(hints));
211
    hints.ai_flags = AI_NUMERICHOST;
212
    if (getaddrinfo(buf, NULL, &hints, &ai))
213
        return -1;
214
    memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen));
215
    freeaddrinfo(ai);
216
    return 0;
217
}
218

    
219
typedef struct SDPParseState {
220
    /* SDP only */
221
    struct sockaddr_storage default_ip;
222
    int            default_ttl;
223
    int            skip_media;  ///< set if an unknown m= line occurs
224
} SDPParseState;
225

    
226
static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
227
                           int letter, const char *buf)
228
{
229
    RTSPState *rt = s->priv_data;
230
    char buf1[64], st_type[64];
231
    const char *p;
232
    enum AVMediaType codec_type;
233
    int payload_type, i;
234
    AVStream *st;
235
    RTSPStream *rtsp_st;
236
    struct sockaddr_storage sdp_ip;
237
    int ttl;
238

    
239
    dprintf(s, "sdp: %c='%s'\n", letter, buf);
240

    
241
    p = buf;
242
    if (s1->skip_media && letter != 'm')
243
        return;
244
    switch (letter) {
245
    case 'c':
246
        get_word(buf1, sizeof(buf1), &p);
247
        if (strcmp(buf1, "IN") != 0)
248
            return;
249
        get_word(buf1, sizeof(buf1), &p);
250
        if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6"))
251
            return;
252
        get_word_sep(buf1, sizeof(buf1), "/", &p);
253
        if (get_sockaddr(buf1, &sdp_ip))
254
            return;
255
        ttl = 16;
256
        if (*p == '/') {
257
            p++;
258
            get_word_sep(buf1, sizeof(buf1), "/", &p);
259
            ttl = atoi(buf1);
260
        }
261
        if (s->nb_streams == 0) {
262
            s1->default_ip = sdp_ip;
263
            s1->default_ttl = ttl;
264
        } else {
265
            st = s->streams[s->nb_streams - 1];
266
            rtsp_st = st->priv_data;
267
            rtsp_st->sdp_ip = sdp_ip;
268
            rtsp_st->sdp_ttl = ttl;
269
        }
270
        break;
271
    case 's':
272
        av_metadata_set2(&s->metadata, "title", p, 0);
273
        break;
274
    case 'i':
275
        if (s->nb_streams == 0) {
276
            av_metadata_set2(&s->metadata, "comment", p, 0);
277
            break;
278
        }
279
        break;
280
    case 'm':
281
        /* new stream */
282
        s1->skip_media = 0;
283
        get_word(st_type, sizeof(st_type), &p);
284
        if (!strcmp(st_type, "audio")) {
285
            codec_type = AVMEDIA_TYPE_AUDIO;
286
        } else if (!strcmp(st_type, "video")) {
287
            codec_type = AVMEDIA_TYPE_VIDEO;
288
        } else if (!strcmp(st_type, "application")) {
289
            codec_type = AVMEDIA_TYPE_DATA;
290
        } else {
291
            s1->skip_media = 1;
292
            return;
293
        }
294
        rtsp_st = av_mallocz(sizeof(RTSPStream));
295
        if (!rtsp_st)
296
            return;
297
        rtsp_st->stream_index = -1;
298
        dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
299

    
300
        rtsp_st->sdp_ip = s1->default_ip;
301
        rtsp_st->sdp_ttl = s1->default_ttl;
302

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

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

    
308
        /* XXX: handle list of formats */
309
        get_word(buf1, sizeof(buf1), &p); /* format list */
310
        rtsp_st->sdp_payload_type = atoi(buf1);
311

    
312
        if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
313
            /* no corresponding stream */
314
        } else {
315
            st = av_new_stream(s, 0);
316
            if (!st)
317
                return;
318
            st->priv_data = rtsp_st;
319
            rtsp_st->stream_index = st->index;
320
            st->codec->codec_type = codec_type;
321
            if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
322
                /* if standard payload type, we can find the codec right now */
323
                ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
324
            }
325
        }
326
        /* put a default control url */
327
        av_strlcpy(rtsp_st->control_url, rt->control_uri,
328
                   sizeof(rtsp_st->control_url));
329
        break;
330
    case 'a':
331
        if (av_strstart(p, "control:", &p)) {
332
            if (s->nb_streams == 0) {
333
                if (!strncmp(p, "rtsp://", 7))
334
                    av_strlcpy(rt->control_uri, p,
335
                               sizeof(rt->control_uri));
336
            } else {
337
            char proto[32];
338
            /* get the control url */
339
            st = s->streams[s->nb_streams - 1];
340
            rtsp_st = st->priv_data;
341

    
342
            /* XXX: may need to add full url resolution */
343
            av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
344
                         NULL, NULL, 0, p);
345
            if (proto[0] == '\0') {
346
                /* relative control URL */
347
                if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
348
                av_strlcat(rtsp_st->control_url, "/",
349
                           sizeof(rtsp_st->control_url));
350
                av_strlcat(rtsp_st->control_url, p,
351
                           sizeof(rtsp_st->control_url));
352
            } else
353
                av_strlcpy(rtsp_st->control_url, p,
354
                           sizeof(rtsp_st->control_url));
355
            }
356
        } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
357
            /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
358
            get_word(buf1, sizeof(buf1), &p);
359
            payload_type = atoi(buf1);
360
            st = s->streams[s->nb_streams - 1];
361
            rtsp_st = st->priv_data;
362
            sdp_parse_rtpmap(s, st->codec, rtsp_st, payload_type, p);
363
        } else if (av_strstart(p, "fmtp:", &p) ||
364
                   av_strstart(p, "framesize:", &p)) {
365
            /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
366
            // let dynamic protocol handlers have a stab at the line.
367
            get_word(buf1, sizeof(buf1), &p);
368
            payload_type = atoi(buf1);
369
            for (i = 0; i < s->nb_streams; i++) {
370
                st      = s->streams[i];
371
                rtsp_st = st->priv_data;
372
                if (rtsp_st->sdp_payload_type == payload_type &&
373
                    rtsp_st->dynamic_handler &&
374
                    rtsp_st->dynamic_handler->parse_sdp_a_line)
375
                    rtsp_st->dynamic_handler->parse_sdp_a_line(s, i,
376
                        rtsp_st->dynamic_protocol_context, buf);
377
            }
378
        } else if (av_strstart(p, "range:", &p)) {
379
            int64_t start, end;
380

    
381
            // this is so that seeking on a streamed file can work.
382
            rtsp_parse_range_npt(p, &start, &end);
383
            s->start_time = start;
384
            /* AV_NOPTS_VALUE means live broadcast (and can't seek) */
385
            s->duration   = (end == AV_NOPTS_VALUE) ?
386
                            AV_NOPTS_VALUE : end - start;
387
        } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
388
            if (atoi(p) == 1)
389
                rt->transport = RTSP_TRANSPORT_RDT;
390
        } else {
391
            if (rt->server_type == RTSP_SERVER_WMS)
392
                ff_wms_parse_sdp_a_line(s, p);
393
            if (s->nb_streams > 0) {
394
                if (rt->server_type == RTSP_SERVER_REAL)
395
                    ff_real_parse_sdp_a_line(s, s->nb_streams - 1, p);
396

    
397
                rtsp_st = s->streams[s->nb_streams - 1]->priv_data;
398
                if (rtsp_st->dynamic_handler &&
399
                    rtsp_st->dynamic_handler->parse_sdp_a_line)
400
                    rtsp_st->dynamic_handler->parse_sdp_a_line(s,
401
                        s->nb_streams - 1,
402
                        rtsp_st->dynamic_protocol_context, buf);
403
            }
404
        }
405
        break;
406
    }
407
}
408

    
409
static int sdp_parse(AVFormatContext *s, const char *content)
410
{
411
    const char *p;
412
    int letter;
413
    /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
414
     * contain long SDP lines containing complete ASF Headers (several
415
     * kB) or arrays of MDPR (RM stream descriptor) headers plus
416
     * "rulebooks" describing their properties. Therefore, the SDP line
417
     * buffer is large.
418
     *
419
     * The Vorbis FMTP line can be up to 16KB - see xiph_parse_sdp_line
420
     * in rtpdec_xiph.c. */
421
    char buf[16384], *q;
422
    SDPParseState sdp_parse_state, *s1 = &sdp_parse_state;
423

    
424
    memset(s1, 0, sizeof(SDPParseState));
425
    p = content;
426
    for (;;) {
427
        p += strspn(p, SPACE_CHARS);
428
        letter = *p;
429
        if (letter == '\0')
430
            break;
431
        p++;
432
        if (*p != '=')
433
            goto next_line;
434
        p++;
435
        /* get the content */
436
        q = buf;
437
        while (*p != '\n' && *p != '\r' && *p != '\0') {
438
            if ((q - buf) < sizeof(buf) - 1)
439
                *q++ = *p;
440
            p++;
441
        }
442
        *q = '\0';
443
        sdp_parse_line(s, s1, letter, buf);
444
    next_line:
445
        while (*p != '\n' && *p != '\0')
446
            p++;
447
        if (*p == '\n')
448
            p++;
449
    }
450
    return 0;
451
}
452

    
453
/* close and free RTSP streams */
454
void ff_rtsp_close_streams(AVFormatContext *s)
455
{
456
    RTSPState *rt = s->priv_data;
457
    int i;
458
    RTSPStream *rtsp_st;
459

    
460
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
461
        rtsp_st = rt->rtsp_streams[i];
462
        if (rtsp_st) {
463
            if (rtsp_st->transport_priv) {
464
                if (s->oformat) {
465
                    AVFormatContext *rtpctx = rtsp_st->transport_priv;
466
                    av_write_trailer(rtpctx);
467
                    if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
468
                        uint8_t *ptr;
469
                        url_close_dyn_buf(rtpctx->pb, &ptr);
470
                        av_free(ptr);
471
                    } else {
472
                        url_fclose(rtpctx->pb);
473
                    }
474
                    av_metadata_free(&rtpctx->streams[0]->metadata);
475
                    av_metadata_free(&rtpctx->metadata);
476
                    av_free(rtpctx->streams[0]);
477
                    av_free(rtpctx);
478
                } else if (rt->transport == RTSP_TRANSPORT_RDT)
479
                    ff_rdt_parse_close(rtsp_st->transport_priv);
480
                else
481
                    rtp_parse_close(rtsp_st->transport_priv);
482
            }
483
            if (rtsp_st->rtp_handle)
484
                url_close(rtsp_st->rtp_handle);
485
            if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
486
                rtsp_st->dynamic_handler->close(
487
                    rtsp_st->dynamic_protocol_context);
488
        }
489
    }
490
    av_free(rt->rtsp_streams);
491
    if (rt->asf_ctx) {
492
        av_close_input_stream (rt->asf_ctx);
493
        rt->asf_ctx = NULL;
494
    }
495
}
496

    
497
static void *rtsp_rtp_mux_open(AVFormatContext *s, AVStream *st,
498
                               URLContext *handle)
499
{
500
    RTSPState *rt = s->priv_data;
501
    AVFormatContext *rtpctx;
502
    int ret;
503
    AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
504

    
505
    if (!rtp_format)
506
        return NULL;
507

    
508
    /* Allocate an AVFormatContext for each output stream */
509
    rtpctx = avformat_alloc_context();
510
    if (!rtpctx)
511
        return NULL;
512

    
513
    rtpctx->oformat = rtp_format;
514
    if (!av_new_stream(rtpctx, 0)) {
515
        av_free(rtpctx);
516
        return NULL;
517
    }
518
    /* Copy the max delay setting; the rtp muxer reads this. */
519
    rtpctx->max_delay = s->max_delay;
520
    /* Copy other stream parameters. */
521
    rtpctx->streams[0]->sample_aspect_ratio = st->sample_aspect_ratio;
522

    
523
    /* Set the synchronized start time. */
524
    rtpctx->start_time_realtime = rt->start_time;
525

    
526
    /* Remove the local codec, link to the original codec
527
     * context instead, to give the rtp muxer access to
528
     * codec parameters. */
529
    av_free(rtpctx->streams[0]->codec);
530
    rtpctx->streams[0]->codec = st->codec;
531

    
532
    if (handle) {
533
        url_fdopen(&rtpctx->pb, handle);
534
    } else
535
        url_open_dyn_packet_buf(&rtpctx->pb, RTSP_TCP_MAX_PACKET_SIZE);
536
    ret = av_write_header(rtpctx);
537

    
538
    if (ret) {
539
        if (handle) {
540
            url_fclose(rtpctx->pb);
541
        } else {
542
            uint8_t *ptr;
543
            url_close_dyn_buf(rtpctx->pb, &ptr);
544
            av_free(ptr);
545
        }
546
        av_free(rtpctx->streams[0]);
547
        av_free(rtpctx);
548
        return NULL;
549
    }
550

    
551
    /* Copy the RTP AVStream timebase back to the original AVStream */
552
    st->time_base = rtpctx->streams[0]->time_base;
553
    return rtpctx;
554
}
555

    
556
static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
557
{
558
    RTSPState *rt = s->priv_data;
559
    AVStream *st = NULL;
560

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

    
567
    if (s->oformat) {
568
        rtsp_st->transport_priv = rtsp_rtp_mux_open(s, st, rtsp_st->rtp_handle);
569
        /* Ownership of rtp_handle is passed to the rtp mux context */
570
        rtsp_st->rtp_handle = NULL;
571
    } else if (rt->transport == RTSP_TRANSPORT_RDT)
572
        rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
573
                                            rtsp_st->dynamic_protocol_context,
574
                                            rtsp_st->dynamic_handler);
575
    else
576
        rtsp_st->transport_priv = rtp_parse_open(s, st, rtsp_st->rtp_handle,
577
                                         rtsp_st->sdp_payload_type);
578

    
579
    if (!rtsp_st->transport_priv) {
580
         return AVERROR(ENOMEM);
581
    } else if (rt->transport != RTSP_TRANSPORT_RDT) {
582
        if (rtsp_st->dynamic_handler) {
583
            rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
584
                                           rtsp_st->dynamic_protocol_context,
585
                                           rtsp_st->dynamic_handler);
586
        }
587
    }
588

    
589
    return 0;
590
}
591

    
592
#if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
593
static int rtsp_probe(AVProbeData *p)
594
{
595
    if (av_strstart(p->filename, "rtsp:", NULL))
596
        return AVPROBE_SCORE_MAX;
597
    return 0;
598
}
599

    
600
static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
601
{
602
    const char *p;
603
    int v;
604

    
605
    p = *pp;
606
    p += strspn(p, SPACE_CHARS);
607
    v = strtol(p, (char **)&p, 10);
608
    if (*p == '-') {
609
        p++;
610
        *min_ptr = v;
611
        v = strtol(p, (char **)&p, 10);
612
        *max_ptr = v;
613
    } else {
614
        *min_ptr = v;
615
        *max_ptr = v;
616
    }
617
    *pp = p;
618
}
619

    
620
/* XXX: only one transport specification is parsed */
621
static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
622
{
623
    char transport_protocol[16];
624
    char profile[16];
625
    char lower_transport[16];
626
    char parameter[16];
627
    RTSPTransportField *th;
628
    char buf[256];
629

    
630
    reply->nb_transports = 0;
631

    
632
    for (;;) {
633
        p += strspn(p, SPACE_CHARS);
634
        if (*p == '\0')
635
            break;
636

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

    
639
        get_word_sep(transport_protocol, sizeof(transport_protocol),
640
                     "/", &p);
641
        if (!strcasecmp (transport_protocol, "rtp")) {
642
            get_word_sep(profile, sizeof(profile), "/;,", &p);
643
            lower_transport[0] = '\0';
644
            /* rtp/avp/<protocol> */
645
            if (*p == '/') {
646
                get_word_sep(lower_transport, sizeof(lower_transport),
647
                             ";,", &p);
648
            }
649
            th->transport = RTSP_TRANSPORT_RTP;
650
        } else if (!strcasecmp (transport_protocol, "x-pn-tng") ||
651
                   !strcasecmp (transport_protocol, "x-real-rdt")) {
652
            /* x-pn-tng/<protocol> */
653
            get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
654
            profile[0] = '\0';
655
            th->transport = RTSP_TRANSPORT_RDT;
656
        }
657
        if (!strcasecmp(lower_transport, "TCP"))
658
            th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
659
        else
660
            th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
661

    
662
        if (*p == ';')
663
            p++;
664
        /* get each parameter */
665
        while (*p != '\0' && *p != ',') {
666
            get_word_sep(parameter, sizeof(parameter), "=;,", &p);
667
            if (!strcmp(parameter, "port")) {
668
                if (*p == '=') {
669
                    p++;
670
                    rtsp_parse_range(&th->port_min, &th->port_max, &p);
671
                }
672
            } else if (!strcmp(parameter, "client_port")) {
673
                if (*p == '=') {
674
                    p++;
675
                    rtsp_parse_range(&th->client_port_min,
676
                                     &th->client_port_max, &p);
677
                }
678
            } else if (!strcmp(parameter, "server_port")) {
679
                if (*p == '=') {
680
                    p++;
681
                    rtsp_parse_range(&th->server_port_min,
682
                                     &th->server_port_max, &p);
683
                }
684
            } else if (!strcmp(parameter, "interleaved")) {
685
                if (*p == '=') {
686
                    p++;
687
                    rtsp_parse_range(&th->interleaved_min,
688
                                     &th->interleaved_max, &p);
689
                }
690
            } else if (!strcmp(parameter, "multicast")) {
691
                if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
692
                    th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
693
            } else if (!strcmp(parameter, "ttl")) {
694
                if (*p == '=') {
695
                    p++;
696
                    th->ttl = strtol(p, (char **)&p, 10);
697
                }
698
            } else if (!strcmp(parameter, "destination")) {
699
                if (*p == '=') {
700
                    p++;
701
                    get_word_sep(buf, sizeof(buf), ";,", &p);
702
                    get_sockaddr(buf, &th->destination);
703
                }
704
            } else if (!strcmp(parameter, "source")) {
705
                if (*p == '=') {
706
                    p++;
707
                    get_word_sep(buf, sizeof(buf), ";,", &p);
708
                    av_strlcpy(th->source, buf, sizeof(th->source));
709
                }
710
            }
711

    
712
            while (*p != ';' && *p != '\0' && *p != ',')
713
                p++;
714
            if (*p == ';')
715
                p++;
716
        }
717
        if (*p == ',')
718
            p++;
719

    
720
        reply->nb_transports++;
721
    }
722
}
723

    
724
void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf,
725
                        HTTPAuthState *auth_state)
726
{
727
    const char *p;
728

    
729
    /* NOTE: we do case independent match for broken servers */
730
    p = buf;
731
    if (av_stristart(p, "Session:", &p)) {
732
        int t;
733
        get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
734
        if (av_stristart(p, ";timeout=", &p) &&
735
            (t = strtol(p, NULL, 10)) > 0) {
736
            reply->timeout = t;
737
        }
738
    } else if (av_stristart(p, "Content-Length:", &p)) {
739
        reply->content_length = strtol(p, NULL, 10);
740
    } else if (av_stristart(p, "Transport:", &p)) {
741
        rtsp_parse_transport(reply, p);
742
    } else if (av_stristart(p, "CSeq:", &p)) {
743
        reply->seq = strtol(p, NULL, 10);
744
    } else if (av_stristart(p, "Range:", &p)) {
745
        rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
746
    } else if (av_stristart(p, "RealChallenge1:", &p)) {
747
        p += strspn(p, SPACE_CHARS);
748
        av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
749
    } else if (av_stristart(p, "Server:", &p)) {
750
        p += strspn(p, SPACE_CHARS);
751
        av_strlcpy(reply->server, p, sizeof(reply->server));
752
    } else if (av_stristart(p, "Notice:", &p) ||
753
               av_stristart(p, "X-Notice:", &p)) {
754
        reply->notice = strtol(p, NULL, 10);
755
    } else if (av_stristart(p, "Location:", &p)) {
756
        p += strspn(p, SPACE_CHARS);
757
        av_strlcpy(reply->location, p , sizeof(reply->location));
758
    } else if (av_stristart(p, "WWW-Authenticate:", &p) && auth_state) {
759
        p += strspn(p, SPACE_CHARS);
760
        ff_http_auth_handle_header(auth_state, "WWW-Authenticate", p);
761
    } else if (av_stristart(p, "Authentication-Info:", &p) && auth_state) {
762
        p += strspn(p, SPACE_CHARS);
763
        ff_http_auth_handle_header(auth_state, "Authentication-Info", p);
764
    }
765
}
766

    
767
/* skip a RTP/TCP interleaved packet */
768
void ff_rtsp_skip_packet(AVFormatContext *s)
769
{
770
    RTSPState *rt = s->priv_data;
771
    int ret, len, len1;
772
    uint8_t buf[1024];
773

    
774
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
775
    if (ret != 3)
776
        return;
777
    len = AV_RB16(buf + 1);
778

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

    
781
    /* skip payload */
782
    while (len > 0) {
783
        len1 = len;
784
        if (len1 > sizeof(buf))
785
            len1 = sizeof(buf);
786
        ret = url_read_complete(rt->rtsp_hd, buf, len1);
787
        if (ret != len1)
788
            return;
789
        len -= len1;
790
    }
791
}
792

    
793
int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
794
                       unsigned char **content_ptr,
795
                       int return_on_interleaved_data)
796
{
797
    RTSPState *rt = s->priv_data;
798
    char buf[4096], buf1[1024], *q;
799
    unsigned char ch;
800
    const char *p;
801
    int ret, content_length, line_count = 0;
802
    unsigned char *content = NULL;
803

    
804
    memset(reply, 0, sizeof(*reply));
805

    
806
    /* parse reply (XXX: use buffers) */
807
    rt->last_reply[0] = '\0';
808
    for (;;) {
809
        q = buf;
810
        for (;;) {
811
            ret = url_read_complete(rt->rtsp_hd, &ch, 1);
812
#ifdef DEBUG_RTP_TCP
813
            dprintf(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
814
#endif
815
            if (ret != 1)
816
                return AVERROR_EOF;
817
            if (ch == '\n')
818
                break;
819
            if (ch == '$') {
820
                /* XXX: only parse it if first char on line ? */
821
                if (return_on_interleaved_data) {
822
                    return 1;
823
                } else
824
                    ff_rtsp_skip_packet(s);
825
            } else if (ch != '\r') {
826
                if ((q - buf) < sizeof(buf) - 1)
827
                    *q++ = ch;
828
            }
829
        }
830
        *q = '\0';
831

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

    
834
        /* test if last line */
835
        if (buf[0] == '\0')
836
            break;
837
        p = buf;
838
        if (line_count == 0) {
839
            /* get reply code */
840
            get_word(buf1, sizeof(buf1), &p);
841
            get_word(buf1, sizeof(buf1), &p);
842
            reply->status_code = atoi(buf1);
843
            av_strlcpy(reply->reason, p, sizeof(reply->reason));
844
        } else {
845
            ff_rtsp_parse_line(reply, p, &rt->auth_state);
846
            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
847
            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
848
        }
849
        line_count++;
850
    }
851

    
852
    if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
853
        av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
854

    
855
    content_length = reply->content_length;
856
    if (content_length > 0) {
857
        /* leave some room for a trailing '\0' (useful for simple parsing) */
858
        content = av_malloc(content_length + 1);
859
        (void)url_read_complete(rt->rtsp_hd, content, content_length);
860
        content[content_length] = '\0';
861
    }
862
    if (content_ptr)
863
        *content_ptr = content;
864
    else
865
        av_free(content);
866

    
867
    if (rt->seq != reply->seq) {
868
        av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
869
            rt->seq, reply->seq);
870
    }
871

    
872
    /* EOS */
873
    if (reply->notice == 2101 /* End-of-Stream Reached */      ||
874
        reply->notice == 2104 /* Start-of-Stream Reached */    ||
875
        reply->notice == 2306 /* Continuous Feed Terminated */) {
876
        rt->state = RTSP_STATE_IDLE;
877
    } else if (reply->notice >= 4400 && reply->notice < 5500) {
878
        return AVERROR(EIO); /* data or server error */
879
    } else if (reply->notice == 2401 /* Ticket Expired */ ||
880
             (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
881
        return AVERROR(EPERM);
882

    
883
    return 0;
884
}
885

    
886
int ff_rtsp_send_cmd_with_content_async(AVFormatContext *s,
887
                                        const char *method, const char *url,
888
                                        const char *headers,
889
                                        const unsigned char *send_content,
890
                                        int send_content_length)
891
{
892
    RTSPState *rt = s->priv_data;
893
    char buf[4096], *out_buf;
894
    char base64buf[AV_BASE64_SIZE(sizeof(buf))];
895

    
896
    /* Add in RTSP headers */
897
    out_buf = buf;
898
    rt->seq++;
899
    snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);
900
    if (headers)
901
        av_strlcat(buf, headers, sizeof(buf));
902
    av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);
903
    if (rt->session_id[0] != '\0' && (!headers ||
904
        !strstr(headers, "\nIf-Match:"))) {
905
        av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);
906
    }
907
    if (rt->auth[0]) {
908
        char *str = ff_http_auth_create_response(&rt->auth_state,
909
                                                 rt->auth, url, method);
910
        if (str)
911
            av_strlcat(buf, str, sizeof(buf));
912
        av_free(str);
913
    }
914
    if (send_content_length > 0 && send_content)
915
        av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
916
    av_strlcat(buf, "\r\n", sizeof(buf));
917

    
918
    /* base64 encode rtsp if tunneling */
919
    if (rt->control_transport == RTSP_MODE_TUNNEL) {
920
        av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
921
        out_buf = base64buf;
922
    }
923

    
924
    dprintf(s, "Sending:\n%s--\n", buf);
925

    
926
    url_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
927
    if (send_content_length > 0 && send_content) {
928
        if (rt->control_transport == RTSP_MODE_TUNNEL) {
929
            av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "
930
                                    "with content data not supported\n");
931
            return AVERROR_PATCHWELCOME;
932
        }
933
        url_write(rt->rtsp_hd_out, send_content, send_content_length);
934
    }
935
    rt->last_cmd_time = av_gettime();
936

    
937
    return 0;
938
}
939

    
940
int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
941
                           const char *url, const char *headers)
942
{
943
    return ff_rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
944
}
945

    
946
int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
947
                     const char *headers, RTSPMessageHeader *reply,
948
                     unsigned char **content_ptr)
949
{
950
    return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
951
                                         content_ptr, NULL, 0);
952
}
953

    
954
int ff_rtsp_send_cmd_with_content(AVFormatContext *s,
955
                                  const char *method, const char *url,
956
                                  const char *header,
957
                                  RTSPMessageHeader *reply,
958
                                  unsigned char **content_ptr,
959
                                  const unsigned char *send_content,
960
                                  int send_content_length)
961
{
962
    RTSPState *rt = s->priv_data;
963
    HTTPAuthType cur_auth_type;
964
    int ret;
965

    
966
retry:
967
    cur_auth_type = rt->auth_state.auth_type;
968
    if ((ret = ff_rtsp_send_cmd_with_content_async(s, method, url, header,
969
                                                   send_content,
970
                                                   send_content_length)))
971
        return ret;
972

    
973
    if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0) ) < 0)
974
        return ret;
975

    
976
    if (reply->status_code == 401 && cur_auth_type == HTTP_AUTH_NONE &&
977
        rt->auth_state.auth_type != HTTP_AUTH_NONE)
978
        goto retry;
979

    
980
    if (reply->status_code > 400){
981
        av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",
982
               method,
983
               reply->status_code,
984
               reply->reason);
985
        av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
986
    }
987

    
988
    return 0;
989
}
990

    
991
/**
992
 * @return 0 on success, <0 on error, 1 if protocol is unavailable.
993
 */
994
static int make_setup_request(AVFormatContext *s, const char *host, int port,
995
                              int lower_transport, const char *real_challenge)
996
{
997
    RTSPState *rt = s->priv_data;
998
    int rtx, j, i, err, interleave = 0;
999
    RTSPStream *rtsp_st;
1000
    RTSPMessageHeader reply1, *reply = &reply1;
1001
    char cmd[2048];
1002
    const char *trans_pref;
1003

    
1004
    if (rt->transport == RTSP_TRANSPORT_RDT)
1005
        trans_pref = "x-pn-tng";
1006
    else
1007
        trans_pref = "RTP/AVP";
1008

    
1009
    /* default timeout: 1 minute */
1010
    rt->timeout = 60;
1011

    
1012
    /* for each stream, make the setup request */
1013
    /* XXX: we assume the same server is used for the control of each
1014
     * RTSP stream */
1015

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

    
1019
        /**
1020
         * WMS serves all UDP data over a single connection, the RTX, which
1021
         * isn't necessarily the first in the SDP but has to be the first
1022
         * to be set up, else the second/third SETUP will fail with a 461.
1023
         */
1024
        if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1025
             rt->server_type == RTSP_SERVER_WMS) {
1026
            if (i == 0) {
1027
                /* rtx first */
1028
                for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1029
                    int len = strlen(rt->rtsp_streams[rtx]->control_url);
1030
                    if (len >= 4 &&
1031
                        !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1032
                                "/rtx"))
1033
                        break;
1034
                }
1035
                if (rtx == rt->nb_rtsp_streams)
1036
                    return -1; /* no RTX found */
1037
                rtsp_st = rt->rtsp_streams[rtx];
1038
            } else
1039
                rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1040
        } else
1041
            rtsp_st = rt->rtsp_streams[i];
1042

    
1043
        /* RTP/UDP */
1044
        if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1045
            char buf[256];
1046

    
1047
            if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1048
                port = reply->transports[0].client_port_min;
1049
                goto have_port;
1050
            }
1051

    
1052
            /* first try in specified port range */
1053
            if (RTSP_RTP_PORT_MIN != 0) {
1054
                while (j <= RTSP_RTP_PORT_MAX) {
1055
                    ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1056
                                "?localport=%d", j);
1057
                    /* we will use two ports per rtp stream (rtp and rtcp) */
1058
                    j += 2;
1059
                    if (url_open(&rtsp_st->rtp_handle, buf, URL_RDWR) == 0)
1060
                        goto rtp_opened;
1061
                }
1062
            }
1063

    
1064
#if 0
1065
            /* then try on any port */
1066
            if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
1067
                err = AVERROR_INVALIDDATA;
1068
                goto fail;
1069
            }
1070
#endif
1071

    
1072
        rtp_opened:
1073
            port = rtp_get_local_port(rtsp_st->rtp_handle);
1074
        have_port:
1075
            snprintf(transport, sizeof(transport) - 1,
1076
                     "%s/UDP;", trans_pref);
1077
            if (rt->server_type != RTSP_SERVER_REAL)
1078
                av_strlcat(transport, "unicast;", sizeof(transport));
1079
            av_strlcatf(transport, sizeof(transport),
1080
                     "client_port=%d", port);
1081
            if (rt->transport == RTSP_TRANSPORT_RTP &&
1082
                !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1083
                av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1084
        }
1085

    
1086
        /* RTP/TCP */
1087
        else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1088
            /** For WMS streams, the application streams are only used for
1089
             * UDP. When trying to set it up for TCP streams, the server
1090
             * will return an error. Therefore, we skip those streams. */
1091
            if (rt->server_type == RTSP_SERVER_WMS &&
1092
                s->streams[rtsp_st->stream_index]->codec->codec_type ==
1093
                    AVMEDIA_TYPE_DATA)
1094
                continue;
1095
            snprintf(transport, sizeof(transport) - 1,
1096
                     "%s/TCP;", trans_pref);
1097
            if (rt->server_type == RTSP_SERVER_WMS)
1098
                av_strlcat(transport, "unicast;", sizeof(transport));
1099
            av_strlcatf(transport, sizeof(transport),
1100
                        "interleaved=%d-%d",
1101
                        interleave, interleave + 1);
1102
            interleave += 2;
1103
        }
1104

    
1105
        else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1106
            snprintf(transport, sizeof(transport) - 1,
1107
                     "%s/UDP;multicast", trans_pref);
1108
        }
1109
        if (s->oformat) {
1110
            av_strlcat(transport, ";mode=receive", sizeof(transport));
1111
        } else if (rt->server_type == RTSP_SERVER_REAL ||
1112
                   rt->server_type == RTSP_SERVER_WMS)
1113
            av_strlcat(transport, ";mode=play", sizeof(transport));
1114
        snprintf(cmd, sizeof(cmd),
1115
                 "Transport: %s\r\n",
1116
                 transport);
1117
        if (i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1118
            char real_res[41], real_csum[9];
1119
            ff_rdt_calc_response_and_checksum(real_res, real_csum,
1120
                                              real_challenge);
1121
            av_strlcatf(cmd, sizeof(cmd),
1122
                        "If-Match: %s\r\n"
1123
                        "RealChallenge2: %s, sd=%s\r\n",
1124
                        rt->session_id, real_res, real_csum);
1125
        }
1126
        ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);
1127
        if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1128
            err = 1;
1129
            goto fail;
1130
        } else if (reply->status_code != RTSP_STATUS_OK ||
1131
                   reply->nb_transports != 1) {
1132
            err = AVERROR_INVALIDDATA;
1133
            goto fail;
1134
        }
1135

    
1136
        /* XXX: same protocol for all streams is required */
1137
        if (i > 0) {
1138
            if (reply->transports[0].lower_transport != rt->lower_transport ||
1139
                reply->transports[0].transport != rt->transport) {
1140
                err = AVERROR_INVALIDDATA;
1141
                goto fail;
1142
            }
1143
        } else {
1144
            rt->lower_transport = reply->transports[0].lower_transport;
1145
            rt->transport = reply->transports[0].transport;
1146
        }
1147

    
1148
        /* close RTP connection if not chosen */
1149
        if (reply->transports[0].lower_transport != RTSP_LOWER_TRANSPORT_UDP &&
1150
            (lower_transport == RTSP_LOWER_TRANSPORT_UDP)) {
1151
            url_close(rtsp_st->rtp_handle);
1152
            rtsp_st->rtp_handle = NULL;
1153
        }
1154

    
1155
        switch(reply->transports[0].lower_transport) {
1156
        case RTSP_LOWER_TRANSPORT_TCP:
1157
            rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1158
            rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1159
            break;
1160

    
1161
        case RTSP_LOWER_TRANSPORT_UDP: {
1162
            char url[1024];
1163

    
1164
            /* Use source address if specified */
1165
            if (reply->transports[0].source[0]) {
1166
                ff_url_join(url, sizeof(url), "rtp", NULL,
1167
                            reply->transports[0].source,
1168
                            reply->transports[0].server_port_min, NULL);
1169
            } else {
1170
                ff_url_join(url, sizeof(url), "rtp", NULL, host,
1171
                            reply->transports[0].server_port_min, NULL);
1172
            }
1173
            if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1174
                rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1175
                err = AVERROR_INVALIDDATA;
1176
                goto fail;
1177
            }
1178
            /* Try to initialize the connection state in a
1179
             * potential NAT router by sending dummy packets.
1180
             * RTP/RTCP dummy packets are used for RDT, too.
1181
             */
1182
            if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat)
1183
                rtp_send_punch_packets(rtsp_st->rtp_handle);
1184
            break;
1185
        }
1186
        case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1187
            char url[1024], namebuf[50];
1188
            struct sockaddr_storage addr;
1189
            int port, ttl;
1190

    
1191
            if (reply->transports[0].destination.ss_family) {
1192
                addr      = reply->transports[0].destination;
1193
                port      = reply->transports[0].port_min;
1194
                ttl       = reply->transports[0].ttl;
1195
            } else {
1196
                addr      = rtsp_st->sdp_ip;
1197
                port      = rtsp_st->sdp_port;
1198
                ttl       = rtsp_st->sdp_ttl;
1199
            }
1200
            getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1201
                        namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1202
            ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1203
                        port, "?ttl=%d", ttl);
1204
            if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1205
                err = AVERROR_INVALIDDATA;
1206
                goto fail;
1207
            }
1208
            break;
1209
        }
1210
        }
1211

    
1212
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1213
            goto fail;
1214
    }
1215

    
1216
    if (reply->timeout > 0)
1217
        rt->timeout = reply->timeout;
1218

    
1219
    if (rt->server_type == RTSP_SERVER_REAL)
1220
        rt->need_subscription = 1;
1221

    
1222
    return 0;
1223

    
1224
fail:
1225
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1226
        if (rt->rtsp_streams[i]->rtp_handle) {
1227
            url_close(rt->rtsp_streams[i]->rtp_handle);
1228
            rt->rtsp_streams[i]->rtp_handle = NULL;
1229
        }
1230
    }
1231
    return err;
1232
}
1233

    
1234
static int rtsp_read_play(AVFormatContext *s)
1235
{
1236
    RTSPState *rt = s->priv_data;
1237
    RTSPMessageHeader reply1, *reply = &reply1;
1238
    int i;
1239
    char cmd[1024];
1240

    
1241
    av_log(s, AV_LOG_DEBUG, "hello state=%d\n", rt->state);
1242
    rt->nb_byes = 0;
1243

    
1244
    if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1245
        if (rt->state == RTSP_STATE_PAUSED) {
1246
            cmd[0] = 0;
1247
        } else {
1248
            snprintf(cmd, sizeof(cmd),
1249
                     "Range: npt=%0.3f-\r\n",
1250
                     (double)rt->seek_timestamp / AV_TIME_BASE);
1251
        }
1252
        ff_rtsp_send_cmd(s, "PLAY", rt->control_uri, cmd, reply, NULL);
1253
        if (reply->status_code != RTSP_STATUS_OK) {
1254
            return -1;
1255
        }
1256
        if (reply->range_start != AV_NOPTS_VALUE &&
1257
            rt->transport == RTSP_TRANSPORT_RTP) {
1258
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1259
                RTSPStream *rtsp_st = rt->rtsp_streams[i];
1260
                RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
1261
                AVStream *st = NULL;
1262
                if (!rtpctx)
1263
                    continue;
1264
                if (rtsp_st->stream_index >= 0)
1265
                    st = s->streams[rtsp_st->stream_index];
1266
                rtpctx->last_rtcp_ntp_time  = AV_NOPTS_VALUE;
1267
                rtpctx->first_rtcp_ntp_time = AV_NOPTS_VALUE;
1268
                if (st)
1269
                    rtpctx->range_start_offset = av_rescale_q(reply->range_start,
1270
                                                              AV_TIME_BASE_Q,
1271
                                                              st->time_base);
1272
            }
1273
        }
1274
    }
1275
    rt->state = RTSP_STATE_STREAMING;
1276
    return 0;
1277
}
1278

    
1279
static int rtsp_setup_input_streams(AVFormatContext *s, RTSPMessageHeader *reply)
1280
{
1281
    RTSPState *rt = s->priv_data;
1282
    char cmd[1024];
1283
    unsigned char *content = NULL;
1284
    int ret;
1285

    
1286
    /* describe the stream */
1287
    snprintf(cmd, sizeof(cmd),
1288
             "Accept: application/sdp\r\n");
1289
    if (rt->server_type == RTSP_SERVER_REAL) {
1290
        /**
1291
         * The Require: attribute is needed for proper streaming from
1292
         * Realmedia servers.
1293
         */
1294
        av_strlcat(cmd,
1295
                   "Require: com.real.retain-entity-for-setup\r\n",
1296
                   sizeof(cmd));
1297
    }
1298
    ff_rtsp_send_cmd(s, "DESCRIBE", rt->control_uri, cmd, reply, &content);
1299
    if (!content)
1300
        return AVERROR_INVALIDDATA;
1301
    if (reply->status_code != RTSP_STATUS_OK) {
1302
        av_freep(&content);
1303
        return AVERROR_INVALIDDATA;
1304
    }
1305

    
1306
    /* now we got the SDP description, we parse it */
1307
    ret = sdp_parse(s, (const char *)content);
1308
    av_freep(&content);
1309
    if (ret < 0)
1310
        return AVERROR_INVALIDDATA;
1311

    
1312
    return 0;
1313
}
1314

    
1315
static int rtsp_setup_output_streams(AVFormatContext *s, const char *addr)
1316
{
1317
    RTSPState *rt = s->priv_data;
1318
    RTSPMessageHeader reply1, *reply = &reply1;
1319
    int i;
1320
    char *sdp;
1321
    AVFormatContext sdp_ctx, *ctx_array[1];
1322

    
1323
    rt->start_time = av_gettime();
1324

    
1325
    /* Announce the stream */
1326
    sdp = av_mallocz(SDP_MAX_SIZE);
1327
    if (sdp == NULL)
1328
        return AVERROR(ENOMEM);
1329
    /* We create the SDP based on the RTSP AVFormatContext where we
1330
     * aren't allowed to change the filename field. (We create the SDP
1331
     * based on the RTSP context since the contexts for the RTP streams
1332
     * don't exist yet.) In order to specify a custom URL with the actual
1333
     * peer IP instead of the originally specified hostname, we create
1334
     * a temporary copy of the AVFormatContext, where the custom URL is set.
1335
     *
1336
     * FIXME: Create the SDP without copying the AVFormatContext.
1337
     * This either requires setting up the RTP stream AVFormatContexts
1338
     * already here (complicating things immensely) or getting a more
1339
     * flexible SDP creation interface.
1340
     */
1341
    sdp_ctx = *s;
1342
    ff_url_join(sdp_ctx.filename, sizeof(sdp_ctx.filename),
1343
                "rtsp", NULL, addr, -1, NULL);
1344
    ctx_array[0] = &sdp_ctx;
1345
    if (avf_sdp_create(ctx_array, 1, sdp, SDP_MAX_SIZE)) {
1346
        av_free(sdp);
1347
        return AVERROR_INVALIDDATA;
1348
    }
1349
    av_log(s, AV_LOG_INFO, "SDP:\n%s\n", sdp);
1350
    ff_rtsp_send_cmd_with_content(s, "ANNOUNCE", rt->control_uri,
1351
                                  "Content-Type: application/sdp\r\n",
1352
                                  reply, NULL, sdp, strlen(sdp));
1353
    av_free(sdp);
1354
    if (reply->status_code != RTSP_STATUS_OK)
1355
        return AVERROR_INVALIDDATA;
1356

    
1357
    /* Set up the RTSPStreams for each AVStream */
1358
    for (i = 0; i < s->nb_streams; i++) {
1359
        RTSPStream *rtsp_st;
1360
        AVStream *st = s->streams[i];
1361

    
1362
        rtsp_st = av_mallocz(sizeof(RTSPStream));
1363
        if (!rtsp_st)
1364
            return AVERROR(ENOMEM);
1365
        dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
1366

    
1367
        st->priv_data = rtsp_st;
1368
        rtsp_st->stream_index = i;
1369

    
1370
        av_strlcpy(rtsp_st->control_url, rt->control_uri, sizeof(rtsp_st->control_url));
1371
        /* Note, this must match the relative uri set in the sdp content */
1372
        av_strlcatf(rtsp_st->control_url, sizeof(rtsp_st->control_url),
1373
                    "/streamid=%d", i);
1374
    }
1375

    
1376
    return 0;
1377
}
1378

    
1379
void ff_rtsp_close_connections(AVFormatContext *s)
1380
{
1381
    RTSPState *rt = s->priv_data;
1382
    if (rt->rtsp_hd_out != rt->rtsp_hd) url_close(rt->rtsp_hd_out);
1383
    url_close(rt->rtsp_hd);
1384
    rt->rtsp_hd = rt->rtsp_hd_out = NULL;
1385
}
1386

    
1387
int ff_rtsp_connect(AVFormatContext *s)
1388
{
1389
    RTSPState *rt = s->priv_data;
1390
    char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1391
    char *option_list, *option, *filename;
1392
    int port, err, tcp_fd;
1393
    RTSPMessageHeader reply1 = {0}, *reply = &reply1;
1394
    int lower_transport_mask = 0;
1395
    char real_challenge[64];
1396
    struct sockaddr_storage peer;
1397
    socklen_t peer_len = sizeof(peer);
1398

    
1399
    if (!ff_network_init())
1400
        return AVERROR(EIO);
1401
redirect:
1402
    rt->control_transport = RTSP_MODE_PLAIN;
1403
    /* extract hostname and port */
1404
    av_url_split(NULL, 0, auth, sizeof(auth),
1405
                 host, sizeof(host), &port, path, sizeof(path), s->filename);
1406
    if (*auth) {
1407
        av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1408
    }
1409
    if (port < 0)
1410
        port = RTSP_DEFAULT_PORT;
1411

    
1412
    /* search for options */
1413
    option_list = strrchr(path, '?');
1414
    if (option_list) {
1415
        /* Strip out the RTSP specific options, write out the rest of
1416
         * the options back into the same string. */
1417
        filename = option_list;
1418
        while (option_list) {
1419
            /* move the option pointer */
1420
            option = ++option_list;
1421
            option_list = strchr(option_list, '&');
1422
            if (option_list)
1423
                *option_list = 0;
1424

    
1425
            /* handle the options */
1426
            if (!strcmp(option, "udp")) {
1427
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_UDP);
1428
            } else if (!strcmp(option, "multicast")) {
1429
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
1430
            } else if (!strcmp(option, "tcp")) {
1431
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_TCP);
1432
            } else if(!strcmp(option, "http")) {
1433
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_TCP);
1434
                rt->control_transport = RTSP_MODE_TUNNEL;
1435
            } else {
1436
                /* Write options back into the buffer, using memmove instead
1437
                 * of strcpy since the strings may overlap. */
1438
                int len = strlen(option);
1439
                memmove(++filename, option, len);
1440
                filename += len;
1441
                if (option_list) *filename = '&';
1442
            }
1443
        }
1444
        *filename = 0;
1445
    }
1446

    
1447
    if (!lower_transport_mask)
1448
        lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1449

    
1450
    if (s->oformat) {
1451
        /* Only UDP or TCP - UDP multicast isn't supported. */
1452
        lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
1453
                                (1 << RTSP_LOWER_TRANSPORT_TCP);
1454
        if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
1455
            av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1456
                                    "only UDP and TCP are supported for output.\n");
1457
            err = AVERROR(EINVAL);
1458
            goto fail;
1459
        }
1460
    }
1461

    
1462
    /* Construct the URI used in request; this is similar to s->filename,
1463
     * but with authentication credentials removed and RTSP specific options
1464
     * stripped out. */
1465
    ff_url_join(rt->control_uri, sizeof(rt->control_uri), "rtsp", NULL,
1466
                host, port, "%s", path);
1467

    
1468
    if (rt->control_transport == RTSP_MODE_TUNNEL) {
1469
        /* set up initial handshake for tunneling */
1470
        char httpname[1024];
1471
        char sessioncookie[17];
1472
        char headers[1024];
1473

    
1474
        ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path);
1475
        snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
1476
                 av_get_random_seed(), av_get_random_seed());
1477

    
1478
        /* GET requests */
1479
        if (url_alloc(&rt->rtsp_hd, httpname, URL_RDONLY) < 0) {
1480
            err = AVERROR(EIO);
1481
            goto fail;
1482
        }
1483

    
1484
        /* generate GET headers */
1485
        snprintf(headers, sizeof(headers),
1486
                 "x-sessioncookie: %s\r\n"
1487
                 "Accept: application/x-rtsp-tunnelled\r\n"
1488
                 "Pragma: no-cache\r\n"
1489
                 "Cache-Control: no-cache\r\n",
1490
                 sessioncookie);
1491
        ff_http_set_headers(rt->rtsp_hd, headers);
1492

    
1493
        /* complete the connection */
1494
        if (url_connect(rt->rtsp_hd)) {
1495
            err = AVERROR(EIO);
1496
            goto fail;
1497
        }
1498

    
1499
        /* POST requests */
1500
        if (url_alloc(&rt->rtsp_hd_out, httpname, URL_WRONLY) < 0 ) {
1501
            err = AVERROR(EIO);
1502
            goto fail;
1503
        }
1504

    
1505
        /* generate POST headers */
1506
        snprintf(headers, sizeof(headers),
1507
                 "x-sessioncookie: %s\r\n"
1508
                 "Content-Type: application/x-rtsp-tunnelled\r\n"
1509
                 "Pragma: no-cache\r\n"
1510
                 "Cache-Control: no-cache\r\n"
1511
                 "Content-Length: 32767\r\n"
1512
                 "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1513
                 sessioncookie);
1514
        ff_http_set_headers(rt->rtsp_hd_out, headers);
1515
        ff_http_set_chunked_transfer_encoding(rt->rtsp_hd_out, 0);
1516

    
1517
        /* Initialize the authentication state for the POST session. The HTTP
1518
         * protocol implementation doesn't properly handle multi-pass
1519
         * authentication for POST requests, since it would require one of
1520
         * the following:
1521
         * - implementing Expect: 100-continue, which many HTTP servers
1522
         *   don't support anyway, even less the RTSP servers that do HTTP
1523
         *   tunneling
1524
         * - sending the whole POST data until getting a 401 reply specifying
1525
         *   what authentication method to use, then resending all that data
1526
         * - waiting for potential 401 replies directly after sending the
1527
         *   POST header (waiting for some unspecified time)
1528
         * Therefore, we copy the full auth state, which works for both basic
1529
         * and digest. (For digest, we would have to synchronize the nonce
1530
         * count variable between the two sessions, if we'd do more requests
1531
         * with the original session, though.)
1532
         */
1533
        ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
1534

    
1535
        /* complete the connection */
1536
        if (url_connect(rt->rtsp_hd_out)) {
1537
            err = AVERROR(EIO);
1538
            goto fail;
1539
        }
1540
    } else {
1541
        /* open the tcp connection */
1542
        ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port, NULL);
1543
        if (url_open(&rt->rtsp_hd, tcpname, URL_RDWR) < 0) {
1544
            err = AVERROR(EIO);
1545
            goto fail;
1546
        }
1547
        rt->rtsp_hd_out = rt->rtsp_hd;
1548
    }
1549
    rt->seq = 0;
1550

    
1551
    tcp_fd = url_get_file_handle(rt->rtsp_hd);
1552
    if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1553
        getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1554
                    NULL, 0, NI_NUMERICHOST);
1555
    }
1556

    
1557
    /* request options supported by the server; this also detects server
1558
     * type */
1559
    for (rt->server_type = RTSP_SERVER_RTP;;) {
1560
        cmd[0] = 0;
1561
        if (rt->server_type == RTSP_SERVER_REAL)
1562
            av_strlcat(cmd,
1563
                       /**
1564
                        * The following entries are required for proper
1565
                        * streaming from a Realmedia server. They are
1566
                        * interdependent in some way although we currently
1567
                        * don't quite understand how. Values were copied
1568
                        * from mplayer SVN r23589.
1569
                        * @param CompanyID is a 16-byte ID in base64
1570
                        * @param ClientChallenge is a 16-byte ID in hex
1571
                        */
1572
                       "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1573
                       "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1574
                       "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1575
                       "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1576
                       sizeof(cmd));
1577
        ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
1578
        if (reply->status_code != RTSP_STATUS_OK) {
1579
            err = AVERROR_INVALIDDATA;
1580
            goto fail;
1581
        }
1582

    
1583
        /* detect server type if not standard-compliant RTP */
1584
        if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1585
            rt->server_type = RTSP_SERVER_REAL;
1586
            continue;
1587
        } else if (!strncasecmp(reply->server, "WMServer/", 9)) {
1588
            rt->server_type = RTSP_SERVER_WMS;
1589
        } else if (rt->server_type == RTSP_SERVER_REAL)
1590
            strcpy(real_challenge, reply->real_challenge);
1591
        break;
1592
    }
1593

    
1594
    if (s->iformat)
1595
        err = rtsp_setup_input_streams(s, reply);
1596
    else
1597
        err = rtsp_setup_output_streams(s, host);
1598
    if (err)
1599
        goto fail;
1600

    
1601
    do {
1602
        int lower_transport = ff_log2_tab[lower_transport_mask &
1603
                                  ~(lower_transport_mask - 1)];
1604

    
1605
        err = make_setup_request(s, host, port, lower_transport,
1606
                                 rt->server_type == RTSP_SERVER_REAL ?
1607
                                     real_challenge : NULL);
1608
        if (err < 0)
1609
            goto fail;
1610
        lower_transport_mask &= ~(1 << lower_transport);
1611
        if (lower_transport_mask == 0 && err == 1) {
1612
            err = FF_NETERROR(EPROTONOSUPPORT);
1613
            goto fail;
1614
        }
1615
    } while (err);
1616

    
1617
    rt->state = RTSP_STATE_IDLE;
1618
    rt->seek_timestamp = 0; /* default is to start stream at position zero */
1619
    return 0;
1620
 fail:
1621
    ff_rtsp_close_streams(s);
1622
    ff_rtsp_close_connections(s);
1623
    if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1624
        av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1625
        av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1626
               reply->status_code,
1627
               s->filename);
1628
        goto redirect;
1629
    }
1630
    ff_network_close();
1631
    return err;
1632
}
1633
#endif
1634

    
1635
#if CONFIG_RTSP_DEMUXER
1636
static int rtsp_read_header(AVFormatContext *s,
1637
                            AVFormatParameters *ap)
1638
{
1639
    RTSPState *rt = s->priv_data;
1640
    int ret;
1641

    
1642
    ret = ff_rtsp_connect(s);
1643
    if (ret)
1644
        return ret;
1645

    
1646
    rt->real_setup_cache = av_mallocz(2 * s->nb_streams * sizeof(*rt->real_setup_cache));
1647
    if (!rt->real_setup_cache)
1648
        return AVERROR(ENOMEM);
1649
    rt->real_setup = rt->real_setup_cache + s->nb_streams * sizeof(*rt->real_setup);
1650

    
1651
    if (ap->initial_pause) {
1652
         /* do not start immediately */
1653
    } else {
1654
         if (rtsp_read_play(s) < 0) {
1655
            ff_rtsp_close_streams(s);
1656
            ff_rtsp_close_connections(s);
1657
            return AVERROR_INVALIDDATA;
1658
        }
1659
    }
1660

    
1661
    return 0;
1662
}
1663

    
1664
static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1665
                           uint8_t *buf, int buf_size)
1666
{
1667
    RTSPState *rt = s->priv_data;
1668
    RTSPStream *rtsp_st;
1669
    fd_set rfds;
1670
    int fd, fd_rtcp, fd_max, n, i, ret, tcp_fd, timeout_cnt = 0;
1671
    struct timeval tv;
1672

    
1673
    for (;;) {
1674
        if (url_interrupt_cb())
1675
            return AVERROR(EINTR);
1676
        FD_ZERO(&rfds);
1677
        if (rt->rtsp_hd) {
1678
            tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd);
1679
            FD_SET(tcp_fd, &rfds);
1680
        } else {
1681
            fd_max = 0;
1682
            tcp_fd = -1;
1683
        }
1684
        for (i = 0; i < rt->nb_rtsp_streams; i++) {
1685
            rtsp_st = rt->rtsp_streams[i];
1686
            if (rtsp_st->rtp_handle) {
1687
                fd = url_get_file_handle(rtsp_st->rtp_handle);
1688
                fd_rtcp = rtp_get_rtcp_file_handle(rtsp_st->rtp_handle);
1689
                if (FFMAX(fd, fd_rtcp) > fd_max)
1690
                    fd_max = FFMAX(fd, fd_rtcp);
1691
                FD_SET(fd, &rfds);
1692
                FD_SET(fd_rtcp, &rfds);
1693
            }
1694
        }
1695
        tv.tv_sec = 0;
1696
        tv.tv_usec = SELECT_TIMEOUT_MS * 1000;
1697
        n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
1698
        if (n > 0) {
1699
            timeout_cnt = 0;
1700
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1701
                rtsp_st = rt->rtsp_streams[i];
1702
                if (rtsp_st->rtp_handle) {
1703
                    fd = url_get_file_handle(rtsp_st->rtp_handle);
1704
                    fd_rtcp = rtp_get_rtcp_file_handle(rtsp_st->rtp_handle);
1705
                    if (FD_ISSET(fd_rtcp, &rfds) || FD_ISSET(fd, &rfds)) {
1706
                        ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
1707
                        if (ret > 0) {
1708
                            *prtsp_st = rtsp_st;
1709
                            return ret;
1710
                        }
1711
                    }
1712
                }
1713
            }
1714
#if CONFIG_RTSP_DEMUXER
1715
            if (tcp_fd != -1 && FD_ISSET(tcp_fd, &rfds)) {
1716
                RTSPMessageHeader reply;
1717

    
1718
                ret = ff_rtsp_read_reply(s, &reply, NULL, 0);
1719
                if (ret < 0)
1720
                    return ret;
1721
                /* XXX: parse message */
1722
                if (rt->state != RTSP_STATE_STREAMING)
1723
                    return 0;
1724
            }
1725
#endif
1726
        } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
1727
            return FF_NETERROR(ETIMEDOUT);
1728
        } else if (n < 0 && errno != EINTR)
1729
            return AVERROR(errno);
1730
    }
1731
}
1732

    
1733
static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1734
                           uint8_t *buf, int buf_size)
1735
{
1736
    RTSPState *rt = s->priv_data;
1737
    int id, len, i, ret;
1738
    RTSPStream *rtsp_st;
1739

    
1740
#ifdef DEBUG_RTP_TCP
1741
    dprintf(s, "tcp_read_packet:\n");
1742
#endif
1743
redo:
1744
    for (;;) {
1745
        RTSPMessageHeader reply;
1746

    
1747
        ret = ff_rtsp_read_reply(s, &reply, NULL, 1);
1748
        if (ret < 0)
1749
            return ret;
1750
        if (ret == 1) /* received '$' */
1751
            break;
1752
        /* XXX: parse message */
1753
        if (rt->state != RTSP_STATE_STREAMING)
1754
            return 0;
1755
    }
1756
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
1757
    if (ret != 3)
1758
        return -1;
1759
    id  = buf[0];
1760
    len = AV_RB16(buf + 1);
1761
#ifdef DEBUG_RTP_TCP
1762
    dprintf(s, "id=%d len=%d\n", id, len);
1763
#endif
1764
    if (len > buf_size || len < 12)
1765
        goto redo;
1766
    /* get the data */
1767
    ret = url_read_complete(rt->rtsp_hd, buf, len);
1768
    if (ret != len)
1769
        return -1;
1770
    if (rt->transport == RTSP_TRANSPORT_RDT &&
1771
        ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
1772
        return -1;
1773

    
1774
    /* find the matching stream */
1775
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1776
        rtsp_st = rt->rtsp_streams[i];
1777
        if (id >= rtsp_st->interleaved_min &&
1778
            id <= rtsp_st->interleaved_max)
1779
            goto found;
1780
    }
1781
    goto redo;
1782
found:
1783
    *prtsp_st = rtsp_st;
1784
    return len;
1785
}
1786

    
1787
static int rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
1788
{
1789
    RTSPState *rt = s->priv_data;
1790
    int ret, len;
1791
    uint8_t buf[10 * RTP_MAX_PACKET_LENGTH];
1792
    RTSPStream *rtsp_st;
1793

    
1794
    if (rt->nb_byes == rt->nb_rtsp_streams)
1795
        return AVERROR_EOF;
1796

    
1797
    /* get next frames from the same RTP packet */
1798
    if (rt->cur_transport_priv) {
1799
        if (rt->transport == RTSP_TRANSPORT_RDT) {
1800
            ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1801
        } else
1802
            ret = rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1803
        if (ret == 0) {
1804
            rt->cur_transport_priv = NULL;
1805
            return 0;
1806
        } else if (ret == 1) {
1807
            return 0;
1808
        } else
1809
            rt->cur_transport_priv = NULL;
1810
    }
1811

    
1812
    /* read next RTP packet */
1813
 redo:
1814
    switch(rt->lower_transport) {
1815
    default:
1816
#if CONFIG_RTSP_DEMUXER
1817
    case RTSP_LOWER_TRANSPORT_TCP:
1818
        len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1819
        break;
1820
#endif
1821
    case RTSP_LOWER_TRANSPORT_UDP:
1822
    case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1823
        len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1824
        if (len >=0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
1825
            rtp_check_and_send_back_rr(rtsp_st->transport_priv, len);
1826
        break;
1827
    }
1828
    if (len < 0)
1829
        return len;
1830
    if (len == 0)
1831
        return AVERROR_EOF;
1832
    if (rt->transport == RTSP_TRANSPORT_RDT) {
1833
        ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1834
    } else {
1835
        ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1836
        if (ret < 0) {
1837
            /* Either bad packet, or a RTCP packet. Check if the
1838
             * first_rtcp_ntp_time field was initialized. */
1839
            RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
1840
            if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
1841
                /* first_rtcp_ntp_time has been initialized for this stream,
1842
                 * copy the same value to all other uninitialized streams,
1843
                 * in order to map their timestamp origin to the same ntp time
1844
                 * as this one. */
1845
                int i;
1846
                for (i = 0; i < rt->nb_rtsp_streams; i++) {
1847
                    RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
1848
                    if (rtpctx2 &&
1849
                        rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE)
1850
                        rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
1851
                }
1852
            }
1853
            if (ret == -RTCP_BYE) {
1854
                rt->nb_byes++;
1855

    
1856
                av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
1857
                       rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
1858

    
1859
                if (rt->nb_byes == rt->nb_rtsp_streams)
1860
                    return AVERROR_EOF;
1861
            }
1862
        }
1863
    }
1864
    if (ret < 0)
1865
        goto redo;
1866
    if (ret == 1)
1867
        /* more packets may follow, so we save the RTP context */
1868
        rt->cur_transport_priv = rtsp_st->transport_priv;
1869

    
1870
    return ret;
1871
}
1872

    
1873
static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt)
1874
{
1875
    RTSPState *rt = s->priv_data;
1876
    int ret;
1877
    RTSPMessageHeader reply1, *reply = &reply1;
1878
    char cmd[1024];
1879

    
1880
    if (rt->server_type == RTSP_SERVER_REAL) {
1881
        int i;
1882

    
1883
        for (i = 0; i < s->nb_streams; i++)
1884
            rt->real_setup[i] = s->streams[i]->discard;
1885

    
1886
        if (!rt->need_subscription) {
1887
            if (memcmp (rt->real_setup, rt->real_setup_cache,
1888
                        sizeof(enum AVDiscard) * s->nb_streams)) {
1889
                snprintf(cmd, sizeof(cmd),
1890
                         "Unsubscribe: %s\r\n",
1891
                         rt->last_subscription);
1892
                ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
1893
                                 cmd, reply, NULL);
1894
                if (reply->status_code != RTSP_STATUS_OK)
1895
                    return AVERROR_INVALIDDATA;
1896
                rt->need_subscription = 1;
1897
            }
1898
        }
1899

    
1900
        if (rt->need_subscription) {
1901
            int r, rule_nr, first = 1;
1902

    
1903
            memcpy(rt->real_setup_cache, rt->real_setup,
1904
                   sizeof(enum AVDiscard) * s->nb_streams);
1905
            rt->last_subscription[0] = 0;
1906

    
1907
            snprintf(cmd, sizeof(cmd),
1908
                     "Subscribe: ");
1909
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1910
                rule_nr = 0;
1911
                for (r = 0; r < s->nb_streams; r++) {
1912
                    if (s->streams[r]->priv_data == rt->rtsp_streams[i]) {
1913
                        if (s->streams[r]->discard != AVDISCARD_ALL) {
1914
                            if (!first)
1915
                                av_strlcat(rt->last_subscription, ",",
1916
                                           sizeof(rt->last_subscription));
1917
                            ff_rdt_subscribe_rule(
1918
                                rt->last_subscription,
1919
                                sizeof(rt->last_subscription), i, rule_nr);
1920
                            first = 0;
1921
                        }
1922
                        rule_nr++;
1923
                    }
1924
                }
1925
            }
1926
            av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
1927
            ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
1928
                             cmd, reply, NULL);
1929
            if (reply->status_code != RTSP_STATUS_OK)
1930
                return AVERROR_INVALIDDATA;
1931
            rt->need_subscription = 0;
1932

    
1933
            if (rt->state == RTSP_STATE_STREAMING)
1934
                rtsp_read_play (s);
1935
        }
1936
    }
1937

    
1938
    ret = rtsp_fetch_packet(s, pkt);
1939
    if (ret < 0)
1940
        return ret;
1941

    
1942
    /* send dummy request to keep TCP connection alive */
1943
    if ((av_gettime() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2) {
1944
        if (rt->server_type == RTSP_SERVER_WMS) {
1945
            ff_rtsp_send_cmd_async(s, "GET_PARAMETER", rt->control_uri, NULL);
1946
        } else {
1947
            ff_rtsp_send_cmd_async(s, "OPTIONS", "*", NULL);
1948
        }
1949
    }
1950

    
1951
    return 0;
1952
}
1953

    
1954
/* pause the stream */
1955
static int rtsp_read_pause(AVFormatContext *s)
1956
{
1957
    RTSPState *rt = s->priv_data;
1958
    RTSPMessageHeader reply1, *reply = &reply1;
1959

    
1960
    if (rt->state != RTSP_STATE_STREAMING)
1961
        return 0;
1962
    else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1963
        ff_rtsp_send_cmd(s, "PAUSE", rt->control_uri, NULL, reply, NULL);
1964
        if (reply->status_code != RTSP_STATUS_OK) {
1965
            return -1;
1966
        }
1967
    }
1968
    rt->state = RTSP_STATE_PAUSED;
1969
    return 0;
1970
}
1971

    
1972
static int rtsp_read_seek(AVFormatContext *s, int stream_index,
1973
                          int64_t timestamp, int flags)
1974
{
1975
    RTSPState *rt = s->priv_data;
1976

    
1977
    rt->seek_timestamp = av_rescale_q(timestamp,
1978
                                      s->streams[stream_index]->time_base,
1979
                                      AV_TIME_BASE_Q);
1980
    switch(rt->state) {
1981
    default:
1982
    case RTSP_STATE_IDLE:
1983
        break;
1984
    case RTSP_STATE_STREAMING:
1985
        if (rtsp_read_pause(s) != 0)
1986
            return -1;
1987
        rt->state = RTSP_STATE_SEEKING;
1988
        if (rtsp_read_play(s) != 0)
1989
            return -1;
1990
        break;
1991
    case RTSP_STATE_PAUSED:
1992
        rt->state = RTSP_STATE_IDLE;
1993
        break;
1994
    }
1995
    return 0;
1996
}
1997

    
1998
static int rtsp_read_close(AVFormatContext *s)
1999
{
2000
    RTSPState *rt = s->priv_data;
2001

    
2002
#if 0
2003
    /* NOTE: it is valid to flush the buffer here */
2004
    if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
2005
        url_fclose(&rt->rtsp_gb);
2006
    }
2007
#endif
2008
    ff_rtsp_send_cmd_async(s, "TEARDOWN", rt->control_uri, NULL);
2009

    
2010
    ff_rtsp_close_streams(s);
2011
    ff_rtsp_close_connections(s);
2012
    ff_network_close();
2013
    rt->real_setup = NULL;
2014
    av_freep(&rt->real_setup_cache);
2015
    return 0;
2016
}
2017

    
2018
AVInputFormat rtsp_demuxer = {
2019
    "rtsp",
2020
    NULL_IF_CONFIG_SMALL("RTSP input format"),
2021
    sizeof(RTSPState),
2022
    rtsp_probe,
2023
    rtsp_read_header,
2024
    rtsp_read_packet,
2025
    rtsp_read_close,
2026
    rtsp_read_seek,
2027
    .flags = AVFMT_NOFILE,
2028
    .read_play = rtsp_read_play,
2029
    .read_pause = rtsp_read_pause,
2030
};
2031
#endif
2032

    
2033
static int sdp_probe(AVProbeData *p1)
2034
{
2035
    const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
2036

    
2037
    /* we look for a line beginning "c=IN IP" */
2038
    while (p < p_end && *p != '\0') {
2039
        if (p + sizeof("c=IN IP") - 1 < p_end &&
2040
            av_strstart(p, "c=IN IP", NULL))
2041
            return AVPROBE_SCORE_MAX / 2;
2042

    
2043
        while (p < p_end - 1 && *p != '\n') p++;
2044
        if (++p >= p_end)
2045
            break;
2046
        if (*p == '\r')
2047
            p++;
2048
    }
2049
    return 0;
2050
}
2051

    
2052
static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap)
2053
{
2054
    RTSPState *rt = s->priv_data;
2055
    RTSPStream *rtsp_st;
2056
    int size, i, err;
2057
    char *content;
2058
    char url[1024];
2059

    
2060
    if (!ff_network_init())
2061
        return AVERROR(EIO);
2062

    
2063
    /* read the whole sdp file */
2064
    /* XXX: better loading */
2065
    content = av_malloc(SDP_MAX_SIZE);
2066
    size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
2067
    if (size <= 0) {
2068
        av_free(content);
2069
        return AVERROR_INVALIDDATA;
2070
    }
2071
    content[size] ='\0';
2072

    
2073
    sdp_parse(s, content);
2074
    av_free(content);
2075

    
2076
    /* open each RTP stream */
2077
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
2078
        char namebuf[50];
2079
        rtsp_st = rt->rtsp_streams[i];
2080

    
2081
        getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip),
2082
                    namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
2083
        ff_url_join(url, sizeof(url), "rtp", NULL,
2084
                    namebuf, rtsp_st->sdp_port,
2085
                    "?localport=%d&ttl=%d", rtsp_st->sdp_port,
2086
                    rtsp_st->sdp_ttl);
2087
        if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
2088
            err = AVERROR_INVALIDDATA;
2089
            goto fail;
2090
        }
2091
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
2092
            goto fail;
2093
    }
2094
    return 0;
2095
fail:
2096
    ff_rtsp_close_streams(s);
2097
    ff_network_close();
2098
    return err;
2099
}
2100

    
2101
static int sdp_read_close(AVFormatContext *s)
2102
{
2103
    ff_rtsp_close_streams(s);
2104
    ff_network_close();
2105
    return 0;
2106
}
2107

    
2108
AVInputFormat sdp_demuxer = {
2109
    "sdp",
2110
    NULL_IF_CONFIG_SMALL("SDP"),
2111
    sizeof(RTSPState),
2112
    sdp_probe,
2113
    sdp_read_header,
2114
    rtsp_fetch_packet,
2115
    sdp_read_close,
2116
};