Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtsp.c @ a1ba71aa

History | View | Annotate | Download (70.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
#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
            }
705
            while (*p != ';' && *p != '\0' && *p != ',')
706
                p++;
707
            if (*p == ';')
708
                p++;
709
        }
710
        if (*p == ',')
711
            p++;
712

    
713
        reply->nb_transports++;
714
    }
715
}
716

    
717
void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf,
718
                        HTTPAuthState *auth_state)
719
{
720
    const char *p;
721

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

    
760
/* skip a RTP/TCP interleaved packet */
761
void ff_rtsp_skip_packet(AVFormatContext *s)
762
{
763
    RTSPState *rt = s->priv_data;
764
    int ret, len, len1;
765
    uint8_t buf[1024];
766

    
767
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
768
    if (ret != 3)
769
        return;
770
    len = AV_RB16(buf + 1);
771

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

    
774
    /* skip payload */
775
    while (len > 0) {
776
        len1 = len;
777
        if (len1 > sizeof(buf))
778
            len1 = sizeof(buf);
779
        ret = url_read_complete(rt->rtsp_hd, buf, len1);
780
        if (ret != len1)
781
            return;
782
        len -= len1;
783
    }
784
}
785

    
786
int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
787
                       unsigned char **content_ptr,
788
                       int return_on_interleaved_data)
789
{
790
    RTSPState *rt = s->priv_data;
791
    char buf[4096], buf1[1024], *q;
792
    unsigned char ch;
793
    const char *p;
794
    int ret, content_length, line_count = 0;
795
    unsigned char *content = NULL;
796

    
797
    memset(reply, 0, sizeof(*reply));
798

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

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

    
827
        /* test if last line */
828
        if (buf[0] == '\0')
829
            break;
830
        p = buf;
831
        if (line_count == 0) {
832
            /* get reply code */
833
            get_word(buf1, sizeof(buf1), &p);
834
            get_word(buf1, sizeof(buf1), &p);
835
            reply->status_code = atoi(buf1);
836
            av_strlcpy(reply->reason, p, sizeof(reply->reason));
837
        } else {
838
            ff_rtsp_parse_line(reply, p, &rt->auth_state);
839
            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
840
            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
841
        }
842
        line_count++;
843
    }
844

    
845
    if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
846
        av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
847

    
848
    content_length = reply->content_length;
849
    if (content_length > 0) {
850
        /* leave some room for a trailing '\0' (useful for simple parsing) */
851
        content = av_malloc(content_length + 1);
852
        (void)url_read_complete(rt->rtsp_hd, content, content_length);
853
        content[content_length] = '\0';
854
    }
855
    if (content_ptr)
856
        *content_ptr = content;
857
    else
858
        av_free(content);
859

    
860
    if (rt->seq != reply->seq) {
861
        av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
862
            rt->seq, reply->seq);
863
    }
864

    
865
    /* EOS */
866
    if (reply->notice == 2101 /* End-of-Stream Reached */      ||
867
        reply->notice == 2104 /* Start-of-Stream Reached */    ||
868
        reply->notice == 2306 /* Continuous Feed Terminated */) {
869
        rt->state = RTSP_STATE_IDLE;
870
    } else if (reply->notice >= 4400 && reply->notice < 5500) {
871
        return AVERROR(EIO); /* data or server error */
872
    } else if (reply->notice == 2401 /* Ticket Expired */ ||
873
             (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
874
        return AVERROR(EPERM);
875

    
876
    return 0;
877
}
878

    
879
int ff_rtsp_send_cmd_with_content_async(AVFormatContext *s,
880
                                        const char *method, const char *url,
881
                                        const char *headers,
882
                                        const unsigned char *send_content,
883
                                        int send_content_length)
884
{
885
    RTSPState *rt = s->priv_data;
886
    char buf[4096], *out_buf;
887
    char base64buf[AV_BASE64_SIZE(sizeof(buf))];
888

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

    
911
    /* base64 encode rtsp if tunneling */
912
    if (rt->control_transport == RTSP_MODE_TUNNEL) {
913
        av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
914
        out_buf = base64buf;
915
    }
916

    
917
    dprintf(s, "Sending:\n%s--\n", buf);
918

    
919
    url_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
920
    if (send_content_length > 0 && send_content) {
921
        if (rt->control_transport == RTSP_MODE_TUNNEL) {
922
            av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "
923
                                    "with content data not supported\n");
924
            return AVERROR_PATCHWELCOME;
925
        }
926
        url_write(rt->rtsp_hd_out, send_content, send_content_length);
927
    }
928
    rt->last_cmd_time = av_gettime();
929

    
930
    return 0;
931
}
932

    
933
int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
934
                           const char *url, const char *headers)
935
{
936
    return ff_rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
937
}
938

    
939
int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
940
                     const char *headers, RTSPMessageHeader *reply,
941
                     unsigned char **content_ptr)
942
{
943
    return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
944
                                         content_ptr, NULL, 0);
945
}
946

    
947
int ff_rtsp_send_cmd_with_content(AVFormatContext *s,
948
                                  const char *method, const char *url,
949
                                  const char *header,
950
                                  RTSPMessageHeader *reply,
951
                                  unsigned char **content_ptr,
952
                                  const unsigned char *send_content,
953
                                  int send_content_length)
