55 #define READ_PACKET_TIMEOUT_S 10
56 #define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH
57 #define DEFAULT_REORDERING_DELAY 100000
59 #define OFFSET(x) offsetof(RTSPState, x)
60 #define DEC AV_OPT_FLAG_DECODING_PARAM
61 #define ENC AV_OPT_FLAG_ENCODING_PARAM
63 #define RTSP_FLAG_OPTS(name, longname) \
64 { name, longname, OFFSET(rtsp_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtsp_flags" }, \
65 { "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" }
67 #define RTSP_MEDIATYPE_OPTS(name, longname) \
68 { name, longname, OFFSET(media_type_mask), AV_OPT_TYPE_FLAGS, { .i64 = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1 }, INT_MIN, INT_MAX, DEC, "allowed_media_types" }, \
69 { "video", "Video", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_VIDEO}, 0, 0, DEC, "allowed_media_types" }, \
70 { "audio", "Audio", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_AUDIO}, 0, 0, DEC, "allowed_media_types" }, \
71 { "data", "Data", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_DATA}, 0, 0, DEC, "allowed_media_types" }, \
72 { "subtitle", "Subtitle", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_SUBTITLE}, 0, 0, DEC, "allowed_media_types" }
74 #define COMMON_OPTS() \
75 { "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 }, \
76 { "buffer_size", "Underlying protocol send/receive buffer size", OFFSET(buffer_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC|ENC }, \
77 { "pkt_size", "Underlying protocol send packet size", OFFSET(pkt_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, ENC } \
81 {
"initial_pause",
"do not start playing the stream immediately",
OFFSET(initial_pause),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
DEC },
83 {
"rtsp_transport",
"set RTSP transport protocols",
OFFSET(lower_transport_mask),
AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX,
DEC|
ENC,
"rtsp_transport" }, \
91 {
"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" },
96 {
"listen_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 },
97 #if FF_API_OLD_RTSP_OPTIONS
98 {
"timeout",
"set maximum timeout (in seconds) to wait for incoming connections (-1 is infinite, imply flag listen) (deprecated, use listen_timeout)",
OFFSET(initial_timeout),
AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX,
DEC|
AV_OPT_FLAG_DEPRECATED },
99 {
"stimeout",
"set timeout (in microseconds) of socket TCP I/O operations",
OFFSET(stimeout),
AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX,
DEC },
101 {
"timeout",
"set timeout (in microseconds) of socket TCP I/O operations",
OFFSET(stimeout),
AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX,
DEC },
105 #if FF_API_OLD_RTSP_OPTIONS
144 const char *sep,
const char **pp)
152 while (!strchr(sep, *p) && *p !=
'\0') {
153 if ((q - buf) < buf_size - 1)
165 if (**pp ==
'/') (*pp)++;
169 static void get_word(
char *buf,
int buf_size,
const char **pp)
213 memcpy(sock, ai->ai_addr,
FFMIN(
sizeof(*sock), ai->ai_addrlen));
280 finalize_rtp_handler_init(
s, rtsp_st,
NULL);
288 int payload_type,
const char *p)
310 init_rtp_handler(
handler, rtsp_st, st);
353 finalize_rtp_handler_init(
s, rtsp_st, st);
361 char *
value,
int value_size)
376 typedef struct SDPParseState {
381 int nb_default_include_source_addrs;
382 struct RTSPSource **default_include_source_addrs;
383 int nb_default_exclude_source_addrs;
384 struct RTSPSource **default_exclude_source_addrs;
387 char delayed_fmtp[2048];
390 static void copy_default_source_addrs(
struct RTSPSource **addrs,
int count,
395 for (
i = 0;
i < count;
i++) {
397 rtsp_src2 =
av_malloc(
sizeof(*rtsp_src2));
400 memcpy(rtsp_src2, rtsp_src,
sizeof(*rtsp_src));
406 int payload_type,
const char *
line)
422 int letter,
const char *buf)
425 char buf1[64], st_type[64];
438 if (
s1->skip_media && letter !=
'm')
443 if (strcmp(buf1,
"IN") != 0)
446 if (strcmp(buf1,
"IP4") && strcmp(buf1,
"IP6"))
457 if (
s->nb_streams == 0) {
458 s1->default_ip = sdp_ip;
459 s1->default_ttl = ttl;
470 if (
s->nb_streams == 0) {
481 get_word(st_type,
sizeof(st_type), &p);
482 if (!strcmp(st_type,
"audio")) {
484 }
else if (!strcmp(st_type,
"video")) {
486 }
else if (!strcmp(st_type,
"application")) {
488 }
else if (!strcmp(st_type,
"text")) {
507 copy_default_source_addrs(
s1->default_include_source_addrs,
508 s1->nb_default_include_source_addrs,
511 copy_default_source_addrs(
s1->default_exclude_source_addrs,
512 s1->nb_default_exclude_source_addrs,
520 if (!strcmp(buf1,
"udp"))
522 else if (strstr(buf1,
"/AVPF") || strstr(buf1,
"/SAVPF"))
539 finalize_rtp_handler_init(
s, rtsp_st,
NULL);
562 init_rtp_handler(
handler, rtsp_st, st);
563 finalize_rtp_handler_init(
s, rtsp_st, st);
575 if (!strncmp(p,
"rtsp://", 7))
586 if (proto[0] ==
'\0') {
597 }
else if (
av_strstart(p,
"rtpmap:", &p) &&
s->nb_streams > 0) {
600 payload_type = atoi(buf1);
604 sdp_parse_rtpmap(
s, st, rtsp_st, payload_type, p);
614 payload_type = atoi(buf1);
615 if (
s1->seen_rtpmap) {
621 }
else if (
av_strstart(p,
"ssrc:", &p) &&
s->nb_streams > 0) {
624 rtsp_st->
ssrc = strtoll(buf1,
NULL, 10);
630 s->start_time = start;
635 if (
s->nb_streams > 0) {
644 }
else if (
av_strstart(p,
"IsRealDataType:integer;",&p)) {
647 }
else if (
av_strstart(p,
"SampleRate:integer;", &p) &&
649 st =
s->streams[
s->nb_streams - 1];
651 }
else if (
av_strstart(p,
"crypto:", &p) &&
s->nb_streams > 0) {
662 if (strcmp(buf1,
"incl") && strcmp(buf1,
"excl"))
664 exclude = !strcmp(buf1,
"excl");
667 if (strcmp(buf1,
"IN") != 0)
670 if (strcmp(buf1,
"IP4") && strcmp(buf1,
"IP6") && strcmp(buf1,
"*"))
681 if (
s->nb_streams == 0) {
682 dynarray_add(&
s1->default_exclude_source_addrs, &
s1->nb_default_exclude_source_addrs, rtsp_src);
688 if (
s->nb_streams == 0) {
689 dynarray_add(&
s1->default_include_source_addrs, &
s1->nb_default_include_source_addrs, rtsp_src);
699 if (
s->nb_streams > 0) {
721 SDPParseState sdp_parse_state = { { 0 } }, *
s1 = &sdp_parse_state;
735 while (*p !=
'\n' && *p !=
'\r' && *p !=
'\0') {
736 if ((q - buf) <
sizeof(buf) - 1)
741 sdp_parse_line(
s,
s1, letter, buf);
743 while (*p !=
'\n' && *p !=
'\0')
749 for (
i = 0;
i <
s1->nb_default_include_source_addrs;
i++)
752 for (
i = 0;
i <
s1->nb_default_exclude_source_addrs;
i++)
833 if (reordering_queue_size < 0) {
835 reordering_queue_size = 0;
865 reordering_queue_size);
887 #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
888 static void rtsp_parse_range(
int *min_ptr,
int *max_ptr,
const char **pp)
896 v = strtol(q, &p, 10);
900 v = strtol(p, &p, 10);
913 char transport_protocol[16];
915 char lower_transport[16];
929 get_word_sep(transport_protocol,
sizeof(transport_protocol),
933 lower_transport[0] =
'\0';
940 }
else if (!
av_strcasecmp (transport_protocol,
"x-pn-tng") ||
943 get_word_sep(lower_transport,
sizeof(lower_transport),
"/;,", &p);
948 lower_transport[0] =
'\0';
966 while (*p !=
'\0' && *p !=
',') {
968 if (!strcmp(parameter,
"port")) {
971 rtsp_parse_range(&
th->port_min, &
th->port_max, &p);
973 }
else if (!strcmp(parameter,
"client_port")) {
976 rtsp_parse_range(&
th->client_port_min,
977 &
th->client_port_max, &p);
979 }
else if (!strcmp(parameter,
"server_port")) {
982 rtsp_parse_range(&
th->server_port_min,
983 &
th->server_port_max, &p);
985 }
else if (!strcmp(parameter,
"interleaved")) {
988 rtsp_parse_range(&
th->interleaved_min,
989 &
th->interleaved_max, &p);
991 }
else if (!strcmp(parameter,
"multicast")) {
994 }
else if (!strcmp(parameter,
"ttl")) {
998 th->ttl = strtol(p, &end, 10);
1001 }
else if (!strcmp(parameter,
"destination")) {
1007 }
else if (!strcmp(parameter,
"source")) {
1013 }
else if (!strcmp(parameter,
"mode")) {
1017 if (!strcmp(buf,
"record") ||
1018 !strcmp(buf,
"receive"))
1019 th->mode_record = 1;
1023 while (*p !=
';' && *p !=
'\0' && *p !=
',')
1037 static void handle_rtp_info(
RTSPState *rt,
const char *url,
1038 uint32_t seq, uint32_t rtptime)
1041 if (!rtptime || !url[0])
1057 static void rtsp_parse_rtp_info(
RTSPState *rt,
const char *p)
1061 uint32_t seq = 0, rtptime = 0;
1073 if (!strcmp(
key,
"url"))
1075 else if (!strcmp(
key,
"seq"))
1077 else if (!strcmp(
key,
"rtptime"))
1080 handle_rtp_info(rt, url, seq, rtptime);
1089 handle_rtp_info(rt, url, seq, rtptime);
1104 (t = strtol(p,
NULL, 10)) > 0) {
1110 rtsp_parse_transport(
s, reply, p);
1112 reply->
seq = strtol(p,
NULL, 10);
1127 }
else if (
av_stristart(p,
"WWW-Authenticate:", &p) && rt) {
1130 }
else if (
av_stristart(p,
"Authentication-Info:", &p) && rt) {
1133 }
else if (
av_stristart(p,
"Content-Base:", &p) && rt) {
1135 if (method && !strcmp(method,
"DESCRIBE"))
1139 if (method && !strcmp(method,
"PLAY"))
1140 rtsp_parse_rtp_info(rt, p);
1142 if (strstr(p,
"GET_PARAMETER") &&
1143 method && !strcmp(method,
"OPTIONS"))
1145 }
else if (
av_stristart(p,
"x-Accept-Dynamic-Rate:", &p) && rt) {
1174 if (len1 >
sizeof(buf))
1184 unsigned char **content_ptr,
1185 int return_on_interleaved_data,
const char *method)
1191 int ret, content_length, line_count = 0, request = 0;
1192 unsigned char *content =
NULL;
1198 memset(reply, 0,
sizeof(*reply));
1211 if (ch ==
'$' && q == buf) {
1212 if (return_on_interleaved_data) {
1216 }
else if (ch !=
'\r') {
1217 if ((q - buf) <
sizeof(buf) - 1)
1229 if (line_count == 0) {
1232 if (!strncmp(buf1,
"RTSP/", 5)) {
1253 if (content_length > 0) {
1255 content =
av_malloc(content_length + 1);
1260 content[content_length] =
'\0';
1263 *content_ptr = content;
1270 const char* ptr = buf;
1272 if (!strcmp(reply->
reason,
"OPTIONS")) {
1273 snprintf(buf,
sizeof(buf),
"RTSP/1.0 200 OK\r\n");
1280 snprintf(buf,
sizeof(buf),
"RTSP/1.0 501 Not Implemented\r\n");
1305 if (rt->
seq != reply->
seq) {
1311 if (reply->
notice == 2101 ||
1313 reply->
notice == 2306 ) {
1315 }
else if (reply->
notice >= 4400 && reply->
notice < 5500) {
1317 }
else if (reply->
notice == 2401 ||
1338 const char *method,
const char *url,
1339 const char *headers,
1340 const unsigned char *send_content,
1341 int send_content_length)
1353 snprintf(buf,
sizeof(buf),
"%s %s RTSP/1.0\r\n", method, url);
1358 if (rt->
session_id[0] !=
'\0' && (!headers ||
1359 !strstr(headers,
"\nIf-Match:"))) {
1364 rt->
auth, url, method);
1369 if (send_content_length > 0 && send_content)
1370 av_strlcatf(buf,
sizeof(buf),
"Content-Length: %d\r\n", send_content_length);
1376 out_buf = base64buf;
1382 if (send_content_length > 0 && send_content) {
1395 const char *url,
const char *headers)
1397 return rtsp_send_cmd_with_content_async(
s, method, url, headers,
NULL, 0);
1402 unsigned char **content_ptr)
1405 content_ptr,
NULL, 0);
1409 const char *method,
const char *url,
1412 unsigned char **content_ptr,
1413 const unsigned char *send_content,
1414 int send_content_length)
1418 int ret, attempts = 0;
1422 if ((ret = rtsp_send_cmd_with_content_async(
s, method, url,
header,
1424 send_content_length)) < 0)
1448 int lower_transport,
const char *real_challenge)
1455 const char *trans_pref;
1457 memset(&reply1, 0,
sizeof(reply1));
1460 trans_pref =
"x-pn-tng";
1462 trans_pref =
"RAW/RAW";
1464 trans_pref =
"RTP/AVP";
1474 port_off -= port_off & 0x01;
1476 for (j = rt->
rtp_port_min + port_off,
i = 0; i < rt->nb_rtsp_streams; ++
i) {
1513 while (j <= rt->rtp_port_max) {
1517 "?localport=%d", j);
1521 &
s->interrupt_callback, &
opts,
s->protocol_whitelist,
s->protocol_blacklist,
NULL);
1535 av_strlcpy(transport, trans_pref,
sizeof(transport));
1540 av_strlcat(transport,
"unicast;",
sizeof(transport));
1542 "client_port=%d", port);
1545 av_strlcatf(transport,
sizeof(transport),
"-%d", port + 1);
1558 snprintf(transport,
sizeof(transport) - 1,
1559 "%s/TCP;", trans_pref);
1561 av_strlcat(transport,
"unicast;",
sizeof(transport));
1563 "interleaved=%d-%d",
1569 snprintf(transport,
sizeof(transport) - 1,
1570 "%s/UDP;multicast", trans_pref);
1577 av_strlcat(transport,
";mode=record",
sizeof(transport));
1580 av_strlcat(transport,
";mode=play",
sizeof(transport));
1582 "Transport: %s\r\n",
1585 av_strlcat(cmd,
"x-Dynamic-Rate: 0\r\n",
sizeof(cmd));
1587 char real_res[41], real_csum[9];
1592 "RealChallenge2: %s, sd=%s\r\n",
1606 char proto[128], host[128], path[512], auth[128];
1608 av_url_split(proto,
sizeof(proto), auth,
sizeof(auth), host,
sizeof(host),
1642 const char *peer = host;
1674 snprintf(optbuf,
sizeof(optbuf),
"?ttl=%d", ttl);
1675 getnameinfo((
struct sockaddr*) &addr,
sizeof(addr),
1678 port,
"%s", optbuf);
1680 &
s->interrupt_callback, &
opts,
s->protocol_whitelist,
s->protocol_blacklist,
NULL);
1720 char proto[128], host[1024], path[1024];
1722 const char *lower_rtsp_proto =
"tcp";
1723 int port, err, tcp_fd;
1725 int lower_transport_mask = 0;
1727 int https_tunnel = 0;
1728 char real_challenge[64] =
"";
1730 socklen_t peer_len =
sizeof(peer);
1742 if (
s->max_delay < 0)
1756 memset(&reply1, 0,
sizeof(reply1));
1759 host,
sizeof(host), &port, path,
sizeof(path),
s->url);
1761 if (!strcmp(proto,
"rtsps")) {
1762 lower_rtsp_proto =
"tls";
1765 }
else if (!strcmp(proto,
"satip")) {
1774 port = default_port;
1778 if (!lower_transport_mask)
1787 "only UDP and TCP are supported for output.\n");
1797 host, port,
"%s", path);
1801 char httpname[1024];
1802 char sessioncookie[17];
1808 ff_url_join(httpname,
sizeof(httpname), https_tunnel ?
"https" :
"http", auth, host, port,
"%s", path);
1809 snprintf(sessioncookie,
sizeof(sessioncookie),
"%08x%08x",
1814 &
s->interrupt_callback) < 0) {
1821 "x-sessioncookie: %s\r\n"
1822 "Accept: application/x-rtsp-tunnelled\r\n"
1823 "Pragma: no-cache\r\n"
1824 "Cache-Control: no-cache\r\n",
1845 &
s->interrupt_callback) < 0 ) {
1852 "x-sessioncookie: %s\r\n"
1853 "Content-Type: application/x-rtsp-tunnelled\r\n"
1854 "Pragma: no-cache\r\n"
1855 "Cache-Control: no-cache\r\n"
1856 "Content-Length: 32767\r\n"
1857 "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1895 &
s->interrupt_callback,
NULL,
s->protocol_whitelist,
s->protocol_blacklist,
NULL)) < 0) {
1908 if (!getpeername(tcp_fd, (
struct sockaddr*) &peer, &peer_len)) {
1909 getnameinfo((
struct sockaddr*) &peer, peer_len, host,
sizeof(host),
1930 "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1931 "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1932 "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1933 "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1952 #if CONFIG_RTSP_DEMUXER
1955 err = init_satip_stream(
s);
1968 int lower_transport =
ff_log2_tab[lower_transport_mask &
1969 ~(lower_transport_mask - 1)];
1977 real_challenge :
NULL);
1980 lower_transport_mask &= ~(1 << lower_transport);
1981 if (lower_transport_mask == 0 && err == 1) {
1982 err =
AVERROR(EPROTONOSUPPORT);
2044 struct pollfd *p = rt->
p;
2045 int *fds =
NULL, fdsnum, fdsidx;
2055 p[rt->
max_p++].events = POLLIN;
2067 "Number of fds %d not supported\n", fdsnum);
2070 for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
2071 p[rt->
max_p].fd = fds[fdsidx];
2072 p[rt->
max_p++].events = POLLIN;
2090 if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
2093 *prtsp_st = rtsp_st;
2100 #if CONFIG_RTSP_DEMUXER
2101 if (rt->
rtsp_hd && p[0].revents & POLLIN) {
2102 if ((ret = parse_rtsp_message(
s)) < 0) {
2109 }
else if (n < 0 && errno != EINTR)
2141 "Unable to pick stream for packet - SSRC not known for "
2167 #if CONFIG_RTSP_DEMUXER
2223 }
else if (ret == 1) {
2239 if (queue_time && (queue_time - first_queue_time < 0 ||
2240 !first_queue_time)) {
2241 first_queue_time = queue_time;
2245 if (first_queue_time) {
2246 wait_end = first_queue_time +
s->max_delay;
2249 first_queue_st =
NULL;
2261 if (
len ==
AVERROR(EAGAIN) && first_queue_st &&
2264 "max delay reached. need to consume packet\n");
2265 rtsp_st = first_queue_st;
2300 if (rtpctx2 && st && st2 &&
2312 s->start_time_realtime -=
2353 #if CONFIG_SDP_DEMUXER
2359 while (p < p_end && *p !=
'\0') {
2360 if (
sizeof(
"c=IN IP") - 1 < p_end - p &&
2364 while (p < p_end - 1 && *p !=
'\n') p++;
2373 static void append_source_addrs(
char *buf,
int size,
const char *
name,
2380 for (
i = 1;
i < count;
i++)
2395 if (
s->max_delay < 0)
2413 content[
size] =
'\0';
2438 "?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2443 append_source_addrs(url,
sizeof(url),
"sources",
2446 append_source_addrs(url,
sizeof(url),
"block",
2450 &
s->interrupt_callback, &
opts,
s->protocol_whitelist,
s->protocol_blacklist,
NULL);
2476 static const AVClass sdp_demuxer_class = {
2491 .priv_class = &sdp_demuxer_class,
2495 #if CONFIG_RTP_DEMUXER
2506 char host[500], filters_buf[1000];
2513 socklen_t addrlen =
sizeof(addr);
2524 &
s->interrupt_callback, &
opts,
s->protocol_whitelist,
s->protocol_blacklist,
NULL);
2540 if ((recvbuf[0] & 0xc0) != 0x80) {
2549 payload_type = recvbuf[1] & 0x7f;
2563 "without an SDP file describing it\n",
2570 "properly you need an SDP file "
2579 addr.ss_family == AF_INET ? 4 : 6, host);
2581 p = strchr(
s->url,
'?');
2583 static const char filters[][2][8] = { {
"sources",
"incl" },
2584 {
"block",
"excl" } };
2590 while ((q = strchr(q,
',')) !=
NULL)
2592 av_bprintf(&sdp,
"a=source-filter:%s IN IP%d %s %s\r\n",
2594 addr.ss_family == AF_INET ? 4 : 6, host,
2603 port, payload_type);
2619 ret = sdp_read_header(
s);
2635 static const AVClass rtp_demuxer_class = {
2651 .priv_class = &rtp_demuxer_class,
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ffurl_alloc(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb)
Create a URLContext for accessing to the resource indicated by url, but do not initiate the connectio...
int ffurl_read(URLContext *h, unsigned char *buf, int size)
Read up to size bytes from the resource accessed by h, and store the read bytes in buf.
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist, URLContext *parent)
Create an URLContext for accessing to the resource indicated by url, and open it.
int ffurl_closep(URLContext **hh)
Close the resource accessed by the URLContext h, and free the memory used by it.
int ffurl_connect(URLContext *uc, AVDictionary **options)
Connect an URLContext that has been allocated by ffurl_alloc.
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
int ffurl_get_file_handle(URLContext *h)
Return the file descriptor associated with this URL.
int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
Return the file descriptors associated with this URL.
int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)
Read as many bytes as possible (up to size), calling the read function multiple times if necessary.
#define AVIO_FLAG_READ
read-only
int avio_read_partial(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
#define AVIO_FLAG_WRITE
write-only
#define AVIO_FLAG_READ_WRITE
read-write pseudo flag
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
void av_bprintf(AVBPrint *buf, const char *fmt,...)
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
#define AV_BPRINT_SIZE_UNLIMITED
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
#define flags(name, subs,...)
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
#define CONFIG_RTSP_MUXER
static av_always_inline void RENAME() interleave(TYPE *dst, TYPE *src0, TYPE *src1, int w2, int add, int shift)
const OptionDef options[]
static int read_header(FFV1Context *f)
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
@ AV_CODEC_ID_MPEG2TS
FAKE codec to indicate a raw MPEG-2 TS stream (only used by libavformat)
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it.
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AVERROR_EOF
End of file.
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
char * av_strdup(const char *s)
Duplicate a string.
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
int av_stristart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str independent of case.
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
#define AV_NOPTS_VALUE
Undefined timestamp value.
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
#define LIBAVUTIL_VERSION_INT
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
void ff_http_init_auth_state(URLContext *dest, const URLContext *src)
Initialize the authentication state based on another HTTP URLContext.
char * ff_http_auth_create_response(HTTPAuthState *state, const char *auth, const char *path, const char *method)
void ff_http_auth_handle_header(HTTPAuthState *state, const char *key, const char *value)
HTTPAuthType
Authentication types, ordered from weakest to strongest.
@ HTTP_AUTH_NONE
No authentication specified.
const uint8_t ff_log2_tab[256]
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static av_cold int read_close(AVFormatContext *ctx)
static void handler(vbi_event *ev, void *user_data)
void avpriv_mpegts_parse_close(MpegTSContext *ts)
int avpriv_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt, const uint8_t *buf, int len)
MpegTSContext * avpriv_mpegts_parse_open(AVFormatContext *s)
int ff_network_init(void)
void ff_network_close(void)
#define AV_OPT_FLAG_DEPRECATED
set if option is deprecated, users should refer to AVOption.help text for more information
miscellaneous OS support macros and functions.
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
Attempt to find a specific tag in a URL.
static const struct PPFilter filters[]
int ff_rdt_parse_packet(RDTDemuxContext *s, AVPacket *pkt, uint8_t **bufptr, int len)
Parse RDT-style packet data (header + media data).
void ff_rdt_parse_close(RDTDemuxContext *s)
void ff_rdt_calc_response_and_checksum(char response[41], char chksum[9], const char *challenge)
Calculate the response (RealChallenge2 in the RTSP header) to the challenge (RealChallenge1 in the RT...
RDTDemuxContext * ff_rdt_parse_open(AVFormatContext *ic, int first_stream_of_set_idx, void *priv_data, const RTPDynamicProtocolHandler *handler)
Allocate and init the RDT parsing context.
void ff_real_parse_sdp_a_line(AVFormatContext *s, int stream_index, const char *line)
Parse a server-related SDP line.
enum AVMediaType codec_type
int ff_rtp_get_codec_info(AVCodecParameters *par, int payload_type)
Initialize a codec context based on the payload type.
enum AVCodecID ff_rtp_codec_id(const char *buf, enum AVMediaType codec_type)
Return the codec id for the given encoding name and codec type.
const char * ff_rtp_enc_name(int payload_type)
Return the encoding name (as defined in http://www.iana.org/assignments/rtp-parameters) for a given p...
#define RTP_PT_IS_RTCP(x)
const RTPDynamicProtocolHandler * ff_rtp_handler_find_by_id(int id, enum AVMediaType codec_type)
Find a registered rtp dynamic protocol handler with a matching codec ID.
const RTPDynamicProtocolHandler * ff_rtp_handler_find_by_name(const char *name, enum AVMediaType codec_type)
Find a registered rtp dynamic protocol handler with the specified name.
void ff_rtp_parse_close(RTPDemuxContext *s)
void ff_rtp_parse_set_crypto(RTPDemuxContext *s, const char *suite, const char *params)
int ff_rtp_check_and_send_back_rr(RTPDemuxContext *s, URLContext *fd, AVIOContext *avio, int count)
some rtp servers assume client is dead if they don't hear from them...
void ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx, const RTPDynamicProtocolHandler *handler)
RTPDemuxContext * ff_rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_type, int queue_size)
open a new RTP parse context for stream 'st'.
int ff_rtp_send_rtcp_feedback(RTPDemuxContext *s, URLContext *fd, AVIOContext *avio)
int ff_rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, uint8_t **bufptr, int len)
Parse an RTP or RTCP packet directly sent as a buffer.
int64_t ff_rtp_queued_packet_time(RTPDemuxContext *s)
#define RTP_REORDER_QUEUE_DEFAULT_SIZE
int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, char *value, int value_size)
#define RTP_MAX_PACKET_LENGTH
int ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p)
Parse a Windows Media Server-specific SDP line.
static int parse_fmtp(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *attr, const char *value)
#define FF_RTP_FLAG_OPTS(ctx, fieldname)
int ff_rtp_chain_mux_open(AVFormatContext **out, AVFormatContext *s, AVStream *st, URLContext *handle, int packet_size, int idx)
int ff_rtp_get_local_rtp_port(URLContext *h)
Return the local rtp port used by the RTP connection.
int ff_rtp_set_remote_url(URLContext *h, const char *uri)
If no filename is given to av_open_input_file because you want to get the local port first,...
static const AVOption sdp_options[]
static void get_word_until_chars(char *buf, int buf_size, const char *sep, const char **pp)
#define DEFAULT_REORDERING_DELAY
int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
Open RTSP transport context.
static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
Parse a string p in the form of Range:npt=xx-xx, and determine the start and end time.
static void get_word_sep(char *buf, int buf_size, const char *sep, const char **pp)
static const AVOption rtp_options[]
static void get_word(char *buf, int buf_size, const char **pp)
static int get_sockaddr(AVFormatContext *s, const char *buf, struct sockaddr_storage *sock)
const AVOption ff_rtsp_options[]
void ff_rtsp_close_streams(AVFormatContext *s)
Close and free all streams within the RTSP (de)muxer.
#define READ_PACKET_TIMEOUT_S
#define RTSP_FLAG_OPTS(name, longname)
static AVDictionary * map_to_opts(RTSPState *rt)
void ff_rtsp_undo_setup(AVFormatContext *s, int send_packets)
Undo the effect of ff_rtsp_make_setup_request, close the transport_priv and rtp_handle fields.
#define RTSP_MEDIATYPE_OPTS(name, longname)
void ff_rtsp_skip_packet(AVFormatContext *s)
Skip a RTP/TCP interleaved packet.
int ff_sdp_parse(AVFormatContext *s, const char *content)
Parse an SDP description of streams by populating an RTSPState struct within the AVFormatContext; als...
#define RTSP_FLAG_LISTEN
Wait for incoming connections.
@ RTSP_SERVER_SATIP
SAT>IP server.
@ RTSP_SERVER_WMS
Windows Media server.
@ RTSP_SERVER_RTP
Standards-compliant RTP-server.
@ RTSP_SERVER_REAL
Realmedia-style server.
int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url, const char *headers, RTSPMessageHeader *reply, unsigned char **content_ptr)
Send a command to the RTSP server and wait for the reply.
#define RTSP_DEFAULT_NB_AUDIO_CHANNELS
int ff_rtsp_setup_input_streams(AVFormatContext *s, RTSPMessageHeader *reply)
Get the description of the stream and set up the RTSPStream child objects.
#define RTSP_FLAG_SATIP_RAW
Export SAT>IP stream as raw MPEG-TS.
int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply, unsigned char **content_ptr, int return_on_interleaved_data, const char *method)
Read a RTSP message from the server, or prepare to read data packets if we're reading data interleave...
int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port, int lower_transport, const char *real_challenge)
Do the SETUP requests for each stream for the chosen lower transport mode.
#define RTSP_DEFAULT_AUDIO_SAMPLERATE
int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method, const char *url, const char *headers)
Send a command to the RTSP server without waiting for the reply.
#define RTSP_FLAG_FILTER_SRC
Filter incoming UDP packets - receive packets only from the right source address and port.
#define RTSP_TCP_MAX_PACKET_SIZE
#define RTSP_FLAG_CUSTOM_IO
Do all IO via the AVIOContext.
int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
Receive one packet from the RTSPStreams set up in the AVFormatContext (which should contain a RTSPSta...
#define RTSP_MAX_TRANSPORTS
void ff_rtsp_parse_line(AVFormatContext *s, RTSPMessageHeader *reply, const char *buf, RTSPState *rt, const char *method)
#define RTSPS_DEFAULT_PORT
@ RTSP_LOWER_TRANSPORT_TCP
TCP; interleaved in RTSP.
@ RTSP_LOWER_TRANSPORT_HTTP
HTTP tunneled - not a proper transport mode as such, only for use via AVOptions.
@ RTSP_LOWER_TRANSPORT_NB
@ RTSP_LOWER_TRANSPORT_UDP_MULTICAST
UDP/multicast.
@ RTSP_LOWER_TRANSPORT_CUSTOM
Custom IO - not a public option for lower_transport_mask, but set in the SDP demuxer based on a flag.
@ RTSP_LOWER_TRANSPORT_UDP
UDP/unicast.
@ RTSP_LOWER_TRANSPORT_HTTPS
HTTPS tunneled.
int ff_rtsp_parse_streaming_commands(AVFormatContext *s)
Parse RTSP commands (OPTIONS, PAUSE and TEARDOWN) during streaming in listen mode.
#define RTSP_RTP_PORT_MIN
@ RTSP_MODE_PLAIN
Normal RTSP.
@ RTSP_MODE_TUNNEL
RTSP over HTTP (tunneling)
void ff_rtsp_close_connections(AVFormatContext *s)
Close all connection handles within the RTSP (de)muxer.
@ RTSP_STATE_STREAMING
initialized and sending/receiving data
@ RTSP_STATE_IDLE
not initialized
#define RTSP_FLAG_PREFER_TCP
Try RTP via TCP first if possible.
int ff_rtsp_send_cmd_with_content(AVFormatContext *s, const char *method, const char *url, const char *headers, RTSPMessageHeader *reply, unsigned char **content_ptr, const unsigned char *send_content, int send_content_length)
Send a command to the RTSP server and wait for the reply.
int ff_rtsp_tcp_write_packet(AVFormatContext *s, RTSPStream *rtsp_st)
Send buffered packets over TCP.
#define RTSP_DEFAULT_PORT
int ff_rtsp_tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st, uint8_t *buf, int buf_size)
Receive one RTP packet from an TCP interleaved RTSP stream.
#define RTSP_RTP_PORT_MAX
int ff_rtsp_connect(AVFormatContext *s)
Connect to the RTSP server and set up the individual media streams.
@ RTSP_TRANSPORT_RTP
Standards-compliant RTP.
@ RTSP_TRANSPORT_RAW
Raw data (over UDP)
@ RTSP_TRANSPORT_RDT
Realmedia Data Transport.
int ff_rtsp_setup_output_streams(AVFormatContext *s, const char *addr)
Announce the stream to the server and set up the RTSPStream child objects for each media stream.
#define RTSP_FLAG_RTCP_TO_SOURCE
Send RTCP packets to the source address of received packets.
static int ff_rtsp_averror(enum RTSPStatusCode status_code, int default_averror)
static const uint8_t header[24]
#define FF_ARRAY_ELEMS(a)
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
This struct describes the properties of a single codec described by an AVCodecID.
This struct describes the properties of an encoded stream.
enum AVMediaType codec_type
General type of the encoded data.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
int sample_rate
Audio only.
AVIOContext * pb
I/O context.
This structure stores compressed data.
This structure contains the data a format has to probe a file.
int buf_size
Size of buf except extra allocated bytes.
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
AVCodecParameters * codecpar
Codec parameters associated with this stream.
int id
Format-specific stream ID.
int index
stream index in AVFormatContext
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
enum AVStreamParseType need_parsing
int stale
Auth ok, but needs to be resent with a new nonce.
int auth_type
The currently chosen auth type.
uint64_t first_rtcp_ntp_time
int(* parse_sdp_a_line)(AVFormatContext *s, int st_index, PayloadContext *priv_data, const char *line)
Parse the a= line from the sdp field.
void(* close)(PayloadContext *protocol_data)
Free any data needed by the rtp parsing for this dynamic data.
int(* init)(AVFormatContext *s, int st_index, PayloadContext *priv_data)
Initialize dynamic protocol handler, called after the full rtpmap line is parsed, may be null.
char addr[128]
Source-specific multicast include source IP address (from SDP content)
Private data for the RTSP demuxer.
char real_challenge[64]
the "RealChallenge1:" field from the server
int nb_rtsp_streams
number of items in the 'rtsp_streams' variable
enum RTSPTransport transport
the negotiated data/packet transport protocol; e.g.
AVFormatContext * asf_ctx
The following are used for RTP/ASF streams.
int timeout
copy of RTSPMessageHeader->timeout, i.e.
int accept_dynamic_rate
Whether the server accepts the x-Dynamic-Rate header.
HTTPAuthState auth_state
authentication state
int initial_timeout
Timeout to wait for incoming connections.
URLContext * rtsp_hd_out
Additional output handle, used when input and output are done separately, eg for HTTP tunneling.
int lower_transport_mask
A mask with all requested transport methods.
enum RTSPLowerTransport lower_transport
the negotiated network layer transport protocol; e.g.
int64_t last_cmd_time
timestamp of the last RTSP command that we sent to the RTSP server.
int need_subscription
The following are used for Real stream selection.
char session_id[512]
copy of RTSPMessageHeader->session_id, i.e.
int media_type_mask
Mask of all requested media types.
struct MpegTSContext * ts
The following are used for parsing raw mpegts in udp.
enum RTSPServerType server_type
brand of server that we're talking to; e.g.
uint8_t * recvbuf
Reusable buffer for receiving packets.
char * user_agent
User-Agent string.
int rtsp_flags
Various option flags for the RTSP muxer/demuxer.
int64_t seek_timestamp
the seek value requested when calling av_seek_frame().
char control_uri[MAX_URL_SIZE]
some MS RTSP streams contain a URL in the SDP that we need to use for all subsequent RTSP requests,...
enum RTSPControlTransport control_transport
RTSP transport mode, such as plain or tunneled.
void * cur_transport_priv
RTSPStream->transport_priv of the last stream that we read a packet from.
int reordering_queue_size
Size of RTP packet reordering queue.
char auth[128]
plaintext authorization line (username:password)
int rtp_port_min
Minimum and maximum local UDP ports.
enum RTSPClientState state
indicator of whether we are currently receiving data from the server.
int seq
RTSP command sequence number.
int stimeout
timeout of socket i/o operations.
struct RTSPStream ** rtsp_streams
streams in this session
struct pollfd * p
Polling array for udp.
int get_parameter_supported
Whether the server supports the GET_PARAMETER method.
char last_reply[2048]
The last reply of the server to a RTSP command.
Describe a single stream, as identified by a single m= line block in the SDP content.
struct RTSPSource ** exclude_source_addrs
Source-specific multicast exclude source IP addresses (from SDP content)
int sdp_ttl
IP Time-To-Live (from SDP content)
const RTPDynamicProtocolHandler * dynamic_handler
The following are used for dynamic protocols (rtpdec_*.c/rdt.c)
int sdp_port
The following are used only in SDP, not RTSP.
int nb_include_source_addrs
Number of source-specific multicast include source IP addresses (from SDP content)
int interleaved_min
interleave IDs; copies of RTSPTransportField->interleaved_min/max for the selected transport.
char control_url[MAX_URL_SIZE]
url for this stream (from SDP)
int sdp_payload_type
payload type
URLContext * rtp_handle
RTP stream handle (if UDP)
int stream_index
corresponding stream index, if any.
struct RTSPSource ** include_source_addrs
Source-specific multicast include source IP addresses (from SDP content)
int feedback
Enable sending RTCP feedback messages according to RFC 4585.
PayloadContext * dynamic_protocol_context
private data associated with the dynamic protocol
void * transport_priv
RTP/RDT parse context if input, RTP AVFormatContext if output.
uint32_t ssrc
SSRC for this stream, to allow identifying RTCP packets before the first RTP packet.
int nb_exclude_source_addrs
Number of source-specific multicast exclude source IP addresses (from SDP content)
struct sockaddr_storage sdp_ip
IP address (from SDP content)
This describes a single item in the "Transport:" line of one stream as negotiated by the SETUP RTSP c...
int server_port_min
UDP unicast server port range; the ports to which we should connect to receive unicast UDP RTP/RTCP d...
int client_port_min
UDP client ports; these should be the local ports of the UDP RTP (and RTCP) sockets over which we rec...
char source[INET6_ADDRSTRLEN+1]
source IP address
enum RTSPTransport transport
data/packet transport protocol; e.g.
struct sockaddr_storage destination
destination IP address
int ttl
time-to-live value (required for multicast); the amount of HOPs that packets will be allowed to make ...
enum RTSPLowerTransport lower_transport
network layer transport protocol; e.g.
int port_min
UDP multicast port range; the ports to which we should connect to receive multicast UDP data.
int interleaved_min
interleave ids, if TCP transport; each TCP/RTSP data packet starts with a '$', stream length and stre...
const char * protocol_whitelist
#define av_malloc_array(a, b)
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
int ff_url_join(char *str, int size, const char *proto, const char *authorization, const char *hostname, int port, const char *fmt,...)
unbuffered private I/O API