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));
92 read = bytestream2_get_be64(bc);
98 int strsize,
int *length)
102 stringlen = bytestream2_get_be16(bc);
103 if (stringlen + 1 > strsize)
106 if (readsize != stringlen) {
108 "Unable to read as many bytes as AMF string signaled\n");
110 str[readsize] =
'\0';
111 *length =
FFMIN(stringlen, readsize);
116 int strsize,
int *length)
145 memset(ptr + *nb_prev_pkt, 0, (nb_alloc - *nb_prev_pkt) *
sizeof(*ptr));
147 *nb_prev_pkt = nb_alloc;
152 int chunk_size,
RTMPPacket **prev_pkt,
int *nb_prev_pkt)
169 int channel_id, timestamp,
size;
178 channel_id = hdr & 0x3F;
180 if (channel_id < 2) {
184 written += channel_id + 1;
185 channel_id =
AV_RL16(buf) + 64;
190 prev_pkt = *prev_pkt_ptr;
193 extra = prev_pkt[channel_id].
extra;
197 ts_field = prev_pkt[channel_id].
ts_field;
220 if (ts_field == 0xFFFFFF) {
225 timestamp = ts_field;
228 timestamp += prev_pkt[channel_id].
timestamp;
230 if (prev_pkt[channel_id].read &&
size != prev_pkt[channel_id].
size) {
234 prev_pkt[channel_id].
read = 0;
238 if (!prev_pkt[channel_id].read) {
244 prev_pkt[channel_id].
ts_field = ts_field;
245 prev_pkt[channel_id].
timestamp = timestamp;
265 prev_pkt[channel_id].
extra = extra;
286 prev_pkt[channel_id].
read = 0;
297 if (ret > 0 || ret !=
AVERROR(EAGAIN))
309 uint8_t pkt_hdr[16], *p = pkt_hdr;
319 pkt->channel_id)) < 0)
321 prev_pkt = *prev_pkt_ptr;
328 timestamp =
pkt->timestamp;
332 if (timestamp >= 0xFFFFFF) {
333 pkt->ts_field = 0xFFFFFF;
335 pkt->ts_field = timestamp;
339 if (
pkt->type == prev_pkt[
pkt->channel_id].
type &&
349 if (
pkt->channel_id < 64) {
350 bytestream_put_byte(&p,
pkt->channel_id | (
mode << 6));
351 }
else if (
pkt->channel_id < 64 + 256) {
352 bytestream_put_byte(&p, 0 | (
mode << 6));
353 bytestream_put_byte(&p,
pkt->channel_id - 64);
355 bytestream_put_byte(&p, 1 | (
mode << 6));
356 bytestream_put_le16(&p,
pkt->channel_id - 64);
359 bytestream_put_be24(&p,
pkt->ts_field);
361 bytestream_put_be24(&p,
pkt->
size);
362 bytestream_put_byte(&p,
pkt->type);
364 bytestream_put_le32(&p,
pkt->extra);
367 if (
pkt->ts_field == 0xFFFFFF)
368 bytestream_put_be32(&p, timestamp);
379 written = p - pkt_hdr +
pkt->
size;
380 while (off < pkt->
size) {
385 if (off < pkt->
size) {
390 if (
pkt->ts_field == 0xFFFFFF) {
403 int timestamp,
int size)
411 pkt->channel_id = channel_id;
413 pkt->timestamp = timestamp;
436 type = bytestream2_get_byte(gb);
439 bytestream2_get_be64(gb);
442 bytestream2_get_byte(gb);
457 nb = bytestream2_get_be32(gb);
462 int size = bytestream2_get_be16(gb);
464 bytestream2_get_byte(gb);
486 if (
data >= data_end)
501 int namelen = strlen(
name);
511 bytestream2_get_byte(gb);
514 int size = bytestream2_get_be16(gb);
521 switch (bytestream2_get_byte(gb)) {
526 snprintf(dst, dst_size,
"%s", bytestream2_get_byte(gb) ?
"true" :
"false");
529 len = bytestream2_get_be16(gb);
532 if (dst_size <
len + 1)
554 if (
data >= data_end)
563 static const char* rtmp_packet_type(
int type)
580 default:
return "unknown";
587 unsigned int size, nb = -1;
592 if (
data >= data_end)
619 nb = bytestream_get_be32(&
data);
639 amf_tag_contents(
ctx,
data, data_end);
641 if (t < 0 || t >= data_end -
data)
656 av_log(
ctx,
AV_LOG_DEBUG,
"RTMP packet type '%s'(%d) for channel %d, timestamp %d, extra field %d size %d\n",
660 while (
src < src_end) {
662 amf_tag_contents(
ctx,
src, src_end);
696 if ((
size -= 4 + 1) < 0)
698 amf_len = bytestream_get_be32(&
data);
700 if ((
size -= 2 + 1) < 0)
702 amf_len = bytestream_get_be16(&
data);
static double val(void *priv, double ch)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ffurl_read(URLContext *h, unsigned char *buf, int size)
Read up to size bytes from the resource accessed by h, and store the read bytes in buf.
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
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 av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
static av_always_inline int bytestream2_tell(GetByteContext *g)
static int parse_key(DBEContext *s)
mode
Use these values in ebur128_init (or'ed).
channel
Use these values when setting the channel map with ebur128_set_channel().
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
static av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
void ff_amf_write_string(uint8_t **dst, const char *str)
Write string in AMF format to buffer.
void ff_amf_write_null(uint8_t **dst)
Write AMF NULL value to buffer.
static int amf_tag_skip(GetByteContext *gb)
void ff_amf_write_number(uint8_t **dst, double val)
Write number in AMF format to buffer.
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.
static int rtmp_packet_read_one_chunk(URLContext *h, RTMPPacket *p, int chunk_size, RTMPPacket **prev_pkt_ptr, int *nb_prev_pkt, uint8_t hdr)
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.
void ff_amf_write_object_start(uint8_t **dst)
Write marker for AMF object to buffer.
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.
int ff_amf_get_string(GetByteContext *bc, uint8_t *str, int strsize, int *length)
Get AMF string value.
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_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.
int ff_amf_read_null(GetByteContext *bc)
Read AMF NULL value.
static int amf_get_field_value2(GetByteContext *gb, const uint8_t *name, uint8_t *dst, int dst_size)
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.
void ff_amf_write_bool(uint8_t **dst, int val)
Write boolean value in AMF format to buffer.
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_create(RTMPPacket *pkt, int channel_id, RTMPPacketType type, int timestamp, int size)
Create new RTMP packet with given attributes.
void ff_rtmp_packet_destroy(RTMPPacket *pkt)
Free RTMP packet.
int ff_amf_match_string(const uint8_t *data, int size, const char *str)
Match AMF string with a NULL-terminated string.
void ff_amf_write_object_end(uint8_t **dst)
Write marker for end of AMF object to buffer.
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_read_string(GetByteContext *bc, uint8_t *str, int strsize, int *length)
Read AMF string value.
int ff_amf_read_number(GetByteContext *bc, double *val)
Read AMF number value.
@ RTMP_PS_TWELVEBYTES
packet has 12-byte header
@ RTMP_PS_EIGHTBYTES
packet has 8-byte header
@ RTMP_PS_FOURBYTES
packet has 4-byte header
@ RTMP_PS_ONEBYTE
packet is really a next chunk of a packet
void ff_rtmp_packet_dump(void *ctx, RTMPPacket *p)
Print information and contents of RTMP packet.
RTMPPacketType
known RTMP packet types
@ RTMP_PT_FLEX_OBJECT
Flex shared object.
@ RTMP_PT_USER_CONTROL
user control
@ RTMP_PT_NOTIFY
some notification
@ RTMP_PT_SHARED_OBJ
shared object
@ RTMP_PT_CHUNK_SIZE
chunk size change
@ RTMP_PT_INVOKE
invoke some stream action
@ RTMP_PT_BYTES_READ
number of bytes read
@ RTMP_PT_SET_PEER_BW
peer bandwidth
@ RTMP_PT_WINDOW_ACK_SIZE
window acknowledgement size
@ RTMP_PT_VIDEO
video packet
@ RTMP_PT_FLEX_STREAM
Flex shared stream.
@ RTMP_PT_METADATA
FLV metadata.
@ RTMP_PT_AUDIO
audio packet
@ RTMP_PT_FLEX_MESSAGE
Flex shared message.
structure for holding RTMP packets
int size
packet payload size
uint32_t extra
probably an additional channel ID used during streaming data
RTMPPacketType type
packet payload type
uint32_t ts_field
24-bit timestamp or increment to the previous one, in milliseconds (latter only for media packets)....
uint32_t timestamp
packet full timestamp
uint8_t * data
packet payload
int channel_id
RTMP channel ID (nothing to do with audio/video channels though)
int read
amount read, including headers
int offset
amount of data read so far
unbuffered private I/O API