954
{
955
    RTSPState *rt = s->priv_data;
956
    HTTPAuthType cur_auth_type;
957
    int ret;
958

    
959
retry:
960
    cur_auth_type = rt->auth_state.auth_type;
961
    if ((ret = ff_rtsp_send_cmd_with_content_async(s, method, url, header,
962
                                                   send_content,
963
                                                   send_content_length)))
964
        return ret;
965

    
966
    if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0) ) < 0)
967
        return ret;
968

    
969
    if (reply->status_code == 401 && cur_auth_type == HTTP_AUTH_NONE &&
970
        rt->auth_state.auth_type != HTTP_AUTH_NONE)
971
        goto retry;
972

    
973
    if (reply->status_code > 400){
974
        av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",
975
               method,
976
               reply->status_code,
977
               reply->reason);
978
        av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
979
    }
980

    
981
    return 0;
982
}
983

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

    
997
    if (rt->transport == RTSP_TRANSPORT_RDT)
998
        trans_pref = "x-pn-tng";
999
    else
1000
        trans_pref = "RTP/AVP";
1001

    
1002
    /* default timeout: 1 minute */
1003
    rt->timeout = 60;
1004

    
1005
    /* for each stream, make the setup request */
1006
    /* XXX: we assume the same server is used for the control of each
1007
     * RTSP stream */
1008

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

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

    
1036
        /* RTP/UDP */
1037
        if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1038
            char buf[256];
1039

    
1040
            if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1041
                port = reply->transports[0].client_port_min;
1042
                goto have_port;
1043
            }
1044

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

    
1057
#if 0
1058
            /* then try on any port */
1059
            if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
1060
                err = AVERROR_INVALIDDATA;
1061
                goto fail;
1062
            }
1063
#endif
1064

    
1065
        rtp_opened:
1066
            port = rtp_get_local_port(rtsp_st->rtp_handle);
1067
        have_port:
1068
            snprintf(transport, sizeof(transport) - 1,
1069
                     "%s/UDP;", trans_pref);
1070
            if (rt->server_type != RTSP_SERVER_REAL)
1071
                av_strlcat(transport, "unicast;", sizeof(transport));
1072
            av_strlcatf(transport, sizeof(transport),
1073
                     "client_port=%d", port);
1074
            if (rt->transport == RTSP_TRANSPORT_RTP &&
1075
                !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1076
                av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1077
        }
1078

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

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

    
1129
        /* XXX: same protocol for all streams is required */
1130
        if (i > 0) {
1131
            if (reply->transports[0].lower_transport != rt->lower_transport ||
1132
                reply->transports[0].transport != rt->transport) {
1133
                err = AVERROR_INVALIDDATA;
1134
                goto fail;
1135
            }
1136
        } else {
1137
            rt->lower_transport = reply->transports[0].lower_transport;
1138
            rt->transport = reply->transports[0].transport;
1139
        }
1140

    
1141
        /* close RTP connection if not chosen */
1142
        if (reply->transports[0].lower_transport != RTSP_LOWER_TRANSPORT_UDP &&
1143
            (lower_transport == RTSP_LOWER_TRANSPORT_UDP)) {
1144
            url_close(rtsp_st->rtp_handle);
1145
            rtsp_st->rtp_handle = NULL;
1146
        }
1147

    
1148
        switch(reply->transports[0].lower_transport) {
1149
        case RTSP_LOWER_TRANSPORT_TCP:
1150
            rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1151
            rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1152
            break;
1153

    
1154
        case RTSP_LOWER_TRANSPORT_UDP: {
1155
            char url[1024];
1156

    
1157
            /* XXX: also use address if specified */
1158
            ff_url_join(url, sizeof(url), "rtp", NULL, host,
1159
                        reply->transports[0].server_port_min, NULL);
1160
            if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1161
                rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1162
                err = AVERROR_INVALIDDATA;
1163
                goto fail;
1164
            }
1165
            /* Try to initialize the connection state in a
1166
             * potential NAT router by sending dummy packets.
1167
             * RTP/RTCP dummy packets are used for RDT, too.
1168
             */
1169
            if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat)
1170
                rtp_send_punch_packets(rtsp_st->rtp_handle);
1171
            break;
1172
        }
1173
        case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1174
            char url[1024], namebuf[50];
1175
            struct sockaddr_storage addr;
1176
            int port, ttl;
1177

    
1178
            if (reply->transports[0].destination.ss_family) {
1179
                addr      = reply->transports[0].destination;
1180
                port      = reply->transports[0].port_min;
1181
                ttl       = reply->transports[0].ttl;
1182
            } else {
1183
                addr      = rtsp_st->sdp_ip;
1184
                port      = rtsp_st->sdp_port;
1185
                ttl       = rtsp_st->sdp_ttl;
1186
            }
1187
            getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1188
                        namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1189
            ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1190
                        port, "?ttl=%d", ttl);
1191
            if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1192
                err = AVERROR_INVALIDDATA;
1193
                goto fail;
1194
            }
1195
            break;
1196
        }
1197
        }
1198

    
1199
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1200
            goto fail;
1201
    }
1202

    
1203
    if (reply->timeout > 0)
1204
        rt->timeout = reply->timeout;
1205

    
1206
    if (rt->server_type == RTSP_SERVER_REAL)
1207
        rt->need_subscription = 1;
1208

    
1209
    return 0;
