[FFmpeg-devel] [PATCH 01/10] avio: add avio_ prefix to put_* functions
Anton Khirnov
anton
Sat Feb 19 12:42:45 CET 2011
---
ffserver.c | 6 +-
libavformat/a64.c | 12 +-
libavformat/adtsenc.c | 6 +-
libavformat/aiffenc.c | 46 +-
libavformat/amr.c | 6 +-
libavformat/asfenc.c | 180 ++++----
libavformat/assenc.c | 6 +-
libavformat/au.c | 16 +-
libavformat/avc.c | 30 +-
libavformat/avienc.c | 226 +++++-----
libavformat/avio.h | 47 ++-
libavformat/aviobuf.c | 110 +++--
libavformat/crcenc.c | 2 +-
libavformat/daud.c | 6 +-
libavformat/dvenc.c | 2 +-
libavformat/ffmenc.c | 140 +++---
libavformat/ffmetaenc.c | 22 +-
libavformat/filmstripenc.c | 20 +-
libavformat/flacenc.c | 12 +-
libavformat/flacenc_header.c | 4 +-
libavformat/flvenc.c | 126 +++---
libavformat/framecrcenc.c | 2 +-
libavformat/gif.c | 76 ++--
libavformat/gxfenc.c | 328 +++++++-------
libavformat/idroqenc.c | 2 +-
libavformat/img2.c | 26 +-
libavformat/ivfenc.c | 24 +-
libavformat/libnut.c | 2 +-
libavformat/matroskadec.c | 12 +-
libavformat/matroskaenc.c | 46 +-
libavformat/md5enc.c | 2 +-
libavformat/mmf.c | 58 ++--
libavformat/movenc.c | 1106 +++++++++++++++++++++---------------------
libavformat/movenchint.c | 40 +-
libavformat/mp3enc.c | 30 +-
libavformat/mpegenc.c | 82 ++--
libavformat/mpegtsenc.c | 8 +-
libavformat/mpjpeg.c | 8 +-
libavformat/mxfenc.c | 332 +++++++-------
libavformat/nutenc.c | 32 +-
libavformat/oggenc.c | 24 +-
libavformat/rawenc.c | 2 +-
libavformat/riff.c | 66 ++--
libavformat/rmenc.c | 210 ++++----
libavformat/rsoenc.c | 12 +-
libavformat/rtpdec.c | 58 ++--
libavformat/rtpdec_asf.c | 2 +-
libavformat/rtpdec_latm.c | 2 +-
libavformat/rtpdec_svq3.c | 2 +-
libavformat/rtpdec_vp8.c | 2 +-
libavformat/rtpdec_xiph.c | 4 +-
libavformat/rtpenc.c | 30 +-
libavformat/soxenc.c | 34 +-
libavformat/spdifenc.c | 10 +-
libavformat/swfenc.c | 112 +++---
libavformat/vc1testenc.c | 32 +-
libavformat/vocenc.c | 48 +-
libavformat/wav.c | 14 +-
libavformat/yuv4mpeg.c | 10 +-
59 files changed, 1983 insertions(+), 1932 deletions(-)
diff --git a/ffserver.c b/ffserver.c
index 74bce85..7a16b2d 100644
--- a/ffserver.c
+++ b/ffserver.c
@@ -2514,10 +2514,10 @@ static int http_send_data(HTTPContext *c)
header[1] = interleaved_index;
header[2] = len >> 8;
header[3] = len;
- put_buffer(pb, header, 4);
+ avio_put_buffer(pb, header, 4);
/* write RTP packet data */
c->buffer_ptr += 4;
- put_buffer(pb, c->buffer_ptr, len);
+ avio_put_buffer(pb, c->buffer_ptr, len);
size = url_close_dyn_buf(pb, &c->packet_buffer);
/* prepare asynchronous TCP sending */
rtsp_c->packet_buffer_ptr = c->packet_buffer;
@@ -3018,7 +3018,7 @@ static void rtsp_cmd_describe(HTTPContext *c, const char *url)
url_fprintf(c->pb, "Content-Type: application/sdp\r\n");
url_fprintf(c->pb, "Content-Length: %d\r\n", content_length);
url_fprintf(c->pb, "\r\n");
- put_buffer(c->pb, content, content_length);
+ avio_put_buffer(c->pb, content, content_length);
av_free(content);
}
diff --git a/libavformat/a64.c b/libavformat/a64.c
index 46441b2..e6f2907 100644
--- a/libavformat/a64.c
+++ b/libavformat/a64.c
@@ -57,7 +57,7 @@ static int a64_write_header(struct AVFormatContext *s)
return AVERROR(EINVAL);
break;
}
- put_buffer(s->pb, header, 2);
+ avio_put_buffer(s->pb, header, 2);
c->prev_pkt.size = 0;
c->prev_frame_count = 0;
return 0;
@@ -110,18 +110,18 @@ static int a64_write_packet(struct AVFormatContext *s, AVPacket *pkt)
for(i = 0; i < num_frames; i++) {
if(pkt->data) {
/* if available, put newest charset chunk into buffer */
- put_buffer(s->pb, pkt->data + ch_chunksize * i, ch_chunksize);
+ avio_put_buffer(s->pb, pkt->data + ch_chunksize * i, ch_chunksize);
} else {
/* a bit ugly, but is there an alternative to put many zeros? */
- for(j = 0; j < ch_chunksize; j++) put_byte(s->pb, 0);
+ for(j = 0; j < ch_chunksize; j++) avio_put_byte(s->pb, 0);
}
if(c->prev_pkt.data) {
/* put frame (screen + colram) from last packet into buffer */
- put_buffer(s->pb, c->prev_pkt.data + charset_size + frame_size * i, frame_size);
+ avio_put_buffer(s->pb, c->prev_pkt.data + charset_size + frame_size * i, frame_size);
} else {
/* a bit ugly, but is there an alternative to put many zeros? */
- for(j = 0; j < frame_size; j++) put_byte(s->pb, 0);
+ for(j = 0; j < frame_size; j++) avio_put_byte(s->pb, 0);
}
}
@@ -145,7 +145,7 @@ static int a64_write_packet(struct AVFormatContext *s, AVPacket *pkt)
default:
/* Write things as is. Nice for self-contained frames from non-multicolor modes or if played
* directly from ram and not from a streaming device (rrnet/mmc) */
- if(pkt) put_buffer(s->pb, pkt->data, pkt->size);
+ if(pkt) avio_put_buffer(s->pb, pkt->data, pkt->size);
break;
}
diff --git a/libavformat/adtsenc.c b/libavformat/adtsenc.c
index f309c89..147e205 100644
--- a/libavformat/adtsenc.c
+++ b/libavformat/adtsenc.c
@@ -125,13 +125,13 @@ static int adts_write_packet(AVFormatContext *s, AVPacket *pkt)
return 0;
if (adts->write_adts) {
ff_adts_write_frame_header(adts, buf, pkt->size, adts->pce_size);
- put_buffer(pb, buf, ADTS_HEADER_SIZE);
+ avio_put_buffer(pb, buf, ADTS_HEADER_SIZE);
if (adts->pce_size) {
- put_buffer(pb, adts->pce_data, adts->pce_size);
+ avio_put_buffer(pb, adts->pce_data, adts->pce_size);
adts->pce_size = 0;
}
}
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_buffer(pb, pkt->data, pkt->size);
put_flush_packet(pb);
return 0;
diff --git a/libavformat/aiffenc.c b/libavformat/aiffenc.c
index 6e47390..27a1b64 100644
--- a/libavformat/aiffenc.c
+++ b/libavformat/aiffenc.c
@@ -43,10 +43,10 @@ static int aiff_write_header(AVFormatContext *s)
aifc = 1;
/* FORM AIFF header */
- put_tag(pb, "FORM");
+ avio_put_tag(pb, "FORM");
aiff->form = url_ftell(pb);
- put_be32(pb, 0); /* file length */
- put_tag(pb, aifc ? "AIFC" : "AIFF");
+ avio_put_be32(pb, 0); /* file length */
+ avio_put_tag(pb, aifc ? "AIFC" : "AIFF");
if (aifc) { // compressed audio
enc->bits_per_coded_sample = 16;
@@ -55,18 +55,18 @@ static int aiff_write_header(AVFormatContext *s)
return -1;
}
/* Version chunk */
- put_tag(pb, "FVER");
- put_be32(pb, 4);
- put_be32(pb, 0xA2805140);
+ avio_put_tag(pb, "FVER");
+ avio_put_be32(pb, 4);
+ avio_put_be32(pb, 0xA2805140);
}
/* Common chunk */
- put_tag(pb, "COMM");
- put_be32(pb, aifc ? 24 : 18); /* size */
- put_be16(pb, enc->channels); /* Number of channels */
+ avio_put_tag(pb, "COMM");
+ avio_put_be32(pb, aifc ? 24 : 18); /* size */
+ avio_put_be16(pb, enc->channels); /* Number of channels */
aiff->frames = url_ftell(pb);
- put_be32(pb, 0); /* Number of frames */
+ avio_put_be32(pb, 0); /* Number of frames */
if (!enc->bits_per_coded_sample)
enc->bits_per_coded_sample = av_get_bits_per_sample(enc->codec_id);
@@ -77,22 +77,22 @@ static int aiff_write_header(AVFormatContext *s)
if (!enc->block_align)
enc->block_align = (enc->bits_per_coded_sample * enc->channels) >> 3;
- put_be16(pb, enc->bits_per_coded_sample); /* Sample size */
+ avio_put_be16(pb, enc->bits_per_coded_sample); /* Sample size */
sample_rate = av_dbl2ext((double)enc->sample_rate);
- put_buffer(pb, (uint8_t*)&sample_rate, sizeof(sample_rate));
+ avio_put_buffer(pb, (uint8_t*)&sample_rate, sizeof(sample_rate));
if (aifc) {
- put_le32(pb, enc->codec_tag);
- put_be16(pb, 0);
+ avio_put_le32(pb, enc->codec_tag);
+ avio_put_be16(pb, 0);
}
/* Sound data chunk */
- put_tag(pb, "SSND");
+ avio_put_tag(pb, "SSND");
aiff->ssnd = url_ftell(pb); /* Sound chunk size */
- put_be32(pb, 0); /* Sound samples data size */
- put_be32(pb, 0); /* Data offset */
- put_be32(pb, 0); /* Block-size (block align) */
+ avio_put_be32(pb, 0); /* Sound samples data size */
+ avio_put_be32(pb, 0); /* Data offset */
+ avio_put_be32(pb, 0); /* Block-size (block align) */
av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate);
@@ -105,7 +105,7 @@ static int aiff_write_header(AVFormatContext *s)
static int aiff_write_packet(AVFormatContext *s, AVPacket *pkt)
{
ByteIOContext *pb = s->pb;
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_buffer(pb, pkt->data, pkt->size);
return 0;
}
@@ -119,22 +119,22 @@ static int aiff_write_trailer(AVFormatContext *s)
int64_t file_size, end_size;
end_size = file_size = url_ftell(pb);
if (file_size & 1) {
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
end_size++;
}
if (!url_is_streamed(s->pb)) {
/* File length */
url_fseek(pb, aiff->form, SEEK_SET);
- put_be32(pb, file_size - aiff->form - 4);
+ avio_put_be32(pb, file_size - aiff->form - 4);
/* Number of sample frames */
url_fseek(pb, aiff->frames, SEEK_SET);
- put_be32(pb, (file_size-aiff->ssnd-12)/enc->block_align);
+ avio_put_be32(pb, (file_size-aiff->ssnd-12)/enc->block_align);
/* Sound Data chunk size */
url_fseek(pb, aiff->ssnd, SEEK_SET);
- put_be32(pb, file_size - aiff->ssnd - 4);
+ avio_put_be32(pb, file_size - aiff->ssnd - 4);
/* return to the end */
url_fseek(pb, end_size, SEEK_SET);
diff --git a/libavformat/amr.c b/libavformat/amr.c
index 11bb4e5..400b5f3 100644
--- a/libavformat/amr.c
+++ b/libavformat/amr.c
@@ -40,11 +40,11 @@ static int amr_write_header(AVFormatContext *s)
if (enc->codec_id == CODEC_ID_AMR_NB)
{
- put_tag(pb, AMR_header); /* magic number */
+ avio_put_tag(pb, AMR_header); /* magic number */
}
else if(enc->codec_id == CODEC_ID_AMR_WB)
{
- put_tag(pb, AMRWB_header); /* magic number */
+ avio_put_tag(pb, AMRWB_header); /* magic number */
}
else
{
@@ -56,7 +56,7 @@ static int amr_write_header(AVFormatContext *s)
static int amr_write_packet(AVFormatContext *s, AVPacket *pkt)
{
- put_buffer(s->pb, pkt->data, pkt->size);
+ avio_put_buffer(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb);
return 0;
}
diff --git a/libavformat/asfenc.c b/libavformat/asfenc.c
index 709080f..799b993 100644
--- a/libavformat/asfenc.c
+++ b/libavformat/asfenc.c
@@ -225,7 +225,7 @@ static const AVCodecTag codec_asf_bmp_tags[] = {
static void put_guid(ByteIOContext *s, const ff_asf_guid *g)
{
assert(sizeof(*g) == 16);
- put_buffer(s, *g, sizeof(*g));
+ avio_put_buffer(s, *g, sizeof(*g));
}
static void put_str16(ByteIOContext *s, const char *tag)
@@ -238,8 +238,8 @@ static void put_str16(ByteIOContext *s, const char *tag)
avio_put_str16le(dyn_buf, tag);
len = url_close_dyn_buf(dyn_buf, &pb);
- put_le16(s, len);
- put_buffer(s, pb, len);
+ avio_put_le16(s, len);
+ avio_put_buffer(s, pb, len);
av_freep(&pb);
}
@@ -249,7 +249,7 @@ static int64_t put_header(ByteIOContext *pb, const ff_asf_guid *g)
pos = url_ftell(pb);
put_guid(pb, g);
- put_le64(pb, 24);
+ avio_put_le64(pb, 24);
return pos;
}
@@ -260,7 +260,7 @@ static void end_header(ByteIOContext *pb, int64_t pos)
pos1 = url_ftell(pb);
url_fseek(pb, pos + 16, SEEK_SET);
- put_le64(pb, pos1 - pos);
+ avio_put_le64(pb, pos1 - pos);
url_fseek(pb, pos1, SEEK_SET);
}
@@ -272,11 +272,11 @@ static void put_chunk(AVFormatContext *s, int type, int payload_length, int flag
int length;
length = payload_length + 8;
- put_le16(pb, type);
- put_le16(pb, length); //size
- put_le32(pb, asf->seqno);//sequence number
- put_le16(pb, flags); /* unknown bytes */
- put_le16(pb, length); //size_confirm
+ avio_put_le16(pb, type);
+ avio_put_le16(pb, length); //size
+ avio_put_le32(pb, asf->seqno);//sequence number
+ avio_put_le16(pb, flags); /* unknown bytes */
+ avio_put_le16(pb, length); //size_confirm
asf->seqno++;
}
@@ -330,33 +330,33 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
}
put_guid(pb, &ff_asf_header);
- put_le64(pb, -1); /* header length, will be patched after */
- put_le32(pb, 3 + has_title + !!metadata_count + s->nb_streams); /* number of chunks in header */
- put_byte(pb, 1); /* ??? */
- put_byte(pb, 2); /* ??? */
+ avio_put_le64(pb, -1); /* header length, will be patched after */
+ avio_put_le32(pb, 3 + has_title + !!metadata_count + s->nb_streams); /* number of chunks in header */
+ avio_put_byte(pb, 1); /* ??? */
+ avio_put_byte(pb, 2); /* ??? */
/* file header */
header_offset = url_ftell(pb);
hpos = put_header(pb, &ff_asf_file_header);
put_guid(pb, &ff_asf_my_guid);
- put_le64(pb, file_size);
+ avio_put_le64(pb, file_size);
file_time = 0;
- put_le64(pb, unix_to_file_time(file_time));
- put_le64(pb, asf->nb_packets); /* number of packets */
- put_le64(pb, duration); /* end time stamp (in 100ns units) */
- put_le64(pb, asf->duration); /* duration (in 100ns units) */
- put_le64(pb, PREROLL_TIME); /* start time stamp */
- put_le32(pb, (asf->is_streamed || url_is_streamed(pb)) ? 3 : 2); /* ??? */
- put_le32(pb, s->packet_size); /* packet size */
- put_le32(pb, s->packet_size); /* packet size */
- put_le32(pb, bit_rate); /* Nominal data rate in bps */
+ avio_put_le64(pb, unix_to_file_time(file_time));
+ avio_put_le64(pb, asf->nb_packets); /* number of packets */
+ avio_put_le64(pb, duration); /* end time stamp (in 100ns units) */
+ avio_put_le64(pb, asf->duration); /* duration (in 100ns units) */
+ avio_put_le64(pb, PREROLL_TIME); /* start time stamp */
+ avio_put_le32(pb, (asf->is_streamed || url_is_streamed(pb)) ? 3 : 2); /* ??? */
+ avio_put_le32(pb, s->packet_size); /* packet size */
+ avio_put_le32(pb, s->packet_size); /* packet size */
+ avio_put_le32(pb, bit_rate); /* Nominal data rate in bps */
end_header(pb, hpos);
/* unknown headers */
hpos = put_header(pb, &ff_asf_head1_guid);
put_guid(pb, &ff_asf_head2_guid);
- put_le32(pb, 6);
- put_le16(pb, 0);
+ avio_put_le32(pb, 6);
+ avio_put_le16(pb, 0);
end_header(pb, hpos);
/* title and other infos */
@@ -372,20 +372,20 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
for (n = 0; n < FF_ARRAY_ELEMS(tags); n++) {
len = tags[n] ? avio_put_str16le(dyn_buf, tags[n]->value) : 0;
- put_le16(pb, len);
+ avio_put_le16(pb, len);
}
len = url_close_dyn_buf(dyn_buf, &buf);
- put_buffer(pb, buf, len);
+ avio_put_buffer(pb, buf, len);
av_freep(&buf);
end_header(pb, hpos);
}
if (metadata_count) {
AVMetadataTag *tag = NULL;
hpos = put_header(pb, &ff_asf_extended_content_header);
- put_le16(pb, metadata_count);
+ avio_put_le16(pb, metadata_count);
while ((tag = av_metadata_get(s->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
put_str16(pb, tag->key);
- put_le16(pb, 0);
+ avio_put_le16(pb, 0);
put_str16(pb, tag->value);
}
end_header(pb, hpos);
@@ -423,19 +423,19 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
put_guid(pb, &ff_asf_video_stream);
put_guid(pb, &ff_asf_video_conceal_none);
}
- put_le64(pb, 0); /* ??? */
+ avio_put_le64(pb, 0); /* ??? */
es_pos = url_ftell(pb);
- put_le32(pb, extra_size); /* wav header len */
- put_le32(pb, extra_size2); /* additional data len */
- put_le16(pb, n + 1); /* stream number */
- put_le32(pb, 0); /* ??? */
+ avio_put_le32(pb, extra_size); /* wav header len */
+ avio_put_le32(pb, extra_size2); /* additional data len */
+ avio_put_le16(pb, n + 1); /* stream number */
+ avio_put_le32(pb, 0); /* ??? */
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
/* WAVEFORMATEX header */
int wavsize = ff_put_wav_header(pb, enc);
if ((enc->codec_id != CODEC_ID_MP3) && (enc->codec_id != CODEC_ID_MP2) && (enc->codec_id != CODEC_ID_ADPCM_IMA_WAV) && (enc->extradata_size==0)) {
wavsize += 2;
- put_le16(pb, 0);
+ avio_put_le16(pb, 0);
}
if (wavsize < 0)
@@ -443,25 +443,25 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
if (wavsize != extra_size) {
cur_pos = url_ftell(pb);
url_fseek(pb, es_pos, SEEK_SET);
- put_le32(pb, wavsize); /* wav header len */
+ avio_put_le32(pb, wavsize); /* wav header len */
url_fseek(pb, cur_pos, SEEK_SET);
}
/* ERROR Correction */
- put_byte(pb, 0x01);
+ avio_put_byte(pb, 0x01);
if(enc->codec_id == CODEC_ID_ADPCM_G726 || !enc->block_align){
- put_le16(pb, 0x0190);
- put_le16(pb, 0x0190);
+ avio_put_le16(pb, 0x0190);
+ avio_put_le16(pb, 0x0190);
}else{
- put_le16(pb, enc->block_align);
- put_le16(pb, enc->block_align);
+ avio_put_le16(pb, enc->block_align);
+ avio_put_le16(pb, enc->block_align);
}
- put_le16(pb, 0x01);
- put_byte(pb, 0x00);
+ avio_put_le16(pb, 0x01);
+ avio_put_byte(pb, 0x00);
} else {
- put_le32(pb, enc->width);
- put_le32(pb, enc->height);
- put_byte(pb, 2); /* ??? */
- put_le16(pb, 40 + enc->extradata_size); /* size */
+ avio_put_le32(pb, enc->width);
+ avio_put_le32(pb, enc->height);
+ avio_put_byte(pb, 2); /* ??? */
+ avio_put_le16(pb, 40 + enc->extradata_size); /* size */
/* BITMAPINFOHEADER header */
ff_put_bmp_header(pb, enc, ff_codec_bmp_tags, 1);
@@ -473,7 +473,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
hpos = put_header(pb, &ff_asf_codec_comment_header);
put_guid(pb, &ff_asf_codec_comment1_header);
- put_le32(pb, s->nb_streams);
+ avio_put_le32(pb, s->nb_streams);
for(n=0;n<s->nb_streams;n++) {
AVCodec *p;
const char *desc;
@@ -485,11 +485,11 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
p = avcodec_find_encoder(enc->codec_id);
if(enc->codec_type == AVMEDIA_TYPE_AUDIO)
- put_le16(pb, 2);
+ avio_put_le16(pb, 2);
else if(enc->codec_type == AVMEDIA_TYPE_VIDEO)
- put_le16(pb, 1);
+ avio_put_le16(pb, 1);
else
- put_le16(pb, -1);
+ avio_put_le16(pb, -1);
if(enc->codec_id == CODEC_ID_WMAV2)
desc = "Windows Media Audio V8";
@@ -501,21 +501,21 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
avio_put_str16le(dyn_buf, desc);
len = url_close_dyn_buf(dyn_buf, &buf);
- put_le16(pb, len / 2); // "number of characters" = length in bytes / 2
+ avio_put_le16(pb, len / 2); // "number of characters" = length in bytes / 2
- put_buffer(pb, buf, len);
+ avio_put_buffer(pb, buf, len);
av_freep(&buf);
- put_le16(pb, 0); /* no parameters */
+ avio_put_le16(pb, 0); /* no parameters */
/* id */
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
- put_le16(pb, 2);
- put_le16(pb, enc->codec_tag);
+ avio_put_le16(pb, 2);
+ avio_put_le16(pb, enc->codec_tag);
} else {
- put_le16(pb, 4);
- put_le32(pb, enc->codec_tag);
+ avio_put_le16(pb, 4);
+ avio_put_le32(pb, enc->codec_tag);
}
if(!enc->codec_tag)
return -1;
@@ -530,25 +530,25 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
header_size += 8 + 30 + 50;
url_fseek(pb, header_offset - 10 - 30, SEEK_SET);
- put_le16(pb, header_size);
+ avio_put_le16(pb, header_size);
url_fseek(pb, header_offset - 2 - 30, SEEK_SET);
- put_le16(pb, header_size);
+ avio_put_le16(pb, header_size);
header_size -= 8 + 30 + 50;
}
header_size += 24 + 6;
url_fseek(pb, header_offset - 14, SEEK_SET);
- put_le64(pb, header_size);
+ avio_put_le64(pb, header_size);
url_fseek(pb, cur_pos, SEEK_SET);
/* movie chunk, followed by packets of packet_size */
asf->data_offset = cur_pos;
put_guid(pb, &ff_asf_data_header);
- put_le64(pb, data_chunk_size);
+ avio_put_le64(pb, data_chunk_size);
put_guid(pb, &ff_asf_my_guid);
- put_le64(pb, asf->nb_packets); /* nb packets */
- put_byte(pb, 1); /* ??? */
- put_byte(pb, 1); /* ??? */
+ avio_put_le64(pb, asf->nb_packets); /* nb packets */
+ avio_put_byte(pb, 1); /* ??? */
+ avio_put_byte(pb, 1); /* ??? */
return 0;
}
@@ -613,9 +613,9 @@ static int put_payload_parsing_info(
padsize--;
assert(padsize>=0);
- put_byte(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS);
+ avio_put_byte(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS);
for (i = 0; i < ASF_PACKET_ERROR_CORRECTION_DATA_SIZE; i++){
- put_byte(pb, 0x0);
+ avio_put_byte(pb, 0x0);
}
if (asf->multi_payloads_present)
@@ -627,19 +627,19 @@ static int put_payload_parsing_info(
else
iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD;
}
- put_byte(pb, iLengthTypeFlags);
+ avio_put_byte(pb, iLengthTypeFlags);
- put_byte(pb, ASF_PPI_PROPERTY_FLAGS);
+ avio_put_byte(pb, ASF_PPI_PROPERTY_FLAGS);
if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD)
- put_le16(pb, padsize - 2);
+ avio_put_le16(pb, padsize - 2);
if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE)
- put_byte(pb, padsize - 1);
+ avio_put_byte(pb, padsize - 1);
- put_le32(pb, sendtime);
- put_le16(pb, duration);
+ avio_put_le32(pb, sendtime);
+ avio_put_le16(pb, duration);
if (asf->multi_payloads_present)
- put_byte(pb, nb_payloads | ASF_PAYLOAD_FLAGS);
+ avio_put_byte(pb, nb_payloads | ASF_PAYLOAD_FLAGS);
ppi_size = url_ftell(pb) - start;
@@ -669,7 +669,7 @@ static void flush_packet(AVFormatContext *s)
assert(packet_hdr_size <= asf->packet_size_left);
memset(asf->packet_buf + packet_filled_size, 0, asf->packet_size_left);
- put_buffer(s->pb, asf->packet_buf, s->packet_size - packet_hdr_size);
+ avio_put_buffer(s->pb, asf->packet_buf, s->packet_size - packet_hdr_size);
put_flush_packet(s->pb);
asf->nb_packets++;
@@ -697,23 +697,23 @@ static void put_payload_header(
val = stream->num;
if (flags & AV_PKT_FLAG_KEY)
val |= ASF_PL_FLAG_KEY_FRAME;
- put_byte(pb, val);
+ avio_put_byte(pb, val);
- put_byte(pb, stream->seq); //Media object number
- put_le32(pb, m_obj_offset); //Offset Into Media Object
+ avio_put_byte(pb, stream->seq); //Media object number
+ avio_put_le32(pb, m_obj_offset); //Offset Into Media Object
// Replicated Data shall be at least 8 bytes long.
// The first 4 bytes of data shall contain the
// Size of the Media Object that the payload belongs to.
// The next 4 bytes of data shall contain the
// Presentation Time for the media object that the payload belongs to.
- put_byte(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH);
+ avio_put_byte(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH);
- put_le32(pb, m_obj_size); //Replicated Data - Media Object Size
- put_le32(pb, presentation_time);//Replicated Data - Presentation Time
+ avio_put_le32(pb, m_obj_size); //Replicated Data - Media Object Size
+ avio_put_le32(pb, presentation_time);//Replicated Data - Presentation Time
if (asf->multi_payloads_present){
- put_le16(pb, payload_len); //payload length
+ avio_put_le16(pb, payload_len); //payload length
}
}
@@ -761,7 +761,7 @@ static void put_frame(
payload_len = frag_len1 - 2; //additional byte need to put padding length
put_payload_header(s, stream, timestamp+PREROLL_TIME, m_obj_size, m_obj_offset, payload_len, flags);
- put_buffer(&asf->pb, buf, payload_len);
+ avio_put_buffer(&asf->pb, buf, payload_len);
if (asf->multi_payloads_present)
asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS);
@@ -836,14 +836,14 @@ static int asf_write_index(AVFormatContext *s, ASFIndex *index, uint16_t max, ui
int i;
put_guid(pb, &ff_asf_simple_index_header);
- put_le64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2)*count);
+ avio_put_le64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2)*count);
put_guid(pb, &ff_asf_my_guid);
- put_le64(pb, ASF_INDEXED_INTERVAL);
- put_le32(pb, max);
- put_le32(pb, count);
+ avio_put_le64(pb, ASF_INDEXED_INTERVAL);
+ avio_put_le32(pb, max);
+ avio_put_le32(pb, count);
for(i=0; i<count; i++) {
- put_le32(pb, index[i].packet_number);
- put_le16(pb, index[i].packet_count);
+ avio_put_le32(pb, index[i].packet_number);
+ avio_put_le16(pb, index[i].packet_count);
}
return 0;
diff --git a/libavformat/assenc.c b/libavformat/assenc.c
index fdd5306..7c1cfd7 100644
--- a/libavformat/assenc.c
+++ b/libavformat/assenc.c
@@ -42,7 +42,7 @@ static int write_header(AVFormatContext *s)
if(!end) end= avctx->extradata + avctx->extradata_size;
else end++;
- put_buffer(s->pb, p, end-p);
+ avio_put_buffer(s->pb, p, end-p);
ass->extra_index += end-p;
if(last && !memcmp(last, "[Events]", 8))
@@ -57,7 +57,7 @@ static int write_header(AVFormatContext *s)
static int write_packet(AVFormatContext *s, AVPacket *pkt)
{
- put_buffer(s->pb, pkt->data, pkt->size);
+ avio_put_buffer(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb);
@@ -69,7 +69,7 @@ static int write_trailer(AVFormatContext *s)
ASSContext *ass = s->priv_data;
AVCodecContext *avctx= s->streams[0]->codec;
- put_buffer(s->pb, avctx->extradata + ass->extra_index,
+ avio_put_buffer(s->pb, avctx->extradata + ass->extra_index,
avctx->extradata_size - ass->extra_index);
put_flush_packet(s->pb);
diff --git a/libavformat/au.c b/libavformat/au.c
index e18022d..cb1b93b 100644
--- a/libavformat/au.c
+++ b/libavformat/au.c
@@ -53,12 +53,12 @@ static int put_au_header(ByteIOContext *pb, AVCodecContext *enc)
{
if(!enc->codec_tag)
return -1;
- put_tag(pb, ".snd"); /* magic number */
- put_be32(pb, 24); /* header size */
- put_be32(pb, AU_UNKNOWN_SIZE); /* data size */
- put_be32(pb, (uint32_t)enc->codec_tag); /* codec ID */
- put_be32(pb, enc->sample_rate);
- put_be32(pb, (uint32_t)enc->channels);
+ avio_put_tag(pb, ".snd"); /* magic number */
+ avio_put_be32(pb, 24); /* header size */
+ avio_put_be32(pb, AU_UNKNOWN_SIZE); /* data size */
+ avio_put_be32(pb, (uint32_t)enc->codec_tag); /* codec ID */
+ avio_put_be32(pb, enc->sample_rate);
+ avio_put_be32(pb, (uint32_t)enc->channels);
return 0;
}
@@ -81,7 +81,7 @@ static int au_write_header(AVFormatContext *s)
static int au_write_packet(AVFormatContext *s, AVPacket *pkt)
{
ByteIOContext *pb = s->pb;
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_buffer(pb, pkt->data, pkt->size);
return 0;
}
@@ -95,7 +95,7 @@ static int au_write_trailer(AVFormatContext *s)
/* update file size */
file_size = url_ftell(pb);
url_fseek(pb, 8, SEEK_SET);
- put_be32(pb, (uint32_t)(file_size - 24));
+ avio_put_be32(pb, (uint32_t)(file_size - 24));
url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb);
diff --git a/libavformat/avc.c b/libavformat/avc.c
index 7c99196..5eac1db 100644
--- a/libavformat/avc.c
+++ b/libavformat/avc.c
@@ -78,8 +78,8 @@ int ff_avc_parse_nal_units(ByteIOContext *pb, const uint8_t *buf_in, int size)
while (nal_start < end) {
while(!*(nal_start++));
nal_end = ff_avc_find_startcode(nal_start, end);
- put_be32(pb, nal_end - nal_start);
- put_buffer(pb, nal_start, nal_end - nal_start);
+ avio_put_be32(pb, nal_end - nal_start);
+ avio_put_buffer(pb, nal_start, nal_end - nal_start);
size += 4 + nal_end - nal_start;
nal_start = nal_end;
}
@@ -134,21 +134,21 @@ int ff_isom_write_avcc(ByteIOContext *pb, const uint8_t *data, int len)
assert(sps);
assert(pps);
- put_byte(pb, 1); /* version */
- put_byte(pb, sps[1]); /* profile */
- put_byte(pb, sps[2]); /* profile compat */
- put_byte(pb, sps[3]); /* level */
- put_byte(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */
- put_byte(pb, 0xe1); /* 3 bits reserved (111) + 5 bits number of sps (00001) */
-
- put_be16(pb, sps_size);
- put_buffer(pb, sps, sps_size);
- put_byte(pb, 1); /* number of pps */
- put_be16(pb, pps_size);
- put_buffer(pb, pps, pps_size);
+ avio_put_byte(pb, 1); /* version */
+ avio_put_byte(pb, sps[1]); /* profile */
+ avio_put_byte(pb, sps[2]); /* profile compat */
+ avio_put_byte(pb, sps[3]); /* level */
+ avio_put_byte(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */
+ avio_put_byte(pb, 0xe1); /* 3 bits reserved (111) + 5 bits number of sps (00001) */
+
+ avio_put_be16(pb, sps_size);
+ avio_put_buffer(pb, sps, sps_size);
+ avio_put_byte(pb, 1); /* number of pps */
+ avio_put_be16(pb, pps_size);
+ avio_put_buffer(pb, pps, pps_size);
av_free(start);
} else {
- put_buffer(pb, data, len);
+ avio_put_buffer(pb, data, len);
}
}
return 0;
diff --git a/libavformat/avienc.c b/libavformat/avienc.c
index 3397657..178c22b 100644
--- a/libavformat/avienc.c
+++ b/libavformat/avienc.c
@@ -77,9 +77,9 @@ static int64_t avi_start_new_riff(AVFormatContext *s, ByteIOContext *pb,
}
avi->riff_start = ff_start_tag(pb, "RIFF");
- put_tag(pb, riff_tag);
+ avio_put_tag(pb, riff_tag);
loff = ff_start_tag(pb, "LIST");
- put_tag(pb, list_tag);
+ avio_put_tag(pb, list_tag);
return loff;
}
@@ -107,11 +107,11 @@ static void avi_write_info_tag(ByteIOContext *pb, const char *tag, const char *s
int len = strlen(str);
if (len > 0) {
len++;
- put_tag(pb, tag);
- put_le32(pb, len);
+ avio_put_tag(pb, tag);
+ avio_put_le32(pb, len);
avio_put_str(pb, str);
if (len & 1)
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
}
}
@@ -132,9 +132,9 @@ static int avi_write_counters(AVFormatContext* s, int riff_id)
url_fseek(pb, avist->frames_hdr_strm, SEEK_SET);
ff_parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale);
if(au_ssize == 0) {
- put_le32(pb, avist->packet_count);
+ avio_put_le32(pb, avist->packet_count);
} else {
- put_le32(pb, avist->audio_strm_length / au_ssize);
+ avio_put_le32(pb, avist->audio_strm_length / au_ssize);
}
if(stream->codec_type == AVMEDIA_TYPE_VIDEO)
nb_frames = FFMAX(nb_frames, avist->packet_count);
@@ -142,7 +142,7 @@ static int avi_write_counters(AVFormatContext* s, int riff_id)
if(riff_id == 1) {
assert(avi->frames_hdr_all);
url_fseek(pb, avi->frames_hdr_all, SEEK_SET);
- put_le32(pb, nb_frames);
+ avio_put_le32(pb, nb_frames);
}
url_fseek(pb, file_size, SEEK_SET);
@@ -169,8 +169,8 @@ static int avi_write_header(AVFormatContext *s)
list1 = avi_start_new_riff(s, pb, "AVI ", "hdrl");
/* avi header */
- put_tag(pb, "avih");
- put_le32(pb, 14 * 4);
+ avio_put_tag(pb, "avih");
+ avio_put_le32(pb, 14 * 4);
bitrate = 0;
video_enc = NULL;
@@ -184,38 +184,38 @@ static int avi_write_header(AVFormatContext *s)
nb_frames = 0;
if(video_enc){
- put_le32(pb, (uint32_t)(INT64_C(1000000) * video_enc->time_base.num / video_enc->time_base.den));
+ avio_put_le32(pb, (uint32_t)(INT64_C(1000000) * video_enc->time_base.num / video_enc->time_base.den));
} else {
- put_le32(pb, 0);
+ avio_put_le32(pb, 0);
}
- put_le32(pb, bitrate / 8); /* XXX: not quite exact */
- put_le32(pb, 0); /* padding */
+ avio_put_le32(pb, bitrate / 8); /* XXX: not quite exact */
+ avio_put_le32(pb, 0); /* padding */
if (url_is_streamed(pb))
- put_le32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED); /* flags */
+ avio_put_le32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED); /* flags */
else
- put_le32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */
+ avio_put_le32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */
avi->frames_hdr_all = url_ftell(pb); /* remember this offset to fill later */
- put_le32(pb, nb_frames); /* nb frames, filled later */
- put_le32(pb, 0); /* initial frame */
- put_le32(pb, s->nb_streams); /* nb streams */
- put_le32(pb, 1024 * 1024); /* suggested buffer size */
+ avio_put_le32(pb, nb_frames); /* nb frames, filled later */
+ avio_put_le32(pb, 0); /* initial frame */
+ avio_put_le32(pb, s->nb_streams); /* nb streams */
+ avio_put_le32(pb, 1024 * 1024); /* suggested buffer size */
if(video_enc){
- put_le32(pb, video_enc->width);
- put_le32(pb, video_enc->height);
+ avio_put_le32(pb, video_enc->width);
+ avio_put_le32(pb, video_enc->height);
} else {
- put_le32(pb, 0);
- put_le32(pb, 0);
+ avio_put_le32(pb, 0);
+ avio_put_le32(pb, 0);
}
- put_le32(pb, 0); /* reserved */
- put_le32(pb, 0); /* reserved */
- put_le32(pb, 0); /* reserved */
- put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
/* stream list */
for(i=0;i<n;i++) {
AVIStream *avist= s->streams[i]->priv_data;
list2 = ff_start_tag(pb, "LIST");
- put_tag(pb, "strl");
+ avio_put_tag(pb, "strl");
stream = s->streams[i]->codec;
@@ -229,46 +229,46 @@ static int avi_write_header(AVFormatContext *s)
av_log(s, AV_LOG_ERROR, "Subtitle streams other than DivX XSUB are not supported by the AVI muxer.\n");
return AVERROR_PATCHWELCOME;
}
- case AVMEDIA_TYPE_VIDEO: put_tag(pb, "vids"); break;
- case AVMEDIA_TYPE_AUDIO: put_tag(pb, "auds"); break;
-// case AVMEDIA_TYPE_TEXT : put_tag(pb, "txts"); break;
- case AVMEDIA_TYPE_DATA : put_tag(pb, "dats"); break;
+ case AVMEDIA_TYPE_VIDEO: avio_put_tag(pb, "vids"); break;
+ case AVMEDIA_TYPE_AUDIO: avio_put_tag(pb, "auds"); break;
+// case AVMEDIA_TYPE_TEXT : avio_put_tag(pb, "txts"); break;
+ case AVMEDIA_TYPE_DATA : avio_put_tag(pb, "dats"); break;
}
if(stream->codec_type == AVMEDIA_TYPE_VIDEO ||
stream->codec_id == CODEC_ID_XSUB)
- put_le32(pb, stream->codec_tag);
+ avio_put_le32(pb, stream->codec_tag);
else
- put_le32(pb, 1);
- put_le32(pb, 0); /* flags */
- put_le16(pb, 0); /* priority */
- put_le16(pb, 0); /* language */
- put_le32(pb, 0); /* initial frame */
+ avio_put_le32(pb, 1);
+ avio_put_le32(pb, 0); /* flags */
+ avio_put_le16(pb, 0); /* priority */
+ avio_put_le16(pb, 0); /* language */
+ avio_put_le32(pb, 0); /* initial frame */
ff_parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale);
- put_le32(pb, au_scale); /* scale */
- put_le32(pb, au_byterate); /* rate */
+ avio_put_le32(pb, au_scale); /* scale */
+ avio_put_le32(pb, au_byterate); /* rate */
av_set_pts_info(s->streams[i], 64, au_scale, au_byterate);
- put_le32(pb, 0); /* start */
+ avio_put_le32(pb, 0); /* start */
avist->frames_hdr_strm = url_ftell(pb); /* remember this offset to fill later */
if (url_is_streamed(pb))
- put_le32(pb, AVI_MAX_RIFF_SIZE); /* FIXME: this may be broken, but who cares */
+ avio_put_le32(pb, AVI_MAX_RIFF_SIZE); /* FIXME: this may be broken, but who cares */
else
- put_le32(pb, 0); /* length, XXX: filled later */
+ avio_put_le32(pb, 0); /* length, XXX: filled later */
/* suggested buffer size */ //FIXME set at the end to largest chunk
if(stream->codec_type == AVMEDIA_TYPE_VIDEO)
- put_le32(pb, 1024 * 1024);
+ avio_put_le32(pb, 1024 * 1024);
else if(stream->codec_type == AVMEDIA_TYPE_AUDIO)
- put_le32(pb, 12 * 1024);
+ avio_put_le32(pb, 12 * 1024);
else
- put_le32(pb, 0);
- put_le32(pb, -1); /* quality */
- put_le32(pb, au_ssize); /* sample size */
- put_le32(pb, 0);
- put_le16(pb, stream->width);
- put_le16(pb, stream->height);
+ avio_put_le32(pb, 0);
+ avio_put_le32(pb, -1); /* quality */
+ avio_put_le32(pb, au_ssize); /* sample size */
+ avio_put_le32(pb, 0);
+ avio_put_le16(pb, stream->width);
+ avio_put_le16(pb, stream->height);
ff_end_tag(pb, strh);
if(stream->codec_type != AVMEDIA_TYPE_DATA){
@@ -307,16 +307,16 @@ static int avi_write_header(AVFormatContext *s)
*/
avist->indexes.entry = avist->indexes.ents_allocated = 0;
avist->indexes.indx_start = ff_start_tag(pb, "JUNK");
- put_le16(pb, 4); /* wLongsPerEntry */
- put_byte(pb, 0); /* bIndexSubType (0 == frame index) */
- put_byte(pb, 0); /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */
- put_le32(pb, 0); /* nEntriesInUse (will fill out later on) */
- put_tag(pb, avi_stream2fourcc(&tag[0], i, stream->codec_type));
+ avio_put_le16(pb, 4); /* wLongsPerEntry */
+ avio_put_byte(pb, 0); /* bIndexSubType (0 == frame index) */
+ avio_put_byte(pb, 0); /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */
+ avio_put_le32(pb, 0); /* nEntriesInUse (will fill out later on) */
+ avio_put_tag(pb, avi_stream2fourcc(&tag[0], i, stream->codec_type));
/* dwChunkId */
- put_le64(pb, 0); /* dwReserved[3]
- put_le32(pb, 0); Must be 0. */
+ avio_put_le64(pb, 0); /* dwReserved[3]
+ avio_put_le32(pb, 0); Must be 0. */
for (j=0; j < AVI_MASTER_INDEX_SIZE * 2; j++)
- put_le64(pb, 0);
+ avio_put_le64(pb, 0);
ff_end_tag(pb, avist->indexes.indx_start);
}
@@ -329,26 +329,26 @@ static int avi_write_header(AVFormatContext *s)
int num, den;
av_reduce(&num, &den, dar.num, dar.den, 0xFFFF);
- put_le32(pb, 0); //video format = unknown
- put_le32(pb, 0); //video standard= unknown
- put_le32(pb, lrintf(1.0/av_q2d(stream->time_base)));
- put_le32(pb, stream->width );
- put_le32(pb, stream->height);
- put_le16(pb, den);
- put_le16(pb, num);
- put_le32(pb, stream->width );
- put_le32(pb, stream->height);
- put_le32(pb, 1); //progressive FIXME
-
- put_le32(pb, stream->height);
- put_le32(pb, stream->width );
- put_le32(pb, stream->height);
- put_le32(pb, stream->width );
- put_le32(pb, 0);
- put_le32(pb, 0);
-
- put_le32(pb, 0);
- put_le32(pb, 0);
+ avio_put_le32(pb, 0); //video format = unknown
+ avio_put_le32(pb, 0); //video standard= unknown
+ avio_put_le32(pb, lrintf(1.0/av_q2d(stream->time_base)));
+ avio_put_le32(pb, stream->width );
+ avio_put_le32(pb, stream->height);
+ avio_put_le16(pb, den);
+ avio_put_le16(pb, num);
+ avio_put_le32(pb, stream->width );
+ avio_put_le32(pb, stream->height);
+ avio_put_le32(pb, 1); //progressive FIXME
+
+ avio_put_le32(pb, stream->height);
+ avio_put_le32(pb, stream->width );
+ avio_put_le32(pb, stream->height);
+ avio_put_le32(pb, stream->width );
+ avio_put_le32(pb, 0);
+ avio_put_le32(pb, 0);
+
+ avio_put_le32(pb, 0);
+ avio_put_le32(pb, 0);
ff_end_tag(pb, vprp);
}
@@ -358,18 +358,18 @@ static int avi_write_header(AVFormatContext *s)
if (!url_is_streamed(pb)) {
/* AVI could become an OpenDML one, if it grows beyond 2Gb range */
avi->odml_list = ff_start_tag(pb, "JUNK");
- put_tag(pb, "odml");
- put_tag(pb, "dmlh");
- put_le32(pb, 248);
+ avio_put_tag(pb, "odml");
+ avio_put_tag(pb, "dmlh");
+ avio_put_le32(pb, 248);
for (i = 0; i < 248; i+= 4)
- put_le32(pb, 0);
+ avio_put_le32(pb, 0);
ff_end_tag(pb, avi->odml_list);
}
ff_end_tag(pb, list1);
list2 = ff_start_tag(pb, "LIST");
- put_tag(pb, "INFO");
+ avio_put_tag(pb, "INFO");
ff_metadata_conv(&s->metadata, ff_avi_metadata_conv, NULL);
for (i = 0; *ff_avi_tags[i]; i++) {
if ((t = av_metadata_get(s->metadata, ff_avi_tags[i], NULL, AV_METADATA_MATCH_CASE)))
@@ -380,11 +380,11 @@ static int avi_write_header(AVFormatContext *s)
/* some padding for easier tag editing */
list2 = ff_start_tag(pb, "JUNK");
for (i = 0; i < 1016; i += 4)
- put_le32(pb, 0);
+ avio_put_le32(pb, 0);
ff_end_tag(pb, list2);
avi->movi_list = ff_start_tag(pb, "LIST");
- put_tag(pb, "movi");
+ avio_put_tag(pb, "movi");
put_flush_packet(pb);
@@ -413,22 +413,22 @@ static int avi_write_ix(AVFormatContext *s)
/* Writing AVI OpenDML leaf index chunk */
ix = url_ftell(pb);
- put_tag(pb, &ix_tag[0]); /* ix?? */
- put_le32(pb, avist->indexes.entry * 8 + 24);
+ avio_put_tag(pb, &ix_tag[0]); /* ix?? */
+ avio_put_le32(pb, avist->indexes.entry * 8 + 24);
/* chunk size */
- put_le16(pb, 2); /* wLongsPerEntry */
- put_byte(pb, 0); /* bIndexSubType (0 == frame index) */
- put_byte(pb, 1); /* bIndexType (1 == AVI_INDEX_OF_CHUNKS) */
- put_le32(pb, avist->indexes.entry);
+ avio_put_le16(pb, 2); /* wLongsPerEntry */
+ avio_put_byte(pb, 0); /* bIndexSubType (0 == frame index) */
+ avio_put_byte(pb, 1); /* bIndexType (1 == AVI_INDEX_OF_CHUNKS) */
+ avio_put_le32(pb, avist->indexes.entry);
/* nEntriesInUse */
- put_tag(pb, &tag[0]); /* dwChunkId */
- put_le64(pb, avi->movi_list);/* qwBaseOffset */
- put_le32(pb, 0); /* dwReserved_3 (must be 0) */
+ avio_put_tag(pb, &tag[0]); /* dwChunkId */
+ avio_put_le64(pb, avi->movi_list);/* qwBaseOffset */
+ avio_put_le32(pb, 0); /* dwReserved_3 (must be 0) */
for (j=0; j<avist->indexes.entry; j++) {
AVIIentry* ie = avi_get_ientry(&avist->indexes, j);
- put_le32(pb, ie->pos + 8);
- put_le32(pb, ((uint32_t)ie->len & ~0x80000000) |
+ avio_put_le32(pb, ie->pos + 8);
+ avio_put_le32(pb, ((uint32_t)ie->len & ~0x80000000) |
(ie->flags & 0x10 ? 0 : 0x80000000));
}
put_flush_packet(pb);
@@ -436,13 +436,13 @@ static int avi_write_ix(AVFormatContext *s)
/* Updating one entry in the AVI OpenDML master index */
url_fseek(pb, avist->indexes.indx_start - 8, SEEK_SET);
- put_tag(pb, "indx"); /* enabling this entry */
+ avio_put_tag(pb, "indx"); /* enabling this entry */
url_fskip(pb, 8);
- put_le32(pb, avi->riff_id); /* nEntriesInUse */
+ avio_put_le32(pb, avi->riff_id); /* nEntriesInUse */
url_fskip(pb, 16*avi->riff_id);
- put_le64(pb, ix); /* qwOffset */
- put_le32(pb, pos - ix); /* dwSize */
- put_le32(pb, avist->indexes.entry); /* dwDuration */
+ avio_put_le64(pb, ix); /* qwOffset */
+ avio_put_le32(pb, pos - ix); /* dwSize */
+ avio_put_le32(pb, avist->indexes.entry); /* dwDuration */
url_fseek(pb, pos, SEEK_SET);
}
@@ -486,10 +486,10 @@ static int avi_write_idx1(AVFormatContext *s)
avist= s->streams[stream_id]->priv_data;
avi_stream2fourcc(&tag[0], stream_id,
s->streams[stream_id]->codec->codec_type);
- put_tag(pb, &tag[0]);
- put_le32(pb, ie->flags);
- put_le32(pb, ie->pos);
- put_le32(pb, ie->len);
+ avio_put_tag(pb, &tag[0]);
+ avio_put_le32(pb, ie->flags);
+ avio_put_le32(pb, ie->pos);
+ avio_put_le32(pb, ie->len);
avist->entry++;
}
} while (!empty);
@@ -565,11 +565,11 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
idx->entry++;
}
- put_buffer(pb, tag, 4);
- put_le32(pb, size);
- put_buffer(pb, pkt->data, size);
+ avio_put_buffer(pb, tag, 4);
+ avio_put_le32(pb, size);
+ avio_put_buffer(pb, pkt->data, size);
if (size & 1)
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
put_flush_packet(pb);
return 0;
@@ -595,7 +595,7 @@ static int avi_write_trailer(AVFormatContext *s)
file_size = url_ftell(pb);
url_fseek(pb, avi->odml_list - 8, SEEK_SET);
- put_tag(pb, "LIST"); /* Making this AVI OpenDML one */
+ avio_put_tag(pb, "LIST"); /* Making this AVI OpenDML one */
url_fskip(pb, 16);
for (n=nb_frames=0;n<s->nb_streams;n++) {
@@ -611,7 +611,7 @@ static int avi_write_trailer(AVFormatContext *s)
}
}
}
- put_le32(pb, nb_frames);
+ avio_put_le32(pb, nb_frames);
url_fseek(pb, file_size, SEEK_SET);
avi_write_counters(s, avi->riff_id);
diff --git a/libavformat/avio.h b/libavformat/avio.h
index c899c0d..5cacb8b 100644
--- a/libavformat/avio.h
+++ b/libavformat/avio.h
@@ -376,18 +376,41 @@ ByteIOContext *av_alloc_put_byte(
int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
int64_t (*seek)(void *opaque, int64_t offset, int whence));
-void put_byte(ByteIOContext *s, int b);
-void put_nbyte(ByteIOContext *s, int b, int count);
-void put_buffer(ByteIOContext *s, const unsigned char *buf, int size);
-void put_le64(ByteIOContext *s, uint64_t val);
-void put_be64(ByteIOContext *s, uint64_t val);
-void put_le32(ByteIOContext *s, unsigned int val);
-void put_be32(ByteIOContext *s, unsigned int val);
-void put_le24(ByteIOContext *s, unsigned int val);
-void put_be24(ByteIOContext *s, unsigned int val);
-void put_le16(ByteIOContext *s, unsigned int val);
-void put_be16(ByteIOContext *s, unsigned int val);
-void put_tag(ByteIOContext *s, const char *tag);
+#if FF_API_OLD_AVIO
+/**
+ * @defgroup old_avio_funcs Old put_/get_*() functions
+ * @deprecated use the avio_ -prefixed functions instead.
+ * @{
+ */
+attribute_deprecated void put_byte(ByteIOContext *s, int b);
+attribute_deprecated void put_nbyte(ByteIOContext *s, int b, int count);
+attribute_deprecated void put_buffer(ByteIOContext *s, const unsigned char *buf, int size);
+attribute_deprecated void put_le64(ByteIOContext *s, uint64_t val);
+attribute_deprecated void put_be64(ByteIOContext *s, uint64_t val);
+attribute_deprecated void put_le32(ByteIOContext *s, unsigned int val);
+attribute_deprecated void put_be32(ByteIOContext *s, unsigned int val);
+attribute_deprecated void put_le24(ByteIOContext *s, unsigned int val);
+attribute_deprecated void put_be24(ByteIOContext *s, unsigned int val);
+attribute_deprecated void put_le16(ByteIOContext *s, unsigned int val);
+attribute_deprecated void put_be16(ByteIOContext *s, unsigned int val);
+attribute_deprecated void put_tag(ByteIOContext *s, const char *tag);
+/**
+ * @}
+ */
+#endif
+
+void avio_put_byte( ByteIOContext *s, int b);
+void avio_put_nbyte( ByteIOContext *s, int b, int count);
+void avio_put_buffer(ByteIOContext *s, const unsigned char *buf, int size);
+void avio_put_le64( ByteIOContext *s, uint64_t val);
+void avio_put_be64( ByteIOContext *s, uint64_t val);
+void avio_put_le32( ByteIOContext *s, unsigned int val);
+void avio_put_be32( ByteIOContext *s, unsigned int val);
+void avio_put_le24( ByteIOContext *s, unsigned int val);
+void avio_put_be24( ByteIOContext *s, unsigned int val);
+void avio_put_le16( ByteIOContext *s, unsigned int val);
+void avio_put_be16( ByteIOContext *s, unsigned int val);
+void avio_put_tag( ByteIOContext *s, const char *tag);
#if FF_API_OLD_AVIO
attribute_deprecated void put_strz(ByteIOContext *s, const char *buf);
diff --git a/libavformat/aviobuf.c b/libavformat/aviobuf.c
index acea811..8429032 100644
--- a/libavformat/aviobuf.c
+++ b/libavformat/aviobuf.c
@@ -106,14 +106,14 @@ static void flush_buffer(ByteIOContext *s)
s->buf_ptr = s->buffer;
}
-void put_byte(ByteIOContext *s, int b)
+void avio_put_byte(ByteIOContext *s, int b)
{
*(s->buf_ptr)++ = b;
if (s->buf_ptr >= s->buf_end)
flush_buffer(s);
}
-void put_nbyte(ByteIOContext *s, int b, int count)
+void avio_put_nbyte(ByteIOContext *s, int b, int count)
{
while (count > 0) {
int len = FFMIN(s->buf_end - s->buf_ptr, count);
@@ -127,7 +127,7 @@ void put_nbyte(ByteIOContext *s, int b, int count)
}
}
-void put_buffer(ByteIOContext *s, const unsigned char *buf, int size)
+void avio_put_buffer(ByteIOContext *s, const unsigned char *buf, int size)
{
while (size > 0) {
int len = FFMIN(s->buf_end - s->buf_ptr, size);
@@ -249,20 +249,20 @@ int url_ferror(ByteIOContext *s)
return s->error;
}
-void put_le32(ByteIOContext *s, unsigned int val)
+void avio_put_le32(ByteIOContext *s, unsigned int val)
{
- put_byte(s, val);
- put_byte(s, val >> 8);
- put_byte(s, val >> 16);
- put_byte(s, val >> 24);
+ avio_put_byte(s, val);
+ avio_put_byte(s, val >> 8);
+ avio_put_byte(s, val >> 16);
+ avio_put_byte(s, val >> 24);
}
-void put_be32(ByteIOContext *s, unsigned int val)
+void avio_put_be32(ByteIOContext *s, unsigned int val)
{
- put_byte(s, val >> 24);
- put_byte(s, val >> 16);
- put_byte(s, val >> 8);
- put_byte(s, val);
+ avio_put_byte(s, val >> 24);
+ avio_put_byte(s, val >> 16);
+ avio_put_byte(s, val >> 8);
+ avio_put_byte(s, val);
}
#if FF_API_OLD_AVIO
@@ -270,6 +270,34 @@ void put_strz(ByteIOContext *s, const char *str)
{
avio_put_str(s, str);
}
+
+#define PUT(name, type ) \
+ void put_ ##name ( ByteIOContext *s, type val)\
+{\
+ avio_put_ ##name ( s, val );\
+}
+
+PUT(byte, int)
+PUT(le16, unsigned int)
+PUT(be16, unsigned int)
+PUT(le24, unsigned int)
+PUT(be24, unsigned int)
+PUT(le32, unsigned int)
+PUT(be32, unsigned int)
+PUT(le64, uint64_t)
+PUT(be64, uint64_t)
+PUT(tag, const char *)
+#undef PUT
+
+void put_buffer(ByteIOContext *s, const unsigned char *buf, int size)
+{
+ avio_put_buffer(s, buf, size);
+}
+void put_nbyte(ByteIOContext *s, int b, int count)
+{
+ avio_put_nbyte(s, b, count);
+}
+
#endif
int avio_put_str(ByteIOContext *s, const char *str)
@@ -277,9 +305,9 @@ int avio_put_str(ByteIOContext *s, const char *str)
int len = 1;
if (str) {
len += strlen(str);
- put_buffer(s, (const unsigned char *) str, len);
+ avio_put_buffer(s, (const unsigned char *) str, len);
} else
- put_byte(s, 0);
+ avio_put_byte(s, 0);
return len;
}
@@ -293,9 +321,9 @@ int avio_put_str16le(ByteIOContext *s, const char *str)
uint16_t tmp;
GET_UTF8(ch, *q++, break;)
- PUT_UTF16(ch, tmp, put_le16(s, tmp);ret += 2;)
+ PUT_UTF16(ch, tmp, avio_put_le16(s, tmp);ret += 2;)
}
- put_le16(s, 0);
+ avio_put_le16(s, 0);
ret += 2;
return ret;
}
@@ -313,51 +341,51 @@ void ff_put_v(ByteIOContext *bc, uint64_t val){
int i= ff_get_v_length(val);
while(--i>0)
- put_byte(bc, 128 | (val>>(7*i)));
+ avio_put_byte(bc, 128 | (val>>(7*i)));
- put_byte(bc, val&127);
+ avio_put_byte(bc, val&127);
}
-void put_le64(ByteIOContext *s, uint64_t val)
+void avio_put_le64(ByteIOContext *s, uint64_t val)
{
- put_le32(s, (uint32_t)(val & 0xffffffff));
- put_le32(s, (uint32_t)(val >> 32));
+ avio_put_le32(s, (uint32_t)(val & 0xffffffff));
+ avio_put_le32(s, (uint32_t)(val >> 32));
}
-void put_be64(ByteIOContext *s, uint64_t val)
+void avio_put_be64(ByteIOContext *s, uint64_t val)
{
- put_be32(s, (uint32_t)(val >> 32));
- put_be32(s, (uint32_t)(val & 0xffffffff));
+ avio_put_be32(s, (uint32_t)(val >> 32));
+ avio_put_be32(s, (uint32_t)(val & 0xffffffff));
}
-void put_le16(ByteIOContext *s, unsigned int val)
+void avio_put_le16(ByteIOContext *s, unsigned int val)
{
- put_byte(s, val);
- put_byte(s, val >> 8);
+ avio_put_byte(s, val);
+ avio_put_byte(s, val >> 8);
}
-void put_be16(ByteIOContext *s, unsigned int val)
+void avio_put_be16(ByteIOContext *s, unsigned int val)
{
- put_byte(s, val >> 8);
- put_byte(s, val);
+ avio_put_byte(s, val >> 8);
+ avio_put_byte(s, val);
}
-void put_le24(ByteIOContext *s, unsigned int val)
+void avio_put_le24(ByteIOContext *s, unsigned int val)
{
- put_le16(s, val & 0xffff);
- put_byte(s, val >> 16);
+ avio_put_le16(s, val & 0xffff);
+ avio_put_byte(s, val >> 16);
}
-void put_be24(ByteIOContext *s, unsigned int val)
+void avio_put_be24(ByteIOContext *s, unsigned int val)
{
- put_be16(s, val >> 8);
- put_byte(s, val);
+ avio_put_be16(s, val >> 8);
+ avio_put_byte(s, val);
}
-void put_tag(ByteIOContext *s, const char *tag)
+void avio_put_tag(ByteIOContext *s, const char *tag)
{
while (*tag) {
- put_byte(s, *tag++);
+ avio_put_byte(s, *tag++);
}
}
@@ -797,7 +825,7 @@ int url_fprintf(ByteIOContext *s, const char *fmt, ...)
va_start(ap, fmt);
ret = vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
- put_buffer(s, buf, strlen(buf));
+ avio_put_buffer(s, buf, strlen(buf));
return ret;
}
#endif //CONFIG_MUXERS
@@ -998,7 +1026,7 @@ int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer)
/* don't attempt to pad fixed-size packet buffers */
if (!s->max_packet_size) {
- put_buffer(s, padbuf, sizeof(padbuf));
+ avio_put_buffer(s, padbuf, sizeof(padbuf));
padding = FF_INPUT_BUFFER_PADDING_SIZE;
}
diff --git a/libavformat/crcenc.c b/libavformat/crcenc.c
index 2f9a099..5cd5e5e 100644
--- a/libavformat/crcenc.c
+++ b/libavformat/crcenc.c
@@ -49,7 +49,7 @@ static int crc_write_trailer(struct AVFormatContext *s)
char buf[64];
snprintf(buf, sizeof(buf), "CRC=0x%08x\n", crc->crcval);
- put_buffer(s->pb, buf, strlen(buf));
+ avio_put_buffer(s->pb, buf, strlen(buf));
put_flush_packet(s->pb);
return 0;
}
diff --git a/libavformat/daud.c b/libavformat/daud.c
index c8af2e4..887a910 100644
--- a/libavformat/daud.c
+++ b/libavformat/daud.c
@@ -57,9 +57,9 @@ static int daud_write_header(struct AVFormatContext *s)
static int daud_write_packet(struct AVFormatContext *s, AVPacket *pkt)
{
- put_be16(s->pb, pkt->size);
- put_be16(s->pb, 0x8010); // unknown
- put_buffer(s->pb, pkt->data, pkt->size);
+ avio_put_be16(s->pb, pkt->size);
+ avio_put_be16(s->pb, 0x8010); // unknown
+ avio_put_buffer(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb);
return 0;
}
diff --git a/libavformat/dvenc.c b/libavformat/dvenc.c
index faaa529..928eda7 100644
--- a/libavformat/dvenc.c
+++ b/libavformat/dvenc.c
@@ -381,7 +381,7 @@ static int dv_write_packet(struct AVFormatContext *s, AVPacket *pkt)
fsize = dv_assemble_frame(s->priv_data, s->streams[pkt->stream_index],
pkt->data, pkt->size, &frame);
if (fsize > 0) {
- put_buffer(s->pb, frame, fsize);
+ avio_put_buffer(s->pb, frame, fsize);
put_flush_packet(s->pb);
}
return 0;
diff --git a/libavformat/ffmenc.c b/libavformat/ffmenc.c
index f9e0782..2f3a203 100644
--- a/libavformat/ffmenc.c
+++ b/libavformat/ffmenc.c
@@ -36,14 +36,14 @@ static void flush_packet(AVFormatContext *s)
av_abort();
/* put header */
- put_be16(pb, PACKET_ID);
- put_be16(pb, fill_size);
- put_be64(pb, ffm->dts);
+ avio_put_be16(pb, PACKET_ID);
+ avio_put_be16(pb, fill_size);
+ avio_put_be64(pb, ffm->dts);
h = ffm->frame_offset;
if (ffm->first_packet)
h |= 0x8000;
- put_be16(pb, h);
- put_buffer(pb, ffm->packet, ffm->packet_end - ffm->packet);
+ avio_put_be16(pb, h);
+ avio_put_buffer(pb, ffm->packet, ffm->packet_end - ffm->packet);
put_flush_packet(pb);
/* prepare next packet */
@@ -91,17 +91,17 @@ static int ffm_write_header(AVFormatContext *s)
ffm->packet_size = FFM_PACKET_SIZE;
/* header */
- put_le32(pb, MKTAG('F', 'F', 'M', '1'));
- put_be32(pb, ffm->packet_size);
- put_be64(pb, 0); /* current write position */
+ avio_put_le32(pb, MKTAG('F', 'F', 'M', '1'));
+ avio_put_be32(pb, ffm->packet_size);
+ avio_put_be64(pb, 0); /* current write position */
- put_be32(pb, s->nb_streams);
+ avio_put_be32(pb, s->nb_streams);
bit_rate = 0;
for(i=0;i<s->nb_streams;i++) {
st = s->streams[i];
bit_rate += st->codec->bit_rate;
}
- put_be32(pb, bit_rate);
+ avio_put_be32(pb, bit_rate);
/* list of streams */
for(i=0;i<s->nb_streams;i++) {
@@ -110,82 +110,82 @@ static int ffm_write_header(AVFormatContext *s)
codec = st->codec;
/* generic info */
- put_be32(pb, codec->codec_id);
- put_byte(pb, codec->codec_type);
- put_be32(pb, codec->bit_rate);
- put_be32(pb, st->quality);
- put_be32(pb, codec->flags);
- put_be32(pb, codec->flags2);
- put_be32(pb, codec->debug);
+ avio_put_be32(pb, codec->codec_id);
+ avio_put_byte(pb, codec->codec_type);
+ avio_put_be32(pb, codec->bit_rate);
+ avio_put_be32(pb, st->quality);
+ avio_put_be32(pb, codec->flags);
+ avio_put_be32(pb, codec->flags2);
+ avio_put_be32(pb, codec->debug);
/* specific info */
switch(codec->codec_type) {
case AVMEDIA_TYPE_VIDEO:
- put_be32(pb, codec->time_base.num);
- put_be32(pb, codec->time_base.den);
- put_be16(pb, codec->width);
- put_be16(pb, codec->height);
- put_be16(pb, codec->gop_size);
- put_be32(pb, codec->pix_fmt);
- put_byte(pb, codec->qmin);
- put_byte(pb, codec->qmax);
- put_byte(pb, codec->max_qdiff);
- put_be16(pb, (int) (codec->qcompress * 10000.0));
- put_be16(pb, (int) (codec->qblur * 10000.0));
- put_be32(pb, codec->bit_rate_tolerance);
+ avio_put_be32(pb, codec->time_base.num);
+ avio_put_be32(pb, codec->time_base.den);
+ avio_put_be16(pb, codec->width);
+ avio_put_be16(pb, codec->height);
+ avio_put_be16(pb, codec->gop_size);
+ avio_put_be32(pb, codec->pix_fmt);
+ avio_put_byte(pb, codec->qmin);
+ avio_put_byte(pb, codec->qmax);
+ avio_put_byte(pb, codec->max_qdiff);
+ avio_put_be16(pb, (int) (codec->qcompress * 10000.0));
+ avio_put_be16(pb, (int) (codec->qblur * 10000.0));
+ avio_put_be32(pb, codec->bit_rate_tolerance);
avio_put_str(pb, codec->rc_eq ? codec->rc_eq : "tex^qComp");
- put_be32(pb, codec->rc_max_rate);
- put_be32(pb, codec->rc_min_rate);
- put_be32(pb, codec->rc_buffer_size);
- put_be64(pb, av_dbl2int(codec->i_quant_factor));
- put_be64(pb, av_dbl2int(codec->b_quant_factor));
- put_be64(pb, av_dbl2int(codec->i_quant_offset));
- put_be64(pb, av_dbl2int(codec->b_quant_offset));
- put_be32(pb, codec->dct_algo);
- put_be32(pb, codec->strict_std_compliance);
- put_be32(pb, codec->max_b_frames);
- put_be32(pb, codec->luma_elim_threshold);
- put_be32(pb, codec->chroma_elim_threshold);
- put_be32(pb, codec->mpeg_quant);
- put_be32(pb, codec->intra_dc_precision);
- put_be32(pb, codec->me_method);
- put_be32(pb, codec->mb_decision);
- put_be32(pb, codec->nsse_weight);
- put_be32(pb, codec->frame_skip_cmp);
- put_be64(pb, av_dbl2int(codec->rc_buffer_aggressivity));
- put_be32(pb, codec->codec_tag);
- put_byte(pb, codec->thread_count);
- put_be32(pb, codec->coder_type);
- put_be32(pb, codec->me_cmp);
- put_be32(pb, codec->partitions);
- put_be32(pb, codec->me_subpel_quality);
- put_be32(pb, codec->me_range);
- put_be32(pb, codec->keyint_min);
- put_be32(pb, codec->scenechange_threshold);
- put_be32(pb, codec->b_frame_strategy);
- put_be64(pb, av_dbl2int(codec->qcompress));
- put_be64(pb, av_dbl2int(codec->qblur));
- put_be32(pb, codec->max_qdiff);
- put_be32(pb, codec->refs);
- put_be32(pb, codec->directpred);
+ avio_put_be32(pb, codec->rc_max_rate);
+ avio_put_be32(pb, codec->rc_min_rate);
+ avio_put_be32(pb, codec->rc_buffer_size);
+ avio_put_be64(pb, av_dbl2int(codec->i_quant_factor));
+ avio_put_be64(pb, av_dbl2int(codec->b_quant_factor));
+ avio_put_be64(pb, av_dbl2int(codec->i_quant_offset));
+ avio_put_be64(pb, av_dbl2int(codec->b_quant_offset));
+ avio_put_be32(pb, codec->dct_algo);
+ avio_put_be32(pb, codec->strict_std_compliance);
+ avio_put_be32(pb, codec->max_b_frames);
+ avio_put_be32(pb, codec->luma_elim_threshold);
+ avio_put_be32(pb, codec->chroma_elim_threshold);
+ avio_put_be32(pb, codec->mpeg_quant);
+ avio_put_be32(pb, codec->intra_dc_precision);
+ avio_put_be32(pb, codec->me_method);
+ avio_put_be32(pb, codec->mb_decision);
+ avio_put_be32(pb, codec->nsse_weight);
+ avio_put_be32(pb, codec->frame_skip_cmp);
+ avio_put_be64(pb, av_dbl2int(codec->rc_buffer_aggressivity));
+ avio_put_be32(pb, codec->codec_tag);
+ avio_put_byte(pb, codec->thread_count);
+ avio_put_be32(pb, codec->coder_type);
+ avio_put_be32(pb, codec->me_cmp);
+ avio_put_be32(pb, codec->partitions);
+ avio_put_be32(pb, codec->me_subpel_quality);
+ avio_put_be32(pb, codec->me_range);
+ avio_put_be32(pb, codec->keyint_min);
+ avio_put_be32(pb, codec->scenechange_threshold);
+ avio_put_be32(pb, codec->b_frame_strategy);
+ avio_put_be64(pb, av_dbl2int(codec->qcompress));
+ avio_put_be64(pb, av_dbl2int(codec->qblur));
+ avio_put_be32(pb, codec->max_qdiff);
+ avio_put_be32(pb, codec->refs);
+ avio_put_be32(pb, codec->directpred);
break;
case AVMEDIA_TYPE_AUDIO:
- put_be32(pb, codec->sample_rate);
- put_le16(pb, codec->channels);
- put_le16(pb, codec->frame_size);
- put_le16(pb, codec->sample_fmt);
+ avio_put_be32(pb, codec->sample_rate);
+ avio_put_le16(pb, codec->channels);
+ avio_put_le16(pb, codec->frame_size);
+ avio_put_le16(pb, codec->sample_fmt);
break;
default:
return -1;
}
if (codec->flags & CODEC_FLAG_GLOBAL_HEADER) {
- put_be32(pb, codec->extradata_size);
- put_buffer(pb, codec->extradata, codec->extradata_size);
+ avio_put_be32(pb, codec->extradata_size);
+ avio_put_buffer(pb, codec->extradata, codec->extradata_size);
}
}
/* flush until end of block reached */
while ((url_ftell(pb) % ffm->packet_size) != 0)
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
put_flush_packet(pb);
diff --git a/libavformat/ffmetaenc.c b/libavformat/ffmetaenc.c
index b20abc9..c53c29c 100644
--- a/libavformat/ffmetaenc.c
+++ b/libavformat/ffmetaenc.c
@@ -31,8 +31,8 @@ static void write_escape_str(ByteIOContext *s, const uint8_t *str)
while (*p) {
if (*p == '#' || *p == ';' || *p == '=' || *p == '\\' || *p == '\n')
- put_byte(s, '\\');
- put_byte(s, *p);
+ avio_put_byte(s, '\\');
+ avio_put_byte(s, *p);
p++;
}
}
@@ -42,17 +42,17 @@ static void write_tags(ByteIOContext *s, AVMetadata *m)
AVMetadataTag *t = NULL;
while ((t = av_metadata_get(m, "", t, AV_METADATA_IGNORE_SUFFIX))) {
write_escape_str(s, t->key);
- put_byte(s, '=');
+ avio_put_byte(s, '=');
write_escape_str(s, t->value);
- put_byte(s, '\n');
+ avio_put_byte(s, '\n');
}
}
static int write_header(AVFormatContext *s)
{
- put_tag(s->pb, ID_STRING);
- put_byte(s->pb, '1'); // version
- put_byte(s->pb, '\n');
+ avio_put_tag(s->pb, ID_STRING);
+ avio_put_byte(s->pb, '1'); // version
+ avio_put_byte(s->pb, '\n');
put_flush_packet(s->pb);
return 0;
}
@@ -64,15 +64,15 @@ static int write_trailer(AVFormatContext *s)
write_tags(s->pb, s->metadata);
for (i = 0; i < s->nb_streams; i++) {
- put_tag(s->pb, ID_STREAM);
- put_byte(s->pb, '\n');
+ avio_put_tag(s->pb, ID_STREAM);
+ avio_put_byte(s->pb, '\n');
write_tags(s->pb, s->streams[i]->metadata);
}
for (i = 0; i < s->nb_chapters; i++) {
AVChapter *ch = s->chapters[i];
- put_tag(s->pb, ID_CHAPTER);
- put_byte(s->pb, '\n');
+ avio_put_tag(s->pb, ID_CHAPTER);
+ avio_put_byte(s->pb, '\n');
url_fprintf(s->pb, "TIMEBASE=%d/%d\n", ch->time_base.num, ch->time_base.den);
url_fprintf(s->pb, "START=%"PRId64"\n", ch->start);
url_fprintf(s->pb, "END=%"PRId64"\n", ch->end);
diff --git a/libavformat/filmstripenc.c b/libavformat/filmstripenc.c
index 6da575c..5ff17df 100644
--- a/libavformat/filmstripenc.c
+++ b/libavformat/filmstripenc.c
@@ -45,7 +45,7 @@ static int write_header(AVFormatContext *s)
static int write_packet(AVFormatContext *s, AVPacket *pkt)
{
FilmstripMuxContext *film = s->priv_data;
- put_buffer(s->pb, pkt->data, pkt->size);
+ avio_put_buffer(s->pb, pkt->data, pkt->size);
film->nb_frames++;
return 0;
}
@@ -57,16 +57,16 @@ static int write_trailer(AVFormatContext *s)
AVStream *st = s->streams[0];
int i;
- put_be32(pb, RAND_TAG);
- put_be32(pb, film->nb_frames);
- put_be16(pb, 0); // packing method
- put_be16(pb, 0); // reserved
- put_be16(pb, st->codec->width);
- put_be16(pb, st->codec->height);
- put_be16(pb, 0); // leading
- put_be16(pb, 1/av_q2d(st->codec->time_base));
+ avio_put_be32(pb, RAND_TAG);
+ avio_put_be32(pb, film->nb_frames);
+ avio_put_be16(pb, 0); // packing method
+ avio_put_be16(pb, 0); // reserved
+ avio_put_be16(pb, st->codec->width);
+ avio_put_be16(pb, st->codec->height);
+ avio_put_be16(pb, 0); // leading
+ avio_put_be16(pb, 1/av_q2d(st->codec->time_base));
for (i = 0; i < 16; i++)
- put_byte(pb, 0x00); // reserved
+ avio_put_byte(pb, 0x00); // reserved
put_flush_packet(pb);
return 0;
}
diff --git a/libavformat/flacenc.c b/libavformat/flacenc.c
index 5eee5be..de05972 100644
--- a/libavformat/flacenc.c
+++ b/libavformat/flacenc.c
@@ -30,10 +30,10 @@
static int flac_write_block_padding(ByteIOContext *pb, unsigned int n_padding_bytes,
int last_block)
{
- put_byte(pb, last_block ? 0x81 : 0x01);
- put_be24(pb, n_padding_bytes);
+ avio_put_byte(pb, last_block ? 0x81 : 0x01);
+ avio_put_be24(pb, n_padding_bytes);
while (n_padding_bytes > 0) {
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
n_padding_bytes--;
}
return 0;
@@ -58,7 +58,7 @@ static int flac_write_block_comment(ByteIOContext *pb, AVMetadata **m,
bytestream_put_be24(&p, len);
ff_vorbiscomment_write(&p, m, vendor, count);
- put_buffer(pb, p0, len+4);
+ avio_put_buffer(pb, p0, len+4);
av_freep(&p0);
p = NULL;
@@ -102,7 +102,7 @@ static int flac_write_trailer(struct AVFormatContext *s)
/* rewrite the STREAMINFO header block data */
file_size = url_ftell(pb);
url_fseek(pb, 8, SEEK_SET);
- put_buffer(pb, streaminfo, FLAC_STREAMINFO_SIZE);
+ avio_put_buffer(pb, streaminfo, FLAC_STREAMINFO_SIZE);
url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb);
} else {
@@ -113,7 +113,7 @@ static int flac_write_trailer(struct AVFormatContext *s)
static int flac_write_packet(struct AVFormatContext *s, AVPacket *pkt)
{
- put_buffer(s->pb, pkt->data, pkt->size);
+ avio_put_buffer(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb);
return 0;
}
diff --git a/libavformat/flacenc_header.c b/libavformat/flacenc_header.c
index 92a129a..2465fc2 100644
--- a/libavformat/flacenc_header.c
+++ b/libavformat/flacenc_header.c
@@ -39,11 +39,11 @@ int ff_flac_write_header(ByteIOContext *pb, AVCodecContext *codec,
/* write "fLaC" stream marker and first metadata block header if needed */
if (format == FLAC_EXTRADATA_FORMAT_STREAMINFO) {
- put_buffer(pb, header, 8);
+ avio_put_buffer(pb, header, 8);
}
/* write STREAMINFO or full header */
- put_buffer(pb, codec->extradata, codec->extradata_size);
+ avio_put_buffer(pb, codec->extradata, codec->extradata_size);
return 0;
}
diff --git a/libavformat/flvenc.c b/libavformat/flvenc.c
index b6e406b..24f75b2 100644
--- a/libavformat/flvenc.c
+++ b/libavformat/flvenc.c
@@ -142,31 +142,31 @@ static int get_audio_flags(AVCodecContext *enc){
static void put_amf_string(ByteIOContext *pb, const char *str)
{
size_t len = strlen(str);
- put_be16(pb, len);
- put_buffer(pb, str, len);
+ avio_put_be16(pb, len);
+ avio_put_buffer(pb, str, len);
}
static void put_avc_eos_tag(ByteIOContext *pb, unsigned ts) {
- put_byte(pb, FLV_TAG_TYPE_VIDEO);
- put_be24(pb, 5); /* Tag Data Size */
- put_be24(pb, ts); /* lower 24 bits of timestamp in ms*/
- put_byte(pb, (ts >> 24) & 0x7F); /* MSB of ts in ms*/
- put_be24(pb, 0); /* StreamId = 0 */
- put_byte(pb, 23); /* ub[4] FrameType = 1, ub[4] CodecId = 7 */
- put_byte(pb, 2); /* AVC end of sequence */
- put_be24(pb, 0); /* Always 0 for AVC EOS. */
- put_be32(pb, 16); /* Size of FLV tag */
+ avio_put_byte(pb, FLV_TAG_TYPE_VIDEO);
+ avio_put_be24(pb, 5); /* Tag Data Size */
+ avio_put_be24(pb, ts); /* lower 24 bits of timestamp in ms*/
+ avio_put_byte(pb, (ts >> 24) & 0x7F); /* MSB of ts in ms*/
+ avio_put_be24(pb, 0); /* StreamId = 0 */
+ avio_put_byte(pb, 23); /* ub[4] FrameType = 1, ub[4] CodecId = 7 */
+ avio_put_byte(pb, 2); /* AVC end of sequence */
+ avio_put_be24(pb, 0); /* Always 0 for AVC EOS. */
+ avio_put_be32(pb, 16); /* Size of FLV tag */
}
static void put_amf_double(ByteIOContext *pb, double d)
{
- put_byte(pb, AMF_DATA_TYPE_NUMBER);
- put_be64(pb, av_dbl2int(d));
+ avio_put_byte(pb, AMF_DATA_TYPE_NUMBER);
+ avio_put_be64(pb, av_dbl2int(d));
}
static void put_amf_bool(ByteIOContext *pb, int b) {
- put_byte(pb, AMF_DATA_TYPE_BOOL);
- put_byte(pb, !!b);
+ avio_put_byte(pb, AMF_DATA_TYPE_BOOL);
+ avio_put_byte(pb, !!b);
}
static int flv_write_header(AVFormatContext *s)
@@ -199,20 +199,20 @@ static int flv_write_header(AVFormatContext *s)
}
av_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
}
- put_tag(pb,"FLV");
- put_byte(pb,1);
- put_byte(pb, FLV_HEADER_FLAG_HASAUDIO * !!audio_enc
+ avio_put_tag(pb,"FLV");
+ avio_put_byte(pb,1);
+ avio_put_byte(pb, FLV_HEADER_FLAG_HASAUDIO * !!audio_enc
+ FLV_HEADER_FLAG_HASVIDEO * !!video_enc);
- put_be32(pb,9);
- put_be32(pb,0);
+ avio_put_be32(pb,9);
+ avio_put_be32(pb,0);
for(i=0; i<s->nb_streams; i++){
if(s->streams[i]->codec->codec_tag == 5){
- put_byte(pb,8); // message type
- put_be24(pb,0); // include flags
- put_be24(pb,0); // time stamp
- put_be32(pb,0); // reserved
- put_be32(pb,11); // size
+ avio_put_byte(pb,8); // message type
+ avio_put_be24(pb,0); // include flags
+ avio_put_be24(pb,0); // time stamp
+ avio_put_be32(pb,0); // reserved
+ avio_put_be32(pb,11); // size
flv->reserved=5;
}
}
@@ -220,21 +220,21 @@ static int flv_write_header(AVFormatContext *s)
flv->last_video_ts = -1;
/* write meta_tag */
- put_byte(pb, 18); // tag type META
+ avio_put_byte(pb, 18); // tag type META
metadata_size_pos= url_ftell(pb);
- put_be24(pb, 0); // size of data part (sum of all parts below)
- put_be24(pb, 0); // time stamp
- put_be32(pb, 0); // reserved
+ avio_put_be24(pb, 0); // size of data part (sum of all parts below)
+ avio_put_be24(pb, 0); // time stamp
+ avio_put_be32(pb, 0); // reserved
/* now data of data_size size */
/* first event name as a string */
- put_byte(pb, AMF_DATA_TYPE_STRING);
+ avio_put_byte(pb, AMF_DATA_TYPE_STRING);
put_amf_string(pb, "onMetaData"); // 12 bytes
/* mixed array (hash) with size and string/type/data tuples */
- put_byte(pb, AMF_DATA_TYPE_MIXEDARRAY);
- put_be32(pb, 5*!!video_enc + 5*!!audio_enc + 2); // +2 for duration and file size
+ avio_put_byte(pb, AMF_DATA_TYPE_MIXEDARRAY);
+ avio_put_be32(pb, 5*!!video_enc + 5*!!audio_enc + 2); // +2 for duration and file size
put_amf_string(pb, "duration");
flv->duration_offset= url_ftell(pb);
@@ -276,7 +276,7 @@ static int flv_write_header(AVFormatContext *s)
while ((tag = av_metadata_get(s->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
put_amf_string(pb, tag->key);
- put_byte(pb, AMF_DATA_TYPE_STRING);
+ avio_put_byte(pb, AMF_DATA_TYPE_STRING);
put_amf_string(pb, tag->value);
}
@@ -285,41 +285,41 @@ static int flv_write_header(AVFormatContext *s)
put_amf_double(pb, 0); // delayed write
put_amf_string(pb, "");
- put_byte(pb, AMF_END_OF_OBJECT);
+ avio_put_byte(pb, AMF_END_OF_OBJECT);
/* write total size of tag */
data_size= url_ftell(pb) - metadata_size_pos - 10;
url_fseek(pb, metadata_size_pos, SEEK_SET);
- put_be24(pb, data_size);
+ avio_put_be24(pb, data_size);
url_fseek(pb, data_size + 10 - 3, SEEK_CUR);
- put_be32(pb, data_size + 11);
+ avio_put_be32(pb, data_size + 11);
for (i = 0; i < s->nb_streams; i++) {
AVCodecContext *enc = s->streams[i]->codec;
if (enc->codec_id == CODEC_ID_AAC || enc->codec_id == CODEC_ID_H264) {
int64_t pos;
- put_byte(pb, enc->codec_type == AVMEDIA_TYPE_VIDEO ?
+ avio_put_byte(pb, enc->codec_type == AVMEDIA_TYPE_VIDEO ?
FLV_TAG_TYPE_VIDEO : FLV_TAG_TYPE_AUDIO);
- put_be24(pb, 0); // size patched later
- put_be24(pb, 0); // ts
- put_byte(pb, 0); // ts ext
- put_be24(pb, 0); // streamid
+ avio_put_be24(pb, 0); // size patched later
+ avio_put_be24(pb, 0); // ts
+ avio_put_byte(pb, 0); // ts ext
+ avio_put_be24(pb, 0); // streamid
pos = url_ftell(pb);
if (enc->codec_id == CODEC_ID_AAC) {
- put_byte(pb, get_audio_flags(enc));
- put_byte(pb, 0); // AAC sequence header
- put_buffer(pb, enc->extradata, enc->extradata_size);
+ avio_put_byte(pb, get_audio_flags(enc));
+ avio_put_byte(pb, 0); // AAC sequence header
+ avio_put_buffer(pb, enc->extradata, enc->extradata_size);
} else {
- put_byte(pb, enc->codec_tag | FLV_FRAME_KEY); // flags
- put_byte(pb, 0); // AVC sequence header
- put_be24(pb, 0); // composition time
+ avio_put_byte(pb, enc->codec_tag | FLV_FRAME_KEY); // flags
+ avio_put_byte(pb, 0); // AVC sequence header
+ avio_put_be24(pb, 0); // composition time
ff_isom_write_avcc(pb, enc->extradata, enc->extradata_size);
}
data_size = url_ftell(pb) - pos;
url_fseek(pb, -data_size - 10, SEEK_CUR);
- put_be24(pb, data_size);
+ avio_put_be24(pb, data_size);
url_fseek(pb, data_size + 10 - 3, SEEK_CUR);
- put_be32(pb, data_size + 11); // previous tag size
+ avio_put_be32(pb, data_size + 11); // previous tag size
}
}
@@ -376,7 +376,7 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
flags_size= 1;
if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
- put_byte(pb, FLV_TAG_TYPE_VIDEO);
+ avio_put_byte(pb, FLV_TAG_TYPE_VIDEO);
flags = enc->codec_tag;
if(flags == 0) {
@@ -391,7 +391,7 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
assert(size);
- put_byte(pb, FLV_TAG_TYPE_AUDIO);
+ avio_put_byte(pb, FLV_TAG_TYPE_AUDIO);
}
if (enc->codec_id == CODEC_ID_H264) {
@@ -409,25 +409,25 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
if (flv->last_video_ts < ts)
flv->last_video_ts = ts;
}
- put_be24(pb,size + flags_size);
- put_be24(pb,ts);
- put_byte(pb,(ts >> 24) & 0x7F); // timestamps are 32bits _signed_
- put_be24(pb,flv->reserved);
- put_byte(pb,flags);
+ avio_put_be24(pb,size + flags_size);
+ avio_put_be24(pb,ts);
+ avio_put_byte(pb,(ts >> 24) & 0x7F); // timestamps are 32bits _signed_
+ avio_put_be24(pb,flv->reserved);
+ avio_put_byte(pb,flags);
if (enc->codec_id == CODEC_ID_VP6)
- put_byte(pb,0);
+ avio_put_byte(pb,0);
if (enc->codec_id == CODEC_ID_VP6F)
- put_byte(pb, enc->extradata_size ? enc->extradata[0] : 0);
+ avio_put_byte(pb, enc->extradata_size ? enc->extradata[0] : 0);
else if (enc->codec_id == CODEC_ID_AAC)
- put_byte(pb,1); // AAC raw
+ avio_put_byte(pb,1); // AAC raw
else if (enc->codec_id == CODEC_ID_H264) {
- put_byte(pb,1); // AVC NALU
- put_be24(pb,pkt->pts - pkt->dts);
+ avio_put_byte(pb,1); // AVC NALU
+ avio_put_be24(pb,pkt->pts - pkt->dts);
}
- put_buffer(pb, data ? data : pkt->data, size);
+ avio_put_buffer(pb, data ? data : pkt->data, size);
- put_be32(pb,size+flags_size+11); // previous tag size
+ avio_put_be32(pb,size+flags_size+11); // previous tag size
flv->duration = FFMAX(flv->duration, pkt->pts + flv->delay + pkt->duration);
put_flush_packet(pb);
diff --git a/libavformat/framecrcenc.c b/libavformat/framecrcenc.c
index f456ec6..ecc655f 100644
--- a/libavformat/framecrcenc.c
+++ b/libavformat/framecrcenc.c
@@ -28,7 +28,7 @@ static int framecrc_write_packet(struct AVFormatContext *s, AVPacket *pkt)
char buf[256];
snprintf(buf, sizeof(buf), "%d, %"PRId64", %d, 0x%08x\n", pkt->stream_index, pkt->dts, pkt->size, crc);
- put_buffer(s->pb, buf, strlen(buf));
+ avio_put_buffer(s->pb, buf, strlen(buf));
put_flush_packet(s->pb);
return 0;
}
diff --git a/libavformat/gif.c b/libavformat/gif.c
index 2388f9b..e90eb32 100644
--- a/libavformat/gif.c
+++ b/libavformat/gif.c
@@ -114,26 +114,26 @@ static int gif_image_write_header(ByteIOContext *pb,
int i;
unsigned int v;
- put_tag(pb, "GIF");
- put_tag(pb, "89a");
- put_le16(pb, width);
- put_le16(pb, height);
+ avio_put_tag(pb, "GIF");
+ avio_put_tag(pb, "89a");
+ avio_put_le16(pb, width);
+ avio_put_le16(pb, height);
- put_byte(pb, 0xf7); /* flags: global clut, 256 entries */
- put_byte(pb, 0x1f); /* background color index */
- put_byte(pb, 0); /* aspect ratio */
+ avio_put_byte(pb, 0xf7); /* flags: global clut, 256 entries */
+ avio_put_byte(pb, 0x1f); /* background color index */
+ avio_put_byte(pb, 0); /* aspect ratio */
/* the global palette */
if (!palette) {
- put_buffer(pb, (const unsigned char *)gif_clut, 216*3);
+ avio_put_buffer(pb, (const unsigned char *)gif_clut, 216*3);
for(i=0;i<((256-216)*3);i++)
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
} else {
for(i=0;i<256;i++) {
v = palette[i];
- put_byte(pb, (v >> 16) & 0xff);
- put_byte(pb, (v >> 8) & 0xff);
- put_byte(pb, (v) & 0xff);
+ avio_put_byte(pb, (v >> 16) & 0xff);
+ avio_put_byte(pb, (v >> 8) & 0xff);
+ avio_put_byte(pb, (v) & 0xff);
}
}
@@ -159,14 +159,14 @@ static int gif_image_write_header(ByteIOContext *pb,
/* application extension header */
#ifdef GIF_ADD_APP_HEADER
if (loop_count >= 0 && loop_count <= 65535) {
- put_byte(pb, 0x21);
- put_byte(pb, 0xff);
- put_byte(pb, 0x0b);
- put_tag(pb, "NETSCAPE2.0"); // bytes 4 to 14
- put_byte(pb, 0x03); // byte 15
- put_byte(pb, 0x01); // byte 16
- put_le16(pb, (uint16_t)loop_count);
- put_byte(pb, 0x00); // byte 19
+ avio_put_byte(pb, 0x21);
+ avio_put_byte(pb, 0xff);
+ avio_put_byte(pb, 0x0b);
+ avio_put_tag(pb, "NETSCAPE2.0"); // bytes 4 to 14
+ avio_put_byte(pb, 0x03); // byte 15
+ avio_put_byte(pb, 0x01); // byte 16
+ avio_put_le16(pb, (uint16_t)loop_count);
+ avio_put_byte(pb, 0x00); // byte 19
}
#endif
return 0;
@@ -189,15 +189,15 @@ static int gif_image_write_image(ByteIOContext *pb,
const uint8_t *ptr;
/* image block */
- put_byte(pb, 0x2c);
- put_le16(pb, x1);
- put_le16(pb, y1);
- put_le16(pb, width);
- put_le16(pb, height);
- put_byte(pb, 0x00); /* flags */
+ avio_put_byte(pb, 0x2c);
+ avio_put_le16(pb, x1);
+ avio_put_le16(pb, y1);
+ avio_put_le16(pb, width);
+ avio_put_le16(pb, height);
+ avio_put_byte(pb, 0x00); /* flags */
/* no local clut */
- put_byte(pb, 0x08);
+ avio_put_byte(pb, 0x08);
left= width * height;
@@ -233,13 +233,13 @@ static int gif_image_write_image(ByteIOContext *pb,
flush_put_bits(&p);
}
if(put_bits_ptr(&p) - p.buf > 0) {
- put_byte(pb, put_bits_ptr(&p) - p.buf); /* byte count of the packet */
- put_buffer(pb, p.buf, put_bits_ptr(&p) - p.buf); /* the actual buffer */
+ avio_put_byte(pb, put_bits_ptr(&p) - p.buf); /* byte count of the packet */
+ avio_put_buffer(pb, p.buf, put_bits_ptr(&p) - p.buf); /* the actual buffer */
p.buf_ptr = p.buf; /* dequeue the bytes off the bitstream */
}
left-=GIF_CHUNKS;
}
- put_byte(pb, 0x00); /* end of image block */
+ avio_put_byte(pb, 0x00); /* end of image block */
return 0;
}
@@ -300,10 +300,10 @@ static int gif_write_video(AVFormatContext *s,
int64_t delay;
/* graphic control extension block */
- put_byte(pb, 0x21);
- put_byte(pb, 0xf9);
- put_byte(pb, 0x04); /* block size */
- put_byte(pb, 0x04); /* flags */
+ avio_put_byte(pb, 0x21);
+ avio_put_byte(pb, 0xf9);
+ avio_put_byte(pb, 0x04); /* block size */
+ avio_put_byte(pb, 0x04); /* flags */
/* 1 jiffy is 1/70 s */
/* the delay_time field indicates the number of jiffies - 1 */
@@ -314,10 +314,10 @@ static int gif_write_video(AVFormatContext *s,
/* XXX: don't even remember if I really use it for now */
jiffies = (70*enc->time_base.num/enc->time_base.den) - 1;
- put_le16(pb, jiffies);
+ avio_put_le16(pb, jiffies);
- put_byte(pb, 0x1f); /* transparent color index */
- put_byte(pb, 0x00);
+ avio_put_byte(pb, 0x1f); /* transparent color index */
+ avio_put_byte(pb, 0x00);
gif_image_write_image(pb, 0, 0, enc->width, enc->height,
buf, enc->width * 3, PIX_FMT_RGB24);
@@ -339,7 +339,7 @@ static int gif_write_trailer(AVFormatContext *s)
{
ByteIOContext *pb = s->pb;
- put_byte(pb, 0x3b);
+ avio_put_byte(pb, 0x3b);
put_flush_packet(s->pb);
return 0;
}
diff --git a/libavformat/gxfenc.c b/libavformat/gxfenc.c
index 94976a3..7f01b41 100644
--- a/libavformat/gxfenc.c
+++ b/libavformat/gxfenc.c
@@ -116,7 +116,7 @@ static int gxf_find_lines_index(AVStream *st)
static void gxf_write_padding(ByteIOContext *pb, int64_t to_pad)
{
for (; to_pad > 0; to_pad--) {
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
}
}
@@ -132,7 +132,7 @@ static int64_t updatePacketSize(ByteIOContext *pb, int64_t pos)
}
curpos = url_ftell(pb);
url_fseek(pb, pos + 6, SEEK_SET);
- put_be32(pb, size);
+ avio_put_be32(pb, size);
url_fseek(pb, curpos, SEEK_SET);
return curpos - pos;
}
@@ -143,20 +143,20 @@ static int64_t updateSize(ByteIOContext *pb, int64_t pos)
curpos = url_ftell(pb);
url_fseek(pb, pos, SEEK_SET);
- put_be16(pb, curpos - pos - 2);
+ avio_put_be16(pb, curpos - pos - 2);
url_fseek(pb, curpos, SEEK_SET);
return curpos - pos;
}
static void gxf_write_packet_header(ByteIOContext *pb, GXFPktType type)
{
- put_be32(pb, 0); /* packet leader for synchro */
- put_byte(pb, 1);
- put_byte(pb, type); /* map packet */
- put_be32(pb, 0); /* size */
- put_be32(pb, 0); /* reserved */
- put_byte(pb, 0xE1); /* trailer 1 */
- put_byte(pb, 0xE2); /* trailer 2 */
+ avio_put_be32(pb, 0); /* packet leader for synchro */
+ avio_put_byte(pb, 1);
+ avio_put_byte(pb, type); /* map packet */
+ avio_put_be32(pb, 0); /* size */
+ avio_put_be32(pb, 0); /* reserved */
+ avio_put_byte(pb, 0xE1); /* trailer 1 */
+ avio_put_byte(pb, 0xE2); /* trailer 2 */
}
static int gxf_write_mpeg_auxiliary(ByteIOContext *pb, AVStream *st)
@@ -191,20 +191,20 @@ static int gxf_write_mpeg_auxiliary(ByteIOContext *pb, AVStream *st)
(float)st->codec->bit_rate, sc->p_per_gop, sc->b_per_i_or_p,
st->codec->pix_fmt == PIX_FMT_YUV422P ? 2 : 1, sc->first_gop_closed == 1,
starting_line, (st->codec->height + 15) / 16);
- put_byte(pb, TRACK_MPG_AUX);
- put_byte(pb, size + 1);
- put_buffer(pb, (uint8_t *)buffer, size + 1);
+ avio_put_byte(pb, TRACK_MPG_AUX);
+ avio_put_byte(pb, size + 1);
+ avio_put_buffer(pb, (uint8_t *)buffer, size + 1);
return size + 3;
}
static int gxf_write_timecode_auxiliary(ByteIOContext *pb, GXFStreamContext *sc)
{
- put_byte(pb, 0); /* fields */
- put_byte(pb, 0); /* seconds */
- put_byte(pb, 0); /* minutes */
- put_byte(pb, 0); /* flags + hours */
+ avio_put_byte(pb, 0); /* fields */
+ avio_put_byte(pb, 0); /* seconds */
+ avio_put_byte(pb, 0); /* minutes */
+ avio_put_byte(pb, 0); /* flags + hours */
/* reserved */
- put_be32(pb, 0);
+ avio_put_be32(pb, 0);
return 8;
}
@@ -215,51 +215,51 @@ static int gxf_write_track_description(AVFormatContext *s, GXFStreamContext *sc,
int mpeg = sc->track_type == 4 || sc->track_type == 9;
/* track description section */
- put_byte(pb, sc->media_type + 0x80);
- put_byte(pb, index + 0xC0);
+ avio_put_byte(pb, sc->media_type + 0x80);
+ avio_put_byte(pb, index + 0xC0);
pos = url_ftell(pb);
- put_be16(pb, 0); /* size */
+ avio_put_be16(pb, 0); /* size */
/* media file name */
- put_byte(pb, TRACK_NAME);
- put_byte(pb, strlen(ES_NAME_PATTERN) + 3);
- put_tag(pb, ES_NAME_PATTERN);
- put_be16(pb, sc->media_info);
- put_byte(pb, 0);
+ avio_put_byte(pb, TRACK_NAME);
+ avio_put_byte(pb, strlen(ES_NAME_PATTERN) + 3);
+ avio_put_tag(pb, ES_NAME_PATTERN);
+ avio_put_be16(pb, sc->media_info);
+ avio_put_byte(pb, 0);
if (!mpeg) {
/* auxiliary information */
- put_byte(pb, TRACK_AUX);
- put_byte(pb, 8);
+ avio_put_byte(pb, TRACK_AUX);
+ avio_put_byte(pb, 8);
if (sc->track_type == 3)
gxf_write_timecode_auxiliary(pb, sc);
else
- put_le64(pb, 0);
+ avio_put_le64(pb, 0);
}
/* file system version */
- put_byte(pb, TRACK_VER);
- put_byte(pb, 4);
- put_be32(pb, 0);
+ avio_put_byte(pb, TRACK_VER);
+ avio_put_byte(pb, 4);
+ avio_put_be32(pb, 0);
if (mpeg)
gxf_write_mpeg_auxiliary(pb, s->streams[index]);
/* frame rate */
- put_byte(pb, TRACK_FPS);
- put_byte(pb, 4);
- put_be32(pb, sc->frame_rate_index);
+ avio_put_byte(pb, TRACK_FPS);
+ avio_put_byte(pb, 4);
+ avio_put_be32(pb, sc->frame_rate_index);
/* lines per frame */
- put_byte(pb, TRACK_LINES);
- put_byte(pb, 4);
- put_be32(pb, sc->lines_index);
+ avio_put_byte(pb, TRACK_LINES);
+ avio_put_byte(pb, 4);
+ avio_put_be32(pb, sc->lines_index);
/* fields per frame */
- put_byte(pb, TRACK_FPF);
- put_byte(pb, 4);
- put_be32(pb, sc->fields);
+ avio_put_byte(pb, TRACK_FPF);
+ avio_put_byte(pb, 4);
+ avio_put_be32(pb, sc->fields);
return updateSize(pb, pos);
}
@@ -272,42 +272,42 @@ static int gxf_write_material_data_section(AVFormatContext *s)
const char *filename = strrchr(s->filename, '/');
pos = url_ftell(pb);
- put_be16(pb, 0); /* size */
+ avio_put_be16(pb, 0); /* size */
/* name */
if (filename)
filename++;
else
filename = s->filename;
- put_byte(pb, MAT_NAME);
- put_byte(pb, strlen(SERVER_PATH) + strlen(filename) + 1);
- put_tag(pb, SERVER_PATH);
- put_tag(pb, filename);
- put_byte(pb, 0);
+ avio_put_byte(pb, MAT_NAME);
+ avio_put_byte(pb, strlen(SERVER_PATH) + strlen(filename) + 1);
+ avio_put_tag(pb, SERVER_PATH);
+ avio_put_tag(pb, filename);
+ avio_put_byte(pb, 0);
/* first field */
- put_byte(pb, MAT_FIRST_FIELD);
- put_byte(pb, 4);
- put_be32(pb, 0);
+ avio_put_byte(pb, MAT_FIRST_FIELD);
+ avio_put_byte(pb, 4);
+ avio_put_be32(pb, 0);
/* last field */
- put_byte(pb, MAT_LAST_FIELD);
- put_byte(pb, 4);
- put_be32(pb, gxf->nb_fields);
+ avio_put_byte(pb, MAT_LAST_FIELD);
+ avio_put_byte(pb, 4);
+ avio_put_be32(pb, gxf->nb_fields);
/* reserved */
- put_byte(pb, MAT_MARK_IN);
- put_byte(pb, 4);
- put_be32(pb, 0);
+ avio_put_byte(pb, MAT_MARK_IN);
+ avio_put_byte(pb, 4);
+ avio_put_be32(pb, 0);
- put_byte(pb, MAT_MARK_OUT);
- put_byte(pb, 4);
- put_be32(pb, gxf->nb_fields);
+ avio_put_byte(pb, MAT_MARK_OUT);
+ avio_put_byte(pb, 4);
+ avio_put_be32(pb, gxf->nb_fields);
/* estimated size */
- put_byte(pb, MAT_SIZE);
- put_byte(pb, 4);
- put_be32(pb, url_fsize(pb) / 1024);
+ avio_put_byte(pb, MAT_SIZE);
+ avio_put_byte(pb, 4);
+ avio_put_be32(pb, url_fsize(pb) / 1024);
return updateSize(pb, pos);
}
@@ -320,7 +320,7 @@ static int gxf_write_track_description_section(AVFormatContext *s)
int i;
pos = url_ftell(pb);
- put_be16(pb, 0); /* size */
+ avio_put_be16(pb, 0); /* size */
for (i = 0; i < s->nb_streams; ++i)
gxf_write_track_description(s, s->streams[i]->priv_data, i);
@@ -350,8 +350,8 @@ static int gxf_write_map_packet(AVFormatContext *s, int rewrite)
gxf_write_packet_header(pb, PKT_MAP);
/* preamble */
- put_byte(pb, 0xE0); /* version */
- put_byte(pb, 0xFF); /* reserved */
+ avio_put_byte(pb, 0xE0); /* version */
+ avio_put_byte(pb, 0xFF); /* reserved */
gxf_write_material_data_section(s);
gxf_write_track_description_section(s);
@@ -370,16 +370,16 @@ static int gxf_write_flt_packet(AVFormatContext *s)
gxf_write_packet_header(pb, PKT_FLT);
- put_le32(pb, fields_per_flt); /* number of fields */
- put_le32(pb, flt_entries); /* number of active flt entries */
+ avio_put_le32(pb, fields_per_flt); /* number of fields */
+ avio_put_le32(pb, flt_entries); /* number of active flt entries */
if (gxf->flt_entries) {
for (i = 0; i < flt_entries; i++)
- put_le32(pb, gxf->flt_entries[(i*fields_per_flt)>>1]);
+ avio_put_le32(pb, gxf->flt_entries[(i*fields_per_flt)>>1]);
}
for (; i < 1000; i++)
- put_le32(pb, 0);
+ avio_put_le32(pb, 0);
return updatePacketSize(pb, pos);
}
@@ -397,21 +397,21 @@ static int gxf_write_umf_material_description(AVFormatContext *s)
gxf->nb_fields / timecode_base % 60 << 8 | // seconds
gxf->nb_fields % timecode_base; // fields
- put_le32(pb, gxf->flags);
- put_le32(pb, gxf->nb_fields); /* length of the longest track */
- put_le32(pb, gxf->nb_fields); /* length of the shortest track */
- put_le32(pb, 0); /* mark in */
- put_le32(pb, gxf->nb_fields); /* mark out */
- put_le32(pb, 0); /* timecode mark in */
- put_le32(pb, timecode); /* timecode mark out */
- put_le64(pb, s->timestamp); /* modification time */
- put_le64(pb, s->timestamp); /* creation time */
- put_le16(pb, 0); /* reserved */
- put_le16(pb, 0); /* reserved */
- put_le16(pb, gxf->audio_tracks);
- put_le16(pb, 1); /* timecode track count */
- put_le16(pb, 0); /* reserved */
- put_le16(pb, gxf->mpeg_tracks);
+ avio_put_le32(pb, gxf->flags);
+ avio_put_le32(pb, gxf->nb_fields); /* length of the longest track */
+ avio_put_le32(pb, gxf->nb_fields); /* length of the shortest track */
+ avio_put_le32(pb, 0); /* mark in */
+ avio_put_le32(pb, gxf->nb_fields); /* mark out */
+ avio_put_le32(pb, 0); /* timecode mark in */
+ avio_put_le32(pb, timecode); /* timecode mark out */
+ avio_put_le64(pb, s->timestamp); /* modification time */
+ avio_put_le64(pb, s->timestamp); /* creation time */
+ avio_put_le16(pb, 0); /* reserved */
+ avio_put_le16(pb, 0); /* reserved */
+ avio_put_le16(pb, gxf->audio_tracks);
+ avio_put_le16(pb, 1); /* timecode track count */
+ avio_put_le16(pb, 0); /* reserved */
+ avio_put_le16(pb, gxf->mpeg_tracks);
return 48;
}
@@ -420,18 +420,18 @@ static int gxf_write_umf_payload(AVFormatContext *s)
GXFContext *gxf = s->priv_data;
ByteIOContext *pb = s->pb;
- put_le32(pb, gxf->umf_length); /* total length of the umf data */
- put_le32(pb, 3); /* version */
- put_le32(pb, s->nb_streams+1);
- put_le32(pb, gxf->umf_track_offset); /* umf track section offset */
- put_le32(pb, gxf->umf_track_size);
- put_le32(pb, s->nb_streams+1);
- put_le32(pb, gxf->umf_media_offset);
- put_le32(pb, gxf->umf_media_size);
- put_le32(pb, gxf->umf_length); /* user data offset */
- put_le32(pb, 0); /* user data size */
- put_le32(pb, 0); /* reserved */
- put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, gxf->umf_length); /* total length of the umf data */
+ avio_put_le32(pb, 3); /* version */
+ avio_put_le32(pb, s->nb_streams+1);
+ avio_put_le32(pb, gxf->umf_track_offset); /* umf track section offset */
+ avio_put_le32(pb, gxf->umf_track_size);
+ avio_put_le32(pb, s->nb_streams+1);
+ avio_put_le32(pb, gxf->umf_media_offset);
+ avio_put_le32(pb, gxf->umf_media_size);
+ avio_put_le32(pb, gxf->umf_length); /* user data offset */
+ avio_put_le32(pb, 0); /* user data size */
+ avio_put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
return 48;
}
@@ -445,12 +445,12 @@ static int gxf_write_umf_track_description(AVFormatContext *s)
gxf->umf_track_offset = pos - gxf->umf_start_offset;
for (i = 0; i < s->nb_streams; ++i) {
GXFStreamContext *sc = s->streams[i]->priv_data;
- put_le16(pb, sc->media_info);
- put_le16(pb, 1);
+ avio_put_le16(pb, sc->media_info);
+ avio_put_le16(pb, 1);
}
- put_le16(pb, gxf->timecode_track.media_info);
- put_le16(pb, 1);
+ avio_put_le16(pb, gxf->timecode_track.media_info);
+ avio_put_le16(pb, 1);
return url_ftell(pb) - pos;
}
@@ -460,34 +460,34 @@ static int gxf_write_umf_media_mpeg(ByteIOContext *pb, AVStream *st)
GXFStreamContext *sc = st->priv_data;
if (st->codec->pix_fmt == PIX_FMT_YUV422P)
- put_le32(pb, 2);
+ avio_put_le32(pb, 2);
else
- put_le32(pb, 1); /* default to 420 */
- put_le32(pb, sc->first_gop_closed == 1); /* closed = 1, open = 0, unknown = 255 */
- put_le32(pb, 3); /* top = 1, bottom = 2, frame = 3, unknown = 0 */
- put_le32(pb, 1); /* I picture per GOP */
- put_le32(pb, sc->p_per_gop);
- put_le32(pb, sc->b_per_i_or_p);
+ avio_put_le32(pb, 1); /* default to 420 */
+ avio_put_le32(pb, sc->first_gop_closed == 1); /* closed = 1, open = 0, unknown = 255 */
+ avio_put_le32(pb, 3); /* top = 1, bottom = 2, frame = 3, unknown = 0 */
+ avio_put_le32(pb, 1); /* I picture per GOP */
+ avio_put_le32(pb, sc->p_per_gop);
+ avio_put_le32(pb, sc->b_per_i_or_p);
if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
- put_le32(pb, 2);
+ avio_put_le32(pb, 2);
else if (st->codec->codec_id == CODEC_ID_MPEG1VIDEO)
- put_le32(pb, 1);
+ avio_put_le32(pb, 1);
else
- put_le32(pb, 0);
- put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0);
+ avio_put_le32(pb, 0); /* reserved */
return 32;
}
static int gxf_write_umf_media_timecode(ByteIOContext *pb, GXFStreamContext *sc)
{
- put_le32(pb, 1); /* non drop frame */
- put_le32(pb, 0); /* reserved */
- put_le32(pb, 0); /* reserved */
- put_le32(pb, 0); /* reserved */
- put_le32(pb, 0); /* reserved */
- put_le32(pb, 0); /* reserved */
- put_le32(pb, 0); /* reserved */
- put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 1); /* non drop frame */
+ avio_put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
return 32;
}
@@ -496,29 +496,29 @@ static int gxf_write_umf_media_dv(ByteIOContext *pb, GXFStreamContext *sc)
int i;
for (i = 0; i < 8; i++) {
- put_be32(pb, 0);
+ avio_put_be32(pb, 0);
}
return 32;
}
static int gxf_write_umf_media_audio(ByteIOContext *pb, GXFStreamContext *sc)
{
- put_le64(pb, av_dbl2int(1)); /* sound level to begin to */
- put_le64(pb, av_dbl2int(1)); /* sound level to begin to */
- put_le32(pb, 0); /* number of fields over which to ramp up sound level */
- put_le32(pb, 0); /* number of fields over which to ramp down sound level */
- put_le32(pb, 0); /* reserved */
- put_le32(pb, 0); /* reserved */
+ avio_put_le64(pb, av_dbl2int(1)); /* sound level to begin to */
+ avio_put_le64(pb, av_dbl2int(1)); /* sound level to begin to */
+ avio_put_le32(pb, 0); /* number of fields over which to ramp up sound level */
+ avio_put_le32(pb, 0); /* number of fields over which to ramp down sound level */
+ avio_put_le32(pb, 0); /* reserved */
+ avio_put_le32(pb, 0); /* reserved */
return 32;
}
#if 0
static int gxf_write_umf_media_mjpeg(ByteIOContext *pb, GXFStreamContext *sc)
{
- put_be64(pb, 0); /* FIXME FLOAT max chroma quant level */
- put_be64(pb, 0); /* FIXME FLOAT max luma quant level */
- put_be64(pb, 0); /* FIXME FLOAT min chroma quant level */
- put_be64(pb, 0); /* FIXME FLOAT min luma quant level */
+ avio_put_be64(pb, 0); /* FIXME FLOAT max chroma quant level */
+ avio_put_be64(pb, 0); /* FIXME FLOAT max luma quant level */
+ avio_put_be64(pb, 0); /* FIXME FLOAT min chroma quant level */
+ avio_put_be64(pb, 0); /* FIXME FLOAT min luma quant level */
return 32;
}
#endif
@@ -542,22 +542,22 @@ static int gxf_write_umf_media_description(AVFormatContext *s)
sc = s->streams[i]->priv_data;
startpos = url_ftell(pb);
- put_le16(pb, 0); /* length */
- put_le16(pb, sc->media_info);
- put_le16(pb, 0); /* reserved */
- put_le16(pb, 0); /* reserved */
- put_le32(pb, gxf->nb_fields);
- put_le32(pb, 0); /* attributes rw, ro */
- put_le32(pb, 0); /* mark in */
- put_le32(pb, gxf->nb_fields); /* mark out */
- put_buffer(pb, ES_NAME_PATTERN, strlen(ES_NAME_PATTERN));
- put_be16(pb, sc->media_info);
+ avio_put_le16(pb, 0); /* length */
+ avio_put_le16(pb, sc->media_info);
+ avio_put_le16(pb, 0); /* reserved */
+ avio_put_le16(pb, 0); /* reserved */
+ avio_put_le32(pb, gxf->nb_fields);
+ avio_put_le32(pb, 0); /* attributes rw, ro */
+ avio_put_le32(pb, 0); /* mark in */
+ avio_put_le32(pb, gxf->nb_fields); /* mark out */
+ avio_put_buffer(pb, ES_NAME_PATTERN, strlen(ES_NAME_PATTERN));
+ avio_put_be16(pb, sc->media_info);
for (j = strlen(ES_NAME_PATTERN)+2; j < 88; j++)
- put_byte(pb, 0);
- put_le32(pb, sc->track_type);
- put_le32(pb, sc->sample_rate);
- put_le32(pb, sc->sample_size);
- put_le32(pb, 0); /* reserved */
+ avio_put_byte(pb, 0);
+ avio_put_le32(pb, sc->track_type);
+ avio_put_le32(pb, sc->sample_rate);
+ avio_put_le32(pb, sc->sample_size);
+ avio_put_le32(pb, 0); /* reserved */
if (sc == &gxf->timecode_track)
gxf_write_umf_media_timecode(pb, sc); /* 8 0bytes */
@@ -579,7 +579,7 @@ static int gxf_write_umf_media_description(AVFormatContext *s)
curpos = url_ftell(pb);
url_fseek(pb, startpos, SEEK_SET);
- put_le16(pb, curpos - startpos);
+ avio_put_le16(pb, curpos - startpos);
url_fseek(pb, curpos, SEEK_SET);
}
return url_ftell(pb) - pos;
@@ -594,8 +594,8 @@ static int gxf_write_umf_packet(AVFormatContext *s)
gxf_write_packet_header(pb, PKT_UMF);
/* preamble */
- put_byte(pb, 3); /* first and last (only) packet */
- put_be32(pb, gxf->umf_length); /* data length */
+ avio_put_byte(pb, 3); /* first and last (only) packet */
+ avio_put_be32(pb, gxf->umf_length); /* data length */
gxf->umf_start_offset = url_ftell(pb);
gxf_write_umf_payload(s);
@@ -823,33 +823,33 @@ static int gxf_write_media_preamble(AVFormatContext *s, AVPacket *pkt, int size)
(int64_t)48000*gxf->time_base.num, AV_ROUND_UP);
}
- put_byte(pb, sc->media_type);
- put_byte(pb, st->index);
- put_be32(pb, field_nb);
+ avio_put_byte(pb, sc->media_type);
+ avio_put_byte(pb, st->index);
+ avio_put_be32(pb, field_nb);
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
- put_be16(pb, 0);
- put_be16(pb, size / 2);
+ avio_put_be16(pb, 0);
+ avio_put_be16(pb, size / 2);
} else if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO) {
int frame_type = gxf_parse_mpeg_frame(sc, pkt->data, pkt->size);
if (frame_type == FF_I_TYPE) {
- put_byte(pb, 0x0d);
+ avio_put_byte(pb, 0x0d);
sc->iframes++;
} else if (frame_type == FF_B_TYPE) {
- put_byte(pb, 0x0f);
+ avio_put_byte(pb, 0x0f);
sc->bframes++;
} else {
- put_byte(pb, 0x0e);
+ avio_put_byte(pb, 0x0e);
sc->pframes++;
}
- put_be24(pb, size);
+ avio_put_be24(pb, size);
} else if (st->codec->codec_id == CODEC_ID_DVVIDEO) {
- put_byte(pb, size / 4096);
- put_be24(pb, 0);
+ avio_put_byte(pb, size / 4096);
+ avio_put_be24(pb, 0);
} else
- put_be32(pb, size);
- put_be32(pb, field_nb);
- put_byte(pb, 1); /* flags */
- put_byte(pb, 0); /* reserved */
+ avio_put_be32(pb, size);
+ avio_put_be32(pb, field_nb);
+ avio_put_byte(pb, 1); /* flags */
+ avio_put_byte(pb, 0); /* reserved */
return 16;
}
@@ -868,7 +868,7 @@ static int gxf_write_packet(AVFormatContext *s, AVPacket *pkt)
else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
padding = GXF_AUDIO_PACKET_SIZE - pkt->size;
gxf_write_media_preamble(s, pkt, pkt->size + padding);
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_buffer(pb, pkt->data, pkt->size);
gxf_write_padding(pb, padding);
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
diff --git a/libavformat/idroqenc.c b/libavformat/idroqenc.c
index 8859c98..c7bf87f 100644
--- a/libavformat/idroqenc.c
+++ b/libavformat/idroqenc.c
@@ -29,7 +29,7 @@ static int roq_write_header(struct AVFormatContext *s)
0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00
};
- put_buffer(s->pb, header, 8);
+ avio_put_buffer(s->pb, header, 8);
put_flush_packet(s->pb);
return 0;
diff --git a/libavformat/img2.c b/libavformat/img2.c
index 9583eea..e646e78 100644
--- a/libavformat/img2.c
+++ b/libavformat/img2.c
@@ -368,9 +368,9 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
if(codec->codec_id == CODEC_ID_RAWVIDEO){
int ysize = codec->width * codec->height;
- put_buffer(pb[0], pkt->data , ysize);
- put_buffer(pb[1], pkt->data + ysize, (pkt->size - ysize)/2);
- put_buffer(pb[2], pkt->data + ysize +(pkt->size - ysize)/2, (pkt->size - ysize)/2);
+ avio_put_buffer(pb[0], pkt->data , ysize);
+ avio_put_buffer(pb[1], pkt->data + ysize, (pkt->size - ysize)/2);
+ avio_put_buffer(pb[2], pkt->data + ysize +(pkt->size - ysize)/2, (pkt->size - ysize)/2);
put_flush_packet(pb[1]);
put_flush_packet(pb[2]);
url_fclose(pb[1]);
@@ -382,15 +382,15 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
AV_RL32(st->codec->extradata+4) == MKTAG('j','p','2','h')){
if(pkt->size < 8 || AV_RL32(pkt->data+4) != MKTAG('j','p','2','c'))
goto error;
- put_be32(pb[0], 12);
- put_tag (pb[0], "jP ");
- put_be32(pb[0], 0x0D0A870A); // signature
- put_be32(pb[0], 20);
- put_tag (pb[0], "ftyp");
- put_tag (pb[0], "jp2 ");
- put_be32(pb[0], 0);
- put_tag (pb[0], "jp2 ");
- put_buffer(pb[0], st->codec->extradata, st->codec->extradata_size);
+ avio_put_be32(pb[0], 12);
+ avio_put_tag (pb[0], "jP ");
+ avio_put_be32(pb[0], 0x0D0A870A); // signature
+ avio_put_be32(pb[0], 20);
+ avio_put_tag (pb[0], "ftyp");
+ avio_put_tag (pb[0], "jp2 ");
+ avio_put_be32(pb[0], 0);
+ avio_put_tag (pb[0], "jp2 ");
+ avio_put_buffer(pb[0], st->codec->extradata, st->codec->extradata_size);
}else if(pkt->size < 8 ||
(!st->codec->extradata_size &&
AV_RL32(pkt->data+4) != MKTAG('j','P',' ',' '))){ // signature
@@ -399,7 +399,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
return -1;
}
}
- put_buffer(pb[0], pkt->data, pkt->size);
+ avio_put_buffer(pb[0], pkt->data, pkt->size);
}
put_flush_packet(pb[0]);
if (!img->is_pipe) {
diff --git a/libavformat/ivfenc.c b/libavformat/ivfenc.c
index 021eb51..cb6fb11 100644
--- a/libavformat/ivfenc.c
+++ b/libavformat/ivfenc.c
@@ -34,15 +34,15 @@ static int ivf_write_header(AVFormatContext *s)
av_log(s, AV_LOG_ERROR, "Currently only VP8 is supported!\n");
return AVERROR(EINVAL);
}
- put_buffer(pb, "DKIF", 4);
- put_le16(pb, 0); // version
- put_le16(pb, 32); // header length
- put_le32(pb, ctx->codec_tag ? ctx->codec_tag : AV_RL32("VP80"));
- put_le16(pb, ctx->width);
- put_le16(pb, ctx->height);
- put_le32(pb, s->streams[0]->time_base.den);
- put_le32(pb, s->streams[0]->time_base.num);
- put_le64(pb, s->streams[0]->duration); // TODO: duration or number of frames?!?
+ avio_put_buffer(pb, "DKIF", 4);
+ avio_put_le16(pb, 0); // version
+ avio_put_le16(pb, 32); // header length
+ avio_put_le32(pb, ctx->codec_tag ? ctx->codec_tag : AV_RL32("VP80"));
+ avio_put_le16(pb, ctx->width);
+ avio_put_le16(pb, ctx->height);
+ avio_put_le32(pb, s->streams[0]->time_base.den);
+ avio_put_le32(pb, s->streams[0]->time_base.num);
+ avio_put_le64(pb, s->streams[0]->duration); // TODO: duration or number of frames?!?
return 0;
}
@@ -50,9 +50,9 @@ static int ivf_write_header(AVFormatContext *s)
static int ivf_write_packet(AVFormatContext *s, AVPacket *pkt)
{
ByteIOContext *pb = s->pb;
- put_le32(pb, pkt->size);
- put_le64(pb, pkt->pts);
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_le32(pb, pkt->size);
+ avio_put_le64(pb, pkt->pts);
+ avio_put_buffer(pb, pkt->data, pkt->size);
put_flush_packet(pb);
return 0;
diff --git a/libavformat/libnut.c b/libavformat/libnut.c
index 5630bf8..3de8cb0 100644
--- a/libavformat/libnut.c
+++ b/libavformat/libnut.c
@@ -47,7 +47,7 @@ static const AVCodecTag nut_tags[] = {
#if CONFIG_LIBNUT_MUXER
static int av_write(void * h, size_t len, const uint8_t * buf) {
ByteIOContext * bc = h;
- put_buffer(bc, buf, len);
+ avio_put_buffer(bc, buf, len);
//put_flush_packet(bc);
return len;
}
diff --git a/libavformat/matroskadec.c b/libavformat/matroskadec.c
index 9a670e8..6bcb038 100644
--- a/libavformat/matroskadec.c
+++ b/libavformat/matroskadec.c
@@ -1375,12 +1375,12 @@ static int matroska_read_header(AVFormatContext *s, AVFormatParameters *ap)
return AVERROR(ENOMEM);
init_put_byte(&b, extradata, extradata_size, 1,
NULL, NULL, NULL, NULL);
- put_buffer(&b, "TTA1", 4);
- put_le16(&b, 1);
- put_le16(&b, track->audio.channels);
- put_le16(&b, track->audio.bitdepth);
- put_le32(&b, track->audio.out_samplerate);
- put_le32(&b, matroska->ctx->duration * track->audio.out_samplerate);
+ avio_put_buffer(&b, "TTA1", 4);
+ avio_put_le16(&b, 1);
+ avio_put_le16(&b, track->audio.channels);
+ avio_put_le16(&b, track->audio.bitdepth);
+ avio_put_le32(&b, track->audio.out_samplerate);
+ avio_put_le32(&b, matroska->ctx->duration * track->audio.out_samplerate);
} else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||
codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {
extradata_offset = 26;
diff --git a/libavformat/matroskaenc.c b/libavformat/matroskaenc.c
index 1d0dc38..3600576 100644
--- a/libavformat/matroskaenc.c
+++ b/libavformat/matroskaenc.c
@@ -112,7 +112,7 @@ static void put_ebml_id(ByteIOContext *pb, unsigned int id)
{
int i = ebml_id_size(id);
while (i--)
- put_byte(pb, id >> (i*8));
+ avio_put_byte(pb, id >> (i*8));
}
/**
@@ -123,9 +123,9 @@ static void put_ebml_id(ByteIOContext *pb, unsigned int id)
static void put_ebml_size_unknown(ByteIOContext *pb, int bytes)
{
assert(bytes <= 8);
- put_byte(pb, 0x1ff >> bytes);
+ avio_put_byte(pb, 0x1ff >> bytes);
while (--bytes)
- put_byte(pb, 0xff);
+ avio_put_byte(pb, 0xff);
}
/**
@@ -160,7 +160,7 @@ static void put_ebml_num(ByteIOContext *pb, uint64_t num, int bytes)
num |= 1ULL << bytes*7;
for (i = bytes - 1; i >= 0; i--)
- put_byte(pb, num >> i*8);
+ avio_put_byte(pb, num >> i*8);
}
static void put_ebml_uint(ByteIOContext *pb, unsigned int elementid, uint64_t val)
@@ -172,14 +172,14 @@ static void put_ebml_uint(ByteIOContext *pb, unsigned int elementid, uint64_t va
put_ebml_id(pb, elementid);
put_ebml_num(pb, bytes, 0);
for (i = bytes - 1; i >= 0; i--)
- put_byte(pb, val >> i*8);
+ avio_put_byte(pb, val >> i*8);
}
static void put_ebml_float(ByteIOContext *pb, unsigned int elementid, double val)
{
put_ebml_id(pb, elementid);
put_ebml_num(pb, 8, 0);
- put_be64(pb, av_dbl2int(val));
+ avio_put_be64(pb, av_dbl2int(val));
}
static void put_ebml_binary(ByteIOContext *pb, unsigned int elementid,
@@ -187,7 +187,7 @@ static void put_ebml_binary(ByteIOContext *pb, unsigned int elementid,
{
put_ebml_id(pb, elementid);
put_ebml_num(pb, size, 0);
- put_buffer(pb, buf, size);
+ avio_put_buffer(pb, buf, size);
}
static void put_ebml_string(ByteIOContext *pb, unsigned int elementid, const char *str)
@@ -216,7 +216,7 @@ static void put_ebml_void(ByteIOContext *pb, uint64_t size)
else
put_ebml_num(pb, size-9, 8);
while(url_ftell(pb) < currentpos + size)
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
}
static ebml_master start_ebml_master(ByteIOContext *pb, unsigned int elementid, uint64_t expectedsize)
@@ -241,8 +241,8 @@ static void put_xiph_size(ByteIOContext *pb, int size)
{
int i;
for (i = 0; i < size / 255; i++)
- put_byte(pb, 255);
- put_byte(pb, size % 255);
+ avio_put_byte(pb, 255);
+ avio_put_byte(pb, size % 255);
}
/**
@@ -426,12 +426,12 @@ static int put_xiph_codecpriv(AVFormatContext *s, ByteIOContext *pb, AVCodecCont
return -1;
}
- put_byte(pb, 2); // number packets - 1
+ avio_put_byte(pb, 2); // number packets - 1
for (j = 0; j < 2; j++) {
put_xiph_size(pb, header_len[j]);
}
for (j = 0; j < 3; j++)
- put_buffer(pb, header_start[j], header_len[j]);
+ avio_put_buffer(pb, header_start[j], header_len[j]);
return 0;
}
@@ -481,13 +481,13 @@ static int mkv_write_codecprivate(AVFormatContext *s, ByteIOContext *pb, AVCodec
else if (codec->codec_id == CODEC_ID_H264)
ret = ff_isom_write_avcc(dyn_cp, codec->extradata, codec->extradata_size);
else if (codec->extradata_size)
- put_buffer(dyn_cp, codec->extradata, codec->extradata_size);
+ avio_put_buffer(dyn_cp, codec->extradata, codec->extradata_size);
} else if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
if (qt_id) {
if (!codec->codec_tag)
codec->codec_tag = ff_codec_get_tag(codec_movvideo_tags, codec->codec_id);
if (codec->extradata_size)
- put_buffer(dyn_cp, codec->extradata, codec->extradata_size);
+ avio_put_buffer(dyn_cp, codec->extradata, codec->extradata_size);
} else {
if (!codec->codec_tag)
codec->codec_tag = ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id);
@@ -932,10 +932,10 @@ static int mkv_write_ass_blocks(AVFormatContext *s, ByteIOContext *pb, AVPacket
blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(size));
put_ebml_id(pb, MATROSKA_ID_BLOCK);
put_ebml_num(pb, size+4, 0);
- put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
- put_be16(pb, pkt->pts - mkv->cluster_pts);
- put_byte(pb, 0);
- put_buffer(pb, buffer, size);
+ avio_put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
+ avio_put_be16(pb, pkt->pts - mkv->cluster_pts);
+ avio_put_byte(pb, 0);
+ avio_put_buffer(pb, buffer, size);
put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration);
end_ebml_master(pb, blockgroup);
@@ -965,10 +965,10 @@ static void mkv_write_block(AVFormatContext *s, ByteIOContext *pb,
data = pkt->data;
put_ebml_id(pb, blockid);
put_ebml_num(pb, size+4, 0);
- put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
- put_be16(pb, ts - mkv->cluster_pts);
- put_byte(pb, flags);
- put_buffer(pb, data, size);
+ avio_put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
+ avio_put_be16(pb, ts - mkv->cluster_pts);
+ avio_put_byte(pb, flags);
+ avio_put_buffer(pb, data, size);
if (data != pkt->data)
av_free(data);
}
@@ -1018,7 +1018,7 @@ static void mkv_flush_dynbuf(AVFormatContext *s)
return;
bufsize = url_close_dyn_buf(mkv->dyn_bc, &dyn_buf);
- put_buffer(s->pb, dyn_buf, bufsize);
+ avio_put_buffer(s->pb, dyn_buf, bufsize);
av_free(dyn_buf);
mkv->dyn_bc = NULL;
}
diff --git a/libavformat/md5enc.c b/libavformat/md5enc.c
index dd2f7c0..b0eb3d4 100644
--- a/libavformat/md5enc.c
+++ b/libavformat/md5enc.c
@@ -36,7 +36,7 @@ static void md5_finish(struct AVFormatContext *s, char *buf)
buf[offset] = '\n';
buf[offset+1] = 0;
- put_buffer(s->pb, buf, strlen(buf));
+ avio_put_buffer(s->pb, buf, strlen(buf));
put_flush_packet(s->pb);
}
diff --git a/libavformat/mmf.c b/libavformat/mmf.c
index 2b2af4d..11f1187 100644
--- a/libavformat/mmf.c
+++ b/libavformat/mmf.c
@@ -53,7 +53,7 @@ static void end_tag_be(ByteIOContext *pb, int64_t start)
pos = url_ftell(pb);
url_fseek(pb, start - 4, SEEK_SET);
- put_be32(pb, (uint32_t)(pos - start));
+ avio_put_be32(pb, (uint32_t)(pos - start));
url_fseek(pb, pos, SEEK_SET);
}
@@ -70,32 +70,32 @@ static int mmf_write_header(AVFormatContext *s)
return -1;
}
- put_tag(pb, "MMMD");
- put_be32(pb, 0);
+ avio_put_tag(pb, "MMMD");
+ avio_put_be32(pb, 0);
pos = ff_start_tag(pb, "CNTI");
- put_byte(pb, 0); /* class */
- put_byte(pb, 0); /* type */
- put_byte(pb, 0); /* code type */
- put_byte(pb, 0); /* status */
- put_byte(pb, 0); /* counts */
- put_tag(pb, "VN:libavcodec,"); /* metadata ("ST:songtitle,VN:version,...") */
+ avio_put_byte(pb, 0); /* class */
+ avio_put_byte(pb, 0); /* type */
+ avio_put_byte(pb, 0); /* code type */
+ avio_put_byte(pb, 0); /* status */
+ avio_put_byte(pb, 0); /* counts */
+ avio_put_tag(pb, "VN:libavcodec,"); /* metadata ("ST:songtitle,VN:version,...") */
end_tag_be(pb, pos);
- put_buffer(pb, "ATR\x00", 4);
- put_be32(pb, 0);
+ avio_put_buffer(pb, "ATR\x00", 4);
+ avio_put_be32(pb, 0);
mmf->atrpos = url_ftell(pb);
- put_byte(pb, 0); /* format type */
- put_byte(pb, 0); /* sequence type */
- put_byte(pb, (0 << 7) | (1 << 4) | rate); /* (channel << 7) | (format << 4) | rate */
- put_byte(pb, 0); /* wave base bit */
- put_byte(pb, 2); /* time base d */
- put_byte(pb, 2); /* time base g */
-
- put_tag(pb, "Atsq");
- put_be32(pb, 16);
+ avio_put_byte(pb, 0); /* format type */
+ avio_put_byte(pb, 0); /* sequence type */
+ avio_put_byte(pb, (0 << 7) | (1 << 4) | rate); /* (channel << 7) | (format << 4) | rate */
+ avio_put_byte(pb, 0); /* wave base bit */
+ avio_put_byte(pb, 2); /* time base d */
+ avio_put_byte(pb, 2); /* time base g */
+
+ avio_put_tag(pb, "Atsq");
+ avio_put_be32(pb, 16);
mmf->atsqpos = url_ftell(pb);
/* Will be filled on close */
- put_buffer(pb, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16);
+ avio_put_buffer(pb, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16);
mmf->awapos = ff_start_tag(pb, "Awa\x01");
@@ -109,7 +109,7 @@ static int mmf_write_header(AVFormatContext *s)
static int mmf_write_packet(AVFormatContext *s, AVPacket *pkt)
{
ByteIOContext *pb = s->pb;
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_buffer(pb, pkt->data, pkt->size);
return 0;
}
@@ -117,11 +117,11 @@ static int mmf_write_packet(AVFormatContext *s, AVPacket *pkt)
static void put_varlength(ByteIOContext *pb, int val)
{
if(val < 128)
- put_byte(pb, val);
+ avio_put_byte(pb, val);
else {
val -= 128;
- put_byte(pb, 0x80 | val >> 7);
- put_byte(pb, 0x7f & val);
+ avio_put_byte(pb, 0x80 | val >> 7);
+ avio_put_byte(pb, 0x7f & val);
}
}
@@ -145,17 +145,17 @@ static int mmf_write_trailer(AVFormatContext *s)
url_fseek(pb, mmf->atsqpos, SEEK_SET);
/* "play wav" */
- put_byte(pb, 0); /* start time */
- put_byte(pb, 1); /* (channel << 6) | wavenum */
+ avio_put_byte(pb, 0); /* start time */
+ avio_put_byte(pb, 1); /* (channel << 6) | wavenum */
gatetime = size * 500 / s->streams[0]->codec->sample_rate;
put_varlength(pb, gatetime); /* duration */
/* "nop" */
put_varlength(pb, gatetime); /* start time */
- put_buffer(pb, "\xff\x00", 2); /* nop */
+ avio_put_buffer(pb, "\xff\x00", 2); /* nop */
/* "end of sequence" */
- put_buffer(pb, "\x00\x00\x00\x00", 4);
+ avio_put_buffer(pb, "\x00\x00\x00\x00", 4);
url_fseek(pb, pos, SEEK_SET);
diff --git a/libavformat/movenc.c b/libavformat/movenc.c
index 5e6e3a6..389667f 100644
--- a/libavformat/movenc.c
+++ b/libavformat/movenc.c
@@ -40,7 +40,7 @@ static int64_t updateSize(ByteIOContext *pb, int64_t pos)
{
int64_t curpos = url_ftell(pb);
url_fseek(pb, pos, SEEK_SET);
- put_be32(pb, curpos - pos); /* rewrite size */
+ avio_put_be32(pb, curpos - pos); /* rewrite size */
url_fseek(pb, curpos, SEEK_SET);
return curpos - pos;
@@ -52,19 +52,19 @@ static int mov_write_stco_tag(ByteIOContext *pb, MOVTrack *track)
int i;
int mode64 = 0; // use 32 bit size variant if possible
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
+ avio_put_be32(pb, 0); /* size */
if (pos > UINT32_MAX) {
mode64 = 1;
- put_tag(pb, "co64");
+ avio_put_tag(pb, "co64");
} else
- put_tag(pb, "stco");
- put_be32(pb, 0); /* version & flags */
- put_be32(pb, track->entry); /* entry count */
+ avio_put_tag(pb, "stco");
+ avio_put_be32(pb, 0); /* version & flags */
+ avio_put_be32(pb, track->entry); /* entry count */
for (i=0; i<track->entry; i++) {
if(mode64 == 1)
- put_be64(pb, track->cluster[i].pos);
+ avio_put_be64(pb, track->cluster[i].pos);
else
- put_be32(pb, track->cluster[i].pos);
+ avio_put_be32(pb, track->cluster[i].pos);
}
return updateSize(pb, pos);
}
@@ -76,9 +76,9 @@ static int mov_write_stsz_tag(ByteIOContext *pb, MOVTrack *track)
int i, j, entries = 0, tst = -1, oldtst = -1;
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "stsz");
- put_be32(pb, 0); /* version & flags */
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "stsz");
+ avio_put_be32(pb, 0); /* version & flags */
for (i=0; i<track->entry; i++) {
tst = track->cluster[i].size/track->cluster[i].entries;
@@ -90,15 +90,15 @@ static int mov_write_stsz_tag(ByteIOContext *pb, MOVTrack *track)
}
if (equalChunks) {
int sSize = track->cluster[0].size/track->cluster[0].entries;
- put_be32(pb, sSize); // sample size
- put_be32(pb, entries); // sample count
+ avio_put_be32(pb, sSize); // sample size
+ avio_put_be32(pb, entries); // sample count
}
else {
- put_be32(pb, 0); // sample size
- put_be32(pb, entries); // sample count
+ avio_put_be32(pb, 0); // sample size
+ avio_put_be32(pb, entries); // sample count
for (i=0; i<track->entry; i++) {
for (j=0; j<track->cluster[i].entries; j++) {
- put_be32(pb, track->cluster[i].size /
+ avio_put_be32(pb, track->cluster[i].size /
track->cluster[i].entries);
}
}
@@ -113,24 +113,24 @@ static int mov_write_stsc_tag(ByteIOContext *pb, MOVTrack *track)
int64_t entryPos, curpos;
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "stsc");
- put_be32(pb, 0); // version & flags
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "stsc");
+ avio_put_be32(pb, 0); // version & flags
entryPos = url_ftell(pb);
- put_be32(pb, track->entry); // entry count
+ avio_put_be32(pb, track->entry); // entry count
for (i=0; i<track->entry; i++) {
if(oldval != track->cluster[i].samplesInChunk)
{
- put_be32(pb, i+1); // first chunk
- put_be32(pb, track->cluster[i].samplesInChunk); // samples per chunk
- put_be32(pb, 0x1); // sample description index
+ avio_put_be32(pb, i+1); // first chunk
+ avio_put_be32(pb, track->cluster[i].samplesInChunk); // samples per chunk
+ avio_put_be32(pb, 0x1); // sample description index
oldval = track->cluster[i].samplesInChunk;
index++;
}
}
curpos = url_ftell(pb);
url_fseek(pb, entryPos, SEEK_SET);
- put_be32(pb, index); // rewrite size
+ avio_put_be32(pb, index); // rewrite size
url_fseek(pb, curpos, SEEK_SET);
return updateSize(pb, pos);
@@ -142,35 +142,35 @@ static int mov_write_stss_tag(ByteIOContext *pb, MOVTrack *track, uint32_t flag)
int64_t curpos, entryPos;
int i, index = 0;
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); // size
- put_tag(pb, flag == MOV_SYNC_SAMPLE ? "stss" : "stps");
- put_be32(pb, 0); // version & flags
+ avio_put_be32(pb, 0); // size
+ avio_put_tag(pb, flag == MOV_SYNC_SAMPLE ? "stss" : "stps");
+ avio_put_be32(pb, 0); // version & flags
entryPos = url_ftell(pb);
- put_be32(pb, track->entry); // entry count
+ avio_put_be32(pb, track->entry); // entry count
for (i=0; i<track->entry; i++) {
if (track->cluster[i].flags & flag) {
- put_be32(pb, i+1);
+ avio_put_be32(pb, i+1);
index++;
}
}
curpos = url_ftell(pb);
url_fseek(pb, entryPos, SEEK_SET);
- put_be32(pb, index); // rewrite size
+ avio_put_be32(pb, index); // rewrite size
url_fseek(pb, curpos, SEEK_SET);
return updateSize(pb, pos);
}
static int mov_write_amr_tag(ByteIOContext *pb, MOVTrack *track)
{
- put_be32(pb, 0x11); /* size */
- if (track->mode == MODE_MOV) put_tag(pb, "samr");
- else put_tag(pb, "damr");
- put_tag(pb, "FFMP");
- put_byte(pb, 0); /* decoder version */
+ avio_put_be32(pb, 0x11); /* size */
+ if (track->mode == MODE_MOV) avio_put_tag(pb, "samr");
+ else avio_put_tag(pb, "damr");
+ avio_put_tag(pb, "FFMP");
+ avio_put_byte(pb, 0); /* decoder version */
- put_be16(pb, 0x81FF); /* Mode set (all modes for AMR_NB) */
- put_byte(pb, 0x00); /* Mode change period (no restriction) */
- put_byte(pb, 0x01); /* Frames per sample */
+ avio_put_be16(pb, 0x81FF); /* Mode set (all modes for AMR_NB) */
+ avio_put_byte(pb, 0x00); /* Mode change period (no restriction) */
+ avio_put_byte(pb, 0x01); /* Frames per sample */
return 0x11;
}
@@ -184,8 +184,8 @@ static int mov_write_ac3_tag(ByteIOContext *pb, MOVTrack *track)
if (track->vosLen < 7)
return -1;
- put_be32(pb, 11);
- put_tag(pb, "dac3");
+ avio_put_be32(pb, 11);
+ avio_put_tag(pb, "dac3");
init_get_bits(&gbc, track->vosData+4, track->vosLen-4);
fscod = get_bits(&gbc, 2);
@@ -213,7 +213,7 @@ static int mov_write_ac3_tag(ByteIOContext *pb, MOVTrack *track)
put_bits(&pbc, 5, 0); // reserved
flush_put_bits(&pbc);
- put_buffer(pb, buf, sizeof(buf));
+ avio_put_buffer(pb, buf, sizeof(buf));
return 11;
}
@@ -224,15 +224,15 @@ static int mov_write_ac3_tag(ByteIOContext *pb, MOVTrack *track)
*/
static int mov_write_extradata_tag(ByteIOContext *pb, MOVTrack *track)
{
- put_buffer(pb, track->enc->extradata, track->enc->extradata_size);
+ avio_put_buffer(pb, track->enc->extradata, track->enc->extradata_size);
return track->enc->extradata_size;
}
static int mov_write_enda_tag(ByteIOContext *pb)
{
- put_be32(pb, 10);
- put_tag(pb, "enda");
- put_be16(pb, 1); /* little endian */
+ avio_put_be32(pb, 10);
+ avio_put_tag(pb, "enda");
+ avio_put_be16(pb, 1); /* little endian */
return 10;
}
@@ -246,10 +246,10 @@ static unsigned int descrLength(unsigned int len)
static void putDescr(ByteIOContext *pb, int tag, unsigned int size)
{
int i= descrLength(size) - size - 2;
- put_byte(pb, tag);
+ avio_put_byte(pb, tag);
for(; i>0; i--)
- put_byte(pb, (size>>(7*i)) | 0x80);
- put_byte(pb, size & 0x7F);
+ avio_put_byte(pb, (size>>(7*i)) | 0x80);
+ avio_put_byte(pb, size & 0x7F);
}
static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack *track) // Basic
@@ -257,15 +257,15 @@ static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack *track) // Basic
int64_t pos = url_ftell(pb);
int decoderSpecificInfoLen = track->vosLen ? descrLength(track->vosLen):0;
- put_be32(pb, 0); // size
- put_tag(pb, "esds");
- put_be32(pb, 0); // Version
+ avio_put_be32(pb, 0); // size
+ avio_put_tag(pb, "esds");
+ avio_put_be32(pb, 0); // Version
// ES descriptor
putDescr(pb, 0x03, 3 + descrLength(13 + decoderSpecificInfoLen) +
descrLength(1));
- put_be16(pb, track->trackID);
- put_byte(pb, 0x00); // flags (= no flags)
+ avio_put_be16(pb, track->trackID);
+ avio_put_byte(pb, 0x00); // flags (= no flags)
// DecoderConfig descriptor
putDescr(pb, 0x04, 13 + decoderSpecificInfoLen);
@@ -274,35 +274,35 @@ static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack *track) // Basic
if ((track->enc->codec_id == CODEC_ID_MP2 ||
track->enc->codec_id == CODEC_ID_MP3) &&
track->enc->sample_rate > 24000)
- put_byte(pb, 0x6B); // 11172-3
+ avio_put_byte(pb, 0x6B); // 11172-3
else
- put_byte(pb, ff_codec_get_tag(ff_mp4_obj_type, track->enc->codec_id));
+ avio_put_byte(pb, ff_codec_get_tag(ff_mp4_obj_type, track->enc->codec_id));
// the following fields is made of 6 bits to identify the streamtype (4 for video, 5 for audio)
// plus 1 bit to indicate upstream and 1 bit set to 1 (reserved)
if(track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
- put_byte(pb, 0x15); // flags (= Audiostream)
+ avio_put_byte(pb, 0x15); // flags (= Audiostream)
else
- put_byte(pb, 0x11); // flags (= Visualstream)
+ avio_put_byte(pb, 0x11); // flags (= Visualstream)
- put_byte(pb, track->enc->rc_buffer_size>>(3+16)); // Buffersize DB (24 bits)
- put_be16(pb, (track->enc->rc_buffer_size>>3)&0xFFFF); // Buffersize DB
+ avio_put_byte(pb, track->enc->rc_buffer_size>>(3+16)); // Buffersize DB (24 bits)
+ avio_put_be16(pb, (track->enc->rc_buffer_size>>3)&0xFFFF); // Buffersize DB
- put_be32(pb, FFMAX(track->enc->bit_rate, track->enc->rc_max_rate)); // maxbitrate (FIXME should be max rate in any 1 sec window)
+ avio_put_be32(pb, FFMAX(track->enc->bit_rate, track->enc->rc_max_rate)); // maxbitrate (FIXME should be max rate in any 1 sec window)
if(track->enc->rc_max_rate != track->enc->rc_min_rate || track->enc->rc_min_rate==0)
- put_be32(pb, 0); // vbr
+ avio_put_be32(pb, 0); // vbr
else
- put_be32(pb, track->enc->rc_max_rate); // avg bitrate
+ avio_put_be32(pb, track->enc->rc_max_rate); // avg bitrate
if (track->vosLen) {
// DecoderSpecific info descriptor
putDescr(pb, 0x05, track->vosLen);
- put_buffer(pb, track->vosData, track->vosLen);
+ avio_put_buffer(pb, track->vosData, track->vosLen);
}
// SL descriptor
putDescr(pb, 0x06, 1);
- put_byte(pb, 0x02);
+ avio_put_byte(pb, 0x02);
return updateSize(pb, pos);
}
@@ -317,8 +317,8 @@ static int mov_pcm_le_gt16(enum CodecID codec_id)
static int mov_write_ms_tag(ByteIOContext *pb, MOVTrack *track)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0);
- put_le32(pb, track->tag); // store it byteswapped
+ avio_put_be32(pb, 0);
+ avio_put_le32(pb, track->tag); // store it byteswapped
track->enc->codec_tag = av_bswap16(track->tag >> 16);
ff_put_wav_header(pb, track->enc);
return updateSize(pb, pos);
@@ -328,18 +328,18 @@ static int mov_write_wave_tag(ByteIOContext *pb, MOVTrack *track)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "wave");
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "wave");
- put_be32(pb, 12); /* size */
- put_tag(pb, "frma");
- put_le32(pb, track->tag);
+ avio_put_be32(pb, 12); /* size */
+ avio_put_tag(pb, "frma");
+ avio_put_le32(pb, track->tag);
if (track->enc->codec_id == CODEC_ID_AAC) {
/* useless atom needed by mplayer, ipod, not needed by quicktime */
- put_be32(pb, 12); /* size */
- put_tag(pb, "mp4a");
- put_be32(pb, 0);
+ avio_put_be32(pb, 12); /* size */
+ avio_put_tag(pb, "mp4a");
+ avio_put_be32(pb, 0);
mov_write_esds_tag(pb, track);
} else if (mov_pcm_le_gt16(track->enc->codec_id)) {
mov_write_enda_tag(pb);
@@ -354,17 +354,17 @@ static int mov_write_wave_tag(ByteIOContext *pb, MOVTrack *track)
mov_write_ms_tag(pb, track);
}
- put_be32(pb, 8); /* size */
- put_be32(pb, 0); /* null tag */
+ avio_put_be32(pb, 8); /* size */
+ avio_put_be32(pb, 0); /* null tag */
return updateSize(pb, pos);
}
static int mov_write_glbl_tag(ByteIOContext *pb, MOVTrack *track)
{
- put_be32(pb, track->vosLen+8);
- put_tag(pb, "glbl");
- put_buffer(pb, track->vosData, track->vosLen);
+ avio_put_be32(pb, track->vosLen+8);
+ avio_put_tag(pb, "glbl");
+ avio_put_buffer(pb, track->vosData, track->vosLen);
return 8+track->vosLen;
}
@@ -415,56 +415,56 @@ static int mov_write_audio_tag(ByteIOContext *pb, MOVTrack *track)
}
}
- put_be32(pb, 0); /* size */
- put_le32(pb, tag); // store it byteswapped
- put_be32(pb, 0); /* Reserved */
- put_be16(pb, 0); /* Reserved */
- put_be16(pb, 1); /* Data-reference index, XXX == 1 */
+ avio_put_be32(pb, 0); /* size */
+ avio_put_le32(pb, tag); // store it byteswapped
+ avio_put_be32(pb, 0); /* Reserved */
+ avio_put_be16(pb, 0); /* Reserved */
+ avio_put_be16(pb, 1); /* Data-reference index, XXX == 1 */
/* SoundDescription */
- put_be16(pb, version); /* Version */
- put_be16(pb, 0); /* Revision level */
- put_be32(pb, 0); /* Reserved */
+ avio_put_be16(pb, version); /* Version */
+ avio_put_be16(pb, 0); /* Revision level */
+ avio_put_be32(pb, 0); /* Reserved */
if (version == 2) {
- put_be16(pb, 3);
- put_be16(pb, 16);
- put_be16(pb, 0xfffe);
- put_be16(pb, 0);
- put_be32(pb, 0x00010000);
- put_be32(pb, 72);
- put_be64(pb, av_dbl2int(track->timescale));
- put_be32(pb, track->enc->channels);
- put_be32(pb, 0x7F000000);
- put_be32(pb, av_get_bits_per_sample(track->enc->codec_id));
- put_be32(pb, mov_get_lpcm_flags(track->enc->codec_id));
- put_be32(pb, track->sampleSize);
- put_be32(pb, track->enc->frame_size);
+ avio_put_be16(pb, 3);
+ avio_put_be16(pb, 16);
+ avio_put_be16(pb, 0xfffe);
+ avio_put_be16(pb, 0);
+ avio_put_be32(pb, 0x00010000);
+ avio_put_be32(pb, 72);
+ avio_put_be64(pb, av_dbl2int(track->timescale));
+ avio_put_be32(pb, track->enc->channels);
+ avio_put_be32(pb, 0x7F000000);
+ avio_put_be32(pb, av_get_bits_per_sample(track->enc->codec_id));
+ avio_put_be32(pb, mov_get_lpcm_flags(track->enc->codec_id));
+ avio_put_be32(pb, track->sampleSize);
+ avio_put_be32(pb, track->enc->frame_size);
} else {
if (track->mode == MODE_MOV) {
- put_be16(pb, track->enc->channels);
+ avio_put_be16(pb, track->enc->channels);
if (track->enc->codec_id == CODEC_ID_PCM_U8 ||
track->enc->codec_id == CODEC_ID_PCM_S8)
- put_be16(pb, 8); /* bits per sample */
+ avio_put_be16(pb, 8); /* bits per sample */
else
- put_be16(pb, 16);
- put_be16(pb, track->audio_vbr ? -2 : 0); /* compression ID */
+ avio_put_be16(pb, 16);
+ avio_put_be16(pb, track->audio_vbr ? -2 : 0); /* compression ID */
} else { /* reserved for mp4/3gp */
- put_be16(pb, 2);
- put_be16(pb, 16);
- put_be16(pb, 0);
+ avio_put_be16(pb, 2);
+ avio_put_be16(pb, 16);
+ avio_put_be16(pb, 0);
}
- put_be16(pb, 0); /* packet size (= 0) */
- put_be16(pb, track->timescale); /* Time scale */
- put_be16(pb, 0); /* Reserved */
+ avio_put_be16(pb, 0); /* packet size (= 0) */
+ avio_put_be16(pb, track->timescale); /* Time scale */
+ avio_put_be16(pb, 0); /* Reserved */
}
if(version == 1) { /* SoundDescription V1 extended info */
- put_be32(pb, track->enc->frame_size); /* Samples per packet */
- put_be32(pb, track->sampleSize / track->enc->channels); /* Bytes per packet */
- put_be32(pb, track->sampleSize); /* Bytes per frame */
- put_be32(pb, 2); /* Bytes per sample */
+ avio_put_be32(pb, track->enc->frame_size); /* Samples per packet */
+ avio_put_be32(pb, track->sampleSize / track->enc->channels); /* Bytes per packet */
+ avio_put_be32(pb, track->sampleSize); /* Bytes per frame */
+ avio_put_be32(pb, 2); /* Bytes per sample */
}
if(track->mode == MODE_MOV &&
@@ -492,26 +492,26 @@ static int mov_write_audio_tag(ByteIOContext *pb, MOVTrack *track)
static int mov_write_d263_tag(ByteIOContext *pb)
{
- put_be32(pb, 0xf); /* size */
- put_tag(pb, "d263");
- put_tag(pb, "FFMP");
- put_byte(pb, 0); /* decoder version */
+ avio_put_be32(pb, 0xf); /* size */
+ avio_put_tag(pb, "d263");
+ avio_put_tag(pb, "FFMP");
+ avio_put_byte(pb, 0); /* decoder version */
/* FIXME use AVCodecContext level/profile, when encoder will set values */
- put_byte(pb, 0xa); /* level */
- put_byte(pb, 0); /* profile */
+ avio_put_byte(pb, 0xa); /* level */
+ avio_put_byte(pb, 0); /* profile */
return 0xf;
}
/* TODO: No idea about these values */
static int mov_write_svq3_tag(ByteIOContext *pb)
{
- put_be32(pb, 0x15);
- put_tag(pb, "SMI ");
- put_tag(pb, "SEQH");
- put_be32(pb, 0x5);
- put_be32(pb, 0xe2c0211d);
- put_be32(pb, 0xc0000000);
- put_byte(pb, 0);
+ avio_put_be32(pb, 0x15);
+ avio_put_tag(pb, "SMI ");
+ avio_put_tag(pb, "SEQH");
+ avio_put_be32(pb, 0x5);
+ avio_put_be32(pb, 0xe2c0211d);
+ avio_put_be32(pb, 0xc0000000);
+ avio_put_byte(pb, 0);
return 0x15;
}
@@ -519,8 +519,8 @@ static int mov_write_avcc_tag(ByteIOContext *pb, MOVTrack *track)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0);
- put_tag(pb, "avcC");
+ avio_put_be32(pb, 0);
+ avio_put_tag(pb, "avcC");
ff_isom_write_avcc(pb, track->vosData, track->vosLen);
return updateSize(pb, pos);
}
@@ -529,47 +529,47 @@ static int mov_write_avcc_tag(ByteIOContext *pb, MOVTrack *track)
static int mov_write_avid_tag(ByteIOContext *pb, MOVTrack *track)
{
int i;
- put_be32(pb, 24); /* size */
- put_tag(pb, "ACLR");
- put_tag(pb, "ACLR");
- put_tag(pb, "0001");
- put_be32(pb, 1); /* yuv 1 / rgb 2 ? */
- put_be32(pb, 0); /* unknown */
-
- put_be32(pb, 24); /* size */
- put_tag(pb, "APRG");
- put_tag(pb, "APRG");
- put_tag(pb, "0001");
- put_be32(pb, 1); /* unknown */
- put_be32(pb, 0); /* unknown */
-
- put_be32(pb, 120); /* size */
- put_tag(pb, "ARES");
- put_tag(pb, "ARES");
- put_tag(pb, "0001");
- put_be32(pb, AV_RB32(track->vosData + 0x28)); /* dnxhd cid, some id ? */
- put_be32(pb, track->enc->width);
+ avio_put_be32(pb, 24); /* size */
+ avio_put_tag(pb, "ACLR");
+ avio_put_tag(pb, "ACLR");
+ avio_put_tag(pb, "0001");
+ avio_put_be32(pb, 1); /* yuv 1 / rgb 2 ? */
+ avio_put_be32(pb, 0); /* unknown */
+
+ avio_put_be32(pb, 24); /* size */
+ avio_put_tag(pb, "APRG");
+ avio_put_tag(pb, "APRG");
+ avio_put_tag(pb, "0001");
+ avio_put_be32(pb, 1); /* unknown */
+ avio_put_be32(pb, 0); /* unknown */
+
+ avio_put_be32(pb, 120); /* size */
+ avio_put_tag(pb, "ARES");
+ avio_put_tag(pb, "ARES");
+ avio_put_tag(pb, "0001");
+ avio_put_be32(pb, AV_RB32(track->vosData + 0x28)); /* dnxhd cid, some id ? */
+ avio_put_be32(pb, track->enc->width);
/* values below are based on samples created with quicktime and avid codecs */
if (track->vosData[5] & 2) { // interlaced
- put_be32(pb, track->enc->height/2);
- put_be32(pb, 2); /* unknown */
- put_be32(pb, 0); /* unknown */
- put_be32(pb, 4); /* unknown */
+ avio_put_be32(pb, track->enc->height/2);
+ avio_put_be32(pb, 2); /* unknown */
+ avio_put_be32(pb, 0); /* unknown */
+ avio_put_be32(pb, 4); /* unknown */
} else {
- put_be32(pb, track->enc->height);
- put_be32(pb, 1); /* unknown */
- put_be32(pb, 0); /* unknown */
+ avio_put_be32(pb, track->enc->height);
+ avio_put_be32(pb, 1); /* unknown */
+ avio_put_be32(pb, 0); /* unknown */
if (track->enc->height == 1080)
- put_be32(pb, 5); /* unknown */
+ avio_put_be32(pb, 5); /* unknown */
else
- put_be32(pb, 6); /* unknown */
+ avio_put_be32(pb, 6); /* unknown */
}
/* padding */
for (i = 0; i < 10; i++)
- put_be64(pb, 0);
+ avio_put_be64(pb, 0);
/* extra padding for stsd needed */
- put_be32(pb, 0);
+ avio_put_be32(pb, 0);
return 0;
}
@@ -740,27 +740,27 @@ static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
*/
static int mov_write_uuid_tag_ipod(ByteIOContext *pb)
{
- put_be32(pb, 28);
- put_tag(pb, "uuid");
- put_be32(pb, 0x6b6840f2);
- put_be32(pb, 0x5f244fc5);
- put_be32(pb, 0xba39a51b);
- put_be32(pb, 0xcf0323f3);
- put_be32(pb, 0x0);
+ avio_put_be32(pb, 28);
+ avio_put_tag(pb, "uuid");
+ avio_put_be32(pb, 0x6b6840f2);
+ avio_put_be32(pb, 0x5f244fc5);
+ avio_put_be32(pb, 0xba39a51b);
+ avio_put_be32(pb, 0xcf0323f3);
+ avio_put_be32(pb, 0x0);
return 28;
}
static int mov_write_subtitle_tag(ByteIOContext *pb, MOVTrack *track)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_le32(pb, track->tag); // store it byteswapped
- put_be32(pb, 0); /* Reserved */
- put_be16(pb, 0); /* Reserved */
- put_be16(pb, 1); /* Data-reference index */
+ avio_put_be32(pb, 0); /* size */
+ avio_put_le32(pb, track->tag); // store it byteswapped
+ avio_put_be32(pb, 0); /* Reserved */
+ avio_put_be16(pb, 0); /* Reserved */
+ avio_put_be16(pb, 1); /* Data-reference index */
if (track->enc->extradata_size)
- put_buffer(pb, track->enc->extradata, track->enc->extradata_size);
+ avio_put_buffer(pb, track->enc->extradata, track->enc->extradata_size);
return updateSize(pb, pos);
}
@@ -771,10 +771,10 @@ static int mov_write_pasp_tag(ByteIOContext *pb, MOVTrack *track)
av_reduce(&sar.num, &sar.den, track->enc->sample_aspect_ratio.num,
track->enc->sample_aspect_ratio.den, INT_MAX);
- put_be32(pb, 16);
- put_tag(pb, "pasp");
- put_be32(pb, sar.num);
- put_be32(pb, sar.den);
+ avio_put_be32(pb, 16);
+ avio_put_tag(pb, "pasp");
+ avio_put_be32(pb, sar.num);
+ avio_put_be32(pb, sar.den);
return 16;
}
@@ -783,47 +783,47 @@ static int mov_write_video_tag(ByteIOContext *pb, MOVTrack *track)
int64_t pos = url_ftell(pb);
char compressor_name[32];
- put_be32(pb, 0); /* size */
- put_le32(pb, track->tag); // store it byteswapped
- put_be32(pb, 0); /* Reserved */
- put_be16(pb, 0); /* Reserved */
- put_be16(pb, 1); /* Data-reference index */
+ avio_put_be32(pb, 0); /* size */
+ avio_put_le32(pb, track->tag); // store it byteswapped
+ avio_put_be32(pb, 0); /* Reserved */
+ avio_put_be16(pb, 0); /* Reserved */
+ avio_put_be16(pb, 1); /* Data-reference index */
- put_be16(pb, 0); /* Codec stream version */
- put_be16(pb, 0); /* Codec stream revision (=0) */
+ avio_put_be16(pb, 0); /* Codec stream version */
+ avio_put_be16(pb, 0); /* Codec stream revision (=0) */
if (track->mode == MODE_MOV) {
- put_tag(pb, "FFMP"); /* Vendor */
+ avio_put_tag(pb, "FFMP"); /* Vendor */
if(track->enc->codec_id == CODEC_ID_RAWVIDEO) {
- put_be32(pb, 0); /* Temporal Quality */
- put_be32(pb, 0x400); /* Spatial Quality = lossless*/
+ avio_put_be32(pb, 0); /* Temporal Quality */
+ avio_put_be32(pb, 0x400); /* Spatial Quality = lossless*/
} else {
- put_be32(pb, 0x200); /* Temporal Quality = normal */
- put_be32(pb, 0x200); /* Spatial Quality = normal */
+ avio_put_be32(pb, 0x200); /* Temporal Quality = normal */
+ avio_put_be32(pb, 0x200); /* Spatial Quality = normal */
}
} else {
- put_be32(pb, 0); /* Reserved */
- put_be32(pb, 0); /* Reserved */
- put_be32(pb, 0); /* Reserved */
+ avio_put_be32(pb, 0); /* Reserved */
+ avio_put_be32(pb, 0); /* Reserved */
+ avio_put_be32(pb, 0); /* Reserved */
}
- put_be16(pb, track->enc->width); /* Video width */
- put_be16(pb, track->height); /* Video height */
- put_be32(pb, 0x00480000); /* Horizontal resolution 72dpi */
- put_be32(pb, 0x00480000); /* Vertical resolution 72dpi */
- put_be32(pb, 0); /* Data size (= 0) */
- put_be16(pb, 1); /* Frame count (= 1) */
+ avio_put_be16(pb, track->enc->width); /* Video width */
+ avio_put_be16(pb, track->height); /* Video height */
+ avio_put_be32(pb, 0x00480000); /* Horizontal resolution 72dpi */
+ avio_put_be32(pb, 0x00480000); /* Vertical resolution 72dpi */
+ avio_put_be32(pb, 0); /* Data size (= 0) */
+ avio_put_be16(pb, 1); /* Frame count (= 1) */
memset(compressor_name,0,32);
/* FIXME not sure, ISO 14496-1 draft where it shall be set to 0 */
if (track->mode == MODE_MOV && track->enc->codec && track->enc->codec->name)
strncpy(compressor_name,track->enc->codec->name,31);
- put_byte(pb, strlen(compressor_name));
- put_buffer(pb, compressor_name, 31);
+ avio_put_byte(pb, strlen(compressor_name));
+ avio_put_buffer(pb, compressor_name, 31);
if (track->mode == MODE_MOV && track->enc->bits_per_coded_sample)
- put_be16(pb, track->enc->bits_per_coded_sample);
+ avio_put_be16(pb, track->enc->bits_per_coded_sample);
else
- put_be16(pb, 0x18); /* Reserved */
- put_be16(pb, 0xffff); /* Reserved */
+ avio_put_be16(pb, 0x18); /* Reserved */
+ avio_put_be16(pb, 0xffff); /* Reserved */
if(track->tag == MKTAG('m','p','4','v'))
mov_write_esds_tag(pb, track);
else if(track->enc->codec_id == CODEC_ID_H263)
@@ -851,19 +851,19 @@ static int mov_write_video_tag(ByteIOContext *pb, MOVTrack *track)
static int mov_write_rtp_tag(ByteIOContext *pb, MOVTrack *track)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "rtp ");
- put_be32(pb, 0); /* Reserved */
- put_be16(pb, 0); /* Reserved */
- put_be16(pb, 1); /* Data-reference index */
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "rtp ");
+ avio_put_be32(pb, 0); /* Reserved */
+ avio_put_be16(pb, 0); /* Reserved */
+ avio_put_be16(pb, 1); /* Data-reference index */
- put_be16(pb, 1); /* Hint track version */
- put_be16(pb, 1); /* Highest compatible version */
- put_be32(pb, track->max_packet_size); /* Max packet size */
+ avio_put_be16(pb, 1); /* Hint track version */
+ avio_put_be16(pb, 1); /* Highest compatible version */
+ avio_put_be32(pb, track->max_packet_size); /* Max packet size */
- put_be32(pb, 12); /* size */
- put_tag(pb, "tims");
- put_be32(pb, track->timescale);
+ avio_put_be32(pb, 12); /* size */
+ avio_put_tag(pb, "tims");
+ avio_put_be32(pb, track->timescale);
return updateSize(pb, pos);
}
@@ -871,10 +871,10 @@ static int mov_write_rtp_tag(ByteIOContext *pb, MOVTrack *track)
static int mov_write_stsd_tag(ByteIOContext *pb, MOVTrack *track)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "stsd");
- put_be32(pb, 0); /* version & flags */
- put_be32(pb, 1); /* entry count */
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "stsd");
+ avio_put_be32(pb, 0); /* version & flags */
+ avio_put_be32(pb, 1); /* entry count */
if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO)
mov_write_video_tag(pb, track);
else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
@@ -907,13 +907,13 @@ static int mov_write_ctts_tag(ByteIOContext *pb, MOVTrack *track)
}
entries++; /* last one */
atom_size = 16 + (entries * 8);
- put_be32(pb, atom_size); /* size */
- put_tag(pb, "ctts");
- put_be32(pb, 0); /* version & flags */
- put_be32(pb, entries); /* entry count */
+ avio_put_be32(pb, atom_size); /* size */
+ avio_put_tag(pb, "ctts");
+ avio_put_be32(pb, 0); /* version & flags */
+ avio_put_be32(pb, entries); /* entry count */
for (i=0; i<entries; i++) {
- put_be32(pb, ctts_entries[i].count);
- put_be32(pb, ctts_entries[i].duration);
+ avio_put_be32(pb, ctts_entries[i].count);
+ avio_put_be32(pb, ctts_entries[i].duration);
}
av_free(ctts_entries);
return atom_size;
@@ -949,13 +949,13 @@ static int mov_write_stts_tag(ByteIOContext *pb, MOVTrack *track)
entries++; /* last one */
}
atom_size = 16 + (entries * 8);
- put_be32(pb, atom_size); /* size */
- put_tag(pb, "stts");
- put_be32(pb, 0); /* version & flags */
- put_be32(pb, entries); /* entry count */
+ avio_put_be32(pb, atom_size); /* size */
+ avio_put_tag(pb, "stts");
+ avio_put_be32(pb, 0); /* version & flags */
+ avio_put_be32(pb, entries); /* entry count */
for (i=0; i<entries; i++) {
- put_be32(pb, stts_entries[i].count);
- put_be32(pb, stts_entries[i].duration);
+ avio_put_be32(pb, stts_entries[i].count);
+ avio_put_be32(pb, stts_entries[i].duration);
}
av_free(stts_entries);
return atom_size;
@@ -963,14 +963,14 @@ static int mov_write_stts_tag(ByteIOContext *pb, MOVTrack *track)
static int mov_write_dref_tag(ByteIOContext *pb)
{
- put_be32(pb, 28); /* size */
- put_tag(pb, "dref");
- put_be32(pb, 0); /* version & flags */
- put_be32(pb, 1); /* entry count */
+ avio_put_be32(pb, 28); /* size */
+ avio_put_tag(pb, "dref");
+ avio_put_be32(pb, 0); /* version & flags */
+ avio_put_be32(pb, 1); /* entry count */
- put_be32(pb, 0xc); /* size */
- put_tag(pb, "url ");
- put_be32(pb, 1); /* version & flags */
+ avio_put_be32(pb, 0xc); /* size */
+ avio_put_tag(pb, "url ");
+ avio_put_be32(pb, 1); /* version & flags */
return 28;
}
@@ -978,8 +978,8 @@ static int mov_write_dref_tag(ByteIOContext *pb)
static int mov_write_stbl_tag(ByteIOContext *pb, MOVTrack *track)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "stbl");
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "stbl");
mov_write_stsd_tag(pb, track);
mov_write_stts_tag(pb, track);
if ((track->enc->codec_type == AVMEDIA_TYPE_VIDEO ||
@@ -1000,52 +1000,52 @@ static int mov_write_stbl_tag(ByteIOContext *pb, MOVTrack *track)
static int mov_write_dinf_tag(ByteIOContext *pb)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "dinf");
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "dinf");
mov_write_dref_tag(pb);
return updateSize(pb, pos);
}
static int mov_write_nmhd_tag(ByteIOContext *pb)
{
- put_be32(pb, 12);
- put_tag(pb, "nmhd");
- put_be32(pb, 0);
+ avio_put_be32(pb, 12);
+ avio_put_tag(pb, "nmhd");
+ avio_put_be32(pb, 0);
return 12;
}
static int mov_write_gmhd_tag(ByteIOContext *pb)
{
- put_be32(pb, 0x20); /* size */
- put_tag(pb, "gmhd");
- put_be32(pb, 0x18); /* gmin size */
- put_tag(pb, "gmin"); /* generic media info */
- put_be32(pb, 0); /* version & flags */
- put_be16(pb, 0x40); /* graphics mode = */
- put_be16(pb, 0x8000); /* opColor (r?) */
- put_be16(pb, 0x8000); /* opColor (g?) */
- put_be16(pb, 0x8000); /* opColor (b?) */
- put_be16(pb, 0); /* balance */
- put_be16(pb, 0); /* reserved */
+ avio_put_be32(pb, 0x20); /* size */
+ avio_put_tag(pb, "gmhd");
+ avio_put_be32(pb, 0x18); /* gmin size */
+ avio_put_tag(pb, "gmin"); /* generic media info */
+ avio_put_be32(pb, 0); /* version & flags */
+ avio_put_be16(pb, 0x40); /* graphics mode = */
+ avio_put_be16(pb, 0x8000); /* opColor (r?) */
+ avio_put_be16(pb, 0x8000); /* opColor (g?) */
+ avio_put_be16(pb, 0x8000); /* opColor (b?) */
+ avio_put_be16(pb, 0); /* balance */
+ avio_put_be16(pb, 0); /* reserved */
return 0x20;
}
static int mov_write_smhd_tag(ByteIOContext *pb)
{
- put_be32(pb, 16); /* size */
- put_tag(pb, "smhd");
- put_be32(pb, 0); /* version & flags */
- put_be16(pb, 0); /* reserved (balance, normally = 0) */
- put_be16(pb, 0); /* reserved */
+ avio_put_be32(pb, 16); /* size */
+ avio_put_tag(pb, "smhd");
+ avio_put_be32(pb, 0); /* version & flags */
+ avio_put_be16(pb, 0); /* reserved (balance, normally = 0) */
+ avio_put_be16(pb, 0); /* reserved */
return 16;
}
static int mov_write_vmhd_tag(ByteIOContext *pb)
{
- put_be32(pb, 0x14); /* size (always 0x14) */
- put_tag(pb, "vmhd");
- put_be32(pb, 0x01); /* version & flags */
- put_be64(pb, 0); /* reserved (graphics mode = copy) */
+ avio_put_be32(pb, 0x14); /* size (always 0x14) */
+ avio_put_tag(pb, "vmhd");
+ avio_put_be32(pb, 0x01); /* version & flags */
+ avio_put_be64(pb, 0); /* reserved (graphics mode = copy) */
return 0x14;
}
@@ -1076,19 +1076,19 @@ static int mov_write_hdlr_tag(ByteIOContext *pb, MOVTrack *track)
}
}
- put_be32(pb, 0); /* size */
- put_tag(pb, "hdlr");
- put_be32(pb, 0); /* Version & flags */
- put_buffer(pb, hdlr, 4); /* handler */
- put_tag(pb, hdlr_type); /* handler type */
- put_be32(pb ,0); /* reserved */
- put_be32(pb ,0); /* reserved */
- put_be32(pb ,0); /* reserved */
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "hdlr");
+ avio_put_be32(pb, 0); /* Version & flags */
+ avio_put_buffer(pb, hdlr, 4); /* handler */
+ avio_put_tag(pb, hdlr_type); /* handler type */
+ avio_put_be32(pb ,0); /* reserved */
+ avio_put_be32(pb ,0); /* reserved */
+ avio_put_be32(pb ,0); /* reserved */
if (!track || track->mode == MODE_MOV)
- put_byte(pb, strlen(descr)); /* pascal string */
- put_buffer(pb, descr, strlen(descr)); /* handler description */
+ avio_put_byte(pb, strlen(descr)); /* pascal string */
+ avio_put_buffer(pb, descr, strlen(descr)); /* handler description */
if (track && track->mode != MODE_MOV)
- put_byte(pb, 0); /* c string */
+ avio_put_byte(pb, 0); /* c string */
return updateSize(pb, pos);
}
@@ -1096,22 +1096,22 @@ static int mov_write_hmhd_tag(ByteIOContext *pb)
{
/* This atom must be present, but leaving the values at zero
* seems harmless. */
- put_be32(pb, 28); /* size */
- put_tag(pb, "hmhd");
- put_be32(pb, 0); /* version, flags */
- put_be16(pb, 0); /* maxPDUsize */
- put_be16(pb, 0); /* avgPDUsize */
- put_be32(pb, 0); /* maxbitrate */
- put_be32(pb, 0); /* avgbitrate */
- put_be32(pb, 0); /* reserved */
+ avio_put_be32(pb, 28); /* size */
+ avio_put_tag(pb, "hmhd");
+ avio_put_be32(pb, 0); /* version, flags */
+ avio_put_be16(pb, 0); /* maxPDUsize */
+ avio_put_be16(pb, 0); /* avgPDUsize */
+ avio_put_be32(pb, 0); /* maxbitrate */
+ avio_put_be32(pb, 0); /* avgbitrate */
+ avio_put_be32(pb, 0); /* reserved */
return 28;
}
static int mov_write_minf_tag(ByteIOContext *pb, MOVTrack *track)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "minf");
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "minf");
if(track->enc->codec_type == AVMEDIA_TYPE_VIDEO)
mov_write_vmhd_tag(pb);
else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
@@ -1133,21 +1133,21 @@ static int mov_write_mdhd_tag(ByteIOContext *pb, MOVTrack *track)
{
int version = track->trackDuration < INT32_MAX ? 0 : 1;
- (version == 1) ? put_be32(pb, 44) : put_be32(pb, 32); /* size */
- put_tag(pb, "mdhd");
- put_byte(pb, version);
- put_be24(pb, 0); /* flags */
+ (version == 1) ? avio_put_be32(pb, 44) : avio_put_be32(pb, 32); /* size */
+ avio_put_tag(pb, "mdhd");
+ avio_put_byte(pb, version);
+ avio_put_be24(pb, 0); /* flags */
if (version == 1) {
- put_be64(pb, track->time);
- put_be64(pb, track->time);
+ avio_put_be64(pb, track->time);
+ avio_put_be64(pb, track->time);
} else {
- put_be32(pb, track->time); /* creation time */
- put_be32(pb, track->time); /* modification time */
+ avio_put_be32(pb, track->time); /* creation time */
+ avio_put_be32(pb, track->time); /* modification time */
}
- put_be32(pb, track->timescale); /* time scale (sample rate for audio) */
- (version == 1) ? put_be64(pb, track->trackDuration) : put_be32(pb, track->trackDuration); /* duration */
- put_be16(pb, track->language); /* language */
- put_be16(pb, 0); /* reserved (quality) */
+ avio_put_be32(pb, track->timescale); /* time scale (sample rate for audio) */
+ (version == 1) ? avio_put_be64(pb, track->trackDuration) : avio_put_be32(pb, track->trackDuration); /* duration */
+ avio_put_be16(pb, track->language); /* language */
+ avio_put_be16(pb, 0); /* reserved (quality) */
if(version!=0 && track->mode == MODE_MOV){
av_log(NULL, AV_LOG_ERROR,
@@ -1162,8 +1162,8 @@ static int mov_write_mdhd_tag(ByteIOContext *pb, MOVTrack *track)
static int mov_write_mdia_tag(ByteIOContext *pb, MOVTrack *track)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "mdia");
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "mdia");
mov_write_mdhd_tag(pb, track);
mov_write_hdlr_tag(pb, track);
mov_write_minf_tag(pb, track);
@@ -1176,41 +1176,41 @@ static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
track->timescale, AV_ROUND_UP);
int version = duration < INT32_MAX ? 0 : 1;
- (version == 1) ? put_be32(pb, 104) : put_be32(pb, 92); /* size */
- put_tag(pb, "tkhd");
- put_byte(pb, version);
- put_be24(pb, 0xf); /* flags (track enabled) */
+ (version == 1) ? avio_put_be32(pb, 104) : avio_put_be32(pb, 92); /* size */
+ avio_put_tag(pb, "tkhd");
+ avio_put_byte(pb, version);
+ avio_put_be24(pb, 0xf); /* flags (track enabled) */
if (version == 1) {
- put_be64(pb, track->time);
- put_be64(pb, track->time);
+ avio_put_be64(pb, track->time);
+ avio_put_be64(pb, track->time);
} else {
- put_be32(pb, track->time); /* creation time */
- put_be32(pb, track->time); /* modification time */
+ avio_put_be32(pb, track->time); /* creation time */
+ avio_put_be32(pb, track->time); /* modification time */
}
- put_be32(pb, track->trackID); /* track-id */
- put_be32(pb, 0); /* reserved */
- (version == 1) ? put_be64(pb, duration) : put_be32(pb, duration);
+ avio_put_be32(pb, track->trackID); /* track-id */
+ avio_put_be32(pb, 0); /* reserved */
+ (version == 1) ? avio_put_be64(pb, duration) : avio_put_be32(pb, duration);
- put_be32(pb, 0); /* reserved */
- put_be32(pb, 0); /* reserved */
- put_be32(pb, 0x0); /* reserved (Layer & Alternate group) */
+ avio_put_be32(pb, 0); /* reserved */
+ avio_put_be32(pb, 0); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved (Layer & Alternate group) */
/* Volume, only for audio */
if(track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
- put_be16(pb, 0x0100);
+ avio_put_be16(pb, 0x0100);
else
- put_be16(pb, 0);
- put_be16(pb, 0); /* reserved */
+ avio_put_be16(pb, 0);
+ avio_put_be16(pb, 0); /* reserved */
/* Matrix structure */
- put_be32(pb, 0x00010000); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x00010000); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x40000000); /* reserved */
+ avio_put_be32(pb, 0x00010000); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x00010000); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x40000000); /* reserved */
/* Track width and height, for visual only */
if(st && (track->enc->codec_type == AVMEDIA_TYPE_VIDEO ||
@@ -1218,12 +1218,12 @@ static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
if(!sample_aspect_ratio || track->height != track->enc->height)
sample_aspect_ratio = 1;
- put_be32(pb, sample_aspect_ratio * track->enc->width*0x10000);
- put_be32(pb, track->height*0x10000);
+ avio_put_be32(pb, sample_aspect_ratio * track->enc->width*0x10000);
+ avio_put_be32(pb, track->height*0x10000);
}
else {
- put_be32(pb, 0);
- put_be32(pb, 0);
+ avio_put_be32(pb, 0);
+ avio_put_be32(pb, 0);
}
return 0x5c;
}
@@ -1231,48 +1231,48 @@ static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
// This box seems important for the psp playback ... without it the movie seems to hang
static int mov_write_edts_tag(ByteIOContext *pb, MOVTrack *track)
{
- put_be32(pb, 0x24); /* size */
- put_tag(pb, "edts");
- put_be32(pb, 0x1c); /* size */
- put_tag(pb, "elst");
- put_be32(pb, 0x0);
- put_be32(pb, 0x1);
+ avio_put_be32(pb, 0x24); /* size */
+ avio_put_tag(pb, "edts");
+ avio_put_be32(pb, 0x1c); /* size */
+ avio_put_tag(pb, "elst");
+ avio_put_be32(pb, 0x0);
+ avio_put_be32(pb, 0x1);
/* duration ... doesn't seem to effect psp */
- put_be32(pb, av_rescale_rnd(track->trackDuration, MOV_TIMESCALE,
+ avio_put_be32(pb, av_rescale_rnd(track->trackDuration, MOV_TIMESCALE,
track->timescale, AV_ROUND_UP));
- put_be32(pb, track->cluster[0].cts); /* first pts is cts since dts is 0 */
- put_be32(pb, 0x00010000);
+ avio_put_be32(pb, track->cluster[0].cts); /* first pts is cts since dts is 0 */
+ avio_put_be32(pb, 0x00010000);
return 0x24;
}
static int mov_write_tref_tag(ByteIOContext *pb, MOVTrack *track)
{
- put_be32(pb, 20); // size
- put_tag(pb, "tref");
- put_be32(pb, 12); // size (subatom)
- put_le32(pb, track->tref_tag);
- put_be32(pb, track->tref_id);
+ avio_put_be32(pb, 20); // size
+ avio_put_tag(pb, "tref");
+ avio_put_be32(pb, 12); // size (subatom)
+ avio_put_le32(pb, track->tref_tag);
+ avio_put_be32(pb, track->tref_id);
return 20;
}
// goes at the end of each track! ... Critical for PSP playback ("Incompatible data" without it)
static int mov_write_uuid_tag_psp(ByteIOContext *pb, MOVTrack *mov)
{
- put_be32(pb, 0x34); /* size ... reports as 28 in mp4box! */
- put_tag(pb, "uuid");
- put_tag(pb, "USMT");
- put_be32(pb, 0x21d24fce);
- put_be32(pb, 0xbb88695c);
- put_be32(pb, 0xfac9c740);
- put_be32(pb, 0x1c); // another size here!
- put_tag(pb, "MTDT");
- put_be32(pb, 0x00010012);
- put_be32(pb, 0x0a);
- put_be32(pb, 0x55c40000);
- put_be32(pb, 0x1);
- put_be32(pb, 0x0);
+ avio_put_be32(pb, 0x34); /* size ... reports as 28 in mp4box! */
+ avio_put_tag(pb, "uuid");
+ avio_put_tag(pb, "USMT");
+ avio_put_be32(pb, 0x21d24fce);
+ avio_put_be32(pb, 0xbb88695c);
+ avio_put_be32(pb, 0xfac9c740);
+ avio_put_be32(pb, 0x1c); // another size here!
+ avio_put_tag(pb, "MTDT");
+ avio_put_be32(pb, 0x00010012);
+ avio_put_be32(pb, 0x0a);
+ avio_put_be32(pb, 0x55c40000);
+ avio_put_be32(pb, 0x1);
+ avio_put_be32(pb, 0x0);
return 0x34;
}
@@ -1285,21 +1285,21 @@ static int mov_write_udta_sdp(ByteIOContext *pb, AVCodecContext *ctx, int index)
av_strlcatf(buf, sizeof(buf), "a=control:streamid=%d\r\n", index);
len = strlen(buf);
- put_be32(pb, len + 24);
- put_tag (pb, "udta");
- put_be32(pb, len + 16);
- put_tag (pb, "hnti");
- put_be32(pb, len + 8);
- put_tag (pb, "sdp ");
- put_buffer(pb, buf, len);
+ avio_put_be32(pb, len + 24);
+ avio_put_tag (pb, "udta");
+ avio_put_be32(pb, len + 16);
+ avio_put_tag (pb, "hnti");
+ avio_put_be32(pb, len + 8);
+ avio_put_tag (pb, "sdp ");
+ avio_put_buffer(pb, buf, len);
return len + 24;
}
static int mov_write_trak_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "trak");
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "trak");
mov_write_tkhd_tag(pb, track, st);
if (track->mode == MODE_PSP || track->flags & MOV_TRACK_CTTS)
mov_write_edts_tag(pb, track); // PSP Movies require edts box
@@ -1317,14 +1317,14 @@ static int mov_write_trak_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
/* TODO: Not sorted out, but not necessary either */
static int mov_write_iods_tag(ByteIOContext *pb, MOVMuxContext *mov)
{
- put_be32(pb, 0x15); /* size */
- put_tag(pb, "iods");
- put_be32(pb, 0); /* version & flags */
- put_be16(pb, 0x1007);
- put_byte(pb, 0);
- put_be16(pb, 0x4fff);
- put_be16(pb, 0xfffe);
- put_be16(pb, 0x01ff);
+ avio_put_be32(pb, 0x15); /* size */
+ avio_put_tag(pb, "iods");
+ avio_put_be32(pb, 0); /* version & flags */
+ avio_put_be16(pb, 0x1007);
+ avio_put_byte(pb, 0);
+ avio_put_be16(pb, 0x4fff);
+ avio_put_be16(pb, 0xfffe);
+ avio_put_be16(pb, 0x01ff);
return 0x15;
}
#endif
@@ -1349,59 +1349,59 @@ static int mov_write_mvhd_tag(ByteIOContext *pb, MOVMuxContext *mov)
}
version = maxTrackLen < UINT32_MAX ? 0 : 1;
- (version == 1) ? put_be32(pb, 120) : put_be32(pb, 108); /* size */
- put_tag(pb, "mvhd");
- put_byte(pb, version);
- put_be24(pb, 0); /* flags */
+ (version == 1) ? avio_put_be32(pb, 120) : avio_put_be32(pb, 108); /* size */
+ avio_put_tag(pb, "mvhd");
+ avio_put_byte(pb, version);
+ avio_put_be24(pb, 0); /* flags */
if (version == 1) {
- put_be64(pb, mov->time);
- put_be64(pb, mov->time);
+ avio_put_be64(pb, mov->time);
+ avio_put_be64(pb, mov->time);
} else {
- put_be32(pb, mov->time); /* creation time */
- put_be32(pb, mov->time); /* modification time */
+ avio_put_be32(pb, mov->time); /* creation time */
+ avio_put_be32(pb, mov->time); /* modification time */
}
- put_be32(pb, MOV_TIMESCALE);
- (version == 1) ? put_be64(pb, maxTrackLen) : put_be32(pb, maxTrackLen); /* duration of longest track */
+ avio_put_be32(pb, MOV_TIMESCALE);
+ (version == 1) ? avio_put_be64(pb, maxTrackLen) : avio_put_be32(pb, maxTrackLen); /* duration of longest track */
- put_be32(pb, 0x00010000); /* reserved (preferred rate) 1.0 = normal */
- put_be16(pb, 0x0100); /* reserved (preferred volume) 1.0 = normal */
- put_be16(pb, 0); /* reserved */
- put_be32(pb, 0); /* reserved */
- put_be32(pb, 0); /* reserved */
+ avio_put_be32(pb, 0x00010000); /* reserved (preferred rate) 1.0 = normal */
+ avio_put_be16(pb, 0x0100); /* reserved (preferred volume) 1.0 = normal */
+ avio_put_be16(pb, 0); /* reserved */
+ avio_put_be32(pb, 0); /* reserved */
+ avio_put_be32(pb, 0); /* reserved */
/* Matrix structure */
- put_be32(pb, 0x00010000); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x00010000); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x0); /* reserved */
- put_be32(pb, 0x40000000); /* reserved */
-
- put_be32(pb, 0); /* reserved (preview time) */
- put_be32(pb, 0); /* reserved (preview duration) */
- put_be32(pb, 0); /* reserved (poster time) */
- put_be32(pb, 0); /* reserved (selection time) */
- put_be32(pb, 0); /* reserved (selection duration) */
- put_be32(pb, 0); /* reserved (current time) */
- put_be32(pb, maxTrackID+1); /* Next track id */
+ avio_put_be32(pb, 0x00010000); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x00010000); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x0); /* reserved */
+ avio_put_be32(pb, 0x40000000); /* reserved */
+
+ avio_put_be32(pb, 0); /* reserved (preview time) */
+ avio_put_be32(pb, 0); /* reserved (preview duration) */
+ avio_put_be32(pb, 0); /* reserved (poster time) */
+ avio_put_be32(pb, 0); /* reserved (selection time) */
+ avio_put_be32(pb, 0); /* reserved (selection duration) */
+ avio_put_be32(pb, 0); /* reserved (current time) */
+ avio_put_be32(pb, maxTrackID+1); /* Next track id */
return 0x6c;
}
static int mov_write_itunes_hdlr_tag(ByteIOContext *pb, MOVMuxContext *mov,
AVFormatContext *s)
{
- put_be32(pb, 33); /* size */
- put_tag(pb, "hdlr");
- put_be32(pb, 0);
- put_be32(pb, 0);
- put_tag(pb, "mdir");
- put_tag(pb, "appl");
- put_be32(pb, 0);
- put_be32(pb, 0);
- put_byte(pb, 0);
+ avio_put_be32(pb, 33); /* size */
+ avio_put_tag(pb, "hdlr");
+ avio_put_be32(pb, 0);
+ avio_put_be32(pb, 0);
+ avio_put_tag(pb, "mdir");
+ avio_put_tag(pb, "appl");
+ avio_put_be32(pb, 0);
+ avio_put_be32(pb, 0);
+ avio_put_byte(pb, 0);
return 33;
}
@@ -1410,18 +1410,18 @@ static int mov_write_string_data_tag(ByteIOContext *pb, const char *data, int la
{
if(long_style){
int size = 16 + strlen(data);
- put_be32(pb, size); /* size */
- put_tag(pb, "data");
- put_be32(pb, 1);
- put_be32(pb, 0);
- put_buffer(pb, data, strlen(data));
+ avio_put_be32(pb, size); /* size */
+ avio_put_tag(pb, "data");
+ avio_put_be32(pb, 1);
+ avio_put_be32(pb, 0);
+ avio_put_buffer(pb, data, strlen(data));
return size;
}else{
if (!lang)
lang = ff_mov_iso639_to_lang("und", 1);
- put_be16(pb, strlen(data)); /* string length */
- put_be16(pb, lang);
- put_buffer(pb, data, strlen(data));
+ avio_put_be16(pb, strlen(data)); /* string length */
+ avio_put_be16(pb, lang);
+ avio_put_buffer(pb, data, strlen(data));
return strlen(data) + 4;
}
}
@@ -1430,8 +1430,8 @@ static int mov_write_string_tag(ByteIOContext *pb, const char *name, const char
int size = 0;
if (value && value[0]) {
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, name);
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, name);
mov_write_string_data_tag(pb, value, lang, long_style);
size= updateSize(pb, pos);
}
@@ -1469,16 +1469,16 @@ static int mov_write_trkn_tag(ByteIOContext *pb, MOVMuxContext *mov,
AVMetadataTag *t = av_metadata_get(s->metadata, "track", NULL, 0);
int size = 0, track = t ? atoi(t->value) : 0;
if (track) {
- put_be32(pb, 32); /* size */
- put_tag(pb, "trkn");
- put_be32(pb, 24); /* size */
- put_tag(pb, "data");
- put_be32(pb, 0); // 8 bytes empty
- put_be32(pb, 0);
- put_be16(pb, 0); // empty
- put_be16(pb, track); // track number
- put_be16(pb, 0); // total track number
- put_be16(pb, 0); // empty
+ avio_put_be32(pb, 32); /* size */
+ avio_put_tag(pb, "trkn");
+ avio_put_be32(pb, 24); /* size */
+ avio_put_tag(pb, "data");
+ avio_put_be32(pb, 0); // 8 bytes empty
+ avio_put_be32(pb, 0);
+ avio_put_be16(pb, 0); // empty
+ avio_put_be16(pb, track); // track number
+ avio_put_be16(pb, 0); // total track number
+ avio_put_be16(pb, 0); // empty
size = 32;
}
return size;
@@ -1489,8 +1489,8 @@ static int mov_write_ilst_tag(ByteIOContext *pb, MOVMuxContext *mov,
AVFormatContext *s)
{
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "ilst");
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "ilst");
mov_write_string_metadata(s, pb, "\251nam", "title" , 1);
mov_write_string_metadata(s, pb, "\251ART", "artist" , 1);
mov_write_string_metadata(s, pb, "aART", "album_artist", 1);
@@ -1518,9 +1518,9 @@ static int mov_write_meta_tag(ByteIOContext *pb, MOVMuxContext *mov,
{
int size = 0;
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size */
- put_tag(pb, "meta");
- put_be32(pb, 0);
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "meta");
+ avio_put_be32(pb, 0);
mov_write_itunes_hdlr_tag(pb, mov, s);
mov_write_ilst_tag(pb, mov, s);
size = updateSize(pb, pos);
@@ -1543,9 +1543,9 @@ static int ascii_to_wc(ByteIOContext *pb, const uint8_t *b)
int val;
while(*b){
GET_UTF8(val, *b++, return -1;)
- put_be16(pb, val);
+ avio_put_be16(pb, val);
}
- put_be16(pb, 0x00);
+ avio_put_be16(pb, 0x00);
return 0;
}
@@ -1561,17 +1561,17 @@ static int mov_write_3gp_udta_tag(ByteIOContext *pb, AVFormatContext *s,
AVMetadataTag *t = av_metadata_get(s->metadata, str, NULL, 0);
if (!t || !utf8len(t->value))
return 0;
- put_be32(pb, 0); /* size */
- put_tag (pb, tag); /* type */
- put_be32(pb, 0); /* version + flags */
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag (pb, tag); /* type */
+ avio_put_be32(pb, 0); /* version + flags */
if (!strcmp(tag, "yrrc"))
- put_be16(pb, atoi(t->value));
+ avio_put_be16(pb, atoi(t->value));
else {
- put_be16(pb, language_code("eng")); /* language */
- put_buffer(pb, t->value, strlen(t->value)+1); /* UTF8 string value */
+ avio_put_be16(pb, language_code("eng")); /* language */
+ avio_put_buffer(pb, t->value, strlen(t->value)+1); /* UTF8 string value */
if (!strcmp(tag, "albm") &&
(t = av_metadata_get(s->metadata, "track", NULL, 0)))
- put_byte(pb, atoi(t->value));
+ avio_put_byte(pb, atoi(t->value));
}
return updateSize(pb, pos);
}
@@ -1581,23 +1581,23 @@ static int mov_write_chpl_tag(ByteIOContext *pb, AVFormatContext *s)
int64_t pos = url_ftell(pb);
int i, nb_chapters = FFMIN(s->nb_chapters, 255);
- put_be32(pb, 0); // size
- put_tag (pb, "chpl");
- put_be32(pb, 0x01000000); // version + flags
- put_be32(pb, 0); // unknown
- put_byte(pb, nb_chapters);
+ avio_put_be32(pb, 0); // size
+ avio_put_tag (pb, "chpl");
+ avio_put_be32(pb, 0x01000000); // version + flags
+ avio_put_be32(pb, 0); // unknown
+ avio_put_byte(pb, nb_chapters);
for (i = 0; i < nb_chapters; i++) {
AVChapter *c = s->chapters[i];
AVMetadataTag *t;
- put_be64(pb, av_rescale_q(c->start, c->time_base, (AVRational){1,10000000}));
+ avio_put_be64(pb, av_rescale_q(c->start, c->time_base, (AVRational){1,10000000}));
if ((t = av_metadata_get(c->metadata, "title", NULL, 0))) {
int len = FFMIN(strlen(t->value), 255);
- put_byte(pb, len);
- put_buffer(pb, t->value, len);
+ avio_put_byte(pb, len);
+ avio_put_buffer(pb, t->value, len);
} else
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
}
return updateSize(pb, pos);
}
@@ -1646,9 +1646,9 @@ static int mov_write_udta_tag(ByteIOContext *pb, MOVMuxContext *mov,
mov_write_chpl_tag(pb_buf, s);
if ((size = url_close_dyn_buf(pb_buf, &buf)) > 0) {
- put_be32(pb, size+8);
- put_tag(pb, "udta");
- put_buffer(pb, buf, size);
+ avio_put_be32(pb, size+8);
+ avio_put_tag(pb, "udta");
+ avio_put_buffer(pb, buf, size);
}
av_free(buf);
@@ -1661,10 +1661,10 @@ static void mov_write_psp_udta_tag(ByteIOContext *pb,
int len = utf8len(str)+1;
if(len<=0)
return;
- put_be16(pb, len*2+10); /* size */
- put_be32(pb, type); /* type */
- put_be16(pb, language_code(lang)); /* language */
- put_be16(pb, 0x01); /* ? */
+ avio_put_be16(pb, len*2+10); /* size */
+ avio_put_be32(pb, type); /* type */
+ avio_put_be16(pb, language_code(lang)); /* language */
+ avio_put_be16(pb, 0x01); /* ? */
ascii_to_wc(pb, str);
}
@@ -1675,24 +1675,24 @@ static int mov_write_uuidusmt_tag(ByteIOContext *pb, AVFormatContext *s)
if (title) {
pos = url_ftell(pb);
- put_be32(pb, 0); /* size placeholder*/
- put_tag(pb, "uuid");
- put_tag(pb, "USMT");
- put_be32(pb, 0x21d24fce); /* 96 bit UUID */
- put_be32(pb, 0xbb88695c);
- put_be32(pb, 0xfac9c740);
+ avio_put_be32(pb, 0); /* size placeholder*/
+ avio_put_tag(pb, "uuid");
+ avio_put_tag(pb, "USMT");
+ avio_put_be32(pb, 0x21d24fce); /* 96 bit UUID */
+ avio_put_be32(pb, 0xbb88695c);
+ avio_put_be32(pb, 0xfac9c740);
pos2 = url_ftell(pb);
- put_be32(pb, 0); /* size placeholder*/
- put_tag(pb, "MTDT");
- put_be16(pb, 4);
+ avio_put_be32(pb, 0); /* size placeholder*/
+ avio_put_tag(pb, "MTDT");
+ avio_put_be16(pb, 4);
// ?
- put_be16(pb, 0x0C); /* size */
- put_be32(pb, 0x0B); /* type */
- put_be16(pb, language_code("und")); /* language */
- put_be16(pb, 0x0); /* ? */
- put_be16(pb, 0x021C); /* data */
+ avio_put_be16(pb, 0x0C); /* size */
+ avio_put_be32(pb, 0x0B); /* type */
+ avio_put_be16(pb, language_code("und")); /* language */
+ avio_put_be16(pb, 0x0); /* ? */
+ avio_put_be16(pb, 0x021C); /* data */
mov_write_psp_udta_tag(pb, LIBAVCODEC_IDENT, "eng", 0x04);
mov_write_psp_udta_tag(pb, title->value, "eng", 0x01);
@@ -1711,8 +1711,8 @@ static int mov_write_moov_tag(ByteIOContext *pb, MOVMuxContext *mov,
{
int i;
int64_t pos = url_ftell(pb);
- put_be32(pb, 0); /* size placeholder*/
- put_tag(pb, "moov");
+ avio_put_be32(pb, 0); /* size placeholder*/
+ avio_put_tag(pb, "moov");
for (i=0; i<mov->nb_streams; i++) {
if(mov->tracks[i].entry <= 0) continue;
@@ -1752,12 +1752,12 @@ static int mov_write_moov_tag(ByteIOContext *pb, MOVMuxContext *mov,
static int mov_write_mdat_tag(ByteIOContext *pb, MOVMuxContext *mov)
{
- put_be32(pb, 8); // placeholder for extended size field (64 bit)
- put_tag(pb, mov->mode == MODE_MOV ? "wide" : "free");
+ avio_put_be32(pb, 8); // placeholder for extended size field (64 bit)
+ avio_put_tag(pb, mov->mode == MODE_MOV ? "wide" : "free");
mov->mdat_pos = url_ftell(pb);
- put_be32(pb, 0); /* size placeholder*/
- put_tag(pb, "mdat");
+ avio_put_be32(pb, 0); /* size placeholder*/
+ avio_put_tag(pb, "mdat");
return 0;
}
@@ -1778,43 +1778,43 @@ static int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)
has_h264 = 1;
}
- put_be32(pb, 0); /* size */
- put_tag(pb, "ftyp");
+ avio_put_be32(pb, 0); /* size */
+ avio_put_tag(pb, "ftyp");
if (mov->mode == MODE_3GP) {
- put_tag(pb, has_h264 ? "3gp6" : "3gp4");
+ avio_put_tag(pb, has_h264 ? "3gp6" : "3gp4");
minor = has_h264 ? 0x100 : 0x200;
} else if (mov->mode & MODE_3G2) {
- put_tag(pb, has_h264 ? "3g2b" : "3g2a");
+ avio_put_tag(pb, has_h264 ? "3g2b" : "3g2a");
minor = has_h264 ? 0x20000 : 0x10000;
}else if (mov->mode == MODE_PSP)
- put_tag(pb, "MSNV");
+ avio_put_tag(pb, "MSNV");
else if (mov->mode == MODE_MP4)
- put_tag(pb, "isom");
+ avio_put_tag(pb, "isom");
else if (mov->mode == MODE_IPOD)
- put_tag(pb, has_video ? "M4V ":"M4A ");
+ avio_put_tag(pb, has_video ? "M4V ":"M4A ");
else
- put_tag(pb, "qt ");
+ avio_put_tag(pb, "qt ");
- put_be32(pb, minor);
+ avio_put_be32(pb, minor);
if(mov->mode == MODE_MOV)
- put_tag(pb, "qt ");
+ avio_put_tag(pb, "qt ");
else{
- put_tag(pb, "isom");
- put_tag(pb, "iso2");
+ avio_put_tag(pb, "isom");
+ avio_put_tag(pb, "iso2");
if(has_h264)
- put_tag(pb, "avc1");
+ avio_put_tag(pb, "avc1");
}
if (mov->mode == MODE_3GP)
- put_tag(pb, has_h264 ? "3gp6":"3gp4");
+ avio_put_tag(pb, has_h264 ? "3gp6":"3gp4");
else if (mov->mode & MODE_3G2)
- put_tag(pb, has_h264 ? "3g2b":"3g2a");
+ avio_put_tag(pb, has_h264 ? "3g2b":"3g2a");
else if (mov->mode == MODE_PSP)
- put_tag(pb, "MSNV");
+ avio_put_tag(pb, "MSNV");
else if (mov->mode == MODE_MP4)
- put_tag(pb, "mp41");
+ avio_put_tag(pb, "mp41");
return updateSize(pb, pos);
}
@@ -1827,56 +1827,56 @@ static void mov_write_uuidprof_tag(ByteIOContext *pb, AVFormatContext *s)
int audio_kbitrate= AudioCodec->bit_rate / 1000;
int video_kbitrate= FFMIN(VideoCodec->bit_rate / 1000, 800 - audio_kbitrate);
- put_be32(pb, 0x94); /* size */
- put_tag(pb, "uuid");
- put_tag(pb, "PROF");
-
- put_be32(pb, 0x21d24fce); /* 96 bit UUID */
- put_be32(pb, 0xbb88695c);
- put_be32(pb, 0xfac9c740);
-
- put_be32(pb, 0x0); /* ? */
- put_be32(pb, 0x3); /* 3 sections ? */
-
- put_be32(pb, 0x14); /* size */
- put_tag(pb, "FPRF");
- put_be32(pb, 0x0); /* ? */
- put_be32(pb, 0x0); /* ? */
- put_be32(pb, 0x0); /* ? */
-
- put_be32(pb, 0x2c); /* size */
- put_tag(pb, "APRF"); /* audio */
- put_be32(pb, 0x0);
- put_be32(pb, 0x2); /* TrackID */
- put_tag(pb, "mp4a");
- put_be32(pb, 0x20f);
- put_be32(pb, 0x0);
- put_be32(pb, audio_kbitrate);
- put_be32(pb, audio_kbitrate);
- put_be32(pb, AudioRate);
- put_be32(pb, AudioCodec->channels);
-
- put_be32(pb, 0x34); /* size */
- put_tag(pb, "VPRF"); /* video */
- put_be32(pb, 0x0);
- put_be32(pb, 0x1); /* TrackID */
+ avio_put_be32(pb, 0x94); /* size */
+ avio_put_tag(pb, "uuid");
+ avio_put_tag(pb, "PROF");
+
+ avio_put_be32(pb, 0x21d24fce); /* 96 bit UUID */
+ avio_put_be32(pb, 0xbb88695c);
+ avio_put_be32(pb, 0xfac9c740);
+
+ avio_put_be32(pb, 0x0); /* ? */
+ avio_put_be32(pb, 0x3); /* 3 sections ? */
+
+ avio_put_be32(pb, 0x14); /* size */
+ avio_put_tag(pb, "FPRF");
+ avio_put_be32(pb, 0x0); /* ? */
+ avio_put_be32(pb, 0x0); /* ? */
+ avio_put_be32(pb, 0x0); /* ? */
+
+ avio_put_be32(pb, 0x2c); /* size */
+ avio_put_tag(pb, "APRF"); /* audio */
+ avio_put_be32(pb, 0x0);
+ avio_put_be32(pb, 0x2); /* TrackID */
+ avio_put_tag(pb, "mp4a");
+ avio_put_be32(pb, 0x20f);
+ avio_put_be32(pb, 0x0);
+ avio_put_be32(pb, audio_kbitrate);
+ avio_put_be32(pb, audio_kbitrate);
+ avio_put_be32(pb, AudioRate);
+ avio_put_be32(pb, AudioCodec->channels);
+
+ avio_put_be32(pb, 0x34); /* size */
+ avio_put_tag(pb, "VPRF"); /* video */
+ avio_put_be32(pb, 0x0);
+ avio_put_be32(pb, 0x1); /* TrackID */
if (VideoCodec->codec_id == CODEC_ID_H264) {
- put_tag(pb, "avc1");
- put_be16(pb, 0x014D);
- put_be16(pb, 0x0015);
+ avio_put_tag(pb, "avc1");
+ avio_put_be16(pb, 0x014D);
+ avio_put_be16(pb, 0x0015);
} else {
- put_tag(pb, "mp4v");
- put_be16(pb, 0x0000);
- put_be16(pb, 0x0103);
+ avio_put_tag(pb, "mp4v");
+ avio_put_be16(pb, 0x0000);
+ avio_put_be16(pb, 0x0103);
}
- put_be32(pb, 0x0);
- put_be32(pb, video_kbitrate);
- put_be32(pb, video_kbitrate);
- put_be32(pb, FrameRate);
- put_be32(pb, FrameRate);
- put_be16(pb, VideoCodec->width);
- put_be16(pb, VideoCodec->height);
- put_be32(pb, 0x010001); /* ? */
+ avio_put_be32(pb, 0x0);
+ avio_put_be32(pb, video_kbitrate);
+ avio_put_be32(pb, video_kbitrate);
+ avio_put_be32(pb, FrameRate);
+ avio_put_be32(pb, FrameRate);
+ avio_put_be16(pb, VideoCodec->width);
+ avio_put_be16(pb, VideoCodec->height);
+ avio_put_be32(pb, 0x010001); /* ? */
}
static int mov_parse_mpeg2_frame(AVPacket *pkt, uint32_t *flags)
@@ -1946,7 +1946,7 @@ int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
/* nal reformating needed */
size = ff_avc_parse_nal_units(pb, pkt->data, pkt->size);
} else {
- put_buffer(pb, pkt->data, size);
+ avio_put_buffer(pb, pkt->data, size);
}
if ((enc->codec_id == CODEC_ID_DNXHD ||
@@ -2201,13 +2201,13 @@ static int mov_write_trailer(AVFormatContext *s)
/* Write size of mdat tag */
if (mov->mdat_size+8 <= UINT32_MAX) {
url_fseek(pb, mov->mdat_pos, SEEK_SET);
- put_be32(pb, mov->mdat_size+8);
+ avio_put_be32(pb, mov->mdat_size+8);
} else {
/* overwrite 'wide' placeholder atom */
url_fseek(pb, mov->mdat_pos - 8, SEEK_SET);
- put_be32(pb, 1); /* special value: real atom size will be 64 bit value after tag field */
- put_tag(pb, "mdat");
- put_be64(pb, mov->mdat_size+16);
+ avio_put_be32(pb, 1); /* special value: real atom size will be 64 bit value after tag field */
+ avio_put_tag(pb, "mdat");
+ avio_put_be64(pb, mov->mdat_size+16);
}
url_fseek(pb, moov_pos, SEEK_SET);
diff --git a/libavformat/movenchint.c b/libavformat/movenchint.c
index cdfb276..ef07e46 100644
--- a/libavformat/movenchint.c
+++ b/libavformat/movenchint.c
@@ -251,14 +251,14 @@ static void output_immediate(const uint8_t *data, int size,
int len = size;
if (len > 14)
len = 14;
- put_byte(out, 1); /* immediate constructor */
- put_byte(out, len); /* amount of valid data */
- put_buffer(out, data, len);
+ avio_put_byte(out, 1); /* immediate constructor */
+ avio_put_byte(out, len); /* amount of valid data */
+ avio_put_buffer(out, data, len);
data += len;
size -= len;
for (; len < 14; len++)
- put_byte(out, 0);
+ avio_put_byte(out, 0);
(*entries)++;
}
@@ -267,13 +267,13 @@ static void output_immediate(const uint8_t *data, int size,
static void output_match(ByteIOContext *out, int match_sample,
int match_offset, int match_len, int *entries)
{
- put_byte(out, 2); /* sample constructor */
- put_byte(out, 0); /* track reference */
- put_be16(out, match_len);
- put_be32(out, match_sample);
- put_be32(out, match_offset);
- put_be16(out, 1); /* bytes per block */
- put_be16(out, 1); /* samples per block */
+ avio_put_byte(out, 2); /* sample constructor */
+ avio_put_byte(out, 0); /* track reference */
+ avio_put_be16(out, match_len);
+ avio_put_be32(out, match_sample);
+ avio_put_be32(out, match_offset);
+ avio_put_be16(out, 1); /* bytes per block */
+ avio_put_be16(out, 1); /* samples per block */
(*entries)++;
}
@@ -318,8 +318,8 @@ static int write_hint_packets(ByteIOContext *out, const uint8_t *data,
count_pos = url_ftell(out);
/* RTPsample header */
- put_be16(out, 0); /* packet count */
- put_be16(out, 0); /* reserved */
+ avio_put_be16(out, 0); /* packet count */
+ avio_put_be16(out, 0); /* reserved */
while (size > 4) {
uint32_t packet_len = AV_RB32(data);
@@ -354,12 +354,12 @@ static int write_hint_packets(ByteIOContext *out, const uint8_t *data,
count++;
/* RTPpacket header */
- put_be32(out, 0); /* relative_time */
- put_buffer(out, data, 2); /* RTP header */
- put_be16(out, seq); /* RTPsequenceseed */
- put_be16(out, 0); /* reserved + flags */
+ avio_put_be32(out, 0); /* relative_time */
+ avio_put_buffer(out, data, 2); /* RTP header */
+ avio_put_be16(out, seq); /* RTPsequenceseed */
+ avio_put_be16(out, 0); /* reserved + flags */
entries_pos = url_ftell(out);
- put_be16(out, 0); /* entry count */
+ avio_put_be16(out, 0); /* entry count */
data += 12;
size -= 12;
@@ -373,13 +373,13 @@ static int write_hint_packets(ByteIOContext *out, const uint8_t *data,
curpos = url_ftell(out);
url_fseek(out, entries_pos, SEEK_SET);
- put_be16(out, entries);
+ avio_put_be16(out, entries);
url_fseek(out, curpos, SEEK_SET);
}
curpos = url_ftell(out);
url_fseek(out, count_pos, SEEK_SET);
- put_be16(out, count);
+ avio_put_be16(out, count);
url_fseek(out, curpos, SEEK_SET);
return count;
}
diff --git a/libavformat/mp3enc.c b/libavformat/mp3enc.c
index 5921ded..f2b7d49 100644
--- a/libavformat/mp3enc.c
+++ b/libavformat/mp3enc.c
@@ -71,10 +71,10 @@ static int id3v1_create_tag(AVFormatContext *s, uint8_t *buf)
static void id3v2_put_size(AVFormatContext *s, int size)
{
- put_byte(s->pb, size >> 21 & 0x7f);
- put_byte(s->pb, size >> 14 & 0x7f);
- put_byte(s->pb, size >> 7 & 0x7f);
- put_byte(s->pb, size & 0x7f);
+ avio_put_byte(s->pb, size >> 21 & 0x7f);
+ avio_put_byte(s->pb, size >> 14 & 0x7f);
+ avio_put_byte(s->pb, size >> 7 & 0x7f);
+ avio_put_byte(s->pb, size & 0x7f);
}
static int string_is_ascii(const uint8_t *str)
@@ -104,9 +104,9 @@ static int id3v2_put_ttag(AVFormatContext *s, const char *str1, const char *str2
(!str2 || string_is_ascii(str2)))
enc = ID3v2_ENCODING_ISO8859;
- put_byte(dyn_buf, enc);
+ avio_put_byte(dyn_buf, enc);
if (enc == ID3v2_ENCODING_UTF16BOM) {
- put_le16(dyn_buf, 0xFEFF); /* BOM */
+ avio_put_le16(dyn_buf, 0xFEFF); /* BOM */
put = avio_put_str16le;
} else
put = avio_put_str;
@@ -116,10 +116,10 @@ static int id3v2_put_ttag(AVFormatContext *s, const char *str1, const char *str2
put(dyn_buf, str2);
len = url_close_dyn_buf(dyn_buf, &pb);
- put_be32(s->pb, tag);
+ avio_put_be32(s->pb, tag);
id3v2_put_size(s, len);
- put_be16(s->pb, 0);
- put_buffer(s->pb, pb, len);
+ avio_put_be16(s->pb, 0);
+ avio_put_buffer(s->pb, pb, len);
av_freep(&pb);
return len + ID3v2_HEADER_SIZE;
@@ -128,7 +128,7 @@ static int id3v2_put_ttag(AVFormatContext *s, const char *str1, const char *str2
static int mp3_write_packet(struct AVFormatContext *s, AVPacket *pkt)
{
- put_buffer(s->pb, pkt->data, pkt->size);
+ avio_put_buffer(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb);
return 0;
}
@@ -139,7 +139,7 @@ static int mp3_write_trailer(struct AVFormatContext *s)
/* write the id3v1 tag */
if (id3v1_create_tag(s, buf) > 0) {
- put_buffer(s->pb, buf, ID3v1_TAG_SIZE);
+ avio_put_buffer(s->pb, buf, ID3v1_TAG_SIZE);
put_flush_packet(s->pb);
}
return 0;
@@ -206,13 +206,13 @@ static int mp3_write_header(struct AVFormatContext *s)
ID3v2_ENCODING_UTF8;
int64_t size_pos, cur_pos;
- put_be32(s->pb, MKBETAG('I', 'D', '3', mp3->id3v2_version));
- put_byte(s->pb, 0);
- put_byte(s->pb, 0); /* flags */
+ avio_put_be32(s->pb, MKBETAG('I', 'D', '3', mp3->id3v2_version));
+ avio_put_byte(s->pb, 0);
+ avio_put_byte(s->pb, 0); /* flags */
/* reserve space for size */
size_pos = url_ftell(s->pb);
- put_be32(s->pb, 0);
+ avio_put_be32(s->pb, 0);
ff_metadata_conv(&s->metadata, ff_id3v2_34_metadata_conv, NULL);
if (mp3->id3v2_version == 4)
diff --git a/libavformat/mpegenc.c b/libavformat/mpegenc.c
index eef385f..19ca65f 100644
--- a/libavformat/mpegenc.c
+++ b/libavformat/mpegenc.c
@@ -493,12 +493,12 @@ static int mpeg_mux_init(AVFormatContext *ctx)
static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
{
- put_byte(pb,
+ avio_put_byte(pb,
(id << 4) |
(((timestamp >> 30) & 0x07) << 1) |
1);
- put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
- put_be16(pb, (uint16_t)((((timestamp ) & 0x7fff) << 1) | 1));
+ avio_put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
+ avio_put_be16(pb, (uint16_t)((((timestamp ) & 0x7fff) << 1) | 1));
}
@@ -618,16 +618,16 @@ static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packe
MpegMuxContext *s = ctx->priv_data;
int i;
- put_be32(pb, PADDING_STREAM);
- put_be16(pb, packet_bytes - 6);
+ avio_put_be32(pb, PADDING_STREAM);
+ avio_put_be16(pb, packet_bytes - 6);
if (!s->is_mpeg2) {
- put_byte(pb, 0x0f);
+ avio_put_byte(pb, 0x0f);
packet_bytes -= 7;
} else
packet_bytes -= 6;
for(i=0;i<packet_bytes;i++)
- put_byte(pb, 0xff);
+ avio_put_byte(pb, 0xff);
}
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
@@ -699,19 +699,19 @@ static int flush_packet(AVFormatContext *ctx, int stream_index,
size = put_system_header(ctx, buf_ptr, 0);
buf_ptr += size;
size = buf_ptr - buffer;
- put_buffer(ctx->pb, buffer, size);
+ avio_put_buffer(ctx->pb, buffer, size);
- put_be32(ctx->pb, PRIVATE_STREAM_2);
- put_be16(ctx->pb, 0x03d4); // length
- put_byte(ctx->pb, 0x00); // substream ID, 00=PCI
+ avio_put_be32(ctx->pb, PRIVATE_STREAM_2);
+ avio_put_be16(ctx->pb, 0x03d4); // length
+ avio_put_byte(ctx->pb, 0x00); // substream ID, 00=PCI
for (i = 0; i < 979; i++)
- put_byte(ctx->pb, 0x00);
+ avio_put_byte(ctx->pb, 0x00);
- put_be32(ctx->pb, PRIVATE_STREAM_2);
- put_be16(ctx->pb, 0x03fa); // length
- put_byte(ctx->pb, 0x01); // substream ID, 01=DSI
+ avio_put_be32(ctx->pb, PRIVATE_STREAM_2);
+ avio_put_be16(ctx->pb, 0x03fa); // length
+ avio_put_byte(ctx->pb, 0x01); // substream ID, 01=DSI
for (i = 0; i < 1017; i++)
- put_byte(ctx->pb, 0x00);
+ avio_put_byte(ctx->pb, 0x00);
memset(buffer, 0, 128);
buf_ptr = buffer;
@@ -734,7 +734,7 @@ static int flush_packet(AVFormatContext *ctx, int stream_index,
}
}
size = buf_ptr - buffer;
- put_buffer(ctx->pb, buffer, size);
+ avio_put_buffer(ctx->pb, buffer, size);
packet_size = s->packet_size - size;
@@ -839,16 +839,16 @@ static int flush_packet(AVFormatContext *ctx, int stream_index,
nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
- put_be32(ctx->pb, startcode);
+ avio_put_be32(ctx->pb, startcode);
- put_be16(ctx->pb, packet_size);
+ avio_put_be16(ctx->pb, packet_size);
if (!s->is_mpeg2)
for(i=0;i<stuffing_size;i++)
- put_byte(ctx->pb, 0xff);
+ avio_put_byte(ctx->pb, 0xff);
if (s->is_mpeg2) {
- put_byte(ctx->pb, 0x80); /* mpeg2 id */
+ avio_put_byte(ctx->pb, 0x80); /* mpeg2 id */
pes_flags=0;
@@ -865,8 +865,8 @@ static int flush_packet(AVFormatContext *ctx, int stream_index,
if (stream->packet_number == 0)
pes_flags |= 0x01;
- put_byte(ctx->pb, pes_flags); /* flags */
- put_byte(ctx->pb, header_len - 3 + stuffing_size);
+ avio_put_byte(ctx->pb, pes_flags); /* flags */
+ avio_put_byte(ctx->pb, header_len - 3 + stuffing_size);
if (pes_flags & 0x80) /*write pts*/
put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
@@ -874,13 +874,13 @@ static int flush_packet(AVFormatContext *ctx, int stream_index,
put_timestamp(ctx->pb, 0x01, dts);
if (pes_flags & 0x01) { /*write pes extension*/
- put_byte(ctx->pb, 0x10); /* flags */
+ avio_put_byte(ctx->pb, 0x10); /* flags */
/* P-STD buffer info */
if ((id & 0xe0) == AUDIO_ID)
- put_be16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
+ avio_put_be16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
else
- put_be16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
+ avio_put_be16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
}
} else {
@@ -892,38 +892,38 @@ static int flush_packet(AVFormatContext *ctx, int stream_index,
put_timestamp(ctx->pb, 0x02, pts);
}
} else {
- put_byte(ctx->pb, 0x0f);
+ avio_put_byte(ctx->pb, 0x0f);
}
}
if (s->is_mpeg2) {
/* special stuffing byte that is always written
to prevent accidental generation of start codes. */
- put_byte(ctx->pb, 0xff);
+ avio_put_byte(ctx->pb, 0xff);
for(i=0;i<stuffing_size;i++)
- put_byte(ctx->pb, 0xff);
+ avio_put_byte(ctx->pb, 0xff);
}
if (startcode == PRIVATE_STREAM_1) {
- put_byte(ctx->pb, id);
+ avio_put_byte(ctx->pb, id);
if (id >= 0xa0) {
/* LPCM (XXX: check nb_frames) */
- put_byte(ctx->pb, 7);
- put_be16(ctx->pb, 4); /* skip 3 header bytes */
- put_byte(ctx->pb, stream->lpcm_header[0]);
- put_byte(ctx->pb, stream->lpcm_header[1]);
- put_byte(ctx->pb, stream->lpcm_header[2]);
+ avio_put_byte(ctx->pb, 7);
+ avio_put_be16(ctx->pb, 4); /* skip 3 header bytes */
+ avio_put_byte(ctx->pb, stream->lpcm_header[0]);
+ avio_put_byte(ctx->pb, stream->lpcm_header[1]);
+ avio_put_byte(ctx->pb, stream->lpcm_header[2]);
} else if (id >= 0x40) {
/* AC-3 */
- put_byte(ctx->pb, nb_frames);
- put_be16(ctx->pb, trailer_size+1);
+ avio_put_byte(ctx->pb, nb_frames);
+ avio_put_be16(ctx->pb, trailer_size+1);
}
}
/* output data */
assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
- av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, &put_buffer);
+ av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, &avio_put_buffer);
stream->bytes_to_iframe -= payload_size - stuffing_size;
}else{
payload_size=
@@ -934,7 +934,7 @@ static int flush_packet(AVFormatContext *ctx, int stream_index,
put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
for(i=0;i<zero_trail_bytes;i++)
- put_byte(ctx->pb, 0x00);
+ avio_put_byte(ctx->pb, 0x00);
put_flush_packet(ctx->pb);
@@ -961,7 +961,7 @@ static void put_vcd_padding_sector(AVFormatContext *ctx)
int i;
for(i=0;i<s->packet_size;i++)
- put_byte(ctx->pb, 0);
+ avio_put_byte(ctx->pb, 0);
s->vcd_padding_bytes_written += s->packet_size;
@@ -1220,7 +1220,7 @@ static int mpeg_mux_end(AVFormatContext *ctx)
/* End header according to MPEG1 systems standard. We do not write
it as it is usually not needed by decoders and because it
complicates MPEG stream concatenation. */
- //put_be32(ctx->pb, ISO_11172_END_CODE);
+ //avio_put_be32(ctx->pb, ISO_11172_END_CODE);
//put_flush_packet(ctx->pb);
for(i=0;i<ctx->nb_streams;i++) {
diff --git a/libavformat/mpegtsenc.c b/libavformat/mpegtsenc.c
index 89b88d7..e0d9da6 100644
--- a/libavformat/mpegtsenc.c
+++ b/libavformat/mpegtsenc.c
@@ -415,7 +415,7 @@ static MpegTSService *mpegts_add_service(MpegTSWrite *ts,
static void section_write_packet(MpegTSSection *s, const uint8_t *packet)
{
AVFormatContext *ctx = s->opaque;
- put_buffer(ctx->pb, packet, TS_PACKET_SIZE);
+ avio_put_buffer(ctx->pb, packet, TS_PACKET_SIZE);
}
static int mpegts_write_header(AVFormatContext *s)
@@ -625,7 +625,7 @@ static void mpegts_insert_null_packet(AVFormatContext *s)
*q++ = 0xff;
*q++ = 0x10;
memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf));
- put_buffer(s->pb, buf, TS_PACKET_SIZE);
+ avio_put_buffer(s->pb, buf, TS_PACKET_SIZE);
}
/* Write a single transport stream packet with a PCR and no payload */
@@ -650,7 +650,7 @@ static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st)
/* stuffing bytes */
memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
- put_buffer(s->pb, buf, TS_PACKET_SIZE);
+ avio_put_buffer(s->pb, buf, TS_PACKET_SIZE);
}
static void write_pts(uint8_t *q, int fourbits, int64_t pts)
@@ -844,7 +844,7 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
memcpy(buf + TS_PACKET_SIZE - len, payload, len);
payload += len;
payload_size -= len;
- put_buffer(s->pb, buf, TS_PACKET_SIZE);
+ avio_put_buffer(s->pb, buf, TS_PACKET_SIZE);
}
put_flush_packet(s->pb);
}
diff --git a/libavformat/mpjpeg.c b/libavformat/mpjpeg.c
index 76f5985..75090e3 100644
--- a/libavformat/mpjpeg.c
+++ b/libavformat/mpjpeg.c
@@ -29,7 +29,7 @@ static int mpjpeg_write_header(AVFormatContext *s)
uint8_t buf1[256];
snprintf(buf1, sizeof(buf1), "--%s\n", BOUNDARY_TAG);
- put_buffer(s->pb, buf1, strlen(buf1));
+ avio_put_buffer(s->pb, buf1, strlen(buf1));
put_flush_packet(s->pb);
return 0;
}
@@ -39,11 +39,11 @@ static int mpjpeg_write_packet(AVFormatContext *s, AVPacket *pkt)
uint8_t buf1[256];
snprintf(buf1, sizeof(buf1), "Content-type: image/jpeg\n\n");
- put_buffer(s->pb, buf1, strlen(buf1));
- put_buffer(s->pb, pkt->data, pkt->size);
+ avio_put_buffer(s->pb, buf1, strlen(buf1));
+ avio_put_buffer(s->pb, pkt->data, pkt->size);
snprintf(buf1, sizeof(buf1), "\n--%s\n", BOUNDARY_TAG);
- put_buffer(s->pb, buf1, strlen(buf1));
+ avio_put_buffer(s->pb, buf1, strlen(buf1));
put_flush_packet(s->pb);
return 0;
}
diff --git a/libavformat/mxfenc.c b/libavformat/mxfenc.c
index 8a8d7dd..7a4f87f 100644
--- a/libavformat/mxfenc.c
+++ b/libavformat/mxfenc.c
@@ -307,24 +307,24 @@ static const MXFLocalTagPair mxf_local_tag_batch[] = {
static void mxf_write_uuid(ByteIOContext *pb, enum MXFMetadataSetType type, int value)
{
- put_buffer(pb, uuid_base, 12);
- put_be16(pb, type);
- put_be16(pb, value);
+ avio_put_buffer(pb, uuid_base, 12);
+ avio_put_be16(pb, type);
+ avio_put_be16(pb, value);
}
static void mxf_write_umid(AVFormatContext *s, int type)
{
MXFContext *mxf = s->priv_data;
- put_buffer(s->pb, umid_ul, 13);
- put_be24(s->pb, mxf->instance_number);
- put_buffer(s->pb, mxf->umid, 15);
- put_byte(s->pb, type);
+ avio_put_buffer(s->pb, umid_ul, 13);
+ avio_put_be24(s->pb, mxf->instance_number);
+ avio_put_buffer(s->pb, mxf->umid, 15);
+ avio_put_byte(s->pb, type);
}
static void mxf_write_refs_count(ByteIOContext *pb, int ref_count)
{
- put_be32(pb, ref_count);
- put_be32(pb, 16);
+ avio_put_be32(pb, ref_count);
+ avio_put_be32(pb, 16);
}
static int klv_ber_length(uint64_t len)
@@ -341,25 +341,25 @@ static int klv_encode_ber_length(ByteIOContext *pb, uint64_t len)
int size;
if (len < 128) {
//short form
- put_byte(pb, len);
+ avio_put_byte(pb, len);
return 1;
}
size = (av_log2(len) >> 3) + 1;
// long form
- put_byte(pb, 0x80 + size);
+ avio_put_byte(pb, 0x80 + size);
while(size) {
size--;
- put_byte(pb, len >> 8 * size & 0xff);
+ avio_put_byte(pb, len >> 8 * size & 0xff);
}
return 0;
}
static void klv_encode_ber4_length(ByteIOContext *pb, int len)
{
- put_byte(pb, 0x80 + 3);
- put_be24(pb, len);
+ avio_put_byte(pb, 0x80 + 3);
+ avio_put_be24(pb, len);
}
/*
@@ -381,28 +381,28 @@ static void mxf_write_primer_pack(AVFormatContext *s)
local_tag_number = FF_ARRAY_ELEMS(mxf_local_tag_batch);
- put_buffer(pb, primer_pack_key, 16);
+ avio_put_buffer(pb, primer_pack_key, 16);
klv_encode_ber_length(pb, local_tag_number * 18 + 8);
- put_be32(pb, local_tag_number); // local_tag num
- put_be32(pb, 18); // item size, always 18 according to the specs
+ avio_put_be32(pb, local_tag_number); // local_tag num
+ avio_put_be32(pb, 18); // item size, always 18 according to the specs
for (i = 0; i < local_tag_number; i++) {
- put_be16(pb, mxf_local_tag_batch[i].local_tag);
- put_buffer(pb, mxf_local_tag_batch[i].uid, 16);
+ avio_put_be16(pb, mxf_local_tag_batch[i].local_tag);
+ avio_put_buffer(pb, mxf_local_tag_batch[i].uid, 16);
}
}
static void mxf_write_local_tag(ByteIOContext *pb, int size, int tag)
{
- put_be16(pb, tag);
- put_be16(pb, size);
+ avio_put_be16(pb, tag);
+ avio_put_be16(pb, size);
}
static void mxf_write_metadata_key(ByteIOContext *pb, unsigned int value)
{
- put_buffer(pb, header_metadata_key, 13);
- put_be24(pb, value);
+ avio_put_buffer(pb, header_metadata_key, 13);
+ avio_put_be24(pb, value);
}
static void mxf_free(AVFormatContext *s)
@@ -436,7 +436,7 @@ static void mxf_write_essence_container_refs(AVFormatContext *s)
av_log(s,AV_LOG_DEBUG, "essence container count:%d\n", c->essence_container_count);
for (i = 0; i < c->essence_container_count; i++) {
MXFStreamContext *sc = s->streams[i]->priv_data;
- put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
+ avio_put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
}
}
@@ -456,11 +456,11 @@ static void mxf_write_preface(AVFormatContext *s)
// last modified date
mxf_write_local_tag(pb, 8, 0x3B02);
- put_be64(pb, mxf->timestamp);
+ avio_put_be64(pb, mxf->timestamp);
// write version
mxf_write_local_tag(pb, 2, 0x3B05);
- put_be16(pb, 258); // v1.2
+ avio_put_be16(pb, 258); // v1.2
// write identification_refs
mxf_write_local_tag(pb, 16 + 8, 0x3B06);
@@ -473,7 +473,7 @@ static void mxf_write_preface(AVFormatContext *s)
// operational pattern
mxf_write_local_tag(pb, 16, 0x3B09);
- put_buffer(pb, op1a_ul, 16);
+ avio_put_buffer(pb, op1a_ul, 16);
// write essence_container_refs
mxf_write_local_tag(pb, 8 + 16 * mxf->essence_container_count, 0x3B0A);
@@ -481,7 +481,7 @@ static void mxf_write_preface(AVFormatContext *s)
// write dm_scheme_refs
mxf_write_local_tag(pb, 8, 0x3B0B);
- put_be64(pb, 0);
+ avio_put_be64(pb, 0);
}
/*
@@ -492,7 +492,7 @@ static void mxf_write_local_tag_utf16(ByteIOContext *pb, int tag, const char *va
int i, size = strlen(value);
mxf_write_local_tag(pb, size*2, tag);
for (i = 0; i < size; i++)
- put_be16(pb, value[i]);
+ avio_put_be16(pb, value[i]);
}
static void mxf_write_identification(AVFormatContext *s)
@@ -531,7 +531,7 @@ static void mxf_write_identification(AVFormatContext *s)
// modification date
mxf_write_local_tag(pb, 8, 0x3C06);
- put_be64(pb, mxf->timestamp);
+ avio_put_be64(pb, mxf->timestamp);
}
static void mxf_write_content_storage(AVFormatContext *s)
@@ -576,22 +576,22 @@ static void mxf_write_track(AVFormatContext *s, AVStream *st, enum MXFMetadataSe
// write track id
mxf_write_local_tag(pb, 4, 0x4801);
- put_be32(pb, st->index+2);
+ avio_put_be32(pb, st->index+2);
// write track number
mxf_write_local_tag(pb, 4, 0x4804);
if (type == MaterialPackage)
- put_be32(pb, 0); // track number of material package is 0
+ avio_put_be32(pb, 0); // track number of material package is 0
else
- put_buffer(pb, sc->track_essence_element_key + 12, 4);
+ avio_put_buffer(pb, sc->track_essence_element_key + 12, 4);
mxf_write_local_tag(pb, 8, 0x4B01);
- put_be32(pb, mxf->time_base.den);
- put_be32(pb, mxf->time_base.num);
+ avio_put_be32(pb, mxf->time_base.den);
+ avio_put_be32(pb, mxf->time_base.num);
// write origin
mxf_write_local_tag(pb, 8, 0x4B02);
- put_be64(pb, 0);
+ avio_put_be64(pb, 0);
// write sequence refs
mxf_write_local_tag(pb, 16, 0x4803);
@@ -608,15 +608,15 @@ static void mxf_write_common_fields(AVFormatContext *s, AVStream *st)
// find data define uls
mxf_write_local_tag(pb, 16, 0x0201);
if (st == mxf->timecode_track)
- put_buffer(pb, smpte_12m_timecode_track_data_ul, 16);
+ avio_put_buffer(pb, smpte_12m_timecode_track_data_ul, 16);
else {
const MXFCodecUL *data_def_ul = mxf_get_data_definition_ul(st->codec->codec_type);
- put_buffer(pb, data_def_ul->uid, 16);
+ avio_put_buffer(pb, data_def_ul->uid, 16);
}
// write duration
mxf_write_local_tag(pb, 8, 0x0202);
- put_be64(pb, mxf->duration);
+ avio_put_be64(pb, mxf->duration);
}
static void mxf_write_sequence(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
@@ -664,15 +664,15 @@ static void mxf_write_timecode_component(AVFormatContext *s, AVStream *st, enum
// Start Time Code
mxf_write_local_tag(pb, 8, 0x1501);
- put_be64(pb, mxf->timecode_start);
+ avio_put_be64(pb, mxf->timecode_start);
// Rounded Time Code Base
mxf_write_local_tag(pb, 2, 0x1502);
- put_be16(pb, mxf->timecode_base);
+ avio_put_be16(pb, mxf->timecode_base);
// Drop Frame
mxf_write_local_tag(pb, 1, 0x1503);
- put_byte(pb, mxf->timecode_drop_frame);
+ avio_put_byte(pb, mxf->timecode_drop_frame);
}
static void mxf_write_structural_component(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
@@ -693,22 +693,22 @@ static void mxf_write_structural_component(AVFormatContext *s, AVStream *st, enu
// write start_position
mxf_write_local_tag(pb, 8, 0x1201);
- put_be64(pb, 0);
+ avio_put_be64(pb, 0);
// write source package uid, end of the reference
mxf_write_local_tag(pb, 32, 0x1101);
if (type == SourcePackage) {
for (i = 0; i < 4; i++)
- put_be64(pb, 0);
+ avio_put_be64(pb, 0);
} else
mxf_write_umid(s, 1);
// write source track id
mxf_write_local_tag(pb, 4, 0x1102);
if (type == SourcePackage)
- put_be32(pb, 0);
+ avio_put_be32(pb, 0);
else
- put_be32(pb, st->index+2);
+ avio_put_be32(pb, st->index+2);
}
static void mxf_write_multi_descriptor(AVFormatContext *s)
@@ -728,8 +728,8 @@ static void mxf_write_multi_descriptor(AVFormatContext *s)
// write sample rate
mxf_write_local_tag(pb, 8, 0x3001);
- put_be32(pb, mxf->time_base.den);
- put_be32(pb, mxf->time_base.num);
+ avio_put_be32(pb, mxf->time_base.den);
+ avio_put_be32(pb, mxf->time_base.num);
// write essence container ul
mxf_write_local_tag(pb, 16, 0x3004);
@@ -739,7 +739,7 @@ static void mxf_write_multi_descriptor(AVFormatContext *s)
MXFStreamContext *sc = s->streams[0]->priv_data;
ul = mxf_essence_container_uls[sc->index].container_ul;
}
- put_buffer(pb, ul, 16);
+ avio_put_buffer(pb, ul, 16);
// write sub descriptor refs
mxf_write_local_tag(pb, s->nb_streams * 16 + 8, 0x3F01);
@@ -754,21 +754,21 @@ static void mxf_write_generic_desc(AVFormatContext *s, AVStream *st, const UID k
MXFStreamContext *sc = st->priv_data;
ByteIOContext *pb = s->pb;
- put_buffer(pb, key, 16);
+ avio_put_buffer(pb, key, 16);
klv_encode_ber4_length(pb, size+20+8+12+20);
mxf_write_local_tag(pb, 16, 0x3C0A);
mxf_write_uuid(pb, SubDescriptor, st->index);
mxf_write_local_tag(pb, 4, 0x3006);
- put_be32(pb, st->index+2);
+ avio_put_be32(pb, st->index+2);
mxf_write_local_tag(pb, 8, 0x3001);
- put_be32(pb, mxf->time_base.den);
- put_be32(pb, mxf->time_base.num);
+ avio_put_be32(pb, mxf->time_base.den);
+ avio_put_be32(pb, mxf->time_base.num);
mxf_write_local_tag(pb, 16, 0x3004);
- put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
+ avio_put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
}
static const UID mxf_mpegvideo_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 };
@@ -788,13 +788,13 @@ static void mxf_write_cdci_common(AVFormatContext *s, AVStream *st, const UID ke
mxf_write_generic_desc(s, st, key, size+8+8+8+8+8+8+5+16+sc->interlaced*4+12+20);
mxf_write_local_tag(pb, 4, 0x3203);
- put_be32(pb, st->codec->width);
+ avio_put_be32(pb, st->codec->width);
mxf_write_local_tag(pb, 4, 0x3202);
- put_be32(pb, stored_height>>sc->interlaced);
+ avio_put_be32(pb, stored_height>>sc->interlaced);
mxf_write_local_tag(pb, 4, 0x3209);
- put_be32(pb, st->codec->width);
+ avio_put_be32(pb, st->codec->width);
if (st->codec->height == 608) // PAL + VBI
display_height = 576;
@@ -804,19 +804,19 @@ static void mxf_write_cdci_common(AVFormatContext *s, AVStream *st, const UID ke
display_height = st->codec->height;
mxf_write_local_tag(pb, 4, 0x3208);
- put_be32(pb, display_height>>sc->interlaced);
+ avio_put_be32(pb, display_height>>sc->interlaced);
// component depth
mxf_write_local_tag(pb, 4, 0x3301);
- put_be32(pb, 8);
+ avio_put_be32(pb, 8);
// horizontal subsampling
mxf_write_local_tag(pb, 4, 0x3302);
- put_be32(pb, 2);
+ avio_put_be32(pb, 2);
// frame layout
mxf_write_local_tag(pb, 1, 0x320C);
- put_byte(pb, sc->interlaced);
+ avio_put_byte(pb, sc->interlaced);
// video line map
switch (st->codec->height) {
@@ -835,18 +835,18 @@ static void mxf_write_cdci_common(AVFormatContext *s, AVStream *st, const UID ke
}
mxf_write_local_tag(pb, 12+sc->interlaced*4, 0x320D);
- put_be32(pb, sc->interlaced ? 2 : 1);
- put_be32(pb, 4);
- put_be32(pb, f1);
+ avio_put_be32(pb, sc->interlaced ? 2 : 1);
+ avio_put_be32(pb, 4);
+ avio_put_be32(pb, f1);
if (sc->interlaced)
- put_be32(pb, f2);
+ avio_put_be32(pb, f2);
mxf_write_local_tag(pb, 8, 0x320E);
- put_be32(pb, sc->aspect_ratio.num);
- put_be32(pb, sc->aspect_ratio.den);
+ avio_put_be32(pb, sc->aspect_ratio.num);
+ avio_put_be32(pb, sc->aspect_ratio.den);
mxf_write_local_tag(pb, 16, 0x3201);
- put_buffer(pb, *sc->codec_ul, 16);
+ avio_put_buffer(pb, *sc->codec_ul, 16);
}
static void mxf_write_cdci_desc(AVFormatContext *s, AVStream *st)
@@ -863,13 +863,13 @@ static void mxf_write_mpegvideo_desc(AVFormatContext *s, AVStream *st)
// bit rate
mxf_write_local_tag(pb, 4, 0x8000);
- put_be32(pb, st->codec->bit_rate);
+ avio_put_be32(pb, st->codec->bit_rate);
// profile and level
mxf_write_local_tag(pb, 1, 0x8007);
if (!st->codec->profile)
profile_and_level |= 0x80; // escape bit
- put_byte(pb, profile_and_level);
+ avio_put_byte(pb, profile_and_level);
}
static void mxf_write_generic_sound_common(AVFormatContext *s, AVStream *st, const UID key, unsigned size)
@@ -880,18 +880,18 @@ static void mxf_write_generic_sound_common(AVFormatContext *s, AVStream *st, con
// audio locked
mxf_write_local_tag(pb, 1, 0x3D02);
- put_byte(pb, 1);
+ avio_put_byte(pb, 1);
// write audio sampling rate
mxf_write_local_tag(pb, 8, 0x3D03);
- put_be32(pb, st->codec->sample_rate);
- put_be32(pb, 1);
+ avio_put_be32(pb, st->codec->sample_rate);
+ avio_put_be32(pb, 1);
mxf_write_local_tag(pb, 4, 0x3D07);
- put_be32(pb, st->codec->channels);
+ avio_put_be32(pb, st->codec->channels);
mxf_write_local_tag(pb, 4, 0x3D01);
- put_be32(pb, av_get_bits_per_sample(st->codec->codec_id));
+ avio_put_be32(pb, av_get_bits_per_sample(st->codec->codec_id));
}
static void mxf_write_wav_common(AVFormatContext *s, AVStream *st, const UID key, unsigned size)
@@ -901,11 +901,11 @@ static void mxf_write_wav_common(AVFormatContext *s, AVStream *st, const UID key
mxf_write_generic_sound_common(s, st, key, size+6+8);
mxf_write_local_tag(pb, 2, 0x3D0A);
- put_be16(pb, st->codec->block_align);
+ avio_put_be16(pb, st->codec->block_align);
// avg bytes per sec
mxf_write_local_tag(pb, 4, 0x3D09);
- put_be32(pb, st->codec->block_align*st->codec->sample_rate);
+ avio_put_be32(pb, st->codec->block_align*st->codec->sample_rate);
}
static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st)
@@ -952,11 +952,11 @@ static void mxf_write_package(AVFormatContext *s, enum MXFMetadataSetType type)
// package creation date
mxf_write_local_tag(pb, 8, 0x4405);
- put_be64(pb, mxf->timestamp);
+ avio_put_be64(pb, mxf->timestamp);
// package modified date
mxf_write_local_tag(pb, 8, 0x4404);
- put_be64(pb, mxf->timestamp);
+ avio_put_be64(pb, mxf->timestamp);
// write track refs
mxf_write_local_tag(pb, track_count*16 + 8, 0x4403);
@@ -1008,10 +1008,10 @@ static int mxf_write_essence_container_data(AVFormatContext *s)
mxf_write_umid(s, 1);
mxf_write_local_tag(pb, 4, 0x3F07); // BodySID
- put_be32(pb, 1);
+ avio_put_be32(pb, 1);
mxf_write_local_tag(pb, 4, 0x3F06); // IndexSID
- put_be32(pb, 2);
+ avio_put_be32(pb, 2);
return 0;
}
@@ -1048,7 +1048,7 @@ static void mxf_write_index_table_segment(AVFormatContext *s)
if (!mxf->edit_units_count && !mxf->edit_unit_byte_count)
return;
- put_buffer(pb, index_table_segment_key, 16);
+ avio_put_buffer(pb, index_table_segment_key, 16);
if (mxf->edit_unit_byte_count) {
klv_encode_ber_length(pb, 80);
@@ -1063,65 +1063,65 @@ static void mxf_write_index_table_segment(AVFormatContext *s)
// index edit rate
mxf_write_local_tag(pb, 8, 0x3F0B);
- put_be32(pb, mxf->time_base.den);
- put_be32(pb, mxf->time_base.num);
+ avio_put_be32(pb, mxf->time_base.den);
+ avio_put_be32(pb, mxf->time_base.num);
// index start position
mxf_write_local_tag(pb, 8, 0x3F0C);
- put_be64(pb, mxf->last_indexed_edit_unit);
+ avio_put_be64(pb, mxf->last_indexed_edit_unit);
// index duration
mxf_write_local_tag(pb, 8, 0x3F0D);
if (mxf->edit_unit_byte_count)
- put_be64(pb, 0); // index table covers whole container
+ avio_put_be64(pb, 0); // index table covers whole container
else
- put_be64(pb, mxf->edit_units_count);
+ avio_put_be64(pb, mxf->edit_units_count);
// edit unit byte count
mxf_write_local_tag(pb, 4, 0x3F05);
- put_be32(pb, mxf->edit_unit_byte_count);
+ avio_put_be32(pb, mxf->edit_unit_byte_count);
// index sid
mxf_write_local_tag(pb, 4, 0x3F06);
- put_be32(pb, 2);
+ avio_put_be32(pb, 2);
// body sid
mxf_write_local_tag(pb, 4, 0x3F07);
- put_be32(pb, 1);
+ avio_put_be32(pb, 1);
if (!mxf->edit_unit_byte_count) {
// real slice count - 1
mxf_write_local_tag(pb, 1, 0x3F08);
- put_byte(pb, mxf->slice_count);
+ avio_put_byte(pb, mxf->slice_count);
// delta entry array
mxf_write_local_tag(pb, 8 + (s->nb_streams+1)*6, 0x3F09);
- put_be32(pb, s->nb_streams+1); // num of entries
- put_be32(pb, 6); // size of one entry
+ avio_put_be32(pb, s->nb_streams+1); // num of entries
+ avio_put_be32(pb, 6); // size of one entry
// write system item delta entry
- put_byte(pb, 0);
- put_byte(pb, 0); // slice entry
- put_be32(pb, 0); // element delta
+ avio_put_byte(pb, 0);
+ avio_put_byte(pb, 0); // slice entry
+ avio_put_be32(pb, 0); // element delta
for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i];
MXFStreamContext *sc = st->priv_data;
- put_byte(pb, sc->temporal_reordering);
+ avio_put_byte(pb, sc->temporal_reordering);
if (sc->temporal_reordering)
temporal_reordering = 1;
if (i == 0) { // video track
- put_byte(pb, 0); // slice number
- put_be32(pb, KAG_SIZE); // system item size including klv fill
+ avio_put_byte(pb, 0); // slice number
+ avio_put_be32(pb, KAG_SIZE); // system item size including klv fill
} else { // audio track
unsigned audio_frame_size = sc->aic.samples[0]*sc->aic.sample_size;
audio_frame_size += klv_fill_size(audio_frame_size);
- put_byte(pb, 1);
- put_be32(pb, (i-1)*audio_frame_size); // element delta
+ avio_put_byte(pb, 1);
+ avio_put_be32(pb, (i-1)*audio_frame_size); // element delta
}
}
mxf_write_local_tag(pb, 8 + mxf->edit_units_count*(11+mxf->slice_count*4), 0x3F0A);
- put_be32(pb, mxf->edit_units_count); // num of entries
- put_be32(pb, 11+mxf->slice_count*4); // size of one entry
+ avio_put_be32(pb, mxf->edit_units_count); // num of entries
+ avio_put_be32(pb, 11+mxf->slice_count*4); // size of one entry
for (i = 0; i < mxf->edit_units_count; i++) {
int temporal_offset = 0;
@@ -1143,12 +1143,12 @@ static void mxf_write_index_table_segment(AVFormatContext *s)
temporal_offset = j - key_index - pic_num_in_gop;
}
}
- put_byte(pb, temporal_offset);
+ avio_put_byte(pb, temporal_offset);
if ((mxf->index_entries[i].flags & 0x30) == 0x30) { // back and forward prediction
- put_byte(pb, mxf->last_key_index - i);
+ avio_put_byte(pb, mxf->last_key_index - i);
} else {
- put_byte(pb, key_index - i); // key frame offset
+ avio_put_byte(pb, key_index - i); // key frame offset
if ((mxf->index_entries[i].flags & 0x20) == 0x20) // only forward
mxf->last_key_index = key_index;
}
@@ -1156,11 +1156,11 @@ static void mxf_write_index_table_segment(AVFormatContext *s)
if (!(mxf->index_entries[i].flags & 0x33) && // I frame
mxf->index_entries[i].flags & 0x40 && !temporal_offset)
mxf->index_entries[i].flags |= 0x80; // random access
- put_byte(pb, mxf->index_entries[i].flags);
+ avio_put_byte(pb, mxf->index_entries[i].flags);
// stream offset
- put_be64(pb, mxf->index_entries[i].offset);
+ avio_put_be64(pb, mxf->index_entries[i].offset);
if (s->nb_streams > 1)
- put_be32(pb, mxf->index_entries[i].slice_offset);
+ avio_put_be32(pb, mxf->index_entries[i].slice_offset);
}
mxf->last_key_index = key_index - mxf->edit_units_count;
@@ -1173,11 +1173,11 @@ static void mxf_write_klv_fill(AVFormatContext *s)
{
unsigned pad = klv_fill_size(url_ftell(s->pb));
if (pad) {
- put_buffer(s->pb, klv_fill_key, 16);
+ avio_put_buffer(s->pb, klv_fill_key, 16);
pad -= 16 + 4;
klv_encode_ber4_length(s->pb, pad);
for (; pad; pad--)
- put_byte(s->pb, 0);
+ avio_put_byte(s->pb, 0);
assert(!(url_ftell(s->pb) & (KAG_SIZE-1)));
}
}
@@ -1213,43 +1213,43 @@ static void mxf_write_partition(AVFormatContext *s, int bodysid,
}
// write klv
- put_buffer(pb, key, 16);
+ avio_put_buffer(pb, key, 16);
klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count);
// write partition value
- put_be16(pb, 1); // majorVersion
- put_be16(pb, 2); // minorVersion
- put_be32(pb, KAG_SIZE); // KAGSize
+ avio_put_be16(pb, 1); // majorVersion
+ avio_put_be16(pb, 2); // minorVersion
+ avio_put_be32(pb, KAG_SIZE); // KAGSize
- put_be64(pb, partition_offset); // ThisPartition
+ avio_put_be64(pb, partition_offset); // ThisPartition
if (!memcmp(key, body_partition_key, 16) && mxf->body_partitions_count > 1)
- put_be64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]); // PreviousPartition
+ avio_put_be64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]); // PreviousPartition
else if (!memcmp(key, footer_partition_key, 16) && mxf->body_partitions_count)
- put_be64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]); // PreviousPartition
+ avio_put_be64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]); // PreviousPartition
else
- put_be64(pb, 0);
+ avio_put_be64(pb, 0);
- put_be64(pb, mxf->footer_partition_offset); // footerPartition
+ avio_put_be64(pb, mxf->footer_partition_offset); // footerPartition
// set offset
header_byte_count_offset = url_ftell(pb);
- put_be64(pb, 0); // headerByteCount, update later
+ avio_put_be64(pb, 0); // headerByteCount, update later
// indexTable
- put_be64(pb, index_byte_count); // indexByteCount
- put_be32(pb, index_byte_count ? indexsid : 0); // indexSID
+ avio_put_be64(pb, index_byte_count); // indexByteCount
+ avio_put_be32(pb, index_byte_count ? indexsid : 0); // indexSID
// BodyOffset
if (bodysid && mxf->edit_units_count && mxf->body_partitions_count) {
- put_be64(pb, mxf->body_offset);
+ avio_put_be64(pb, mxf->body_offset);
} else
- put_be64(pb, 0);
+ avio_put_be64(pb, 0);
- put_be32(pb, bodysid); // bodySID
+ avio_put_be32(pb, bodysid); // bodySID
// operational pattern
- put_buffer(pb, op1a_ul, 16);
+ avio_put_buffer(pb, op1a_ul, 16);
// essence container
mxf_write_essence_container_refs(s);
@@ -1268,7 +1268,7 @@ static void mxf_write_partition(AVFormatContext *s, int bodysid,
// update header_byte_count
url_fseek(pb, header_byte_count_offset, SEEK_SET);
- put_be64(pb, header_byte_count);
+ avio_put_be64(pb, header_byte_count);
url_fseek(pb, pos, SEEK_SET);
}
@@ -1564,34 +1564,34 @@ static void mxf_write_system_item(AVFormatContext *s)
frame = mxf->timecode_start + mxf->last_indexed_edit_unit + mxf->edit_units_count;
// write system metadata pack
- put_buffer(pb, system_metadata_pack_key, 16);
+ avio_put_buffer(pb, system_metadata_pack_key, 16);
klv_encode_ber4_length(pb, 57);
- put_byte(pb, 0x5c); // UL, user date/time stamp, picture and sound item present
- put_byte(pb, 0x04); // content package rate
- put_byte(pb, 0x00); // content package type
- put_be16(pb, 0x00); // channel handle
- put_be16(pb, frame); // continuity count
+ avio_put_byte(pb, 0x5c); // UL, user date/time stamp, picture and sound item present
+ avio_put_byte(pb, 0x04); // content package rate
+ avio_put_byte(pb, 0x00); // content package type
+ avio_put_be16(pb, 0x00); // channel handle
+ avio_put_be16(pb, frame); // continuity count
if (mxf->essence_container_count > 1)
- put_buffer(pb, multiple_desc_ul, 16);
+ avio_put_buffer(pb, multiple_desc_ul, 16);
else {
MXFStreamContext *sc = s->streams[0]->priv_data;
- put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
+ avio_put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
}
- put_byte(pb, 0);
- put_be64(pb, 0);
- put_be64(pb, 0); // creation date/time stamp
+ avio_put_byte(pb, 0);
+ avio_put_be64(pb, 0);
+ avio_put_be64(pb, 0); // creation date/time stamp
- put_byte(pb, 0x81); // SMPTE 12M time code
+ avio_put_byte(pb, 0x81); // SMPTE 12M time code
time_code = ff_framenum_to_12m_time_code(frame, mxf->timecode_drop_frame, mxf->timecode_base);
- put_be32(pb, time_code);
- put_be32(pb, 0); // binary group data
- put_be64(pb, 0);
+ avio_put_be32(pb, time_code);
+ avio_put_be32(pb, 0); // binary group data
+ avio_put_be64(pb, 0);
// write system metadata package set
- put_buffer(pb, system_metadata_package_set_key, 16);
+ avio_put_buffer(pb, system_metadata_package_set_key, 16);
klv_encode_ber4_length(pb, 35);
- put_byte(pb, 0x83); // UMID
- put_be16(pb, 0x20);
+ avio_put_byte(pb, 0x83); // UMID
+ avio_put_be16(pb, 0x20);
mxf_write_umid(s, 1);
}
@@ -1607,21 +1607,21 @@ static void mxf_write_d10_video_packet(AVFormatContext *s, AVStream *st, AVPacke
packet_size += klv_fill_size(packet_size);
klv_encode_ber4_length(pb, pkt->size);
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_buffer(pb, pkt->data, pkt->size);
// ensure CBR muxing by padding to correct video frame size
pad = packet_size - pkt->size - 16 - 4;
if (pad > 20) {
- put_buffer(s->pb, klv_fill_key, 16);
+ avio_put_buffer(s->pb, klv_fill_key, 16);
pad -= 16 + 4;
klv_encode_ber4_length(s->pb, pad);
for (; pad; pad--)
- put_byte(s->pb, 0);
+ avio_put_byte(s->pb, 0);
assert(!(url_ftell(s->pb) & (KAG_SIZE-1)));
} else {
av_log(s, AV_LOG_WARNING, "cannot fill d-10 video packet\n");
for (; pad > 0; pad--)
- put_byte(s->pb, 0);
+ avio_put_byte(s->pb, 0);
}
}
@@ -1636,9 +1636,9 @@ static void mxf_write_d10_audio_packet(AVFormatContext *s, AVStream *st, AVPacke
klv_encode_ber4_length(pb, 4 + frame_size*4*8);
- put_byte(pb, (frame_size == 1920 ? 0 : (mxf->edit_units_count-1) % 5 + 1));
- put_le16(pb, frame_size);
- put_byte(pb, (1<<st->codec->channels)-1);
+ avio_put_byte(pb, (frame_size == 1920 ? 0 : (mxf->edit_units_count-1) % 5 + 1));
+ avio_put_le16(pb, frame_size);
+ avio_put_byte(pb, (1<<st->codec->channels)-1);
while (samples < end) {
for (i = 0; i < st->codec->channels; i++) {
@@ -1650,10 +1650,10 @@ static void mxf_write_d10_audio_packet(AVFormatContext *s, AVStream *st, AVPacke
sample = AV_RL16(samples)<<12;
samples += 2;
}
- put_le32(pb, sample | i);
+ avio_put_le32(pb, sample | i);
}
for (; i < 8; i++)
- put_le32(pb, i);
+ avio_put_le32(pb, i);
}
}
@@ -1719,7 +1719,7 @@ static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
}
mxf_write_klv_fill(s);
- put_buffer(pb, sc->track_essence_element_key, 16); // write key
+ avio_put_buffer(pb, sc->track_essence_element_key, 16); // write key
if (s->oformat == &ff_mxf_d10_muxer) {
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
mxf_write_d10_video_packet(s, st, pkt);
@@ -1727,7 +1727,7 @@ static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
mxf_write_d10_audio_packet(s, st, pkt);
} else {
klv_encode_ber4_length(pb, pkt->size); // write length
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_buffer(pb, pkt->data, pkt->size);
mxf->body_offset += 16+4+pkt->size + klv_fill_size(16+4+pkt->size);
}
@@ -1743,24 +1743,24 @@ static void mxf_write_random_index_pack(AVFormatContext *s)
uint64_t pos = url_ftell(pb);
int i;
- put_buffer(pb, random_index_pack_key, 16);
+ avio_put_buffer(pb, random_index_pack_key, 16);
klv_encode_ber_length(pb, 28 + 12*mxf->body_partitions_count);
if (mxf->edit_unit_byte_count)
- put_be32(pb, 1); // BodySID of header partition
+ avio_put_be32(pb, 1); // BodySID of header partition
else
- put_be32(pb, 0);
- put_be64(pb, 0); // offset of header partition
+ avio_put_be32(pb, 0);
+ avio_put_be64(pb, 0); // offset of header partition
for (i = 0; i < mxf->body_partitions_count; i++) {
- put_be32(pb, 1); // BodySID
- put_be64(pb, mxf->body_partition_offset[i]);
+ avio_put_be32(pb, 1); // BodySID
+ avio_put_be64(pb, mxf->body_partition_offset[i]);
}
- put_be32(pb, 0); // BodySID of footer partition
- put_be64(pb, mxf->footer_partition_offset);
+ avio_put_be32(pb, 0); // BodySID of footer partition
+ avio_put_be64(pb, mxf->footer_partition_offset);
- put_be32(pb, url_ftell(pb) - pos + 4);
+ avio_put_be32(pb, url_ftell(pb) - pos + 4);
}
static int mxf_write_footer(AVFormatContext *s)
diff --git a/libavformat/nutenc.c b/libavformat/nutenc.c
index 288e4bd..43d2751 100644
--- a/libavformat/nutenc.c
+++ b/libavformat/nutenc.c
@@ -254,7 +254,7 @@ static void put_str(ByteIOContext *bc, const char *string){
int len= strlen(string);
ff_put_v(bc, len);
- put_buffer(bc, string, len);
+ avio_put_buffer(bc, string, len);
}
static void put_s(ByteIOContext *bc, int64_t val){
@@ -285,16 +285,16 @@ static void put_packet(NUTContext *nut, ByteIOContext *bc, ByteIOContext *dyn_bc
if(forw_ptr > 4096)
init_checksum(bc, ff_crc04C11DB7_update, 0);
- put_be64(bc, startcode);
+ avio_put_be64(bc, startcode);
ff_put_v(bc, forw_ptr);
if(forw_ptr > 4096)
- put_le32(bc, get_checksum(bc));
+ avio_put_le32(bc, get_checksum(bc));
if(calculate_checksum)
init_checksum(bc, ff_crc04C11DB7_update, 0);
- put_buffer(bc, dyn_buf, dyn_size);
+ avio_put_buffer(bc, dyn_buf, dyn_size);
if(calculate_checksum)
- put_le32(bc, get_checksum(bc));
+ avio_put_le32(bc, get_checksum(bc));
av_free(dyn_buf);
}
@@ -366,7 +366,7 @@ static void write_mainheader(NUTContext *nut, ByteIOContext *bc){
ff_put_v(bc, nut->header_count-1);
for(i=1; i<nut->header_count; i++){
ff_put_v(bc, nut->header_len[i]);
- put_buffer(bc, nut->header[i], nut->header_len[i]);
+ avio_put_buffer(bc, nut->header[i], nut->header_len[i]);
}
}
@@ -382,7 +382,7 @@ static int write_streamheader(AVFormatContext *avctx, ByteIOContext *bc, AVStrea
}
ff_put_v(bc, 4);
if (codec->codec_tag){
- put_le32(bc, codec->codec_tag);
+ avio_put_le32(bc, codec->codec_tag);
} else {
av_log(avctx, AV_LOG_ERROR, "No codec tag defined for stream %d\n", i);
return AVERROR(EINVAL);
@@ -392,10 +392,10 @@ static int write_streamheader(AVFormatContext *avctx, ByteIOContext *bc, AVStrea
ff_put_v(bc, nut->stream[i].msb_pts_shift);
ff_put_v(bc, nut->stream[i].max_pts_distance);
ff_put_v(bc, codec->has_b_frames);
- put_byte(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */
+ avio_put_byte(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */
ff_put_v(bc, codec->extradata_size);
- put_buffer(bc, codec->extradata, codec->extradata_size);
+ avio_put_buffer(bc, codec->extradata, codec->extradata_size);
switch(codec->codec_type){
case AVMEDIA_TYPE_AUDIO:
@@ -450,7 +450,7 @@ static int write_globalinfo(NUTContext *nut, ByteIOContext *bc){
ff_put_v(bc, count);
dyn_size= url_close_dyn_buf(dyn_bc, &dyn_buf);
- put_buffer(bc, dyn_buf, dyn_size);
+ avio_put_buffer(bc, dyn_buf, dyn_size);
av_free(dyn_buf);
return 0;
}
@@ -479,7 +479,7 @@ static int write_streaminfo(NUTContext *nut, ByteIOContext *bc, int stream_id){
ff_put_v(bc, count);
- put_buffer(bc, dyn_buf, dyn_size);
+ avio_put_buffer(bc, dyn_buf, dyn_size);
}
av_free(dyn_buf);
@@ -575,8 +575,8 @@ static int write_header(AVFormatContext *s){
build_frame_code(s);
assert(nut->frame_code['N'].flags == FLAG_INVALID);
- put_buffer(bc, ID_STRING, strlen(ID_STRING));
- put_byte(bc, 0);
+ avio_put_buffer(bc, ID_STRING, strlen(ID_STRING));
+ avio_put_byte(bc, 0);
if ((ret = write_headers(s, bc)) < 0)
return ret;
@@ -749,7 +749,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt){
header_idx= fc->header_idx;
init_checksum(bc, ff_crc04C11DB7_update, 0);
- put_byte(bc, frame_code);
+ avio_put_byte(bc, frame_code);
if(flags & FLAG_CODED){
ff_put_v(bc, (flags^needed_flags) & ~(FLAG_CODED));
flags = needed_flags;
@@ -759,10 +759,10 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt){
if(flags & FLAG_SIZE_MSB) ff_put_v(bc, pkt->size / fc->size_mul);
if(flags & FLAG_HEADER_IDX) ff_put_v(bc, header_idx= best_header_idx);
- if(flags & FLAG_CHECKSUM) put_le32(bc, get_checksum(bc));
+ if(flags & FLAG_CHECKSUM) avio_put_le32(bc, get_checksum(bc));
else get_checksum(bc);
- put_buffer(bc, pkt->data + nut->header_len[header_idx], pkt->size - nut->header_len[header_idx]);
+ avio_put_buffer(bc, pkt->data + nut->header_len[header_idx], pkt->size - nut->header_len[header_idx]);
nus->last_flags= flags;
nus->last_pts= pkt->pts;
diff --git a/libavformat/oggenc.c b/libavformat/oggenc.c
index 4c2a9d6..4361876 100644
--- a/libavformat/oggenc.c
+++ b/libavformat/oggenc.c
@@ -69,7 +69,7 @@ static void ogg_update_checksum(AVFormatContext *s, ByteIOContext *pb, int64_t c
int64_t pos = url_ftell(pb);
uint32_t checksum = get_checksum(pb);
url_fseek(pb, crc_offset, SEEK_SET);
- put_be32(pb, checksum);
+ avio_put_be32(pb, checksum);
url_fseek(pb, pos, SEEK_SET);
}
@@ -85,17 +85,17 @@ static int ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)
if (ret < 0)
return ret;
init_checksum(pb, ff_crc04C11DB7_update, 0);
- put_tag(pb, "OggS");
- put_byte(pb, 0);
- put_byte(pb, page->flags | extra_flags);
- put_le64(pb, page->granule);
- put_le32(pb, oggstream->serial_num);
- put_le32(pb, oggstream->page_counter++);
+ avio_put_tag(pb, "OggS");
+ avio_put_byte(pb, 0);
+ avio_put_byte(pb, page->flags | extra_flags);
+ avio_put_le64(pb, page->granule);
+ avio_put_le32(pb, oggstream->serial_num);
+ avio_put_le32(pb, oggstream->page_counter++);
crc_offset = url_ftell(pb);
- put_le32(pb, 0); // crc
- put_byte(pb, page->segments_count);
- put_buffer(pb, page->segments, page->segments_count);
- put_buffer(pb, page->data, page->size);
+ avio_put_le32(pb, 0); // crc
+ avio_put_byte(pb, page->segments_count);
+ avio_put_buffer(pb, page->segments, page->segments_count);
+ avio_put_buffer(pb, page->data, page->size);
ogg_update_checksum(s, pb, crc_offset);
put_flush_packet(pb);
@@ -104,7 +104,7 @@ static int ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)
if (size < 0)
return size;
- put_buffer(s->pb, buf, size);
+ avio_put_buffer(s->pb, buf, size);
put_flush_packet(s->pb);
av_free(buf);
oggstream->page_count--;
diff --git a/libavformat/rawenc.c b/libavformat/rawenc.c
index 6f9fdce..769c037 100644
--- a/libavformat/rawenc.c
+++ b/libavformat/rawenc.c
@@ -25,7 +25,7 @@
int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)
{
- put_buffer(s->pb, pkt->data, pkt->size);
+ avio_put_buffer(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb);
return 0;
}
diff --git a/libavformat/riff.c b/libavformat/riff.c
index 4edccce..27e6e7b 100644
--- a/libavformat/riff.c
+++ b/libavformat/riff.c
@@ -321,8 +321,8 @@ const AVCodecTag ff_codec_wav_tags[] = {
#if CONFIG_MUXERS
int64_t ff_start_tag(ByteIOContext *pb, const char *tag)
{
- put_tag(pb, tag);
- put_le32(pb, 0);
+ avio_put_tag(pb, tag);
+ avio_put_le32(pb, 0);
return url_ftell(pb);
}
@@ -332,7 +332,7 @@ void ff_end_tag(ByteIOContext *pb, int64_t start)
pos = url_ftell(pb);
url_fseek(pb, start - 4, SEEK_SET);
- put_le32(pb, (uint32_t)(pos - start));
+ avio_put_le32(pb, (uint32_t)(pos - start));
url_fseek(pb, pos, SEEK_SET);
}
@@ -354,12 +354,12 @@ int ff_put_wav_header(ByteIOContext *pb, AVCodecContext *enc)
|| av_get_bits_per_sample(enc->codec_id) > 16;
if (waveformatextensible) {
- put_le16(pb, 0xfffe);
+ avio_put_le16(pb, 0xfffe);
} else {
- put_le16(pb, enc->codec_tag);
+ avio_put_le16(pb, enc->codec_tag);
}
- put_le16(pb, enc->channels);
- put_le32(pb, enc->sample_rate);
+ avio_put_le16(pb, enc->channels);
+ avio_put_le32(pb, enc->sample_rate);
if (enc->codec_id == CODEC_ID_MP2 || enc->codec_id == CODEC_ID_MP3 || enc->codec_id == CODEC_ID_GSM_MS) {
bps = 0;
} else if (enc->codec_id == CODEC_ID_ADPCM_G726) {
@@ -393,9 +393,9 @@ int ff_put_wav_header(ByteIOContext *pb, AVCodecContext *enc)
} else {
bytespersec = enc->bit_rate / 8;
}
- put_le32(pb, bytespersec); /* bytes per second */
- put_le16(pb, blkalign); /* block align */
- put_le16(pb, bps); /* bits per sample */
+ avio_put_le32(pb, bytespersec); /* bytes per second */
+ avio_put_le16(pb, blkalign); /* block align */
+ avio_put_le16(pb, bps); /* bits per sample */
if (enc->codec_id == CODEC_ID_MP3) {
hdrsize += 12;
bytestream_put_le16(&riff_extradata, 1); /* wID */
@@ -425,20 +425,20 @@ int ff_put_wav_header(ByteIOContext *pb, AVCodecContext *enc)
}
if(waveformatextensible) { /* write WAVEFORMATEXTENSIBLE extensions */
hdrsize += 22;
- put_le16(pb, riff_extradata - riff_extradata_start + 22); /* 22 is WAVEFORMATEXTENSIBLE size */
- put_le16(pb, enc->bits_per_coded_sample); /* ValidBitsPerSample || SamplesPerBlock || Reserved */
- put_le32(pb, enc->channel_layout); /* dwChannelMask */
- put_le32(pb, enc->codec_tag); /* GUID + next 3 */
- put_le32(pb, 0x00100000);
- put_le32(pb, 0xAA000080);
- put_le32(pb, 0x719B3800);
+ avio_put_le16(pb, riff_extradata - riff_extradata_start + 22); /* 22 is WAVEFORMATEXTENSIBLE size */
+ avio_put_le16(pb, enc->bits_per_coded_sample); /* ValidBitsPerSample || SamplesPerBlock || Reserved */
+ avio_put_le32(pb, enc->channel_layout); /* dwChannelMask */
+ avio_put_le32(pb, enc->codec_tag); /* GUID + next 3 */
+ avio_put_le32(pb, 0x00100000);
+ avio_put_le32(pb, 0xAA000080);
+ avio_put_le32(pb, 0x719B3800);
} else if(riff_extradata - riff_extradata_start) {
- put_le16(pb, riff_extradata - riff_extradata_start);
+ avio_put_le16(pb, riff_extradata - riff_extradata_start);
}
- put_buffer(pb, riff_extradata_start, riff_extradata - riff_extradata_start);
+ avio_put_buffer(pb, riff_extradata_start, riff_extradata - riff_extradata_start);
if(hdrsize&1){
hdrsize++;
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
}
return hdrsize;
@@ -447,25 +447,25 @@ int ff_put_wav_header(ByteIOContext *pb, AVCodecContext *enc)
/* BITMAPINFOHEADER header */
void ff_put_bmp_header(ByteIOContext *pb, AVCodecContext *enc, const AVCodecTag *tags, int for_asf)
{
- put_le32(pb, 40 + enc->extradata_size); /* size */
- put_le32(pb, enc->width);
+ avio_put_le32(pb, 40 + enc->extradata_size); /* size */
+ avio_put_le32(pb, enc->width);
//We always store RGB TopDown
- put_le32(pb, enc->codec_tag ? enc->height : -enc->height);
- put_le16(pb, 1); /* planes */
+ avio_put_le32(pb, enc->codec_tag ? enc->height : -enc->height);
+ avio_put_le16(pb, 1); /* planes */
- put_le16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24); /* depth */
+ avio_put_le16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24); /* depth */
/* compression type */
- put_le32(pb, enc->codec_tag);
- put_le32(pb, enc->width * enc->height * 3);
- put_le32(pb, 0);
- put_le32(pb, 0);
- put_le32(pb, 0);
- put_le32(pb, 0);
+ avio_put_le32(pb, enc->codec_tag);
+ avio_put_le32(pb, enc->width * enc->height * 3);
+ avio_put_le32(pb, 0);
+ avio_put_le32(pb, 0);
+ avio_put_le32(pb, 0);
+ avio_put_le32(pb, 0);
- put_buffer(pb, enc->extradata, enc->extradata_size);
+ avio_put_buffer(pb, enc->extradata, enc->extradata_size);
if (!for_asf && enc->extradata_size & 1)
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
}
#endif //CONFIG_MUXERS
diff --git a/libavformat/rmenc.c b/libavformat/rmenc.c
index 5670d95..22755f8 100644
--- a/libavformat/rmenc.c
+++ b/libavformat/rmenc.c
@@ -46,17 +46,17 @@ typedef struct {
static void put_str(ByteIOContext *s, const char *tag)
{
- put_be16(s,strlen(tag));
+ avio_put_be16(s,strlen(tag));
while (*tag) {
- put_byte(s, *tag++);
+ avio_put_byte(s, *tag++);
}
}
static void put_str8(ByteIOContext *s, const char *tag)
{
- put_byte(s, strlen(tag));
+ avio_put_byte(s, strlen(tag));
while (*tag) {
- put_byte(s, *tag++);
+ avio_put_byte(s, *tag++);
}
}
@@ -74,15 +74,15 @@ static int rv10_write_header(AVFormatContext *ctx,
start_ptr = s->buf_ptr;
- put_tag(s, ".RMF");
- put_be32(s,18); /* header size */
- put_be16(s,0);
- put_be32(s,0);
- put_be32(s,4 + ctx->nb_streams); /* num headers */
+ avio_put_tag(s, ".RMF");
+ avio_put_be32(s,18); /* header size */
+ avio_put_be16(s,0);
+ avio_put_be32(s,0);
+ avio_put_be32(s,4 + ctx->nb_streams); /* num headers */
- put_tag(s,"PROP");
- put_be32(s, 50);
- put_be16(s, 0);
+ avio_put_tag(s,"PROP");
+ avio_put_be32(s, 50);
+ avio_put_be16(s, 0);
packet_max_size = 0;
packet_total_size = 0;
nb_packets = 0;
@@ -100,37 +100,37 @@ static int rv10_write_header(AVFormatContext *ctx,
if (v > duration)
duration = v;
}
- put_be32(s, bit_rate); /* max bit rate */
- put_be32(s, bit_rate); /* avg bit rate */
- put_be32(s, packet_max_size); /* max packet size */
+ avio_put_be32(s, bit_rate); /* max bit rate */
+ avio_put_be32(s, bit_rate); /* avg bit rate */
+ avio_put_be32(s, packet_max_size); /* max packet size */
if (nb_packets > 0)
packet_avg_size = packet_total_size / nb_packets;
else
packet_avg_size = 0;
- put_be32(s, packet_avg_size); /* avg packet size */
- put_be32(s, nb_packets); /* num packets */
- put_be32(s, duration); /* duration */
- put_be32(s, BUFFER_DURATION); /* preroll */
- put_be32(s, index_pos); /* index offset */
+ avio_put_be32(s, packet_avg_size); /* avg packet size */
+ avio_put_be32(s, nb_packets); /* num packets */
+ avio_put_be32(s, duration); /* duration */
+ avio_put_be32(s, BUFFER_DURATION); /* preroll */
+ avio_put_be32(s, index_pos); /* index offset */
/* computation of data the data offset */
data_offset_ptr = s->buf_ptr;
- put_be32(s, 0); /* data offset : will be patched after */
- put_be16(s, ctx->nb_streams); /* num streams */
+ avio_put_be32(s, 0); /* data offset : will be patched after */
+ avio_put_be16(s, ctx->nb_streams); /* num streams */
flags = 1 | 2; /* save allowed & perfect play */
if (url_is_streamed(s))
flags |= 4; /* live broadcast */
- put_be16(s, flags);
+ avio_put_be16(s, flags);
/* comments */
- put_tag(s,"CONT");
+ avio_put_tag(s,"CONT");
size = 4 * 2 + 10;
for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
tag = av_metadata_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
if(tag) size += strlen(tag->value);
}
- put_be32(s,size);
- put_be16(s,0);
+ avio_put_be32(s,size);
+ avio_put_be16(s,0);
for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
tag = av_metadata_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
put_str(s, tag ? tag->value : "");
@@ -151,31 +151,31 @@ static int rv10_write_header(AVFormatContext *ctx,
codec_data_size = 34;
}
- put_tag(s,"MDPR");
+ avio_put_tag(s,"MDPR");
size = 10 + 9 * 4 + strlen(desc) + strlen(mimetype) + codec_data_size;
- put_be32(s, size);
- put_be16(s, 0);
+ avio_put_be32(s, size);
+ avio_put_be16(s, 0);
- put_be16(s, i); /* stream number */
- put_be32(s, stream->bit_rate); /* max bit rate */
- put_be32(s, stream->bit_rate); /* avg bit rate */
- put_be32(s, stream->packet_max_size); /* max packet size */
+ avio_put_be16(s, i); /* stream number */
+ avio_put_be32(s, stream->bit_rate); /* max bit rate */
+ avio_put_be32(s, stream->bit_rate); /* avg bit rate */
+ avio_put_be32(s, stream->packet_max_size); /* max packet size */
if (stream->nb_packets > 0)
packet_avg_size = stream->packet_total_size /
stream->nb_packets;
else
packet_avg_size = 0;
- put_be32(s, packet_avg_size); /* avg packet size */
- put_be32(s, 0); /* start time */
- put_be32(s, BUFFER_DURATION); /* preroll */
+ avio_put_be32(s, packet_avg_size); /* avg packet size */
+ avio_put_be32(s, 0); /* start time */
+ avio_put_be32(s, BUFFER_DURATION); /* preroll */
/* duration */
if (url_is_streamed(s) || !stream->total_frames)
- put_be32(s, (int)(3600 * 1000));
+ avio_put_be32(s, (int)(3600 * 1000));
else
- put_be32(s, (int)(stream->total_frames * 1000 / stream->frame_rate));
+ avio_put_be32(s, (int)(stream->total_frames * 1000 / stream->frame_rate));
put_str8(s, desc);
put_str8(s, mimetype);
- put_be32(s, codec_data_size);
+ avio_put_be32(s, codec_data_size);
if (stream->enc->codec_type == AVMEDIA_TYPE_AUDIO) {
int coded_frame_size, fscode, sample_rate;
@@ -183,13 +183,13 @@ static int rv10_write_header(AVFormatContext *ctx,
coded_frame_size = (stream->enc->bit_rate *
stream->enc->frame_size) / (8 * sample_rate);
/* audio codec info */
- put_tag(s, ".ra");
- put_byte(s, 0xfd);
- put_be32(s, 0x00040000); /* version */
- put_tag(s, ".ra4");
- put_be32(s, 0x01b53530); /* stream length */
- put_be16(s, 4); /* unknown */
- put_be32(s, 0x39); /* header size */
+ avio_put_tag(s, ".ra");
+ avio_put_byte(s, 0xfd);
+ avio_put_be32(s, 0x00040000); /* version */
+ avio_put_tag(s, ".ra4");
+ avio_put_be32(s, 0x01b53530); /* stream length */
+ avio_put_be16(s, 4); /* unknown */
+ avio_put_be32(s, 0x39); /* header size */
switch(sample_rate) {
case 48000:
@@ -208,56 +208,56 @@ static int rv10_write_header(AVFormatContext *ctx,
case 8000:
fscode = 3;
}
- put_be16(s, fscode); /* codec additional info, for AC-3, seems
+ avio_put_be16(s, fscode); /* codec additional info, for AC-3, seems
to be a frequency code */
/* special hack to compensate rounding errors... */
if (coded_frame_size == 557)
coded_frame_size--;
- put_be32(s, coded_frame_size); /* frame length */
- put_be32(s, 0x51540); /* unknown */
- put_be32(s, 0x249f0); /* unknown */
- put_be32(s, 0x249f0); /* unknown */
- put_be16(s, 0x01);
+ avio_put_be32(s, coded_frame_size); /* frame length */
+ avio_put_be32(s, 0x51540); /* unknown */
+ avio_put_be32(s, 0x249f0); /* unknown */
+ avio_put_be32(s, 0x249f0); /* unknown */
+ avio_put_be16(s, 0x01);
/* frame length : seems to be very important */
- put_be16(s, coded_frame_size);
- put_be32(s, 0); /* unknown */
- put_be16(s, stream->enc->sample_rate); /* sample rate */
- put_be32(s, 0x10); /* unknown */
- put_be16(s, stream->enc->channels);
+ avio_put_be16(s, coded_frame_size);
+ avio_put_be32(s, 0); /* unknown */
+ avio_put_be16(s, stream->enc->sample_rate); /* sample rate */
+ avio_put_be32(s, 0x10); /* unknown */
+ avio_put_be16(s, stream->enc->channels);
put_str8(s, "Int0"); /* codec name */
if (stream->enc->codec_tag) {
- put_byte(s, 4); /* tag length */
- put_le32(s, stream->enc->codec_tag);
+ avio_put_byte(s, 4); /* tag length */
+ avio_put_le32(s, stream->enc->codec_tag);
} else {
av_log(ctx, AV_LOG_ERROR, "Invalid codec tag\n");
return -1;
}
- put_be16(s, 0); /* title length */
- put_be16(s, 0); /* author length */
- put_be16(s, 0); /* copyright length */
- put_byte(s, 0); /* end of header */
+ avio_put_be16(s, 0); /* title length */
+ avio_put_be16(s, 0); /* author length */
+ avio_put_be16(s, 0); /* copyright length */
+ avio_put_byte(s, 0); /* end of header */
} else {
/* video codec info */
- put_be32(s,34); /* size */
+ avio_put_be32(s,34); /* size */
if(stream->enc->codec_id == CODEC_ID_RV10)
- put_tag(s,"VIDORV10");
+ avio_put_tag(s,"VIDORV10");
else
- put_tag(s,"VIDORV20");
- put_be16(s, stream->enc->width);
- put_be16(s, stream->enc->height);
- put_be16(s, (int) stream->frame_rate); /* frames per seconds ? */
- put_be32(s,0); /* unknown meaning */
- put_be16(s, (int) stream->frame_rate); /* unknown meaning */
- put_be32(s,0); /* unknown meaning */
- put_be16(s, 8); /* unknown meaning */
+ avio_put_tag(s,"VIDORV20");
+ avio_put_be16(s, stream->enc->width);
+ avio_put_be16(s, stream->enc->height);
+ avio_put_be16(s, (int) stream->frame_rate); /* frames per seconds ? */
+ avio_put_be32(s,0); /* unknown meaning */
+ avio_put_be16(s, (int) stream->frame_rate); /* unknown meaning */
+ avio_put_be32(s,0); /* unknown meaning */
+ avio_put_be16(s, 8); /* unknown meaning */
/* Seems to be the codec version: only use basic H263. The next
versions seems to add a diffential DC coding as in
MPEG... nothing new under the sun */
if(stream->enc->codec_id == CODEC_ID_RV10)
- put_be32(s,0x10000000);
+ avio_put_be32(s,0x10000000);
else
- put_be32(s,0x20103001);
- //put_be32(s,0x10003000);
+ avio_put_be32(s,0x20103001);
+ //avio_put_be32(s,0x10003000);
}
}
@@ -270,12 +270,12 @@ static int rv10_write_header(AVFormatContext *ctx,
data_offset_ptr[3] = data_pos;
/* data stream */
- put_tag(s,"DATA");
- put_be32(s,data_size + 10 + 8);
- put_be16(s,0);
+ avio_put_tag(s,"DATA");
+ avio_put_be32(s,data_size + 10 + 8);
+ avio_put_be16(s,0);
- put_be32(s, nb_packets); /* number of packets */
- put_be32(s,0); /* next data header */
+ avio_put_be32(s, nb_packets); /* number of packets */
+ avio_put_be32(s,0); /* next data header */
return 0;
}
@@ -290,13 +290,13 @@ static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream,
if (length > stream->packet_max_size)
stream->packet_max_size = length;
- put_be16(s,0); /* version */
- put_be16(s,length + 12);
- put_be16(s, stream->num); /* stream number */
+ avio_put_be16(s,0); /* version */
+ avio_put_be16(s,length + 12);
+ avio_put_be16(s, stream->num); /* stream number */
timestamp = (1000 * (float)stream->nb_frames) / stream->frame_rate;
- put_be32(s, timestamp); /* timestamp */
- put_byte(s, 0); /* reserved */
- put_byte(s, key_frame ? 2 : 0); /* flags */
+ avio_put_be32(s, timestamp); /* timestamp */
+ avio_put_byte(s, 0); /* reserved */
+ avio_put_byte(s, key_frame ? 2 : 0); /* flags */
}
static int rm_write_header(AVFormatContext *s)
@@ -362,9 +362,9 @@ static int rm_write_audio(AVFormatContext *s, const uint8_t *buf, int size, int
buf1[i] = buf[i+1];
buf1[i+1] = buf[i];
}
- put_buffer(pb, buf1, size);
+ avio_put_buffer(pb, buf1, size);
} else {
- put_buffer(pb, buf, size);
+ avio_put_buffer(pb, buf, size);
}
put_flush_packet(pb);
stream->nb_frames++;
@@ -386,31 +386,31 @@ static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int
#if 1
write_packet_header(s, stream, size + 7 + (size >= 0x4000)*4, key_frame);
/* bit 7: '1' if final packet of a frame converted in several packets */
- put_byte(pb, 0x81);
+ avio_put_byte(pb, 0x81);
/* bit 7: '1' if I frame. bits 6..0 : sequence number in current
frame starting from 1 */
if (key_frame) {
- put_byte(pb, 0x81);
+ avio_put_byte(pb, 0x81);
} else {
- put_byte(pb, 0x01);
+ avio_put_byte(pb, 0x01);
}
if(size >= 0x4000){
- put_be32(pb, size); /* total frame size */
- put_be32(pb, size); /* offset from the start or the end */
+ avio_put_be32(pb, size); /* total frame size */
+ avio_put_be32(pb, size); /* offset from the start or the end */
}else{
- put_be16(pb, 0x4000 | size); /* total frame size */
- put_be16(pb, 0x4000 | size); /* offset from the start or the end */
+ avio_put_be16(pb, 0x4000 | size); /* total frame size */
+ avio_put_be16(pb, 0x4000 | size); /* offset from the start or the end */
}
#else
/* full frame */
write_packet_header(s, size + 6);
- put_byte(pb, 0xc0);
- put_be16(pb, 0x4000 + size); /* total frame size */
- put_be16(pb, 0x4000 + packet_number * 126); /* position in stream */
+ avio_put_byte(pb, 0xc0);
+ avio_put_be16(pb, 0x4000 + size); /* total frame size */
+ avio_put_be16(pb, 0x4000 + packet_number * 126); /* position in stream */
#endif
- put_byte(pb, stream->nb_frames & 0xff);
+ avio_put_byte(pb, stream->nb_frames & 0xff);
- put_buffer(pb, buf, size);
+ avio_put_buffer(pb, buf, size);
put_flush_packet(pb);
stream->nb_frames++;
@@ -440,8 +440,8 @@ static int rm_write_trailer(AVFormatContext *s)
/* FIXME: write index */
/* undocumented end header */
- put_be32(pb, 0);
- put_be32(pb, 0);
+ avio_put_be32(pb, 0);
+ avio_put_be32(pb, 0);
url_fseek(pb, 0, SEEK_SET);
for(i=0;i<s->nb_streams;i++)
@@ -449,8 +449,8 @@ static int rm_write_trailer(AVFormatContext *s)
rv10_write_header(s, data_size, 0);
} else {
/* undocumented end header */
- put_be32(pb, 0);
- put_be32(pb, 0);
+ avio_put_be32(pb, 0);
+ avio_put_be32(pb, 0);
}
put_flush_packet(pb);
return 0;
diff --git a/libavformat/rsoenc.c b/libavformat/rsoenc.c
index 7b13898..b349b3c 100644
--- a/libavformat/rsoenc.c
+++ b/libavformat/rsoenc.c
@@ -55,10 +55,10 @@ static int rso_write_header(AVFormatContext *s)
}
/* format header */
- put_be16(pb, enc->codec_tag); /* codec ID */
- put_be16(pb, 0); /* data size, will be written at EOF */
- put_be16(pb, enc->sample_rate);
- put_be16(pb, 0x0000); /* play mode ? (0x0000 = don't loop) */
+ avio_put_be16(pb, enc->codec_tag); /* codec ID */
+ avio_put_be16(pb, 0); /* data size, will be written at EOF */
+ avio_put_be16(pb, enc->sample_rate);
+ avio_put_be16(pb, 0x0000); /* play mode ? (0x0000 = don't loop) */
put_flush_packet(pb);
@@ -67,7 +67,7 @@ static int rso_write_header(AVFormatContext *s)
static int rso_write_packet(AVFormatContext *s, AVPacket *pkt)
{
- put_buffer(s->pb, pkt->data, pkt->size);
+ avio_put_buffer(s->pb, pkt->data, pkt->size);
return 0;
}
@@ -92,7 +92,7 @@ static int rso_write_trailer(AVFormatContext *s)
/* update file size */
url_fseek(pb, 2, SEEK_SET);
- put_be16(pb, coded_file_size);
+ avio_put_be16(pb, coded_file_size);
url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb);
diff --git a/libavformat/rtpdec.c b/libavformat/rtpdec.c
index c81ba1c..264b3f9 100644
--- a/libavformat/rtpdec.c
+++ b/libavformat/rtpdec.c
@@ -268,12 +268,12 @@ int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
return -1;
// Receiver Report
- put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
- put_byte(pb, RTCP_RR);
- put_be16(pb, 7); /* length in words - 1 */
+ avio_put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
+ avio_put_byte(pb, RTCP_RR);
+ avio_put_be16(pb, 7); /* length in words - 1 */
// our own SSRC: we use the server's SSRC + 1 to avoid conflicts
- put_be32(pb, s->ssrc + 1);
- put_be32(pb, s->ssrc); // server SSRC
+ avio_put_be32(pb, s->ssrc + 1);
+ avio_put_be32(pb, s->ssrc); // server SSRC
// some placeholders we should really fill...
// RFC 1889/p64
extended_max= stats->cycles + stats->max_seq;
@@ -290,34 +290,34 @@ int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
fraction= (fraction<<24) | lost;
- put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
- put_be32(pb, extended_max); /* max sequence received */
- put_be32(pb, stats->jitter>>4); /* jitter */
+ avio_put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
+ avio_put_be32(pb, extended_max); /* max sequence received */
+ avio_put_be32(pb, stats->jitter>>4); /* jitter */
if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
{
- put_be32(pb, 0); /* last SR timestamp */
- put_be32(pb, 0); /* delay since last SR */
+ avio_put_be32(pb, 0); /* last SR timestamp */
+ avio_put_be32(pb, 0); /* delay since last SR */
} else {
uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
- put_be32(pb, middle_32_bits); /* last SR timestamp */
- put_be32(pb, delay_since_last); /* delay since last SR */
+ avio_put_be32(pb, middle_32_bits); /* last SR timestamp */
+ avio_put_be32(pb, delay_since_last); /* delay since last SR */
}
// CNAME
- put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
- put_byte(pb, RTCP_SDES);
+ avio_put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
+ avio_put_byte(pb, RTCP_SDES);
len = strlen(s->hostname);
- put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
- put_be32(pb, s->ssrc);
- put_byte(pb, 0x01);
- put_byte(pb, len);
- put_buffer(pb, s->hostname, len);
+ avio_put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
+ avio_put_be32(pb, s->ssrc);
+ avio_put_byte(pb, 0x01);
+ avio_put_byte(pb, len);
+ avio_put_buffer(pb, s->hostname, len);
// padding
for (len = (6 + len) % 4; len % 4; len++) {
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
}
put_flush_packet(pb);
@@ -342,11 +342,11 @@ void rtp_send_punch_packets(URLContext* rtp_handle)
if (url_open_dyn_buf(&pb) < 0)
return;
- put_byte(pb, (RTP_VERSION << 6));
- put_byte(pb, 0); /* Payload type */
- put_be16(pb, 0); /* Seq */
- put_be32(pb, 0); /* Timestamp */
- put_be32(pb, 0); /* SSRC */
+ avio_put_byte(pb, (RTP_VERSION << 6));
+ avio_put_byte(pb, 0); /* Payload type */
+ avio_put_be16(pb, 0); /* Seq */
+ avio_put_be32(pb, 0); /* Timestamp */
+ avio_put_be32(pb, 0); /* SSRC */
put_flush_packet(pb);
len = url_close_dyn_buf(pb, &buf);
@@ -358,10 +358,10 @@ void rtp_send_punch_packets(URLContext* rtp_handle)
if (url_open_dyn_buf(&pb) < 0)
return;
- put_byte(pb, (RTP_VERSION << 6));
- put_byte(pb, RTCP_RR); /* receiver report */
- put_be16(pb, 1); /* length in words - 1 */
- put_be32(pb, 0); /* our own SSRC */
+ avio_put_byte(pb, (RTP_VERSION << 6));
+ avio_put_byte(pb, RTCP_RR); /* receiver report */
+ avio_put_be16(pb, 1); /* length in words - 1 */
+ avio_put_be32(pb, 0); /* our own SSRC */
put_flush_packet(pb);
len = url_close_dyn_buf(pb, &buf);
diff --git a/libavformat/rtpdec_asf.c b/libavformat/rtpdec_asf.c
index 5d52765..1ce9e77 100644
--- a/libavformat/rtpdec_asf.c
+++ b/libavformat/rtpdec_asf.c
@@ -212,7 +212,7 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf,
if (!asf->pktbuf)
return AVERROR(EIO);
- put_buffer(asf->pktbuf, buf + off, len - off);
+ avio_put_buffer(asf->pktbuf, buf + off, len - off);
url_fskip(pb, len - off);
if (!(flags & RTP_FLAG_MARKER))
return -1;
diff --git a/libavformat/rtpdec_latm.c b/libavformat/rtpdec_latm.c
index 8ed42a7..aa0c9e3 100644
--- a/libavformat/rtpdec_latm.c
+++ b/libavformat/rtpdec_latm.c
@@ -68,7 +68,7 @@ static int latm_parse_packet(AVFormatContext *ctx, PayloadContext *data,
if ((ret = url_open_dyn_buf(&data->dyn_buf)) < 0)
return ret;
}
- put_buffer(data->dyn_buf, buf, len);
+ avio_put_buffer(data->dyn_buf, buf, len);
if (!(flags & RTP_FLAG_MARKER))
return AVERROR(EAGAIN);
diff --git a/libavformat/rtpdec_svq3.c b/libavformat/rtpdec_svq3.c
index 79a5775..59a1d71 100644
--- a/libavformat/rtpdec_svq3.c
+++ b/libavformat/rtpdec_svq3.c
@@ -94,7 +94,7 @@ static int svq3_parse_packet (AVFormatContext *s, PayloadContext *sv,
if (!sv->pktbuf)
return AVERROR_INVALIDDATA;
- put_buffer(sv->pktbuf, buf, len);
+ avio_put_buffer(sv->pktbuf, buf, len);
if (end_packet) {
av_init_packet(pkt);
diff --git a/libavformat/rtpdec_vp8.c b/libavformat/rtpdec_vp8.c
index b18017b..888186c 100644
--- a/libavformat/rtpdec_vp8.c
+++ b/libavformat/rtpdec_vp8.c
@@ -111,7 +111,7 @@ static int vp8_handle_packet(AVFormatContext *ctx,
}
}
- put_buffer(vp8->data, buf, au_len);
+ avio_put_buffer(vp8->data, buf, au_len);
buf += au_len;
len -= au_len;
}
diff --git a/libavformat/rtpdec_xiph.c b/libavformat/rtpdec_xiph.c
index fe17a42..f417cb3 100644
--- a/libavformat/rtpdec_xiph.c
+++ b/libavformat/rtpdec_xiph.c
@@ -179,7 +179,7 @@ static int xiph_handle_packet(AVFormatContext * ctx,
if((res = url_open_dyn_buf(&data->fragment)) < 0)
return res;
- put_buffer(data->fragment, buf, pkt_len);
+ avio_put_buffer(data->fragment, buf, pkt_len);
data->timestamp = *timestamp;
} else {
@@ -198,7 +198,7 @@ static int xiph_handle_packet(AVFormatContext * ctx,
}
// copy data to fragment buffer
- put_buffer(data->fragment, buf, pkt_len);
+ avio_put_buffer(data->fragment, buf, pkt_len);
if (fragmented == 3) {
// end of xiph data packet
diff --git a/libavformat/rtpenc.c b/libavformat/rtpenc.c
index 22e68ba..640c87c 100644
--- a/libavformat/rtpenc.c
+++ b/libavformat/rtpenc.c
@@ -197,15 +197,15 @@ static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
s->last_rtcp_ntp_time = ntp_time;
rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
s1->streams[0]->time_base) + s->base_timestamp;
- put_byte(s1->pb, (RTP_VERSION << 6));
- put_byte(s1->pb, RTCP_SR);
- put_be16(s1->pb, 6); /* length in words - 1 */
- put_be32(s1->pb, s->ssrc);
- put_be32(s1->pb, ntp_time / 1000000);
- put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
- put_be32(s1->pb, rtp_ts);
- put_be32(s1->pb, s->packet_count);
- put_be32(s1->pb, s->octet_count);
+ avio_put_byte(s1->pb, (RTP_VERSION << 6));
+ avio_put_byte(s1->pb, RTCP_SR);
+ avio_put_be16(s1->pb, 6); /* length in words - 1 */
+ avio_put_be32(s1->pb, s->ssrc);
+ avio_put_be32(s1->pb, ntp_time / 1000000);
+ avio_put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
+ avio_put_be32(s1->pb, rtp_ts);
+ avio_put_be32(s1->pb, s->packet_count);
+ avio_put_be32(s1->pb, s->octet_count);
put_flush_packet(s1->pb);
}
@@ -218,13 +218,13 @@ void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
av_dlog(s1, "rtp_send_data size=%d\n", len);
/* build the RTP header */
- put_byte(s1->pb, (RTP_VERSION << 6));
- put_byte(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
- put_be16(s1->pb, s->seq);
- put_be32(s1->pb, s->timestamp);
- put_be32(s1->pb, s->ssrc);
+ avio_put_byte(s1->pb, (RTP_VERSION << 6));
+ avio_put_byte(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
+ avio_put_be16(s1->pb, s->seq);
+ avio_put_be32(s1->pb, s->timestamp);
+ avio_put_be32(s1->pb, s->ssrc);
- put_buffer(s1->pb, buf1, len);
+ avio_put_buffer(s1->pb, buf1, len);
put_flush_packet(s1->pb);
s->seq++;
diff --git a/libavformat/soxenc.c b/libavformat/soxenc.c
index 413a538..5142f46 100644
--- a/libavformat/soxenc.c
+++ b/libavformat/soxenc.c
@@ -53,29 +53,29 @@ static int sox_write_header(AVFormatContext *s)
sox->header_size = SOX_FIXED_HDR + comment_size;
if (enc->codec_id == CODEC_ID_PCM_S32LE) {
- put_tag(pb, ".SoX");
- put_le32(pb, sox->header_size);
- put_le64(pb, 0); /* number of samples */
- put_le64(pb, av_dbl2int(enc->sample_rate));
- put_le32(pb, enc->channels);
- put_le32(pb, comment_size);
+ avio_put_tag(pb, ".SoX");
+ avio_put_le32(pb, sox->header_size);
+ avio_put_le64(pb, 0); /* number of samples */
+ avio_put_le64(pb, av_dbl2int(enc->sample_rate));
+ avio_put_le32(pb, enc->channels);
+ avio_put_le32(pb, comment_size);
} else if (enc->codec_id == CODEC_ID_PCM_S32BE) {
- put_tag(pb, "XoS.");
- put_be32(pb, sox->header_size);
- put_be64(pb, 0); /* number of samples */
- put_be64(pb, av_dbl2int(enc->sample_rate));
- put_be32(pb, enc->channels);
- put_be32(pb, comment_size);
+ avio_put_tag(pb, "XoS.");
+ avio_put_be32(pb, sox->header_size);
+ avio_put_be64(pb, 0); /* number of samples */
+ avio_put_be64(pb, av_dbl2int(enc->sample_rate));
+ avio_put_be32(pb, enc->channels);
+ avio_put_be32(pb, comment_size);
} else {
av_log(s, AV_LOG_ERROR, "invalid codec; use pcm_s32le or pcm_s32be\n");
return -1;
}
if (comment_len)
- put_buffer(pb, comment->value, comment_len);
+ avio_put_buffer(pb, comment->value, comment_len);
for ( ; comment_size > comment_len; comment_len++)
- put_byte(pb, 0);
+ avio_put_byte(pb, 0);
put_flush_packet(pb);
@@ -85,7 +85,7 @@ static int sox_write_header(AVFormatContext *s)
static int sox_write_packet(AVFormatContext *s, AVPacket *pkt)
{
ByteIOContext *pb = s->pb;
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_buffer(pb, pkt->data, pkt->size);
return 0;
}
@@ -101,9 +101,9 @@ static int sox_write_trailer(AVFormatContext *s)
int64_t num_samples = (file_size - sox->header_size - 4LL) >> 2LL;
url_fseek(pb, 8, SEEK_SET);
if (enc->codec_id == CODEC_ID_PCM_S32LE) {
- put_le64(pb, num_samples);
+ avio_put_le64(pb, num_samples);
} else
- put_be64(pb, num_samples);
+ avio_put_be64(pb, num_samples);
url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb);
diff --git a/libavformat/spdifenc.c b/libavformat/spdifenc.c
index 7c6591a..a27e7b4 100644
--- a/libavformat/spdifenc.c
+++ b/libavformat/spdifenc.c
@@ -476,9 +476,9 @@ static av_always_inline void spdif_put_16(IEC61937Context *ctx,
ByteIOContext *pb, unsigned int val)
{
if (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)
- put_be16(pb, val);
+ avio_put_be16(pb, val);
else
- put_le16(pb, val);
+ avio_put_le16(pb, val);
}
static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
@@ -512,20 +512,20 @@ static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
}
if (ctx->extra_bswap ^ (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)) {
- put_buffer(s->pb, ctx->out_buf, ctx->out_bytes & ~1);
+ avio_put_buffer(s->pb, ctx->out_buf, ctx->out_bytes & ~1);
} else {
av_fast_malloc(&ctx->buffer, &ctx->buffer_size, ctx->out_bytes + FF_INPUT_BUFFER_PADDING_SIZE);
if (!ctx->buffer)
return AVERROR(ENOMEM);
ff_spdif_bswap_buf16((uint16_t *)ctx->buffer, (uint16_t *)ctx->out_buf, ctx->out_bytes >> 1);
- put_buffer(s->pb, ctx->buffer, ctx->out_bytes & ~1);
+ avio_put_buffer(s->pb, ctx->buffer, ctx->out_bytes & ~1);
}
/* a final lone byte has to be MSB aligned */
if (ctx->out_bytes & 1)
spdif_put_16(ctx, s->pb, ctx->out_buf[ctx->out_bytes - 1] << 8);
- put_nbyte(s->pb, 0, padding);
+ avio_put_nbyte(s->pb, 0, padding);
av_log(s, AV_LOG_DEBUG, "type=%x len=%i pkt_offset=%i\n",
ctx->data_type, ctx->out_bytes, ctx->pkt_offset);
diff --git a/libavformat/swfenc.c b/libavformat/swfenc.c
index 1ade1bf..0acd2cb 100644
--- a/libavformat/swfenc.c
+++ b/libavformat/swfenc.c
@@ -33,10 +33,10 @@ static void put_swf_tag(AVFormatContext *s, int tag)
swf->tag = tag;
/* reserve some room for the tag */
if (tag & TAG_LONG) {
- put_le16(pb, 0);
- put_le32(pb, 0);
+ avio_put_le16(pb, 0);
+ avio_put_le32(pb, 0);
} else {
- put_le16(pb, 0);
+ avio_put_le16(pb, 0);
}
}
@@ -53,11 +53,11 @@ static void put_swf_end_tag(AVFormatContext *s)
url_fseek(pb, swf->tag_pos, SEEK_SET);
if (tag & TAG_LONG) {
tag &= ~TAG_LONG;
- put_le16(pb, (tag << 6) | 0x3f);
- put_le32(pb, tag_len - 4);
+ avio_put_le16(pb, (tag << 6) | 0x3f);
+ avio_put_le32(pb, tag_len - 4);
} else {
assert(tag_len < 0x3f);
- put_le16(pb, (tag << 6) | tag_len);
+ avio_put_le16(pb, (tag << 6) | tag_len);
}
url_fseek(pb, pos, SEEK_SET);
}
@@ -102,7 +102,7 @@ static void put_swf_rect(ByteIOContext *pb,
put_bits(&p, nbits, ymax & mask);
flush_put_bits(&p);
- put_buffer(pb, buf, put_bits_ptr(&p) - p.buf);
+ avio_put_buffer(pb, buf, put_bits_ptr(&p) - p.buf);
}
static void put_swf_line_edge(PutBitContext *pb, int dx, int dy)
@@ -167,7 +167,7 @@ static void put_swf_matrix(ByteIOContext *pb,
put_bits(&p, nbits, ty);
flush_put_bits(&p);
- put_buffer(pb, buf, put_bits_ptr(&p) - p.buf);
+ avio_put_buffer(pb, buf, put_bits_ptr(&p) - p.buf);
}
static int swf_write_header(AVFormatContext *s)
@@ -229,7 +229,7 @@ static int swf_write_header(AVFormatContext *s)
else
swf->samples_per_frame = (swf->audio_enc->sample_rate * rate_base) / rate;
- put_tag(pb, "FWS");
+ avio_put_tag(pb, "FWS");
if (!strcmp("avm2", s->oformat->name))
version = 9;
@@ -239,20 +239,20 @@ static int swf_write_header(AVFormatContext *s)
version = 6; /* version 6 and above support FLV1 codec */
else
version = 4; /* version 4 for mpeg audio support */
- put_byte(pb, version);
+ avio_put_byte(pb, version);
- put_le32(pb, DUMMY_FILE_SIZE); /* dummy size
+ avio_put_le32(pb, DUMMY_FILE_SIZE); /* dummy size
(will be patched if not streamed) */
put_swf_rect(pb, 0, width * 20, 0, height * 20);
- put_le16(pb, (rate * 256) / rate_base); /* frame rate */
+ avio_put_le16(pb, (rate * 256) / rate_base); /* frame rate */
swf->duration_pos = url_ftell(pb);
- put_le16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */
+ avio_put_le16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */
/* avm2/swf v9 (also v8?) files require a file attribute tag */
if (version == 9) {
put_swf_tag(s, TAG_FILEATTRIBUTES);
- put_le32(pb, 1<<3); /* set ActionScript v3/AVM2 flag */
+ avio_put_le32(pb, 1<<3); /* set ActionScript v3/AVM2 flag */
put_swf_end_tag(s);
}
@@ -260,17 +260,17 @@ static int swf_write_header(AVFormatContext *s)
if (swf->video_enc && swf->video_enc->codec_id == CODEC_ID_MJPEG) {
put_swf_tag(s, TAG_DEFINESHAPE);
- put_le16(pb, SHAPE_ID); /* ID of shape */
+ avio_put_le16(pb, SHAPE_ID); /* ID of shape */
/* bounding rectangle */
put_swf_rect(pb, 0, width, 0, height);
/* style info */
- put_byte(pb, 1); /* one fill style */
- put_byte(pb, 0x41); /* clipped bitmap fill */
- put_le16(pb, BITMAP_ID); /* bitmap ID */
+ avio_put_byte(pb, 1); /* one fill style */
+ avio_put_byte(pb, 0x41); /* clipped bitmap fill */
+ avio_put_le16(pb, BITMAP_ID); /* bitmap ID */
/* position of the bitmap */
put_swf_matrix(pb, (int)(1.0 * (1 << FRAC_BITS)), 0,
0, (int)(1.0 * (1 << FRAC_BITS)), 0, 0);
- put_byte(pb, 0); /* no line style */
+ avio_put_byte(pb, 0); /* no line style */
/* shape drawing */
init_put_bits(&p, buf1, sizeof(buf1));
@@ -295,7 +295,7 @@ static int swf_write_header(AVFormatContext *s)
put_bits(&p, 5, 0);
flush_put_bits(&p);
- put_buffer(pb, buf1, put_bits_ptr(&p) - p.buf);
+ avio_put_buffer(pb, buf1, put_bits_ptr(&p) - p.buf);
put_swf_end_tag(s);
}
@@ -317,11 +317,11 @@ static int swf_write_header(AVFormatContext *s)
v |= 0x02; /* 16 bit playback */
if (swf->audio_enc->channels == 2)
v |= 0x01; /* stereo playback */
- put_byte(s->pb, v);
+ avio_put_byte(s->pb, v);
v |= 0x20; /* mp3 compressed */
- put_byte(s->pb, v);
- put_le16(s->pb, swf->samples_per_frame); /* avg samples per frame */
- put_le16(s->pb, 0);
+ avio_put_byte(s->pb, v);
+ avio_put_le16(s->pb, swf->samples_per_frame); /* avg samples per frame */
+ avio_put_le16(s->pb, 0);
put_swf_end_tag(s);
}
@@ -345,70 +345,70 @@ static int swf_write_video(AVFormatContext *s,
if (swf->video_frame_number == 0) {
/* create a new video object */
put_swf_tag(s, TAG_VIDEOSTREAM);
- put_le16(pb, VIDEO_ID);
+ avio_put_le16(pb, VIDEO_ID);
swf->vframes_pos = url_ftell(pb);
- put_le16(pb, 15000); /* hard flash player limit */
- put_le16(pb, enc->width);
- put_le16(pb, enc->height);
- put_byte(pb, 0);
- put_byte(pb,ff_codec_get_tag(swf_codec_tags,enc->codec_id));
+ avio_put_le16(pb, 15000); /* hard flash player limit */
+ avio_put_le16(pb, enc->width);
+ avio_put_le16(pb, enc->height);
+ avio_put_byte(pb, 0);
+ avio_put_byte(pb,ff_codec_get_tag(swf_codec_tags,enc->codec_id));
put_swf_end_tag(s);
/* place the video object for the first time */
put_swf_tag(s, TAG_PLACEOBJECT2);
- put_byte(pb, 0x36);
- put_le16(pb, 1);
- put_le16(pb, VIDEO_ID);
+ avio_put_byte(pb, 0x36);
+ avio_put_le16(pb, 1);
+ avio_put_le16(pb, VIDEO_ID);
put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0);
- put_le16(pb, swf->video_frame_number);
- put_tag(pb, "video");
- put_byte(pb, 0x00);
+ avio_put_le16(pb, swf->video_frame_number);
+ avio_put_tag(pb, "video");
+ avio_put_byte(pb, 0x00);
put_swf_end_tag(s);
} else {
/* mark the character for update */
put_swf_tag(s, TAG_PLACEOBJECT2);
- put_byte(pb, 0x11);
- put_le16(pb, 1);
- put_le16(pb, swf->video_frame_number);
+ avio_put_byte(pb, 0x11);
+ avio_put_le16(pb, 1);
+ avio_put_le16(pb, swf->video_frame_number);
put_swf_end_tag(s);
}
/* set video frame data */
put_swf_tag(s, TAG_VIDEOFRAME | TAG_LONG);
- put_le16(pb, VIDEO_ID);
- put_le16(pb, swf->video_frame_number++);
- put_buffer(pb, buf, size);
+ avio_put_le16(pb, VIDEO_ID);
+ avio_put_le16(pb, swf->video_frame_number++);
+ avio_put_buffer(pb, buf, size);
put_swf_end_tag(s);
} else if (enc->codec_id == CODEC_ID_MJPEG) {
if (swf->swf_frame_number > 0) {
/* remove the shape */
put_swf_tag(s, TAG_REMOVEOBJECT);
- put_le16(pb, SHAPE_ID); /* shape ID */
- put_le16(pb, 1); /* depth */
+ avio_put_le16(pb, SHAPE_ID); /* shape ID */
+ avio_put_le16(pb, 1); /* depth */
put_swf_end_tag(s);
/* free the bitmap */
put_swf_tag(s, TAG_FREECHARACTER);
- put_le16(pb, BITMAP_ID);
+ avio_put_le16(pb, BITMAP_ID);
put_swf_end_tag(s);
}
put_swf_tag(s, TAG_JPEG2 | TAG_LONG);
- put_le16(pb, BITMAP_ID); /* ID of the image */
+ avio_put_le16(pb, BITMAP_ID); /* ID of the image */
/* a dummy jpeg header seems to be required */
- put_be32(pb, 0xffd8ffd9);
+ avio_put_be32(pb, 0xffd8ffd9);
/* write the jpeg image */
- put_buffer(pb, buf, size);
+ avio_put_buffer(pb, buf, size);
put_swf_end_tag(s);
/* draw the shape */
put_swf_tag(s, TAG_PLACEOBJECT);
- put_le16(pb, SHAPE_ID); /* shape ID */
- put_le16(pb, 1); /* depth */
+ avio_put_le16(pb, SHAPE_ID); /* shape ID */
+ avio_put_le16(pb, 1); /* depth */
put_swf_matrix(pb, 20 << FRAC_BITS, 0, 0, 20 << FRAC_BITS, 0, 0);
put_swf_end_tag(s);
}
@@ -419,9 +419,9 @@ static int swf_write_video(AVFormatContext *s,
if (swf->audio_enc && av_fifo_size(swf->audio_fifo)) {
int frame_size = av_fifo_size(swf->audio_fifo);
put_swf_tag(s, TAG_STREAMBLOCK | TAG_LONG);
- put_le16(pb, swf->sound_samples);
- put_le16(pb, 0); // seek samples
- av_fifo_generic_read(swf->audio_fifo, pb, frame_size, &put_buffer);
+ avio_put_le16(pb, swf->sound_samples);
+ avio_put_le16(pb, 0); // seek samples
+ av_fifo_generic_read(swf->audio_fifo, pb, frame_size, &avio_put_buffer);
put_swf_end_tag(s);
/* update FIFO */
@@ -495,11 +495,11 @@ static int swf_write_trailer(AVFormatContext *s)
if (!url_is_streamed(s->pb) && video_enc) {
file_size = url_ftell(pb);
url_fseek(pb, 4, SEEK_SET);
- put_le32(pb, file_size);
+ avio_put_le32(pb, file_size);
url_fseek(pb, swf->duration_pos, SEEK_SET);
- put_le16(pb, swf->video_frame_number);
+ avio_put_le16(pb, swf->video_frame_number);
url_fseek(pb, swf->vframes_pos, SEEK_SET);
- put_le16(pb, swf->video_frame_number);
+ avio_put_le16(pb, swf->video_frame_number);
url_fseek(pb, file_size, SEEK_SET);
}
return 0;
diff --git a/libavformat/vc1testenc.c b/libavformat/vc1testenc.c
index 567efb2..52687d4 100644
--- a/libavformat/vc1testenc.c
+++ b/libavformat/vc1testenc.c
@@ -33,20 +33,20 @@ static int vc1test_write_header(AVFormatContext *s)
av_log(s, AV_LOG_ERROR, "Only WMV3 is accepted!\n");
return -1;
}
- put_le24(pb, 0); //frames count will be here
- put_byte(pb, 0xC5);
- put_le32(pb, 4);
- put_buffer(pb, avc->extradata, 4);
- put_le32(pb, avc->height);
- put_le32(pb, avc->width);
- put_le32(pb, 0xC);
- put_le24(pb, 0); // hrd_buffer
- put_byte(pb, 0x80); // level|cbr|res1
- put_le32(pb, 0); // hrd_rate
+ avio_put_le24(pb, 0); //frames count will be here
+ avio_put_byte(pb, 0xC5);
+ avio_put_le32(pb, 4);
+ avio_put_buffer(pb, avc->extradata, 4);
+ avio_put_le32(pb, avc->height);
+ avio_put_le32(pb, avc->width);
+ avio_put_le32(pb, 0xC);
+ avio_put_le24(pb, 0); // hrd_buffer
+ avio_put_byte(pb, 0x80); // level|cbr|res1
+ avio_put_le32(pb, 0); // hrd_rate
if (s->streams[0]->r_frame_rate.den && s->streams[0]->r_frame_rate.num == 1)
- put_le32(pb, s->streams[0]->r_frame_rate.den);
+ avio_put_le32(pb, s->streams[0]->r_frame_rate.den);
else
- put_le32(pb, 0xFFFFFFFF); //variable framerate
+ avio_put_le32(pb, 0xFFFFFFFF); //variable framerate
av_set_pts_info(s->streams[0], 32, 1, 1000);
return 0;
@@ -59,9 +59,9 @@ static int vc1test_write_packet(AVFormatContext *s, AVPacket *pkt)
if (!pkt->size)
return 0;
- put_le32(pb, pkt->size | ((pkt->flags & AV_PKT_FLAG_KEY) ? 0x80000000 : 0));
- put_le32(pb, pkt->pts);
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_le32(pb, pkt->size | ((pkt->flags & AV_PKT_FLAG_KEY) ? 0x80000000 : 0));
+ avio_put_le32(pb, pkt->pts);
+ avio_put_buffer(pb, pkt->data, pkt->size);
put_flush_packet(pb);
ctx->frames++;
@@ -75,7 +75,7 @@ static int vc1test_write_trailer(AVFormatContext *s)
if (!url_is_streamed(s->pb)) {
url_fseek(pb, 0, SEEK_SET);
- put_le24(pb, ctx->frames);
+ avio_put_le24(pb, ctx->frames);
put_flush_packet(pb);
}
return 0;
diff --git a/libavformat/vocenc.c b/libavformat/vocenc.c
index 8d181de..745409f 100644
--- a/libavformat/vocenc.c
+++ b/libavformat/vocenc.c
@@ -37,10 +37,10 @@ static int voc_write_header(AVFormatContext *s)
|| s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
return AVERROR_PATCHWELCOME;
- put_buffer(pb, ff_voc_magic, sizeof(ff_voc_magic) - 1);
- put_le16(pb, header_size);
- put_le16(pb, version);
- put_le16(pb, ~version + 0x1234);
+ avio_put_buffer(pb, ff_voc_magic, sizeof(ff_voc_magic) - 1);
+ avio_put_le16(pb, header_size);
+ avio_put_le16(pb, version);
+ avio_put_le16(pb, ~version + 0x1234);
return 0;
}
@@ -53,39 +53,39 @@ static int voc_write_packet(AVFormatContext *s, AVPacket *pkt)
if (!voc->param_written) {
if (enc->codec_tag > 0xFF) {
- put_byte(pb, VOC_TYPE_NEW_VOICE_DATA);
- put_le24(pb, pkt->size + 12);
- put_le32(pb, enc->sample_rate);
- put_byte(pb, enc->bits_per_coded_sample);
- put_byte(pb, enc->channels);
- put_le16(pb, enc->codec_tag);
- put_le32(pb, 0);
+ avio_put_byte(pb, VOC_TYPE_NEW_VOICE_DATA);
+ avio_put_le24(pb, pkt->size + 12);
+ avio_put_le32(pb, enc->sample_rate);
+ avio_put_byte(pb, enc->bits_per_coded_sample);
+ avio_put_byte(pb, enc->channels);
+ avio_put_le16(pb, enc->codec_tag);
+ avio_put_le32(pb, 0);
} else {
if (s->streams[0]->codec->channels > 1) {
- put_byte(pb, VOC_TYPE_EXTENDED);
- put_le24(pb, 4);
- put_le16(pb, 65536-256000000/(enc->sample_rate*enc->channels));
- put_byte(pb, enc->codec_tag);
- put_byte(pb, enc->channels - 1);
+ avio_put_byte(pb, VOC_TYPE_EXTENDED);
+ avio_put_le24(pb, 4);
+ avio_put_le16(pb, 65536-256000000/(enc->sample_rate*enc->channels));
+ avio_put_byte(pb, enc->codec_tag);
+ avio_put_byte(pb, enc->channels - 1);
}
- put_byte(pb, VOC_TYPE_VOICE_DATA);
- put_le24(pb, pkt->size + 2);
- put_byte(pb, 256 - 1000000 / enc->sample_rate);
- put_byte(pb, enc->codec_tag);
+ avio_put_byte(pb, VOC_TYPE_VOICE_DATA);
+ avio_put_le24(pb, pkt->size + 2);
+ avio_put_byte(pb, 256 - 1000000 / enc->sample_rate);
+ avio_put_byte(pb, enc->codec_tag);
}
voc->param_written = 1;
} else {
- put_byte(pb, VOC_TYPE_VOICE_DATA_CONT);
- put_le24(pb, pkt->size);
+ avio_put_byte(pb, VOC_TYPE_VOICE_DATA_CONT);
+ avio_put_le24(pb, pkt->size);
}
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_buffer(pb, pkt->data, pkt->size);
return 0;
}
static int voc_write_trailer(AVFormatContext *s)
{
- put_byte(s->pb, 0);
+ avio_put_byte(s->pb, 0);
return 0;
}
diff --git a/libavformat/wav.c b/libavformat/wav.c
index 4cf138c..354afb6 100644
--- a/libavformat/wav.c
+++ b/libavformat/wav.c
@@ -42,9 +42,9 @@ static int wav_write_header(AVFormatContext *s)
ByteIOContext *pb = s->pb;
int64_t fmt, fact;
- put_tag(pb, "RIFF");
- put_le32(pb, 0); /* file length */
- put_tag(pb, "WAVE");
+ avio_put_tag(pb, "RIFF");
+ avio_put_le32(pb, 0); /* file length */
+ avio_put_tag(pb, "WAVE");
/* format header */
fmt = ff_start_tag(pb, "fmt ");
@@ -59,7 +59,7 @@ static int wav_write_header(AVFormatContext *s)
if (s->streams[0]->codec->codec_tag != 0x01 /* hence for all other than PCM */
&& !url_is_streamed(s->pb)) {
fact = ff_start_tag(pb, "fact");
- put_le32(pb, 0);
+ avio_put_le32(pb, 0);
ff_end_tag(pb, fact);
}
@@ -79,7 +79,7 @@ static int wav_write_packet(AVFormatContext *s, AVPacket *pkt)
{
ByteIOContext *pb = s->pb;
WAVContext *wav = s->priv_data;
- put_buffer(pb, pkt->data, pkt->size);
+ avio_put_buffer(pb, pkt->data, pkt->size);
if(pkt->pts != AV_NOPTS_VALUE) {
wav->minpts = FFMIN(wav->minpts, pkt->pts);
wav->maxpts = FFMAX(wav->maxpts, pkt->pts);
@@ -103,7 +103,7 @@ static int wav_write_trailer(AVFormatContext *s)
/* update file size */
file_size = url_ftell(pb);
url_fseek(pb, 4, SEEK_SET);
- put_le32(pb, (uint32_t)(file_size - 8));
+ avio_put_le32(pb, (uint32_t)(file_size - 8));
url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb);
@@ -115,7 +115,7 @@ static int wav_write_trailer(AVFormatContext *s)
s->streams[0]->codec->sample_rate * (int64_t)s->streams[0]->time_base.num,
s->streams[0]->time_base.den);
url_fseek(pb, wav->data-12, SEEK_SET);
- put_le32(pb, number_of_samples);
+ avio_put_le32(pb, number_of_samples);
url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb);
}
diff --git a/libavformat/yuv4mpeg.c b/libavformat/yuv4mpeg.c
index 6c76398..b2df31f 100644
--- a/libavformat/yuv4mpeg.c
+++ b/libavformat/yuv4mpeg.c
@@ -108,21 +108,21 @@ static int yuv4_write_packet(AVFormatContext *s, AVPacket *pkt)
av_log(s, AV_LOG_ERROR, "Error. YUV4MPEG stream header write failed.\n");
return AVERROR(EIO);
} else {
- put_buffer(pb, buf2, strlen(buf2));
+ avio_put_buffer(pb, buf2, strlen(buf2));
}
}
/* construct frame header */
m = snprintf(buf1, sizeof(buf1), "%s\n", Y4M_FRAME_MAGIC);
- put_buffer(pb, buf1, strlen(buf1));
+ avio_put_buffer(pb, buf1, strlen(buf1));
width = st->codec->width;
height = st->codec->height;
ptr = picture->data[0];
for(i=0;i<height;i++) {
- put_buffer(pb, ptr, width);
+ avio_put_buffer(pb, ptr, width);
ptr += picture->linesize[0];
}
@@ -135,11 +135,11 @@ static int yuv4_write_packet(AVFormatContext *s, AVPacket *pkt)
ptr1 = picture->data[1];
ptr2 = picture->data[2];
for(i=0;i<height;i++) { /* Cb */
- put_buffer(pb, ptr1, width);
+ avio_put_buffer(pb, ptr1, width);
ptr1 += picture->linesize[1];
}
for(i=0;i<height;i++) { /* Cr */
- put_buffer(pb, ptr2, width);
+ avio_put_buffer(pb, ptr2, width);
ptr2 += picture->linesize[2];
}
}
--
1.7.2.3
More information about the ffmpeg-devel
mailing list