50 #define APP_MAX_LENGTH 1024 51 #define TCURL_MAX_LENGTH 1024 52 #define FLASHVER_MAX_LENGTH 64 53 #define RTMP_PKTDATA_DEFAULT_SIZE 4096 54 #define RTMP_HEADER 11 112 char swfverification[42];
128 char auth_params[500];
133 #define PLAYER_KEY_OPEN_PART_LEN 30 136 'G',
'e',
'n',
'u',
'i',
'n',
'e',
' ',
'A',
'd',
'o',
'b',
'e',
' ',
137 'F',
'l',
'a',
's',
'h',
' ',
'P',
'l',
'a',
'y',
'e',
'r',
' ',
'0',
'0',
'1',
139 0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
140 0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
141 0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
144 #define SERVER_KEY_OPEN_PART_LEN 36 147 'G',
'e',
'n',
'u',
'i',
'n',
'e',
' ',
'A',
'd',
'o',
'b',
'e',
' ',
148 'F',
'l',
'a',
's',
'h',
' ',
'M',
'e',
'd',
'i',
'a',
' ',
149 'S',
'e',
'r',
'v',
'e',
'r',
' ',
'0',
'0',
'1',
151 0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
152 0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
153 0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
191 char **tracked_method)
266 if (param[0] && param[1] ==
':') {
269 }
else if (param[0] ==
'N' && param[1] && param[2] ==
':') {
272 value = strchr(field,
':');
376 char *param = rt->
conn;
381 param += strspn(param,
" ");
384 sep = strchr(param,
' ');
406 #define RTMP_CTRL_ABORT_MESSAGE (2) 465 if (strcmp(command,
"connect")) {
476 "app", tmpstr,
sizeof(tmpstr));
479 if (!ret && strcmp(tmpstr, rt->
app))
506 bytestream_put_byte(&p, 2);
520 bytestream_put_be16(&p, 0);
521 bytestream_put_be32(&p, 0);
752 bytestream_put_be16(&p, 3);
873 if (ppkt->
size < 6) {
884 bytestream_put_be16(&p, 7);
905 bytestream_put_be16(&p, 27);
971 const char *subscribe)
978 0, 27 + strlen(subscribe))) < 0)
1000 int ret, digest_pos;
1026 int ret, digest_pos;
1036 if (!memcmp(digest, buf + digest_pos, 32))
1049 "Hash of the decompressed SWF file is not 32 bytes long.\n");
1054 bytestream_put_byte(&p, 1);
1055 bytestream_put_byte(&p, 1);
1056 bytestream_put_be32(&p, rt->
swfsize);
1057 bytestream_put_be32(&p, rt->
swfsize);
1066 static int rtmp_uncompress_swfplayer(
uint8_t *in_data, int64_t in_size,
1069 z_stream zs = { 0 };
1074 zs.avail_in = in_size;
1075 zs.next_in = in_data;
1076 ret = inflateInit(&zs);
1083 zs.avail_out =
sizeof(tmp_buf);
1084 zs.next_out = tmp_buf;
1086 ret =
inflate(&zs, Z_NO_FLUSH);
1087 if (ret != Z_OK && ret != Z_STREAM_END) {
1092 size =
sizeof(tmp_buf) - zs.avail_out;
1093 if (!(ptr =
av_realloc(*out_data, *out_size + size))) {
1099 memcpy(*out_data + *out_size, tmp_buf, size);
1101 }
while (zs.avail_out == 0);
1145 if (!memcmp(in_data,
"CWS", 3)) {
1154 memcpy(out_data, in_data, 8);
1157 if ((ret = rtmp_uncompress_swfplayer(in_data + 8, in_size - 8,
1158 &out_data, &out_size)) < 0)
1164 "Zlib is required for decompressing the SWF player file.\n");
1175 "Genuine Adobe Flash Player 001", 30,
1210 int server_pos, client_pos;
1221 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->
encrypted) {
1261 serverdata[5], serverdata[6], serverdata[7], serverdata[8]);
1263 if (rt->
is_input && serverdata[5] >= 3) {
1295 0, digest, 32, signature);
1299 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->
encrypted) {
1303 tosend + 1, type)) < 0)
1325 tosend + RTMP_HANDSHAKE_PACKET_SIZE - 32);
1329 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->
encrypted) {
1332 RTMP_HANDSHAKE_PACKET_SIZE - 32, digest,
1338 RTMP_HANDSHAKE_PACKET_SIZE)) < 0)
1341 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->
encrypted) {
1347 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->
encrypted) {
1351 tosend + 1, 1)) < 0)
1354 if (serverdata[0] == 9) {
1365 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->
encrypted) {
1376 uint32_t *second_int,
char *arraydata,
1387 " not following standard\n", (
int)inoutsize);
1391 *first_int =
AV_RB32(arraydata);
1392 *second_int =
AV_RB32(arraydata + 4);
1397 uint32_t second_int,
char *arraydata,
int size)
1401 AV_WB32(arraydata, first_int);
1402 AV_WB32(arraydata + 4, second_int);
1420 uint32_t hs_my_epoch;
1430 if (inoutsize <= 0) {
1435 if (buffer[0] != 3) {
1441 "Unable to write answer - RTMP S0\n");
1453 hs_my_epoch = hs_epoch;
1479 if (temp != hs_my_epoch)
1481 "Erroneous C2 Message epoch does not match up with C1 epoch\n");
1482 if (memcmp(buffer + 8, hs_s1 + 8,
1485 "Erroneous C2 Message random does not match up\n");
1495 if (pkt->
size < 4) {
1497 "Too short chunk size change packet (%d)\n",
1528 if (pkt->
size < 2) {
1536 if ((ret =
gen_pong(s, rt, pkt)) < 0)
1538 }
else if (t == 26) {
1554 if (pkt->
size < 4) {
1556 "Peer bandwidth packet is less than 4 bytes long (%d)\n",
1581 if (pkt->
size < 4) {
1583 "Too short window acknowledgement size packet (%d)\n",
1604 const char *opaque,
const char *challenge)
1632 "?authmod=%s&user=%s&challenge=%s&response=%s",
1633 "adobe", user, challenge2, hashstr);
1636 "&opaque=%s", opaque);
1645 char hashstr1[33], hashstr2[33];
1646 const char *realm =
"live";
1647 const char *method =
"publish";
1648 const char *qop =
"auth";
1649 const char *nc =
"00000001";
1665 hashstr1[32] =
'\0';
1671 if (!strchr(rt->
app,
'/'))
1675 hashstr2[32] =
'\0';
1694 "?authmod=%s&user=%s&nonce=%s&cnonce=%s&nc=%s&response=%s",
1695 "llnw", user, nonce, cnonce, nc, hashstr1);
1704 char buf[300], *ptr, authmod[15];
1706 const char *user =
"", *salt =
"", *opaque =
NULL,
1709 if (!(cptr = strstr(desc,
"authmod=adobe")) &&
1710 !(cptr = strstr(desc,
"authmod=llnw"))) {
1712 "Unknown connect error (unsupported authentication method?)\n");
1715 cptr += strlen(
"authmod=");
1716 while (*cptr && *cptr !=
' ' && i <
sizeof(authmod) - 1)
1717 authmod[i++] = *cptr++;
1725 if (strstr(desc,
"?reason=authfailed")) {
1728 }
else if (strstr(desc,
"?reason=nosuchuser")) {
1740 if (strstr(desc,
"code=403 need auth")) {
1742 "?authmod=%s&user=%s", authmod, rt->
username);
1746 if (!(cptr = strstr(desc,
"?reason=needauth"))) {
1755 char *next = strchr(ptr,
'&');
1756 char *
value = strchr(ptr,
'=');
1761 if (!strcmp(ptr,
"user")) {
1763 }
else if (!strcmp(ptr,
"salt")) {
1765 }
else if (!strcmp(ptr,
"opaque")) {
1767 }
else if (!strcmp(ptr,
"challenge")) {
1769 }
else if (!strcmp(ptr,
"nonce")) {
1780 if (!strcmp(authmod,
"adobe")) {
1796 char *tracked_method =
NULL;
1805 "description", tmpstr,
sizeof(tmpstr))) {
1806 if (tracked_method && (!strcmp(tracked_method,
"_checkbw") ||
1807 !strcmp(tracked_method,
"releaseStream") ||
1808 !strcmp(tracked_method,
"FCSubscribe") ||
1809 !strcmp(tracked_method,
"FCPublish"))) {
1813 }
else if (tracked_method && !strcmp(tracked_method,
"getStreamLength")) {
1816 }
else if (tracked_method && !strcmp(tracked_method,
"connect")) {
1824 av_log(s, level,
"Server error: %s\n", tmpstr);
1846 bytestream2_put_be16(&pbc, 0);
1858 const char *
status,
const char *filename)
1862 char statusmsg[128];
1885 snprintf(statusmsg,
sizeof(statusmsg),
1886 "%s is now published", filename);
1927 if (!strcmp(command,
"FCPublish") ||
1928 !strcmp(command,
"publish")) {
1930 sizeof(filename), &stringlen);
1943 "Unable to find / in url %s, bad format\n",
1948 if (strcmp(pchar, filename))
1950 " %s\n", filename, pchar);
1955 if (!strcmp(command,
"FCPublish")) {
1964 }
else if (!strcmp(command,
"publish")) {
1972 }
else if (!strcmp(command,
"play")) {
1990 if (!strcmp(command,
"createStream")) {
2029 if (strcmp(strbuffer,
"_result"))
2041 *number = numbuffer;
2049 char *tracked_method =
NULL;
2055 if (!tracked_method) {
2060 if (!strcmp(tracked_method,
"connect")) {
2081 }
else if (rt->
live == -1) {
2086 }
else if (!strcmp(tracked_method,
"createStream")) {
2098 if (rt->
live != -1) {
2107 }
else if (!strcmp(tracked_method,
"getStreamLength")) {
2126 for (i = 0; i < 2; i++) {
2134 if (!t && !strcmp(tmpstr,
"error")) {
2136 "description", tmpstr,
sizeof(tmpstr));
2137 if (t || !tmpstr[0])
2139 tmpstr,
sizeof(tmpstr));
2148 if (!t && !strcmp(tmpstr,
"NetStream.Play.UnpublishNotify")) rt->
state =
STATE_STOPPED;
2202 return old_flv_size;
2207 int old_flv_size,
ret;
2227 bytestream2_put_byte(&pbc, pkt->
type);
2228 bytestream2_put_be24(&pbc, size);
2229 bytestream2_put_be24(&pbc, ts);
2230 bytestream2_put_byte(&pbc, ts >> 24);
2231 bytestream2_put_be24(&pbc, 0);
2242 char statusmsg[128];
2243 int stringlen,
ret, skip = 0;
2251 if (!strcmp(commandbuffer,
"onMetaData")) {
2271 if (!strcmp(statusmsg,
"videocodecid")) {
2274 if (!strcmp(statusmsg,
"audiocodecid")) {
2284 if (!strcmp(commandbuffer,
"@setDataFrame")) {
2287 sizeof(statusmsg), &stringlen);
2309 switch (pkt->
type) {
2352 uint32_t ts, cts,
pts = 0;
2368 type = bytestream_get_byte(&next);
2369 size = bytestream_get_be24(&next);
2370 cts = bytestream_get_be24(&next);
2371 cts |= bytestream_get_byte(&next) << 24;
2376 if (size + 3 + 4 > pkt->
data + pkt->
size - next)
2378 bytestream_put_byte(&p, type);
2379 bytestream_put_be24(&p, size);
2380 bytestream_put_be24(&p, ts);
2381 bytestream_put_byte(&p, ts >> 24);
2382 memcpy(p, next, size + 3 + 4);
2385 next += size + 3 + 4;
2389 "RTMP_PT_METADATA packet\n");
2506 for (
i = 0;
i < 2;
i++) {
2544 memcpy(rt->
flv_data, old_flv_data, 13);
2554 bytestream_put_be24(&p, 40);
2555 bytestream_put_be24(&p, 0);
2556 bytestream_put_be32(&p, 0);
2561 bytestream_put_be16(&p, 10);
2566 bytestream_put_be32(&p, 1);
2569 bytestream_put_be16(&p, 8);
2575 bytestream_put_be16(&p, 0);
2594 char proto[8], hostname[256], path[1024], auth[100], *fname;
2595 char *old_app, *qmark, *n, fname_buffer[1024];
2606 hostname,
sizeof(hostname), &port,
2609 n = strchr(path,
' ');
2612 "Detected librtmp style URL parameters, these aren't supported " 2613 "by the libavformat internal RTMP handler currently enabled. " 2614 "See the documentation for the correct way to pass parameters.\n");
2619 char *ptr = strchr(auth,
':');
2627 if (rt->
listen && strcmp(proto,
"rtmp")) {
2632 if (!strcmp(proto,
"rtmpt") || !strcmp(proto,
"rtmpts")) {
2633 if (!strcmp(proto,
"rtmpts"))
2638 }
else if (!strcmp(proto,
"rtmps")) {
2643 }
else if (!strcmp(proto,
"rtmpe") || (!strcmp(proto,
"rtmpte"))) {
2644 if (!strcmp(proto,
"rtmpte"))
2645 av_dict_set(opts,
"ffrtmpcrypt_tunneling",
"1", 1);
2656 "?listen&listen_timeout=%d",
2695 qmark = strchr(path,
'?');
2696 if (qmark && strstr(qmark,
"slist=")) {
2700 fname = strstr(path,
"slist=") + 6;
2702 amp = strchr(fname,
'&');
2705 sizeof(fname_buffer)));
2706 fname = fname_buffer;
2708 }
else if (!strncmp(path,
"/ondemand/", 10)) {
2710 memcpy(rt->
app,
"ondemand", 9);
2712 char *next = *path ? path + 1 : path;
2713 char *p = strchr(next,
'/');
2725 char *
c = strchr(p + 1,
':');
2726 fname = strchr(p + 1,
'/');
2727 if (!fname || (c && c < fname)) {
2750 max_len = strlen(fname) + 5;
2758 int len = strlen(fname);
2759 if (!strchr(fname,
':') && len >= 4 &&
2760 (!strcmp(fname + len - 4,
".f4v") ||
2761 !strcmp(fname + len - 4,
".mp4"))) {
2764 if (len >= 4 && !strcmp(fname + len - 4,
".flv"))
2765 fname[len - 4] =
'\0';
2781 port,
"/%s", rt->
app);
2821 }
while (ret ==
AVERROR(EAGAIN));
2830 for (i = 0; i < 2; i++)
2895 int orig_size =
size;
2901 if (data_left >= size) {
2906 if (data_left > 0) {
2925 "Seek on stream index %d at timestamp %"PRId64
" with flags %08x\n",
2926 stream_index, timestamp, flags);
2927 if ((ret =
gen_seek(s, rt, timestamp)) < 0) {
2929 "Unable to send seek command on stream index %d at timestamp " 2930 "%"PRId64
" with flags %08x\n",
2931 stream_index, timestamp, flags);
2956 int size_temp =
size;
2957 int pktsize, pkttype,
copy;
2959 const uint8_t *buf_temp = buf;
2983 pkttype = bytestream_get_byte(&header);
2984 pktsize = bytestream_get_be24(&header);
2985 ts = bytestream_get_be24(&header);
2986 ts |= bytestream_get_byte(&header) << 24;
2987 bytestream_get_be24(&header);
3007 pkttype, ts, pktsize)) < 0)
3034 if (!strcmp(commandbuffer,
"onMetaData") ||
3035 !strcmp(commandbuffer,
"|RtmpSampleAccess")) {
3056 }
while (buf_temp - buf < size);
3074 }
else if (ret < 0) {
3076 }
else if (ret == 1) {
3094 #define OFFSET(x) offsetof(RTMPContext, x) 3095 #define DEC AV_OPT_FLAG_DECODING_PARAM 3096 #define ENC AV_OPT_FLAG_ENCODING_PARAM 3100 {
"rtmp_buffer",
"Set buffer time in milliseconds. The default is 3000.",
OFFSET(client_buffer_time),
AV_OPT_TYPE_INT, {.i64 = 3000}, 0, INT_MAX,
DEC|
ENC},
3103 {
"rtmp_flush_interval",
"Number of packets flushed in the same request (RTMPT only).",
OFFSET(flush_interval),
AV_OPT_TYPE_INT, {.i64 = 10}, 0, INT_MAX,
ENC},
3104 {
"rtmp_live",
"Specify that the media is a live stream.",
OFFSET(live),
AV_OPT_TYPE_INT, {.i64 = -2}, INT_MIN, INT_MAX,
DEC,
"rtmp_live"},
3108 {
"rtmp_pageurl",
"URL of the web page in which the media was embedded. By default no value will be sent.",
OFFSET(pageurl),
AV_OPT_TYPE_STRING, {.str =
NULL }, 0, 0,
DEC},
3110 {
"rtmp_subscribe",
"Name of live stream to subscribe to. Defaults to rtmp_playpath.",
OFFSET(subscribe),
AV_OPT_TYPE_STRING, {.str =
NULL }, 0, 0, DEC},
3111 {
"rtmp_swfhash",
"SHA256 hash of the decompressed SWF file (32 bytes).",
OFFSET(swfhash),
AV_OPT_TYPE_BINARY, .flags = DEC},
3112 {
"rtmp_swfsize",
"Size of the decompressed SWF file, required for SWFVerification.",
OFFSET(swfsize),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC},
3113 {
"rtmp_swfurl",
"URL of the SWF player. By default no value will be sent",
OFFSET(swfurl),
AV_OPT_TYPE_STRING, {.str =
NULL }, 0, 0, DEC|ENC},
3114 {
"rtmp_swfverify",
"URL to player swf file, compute hash/size automatically.",
OFFSET(swfverify),
AV_OPT_TYPE_STRING, {.str =
NULL }, 0, 0, DEC},
3115 {
"rtmp_tcurl",
"URL of the target stream. Defaults to proto://host[:port]/app.",
OFFSET(tcurl),
AV_OPT_TYPE_STRING, {.str =
NULL }, 0, 0, DEC|ENC},
3116 {
"rtmp_listen",
"Listen for incoming rtmp connections",
OFFSET(listen),
AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX,
DEC,
"rtmp_listen" },
3117 {
"listen",
"Listen for incoming rtmp connections",
OFFSET(listen),
AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX,
DEC,
"rtmp_listen" },
3118 {
"timeout",
"Maximum timeout (in seconds) to wait for incoming connections. -1 is infinite. Implies -rtmp_listen 1",
OFFSET(listen_timeout),
AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX,
DEC,
"rtmp_listen" },
3122 #define RTMP_PROTOCOL(flavor) \ 3123 static const AVClass flavor##_class = { \ 3124 .class_name = #flavor, \ 3125 .item_name = av_default_item_name, \ 3126 .option = rtmp_options, \ 3127 .version = LIBAVUTIL_VERSION_INT, \ 3130 const URLProtocol ff_##flavor##_protocol = { \ 3132 .url_open2 = rtmp_open, \ 3133 .url_read = rtmp_read, \ 3134 .url_read_seek = rtmp_seek, \ 3135 .url_read_pause = rtmp_pause, \ 3136 .url_write = rtmp_write, \ 3137 .url_close = rtmp_close, \ 3138 .priv_data_size = sizeof(RTMPContext), \ 3139 .flags = URL_PROTOCOL_FLAG_NETWORK, \ 3140 .priv_data_class= &flavor##_class, \ static int gen_bytes_read(URLContext *s, RTMPContext *rt, uint32_t ts)
Generate report on bytes read so far and send it to the server.
Context structure for the Lagged Fibonacci PRNG.
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.
static int gen_swf_verification(URLContext *s, RTMPContext *rt)
Generate SWF verification message and send it to the server.
int ff_amf_match_string(const uint8_t *data, int size, const char *str)
Match AMF string with a NULL-terminated string.
int ff_rtmp_packet_read_internal(URLContext *h, RTMPPacket *p, int chunk_size, RTMPPacket **prev_pkt, int *nb_prev_pkt, uint8_t hdr)
Read internal RTMP packet sent by the server.
static int rtmp_read(URLContext *s, uint8_t *buf, int size)
int live
0: recorded, -1: live, -2: both
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int ff_amf_read_null(GetByteContext *bc)
Read AMF NULL value.
static int gen_pause(URLContext *s, RTMPContext *rt, int pause, uint32_t timestamp)
Generate a pause packet that either pauses or unpauses the current stream.
uint8_t flv_header[RTMP_HEADER]
partial incoming flv packet header
static void copy(const float *p1, float *p2, const int length)
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. ...
#define RTMP_CTRL_ABORT_MESSAGE
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
ptrdiff_t const GLvoid * data
static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
static int gen_window_ack_size(URLContext *s, RTMPContext *rt)
Generate window acknowledgement size message and send it to the server.
static int handle_invoke_error(URLContext *s, RTMPPacket *pkt)
static int handle_invoke(URLContext *s, RTMPPacket *pkt)
int ff_rtmp_packet_read(URLContext *h, RTMPPacket *p, int chunk_size, RTMPPacket **prev_pkt, int *nb_prev_pkt)
Read RTMP packet sent by the server.
#define AV_LOG_WARNING
Something somehow does not look correct.
static int gen_check_bw(URLContext *s, RTMPContext *rt)
Generate check bandwidth message and send it to the server.
static const uint8_t rtmp_server_key[]
Key used for RTMP server digest signing.
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
int max_sent_unacked
max unacked sent bytes
#define RTMPS_DEFAULT_PORT
int is_streamed
true if streamed (no seek possible), default = false
static int gen_fcsubscribe_stream(URLContext *s, RTMPContext *rt, const char *subscribe)
void ff_amf_write_field_name(uint8_t **dst, const char *str)
Write string used as field name in AMF object to buffer.
int flv_header_bytes
number of initialized bytes in flv_header
AVIOInterruptCB interrupt_callback
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
#define AVIO_FLAG_READ
read-only
#define AVIO_FLAG_WRITE
write-only
int ff_amf_tag_size(const uint8_t *data, const uint8_t *data_end)
Calculate number of bytes taken by first AMF entry in data.
static int gen_create_stream(URLContext *s, RTMPContext *rt)
Generate 'createStream' call and send it to the server.
static av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
URLContext * stream
TCP stream used in interactions with RTMP server.
int in_chunk_size
size of the chunks incoming RTMP packets are divided into
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
double duration
Duration of the stream in seconds as returned by the server (only valid if non-zero) ...
int skip_bytes
number of bytes to skip from the input FLV stream in the next write call
static int rtmp_server_handshake(URLContext *s, RTMPContext *rt)
rtmp handshake server side
void av_md5_update(AVMD5 *ctx, const uint8_t *src, int len)
Update hash value.
uint32_t receive_report_size
number of bytes after which we should report the number of received bytes to the peer ...
RTMPPacketType type
packet payload type
static int handle_set_peer_bw(URLContext *s, RTMPPacket *pkt)
int flv_nb_packets
number of flv packets published
static const char signature[]
struct AVMD5 * av_md5_alloc(void)
Allocate an AVMD5 context.
static int append_flv_data(RTMPContext *rt, RTMPPacket *pkt, int skip)
static int handle_window_ack_size(URLContext *s, RTMPPacket *pkt)
#define RTMP_DEFAULT_PORT
uint32_t extra
probably an additional channel ID used during streaming data
ClientState state
current state
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
GLsizei GLboolean const GLfloat * value
static int gen_fcunpublish_stream(URLContext *s, RTMPContext *rt)
Generate 'FCUnpublish' call and send it to the server.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
#define RTMP_PKTDATA_DEFAULT_SIZE
TrackedMethod * tracked_methods
tracked methods buffer
double strtod(const char *, char **)
void ff_amf_write_string(uint8_t **dst, const char *str)
Write string in AMF format to buffer.
static int rtmp_write_amf_data(URLContext *s, char *param, uint8_t **p)
int ff_rtmpe_compute_secret_key(URLContext *h, const uint8_t *serverdata, const uint8_t *clientdata, int type)
Compute the shared secret key and initialize the RC4 encryption.
void ff_rtmp_packet_dump(void *ctx, RTMPPacket *p)
Print information and contents of RTMP packet.
int nb_invokes
keeps track of invoke messages
int out_chunk_size
size of the chunks outgoing RTMP packets are divided into
#define AVERROR_EOF
End of file.
int flv_size
current buffer size
#define AV_LOG_VERBOSE
Detailed information.
int listen_timeout
listen timeout to wait for new connections
int flush_interval
number of packets flushed in the same request (RTMPT only)
char * swfverify
URL to player swf file, compute hash/size automatically.
static int rtmp_handshake(URLContext *s, RTMPContext *rt)
Perform handshake with the server by means of exchanging pseudorandom data signed with HMAC-SHA2 dige...
int encrypted
use an encrypted connection (RTMPE only)
static const uint8_t header[24]
int ff_rtmpe_gen_pub_key(URLContext *h, uint8_t *buf)
Initialize the Diffie-Hellmann context and generate the public key.
void ff_amf_write_object_end(uint8_t **dst)
Write marker for end of AMF object to buffer.
char * conn
append arbitrary AMF data to the Connect message
received a play command (for output)
static void del_tracked_method(RTMPContext *rt, int index)
int ff_rtmp_calc_digest_pos(const uint8_t *buf, int off, int mod_val, int add_val)
Calculate digest position for RTMP handshake packets.
static int rtmp_validate_digest(uint8_t *buf, int off)
Verify that the received server response has the expected digest value.
int size
packet payload size
static int gen_seek(URLContext *s, RTMPContext *rt, int64_t timestamp)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
void ff_amf_write_bool(uint8_t **dst, int val)
Write boolean value in AMF format to buffer.
static int do_adobe_auth(RTMPContext *rt, const char *user, const char *salt, const char *opaque, const char *challenge)
static int rtmp_handshake_imprint_with_digest(uint8_t *buf, int encrypted)
Put HMAC-SHA2 digest of packet data (except for the bytes where this digest will be stored) into that...
static int write_status(URLContext *s, RTMPPacket *pkt, const char *status, const char *filename)
static int handle_user_control(URLContext *s, RTMPPacket *pkt)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
char * pageurl
url of the web page
client has started the seek operation. Back on STATE_PLAYING when the time comes
static int rtmp_send_packet(RTMPContext *rt, RTMPPacket *pkt, int track)
static int inject_fake_duration_metadata(RTMPContext *rt)
Insert a fake onMetadata packet into the FLV stream to notify the FLV demuxer about the duration of t...
const char * protocol_whitelist
char * flashver
version of the flash plugin
static int handle_invoke_status(URLContext *s, RTMPPacket *pkt)
ClientState
RTMP protocol handler state.
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
char * swfurl
url of the swf player
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define PLAYER_KEY_OPEN_PART_LEN
length of partial key used for first client digest signing
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
static int gen_fcpublish_stream(URLContext *s, RTMPContext *rt)
Generate 'FCPublish' call and send it to the server.
static int gen_delete_stream(URLContext *s, RTMPContext *rt)
Generate 'deleteStream' call and send it to the server.
char * playpath
stream identifier to play (with possible "mp4:" prefix)
int ff_amf_get_string(GetByteContext *bc, uint8_t *str, int strsize, int *length)
Get AMF string value.
client has not done anything yet
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
static void free_tracked_methods(RTMPContext *rt)
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 tracked_methods_size
size of the tracked methods buffer
static int rtmp_pause(URLContext *s, int pause)
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
#define RTMP_PROTOCOL(flavor)
client has performed handshake
static int gen_play(URLContext *s, RTMPContext *rt)
Generate 'play' call and send it to the server, then ping the server to start actual playing...
const uint8_t * buffer_end
static av_always_inline void bytestream2_skip_p(PutByteContext *p, unsigned int size)
int swfhash_len
length of the SHA256 hash
uint64_t last_bytes_read
number of bytes read last reported to server
static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
Parse received packet and possibly perform some action depending on the packet contents.
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
client has started sending multimedia data to server (for output)
void ff_rtmp_packet_destroy(RTMPPacket *pkt)
Free RTMP packet.
static int gen_publish(URLContext *s, RTMPContext *rt)
Generate 'publish' call and send it to the server.
client has started receiving multimedia data from server
int client_buffer_time
client buffer time in ms
client FCPublishing stream (for output)
int ff_amf_get_field_value(const uint8_t *data, const uint8_t *data_end, const uint8_t *name, uint8_t *dst, int dst_size)
Retrieve value of given AMF object field in string form.
static int rtmp_close(URLContext *h)
int nb_streamid
The next stream id to return on createStream calls.
#define RTMP_CLIENT_PLATFORM
emulated Flash client version - 9.0.124.2 on Linux
int has_video
presence of video data
static int gen_pong(URLContext *s, RTMPContext *rt, RTMPPacket *ppkt)
Generate ping reply and send it to the server.
static int add_tracked_method(RTMPContext *rt, const char *name, int id)
int is_input
input/output flag
static const uint8_t rtmp_player_key[]
Client key used for digest signing.
received a publish command (for input)
static int rtmp_send_hs_packet(RTMPContext *rt, uint32_t first_int, uint32_t second_int, char *arraydata, int size)
static int64_t rtmp_seek(URLContext *s, int stream_index, int64_t timestamp, int flags)
int ff_rtmp_packet_write(URLContext *h, RTMPPacket *pkt, int chunk_size, RTMPPacket **prev_pkt_ptr, int *nb_prev_pkt)
Send RTMP packet to the server.
static int gen_get_stream_length(URLContext *s, RTMPContext *rt)
Generate 'getStreamLength' call and send it to the server.
static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b, uint8_t *dst, unsigned int size)
static int gen_buffer_time(URLContext *s, RTMPContext *rt)
Generate client buffer time and send it to the server.
static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p, const uint8_t *src, unsigned int size)
the broadcast has been stopped
char * swfhash
SHA256 hash of the decompressed SWF file (32 bytes)
char swfverification[42]
hash of the SWF verification
int nb_tracked_methods
number of tracked methods
offset must point to a pointer immediately followed by an int for the length
int ffurl_closep(URLContext **hh)
Close the resource accessed by the URLContext h, and free the memory used by it.
int ff_url_join(char *str, int size, const char *proto, const char *authorization, const char *hostname, int port, const char *fmt,...)
static int do_llnw_auth(RTMPContext *rt, const char *user, const char *nonce)
#define AV_LOG_INFO
Standard information.
int flv_off
number of bytes read from current buffer
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
char * av_strdup(const char *s)
Duplicate a string.
const char * protocol_blacklist
static int handle_chunk_size(URLContext *s, RTMPPacket *pkt)
#define AVIO_FLAG_NONBLOCK
Use non-blocking mode.
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
uint64_t bytes_read
number of bytes read from server
void av_md5_init(AVMD5 *ctx)
Initialize MD5 hashing.
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
uint32_t last_timestamp
last timestamp received in a packet
char * subscribe
name of live stream to subscribe
void ff_rtmpe_encrypt_sig(URLContext *h, uint8_t *sig, const uint8_t *digest, int type)
Encrypt the signature.
#define AVIO_FLAG_READ_WRITE
read-write pseudo flag
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
channel for sending server control messages
static int gen_connect(URLContext *s, RTMPContext *rt)
Generate 'connect' call and send it to the server.
static int gen_release_stream(URLContext *s, RTMPContext *rt)
Generate 'releaseStream' call and send it to the server.
Describe the class of an AVClass context structure.
static int write_begin(URLContext *s)
static int find_tracked_method(URLContext *s, RTMPPacket *pkt, int offset, char **tracked_method)
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
int ff_rtmp_packet_create(RTMPPacket *pkt, int channel_id, RTMPPacketType type, int timestamp, int size)
Create new RTMP packet with given attributes.
int ff_rtmpe_update_keystream(URLContext *h)
Update the keystream and set RC4 keys for encryption.
int ff_amf_read_number(GetByteContext *bc, double *val)
Read AMF number value.
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
static int handle_notify(URLContext *s, RTMPPacket *pkt)
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
int channel_id
RTMP channel ID (nothing to do with audio/video channels though)
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
RTMPPacket out_pkt
rtmp packet, created from flv a/v or metadata (for output)
char * tcurl
url of the target stream
static int handle_connect_error(URLContext *s, const char *desc)
void av_md5_final(AVMD5 *ctx, uint8_t *dst)
Finish hashing and output digest value.
int listen
listen mode flag
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...
static int rtmp_receive_hs_packet(RTMPContext *rt, uint32_t *first_int, uint32_t *second_int, char *arraydata, int size)
#define flags(name, subs,...)
int ffurl_close(URLContext *h)
#define SERVER_KEY_OPEN_PART_LEN
length of partial key used for first server digest signing
channel for network-related messages (bandwidth report, ping, etc)
static int handle_metadata(RTMPContext *rt, RTMPPacket *pkt)
void ff_amf_write_null(uint8_t **dst)
Write AMF NULL value to buffer.
uint32_t timestamp
packet full timestamp
#define RTMP_HANDSHAKE_PACKET_SIZE
#define FLASHVER_MAX_LENGTH
uint8_t * data
packet payload
int stream_id
ID assigned by the server for the stream.
int has_audio
presence of audio data
RTMPPacket * prev_pkt[2]
packet history used when reading and sending packets ([0] for reading, [1] for writing) ...
int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)
Change the position that will be used by the next read/write operation on the resource accessed by h...
char * app
name of application
static int rtmp_open(URLContext *s, const char *uri, int flags, AVDictionary **opts)
Open RTMP connection and verify that the stream can be played.
channel
Use these values when setting the channel map with ebur128_set_channel().
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...
static int rtmp_calc_swfhash(URLContext *s)
char * filename
specified URL
int ff_rtmp_check_alloc_array(RTMPPacket **prev_pkt, int *nb_prev_pkt, int channel)
Enlarge the prev_pkt array to fit the given channel.
int ff_rtmp_calc_digest(const uint8_t *src, int len, int gap, const uint8_t *key, int keylen, uint8_t *dst)
Calculate HMAC-SHA2 digest for RTMP handshake packets.
#define AVSEEK_SIZE
ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
int ff_amf_read_string(GetByteContext *bc, uint8_t *str, int strsize, int *length)
Read AMF string value.
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
static int send_invoke_response(URLContext *s, RTMPPacket *pkt)
void ff_amf_write_number(uint8_t **dst, double val)
Write number in AMF format to buffer.
static const AVOption rtmp_options[]
static int get_packet(URLContext *s, int for_header)
Interact with the server by receiving and sending RTMP packets until there is some significant data (...
static int handle_invoke_result(URLContext *s, RTMPPacket *pkt)
uint8_t * flv_data
buffer with data for demuxer
static int read_connect(URLContext *s, RTMPContext *rt)
int received_metadata
Indicates if we have received metadata about the streams.
void ff_amf_write_object_start(uint8_t **dst)
Write marker for AMF object to buffer.
int max_packet_size
if non zero, the stream is packetized with this max packet size
Public header for MD5 hash function implementation.
int nb_prev_pkt[2]
number of elements in prev_pkt
int swfsize
size of the decompressed SWF file
structure for holding RTMP packets
void ff_amf_write_string2(uint8_t **dst, const char *str1, const char *str2)
Write a string consisting of two parts in AMF format to a buffer.
static int update_offset(RTMPContext *rt, int size)
unbuffered private I/O API
invoke some stream action
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
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...
window acknowledgement size
static int rtmp_calc_swf_verification(URLContext *s, RTMPContext *rt, uint8_t *buf)
static int read_number_result(RTMPPacket *pkt, double *number)
Read the AMF_NUMBER response ("_result") to a function call (e.g.