1210

    
1211
fail:
1212
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1213
        if (rt->rtsp_streams[i]->rtp_handle) {
1214
            url_close(rt->rtsp_streams[i]->rtp_handle);
1215
            rt->rtsp_streams[i]->rtp_handle = NULL;
1216
        }
1217
    }
1218
    return err;
1219
}
1220

    
1221
static int rtsp_read_play(AVFormatContext *s)
1222
{
1223
    RTSPState *rt = s->priv_data;
1224
    RTSPMessageHeader reply1, *reply = &reply1;
1225
    int i;
1226
    char cmd[1024];
1227

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

    
1230
    if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1231
        if (rt->state == RTSP_STATE_PAUSED) {
1232
            cmd[0] = 0;
1233
        } else {
1234
            snprintf(cmd, sizeof(cmd),
1235
                     "Range: npt=%0.3f-\r\n",
1236
                     (double)rt->seek_timestamp / AV_TIME_BASE);
1237
        }
1238
        ff_rtsp_send_cmd(s, "PLAY", rt->control_uri, cmd, reply, NULL);
1239
        if (reply->status_code != RTSP_STATUS_OK) {
1240
            return -1;
1241
        }
1242
        if (reply->range_start != AV_NOPTS_VALUE &&
1243
            rt->transport == RTSP_TRANSPORT_RTP) {
1244
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1245
                RTSPStream *rtsp_st = rt->rtsp_streams[i];
1246
                RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
1247
                AVStream *st = NULL;
1248
                if (!rtpctx)
1249
                    continue;
1250
                if (rtsp_st->stream_index >= 0)
1251
                    st = s->streams[rtsp_st->stream_index];
1252
                rtpctx->last_rtcp_ntp_time  = AV_NOPTS_VALUE;
1253
                rtpctx->first_rtcp_ntp_time = AV_NOPTS_VALUE;
1254
                if (st)
1255
                    rtpctx->range_start_offset = av_rescale_q(reply->range_start,
1256
                                                              AV_TIME_BASE_Q,
1257
                                                              st->time_base);
1258
            }
1259
        }
1260
    }
1261
    rt->state = RTSP_STATE_STREAMING;
1262
    return 0;
1263
}
1264

    
1265
static int rtsp_setup_input_streams(AVFormatContext *s, RTSPMessageHeader *reply)
1266
{
1267
    RTSPState *rt = s->priv_data;
1268
    char cmd[1024];
1269
    unsigned char *content = NULL;
1270
    int ret;
1271

    
1272
    /* describe the stream */
1273
    snprintf(cmd, sizeof(cmd),
1274
             "Accept: application/sdp\r\n");
1275
    if (rt->server_type == RTSP_SERVER_REAL) {
1276
        /**
1277
         * The Require: attribute is needed for proper streaming from
1278
         * Realmedia servers.
1279
         */
1280
        av_strlcat(cmd,
1281
                   "Require: com.real.retain-entity-for-setup\r\n",
1282
                   sizeof(cmd));
1283
    }
1284
    ff_rtsp_send_cmd(s, "DESCRIBE", rt->control_uri, cmd, reply, &content);
1285
    if (!content)
1286
        return AVERROR_INVALIDDATA;
1287
    if (reply->status_code != RTSP_STATUS_OK) {
1288
        av_freep(&content);
1289
        return AVERROR_INVALIDDATA;
1290
    }
1291

    
1292
    /* now we got the SDP description, we parse it */
1293
    ret = sdp_parse(s, (const char *)content);
1294
    av_freep(&content);
1295
    if (ret < 0)
1296
        return AVERROR_INVALIDDATA;
1297

    
1298
    return 0;
1299
}
1300

    
1301
static int rtsp_setup_output_streams(AVFormatContext *s, const char *addr)
1302
{
1303
    RTSPState *rt = s->priv_data;
1304
    RTSPMessageHeader reply1, *reply = &reply1;
1305
    int i;
1306
    char *sdp;
1307
    AVFormatContext sdp_ctx, *ctx_array[1];
1308

    
1309
    rt->start_time = av_gettime();
1310

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

    
1343
    /* Set up the RTSPStreams for each AVStream */
1344
    for (i = 0; i < s->nb_streams; i++) {
1345
        RTSPStream *rtsp_st;
1346
        AVStream *st = s->streams[i];
1347

    
1348
        rtsp_st = av_mallocz(sizeof(RTSPStream));
1349
        if (!rtsp_st)
1350
            return AVERROR(ENOMEM);
1351
        dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
1352

    
1353
        st->priv_data = rtsp_st;
1354
        rtsp_st->stream_index = i;
1355

    
1356
        av_strlcpy(rtsp_st->control_url, rt->control_uri, sizeof(rtsp_st->control_url));
1357
        /* Note, this must match the relative uri set in the sdp content */
1358
        av_strlcatf(rtsp_st->control_url, sizeof(rtsp_st->control_url),
1359
                    "/streamid=%d", i);
1360
    }
1361

    
1362
    return 0;
1363
}
1364

    
1365
void ff_rtsp_close_connections(AVFormatContext *s)
1366
{
1367
    RTSPState *rt = s->priv_data;
1368
    if (rt->rtsp_hd_out != rt->rtsp_hd) url_close(rt->rtsp_hd_out);
1369
    url_close(rt->rtsp_hd);
1370
    rt->rtsp_hd = rt->rtsp_hd_out = NULL;
1371
}
1372

    
1373
int ff_rtsp_connect(AVFormatContext *s)
1374
{
1375
    RTSPState *rt = s->priv_data;
1376
    char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1377
    char *option_list, *option, *filename;
1378
    int port, err, tcp_fd;
1379
    RTSPMessageHeader reply1 = {0}, *reply = &reply1;
1380
    int lower_transport_mask = 0;
1381
    char real_challenge[64];
1382
    struct sockaddr_storage peer;
1383
    socklen_t peer_len = sizeof(peer);
1384

    
1385
    if (!ff_network_init())
1386
        return AVERROR(EIO);
1387
redirect:
1388
    rt->control_transport = RTSP_MODE_PLAIN;
1389
    /* extract hostname and port */
1390
    av_url_split(NULL, 0, auth, sizeof(auth),
1391
                 host, sizeof(host), &port, path, sizeof(path), s->filename);
1392
    if (*auth) {
1393
        av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1394
    }
1395
    if (port < 0)
1396
        port = RTSP_DEFAULT_PORT;
1397

    
1398
    /* search for options */
1399
    option_list = strrchr(path, '?');
1400
    if (option_list) {
1401
        /* Strip out the RTSP specific options, write out the rest of
1402
         * the options back into the same string. */
1403
        filename = option_list;
1404
        while (option_list) {
1405
            /* move the option pointer */
1406
            option = ++option_list;
1407
            option_list = strchr(option_list, '&');
1408
            if (option_list)
1409
                *option_list = 0;
1410

    
1411
            /* handle the options */
1412
            if (!strcmp(option, "udp")) {
1413
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_UDP);
1414
            } else if (!strcmp(option, "multicast")) {
1415
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
1416
            } else if (!strcmp(option, "tcp")) {
1417
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_TCP);
1418
            } else if(!strcmp(option, "http")) {
1419
                lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_TCP);
1420
                rt->control_transport = RTSP_MODE_TUNNEL;
1421
            } else {
1422
                /* Write options back into the buffer, using memmove instead
1423
                 * of strcpy since the strings may overlap. */
1424
                int len = strlen(option);
1425
                memmove(++filename, option, len);
1426
                filename += len;
1427
                if (option_list) *filename = '&';
1428
            }
