Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

avio: avio: avio_ prefixes for put_* functions

Browse Source 
In the name of consistency:
put_byte           -> avio_w8
put_<type>         -> avio_w<type>
put_buffer         -> avio_write

put_nbyte will be made private
put_tag will be merged with avio_put_str

Signed-off-by: Ronald S. Bultje <rsbultje@gmail.com>
oldabi
Anton Khirnov 14 years ago committed by Ronald S. Bultje
parent 78e2380a6d
commit 77eb5504d3
59 changed files with 1787 additions and 1752 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      ffserver.c
  2. 12
      libavformat/a64.c
  3. 6
      libavformat/adtsenc.c
  4. 36
      libavformat/aiffenc.c
  5. 2
      libavformat/amr.c
  6. 180
      libavformat/asfenc.c
  7. 6
      libavformat/assenc.c
  8. 14
      libavformat/au.c
  9. 30
      libavformat/avc.c
  10. 188
      libavformat/avienc.c
  11. 31
      libavformat/avio.h
  12. 102
      libavformat/aviobuf.c
  13. 2
      libavformat/crcenc.c
  14. 6
      libavformat/daud.c
  15. 2
      libavformat/dvenc.c
  16. 140
      libavformat/ffmenc.c
  17. 16
      libavformat/ffmetaenc.c
  18. 20
      libavformat/filmstripenc.c
  19. 12
      libavformat/flacenc.c
  20. 4
      libavformat/flacenc_header.c
  21. 124
      libavformat/flvenc.c
  22. 2
      libavformat/framecrcenc.c
  23. 70
      libavformat/gif.c
  24. 322
      libavformat/gxfenc.c
  25. 2
      libavformat/idroqenc.c
  26. 18
      libavformat/img2.c
  27. 24
      libavformat/ivfenc.c
  28. 2
      libavformat/libnut.c
  29. 12
      libavformat/matroskadec.c
  30. 46
      libavformat/matroskaenc.c
  31. 2
      libavformat/md5enc.c
  32. 50
      libavformat/mmf.c
  33. 880
      libavformat/movenc.c
  34. 40
      libavformat/movenchint.c
  35. 30
      libavformat/mp3enc.c
  36. 82
      libavformat/mpegenc.c
  37. 8
      libavformat/mpegtsenc.c
  38. 8
      libavformat/mpjpeg.c
  39. 332
      libavformat/mxfenc.c
  40. 32
      libavformat/nutenc.c
  41. 22
      libavformat/oggenc.c
  42. 2
      libavformat/rawenc.c
  43. 64
      libavformat/riff.c
  44. 192
      libavformat/rmenc.c
  45. 12
      libavformat/rsoenc.c
  46. 58
      libavformat/rtpdec.c
  47. 2
      libavformat/rtpdec_asf.c
  48. 2
      libavformat/rtpdec_latm.c
  49. 2
      libavformat/rtpdec_svq3.c
  50. 2
      libavformat/rtpdec_vp8.c
  51. 4
      libavformat/rtpdec_xiph.c
  52. 30
      libavformat/rtpenc.c
  53. 30
      libavformat/soxenc.c
  54. 8
      libavformat/spdifenc.c
  55. 108
      libavformat/swfenc.c
  56. 32
      libavformat/vc1testenc.c
  57. 48
      libavformat/vocenc.c
  58. 10
      libavformat/wav.c
  59. 10
      libavformat/yuv4mpeg.c

6
ffserver.c
Unescape View File

@ -2514,10 +2514,10 @@ static int http_send_data(HTTPContext *c)
header[1] = interleaved_index; header[1] = interleaved_index;
header[2] = len >> 8; header[2] = len >> 8;
header[3] = len; header[3] = len;
put_buffer(pb, header, 4); avio_write(pb, header, 4);
/* write RTP packet data */ /* write RTP packet data */
c->buffer_ptr += 4; c->buffer_ptr += 4;
put_buffer(pb, c->buffer_ptr, len); avio_write(pb, c->buffer_ptr, len);
size = url_close_dyn_buf(pb, &c->packet_buffer); size = url_close_dyn_buf(pb, &c->packet_buffer);
/* prepare asynchronous TCP sending */ /* prepare asynchronous TCP sending */
rtsp_c->packet_buffer_ptr = c->packet_buffer; 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-Type: application/sdp\r\n");
url_fprintf(c->pb, "Content-Length: %d\r\n", content_length); url_fprintf(c->pb, "Content-Length: %d\r\n", content_length);
url_fprintf(c->pb, "\r\n"); url_fprintf(c->pb, "\r\n");
put_buffer(c->pb, content, content_length); avio_write(c->pb, content, content_length);
av_free(content); av_free(content);
} }

12
libavformat/a64.c
Unescape View File

@ -57,7 +57,7 @@ static int a64_write_header(struct AVFormatContext *s)
return AVERROR(EINVAL); return AVERROR(EINVAL);
break; break;
} }
put_buffer(s->pb, header, 2); avio_write(s->pb, header, 2);
c->prev_pkt.size = 0; c->prev_pkt.size = 0;
c->prev_frame_count = 0; c->prev_frame_count = 0;
return 0; return 0;
@ -110,18 +110,18 @@ static int a64_write_packet(struct AVFormatContext *s, AVPacket *pkt)
for(i = 0; i < num_frames; i++) { for(i = 0; i < num_frames; i++) {
if(pkt->data) { if(pkt->data) {
/* if available, put newest charset chunk into buffer */ /* if available, put newest charset chunk into buffer */
put_buffer(s->pb, pkt->data + ch_chunksize * i, ch_chunksize); avio_write(s->pb, pkt->data + ch_chunksize * i, ch_chunksize);
} else { } else {
/* a bit ugly, but is there an alternative to put many zeros? */ /* 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_w8(s->pb, 0);
} }
if(c->prev_pkt.data) { if(c->prev_pkt.data) {
/* put frame (screen + colram) from last packet into buffer */ /* 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_write(s->pb, c->prev_pkt.data + charset_size + frame_size * i, frame_size);
} else { } else {
/* a bit ugly, but is there an alternative to put many zeros? */ /* 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_w8(s->pb, 0);
} }
} }
@ -145,7 +145,7 @@ static int a64_write_packet(struct AVFormatContext *s, AVPacket *pkt)
default: default:
/* Write things as is. Nice for self-contained frames from non-multicolor modes or if played /* 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) */ * directly from ram and not from a streaming device (rrnet/mmc) */
if(pkt) put_buffer(s->pb, pkt->data, pkt->size); if(pkt) avio_write(s->pb, pkt->data, pkt->size);
break; break;
} }

6
libavformat/adtsenc.c
Unescape View File

@ -125,13 +125,13 @@ static int adts_write_packet(AVFormatContext *s, AVPacket *pkt)
return 0; return 0;
if (adts->write_adts) { if (adts->write_adts) {
ff_adts_write_frame_header(adts, buf, pkt->size, adts->pce_size); ff_adts_write_frame_header(adts, buf, pkt->size, adts->pce_size);
put_buffer(pb, buf, ADTS_HEADER_SIZE); avio_write(pb, buf, ADTS_HEADER_SIZE);
if (adts->pce_size) { if (adts->pce_size) {
put_buffer(pb, adts->pce_data, adts->pce_size); avio_write(pb, adts->pce_data, adts->pce_size);
adts->pce_size = 0; adts->pce_size = 0;
} }
} }
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
put_flush_packet(pb); put_flush_packet(pb);
return 0; return 0;

36
libavformat/aiffenc.c
Unescape View File

@ -45,7 +45,7 @@ static int aiff_write_header(AVFormatContext *s)
/* FORM AIFF header */ /* FORM AIFF header */
put_tag(pb, "FORM"); put_tag(pb, "FORM");
aiff->form = url_ftell(pb); aiff->form = url_ftell(pb);
put_be32(pb, 0); /* file length */ avio_wb32(pb, 0); /* file length */
put_tag(pb, aifc ? "AIFC" : "AIFF"); put_tag(pb, aifc ? "AIFC" : "AIFF");
if (aifc) { // compressed audio if (aifc) { // compressed audio
@ -56,17 +56,17 @@ static int aiff_write_header(AVFormatContext *s)
} }
/* Version chunk */ /* Version chunk */
put_tag(pb, "FVER"); put_tag(pb, "FVER");
put_be32(pb, 4); avio_wb32(pb, 4);
put_be32(pb, 0xA2805140); avio_wb32(pb, 0xA2805140);
} }
/* Common chunk */ /* Common chunk */
put_tag(pb, "COMM"); put_tag(pb, "COMM");
put_be32(pb, aifc ? 24 : 18); /* size */ avio_wb32(pb, aifc ? 24 : 18); /* size */
put_be16(pb, enc->channels); /* Number of channels */ avio_wb16(pb, enc->channels); /* Number of channels */
aiff->frames = url_ftell(pb); aiff->frames = url_ftell(pb);
put_be32(pb, 0); /* Number of frames */ avio_wb32(pb, 0); /* Number of frames */
if (!enc->bits_per_coded_sample) if (!enc->bits_per_coded_sample)
enc->bits_per_coded_sample = av_get_bits_per_sample(enc->codec_id); 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) if (!enc->block_align)
enc->block_align = (enc->bits_per_coded_sample * enc->channels) >> 3; enc->block_align = (enc->bits_per_coded_sample * enc->channels) >> 3;
put_be16(pb, enc->bits_per_coded_sample); /* Sample size */ avio_wb16(pb, enc->bits_per_coded_sample); /* Sample size */
sample_rate = av_dbl2ext((double)enc->sample_rate); sample_rate = av_dbl2ext((double)enc->sample_rate);
put_buffer(pb, (uint8_t*)&sample_rate, sizeof(sample_rate)); avio_write(pb, (uint8_t*)&sample_rate, sizeof(sample_rate));
if (aifc) { if (aifc) {
put_le32(pb, enc->codec_tag); avio_wl32(pb, enc->codec_tag);
put_be16(pb, 0); avio_wb16(pb, 0);
} }
/* Sound data chunk */ /* Sound data chunk */
put_tag(pb, "SSND"); put_tag(pb, "SSND");
aiff->ssnd = url_ftell(pb); /* Sound chunk size */ aiff->ssnd = url_ftell(pb); /* Sound chunk size */
put_be32(pb, 0); /* Sound samples data size */ avio_wb32(pb, 0); /* Sound samples data size */
put_be32(pb, 0); /* Data offset */ avio_wb32(pb, 0); /* Data offset */
put_be32(pb, 0); /* Block-size (block align) */ avio_wb32(pb, 0); /* Block-size (block align) */
av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate); 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) static int aiff_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
return 0; return 0;
} }
@ -119,22 +119,22 @@ static int aiff_write_trailer(AVFormatContext *s)
int64_t file_size, end_size; int64_t file_size, end_size;
end_size = file_size = url_ftell(pb); end_size = file_size = url_ftell(pb);
if (file_size & 1) { if (file_size & 1) {
put_byte(pb, 0); avio_w8(pb, 0);
end_size++; end_size++;
} }
if (!url_is_streamed(s->pb)) { if (!url_is_streamed(s->pb)) {
/* File length */ /* File length */
url_fseek(pb, aiff->form, SEEK_SET); url_fseek(pb, aiff->form, SEEK_SET);
put_be32(pb, file_size - aiff->form - 4); avio_wb32(pb, file_size - aiff->form - 4);
/* Number of sample frames */ /* Number of sample frames */
url_fseek(pb, aiff->frames, SEEK_SET); url_fseek(pb, aiff->frames, SEEK_SET);
put_be32(pb, (file_size-aiff->ssnd-12)/enc->block_align); avio_wb32(pb, (file_size-aiff->ssnd-12)/enc->block_align);
/* Sound Data chunk size */ /* Sound Data chunk size */
url_fseek(pb, aiff->ssnd, SEEK_SET); url_fseek(pb, aiff->ssnd, SEEK_SET);
put_be32(pb, file_size - aiff->ssnd - 4); avio_wb32(pb, file_size - aiff->ssnd - 4);
/* return to the end */ /* return to the end */
url_fseek(pb, end_size, SEEK_SET); url_fseek(pb, end_size, SEEK_SET);

2
libavformat/amr.c
Unescape View File

@ -56,7 +56,7 @@ static int amr_write_header(AVFormatContext *s)
static int amr_write_packet(AVFormatContext *s, AVPacket *pkt) static int amr_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
put_buffer(s->pb, pkt->data, pkt->size); avio_write(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;
} }

180
libavformat/asfenc.c
Unescape View File

@ -226,7 +226,7 @@ static const AVCodecTag codec_asf_bmp_tags[] = {
static void put_guid(AVIOContext *s, const ff_asf_guid *g) static void put_guid(AVIOContext *s, const ff_asf_guid *g)
{ {
assert(sizeof(*g) == 16); assert(sizeof(*g) == 16);
put_buffer(s, *g, sizeof(*g)); avio_write(s, *g, sizeof(*g));
} }
static void put_str16(AVIOContext *s, const char *tag) static void put_str16(AVIOContext *s, const char *tag)
@ -239,8 +239,8 @@ static void put_str16(AVIOContext *s, const char *tag)
avio_put_str16le(dyn_buf, tag); avio_put_str16le(dyn_buf, tag);
len = url_close_dyn_buf(dyn_buf, &pb); len = url_close_dyn_buf(dyn_buf, &pb);
put_le16(s, len); avio_wl16(s, len);
put_buffer(s, pb, len); avio_write(s, pb, len);
av_freep(&pb); av_freep(&pb);
} }
@ -250,7 +250,7 @@ static int64_t put_header(AVIOContext *pb, const ff_asf_guid *g)
pos = url_ftell(pb); pos = url_ftell(pb);
put_guid(pb, g); put_guid(pb, g);
put_le64(pb, 24); avio_wl64(pb, 24);
return pos; return pos;
} }
@ -261,7 +261,7 @@ static void end_header(AVIOContext *pb, int64_t pos)
pos1 = url_ftell(pb); pos1 = url_ftell(pb);
url_fseek(pb, pos + 16, SEEK_SET); url_fseek(pb, pos + 16, SEEK_SET);
put_le64(pb, pos1 - pos); avio_wl64(pb, pos1 - pos);
url_fseek(pb, pos1, SEEK_SET); url_fseek(pb, pos1, SEEK_SET);
} }
@ -273,11 +273,11 @@ static void put_chunk(AVFormatContext *s, int type, int payload_length, int flag
int length; int length;
length = payload_length + 8; length = payload_length + 8;
put_le16(pb, type); avio_wl16(pb, type);
put_le16(pb, length); //size avio_wl16(pb, length); //size
put_le32(pb, asf->seqno);//sequence number avio_wl32(pb, asf->seqno);//sequence number
put_le16(pb, flags); /* unknown bytes */ avio_wl16(pb, flags); /* unknown bytes */
put_le16(pb, length); //size_confirm avio_wl16(pb, length); //size_confirm
asf->seqno++; asf->seqno++;
} }
@ -331,33 +331,33 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
} }
put_guid(pb, &ff_asf_header); put_guid(pb, &ff_asf_header);
put_le64(pb, -1); /* header length, will be patched after */ avio_wl64(pb, -1); /* header length, will be patched after */
put_le32(pb, 3 + has_title + !!metadata_count + s->nb_streams); /* number of chunks in header */ avio_wl32(pb, 3 + has_title + !!metadata_count + s->nb_streams); /* number of chunks in header */
put_byte(pb, 1); /* ??? */ avio_w8(pb, 1); /* ??? */
put_byte(pb, 2); /* ??? */ avio_w8(pb, 2); /* ??? */
/* file header */ /* file header */
header_offset = url_ftell(pb); header_offset = url_ftell(pb);
hpos = put_header(pb, &ff_asf_file_header); hpos = put_header(pb, &ff_asf_file_header);
put_guid(pb, &ff_asf_my_guid); put_guid(pb, &ff_asf_my_guid);
put_le64(pb, file_size); avio_wl64(pb, file_size);
file_time = 0; file_time = 0;
put_le64(pb, unix_to_file_time(file_time)); avio_wl64(pb, unix_to_file_time(file_time));
put_le64(pb, asf->nb_packets); /* number of packets */ avio_wl64(pb, asf->nb_packets); /* number of packets */
put_le64(pb, duration); /* end time stamp (in 100ns units) */ avio_wl64(pb, duration); /* end time stamp (in 100ns units) */
put_le64(pb, asf->duration); /* duration (in 100ns units) */ avio_wl64(pb, asf->duration); /* duration (in 100ns units) */
put_le64(pb, PREROLL_TIME); /* start time stamp */ avio_wl64(pb, PREROLL_TIME); /* start time stamp */
put_le32(pb, (asf->is_streamed || url_is_streamed(pb)) ? 3 : 2); /* ??? */ avio_wl32(pb, (asf->is_streamed || url_is_streamed(pb)) ? 3 : 2); /* ??? */
put_le32(pb, s->packet_size); /* packet size */ avio_wl32(pb, s->packet_size); /* packet size */
put_le32(pb, s->packet_size); /* packet size */ avio_wl32(pb, s->packet_size); /* packet size */
put_le32(pb, bit_rate); /* Nominal data rate in bps */ avio_wl32(pb, bit_rate); /* Nominal data rate in bps */
end_header(pb, hpos); end_header(pb, hpos);
/* unknown headers */ /* unknown headers */
hpos = put_header(pb, &ff_asf_head1_guid); hpos = put_header(pb, &ff_asf_head1_guid);
put_guid(pb, &ff_asf_head2_guid); put_guid(pb, &ff_asf_head2_guid);
put_le32(pb, 6); avio_wl32(pb, 6);
put_le16(pb, 0); avio_wl16(pb, 0);
end_header(pb, hpos); end_header(pb, hpos);
/* title and other infos */ /* title and other infos */
@ -373,20 +373,20 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
for (n = 0; n < FF_ARRAY_ELEMS(tags); n++) { for (n = 0; n < FF_ARRAY_ELEMS(tags); n++) {
len = tags[n] ? avio_put_str16le(dyn_buf, tags[n]->value) : 0; len = tags[n] ? avio_put_str16le(dyn_buf, tags[n]->value) : 0;
put_le16(pb, len); avio_wl16(pb, len);
} }
len = url_close_dyn_buf(dyn_buf, &buf); len = url_close_dyn_buf(dyn_buf, &buf);
put_buffer(pb, buf, len); avio_write(pb, buf, len);
av_freep(&buf); av_freep(&buf);
end_header(pb, hpos); end_header(pb, hpos);
} }
if (metadata_count) { if (metadata_count) {
AVMetadataTag *tag = NULL; AVMetadataTag *tag = NULL;
hpos = put_header(pb, &ff_asf_extended_content_header); hpos = put_header(pb, &ff_asf_extended_content_header);
put_le16(pb, metadata_count); avio_wl16(pb, metadata_count);
while ((tag = av_metadata_get(s->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) { while ((tag = av_metadata_get(s->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
put_str16(pb, tag->key); put_str16(pb, tag->key);
put_le16(pb, 0); avio_wl16(pb, 0);
put_str16(pb, tag->value); put_str16(pb, tag->value);
} }
end_header(pb, hpos); end_header(pb, hpos);
@ -424,19 +424,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_stream);
put_guid(pb, &ff_asf_video_conceal_none); put_guid(pb, &ff_asf_video_conceal_none);
} }
put_le64(pb, 0); /* ??? */ avio_wl64(pb, 0); /* ??? */
es_pos = url_ftell(pb); es_pos = url_ftell(pb);
put_le32(pb, extra_size); /* wav header len */ avio_wl32(pb, extra_size); /* wav header len */
put_le32(pb, extra_size2); /* additional data len */ avio_wl32(pb, extra_size2); /* additional data len */
put_le16(pb, n + 1); /* stream number */ avio_wl16(pb, n + 1); /* stream number */
put_le32(pb, 0); /* ??? */ avio_wl32(pb, 0); /* ??? */
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) { if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
/* WAVEFORMATEX header */ /* WAVEFORMATEX header */
int wavsize = ff_put_wav_header(pb, enc); 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)) { 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; wavsize += 2;
put_le16(pb, 0); avio_wl16(pb, 0);
} }
if (wavsize < 0) if (wavsize < 0)
@ -444,25 +444,25 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
if (wavsize != extra_size) { if (wavsize != extra_size) {
cur_pos = url_ftell(pb); cur_pos = url_ftell(pb);
url_fseek(pb, es_pos, SEEK_SET); url_fseek(pb, es_pos, SEEK_SET);
put_le32(pb, wavsize); /* wav header len */ avio_wl32(pb, wavsize); /* wav header len */
url_fseek(pb, cur_pos, SEEK_SET); url_fseek(pb, cur_pos, SEEK_SET);
} }
/* ERROR Correction */ /* ERROR Correction */
put_byte(pb, 0x01); avio_w8(pb, 0x01);
if(enc->codec_id == CODEC_ID_ADPCM_G726 || !enc->block_align){ if(enc->codec_id == CODEC_ID_ADPCM_G726 || !enc->block_align){
put_le16(pb, 0x0190); avio_wl16(pb, 0x0190);
put_le16(pb, 0x0190); avio_wl16(pb, 0x0190);
}else{ }else{
put_le16(pb, enc->block_align); avio_wl16(pb, enc->block_align);
put_le16(pb, enc->block_align); avio_wl16(pb, enc->block_align);
} }
put_le16(pb, 0x01); avio_wl16(pb, 0x01);
put_byte(pb, 0x00); avio_w8(pb, 0x00);
} else { } else {
put_le32(pb, enc->width); avio_wl32(pb, enc->width);
put_le32(pb, enc->height); avio_wl32(pb, enc->height);
put_byte(pb, 2); /* ??? */ avio_w8(pb, 2); /* ??? */
put_le16(pb, 40 + enc->extradata_size); /* size */ avio_wl16(pb, 40 + enc->extradata_size); /* size */
/* BITMAPINFOHEADER header */ /* BITMAPINFOHEADER header */
ff_put_bmp_header(pb, enc, ff_codec_bmp_tags, 1); ff_put_bmp_header(pb, enc, ff_codec_bmp_tags, 1);
@ -474,7 +474,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
hpos = put_header(pb, &ff_asf_codec_comment_header); hpos = put_header(pb, &ff_asf_codec_comment_header);
put_guid(pb, &ff_asf_codec_comment1_header); put_guid(pb, &ff_asf_codec_comment1_header);
put_le32(pb, s->nb_streams); avio_wl32(pb, s->nb_streams);
for(n=0;n<s->nb_streams;n++) { for(n=0;n<s->nb_streams;n++) {
AVCodec *p; AVCodec *p;
const char *desc; const char *desc;
@ -486,11 +486,11 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
p = avcodec_find_encoder(enc->codec_id); p = avcodec_find_encoder(enc->codec_id);
if(enc->codec_type == AVMEDIA_TYPE_AUDIO) if(enc->codec_type == AVMEDIA_TYPE_AUDIO)
put_le16(pb, 2); avio_wl16(pb, 2);
else if(enc->codec_type == AVMEDIA_TYPE_VIDEO) else if(enc->codec_type == AVMEDIA_TYPE_VIDEO)
put_le16(pb, 1); avio_wl16(pb, 1);
else else
put_le16(pb, -1); avio_wl16(pb, -1);
if(enc->codec_id == CODEC_ID_WMAV2) if(enc->codec_id == CODEC_ID_WMAV2)
desc = "Windows Media Audio V8"; desc = "Windows Media Audio V8";
@ -502,21 +502,21 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
avio_put_str16le(dyn_buf, desc); avio_put_str16le(dyn_buf, desc);
len = url_close_dyn_buf(dyn_buf, &buf); len = url_close_dyn_buf(dyn_buf, &buf);
put_le16(pb, len / 2); // "number of characters" = length in bytes / 2 avio_wl16(pb, len / 2); // "number of characters" = length in bytes / 2
put_buffer(pb, buf, len); avio_write(pb, buf, len);
av_freep(&buf); av_freep(&buf);
put_le16(pb, 0); /* no parameters */ avio_wl16(pb, 0); /* no parameters */
/* id */ /* id */
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) { if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
put_le16(pb, 2); avio_wl16(pb, 2);
put_le16(pb, enc->codec_tag); avio_wl16(pb, enc->codec_tag);
} else { } else {
put_le16(pb, 4); avio_wl16(pb, 4);
put_le32(pb, enc->codec_tag); avio_wl32(pb, enc->codec_tag);
} }
if(!enc->codec_tag) if(!enc->codec_tag)
return -1; return -1;
@ -531,25 +531,25 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
header_size += 8 + 30 + 50; header_size += 8 + 30 + 50;
url_fseek(pb, header_offset - 10 - 30, SEEK_SET); url_fseek(pb, header_offset - 10 - 30, SEEK_SET);
put_le16(pb, header_size); avio_wl16(pb, header_size);
url_fseek(pb, header_offset - 2 - 30, SEEK_SET); url_fseek(pb, header_offset - 2 - 30, SEEK_SET);
put_le16(pb, header_size); avio_wl16(pb, header_size);
header_size -= 8 + 30 + 50; header_size -= 8 + 30 + 50;
} }
header_size += 24 + 6; header_size += 24 + 6;
url_fseek(pb, header_offset - 14, SEEK_SET); url_fseek(pb, header_offset - 14, SEEK_SET);
put_le64(pb, header_size); avio_wl64(pb, header_size);
url_fseek(pb, cur_pos, SEEK_SET); url_fseek(pb, cur_pos, SEEK_SET);
/* movie chunk, followed by packets of packet_size */ /* movie chunk, followed by packets of packet_size */
asf->data_offset = cur_pos; asf->data_offset = cur_pos;
put_guid(pb, &ff_asf_data_header); put_guid(pb, &ff_asf_data_header);
put_le64(pb, data_chunk_size); avio_wl64(pb, data_chunk_size);
put_guid(pb, &ff_asf_my_guid); put_guid(pb, &ff_asf_my_guid);
put_le64(pb, asf->nb_packets); /* nb packets */ avio_wl64(pb, asf->nb_packets); /* nb packets */
put_byte(pb, 1); /* ??? */ avio_w8(pb, 1); /* ??? */
put_byte(pb, 1); /* ??? */ avio_w8(pb, 1); /* ??? */
return 0; return 0;
} }
@ -614,9 +614,9 @@ static int put_payload_parsing_info(
padsize--; padsize--;
assert(padsize>=0); assert(padsize>=0);
put_byte(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS); avio_w8(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS);
for (i = 0; i < ASF_PACKET_ERROR_CORRECTION_DATA_SIZE; i++){ for (i = 0; i < ASF_PACKET_ERROR_CORRECTION_DATA_SIZE; i++){
put_byte(pb, 0x0); avio_w8(pb, 0x0);
} }
if (asf->multi_payloads_present) if (asf->multi_payloads_present)
@ -628,19 +628,19 @@ static int put_payload_parsing_info(
else else
iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD; iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD;
} }
put_byte(pb, iLengthTypeFlags); avio_w8(pb, iLengthTypeFlags);
put_byte(pb, ASF_PPI_PROPERTY_FLAGS); avio_w8(pb, ASF_PPI_PROPERTY_FLAGS);
if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD) if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD)
put_le16(pb, padsize - 2); avio_wl16(pb, padsize - 2);
if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE) if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE)
put_byte(pb, padsize - 1); avio_w8(pb, padsize - 1);
put_le32(pb, sendtime); avio_wl32(pb, sendtime);
put_le16(pb, duration); avio_wl16(pb, duration);
if (asf->multi_payloads_present) if (asf->multi_payloads_present)
put_byte(pb, nb_payloads | ASF_PAYLOAD_FLAGS); avio_w8(pb, nb_payloads | ASF_PAYLOAD_FLAGS);
ppi_size = url_ftell(pb) - start; ppi_size = url_ftell(pb) - start;
@ -670,7 +670,7 @@ static void flush_packet(AVFormatContext *s)
assert(packet_hdr_size <= asf->packet_size_left); assert(packet_hdr_size <= asf->packet_size_left);
memset(asf->packet_buf + packet_filled_size, 0, 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_write(s->pb, asf->packet_buf, s->packet_size - packet_hdr_size);
put_flush_packet(s->pb); put_flush_packet(s->pb);
asf->nb_packets++; asf->nb_packets++;
@ -698,23 +698,23 @@ static void put_payload_header(
val = stream->num; val = stream->num;
if (flags & AV_PKT_FLAG_KEY) if (flags & AV_PKT_FLAG_KEY)
val |= ASF_PL_FLAG_KEY_FRAME; val |= ASF_PL_FLAG_KEY_FRAME;
put_byte(pb, val); avio_w8(pb, val);
put_byte(pb, stream->seq); //Media object number avio_w8(pb, stream->seq); //Media object number
put_le32(pb, m_obj_offset); //Offset Into Media Object avio_wl32(pb, m_obj_offset); //Offset Into Media Object
// Replicated Data shall be at least 8 bytes long. // Replicated Data shall be at least 8 bytes long.
// The first 4 bytes of data shall contain the // The first 4 bytes of data shall contain the
// Size of the Media Object that the payload belongs to. // Size of the Media Object that the payload belongs to.
// The next 4 bytes of data shall contain the // The next 4 bytes of data shall contain the
// Presentation Time for the media object that the payload belongs to. // Presentation Time for the media object that the payload belongs to.
put_byte(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH); avio_w8(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH);
put_le32(pb, m_obj_size); //Replicated Data - Media Object Size avio_wl32(pb, m_obj_size); //Replicated Data - Media Object Size
put_le32(pb, presentation_time);//Replicated Data - Presentation Time avio_wl32(pb, presentation_time);//Replicated Data - Presentation Time
if (asf->multi_payloads_present){ if (asf->multi_payloads_present){
put_le16(pb, payload_len); //payload length avio_wl16(pb, payload_len); //payload length
} }
} }
@ -762,7 +762,7 @@ static void put_frame(
payload_len = frag_len1 - 2; //additional byte need to put padding length 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_payload_header(s, stream, timestamp+PREROLL_TIME, m_obj_size, m_obj_offset, payload_len, flags);
put_buffer(&asf->pb, buf, payload_len); avio_write(&asf->pb, buf, payload_len);
if (asf->multi_payloads_present) if (asf->multi_payloads_present)
asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS); asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS);
@ -837,14 +837,14 @@ static int asf_write_index(AVFormatContext *s, ASFIndex *index, uint16_t max, ui
int i; int i;
put_guid(pb, &ff_asf_simple_index_header); put_guid(pb, &ff_asf_simple_index_header);
put_le64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2)*count); avio_wl64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2)*count);
put_guid(pb, &ff_asf_my_guid); put_guid(pb, &ff_asf_my_guid);
put_le64(pb, ASF_INDEXED_INTERVAL); avio_wl64(pb, ASF_INDEXED_INTERVAL);
put_le32(pb, max); avio_wl32(pb, max);
put_le32(pb, count); avio_wl32(pb, count);
for(i=0; i<count; i++) { for(i=0; i<count; i++) {
put_le32(pb, index[i].packet_number); avio_wl32(pb, index[i].packet_number);
put_le16(pb, index[i].packet_count); avio_wl16(pb, index[i].packet_count);
} }
return 0; return 0;

6
libavformat/assenc.c
Unescape View File

@ -42,7 +42,7 @@ static int write_header(AVFormatContext *s)
if(!end) end= avctx->extradata + avctx->extradata_size; if(!end) end= avctx->extradata + avctx->extradata_size;
else end++; else end++;
put_buffer(s->pb, p, end-p); avio_write(s->pb, p, end-p);
ass->extra_index += end-p; ass->extra_index += end-p;
if(last && !memcmp(last, "[Events]", 8)) if(last && !memcmp(last, "[Events]", 8))
@ -57,7 +57,7 @@ static int write_header(AVFormatContext *s)
static int write_packet(AVFormatContext *s, AVPacket *pkt) static int write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
put_buffer(s->pb, pkt->data, pkt->size); avio_write(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb); put_flush_packet(s->pb);
@ -69,7 +69,7 @@ static int write_trailer(AVFormatContext *s)
ASSContext *ass = s->priv_data; ASSContext *ass = s->priv_data;
AVCodecContext *avctx= s->streams[0]->codec; AVCodecContext *avctx= s->streams[0]->codec;
put_buffer(s->pb, avctx->extradata + ass->extra_index, avio_write(s->pb, avctx->extradata + ass->extra_index,
avctx->extradata_size - ass->extra_index); avctx->extradata_size - ass->extra_index);
put_flush_packet(s->pb); put_flush_packet(s->pb);

14
libavformat/au.c
Unescape View File

