22 #include "libavutil/avassert.h"
23 #include "libavutil/base64.h"
24 #include "libavutil/avstring.h"
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"
55 #define POLL_TIMEOUT_MS 100
56 #define READ_PACKET_TIMEOUT_S 10
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", "Number of packets to buffer for handling of reordered packets", OFFSET(reordering_queue_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC }
80 {
"initial_pause",
"Don't start playing the stream immediately",
OFFSET(initial_pause),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1,
DEC },
82 {
"rtsp_transport",
"RTSP transport protocols",
OFFSET(lower_transport_mask),
AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX,
DEC|
ENC,
"rtsp_transport" }, \
92 {
"timeout",
"Maximum timeout (in seconds) to wait for incoming connections. -1 is infinite. Implies flag listen",
OFFSET(initial_timeout),
AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX,
DEC },
93 {
"stimeout",
"timeout (in micro seconds) of socket i/o operations.",
OFFSET(stimeout),
AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX,
DEC },
115 const char *sep,
const char **pp)
123 while (!strchr(sep, *p) && *p !=
'\0') {
124 if ((q - buf) < buf_size - 1)
136 if (**pp ==
'/') (*pp)++;
171 struct addrinfo hints = { 0 }, *ai = NULL;
175 memcpy(sock, ai->ai_addr,
FFMIN(
sizeof(*sock), ai->ai_addrlen));
189 if (handler->
alloc) {
199 int payload_type,
const char *p)
221 init_rtp_handler(handler, rtsp_st, codec);
274 char *
value,
int value_size)
289 typedef struct SDPParseState {
294 int nb_default_include_source_addrs;
295 struct RTSPSource **default_include_source_addrs;
296 int nb_default_exclude_source_addrs;
297 struct RTSPSource **default_exclude_source_addrs;
300 static void copy_default_source_addrs(
struct RTSPSource **addrs,
int count,
305 for (i = 0; i <
count; i++) {
307 rtsp_src2 =
av_malloc(
sizeof(*rtsp_src2));
310 memcpy(rtsp_src2, rtsp_src,
sizeof(*rtsp_src));
316 int letter,
const char *buf)
319 char buf1[64], st_type[64];
329 av_dlog(s,
"sdp: %c='%s'\n", letter, buf);
332 if (s1->skip_media && letter !=
'm')
337 if (strcmp(buf1,
"IN") != 0)
340 if (strcmp(buf1,
"IP4") && strcmp(buf1,
"IP6"))
352 s1->default_ip = sdp_ip;
353 s1->default_ttl = ttl;
373 get_word(st_type,
sizeof(st_type), &p);
374 if (!strcmp(st_type,
"audio")) {
376 }
else if (!strcmp(st_type,
"video")) {
378 }
else if (!strcmp(st_type,
"application")) {
391 rtsp_st->
sdp_ip = s1->default_ip;
392 rtsp_st->
sdp_ttl = s1->default_ttl;
394 copy_default_source_addrs(s1->default_include_source_addrs,
395 s1->nb_default_include_source_addrs,
398 copy_default_source_addrs(s1->default_exclude_source_addrs,
399 s1->nb_default_exclude_source_addrs,
407 if (!strcmp(buf1,
"udp"))
409 else if (strstr(buf1,
"/AVPF") || strstr(buf1,
"/SAVPF"))
425 init_rtp_handler(handler, rtsp_st, NULL);
426 if (handler && handler->
init)
450 init_rtp_handler(handler, rtsp_st, st->
codec);
451 if (handler && handler->
init)
463 if (!strncmp(p,
"rtsp://", 7))
474 if (proto[0] ==
'\0') {
488 payload_type = atoi(buf1);
492 sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p);
499 payload_type = atoi(buf1);
517 }
else if (
av_strstart(p,
"IsRealDataType:integer;",&p)) {
520 }
else if (
av_strstart(p,
"SampleRate:integer;", &p) &&
535 if (strcmp(buf1,
"incl") && strcmp(buf1,
"excl"))
537 exclude = !strcmp(buf1,
"excl");
540 if (strcmp(buf1,
"IN") != 0)
543 if (strcmp(buf1,
"IP4") && strcmp(buf1,
"IP6") && strcmp(buf1,
"*"))
555 dynarray_add(&s1->default_exclude_source_addrs, &s1->nb_default_exclude_source_addrs, rtsp_src);
562 dynarray_add(&s1->default_include_source_addrs, &s1->nb_default_include_source_addrs, rtsp_src);
603 SDPParseState sdp_parse_state = { { 0 } }, *s1 = &sdp_parse_state;
617 while (*p !=
'\n' && *p !=
'\r' && *p !=
'\0') {
618 if ((q - buf) <
sizeof(buf) - 1)
623 sdp_parse_line(s, s1, letter, buf);
625 while (*p !=
'\n' && *p !=
'\0')
631 for (i = 0; i < s1->nb_default_include_source_addrs; i++)
632 av_free(s1->default_include_source_addrs[i]);
633 av_freep(&s1->default_include_source_addrs);
634 for (i = 0; i < s1->nb_default_exclude_source_addrs; i++)
635 av_free(s1->default_exclude_source_addrs[i]);
636 av_freep(&s1->default_exclude_source_addrs);
716 if (reordering_queue_size < 0) {
718 reordering_queue_size = 0;
747 reordering_queue_size);
766 #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
767 static void rtsp_parse_range(
int *min_ptr,
int *max_ptr,
const char **pp)
775 v = strtol(q, &p, 10);
779 v = strtol(p, &p, 10);
791 char transport_protocol[16];
793 char lower_transport[16];
807 get_word_sep(transport_protocol,
sizeof(transport_protocol),
811 lower_transport[0] =
'\0';
818 }
else if (!
av_strcasecmp (transport_protocol,
"x-pn-tng") ||
821 get_word_sep(lower_transport,
sizeof(lower_transport),
"/;,", &p);
826 lower_transport[0] =
'\0';
842 while (*p !=
'\0' && *p !=
',') {
844 if (!strcmp(parameter,
"port")) {
849 }
else if (!strcmp(parameter,
"client_port")) {
855 }
else if (!strcmp(parameter,
"server_port")) {
861 }
else if (!strcmp(parameter,
"interleaved")) {
867 }
else if (!strcmp(parameter,
"multicast")) {
870 }
else if (!strcmp(parameter,
"ttl")) {
874 th->
ttl = strtol(p, &end, 10);
877 }
else if (!strcmp(parameter,
"destination")) {
883 }
else if (!strcmp(parameter,
"source")) {
889 }
else if (!strcmp(parameter,
"mode")) {
893 if (!strcmp(buf,
"record") ||
894 !strcmp(buf,
"receive"))
899 while (*p !=
';' && *p !=
'\0' && *p !=
',')
911 static void handle_rtp_info(
RTSPState *rt,
const char *url,
912 uint32_t seq, uint32_t rtptime)
915 if (!rtptime || !url[0])
931 static void rtsp_parse_rtp_info(
RTSPState *rt,
const char *p)
934 char key[20], value[1024], url[1024] =
"";
935 uint32_t seq = 0, rtptime = 0;
947 if (!strcmp(key,
"url"))
949 else if (!strcmp(key,
"seq"))
950 seq = strtoul(value, NULL, 10);
951 else if (!strcmp(key,
"rtptime"))
952 rtptime = strtoul(value, NULL, 10);
954 handle_rtp_info(rt, url, seq, rtptime);
963 handle_rtp_info(rt, url, seq, rtptime);
977 (t = strtol(p, NULL, 10)) > 0) {
983 rtsp_parse_transport(reply, p);
985 reply->
seq = strtol(p, NULL, 10);
996 reply->
notice = strtol(p, NULL, 10);
1000 }
else if (
av_stristart(p,
"WWW-Authenticate:", &p) && rt) {
1003 }
else if (
av_stristart(p,
"Authentication-Info:", &p) && rt) {
1006 }
else if (
av_stristart(p,
"Content-Base:", &p) && rt) {
1008 if (method && !strcmp(method,
"DESCRIBE"))
1012 if (method && !strcmp(method,
"PLAY"))
1013 rtsp_parse_rtp_info(rt, p);
1015 if (strstr(p,
"GET_PARAMETER") &&
1016 method && !strcmp(method,
"OPTIONS"))
1018 }
else if (
av_stristart(p,
"x-Accept-Dynamic-Rate:", &p) && rt) {
1039 av_dlog(s,
"skipping RTP packet len=%d\n", len);
1044 if (len1 >
sizeof(buf))
1054 unsigned char **content_ptr,
1055 int return_on_interleaved_data,
const char *method)
1058 char buf[4096], buf1[1024], *q;
1061 int ret, content_length, line_count = 0, request = 0;
1062 unsigned char *content = NULL;
1068 memset(reply, 0,
sizeof(*reply));
1076 av_dlog(s,
"ret=%d c=%02x [%c]\n", ret, ch, ch);
1083 if (return_on_interleaved_data) {
1087 }
else if (ch !=
'\r') {
1088 if ((q - buf) <
sizeof(buf) - 1)
1094 av_dlog(s,
"line='%s'\n", buf);
1100 if (line_count == 0) {
1103 if (!strncmp(buf1,
"RTSP/", 5)) {
1124 if (content_length > 0) {
1126 content =
av_malloc(content_length + 1);
1128 content[content_length] =
'\0';
1131 *content_ptr = content;
1138 const char* ptr =
buf;
1140 if (!strcmp(reply->
reason,
"OPTIONS")) {
1141 snprintf(buf,
sizeof(buf),
"RTSP/1.0 200 OK\r\n");
1148 snprintf(buf,
sizeof(buf),
"RTSP/1.0 501 Not Implemented\r\n");
1173 if (rt->
seq != reply->
seq) {
1179 if (reply->
notice == 2101 ||
1181 reply->
notice == 2306 ) {
1183 }
else if (reply->
notice >= 4400 && reply->
notice < 5500) {
1185 }
else if (reply->
notice == 2401 ||
1206 const char *method,
const char *url,
1207 const char *headers,
1208 const unsigned char *send_content,
1209 int send_content_length)
1212 char buf[4096], *out_buf;
1218 snprintf(buf,
sizeof(buf),
"%s %s RTSP/1.0\r\n", method, url);
1223 if (rt->
session_id[0] !=
'\0' && (!headers ||
1224 !strstr(headers,
"\nIf-Match:"))) {
1229 rt->
auth, url, method);
1234 if (send_content_length > 0 && send_content)
1235 av_strlcatf(buf,
sizeof(buf),
"Content-Length: %d\r\n", send_content_length);
1241 out_buf = base64buf;
1244 av_dlog(s,
"Sending:\n%s--\n", buf);
1247 if (send_content_length > 0 && send_content) {
1250 "with content data not supported\n");
1261 const char *url,
const char *headers)
1263 return rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
1268 unsigned char **content_ptr)
1271 content_ptr, NULL, 0);
1275 const char *method,
const char *url,
1278 unsigned char **content_ptr,
1279 const unsigned char *send_content,
1280 int send_content_length)
1284 int ret, attempts = 0;
1288 if ((ret = rtsp_send_cmd_with_content_async(s, method, url, header,
1290 send_content_length)))
1314 int lower_transport,
const char *real_challenge)
1317 int rtx = 0, j, i, err,
interleave = 0, port_off;
1321 const char *trans_pref;
1324 trans_pref =
"x-pn-tng";
1326 trans_pref =
"RAW/RAW";
1328 trans_pref =
"RTP/AVP";
1338 port_off -= port_off & 0x01;
1340 for (j = rt->
rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) {
1341 char transport[2048];
1377 while (j <= rt->rtp_port_max) {
1378 ff_url_join(buf,
sizeof(buf),
"rtp", NULL, host, -1,
1379 "?localport=%d", j);
1393 snprintf(transport,
sizeof(transport) - 1,
1394 "%s/UDP;", trans_pref);
1396 av_strlcat(transport,
"unicast;",
sizeof(transport));
1398 "client_port=%d", port);
1401 av_strlcatf(transport,
sizeof(transport),
"-%d", port + 1);
1414 snprintf(transport,
sizeof(transport) - 1,
1415 "%s/TCP;", trans_pref);
1417 av_strlcat(transport,
"unicast;",
sizeof(transport));
1419 "interleaved=%d-%d",
1420 interleave, interleave + 1);
1425 snprintf(transport,
sizeof(transport) - 1,
1426 "%s/UDP;multicast", trans_pref);
1429 av_strlcat(transport,
";mode=record",
sizeof(transport));
1432 av_strlcat(transport,
";mode=play",
sizeof(transport));
1434 "Transport: %s\r\n",
1437 av_strlcat(cmd,
"x-Dynamic-Rate: 0\r\n",
sizeof(cmd));
1439 char real_res[41], real_csum[9];
1444 "RealChallenge2: %s, sd=%s\r\n",
1484 char url[1024],
options[30] =
"";
1485 const char *peer = host;
1488 av_strlcpy(options,
"?connect=1",
sizeof(options));
1509 char url[1024], namebuf[50], optbuf[20] =
"";
1523 snprintf(optbuf,
sizeof(optbuf),
"?ttl=%d", ttl);
1524 getnameinfo((
struct sockaddr*) &addr,
sizeof(addr),
1526 ff_url_join(url,
sizeof(url),
"rtp", NULL, namebuf,
1527 port,
"%s", optbuf);
1565 char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1566 int port, err, tcp_fd;
1568 int lower_transport_mask = 0;
1569 char real_challenge[64] =
"";
1571 socklen_t peer_len =
sizeof(peer);
1598 host,
sizeof(host), &port, path,
sizeof(path), s->
filename);
1605 if (!lower_transport_mask)
1614 "only UDP and TCP are supported for output.\n");
1624 host, port,
"%s", path);
1628 char httpname[1024];
1629 char sessioncookie[17];
1632 ff_url_join(httpname,
sizeof(httpname),
"http", auth, host, port,
"%s", path);
1633 snprintf(sessioncookie,
sizeof(sessioncookie),
"%08x%08x",
1645 "x-sessioncookie: %s\r\n"
1646 "Accept: application/x-rtsp-tunnelled\r\n"
1647 "Pragma: no-cache\r\n"
1648 "Cache-Control: no-cache\r\n",
1667 "x-sessioncookie: %s\r\n"
1668 "Content-Type: application/x-rtsp-tunnelled\r\n"
1669 "Pragma: no-cache\r\n"
1670 "Cache-Control: no-cache\r\n"
1671 "Content-Length: 32767\r\n"
1672 "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1702 ff_url_join(tcpname,
sizeof(tcpname),
"tcp", NULL, host, port,
1714 if (!getpeername(tcp_fd, (
struct sockaddr*) &peer, &peer_len)) {
1715 getnameinfo((
struct sockaddr*) &peer, peer_len, host,
sizeof(host),
1734 "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1735 "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1736 "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1737 "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1764 int lower_transport =
ff_log2_tab[lower_transport_mask &
1765 ~(lower_transport_mask - 1)];
1769 real_challenge : NULL);
1772 lower_transport_mask &= ~(1 << lower_transport);
1773 if (lower_transport_mask == 0 && err == 1) {
1774 err =
AVERROR(EPROTONOSUPPORT);
1801 uint8_t *buf,
int buf_size, int64_t wait_end)
1805 int n, i,
ret, tcp_fd, timeout_cnt = 0;
1807 struct pollfd *p = rt->
p;
1808 int *fds = NULL, fdsnum, fdsidx;
1818 p[max_p].fd = tcp_fd;
1819 p[max_p++].events = POLLIN;
1833 "Number of fds %d not supported\n", fdsnum);
1836 for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
1837 p[max_p].fd = fds[fdsidx];
1838 p[max_p++].events = POLLIN;
1845 int j = 1 - (tcp_fd == -1);
1850 if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
1853 *prtsp_st = rtsp_st;
1860 #if CONFIG_RTSP_DEMUXER
1861 if (tcp_fd != -1 && p[0].revents & POLLIN) {
1868 "Unable to answer to TEARDOWN\n");
1884 }
else if (n < 0 && errno != EINTR)
1916 "Unable to pick stream for packet - SSRC not known for "
1938 int64_t wait_end = 0;
1960 }
else if (ret == 1) {
1969 int64_t first_queue_time = 0;
1976 if (queue_time && (queue_time - first_queue_time < 0 ||
1977 !first_queue_time)) {
1978 first_queue_time = queue_time;
1982 if (first_queue_time) {
1983 wait_end = first_queue_time + s->
max_delay;
1986 first_queue_st = NULL;
1999 #if CONFIG_RTSP_DEMUXER
2016 len = pick_stream(s, &rtsp_st, rt->
recvbuf, len);
2021 if (len ==
AVERROR(EAGAIN) && first_queue_st &&
2023 rtsp_st = first_queue_st;
2059 if (rtpctx2 && st && st2 &&
2104 #if CONFIG_SDP_DEMUXER
2110 while (p < p_end && *p !=
'\0') {
2111 if (p +
sizeof(
"c=IN IP") - 1 < p_end &&
2115 while (p < p_end - 1 && *p !=
'\n') p++;
2124 static void append_source_addrs(
char *buf,
int size,
const char *
name,
2130 av_strlcatf(buf, size,
"&%s=%s", name, addrs[0]->addr);
2131 for (i = 1; i <
count; i++)
2159 content[
size] =
'\0';
2175 "?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2180 append_source_addrs(url,
sizeof(url),
"sources",
2183 append_source_addrs(url,
sizeof(url),
"block",
2209 static const AVClass sdp_demuxer_class = {
2224 .priv_class = &sdp_demuxer_class,
2228 #if CONFIG_RTP_DEMUXER
2239 char host[500], sdp[500];
2246 socklen_t addrlen =
sizeof(addr);
2258 ret =
ffurl_read(in, recvbuf,
sizeof(recvbuf));
2268 if ((recvbuf[0] & 0xc0) != 0x80) {
2277 payload_type = recvbuf[1] & 0x7f;
2286 "without an SDP file describing it\n",
2292 "properly you need an SDP file "
2296 av_url_split(NULL, 0, NULL, 0, host,
sizeof(host), &port,
2300 "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",
2301 addr.ss_family == AF_INET ? 4 : 6, host,
2304 port, payload_type);
2315 ret = sdp_read_header(s);
2326 static const AVClass rtp_demuxer_class = {
2342 .priv_class = &rtp_demuxer_class,
char auth[128]
plaintext authorization line (username:password)
int interleaved_min
interleave ids, if TCP transport; each TCP/RTSP data packet starts with a '$', stream length and stre...
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.
void ff_rtsp_skip_packet(AVFormatContext *s)
Skip a RTP/TCP interleaved packet.
int rtp_port_min
Minimum and maximum local UDP ports.
int ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p)
Parse a Windows Media Server-specific SDP line.
void ff_rtp_parse_set_crypto(RTPDemuxContext *s, const char *suite, const char *params)
Realmedia Data Transport.
#define AVERROR_PATCHWELCOME
int ff_rtp_get_local_rtp_port(URLContext *h)
Return the local rtp port used by the RTP connection.
#define RTP_MAX_PACKET_LENGTH
void ff_rtsp_undo_setup(AVFormatContext *s)
Undo the effect of ff_rtsp_make_setup_request, close the transport_priv and rtp_handle fields...
void ff_rtp_send_punch_packets(URLContext *rtp_handle)
Send a dummy packet on both port pairs to set up the connection state in potential NAT routers...
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
char source[INET6_ADDRSTRLEN+1]
source IP address
HTTPAuthType
Authentication types, ordered from weakest to strongest.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
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.
char control_uri[1024]
some MS RTSP streams contain a URL in the SDP that we need to use for all subsequent RTSP requests...
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
#define RTSP_DEFAULT_PORT
struct pollfd * p
Polling array for udp.
int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
Open RTSP transport context.
int ffurl_connect(URLContext *uc, AVDictionary **options)
Connect an URLContext that has been allocated by ffurl_alloc.
AVCodecContext * codec
Codec context associated with this stream.
int ff_rdt_parse_packet(RDTDemuxContext *s, AVPacket *pkt, uint8_t **bufptr, int len)
Parse RDT-style packet data (header + media data).
int index
stream index in AVFormatContext
char * user_agent
User-Agent string.
int mode_record
transport set to record data
enum AVMediaType codec_type
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
void ff_network_close(void)
initialized and sending/receiving data
char real_challenge[64]
the "RealChallenge1:" field from the server
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
static av_always_inline void interleave(IDWTELEM *dst, IDWTELEM *src0, IDWTELEM *src1, int w2, int add, int shift)
#define RTSP_FLAG_RTCP_TO_SOURCE
Send RTCP packets to the source address of received packets.
#define RTSP_RTP_PORT_MAX
int nb_include_source_addrs
Number of source-specific multicast include source IP addresses (from SDP content) ...
int ctx_flags
Format-specific flags, see AVFMTCTX_xx.
#define RTSP_FLAG_LISTEN
Wait for incoming connections.
char session_id[512]
copy of RTSPMessageHeader->session_id, i.e.
int64_t seek_timestamp
the seek value requested when calling av_seek_frame().
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...
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.
enum RTSPLowerTransport lower_transport
network layer transport protocol; e.g.
RTPDemuxContext * ff_rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_type, int queue_size)
open a new RTP parse context for stream 'st'.
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
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.
int ff_rtsp_connect(AVFormatContext *s)
Connect to the RTSP server and set up the individual media streams.
Standards-compliant RTP-server.
int reordering_queue_size
Size of RTP packet reordering queue.
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 get_parameter_supported
Whether the server supports the GET_PARAMETER method.
#define CONFIG_RTSP_DEMUXER
const char * av_default_item_name(void *ctx)
Return the context name.
int ttl
time-to-live value (required for multicast); the amount of HOPs that packets will be allowed to make ...
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...
int ff_network_init(void)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
miscellaneous OS support macros and functions.
int feedback
Enable sending RTCP feedback messages according to RFC 4585.
static av_cold int end(AVCodecContext *avctx)
PayloadContext *(* alloc)(void)
Allocate any data needed by the rtp parsing for this dynamic data.
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
int id
Format-specific stream ID.
#define DEFAULT_REORDERING_DELAY
void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf, RTSPState *rt, const char *method)
void(* free)(PayloadContext *protocol_data)
Free any data needed by the rtp parsing for this dynamic data.
const char * name
Name of the codec implementation.
static void handler(vbi_event *ev, void *user_data)
int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, char *value, int value_size)
int accept_dynamic_rate
Whether the server accepts the x-Dynamic-Rate header.
URLContext * rtsp_hd_out
Additional output handle, used when input and output are done separately, eg for HTTP tunneling...
Describe a single stream, as identified by a single m= line block in the SDP content.
Custom IO - not a public option for lower_transport_mask, but set in the SDP demuxer based on a flag...
#define CONFIG_RTSP_MUXER
void ff_http_init_auth_state(URLContext *dest, const URLContext *src)
Initialize the authentication state based on another HTTP URLContext.
#define AV_LOG_VERBOSE
Detailed information.
static av_cold int read_close(AVFormatContext *ctx)
const uint8_t ff_log2_tab[256]
int ff_rtsp_parse_streaming_commands(AVFormatContext *s)
Parse RTSP commands (OPTIONS, PAUSE and TEARDOWN) during streaming in listen mode.
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.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
const OptionDef options[]
#define RTSP_DEFAULT_AUDIO_SAMPLERATE
void ff_rdt_parse_close(RDTDemuxContext *s)
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const
Rescale a 64-bit integer by 2 rational numbers.
int ff_sdp_parse(AVFormatContext *s, const char *content)
Parse an SDP description of streams by populating an RTSPState struct within the AVFormatContext; als...
struct RTSPSource ** exclude_source_addrs
Source-specific multicast exclude source IP addresses (from SDP content)
Private data for the RTSP demuxer.
int64_t last_cmd_time
timestamp of the last RTSP command that we sent to the RTSP server.
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...
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));returnNULL;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);returnNULL;}returnac;}in_planar=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);ff_audio_convert_init_arm(ac);ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
Return the file descriptors associated with this URL.
int timeout
copy of RTSPMessageHeader->timeout, i.e.
void * priv_data
Format private data.
char filename[1024]
input or output filename
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
const AVOption ff_rtsp_options[]
struct AVInputFormat * iformat
Can only be iformat or oformat, not both at the same time.
enum RTSPControlTransport control_transport
RTSP transport mode, such as plain or tunneled.
struct RTSPSource ** include_source_addrs
Source-specific multicast include source IP addresses (from SDP content)
int ffio_read_partial(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
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.
RTPDynamicProtocolHandler * ff_rtp_handler_find_by_id(int id, enum AVMediaType codec_type)
struct RTSPStream ** rtsp_streams
streams in this session
int ff_rtp_get_codec_info(AVCodecContext *codec, int payload_type)
Initialize a codec context based on the payload type.
int stream_index
corresponding stream index, if any.
MpegTSContext * ff_mpegts_parse_open(AVFormatContext *s)
int buf_size
Size of buf except extra allocated bytes.
int seq
RTSP command sequence number.
uint8_t * recvbuf
Reusable buffer for receiving packets.
unsigned int nb_streams
A list of all streams in the file.
#define RTSP_FLAG_CUSTOM_IO
Do all IO via the AVIOContext.
AVFormatContext * asf_ctx
The following are used for RTP/ASF streams.
int64_t av_gettime(void)
Get the current time in microseconds.
int nb_rtsp_streams
number of items in the 'rtsp_streams' variable
Opaque data information usually continuous.
int64_t first_rtcp_ntp_time
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
void * cur_transport_priv
RTSPStream->transport_priv of the last stream that we read a packet from.
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
#define RTSP_TCP_MAX_PACKET_SIZE
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
HTTP tunneled - not a proper transport mode as such, only for use via AVOptions.
This describes a single item in the "Transport:" line of one stream as negotiated by the SETUP RTSP c...
RTSP over HTTP (tunneling)
static void get_word_until_chars(char *buf, int buf_size, const char *sep, const char **pp)
static void get_word(char *buf, int buf_size, const char **pp)
int(* parse_sdp_a_line)(AVFormatContext *s, int st_index, PayloadContext *priv_data, const char *line)
Parse the a= line from the sdp field.
int ffurl_get_file_handle(URLContext *h)
Return the file descriptor associated with this URL.
int sdp_port
The following are used only in SDP, not RTSP.
int ff_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt, const uint8_t *buf, int len)
struct MpegTSContext * ts
The following are used for parsing raw mpegts in udp.
int stale
Auth ok, but needs to be resent with a new nonce.
int sdp_payload_type
payload type
void ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx, RTPDynamicProtocolHandler *handler)
int nb_exclude_source_addrs
Number of source-specific multicast exclude source IP addresses (from SDP content) ...
static int get_sockaddr(const char *buf, struct sockaddr_storage *sock)
static int read_header(FFV1Context *f)
int ff_rtp_send_rtcp_feedback(RTPDemuxContext *s, URLContext *fd, AVIOContext *avio)
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
int ff_url_join(char *str, int size, const char *proto, const char *authorization, const char *hostname, int port, const char *fmt,...)
enum RTSPLowerTransport lower_transport
the negotiated network layer transport protocol; e.g.
char addr[128]
Source-specific multicast include source IP address (from SDP content)
#define AV_LOG_INFO
Standard information.
struct sockaddr_storage sdp_ip
IP address (from SDP content)
enum AVMediaType codec_type
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrup a blocking function associated with cb.
int sample_rate
samples per second
int media_type_mask
Mask of all requested media types.
#define FF_RTP_FLAG_OPTS(ctx, fieldname)
main external API structure.
#define RTSP_FLAG_OPTS(name, longname)
RDTDemuxContext * ff_rdt_parse_open(AVFormatContext *ic, int first_stream_of_set_idx, void *priv_data, RTPDynamicProtocolHandler *handler)
Allocate and init the RDT parsing context.
#define RTSP_FLAG_FILTER_SRC
Filter incoming UDP packets - receive packets only from the right source address and port...
enum RTSPTransport transport
the negotiated data/packet transport protocol; e.g.
AVIOContext * pb
I/O context.
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...
static int read_packet(AVFormatContext *ctx, AVPacket *pkt)
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 rtsp_flags
Various option flags for the RTSP muxer/demuxer.
Describe the class of an AVClass context structure.
void ff_real_parse_sdp_a_line(AVFormatContext *s, int stream_index, const char *line)
Parse a server-related SDP line.
PayloadContext * dynamic_protocol_context
private data associated with the dynamic protocol
char last_reply[2048]
The last reply of the server to a RTSP command.
enum RTSPTransport transport
data/packet transport protocol; e.g.
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
#define RTSP_MEDIATYPE_OPTS(name, longname)
int64_t ff_rtp_queued_packet_time(RTPDemuxContext *s)
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.
void ff_rtsp_close_streams(AVFormatContext *s)
Close and free all streams within the RTSP (de)muxer.
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...
Usually treated as AVMEDIA_TYPE_DATA.
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
This structure contains the data a format has to probe a file.
#define RTSP_DEFAULT_NB_AUDIO_CHANNELS
char * ff_http_auth_create_response(HTTPAuthState *state, const char *auth, const char *path, const char *method)
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...
#define RTP_PT_IS_RTCP(x)
enum RTSPServerType server_type
brand of server that we're talking to; e.g.
int ffurl_close(URLContext *h)
int64_t start_time
Decoding: position of the first frame of the component, in AV_TIME_BASE fractional seconds...
enum RTSPClientState state
indicator of whether we are currently receiving data from the server.
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...
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
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.
static const AVOption sdp_options[]
void ff_mpegts_parse_close(MpegTSContext *ts)
int ff_rtp_chain_mux_open(AVFormatContext **out, AVFormatContext *s, AVStream *st, URLContext *handle, int packet_size, int idx)
RTPDynamicProtocolHandler * ff_rtp_handler_find_by_name(const char *name, enum AVMediaType codec_type)
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))
int ffurl_open(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create an URLContext for accessing to the resource indicated by url, and open it. ...
int need_subscription
The following are used for Real stream selection.
RTPDynamicProtocolHandler * dynamic_handler
The following are used for dynamic protocols (rtpdec_*.c/rdt.c)
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...
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...
#define RTSP_REORDERING_OPTS()
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
void ff_http_auth_handle_header(HTTPAuthState *state, const char *key, const char *value)
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 stimeout
timeout of socket i/o operations.
struct AVOutputFormat * oformat
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.
static void get_word_sep(char *buf, int buf_size, const char *sep, const char **pp)
#define AVERROR_INVALIDDATA
TCP; interleaved in RTSP.
HTTPAuthState auth_state
authentication state
#define RTSP_RTP_PORT_MIN
int channels
number of audio channels
char control_url[1024]
url for this stream (from SDP)
int ff_rtsp_setup_input_streams(AVFormatContext *s, RTSPMessageHeader *reply)
Get the description of the stream and set up the RTSPStream child objects.
void ff_rtp_parse_close(RTPDemuxContext *s)
int sdp_ttl
IP Time-To-Live (from SDP content)
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
int64_t duration
Decoding: duration of the stream, in AV_TIME_BASE fractional seconds.
HTTPAuthType auth_type
The currently chosen auth type.
int lower_transport_mask
A mask with all requested transport methods.
unbuffered private I/O API
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
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.
struct sockaddr_storage destination
destination IP address
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...
#define RTP_REORDER_QUEUE_DEFAULT_SIZE
int interleaved_min
interleave IDs; copies of RTSPTransportField->interleaved_min/max for the selected transport...
This structure stores compressed data.
int server_port_min
UDP unicast server port range; the ports to which we should connect to receive unicast UDP RTP/RTCP d...
void ff_rtsp_close_connections(AVFormatContext *s)
Close all connection handles within the RTSP (de)muxer.
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
static const AVOption rtp_options[]
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...
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...) av_printf_format(3
Append output to a string, according to a format.
URLContext * rtp_handle
RTP stream handle (if UDP)
#define AV_NOPTS_VALUE
Undefined timestamp value.
int port_min
UDP multicast port range; the ports to which we should connect to receive multicast UDP data...
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
void * transport_priv
RTP/RDT parse context if input, RTP AVFormatContext if output.
No authentication specified.
int client_port_min
UDP client ports; these should be the local ports of the UDP RTP (and RTCP) sockets over which we rec...