1429
        }
1430
        *filename = 0;
1431
    }
1432

    
1433
    if (!lower_transport_mask)
1434
        lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1435

    
1436
    if (s->oformat) {
1437
        /* Only UDP or TCP - UDP multicast isn't supported. */
1438
        lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
1439
                                (1 << RTSP_LOWER_TRANSPORT_TCP);
1440
        if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
1441
            av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1442
                                    "only UDP and TCP are supported for output.\n");
1443
            err = AVERROR(EINVAL);
1444
            goto fail;
1445
        }
1446
    }
1447

    
1448
    /* Construct the URI used in request; this is similar to s->filename,
1449
     * but with authentication credentials removed and RTSP specific options
1450
     * stripped out. */
1451
    ff_url_join(rt->control_uri, sizeof(rt->control_uri), "rtsp", NULL,
1452
                host, port, "%s", path);
1453

    
1454
    if (rt->control_transport == RTSP_MODE_TUNNEL) {
1455
        /* set up initial handshake for tunneling */
1456
        char httpname[1024];
1457
        char sessioncookie[17];
1458
        char headers[1024];
1459

    
1460
        ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path);
1461
        snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
1462
                 av_get_random_seed(), av_get_random_seed());
1463

    
1464
        /* GET requests */
1465
        if (url_alloc(&rt->rtsp_hd, httpname, URL_RDONLY) < 0) {
1466
            err = AVERROR(EIO);
1467
            goto fail;
1468
        }
1469

    
1470
        /* generate GET headers */
1471
        snprintf(headers, sizeof(headers),
1472
                 "x-sessioncookie: %s\r\n"
1473
                 "Accept: application/x-rtsp-tunnelled\r\n"
1474
                 "Pragma: no-cache\r\n"
1475
                 "Cache-Control: no-cache\r\n",
1476
                 sessioncookie);
1477
        ff_http_set_headers(rt->rtsp_hd, headers);
1478

    
1479
        /* complete the connection */
1480
        if (url_connect(rt->rtsp_hd)) {
1481
            err = AVERROR(EIO);
1482
            goto fail;
1483
        }
1484

    
1485
        /* POST requests */
1486
        if (url_alloc(&rt->rtsp_hd_out, httpname, URL_WRONLY) < 0 ) {
1487
            err = AVERROR(EIO);
1488
            goto fail;
1489
        }
1490

    
1491
        /* generate POST headers */
1492
        snprintf(headers, sizeof(headers),
1493
                 "x-sessioncookie: %s\r\n"
1494
                 "Content-Type: application/x-rtsp-tunnelled\r\n"
1495
                 "Pragma: no-cache\r\n"
1496
                 "Cache-Control: no-cache\r\n"
1497
                 "Content-Length: 32767\r\n"
1498
                 "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1499
                 sessioncookie);
1500
        ff_http_set_headers(rt->rtsp_hd_out, headers);
1501
        ff_http_set_chunked_transfer_encoding(rt->rtsp_hd_out, 0);