@ -54,11 +54,11 @@ static int put_au_header(AVIOContext *pb, AVCodecContext *enc)
if(!enc->codec_tag) if(!enc->codec_tag)
return -1; return -1;
put_tag(pb, ".snd"); /* magic number */ put_tag(pb, ".snd"); /* magic number */
put_be32(pb, 24); /* header size */ avio_wb32(pb, 24); /* header size */
put_be32(pb, AU_UNKNOWN_SIZE); /* data size */ avio_wb32(pb, AU_UNKNOWN_SIZE); /* data size */
put_be32(pb, (uint32_t)enc->codec_tag); /* codec ID */ avio_wb32(pb, (uint32_t)enc->codec_tag); /* codec ID */
put_be32(pb, enc->sample_rate); avio_wb32(pb, enc->sample_rate);
put_be32(pb, (uint32_t)enc->channels); avio_wb32(pb, (uint32_t)enc->channels);
return 0; return 0;
} }
@ -81,7 +81,7 @@ static int au_write_header(AVFormatContext *s)
static int au_write_packet(AVFormatContext *s, AVPacket *pkt) static int au_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
return 0; return 0;
} }
@ -95,7 +95,7 @@ static int au_write_trailer(AVFormatContext *s)
/* update file size */ /* update file size */
file_size = url_ftell(pb); file_size = url_ftell(pb);
url_fseek(pb, 8, SEEK_SET); url_fseek(pb, 8, SEEK_SET);
put_be32(pb, (uint32_t)(file_size - 24)); avio_wb32(pb, (uint32_t)(file_size - 24));
url_fseek(pb, file_size, SEEK_SET); url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb); put_flush_packet(pb);

30
libavformat/avc.c
Unescape View File

@ -78,8 +78,8 @@ int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)
while (nal_start < end) { while (nal_start < end) {
while(!*(nal_start++)); while(!*(nal_start++));
nal_end = ff_avc_find_startcode(nal_start, end); nal_end = ff_avc_find_startcode(nal_start, end);
put_be32(pb, nal_end - nal_start); avio_wb32(pb, nal_end - nal_start);
put_buffer(pb, nal_start, nal_end - nal_start); avio_write(pb, nal_start, nal_end - nal_start);
size += 4 + nal_end - nal_start; size += 4 + nal_end - nal_start;
nal_start = nal_end; nal_start = nal_end;
} }
@ -134,21 +134,21 @@ int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
assert(sps); assert(sps);
assert(pps); assert(pps);
put_byte(pb, 1); /* version */ avio_w8(pb, 1); /* version */
put_byte(pb, sps[1]); /* profile */ avio_w8(pb, sps[1]); /* profile */
put_byte(pb, sps[2]); /* profile compat */ avio_w8(pb, sps[2]); /* profile compat */
put_byte(pb, sps[3]); /* level */ avio_w8(pb, sps[3]); /* level */
put_byte(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */ avio_w8(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) */ avio_w8(pb, 0xe1); /* 3 bits reserved (111) + 5 bits number of sps (00001) */
put_be16(pb, sps_size); avio_wb16(pb, sps_size);
put_buffer(pb, sps, sps_size); avio_write(pb, sps, sps_size);
put_byte(pb, 1); /* number of pps */ avio_w8(pb, 1); /* number of pps */
put_be16(pb, pps_size); avio_wb16(pb, pps_size);
put_buffer(pb, pps, pps_size); avio_write(pb, pps, pps_size);
av_free(start); av_free(start);
} else { } else {
put_buffer(pb, data, len); avio_write(pb, data, len);
} }
} }
return 0; return 0;

188
libavformat/avienc.c
Unescape View File

@ -108,10 +108,10 @@ static void avi_write_info_tag(AVIOContext *pb, const char *tag, const char *str
if (len > 0) { if (len > 0) {
len++; len++;
put_tag(pb, tag); put_tag(pb, tag);
put_le32(pb, len); avio_wl32(pb, len);
avio_put_str(pb, str); avio_put_str(pb, str);
if (len & 1) if (len & 1)
put_byte(pb, 0); avio_w8(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); url_fseek(pb, avist->frames_hdr_strm, SEEK_SET);
ff_parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale); ff_parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale);
if(au_ssize == 0) { if(au_ssize == 0) {
put_le32(pb, avist->packet_count); avio_wl32(pb, avist->packet_count);
} else { } else {
put_le32(pb, avist->audio_strm_length / au_ssize); avio_wl32(pb, avist->audio_strm_length / au_ssize);
} }
if(stream->codec_type == AVMEDIA_TYPE_VIDEO) if(stream->codec_type == AVMEDIA_TYPE_VIDEO)
nb_frames = FFMAX(nb_frames, avist->packet_count); 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) { if(riff_id == 1) {
assert(avi->frames_hdr_all); assert(avi->frames_hdr_all);
url_fseek(pb, avi->frames_hdr_all, SEEK_SET); url_fseek(pb, avi->frames_hdr_all, SEEK_SET);
put_le32(pb, nb_frames); avio_wl32(pb, nb_frames);
} }
url_fseek(pb, file_size, SEEK_SET); url_fseek(pb, file_size, SEEK_SET);
@ -170,7 +170,7 @@ static int avi_write_header(AVFormatContext *s)
/* avi header */ /* avi header */
put_tag(pb, "avih"); put_tag(pb, "avih");
put_le32(pb, 14 * 4); avio_wl32(pb, 14 * 4);
bitrate = 0; bitrate = 0;
video_enc = NULL; video_enc = NULL;
@ -184,32 +184,32 @@ static int avi_write_header(AVFormatContext *s)
nb_frames = 0; nb_frames = 0;
if(video_enc){ if(video_enc){
put_le32(pb, (uint32_t)(INT64_C(1000000) * video_enc->time_base.num / video_enc->time_base.den)); avio_wl32(pb, (uint32_t)(INT64_C(1000000) * video_enc->time_base.num / video_enc->time_base.den));
} else { } else {
put_le32(pb, 0); avio_wl32(pb, 0);
} }
put_le32(pb, bitrate / 8); /* XXX: not quite exact */ avio_wl32(pb, bitrate / 8); /* XXX: not quite exact */
put_le32(pb, 0); /* padding */ avio_wl32(pb, 0); /* padding */
if (url_is_streamed(pb)) if (url_is_streamed(pb))
put_le32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED); /* flags */ avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED); /* flags */
else else
put_le32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */ avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */
avi->frames_hdr_all = url_ftell(pb); /* remember this offset to fill later */ avi->frames_hdr_all = url_ftell(pb); /* remember this offset to fill later */
put_le32(pb, nb_frames); /* nb frames, filled later */ avio_wl32(pb, nb_frames); /* nb frames, filled later */
put_le32(pb, 0); /* initial frame */ avio_wl32(pb, 0); /* initial frame */
put_le32(pb, s->nb_streams); /* nb streams */ avio_wl32(pb, s->nb_streams); /* nb streams */
put_le32(pb, 1024 * 1024); /* suggested buffer size */ avio_wl32(pb, 1024 * 1024); /* suggested buffer size */
if(video_enc){ if(video_enc){
put_le32(pb, video_enc->width); avio_wl32(pb, video_enc->width);
put_le32(pb, video_enc->height); avio_wl32(pb, video_enc->height);
} else { } else {
put_le32(pb, 0); avio_wl32(pb, 0);
put_le32(pb, 0); avio_wl32(pb, 0);
} }
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
/* stream list */ /* stream list */
for(i=0;i<n;i++) { for(i=0;i<n;i++) {
@ -236,39 +236,39 @@ static int avi_write_header(AVFormatContext *s)
} }
if(stream->codec_type == AVMEDIA_TYPE_VIDEO || if(stream->codec_type == AVMEDIA_TYPE_VIDEO ||
stream->codec_id == CODEC_ID_XSUB) stream->codec_id == CODEC_ID_XSUB)
put_le32(pb, stream->codec_tag); avio_wl32(pb, stream->codec_tag);
else else
put_le32(pb, 1); avio_wl32(pb, 1);
put_le32(pb, 0); /* flags */ avio_wl32(pb, 0); /* flags */
put_le16(pb, 0); /* priority */ avio_wl16(pb, 0); /* priority */
put_le16(pb, 0); /* language */ avio_wl16(pb, 0); /* language */
put_le32(pb, 0); /* initial frame */ avio_wl32(pb, 0); /* initial frame */
ff_parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale); ff_parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale);
put_le32(pb, au_scale); /* scale */ avio_wl32(pb, au_scale); /* scale */
put_le32(pb, au_byterate); /* rate */ avio_wl32(pb, au_byterate); /* rate */
av_set_pts_info(s->streams[i], 64, au_scale, au_byterate); av_set_pts_info(s->streams[i], 64, au_scale, au_byterate);
put_le32(pb, 0); /* start */ avio_wl32(pb, 0); /* start */
avist->frames_hdr_strm = url_ftell(pb); /* remember this offset to fill later */ avist->frames_hdr_strm = url_ftell(pb); /* remember this offset to fill later */
if (url_is_streamed(pb)) if (url_is_streamed(pb))
put_le32(pb, AVI_MAX_RIFF_SIZE); /* FIXME: this may be broken, but who cares */ avio_wl32(pb, AVI_MAX_RIFF_SIZE); /* FIXME: this may be broken, but who cares */
else else
put_le32(pb, 0); /* length, XXX: filled later */ avio_wl32(pb, 0); /* length, XXX: filled later */
/* suggested buffer size */ //FIXME set at the end to largest chunk /* suggested buffer size */ //FIXME set at the end to largest chunk
if(stream->codec_type == AVMEDIA_TYPE_VIDEO) if(stream->codec_type == AVMEDIA_TYPE_VIDEO)
put_le32(pb, 1024 * 1024); avio_wl32(pb, 1024 * 1024);
else if(stream->codec_type == AVMEDIA_TYPE_AUDIO) else if(stream->codec_type == AVMEDIA_TYPE_AUDIO)
put_le32(pb, 12 * 1024); avio_wl32(pb, 12 * 1024);
else else
put_le32(pb, 0); avio_wl32(pb, 0);
put_le32(pb, -1); /* quality */ avio_wl32(pb, -1); /* quality */
put_le32(pb, au_ssize); /* sample size */ avio_wl32(pb, au_ssize); /* sample size */
put_le32(pb, 0); avio_wl32(pb, 0);
put_le16(pb, stream->width); avio_wl16(pb, stream->width);
put_le16(pb, stream->height); avio_wl16(pb, stream->height);
ff_end_tag(pb, strh); ff_end_tag(pb, strh);
if(stream->codec_type != AVMEDIA_TYPE_DATA){ 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.entry = avist->indexes.ents_allocated = 0;
avist->indexes.indx_start = ff_start_tag(pb, "JUNK"); avist->indexes.indx_start = ff_start_tag(pb, "JUNK");
put_le16(pb, 4); /* wLongsPerEntry */ avio_wl16(pb, 4); /* wLongsPerEntry */
put_byte(pb, 0); /* bIndexSubType (0 == frame index) */ avio_w8(pb, 0); /* bIndexSubType (0 == frame index) */
put_byte(pb, 0); /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */ avio_w8(pb, 0); /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */
put_le32(pb, 0); /* nEntriesInUse (will fill out later on) */ avio_wl32(pb, 0); /* nEntriesInUse (will fill out later on) */
put_tag(pb, avi_stream2fourcc(&tag[0], i, stream->codec_type)); put_tag(pb, avi_stream2fourcc(&tag[0], i, stream->codec_type));
/* dwChunkId */ /* dwChunkId */
put_le64(pb, 0); /* dwReserved[3] avio_wl64(pb, 0); /* dwReserved[3]
put_le32(pb, 0); Must be 0. */ avio_wl32(pb, 0); Must be 0. */
for (j=0; j < AVI_MASTER_INDEX_SIZE * 2; j++) for (j=0; j < AVI_MASTER_INDEX_SIZE * 2; j++)
put_le64(pb, 0); avio_wl64(pb, 0);
ff_end_tag(pb, avist->indexes.indx_start); ff_end_tag(pb, avist->indexes.indx_start);
} }
@ -329,26 +329,26 @@ static int avi_write_header(AVFormatContext *s)
int num, den; int num, den;
av_reduce(&num, &den, dar.num, dar.den, 0xFFFF); av_reduce(&num, &den, dar.num, dar.den, 0xFFFF);
put_le32(pb, 0); //video format = unknown avio_wl32(pb, 0); //video format = unknown
put_le32(pb, 0); //video standard= unknown avio_wl32(pb, 0); //video standard= unknown
put_le32(pb, lrintf(1.0/av_q2d(stream->time_base))); avio_wl32(pb, lrintf(1.0/av_q2d(stream->time_base)));
put_le32(pb, stream->width ); avio_wl32(pb, stream->width );
put_le32(pb, stream->height); avio_wl32(pb, stream->height);
put_le16(pb, den); avio_wl16(pb, den);
put_le16(pb, num); avio_wl16(pb, num);
put_le32(pb, stream->width ); avio_wl32(pb, stream->width );
put_le32(pb, stream->height); avio_wl32(pb, stream->height);
put_le32(pb, 1); //progressive FIXME avio_wl32(pb, 1); //progressive FIXME
put_le32(pb, stream->height); avio_wl32(pb, stream->height);
put_le32(pb, stream->width ); avio_wl32(pb, stream->width );
put_le32(pb, stream->height); avio_wl32(pb, stream->height);
put_le32(pb, stream->width ); avio_wl32(pb, stream->width );
put_le32(pb, 0); avio_wl32(pb, 0);
put_le32(pb, 0); avio_wl32(pb, 0);
put_le32(pb, 0); avio_wl32(pb, 0);
put_le32(pb, 0); avio_wl32(pb, 0);
ff_end_tag(pb, vprp); ff_end_tag(pb, vprp);
} }
@ -360,9 +360,9 @@ static int avi_write_header(AVFormatContext *s)
avi->odml_list = ff_start_tag(pb, "JUNK"); avi->odml_list = ff_start_tag(pb, "JUNK");
put_tag(pb, "odml"); put_tag(pb, "odml");
put_tag(pb, "dmlh"); put_tag(pb, "dmlh");
put_le32(pb, 248); avio_wl32(pb, 248);
for (i = 0; i < 248; i+= 4) for (i = 0; i < 248; i+= 4)
put_le32(pb, 0); avio_wl32(pb, 0);
ff_end_tag(pb, avi->odml_list); ff_end_tag(pb, avi->odml_list);
} }
@ -380,7 +380,7 @@ static int avi_write_header(AVFormatContext *s)
/* some padding for easier tag editing */ /* some padding for easier tag editing */
list2 = ff_start_tag(pb, "JUNK"); list2 = ff_start_tag(pb, "JUNK");
for (i = 0; i < 1016; i += 4) for (i = 0; i < 1016; i += 4)
put_le32(pb, 0); avio_wl32(pb, 0);
ff_end_tag(pb, list2); ff_end_tag(pb, list2);
avi->movi_list = ff_start_tag(pb, "LIST"); avi->movi_list = ff_start_tag(pb, "LIST");
@ -414,21 +414,21 @@ static int avi_write_ix(AVFormatContext *s)
/* Writing AVI OpenDML leaf index chunk */ /* Writing AVI OpenDML leaf index chunk */
ix = url_ftell(pb); ix = url_ftell(pb);
put_tag(pb, &ix_tag[0]); /* ix?? */ put_tag(pb, &ix_tag[0]); /* ix?? */
put_le32(pb, avist->indexes.entry * 8 + 24); avio_wl32(pb, avist->indexes.entry * 8 + 24);
/* chunk size */ /* chunk size */
put_le16(pb, 2); /* wLongsPerEntry */ avio_wl16(pb, 2); /* wLongsPerEntry */
put_byte(pb, 0); /* bIndexSubType (0 == frame index) */ avio_w8(pb, 0); /* bIndexSubType (0 == frame index) */
put_byte(pb, 1); /* bIndexType (1 == AVI_INDEX_OF_CHUNKS) */ avio_w8(pb, 1); /* bIndexType (1 == AVI_INDEX_OF_CHUNKS) */
put_le32(pb, avist->indexes.entry); avio_wl32(pb, avist->indexes.entry);
/* nEntriesInUse */ /* nEntriesInUse */
put_tag(pb, &tag[0]); /* dwChunkId */ put_tag(pb, &tag[0]); /* dwChunkId */
put_le64(pb, avi->movi_list);/* qwBaseOffset */ avio_wl64(pb, avi->movi_list);/* qwBaseOffset */
put_le32(pb, 0); /* dwReserved_3 (must be 0) */ avio_wl32(pb, 0); /* dwReserved_3 (must be 0) */
for (j=0; j<avist->indexes.entry; j++) { for (j=0; j<avist->indexes.entry; j++) {
AVIIentry* ie = avi_get_ientry(&avist->indexes, j); AVIIentry* ie = avi_get_ientry(&avist->indexes, j);
put_le32(pb, ie->pos + 8); avio_wl32(pb, ie->pos + 8);
put_le32(pb, ((uint32_t)ie->len & ~0x80000000) | avio_wl32(pb, ((uint32_t)ie->len & ~0x80000000) |
(ie->flags & 0x10 ? 0 : 0x80000000)); (ie->flags & 0x10 ? 0 : 0x80000000));
} }
put_flush_packet(pb); put_flush_packet(pb);
@ -438,11 +438,11 @@ static int avi_write_ix(AVFormatContext *s)
url_fseek(pb, avist->indexes.indx_start - 8, SEEK_SET); url_fseek(pb, avist->indexes.indx_start - 8, SEEK_SET);
put_tag(pb, "indx"); /* enabling this entry */ put_tag(pb, "indx"); /* enabling this entry */
url_fskip(pb, 8); url_fskip(pb, 8);
put_le32(pb, avi->riff_id); /* nEntriesInUse */ avio_wl32(pb, avi->riff_id); /* nEntriesInUse */
url_fskip(pb, 16*avi->riff_id); url_fskip(pb, 16*avi->riff_id);
put_le64(pb, ix); /* qwOffset */ avio_wl64(pb, ix); /* qwOffset */
put_le32(pb, pos - ix); /* dwSize */ avio_wl32(pb, pos - ix); /* dwSize */
put_le32(pb, avist->indexes.entry); /* dwDuration */ avio_wl32(pb, avist->indexes.entry); /* dwDuration */
url_fseek(pb, pos, SEEK_SET); url_fseek(pb, pos, SEEK_SET);
} }
@ -487,9 +487,9 @@ static int avi_write_idx1(AVFormatContext *s)
avi_stream2fourcc(&tag[0], stream_id, avi_stream2fourcc(&tag[0], stream_id,
s->streams[stream_id]->codec->codec_type); s->streams[stream_id]->codec->codec_type);
put_tag(pb, &tag[0]); put_tag(pb, &tag[0]);
put_le32(pb, ie->flags); avio_wl32(pb, ie->flags);
put_le32(pb, ie->pos); avio_wl32(pb, ie->pos);
put_le32(pb, ie->len); avio_wl32(pb, ie->len);
avist->entry++; avist->entry++;
} }
} while (!empty); } while (!empty);
@ -565,11 +565,11 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
idx->entry++; idx->entry++;
} }
put_buffer(pb, tag, 4); avio_write(pb, tag, 4);
put_le32(pb, size); avio_wl32(pb, size);
put_buffer(pb, pkt->data, size); avio_write(pb, pkt->data, size);
if (size & 1) if (size & 1)
put_byte(pb, 0); avio_w8(pb, 0);
put_flush_packet(pb); put_flush_packet(pb);
return 0; return 0;
@ -611,7 +611,7 @@ static int avi_write_trailer(AVFormatContext *s)
} }
} }
} }
put_le32(pb, nb_frames); avio_wl32(pb, nb_frames);
url_fseek(pb, file_size, SEEK_SET); url_fseek(pb, file_size, SEEK_SET);
avi_write_counters(s, avi->riff_id); avi_write_counters(s, avi->riff_id);

31
libavformat/avio.h
Unescape View File

@ -395,6 +395,17 @@ attribute_deprecated unsigned int get_be16(AVIOContext *s);
attribute_deprecated unsigned int get_be24(AVIOContext *s); attribute_deprecated unsigned int get_be24(AVIOContext *s);
attribute_deprecated unsigned int get_be32(AVIOContext *s); attribute_deprecated unsigned int get_be32(AVIOContext *s);
attribute_deprecated uint64_t get_be64(AVIOContext *s); attribute_deprecated uint64_t get_be64(AVIOContext *s);
attribute_deprecated void put_byte(AVIOContext *s, int b);
attribute_deprecated void put_buffer(AVIOContext *s, const unsigned char *buf, int size);
attribute_deprecated void put_le64(AVIOContext *s, uint64_t val);
attribute_deprecated void put_be64(AVIOContext *s, uint64_t val);
attribute_deprecated void put_le32(AVIOContext *s, unsigned int val);
attribute_deprecated void put_be32(AVIOContext *s, unsigned int val);
attribute_deprecated void put_le24(AVIOContext *s, unsigned int val);
attribute_deprecated void put_be24(AVIOContext *s, unsigned int val);
attribute_deprecated void put_le16(AVIOContext *s, unsigned int val);
attribute_deprecated void put_be16(AVIOContext *s, unsigned int val);
/** /**
* @} * @}
*/ */
@ -409,17 +420,17 @@ AVIOContext *avio_alloc_context(
int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
int64_t (*seek)(void *opaque, int64_t offset, int whence)); int64_t (*seek)(void *opaque, int64_t offset, int whence));
void put_byte(AVIOContext *s, int b); void avio_w8(AVIOContext *s, int b);
void put_nbyte(AVIOContext *s, int b, int count); void put_nbyte(AVIOContext *s, int b, int count);
void put_buffer(AVIOContext *s, const unsigned char *buf, int size); void avio_write(AVIOContext *s, const unsigned char *buf, int size);
void put_le64(AVIOContext *s, uint64_t val); void avio_wl64(AVIOContext *s, uint64_t val);
void put_be64(AVIOContext *s, uint64_t val); void avio_wb64(AVIOContext *s, uint64_t val);
void put_le32(AVIOContext *s, unsigned int val); void avio_wl32(AVIOContext *s, unsigned int val);
void put_be32(AVIOContext *s, unsigned int val); void avio_wb32(AVIOContext *s, unsigned int val);
void put_le24(AVIOContext *s, unsigned int val); void avio_wl24(AVIOContext *s, unsigned int val);
void put_be24(AVIOContext *s, unsigned int val); void avio_wb24(AVIOContext *s, unsigned int val);
void put_le16(AVIOContext *s, unsigned int val); void avio_wl16(AVIOContext *s, unsigned int val);
void put_be16(AVIOContext *s, unsigned int val); void avio_wb16(AVIOContext *s, unsigned int val);
void put_tag(AVIOContext *s, const char *tag); void put_tag(AVIOContext *s, const char *tag);
#if FF_API_OLD_AVIO #if FF_API_OLD_AVIO

102
libavformat/aviobuf.c
Unescape View File

@ -134,7 +134,7 @@ static void flush_buffer(AVIOContext *s)
s->buf_ptr = s->buffer; s->buf_ptr = s->buffer;
} }
void put_byte(AVIOContext *s, int b) void avio_w8(AVIOContext *s, int b)
{ {
*(s->buf_ptr)++ = b; *(s->buf_ptr)++ = b;
if (s->buf_ptr >= s->buf_end) if (s->buf_ptr >= s->buf_end)
@ -155,7 +155,7 @@ void put_nbyte(AVIOContext *s, int b, int count)
} }
} }
void put_buffer(AVIOContext *s, const unsigned char *buf, int size) void avio_write(AVIOContext *s, const unsigned char *buf, int size)
{ {
while (size > 0) { while (size > 0) {
int len = FFMIN(s->buf_end - s->buf_ptr, size); int len = FFMIN(s->buf_end - s->buf_ptr, size);
@ -277,20 +277,20 @@ int url_ferror(AVIOContext *s)
return s->error; return s->error;
} }
void put_le32(AVIOContext *s, unsigned int val) void avio_wl32(AVIOContext *s, unsigned int val)
{ {
put_byte(s, val); avio_w8(s, val);
put_byte(s, val >> 8); avio_w8(s, val >> 8);
put_byte(s, val >> 16); avio_w8(s, val >> 16);
put_byte(s, val >> 24); avio_w8(s, val >> 24);
} }
void put_be32(AVIOContext *s, unsigned int val) void avio_wb32(AVIOContext *s, unsigned int val)
{ {
put_byte(s, val >> 24); avio_w8(s, val >> 24);
put_byte(s, val >> 16); avio_w8(s, val >> 16);
put_byte(s, val >> 8); avio_w8(s, val >> 8);
put_byte(s, val); avio_w8(s, val);
} }
#if FF_API_OLD_AVIO #if FF_API_OLD_AVIO
@ -316,6 +316,22 @@ GET(64, uint64_t)
#undef GET #undef GET
#define PUT(name, type ) \
void put_le ##name(AVIOContext *s, type val)\
{\
avio_wl ##name(s, val);\
}\
void put_be ##name(AVIOContext *s, type val)\
{\
avio_wb ##name(s, val);\
}
PUT(16, unsigned int)
PUT(24, unsigned int)
PUT(32, unsigned int)
PUT(64, uint64_t)
#undef PUT
int get_byte(AVIOContext *s) int get_byte(AVIOContext *s)
{ {
return avio_r8(s); return avio_r8(s);
@ -328,6 +344,14 @@ int get_partial_buffer(AVIOContext *s, unsigned char *buf, int size)
{ {
return ffio_read_partial(s, buf, size); return ffio_read_partial(s, buf, size);
} }
void put_byte(AVIOContext *s, int val)
{
avio_w8(s, val);
}
void put_buffer(AVIOContext *s, const unsigned char *buf, int size)
{
avio_write(s, buf, size);
}
#endif #endif
int avio_put_str(AVIOContext *s, const char *str) int avio_put_str(AVIOContext *s, const char *str)
@ -335,9 +359,9 @@ int avio_put_str(AVIOContext *s, const char *str)
int len = 1; int len = 1;
if (str) { if (str) {
len += strlen(str); len += strlen(str);
put_buffer(s, (const unsigned char *) str, len); avio_write(s, (const unsigned char *) str, len);
} else } else
put_byte(s, 0); avio_w8(s, 0);
return len; return len;
} }
@ -351,9 +375,9 @@ int avio_put_str16le(AVIOContext *s, const char *str)
uint16_t tmp; uint16_t tmp;
GET_UTF8(ch, *q++, break;) GET_UTF8(ch, *q++, break;)
PUT_UTF16(ch, tmp, put_le16(s, tmp);ret += 2;) PUT_UTF16(ch, tmp, avio_wl16(s, tmp);ret += 2;)
} }
put_le16(s, 0); avio_wl16(s, 0);
ret += 2; ret += 2;
return ret; return ret;
} }
@ -371,51 +395,51 @@ void ff_put_v(AVIOContext *bc, uint64_t val){
int i= ff_get_v_length(val); int i= ff_get_v_length(val);
while(--i>0) while(--i>0)
put_byte(bc, 128 | (val>>(7*i))); avio_w8(bc, 128 | (val>>(7*i)));
put_byte(bc, val&127); avio_w8(bc, val&127);
} }
void put_le64(AVIOContext *s, uint64_t val) void avio_wl64(AVIOContext *s, uint64_t val)
{ {
put_le32(s, (uint32_t)(val & 0xffffffff)); avio_wl32(s, (uint32_t)(val & 0xffffffff));
put_le32(s, (uint32_t)(val >> 32)); avio_wl32(s, (uint32_t)(val >> 32));
} }
void put_be64(AVIOContext *s, uint64_t val) void avio_wb64(AVIOContext *s, uint64_t val)
{ {
put_be32(s, (uint32_t)(val >> 32)); avio_wb32(s, (uint32_t)(val >> 32));
put_be32(s, (uint32_t)(val & 0xffffffff)); avio_wb32(s, (uint32_t)(val & 0xffffffff));
} }
void put_le16(AVIOContext *s, unsigned int val) void avio_wl16(AVIOContext *s, unsigned int val)
{ {
put_byte(s, val); avio_w8(s, val);
put_byte(s, val >> 8); avio_w8(s, val >> 8);
} }
void put_be16(AVIOContext *s, unsigned int val) void avio_wb16(AVIOContext *s, unsigned int val)
{ {
put_byte(s, val >> 8); avio_w8(s, val >> 8);
put_byte(s, val); avio_w8(s, val);
} }
void put_le24(AVIOContext *s, unsigned int val) void avio_wl24(AVIOContext *s, unsigned int val)
{ {
put_le16(s, val & 0xffff); avio_wl16(s, val & 0xffff);
put_byte(s, val >> 16); avio_w8(s, val >> 16);
} }
void put_be24(AVIOContext *s, unsigned int val) void avio_wb24(AVIOContext *s, unsigned int val)
{ {
put_be16(s, val >> 8); avio_wb16(s, val >> 8);
put_byte(s, val); avio_w8(s, val);
} }
void put_tag(AVIOContext *s, const char *tag) void put_tag(AVIOContext *s, const char *tag)
{ {
while (*tag) { while (*tag) {
put_byte(s, *tag++); avio_w8(s, *tag++);
} }
} }
@ -855,7 +879,7 @@ int url_fprintf(AVIOContext *s, const char *fmt, ...)
va_start(ap, fmt); va_start(ap, fmt);
ret = vsnprintf(buf, sizeof(buf), fmt, ap); ret = vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap); va_end(ap);
put_buffer(s, buf, strlen(buf)); avio_write(s, buf, strlen(buf));
return ret; return ret;
} }
#endif //CONFIG_MUXERS #endif //CONFIG_MUXERS
@ -1056,7 +1080,7 @@ int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
/* don't attempt to pad fixed-size packet buffers */ /* don't attempt to pad fixed-size packet buffers */
if (!s->max_packet_size) { if (!s->max_packet_size) {
put_buffer(s, padbuf, sizeof(padbuf)); avio_write(s, padbuf, sizeof(padbuf));
padding = FF_INPUT_BUFFER_PADDING_SIZE; padding = FF_INPUT_BUFFER_PADDING_SIZE;
} }

2
libavformat/crcenc.c
Unescape View File

@ -49,7 +49,7 @@ static int crc_write_trailer(struct AVFormatContext *s)
char buf[64]; char buf[64];
snprintf(buf, sizeof(buf), "CRC=0x%08x\n", crc->crcval); snprintf(buf, sizeof(buf), "CRC=0x%08x\n", crc->crcval);
put_buffer(s->pb, buf, strlen(buf)); avio_write(s->pb, buf, strlen(buf));
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;
} }

6
libavformat/daud.c
Unescape View File

@ -57,9 +57,9 @@ static int daud_write_header(struct AVFormatContext *s)
static int daud_write_packet(struct AVFormatContext *s, AVPacket *pkt) static int daud_write_packet(struct AVFormatContext *s, AVPacket *pkt)
{ {
put_be16(s->pb, pkt->size); avio_wb16(s->pb, pkt->size);
put_be16(s->pb, 0x8010); // unknown avio_wb16(s->pb, 0x8010); // unknown
put_buffer(s->pb, pkt->data, pkt->size); avio_write(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;
} }

2
libavformat/dvenc.c
Unescape View File

@ -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], fsize = dv_assemble_frame(s->priv_data, s->streams[pkt->stream_index],
pkt->data, pkt->size, &frame); pkt->data, pkt->size, &frame);
if (fsize > 0) { if (fsize > 0) {
put_buffer(s->pb, frame, fsize); avio_write(s->pb, frame, fsize);
put_flush_packet(s->pb); put_flush_packet(s->pb);
} }
return 0; return 0;

140
libavformat/ffmenc.c
Unescape View File

