22 #include "libavutil/base64.h"
23 #include "libavutil/avstring.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/mathematics.h"
26 #include "libavutil/parseutils.h"
27 #include "libavutil/random_seed.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/time.h"
54 #define POLL_TIMEOUT_MS 100
55 #define READ_PACKET_TIMEOUT_S 10
56 #define MAX_TIMEOUTS READ_PACKET_TIMEOUT_S * 1000 / POLL_TIMEOUT_MS
57 #define SDP_MAX_SIZE 16384
58 #define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH
59 #define DEFAULT_REORDERING_DELAY 100000
61 #define OFFSET(x) offsetof(RTSPState, x)
62 #define DEC AV_OPT_FLAG_DECODING_PARAM
63 #define ENC AV_OPT_FLAG_ENCODING_PARAM
65 #define RTSP_FLAG_OPTS(name, longname) \
66 { name, longname, OFFSET(rtsp_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtsp_flags" }, \
67 { "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" }
69 #define RTSP_MEDIATYPE_OPTS(name, longname) \
70 { 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" }, \
71 { "video", "Video", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_VIDEO}, 0, 0, DEC, "allowed_media_types" }, \
72 { "audio", "Audio", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_AUDIO}, 0, 0, DEC, "allowed_media_types" }, \
73 { "data", "Data", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_DATA}, 0, 0, DEC, "allowed_media_types" }
75 #define RTSP_REORDERING_OPTS() \
76 { "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 }
79 {
"initial_pause",
"Don't start playing the stream immediately",
OFFSET(initial_pause),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1,
DEC },
81 {
"rtsp_transport",
"RTSP transport protocols",
OFFSET(lower_transport_mask),
AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX,
DEC|
ENC,
"rtsp_transport" }, \
91 {
"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 },
112 const char *sep,
const char **pp)
120 while (!strchr(sep, *p) && *p !=
'\0') {
121 if ((q - buf) < buf_size - 1)
133 if (**pp ==
'/') (*pp)++;
137 static void get_word(
char *buf,
int buf_size,
const char **pp)
172 memcpy(sock, ai->ai_addr,
FFMIN(
sizeof(*sock), ai->ai_addrlen));
186 if (handler->
alloc) {
196 int payload_type,
const char *p)
218 init_rtp_handler(handler, rtsp_st, codec);
271 char *value,
int value_size)
286 typedef struct SDPParseState {
291 int nb_default_include_source_addrs;
292 struct RTSPSource **default_include_source_addrs;
293 int nb_default_exclude_source_addrs;
294 struct RTSPSource **default_exclude_source_addrs;
297 char delayed_fmtp[2048];
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 payload_type,
const char *
line)
332 int letter,
const char *buf)
335 char buf1[64], st_type[64];
345 av_dlog(s,
"sdp: %c='%s'\n", letter, buf);
348 if (s1->skip_media && letter !=
'm')
353 if (strcmp(buf1,
"IN") != 0)
356 if (strcmp(buf1,
"IP4") && strcmp(buf1,
"IP6"))
368 s1->default_ip = sdp_ip;
369 s1->default_ttl = ttl;
391 get_word(st_type,
sizeof(st_type), &p);
392 if (!strcmp(st_type,
"audio")) {
394 }
else if (!strcmp(st_type,
"video")) {
396 }
else if (!strcmp(st_type,
"application")) {
409 rtsp_st->
sdp_ip = s1->default_ip;
410 rtsp_st->
sdp_ttl = s1->default_ttl;
412 copy_default_source_addrs(s1->default_include_source_addrs,
413 s1->nb_default_include_source_addrs,
416 copy_default_source_addrs(s1->default_exclude_source_addrs,
417 s1->nb_default_exclude_source_addrs,
425 if (!strcmp(buf1,
"udp"))
427 else if (strstr(buf1,
"/AVPF") || strstr(buf1,
"/SAVPF"))
443 init_rtp_handler(handler, rtsp_st,
NULL);
444 if (handler && handler->
init)
468 init_rtp_handler(handler, rtsp_st, st->
codec);
469 if (handler && handler->
init)
481 if (!strncmp(p,
"rtsp://", 7))
492 if (proto[0] ==
'\0') {
506 payload_type = atoi(buf1);
510 sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p);
514 parse_fmtp(s, rt, payload_type, s1->delayed_fmtp);
520 payload_type = atoi(buf1);
521 if (s1->seen_rtpmap) {
525 av_strlcpy(s1->delayed_fmtp, buf,
sizeof(s1->delayed_fmtp));
536 }
else if (
av_strstart(p,
"IsRealDataType:integer;",&p)) {
539 }
else if (
av_strstart(p,
"SampleRate:integer;", &p) &&
554 if (strcmp(buf1,
"incl") && strcmp(buf1,
"excl"))
556 exclude = !strcmp(buf1,
"excl");
559 if (strcmp(buf1,
"IN") != 0)
562 if (strcmp(buf1,
"IP4") && strcmp(buf1,
"IP6") && strcmp(buf1,
"*"))
574 dynarray_add(&s1->default_exclude_source_addrs, &s1->nb_default_exclude_source_addrs, rtsp_src);
581 dynarray_add(&s1->default_include_source_addrs, &s1->nb_default_include_source_addrs, rtsp_src);
622 SDPParseState sdp_parse_state = { { 0 } }, *s1 = &sdp_parse_state;
636 while (*p !=
'\n' && *p !=
'\r' && *p !=
'\0') {
637 if ((q - buf) <
sizeof(buf) - 1)
642 sdp_parse_line(s, s1, letter, buf);
644 while (*p !=
'\n' && *p !=
'\0')
650 for (i = 0; i < s1->nb_default_include_source_addrs; i++)
651 av_free(s1->default_include_source_addrs[i]);
652 av_freep(&s1->default_include_source_addrs);
653 for (i = 0; i < s1->nb_default_exclude_source_addrs; i++)
654 av_free(s1->default_exclude_source_addrs[i]);
655 av_freep(&s1->default_exclude_source_addrs);
737 if (reordering_queue_size < 0) {
739 reordering_queue_size = 0;
769 reordering_queue_size);
788 #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
789 static void rtsp_parse_range(
int *min_ptr,
int *max_ptr,
const char **pp)
797 v = strtol(q, &p, 10);
801 v = strtol(p, &p, 10);
813 char transport_protocol[16];
815 char lower_transport[16];
829 get_word_sep(transport_protocol,
sizeof(transport_protocol),
833 lower_transport[0] =
'\0';
840 }
else if (!
av_strcasecmp (transport_protocol,
"x-pn-tng") ||
843 get_word_sep(lower_transport,
sizeof(lower_transport),
"/;,", &p);
848 lower_transport[0] =
'\0';
864 while (*p !=
'\0' && *p !=
',') {
866 if (!strcmp(parameter,
"port")) {
871 }
else if (!strcmp(parameter,
"client_port")) {
877 }
else if (!strcmp(parameter,
"server_port")) {
883 }
else if (!strcmp(parameter,
"interleaved")) {
889 }
else if (!strcmp(parameter,
"multicast")) {
892 }
else if (!strcmp(parameter,
"ttl")) {
896 th->
ttl = strtol(p, &end, 10);
899 }
else if (!strcmp(parameter,
"destination")) {
905 }
else if (!strcmp(parameter,
"source")) {
911 }
else if (!strcmp(parameter,
"mode")) {
915 if (!strcmp(buf,
"record") ||
916 !strcmp(buf,
"receive"))
921 while (*p !=
';' && *p !=
'\0' && *p !=
',')
933 static void handle_rtp_info(
RTSPState *rt,
const char *url,
934 uint32_t seq, uint32_t rtptime)
937 if (!rtptime || !url[0])
953 static void rtsp_parse_rtp_info(
RTSPState *rt,
const char *p)
956 char key[20], value[1024], url[1024] =
"";
957 uint32_t seq = 0, rtptime = 0;
969 if (!strcmp(key,
"url"))
971 else if (!strcmp(key,
"seq"))
972 seq = strtoul(value,
NULL, 10);
973 else if (!strcmp(key,
"rtptime"))
974 rtptime = strtoul(value,
NULL, 10);
976 handle_rtp_info(rt, url, seq, rtptime);
985 handle_rtp_info(rt, url, seq, rtptime);
999 (t = strtol(p,
NULL, 10)) > 0) {
1005 rtsp_parse_transport(reply, p);
1007 reply->
seq = strtol(p,
NULL, 10);
1022 }
else if (
av_stristart(p,
"WWW-Authenticate:", &p) && rt) {
1025 }
else if (
av_stristart(p,
"Authentication-Info:", &p) && rt) {
1028 }
else if (
av_stristart(p,
"Content-Base:", &p) && rt) {
1030 if (method && !strcmp(method,
"DESCRIBE"))
1034 if (method && !strcmp(method,
"PLAY"))
1035 rtsp_parse_rtp_info(rt, p);
1037 if (strstr(p,
"GET_PARAMETER") &&
1038 method && !strcmp(method,
"OPTIONS"))
1040 }
else if (
av_stristart(p,
"x-Accept-Dynamic-Rate:", &p) && rt) {
1061 av_dlog(s,
"skipping RTP packet len=%d\n", len);
1066 if (len1 >
sizeof(buf))
1076 unsigned char **content_ptr,
1077 int return_on_interleaved_data,
const char *method)
1080 char buf[4096], buf1[1024], *q;
1083 int ret, content_length, line_count = 0, request = 0;
1084 unsigned char *content =
NULL;
1090 memset(reply, 0,
sizeof(*reply));
1098 av_dlog(s,
"ret=%d c=%02x [%c]\n", ret, ch, ch);
1105 if (return_on_interleaved_data) {
1109 }
else if (ch !=
'\r') {
1110 if ((q - buf) <
sizeof(buf) - 1)
1116 av_dlog(s,
"line='%s'\n", buf);
1122 if (line_count == 0) {
1125 if (!strncmp(buf1,
"RTSP/", 5)) {
1146 if (content_length > 0) {
1148 content =
av_malloc(content_length + 1);
1150 content[content_length] =
'\0';
1153 *content_ptr = content;
1160 const char* ptr = buf;
1162 if (!strcmp(reply->
reason,
"OPTIONS")) {
1163 snprintf(buf,
sizeof(buf),
"RTSP/1.0 200 OK\r\n");
1170 snprintf(buf,
sizeof(buf),
"RTSP/1.0 501 Not Implemented\r\n");
1195 if (rt->
seq != reply->
seq) {
1201 if (reply->
notice == 2101 ||
1203 reply->
notice == 2306 ) {
1205 }
else if (reply->
notice >= 4400 && reply->
notice < 5500) {
1207 }
else if (reply->
notice == 2401 ||
1228 const char *method,
const char *url,
1229 const char *headers,
1230 const unsigned char *send_content,
1231 int send_content_length)
1234 char buf[4096], *out_buf;
1240 snprintf(buf,
sizeof(buf),
"%s %s RTSP/1.0\r\n", method, url);
1245 if (rt->
session_id[0] !=
'\0' && (!headers ||
1246 !strstr(headers,
"\nIf-Match:"))) {
1251 rt->
auth, url, method);
1256 if (send_content_length > 0 && send_content)
1257 av_strlcatf(buf,
sizeof(buf),
"Content-Length: %d\r\n", send_content_length);
1263 out_buf = base64buf;
1266 av_dlog(s,
"Sending:\n%s--\n", buf);
1269 if (send_content_length > 0 && send_content) {
1272 "with content data not supported\n");
1283 const char *url,
const char *headers)
1285 return rtsp_send_cmd_with_content_async(s, method, url, headers,
NULL, 0);
1290 unsigned char **content_ptr)
1293 content_ptr,
NULL, 0);
1297 const char *method,
const char *url,
1300 unsigned char **content_ptr,
1301 const unsigned char *send_content,
1302 int send_content_length)
1306 int ret, attempts = 0;
1310 if ((ret = rtsp_send_cmd_with_content_async(s, method, url, header,
1312 send_content_length)))
1336 int lower_transport,
const char *real_challenge)
1339 int rtx = 0, j, i, err, interleave = 0, port_off;
1343 const char *trans_pref;
1346 trans_pref =
"x-pn-tng";
1348 trans_pref =
"RAW/RAW";
1350 trans_pref =
"RTP/AVP";
1364 port_off -= port_off & 0x01;
1366 for (j = rt->
rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) {
1367 char transport[2048];
1403 while (j <= rt->rtp_port_max) {
1405 "?localport=%d", j);
1420 snprintf(transport,
sizeof(transport) - 1,
1421 "%s/UDP;", trans_pref);
1423 av_strlcat(transport,
"unicast;",
sizeof(transport));
1425 "client_port=%d", port);
1428 av_strlcatf(transport,
sizeof(transport),
"-%d", port + 1);
1441 snprintf(transport,
sizeof(transport) - 1,
1442 "%s/TCP;", trans_pref);
1444 av_strlcat(transport,
"unicast;",
sizeof(transport));
1446 "interleaved=%d-%d",
1447 interleave, interleave + 1);
1452 snprintf(transport,
sizeof(transport) - 1,
1453 "%s/UDP;multicast", trans_pref);
1456 av_strlcat(transport,
";mode=record",
sizeof(transport));
1459 av_strlcat(transport,
";mode=play",
sizeof(transport));
1460 snprintf(cmd,
sizeof(cmd),
1461 "Transport: %s\r\n",
1464 av_strlcat(cmd,
"x-Dynamic-Rate: 0\r\n",
sizeof(cmd));
1466 char real_res[41], real_csum[9];
1471 "RealChallenge2: %s, sd=%s\r\n",
1511 char url[1024],
options[30] =
"";
1512 const char *peer = host;
1515 av_strlcpy(options,
"?connect=1",
sizeof(options));
1536 char url[1024], namebuf[50], optbuf[20] =
"";
1550 snprintf(optbuf,
sizeof(optbuf),
"?ttl=%d", ttl);
1551 getnameinfo((
struct sockaddr*) &addr,
sizeof(addr),
1554 port,
"%s", optbuf);
1592 char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1593 int port, err, tcp_fd;
1595 int lower_transport_mask = 0;
1596 char real_challenge[64] =
"";
1598 socklen_t peer_len =
sizeof(peer);
1625 host,
sizeof(host), &port, path,
sizeof(path), s->
filename);
1632 if (!lower_transport_mask)
1641 "only UDP and TCP are supported for output.\n");
1651 host, port,
"%s", path);
1655 char httpname[1024];
1656 char sessioncookie[17];
1659 ff_url_join(httpname,
sizeof(httpname),
"http", auth, host, port,
"%s", path);
1660 snprintf(sessioncookie,
sizeof(sessioncookie),
"%08x%08x",
1671 snprintf(headers,
sizeof(headers),
1672 "x-sessioncookie: %s\r\n"
1673 "Accept: application/x-rtsp-tunnelled\r\n"
1674 "Pragma: no-cache\r\n"
1675 "Cache-Control: no-cache\r\n",
1693 snprintf(headers,
sizeof(headers),
1694 "x-sessioncookie: %s\r\n"
1695 "Content-Type: application/x-rtsp-tunnelled\r\n"
1696 "Pragma: no-cache\r\n"
1697 "Cache-Control: no-cache\r\n"
1698 "Content-Length: 32767\r\n"
1699 "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1740 if (!getpeername(tcp_fd, (
struct sockaddr*) &peer, &peer_len)) {
1741 getnameinfo((
struct sockaddr*) &peer, peer_len, host,
sizeof(host),
1760 "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1761 "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1762 "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1763 "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1790 int lower_transport =
ff_log2_tab[lower_transport_mask &
1791 ~(lower_transport_mask - 1)];
1795 real_challenge :
NULL);
1798 lower_transport_mask &= ~(1 << lower_transport);
1799 if (lower_transport_mask == 0 && err == 1) {
1800 err =
AVERROR(EPROTONOSUPPORT);
1827 uint8_t *buf,
int buf_size, int64_t wait_end)
1831 int n, i, ret, tcp_fd, timeout_cnt = 0;
1833 struct pollfd *p = rt->
p;
1834 int *fds =
NULL, fdsnum, fdsidx;
1844 p[max_p].fd = tcp_fd;
1845 p[max_p++].events = POLLIN;
1859 "Number of fds %d not supported\n", fdsnum);
1862 for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
1863 p[max_p].fd = fds[fdsidx];
1864 p[max_p++].events = POLLIN;
1871 int j = 1 - (tcp_fd == -1);
1876 if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
1879 *prtsp_st = rtsp_st;
1886 #if CONFIG_RTSP_DEMUXER
1887 if (tcp_fd != -1 && p[0].revents & POLLIN) {
1894 "Unable to answer to TEARDOWN\n");
1910 }
else if (n < 0 && errno != EINTR)
1942 "Unable to pick stream for packet - SSRC not known for "
1964 int64_t wait_end = 0;
1986 }
else if (ret == 1) {
1995 int64_t first_queue_time = 0;
2002 if (queue_time && (queue_time - first_queue_time < 0 ||
2003 !first_queue_time)) {
2004 first_queue_time = queue_time;
2008 if (first_queue_time) {
2009 wait_end = first_queue_time + s->
max_delay;
2012 first_queue_st =
NULL;
2025 #if CONFIG_RTSP_DEMUXER
2042 len = pick_stream(s, &rtsp_st, rt->
recvbuf, len);
2047 if (len ==
AVERROR(EAGAIN) && first_queue_st &&
2049 rtsp_st = first_queue_st;
2085 if (rtpctx2 && st && st2 &&
2130 #if CONFIG_SDP_DEMUXER
2136 while (p < p_end && *p !=
'\0') {
2137 if (p +
sizeof(
"c=IN IP") - 1 < p_end &&
2141 while (p < p_end - 1 && *p !=
'\n') p++;
2150 static void append_source_addrs(
char *buf,
int size,
const char *
name,
2156 av_strlcatf(buf, size,
"&%s=%s", name, addrs[0]->addr);
2157 for (i = 1; i < count; i++)
2185 content[
size] =
'\0';
2201 "?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2206 append_source_addrs(url,
sizeof(url),
"sources",
2209 append_source_addrs(url,
sizeof(url),
"block",
2235 static const AVClass sdp_demuxer_class = {
2250 .priv_class = &sdp_demuxer_class,
2254 #if CONFIG_RTP_DEMUXER
2265 char host[500], sdp[500];
2272 socklen_t addrlen =
sizeof(addr);
2284 ret =
ffurl_read(in, recvbuf,
sizeof(recvbuf));
2294 if ((recvbuf[0] & 0xc0) != 0x80) {
2303 payload_type = recvbuf[1] & 0x7f;
2312 "without an SDP file describing it\n",
2318 "properly you need an SDP file "
2325 snprintf(sdp,
sizeof(sdp),
2326 "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",
2327 addr.ss_family == AF_INET ? 4 : 6, host,
2330 port, payload_type);
2341 ret = sdp_read_header(s);
2352 static const AVClass rtp_demuxer_class = {
2368 .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_INVALIDDATA
Invalid data found when processing input.
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_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.
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
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){if(!*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));if(!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=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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);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 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)
#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
Flags signalling stream properties.
#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.
Opaque data information usually continuous.
int ttl
time-to-live value (required for multicast); the amount of HOPs that packets will be allowed to make ...
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.
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)
const char * name
Name of the codec implementation.
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 AVERROR_EOF
End of file.
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[]
static int parse_fmtp(AVFormatContext *s, AVStream *stream, PayloadContext *data, char *attr, char *value)
#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(). ...
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
The input container format.
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
Number of elements in AVFormatContext.streams.
#define RTSP_FLAG_CUSTOM_IO
Do all IO via the AVIOContext.
AVFormatContext * asf_ctx
The following are used for RTP/ASF streams.
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...
int64_t av_gettime(void)
Get the current time in microseconds.
int nb_rtsp_streams
number of items in the 'rtsp_streams' variable
int64_t first_rtcp_ntp_time
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes.
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)
#define RTSP_TCP_MAX_PACKET_SIZE
AVStream ** streams
A list of all streams in the file.
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)
int ff_rtsp_tcp_write_packet(AVFormatContext *s, RTSPStream *rtsp_st)
Send buffered packets over TCP.
static void get_word(char *buf, int buf_size, const char **pp)
Usually treated as AVMEDIA_TYPE_DATA.
int ffurl_get_file_handle(URLContext *h)
Return the file descriptor associated with this URL.
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
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)
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
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
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...
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(* parse_sdp_a_line)(AVFormatContext *s, int st_index, PayloadContext *priv_data, const char *line)
Parse the a= line from the sdp field.
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.
PayloadContext *(* alloc)(void)
Allocate any data needed by the rtp parsing for this dynamic data.
AVDictionary * metadata
Metadata that applies to the whole file.
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...
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)
Close the resource accessed by the URLContext h, and free the memory used by it.
int64_t start_time
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(* free)(PayloadContext *protocol_data)
Free any data needed by the rtp parsing for this dynamic data.
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...
struct AVOutputFormat * oformat
The output container format.
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)
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
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 random data.
av_default_item_name
Return the context name.
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...