1502

    
1503
        /* Initialize the authentication state for the POST session. The HTTP
1504
         * protocol implementation doesn't properly handle multi-pass
1505
         * authentication for POST requests, since it would require one of
1506
         * the following:
1507
         * - implementing Expect: 100-continue, which many HTTP servers
1508
         *   don't support anyway, even less the RTSP servers that do HTTP
1509
         *   tunneling
1510
         * - sending the whole POST data until getting a 401 reply specifying
1511
         *   what authentication method to use, then resending all that data
1512
         * - waiting for potential 401 replies directly after sending the
1513
         *   POST header (waiting for some unspecified time)
1514
         * Therefore, we copy the full auth state, which works for both basic
1515
         * and digest. (For digest, we would have to synchronize the nonce
1516
         * count variable between the two sessions, if we'd do more requests
1517
         * with the original session, though.)
1518
         */
1519
        ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
1520

    
1521
        /* complete the connection */
1522
        if (url_connect(rt->rtsp_hd_out)) {
1523
            err = AVERROR(EIO);
1524
            goto fail;
1525
        }
1526
    } else {
1527
        /* open the tcp connection */
1528
        ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port, NULL);
1529
        if (url_open(&rt->rtsp_hd, tcpname, URL_RDWR) < 0) {
1530
            err = AVERROR(EIO);
1531
            goto fail;
1532
        }
1533
        rt->rtsp_hd_out = rt->rtsp_hd;
1534
    }
1535
    rt->seq = 0;
1536

    
1537
    tcp_fd = url_get_file_handle(rt->rtsp_hd);
1538
    if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1539
        getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1540
                    NULL, 0, NI_NUMERICHOST);
1541
    }
1542

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

    
1569
        /* detect server type if not standard-compliant RTP */
1570
        if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1571
            rt->server_type = RTSP_SERVER_REAL;
1572
            continue;
1573
        } else if (!strncasecmp(reply->server, "WMServer/", 9)) {
1574
            rt->server_type = RTSP_SERVER_WMS;
1575
        } else if (rt->server_type == RTSP_SERVER_REAL)
1576
            strcpy(real_challenge, reply->real_challenge);
1577
        break;
1578
    }
1579

    
1580
    if (s->iformat)
1581
        err = rtsp_setup_input_streams(s, reply);
1582
    else
1583
        err = rtsp_setup_output_streams(s, host);
1584
    if (err)
1585
        goto fail;
1586

    
1587
    do {
1588
        int lower_transport = ff_log2_tab[lower_transport_mask &
1589
                                  ~(lower_transport_mask - 1)];
1590

    
1591
        err = make_setup_request(s, host, port, lower_transport,
1592
                                 rt->server_type == RTSP_SERVER_REAL ?
1593
                                     real_challenge : NULL);
1594
        if (err < 0)
1595
            goto fail;
1596
        lower_transport_mask &= ~(1 << lower_transport);
1597
        if (lower_transport_mask == 0 && err == 1) {
1598
            err = FF_NETERROR(EPROTONOSUPPORT);
1599
            goto fail;
1600
        }
1601
    } while (err);
1602

    
1603
    rt->state = RTSP_STATE_IDLE;
1604
    rt->seek_timestamp = 0; /* default is to start stream at position zero */
1605
    return 0;
1606
 fail:
1607
    ff_rtsp_close_streams(s);
1608
    ff_rtsp_close_connections(s);
1609
    if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1610
        av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1611
        av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1612
               reply->status_code,
1613
               s->filename);
1614
        goto redirect;
1615
    }
1616
    ff_network_close();
1617
    return err;
1618
}
1619
#endif
1620

    
1621
#if CONFIG_RTSP_DEMUXER
1622
static int rtsp_read_header(AVFormatContext *s,
1623
                            AVFormatParameters *ap)
1624
{
1625
    RTSPState *rt = s->priv_data;
1626
    int ret;
1627

    
1628
    ret = ff_rtsp_connect(s);
1629
    if (ret)
1630
        return ret;
1631

    
1632
    rt->real_setup_cache = av_mallocz(2 * s->nb_streams * sizeof(*rt->real_setup_cache));
1633
    if (!rt->real_setup_cache)
1634
        return AVERROR(ENOMEM);
1635
    rt->real_setup = rt->real_setup_cache + s->nb_streams * sizeof(*rt->real_setup);
1636

    
1637
    if (ap->initial_pause) {
1638
         /* do not start immediately */
1639
    } else {
1640
         if (rtsp_read_play(s) < 0) {
1641
            ff_rtsp_close_streams(s);
1642
            ff_rtsp_close_connections(s);
1643
            return AVERROR_INVALIDDATA;
1644
        }
1645
    }
1646

    
1647
    return 0;
1648
}
1649

    
1650
static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1651
                           uint8_t *buf, int buf_size)