@ -36,14 +36,14 @@ static void flush_packet(AVFormatContext *s)
av_abort(); av_abort();
/* put header */ /* put header */
put_be16(pb, PACKET_ID); avio_wb16(pb, PACKET_ID);
put_be16(pb, fill_size); avio_wb16(pb, fill_size);
put_be64(pb, ffm->dts); avio_wb64(pb, ffm->dts);
h = ffm->frame_offset; h = ffm->frame_offset;
if (ffm->first_packet) if (ffm->first_packet)
h |= 0x8000; h |= 0x8000;
put_be16(pb, h); avio_wb16(pb, h);
put_buffer(pb, ffm->packet, ffm->packet_end - ffm->packet); avio_write(pb, ffm->packet, ffm->packet_end - ffm->packet);
put_flush_packet(pb); put_flush_packet(pb);
/* prepare next packet */ /* prepare next packet */
@ -91,17 +91,17 @@ static int ffm_write_header(AVFormatContext *s)
ffm->packet_size = FFM_PACKET_SIZE; ffm->packet_size = FFM_PACKET_SIZE;
/* header */ /* header */
put_le32(pb, MKTAG('F', 'F', 'M', '1')); avio_wl32(pb, MKTAG('F', 'F', 'M', '1'));
put_be32(pb, ffm->packet_size); avio_wb32(pb, ffm->packet_size);
put_be64(pb, 0); /* current write position */ avio_wb64(pb, 0); /* current write position */
put_be32(pb, s->nb_streams); avio_wb32(pb, s->nb_streams);
bit_rate = 0; bit_rate = 0;
for(i=0;i<s->nb_streams;i++) { for(i=0;i<s->nb_streams;i++) {
st = s->streams[i]; st = s->streams[i];
bit_rate += st->codec->bit_rate; bit_rate += st->codec->bit_rate;
} }
put_be32(pb, bit_rate); avio_wb32(pb, bit_rate);
/* list of streams */ /* list of streams */
for(i=0;i<s->nb_streams;i++) { for(i=0;i<s->nb_streams;i++) {
@ -110,82 +110,82 @@ static int ffm_write_header(AVFormatContext *s)
codec = st->codec; codec = st->codec;
/* generic info */ /* generic info */
put_be32(pb, codec->codec_id); avio_wb32(pb, codec->codec_id);
put_byte(pb, codec->codec_type); avio_w8(pb, codec->codec_type);
put_be32(pb, codec->bit_rate); avio_wb32(pb, codec->bit_rate);
put_be32(pb, st->quality); avio_wb32(pb, st->quality);
put_be32(pb, codec->flags); avio_wb32(pb, codec->flags);
put_be32(pb, codec->flags2); avio_wb32(pb, codec->flags2);
put_be32(pb, codec->debug); avio_wb32(pb, codec->debug);
/* specific info */ /* specific info */
switch(codec->codec_type) { switch(codec->codec_type) {
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
put_be32(pb, codec->time_base.num); avio_wb32(pb, codec->time_base.num);
put_be32(pb, codec->time_base.den); avio_wb32(pb, codec->time_base.den);
put_be16(pb, codec->width); avio_wb16(pb, codec->width);
put_be16(pb, codec->height); avio_wb16(pb, codec->height);
put_be16(pb, codec->gop_size); avio_wb16(pb, codec->gop_size);
put_be32(pb, codec->pix_fmt); avio_wb32(pb, codec->pix_fmt);
put_byte(pb, codec->qmin); avio_w8(pb, codec->qmin);
put_byte(pb, codec->qmax); avio_w8(pb, codec->qmax);
put_byte(pb, codec->max_qdiff); avio_w8(pb, codec->max_qdiff);
put_be16(pb, (int) (codec->qcompress * 10000.0)); avio_wb16(pb, (int) (codec->qcompress * 10000.0));
put_be16(pb, (int) (codec->qblur * 10000.0)); avio_wb16(pb, (int) (codec->qblur * 10000.0));
put_be32(pb, codec->bit_rate_tolerance); avio_wb32(pb, codec->bit_rate_tolerance);
avio_put_str(pb, codec->rc_eq ? codec->rc_eq : "tex^qComp"); avio_put_str(pb, codec->rc_eq ? codec->rc_eq : "tex^qComp");
put_be32(pb, codec->rc_max_rate); avio_wb32(pb, codec->rc_max_rate);
put_be32(pb, codec->rc_min_rate); avio_wb32(pb, codec->rc_min_rate);
put_be32(pb, codec->rc_buffer_size); avio_wb32(pb, codec->rc_buffer_size);
put_be64(pb, av_dbl2int(codec->i_quant_factor)); avio_wb64(pb, av_dbl2int(codec->i_quant_factor));
put_be64(pb, av_dbl2int(codec->b_quant_factor)); avio_wb64(pb, av_dbl2int(codec->b_quant_factor));
put_be64(pb, av_dbl2int(codec->i_quant_offset)); avio_wb64(pb, av_dbl2int(codec->i_quant_offset));
put_be64(pb, av_dbl2int(codec->b_quant_offset)); avio_wb64(pb, av_dbl2int(codec->b_quant_offset));
put_be32(pb, codec->dct_algo); avio_wb32(pb, codec->dct_algo);
put_be32(pb, codec->strict_std_compliance); avio_wb32(pb, codec->strict_std_compliance);
put_be32(pb, codec->max_b_frames); avio_wb32(pb, codec->max_b_frames);
put_be32(pb, codec->luma_elim_threshold); avio_wb32(pb, codec->luma_elim_threshold);
put_be32(pb, codec->chroma_elim_threshold); avio_wb32(pb, codec->chroma_elim_threshold);
put_be32(pb, codec->mpeg_quant); avio_wb32(pb, codec->mpeg_quant);
put_be32(pb, codec->intra_dc_precision); avio_wb32(pb, codec->intra_dc_precision);
put_be32(pb, codec->me_method); avio_wb32(pb, codec->me_method);
put_be32(pb, codec->mb_decision); avio_wb32(pb, codec->mb_decision);
put_be32(pb, codec->nsse_weight); avio_wb32(pb, codec->nsse_weight);
put_be32(pb, codec->frame_skip_cmp); avio_wb32(pb, codec->frame_skip_cmp);
put_be64(pb, av_dbl2int(codec->rc_buffer_aggressivity)); avio_wb64(pb, av_dbl2int(codec->rc_buffer_aggressivity));
put_be32(pb, codec->codec_tag); avio_wb32(pb, codec->codec_tag);
put_byte(pb, codec->thread_count); avio_w8(pb, codec->thread_count);
put_be32(pb, codec->coder_type); avio_wb32(pb, codec->coder_type);
put_be32(pb, codec->me_cmp); avio_wb32(pb, codec->me_cmp);
put_be32(pb, codec->partitions); avio_wb32(pb, codec->partitions);
put_be32(pb, codec->me_subpel_quality); avio_wb32(pb, codec->me_subpel_quality);
put_be32(pb, codec->me_range); avio_wb32(pb, codec->me_range);
put_be32(pb, codec->keyint_min); avio_wb32(pb, codec->keyint_min);
put_be32(pb, codec->scenechange_threshold); avio_wb32(pb, codec->scenechange_threshold);
put_be32(pb, codec->b_frame_strategy); avio_wb32(pb, codec->b_frame_strategy);
put_be64(pb, av_dbl2int(codec->qcompress)); avio_wb64(pb, av_dbl2int(codec->qcompress));
put_be64(pb, av_dbl2int(codec->qblur)); avio_wb64(pb, av_dbl2int(codec->qblur));
put_be32(pb, codec->max_qdiff); avio_wb32(pb, codec->max_qdiff);
put_be32(pb, codec->refs); avio_wb32(pb, codec->refs);
put_be32(pb, codec->directpred); avio_wb32(pb, codec->directpred);
break; break;
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
put_be32(pb, codec->sample_rate); avio_wb32(pb, codec->sample_rate);
put_le16(pb, codec->channels); avio_wl16(pb, codec->channels);
put_le16(pb, codec->frame_size); avio_wl16(pb, codec->frame_size);
put_le16(pb, codec->sample_fmt); avio_wl16(pb, codec->sample_fmt);
break; break;
default: default:
return -1; return -1;
} }
if (codec->flags & CODEC_FLAG_GLOBAL_HEADER) { if (codec->flags & CODEC_FLAG_GLOBAL_HEADER) {
put_be32(pb, codec->extradata_size); avio_wb32(pb, codec->extradata_size);
put_buffer(pb, codec->extradata, codec->extradata_size); avio_write(pb, codec->extradata, codec->extradata_size);
} }
} }
/* flush until end of block reached */ /* flush until end of block reached */
while ((url_ftell(pb) % ffm->packet_size) != 0) while ((url_ftell(pb) % ffm->packet_size) != 0)
put_byte(pb, 0); avio_w8(pb, 0);
put_flush_packet(pb); put_flush_packet(pb);

16
libavformat/ffmetaenc.c
Unescape View File

@ -31,8 +31,8 @@ static void write_escape_str(AVIOContext *s, const uint8_t *str)
while (*p) { while (*p) {
if (*p == '#' || *p == ';' || *p == '=' || *p == '\\' || *p == '\n') if (*p == '#' || *p == ';' || *p == '=' || *p == '\\' || *p == '\n')
put_byte(s, '\\'); avio_w8(s, '\\');
put_byte(s, *p); avio_w8(s, *p);
p++; p++;
} }
} }
@ -42,17 +42,17 @@ static void write_tags(AVIOContext *s, AVMetadata *m)
AVMetadataTag *t = NULL; AVMetadataTag *t = NULL;
while ((t = av_metadata_get(m, "", t, AV_METADATA_IGNORE_SUFFIX))) { while ((t = av_metadata_get(m, "", t, AV_METADATA_IGNORE_SUFFIX))) {
write_escape_str(s, t->key); write_escape_str(s, t->key);
put_byte(s, '='); avio_w8(s, '=');
write_escape_str(s, t->value); write_escape_str(s, t->value);
put_byte(s, '\n'); avio_w8(s, '\n');
} }
} }
static int write_header(AVFormatContext *s) static int write_header(AVFormatContext *s)
{ {
put_tag(s->pb, ID_STRING); put_tag(s->pb, ID_STRING);
put_byte(s->pb, '1'); // version avio_w8(s->pb, '1'); // version
put_byte(s->pb, '\n'); avio_w8(s->pb, '\n');
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;
} }
@ -65,14 +65,14 @@ static int write_trailer(AVFormatContext *s)
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
put_tag(s->pb, ID_STREAM); put_tag(s->pb, ID_STREAM);
put_byte(s->pb, '\n'); avio_w8(s->pb, '\n');
write_tags(s->pb, s->streams[i]->metadata); write_tags(s->pb, s->streams[i]->metadata);
} }
for (i = 0; i < s->nb_chapters; i++) { for (i = 0; i < s->nb_chapters; i++) {
AVChapter *ch = s->chapters[i]; AVChapter *ch = s->chapters[i];
put_tag(s->pb, ID_CHAPTER); put_tag(s->pb, ID_CHAPTER);
put_byte(s->pb, '\n'); avio_w8(s->pb, '\n');
url_fprintf(s->pb, "TIMEBASE=%d/%d\n", ch->time_base.num, ch->time_base.den); 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, "START=%"PRId64"\n", ch->start);
url_fprintf(s->pb, "END=%"PRId64"\n", ch->end); url_fprintf(s->pb, "END=%"PRId64"\n", ch->end);

20
libavformat/filmstripenc.c
Unescape View File

@ -45,7 +45,7 @@ static int write_header(AVFormatContext *s)
static int write_packet(AVFormatContext *s, AVPacket *pkt) static int write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
FilmstripMuxContext *film = s->priv_data; FilmstripMuxContext *film = s->priv_data;
put_buffer(s->pb, pkt->data, pkt->size); avio_write(s->pb, pkt->data, pkt->size);
film->nb_frames++; film->nb_frames++;
return 0; return 0;
} }
@ -57,16 +57,16 @@ static int write_trailer(AVFormatContext *s)
AVStream *st = s->streams[0]; AVStream *st = s->streams[0];
int i; int i;
put_be32(pb, RAND_TAG); avio_wb32(pb, RAND_TAG);
put_be32(pb, film->nb_frames); avio_wb32(pb, film->nb_frames);
put_be16(pb, 0); // packing method avio_wb16(pb, 0); // packing method
put_be16(pb, 0); // reserved avio_wb16(pb, 0); // reserved
put_be16(pb, st->codec->width); avio_wb16(pb, st->codec->width);
put_be16(pb, st->codec->height); avio_wb16(pb, st->codec->height);
put_be16(pb, 0); // leading avio_wb16(pb, 0); // leading
put_be16(pb, 1/av_q2d(st->codec->time_base)); avio_wb16(pb, 1/av_q2d(st->codec->time_base));
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
put_byte(pb, 0x00); // reserved avio_w8(pb, 0x00); // reserved
put_flush_packet(pb); put_flush_packet(pb);
return 0; return 0;
} }

12
libavformat/flacenc.c
Unescape View File

@ -30,10 +30,10 @@
static int flac_write_block_padding(AVIOContext *pb, unsigned int n_padding_bytes, static int flac_write_block_padding(AVIOContext *pb, unsigned int n_padding_bytes,
int last_block) int last_block)
{ {
put_byte(pb, last_block ? 0x81 : 0x01); avio_w8(pb, last_block ? 0x81 : 0x01);
put_be24(pb, n_padding_bytes); avio_wb24(pb, n_padding_bytes);
while (n_padding_bytes > 0) { while (n_padding_bytes > 0) {
put_byte(pb, 0); avio_w8(pb, 0);
n_padding_bytes--; n_padding_bytes--;
} }
return 0; return 0;
@ -58,7 +58,7 @@ static int flac_write_block_comment(AVIOContext *pb, AVMetadata **m,
bytestream_put_be24(&p, len); bytestream_put_be24(&p, len);
ff_vorbiscomment_write(&p, m, vendor, count); ff_vorbiscomment_write(&p, m, vendor, count);
put_buffer(pb, p0, len+4); avio_write(pb, p0, len+4);
av_freep(&p0); av_freep(&p0);
p = NULL; p = NULL;
@ -102,7 +102,7 @@ static int flac_write_trailer(struct AVFormatContext *s)
/* rewrite the STREAMINFO header block data */ /* rewrite the STREAMINFO header block data */
file_size = url_ftell(pb); file_size = url_ftell(pb);
url_fseek(pb, 8, SEEK_SET); url_fseek(pb, 8, SEEK_SET);
put_buffer(pb, streaminfo, FLAC_STREAMINFO_SIZE); avio_write(pb, streaminfo, FLAC_STREAMINFO_SIZE);
url_fseek(pb, file_size, SEEK_SET); url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb); put_flush_packet(pb);
} else { } else {
@ -113,7 +113,7 @@ static int flac_write_trailer(struct AVFormatContext *s)
static int flac_write_packet(struct AVFormatContext *s, AVPacket *pkt) static int flac_write_packet(struct AVFormatContext *s, AVPacket *pkt)
{ {
put_buffer(s->pb, pkt->data, pkt->size); avio_write(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;
} }

4
libavformat/flacenc_header.c
Unescape View File

@ -39,11 +39,11 @@ int ff_flac_write_header(AVIOContext *pb, AVCodecContext *codec,
/* write "fLaC" stream marker and first metadata block header if needed */ /* write "fLaC" stream marker and first metadata block header if needed */
if (format == FLAC_EXTRADATA_FORMAT_STREAMINFO) { if (format == FLAC_EXTRADATA_FORMAT_STREAMINFO) {
put_buffer(pb, header, 8); avio_write(pb, header, 8);
} }
/* write STREAMINFO or full header */ /* write STREAMINFO or full header */
put_buffer(pb, codec->extradata, codec->extradata_size); avio_write(pb, codec->extradata, codec->extradata_size);
return 0; return 0;
} }

124
libavformat/flvenc.c
Unescape View File

@ -142,31 +142,31 @@ static int get_audio_flags(AVCodecContext *enc){
static void put_amf_string(AVIOContext *pb, const char *str) static void put_amf_string(AVIOContext *pb, const char *str)
{ {
size_t len = strlen(str); size_t len = strlen(str);
put_be16(pb, len); avio_wb16(pb, len);
put_buffer(pb, str, len); avio_write(pb, str, len);
} }
static void put_avc_eos_tag(AVIOContext *pb, unsigned ts) { static void put_avc_eos_tag(AVIOContext *pb, unsigned ts) {
put_byte(pb, FLV_TAG_TYPE_VIDEO); avio_w8(pb, FLV_TAG_TYPE_VIDEO);
put_be24(pb, 5); /* Tag Data Size */ avio_wb24(pb, 5); /* Tag Data Size */
put_be24(pb, ts); /* lower 24 bits of timestamp in ms*/ avio_wb24(pb, ts); /* lower 24 bits of timestamp in ms*/
put_byte(pb, (ts >> 24) & 0x7F); /* MSB of ts in ms*/ avio_w8(pb, (ts >> 24) & 0x7F); /* MSB of ts in ms*/
put_be24(pb, 0); /* StreamId = 0 */ avio_wb24(pb, 0); /* StreamId = 0 */
put_byte(pb, 23); /* ub[4] FrameType = 1, ub[4] CodecId = 7 */ avio_w8(pb, 23); /* ub[4] FrameType = 1, ub[4] CodecId = 7 */
put_byte(pb, 2); /* AVC end of sequence */ avio_w8(pb, 2); /* AVC end of sequence */
put_be24(pb, 0); /* Always 0 for AVC EOS. */ avio_wb24(pb, 0); /* Always 0 for AVC EOS. */
put_be32(pb, 16); /* Size of FLV tag */ avio_wb32(pb, 16); /* Size of FLV tag */
} }
static void put_amf_double(AVIOContext *pb, double d) static void put_amf_double(AVIOContext *pb, double d)
{ {
put_byte(pb, AMF_DATA_TYPE_NUMBER); avio_w8(pb, AMF_DATA_TYPE_NUMBER);
put_be64(pb, av_dbl2int(d)); avio_wb64(pb, av_dbl2int(d));
} }
static void put_amf_bool(AVIOContext *pb, int b) { static void put_amf_bool(AVIOContext *pb, int b) {
put_byte(pb, AMF_DATA_TYPE_BOOL); avio_w8(pb, AMF_DATA_TYPE_BOOL);
put_byte(pb, !!b); avio_w8(pb, !!b);
} }
static int flv_write_header(AVFormatContext *s) static int flv_write_header(AVFormatContext *s)
@ -200,19 +200,19 @@ static int flv_write_header(AVFormatContext *s)
av_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */ av_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
} }
put_tag(pb,"FLV"); put_tag(pb,"FLV");
put_byte(pb,1); avio_w8(pb,1);
put_byte(pb, FLV_HEADER_FLAG_HASAUDIO * !!audio_enc avio_w8(pb, FLV_HEADER_FLAG_HASAUDIO * !!audio_enc
+ FLV_HEADER_FLAG_HASVIDEO * !!video_enc); + FLV_HEADER_FLAG_HASVIDEO * !!video_enc);
put_be32(pb,9); avio_wb32(pb,9);
put_be32(pb,0); avio_wb32(pb,0);
for(i=0; i<s->nb_streams; i++){ for(i=0; i<s->nb_streams; i++){
if(s->streams[i]->codec->codec_tag == 5){ if(s->streams[i]->codec->codec_tag == 5){
put_byte(pb,8); // message type avio_w8(pb,8); // message type
put_be24(pb,0); // include flags avio_wb24(pb,0); // include flags
put_be24(pb,0); // time stamp avio_wb24(pb,0); // time stamp
put_be32(pb,0); // reserved avio_wb32(pb,0); // reserved
put_be32(pb,11); // size avio_wb32(pb,11); // size
flv->reserved=5; flv->reserved=5;
} }
} }
@ -220,21 +220,21 @@ static int flv_write_header(AVFormatContext *s)
flv->last_video_ts = -1; flv->last_video_ts = -1;
/* write meta_tag */ /* write meta_tag */
put_byte(pb, 18); // tag type META avio_w8(pb, 18); // tag type META
metadata_size_pos= url_ftell(pb); metadata_size_pos= url_ftell(pb);
put_be24(pb, 0); // size of data part (sum of all parts below) avio_wb24(pb, 0); // size of data part (sum of all parts below)
put_be24(pb, 0); // time stamp avio_wb24(pb, 0); // time stamp
put_be32(pb, 0); // reserved avio_wb32(pb, 0); // reserved
/* now data of data_size size */ /* now data of data_size size */
/* first event name as a string */ /* first event name as a string */
put_byte(pb, AMF_DATA_TYPE_STRING); avio_w8(pb, AMF_DATA_TYPE_STRING);
put_amf_string(pb, "onMetaData"); // 12 bytes put_amf_string(pb, "onMetaData"); // 12 bytes
/* mixed array (hash) with size and string/type/data tuples */ /* mixed array (hash) with size and string/type/data tuples */
put_byte(pb, AMF_DATA_TYPE_MIXEDARRAY); avio_w8(pb, AMF_DATA_TYPE_MIXEDARRAY);
put_be32(pb, 5*!!video_enc + 5*!!audio_enc + 2); // +2 for duration and file size avio_wb32(pb, 5*!!video_enc + 5*!!audio_enc + 2); // +2 for duration and file size
put_amf_string(pb, "duration"); put_amf_string(pb, "duration");
flv->duration_offset= url_ftell(pb); 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))) { while ((tag = av_metadata_get(s->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
put_amf_string(pb, tag->key); put_amf_string(pb, tag->key);
put_byte(pb, AMF_DATA_TYPE_STRING); avio_w8(pb, AMF_DATA_TYPE_STRING);
put_amf_string(pb, tag->value); 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_double(pb, 0); // delayed write
put_amf_string(pb, ""); put_amf_string(pb, "");
put_byte(pb, AMF_END_OF_OBJECT); avio_w8(pb, AMF_END_OF_OBJECT);
/* write total size of tag */ /* write total size of tag */
data_size= url_ftell(pb) - metadata_size_pos - 10; data_size= url_ftell(pb) - metadata_size_pos - 10;
url_fseek(pb, metadata_size_pos, SEEK_SET); url_fseek(pb, metadata_size_pos, SEEK_SET);
put_be24(pb, data_size); avio_wb24(pb, data_size);
url_fseek(pb, data_size + 10 - 3, SEEK_CUR); url_fseek(pb, data_size + 10 - 3, SEEK_CUR);
put_be32(pb, data_size + 11); avio_wb32(pb, data_size + 11);
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
AVCodecContext *enc = s->streams[i]->codec; AVCodecContext *enc = s->streams[i]->codec;
if (enc->codec_id == CODEC_ID_AAC || enc->codec_id == CODEC_ID_H264) { if (enc->codec_id == CODEC_ID_AAC || enc->codec_id == CODEC_ID_H264) {
int64_t pos; int64_t pos;
put_byte(pb, enc->codec_type == AVMEDIA_TYPE_VIDEO ? avio_w8(pb, enc->codec_type == AVMEDIA_TYPE_VIDEO ?
FLV_TAG_TYPE_VIDEO : FLV_TAG_TYPE_AUDIO); FLV_TAG_TYPE_VIDEO : FLV_TAG_TYPE_AUDIO);
put_be24(pb, 0); // size patched later avio_wb24(pb, 0); // size patched later
put_be24(pb, 0); // ts avio_wb24(pb, 0); // ts
put_byte(pb, 0); // ts ext avio_w8(pb, 0); // ts ext
put_be24(pb, 0); // streamid avio_wb24(pb, 0); // streamid
pos = url_ftell(pb); pos = url_ftell(pb);
if (enc->codec_id == CODEC_ID_AAC) { if (enc->codec_id == CODEC_ID_AAC) {
put_byte(pb, get_audio_flags(enc)); avio_w8(pb, get_audio_flags(enc));
put_byte(pb, 0); // AAC sequence header avio_w8(pb, 0); // AAC sequence header
put_buffer(pb, enc->extradata, enc->extradata_size); avio_write(pb, enc->extradata, enc->extradata_size);
} else { } else {
put_byte(pb, enc->codec_tag | FLV_FRAME_KEY); // flags avio_w8(pb, enc->codec_tag | FLV_FRAME_KEY); // flags
put_byte(pb, 0); // AVC sequence header avio_w8(pb, 0); // AVC sequence header
put_be24(pb, 0); // composition time avio_wb24(pb, 0); // composition time
ff_isom_write_avcc(pb, enc->extradata, enc->extradata_size); ff_isom_write_avcc(pb, enc->extradata, enc->extradata_size);
} }
data_size = url_ftell(pb) - pos; data_size = url_ftell(pb) - pos;
url_fseek(pb, -data_size - 10, SEEK_CUR); url_fseek(pb, -data_size - 10, SEEK_CUR);
put_be24(pb, data_size); avio_wb24(pb, data_size);
url_fseek(pb, data_size + 10 - 3, SEEK_CUR); url_fseek(pb, data_size + 10 - 3, SEEK_CUR);
put_be32(pb, data_size + 11); // previous tag size avio_wb32(pb, data_size + 11); // previous tag size
} }
} }
@ -376,7 +376,7 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
flags_size= 1; flags_size= 1;
if (enc->codec_type == AVMEDIA_TYPE_VIDEO) { if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
put_byte(pb, FLV_TAG_TYPE_VIDEO); avio_w8(pb, FLV_TAG_TYPE_VIDEO);
flags = enc->codec_tag; flags = enc->codec_tag;
if(flags == 0) { if(flags == 0) {
@ -391,7 +391,7 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
assert(size); assert(size);
put_byte(pb, FLV_TAG_TYPE_AUDIO); avio_w8(pb, FLV_TAG_TYPE_AUDIO);
} }
if (enc->codec_id == CODEC_ID_H264) { 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) if (flv->last_video_ts < ts)
flv->last_video_ts = ts; flv->last_video_ts = ts;
} }
put_be24(pb,size + flags_size); avio_wb24(pb,size + flags_size);
put_be24(pb,ts); avio_wb24(pb,ts);
put_byte(pb,(ts >> 24) & 0x7F); // timestamps are 32bits _signed_ avio_w8(pb,(ts >> 24) & 0x7F); // timestamps are 32bits _signed_
put_be24(pb,flv->reserved); avio_wb24(pb,flv->reserved);
put_byte(pb,flags); avio_w8(pb,flags);
if (enc->codec_id == CODEC_ID_VP6) if (enc->codec_id == CODEC_ID_VP6)
put_byte(pb,0); avio_w8(pb,0);
if (enc->codec_id == CODEC_ID_VP6F) if (enc->codec_id == CODEC_ID_VP6F)
put_byte(pb, enc->extradata_size ? enc->extradata[0] : 0); avio_w8(pb, enc->extradata_size ? enc->extradata[0] : 0);
else if (enc->codec_id == CODEC_ID_AAC) else if (enc->codec_id == CODEC_ID_AAC)
put_byte(pb,1); // AAC raw avio_w8(pb,1); // AAC raw
else if (enc->codec_id == CODEC_ID_H264) { else if (enc->codec_id == CODEC_ID_H264) {
put_byte(pb,1); // AVC NALU avio_w8(pb,1); // AVC NALU
put_be24(pb,pkt->pts - pkt->dts); avio_wb24(pb,pkt->pts - pkt->dts);
} }
put_buffer(pb, data ? data : pkt->data, size); avio_write(pb, data ? data : pkt->data, size);
put_be32(pb,size+flags_size+11); // previous tag size avio_wb32(pb,size+flags_size+11); // previous tag size
flv->duration = FFMAX(flv->duration, pkt->pts + flv->delay + pkt->duration); flv->duration = FFMAX(flv->duration, pkt->pts + flv->delay + pkt->duration);
put_flush_packet(pb); put_flush_packet(pb);

2
libavformat/framecrcenc.c
Unescape View File

@ -28,7 +28,7 @@ static int framecrc_write_packet(struct AVFormatContext *s, AVPacket *pkt)
char buf[256]; char buf[256];
snprintf(buf, sizeof(buf), "%d, %"PRId64", %d, 0x%08x\n", pkt->stream_index, pkt->dts, pkt->size, crc); 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_write(s->pb, buf, strlen(buf));
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;
} }

70
libavformat/gif.c
Unescape View File

@ -116,24 +116,24 @@ static int gif_image_write_header(AVIOContext *pb,
put_tag(pb, "GIF"); put_tag(pb, "GIF");
put_tag(pb, "89a"); put_tag(pb, "89a");
put_le16(pb, width); avio_wl16(pb, width);
put_le16(pb, height); avio_wl16(pb, height);
put_byte(pb, 0xf7); /* flags: global clut, 256 entries */ avio_w8(pb, 0xf7); /* flags: global clut, 256 entries */
put_byte(pb, 0x1f); /* background color index */ avio_w8(pb, 0x1f); /* background color index */
put_byte(pb, 0); /* aspect ratio */ avio_w8(pb, 0); /* aspect ratio */
/* the global palette */ /* the global palette */
if (!palette) { if (!palette) {
put_buffer(pb, (const unsigned char *)gif_clut, 216*3); avio_write(pb, (const unsigned char *)gif_clut, 216*3);
for(i=0;i<((256-216)*3);i++) for(i=0;i<((256-216)*3);i++)
put_byte(pb, 0); avio_w8(pb, 0);
} else { } else {
for(i=0;i<256;i++) { for(i=0;i<256;i++) {
v = palette[i]; v = palette[i];
put_byte(pb, (v >> 16) & 0xff); avio_w8(pb, (v >> 16) & 0xff);
put_byte(pb, (v >> 8) & 0xff); avio_w8(pb, (v >> 8) & 0xff);
put_byte(pb, (v) & 0xff); avio_w8(pb, (v) & 0xff);
} }
} }
@ -159,14 +159,14 @@ static int gif_image_write_header(AVIOContext *pb,
/* application extension header */ /* application extension header */
#ifdef GIF_ADD_APP_HEADER #ifdef GIF_ADD_APP_HEADER
if (loop_count >= 0 && loop_count <= 65535) { if (loop_count >= 0 && loop_count <= 65535) {
put_byte(pb, 0x21); avio_w8(pb, 0x21);
put_byte(pb, 0xff); avio_w8(pb, 0xff);
put_byte(pb, 0x0b); avio_w8(pb, 0x0b);
put_tag(pb, "NETSCAPE2.0"); // bytes 4 to 14 put_tag(pb, "NETSCAPE2.0"); // bytes 4 to 14
put_byte(pb, 0x03); // byte 15 avio_w8(pb, 0x03); // byte 15
put_byte(pb, 0x01); // byte 16 avio_w8(pb, 0x01); // byte 16
put_le16(pb, (uint16_t)loop_count); avio_wl16(pb, (uint16_t)loop_count);
put_byte(pb, 0x00); // byte 19 avio_w8(pb, 0x00); // byte 19
} }
#endif #endif
return 0; return 0;
@ -189,15 +189,15 @@ static int gif_image_write_image(AVIOContext *pb,
const uint8_t *ptr; const uint8_t *ptr;
/* image block */ /* image block */
put_byte(pb, 0x2c); avio_w8(pb, 0x2c);
put_le16(pb, x1); avio_wl16(pb, x1);
put_le16(pb, y1); avio_wl16(pb, y1);
put_le16(pb, width); avio_wl16(pb, width);
put_le16(pb, height); avio_wl16(pb, height);
put_byte(pb, 0x00); /* flags */ avio_w8(pb, 0x00); /* flags */
/* no local clut */ /* no local clut */
put_byte(pb, 0x08); avio_w8(pb, 0x08);
left= width * height; left= width * height;
@ -233,13 +233,13 @@ static int gif_image_write_image(AVIOContext *pb,
flush_put_bits(&p); flush_put_bits(&p);
} }
if(put_bits_ptr(&p) - p.buf > 0) { if(put_bits_ptr(&p) - p.buf > 0) {
put_byte(pb, put_bits_ptr(&p) - p.buf); /* byte count of the packet */ avio_w8(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_write(pb, p.buf, put_bits_ptr(&p) - p.buf); /* the actual buffer */
p.buf_ptr = p.buf; /* dequeue the bytes off the bitstream */ p.buf_ptr = p.buf; /* dequeue the bytes off the bitstream */
} }
left-=GIF_CHUNKS; left-=GIF_CHUNKS;
} }
put_byte(pb, 0x00); /* end of image block */ avio_w8(pb, 0x00); /* end of image block */
return 0; return 0;
} }
@ -300,10 +300,10 @@ static int gif_write_video(AVFormatContext *s,
int64_t delay; int64_t delay;
/* graphic control extension block */ /* graphic control extension block */
put_byte(pb, 0x21); avio_w8(pb, 0x21);
put_byte(pb, 0xf9); avio_w8(pb, 0xf9);
put_byte(pb, 0x04); /* block size */ avio_w8(pb, 0x04); /* block size */
put_byte(pb, 0x04); /* flags */ avio_w8(pb, 0x04); /* flags */
/* 1 jiffy is 1/70 s */ /* 1 jiffy is 1/70 s */
/* the delay_time field indicates the number of jiffies - 1 */ /* 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 */ /* XXX: don't even remember if I really use it for now */
jiffies = (70*enc->time_base.num/enc->time_base.den) - 1; jiffies = (70*enc->time_base.num/enc->time_base.den) - 1;
put_le16(pb, jiffies); avio_wl16(pb, jiffies);
put_byte(pb, 0x1f); /* transparent color index */ avio_w8(pb, 0x1f); /* transparent color index */
put_byte(pb, 0x00); avio_w8(pb, 0x00);
gif_image_write_image(pb, 0, 0, enc->width, enc->height, gif_image_write_image(pb, 0, 0, enc->width, enc->height,
buf, enc->width * 3, PIX_FMT_RGB24); buf, enc->width * 3, PIX_FMT_RGB24);
@ -339,7 +339,7 @@ static int gif_write_trailer(AVFormatContext *s)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
put_byte(pb, 0x3b); avio_w8(pb, 0x3b);
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;
} }

322
libavformat/gxfenc.c
Unescape View File

