19
19
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
#include "libavutil/avassert.h"
22
23
#include "libavutil/base64.h"
23
24
#include "libavutil/avstring.h"
24
25
#include "libavutil/intreadwrite.h"
26
#include "libavutil/mathematics.h"
27
#include "libavutil/parseutils.h"
28
#include "libavutil/random_seed.h"
29
#include "libavutil/dict.h"
30
#include "libavutil/opt.h"
31
#include "libavutil/time.h"
25
32
#include "avformat.h"
33
#include "avio_internal.h"
29
#include <sys/select.h>
32
38
#include "internal.h"
33
39
#include "network.h"
34
40
#include "os_support.h"
37
44
#include "rtpdec.h"
39
#include "rtpdec_asf.h"
42
//#define DEBUG_RTP_TCP
44
#if LIBAVFORMAT_VERSION_INT < (53 << 16)
45
int rtsp_default_protocols = (1 << RTSP_LOWER_TRANSPORT_UDP);
48
/* Timeout values for socket select, in ms,
47
#include "rtpdec_formats.h"
48
#include "rtpenc_chain.h"
53
/* Timeout values for socket poll, in ms,
49
54
* and read_packet(), in seconds */
50
#define SELECT_TIMEOUT_MS 100
55
#define POLL_TIMEOUT_MS 100
51
56
#define READ_PACKET_TIMEOUT_S 10
52
#define MAX_TIMEOUTS READ_PACKET_TIMEOUT_S * 1000 / SELECT_TIMEOUT_MS
54
#define SPACE_CHARS " \t\r\n"
55
/* we use memchr() instead of strchr() here because strchr() will return
56
* the terminating '\0' of SPACE_CHARS instead of NULL if c is '\0'. */
57
#define redir_isspace(c) memchr(SPACE_CHARS, c, 4)
58
static void skip_spaces(const char **pp)
62
while (redir_isspace(*p))
57
#define MAX_TIMEOUTS READ_PACKET_TIMEOUT_S * 1000 / POLL_TIMEOUT_MS
58
#define SDP_MAX_SIZE 16384
59
#define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH
60
#define DEFAULT_REORDERING_DELAY 100000
62
#define OFFSET(x) offsetof(RTSPState, x)
63
#define DEC AV_OPT_FLAG_DECODING_PARAM
64
#define ENC AV_OPT_FLAG_ENCODING_PARAM
66
#define RTSP_FLAG_OPTS(name, longname) \
67
{ name, longname, OFFSET(rtsp_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtsp_flags" }, \
68
{ "filter_src", "only receive packets from the negotiated peer IP", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_FILTER_SRC}, 0, 0, DEC, "rtsp_flags" }
70
#define RTSP_MEDIATYPE_OPTS(name, longname) \
71
{ name, longname, OFFSET(media_type_mask), AV_OPT_TYPE_FLAGS, { .i64 = (1 << (AVMEDIA_TYPE_DATA+1)) - 1 }, INT_MIN, INT_MAX, DEC, "allowed_media_types" }, \
72
{ "video", "Video", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_VIDEO}, 0, 0, DEC, "allowed_media_types" }, \
73
{ "audio", "Audio", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_AUDIO}, 0, 0, DEC, "allowed_media_types" }, \
74
{ "data", "Data", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_DATA}, 0, 0, DEC, "allowed_media_types" }
76
#define RTSP_REORDERING_OPTS() \
77
{ "reorder_queue_size", "set number of packets to buffer for handling of reordered packets", OFFSET(reordering_queue_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC }
79
const AVOption ff_rtsp_options[] = {
80
{ "initial_pause", "do not start playing the stream immediately", OFFSET(initial_pause), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DEC },
81
FF_RTP_FLAG_OPTS(RTSPState, rtp_muxer_flags),
82
{ "rtsp_transport", "set RTSP transport protocols", OFFSET(lower_transport_mask), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC|ENC, "rtsp_transport" }, \
83
{ "udp", "UDP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP}, 0, 0, DEC|ENC, "rtsp_transport" }, \
84
{ "tcp", "TCP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_TCP}, 0, 0, DEC|ENC, "rtsp_transport" }, \
85
{ "udp_multicast", "UDP multicast", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP_MULTICAST}, 0, 0, DEC, "rtsp_transport" },
86
{ "http", "HTTP tunneling", 0, AV_OPT_TYPE_CONST, {.i64 = (1 << RTSP_LOWER_TRANSPORT_HTTP)}, 0, 0, DEC, "rtsp_transport" },
87
RTSP_FLAG_OPTS("rtsp_flags", "set RTSP flags"),
88
{ "listen", "wait for incoming connections", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_LISTEN}, 0, 0, DEC, "rtsp_flags" },
89
{ "prefer_tcp", "try RTP via TCP first, if available", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_PREFER_TCP}, 0, 0, DEC|ENC, "rtsp_flags" },
90
RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
91
{ "min_port", "set minimum local UDP port", OFFSET(rtp_port_min), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MIN}, 0, 65535, DEC|ENC },
92
{ "max_port", "set maximum local UDP port", OFFSET(rtp_port_max), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MAX}, 0, 65535, DEC|ENC },
93
{ "timeout", "set maximum timeout (in seconds) to wait for incoming connections (-1 is infinite, imply flag listen)", OFFSET(initial_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, DEC },
94
{ "stimeout", "set timeout (in microseconds) of socket TCP I/O operations", OFFSET(stimeout), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC },
95
RTSP_REORDERING_OPTS(),
96
{ "user-agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = LIBAVFORMAT_IDENT}, 0, 0, DEC },
100
static const AVOption sdp_options[] = {
101
RTSP_FLAG_OPTS("sdp_flags", "SDP flags"),
102
{ "custom_io", "use custom I/O", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_CUSTOM_IO}, 0, 0, DEC, "rtsp_flags" },
103
{ "rtcp_to_source", "send RTCP packets to the source address of received packets", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_RTCP_TO_SOURCE}, 0, 0, DEC, "rtsp_flags" },
104
RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
105
RTSP_REORDERING_OPTS(),
109
static const AVOption rtp_options[] = {
110
RTSP_FLAG_OPTS("rtp_flags", "set RTP flags"),
111
RTSP_REORDERING_OPTS(),
67
115
static void get_word_until_chars(char *buf, int buf_size,
68
116
const char *sep, const char **pp)
95
143
get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);
146
/** Parse a string p in the form of Range:npt=xx-xx, and determine the start
148
* Used for seeking in the rtp stream.
150
static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
154
p += strspn(p, SPACE_CHARS);
155
if (!av_stristart(p, "npt=", &p))
158
*start = AV_NOPTS_VALUE;
159
*end = AV_NOPTS_VALUE;
161
get_word_sep(buf, sizeof(buf), "-", &p);
162
av_parse_time(start, buf, 1);
165
get_word_sep(buf, sizeof(buf), "-", &p);
166
av_parse_time(end, buf, 1);
170
static int get_sockaddr(const char *buf, struct sockaddr_storage *sock)
172
struct addrinfo hints = { 0 }, *ai = NULL;
173
hints.ai_flags = AI_NUMERICHOST;
174
if (getaddrinfo(buf, NULL, &hints, &ai))
176
memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen));
182
static void init_rtp_handler(RTPDynamicProtocolHandler *handler,
183
RTSPStream *rtsp_st, AVCodecContext *codec)
188
codec->codec_id = handler->codec_id;
189
rtsp_st->dynamic_handler = handler;
190
if (handler->alloc) {
191
rtsp_st->dynamic_protocol_context = handler->alloc();
192
if (!rtsp_st->dynamic_protocol_context)
193
rtsp_st->dynamic_handler = NULL;
98
197
/* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
99
198
static int sdp_parse_rtpmap(AVFormatContext *s,
100
AVCodecContext *codec, RTSPStream *rtsp_st,
199
AVStream *st, RTSPStream *rtsp_st,
101
200
int payload_type, const char *p)
202
AVCodecContext *codec = st->codec;
106
206
const char *c_name;
108
/* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and
109
* see if we can handle this kind of payload.
208
/* See if we can handle this kind of payload.
110
209
* The space should normally not be there but some Real streams or
111
210
* particular servers ("RealServer Version 6.1.3.970", see issue 1658)
112
211
* have a trailing space. */
113
212
get_word_sep(buf, sizeof(buf), "/ ", &p);
114
if (payload_type >= RTP_PT_PRIVATE) {
115
RTPDynamicProtocolHandler *handler;
116
for (handler = RTPFirstDynamicPayloadHandler;
117
handler; handler = handler->next) {
118
if (!strcasecmp(buf, handler->enc_name) &&
119
codec->codec_type == handler->codec_type) {
120
codec->codec_id = handler->codec_id;
121
rtsp_st->dynamic_handler = handler;
123
rtsp_st->dynamic_protocol_context = handler->open();
213
if (payload_type < RTP_PT_PRIVATE) {
128
214
/* We are in a standard case
129
215
* (from http://www.iana.org/assignments/rtp-parameters). */
130
/* search into AVRtpPayloadTypes[] */
131
216
codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
219
if (codec->codec_id == AV_CODEC_ID_NONE) {
220
RTPDynamicProtocolHandler *handler =
221
ff_rtp_handler_find_by_name(buf, codec->codec_type);
222
init_rtp_handler(handler, rtsp_st, codec);
223
/* If no dynamic handler was found, check with the list of standard
224
* allocated types, if such a stream for some reason happens to
225
* use a private payload type. This isn't handled in rtpdec.c, since
226
* the format name from the rtpmap line never is passed into rtpdec. */
227
if (!rtsp_st->dynamic_handler)
228
codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
134
231
c = avcodec_find_decoder(codec->codec_id);
135
232
if (c && c->name)
136
233
c_name = c->name;
163
257
case AVMEDIA_TYPE_VIDEO:
164
258
av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
260
avpriv_set_pts_info(st, 32, 1, i);
265
if (rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->init)
266
rtsp_st->dynamic_handler->init(s, st->index,
267
rtsp_st->dynamic_protocol_context);
172
/* return the length and optionally the data */
173
static int hex_to_data(uint8_t *data, const char *p)
183
c = toupper((unsigned char) *p++);
184
if (c >= '0' && c <= '9')
186
else if (c >= 'A' && c <= 'F')
201
static void sdp_parse_fmtp_config(AVCodecContext * codec, void *ctx,
202
char *attr, char *value)
204
switch (codec->codec_id) {
207
if (!strcmp(attr, "config")) {
208
/* decode the hexa encoded parameter */
209
int len = hex_to_data(NULL, value);
210
if (codec->extradata)
211
av_free(codec->extradata);
212
codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
213
if (!codec->extradata)
215
codec->extradata_size = len;
216
hex_to_data(codec->extradata, value);
231
/* All known fmtp parameters and the corresponding RTPAttrTypeEnum */
232
#define ATTR_NAME_TYPE_INT 0
233
#define ATTR_NAME_TYPE_STR 1
234
static const AttrNameMap attr_names[]=
236
{ "SizeLength", ATTR_NAME_TYPE_INT,
237
offsetof(RTPPayloadData, sizelength) },
238
{ "IndexLength", ATTR_NAME_TYPE_INT,
239
offsetof(RTPPayloadData, indexlength) },
240
{ "IndexDeltaLength", ATTR_NAME_TYPE_INT,
241
offsetof(RTPPayloadData, indexdeltalength) },
242
{ "profile-level-id", ATTR_NAME_TYPE_INT,
243
offsetof(RTPPayloadData, profile_level_id) },
244
{ "StreamType", ATTR_NAME_TYPE_INT,
245
offsetof(RTPPayloadData, streamtype) },
246
{ "mode", ATTR_NAME_TYPE_STR,
247
offsetof(RTPPayloadData, mode) },
251
271
/* parse the attribute line from the fmtp a line of an sdp response. This
252
272
* is broken out as a function because it is used in rtp_h264.c, which is
253
273
* forthcoming. */
254
274
int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
255
275
char *value, int value_size)
277
*p += strspn(*p, SPACE_CHARS);
259
279
get_word_sep(attr, attr_size, "=", p);
270
/* parse a SDP line and save stream attributes */
271
static void sdp_parse_fmtp(AVStream *st, const char *p)
274
/* Vorbis setup headers can be up to 12KB and are sent base64
275
* encoded, giving a 12KB * (4/3) = 16KB FMTP line. */
278
RTSPStream *rtsp_st = st->priv_data;
279
AVCodecContext *codec = st->codec;
280
RTPPayloadData *rtp_payload_data = &rtsp_st->rtp_payload_data;
282
/* loop on each attribute */
283
while (ff_rtsp_next_attr_and_value(&p, attr, sizeof(attr),
284
value, sizeof(value))) {
285
/* grab the codec extra_data from the config parameter of the fmtp
287
sdp_parse_fmtp_config(codec, rtsp_st->dynamic_protocol_context,
289
/* Looking for a known attribute */
290
for (i = 0; attr_names[i].str; ++i) {
291
if (!strcasecmp(attr, attr_names[i].str)) {
292
if (attr_names[i].type == ATTR_NAME_TYPE_INT) {
293
*(int *)((char *)rtp_payload_data +
294
attr_names[i].offset) = atoi(value);
295
} else if (attr_names[i].type == ATTR_NAME_TYPE_STR)
296
*(char **)((char *)rtp_payload_data +
297
attr_names[i].offset) = av_strdup(value);
303
/** Parse a string p in the form of Range:npt=xx-xx, and determine the start
305
* Used for seeking in the rtp stream.
307
static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
312
if (!av_stristart(p, "npt=", &p))
315
*start = AV_NOPTS_VALUE;
316
*end = AV_NOPTS_VALUE;
318
get_word_sep(buf, sizeof(buf), "-", &p);
319
*start = parse_date(buf, 1);
322
get_word_sep(buf, sizeof(buf), "-", &p);
323
*end = parse_date(buf, 1);
325
// av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
326
// av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
329
290
typedef struct SDPParseState {
331
struct in_addr default_ip;
292
struct sockaddr_storage default_ip;
333
294
int skip_media; ///< set if an unknown m= line occurs
295
int nb_default_include_source_addrs; /**< Number of source-specific multicast include source IP address (from SDP content) */
296
struct RTSPSource **default_include_source_addrs; /**< Source-specific multicast include source IP address (from SDP content) */
297
int nb_default_exclude_source_addrs; /**< Number of source-specific multicast exclude source IP address (from SDP content) */
298
struct RTSPSource **default_exclude_source_addrs; /**< Source-specific multicast exclude source IP address (from SDP content) */
301
char delayed_fmtp[2048];
304
static void copy_default_source_addrs(struct RTSPSource **addrs, int count,
305
struct RTSPSource ***dest, int *dest_count)
307
RTSPSource *rtsp_src, *rtsp_src2;
309
for (i = 0; i < count; i++) {
311
rtsp_src2 = av_malloc(sizeof(*rtsp_src2));
314
memcpy(rtsp_src2, rtsp_src, sizeof(*rtsp_src));
315
dynarray_add(dest, dest_count, rtsp_src2);
319
static void parse_fmtp(AVFormatContext *s, RTSPState *rt,
320
int payload_type, const char *line)
324
for (i = 0; i < rt->nb_rtsp_streams; i++) {
325
RTSPStream *rtsp_st = rt->rtsp_streams[i];
326
if (rtsp_st->sdp_payload_type == payload_type &&
327
rtsp_st->dynamic_handler &&
328
rtsp_st->dynamic_handler->parse_sdp_a_line) {
329
rtsp_st->dynamic_handler->parse_sdp_a_line(s, i,
330
rtsp_st->dynamic_protocol_context, line);
336
335
static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
337
336
int letter, const char *buf)
422
438
if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
423
439
/* no corresponding stream */
440
if (rt->transport == RTSP_TRANSPORT_RAW) {
441
if (!rt->ts && CONFIG_RTPDEC)
442
rt->ts = avpriv_mpegts_parse_open(s);
444
RTPDynamicProtocolHandler *handler;
445
handler = ff_rtp_handler_find_by_id(
446
rtsp_st->sdp_payload_type, AVMEDIA_TYPE_DATA);
447
init_rtp_handler(handler, rtsp_st, NULL);
448
if (handler && handler->init)
449
handler->init(s, -1, rtsp_st->dynamic_protocol_context);
451
} else if (rt->server_type == RTSP_SERVER_WMS &&
452
codec_type == AVMEDIA_TYPE_DATA) {
453
/* RTX stream, a stream that carries all the other actual
454
* audio/video streams. Don't expose this to the callers. */
425
st = av_new_stream(s, 0);
456
st = avformat_new_stream(s, NULL);
428
st->priv_data = rtsp_st;
459
st->id = rt->nb_rtsp_streams - 1;
429
460
rtsp_st->stream_index = st->index;
430
461
st->codec->codec_type = codec_type;
431
462
if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
463
RTPDynamicProtocolHandler *handler;
432
464
/* if standard payload type, we can find the codec right now */
433
465
ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
466
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
467
st->codec->sample_rate > 0)
468
avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);
469
/* Even static payload types may need a custom depacketizer */
470
handler = ff_rtp_handler_find_by_id(
471
rtsp_st->sdp_payload_type, st->codec->codec_type);
472
init_rtp_handler(handler, rtsp_st, st->codec);
473
if (handler && handler->init)
474
handler->init(s, st->index,
475
rtsp_st->dynamic_protocol_context);
436
478
/* put a default control url */
444
486
av_strlcpy(rt->control_uri, p,
445
487
sizeof(rt->control_uri));
448
/* get the control url */
449
st = s->streams[s->nb_streams - 1];
450
rtsp_st = st->priv_data;
490
/* get the control url */
491
rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
452
/* XXX: may need to add full url resolution */
453
ff_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
455
if (proto[0] == '\0') {
456
/* relative control URL */
457
if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
458
av_strlcat(rtsp_st->control_url, "/",
459
sizeof(rtsp_st->control_url));
460
av_strlcat(rtsp_st->control_url, p,
461
sizeof(rtsp_st->control_url));
463
av_strlcpy(rtsp_st->control_url, p,
464
sizeof(rtsp_st->control_url));
493
/* XXX: may need to add full url resolution */
494
av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
496
if (proto[0] == '\0') {
497
/* relative control URL */
498
if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
499
av_strlcat(rtsp_st->control_url, "/",
500
sizeof(rtsp_st->control_url));
501
av_strlcat(rtsp_st->control_url, p,
502
sizeof(rtsp_st->control_url));
504
av_strlcpy(rtsp_st->control_url, p,
505
sizeof(rtsp_st->control_url));
466
507
} else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
467
508
/* NOTE: rtpmap is only supported AFTER the 'm=' tag */
468
509
get_word(buf1, sizeof(buf1), &p);
469
510
payload_type = atoi(buf1);
470
st = s->streams[s->nb_streams - 1];
471
rtsp_st = st->priv_data;
472
sdp_parse_rtpmap(s, st->codec, rtsp_st, payload_type, p);
473
} else if (av_strstart(p, "fmtp:", &p)) {
474
/* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
475
get_word(buf1, sizeof(buf1), &p);
476
payload_type = atoi(buf1);
477
for (i = 0; i < s->nb_streams; i++) {
479
rtsp_st = st->priv_data;
480
if (rtsp_st->sdp_payload_type == payload_type) {
481
if (!(rtsp_st->dynamic_handler &&
482
rtsp_st->dynamic_handler->parse_sdp_a_line &&
483
rtsp_st->dynamic_handler->parse_sdp_a_line(s,
484
i, rtsp_st->dynamic_protocol_context, buf)))
485
sdp_parse_fmtp(st, p);
488
} else if (av_strstart(p, "framesize:", &p)) {
511
rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
512
if (rtsp_st->stream_index >= 0) {
513
st = s->streams[rtsp_st->stream_index];
514
sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p);
518
parse_fmtp(s, rt, payload_type, s1->delayed_fmtp);
520
} else if (av_strstart(p, "fmtp:", &p) ||
521
av_strstart(p, "framesize:", &p)) {
489
522
// let dynamic protocol handlers have a stab at the line.
490
523
get_word(buf1, sizeof(buf1), &p);
491
524
payload_type = atoi(buf1);
492
for (i = 0; i < s->nb_streams; i++) {
494
rtsp_st = st->priv_data;
495
if (rtsp_st->sdp_payload_type == payload_type &&
496
rtsp_st->dynamic_handler &&
497
rtsp_st->dynamic_handler->parse_sdp_a_line)
498
rtsp_st->dynamic_handler->parse_sdp_a_line(s, i,
499
rtsp_st->dynamic_protocol_context, buf);
525
if (s1->seen_rtpmap) {
526
parse_fmtp(s, rt, payload_type, buf);
529
av_strlcpy(s1->delayed_fmtp, buf, sizeof(s1->delayed_fmtp));
501
531
} else if (av_strstart(p, "range:", &p)) {
502
532
int64_t start, end;
510
540
} else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
511
541
if (atoi(p) == 1)
512
542
rt->transport = RTSP_TRANSPORT_RDT;
543
} else if (av_strstart(p, "SampleRate:integer;", &p) &&
545
st = s->streams[s->nb_streams - 1];
546
st->codec->sample_rate = atoi(p);
547
} else if (av_strstart(p, "crypto:", &p) && s->nb_streams > 0) {
549
rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
550
get_word(buf1, sizeof(buf1), &p); // ignore tag
551
get_word(rtsp_st->crypto_suite, sizeof(rtsp_st->crypto_suite), &p);
552
p += strspn(p, SPACE_CHARS);
553
if (av_strstart(p, "inline:", &p))
554
get_word(rtsp_st->crypto_params, sizeof(rtsp_st->crypto_params), &p);
555
} else if (av_strstart(p, "source-filter:", &p)) {
557
get_word(buf1, sizeof(buf1), &p);
558
if (strcmp(buf1, "incl") && strcmp(buf1, "excl"))
560
exclude = !strcmp(buf1, "excl");
562
get_word(buf1, sizeof(buf1), &p);
563
if (strcmp(buf1, "IN") != 0)
565
get_word(buf1, sizeof(buf1), &p);
566
if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6") && strcmp(buf1, "*"))
568
// not checking that the destination address actually matches or is wildcard
569
get_word(buf1, sizeof(buf1), &p);
572
rtsp_src = av_mallocz(sizeof(*rtsp_src));
575
get_word(rtsp_src->addr, sizeof(rtsp_src->addr), &p);
577
if (s->nb_streams == 0) {
578
dynarray_add(&s1->default_exclude_source_addrs, &s1->nb_default_exclude_source_addrs, rtsp_src);
580
rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
581
dynarray_add(&rtsp_st->exclude_source_addrs, &rtsp_st->nb_exclude_source_addrs, rtsp_src);
584
if (s->nb_streams == 0) {
585
dynarray_add(&s1->default_include_source_addrs, &s1->nb_default_include_source_addrs, rtsp_src);
587
rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
588
dynarray_add(&rtsp_st->include_source_addrs, &rtsp_st->nb_include_source_addrs, rtsp_src);
514
593
if (rt->server_type == RTSP_SERVER_WMS)
515
594
ff_wms_parse_sdp_a_line(s, p);
516
595
if (s->nb_streams > 0) {
596
rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
517
598
if (rt->server_type == RTSP_SERVER_REAL)
518
ff_real_parse_sdp_a_line(s, s->nb_streams - 1, p);
599
ff_real_parse_sdp_a_line(s, rtsp_st->stream_index, p);
520
rtsp_st = s->streams[s->nb_streams - 1]->priv_data;
521
601
if (rtsp_st->dynamic_handler &&
522
602
rtsp_st->dynamic_handler->parse_sdp_a_line)
523
603
rtsp_st->dynamic_handler->parse_sdp_a_line(s,
604
rtsp_st->stream_index,
525
605
rtsp_st->dynamic_protocol_context, buf);
654
for (i = 0; i < s1->nb_default_include_source_addrs; i++)
655
av_free(s1->default_include_source_addrs[i]);
656
av_freep(&s1->default_include_source_addrs);
657
for (i = 0; i < s1->nb_default_exclude_source_addrs; i++)
658
av_free(s1->default_exclude_source_addrs[i]);
659
av_freep(&s1->default_exclude_source_addrs);
661
rt->p = av_malloc_array(rt->nb_rtsp_streams + 1, sizeof(struct pollfd) * 2);
662
if (!rt->p) return AVERROR(ENOMEM);
665
#endif /* CONFIG_RTPDEC */
667
void ff_rtsp_undo_setup(AVFormatContext *s, int send_packets)
669
RTSPState *rt = s->priv_data;
672
for (i = 0; i < rt->nb_rtsp_streams; i++) {
673
RTSPStream *rtsp_st = rt->rtsp_streams[i];
676
if (rtsp_st->transport_priv) {
678
AVFormatContext *rtpctx = rtsp_st->transport_priv;
679
av_write_trailer(rtpctx);
680
if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
682
if (CONFIG_RTSP_MUXER && rtpctx->pb && send_packets)
683
ff_rtsp_tcp_write_packet(s, rtsp_st);
684
avio_close_dyn_buf(rtpctx->pb, &ptr);
687
avio_close(rtpctx->pb);
689
avformat_free_context(rtpctx);
690
} else if (rt->transport == RTSP_TRANSPORT_RDT && CONFIG_RTPDEC)
691
ff_rdt_parse_close(rtsp_st->transport_priv);
692
else if (rt->transport == RTSP_TRANSPORT_RTP && CONFIG_RTPDEC)
693
ff_rtp_parse_close(rtsp_st->transport_priv);
695
rtsp_st->transport_priv = NULL;
696
if (rtsp_st->rtp_handle)
697
ffurl_close(rtsp_st->rtp_handle);
698
rtsp_st->rtp_handle = NULL;
575
702
/* close and free RTSP streams */
576
703
void ff_rtsp_close_streams(AVFormatContext *s)
578
705
RTSPState *rt = s->priv_data;
580
707
RTSPStream *rtsp_st;
709
ff_rtsp_undo_setup(s, 0);
582
710
for (i = 0; i < rt->nb_rtsp_streams; i++) {
583
711
rtsp_st = rt->rtsp_streams[i];
585
if (rtsp_st->transport_priv) {
587
AVFormatContext *rtpctx = rtsp_st->transport_priv;
588
av_write_trailer(rtpctx);
589
if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
591
url_close_dyn_buf(rtpctx->pb, &ptr);
594
url_fclose(rtpctx->pb);
596
av_metadata_free(&rtpctx->streams[0]->metadata);
597
av_metadata_free(&rtpctx->metadata);
598
av_free(rtpctx->streams[0]);
600
} else if (rt->transport == RTSP_TRANSPORT_RDT)
601
ff_rdt_parse_close(rtsp_st->transport_priv);
603
rtp_parse_close(rtsp_st->transport_priv);
605
if (rtsp_st->rtp_handle)
606
url_close(rtsp_st->rtp_handle);
607
713
if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
608
rtsp_st->dynamic_handler->close(
714
rtsp_st->dynamic_handler->free(
609
715
rtsp_st->dynamic_protocol_context);
716
for (j = 0; j < rtsp_st->nb_include_source_addrs; j++)
717
av_free(rtsp_st->include_source_addrs[j]);
718
av_freep(&rtsp_st->include_source_addrs);
719
for (j = 0; j < rtsp_st->nb_exclude_source_addrs; j++)
720
av_free(rtsp_st->exclude_source_addrs[j]);
721
av_freep(&rtsp_st->exclude_source_addrs);
612
726
av_free(rt->rtsp_streams);
613
727
if (rt->asf_ctx) {
614
av_close_input_stream (rt->asf_ctx);
619
static void *rtsp_rtp_mux_open(AVFormatContext *s, AVStream *st,
622
RTSPState *rt = s->priv_data;
623
AVFormatContext *rtpctx;
625
AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
630
/* Allocate an AVFormatContext for each output stream */
631
rtpctx = avformat_alloc_context();
635
rtpctx->oformat = rtp_format;
636
if (!av_new_stream(rtpctx, 0)) {
640
/* Copy the max delay setting; the rtp muxer reads this. */
641
rtpctx->max_delay = s->max_delay;
642
/* Copy other stream parameters. */
643
rtpctx->streams[0]->sample_aspect_ratio = st->sample_aspect_ratio;
645
/* Set the synchronized start time. */
646
rtpctx->start_time_realtime = rt->start_time;
648
/* Remove the local codec, link to the original codec
649
* context instead, to give the rtp muxer access to
650
* codec parameters. */
651
av_free(rtpctx->streams[0]->codec);
652
rtpctx->streams[0]->codec = st->codec;
655
url_fdopen(&rtpctx->pb, handle);
657
url_open_dyn_packet_buf(&rtpctx->pb, RTSP_TCP_MAX_PACKET_SIZE);
658
ret = av_write_header(rtpctx);
662
url_fclose(rtpctx->pb);
665
url_close_dyn_buf(rtpctx->pb, &ptr);
668
av_free(rtpctx->streams[0]);
673
/* Copy the RTP AVStream timebase back to the original AVStream */
674
st->time_base = rtpctx->streams[0]->time_base;
678
static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
728
avformat_close_input(&rt->asf_ctx);
730
if (rt->ts && CONFIG_RTPDEC)
731
avpriv_mpegts_parse_close(rt->ts);
733
av_free(rt->recvbuf);
736
int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
680
738
RTSPState *rt = s->priv_data;
681
739
AVStream *st = NULL;
740
int reordering_queue_size = rt->reordering_queue_size;
741
if (reordering_queue_size < 0) {
742
if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay)
743
reordering_queue_size = 0;
745
reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE;
683
748
/* open the RTP context */
684
749
if (rtsp_st->stream_index >= 0)
687
752
s->ctx_flags |= AVFMTCTX_NOHEADER;
690
rtsp_st->transport_priv = rtsp_rtp_mux_open(s, st, rtsp_st->rtp_handle);
754
if (s->oformat && CONFIG_RTSP_MUXER) {
755
int ret = ff_rtp_chain_mux_open((AVFormatContext **)&rtsp_st->transport_priv,
756
s, st, rtsp_st->rtp_handle,
757
RTSP_TCP_MAX_PACKET_SIZE,
758
rtsp_st->stream_index);
691
759
/* Ownership of rtp_handle is passed to the rtp mux context */
692
760
rtsp_st->rtp_handle = NULL;
693
} else if (rt->transport == RTSP_TRANSPORT_RDT)
763
st->time_base = ((AVFormatContext*)rtsp_st->transport_priv)->streams[0]->time_base;
764
} else if (rt->transport == RTSP_TRANSPORT_RAW) {
765
return 0; // Don't need to open any parser here
766
} else if (rt->transport == RTSP_TRANSPORT_RDT && CONFIG_RTPDEC)
694
767
rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
695
768
rtsp_st->dynamic_protocol_context,
696
769
rtsp_st->dynamic_handler);
698
rtsp_st->transport_priv = rtp_parse_open(s, st, rtsp_st->rtp_handle,
770
else if (CONFIG_RTPDEC)
771
rtsp_st->transport_priv = ff_rtp_parse_open(s, st,
699
772
rtsp_st->sdp_payload_type,
700
&rtsp_st->rtp_payload_data);
773
reordering_queue_size);
702
775
if (!rtsp_st->transport_priv) {
703
776
return AVERROR(ENOMEM);
704
} else if (rt->transport != RTSP_TRANSPORT_RDT) {
777
} else if (rt->transport == RTSP_TRANSPORT_RTP && CONFIG_RTPDEC) {
705
778
if (rtsp_st->dynamic_handler) {
706
rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
707
rtsp_st->dynamic_protocol_context,
708
rtsp_st->dynamic_handler);
779
ff_rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
780
rtsp_st->dynamic_protocol_context,
781
rtsp_st->dynamic_handler);
783
if (rtsp_st->crypto_suite[0])
784
ff_rtp_parse_set_crypto(rtsp_st->transport_priv,
785
rtsp_st->crypto_suite,
786
rtsp_st->crypto_params);
715
792
#if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
716
static int rtsp_probe(AVProbeData *p)
718
if (av_strstart(p->filename, "rtsp:", NULL))
719
return AVPROBE_SCORE_MAX;
723
793
static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
730
v = strtol(p, (char **)&p, 10);
800
q += strspn(q, SPACE_CHARS);
801
v = strtol(q, &p, 10);
734
v = strtol(p, (char **)&p, 10);
805
v = strtol(p, &p, 10);
937
static void handle_rtp_info(RTSPState *rt, const char *url,
938
uint32_t seq, uint32_t rtptime)
941
if (!rtptime || !url[0])
943
if (rt->transport != RTSP_TRANSPORT_RTP)
945
for (i = 0; i < rt->nb_rtsp_streams; i++) {
946
RTSPStream *rtsp_st = rt->rtsp_streams[i];
947
RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
950
if (!strcmp(rtsp_st->control_url, url)) {
951
rtpctx->base_timestamp = rtptime;
957
static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)
960
char key[20], value[1024], url[1024] = "";
961
uint32_t seq = 0, rtptime = 0;
964
p += strspn(p, SPACE_CHARS);
967
get_word_sep(key, sizeof(key), "=", &p);
971
get_word_sep(value, sizeof(value), ";, ", &p);
973
if (!strcmp(key, "url"))
974
av_strlcpy(url, value, sizeof(url));
975
else if (!strcmp(key, "seq"))
976
seq = strtoul(value, NULL, 10);
977
else if (!strcmp(key, "rtptime"))
978
rtptime = strtoul(value, NULL, 10);
980
handle_rtp_info(rt, url, seq, rtptime);
989
handle_rtp_info(rt, url, seq, rtptime);
843
992
void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf,
844
HTTPAuthState *auth_state)
993
RTSPState *rt, const char *method)
863
1012
} else if (av_stristart(p, "Range:", &p)) {
864
1013
rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
865
1014
} else if (av_stristart(p, "RealChallenge1:", &p)) {
1015
p += strspn(p, SPACE_CHARS);
867
1016
av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
868
1017
} else if (av_stristart(p, "Server:", &p)) {
1018
p += strspn(p, SPACE_CHARS);
870
1019
av_strlcpy(reply->server, p, sizeof(reply->server));
871
1020
} else if (av_stristart(p, "Notice:", &p) ||
872
1021
av_stristart(p, "X-Notice:", &p)) {
873
1022
reply->notice = strtol(p, NULL, 10);
874
1023
} else if (av_stristart(p, "Location:", &p)) {
1024
p += strspn(p, SPACE_CHARS);
876
1025
av_strlcpy(reply->location, p , sizeof(reply->location));
877
} else if (av_stristart(p, "WWW-Authenticate:", &p) && auth_state) {
879
ff_http_auth_handle_header(auth_state, "WWW-Authenticate", p);
880
} else if (av_stristart(p, "Authentication-Info:", &p) && auth_state) {
882
ff_http_auth_handle_header(auth_state, "Authentication-Info", p);
1026
} else if (av_stristart(p, "WWW-Authenticate:", &p) && rt) {
1027
p += strspn(p, SPACE_CHARS);
1028
ff_http_auth_handle_header(&rt->auth_state, "WWW-Authenticate", p);
1029
} else if (av_stristart(p, "Authentication-Info:", &p) && rt) {
1030
p += strspn(p, SPACE_CHARS);
1031
ff_http_auth_handle_header(&rt->auth_state, "Authentication-Info", p);
1032
} else if (av_stristart(p, "Content-Base:", &p) && rt) {
1033
p += strspn(p, SPACE_CHARS);
1034
if (method && !strcmp(method, "DESCRIBE"))
1035
av_strlcpy(rt->control_uri, p , sizeof(rt->control_uri));
1036
} else if (av_stristart(p, "RTP-Info:", &p) && rt) {
1037
p += strspn(p, SPACE_CHARS);
1038
if (method && !strcmp(method, "PLAY"))
1039
rtsp_parse_rtp_info(rt, p);
1040
} else if (av_stristart(p, "Public:", &p) && rt) {
1041
if (strstr(p, "GET_PARAMETER") &&
1042
method && !strcmp(method, "OPTIONS"))
1043
rt->get_parameter_supported = 1;
1044
} else if (av_stristart(p, "x-Accept-Dynamic-Rate:", &p) && rt) {
1045
p += strspn(p, SPACE_CHARS);
1046
rt->accept_dynamic_rate = atoi(p);
1047
} else if (av_stristart(p, "Content-Type:", &p)) {
1048
p += strspn(p, SPACE_CHARS);
1049
av_strlcpy(reply->content_type, p, sizeof(reply->content_type));
957
1126
if (line_count == 0) {
958
1127
/* get reply code */
959
1128
get_word(buf1, sizeof(buf1), &p);
960
get_word(buf1, sizeof(buf1), &p);
961
reply->status_code = atoi(buf1);
1129
if (!strncmp(buf1, "RTSP/", 5)) {
1130
get_word(buf1, sizeof(buf1), &p);
1131
reply->status_code = atoi(buf1);
1132
av_strlcpy(reply->reason, p, sizeof(reply->reason));
1134
av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method
1135
get_word(buf1, sizeof(buf1), &p); // object
963
ff_rtsp_parse_line(reply, p, &rt->auth_state);
1139
ff_rtsp_parse_line(reply, p, rt, method);
964
1140
av_strlcat(rt->last_reply, p, sizeof(rt->last_reply));
965
1141
av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
970
if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
1146
if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0' && !request)
971
1147
av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
973
1149
content_length = reply->content_length;
974
1150
if (content_length > 0) {
975
1151
/* leave some room for a trailing '\0' (useful for simple parsing) */
976
1152
content = av_malloc(content_length + 1);
977
(void)url_read_complete(rt->rtsp_hd, content, content_length);
1153
ffurl_read_complete(rt->rtsp_hd, content, content_length);
978
1154
content[content_length] = '\0';
980
1156
if (content_ptr)
983
1159
av_free(content);
1163
char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1164
const char* ptr = buf;
1166
if (!strcmp(reply->reason, "OPTIONS")) {
1167
snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n");
1169
av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq);
1170
if (reply->session_id[0])
1171
av_strlcatf(buf, sizeof(buf), "Session: %s\r\n",
1174
snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n");
1176
av_strlcat(buf, "\r\n", sizeof(buf));
1178
if (rt->control_transport == RTSP_MODE_TUNNEL) {
1179
av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1182
ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr));
1184
rt->last_cmd_time = av_gettime();
1185
/* Even if the request from the server had data, it is not the data
1186
* that the caller wants or expects. The memory could also be leaked
1187
* if the actual following reply has content data. */
1189
av_freep(content_ptr);
1190
/* If method is set, this is called from ff_rtsp_send_cmd,
1191
* where a reply to exactly this request is awaited. For
1192
* callers from within packet receiving, we just want to
1193
* return to the caller and go back to receiving packets. */
985
1199
if (rt->seq != reply->seq) {
986
1200
av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
987
1201
rt->seq, reply->seq);
1004
void ff_rtsp_send_cmd_with_content_async(AVFormatContext *s,
1005
const char *method, const char *url,
1006
const char *headers,
1007
const unsigned char *send_content,
1008
int send_content_length)
1219
* Send a command to the RTSP server without waiting for the reply.
1221
* @param s RTSP (de)muxer context
1222
* @param method the method for the request
1223
* @param url the target url for the request
1224
* @param headers extra header lines to include in the request
1225
* @param send_content if non-null, the data to send as request body content
1226
* @param send_content_length the length of the send_content data, or 0 if
1227
* send_content is null
1229
* @return zero if success, nonzero otherwise
1231
static int rtsp_send_cmd_with_content_async(AVFormatContext *s,
1232
const char *method, const char *url,
1233
const char *headers,
1234
const unsigned char *send_content,
1235
int send_content_length)
1010
1237
RTSPState *rt = s->priv_data;
1238
char buf[4096], *out_buf;
1239
char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1241
/* Add in RTSP headers */
1014
1244
snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);
1016
1246
av_strlcat(buf, headers, sizeof(buf));
1017
1247
av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);
1248
av_strlcatf(buf, sizeof(buf), "User-Agent: %s\r\n", rt->user_agent);
1018
1249
if (rt->session_id[0] != '\0' && (!headers ||
1019
1250
!strstr(headers, "\nIf-Match:"))) {
1020
1251
av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);
1030
1261
av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
1031
1262
av_strlcat(buf, "\r\n", sizeof(buf));
1033
dprintf(s, "Sending:\n%s--\n", buf);
1035
url_write(rt->rtsp_hd, buf, strlen(buf));
1036
if (send_content_length > 0 && send_content)
1037
url_write(rt->rtsp_hd, send_content, send_content_length);
1264
/* base64 encode rtsp if tunneling */
1265
if (rt->control_transport == RTSP_MODE_TUNNEL) {
1266
av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1267
out_buf = base64buf;
1270
av_dlog(s, "Sending:\n%s--\n", buf);
1272
ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
1273
if (send_content_length > 0 && send_content) {
1274
if (rt->control_transport == RTSP_MODE_TUNNEL) {
1275
av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "
1276
"with content data not supported\n");
1277
return AVERROR_PATCHWELCOME;
1279
ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);
1038
1281
rt->last_cmd_time = av_gettime();
1041
void ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
1042
const char *url, const char *headers)
1044
ff_rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
1047
void ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
1048
const char *headers, RTSPMessageHeader *reply,
1049
unsigned char **content_ptr)
1051
ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
1052
content_ptr, NULL, 0);
1055
void ff_rtsp_send_cmd_with_content(AVFormatContext *s,
1056
const char *method, const char *url,
1058
RTSPMessageHeader *reply,
1059
unsigned char **content_ptr,
1060
const unsigned char *send_content,
1061
int send_content_length)
1286
int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
1287
const char *url, const char *headers)
1289
return rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
1292
int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
1293
const char *headers, RTSPMessageHeader *reply,
1294
unsigned char **content_ptr)
1296
return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
1297
content_ptr, NULL, 0);
1300
int ff_rtsp_send_cmd_with_content(AVFormatContext *s,
1301
const char *method, const char *url,
1303
RTSPMessageHeader *reply,
1304
unsigned char **content_ptr,
1305
const unsigned char *send_content,
1306
int send_content_length)
1063
1308
RTSPState *rt = s->priv_data;
1064
1309
HTTPAuthType cur_auth_type;
1310
int ret, attempts = 0;
1067
1313
cur_auth_type = rt->auth_state.auth_type;
1068
ff_rtsp_send_cmd_with_content_async(s, method, url, header,
1069
send_content, send_content_length);
1071
ff_rtsp_read_reply(s, reply, content_ptr, 0);
1073
if (reply->status_code == 401 && cur_auth_type == HTTP_AUTH_NONE &&
1074
rt->auth_state.auth_type != HTTP_AUTH_NONE)
1314
if ((ret = rtsp_send_cmd_with_content_async(s, method, url, header,
1316
send_content_length)))
1319
if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0)
1323
if (reply->status_code == 401 &&
1324
(cur_auth_type == HTTP_AUTH_NONE || rt->auth_state.stale) &&
1325
rt->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2)
1328
if (reply->status_code > 400){
1329
av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",
1333
av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
1079
* @return 0 on success, <0 on error, 1 if protocol is unavailable.
1081
static int make_setup_request(AVFormatContext *s, const char *host, int port,
1339
int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
1082
1340
int lower_transport, const char *real_challenge)
1084
1342
RTSPState *rt = s->priv_data;
1085
int rtx, j, i, err, interleave = 0;
1343
int rtx = 0, j, i, err, interleave = 0, port_off;
1086
1344
RTSPStream *rtsp_st;
1087
1345
RTSPMessageHeader reply1, *reply = &reply1;
1088
1346
char cmd[2048];
1260
1526
* potential NAT router by sending dummy packets.
1261
1527
* RTP/RTCP dummy packets are used for RDT, too.
1263
if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat)
1264
rtp_send_punch_packets(rtsp_st->rtp_handle);
1529
if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat &&
1531
ff_rtp_send_punch_packets(rtsp_st->rtp_handle);
1267
1534
case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1535
char url[1024], namebuf[50], optbuf[20] = "";
1536
struct sockaddr_storage addr;
1272
if (reply->transports[0].destination) {
1273
in.s_addr = htonl(reply->transports[0].destination);
1539
if (reply->transports[0].destination.ss_family) {
1540
addr = reply->transports[0].destination;
1274
1541
port = reply->transports[0].port_min;
1275
1542
ttl = reply->transports[0].ttl;
1277
in = rtsp_st->sdp_ip;
1544
addr = rtsp_st->sdp_ip;
1278
1545
port = rtsp_st->sdp_port;
1279
1546
ttl = rtsp_st->sdp_ttl;
1281
ff_url_join(url, sizeof(url), "rtp", NULL, inet_ntoa(in),
1282
port, "?ttl=%d", ttl);
1283
if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1549
snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl);
1550
getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1551
namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1552
ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1553
port, "%s", optbuf);
1554
if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
1555
&s->interrupt_callback, NULL) < 0) {
1284
1556
err = AVERROR_INVALIDDATA;
1304
for (i = 0; i < rt->nb_rtsp_streams; i++) {
1305
if (rt->rtsp_streams[i]->rtp_handle) {
1306
url_close(rt->rtsp_streams[i]->rtp_handle);
1307
rt->rtsp_streams[i]->rtp_handle = NULL;
1576
ff_rtsp_undo_setup(s, 0);
1313
static int rtsp_read_play(AVFormatContext *s)
1315
RTSPState *rt = s->priv_data;
1316
RTSPMessageHeader reply1, *reply = &reply1;
1320
av_log(s, AV_LOG_DEBUG, "hello state=%d\n", rt->state);
1322
if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1323
if (rt->state == RTSP_STATE_PAUSED) {
1326
snprintf(cmd, sizeof(cmd),
1327
"Range: npt=%0.3f-\r\n",
1328
(double)rt->seek_timestamp / AV_TIME_BASE);
1330
ff_rtsp_send_cmd(s, "PLAY", rt->control_uri, cmd, reply, NULL);
1331
if (reply->status_code != RTSP_STATUS_OK) {
1334
if (reply->range_start != AV_NOPTS_VALUE &&
1335
rt->transport == RTSP_TRANSPORT_RTP) {
1336
for (i = 0; i < rt->nb_rtsp_streams; i++) {
1337
RTSPStream *rtsp_st = rt->rtsp_streams[i];
1338
RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
1339
AVStream *st = NULL;
1342
if (rtsp_st->stream_index >= 0)
1343
st = s->streams[rtsp_st->stream_index];
1344
rtpctx->last_rtcp_ntp_time = AV_NOPTS_VALUE;
1345
rtpctx->first_rtcp_ntp_time = AV_NOPTS_VALUE;
1347
rtpctx->range_start_offset = av_rescale_q(reply->range_start,
1353
rt->state = RTSP_STATE_STREAMING;
1357
static int rtsp_setup_input_streams(AVFormatContext *s, RTSPMessageHeader *reply)
1359
RTSPState *rt = s->priv_data;
1361
unsigned char *content = NULL;
1364
/* describe the stream */
1365
snprintf(cmd, sizeof(cmd),
1366
"Accept: application/sdp\r\n");
1367
if (rt->server_type == RTSP_SERVER_REAL) {
1369
* The Require: attribute is needed for proper streaming from
1370
* Realmedia servers.
1373
"Require: com.real.retain-entity-for-setup\r\n",
1376
ff_rtsp_send_cmd(s, "DESCRIBE", rt->control_uri, cmd, reply, &content);
1378
return AVERROR_INVALIDDATA;
1379
if (reply->status_code != RTSP_STATUS_OK) {
1381
return AVERROR_INVALIDDATA;
1384
/* now we got the SDP description, we parse it */
1385
ret = sdp_parse(s, (const char *)content);
1388
return AVERROR_INVALIDDATA;
1393
static int rtsp_setup_output_streams(AVFormatContext *s, const char *addr)
1395
RTSPState *rt = s->priv_data;
1396
RTSPMessageHeader reply1, *reply = &reply1;
1399
AVFormatContext sdp_ctx, *ctx_array[1];
1401
rt->start_time = av_gettime();
1403
/* Announce the stream */
1404
sdp = av_mallocz(8192);
1406
return AVERROR(ENOMEM);
1407
/* We create the SDP based on the RTSP AVFormatContext where we
1408
* aren't allowed to change the filename field. (We create the SDP
1409
* based on the RTSP context since the contexts for the RTP streams
1410
* don't exist yet.) In order to specify a custom URL with the actual
1411
* peer IP instead of the originally specified hostname, we create
1412
* a temporary copy of the AVFormatContext, where the custom URL is set.
1414
* FIXME: Create the SDP without copying the AVFormatContext.
1415
* This either requires setting up the RTP stream AVFormatContexts
1416
* already here (complicating things immensely) or getting a more
1417
* flexible SDP creation interface.
1420
ff_url_join(sdp_ctx.filename, sizeof(sdp_ctx.filename),
1421
"rtsp", NULL, addr, -1, NULL);
1422
ctx_array[0] = &sdp_ctx;
1423
if (avf_sdp_create(ctx_array, 1, sdp, 8192)) {
1425
return AVERROR_INVALIDDATA;
1427
av_log(s, AV_LOG_INFO, "SDP:\n%s\n", sdp);
1428
ff_rtsp_send_cmd_with_content(s, "ANNOUNCE", rt->control_uri,
1429
"Content-Type: application/sdp\r\n",
1430
reply, NULL, sdp, strlen(sdp));
1432
if (reply->status_code != RTSP_STATUS_OK)
1433
return AVERROR_INVALIDDATA;
1435
/* Set up the RTSPStreams for each AVStream */
1436
for (i = 0; i < s->nb_streams; i++) {
1437
RTSPStream *rtsp_st;
1438
AVStream *st = s->streams[i];
1440
rtsp_st = av_mallocz(sizeof(RTSPStream));
1442
return AVERROR(ENOMEM);
1443
dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
1445
st->priv_data = rtsp_st;
1446
rtsp_st->stream_index = i;
1448
av_strlcpy(rtsp_st->control_url, rt->control_uri, sizeof(rtsp_st->control_url));
1449
/* Note, this must match the relative uri set in the sdp content */
1450
av_strlcatf(rtsp_st->control_url, sizeof(rtsp_st->control_url),
1580
void ff_rtsp_close_connections(AVFormatContext *s)
1582
RTSPState *rt = s->priv_data;
1583
if (rt->rtsp_hd_out != rt->rtsp_hd) ffurl_close(rt->rtsp_hd_out);
1584
ffurl_close(rt->rtsp_hd);
1585
rt->rtsp_hd = rt->rtsp_hd_out = NULL;
1457
1588
int ff_rtsp_connect(AVFormatContext *s)
1459
1590
RTSPState *rt = s->priv_data;
1460
1591
char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1461
char *option_list, *option, *filename;
1462
URLContext *rtsp_hd;
1463
1592
int port, err, tcp_fd;
1464
RTSPMessageHeader reply1 = {}, *reply = &reply1;
1593
RTSPMessageHeader reply1 = {0}, *reply = &reply1;
1465
1594
int lower_transport_mask = 0;
1466
char real_challenge[64];
1595
char real_challenge[64] = "";
1467
1596
struct sockaddr_storage peer;
1468
1597
socklen_t peer_len = sizeof(peer);
1599
if (rt->rtp_port_max < rt->rtp_port_min) {
1600
av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less "
1601
"than min port %d\n", rt->rtp_port_max,
1603
return AVERROR(EINVAL);
1470
1606
if (!ff_network_init())
1471
1607
return AVERROR(EIO);
1609
if (s->max_delay < 0) /* Not set by the caller */
1610
s->max_delay = s->iformat ? DEFAULT_REORDERING_DELAY : 0;
1612
rt->control_transport = RTSP_MODE_PLAIN;
1613
if (rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTP)) {
1614
rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
1615
rt->control_transport = RTSP_MODE_TUNNEL;
1617
/* Only pass through valid flags from here */
1618
rt->lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1621
lower_transport_mask = rt->lower_transport_mask;
1473
1622
/* extract hostname and port */
1474
ff_url_split(NULL, 0, auth, sizeof(auth),
1623
av_url_split(NULL, 0, auth, sizeof(auth),
1475
1624
host, sizeof(host), &port, path, sizeof(path), s->filename);
1477
1626
av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1532
1649
ff_url_join(rt->control_uri, sizeof(rt->control_uri), "rtsp", NULL,
1533
1650
host, port, "%s", path);
1535
/* open the tcp connexion */
1536
ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port, NULL);
1537
if (url_open(&rtsp_hd, tcpname, URL_RDWR) < 0) {
1652
if (rt->control_transport == RTSP_MODE_TUNNEL) {
1653
/* set up initial handshake for tunneling */
1654
char httpname[1024];
1655
char sessioncookie[17];
1658
ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path);
1659
snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
1660
av_get_random_seed(), av_get_random_seed());
1663
if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ,
1664
&s->interrupt_callback) < 0) {
1669
/* generate GET headers */
1670
snprintf(headers, sizeof(headers),
1671
"x-sessioncookie: %s\r\n"
1672
"Accept: application/x-rtsp-tunnelled\r\n"
1673
"Pragma: no-cache\r\n"
1674
"Cache-Control: no-cache\r\n",
1676
av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0);
1678
/* complete the connection */
1679
if (ffurl_connect(rt->rtsp_hd, NULL)) {
1685
if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE,
1686
&s->interrupt_callback) < 0 ) {
1691
/* generate POST headers */
1692
snprintf(headers, sizeof(headers),
1693
"x-sessioncookie: %s\r\n"
1694
"Content-Type: application/x-rtsp-tunnelled\r\n"
1695
"Pragma: no-cache\r\n"
1696
"Cache-Control: no-cache\r\n"
1697
"Content-Length: 32767\r\n"
1698
"Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1700
av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0);
1701
av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0);
1703
/* Initialize the authentication state for the POST session. The HTTP
1704
* protocol implementation doesn't properly handle multi-pass
1705
* authentication for POST requests, since it would require one of
1707
* - implementing Expect: 100-continue, which many HTTP servers
1708
* don't support anyway, even less the RTSP servers that do HTTP
1710
* - sending the whole POST data until getting a 401 reply specifying
1711
* what authentication method to use, then resending all that data
1712
* - waiting for potential 401 replies directly after sending the
1713
* POST header (waiting for some unspecified time)
1714
* Therefore, we copy the full auth state, which works for both basic
1715
* and digest. (For digest, we would have to synchronize the nonce
1716
* count variable between the two sessions, if we'd do more requests
1717
* with the original session, though.)
1719
ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
1721
/* complete the connection */
1722
if (ffurl_connect(rt->rtsp_hd_out, NULL)) {
1727
/* open the tcp connection */
1728
ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port,
1729
"?timeout=%d", rt->stimeout);
1730
if (ffurl_open(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
1731
&s->interrupt_callback, NULL) < 0) {
1735
rt->rtsp_hd_out = rt->rtsp_hd;
1541
rt->rtsp_hd = rtsp_hd;
1544
tcp_fd = url_get_file_handle(rtsp_hd);
1739
tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1545
1740
if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1546
1741
getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1547
1742
NULL, 0, NI_NUMERICHOST);
1623
1824
ff_network_close();
1628
#if CONFIG_RTSP_DEMUXER
1629
static int rtsp_read_header(AVFormatContext *s,
1630
AVFormatParameters *ap)
1632
RTSPState *rt = s->priv_data;
1635
ret = ff_rtsp_connect(s);
1639
if (ap->initial_pause) {
1640
/* do not start immediately */
1642
if (rtsp_read_play(s) < 0) {
1643
ff_rtsp_close_streams(s);
1644
url_close(rt->rtsp_hd);
1645
return AVERROR_INVALIDDATA;
1827
#endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
1652
1830
static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1653
uint8_t *buf, int buf_size)
1831
uint8_t *buf, int buf_size, int64_t wait_end)
1655
1833
RTSPState *rt = s->priv_data;
1656
1834
RTSPStream *rtsp_st;
1658
int fd, fd_max, n, i, ret, tcp_fd, timeout_cnt = 0;
1835
int n, i, ret, tcp_fd, timeout_cnt = 0;
1837
struct pollfd *p = rt->p;
1838
int *fds = NULL, fdsnum, fdsidx;
1662
if (url_interrupt_cb())
1663
return AVERROR(EINTR);
1841
if (ff_check_interrupt(&s->interrupt_callback))
1842
return AVERROR_EXIT;
1843
if (wait_end && wait_end - av_gettime() < 0)
1844
return AVERROR(EAGAIN);
1665
1846
if (rt->rtsp_hd) {
1666
tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd);
1667
FD_SET(tcp_fd, &rfds);
1847
tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1848
p[max_p].fd = tcp_fd;
1849
p[max_p++].events = POLLIN;
1672
1853
for (i = 0; i < rt->nb_rtsp_streams; i++) {
1673
1854
rtsp_st = rt->rtsp_streams[i];
1674
1855
if (rtsp_st->rtp_handle) {
1675
/* currently, we cannot probe RTCP handle because of
1676
* blocking restrictions */
1677
fd = url_get_file_handle(rtsp_st->rtp_handle);
1856
if (ret = ffurl_get_multi_file_handle(rtsp_st->rtp_handle,
1858
av_log(s, AV_LOG_ERROR, "Unable to recover rtp ports\n");
1862
av_log(s, AV_LOG_ERROR,
1863
"Number of fds %d not supported\n", fdsnum);
1864
return AVERROR_INVALIDDATA;
1866
for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
1867
p[max_p].fd = fds[fdsidx];
1868
p[max_p++].events = POLLIN;
1684
tv.tv_usec = SELECT_TIMEOUT_MS * 1000;
1685
n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
1873
n = poll(p, max_p, POLL_TIMEOUT_MS);
1875
int j = 1 - (tcp_fd == -1);
1687
1876
timeout_cnt = 0;
1688
1877
for (i = 0; i < rt->nb_rtsp_streams; i++) {
1689
1878
rtsp_st = rt->rtsp_streams[i];
1690
1879
if (rtsp_st->rtp_handle) {
1691
fd = url_get_file_handle(rtsp_st->rtp_handle);
1692
if (FD_ISSET(fd, &rfds)) {
1693
ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
1880
if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
1881
ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size);
1695
1883
*prtsp_st = rtsp_st;
1701
1890
#if CONFIG_RTSP_DEMUXER
1702
if (tcp_fd != -1 && FD_ISSET(tcp_fd, &rfds)) {
1703
RTSPMessageHeader reply;
1705
ret = ff_rtsp_read_reply(s, &reply, NULL, 0);
1708
/* XXX: parse message */
1709
if (rt->state != RTSP_STATE_STREAMING)
1891
if (tcp_fd != -1 && p[0].revents & POLLIN) {
1892
if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
1893
if (rt->state == RTSP_STATE_STREAMING) {
1894
if (!ff_rtsp_parse_streaming_commands(s))
1897
av_log(s, AV_LOG_WARNING,
1898
"Unable to answer to TEARDOWN\n");
1902
RTSPMessageHeader reply;
1903
ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
1906
/* XXX: parse message */
1907
if (rt->state != RTSP_STATE_STREAMING)
1713
1912
} else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
1714
return FF_NETERROR(ETIMEDOUT);
1913
return AVERROR(ETIMEDOUT);
1715
1914
} else if (n < 0 && errno != EINTR)
1716
1915
return AVERROR(errno);
1720
static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1721
uint8_t *buf, int buf_size)
1919
static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st,
1920
const uint8_t *buf, int len)
1723
1922
RTSPState *rt = s->priv_data;
1724
int id, len, i, ret;
1725
RTSPStream *rtsp_st;
1727
#ifdef DEBUG_RTP_TCP
1728
dprintf(s, "tcp_read_packet:\n");
1732
RTSPMessageHeader reply;
1734
ret = ff_rtsp_read_reply(s, &reply, NULL, 1);
1737
if (ret == 1) /* received '$' */
1739
/* XXX: parse message */
1740
if (rt->state != RTSP_STATE_STREAMING)
1743
ret = url_read_complete(rt->rtsp_hd, buf, 3);
1747
len = AV_RB16(buf + 1);
1748
#ifdef DEBUG_RTP_TCP
1749
dprintf(s, "id=%d len=%d\n", id, len);
1751
if (len > buf_size || len < 12)
1754
ret = url_read_complete(rt->rtsp_hd, buf, len);
1757
if (rt->transport == RTSP_TRANSPORT_RDT &&
1758
ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
1761
/* find the matching stream */
1762
for (i = 0; i < rt->nb_rtsp_streams; i++) {
1763
rtsp_st = rt->rtsp_streams[i];
1764
if (id >= rtsp_st->interleaved_min &&
1765
id <= rtsp_st->interleaved_max)
1770
*prtsp_st = rtsp_st;
1926
if (rt->nb_rtsp_streams == 1) {
1927
*rtsp_st = rt->rtsp_streams[0];
1930
if (len >= 8 && rt->transport == RTSP_TRANSPORT_RTP) {
1931
if (RTP_PT_IS_RTCP(rt->recvbuf[1])) {
1933
for (i = 0; i < rt->nb_rtsp_streams; i++) {
1934
RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
1937
if (rtpctx->ssrc == AV_RB32(&buf[4])) {
1938
*rtsp_st = rt->rtsp_streams[i];
1945
av_log(s, AV_LOG_WARNING,
1946
"Unable to pick stream for packet - SSRC not known for "
1948
return AVERROR(EAGAIN);
1951
for (i = 0; i < rt->nb_rtsp_streams; i++) {
1952
if ((buf[1] & 0x7f) == rt->rtsp_streams[i]->sdp_payload_type) {
1953
*rtsp_st = rt->rtsp_streams[i];
1959
av_log(s, AV_LOG_WARNING, "Unable to pick stream for packet\n");
1960
return AVERROR(EAGAIN);
1774
static int rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
1963
int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
1776
1965
RTSPState *rt = s->priv_data;
1778
uint8_t buf[10 * RTP_MAX_PACKET_LENGTH];
1779
RTSPStream *rtsp_st;
1967
RTSPStream *rtsp_st, *first_queue_st = NULL;
1968
int64_t wait_end = 0;
1970
if (rt->nb_byes == rt->nb_rtsp_streams)
1781
1973
/* get next frames from the same RTP packet */
1782
1974
if (rt->cur_transport_priv) {
1783
1975
if (rt->transport == RTSP_TRANSPORT_RDT) {
1784
1976
ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1977
} else if (rt->transport == RTSP_TRANSPORT_RTP) {
1978
ret = ff_rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1979
} else if (rt->ts && CONFIG_RTPDEC) {
1980
ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf + rt->recvbuf_pos, rt->recvbuf_len - rt->recvbuf_pos);
1982
rt->recvbuf_pos += ret;
1983
ret = rt->recvbuf_pos < rt->recvbuf_len;
1786
ret = rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1787
1987
if (ret == 0) {
1788
1988
rt->cur_transport_priv = NULL;
1793
1993
rt->cur_transport_priv = NULL;
1997
if (rt->transport == RTSP_TRANSPORT_RTP) {
1999
int64_t first_queue_time = 0;
2000
for (i = 0; i < rt->nb_rtsp_streams; i++) {
2001
RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2005
queue_time = ff_rtp_queued_packet_time(rtpctx);
2006
if (queue_time && (queue_time - first_queue_time < 0 ||
2007
!first_queue_time)) {
2008
first_queue_time = queue_time;
2009
first_queue_st = rt->rtsp_streams[i];
2012
if (first_queue_time) {
2013
wait_end = first_queue_time + s->max_delay;
2016
first_queue_st = NULL;
1796
2020
/* read next RTP packet */
2022
rt->recvbuf = av_malloc(RECVBUF_SIZE);
2024
return AVERROR(ENOMEM);
1798
2027
switch(rt->lower_transport) {
1800
2029
#if CONFIG_RTSP_DEMUXER
1801
2030
case RTSP_LOWER_TRANSPORT_TCP:
1802
len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf));
2031
len = ff_rtsp_tcp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE);
1805
2034
case RTSP_LOWER_TRANSPORT_UDP:
1806
2035
case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1807
len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1808
if (len >=0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
1809
rtp_check_and_send_back_rr(rtsp_st->transport_priv, len);
2036
len = udp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
2037
if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2038
ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, rtsp_st->rtp_handle, NULL, len);
2040
case RTSP_LOWER_TRANSPORT_CUSTOM:
2041
if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&
2042
wait_end && wait_end < av_gettime())
2043
len = AVERROR(EAGAIN);
2045
len = ffio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE);
2046
len = pick_stream(s, &rtsp_st, rt->recvbuf, len);
2047
if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2048
ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, NULL, s->pb, len);
2051
if (len == AVERROR(EAGAIN) && first_queue_st &&
2052
rt->transport == RTSP_TRANSPORT_RTP) {
2053
rtsp_st = first_queue_st;
2054
ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0);
1815
2060
return AVERROR_EOF;
1816
2061
if (rt->transport == RTSP_TRANSPORT_RDT) {
1817
ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1819
ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
2062
ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2063
} else if (rt->transport == RTSP_TRANSPORT_RTP) {
2064
ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2065
if (rtsp_st->feedback) {
2066
AVIOContext *pb = NULL;
2067
if (rt->lower_transport == RTSP_LOWER_TRANSPORT_CUSTOM)
2069
ff_rtp_send_rtcp_feedback(rtsp_st->transport_priv, rtsp_st->rtp_handle, pb);
1821
2072
/* Either bad packet, or a RTCP packet. Check if the
1822
2073
* first_rtcp_ntp_time field was initialized. */
1827
2078
* in order to map their timestamp origin to the same ntp time
1828
2079
* as this one. */
2081
AVStream *st = NULL;
2082
if (rtsp_st->stream_index >= 0)
2083
st = s->streams[rtsp_st->stream_index];
1830
2084
for (i = 0; i < rt->nb_rtsp_streams; i++) {
1831
RTPDemuxContext *rtpctx2 = rtsp_st->transport_priv;
1833
rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE)
2085
RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
2086
AVStream *st2 = NULL;
2087
if (rt->rtsp_streams[i]->stream_index >= 0)
2088
st2 = s->streams[rt->rtsp_streams[i]->stream_index];
2089
if (rtpctx2 && st && st2 &&
2090
rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
1834
2091
rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
2092
rtpctx2->rtcp_ts_offset = av_rescale_q(
2093
rtpctx->rtcp_ts_offset, st->time_base,
2097
// Make real NTP start time available in AVFormatContext
2098
if (s->start_time_realtime == AV_NOPTS_VALUE) {
2099
s->start_time_realtime = av_rescale (rtpctx->first_rtcp_ntp_time - (NTP_OFFSET << 32), 1000000, 1LL << 32);
2101
s->start_time_realtime -=
2102
av_rescale (rtpctx->rtcp_ts_offset,
2103
(uint64_t) rtpctx->st->time_base.num * 1000000,
2104
rtpctx->st->time_base.den);
2108
if (ret == -RTCP_BYE) {
2111
av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
2112
rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
2114
if (rt->nb_byes == rt->nb_rtsp_streams)
2118
} else if (rt->ts && CONFIG_RTPDEC) {
2119
ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf, len);
2122
rt->recvbuf_len = len;
2123
rt->recvbuf_pos = ret;
2124
rt->cur_transport_priv = rt->ts;
2131
return AVERROR_INVALIDDATA;
1848
static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt)
1850
RTSPState *rt = s->priv_data;
1852
RTSPMessageHeader reply1, *reply = &reply1;
1855
if (rt->server_type == RTSP_SERVER_REAL) {
1857
enum AVDiscard cache[MAX_STREAMS];
1859
for (i = 0; i < s->nb_streams; i++)
1860
cache[i] = s->streams[i]->discard;
1862
if (!rt->need_subscription) {
1863
if (memcmp (cache, rt->real_setup_cache,
1864
sizeof(enum AVDiscard) * s->nb_streams)) {
1865
snprintf(cmd, sizeof(cmd),
1866
"Unsubscribe: %s\r\n",
1867
rt->last_subscription);
1868
ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
1870
if (reply->status_code != RTSP_STATUS_OK)
1871
return AVERROR_INVALIDDATA;
1872
rt->need_subscription = 1;
1876
if (rt->need_subscription) {
1877
int r, rule_nr, first = 1;
1879
memcpy(rt->real_setup_cache, cache,
1880
sizeof(enum AVDiscard) * s->nb_streams);
1881
rt->last_subscription[0] = 0;
1883
snprintf(cmd, sizeof(cmd),
1885
for (i = 0; i < rt->nb_rtsp_streams; i++) {
1887
for (r = 0; r < s->nb_streams; r++) {
1888
if (s->streams[r]->priv_data == rt->rtsp_streams[i]) {
1889
if (s->streams[r]->discard != AVDISCARD_ALL) {
1891
av_strlcat(rt->last_subscription, ",",
1892
sizeof(rt->last_subscription));
1893
ff_rdt_subscribe_rule(
1894
rt->last_subscription,
1895
sizeof(rt->last_subscription), i, rule_nr);
1902
av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
1903
ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
1905
if (reply->status_code != RTSP_STATUS_OK)
1906
return AVERROR_INVALIDDATA;
1907
rt->need_subscription = 0;
1909
if (rt->state == RTSP_STATE_STREAMING)
1914
ret = rtsp_fetch_packet(s, pkt);
1918
/* send dummy request to keep TCP connection alive */
1919
if ((rt->server_type == RTSP_SERVER_WMS ||
1920
rt->server_type == RTSP_SERVER_REAL) &&
1921
(av_gettime() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2) {
1922
if (rt->server_type == RTSP_SERVER_WMS) {
1923
ff_rtsp_send_cmd_async(s, "GET_PARAMETER", rt->control_uri, NULL);
1925
ff_rtsp_send_cmd_async(s, "OPTIONS", "*", NULL);
1932
/* pause the stream */
1933
static int rtsp_read_pause(AVFormatContext *s)
1935
RTSPState *rt = s->priv_data;
1936
RTSPMessageHeader reply1, *reply = &reply1;
1938
if (rt->state != RTSP_STATE_STREAMING)
1940
else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1941
ff_rtsp_send_cmd(s, "PAUSE", rt->control_uri, NULL, reply, NULL);
1942
if (reply->status_code != RTSP_STATUS_OK) {
1946
rt->state = RTSP_STATE_PAUSED;
1950
static int rtsp_read_seek(AVFormatContext *s, int stream_index,
1951
int64_t timestamp, int flags)
1953
RTSPState *rt = s->priv_data;
1955
rt->seek_timestamp = av_rescale_q(timestamp,
1956
s->streams[stream_index]->time_base,
1960
case RTSP_STATE_IDLE:
1962
case RTSP_STATE_STREAMING:
1963
if (rtsp_read_pause(s) != 0)
1965
rt->state = RTSP_STATE_SEEKING;
1966
if (rtsp_read_play(s) != 0)
1969
case RTSP_STATE_PAUSED:
1970
rt->state = RTSP_STATE_IDLE;
1976
static int rtsp_read_close(AVFormatContext *s)
1978
RTSPState *rt = s->priv_data;
1981
/* NOTE: it is valid to flush the buffer here */
1982
if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1983
url_fclose(&rt->rtsp_gb);
1986
ff_rtsp_send_cmd_async(s, "TEARDOWN", rt->control_uri, NULL);
1988
ff_rtsp_close_streams(s);
1989
url_close(rt->rtsp_hd);
1994
AVInputFormat rtsp_demuxer = {
1996
NULL_IF_CONFIG_SMALL("RTSP input format"),
2003
.flags = AVFMT_NOFILE,
2004
.read_play = rtsp_read_play,
2005
.read_pause = rtsp_read_pause,
2142
#endif /* CONFIG_RTPDEC */
2144
#if CONFIG_SDP_DEMUXER
2009
2145
static int sdp_probe(AVProbeData *p1)
2011
2147
const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
2013
/* we look for a line beginning "c=IN IP4" */
2149
/* we look for a line beginning "c=IN IP" */
2014
2150
while (p < p_end && *p != '\0') {
2015
if (p + sizeof("c=IN IP4") - 1 < p_end &&
2016
av_strstart(p, "c=IN IP4", NULL))
2017
return AVPROBE_SCORE_MAX / 2;
2151
if (p + sizeof("c=IN IP") - 1 < p_end &&
2152
av_strstart(p, "c=IN IP", NULL))
2153
return AVPROBE_SCORE_EXTENSION;
2019
2155
while (p < p_end - 1 && *p != '\n') p++;
2020
2156
if (++p >= p_end)
2038
2183
if (!ff_network_init())
2039
2184
return AVERROR(EIO);
2186
if (s->max_delay < 0) /* Not set by the caller */
2187
s->max_delay = DEFAULT_REORDERING_DELAY;
2188
if (rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)
2189
rt->lower_transport = RTSP_LOWER_TRANSPORT_CUSTOM;
2041
2191
/* read the whole sdp file */
2042
2192
/* XXX: better loading */
2043
2193
content = av_malloc(SDP_MAX_SIZE);
2044
size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
2194
size = avio_read(s->pb, content, SDP_MAX_SIZE - 1);
2045
2195
if (size <= 0) {
2046
2196
av_free(content);
2047
2197
return AVERROR_INVALIDDATA;
2049
2199
content[size] ='\0';
2051
sdp_parse(s, content);
2201
err = ff_sdp_parse(s, content);
2052
2202
av_free(content);
2054
2205
/* open each RTP stream */
2055
2206
for (i = 0; i < rt->nb_rtsp_streams; i++) {
2056
2208
rtsp_st = rt->rtsp_streams[i];
2058
ff_url_join(url, sizeof(url), "rtp", NULL,
2059
inet_ntoa(rtsp_st->sdp_ip), rtsp_st->sdp_port,
2060
"?localport=%d&ttl=%d", rtsp_st->sdp_port,
2062
if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
2063
err = AVERROR_INVALIDDATA;
2210
if (!(rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)) {
2211
getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip),
2212
namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
2213
ff_url_join(url, sizeof(url), "rtp", NULL,
2214
namebuf, rtsp_st->sdp_port,
2215
"?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2216
rtsp_st->sdp_port, rtsp_st->sdp_ttl,
2217
rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0,
2218
rt->rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0);
2220
append_source_addrs(url, sizeof(url), "sources",
2221
rtsp_st->nb_include_source_addrs,
2222
rtsp_st->include_source_addrs);
2223
append_source_addrs(url, sizeof(url), "block",
2224
rtsp_st->nb_exclude_source_addrs,
2225
rtsp_st->exclude_source_addrs);
2226
if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
2227
&s->interrupt_callback, NULL) < 0) {
2228
err = AVERROR_INVALIDDATA;
2066
if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
2232
if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
2083
AVInputFormat sdp_demuxer = {
2085
NULL_IF_CONFIG_SMALL("SDP"),
2249
static const AVClass sdp_demuxer_class = {
2250
.class_name = "SDP demuxer",
2251
.item_name = av_default_item_name,
2252
.option = sdp_options,
2253
.version = LIBAVUTIL_VERSION_INT,
2256
AVInputFormat ff_sdp_demuxer = {
2258
.long_name = NULL_IF_CONFIG_SMALL("SDP"),
2259
.priv_data_size = sizeof(RTSPState),
2260
.read_probe = sdp_probe,
2261
.read_header = sdp_read_header,
2262
.read_packet = ff_rtsp_fetch_packet,
2263
.read_close = sdp_read_close,
2264
.priv_class = &sdp_demuxer_class,
2266
#endif /* CONFIG_SDP_DEMUXER */
2268
#if CONFIG_RTP_DEMUXER
2269
static int rtp_probe(AVProbeData *p)
2271
if (av_strstart(p->filename, "rtp:", NULL))
2272
return AVPROBE_SCORE_MAX;
2276
static int rtp_read_header(AVFormatContext *s)
2278
uint8_t recvbuf[RTP_MAX_PACKET_LENGTH];
2279
char host[500], sdp[500];
2281
URLContext* in = NULL;
2283
AVCodecContext codec = { 0 };
2284
struct sockaddr_storage addr;
2286
socklen_t addrlen = sizeof(addr);
2287
RTSPState *rt = s->priv_data;
2289
if (!ff_network_init())
2290
return AVERROR(EIO);
2292
ret = ffurl_open(&in, s->filename, AVIO_FLAG_READ,
2293
&s->interrupt_callback, NULL);
2298
ret = ffurl_read(in, recvbuf, sizeof(recvbuf));
2299
if (ret == AVERROR(EAGAIN))
2304
av_log(s, AV_LOG_WARNING, "Received too short packet\n");
2308
if ((recvbuf[0] & 0xc0) != 0x80) {
2309
av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet "
2314
if (RTP_PT_IS_RTCP(recvbuf[1]))
2317
payload_type = recvbuf[1] & 0x7f;
2320
getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen);
2324
if (ff_rtp_get_codec_info(&codec, payload_type)) {
2325
av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d "
2326
"without an SDP file describing it\n",
2330
if (codec.codec_type != AVMEDIA_TYPE_DATA) {
2331
av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received "
2332
"properly you need an SDP file "
2336
av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port,
2337
NULL, 0, s->filename);
2339
snprintf(sdp, sizeof(sdp),
2340
"v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",
2341
addr.ss_family == AF_INET ? 4 : 6, host,
2342
codec.codec_type == AVMEDIA_TYPE_DATA ? "application" :
2343
codec.codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio",
2344
port, payload_type);
2345
av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp);
2347
ffio_init_context(&pb, sdp, strlen(sdp), 0, NULL, NULL, NULL, NULL);
2350
/* sdp_read_header initializes this again */
2353
rt->media_type_mask = (1 << (AVMEDIA_TYPE_DATA+1)) - 1;
2355
ret = sdp_read_header(s);
2366
static const AVClass rtp_demuxer_class = {
2367
.class_name = "RTP demuxer",
2368
.item_name = av_default_item_name,
2369
.option = rtp_options,
2370
.version = LIBAVUTIL_VERSION_INT,
2373
AVInputFormat ff_rtp_demuxer = {
2375
.long_name = NULL_IF_CONFIG_SMALL("RTP input"),
2376
.priv_data_size = sizeof(RTSPState),
2377
.read_probe = rtp_probe,
2378
.read_header = rtp_read_header,
2379
.read_packet = ff_rtsp_fetch_packet,
2380
.read_close = sdp_read_close,
2381
.flags = AVFMT_NOFILE,
2382
.priv_class = &rtp_demuxer_class,
2384
#endif /* CONFIG_RTP_DEMUXER */
added
removed
libavformat/rtsp.c