1652
{
1653
    RTSPState *rt = s->priv_data;
1654
    RTSPStream *rtsp_st;
1655
    fd_set rfds;
1656
    int fd, fd_rtcp, fd_max, n, i, ret, tcp_fd, timeout_cnt = 0;
1657
    struct timeval tv;
1658

    
1659
    for (;;) {
1660
        if (url_interrupt_cb())
1661
            return AVERROR(EINTR);
1662
        FD_ZERO(&rfds);
1663
        if (rt->rtsp_hd) {
1664
            tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd);
1665
            FD_SET(tcp_fd, &rfds);
1666
        } else {
1667
            fd_max = 0;
1668
            tcp_fd = -1;
1669
        }
1670
        for (i = 0; i < rt->nb_rtsp_streams; i++) {
1671
            rtsp_st = rt->rtsp_streams[i];
1672
            if (rtsp_st->rtp_handle) {
1673
                fd = url_get_file_handle(rtsp_st->rtp_handle);
1674
                fd_rtcp = rtp_get_rtcp_file_handle(rtsp_st->rtp_handle);
1675
                if (FFMAX(fd, fd_rtcp) > fd_max)
1676
                    fd_max = FFMAX(fd, fd_rtcp);
1677
                FD_SET(fd, &rfds);
1678
                FD_SET(fd_rtcp, &rfds);
1679
            }
1680
        }
1681
        tv.tv_sec = 0;
1682
        tv.tv_usec = SELECT_TIMEOUT_MS * 1000;
1683
        n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
1684
        if (n > 0) {
1685
            timeout_cnt = 0;
1686
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1687
                rtsp_st = rt->rtsp_streams[i];
1688
                if (rtsp_st->rtp_handle) {
1689
                    fd = url_get_file_handle(rtsp_st->rtp_handle);
1690
                    fd_rtcp = rtp_get_rtcp_file_handle(rtsp_st->rtp_handle);
1691
                    if (FD_ISSET(fd_rtcp, &rfds) || FD_ISSET(fd, &rfds)) {
1692
                        ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
1693
                        if (ret > 0) {
1694
                            *prtsp_st = rtsp_st;
1695
                            return ret;
1696
                        }
1697
                    }
1698
                }
1699
            }
1700
#if CONFIG_RTSP_DEMUXER
1701
            if (tcp_fd != -1 && FD_ISSET(tcp_fd, &rfds)) {
1702
                RTSPMessageHeader reply;
1703

    
1704
                ret = ff_rtsp_read_reply(s, &reply, NULL, 0);
1705
                if (ret < 0)
1706
                    return ret;
1707
                /* XXX: parse message */
1708
                if (rt->state != RTSP_STATE_STREAMING)
1709
                    return 0;
1710
            }
1711
#endif
1712
        } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
1713
            return FF_NETERROR(ETIMEDOUT);
1714
        } else if (n < 0 && errno != EINTR)
1715
            return AVERROR(errno);
1716
    }
1717
}
1718

    
1719
static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1720
                           uint8_t *buf, int buf_size)