@ -116,7 +116,7 @@ static int gxf_find_lines_index(AVStream *st)
static void gxf_write_padding(AVIOContext *pb, int64_t to_pad) static void gxf_write_padding(AVIOContext *pb, int64_t to_pad)
{ {
for (; to_pad > 0; to_pad--) { for (; to_pad > 0; to_pad--) {
put_byte(pb, 0); avio_w8(pb, 0);
} }
} }
@ -132,7 +132,7 @@ static int64_t updatePacketSize(AVIOContext *pb, int64_t pos)
} }
curpos = url_ftell(pb); curpos = url_ftell(pb);
url_fseek(pb, pos + 6, SEEK_SET); url_fseek(pb, pos + 6, SEEK_SET);
put_be32(pb, size); avio_wb32(pb, size);
url_fseek(pb, curpos, SEEK_SET); url_fseek(pb, curpos, SEEK_SET);
return curpos - pos; return curpos - pos;
} }
@ -143,20 +143,20 @@ static int64_t updateSize(AVIOContext *pb, int64_t pos)
curpos = url_ftell(pb); curpos = url_ftell(pb);
url_fseek(pb, pos, SEEK_SET); url_fseek(pb, pos, SEEK_SET);
put_be16(pb, curpos - pos - 2); avio_wb16(pb, curpos - pos - 2);
url_fseek(pb, curpos, SEEK_SET); url_fseek(pb, curpos, SEEK_SET);
return curpos - pos; return curpos - pos;
} }
static void gxf_write_packet_header(AVIOContext *pb, GXFPktType type) static void gxf_write_packet_header(AVIOContext *pb, GXFPktType type)
{ {
put_be32(pb, 0); /* packet leader for synchro */ avio_wb32(pb, 0); /* packet leader for synchro */
put_byte(pb, 1); avio_w8(pb, 1);
put_byte(pb, type); /* map packet */ avio_w8(pb, type); /* map packet */
put_be32(pb, 0); /* size */ avio_wb32(pb, 0); /* size */
put_be32(pb, 0); /* reserved */ avio_wb32(pb, 0); /* reserved */
put_byte(pb, 0xE1); /* trailer 1 */ avio_w8(pb, 0xE1); /* trailer 1 */
put_byte(pb, 0xE2); /* trailer 2 */ avio_w8(pb, 0xE2); /* trailer 2 */
} }
static int gxf_write_mpeg_auxiliary(AVIOContext *pb, AVStream *st) static int gxf_write_mpeg_auxiliary(AVIOContext *pb, AVStream *st)
@ -191,20 +191,20 @@ static int gxf_write_mpeg_auxiliary(AVIOContext *pb, AVStream *st)
(float)st->codec->bit_rate, sc->p_per_gop, sc->b_per_i_or_p, (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, st->codec->pix_fmt == PIX_FMT_YUV422P ? 2 : 1, sc->first_gop_closed == 1,
starting_line, (st->codec->height + 15) / 16); starting_line, (st->codec->height + 15) / 16);
put_byte(pb, TRACK_MPG_AUX); avio_w8(pb, TRACK_MPG_AUX);
put_byte(pb, size + 1); avio_w8(pb, size + 1);
put_buffer(pb, (uint8_t *)buffer, size + 1); avio_write(pb, (uint8_t *)buffer, size + 1);
return size + 3; return size + 3;
} }
static int gxf_write_timecode_auxiliary(AVIOContext *pb, GXFStreamContext *sc) static int gxf_write_timecode_auxiliary(AVIOContext *pb, GXFStreamContext *sc)
{ {
put_byte(pb, 0); /* fields */ avio_w8(pb, 0); /* fields */
put_byte(pb, 0); /* seconds */ avio_w8(pb, 0); /* seconds */
put_byte(pb, 0); /* minutes */ avio_w8(pb, 0); /* minutes */
put_byte(pb, 0); /* flags + hours */ avio_w8(pb, 0); /* flags + hours */
/* reserved */ /* reserved */
put_be32(pb, 0); avio_wb32(pb, 0);
return 8; 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; int mpeg = sc->track_type == 4 || sc->track_type == 9;
/* track description section */ /* track description section */
put_byte(pb, sc->media_type + 0x80); avio_w8(pb, sc->media_type + 0x80);
put_byte(pb, index + 0xC0); avio_w8(pb, index + 0xC0);
pos = url_ftell(pb); pos = url_ftell(pb);
put_be16(pb, 0); /* size */ avio_wb16(pb, 0); /* size */
/* media file name */ /* media file name */
put_byte(pb, TRACK_NAME); avio_w8(pb, TRACK_NAME);
put_byte(pb, strlen(ES_NAME_PATTERN) + 3); avio_w8(pb, strlen(ES_NAME_PATTERN) + 3);
put_tag(pb, ES_NAME_PATTERN); put_tag(pb, ES_NAME_PATTERN);
put_be16(pb, sc->media_info); avio_wb16(pb, sc->media_info);
put_byte(pb, 0); avio_w8(pb, 0);
if (!mpeg) { if (!mpeg) {
/* auxiliary information */ /* auxiliary information */
put_byte(pb, TRACK_AUX); avio_w8(pb, TRACK_AUX);
put_byte(pb, 8); avio_w8(pb, 8);
if (sc->track_type == 3) if (sc->track_type == 3)
gxf_write_timecode_auxiliary(pb, sc); gxf_write_timecode_auxiliary(pb, sc);
else else
put_le64(pb, 0); avio_wl64(pb, 0);
} }
/* file system version */ /* file system version */
put_byte(pb, TRACK_VER); avio_w8(pb, TRACK_VER);
put_byte(pb, 4); avio_w8(pb, 4);
put_be32(pb, 0); avio_wb32(pb, 0);
if (mpeg) if (mpeg)
gxf_write_mpeg_auxiliary(pb, s->streams[index]); gxf_write_mpeg_auxiliary(pb, s->streams[index]);
/* frame rate */ /* frame rate */
put_byte(pb, TRACK_FPS); avio_w8(pb, TRACK_FPS);
put_byte(pb, 4); avio_w8(pb, 4);
put_be32(pb, sc->frame_rate_index); avio_wb32(pb, sc->frame_rate_index);
/* lines per frame */ /* lines per frame */
put_byte(pb, TRACK_LINES); avio_w8(pb, TRACK_LINES);
put_byte(pb, 4); avio_w8(pb, 4);
put_be32(pb, sc->lines_index); avio_wb32(pb, sc->lines_index);
/* fields per frame */ /* fields per frame */
put_byte(pb, TRACK_FPF); avio_w8(pb, TRACK_FPF);
put_byte(pb, 4); avio_w8(pb, 4);
put_be32(pb, sc->fields); avio_wb32(pb, sc->fields);
return updateSize(pb, pos); return updateSize(pb, pos);
} }
@ -272,42 +272,42 @@ static int gxf_write_material_data_section(AVFormatContext *s)
const char *filename = strrchr(s->filename, '/'); const char *filename = strrchr(s->filename, '/');
pos = url_ftell(pb); pos = url_ftell(pb);
put_be16(pb, 0); /* size */ avio_wb16(pb, 0); /* size */
/* name */ /* name */
if (filename) if (filename)
filename++; filename++;
else else
filename = s->filename; filename = s->filename;
put_byte(pb, MAT_NAME); avio_w8(pb, MAT_NAME);
put_byte(pb, strlen(SERVER_PATH) + strlen(filename) + 1); avio_w8(pb, strlen(SERVER_PATH) + strlen(filename) + 1);
put_tag(pb, SERVER_PATH); put_tag(pb, SERVER_PATH);
put_tag(pb, filename); put_tag(pb, filename);
put_byte(pb, 0); avio_w8(pb, 0);
/* first field */ /* first field */
put_byte(pb, MAT_FIRST_FIELD); avio_w8(pb, MAT_FIRST_FIELD);
put_byte(pb, 4); avio_w8(pb, 4);
put_be32(pb, 0); avio_wb32(pb, 0);
/* last field */ /* last field */
put_byte(pb, MAT_LAST_FIELD); avio_w8(pb, MAT_LAST_FIELD);
put_byte(pb, 4); avio_w8(pb, 4);
put_be32(pb, gxf->nb_fields); avio_wb32(pb, gxf->nb_fields);
/* reserved */ /* reserved */
put_byte(pb, MAT_MARK_IN); avio_w8(pb, MAT_MARK_IN);
put_byte(pb, 4); avio_w8(pb, 4);
put_be32(pb, 0); avio_wb32(pb, 0);
put_byte(pb, MAT_MARK_OUT); avio_w8(pb, MAT_MARK_OUT);
put_byte(pb, 4); avio_w8(pb, 4);
put_be32(pb, gxf->nb_fields); avio_wb32(pb, gxf->nb_fields);
/* estimated size */ /* estimated size */
put_byte(pb, MAT_SIZE); avio_w8(pb, MAT_SIZE);
put_byte(pb, 4); avio_w8(pb, 4);
put_be32(pb, url_fsize(pb) / 1024); avio_wb32(pb, url_fsize(pb) / 1024);
return updateSize(pb, pos); return updateSize(pb, pos);
} }
@ -320,7 +320,7 @@ static int gxf_write_track_description_section(AVFormatContext *s)
int i; int i;
pos = url_ftell(pb); pos = url_ftell(pb);
put_be16(pb, 0); /* size */ avio_wb16(pb, 0); /* size */
for (i = 0; i < s->nb_streams; ++i) for (i = 0; i < s->nb_streams; ++i)
gxf_write_track_description(s, s->streams[i]->priv_data, 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); gxf_write_packet_header(pb, PKT_MAP);
/* preamble */ /* preamble */
put_byte(pb, 0xE0); /* version */ avio_w8(pb, 0xE0); /* version */
put_byte(pb, 0xFF); /* reserved */ avio_w8(pb, 0xFF); /* reserved */
gxf_write_material_data_section(s); gxf_write_material_data_section(s);
gxf_write_track_description_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); gxf_write_packet_header(pb, PKT_FLT);
put_le32(pb, fields_per_flt); /* number of fields */ avio_wl32(pb, fields_per_flt); /* number of fields */
put_le32(pb, flt_entries); /* number of active flt entries */ avio_wl32(pb, flt_entries); /* number of active flt entries */
if (gxf->flt_entries) { if (gxf->flt_entries) {
for (i = 0; i < flt_entries; i++) for (i = 0; i < flt_entries; i++)
put_le32(pb, gxf->flt_entries[(i*fields_per_flt)>>1]); avio_wl32(pb, gxf->flt_entries[(i*fields_per_flt)>>1]);
} }
for (; i < 1000; i++) for (; i < 1000; i++)
put_le32(pb, 0); avio_wl32(pb, 0);
return updatePacketSize(pb, pos); 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 % 60 << 8 | // seconds
gxf->nb_fields % timecode_base; // fields gxf->nb_fields % timecode_base; // fields
put_le32(pb, gxf->flags); avio_wl32(pb, gxf->flags);
put_le32(pb, gxf->nb_fields); /* length of the longest track */ avio_wl32(pb, gxf->nb_fields); /* length of the longest track */
put_le32(pb, gxf->nb_fields); /* length of the shortest track */ avio_wl32(pb, gxf->nb_fields); /* length of the shortest track */
put_le32(pb, 0); /* mark in */ avio_wl32(pb, 0); /* mark in */
put_le32(pb, gxf->nb_fields); /* mark out */ avio_wl32(pb, gxf->nb_fields); /* mark out */
put_le32(pb, 0); /* timecode mark in */ avio_wl32(pb, 0); /* timecode mark in */
put_le32(pb, timecode); /* timecode mark out */ avio_wl32(pb, timecode); /* timecode mark out */
put_le64(pb, s->timestamp); /* modification time */ avio_wl64(pb, s->timestamp); /* modification time */
put_le64(pb, s->timestamp); /* creation time */ avio_wl64(pb, s->timestamp); /* creation time */
put_le16(pb, 0); /* reserved */ avio_wl16(pb, 0); /* reserved */
put_le16(pb, 0); /* reserved */ avio_wl16(pb, 0); /* reserved */
put_le16(pb, gxf->audio_tracks); avio_wl16(pb, gxf->audio_tracks);
put_le16(pb, 1); /* timecode track count */ avio_wl16(pb, 1); /* timecode track count */
put_le16(pb, 0); /* reserved */ avio_wl16(pb, 0); /* reserved */
put_le16(pb, gxf->mpeg_tracks); avio_wl16(pb, gxf->mpeg_tracks);
return 48; return 48;
} }
@ -420,18 +420,18 @@ static int gxf_write_umf_payload(AVFormatContext *s)
GXFContext *gxf = s->priv_data; GXFContext *gxf = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
put_le32(pb, gxf->umf_length); /* total length of the umf data */ avio_wl32(pb, gxf->umf_length); /* total length of the umf data */
put_le32(pb, 3); /* version */ avio_wl32(pb, 3); /* version */
put_le32(pb, s->nb_streams+1); avio_wl32(pb, s->nb_streams+1);
put_le32(pb, gxf->umf_track_offset); /* umf track section offset */ avio_wl32(pb, gxf->umf_track_offset); /* umf track section offset */
put_le32(pb, gxf->umf_track_size); avio_wl32(pb, gxf->umf_track_size);
put_le32(pb, s->nb_streams+1); avio_wl32(pb, s->nb_streams+1);
put_le32(pb, gxf->umf_media_offset); avio_wl32(pb, gxf->umf_media_offset);
put_le32(pb, gxf->umf_media_size); avio_wl32(pb, gxf->umf_media_size);
put_le32(pb, gxf->umf_length); /* user data offset */ avio_wl32(pb, gxf->umf_length); /* user data offset */
put_le32(pb, 0); /* user data size */ avio_wl32(pb, 0); /* user data size */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
return 48; return 48;
} }
@ -445,12 +445,12 @@ static int gxf_write_umf_track_description(AVFormatContext *s)
gxf->umf_track_offset = pos - gxf->umf_start_offset; gxf->umf_track_offset = pos - gxf->umf_start_offset;
for (i = 0; i < s->nb_streams; ++i) { for (i = 0; i < s->nb_streams; ++i) {
GXFStreamContext *sc = s->streams[i]->priv_data; GXFStreamContext *sc = s->streams[i]->priv_data;
put_le16(pb, sc->media_info); avio_wl16(pb, sc->media_info);
put_le16(pb, 1); avio_wl16(pb, 1);
} }
put_le16(pb, gxf->timecode_track.media_info); avio_wl16(pb, gxf->timecode_track.media_info);
put_le16(pb, 1); avio_wl16(pb, 1);
return url_ftell(pb) - pos; return url_ftell(pb) - pos;
} }
@ -460,34 +460,34 @@ static int gxf_write_umf_media_mpeg(AVIOContext *pb, AVStream *st)
GXFStreamContext *sc = st->priv_data; GXFStreamContext *sc = st->priv_data;
if (st->codec->pix_fmt == PIX_FMT_YUV422P) if (st->codec->pix_fmt == PIX_FMT_YUV422P)
put_le32(pb, 2); avio_wl32(pb, 2);
else else
put_le32(pb, 1); /* default to 420 */ avio_wl32(pb, 1); /* default to 420 */
put_le32(pb, sc->first_gop_closed == 1); /* closed = 1, open = 0, unknown = 255 */ avio_wl32(pb, sc->first_gop_closed == 1); /* closed = 1, open = 0, unknown = 255 */
put_le32(pb, 3); /* top = 1, bottom = 2, frame = 3, unknown = 0 */ avio_wl32(pb, 3); /* top = 1, bottom = 2, frame = 3, unknown = 0 */
put_le32(pb, 1); /* I picture per GOP */ avio_wl32(pb, 1); /* I picture per GOP */
put_le32(pb, sc->p_per_gop); avio_wl32(pb, sc->p_per_gop);
put_le32(pb, sc->b_per_i_or_p); avio_wl32(pb, sc->b_per_i_or_p);
if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO) if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
put_le32(pb, 2); avio_wl32(pb, 2);
else if (st->codec->codec_id == CODEC_ID_MPEG1VIDEO) else if (st->codec->codec_id == CODEC_ID_MPEG1VIDEO)
put_le32(pb, 1); avio_wl32(pb, 1);
else else
put_le32(pb, 0); avio_wl32(pb, 0);
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
return 32; return 32;
} }
static int gxf_write_umf_media_timecode(AVIOContext *pb, GXFStreamContext *sc) static int gxf_write_umf_media_timecode(AVIOContext *pb, GXFStreamContext *sc)
{ {
put_le32(pb, 1); /* non drop frame */ avio_wl32(pb, 1); /* non drop frame */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
return 32; return 32;
} }
@ -496,29 +496,29 @@ static int gxf_write_umf_media_dv(AVIOContext *pb, GXFStreamContext *sc)
int i; int i;
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
put_be32(pb, 0); avio_wb32(pb, 0);
} }
return 32; return 32;
} }
static int gxf_write_umf_media_audio(AVIOContext *pb, GXFStreamContext *sc) static int gxf_write_umf_media_audio(AVIOContext *pb, GXFStreamContext *sc)
{ {
put_le64(pb, av_dbl2int(1)); /* sound level to begin to */ avio_wl64(pb, av_dbl2int(1)); /* sound level to begin to */
put_le64(pb, av_dbl2int(1)); /* sound level to begin to */ avio_wl64(pb, av_dbl2int(1)); /* sound level to begin to */
put_le32(pb, 0); /* number of fields over which to ramp up sound level */ avio_wl32(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 */ avio_wl32(pb, 0); /* number of fields over which to ramp down sound level */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
return 32; return 32;
} }
#if 0 #if 0
static int gxf_write_umf_media_mjpeg(AVIOContext *pb, GXFStreamContext *sc) static int gxf_write_umf_media_mjpeg(AVIOContext *pb, GXFStreamContext *sc)
{ {
put_be64(pb, 0); /* FIXME FLOAT max chroma quant level */ avio_wb64(pb, 0); /* FIXME FLOAT max chroma quant level */
put_be64(pb, 0); /* FIXME FLOAT max luma quant level */ avio_wb64(pb, 0); /* FIXME FLOAT max luma quant level */
put_be64(pb, 0); /* FIXME FLOAT min chroma quant level */ avio_wb64(pb, 0); /* FIXME FLOAT min chroma quant level */
put_be64(pb, 0); /* FIXME FLOAT min luma quant level */ avio_wb64(pb, 0); /* FIXME FLOAT min luma quant level */
return 32; return 32;
} }
#endif #endif
@ -542,22 +542,22 @@ static int gxf_write_umf_media_description(AVFormatContext *s)
sc = s->streams[i]->priv_data; sc = s->streams[i]->priv_data;
startpos = url_ftell(pb); startpos = url_ftell(pb);
put_le16(pb, 0); /* length */ avio_wl16(pb, 0); /* length */
put_le16(pb, sc->media_info); avio_wl16(pb, sc->media_info);
put_le16(pb, 0); /* reserved */ avio_wl16(pb, 0); /* reserved */
put_le16(pb, 0); /* reserved */ avio_wl16(pb, 0); /* reserved */
put_le32(pb, gxf->nb_fields); avio_wl32(pb, gxf->nb_fields);
put_le32(pb, 0); /* attributes rw, ro */ avio_wl32(pb, 0); /* attributes rw, ro */
put_le32(pb, 0); /* mark in */ avio_wl32(pb, 0); /* mark in */
put_le32(pb, gxf->nb_fields); /* mark out */ avio_wl32(pb, gxf->nb_fields); /* mark out */
put_buffer(pb, ES_NAME_PATTERN, strlen(ES_NAME_PATTERN)); avio_write(pb, ES_NAME_PATTERN, strlen(ES_NAME_PATTERN));
put_be16(pb, sc->media_info); avio_wb16(pb, sc->media_info);
for (j = strlen(ES_NAME_PATTERN)+2; j < 88; j++) for (j = strlen(ES_NAME_PATTERN)+2; j < 88; j++)
put_byte(pb, 0); avio_w8(pb, 0);
put_le32(pb, sc->track_type); avio_wl32(pb, sc->track_type);
put_le32(pb, sc->sample_rate); avio_wl32(pb, sc->sample_rate);
put_le32(pb, sc->sample_size); avio_wl32(pb, sc->sample_size);
put_le32(pb, 0); /* reserved */ avio_wl32(pb, 0); /* reserved */
if (sc == &gxf->timecode_track) if (sc == &gxf->timecode_track)
gxf_write_umf_media_timecode(pb, sc); /* 8 0bytes */ 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); curpos = url_ftell(pb);
url_fseek(pb, startpos, SEEK_SET); url_fseek(pb, startpos, SEEK_SET);
put_le16(pb, curpos - startpos); avio_wl16(pb, curpos - startpos);
url_fseek(pb, curpos, SEEK_SET); url_fseek(pb, curpos, SEEK_SET);
} }
return url_ftell(pb) - pos; return url_ftell(pb) - pos;
@ -594,8 +594,8 @@ static int gxf_write_umf_packet(AVFormatContext *s)
gxf_write_packet_header(pb, PKT_UMF); gxf_write_packet_header(pb, PKT_UMF);
/* preamble */ /* preamble */
put_byte(pb, 3); /* first and last (only) packet */ avio_w8(pb, 3); /* first and last (only) packet */
put_be32(pb, gxf->umf_length); /* data length */ avio_wb32(pb, gxf->umf_length); /* data length */
gxf->umf_start_offset = url_ftell(pb); gxf->umf_start_offset = url_ftell(pb);
gxf_write_umf_payload(s); 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); (int64_t)48000*gxf->time_base.num, AV_ROUND_UP);
} }
put_byte(pb, sc->media_type); avio_w8(pb, sc->media_type);
put_byte(pb, st->index); avio_w8(pb, st->index);
put_be32(pb, field_nb); avio_wb32(pb, field_nb);
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
put_be16(pb, 0); avio_wb16(pb, 0);
put_be16(pb, size / 2); avio_wb16(pb, size / 2);
} else if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO) { } else if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO) {
int frame_type = gxf_parse_mpeg_frame(sc, pkt->data, pkt->size); int frame_type = gxf_parse_mpeg_frame(sc, pkt->data, pkt->size);
if (frame_type == FF_I_TYPE) { if (frame_type == FF_I_TYPE) {
put_byte(pb, 0x0d); avio_w8(pb, 0x0d);
sc->iframes++; sc->iframes++;
} else if (frame_type == FF_B_TYPE) { } else if (frame_type == FF_B_TYPE) {
put_byte(pb, 0x0f); avio_w8(pb, 0x0f);
sc->bframes++; sc->bframes++;
} else { } else {
put_byte(pb, 0x0e); avio_w8(pb, 0x0e);
sc->pframes++; sc->pframes++;
} }
put_be24(pb, size); avio_wb24(pb, size);
} else if (st->codec->codec_id == CODEC_ID_DVVIDEO) { } else if (st->codec->codec_id == CODEC_ID_DVVIDEO) {
put_byte(pb, size / 4096); avio_w8(pb, size / 4096);
put_be24(pb, 0); avio_wb24(pb, 0);
} else } else
put_be32(pb, size); avio_wb32(pb, size);
put_be32(pb, field_nb); avio_wb32(pb, field_nb);
put_byte(pb, 1); /* flags */ avio_w8(pb, 1); /* flags */
put_byte(pb, 0); /* reserved */ avio_w8(pb, 0); /* reserved */
return 16; return 16;
} }
@ -868,7 +868,7 @@ static int gxf_write_packet(AVFormatContext *s, AVPacket *pkt)
else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
padding = GXF_AUDIO_PACKET_SIZE - pkt->size; padding = GXF_AUDIO_PACKET_SIZE - pkt->size;
gxf_write_media_preamble(s, pkt, pkt->size + padding); gxf_write_media_preamble(s, pkt, pkt->size + padding);
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
gxf_write_padding(pb, padding); gxf_write_padding(pb, padding);
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {

2
libavformat/idroqenc.c
Unescape View File

@ -29,7 +29,7 @@ static int roq_write_header(struct AVFormatContext *s)
0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00 0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00
}; };
put_buffer(s->pb, header, 8); avio_write(s->pb, header, 8);
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;

18
libavformat/img2.c
Unescape View File

