34 bytestream_put_byte(dst, val);
46 bytestream_put_be16(dst, strlen(str));
52 int len1 = 0, len2 = 0;
58 bytestream_put_be16(dst, len1 + len2);
75 bytestream_put_be16(dst, strlen(str));
91 *val = bytestream2_get_byte(bc);
100 read = bytestream2_get_be64(bc);
106 int strsize,
int *length)
112 stringlen = bytestream2_get_be16(bc);
113 if (stringlen + 1 > strsize)
116 if (readsize != stringlen) {
118 "Unable to read as many bytes as AMF string signaled\n");
120 str[readsize] =
'\0';
121 *length =
FFMIN(stringlen, readsize);
148 int channel_id, timestamp,
size, offset = 0;
155 channel_id = hdr & 0x3F;
157 if (channel_id < 2) {
161 written += channel_id + 1;
162 channel_id =
AV_RL16(buf) + 64;
164 size = prev_pkt[channel_id].
size;
165 type = prev_pkt[channel_id].
type;
166 extra = prev_pkt[channel_id].
extra;
170 timestamp = prev_pkt[channel_id].
ts_delta;
192 if (timestamp == 0xFFFFFF) {
199 timestamp += prev_pkt[channel_id].
timestamp;
207 prev_pkt[channel_id].
type = type;
210 prev_pkt[channel_id].
timestamp = timestamp;
211 prev_pkt[channel_id].
extra = extra;
213 int toread =
FFMIN(size, chunk_size);
219 offset += chunk_size;
220 written += chunk_size;
227 if (t != (0xC0 + channel_id))
237 uint8_t pkt_hdr[16], *p = pkt_hdr;
259 bytestream_put_byte(&p, pkt->
channel_id | (mode << 6));
261 bytestream_put_byte(&p, 0 | (mode << 6));
262 bytestream_put_byte(&p, pkt->
channel_id - 64);
264 bytestream_put_byte(&p, 1 | (mode << 6));
265 bytestream_put_le16(&p, pkt->
channel_id - 64);
271 bytestream_put_be24(&p, timestamp >= 0xFFFFFF ? 0xFFFFFF : timestamp);
273 bytestream_put_be24(&p, pkt->
size);
274 bytestream_put_byte(&p, pkt->
type);
276 bytestream_put_le32(&p, pkt->
extra);
278 if (timestamp >= 0xFFFFFF)
279 bytestream_put_be32(&p, timestamp);
293 if ((ret =
ffurl_write(h, pkt_hdr, p - pkt_hdr)) < 0)
295 written = p - pkt_hdr + pkt->
size;
296 while (off < pkt->
size) {
297 int towrite =
FFMIN(chunk_size, pkt->
size - off);
301 if (off < pkt->size) {
312 int timestamp,
int size)
341 if (data >= data_end)
353 int size = bytestream_get_be16(&data);
359 if (data + size >= data_end || data + size < data)
363 if (t < 0 || data + t >= data_end)
376 int namelen = strlen(name);
382 len = data_end -
data;
385 if (data_end - data < 3)
389 int size = bytestream_get_be16(&data);
392 if (data + size >= data_end || data + size < data)
395 if (size == namelen && !memcmp(data-size, name, namelen)) {
401 snprintf(dst, dst_size,
"%s", *data ?
"true" :
"false");
404 len = bytestream_get_be16(&data);
413 if (len < 0 || data + len >= data_end || data + len < data)
437 default:
return "unknown";
446 if (data >= data_end)
458 size = bytestream_get_be16(&data);
460 size = bytestream_get_be32(&data);
462 size =
FFMIN(size, 1023);
463 memcpy(buf, data, size);
475 int size = bytestream_get_be16(&data);
477 memcpy(buf, data, size);
484 if (data + size >= data_end || data + size < data)
490 if (t < 0 || data + t >= data_end)
505 av_log(ctx,
AV_LOG_DEBUG,
"RTMP packet type '%s'(%d) for channel %d, timestamp %d, extra field %d size %d\n",
509 while (src < src_end) {
523 for (i = 0; i < p->
size; i++)
531 int len = strlen(str);
544 if ((size -= 4 + 1) < 0)
546 amf_len = bytestream_get_be32(&data);
548 if ((size -= 2 + 1) < 0)
550 amf_len = bytestream_get_be16(&data);
559 return !memcmp(data, str, len);
int ff_amf_match_string(const uint8_t *data, int size, const char *str)
Match AMF string with a NULL-terminated string.
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
int ff_amf_read_null(GetByteContext *bc)
Read AMF NULL value.
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
void ff_amf_write_field_name(uint8_t **dst, const char *str)
Write string used as field name in AMF object to buffer.
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 av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
int ff_rtmp_packet_read(URLContext *h, RTMPPacket *p, int chunk_size, RTMPPacket *prev_pkt)
Read RTMP packet sent by the server.
RTMPPacketType type
packet payload type
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
static void ff_amf_tag_contents(void *ctx, const uint8_t *data, const uint8_t *data_end)
uint32_t extra
probably an additional channel ID used during streaming data
uint32_t ts_delta
timestamp increment to the previous one in milliseconds (latter only for media packets) ...
void ff_amf_write_string(uint8_t **dst, const char *str)
Write string in AMF format to buffer.
void ff_rtmp_packet_dump(void *ctx, RTMPPacket *p)
Print information and contents of RTMP packet.
void ff_amf_write_object_end(uint8_t **dst)
Write marker for end of AMF object to buffer.
int size
packet payload size
void ff_amf_write_bool(uint8_t **dst, int val)
Write boolean value in AMF format to buffer.
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
void av_log(void *avcl, int level, const char *fmt,...)
packet has 12-byte header
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.
void ff_rtmp_packet_destroy(RTMPPacket *pkt)
Free RTMP packet.
RTMPPacketType
known RTMP packet types
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.
int ff_rtmp_packet_write(URLContext *h, RTMPPacket *pkt, int chunk_size, RTMPPacket *prev_pkt)
Send RTMP packet to the server.
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_amf_read_number(GetByteContext *bc, double *val)
Read AMF number value.
int channel_id
RTMP channel ID (nothing to do with audio/video channels though)
int ff_amf_read_bool(GetByteContext *bc, int *val)
Read AMF boolean value.
void ff_amf_write_null(uint8_t **dst)
Write AMF NULL value to buffer.
uint32_t timestamp
packet full timestamp
uint8_t * data
packet payload
static const char * rtmp_packet_type(int type)
#define AVERROR_INVALIDDATA
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...
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)
int ff_rtmp_packet_read_internal(URLContext *h, RTMPPacket *p, int chunk_size, RTMPPacket *prev_pkt, uint8_t hdr)
Read internal RTMP packet sent by the server.
packet is really a next chunk of a packet
void ff_amf_write_number(uint8_t **dst, double val)
Write number in AMF format to buffer.
void ff_amf_write_object_start(uint8_t **dst)
Write marker for AMF object to buffer.
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.
unbuffered private I/O API
invoke some stream action
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...