1721
{
1722
    RTSPState *rt = s->priv_data;
1723
    int id, len, i, ret;
1724
    RTSPStream *rtsp_st;
1725

    
1726
#ifdef DEBUG_RTP_TCP
1727
    dprintf(s, "tcp_read_packet:\n");
1728
#endif
1729
redo:
1730
    for (;;) {
1731
        RTSPMessageHeader reply;
1732

    
1733
        ret = ff_rtsp_read_reply(s, &reply, NULL, 1);
1734
        if (ret < 0)
1735
            return ret;
1736
        if (ret == 1) /* received '$' */
1737
            break;
1738
        /* XXX: parse message */
1739
        if (rt->state != RTSP_STATE_STREAMING)
1740
            return 0;
1741
    }
1742
    ret = url_read_complete(rt->rtsp_hd, buf, 3);
1743
    if (ret != 3)
1744
        return -1;
1745
    id  = buf[0];
1746
    len = AV_RB16(buf + 1);
1747
#ifdef DEBUG_RTP_TCP
1748
    dprintf(s, "id=%d len=%d\n", id, len);
1749
#endif
1750
    if (len > buf_size || len < 12)
1751
        goto redo;
1752
    /* get the data */
1753
    ret = url_read_complete(rt->rtsp_hd, buf, len);
1754
    if (ret != len)
1755
        return -1;
1756
    if (rt->transport == RTSP_TRANSPORT_RDT &&
1757
        ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
1758
        return -1;
1759

    
1760
    /* find the matching stream */
1761
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
1762
        rtsp_st = rt->rtsp_streams[i];
1763
        if (id >= rtsp_st->interleaved_min &&
1764
            id <= rtsp_st->interleaved_max)
1765
            goto found;
1766
    }
1767
    goto redo;
1768
found:
1769
    *prtsp_st = rtsp_st;
1770
    return len;
1771
}
1772

    
1773
static int rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
1774
{
1775
    RTSPState *rt = s->priv_data;
1776
    int ret, len;
1777
    uint8_t buf[10 * RTP_MAX_PACKET_LENGTH];
1778
    RTSPStream *rtsp_st;
1779

    
1780
    /* get next frames from the same RTP packet */
1781
    if (rt->cur_transport_priv) {
1782
        if (rt->transport == RTSP_TRANSPORT_RDT) {
1783
            ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1784
        } else
1785
            ret = rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1786
        if (ret == 0) {
1787
            rt->cur_transport_priv = NULL;
1788
            return 0;
1789
        } else if (ret == 1) {
1790
            return 0;
1791
        } else
1792
            rt->cur_transport_priv = NULL;
1793
    }
1794

    
1795
    /* read next RTP packet */
1796
 redo:
1797
    switch(rt->lower_transport) {
1798
    default:
1799
#if CONFIG_RTSP_DEMUXER
1800
    case RTSP_LOWER_TRANSPORT_TCP:
1801
        len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1802
        break;
1803
#endif
1804
    case RTSP_LOWER_TRANSPORT_UDP:
1805
    case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1806
        len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1807
        if (len >=0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
1808
            rtp_check_and_send_back_rr(rtsp_st->transport_priv, len);
1809
        break;
1810
    }
1811
    if (len < 0)
1812
        return len;
1813
    if (len == 0)
1814
        return AVERROR_EOF;
1815
    if (rt->transport == RTSP_TRANSPORT_RDT) {
1816
        ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1817
    } else {
1818
        ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1819
        if (ret < 0) {
1820
            /* Either bad packet, or a RTCP packet. Check if the
1821
             * first_rtcp_ntp_time field was initialized. */
1822
            RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
1823
            if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
1824
                /* first_rtcp_ntp_time has been initialized for this stream,
1825
                 * copy the same value to all other uninitialized streams,
1826
                 * in order to map their timestamp origin to the same ntp time
1827
                 * as this one. */
1828
                int i;
1829
                for (i = 0; i < rt->nb_rtsp_streams; i++) {
1830
                    RTPDemuxContext *rtpctx2 = rtsp_st->transport_priv;
1831
                    if (rtpctx2 &&
1832
                        rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE)
1833
                        rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
1834
                }
1835
            }
1836
        }
1837
    }
1838
    if (ret < 0)
1839
        goto redo;
1840
    if (ret == 1)
1841
        /* more packets may follow, so we save the RTP context */
1842
        rt->cur_transport_priv = rtsp_st->transport_priv;
1843

    
1844
    return ret;
1845
}
1846

    
1847
static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt)
1848
{
1849
    RTSPState *rt = s->priv_data;
1850
    int ret;
1851
    RTSPMessageHeader reply1, *reply = &reply1;
1852
    char cmd[1024];
1853

    
1854
    if (rt->server_type == RTSP_SERVER_REAL) {
1855
        int i;
1856

    
1857
        for (i = 0; i < s->nb_streams; i++)
1858
            rt->real_setup[i] = s->streams[i]->discard;
1859

    
1860
        if (!rt->need_subscription) {
1861
            if (memcmp (rt->real_setup, rt->real_setup_cache,
1862
                        sizeof(enum AVDiscard) * s->nb_streams)) {
1863
                snprintf(cmd, sizeof(cmd),
1864
                         "Unsubscribe: %s\r\n",
1865
                         rt->last_subscription);
1866
                ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
1867
                                 cmd, reply, NULL);
1868
                if (reply->status_code != RTSP_STATUS_OK)
1869
                    return AVERROR_INVALIDDATA;
1870
                rt->need_subscription = 1;
1871
            }
1872
        }
1873

    
1874
        if (rt->need_subscription) {
1875
            int r, rule_nr, first = 1;
1876

    
1877
            memcpy(rt->real_setup_cache, rt->real_setup,
1878
                   sizeof(enum AVDiscard) * s->nb_streams);
1879
            rt->last_subscription[0] = 0;
1880

    
1881
            snprintf(cmd, sizeof(cmd),
1882
                     "Subscribe: ");
1883
            for (i = 0; i < rt->nb_rtsp_streams; i++) {
1884
                rule_nr = 0;
1885
                for (r = 0; r < s->nb_streams; r++) {
1886
                    if (s->streams[r]->priv_data == rt->rtsp_streams[i]) {
1887
                        if (s->streams[r]->discard != AVDISCARD_ALL) {
1888
                            if (!first)
1889
                                av_strlcat(rt->last_subscription, ",",
1890
                                           sizeof(rt->last_subscription));
1891
                            ff_rdt_subscribe_rule(
1892
                                rt->last_subscription,
1893
                                sizeof(rt->last_subscription), i, rule_nr);
1894
                            first = 0;
1895
                        }
1896
                        rule_nr++;
1897
                    }
1898
                }
1899
            }
1900
            av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
1901
            ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
1902
                             cmd, reply, NULL);
1903
            if (reply->status_code != RTSP_STATUS_OK)
1904
                return AVERROR_INVALIDDATA;
1905
            rt->need_subscription = 0;
1906

    
1907
            if (rt->state == RTSP_STATE_STREAMING)
1908
                rtsp_read_play (s);
1909
        }
1910
    }
1911

    
1912
    ret = rtsp_fetch_packet(s, pkt);
1913
    if (ret < 0)
1914
        return ret;
1915

    
1916
    /* send dummy request to keep TCP connection alive */
1917
    if ((av_gettime() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2) {
1918
        if (rt->server_type == RTSP_SERVER_WMS) {
1919
            ff_rtsp_send_cmd_async(s, "GET_PARAMETER", rt->control_uri, NULL);
1920
        } else {
1921
            ff_rtsp_send_cmd_async(s, "OPTIONS", "*", NULL);
1922
        }
1923
    }
1924

    
1925
    return 0;
1926
}
1927

    
1928
/* pause the stream */
1929
static int rtsp_read_pause(AVFormatContext *s)
1930
{
1931
    RTSPState *rt = s->priv_data;
1932
    RTSPMessageHeader reply1, *reply = &reply1;
1933

    
1934
    if (rt->state != RTSP_STATE_STREAMING)
1935
        return 0;
1936
    else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1937
        ff_rtsp_send_cmd(s, "PAUSE", rt->control_uri, NULL, reply, NULL);
1938
        if (reply->status_code != RTSP_STATUS_OK) {
1939
            return -1;
1940
        }
1941
    }