@ -368,9 +368,9 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
if(codec->codec_id == CODEC_ID_RAWVIDEO){ if(codec->codec_id == CODEC_ID_RAWVIDEO){
int ysize = codec->width * codec->height; int ysize = codec->width * codec->height;
put_buffer(pb[0], pkt->data , ysize); avio_write(pb[0], pkt->data , ysize);
put_buffer(pb[1], pkt->data + ysize, (pkt->size - ysize)/2); avio_write(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_write(pb[2], pkt->data + ysize +(pkt->size - ysize)/2, (pkt->size - ysize)/2);
put_flush_packet(pb[1]); put_flush_packet(pb[1]);
put_flush_packet(pb[2]); put_flush_packet(pb[2]);
url_fclose(pb[1]); 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')){ 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')) if(pkt->size < 8 || AV_RL32(pkt->data+4) != MKTAG('j','p','2','c'))
goto error; goto error;
put_be32(pb[0], 12); avio_wb32(pb[0], 12);
put_tag (pb[0], "jP "); put_tag (pb[0], "jP ");
put_be32(pb[0], 0x0D0A870A); // signature avio_wb32(pb[0], 0x0D0A870A); // signature
put_be32(pb[0], 20); avio_wb32(pb[0], 20);
put_tag (pb[0], "ftyp"); put_tag (pb[0], "ftyp");
put_tag (pb[0], "jp2 "); put_tag (pb[0], "jp2 ");
put_be32(pb[0], 0); avio_wb32(pb[0], 0);
put_tag (pb[0], "jp2 "); put_tag (pb[0], "jp2 ");
put_buffer(pb[0], st->codec->extradata, st->codec->extradata_size); avio_write(pb[0], st->codec->extradata, st->codec->extradata_size);
}else if(pkt->size < 8 || }else if(pkt->size < 8 ||
(!st->codec->extradata_size && (!st->codec->extradata_size &&
AV_RL32(pkt->data+4) != MKTAG('j','P',' ',' '))){ // signature AV_RL32(pkt->data+4) != MKTAG('j','P',' ',' '))){ // signature
@ -399,7 +399,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
return -1; return -1;
} }
} }
put_buffer(pb[0], pkt->data, pkt->size); avio_write(pb[0], pkt->data, pkt->size);
} }
put_flush_packet(pb[0]); put_flush_packet(pb[0]);
if (!img->is_pipe) { if (!img->is_pipe) {

24
libavformat/ivfenc.c
Unescape View File

@ -34,15 +34,15 @@ static int ivf_write_header(AVFormatContext *s)
av_log(s, AV_LOG_ERROR, "Currently only VP8 is supported!\n"); av_log(s, AV_LOG_ERROR, "Currently only VP8 is supported!\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
put_buffer(pb, "DKIF", 4); avio_write(pb, "DKIF", 4);
put_le16(pb, 0); // version avio_wl16(pb, 0); // version
put_le16(pb, 32); // header length avio_wl16(pb, 32); // header length
put_le32(pb, ctx->codec_tag ? ctx->codec_tag : AV_RL32("VP80")); avio_wl32(pb, ctx->codec_tag ? ctx->codec_tag : AV_RL32("VP80"));
put_le16(pb, ctx->width); avio_wl16(pb, ctx->width);
put_le16(pb, ctx->height); avio_wl16(pb, ctx->height);
put_le32(pb, s->streams[0]->time_base.den); avio_wl32(pb, s->streams[0]->time_base.den);
put_le32(pb, s->streams[0]->time_base.num); avio_wl32(pb, s->streams[0]->time_base.num);
put_le64(pb, s->streams[0]->duration); // TODO: duration or number of frames?!? avio_wl64(pb, s->streams[0]->duration); // TODO: duration or number of frames?!?
return 0; return 0;
} }
@ -50,9 +50,9 @@ static int ivf_write_header(AVFormatContext *s)
static int ivf_write_packet(AVFormatContext *s, AVPacket *pkt) static int ivf_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
put_le32(pb, pkt->size); avio_wl32(pb, pkt->size);
put_le64(pb, pkt->pts); avio_wl64(pb, pkt->pts);
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
put_flush_packet(pb); put_flush_packet(pb);
return 0; return 0;

2
libavformat/libnut.c
Unescape View File

@ -47,7 +47,7 @@ static const AVCodecTag nut_tags[] = {
#if CONFIG_LIBNUT_MUXER #if CONFIG_LIBNUT_MUXER
static int av_write(void * h, size_t len, const uint8_t * buf) { static int av_write(void * h, size_t len, const uint8_t * buf) {
AVIOContext * bc = h; AVIOContext * bc = h;
put_buffer(bc, buf, len); avio_write(bc, buf, len);
//put_flush_packet(bc); //put_flush_packet(bc);
return len; return len;
} }

12
libavformat/matroskadec.c
Unescape View File

@ -1376,12 +1376,12 @@ static int matroska_read_header(AVFormatContext *s, AVFormatParameters *ap)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ffio_init_context(&b, extradata, extradata_size, 1, ffio_init_context(&b, extradata, extradata_size, 1,
NULL, NULL, NULL, NULL); NULL, NULL, NULL, NULL);
put_buffer(&b, "TTA1", 4); avio_write(&b, "TTA1", 4);
put_le16(&b, 1); avio_wl16(&b, 1);
put_le16(&b, track->audio.channels); avio_wl16(&b, track->audio.channels);
put_le16(&b, track->audio.bitdepth); avio_wl16(&b, track->audio.bitdepth);
put_le32(&b, track->audio.out_samplerate); avio_wl32(&b, track->audio.out_samplerate);
put_le32(&b, matroska->ctx->duration * track->audio.out_samplerate); avio_wl32(&b, matroska->ctx->duration * track->audio.out_samplerate);
} else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 || } else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||
codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) { codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {
extradata_offset = 26; extradata_offset = 26;

46
libavformat/matroskaenc.c
Unescape View File

@ -112,7 +112,7 @@ static void put_ebml_id(AVIOContext *pb, unsigned int id)
{ {
int i = ebml_id_size(id); int i = ebml_id_size(id);
while (i--) while (i--)
put_byte(pb, id >> (i*8)); avio_w8(pb, id >> (i*8));
} }
/** /**
@ -123,9 +123,9 @@ static void put_ebml_id(AVIOContext *pb, unsigned int id)
static void put_ebml_size_unknown(AVIOContext *pb, int bytes) static void put_ebml_size_unknown(AVIOContext *pb, int bytes)
{ {
assert(bytes <= 8); assert(bytes <= 8);
put_byte(pb, 0x1ff >> bytes); avio_w8(pb, 0x1ff >> bytes);
while (--bytes) while (--bytes)
put_byte(pb, 0xff); avio_w8(pb, 0xff);
} }
/** /**
@ -160,7 +160,7 @@ static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
num |= 1ULL << bytes*7; num |= 1ULL << bytes*7;
for (i = bytes - 1; i >= 0; i--) for (i = bytes - 1; i >= 0; i--)
put_byte(pb, num >> i*8); avio_w8(pb, num >> i*8);
} }
static void put_ebml_uint(AVIOContext *pb, unsigned int elementid, uint64_t val) static void put_ebml_uint(AVIOContext *pb, unsigned int elementid, uint64_t val)
@ -172,14 +172,14 @@ static void put_ebml_uint(AVIOContext *pb, unsigned int elementid, uint64_t val)
put_ebml_id(pb, elementid); put_ebml_id(pb, elementid);
put_ebml_num(pb, bytes, 0); put_ebml_num(pb, bytes, 0);
for (i = bytes - 1; i >= 0; i--) for (i = bytes - 1; i >= 0; i--)
put_byte(pb, val >> i*8); avio_w8(pb, val >> i*8);
} }
static void put_ebml_float(AVIOContext *pb, unsigned int elementid, double val) static void put_ebml_float(AVIOContext *pb, unsigned int elementid, double val)
{ {
put_ebml_id(pb, elementid); put_ebml_id(pb, elementid);
put_ebml_num(pb, 8, 0); put_ebml_num(pb, 8, 0);
put_be64(pb, av_dbl2int(val)); avio_wb64(pb, av_dbl2int(val));
} }
static void put_ebml_binary(AVIOContext *pb, unsigned int elementid, static void put_ebml_binary(AVIOContext *pb, unsigned int elementid,
@ -187,7 +187,7 @@ static void put_ebml_binary(AVIOContext *pb, unsigned int elementid,
{ {
put_ebml_id(pb, elementid); put_ebml_id(pb, elementid);
put_ebml_num(pb, size, 0); put_ebml_num(pb, size, 0);
put_buffer(pb, buf, size); avio_write(pb, buf, size);
} }
static void put_ebml_string(AVIOContext *pb, unsigned int elementid, const char *str) static void put_ebml_string(AVIOContext *pb, unsigned int elementid, const char *str)
@ -216,7 +216,7 @@ static void put_ebml_void(AVIOContext *pb, uint64_t size)
else else
put_ebml_num(pb, size-9, 8); put_ebml_num(pb, size-9, 8);
while(url_ftell(pb) < currentpos + size) while(url_ftell(pb) < currentpos + size)
put_byte(pb, 0); avio_w8(pb, 0);
} }
static ebml_master start_ebml_master(AVIOContext *pb, unsigned int elementid, uint64_t expectedsize) static ebml_master start_ebml_master(AVIOContext *pb, unsigned int elementid, uint64_t expectedsize)
@ -241,8 +241,8 @@ static void put_xiph_size(AVIOContext *pb, int size)
{ {
int i; int i;
for (i = 0; i < size / 255; i++) for (i = 0; i < size / 255; i++)
put_byte(pb, 255); avio_w8(pb, 255);
put_byte(pb, size % 255); avio_w8(pb, size % 255);
} }
/** /**
@ -426,12 +426,12 @@ static int put_xiph_codecpriv(AVFormatContext *s, AVIOContext *pb, AVCodecContex
return -1; return -1;
} }
put_byte(pb, 2); // number packets - 1 avio_w8(pb, 2); // number packets - 1
for (j = 0; j < 2; j++) { for (j = 0; j < 2; j++) {
put_xiph_size(pb, header_len[j]); put_xiph_size(pb, header_len[j]);
} }
for (j = 0; j < 3; j++) for (j = 0; j < 3; j++)
put_buffer(pb, header_start[j], header_len[j]); avio_write(pb, header_start[j], header_len[j]);
return 0; return 0;
} }
@ -481,13 +481,13 @@ static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecCo
else if (codec->codec_id == CODEC_ID_H264) else if (codec->codec_id == CODEC_ID_H264)
ret = ff_isom_write_avcc(dyn_cp, codec->extradata, codec->extradata_size); ret = ff_isom_write_avcc(dyn_cp, codec->extradata, codec->extradata_size);
else if (codec->extradata_size) else if (codec->extradata_size)
put_buffer(dyn_cp, codec->extradata, codec->extradata_size); avio_write(dyn_cp, codec->extradata, codec->extradata_size);
} else if (codec->codec_type == AVMEDIA_TYPE_VIDEO) { } else if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
if (qt_id) { if (qt_id) {
if (!codec->codec_tag) if (!codec->codec_tag)
codec->codec_tag = ff_codec_get_tag(codec_movvideo_tags, codec->codec_id); codec->codec_tag = ff_codec_get_tag(codec_movvideo_tags, codec->codec_id);
if (codec->extradata_size) if (codec->extradata_size)
put_buffer(dyn_cp, codec->extradata, codec->extradata_size); avio_write(dyn_cp, codec->extradata, codec->extradata_size);
} else { } else {
if (!codec->codec_tag) if (!codec->codec_tag)
codec->codec_tag = ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id); 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, AVIOContext *pb, AVPacket *p
blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(size)); blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(size));
put_ebml_id(pb, MATROSKA_ID_BLOCK); put_ebml_id(pb, MATROSKA_ID_BLOCK);
put_ebml_num(pb, size+4, 0); put_ebml_num(pb, size+4, 0);
put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126 avio_w8(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
put_be16(pb, pkt->pts - mkv->cluster_pts); avio_wb16(pb, pkt->pts - mkv->cluster_pts);
put_byte(pb, 0); avio_w8(pb, 0);
put_buffer(pb, buffer, size); avio_write(pb, buffer, size);
put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration); put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration);
end_ebml_master(pb, blockgroup); end_ebml_master(pb, blockgroup);
@ -965,10 +965,10 @@ static void mkv_write_block(AVFormatContext *s, AVIOContext *pb,
data = pkt->data; data = pkt->data;
put_ebml_id(pb, blockid); put_ebml_id(pb, blockid);
put_ebml_num(pb, size+4, 0); put_ebml_num(pb, size+4, 0);
put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126 avio_w8(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
put_be16(pb, ts - mkv->cluster_pts); avio_wb16(pb, ts - mkv->cluster_pts);
put_byte(pb, flags); avio_w8(pb, flags);
put_buffer(pb, data, size); avio_write(pb, data, size);
if (data != pkt->data) if (data != pkt->data)
av_free(data); av_free(data);
} }
@ -1018,7 +1018,7 @@ static void mkv_flush_dynbuf(AVFormatContext *s)
return; return;
bufsize = url_close_dyn_buf(mkv->dyn_bc, &dyn_buf); bufsize = url_close_dyn_buf(mkv->dyn_bc, &dyn_buf);
put_buffer(s->pb, dyn_buf, bufsize); avio_write(s->pb, dyn_buf, bufsize);
av_free(dyn_buf); av_free(dyn_buf);
mkv->dyn_bc = NULL; mkv->dyn_bc = NULL;
} }

2
libavformat/md5enc.c
Unescape View File

@ -36,7 +36,7 @@ static void md5_finish(struct AVFormatContext *s, char *buf)
buf[offset] = '\n'; buf[offset] = '\n';
buf[offset+1] = 0; buf[offset+1] = 0;
put_buffer(s->pb, buf, strlen(buf)); avio_write(s->pb, buf, strlen(buf));
put_flush_packet(s->pb); put_flush_packet(s->pb);
} }

50
libavformat/mmf.c
Unescape View File

@ -53,7 +53,7 @@ static void end_tag_be(AVIOContext *pb, int64_t start)
pos = url_ftell(pb); pos = url_ftell(pb);
url_fseek(pb, start - 4, SEEK_SET); url_fseek(pb, start - 4, SEEK_SET);
put_be32(pb, (uint32_t)(pos - start)); avio_wb32(pb, (uint32_t)(pos - start));
url_fseek(pb, pos, SEEK_SET); url_fseek(pb, pos, SEEK_SET);
} }
@ -71,31 +71,31 @@ static int mmf_write_header(AVFormatContext *s)
} }
put_tag(pb, "MMMD"); put_tag(pb, "MMMD");
put_be32(pb, 0); avio_wb32(pb, 0);
pos = ff_start_tag(pb, "CNTI"); pos = ff_start_tag(pb, "CNTI");
put_byte(pb, 0); /* class */ avio_w8(pb, 0); /* class */
put_byte(pb, 0); /* type */ avio_w8(pb, 0); /* type */
put_byte(pb, 0); /* code type */ avio_w8(pb, 0); /* code type */
put_byte(pb, 0); /* status */ avio_w8(pb, 0); /* status */
put_byte(pb, 0); /* counts */ avio_w8(pb, 0); /* counts */
put_tag(pb, "VN:libavcodec,"); /* metadata ("ST:songtitle,VN:version,...") */ put_tag(pb, "VN:libavcodec,"); /* metadata ("ST:songtitle,VN:version,...") */
end_tag_be(pb, pos); end_tag_be(pb, pos);
put_buffer(pb, "ATR\x00", 4); avio_write(pb, "ATR\x00", 4);
put_be32(pb, 0); avio_wb32(pb, 0);
mmf->atrpos = url_ftell(pb); mmf->atrpos = url_ftell(pb);
put_byte(pb, 0); /* format type */ avio_w8(pb, 0); /* format type */
put_byte(pb, 0); /* sequence type */ avio_w8(pb, 0); /* sequence type */
put_byte(pb, (0 << 7) | (1 << 4) | rate); /* (channel << 7) | (format << 4) | rate */ avio_w8(pb, (0 << 7) | (1 << 4) | rate); /* (channel << 7) | (format << 4) | rate */
put_byte(pb, 0); /* wave base bit */ avio_w8(pb, 0); /* wave base bit */
put_byte(pb, 2); /* time base d */ avio_w8(pb, 2); /* time base d */
put_byte(pb, 2); /* time base g */ avio_w8(pb, 2); /* time base g */
put_tag(pb, "Atsq"); put_tag(pb, "Atsq");
put_be32(pb, 16); avio_wb32(pb, 16);
mmf->atsqpos = url_ftell(pb); mmf->atsqpos = url_ftell(pb);
/* Will be filled on close */ /* 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_write(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"); 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) static int mmf_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
return 0; return 0;
} }
@ -117,11 +117,11 @@ static int mmf_write_packet(AVFormatContext *s, AVPacket *pkt)
static void put_varlength(AVIOContext *pb, int val) static void put_varlength(AVIOContext *pb, int val)
{ {
if(val < 128) if(val < 128)
put_byte(pb, val); avio_w8(pb, val);
else { else {
val -= 128; val -= 128;
put_byte(pb, 0x80 | val >> 7); avio_w8(pb, 0x80 | val >> 7);
put_byte(pb, 0x7f & val); avio_w8(pb, 0x7f & val);
} }
} }
@ -145,17 +145,17 @@ static int mmf_write_trailer(AVFormatContext *s)
url_fseek(pb, mmf->atsqpos, SEEK_SET); url_fseek(pb, mmf->atsqpos, SEEK_SET);
/* "play wav" */ /* "play wav" */
put_byte(pb, 0); /* start time */ avio_w8(pb, 0); /* start time */
put_byte(pb, 1); /* (channel << 6) | wavenum */ avio_w8(pb, 1); /* (channel << 6) | wavenum */
gatetime = size * 500 / s->streams[0]->codec->sample_rate; gatetime = size * 500 / s->streams[0]->codec->sample_rate;
put_varlength(pb, gatetime); /* duration */ put_varlength(pb, gatetime); /* duration */
/* "nop" */ /* "nop" */
put_varlength(pb, gatetime); /* start time */ put_varlength(pb, gatetime); /* start time */
put_buffer(pb, "\xff\x00", 2); /* nop */ avio_write(pb, "\xff\x00", 2); /* nop */
/* "end of sequence" */ /* "end of sequence" */
put_buffer(pb, "\x00\x00\x00\x00", 4); avio_write(pb, "\x00\x00\x00\x00", 4);
url_fseek(pb, pos, SEEK_SET); url_fseek(pb, pos, SEEK_SET);

880
libavformat/movenc.c
View File

File diff suppressed because it is too large Load Diff

40
libavformat/movenchint.c
Unescape View File

@ -251,14 +251,14 @@ static void output_immediate(const uint8_t *data, int size,
int len = size; int len = size;
if (len > 14) if (len > 14)
len = 14; len = 14;
put_byte(out, 1); /* immediate constructor */ avio_w8(out, 1); /* immediate constructor */
put_byte(out, len); /* amount of valid data */ avio_w8(out, len); /* amount of valid data */
put_buffer(out, data, len); avio_write(out, data, len);
data += len; data += len;
size -= len; size -= len;
for (; len < 14; len++) for (; len < 14; len++)
put_byte(out, 0); avio_w8(out, 0);
(*entries)++; (*entries)++;
} }
@ -267,13 +267,13 @@ static void output_immediate(const uint8_t *data, int size,
static void output_match(AVIOContext *out, int match_sample, static void output_match(AVIOContext *out, int match_sample,
int match_offset, int match_len, int *entries) int match_offset, int match_len, int *entries)
{ {
put_byte(out, 2); /* sample constructor */ avio_w8(out, 2); /* sample constructor */
put_byte(out, 0); /* track reference */ avio_w8(out, 0); /* track reference */
put_be16(out, match_len); avio_wb16(out, match_len);
put_be32(out, match_sample); avio_wb32(out, match_sample);
put_be32(out, match_offset); avio_wb32(out, match_offset);
put_be16(out, 1); /* bytes per block */ avio_wb16(out, 1); /* bytes per block */
put_be16(out, 1); /* samples per block */ avio_wb16(out, 1); /* samples per block */
(*entries)++; (*entries)++;
} }
@ -318,8 +318,8 @@ static int write_hint_packets(AVIOContext *out, const uint8_t *data,
count_pos = url_ftell(out); count_pos = url_ftell(out);
/* RTPsample header */ /* RTPsample header */
put_be16(out, 0); /* packet count */ avio_wb16(out, 0); /* packet count */
put_be16(out, 0); /* reserved */ avio_wb16(out, 0); /* reserved */
while (size > 4) { while (size > 4) {
uint32_t packet_len = AV_RB32(data); uint32_t packet_len = AV_RB32(data);
@ -354,12 +354,12 @@ static int write_hint_packets(AVIOContext *out, const uint8_t *data,
count++; count++;
/* RTPpacket header */ /* RTPpacket header */
put_be32(out, 0); /* relative_time */ avio_wb32(out, 0); /* relative_time */
put_buffer(out, data, 2); /* RTP header */ avio_write(out, data, 2); /* RTP header */
put_be16(out, seq); /* RTPsequenceseed */ avio_wb16(out, seq); /* RTPsequenceseed */
put_be16(out, 0); /* reserved + flags */ avio_wb16(out, 0); /* reserved + flags */
entries_pos = url_ftell(out); entries_pos = url_ftell(out);
put_be16(out, 0); /* entry count */ avio_wb16(out, 0); /* entry count */
data += 12; data += 12;
size -= 12; size -= 12;
@ -373,13 +373,13 @@ static int write_hint_packets(AVIOContext *out, const uint8_t *data,
curpos = url_ftell(out); curpos = url_ftell(out);
url_fseek(out, entries_pos, SEEK_SET); url_fseek(out, entries_pos, SEEK_SET);
put_be16(out, entries); avio_wb16(out, entries);
url_fseek(out, curpos, SEEK_SET); url_fseek(out, curpos, SEEK_SET);
} }
curpos = url_ftell(out); curpos = url_ftell(out);
url_fseek(out, count_pos, SEEK_SET); url_fseek(out, count_pos, SEEK_SET);
put_be16(out, count); avio_wb16(out, count);
url_fseek(out, curpos, SEEK_SET); url_fseek(out, curpos, SEEK_SET);
return count; return count;
} }

30
libavformat/mp3enc.c
Unescape View File

@ -71,10 +71,10 @@ static int id3v1_create_tag(AVFormatContext *s, uint8_t *buf)
static void id3v2_put_size(AVFormatContext *s, int size) static void id3v2_put_size(AVFormatContext *s, int size)
{ {
put_byte(s->pb, size >> 21 & 0x7f); avio_w8(s->pb, size >> 21 & 0x7f);
put_byte(s->pb, size >> 14 & 0x7f); avio_w8(s->pb, size >> 14 & 0x7f);
put_byte(s->pb, size >> 7 & 0x7f); avio_w8(s->pb, size >> 7 & 0x7f);
put_byte(s->pb, size & 0x7f); avio_w8(s->pb, size & 0x7f);
} }
static int string_is_ascii(const uint8_t *str) 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))) (!str2 || string_is_ascii(str2)))
enc = ID3v2_ENCODING_ISO8859; enc = ID3v2_ENCODING_ISO8859;
put_byte(dyn_buf, enc); avio_w8(dyn_buf, enc);
if (enc == ID3v2_ENCODING_UTF16BOM) { if (enc == ID3v2_ENCODING_UTF16BOM) {
put_le16(dyn_buf, 0xFEFF); /* BOM */ avio_wl16(dyn_buf, 0xFEFF); /* BOM */
put = avio_put_str16le; put = avio_put_str16le;
} else } else
put = avio_put_str; 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); put(dyn_buf, str2);
len = url_close_dyn_buf(dyn_buf, &pb); len = url_close_dyn_buf(dyn_buf, &pb);
put_be32(s->pb, tag); avio_wb32(s->pb, tag);
id3v2_put_size(s, len); id3v2_put_size(s, len);
put_be16(s->pb, 0); avio_wb16(s->pb, 0);
put_buffer(s->pb, pb, len); avio_write(s->pb, pb, len);
av_freep(&pb); av_freep(&pb);
return len + ID3v2_HEADER_SIZE; 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) static int mp3_write_packet(struct AVFormatContext *s, AVPacket *pkt)
{ {
put_buffer(s->pb, pkt->data, pkt->size); avio_write(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;
} }
@ -139,7 +139,7 @@ static int mp3_write_trailer(struct AVFormatContext *s)
/* write the id3v1 tag */ /* write the id3v1 tag */
if (id3v1_create_tag(s, buf) > 0) { if (id3v1_create_tag(s, buf) > 0) {
put_buffer(s->pb, buf, ID3v1_TAG_SIZE); avio_write(s->pb, buf, ID3v1_TAG_SIZE);
put_flush_packet(s->pb); put_flush_packet(s->pb);
} }
return 0; return 0;
@ -206,13 +206,13 @@ static int mp3_write_header(struct AVFormatContext *s)
ID3v2_ENCODING_UTF8; ID3v2_ENCODING_UTF8;
int64_t size_pos, cur_pos; int64_t size_pos, cur_pos;
put_be32(s->pb, MKBETAG('I', 'D', '3', mp3->id3v2_version)); avio_wb32(s->pb, MKBETAG('I', 'D', '3', mp3->id3v2_version));
put_byte(s->pb, 0); avio_w8(s->pb, 0);
put_byte(s->pb, 0); /* flags */ avio_w8(s->pb, 0); /* flags */
/* reserve space for size */ /* reserve space for size */
size_pos = url_ftell(s->pb); size_pos = url_ftell(s->pb);
put_be32(s->pb, 0); avio_wb32(s->pb, 0);
ff_metadata_conv(&s->metadata, ff_id3v2_34_metadata_conv, NULL); ff_metadata_conv(&s->metadata, ff_id3v2_34_metadata_conv, NULL);
if (mp3->id3v2_version == 4) if (mp3->id3v2_version == 4)

82
libavformat/mpegenc.c
Unescape View File

@ -493,12 +493,12 @@ static int mpeg_mux_init(AVFormatContext *ctx)
static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp) static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
{ {
put_byte(pb, avio_w8(pb,
(id << 4) | (id << 4) |
(((timestamp >> 30) & 0x07) << 1) | (((timestamp >> 30) & 0x07) << 1) |
1); 1);
put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1)); avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
put_be16(pb, (uint16_t)((((timestamp ) & 0x7fff) << 1) | 1)); avio_wb16(pb, (uint16_t)((((timestamp ) & 0x7fff) << 1) | 1));
} }
@ -618,16 +618,16 @@ static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,int packet_
MpegMuxContext *s = ctx->priv_data; MpegMuxContext *s = ctx->priv_data;
int i; int i;
put_be32(pb, PADDING_STREAM); avio_wb32(pb, PADDING_STREAM);
put_be16(pb, packet_bytes - 6); avio_wb16(pb, packet_bytes - 6);
if (!s->is_mpeg2) { if (!s->is_mpeg2) {
put_byte(pb, 0x0f); avio_w8(pb, 0x0f);
packet_bytes -= 7; packet_bytes -= 7;
} else } else
packet_bytes -= 6; packet_bytes -= 6;
for(i=0;i<packet_bytes;i++) for(i=0;i<packet_bytes;i++)
put_byte(pb, 0xff); avio_w8(pb, 0xff);
} }
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){ 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); size = put_system_header(ctx, buf_ptr, 0);
buf_ptr += size; buf_ptr += size;
size = buf_ptr - buffer; size = buf_ptr - buffer;
put_buffer(ctx->pb, buffer, size); avio_write(ctx->pb, buffer, size);
put_be32(ctx->pb, PRIVATE_STREAM_2); avio_wb32(ctx->pb, PRIVATE_STREAM_2);
put_be16(ctx->pb, 0x03d4); // length avio_wb16(ctx->pb, 0x03d4); // length
put_byte(ctx->pb, 0x00); // substream ID, 00=PCI avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
for (i = 0; i < 979; i++) for (i = 0; i < 979; i++)
put_byte(ctx->pb, 0x00); avio_w8(ctx->pb, 0x00);
put_be32(ctx->pb, PRIVATE_STREAM_2); avio_wb32(ctx->pb, PRIVATE_STREAM_2);
put_be16(ctx->pb, 0x03fa); // length avio_wb16(ctx->pb, 0x03fa); // length
put_byte(ctx->pb, 0x01); // substream ID, 01=DSI avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
for (i = 0; i < 1017; i++) for (i = 0; i < 1017; i++)
put_byte(ctx->pb, 0x00); avio_w8(ctx->pb, 0x00);
memset(buffer, 0, 128); memset(buffer, 0, 128);
buf_ptr = buffer; buf_ptr = buffer;
@ -734,7 +734,7 @@ static int flush_packet(AVFormatContext *ctx, int stream_index,
} }
} }
size = buf_ptr - buffer; size = buf_ptr - buffer;
put_buffer(ctx->pb, buffer, size); avio_write(ctx->pb, buffer, size);
packet_size = s->packet_size - 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); nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
put_be32(ctx->pb, startcode); avio_wb32(ctx->pb, startcode);
put_be16(ctx->pb, packet_size); avio_wb16(ctx->pb, packet_size);
if (!s->is_mpeg2) if (!s->is_mpeg2)
for(i=0;i<stuffing_size;i++) for(i=0;i<stuffing_size;i++)
put_byte(ctx->pb, 0xff); avio_w8(ctx->pb, 0xff);
if (s->is_mpeg2) { if (s->is_mpeg2) {
put_byte(ctx->pb, 0x80); /* mpeg2 id */ avio_w8(ctx->pb, 0x80); /* mpeg2 id */
pes_flags=0; pes_flags=0;
@ -865,8 +865,8 @@ static int flush_packet(AVFormatContext *ctx, int stream_index,
if (stream->packet_number == 0) if (stream->packet_number == 0)
pes_flags |= 0x01; pes_flags |= 0x01;
put_byte(ctx->pb, pes_flags); /* flags */ avio_w8(ctx->pb, pes_flags); /* flags */
put_byte(ctx->pb, header_len - 3 + stuffing_size); avio_w8(ctx->pb, header_len - 3 + stuffing_size);
if (pes_flags & 0x80) /*write pts*/ if (pes_flags & 0x80) /*write pts*/
put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, 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); put_timestamp(ctx->pb, 0x01, dts);
if (pes_flags & 0x01) { /*write pes extension*/ if (pes_flags & 0x01) { /*write pes extension*/
put_byte(ctx->pb, 0x10); /* flags */ avio_w8(ctx->pb, 0x10); /* flags */
/* P-STD buffer info */ /* P-STD buffer info */
if ((id & 0xe0) == AUDIO_ID) if ((id & 0xe0) == AUDIO_ID)
put_be16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128); avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
else else
put_be16(ctx->pb, 0x6000 | stream->max_buffer_size/1024); avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
} }
} else { } else {
@ -892,38 +892,38 @@ static int flush_packet(AVFormatContext *ctx, int stream_index,
put_timestamp(ctx->pb, 0x02, pts); put_timestamp(ctx->pb, 0x02, pts);
} }
} else { } else {
put_byte(ctx->pb, 0x0f); avio_w8(ctx->pb, 0x0f);
} }
} }
if (s->is_mpeg2) { if (s->is_mpeg2) {
/* special stuffing byte that is always written /* special stuffing byte that is always written
to prevent accidental generation of start codes. */ to prevent accidental generation of start codes. */
put_byte(ctx->pb, 0xff); avio_w8(ctx->pb, 0xff);
for(i=0;i<stuffing_size;i++) for(i=0;i<stuffing_size;i++)
put_byte(ctx->pb, 0xff); avio_w8(ctx->pb, 0xff);
} }
if (startcode == PRIVATE_STREAM_1) { if (startcode == PRIVATE_STREAM_1) {
put_byte(ctx->pb, id); avio_w8(ctx->pb, id);
if (id >= 0xa0) { if (id >= 0xa0) {
/* LPCM (XXX: check nb_frames) */ /* LPCM (XXX: check nb_frames) */
put_byte(ctx->pb, 7); avio_w8(ctx->pb, 7);
put_be16(ctx->pb, 4); /* skip 3 header bytes */ avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
put_byte(ctx->pb, stream->lpcm_header[0]); avio_w8(ctx->pb, stream->lpcm_header[0]);
put_byte(ctx->pb, stream->lpcm_header[1]); avio_w8(ctx->pb, stream->lpcm_header[1]);
put_byte(ctx->pb, stream->lpcm_header[2]); avio_w8(ctx->pb, stream->lpcm_header[2]);
} else if (id >= 0x40) { } else if (id >= 0x40) {
/* AC-3 */ /* AC-3 */
put_byte(ctx->pb, nb_frames); avio_w8(ctx->pb, nb_frames);
put_be16(ctx->pb, trailer_size+1); avio_wb16(ctx->pb, trailer_size+1);
} }
} }
/* output data */ /* output data */
assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo)); 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_write);
stream->bytes_to_iframe -= payload_size - stuffing_size; stream->bytes_to_iframe -= payload_size - stuffing_size;
}else{ }else{
payload_size= payload_size=
@ -934,7 +934,7 @@ static int flush_packet(AVFormatContext *ctx, int stream_index,
put_padding_packet(ctx,ctx->pb, pad_packet_bytes); put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
for(i=0;i<zero_trail_bytes;i++) for(i=0;i<zero_trail_bytes;i++)
put_byte(ctx->pb, 0x00); avio_w8(ctx->pb, 0x00);
put_flush_packet(ctx->pb); put_flush_packet(ctx->pb);
@ -961,7 +961,7 @@ static void put_vcd_padding_sector(AVFormatContext *ctx)
int i; int i;
for(i=0;i<s->packet_size;i++) for(i=0;i<s->packet_size;i++)
put_byte(ctx->pb, 0); avio_w8(ctx->pb, 0);
s->vcd_padding_bytes_written += s->packet_size; 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 /* End header according to MPEG1 systems standard. We do not write
it as it is usually not needed by decoders and because it it as it is usually not needed by decoders and because it
complicates MPEG stream concatenation. */ complicates MPEG stream concatenation. */
//put_be32(ctx->pb, ISO_11172_END_CODE); //avio_wb32(ctx->pb, ISO_11172_END_CODE);
//put_flush_packet(ctx->pb); //put_flush_packet(ctx->pb);
for(i=0;i<ctx->nb_streams;i++) { for(i=0;i<ctx->nb_streams;i++) {

8
libavformat/mpegtsenc.c
Unescape View File

@ -415,7 +415,7 @@ static MpegTSService *mpegts_add_service(MpegTSWrite *ts,
static void section_write_packet(MpegTSSection *s, const uint8_t *packet) static void section_write_packet(MpegTSSection *s, const uint8_t *packet)
{ {
AVFormatContext *ctx = s->opaque; AVFormatContext *ctx = s->opaque;
put_buffer(ctx->pb, packet, TS_PACKET_SIZE); avio_write(ctx->pb, packet, TS_PACKET_SIZE);
} }
static int mpegts_write_header(AVFormatContext *s) static int mpegts_write_header(AVFormatContext *s)
@ -625,7 +625,7 @@ static void mpegts_insert_null_packet(AVFormatContext *s)
*q++ = 0xff; *q++ = 0xff;
*q++ = 0x10; *q++ = 0x10;
memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf)); memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf));
put_buffer(s->pb, buf, TS_PACKET_SIZE); avio_write(s->pb, buf, TS_PACKET_SIZE);
} }
/* Write a single transport stream packet with a PCR and no payload */ /* 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 */ /* stuffing bytes */
memset(q, 0xFF, TS_PACKET_SIZE - (q - buf)); memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
put_buffer(s->pb, buf, TS_PACKET_SIZE); avio_write(s->pb, buf, TS_PACKET_SIZE);
} }
static void write_pts(uint8_t *q, int fourbits, int64_t pts) 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); memcpy(buf + TS_PACKET_SIZE - len, payload, len);
payload += len; payload += len;
payload_size -= len; payload_size -= len;
put_buffer(s->pb, buf, TS_PACKET_SIZE); avio_write(s->pb, buf, TS_PACKET_SIZE);
} }
put_flush_packet(s->pb); put_flush_packet(s->pb);
} }

8
libavformat/mpjpeg.c
Unescape View File

@ -29,7 +29,7 @@ static int mpjpeg_write_header(AVFormatContext *s)
uint8_t buf1[256]; uint8_t buf1[256];
snprintf(buf1, sizeof(buf1), "--%s\n", BOUNDARY_TAG); snprintf(buf1, sizeof(buf1), "--%s\n", BOUNDARY_TAG);
put_buffer(s->pb, buf1, strlen(buf1)); avio_write(s->pb, buf1, strlen(buf1));
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;
} }
@ -39,11 +39,11 @@ static int mpjpeg_write_packet(AVFormatContext *s, AVPacket *pkt)
uint8_t buf1[256]; uint8_t buf1[256];
snprintf(buf1, sizeof(buf1), "Content-type: image/jpeg\n\n"); snprintf(buf1, sizeof(buf1), "Content-type: image/jpeg\n\n");
put_buffer(s->pb, buf1, strlen(buf1)); avio_write(s->pb, buf1, strlen(buf1));
put_buffer(s->pb, pkt->data, pkt->size); avio_write(s->pb, pkt->data, pkt->size);
snprintf(buf1, sizeof(buf1), "\n--%s\n", BOUNDARY_TAG); snprintf(buf1, sizeof(buf1), "\n--%s\n", BOUNDARY_TAG);
put_buffer(s->pb, buf1, strlen(buf1)); avio_write(s->pb, buf1, strlen(buf1));
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;
} }

332
libavformat/mxfenc.c
Unescape View File