1942
    rt->state = RTSP_STATE_PAUSED;
1943
    return 0;
1944
}
1945

    
1946
static int rtsp_read_seek(AVFormatContext *s, int stream_index,
1947
                          int64_t timestamp, int flags)
1948
{
1949
    RTSPState *rt = s->priv_data;
1950

    
1951
    rt->seek_timestamp = av_rescale_q(timestamp,
1952
                                      s->streams[stream_index]->time_base,
1953
                                      AV_TIME_BASE_Q);
1954
    switch(rt->state) {
1955
    default:
1956
    case RTSP_STATE_IDLE:
1957
        break;
1958
    case RTSP_STATE_STREAMING:
1959
        if (rtsp_read_pause(s) != 0)
1960
            return -1;
1961
        rt->state = RTSP_STATE_SEEKING;
1962
        if (rtsp_read_play(s) != 0)
1963
            return -1;
1964
        break;
1965
    case RTSP_STATE_PAUSED:
1966
        rt->state = RTSP_STATE_IDLE;
1967
        break;
1968
    }
1969
    return 0;
1970
}
1971

    
1972
static int rtsp_read_close(AVFormatContext *s)
1973
{
1974
    RTSPState *rt = s->priv_data;
1975

    
1976
#if 0
1977
    /* NOTE: it is valid to flush the buffer here */
1978
    if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1979
        url_fclose(&rt->rtsp_gb);
1980
    }
1981
#endif
1982
    ff_rtsp_send_cmd_async(s, "TEARDOWN", rt->control_uri, NULL);
1983

    
1984
    ff_rtsp_close_streams(s);
1985
    ff_rtsp_close_connections(s);
1986
    ff_network_close();
1987
    rt->real_setup = NULL;
1988
    av_freep(&rt->real_setup_cache);
1989
    return 0;
1990
}
1991

    
1992
AVInputFormat rtsp_demuxer = {
1993
    "rtsp",
1994
    NULL_IF_CONFIG_SMALL("RTSP input format"),
1995
    sizeof(RTSPState),
1996
    rtsp_probe,
1997
    rtsp_read_header,
1998
    rtsp_read_packet,
1999
    rtsp_read_close,
2000
    rtsp_read_seek,
2001
    .flags = AVFMT_NOFILE,
2002
    .read_play = rtsp_read_play,
2003
    .read_pause = rtsp_read_pause,
2004
};
2005
#endif
2006

    
2007
static int sdp_probe(AVProbeData *p1)
2008
{
2009
    const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
2010

    
2011
    /* we look for a line beginning "c=IN IP" */
2012
    while (p < p_end && *p != '\0') {
2013
        if (p + sizeof("c=IN IP") - 1 < p_end &&
2014
            av_strstart(p, "c=IN IP", NULL))
2015
            return AVPROBE_SCORE_MAX / 2;
2016

    
2017
        while (p < p_end - 1 && *p != '\n') p++;
2018
        if (++p >= p_end)
2019
            break;
2020
        if (*p == '\r')
2021
            p++;
2022
    }
2023
    return 0;
2024
}
2025

    
2026
static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap)
2027
{
2028
    RTSPState *rt = s->priv_data;
2029
    RTSPStream *rtsp_st;
2030
    int size, i, err;
2031
    char *content;
2032
    char url[1024];
2033

    
2034
    if (!ff_network_init())
2035
        return AVERROR(EIO);
2036

    
2037
    /* read the whole sdp file */
2038
    /* XXX: better loading */
2039
    content = av_malloc(SDP_MAX_SIZE);
2040
    size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
2041
    if (size <= 0) {
2042
        av_free(content);
2043
        return AVERROR_INVALIDDATA;
2044
    }
2045
    content[size] ='\0';
2046

    
2047
    sdp_parse(s, content);
2048
    av_free(content);
2049

    
2050
    /* open each RTP stream */
2051
    for (i = 0; i < rt->nb_rtsp_streams; i++) {
2052
        char namebuf[50];
2053
        rtsp_st = rt->rtsp_streams[i];
2054

    
2055
        getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip),
2056
                    namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
2057
        ff_url_join(url, sizeof(url), "rtp", NULL,
2058
                    namebuf, rtsp_st->sdp_port,
2059
                    "?localport=%d&ttl=%d", rtsp_st->sdp_port,
2060
                    rtsp_st->sdp_ttl);
2061
        if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
2062
            err = AVERROR_INVALIDDATA;
2063
            goto fail;
2064
        }
2065
        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
2066
            goto fail;
2067
    }
2068
    return 0;
2069
fail:
2070
    ff_rtsp_close_streams(s);
2071
    ff_network_close();
2072
    return err;
2073
}
2074

    
2075
static int sdp_read_close(AVFormatContext *s)
2076
{
2077
    ff_rtsp_close_streams(s);
2078
    ff_network_close();
2079
    return 0;
2080
}
2081

    
2082
AVInputFormat sdp_demuxer = {
2083
    "sdp",
2084
    NULL_IF_CONFIG_SMALL("SDP"),
2085
    sizeof(RTSPState),
2086
    sdp_probe,
2087
    sdp_read_header,
2088
    rtsp_fetch_packet,
2089
    sdp_read_close,
2090
};