@ -307,24 +307,24 @@ static const MXFLocalTagPair mxf_local_tag_batch[] = {
static void mxf_write_uuid(AVIOContext *pb, enum MXFMetadataSetType type, int value) static void mxf_write_uuid(AVIOContext *pb, enum MXFMetadataSetType type, int value)
{ {
put_buffer(pb, uuid_base, 12); avio_write(pb, uuid_base, 12);
put_be16(pb, type); avio_wb16(pb, type);
put_be16(pb, value); avio_wb16(pb, value);
} }
static void mxf_write_umid(AVFormatContext *s, int type) static void mxf_write_umid(AVFormatContext *s, int type)
{ {
MXFContext *mxf = s->priv_data; MXFContext *mxf = s->priv_data;
put_buffer(s->pb, umid_ul, 13); avio_write(s->pb, umid_ul, 13);
put_be24(s->pb, mxf->instance_number); avio_wb24(s->pb, mxf->instance_number);
put_buffer(s->pb, mxf->umid, 15); avio_write(s->pb, mxf->umid, 15);
put_byte(s->pb, type); avio_w8(s->pb, type);
} }
static void mxf_write_refs_count(AVIOContext *pb, int ref_count) static void mxf_write_refs_count(AVIOContext *pb, int ref_count)
{ {
put_be32(pb, ref_count); avio_wb32(pb, ref_count);
put_be32(pb, 16); avio_wb32(pb, 16);
} }
static int klv_ber_length(uint64_t len) static int klv_ber_length(uint64_t len)
@ -341,25 +341,25 @@ static int klv_encode_ber_length(AVIOContext *pb, uint64_t len)
int size; int size;
if (len < 128) { if (len < 128) {
//short form //short form
put_byte(pb, len); avio_w8(pb, len);
return 1; return 1;
} }
size = (av_log2(len) >> 3) + 1; size = (av_log2(len) >> 3) + 1;
// long form // long form
put_byte(pb, 0x80 + size); avio_w8(pb, 0x80 + size);
while(size) { while(size) {
size--; size--;
put_byte(pb, len >> 8 * size & 0xff); avio_w8(pb, len >> 8 * size & 0xff);
} }
return 0; return 0;
} }
static void klv_encode_ber4_length(AVIOContext *pb, int len) static void klv_encode_ber4_length(AVIOContext *pb, int len)
{ {
put_byte(pb, 0x80 + 3); avio_w8(pb, 0x80 + 3);
put_be24(pb, len); avio_wb24(pb, len);
} }
/* /*
@ -381,28 +381,28 @@ static void mxf_write_primer_pack(AVFormatContext *s)
local_tag_number = FF_ARRAY_ELEMS(mxf_local_tag_batch); local_tag_number = FF_ARRAY_ELEMS(mxf_local_tag_batch);
put_buffer(pb, primer_pack_key, 16); avio_write(pb, primer_pack_key, 16);
klv_encode_ber_length(pb, local_tag_number * 18 + 8); klv_encode_ber_length(pb, local_tag_number * 18 + 8);
put_be32(pb, local_tag_number); // local_tag num avio_wb32(pb, local_tag_number); // local_tag num
put_be32(pb, 18); // item size, always 18 according to the specs avio_wb32(pb, 18); // item size, always 18 according to the specs
for (i = 0; i < local_tag_number; i++) { for (i = 0; i < local_tag_number; i++) {
put_be16(pb, mxf_local_tag_batch[i].local_tag); avio_wb16(pb, mxf_local_tag_batch[i].local_tag);
put_buffer(pb, mxf_local_tag_batch[i].uid, 16); avio_write(pb, mxf_local_tag_batch[i].uid, 16);
} }
} }
static void mxf_write_local_tag(AVIOContext *pb, int size, int tag) static void mxf_write_local_tag(AVIOContext *pb, int size, int tag)
{ {
put_be16(pb, tag); avio_wb16(pb, tag);
put_be16(pb, size); avio_wb16(pb, size);
} }
static void mxf_write_metadata_key(AVIOContext *pb, unsigned int value) static void mxf_write_metadata_key(AVIOContext *pb, unsigned int value)
{ {
put_buffer(pb, header_metadata_key, 13); avio_write(pb, header_metadata_key, 13);
put_be24(pb, value); avio_wb24(pb, value);
} }
static void mxf_free(AVFormatContext *s) 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); av_log(s,AV_LOG_DEBUG, "essence container count:%d\n", c->essence_container_count);
for (i = 0; i < c->essence_container_count; i++) { for (i = 0; i < c->essence_container_count; i++) {
MXFStreamContext *sc = s->streams[i]->priv_data; MXFStreamContext *sc = s->streams[i]->priv_data;
put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16); avio_write(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
} }
} }
@ -456,11 +456,11 @@ static void mxf_write_preface(AVFormatContext *s)
// last modified date // last modified date
mxf_write_local_tag(pb, 8, 0x3B02); mxf_write_local_tag(pb, 8, 0x3B02);
put_be64(pb, mxf->timestamp); avio_wb64(pb, mxf->timestamp);
// write version // write version
mxf_write_local_tag(pb, 2, 0x3B05); mxf_write_local_tag(pb, 2, 0x3B05);
put_be16(pb, 258); // v1.2 avio_wb16(pb, 258); // v1.2
// write identification_refs // write identification_refs
mxf_write_local_tag(pb, 16 + 8, 0x3B06); mxf_write_local_tag(pb, 16 + 8, 0x3B06);
@ -473,7 +473,7 @@ static void mxf_write_preface(AVFormatContext *s)
// operational pattern // operational pattern
mxf_write_local_tag(pb, 16, 0x3B09); mxf_write_local_tag(pb, 16, 0x3B09);
put_buffer(pb, op1a_ul, 16); avio_write(pb, op1a_ul, 16);
// write essence_container_refs // write essence_container_refs
mxf_write_local_tag(pb, 8 + 16 * mxf->essence_container_count, 0x3B0A); 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 // write dm_scheme_refs
mxf_write_local_tag(pb, 8, 0x3B0B); mxf_write_local_tag(pb, 8, 0x3B0B);
put_be64(pb, 0); avio_wb64(pb, 0);
} }
/* /*
@ -492,7 +492,7 @@ static void mxf_write_local_tag_utf16(AVIOContext *pb, int tag, const char *valu
int i, size = strlen(value); int i, size = strlen(value);
mxf_write_local_tag(pb, size*2, tag); mxf_write_local_tag(pb, size*2, tag);
for (i = 0; i < size; i++) for (i = 0; i < size; i++)
put_be16(pb, value[i]); avio_wb16(pb, value[i]);
} }
static void mxf_write_identification(AVFormatContext *s) static void mxf_write_identification(AVFormatContext *s)
@ -531,7 +531,7 @@ static void mxf_write_identification(AVFormatContext *s)
// modification date // modification date
mxf_write_local_tag(pb, 8, 0x3C06); mxf_write_local_tag(pb, 8, 0x3C06);
put_be64(pb, mxf->timestamp); avio_wb64(pb, mxf->timestamp);
} }
static void mxf_write_content_storage(AVFormatContext *s) 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 // write track id
mxf_write_local_tag(pb, 4, 0x4801); mxf_write_local_tag(pb, 4, 0x4801);
put_be32(pb, st->index+2); avio_wb32(pb, st->index+2);
// write track number // write track number
mxf_write_local_tag(pb, 4, 0x4804); mxf_write_local_tag(pb, 4, 0x4804);
if (type == MaterialPackage) if (type == MaterialPackage)
put_be32(pb, 0); // track number of material package is 0 avio_wb32(pb, 0); // track number of material package is 0
else else
put_buffer(pb, sc->track_essence_element_key + 12, 4); avio_write(pb, sc->track_essence_element_key + 12, 4);
mxf_write_local_tag(pb, 8, 0x4B01); mxf_write_local_tag(pb, 8, 0x4B01);
put_be32(pb, mxf->time_base.den); avio_wb32(pb, mxf->time_base.den);
put_be32(pb, mxf->time_base.num); avio_wb32(pb, mxf->time_base.num);
// write origin // write origin
mxf_write_local_tag(pb, 8, 0x4B02); mxf_write_local_tag(pb, 8, 0x4B02);
put_be64(pb, 0); avio_wb64(pb, 0);
// write sequence refs // write sequence refs
mxf_write_local_tag(pb, 16, 0x4803); 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 // find data define uls
mxf_write_local_tag(pb, 16, 0x0201); mxf_write_local_tag(pb, 16, 0x0201);
if (st == mxf->timecode_track) if (st == mxf->timecode_track)
put_buffer(pb, smpte_12m_timecode_track_data_ul, 16); avio_write(pb, smpte_12m_timecode_track_data_ul, 16);
else { else {
const MXFCodecUL *data_def_ul = mxf_get_data_definition_ul(st->codec->codec_type); const MXFCodecUL *data_def_ul = mxf_get_data_definition_ul(st->codec->codec_type);
put_buffer(pb, data_def_ul->uid, 16); avio_write(pb, data_def_ul->uid, 16);
} }
// write duration // write duration
mxf_write_local_tag(pb, 8, 0x0202); mxf_write_local_tag(pb, 8, 0x0202);
put_be64(pb, mxf->duration); avio_wb64(pb, mxf->duration);
} }
static void mxf_write_sequence(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type) 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 // Start Time Code
mxf_write_local_tag(pb, 8, 0x1501); mxf_write_local_tag(pb, 8, 0x1501);
put_be64(pb, mxf->timecode_start); avio_wb64(pb, mxf->timecode_start);
// Rounded Time Code Base // Rounded Time Code Base
mxf_write_local_tag(pb, 2, 0x1502); mxf_write_local_tag(pb, 2, 0x1502);
put_be16(pb, mxf->timecode_base); avio_wb16(pb, mxf->timecode_base);
// Drop Frame // Drop Frame
mxf_write_local_tag(pb, 1, 0x1503); mxf_write_local_tag(pb, 1, 0x1503);
put_byte(pb, mxf->timecode_drop_frame); avio_w8(pb, mxf->timecode_drop_frame);
} }
static void mxf_write_structural_component(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type) 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 // write start_position
mxf_write_local_tag(pb, 8, 0x1201); mxf_write_local_tag(pb, 8, 0x1201);
put_be64(pb, 0); avio_wb64(pb, 0);
// write source package uid, end of the reference // write source package uid, end of the reference
mxf_write_local_tag(pb, 32, 0x1101); mxf_write_local_tag(pb, 32, 0x1101);
if (type == SourcePackage) { if (type == SourcePackage) {
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
put_be64(pb, 0); avio_wb64(pb, 0);
} else } else
mxf_write_umid(s, 1); mxf_write_umid(s, 1);
// write source track id // write source track id
mxf_write_local_tag(pb, 4, 0x1102); mxf_write_local_tag(pb, 4, 0x1102);
if (type == SourcePackage) if (type == SourcePackage)
put_be32(pb, 0); avio_wb32(pb, 0);
else else
put_be32(pb, st->index+2); avio_wb32(pb, st->index+2);
} }
static void mxf_write_multi_descriptor(AVFormatContext *s) static void mxf_write_multi_descriptor(AVFormatContext *s)
@ -728,8 +728,8 @@ static void mxf_write_multi_descriptor(AVFormatContext *s)
// write sample rate // write sample rate
mxf_write_local_tag(pb, 8, 0x3001); mxf_write_local_tag(pb, 8, 0x3001);
put_be32(pb, mxf->time_base.den); avio_wb32(pb, mxf->time_base.den);
put_be32(pb, mxf->time_base.num); avio_wb32(pb, mxf->time_base.num);
// write essence container ul // write essence container ul
mxf_write_local_tag(pb, 16, 0x3004); 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; MXFStreamContext *sc = s->streams[0]->priv_data;
ul = mxf_essence_container_uls[sc->index].container_ul; ul = mxf_essence_container_uls[sc->index].container_ul;
} }
put_buffer(pb, ul, 16); avio_write(pb, ul, 16);
// write sub descriptor refs // write sub descriptor refs
mxf_write_local_tag(pb, s->nb_streams * 16 + 8, 0x3F01); 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; MXFStreamContext *sc = st->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
put_buffer(pb, key, 16); avio_write(pb, key, 16);
klv_encode_ber4_length(pb, size+20+8+12+20); klv_encode_ber4_length(pb, size+20+8+12+20);
mxf_write_local_tag(pb, 16, 0x3C0A); mxf_write_local_tag(pb, 16, 0x3C0A);
mxf_write_uuid(pb, SubDescriptor, st->index); mxf_write_uuid(pb, SubDescriptor, st->index);
mxf_write_local_tag(pb, 4, 0x3006); mxf_write_local_tag(pb, 4, 0x3006);
put_be32(pb, st->index+2); avio_wb32(pb, st->index+2);
mxf_write_local_tag(pb, 8, 0x3001); mxf_write_local_tag(pb, 8, 0x3001);
put_be32(pb, mxf->time_base.den); avio_wb32(pb, mxf->time_base.den);
put_be32(pb, mxf->time_base.num); avio_wb32(pb, mxf->time_base.num);
mxf_write_local_tag(pb, 16, 0x3004); mxf_write_local_tag(pb, 16, 0x3004);
put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16); avio_write(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 }; 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_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); mxf_write_local_tag(pb, 4, 0x3203);
put_be32(pb, st->codec->width); avio_wb32(pb, st->codec->width);
mxf_write_local_tag(pb, 4, 0x3202); mxf_write_local_tag(pb, 4, 0x3202);
put_be32(pb, stored_height>>sc->interlaced); avio_wb32(pb, stored_height>>sc->interlaced);
mxf_write_local_tag(pb, 4, 0x3209); mxf_write_local_tag(pb, 4, 0x3209);
put_be32(pb, st->codec->width); avio_wb32(pb, st->codec->width);
if (st->codec->height == 608) // PAL + VBI if (st->codec->height == 608) // PAL + VBI
display_height = 576; 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; display_height = st->codec->height;
mxf_write_local_tag(pb, 4, 0x3208); mxf_write_local_tag(pb, 4, 0x3208);
put_be32(pb, display_height>>sc->interlaced); avio_wb32(pb, display_height>>sc->interlaced);
// component depth // component depth
mxf_write_local_tag(pb, 4, 0x3301); mxf_write_local_tag(pb, 4, 0x3301);
put_be32(pb, 8); avio_wb32(pb, 8);
// horizontal subsampling // horizontal subsampling
mxf_write_local_tag(pb, 4, 0x3302); mxf_write_local_tag(pb, 4, 0x3302);
put_be32(pb, 2); avio_wb32(pb, 2);
// frame layout // frame layout
mxf_write_local_tag(pb, 1, 0x320C); mxf_write_local_tag(pb, 1, 0x320C);
put_byte(pb, sc->interlaced); avio_w8(pb, sc->interlaced);
// video line map // video line map
switch (st->codec->height) { 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); mxf_write_local_tag(pb, 12+sc->interlaced*4, 0x320D);
put_be32(pb, sc->interlaced ? 2 : 1); avio_wb32(pb, sc->interlaced ? 2 : 1);
put_be32(pb, 4); avio_wb32(pb, 4);
put_be32(pb, f1); avio_wb32(pb, f1);
if (sc->interlaced) if (sc->interlaced)
put_be32(pb, f2); avio_wb32(pb, f2);
mxf_write_local_tag(pb, 8, 0x320E); mxf_write_local_tag(pb, 8, 0x320E);
put_be32(pb, sc->aspect_ratio.num); avio_wb32(pb, sc->aspect_ratio.num);
put_be32(pb, sc->aspect_ratio.den); avio_wb32(pb, sc->aspect_ratio.den);
mxf_write_local_tag(pb, 16, 0x3201); mxf_write_local_tag(pb, 16, 0x3201);
put_buffer(pb, *sc->codec_ul, 16); avio_write(pb, *sc->codec_ul, 16);
} }
static void mxf_write_cdci_desc(AVFormatContext *s, AVStream *st) 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 // bit rate
mxf_write_local_tag(pb, 4, 0x8000); mxf_write_local_tag(pb, 4, 0x8000);
put_be32(pb, st->codec->bit_rate); avio_wb32(pb, st->codec->bit_rate);
// profile and level // profile and level
mxf_write_local_tag(pb, 1, 0x8007); mxf_write_local_tag(pb, 1, 0x8007);
if (!st->codec->profile) if (!st->codec->profile)
profile_and_level |= 0x80; // escape bit profile_and_level |= 0x80; // escape bit
put_byte(pb, profile_and_level); avio_w8(pb, profile_and_level);
} }
static void mxf_write_generic_sound_common(AVFormatContext *s, AVStream *st, const UID key, unsigned size) 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 // audio locked
mxf_write_local_tag(pb, 1, 0x3D02); mxf_write_local_tag(pb, 1, 0x3D02);
put_byte(pb, 1); avio_w8(pb, 1);
// write audio sampling rate // write audio sampling rate
mxf_write_local_tag(pb, 8, 0x3D03); mxf_write_local_tag(pb, 8, 0x3D03);
put_be32(pb, st->codec->sample_rate); avio_wb32(pb, st->codec->sample_rate);
put_be32(pb, 1); avio_wb32(pb, 1);
mxf_write_local_tag(pb, 4, 0x3D07); mxf_write_local_tag(pb, 4, 0x3D07);
put_be32(pb, st->codec->channels); avio_wb32(pb, st->codec->channels);
mxf_write_local_tag(pb, 4, 0x3D01); mxf_write_local_tag(pb, 4, 0x3D01);
put_be32(pb, av_get_bits_per_sample(st->codec->codec_id)); avio_wb32(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) 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_generic_sound_common(s, st, key, size+6+8);
mxf_write_local_tag(pb, 2, 0x3D0A); mxf_write_local_tag(pb, 2, 0x3D0A);
put_be16(pb, st->codec->block_align); avio_wb16(pb, st->codec->block_align);
// avg bytes per sec // avg bytes per sec
mxf_write_local_tag(pb, 4, 0x3D09); mxf_write_local_tag(pb, 4, 0x3D09);
put_be32(pb, st->codec->block_align*st->codec->sample_rate); avio_wb32(pb, st->codec->block_align*st->codec->sample_rate);
} }
static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st) 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 // package creation date
mxf_write_local_tag(pb, 8, 0x4405); mxf_write_local_tag(pb, 8, 0x4405);
put_be64(pb, mxf->timestamp); avio_wb64(pb, mxf->timestamp);
// package modified date // package modified date
mxf_write_local_tag(pb, 8, 0x4404); mxf_write_local_tag(pb, 8, 0x4404);
put_be64(pb, mxf->timestamp); avio_wb64(pb, mxf->timestamp);
// write track refs // write track refs
mxf_write_local_tag(pb, track_count*16 + 8, 0x4403); 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_umid(s, 1);
mxf_write_local_tag(pb, 4, 0x3F07); // BodySID mxf_write_local_tag(pb, 4, 0x3F07); // BodySID
put_be32(pb, 1); avio_wb32(pb, 1);
mxf_write_local_tag(pb, 4, 0x3F06); // IndexSID mxf_write_local_tag(pb, 4, 0x3F06); // IndexSID
put_be32(pb, 2); avio_wb32(pb, 2);
return 0; 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) if (!mxf->edit_units_count && !mxf->edit_unit_byte_count)
return; return;
put_buffer(pb, index_table_segment_key, 16); avio_write(pb, index_table_segment_key, 16);
if (mxf->edit_unit_byte_count) { if (mxf->edit_unit_byte_count) {
klv_encode_ber_length(pb, 80); klv_encode_ber_length(pb, 80);
@ -1063,65 +1063,65 @@ static void mxf_write_index_table_segment(AVFormatContext *s)
// index edit rate // index edit rate
mxf_write_local_tag(pb, 8, 0x3F0B); mxf_write_local_tag(pb, 8, 0x3F0B);
put_be32(pb, mxf->time_base.den); avio_wb32(pb, mxf->time_base.den);
put_be32(pb, mxf->time_base.num); avio_wb32(pb, mxf->time_base.num);
// index start position // index start position
mxf_write_local_tag(pb, 8, 0x3F0C); mxf_write_local_tag(pb, 8, 0x3F0C);
put_be64(pb, mxf->last_indexed_edit_unit); avio_wb64(pb, mxf->last_indexed_edit_unit);
// index duration // index duration
mxf_write_local_tag(pb, 8, 0x3F0D); mxf_write_local_tag(pb, 8, 0x3F0D);
if (mxf->edit_unit_byte_count) if (mxf->edit_unit_byte_count)
put_be64(pb, 0); // index table covers whole container avio_wb64(pb, 0); // index table covers whole container
else else
put_be64(pb, mxf->edit_units_count); avio_wb64(pb, mxf->edit_units_count);
// edit unit byte count // edit unit byte count
mxf_write_local_tag(pb, 4, 0x3F05); mxf_write_local_tag(pb, 4, 0x3F05);
put_be32(pb, mxf->edit_unit_byte_count); avio_wb32(pb, mxf->edit_unit_byte_count);
// index sid // index sid
mxf_write_local_tag(pb, 4, 0x3F06); mxf_write_local_tag(pb, 4, 0x3F06);
put_be32(pb, 2); avio_wb32(pb, 2);
// body sid // body sid
mxf_write_local_tag(pb, 4, 0x3F07); mxf_write_local_tag(pb, 4, 0x3F07);
put_be32(pb, 1); avio_wb32(pb, 1);
if (!mxf->edit_unit_byte_count) { if (!mxf->edit_unit_byte_count) {
// real slice count - 1 // real slice count - 1
mxf_write_local_tag(pb, 1, 0x3F08); mxf_write_local_tag(pb, 1, 0x3F08);
put_byte(pb, mxf->slice_count); avio_w8(pb, mxf->slice_count);
// delta entry array // delta entry array
mxf_write_local_tag(pb, 8 + (s->nb_streams+1)*6, 0x3F09); mxf_write_local_tag(pb, 8 + (s->nb_streams+1)*6, 0x3F09);
put_be32(pb, s->nb_streams+1); // num of entries avio_wb32(pb, s->nb_streams+1); // num of entries
put_be32(pb, 6); // size of one entry avio_wb32(pb, 6); // size of one entry
// write system item delta entry // write system item delta entry
put_byte(pb, 0); avio_w8(pb, 0);
put_byte(pb, 0); // slice entry avio_w8(pb, 0); // slice entry
put_be32(pb, 0); // element delta avio_wb32(pb, 0); // element delta
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i]; AVStream *st = s->streams[i];
MXFStreamContext *sc = st->priv_data; MXFStreamContext *sc = st->priv_data;
put_byte(pb, sc->temporal_reordering); avio_w8(pb, sc->temporal_reordering);
if (sc->temporal_reordering) if (sc->temporal_reordering)
temporal_reordering = 1; temporal_reordering = 1;
if (i == 0) { // video track if (i == 0) { // video track
put_byte(pb, 0); // slice number avio_w8(pb, 0); // slice number
put_be32(pb, KAG_SIZE); // system item size including klv fill avio_wb32(pb, KAG_SIZE); // system item size including klv fill
} else { // audio track } else { // audio track
unsigned audio_frame_size = sc->aic.samples[0]*sc->aic.sample_size; unsigned audio_frame_size = sc->aic.samples[0]*sc->aic.sample_size;
audio_frame_size += klv_fill_size(audio_frame_size); audio_frame_size += klv_fill_size(audio_frame_size);
put_byte(pb, 1); avio_w8(pb, 1);
put_be32(pb, (i-1)*audio_frame_size); // element delta avio_wb32(pb, (i-1)*audio_frame_size); // element delta
} }
} }
mxf_write_local_tag(pb, 8 + mxf->edit_units_count*(11+mxf->slice_count*4), 0x3F0A); 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 avio_wb32(pb, mxf->edit_units_count); // num of entries
put_be32(pb, 11+mxf->slice_count*4); // size of one entry avio_wb32(pb, 11+mxf->slice_count*4); // size of one entry
for (i = 0; i < mxf->edit_units_count; i++) { for (i = 0; i < mxf->edit_units_count; i++) {
int temporal_offset = 0; 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; temporal_offset = j - key_index - pic_num_in_gop;
} }
} }
put_byte(pb, temporal_offset); avio_w8(pb, temporal_offset);
if ((mxf->index_entries[i].flags & 0x30) == 0x30) { // back and forward prediction if ((mxf->index_entries[i].flags & 0x30) == 0x30) { // back and forward prediction
put_byte(pb, mxf->last_key_index - i); avio_w8(pb, mxf->last_key_index - i);
} else { } else {
put_byte(pb, key_index - i); // key frame offset avio_w8(pb, key_index - i); // key frame offset
if ((mxf->index_entries[i].flags & 0x20) == 0x20) // only forward if ((mxf->index_entries[i].flags & 0x20) == 0x20) // only forward
mxf->last_key_index = key_index; 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 if (!(mxf->index_entries[i].flags & 0x33) && // I frame
mxf->index_entries[i].flags & 0x40 && !temporal_offset) mxf->index_entries[i].flags & 0x40 && !temporal_offset)
mxf->index_entries[i].flags |= 0x80; // random access mxf->index_entries[i].flags |= 0x80; // random access
put_byte(pb, mxf->index_entries[i].flags); avio_w8(pb, mxf->index_entries[i].flags);
// stream offset // stream offset
put_be64(pb, mxf->index_entries[i].offset); avio_wb64(pb, mxf->index_entries[i].offset);
if (s->nb_streams > 1) if (s->nb_streams > 1)
put_be32(pb, mxf->index_entries[i].slice_offset); avio_wb32(pb, mxf->index_entries[i].slice_offset);
} }
mxf->last_key_index = key_index - mxf->edit_units_count; 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)); unsigned pad = klv_fill_size(url_ftell(s->pb));
if (pad) { if (pad) {
put_buffer(s->pb, klv_fill_key, 16); avio_write(s->pb, klv_fill_key, 16);
pad -= 16 + 4; pad -= 16 + 4;
klv_encode_ber4_length(s->pb, pad); klv_encode_ber4_length(s->pb, pad);
for (; pad; pad--) for (; pad; pad--)
put_byte(s->pb, 0); avio_w8(s->pb, 0);
assert(!(url_ftell(s->pb) & (KAG_SIZE-1))); assert(!(url_ftell(s->pb) & (KAG_SIZE-1)));
} }
} }
@ -1213,43 +1213,43 @@ static void mxf_write_partition(AVFormatContext *s, int bodysid,
} }
// write klv // write klv
put_buffer(pb, key, 16); avio_write(pb, key, 16);
klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count); klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count);
// write partition value // write partition value
put_be16(pb, 1); // majorVersion avio_wb16(pb, 1); // majorVersion
put_be16(pb, 2); // minorVersion avio_wb16(pb, 2); // minorVersion
put_be32(pb, KAG_SIZE); // KAGSize avio_wb32(pb, KAG_SIZE); // KAGSize
put_be64(pb, partition_offset); // ThisPartition avio_wb64(pb, partition_offset); // ThisPartition
if (!memcmp(key, body_partition_key, 16) && mxf->body_partitions_count > 1) 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_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]); // PreviousPartition
else if (!memcmp(key, footer_partition_key, 16) && mxf->body_partitions_count) 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_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]); // PreviousPartition
else else
put_be64(pb, 0); avio_wb64(pb, 0);
put_be64(pb, mxf->footer_partition_offset); // footerPartition avio_wb64(pb, mxf->footer_partition_offset); // footerPartition
// set offset // set offset
header_byte_count_offset = url_ftell(pb); header_byte_count_offset = url_ftell(pb);
put_be64(pb, 0); // headerByteCount, update later avio_wb64(pb, 0); // headerByteCount, update later
// indexTable // indexTable
put_be64(pb, index_byte_count); // indexByteCount avio_wb64(pb, index_byte_count); // indexByteCount
put_be32(pb, index_byte_count ? indexsid : 0); // indexSID avio_wb32(pb, index_byte_count ? indexsid : 0); // indexSID
// BodyOffset // BodyOffset
if (bodysid && mxf->edit_units_count && mxf->body_partitions_count) { if (bodysid && mxf->edit_units_count && mxf->body_partitions_count) {
put_be64(pb, mxf->body_offset); avio_wb64(pb, mxf->body_offset);
} else } else
put_be64(pb, 0); avio_wb64(pb, 0);
put_be32(pb, bodysid); // bodySID avio_wb32(pb, bodysid); // bodySID
// operational pattern // operational pattern
put_buffer(pb, op1a_ul, 16); avio_write(pb, op1a_ul, 16);
// essence container // essence container
mxf_write_essence_container_refs(s); mxf_write_essence_container_refs(s);
@ -1268,7 +1268,7 @@ static void mxf_write_partition(AVFormatContext *s, int bodysid,
// update header_byte_count // update header_byte_count
url_fseek(pb, header_byte_count_offset, SEEK_SET); url_fseek(pb, header_byte_count_offset, SEEK_SET);
put_be64(pb, header_byte_count); avio_wb64(pb, header_byte_count);
url_fseek(pb, pos, SEEK_SET); 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; frame = mxf->timecode_start + mxf->last_indexed_edit_unit + mxf->edit_units_count;
// write system metadata pack // write system metadata pack
put_buffer(pb, system_metadata_pack_key, 16); avio_write(pb, system_metadata_pack_key, 16);
klv_encode_ber4_length(pb, 57); klv_encode_ber4_length(pb, 57);
put_byte(pb, 0x5c); // UL, user date/time stamp, picture and sound item present avio_w8(pb, 0x5c); // UL, user date/time stamp, picture and sound item present
put_byte(pb, 0x04); // content package rate avio_w8(pb, 0x04); // content package rate
put_byte(pb, 0x00); // content package type avio_w8(pb, 0x00); // content package type
put_be16(pb, 0x00); // channel handle avio_wb16(pb, 0x00); // channel handle
put_be16(pb, frame); // continuity count avio_wb16(pb, frame); // continuity count
if (mxf->essence_container_count > 1) if (mxf->essence_container_count > 1)
put_buffer(pb, multiple_desc_ul, 16); avio_write(pb, multiple_desc_ul, 16);
else { else {
MXFStreamContext *sc = s->streams[0]->priv_data; MXFStreamContext *sc = s->streams[0]->priv_data;
put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16); avio_write(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
} }
put_byte(pb, 0); avio_w8(pb, 0);
put_be64(pb, 0); avio_wb64(pb, 0);
put_be64(pb, 0); // creation date/time stamp avio_wb64(pb, 0); // creation date/time stamp
put_byte(pb, 0x81); // SMPTE 12M time code avio_w8(pb, 0x81); // SMPTE 12M time code
time_code = ff_framenum_to_12m_time_code(frame, mxf->timecode_drop_frame, mxf->timecode_base); time_code = ff_framenum_to_12m_time_code(frame, mxf->timecode_drop_frame, mxf->timecode_base);
put_be32(pb, time_code); avio_wb32(pb, time_code);
put_be32(pb, 0); // binary group data avio_wb32(pb, 0); // binary group data
put_be64(pb, 0); avio_wb64(pb, 0);
// write system metadata package set // write system metadata package set
put_buffer(pb, system_metadata_package_set_key, 16); avio_write(pb, system_metadata_package_set_key, 16);
klv_encode_ber4_length(pb, 35); klv_encode_ber4_length(pb, 35);
put_byte(pb, 0x83); // UMID avio_w8(pb, 0x83); // UMID
put_be16(pb, 0x20); avio_wb16(pb, 0x20);
mxf_write_umid(s, 1); 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); packet_size += klv_fill_size(packet_size);
klv_encode_ber4_length(pb, pkt->size); klv_encode_ber4_length(pb, pkt->size);
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
// ensure CBR muxing by padding to correct video frame size // ensure CBR muxing by padding to correct video frame size
pad = packet_size - pkt->size - 16 - 4; pad = packet_size - pkt->size - 16 - 4;
if (pad > 20) { if (pad > 20) {
put_buffer(s->pb, klv_fill_key, 16); avio_write(s->pb, klv_fill_key, 16);
pad -= 16 + 4; pad -= 16 + 4;
klv_encode_ber4_length(s->pb, pad); klv_encode_ber4_length(s->pb, pad);
for (; pad; pad--) for (; pad; pad--)
put_byte(s->pb, 0); avio_w8(s->pb, 0);
assert(!(url_ftell(s->pb) & (KAG_SIZE-1))); assert(!(url_ftell(s->pb) & (KAG_SIZE-1)));
} else { } else {
av_log(s, AV_LOG_WARNING, "cannot fill d-10 video packet\n"); av_log(s, AV_LOG_WARNING, "cannot fill d-10 video packet\n");
for (; pad > 0; pad--) for (; pad > 0; pad--)
put_byte(s->pb, 0); avio_w8(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); klv_encode_ber4_length(pb, 4 + frame_size*4*8);
put_byte(pb, (frame_size == 1920 ? 0 : (mxf->edit_units_count-1) % 5 + 1)); avio_w8(pb, (frame_size == 1920 ? 0 : (mxf->edit_units_count-1) % 5 + 1));
put_le16(pb, frame_size); avio_wl16(pb, frame_size);
put_byte(pb, (1<<st->codec->channels)-1); avio_w8(pb, (1<<st->codec->channels)-1);
while (samples < end) { while (samples < end) {
for (i = 0; i < st->codec->channels; i++) { 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; sample = AV_RL16(samples)<<12;
samples += 2; samples += 2;
} }
put_le32(pb, sample | i); avio_wl32(pb, sample | i);
} }
for (; i < 8; i++) for (; i < 8; i++)
put_le32(pb, i); avio_wl32(pb, i);
} }
} }
@ -1719,7 +1719,7 @@ static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
} }
mxf_write_klv_fill(s); mxf_write_klv_fill(s);
put_buffer(pb, sc->track_essence_element_key, 16); // write key avio_write(pb, sc->track_essence_element_key, 16); // write key
if (s->oformat == &ff_mxf_d10_muxer) { if (s->oformat == &ff_mxf_d10_muxer) {
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
mxf_write_d10_video_packet(s, st, pkt); 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); mxf_write_d10_audio_packet(s, st, pkt);
} else { } else {
klv_encode_ber4_length(pb, pkt->size); // write length klv_encode_ber4_length(pb, pkt->size); // write length
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
mxf->body_offset += 16+4+pkt->size + klv_fill_size(16+4+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); uint64_t pos = url_ftell(pb);
int i; int i;
put_buffer(pb, random_index_pack_key, 16); avio_write(pb, random_index_pack_key, 16);
klv_encode_ber_length(pb, 28 + 12*mxf->body_partitions_count); klv_encode_ber_length(pb, 28 + 12*mxf->body_partitions_count);
if (mxf->edit_unit_byte_count) if (mxf->edit_unit_byte_count)
put_be32(pb, 1); // BodySID of header partition avio_wb32(pb, 1); // BodySID of header partition
else else
put_be32(pb, 0); avio_wb32(pb, 0);
put_be64(pb, 0); // offset of header partition avio_wb64(pb, 0); // offset of header partition
for (i = 0; i < mxf->body_partitions_count; i++) { for (i = 0; i < mxf->body_partitions_count; i++) {
put_be32(pb, 1); // BodySID avio_wb32(pb, 1); // BodySID
put_be64(pb, mxf->body_partition_offset[i]); avio_wb64(pb, mxf->body_partition_offset[i]);
} }
put_be32(pb, 0); // BodySID of footer partition avio_wb32(pb, 0); // BodySID of footer partition
put_be64(pb, mxf->footer_partition_offset); avio_wb64(pb, mxf->footer_partition_offset);
put_be32(pb, url_ftell(pb) - pos + 4); avio_wb32(pb, url_ftell(pb) - pos + 4);
} }
static int mxf_write_footer(AVFormatContext *s) static int mxf_write_footer(AVFormatContext *s)

32
libavformat/nutenc.c
Unescape View File

@ -254,7 +254,7 @@ static void put_str(AVIOContext *bc, const char *string){
int len= strlen(string); int len= strlen(string);
ff_put_v(bc, len); ff_put_v(bc, len);
put_buffer(bc, string, len); avio_write(bc, string, len);
} }
static void put_s(AVIOContext *bc, int64_t val){ static void put_s(AVIOContext *bc, int64_t val){
@ -285,16 +285,16 @@ static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc, in
if(forw_ptr > 4096) if(forw_ptr > 4096)
init_checksum(bc, ff_crc04C11DB7_update, 0); init_checksum(bc, ff_crc04C11DB7_update, 0);
put_be64(bc, startcode); avio_wb64(bc, startcode);
ff_put_v(bc, forw_ptr); ff_put_v(bc, forw_ptr);
if(forw_ptr > 4096) if(forw_ptr > 4096)
put_le32(bc, get_checksum(bc)); avio_wl32(bc, get_checksum(bc));
if(calculate_checksum) if(calculate_checksum)
init_checksum(bc, ff_crc04C11DB7_update, 0); init_checksum(bc, ff_crc04C11DB7_update, 0);
put_buffer(bc, dyn_buf, dyn_size); avio_write(bc, dyn_buf, dyn_size);
if(calculate_checksum) if(calculate_checksum)
put_le32(bc, get_checksum(bc)); avio_wl32(bc, get_checksum(bc));
av_free(dyn_buf); av_free(dyn_buf);
} }
@ -366,7 +366,7 @@ static void write_mainheader(NUTContext *nut, AVIOContext *bc){
ff_put_v(bc, nut->header_count-1); ff_put_v(bc, nut->header_count-1);
for(i=1; i<nut->header_count; i++){ for(i=1; i<nut->header_count; i++){
ff_put_v(bc, nut->header_len[i]); ff_put_v(bc, nut->header_len[i]);
put_buffer(bc, nut->header[i], nut->header_len[i]); avio_write(bc, nut->header[i], nut->header_len[i]);
} }
} }
@ -382,7 +382,7 @@ static int write_streamheader(AVFormatContext *avctx, AVIOContext *bc, AVStream
} }
ff_put_v(bc, 4); ff_put_v(bc, 4);
if (codec->codec_tag){ if (codec->codec_tag){
put_le32(bc, codec->codec_tag); avio_wl32(bc, codec->codec_tag);
} else { } else {
av_log(avctx, AV_LOG_ERROR, "No codec tag defined for stream %d\n", i); av_log(avctx, AV_LOG_ERROR, "No codec tag defined for stream %d\n", i);
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -392,10 +392,10 @@ static int write_streamheader(AVFormatContext *avctx, AVIOContext *bc, AVStream
ff_put_v(bc, nut->stream[i].msb_pts_shift); ff_put_v(bc, nut->stream[i].msb_pts_shift);
ff_put_v(bc, nut->stream[i].max_pts_distance); ff_put_v(bc, nut->stream[i].max_pts_distance);
ff_put_v(bc, codec->has_b_frames); ff_put_v(bc, codec->has_b_frames);
put_byte(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */ avio_w8(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */
ff_put_v(bc, codec->extradata_size); ff_put_v(bc, codec->extradata_size);
put_buffer(bc, codec->extradata, codec->extradata_size); avio_write(bc, codec->extradata, codec->extradata_size);
switch(codec->codec_type){ switch(codec->codec_type){
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
@ -450,7 +450,7 @@ static int write_globalinfo(NUTContext *nut, AVIOContext *bc){
ff_put_v(bc, count); ff_put_v(bc, count);
dyn_size= url_close_dyn_buf(dyn_bc, &dyn_buf); dyn_size= url_close_dyn_buf(dyn_bc, &dyn_buf);
put_buffer(bc, dyn_buf, dyn_size); avio_write(bc, dyn_buf, dyn_size);
av_free(dyn_buf); av_free(dyn_buf);
return 0; return 0;
} }
@ -479,7 +479,7 @@ static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id){
ff_put_v(bc, count); ff_put_v(bc, count);
put_buffer(bc, dyn_buf, dyn_size); avio_write(bc, dyn_buf, dyn_size);
} }
av_free(dyn_buf); av_free(dyn_buf);
@ -575,8 +575,8 @@ static int write_header(AVFormatContext *s){
build_frame_code(s); build_frame_code(s);
assert(nut->frame_code['N'].flags == FLAG_INVALID); assert(nut->frame_code['N'].flags == FLAG_INVALID);
put_buffer(bc, ID_STRING, strlen(ID_STRING)); avio_write(bc, ID_STRING, strlen(ID_STRING));
put_byte(bc, 0); avio_w8(bc, 0);
if ((ret = write_headers(s, bc)) < 0) if ((ret = write_headers(s, bc)) < 0)
return ret; return ret;
@ -749,7 +749,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt){
header_idx= fc->header_idx; header_idx= fc->header_idx;
init_checksum(bc, ff_crc04C11DB7_update, 0); init_checksum(bc, ff_crc04C11DB7_update, 0);
put_byte(bc, frame_code); avio_w8(bc, frame_code);
if(flags & FLAG_CODED){ if(flags & FLAG_CODED){
ff_put_v(bc, (flags^needed_flags) & ~(FLAG_CODED)); ff_put_v(bc, (flags^needed_flags) & ~(FLAG_CODED));
flags = needed_flags; 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_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_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_wl32(bc, get_checksum(bc));
else 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_write(bc, pkt->data + nut->header_len[header_idx], pkt->size - nut->header_len[header_idx]);
nus->last_flags= flags; nus->last_flags= flags;
nus->last_pts= pkt->pts; nus->last_pts= pkt->pts;

22
libavformat/oggenc.c
Unescape View File

@ -69,7 +69,7 @@ static void ogg_update_checksum(AVFormatContext *s, AVIOContext *pb, int64_t crc
int64_t pos = url_ftell(pb); int64_t pos = url_ftell(pb);
uint32_t checksum = get_checksum(pb); uint32_t checksum = get_checksum(pb);
url_fseek(pb, crc_offset, SEEK_SET); url_fseek(pb, crc_offset, SEEK_SET);
put_be32(pb, checksum); avio_wb32(pb, checksum);
url_fseek(pb, pos, SEEK_SET); url_fseek(pb, pos, SEEK_SET);
} }
@ -86,16 +86,16 @@ static int ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)
return ret; return ret;
init_checksum(pb, ff_crc04C11DB7_update, 0); init_checksum(pb, ff_crc04C11DB7_update, 0);
put_tag(pb, "OggS"); put_tag(pb, "OggS");
put_byte(pb, 0); avio_w8(pb, 0);
put_byte(pb, page->flags | extra_flags); avio_w8(pb, page->flags | extra_flags);
put_le64(pb, page->granule); avio_wl64(pb, page->granule);
put_le32(pb, oggstream->serial_num); avio_wl32(pb, oggstream->serial_num);
put_le32(pb, oggstream->page_counter++); avio_wl32(pb, oggstream->page_counter++);
crc_offset = url_ftell(pb); crc_offset = url_ftell(pb);
put_le32(pb, 0); // crc avio_wl32(pb, 0); // crc
put_byte(pb, page->segments_count); avio_w8(pb, page->segments_count);
put_buffer(pb, page->segments, page->segments_count); avio_write(pb, page->segments, page->segments_count);
put_buffer(pb, page->data, page->size); avio_write(pb, page->data, page->size);
ogg_update_checksum(s, pb, crc_offset); ogg_update_checksum(s, pb, crc_offset);
put_flush_packet(pb); put_flush_packet(pb);
@ -104,7 +104,7 @@ static int ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)
if (size < 0) if (size < 0)
return size; return size;
put_buffer(s->pb, buf, size); avio_write(s->pb, buf, size);
put_flush_packet(s->pb); put_flush_packet(s->pb);
av_free(buf); av_free(buf);
oggstream->page_count--; oggstream->page_count--;

2
libavformat/rawenc.c
Unescape View File

@ -25,7 +25,7 @@
int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt) int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
put_buffer(s->pb, pkt->data, pkt->size); avio_write(s->pb, pkt->data, pkt->size);
put_flush_packet(s->pb); put_flush_packet(s->pb);
return 0; return 0;
} }

64
libavformat/riff.c
Unescape View File

@ -322,7 +322,7 @@ const AVCodecTag ff_codec_wav_tags[] = {
int64_t ff_start_tag(AVIOContext *pb, const char *tag) int64_t ff_start_tag(AVIOContext *pb, const char *tag)
{ {
put_tag(pb, tag); put_tag(pb, tag);
put_le32(pb, 0); avio_wl32(pb, 0);
return url_ftell(pb); return url_ftell(pb);
} }
@ -332,7 +332,7 @@ void ff_end_tag(AVIOContext *pb, int64_t start)
pos = url_ftell(pb); pos = url_ftell(pb);
url_fseek(pb, start - 4, SEEK_SET); url_fseek(pb, start - 4, SEEK_SET);
put_le32(pb, (uint32_t)(pos - start)); avio_wl32(pb, (uint32_t)(pos - start));
url_fseek(pb, pos, SEEK_SET); url_fseek(pb, pos, SEEK_SET);
} }
@ -354,12 +354,12 @@ int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc)
|| av_get_bits_per_sample(enc->codec_id) > 16; || av_get_bits_per_sample(enc->codec_id) > 16;
if (waveformatextensible) { if (waveformatextensible) {
put_le16(pb, 0xfffe); avio_wl16(pb, 0xfffe);
} else { } else {
put_le16(pb, enc->codec_tag); avio_wl16(pb, enc->codec_tag);
} }
put_le16(pb, enc->channels); avio_wl16(pb, enc->channels);
put_le32(pb, enc->sample_rate); avio_wl32(pb, enc->sample_rate);
if (enc->codec_id == CODEC_ID_MP2 || enc->codec_id == CODEC_ID_MP3 || enc->codec_id == CODEC_ID_GSM_MS) { if (enc->codec_id == CODEC_ID_MP2 || enc->codec_id == CODEC_ID_MP3 || enc->codec_id == CODEC_ID_GSM_MS) {
bps = 0; bps = 0;
} else if (enc->codec_id == CODEC_ID_ADPCM_G726) { } else if (enc->codec_id == CODEC_ID_ADPCM_G726) {
@ -393,9 +393,9 @@ int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc)
} else { } else {
bytespersec = enc->bit_rate / 8; bytespersec = enc->bit_rate / 8;
} }
put_le32(pb, bytespersec); /* bytes per second */ avio_wl32(pb, bytespersec); /* bytes per second */
put_le16(pb, blkalign); /* block align */ avio_wl16(pb, blkalign); /* block align */
put_le16(pb, bps); /* bits per sample */ avio_wl16(pb, bps); /* bits per sample */
if (enc->codec_id == CODEC_ID_MP3) { if (enc->codec_id == CODEC_ID_MP3) {
hdrsize += 12; hdrsize += 12;
bytestream_put_le16(&riff_extradata, 1); /* wID */ bytestream_put_le16(&riff_extradata, 1); /* wID */
@ -425,20 +425,20 @@ int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc)
} }
if(waveformatextensible) { /* write WAVEFORMATEXTENSIBLE extensions */ if(waveformatextensible) { /* write WAVEFORMATEXTENSIBLE extensions */
hdrsize += 22; hdrsize += 22;
put_le16(pb, riff_extradata - riff_extradata_start + 22); /* 22 is WAVEFORMATEXTENSIBLE size */ avio_wl16(pb, riff_extradata - riff_extradata_start + 22); /* 22 is WAVEFORMATEXTENSIBLE size */
put_le16(pb, enc->bits_per_coded_sample); /* ValidBitsPerSample || SamplesPerBlock || Reserved */ avio_wl16(pb, enc->bits_per_coded_sample); /* ValidBitsPerSample || SamplesPerBlock || Reserved */
put_le32(pb, enc->channel_layout); /* dwChannelMask */ avio_wl32(pb, enc->channel_layout); /* dwChannelMask */
put_le32(pb, enc->codec_tag); /* GUID + next 3 */ avio_wl32(pb, enc->codec_tag); /* GUID + next 3 */
put_le32(pb, 0x00100000); avio_wl32(pb, 0x00100000);
put_le32(pb, 0xAA000080); avio_wl32(pb, 0xAA000080);
put_le32(pb, 0x719B3800); avio_wl32(pb, 0x719B3800);
} else if(riff_extradata - riff_extradata_start) { } else if(riff_extradata - riff_extradata_start) {
put_le16(pb, riff_extradata - riff_extradata_start); avio_wl16(pb, riff_extradata - riff_extradata_start);
} }
put_buffer(pb, riff_extradata_start, riff_extradata - riff_extradata_start); avio_write(pb, riff_extradata_start, riff_extradata - riff_extradata_start);
if(hdrsize&1){ if(hdrsize&1){
hdrsize++; hdrsize++;
put_byte(pb, 0); avio_w8(pb, 0);
} }
return hdrsize; return hdrsize;
@ -447,25 +447,25 @@ int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc)
/* BITMAPINFOHEADER header */ /* BITMAPINFOHEADER header */
void ff_put_bmp_header(AVIOContext *pb, AVCodecContext *enc, const AVCodecTag *tags, int for_asf) void ff_put_bmp_header(AVIOContext *pb, AVCodecContext *enc, const AVCodecTag *tags, int for_asf)
{ {
put_le32(pb, 40 + enc->extradata_size); /* size */ avio_wl32(pb, 40 + enc->extradata_size); /* size */
put_le32(pb, enc->width); avio_wl32(pb, enc->width);
//We always store RGB TopDown //We always store RGB TopDown
put_le32(pb, enc->codec_tag ? enc->height : -enc->height); avio_wl32(pb, enc->codec_tag ? enc->height : -enc->height);
put_le16(pb, 1); /* planes */ avio_wl16(pb, 1); /* planes */
put_le16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24); /* depth */ avio_wl16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24); /* depth */
/* compression type */ /* compression type */
put_le32(pb, enc->codec_tag); avio_wl32(pb, enc->codec_tag);
put_le32(pb, enc->width * enc->height * 3); avio_wl32(pb, enc->width * enc->height * 3);
put_le32(pb, 0); avio_wl32(pb, 0);
put_le32(pb, 0); avio_wl32(pb, 0);
put_le32(pb, 0); avio_wl32(pb, 0);
put_le32(pb, 0); avio_wl32(pb, 0);
put_buffer(pb, enc->extradata, enc->extradata_size); avio_write(pb, enc->extradata, enc->extradata_size);
if (!for_asf && enc->extradata_size & 1) if (!for_asf && enc->extradata_size & 1)
put_byte(pb, 0); avio_w8(pb, 0);
} }
#endif //CONFIG_MUXERS #endif //CONFIG_MUXERS

192
libavformat/rmenc.c
Unescape View File

@ -46,17 +46,17 @@ typedef struct {
static void put_str(AVIOContext *s, const char *tag) static void put_str(AVIOContext *s, const char *tag)
{ {
put_be16(s,strlen(tag)); avio_wb16(s,strlen(tag));
while (*tag) { while (*tag) {
put_byte(s, *tag++); avio_w8(s, *tag++);
} }
} }
static void put_str8(AVIOContext *s, const char *tag) static void put_str8(AVIOContext *s, const char *tag)
{ {
put_byte(s, strlen(tag)); avio_w8(s, strlen(tag));
while (*tag) { while (*tag) {
put_byte(s, *tag++); avio_w8(s, *tag++);
} }
} }
@ -75,14 +75,14 @@ static int rv10_write_header(AVFormatContext *ctx,
start_ptr = s->buf_ptr; start_ptr = s->buf_ptr;
put_tag(s, ".RMF"); put_tag(s, ".RMF");
put_be32(s,18); /* header size */ avio_wb32(s,18); /* header size */
put_be16(s,0); avio_wb16(s,0);
put_be32(s,0); avio_wb32(s,0);
put_be32(s,4 + ctx->nb_streams); /* num headers */ avio_wb32(s,4 + ctx->nb_streams); /* num headers */
put_tag(s,"PROP"); put_tag(s,"PROP");
put_be32(s, 50); avio_wb32(s, 50);
put_be16(s, 0); avio_wb16(s, 0);
packet_max_size = 0; packet_max_size = 0;
packet_total_size = 0; packet_total_size = 0;
nb_packets = 0; nb_packets = 0;
@ -100,26 +100,26 @@ static int rv10_write_header(AVFormatContext *ctx,
if (v > duration) if (v > duration)
duration = v; duration = v;
} }
put_be32(s, bit_rate); /* max bit rate */ avio_wb32(s, bit_rate); /* max bit rate */
put_be32(s, bit_rate); /* avg bit rate */ avio_wb32(s, bit_rate); /* avg bit rate */
put_be32(s, packet_max_size); /* max packet size */ avio_wb32(s, packet_max_size); /* max packet size */
if (nb_packets > 0) if (nb_packets > 0)
packet_avg_size = packet_total_size / nb_packets; packet_avg_size = packet_total_size / nb_packets;
else else
packet_avg_size = 0; packet_avg_size = 0;
put_be32(s, packet_avg_size); /* avg packet size */ avio_wb32(s, packet_avg_size); /* avg packet size */
put_be32(s, nb_packets); /* num packets */ avio_wb32(s, nb_packets); /* num packets */
put_be32(s, duration); /* duration */ avio_wb32(s, duration); /* duration */
put_be32(s, BUFFER_DURATION); /* preroll */ avio_wb32(s, BUFFER_DURATION); /* preroll */
put_be32(s, index_pos); /* index offset */ avio_wb32(s, index_pos); /* index offset */
/* computation of data the data offset */ /* computation of data the data offset */
data_offset_ptr = s->buf_ptr; data_offset_ptr = s->buf_ptr;
put_be32(s, 0); /* data offset : will be patched after */ avio_wb32(s, 0); /* data offset : will be patched after */
put_be16(s, ctx->nb_streams); /* num streams */ avio_wb16(s, ctx->nb_streams); /* num streams */
flags = 1 | 2; /* save allowed & perfect play */ flags = 1 | 2; /* save allowed & perfect play */
if (url_is_streamed(s)) if (url_is_streamed(s))
flags |= 4; /* live broadcast */ flags |= 4; /* live broadcast */
put_be16(s, flags); avio_wb16(s, flags);
/* comments */ /* comments */
@ -129,8 +129,8 @@ static int rv10_write_header(AVFormatContext *ctx,
tag = av_metadata_get(ctx->metadata, ff_rm_metadata[i], NULL, 0); tag = av_metadata_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
if(tag) size += strlen(tag->value); if(tag) size += strlen(tag->value);
} }
put_be32(s,size); avio_wb32(s,size);
put_be16(s,0); avio_wb16(s,0);
for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) { for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
tag = av_metadata_get(ctx->metadata, ff_rm_metadata[i], NULL, 0); tag = av_metadata_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
put_str(s, tag ? tag->value : ""); put_str(s, tag ? tag->value : "");
@ -153,29 +153,29 @@ static int rv10_write_header(AVFormatContext *ctx,
put_tag(s,"MDPR"); put_tag(s,"MDPR");
size = 10 + 9 * 4 + strlen(desc) + strlen(mimetype) + codec_data_size; size = 10 + 9 * 4 + strlen(desc) + strlen(mimetype) + codec_data_size;
put_be32(s, size); avio_wb32(s, size);
put_be16(s, 0); avio_wb16(s, 0);
put_be16(s, i); /* stream number */ avio_wb16(s, i); /* stream number */
put_be32(s, stream->bit_rate); /* max bit rate */ avio_wb32(s, stream->bit_rate); /* max bit rate */
put_be32(s, stream->bit_rate); /* avg bit rate */ avio_wb32(s, stream->bit_rate); /* avg bit rate */
put_be32(s, stream->packet_max_size); /* max packet size */ avio_wb32(s, stream->packet_max_size); /* max packet size */
if (stream->nb_packets > 0) if (stream->nb_packets > 0)
packet_avg_size = stream->packet_total_size / packet_avg_size = stream->packet_total_size /
stream->nb_packets; stream->nb_packets;
else else
packet_avg_size = 0; packet_avg_size = 0;
put_be32(s, packet_avg_size); /* avg packet size */ avio_wb32(s, packet_avg_size); /* avg packet size */
put_be32(s, 0); /* start time */ avio_wb32(s, 0); /* start time */
put_be32(s, BUFFER_DURATION); /* preroll */ avio_wb32(s, BUFFER_DURATION); /* preroll */
/* duration */ /* duration */
if (url_is_streamed(s) || !stream->total_frames) if (url_is_streamed(s) || !stream->total_frames)
put_be32(s, (int)(3600 * 1000)); avio_wb32(s, (int)(3600 * 1000));
else else
put_be32(s, (int)(stream->total_frames * 1000 / stream->frame_rate)); avio_wb32(s, (int)(stream->total_frames * 1000 / stream->frame_rate));
put_str8(s, desc); put_str8(s, desc);
put_str8(s, mimetype); put_str8(s, mimetype);
put_be32(s, codec_data_size); avio_wb32(s, codec_data_size);
if (stream->enc->codec_type == AVMEDIA_TYPE_AUDIO) { if (stream->enc->codec_type == AVMEDIA_TYPE_AUDIO) {
int coded_frame_size, fscode, sample_rate; int coded_frame_size, fscode, sample_rate;
@ -184,12 +184,12 @@ static int rv10_write_header(AVFormatContext *ctx,
stream->enc->frame_size) / (8 * sample_rate); stream->enc->frame_size) / (8 * sample_rate);
/* audio codec info */ /* audio codec info */
put_tag(s, ".ra"); put_tag(s, ".ra");
put_byte(s, 0xfd); avio_w8(s, 0xfd);
put_be32(s, 0x00040000); /* version */ avio_wb32(s, 0x00040000); /* version */
put_tag(s, ".ra4"); put_tag(s, ".ra4");
put_be32(s, 0x01b53530); /* stream length */ avio_wb32(s, 0x01b53530); /* stream length */
put_be16(s, 4); /* unknown */ avio_wb16(s, 4); /* unknown */
put_be32(s, 0x39); /* header size */ avio_wb32(s, 0x39); /* header size */
switch(sample_rate) { switch(sample_rate) {
case 48000: case 48000:
@ -208,56 +208,56 @@ static int rv10_write_header(AVFormatContext *ctx,
case 8000: case 8000:
fscode = 3; fscode = 3;
} }
put_be16(s, fscode); /* codec additional info, for AC-3, seems avio_wb16(s, fscode); /* codec additional info, for AC-3, seems
to be a frequency code */ to be a frequency code */
/* special hack to compensate rounding errors... */ /* special hack to compensate rounding errors... */
if (coded_frame_size == 557) if (coded_frame_size == 557)
coded_frame_size--; coded_frame_size--;
put_be32(s, coded_frame_size); /* frame length */ avio_wb32(s, coded_frame_size); /* frame length */
put_be32(s, 0x51540); /* unknown */ avio_wb32(s, 0x51540); /* unknown */
put_be32(s, 0x249f0); /* unknown */ avio_wb32(s, 0x249f0); /* unknown */
put_be32(s, 0x249f0); /* unknown */ avio_wb32(s, 0x249f0); /* unknown */
put_be16(s, 0x01); avio_wb16(s, 0x01);
/* frame length : seems to be very important */ /* frame length : seems to be very important */
put_be16(s, coded_frame_size); avio_wb16(s, coded_frame_size);
put_be32(s, 0); /* unknown */ avio_wb32(s, 0); /* unknown */
put_be16(s, stream->enc->sample_rate); /* sample rate */ avio_wb16(s, stream->enc->sample_rate); /* sample rate */
put_be32(s, 0x10); /* unknown */ avio_wb32(s, 0x10); /* unknown */
put_be16(s, stream->enc->channels); avio_wb16(s, stream->enc->channels);
put_str8(s, "Int0"); /* codec name */ put_str8(s, "Int0"); /* codec name */
if (stream->enc->codec_tag) { if (stream->enc->codec_tag) {
put_byte(s, 4); /* tag length */ avio_w8(s, 4); /* tag length */
put_le32(s, stream->enc->codec_tag); avio_wl32(s, stream->enc->codec_tag);
} else { } else {
av_log(ctx, AV_LOG_ERROR, "Invalid codec tag\n"); av_log(ctx, AV_LOG_ERROR, "Invalid codec tag\n");
return -1; return -1;
} }
put_be16(s, 0); /* title length */ avio_wb16(s, 0); /* title length */
put_be16(s, 0); /* author length */ avio_wb16(s, 0); /* author length */
put_be16(s, 0); /* copyright length */ avio_wb16(s, 0); /* copyright length */
put_byte(s, 0); /* end of header */ avio_w8(s, 0); /* end of header */
} else { } else {
/* video codec info */ /* video codec info */
put_be32(s,34); /* size */ avio_wb32(s,34); /* size */
if(stream->enc->codec_id == CODEC_ID_RV10) if(stream->enc->codec_id == CODEC_ID_RV10)
put_tag(s,"VIDORV10"); put_tag(s,"VIDORV10");
else else
put_tag(s,"VIDORV20"); put_tag(s,"VIDORV20");
put_be16(s, stream->enc->width); avio_wb16(s, stream->enc->width);
put_be16(s, stream->enc->height); avio_wb16(s, stream->enc->height);
put_be16(s, (int) stream->frame_rate); /* frames per seconds ? */ avio_wb16(s, (int) stream->frame_rate); /* frames per seconds ? */
put_be32(s,0); /* unknown meaning */ avio_wb32(s,0); /* unknown meaning */
put_be16(s, (int) stream->frame_rate); /* unknown meaning */ avio_wb16(s, (int) stream->frame_rate); /* unknown meaning */
put_be32(s,0); /* unknown meaning */ avio_wb32(s,0); /* unknown meaning */
put_be16(s, 8); /* unknown meaning */ avio_wb16(s, 8); /* unknown meaning */
/* Seems to be the codec version: only use basic H263. The next /* Seems to be the codec version: only use basic H263. The next
versions seems to add a diffential DC coding as in versions seems to add a diffential DC coding as in
MPEG... nothing new under the sun */ MPEG... nothing new under the sun */
if(stream->enc->codec_id == CODEC_ID_RV10) if(stream->enc->codec_id == CODEC_ID_RV10)
put_be32(s,0x10000000); avio_wb32(s,0x10000000);
else else
put_be32(s,0x20103001); avio_wb32(s,0x20103001);
//put_be32(s,0x10003000); //avio_wb32(s,0x10003000);
} }
} }
@ -271,11 +271,11 @@ static int rv10_write_header(AVFormatContext *ctx,
/* data stream */ /* data stream */
put_tag(s,"DATA"); put_tag(s,"DATA");
put_be32(s,data_size + 10 + 8); avio_wb32(s,data_size + 10 + 8);
put_be16(s,0); avio_wb16(s,0);
put_be32(s, nb_packets); /* number of packets */ avio_wb32(s, nb_packets); /* number of packets */
put_be32(s,0); /* next data header */ avio_wb32(s,0); /* next data header */
return 0; return 0;
} }
@ -290,13 +290,13 @@ static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream,
if (length > stream->packet_max_size) if (length > stream->packet_max_size)
stream->packet_max_size = length; stream->packet_max_size = length;
put_be16(s,0); /* version */ avio_wb16(s,0); /* version */
put_be16(s,length + 12); avio_wb16(s,length + 12);
put_be16(s, stream->num); /* stream number */ avio_wb16(s, stream->num); /* stream number */
timestamp = (1000 * (float)stream->nb_frames) / stream->frame_rate; timestamp = (1000 * (float)stream->nb_frames) / stream->frame_rate;
put_be32(s, timestamp); /* timestamp */ avio_wb32(s, timestamp); /* timestamp */
put_byte(s, 0); /* reserved */ avio_w8(s, 0); /* reserved */
put_byte(s, key_frame ? 2 : 0); /* flags */ avio_w8(s, key_frame ? 2 : 0); /* flags */
} }
static int rm_write_header(AVFormatContext *s) 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] = buf[i+1];
buf1[i+1] = buf[i]; buf1[i+1] = buf[i];
} }
put_buffer(pb, buf1, size); avio_write(pb, buf1, size);
} else { } else {
put_buffer(pb, buf, size); avio_write(pb, buf, size);
} }
put_flush_packet(pb); put_flush_packet(pb);
stream->nb_frames++; stream->nb_frames++;
@ -386,31 +386,31 @@ static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int
#if 1 #if 1
write_packet_header(s, stream, size + 7 + (size >= 0x4000)*4, key_frame); 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 */ /* bit 7: '1' if final packet of a frame converted in several packets */
put_byte(pb, 0x81); avio_w8(pb, 0x81);
/* bit 7: '1' if I frame. bits 6..0 : sequence number in current /* bit 7: '1' if I frame. bits 6..0 : sequence number in current
frame starting from 1 */ frame starting from 1 */
if (key_frame) { if (key_frame) {
put_byte(pb, 0x81); avio_w8(pb, 0x81);
} else { } else {
put_byte(pb, 0x01); avio_w8(pb, 0x01);
} }
if(size >= 0x4000){ if(size >= 0x4000){
put_be32(pb, size); /* total frame size */ avio_wb32(pb, size); /* total frame size */
put_be32(pb, size); /* offset from the start or the end */ avio_wb32(pb, size); /* offset from the start or the end */
}else{ }else{
put_be16(pb, 0x4000 | size); /* total frame size */ avio_wb16(pb, 0x4000 | size); /* total frame size */
put_be16(pb, 0x4000 | size); /* offset from the start or the end */ avio_wb16(pb, 0x4000 | size); /* offset from the start or the end */
} }
#else #else
/* full frame */ /* full frame */
write_packet_header(s, size + 6); write_packet_header(s, size + 6);
put_byte(pb, 0xc0); avio_w8(pb, 0xc0);
put_be16(pb, 0x4000 + size); /* total frame size */ avio_wb16(pb, 0x4000 + size); /* total frame size */
put_be16(pb, 0x4000 + packet_number * 126); /* position in stream */ avio_wb16(pb, 0x4000 + packet_number * 126); /* position in stream */
#endif #endif
put_byte(pb, stream->nb_frames & 0xff); avio_w8(pb, stream->nb_frames & 0xff);
put_buffer(pb, buf, size); avio_write(pb, buf, size);
put_flush_packet(pb); put_flush_packet(pb);
stream->nb_frames++; stream->nb_frames++;
@ -440,8 +440,8 @@ static int rm_write_trailer(AVFormatContext *s)
/* FIXME: write index */ /* FIXME: write index */
/* undocumented end header */ /* undocumented end header */
put_be32(pb, 0); avio_wb32(pb, 0);
put_be32(pb, 0); avio_wb32(pb, 0);
url_fseek(pb, 0, SEEK_SET); url_fseek(pb, 0, SEEK_SET);
for(i=0;i<s->nb_streams;i++) 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); rv10_write_header(s, data_size, 0);
} else { } else {
/* undocumented end header */ /* undocumented end header */
put_be32(pb, 0); avio_wb32(pb, 0);
put_be32(pb, 0); avio_wb32(pb, 0);
} }
put_flush_packet(pb); put_flush_packet(pb);
return 0; return 0;

12
libavformat/rsoenc.c
Unescape View File

@ -55,10 +55,10 @@ static int rso_write_header(AVFormatContext *s)
} }
/* format header */ /* format header */
put_be16(pb, enc->codec_tag); /* codec ID */ avio_wb16(pb, enc->codec_tag); /* codec ID */
put_be16(pb, 0); /* data size, will be written at EOF */ avio_wb16(pb, 0); /* data size, will be written at EOF */
put_be16(pb, enc->sample_rate); avio_wb16(pb, enc->sample_rate);
put_be16(pb, 0x0000); /* play mode ? (0x0000 = don't loop) */ avio_wb16(pb, 0x0000); /* play mode ? (0x0000 = don't loop) */
put_flush_packet(pb); put_flush_packet(pb);
@ -67,7 +67,7 @@ static int rso_write_header(AVFormatContext *s)
static int rso_write_packet(AVFormatContext *s, AVPacket *pkt) static int rso_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
put_buffer(s->pb, pkt->data, pkt->size); avio_write(s->pb, pkt->data, pkt->size);
return 0; return 0;
} }
@ -92,7 +92,7 @@ static int rso_write_trailer(AVFormatContext *s)
/* update file size */ /* update file size */
url_fseek(pb, 2, SEEK_SET); url_fseek(pb, 2, SEEK_SET);
put_be16(pb, coded_file_size); avio_wb16(pb, coded_file_size);
url_fseek(pb, file_size, SEEK_SET); url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb); put_flush_packet(pb);

58
libavformat/rtpdec.c
Unescape View File

@ -268,12 +268,12 @@ int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
return -1; return -1;
// Receiver Report // Receiver Report
put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */ avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
put_byte(pb, RTCP_RR); avio_w8(pb, RTCP_RR);
put_be16(pb, 7); /* length in words - 1 */ avio_wb16(pb, 7); /* length in words - 1 */
// our own SSRC: we use the server's SSRC + 1 to avoid conflicts // our own SSRC: we use the server's SSRC + 1 to avoid conflicts
put_be32(pb, s->ssrc + 1); avio_wb32(pb, s->ssrc + 1);
put_be32(pb, s->ssrc); // server SSRC avio_wb32(pb, s->ssrc); // server SSRC
// some placeholders we should really fill... // some placeholders we should really fill...
// RFC 1889/p64 // RFC 1889/p64
extended_max= stats->cycles + stats->max_seq; 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; fraction= (fraction<<24) | lost;
put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */ avio_wb32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
put_be32(pb, extended_max); /* max sequence received */ avio_wb32(pb, extended_max); /* max sequence received */
put_be32(pb, stats->jitter>>4); /* jitter */ avio_wb32(pb, stats->jitter>>4); /* jitter */
if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE) if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
{ {
put_be32(pb, 0); /* last SR timestamp */ avio_wb32(pb, 0); /* last SR timestamp */
put_be32(pb, 0); /* delay since last SR */ avio_wb32(pb, 0); /* delay since last SR */
} else { } 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 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; uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
put_be32(pb, middle_32_bits); /* last SR timestamp */ avio_wb32(pb, middle_32_bits); /* last SR timestamp */
put_be32(pb, delay_since_last); /* delay since last SR */ avio_wb32(pb, delay_since_last); /* delay since last SR */
} }
// CNAME // CNAME
put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */ avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
put_byte(pb, RTCP_SDES); avio_w8(pb, RTCP_SDES);
len = strlen(s->hostname); len = strlen(s->hostname);
put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */ avio_wb16(pb, (6 + len + 3) / 4); /* length in words - 1 */
put_be32(pb, s->ssrc); avio_wb32(pb, s->ssrc);
put_byte(pb, 0x01); avio_w8(pb, 0x01);
put_byte(pb, len); avio_w8(pb, len);
put_buffer(pb, s->hostname, len); avio_write(pb, s->hostname, len);
// padding // padding
for (len = (6 + len) % 4; len % 4; len++) { for (len = (6 + len) % 4; len % 4; len++) {
put_byte(pb, 0); avio_w8(pb, 0);
} }
put_flush_packet(pb); put_flush_packet(pb);
@ -342,11 +342,11 @@ void rtp_send_punch_packets(URLContext* rtp_handle)
if (url_open_dyn_buf(&pb) < 0) if (url_open_dyn_buf(&pb) < 0)
return; return;
put_byte(pb, (RTP_VERSION << 6)); avio_w8(pb, (RTP_VERSION << 6));
put_byte(pb, 0); /* Payload type */ avio_w8(pb, 0); /* Payload type */
put_be16(pb, 0); /* Seq */ avio_wb16(pb, 0); /* Seq */
put_be32(pb, 0); /* Timestamp */ avio_wb32(pb, 0); /* Timestamp */
put_be32(pb, 0); /* SSRC */ avio_wb32(pb, 0); /* SSRC */
put_flush_packet(pb); put_flush_packet(pb);
len = url_close_dyn_buf(pb, &buf); 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) if (url_open_dyn_buf(&pb) < 0)
return; return;
put_byte(pb, (RTP_VERSION << 6)); avio_w8(pb, (RTP_VERSION << 6));
put_byte(pb, RTCP_RR); /* receiver report */ avio_w8(pb, RTCP_RR); /* receiver report */
put_be16(pb, 1); /* length in words - 1 */ avio_wb16(pb, 1); /* length in words - 1 */
put_be32(pb, 0); /* our own SSRC */ avio_wb32(pb, 0); /* our own SSRC */
put_flush_packet(pb); put_flush_packet(pb);
len = url_close_dyn_buf(pb, &buf); len = url_close_dyn_buf(pb, &buf);

2
libavformat/rtpdec_asf.c
Unescape View File

@ -213,7 +213,7 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf,
if (!asf->pktbuf) if (!asf->pktbuf)
return AVERROR(EIO); return AVERROR(EIO);
put_buffer(asf->pktbuf, buf + off, len - off); avio_write(asf->pktbuf, buf + off, len - off);
url_fskip(pb, len - off); url_fskip(pb, len - off);
if (!(flags & RTP_FLAG_MARKER)) if (!(flags & RTP_FLAG_MARKER))
return -1; return -1;

2
libavformat/rtpdec_latm.c
Unescape View File

@ -68,7 +68,7 @@ static int latm_parse_packet(AVFormatContext *ctx, PayloadContext *data,
if ((ret = url_open_dyn_buf(&data->dyn_buf)) < 0) if ((ret = url_open_dyn_buf(&data->dyn_buf)) < 0)
return ret; return ret;
} }
put_buffer(data->dyn_buf, buf, len); avio_write(data->dyn_buf, buf, len);
if (!(flags & RTP_FLAG_MARKER)) if (!(flags & RTP_FLAG_MARKER))
return AVERROR(EAGAIN); return AVERROR(EAGAIN);

2
libavformat/rtpdec_svq3.c
Unescape View File

@ -94,7 +94,7 @@ static int svq3_parse_packet (AVFormatContext *s, PayloadContext *sv,
if (!sv->pktbuf) if (!sv->pktbuf)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
put_buffer(sv->pktbuf, buf, len); avio_write(sv->pktbuf, buf, len);
if (end_packet) { if (end_packet) {
av_init_packet(pkt); av_init_packet(pkt);

2
libavformat/rtpdec_vp8.c
Unescape View File

@ -111,7 +111,7 @@ static int vp8_handle_packet(AVFormatContext *ctx,
} }
} }
put_buffer(vp8->data, buf, au_len); avio_write(vp8->data, buf, au_len);
buf += au_len; buf += au_len;
len -= au_len; len -= au_len;
} }

4
libavformat/rtpdec_xiph.c
Unescape View File

@ -179,7 +179,7 @@ static int xiph_handle_packet(AVFormatContext * ctx,
if((res = url_open_dyn_buf(&data->fragment)) < 0) if((res = url_open_dyn_buf(&data->fragment)) < 0)
return res; return res;
put_buffer(data->fragment, buf, pkt_len); avio_write(data->fragment, buf, pkt_len);
data->timestamp = *timestamp; data->timestamp = *timestamp;
} else { } else {
@ -198,7 +198,7 @@ static int xiph_handle_packet(AVFormatContext * ctx,
} }
// copy data to fragment buffer // copy data to fragment buffer
put_buffer(data->fragment, buf, pkt_len); avio_write(data->fragment, buf, pkt_len);
if (fragmented == 3) { if (fragmented == 3) {
// end of xiph data packet // end of xiph data packet

30
libavformat/rtpenc.c
Unescape View File

@ -197,15 +197,15 @@ static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
s->last_rtcp_ntp_time = ntp_time; s->last_rtcp_ntp_time = ntp_time;
rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000}, rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
s1->streams[0]->time_base) + s->base_timestamp; s1->streams[0]->time_base) + s->base_timestamp;
put_byte(s1->pb, (RTP_VERSION << 6)); avio_w8(s1->pb, (RTP_VERSION << 6));
put_byte(s1->pb, RTCP_SR); avio_w8(s1->pb, RTCP_SR);
put_be16(s1->pb, 6); /* length in words - 1 */ avio_wb16(s1->pb, 6); /* length in words - 1 */
put_be32(s1->pb, s->ssrc); avio_wb32(s1->pb, s->ssrc);
put_be32(s1->pb, ntp_time / 1000000); avio_wb32(s1->pb, ntp_time / 1000000);
put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000); avio_wb32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
put_be32(s1->pb, rtp_ts); avio_wb32(s1->pb, rtp_ts);
put_be32(s1->pb, s->packet_count); avio_wb32(s1->pb, s->packet_count);
put_be32(s1->pb, s->octet_count); avio_wb32(s1->pb, s->octet_count);
put_flush_packet(s1->pb); 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); av_dlog(s1, "rtp_send_data size=%d\n", len);
/* build the RTP header */ /* build the RTP header */
put_byte(s1->pb, (RTP_VERSION << 6)); avio_w8(s1->pb, (RTP_VERSION << 6));
put_byte(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7)); avio_w8(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
put_be16(s1->pb, s->seq); avio_wb16(s1->pb, s->seq);
put_be32(s1->pb, s->timestamp); avio_wb32(s1->pb, s->timestamp);
put_be32(s1->pb, s->ssrc); avio_wb32(s1->pb, s->ssrc);
put_buffer(s1->pb, buf1, len); avio_write(s1->pb, buf1, len);
put_flush_packet(s1->pb); put_flush_packet(s1->pb);
s->seq++; s->seq++;

30
libavformat/soxenc.c
Unescape View File

@ -54,28 +54,28 @@ static int sox_write_header(AVFormatContext *s)
if (enc->codec_id == CODEC_ID_PCM_S32LE) { if (enc->codec_id == CODEC_ID_PCM_S32LE) {
put_tag(pb, ".SoX"); put_tag(pb, ".SoX");
put_le32(pb, sox->header_size); avio_wl32(pb, sox->header_size);
put_le64(pb, 0); /* number of samples */ avio_wl64(pb, 0); /* number of samples */
put_le64(pb, av_dbl2int(enc->sample_rate)); avio_wl64(pb, av_dbl2int(enc->sample_rate));
put_le32(pb, enc->channels); avio_wl32(pb, enc->channels);
put_le32(pb, comment_size); avio_wl32(pb, comment_size);
} else if (enc->codec_id == CODEC_ID_PCM_S32BE) { } else if (enc->codec_id == CODEC_ID_PCM_S32BE) {
put_tag(pb, "XoS."); put_tag(pb, "XoS.");
put_be32(pb, sox->header_size); avio_wb32(pb, sox->header_size);
put_be64(pb, 0); /* number of samples */ avio_wb64(pb, 0); /* number of samples */
put_be64(pb, av_dbl2int(enc->sample_rate)); avio_wb64(pb, av_dbl2int(enc->sample_rate));
put_be32(pb, enc->channels); avio_wb32(pb, enc->channels);
put_be32(pb, comment_size); avio_wb32(pb, comment_size);
} else { } else {
av_log(s, AV_LOG_ERROR, "invalid codec; use pcm_s32le or pcm_s32be\n"); av_log(s, AV_LOG_ERROR, "invalid codec; use pcm_s32le or pcm_s32be\n");
return -1; return -1;
} }
if (comment_len) if (comment_len)
put_buffer(pb, comment->value, comment_len); avio_write(pb, comment->value, comment_len);
for ( ; comment_size > comment_len; comment_len++) for ( ; comment_size > comment_len; comment_len++)
put_byte(pb, 0); avio_w8(pb, 0);
put_flush_packet(pb); put_flush_packet(pb);
@ -85,7 +85,7 @@ static int sox_write_header(AVFormatContext *s)
static int sox_write_packet(AVFormatContext *s, AVPacket *pkt) static int sox_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
return 0; return 0;
} }
@ -101,9 +101,9 @@ static int sox_write_trailer(AVFormatContext *s)
int64_t num_samples = (file_size - sox->header_size - 4LL) >> 2LL; int64_t num_samples = (file_size - sox->header_size - 4LL) >> 2LL;
url_fseek(pb, 8, SEEK_SET); url_fseek(pb, 8, SEEK_SET);
if (enc->codec_id == CODEC_ID_PCM_S32LE) { if (enc->codec_id == CODEC_ID_PCM_S32LE) {
put_le64(pb, num_samples); avio_wl64(pb, num_samples);
} else } else
put_be64(pb, num_samples); avio_wb64(pb, num_samples);
url_fseek(pb, file_size, SEEK_SET); url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb); put_flush_packet(pb);

8
libavformat/spdifenc.c
Unescape View File

@ -476,9 +476,9 @@ static av_always_inline void spdif_put_16(IEC61937Context *ctx,
AVIOContext *pb, unsigned int val) AVIOContext *pb, unsigned int val)
{ {
if (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN) if (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)
put_be16(pb, val); avio_wb16(pb, val);
else else
put_le16(pb, val); avio_wl16(pb, val);
} }
static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt) static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
@ -512,13 +512,13 @@ static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
} }
if (ctx->extra_bswap ^ (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)) { if (ctx->extra_bswap ^ (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)) {
put_buffer(s->pb, ctx->out_buf, ctx->out_bytes & ~1); avio_write(s->pb, ctx->out_buf, ctx->out_bytes & ~1);
} else { } else {
av_fast_malloc(&ctx->buffer, &ctx->buffer_size, ctx->out_bytes + FF_INPUT_BUFFER_PADDING_SIZE); av_fast_malloc(&ctx->buffer, &ctx->buffer_size, ctx->out_bytes + FF_INPUT_BUFFER_PADDING_SIZE);
if (!ctx->buffer) if (!ctx->buffer)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ff_spdif_bswap_buf16((uint16_t *)ctx->buffer, (uint16_t *)ctx->out_buf, ctx->out_bytes >> 1); 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_write(s->pb, ctx->buffer, ctx->out_bytes & ~1);
} }
/* a final lone byte has to be MSB aligned */ /* a final lone byte has to be MSB aligned */

108
libavformat/swfenc.c
Unescape View File

@ -33,10 +33,10 @@ static void put_swf_tag(AVFormatContext *s, int tag)
swf->tag = tag; swf->tag = tag;
/* reserve some room for the tag */ /* reserve some room for the tag */
if (tag & TAG_LONG) { if (tag & TAG_LONG) {
put_le16(pb, 0); avio_wl16(pb, 0);
put_le32(pb, 0); avio_wl32(pb, 0);
} else { } else {
put_le16(pb, 0); avio_wl16(pb, 0);
} }
} }
@ -53,11 +53,11 @@ static void put_swf_end_tag(AVFormatContext *s)
url_fseek(pb, swf->tag_pos, SEEK_SET); url_fseek(pb, swf->tag_pos, SEEK_SET);
if (tag & TAG_LONG) { if (tag & TAG_LONG) {
tag &= ~TAG_LONG; tag &= ~TAG_LONG;
put_le16(pb, (tag << 6) | 0x3f); avio_wl16(pb, (tag << 6) | 0x3f);
put_le32(pb, tag_len - 4); avio_wl32(pb, tag_len - 4);
} else { } else {
assert(tag_len < 0x3f); assert(tag_len < 0x3f);
put_le16(pb, (tag << 6) | tag_len); avio_wl16(pb, (tag << 6) | tag_len);
} }
url_fseek(pb, pos, SEEK_SET); url_fseek(pb, pos, SEEK_SET);
} }
@ -102,7 +102,7 @@ static void put_swf_rect(AVIOContext *pb,
put_bits(&p, nbits, ymax & mask); put_bits(&p, nbits, ymax & mask);
flush_put_bits(&p); flush_put_bits(&p);
put_buffer(pb, buf, put_bits_ptr(&p) - p.buf); avio_write(pb, buf, put_bits_ptr(&p) - p.buf);
} }
static void put_swf_line_edge(PutBitContext *pb, int dx, int dy) static void put_swf_line_edge(PutBitContext *pb, int dx, int dy)
@ -167,7 +167,7 @@ static void put_swf_matrix(AVIOContext *pb,
put_bits(&p, nbits, ty); put_bits(&p, nbits, ty);
flush_put_bits(&p); flush_put_bits(&p);
put_buffer(pb, buf, put_bits_ptr(&p) - p.buf); avio_write(pb, buf, put_bits_ptr(&p) - p.buf);
} }
static int swf_write_header(AVFormatContext *s) static int swf_write_header(AVFormatContext *s)
@ -239,20 +239,20 @@ static int swf_write_header(AVFormatContext *s)
version = 6; /* version 6 and above support FLV1 codec */ version = 6; /* version 6 and above support FLV1 codec */
else else
version = 4; /* version 4 for mpeg audio support */ version = 4; /* version 4 for mpeg audio support */
put_byte(pb, version); avio_w8(pb, version);
put_le32(pb, DUMMY_FILE_SIZE); /* dummy size avio_wl32(pb, DUMMY_FILE_SIZE); /* dummy size
(will be patched if not streamed) */ (will be patched if not streamed) */
put_swf_rect(pb, 0, width * 20, 0, height * 20); put_swf_rect(pb, 0, width * 20, 0, height * 20);
put_le16(pb, (rate * 256) / rate_base); /* frame rate */ avio_wl16(pb, (rate * 256) / rate_base); /* frame rate */
swf->duration_pos = url_ftell(pb); swf->duration_pos = url_ftell(pb);
put_le16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */ avio_wl16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */
/* avm2/swf v9 (also v8?) files require a file attribute tag */ /* avm2/swf v9 (also v8?) files require a file attribute tag */
if (version == 9) { if (version == 9) {
put_swf_tag(s, TAG_FILEATTRIBUTES); put_swf_tag(s, TAG_FILEATTRIBUTES);
put_le32(pb, 1<<3); /* set ActionScript v3/AVM2 flag */ avio_wl32(pb, 1<<3); /* set ActionScript v3/AVM2 flag */
put_swf_end_tag(s); 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) { if (swf->video_enc && swf->video_enc->codec_id == CODEC_ID_MJPEG) {
put_swf_tag(s, TAG_DEFINESHAPE); put_swf_tag(s, TAG_DEFINESHAPE);
put_le16(pb, SHAPE_ID); /* ID of shape */ avio_wl16(pb, SHAPE_ID); /* ID of shape */
/* bounding rectangle */ /* bounding rectangle */
put_swf_rect(pb, 0, width, 0, height); put_swf_rect(pb, 0, width, 0, height);
/* style info */ /* style info */
put_byte(pb, 1); /* one fill style */ avio_w8(pb, 1); /* one fill style */
put_byte(pb, 0x41); /* clipped bitmap fill */ avio_w8(pb, 0x41); /* clipped bitmap fill */
put_le16(pb, BITMAP_ID); /* bitmap ID */ avio_wl16(pb, BITMAP_ID); /* bitmap ID */
/* position of the bitmap */ /* position of the bitmap */
put_swf_matrix(pb, (int)(1.0 * (1 << FRAC_BITS)), 0, put_swf_matrix(pb, (int)(1.0 * (1 << FRAC_BITS)), 0,
0, (int)(1.0 * (1 << FRAC_BITS)), 0, 0); 0, (int)(1.0 * (1 << FRAC_BITS)), 0, 0);
put_byte(pb, 0); /* no line style */ avio_w8(pb, 0); /* no line style */
/* shape drawing */ /* shape drawing */
init_put_bits(&p, buf1, sizeof(buf1)); init_put_bits(&p, buf1, sizeof(buf1));
@ -295,7 +295,7 @@ static int swf_write_header(AVFormatContext *s)
put_bits(&p, 5, 0); put_bits(&p, 5, 0);
flush_put_bits(&p); flush_put_bits(&p);
put_buffer(pb, buf1, put_bits_ptr(&p) - p.buf); avio_write(pb, buf1, put_bits_ptr(&p) - p.buf);
put_swf_end_tag(s); put_swf_end_tag(s);
} }
@ -317,11 +317,11 @@ static int swf_write_header(AVFormatContext *s)
v |= 0x02; /* 16 bit playback */ v |= 0x02; /* 16 bit playback */
if (swf->audio_enc->channels == 2) if (swf->audio_enc->channels == 2)
v |= 0x01; /* stereo playback */ v |= 0x01; /* stereo playback */
put_byte(s->pb, v); avio_w8(s->pb, v);
v |= 0x20; /* mp3 compressed */ v |= 0x20; /* mp3 compressed */
put_byte(s->pb, v); avio_w8(s->pb, v);
put_le16(s->pb, swf->samples_per_frame); /* avg samples per frame */ avio_wl16(s->pb, swf->samples_per_frame); /* avg samples per frame */
put_le16(s->pb, 0); avio_wl16(s->pb, 0);
put_swf_end_tag(s); put_swf_end_tag(s);
} }
@ -345,70 +345,70 @@ static int swf_write_video(AVFormatContext *s,
if (swf->video_frame_number == 0) { if (swf->video_frame_number == 0) {
/* create a new video object */ /* create a new video object */
put_swf_tag(s, TAG_VIDEOSTREAM); put_swf_tag(s, TAG_VIDEOSTREAM);
put_le16(pb, VIDEO_ID); avio_wl16(pb, VIDEO_ID);
swf->vframes_pos = url_ftell(pb); swf->vframes_pos = url_ftell(pb);
put_le16(pb, 15000); /* hard flash player limit */ avio_wl16(pb, 15000); /* hard flash player limit */
put_le16(pb, enc->width); avio_wl16(pb, enc->width);
put_le16(pb, enc->height); avio_wl16(pb, enc->height);
put_byte(pb, 0); avio_w8(pb, 0);
put_byte(pb,ff_codec_get_tag(swf_codec_tags,enc->codec_id)); avio_w8(pb,ff_codec_get_tag(swf_codec_tags,enc->codec_id));
put_swf_end_tag(s); put_swf_end_tag(s);
/* place the video object for the first time */ /* place the video object for the first time */
put_swf_tag(s, TAG_PLACEOBJECT2); put_swf_tag(s, TAG_PLACEOBJECT2);
put_byte(pb, 0x36); avio_w8(pb, 0x36);
put_le16(pb, 1); avio_wl16(pb, 1);
put_le16(pb, VIDEO_ID); avio_wl16(pb, VIDEO_ID);
put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0); put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0);
put_le16(pb, swf->video_frame_number); avio_wl16(pb, swf->video_frame_number);
put_tag(pb, "video"); put_tag(pb, "video");
put_byte(pb, 0x00); avio_w8(pb, 0x00);
put_swf_end_tag(s); put_swf_end_tag(s);
} else { } else {
/* mark the character for update */ /* mark the character for update */
put_swf_tag(s, TAG_PLACEOBJECT2); put_swf_tag(s, TAG_PLACEOBJECT2);
put_byte(pb, 0x11); avio_w8(pb, 0x11);
put_le16(pb, 1); avio_wl16(pb, 1);
put_le16(pb, swf->video_frame_number); avio_wl16(pb, swf->video_frame_number);
put_swf_end_tag(s); put_swf_end_tag(s);
} }
/* set video frame data */ /* set video frame data */
put_swf_tag(s, TAG_VIDEOFRAME | TAG_LONG); put_swf_tag(s, TAG_VIDEOFRAME | TAG_LONG);
put_le16(pb, VIDEO_ID); avio_wl16(pb, VIDEO_ID);
put_le16(pb, swf->video_frame_number++); avio_wl16(pb, swf->video_frame_number++);
put_buffer(pb, buf, size); avio_write(pb, buf, size);
put_swf_end_tag(s); put_swf_end_tag(s);
} else if (enc->codec_id == CODEC_ID_MJPEG) { } else if (enc->codec_id == CODEC_ID_MJPEG) {
if (swf->swf_frame_number > 0) { if (swf->swf_frame_number > 0) {
/* remove the shape */ /* remove the shape */
put_swf_tag(s, TAG_REMOVEOBJECT); put_swf_tag(s, TAG_REMOVEOBJECT);
put_le16(pb, SHAPE_ID); /* shape ID */ avio_wl16(pb, SHAPE_ID); /* shape ID */
put_le16(pb, 1); /* depth */ avio_wl16(pb, 1); /* depth */
put_swf_end_tag(s); put_swf_end_tag(s);
/* free the bitmap */ /* free the bitmap */
put_swf_tag(s, TAG_FREECHARACTER); put_swf_tag(s, TAG_FREECHARACTER);
put_le16(pb, BITMAP_ID); avio_wl16(pb, BITMAP_ID);
put_swf_end_tag(s); put_swf_end_tag(s);
} }
put_swf_tag(s, TAG_JPEG2 | TAG_LONG); put_swf_tag(s, TAG_JPEG2 | TAG_LONG);
put_le16(pb, BITMAP_ID); /* ID of the image */ avio_wl16(pb, BITMAP_ID); /* ID of the image */
/* a dummy jpeg header seems to be required */ /* a dummy jpeg header seems to be required */
put_be32(pb, 0xffd8ffd9); avio_wb32(pb, 0xffd8ffd9);
/* write the jpeg image */ /* write the jpeg image */
put_buffer(pb, buf, size); avio_write(pb, buf, size);
put_swf_end_tag(s); put_swf_end_tag(s);
/* draw the shape */ /* draw the shape */
put_swf_tag(s, TAG_PLACEOBJECT); put_swf_tag(s, TAG_PLACEOBJECT);
put_le16(pb, SHAPE_ID); /* shape ID */ avio_wl16(pb, SHAPE_ID); /* shape ID */
put_le16(pb, 1); /* depth */ avio_wl16(pb, 1); /* depth */
put_swf_matrix(pb, 20 << FRAC_BITS, 0, 0, 20 << FRAC_BITS, 0, 0); put_swf_matrix(pb, 20 << FRAC_BITS, 0, 0, 20 << FRAC_BITS, 0, 0);
put_swf_end_tag(s); 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)) { if (swf->audio_enc && av_fifo_size(swf->audio_fifo)) {
int frame_size = av_fifo_size(swf->audio_fifo); int frame_size = av_fifo_size(swf->audio_fifo);
put_swf_tag(s, TAG_STREAMBLOCK | TAG_LONG); put_swf_tag(s, TAG_STREAMBLOCK | TAG_LONG);
put_le16(pb, swf->sound_samples); avio_wl16(pb, swf->sound_samples);
put_le16(pb, 0); // seek samples avio_wl16(pb, 0); // seek samples
av_fifo_generic_read(swf->audio_fifo, pb, frame_size, &put_buffer); av_fifo_generic_read(swf->audio_fifo, pb, frame_size, &avio_write);
put_swf_end_tag(s); put_swf_end_tag(s);
/* update FIFO */ /* update FIFO */
@ -495,11 +495,11 @@ static int swf_write_trailer(AVFormatContext *s)
if (!url_is_streamed(s->pb) && video_enc) { if (!url_is_streamed(s->pb) && video_enc) {
file_size = url_ftell(pb); file_size = url_ftell(pb);
url_fseek(pb, 4, SEEK_SET); url_fseek(pb, 4, SEEK_SET);
put_le32(pb, file_size); avio_wl32(pb, file_size);
url_fseek(pb, swf->duration_pos, SEEK_SET); url_fseek(pb, swf->duration_pos, SEEK_SET);
put_le16(pb, swf->video_frame_number); avio_wl16(pb, swf->video_frame_number);
url_fseek(pb, swf->vframes_pos, SEEK_SET); url_fseek(pb, swf->vframes_pos, SEEK_SET);
put_le16(pb, swf->video_frame_number); avio_wl16(pb, swf->video_frame_number);
url_fseek(pb, file_size, SEEK_SET); url_fseek(pb, file_size, SEEK_SET);
} }
return 0; return 0;

32
libavformat/vc1testenc.c
Unescape View File

@ -33,20 +33,20 @@ static int vc1test_write_header(AVFormatContext *s)
av_log(s, AV_LOG_ERROR, "Only WMV3 is accepted!\n"); av_log(s, AV_LOG_ERROR, "Only WMV3 is accepted!\n");
return -1; return -1;
} }
put_le24(pb, 0); //frames count will be here avio_wl24(pb, 0); //frames count will be here
put_byte(pb, 0xC5); avio_w8(pb, 0xC5);
put_le32(pb, 4); avio_wl32(pb, 4);
put_buffer(pb, avc->extradata, 4); avio_write(pb, avc->extradata, 4);
put_le32(pb, avc->height); avio_wl32(pb, avc->height);
put_le32(pb, avc->width); avio_wl32(pb, avc->width);
put_le32(pb, 0xC); avio_wl32(pb, 0xC);
put_le24(pb, 0); // hrd_buffer avio_wl24(pb, 0); // hrd_buffer
put_byte(pb, 0x80); // level|cbr|res1 avio_w8(pb, 0x80); // level|cbr|res1
put_le32(pb, 0); // hrd_rate avio_wl32(pb, 0); // hrd_rate
if (s->streams[0]->r_frame_rate.den && s->streams[0]->r_frame_rate.num == 1) 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_wl32(pb, s->streams[0]->r_frame_rate.den);
else else
put_le32(pb, 0xFFFFFFFF); //variable framerate avio_wl32(pb, 0xFFFFFFFF); //variable framerate
av_set_pts_info(s->streams[0], 32, 1, 1000); av_set_pts_info(s->streams[0], 32, 1, 1000);
return 0; return 0;
@ -59,9 +59,9 @@ static int vc1test_write_packet(AVFormatContext *s, AVPacket *pkt)
if (!pkt->size) if (!pkt->size)
return 0; return 0;
put_le32(pb, pkt->size | ((pkt->flags & AV_PKT_FLAG_KEY) ? 0x80000000 : 0)); avio_wl32(pb, pkt->size | ((pkt->flags & AV_PKT_FLAG_KEY) ? 0x80000000 : 0));
put_le32(pb, pkt->pts); avio_wl32(pb, pkt->pts);
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
put_flush_packet(pb); put_flush_packet(pb);
ctx->frames++; ctx->frames++;
@ -75,7 +75,7 @@ static int vc1test_write_trailer(AVFormatContext *s)
if (!url_is_streamed(s->pb)) { if (!url_is_streamed(s->pb)) {
url_fseek(pb, 0, SEEK_SET); url_fseek(pb, 0, SEEK_SET);
put_le24(pb, ctx->frames); avio_wl24(pb, ctx->frames);
put_flush_packet(pb); put_flush_packet(pb);
} }
return 0; return 0;

48
libavformat/vocenc.c
Unescape View File

@ -37,10 +37,10 @@ static int voc_write_header(AVFormatContext *s)
|| s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO) || s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
put_buffer(pb, ff_voc_magic, sizeof(ff_voc_magic) - 1); avio_write(pb, ff_voc_magic, sizeof(ff_voc_magic) - 1);
put_le16(pb, header_size); avio_wl16(pb, header_size);
put_le16(pb, version); avio_wl16(pb, version);
put_le16(pb, ~version + 0x1234); avio_wl16(pb, ~version + 0x1234);
return 0; return 0;
} }
@ -53,39 +53,39 @@ static int voc_write_packet(AVFormatContext *s, AVPacket *pkt)
if (!voc->param_written) { if (!voc->param_written) {
if (enc->codec_tag > 0xFF) { if (enc->codec_tag > 0xFF) {
put_byte(pb, VOC_TYPE_NEW_VOICE_DATA); avio_w8(pb, VOC_TYPE_NEW_VOICE_DATA);
put_le24(pb, pkt->size + 12); avio_wl24(pb, pkt->size + 12);
put_le32(pb, enc->sample_rate); avio_wl32(pb, enc->sample_rate);
put_byte(pb, enc->bits_per_coded_sample); avio_w8(pb, enc->bits_per_coded_sample);
put_byte(pb, enc->channels); avio_w8(pb, enc->channels);
put_le16(pb, enc->codec_tag); avio_wl16(pb, enc->codec_tag);
put_le32(pb, 0); avio_wl32(pb, 0);
} else { } else {
if (s->streams[0]->codec->channels > 1) { if (s->streams[0]->codec->channels > 1) {
put_byte(pb, VOC_TYPE_EXTENDED); avio_w8(pb, VOC_TYPE_EXTENDED);
put_le24(pb, 4); avio_wl24(pb, 4);
put_le16(pb, 65536-256000000/(enc->sample_rate*enc->channels)); avio_wl16(pb, 65536-256000000/(enc->sample_rate*enc->channels));
put_byte(pb, enc->codec_tag); avio_w8(pb, enc->codec_tag);
put_byte(pb, enc->channels - 1); avio_w8(pb, enc->channels - 1);
} }
put_byte(pb, VOC_TYPE_VOICE_DATA); avio_w8(pb, VOC_TYPE_VOICE_DATA);
put_le24(pb, pkt->size + 2); avio_wl24(pb, pkt->size + 2);
put_byte(pb, 256 - 1000000 / enc->sample_rate); avio_w8(pb, 256 - 1000000 / enc->sample_rate);
put_byte(pb, enc->codec_tag); avio_w8(pb, enc->codec_tag);
} }
voc->param_written = 1; voc->param_written = 1;
} else { } else {
put_byte(pb, VOC_TYPE_VOICE_DATA_CONT); avio_w8(pb, VOC_TYPE_VOICE_DATA_CONT);
put_le24(pb, pkt->size); avio_wl24(pb, pkt->size);
} }
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
return 0; return 0;
} }
static int voc_write_trailer(AVFormatContext *s) static int voc_write_trailer(AVFormatContext *s)
{ {
put_byte(s->pb, 0); avio_w8(s->pb, 0);
return 0; return 0;
} }

10
libavformat/wav.c
Unescape View File

@ -43,7 +43,7 @@ static int wav_write_header(AVFormatContext *s)
int64_t fmt, fact; int64_t fmt, fact;
put_tag(pb, "RIFF"); put_tag(pb, "RIFF");
put_le32(pb, 0); /* file length */ avio_wl32(pb, 0); /* file length */
put_tag(pb, "WAVE"); put_tag(pb, "WAVE");
/* format header */ /* format header */
@ -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 */ if (s->streams[0]->codec->codec_tag != 0x01 /* hence for all other than PCM */
&& !url_is_streamed(s->pb)) { && !url_is_streamed(s->pb)) {
fact = ff_start_tag(pb, "fact"); fact = ff_start_tag(pb, "fact");
put_le32(pb, 0); avio_wl32(pb, 0);
ff_end_tag(pb, fact); ff_end_tag(pb, fact);
} }
@ -79,7 +79,7 @@ static int wav_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
WAVContext *wav = s->priv_data; WAVContext *wav = s->priv_data;
put_buffer(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
if(pkt->pts != AV_NOPTS_VALUE) { if(pkt->pts != AV_NOPTS_VALUE) {
wav->minpts = FFMIN(wav->minpts, pkt->pts); wav->minpts = FFMIN(wav->minpts, pkt->pts);
wav->maxpts = FFMAX(wav->maxpts, pkt->pts); wav->maxpts = FFMAX(wav->maxpts, pkt->pts);
@ -103,7 +103,7 @@ static int wav_write_trailer(AVFormatContext *s)
/* update file size */ /* update file size */
file_size = url_ftell(pb); file_size = url_ftell(pb);
url_fseek(pb, 4, SEEK_SET); url_fseek(pb, 4, SEEK_SET);
put_le32(pb, (uint32_t)(file_size - 8)); avio_wl32(pb, (uint32_t)(file_size - 8));
url_fseek(pb, file_size, SEEK_SET); url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb); 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]->codec->sample_rate * (int64_t)s->streams[0]->time_base.num,
s->streams[0]->time_base.den); s->streams[0]->time_base.den);
url_fseek(pb, wav->data-12, SEEK_SET); url_fseek(pb, wav->data-12, SEEK_SET);
put_le32(pb, number_of_samples); avio_wl32(pb, number_of_samples);
url_fseek(pb, file_size, SEEK_SET); url_fseek(pb, file_size, SEEK_SET);
put_flush_packet(pb); put_flush_packet(pb);
} }

10
libavformat/yuv4mpeg.c
Unescape View File

@ -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"); av_log(s, AV_LOG_ERROR, "Error. YUV4MPEG stream header write failed.\n");
return AVERROR(EIO); return AVERROR(EIO);
} else { } else {
put_buffer(pb, buf2, strlen(buf2)); avio_write(pb, buf2, strlen(buf2));
} }
} }
/* construct frame header */ /* construct frame header */
m = snprintf(buf1, sizeof(buf1), "%s\n", Y4M_FRAME_MAGIC); m = snprintf(buf1, sizeof(buf1), "%s\n", Y4M_FRAME_MAGIC);
put_buffer(pb, buf1, strlen(buf1)); avio_write(pb, buf1, strlen(buf1));
width = st->codec->width; width = st->codec->width;
height = st->codec->height; height = st->codec->height;
ptr = picture->data[0]; ptr = picture->data[0];
for(i=0;i<height;i++) { for(i=0;i<height;i++) {
put_buffer(pb, ptr, width); avio_write(pb, ptr, width);
ptr += picture->linesize[0]; ptr += picture->linesize[0];
} }
@ -135,11 +135,11 @@ static int yuv4_write_packet(AVFormatContext *s, AVPacket *pkt)
ptr1 = picture->data[1]; ptr1 = picture->data[1];
ptr2 = picture->data[2]; ptr2 = picture->data[2];
for(i=0;i<height;i++) { /* Cb */ for(i=0;i<height;i++) { /* Cb */
put_buffer(pb, ptr1, width); avio_write(pb, ptr1, width);
ptr1 += picture->linesize[1]; ptr1 += picture->linesize[1];
} }
for(i=0;i<height;i++) { /* Cr */ for(i=0;i<height;i++) { /* Cr */
put_buffer(pb, ptr2, width); avio_write(pb, ptr2, width);
ptr2 += picture->linesize[2]; ptr2 += picture->linesize[2];
} }
} }

Write Preview
Loading…
Cancel
Save