virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

avio: avio_ prefixes for get_* functions

Browse Source 
In the name of consistency:
get_byte           -> avio_r8
get_<type>         -> avio_r<type>
get_buffer         -> avio_read

get_partial_buffer will be made private later

get_strz is left out becase I want to change it later to return
something useful.

Signed-off-by: Ronald S. Bultje <rsbultje@gmail.com>
This commit is contained in:
Anton Khirnov 2011-02-21 16:43:01 +01:00 committed by Ronald S. Bultje
parent f8bed30d8b
commit b7effd4e83
107 changed files with 1821 additions and 1776 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
libavformat/4xm.c
View File

@ -54,11 +54,11 @@
#define strk_SIZE 0x28 #define strk_SIZE 0x28
#define GET_LIST_HEADER() \ #define GET_LIST_HEADER() \
fourcc_tag = get_le32(pb); \ fourcc_tag = avio_rl32(pb); \
size = get_le32(pb); \ size = avio_rl32(pb); \
if (fourcc_tag != LIST_TAG) \ if (fourcc_tag != LIST_TAG) \
return AVERROR_INVALIDDATA; \ return AVERROR_INVALIDDATA; \
fourcc_tag = get_le32(pb); fourcc_tag = avio_rl32(pb);
typedef struct AudioTrack { typedef struct AudioTrack {
int sample_rate; int sample_rate;
@ -118,7 +118,7 @@ static int fourxm_read_header(AVFormatContext *s,
header = av_malloc(header_size); header = av_malloc(header_size);
if (!header) if (!header)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (get_buffer(pb, header, header_size) != header_size){ if (avio_read(pb, header, header_size) != header_size){
av_free(header); av_free(header);
return AVERROR(EIO); return AVERROR(EIO);
} }
@ -255,7 +255,7 @@ static int fourxm_read_packet(AVFormatContext *s,
while (!packet_read) { while (!packet_read) {
if ((ret = get_buffer(s->pb, header, 8)) < 0) if ((ret = avio_read(s->pb, header, 8)) < 0)
return ret; return ret;
fourcc_tag = AV_RL32(&header[0]); fourcc_tag = AV_RL32(&header[0]);
size = AV_RL32(&header[4]); size = AV_RL32(&header[4]);
@ -268,7 +268,7 @@ static int fourxm_read_packet(AVFormatContext *s,
fourxm->video_pts ++; fourxm->video_pts ++;
/* skip the LIST-* tag and move on to the next fourcc */ /* skip the LIST-* tag and move on to the next fourcc */
get_le32(pb); avio_rl32(pb);
break; break;
case ifrm_TAG: case ifrm_TAG:
@ -285,7 +285,7 @@ static int fourxm_read_packet(AVFormatContext *s,
pkt->pts = fourxm->video_pts; pkt->pts = fourxm->video_pts;
pkt->pos = url_ftell(s->pb); pkt->pos = url_ftell(s->pb);
memcpy(pkt->data, header, 8); memcpy(pkt->data, header, 8);
ret = get_buffer(s->pb, &pkt->data[8], size); ret = avio_read(s->pb, &pkt->data[8], size);
if (ret < 0){ if (ret < 0){
av_free_packet(pkt); av_free_packet(pkt);
@ -294,8 +294,8 @@ static int fourxm_read_packet(AVFormatContext *s,
break; break;
case snd__TAG: case snd__TAG:
track_number = get_le32(pb); track_number = avio_rl32(pb);
out_size= get_le32(pb); out_size= avio_rl32(pb);
size-=8; size-=8;
if (track_number < fourxm->track_count && fourxm->tracks[track_number].channels>0) { if (track_number < fourxm->track_count && fourxm->tracks[track_number].channels>0) {

2
libavformat/aea.c
View File

@ -63,7 +63,7 @@ static int aea_read_header(AVFormatContext *s,
/* Parse the amount of channels and skip to pos 2048(0x800) */ /* Parse the amount of channels and skip to pos 2048(0x800) */
url_fskip(s->pb, 264); url_fskip(s->pb, 264);
st->codec->channels = get_byte(s->pb); st->codec->channels = avio_r8(s->pb);
url_fskip(s->pb, 1783); url_fskip(s->pb, 1783);

26
libavformat/aiffdec.c
View File

@ -54,8 +54,8 @@ static int get_tag(AVIOContext *pb, uint32_t * tag)
if (url_feof(pb)) if (url_feof(pb))
return AVERROR(EIO); return AVERROR(EIO);
*tag = get_le32(pb); *tag = avio_rl32(pb);
size = get_be32(pb); size = avio_rb32(pb);
if (size < 0) if (size < 0)
size = 0x7fffffff; size = 0x7fffffff;
@ -74,7 +74,7 @@ static void get_meta(AVFormatContext *s, const char *key, int size)
return; return;
} }
res = get_buffer(s->pb, str, size); res = avio_read(s->pb, str, size);
if (res < 0) if (res < 0)
return; return;
@ -93,18 +93,18 @@ static unsigned int get_aiff_header(AVIOContext *pb, AVCodecContext *codec,
if (size & 1) if (size & 1)
size++; size++;
codec->codec_type = AVMEDIA_TYPE_AUDIO; codec->codec_type = AVMEDIA_TYPE_AUDIO;
codec->channels = get_be16(pb); codec->channels = avio_rb16(pb);
num_frames = get_be32(pb); num_frames = avio_rb32(pb);
codec->bits_per_coded_sample = get_be16(pb); codec->bits_per_coded_sample = avio_rb16(pb);
get_buffer(pb, (uint8_t*)&ext, sizeof(ext));/* Sample rate is in */ avio_read(pb, (uint8_t*)&ext, sizeof(ext));/* Sample rate is in */
sample_rate = av_ext2dbl(ext); /* 80 bits BE IEEE extended float */ sample_rate = av_ext2dbl(ext); /* 80 bits BE IEEE extended float */
codec->sample_rate = sample_rate; codec->sample_rate = sample_rate;
size -= 18; size -= 18;
/* Got an AIFF-C? */ /* Got an AIFF-C? */
if (version == AIFF_C_VERSION1) { if (version == AIFF_C_VERSION1) {
codec->codec_tag = get_le32(pb); codec->codec_tag = avio_rl32(pb);
codec->codec_id = ff_codec_get_id(ff_codec_aiff_tags, codec->codec_tag); codec->codec_id = ff_codec_get_id(ff_codec_aiff_tags, codec->codec_tag);
switch (codec->codec_id) { switch (codec->codec_id) {
@ -187,7 +187,7 @@ static int aiff_read_header(AVFormatContext *s,
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
/* AIFF data type */ /* AIFF data type */
tag = get_le32(pb); tag = avio_rl32(pb);
if (tag == MKTAG('A', 'I', 'F', 'F')) /* Got an AIFF file */ if (tag == MKTAG('A', 'I', 'F', 'F')) /* Got an AIFF file */
version = AIFF; version = AIFF;
else if (tag != MKTAG('A', 'I', 'F', 'C')) /* An AIFF-C file then */ else if (tag != MKTAG('A', 'I', 'F', 'C')) /* An AIFF-C file then */
@ -217,7 +217,7 @@ static int aiff_read_header(AVFormatContext *s,
goto got_sound; goto got_sound;
break; break;
case MKTAG('F', 'V', 'E', 'R'): /* Version chunk */ case MKTAG('F', 'V', 'E', 'R'): /* Version chunk */
version = get_be32(pb); version = avio_rb32(pb);
break; break;
case MKTAG('N', 'A', 'M', 'E'): /* Sample name chunk */ case MKTAG('N', 'A', 'M', 'E'): /* Sample name chunk */
get_meta(s, "title" , size); get_meta(s, "title" , size);
@ -233,8 +233,8 @@ static int aiff_read_header(AVFormatContext *s,
break; break;
case MKTAG('S', 'S', 'N', 'D'): /* Sampled sound chunk */ case MKTAG('S', 'S', 'N', 'D'): /* Sampled sound chunk */
aiff->data_end = url_ftell(pb) + size; aiff->data_end = url_ftell(pb) + size;
offset = get_be32(pb); /* Offset of sound data */ offset = avio_rb32(pb); /* Offset of sound data */
get_be32(pb); /* BlockSize... don't care */ avio_rb32(pb); /* BlockSize... don't care */
offset += url_ftell(pb); /* Compute absolute data offset */ offset += url_ftell(pb); /* Compute absolute data offset */
if (st->codec->block_align) /* Assume COMM already parsed */ if (st->codec->block_align) /* Assume COMM already parsed */
goto got_sound; goto got_sound;
@ -251,7 +251,7 @@ static int aiff_read_header(AVFormatContext *s,
if (!st->codec->extradata) if (!st->codec->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata_size = size; st->codec->extradata_size = size;
get_buffer(pb, st->codec->extradata, size); avio_read(pb, st->codec->extradata, size);
break; break;
default: /* Jump */ default: /* Jump */
if (size & 1) /* Always even aligned */ if (size & 1) /* Always even aligned */

8
libavformat/amr.c
View File

@ -82,7 +82,7 @@ static int amr_read_header(AVFormatContext *s,
AVStream *st; AVStream *st;
uint8_t header[9]; uint8_t header[9];
get_buffer(pb, header, 6); avio_read(pb, header, 6);
st = av_new_stream(s, 0); st = av_new_stream(s, 0);
if (!st) if (!st)
@ -91,7 +91,7 @@ static int amr_read_header(AVFormatContext *s,
} }
if(memcmp(header,AMR_header,6)!=0) if(memcmp(header,AMR_header,6)!=0)
{ {
get_buffer(pb, header+6, 3); avio_read(pb, header+6, 3);
if(memcmp(header,AMRWB_header,9)!=0) if(memcmp(header,AMRWB_header,9)!=0)
{ {
return -1; return -1;
@ -128,7 +128,7 @@ static int amr_read_packet(AVFormatContext *s,
} }
//FIXME this is wrong, this should rather be in a AVParset //FIXME this is wrong, this should rather be in a AVParset
toc=get_byte(s->pb); toc=avio_r8(s->pb);
mode = (toc >> 3) & 0x0F; mode = (toc >> 3) & 0x0F;
if (enc->codec_id == CODEC_ID_AMR_NB) if (enc->codec_id == CODEC_ID_AMR_NB)
@ -157,7 +157,7 @@ static int amr_read_packet(AVFormatContext *s,
pkt->pos= url_ftell(s->pb); pkt->pos= url_ftell(s->pb);
pkt->data[0]=toc; pkt->data[0]=toc;
pkt->duration= enc->codec_id == CODEC_ID_AMR_NB ? 160 : 320; pkt->duration= enc->codec_id == CODEC_ID_AMR_NB ? 160 : 320;
read = get_buffer(s->pb, pkt->data+1, size-1); read = avio_read(s->pb, pkt->data+1, size-1);
if (read != size-1) if (read != size-1)
{ {

38
libavformat/anm.c
View File

@ -84,16 +84,16 @@ static int read_header(AVFormatContext *s,
int i, ret; int i, ret;
url_fskip(pb, 4); /* magic number */ url_fskip(pb, 4); /* magic number */
if (get_le16(pb) != MAX_PAGES) { if (avio_rl16(pb) != MAX_PAGES) {
av_log_ask_for_sample(s, "max_pages != " AV_STRINGIFY(MAX_PAGES) "\n"); av_log_ask_for_sample(s, "max_pages != " AV_STRINGIFY(MAX_PAGES) "\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
anm->nb_pages = get_le16(pb); anm->nb_pages = avio_rl16(pb);
anm->nb_records = get_le32(pb); anm->nb_records = avio_rl32(pb);
url_fskip(pb, 2); /* max records per page */ url_fskip(pb, 2); /* max records per page */
anm->page_table_offset = get_le16(pb); anm->page_table_offset = avio_rl16(pb);
if (get_le32(pb) != ANIM_TAG) if (avio_rl32(pb) != ANIM_TAG)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
/* video stream */ /* video stream */
@ -103,32 +103,32 @@ static int read_header(AVFormatContext *s,
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_ANM; st->codec->codec_id = CODEC_ID_ANM;
st->codec->codec_tag = 0; /* no fourcc */ st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = get_le16(pb); st->codec->width = avio_rl16(pb);
st->codec->height = get_le16(pb); st->codec->height = avio_rl16(pb);
if (get_byte(pb) != 0) if (avio_r8(pb) != 0)
goto invalid; goto invalid;
url_fskip(pb, 1); /* frame rate multiplier info */ url_fskip(pb, 1); /* frame rate multiplier info */
/* ignore last delta record (used for looping) */ /* ignore last delta record (used for looping) */
if (get_byte(pb)) /* has_last_delta */ if (avio_r8(pb)) /* has_last_delta */
anm->nb_records = FFMAX(anm->nb_records - 1, 0); anm->nb_records = FFMAX(anm->nb_records - 1, 0);
url_fskip(pb, 1); /* last_delta_valid */ url_fskip(pb, 1); /* last_delta_valid */
if (get_byte(pb) != 0) if (avio_r8(pb) != 0)
goto invalid; goto invalid;
if (get_byte(pb) != 1) if (avio_r8(pb) != 1)
goto invalid; goto invalid;
url_fskip(pb, 1); /* other recs per frame */ url_fskip(pb, 1); /* other recs per frame */
if (get_byte(pb) != 1) if (avio_r8(pb) != 1)
goto invalid; goto invalid;
url_fskip(pb, 32); /* record_types */ url_fskip(pb, 32); /* record_types */
st->nb_frames = get_le32(pb); st->nb_frames = avio_rl32(pb);
av_set_pts_info(st, 64, 1, get_le16(pb)); av_set_pts_info(st, 64, 1, avio_rl16(pb));
url_fskip(pb, 58); url_fskip(pb, 58);
/* color cycling and palette data */ /* color cycling and palette data */
@ -138,7 +138,7 @@ static int read_header(AVFormatContext *s,
ret = AVERROR(ENOMEM); ret = AVERROR(ENOMEM);
goto close_and_return; goto close_and_return;
} }
ret = get_buffer(pb, st->codec->extradata, st->codec->extradata_size); ret = avio_read(pb, st->codec->extradata, st->codec->extradata_size);
if (ret < 0) if (ret < 0)
goto close_and_return; goto close_and_return;
@ -149,9 +149,9 @@ static int read_header(AVFormatContext *s,
for (i = 0; i < MAX_PAGES; i++) { for (i = 0; i < MAX_PAGES; i++) {
Page *p = &anm->pt[i]; Page *p = &anm->pt[i];
p->base_record = get_le16(pb); p->base_record = avio_rl16(pb);
p->nb_records = get_le16(pb); p->nb_records = avio_rl16(pb);
p->size = get_le16(pb); p->size = avio_rl16(pb);
} }
/* find page of first frame */ /* find page of first frame */
@ -211,7 +211,7 @@ repeat:
tmp = url_ftell(pb); tmp = url_ftell(pb);
url_fseek(pb, anm->page_table_offset + MAX_PAGES*6 + (anm->page<<16) + url_fseek(pb, anm->page_table_offset + MAX_PAGES*6 + (anm->page<<16) +
8 + anm->record * 2, SEEK_SET); 8 + anm->record * 2, SEEK_SET);
record_size = get_le16(pb); record_size = avio_rl16(pb);
url_fseek(pb, tmp, SEEK_SET); url_fseek(pb, tmp, SEEK_SET);
/* fetch record */ /* fetch record */

14
libavformat/apc.c
View File

@ -35,9 +35,9 @@ static int apc_read_header(AVFormatContext *s, AVFormatParameters *ap)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVStream *st; AVStream *st;
get_le32(pb); /* CRYO */ avio_rl32(pb); /* CRYO */
get_le32(pb); /* _APC */ avio_rl32(pb); /* _APC */
get_le32(pb); /* 1.20 */ avio_rl32(pb); /* 1.20 */
st = av_new_stream(s, 0); st = av_new_stream(s, 0);
if (!st) if (!st)
@ -46,8 +46,8 @@ static int apc_read_header(AVFormatContext *s, AVFormatParameters *ap)
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS; st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;
get_le32(pb); /* number of samples */ avio_rl32(pb); /* number of samples */
st->codec->sample_rate = get_le32(pb); st->codec->sample_rate = avio_rl32(pb);
st->codec->extradata_size = 2 * 4; st->codec->extradata_size = 2 * 4;
st->codec->extradata = av_malloc(st->codec->extradata_size + st->codec->extradata = av_malloc(st->codec->extradata_size +
@ -56,10 +56,10 @@ static int apc_read_header(AVFormatContext *s, AVFormatParameters *ap)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
/* initial predictor values for adpcm decoder */ /* initial predictor values for adpcm decoder */
get_buffer(pb, st->codec->extradata, 2 * 4); avio_read(pb, st->codec->extradata, 2 * 4);
st->codec->channels = 1; st->codec->channels = 1;
if (get_le32(pb)) if (avio_rl32(pb))
st->codec->channels = 2; st->codec->channels = 2;
st->codec->bits_per_coded_sample = 4; st->codec->bits_per_coded_sample = 4;

60
libavformat/ape.c
View File

@ -162,11 +162,11 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap)
/* TODO: Skip any leading junk such as id3v2 tags */ /* TODO: Skip any leading junk such as id3v2 tags */
ape->junklength = 0; ape->junklength = 0;
tag = get_le32(pb); tag = avio_rl32(pb);
if (tag != MKTAG('M', 'A', 'C', ' ')) if (tag != MKTAG('M', 'A', 'C', ' '))
return -1; return -1;
ape->fileversion = get_le16(pb); ape->fileversion = avio_rl16(pb);
if (ape->fileversion < APE_MIN_VERSION || ape->fileversion > APE_MAX_VERSION) { if (ape->fileversion < APE_MIN_VERSION || ape->fileversion > APE_MAX_VERSION) {
av_log(s, AV_LOG_ERROR, "Unsupported file version - %d.%02d\n", ape->fileversion / 1000, (ape->fileversion % 1000) / 10); av_log(s, AV_LOG_ERROR, "Unsupported file version - %d.%02d\n", ape->fileversion / 1000, (ape->fileversion % 1000) / 10);
@ -174,15 +174,15 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap)
} }
if (ape->fileversion >= 3980) { if (ape->fileversion >= 3980) {
ape->padding1 = get_le16(pb); ape->padding1 = avio_rl16(pb);
ape->descriptorlength = get_le32(pb); ape->descriptorlength = avio_rl32(pb);
ape->headerlength = get_le32(pb); ape->headerlength = avio_rl32(pb);
ape->seektablelength = get_le32(pb); ape->seektablelength = avio_rl32(pb);
ape->wavheaderlength = get_le32(pb); ape->wavheaderlength = avio_rl32(pb);
ape->audiodatalength = get_le32(pb); ape->audiodatalength = avio_rl32(pb);
ape->audiodatalength_high = get_le32(pb); ape->audiodatalength_high = avio_rl32(pb);
ape->wavtaillength = get_le32(pb); ape->wavtaillength = avio_rl32(pb);
get_buffer(pb, ape->md5, 16); avio_read(pb, ape->md5, 16);
/* Skip any unknown bytes at the end of the descriptor. /* Skip any unknown bytes at the end of the descriptor.
This is for future compatibility */ This is for future compatibility */
@ -190,26 +190,26 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap)
url_fseek(pb, ape->descriptorlength - 52, SEEK_CUR); url_fseek(pb, ape->descriptorlength - 52, SEEK_CUR);
/* Read header data */ /* Read header data */
ape->compressiontype = get_le16(pb); ape->compressiontype = avio_rl16(pb);
ape->formatflags = get_le16(pb); ape->formatflags = avio_rl16(pb);
ape->blocksperframe = get_le32(pb); ape->blocksperframe = avio_rl32(pb);
ape->finalframeblocks = get_le32(pb); ape->finalframeblocks = avio_rl32(pb);
ape->totalframes = get_le32(pb); ape->totalframes = avio_rl32(pb);
ape->bps = get_le16(pb); ape->bps = avio_rl16(pb);
ape->channels = get_le16(pb); ape->channels = avio_rl16(pb);
ape->samplerate = get_le32(pb); ape->samplerate = avio_rl32(pb);
} else { } else {
ape->descriptorlength = 0; ape->descriptorlength = 0;
ape->headerlength = 32; ape->headerlength = 32;
ape->compressiontype = get_le16(pb); ape->compressiontype = avio_rl16(pb);
ape->formatflags = get_le16(pb); ape->formatflags = avio_rl16(pb);
ape->channels = get_le16(pb); ape->channels = avio_rl16(pb);
ape->samplerate = get_le32(pb); ape->samplerate = avio_rl32(pb);
ape->wavheaderlength = get_le32(pb); ape->wavheaderlength = avio_rl32(pb);
ape->wavtaillength = get_le32(pb); ape->wavtaillength = avio_rl32(pb);
ape->totalframes = get_le32(pb); ape->totalframes = avio_rl32(pb);
ape->finalframeblocks = get_le32(pb); ape->finalframeblocks = avio_rl32(pb);
if (ape->formatflags & MAC_FORMAT_FLAG_HAS_PEAK_LEVEL) { if (ape->formatflags & MAC_FORMAT_FLAG_HAS_PEAK_LEVEL) {
url_fseek(pb, 4, SEEK_CUR); /* Skip the peak level */ url_fseek(pb, 4, SEEK_CUR); /* Skip the peak level */
@ -217,7 +217,7 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap)
} }
if (ape->formatflags & MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS) { if (ape->formatflags & MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS) {
ape->seektablelength = get_le32(pb); ape->seektablelength = avio_rl32(pb);
ape->headerlength += 4; ape->headerlength += 4;
ape->seektablelength *= sizeof(int32_t); ape->seektablelength *= sizeof(int32_t);
} else } else
@ -260,7 +260,7 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap)
if (ape->seektablelength > 0) { if (ape->seektablelength > 0) {
ape->seektable = av_malloc(ape->seektablelength); ape->seektable = av_malloc(ape->seektablelength);
for (i = 0; i < ape->seektablelength / sizeof(uint32_t); i++) for (i = 0; i < ape->seektablelength / sizeof(uint32_t); i++)
ape->seektable[i] = get_le32(pb); ape->seektable[i] = avio_rl32(pb);
} }
ape->frames[0].pos = ape->firstframe; ape->frames[0].pos = ape->firstframe;
@ -355,7 +355,7 @@ static int ape_read_packet(AVFormatContext * s, AVPacket * pkt)
AV_WL32(pkt->data , nblocks); AV_WL32(pkt->data , nblocks);
AV_WL32(pkt->data + 4, ape->frames[ape->currentframe].skip); AV_WL32(pkt->data + 4, ape->frames[ape->currentframe].skip);
ret = get_buffer(s->pb, pkt->data + extra_size, ape->frames[ape->currentframe].size); ret = avio_read(s->pb, pkt->data + extra_size, ape->frames[ape->currentframe].size);
pkt->pts = ape->frames[ape->currentframe].pts; pkt->pts = ape->frames[ape->currentframe].pts;
pkt->stream_index = 0; pkt->stream_index = 0;

18
libavformat/apetag.c
View File

@ -38,10 +38,10 @@ static int ape_tag_read_field(AVFormatContext *s)
uint32_t size, flags; uint32_t size, flags;
int i, c; int i, c;
size = get_le32(pb); /* field size */ size = avio_rl32(pb); /* field size */
flags = get_le32(pb); /* field flags */ flags = avio_rl32(pb); /* field flags */
for (i = 0; i < sizeof(key) - 1; i++) { for (i = 0; i < sizeof(key) - 1; i++) {
c = get_byte(pb); c = avio_r8(pb);
if (c < 0x20 || c > 0x7E) if (c < 0x20 || c > 0x7E)
break; break;
else else
@ -57,7 +57,7 @@ static int ape_tag_read_field(AVFormatContext *s)
value = av_malloc(size+1); value = av_malloc(size+1);
if (!value) if (!value)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
get_buffer(pb, value, size); avio_read(pb, value, size);
value[size] = 0; value[size] = 0;
av_metadata_set2(&s->metadata, key, value, AV_METADATA_DONT_STRDUP_VAL); av_metadata_set2(&s->metadata, key, value, AV_METADATA_DONT_STRDUP_VAL);
return 0; return 0;
@ -76,30 +76,30 @@ void ff_ape_parse_tag(AVFormatContext *s)
url_fseek(pb, file_size - APE_TAG_FOOTER_BYTES, SEEK_SET); url_fseek(pb, file_size - APE_TAG_FOOTER_BYTES, SEEK_SET);
get_buffer(pb, buf, 8); /* APETAGEX */ avio_read(pb, buf, 8); /* APETAGEX */
if (strncmp(buf, "APETAGEX", 8)) { if (strncmp(buf, "APETAGEX", 8)) {
return; return;
} }
val = get_le32(pb); /* APE tag version */ val = avio_rl32(pb); /* APE tag version */
if (val > APE_TAG_VERSION) { if (val > APE_TAG_VERSION) {
av_log(s, AV_LOG_ERROR, "Unsupported tag version. (>=%d)\n", APE_TAG_VERSION); av_log(s, AV_LOG_ERROR, "Unsupported tag version. (>=%d)\n", APE_TAG_VERSION);
return; return;
} }
tag_bytes = get_le32(pb); /* tag size */ tag_bytes = avio_rl32(pb); /* tag size */
if (tag_bytes - APE_TAG_FOOTER_BYTES > (1024 * 1024 * 16)) { if (tag_bytes - APE_TAG_FOOTER_BYTES > (1024 * 1024 * 16)) {
av_log(s, AV_LOG_ERROR, "Tag size is way too big\n"); av_log(s, AV_LOG_ERROR, "Tag size is way too big\n");
return; return;
} }
fields = get_le32(pb); /* number of fields */ fields = avio_rl32(pb); /* number of fields */
if (fields > 65536) { if (fields > 65536) {
av_log(s, AV_LOG_ERROR, "Too many tag fields (%d)\n", fields); av_log(s, AV_LOG_ERROR, "Too many tag fields (%d)\n", fields);
return; return;
} }
val = get_le32(pb); /* flags */ val = avio_rl32(pb); /* flags */
if (val & APE_TAG_FLAG_IS_HEADER) { if (val & APE_TAG_FLAG_IS_HEADER) {
av_log(s, AV_LOG_ERROR, "APE Tag is a header\n"); av_log(s, AV_LOG_ERROR, "APE Tag is a header\n");
return; return;

252
libavformat/asfdec.c
View File

@ -135,7 +135,7 @@ static void print_guid(const ff_asf_guid *g)
void ff_get_guid(AVIOContext *s, ff_asf_guid *g) void ff_get_guid(AVIOContext *s, ff_asf_guid *g)
{ {
assert(sizeof(*g) == 16); assert(sizeof(*g) == 16);
get_buffer(s, *g, sizeof(*g)); avio_read(s, *g, sizeof(*g));
} }
static int asf_probe(AVProbeData *pd) static int asf_probe(AVProbeData *pd)
@ -149,10 +149,10 @@ static int asf_probe(AVProbeData *pd)
static int get_value(AVIOContext *pb, int type){ static int get_value(AVIOContext *pb, int type){
switch(type){ switch(type){
case 2: return get_le32(pb); case 2: return avio_rl32(pb);
case 3: return get_le32(pb); case 3: return avio_rl32(pb);
case 4: return get_le64(pb); case 4: return avio_rl64(pb);
case 5: return get_le16(pb); case 5: return avio_rl16(pb);
default:return INT_MIN; default:return INT_MIN;
} }
} }
@ -191,17 +191,17 @@ static int asf_read_file_properties(AVFormatContext *s, int64_t size)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
ff_get_guid(pb, &asf->hdr.guid); ff_get_guid(pb, &asf->hdr.guid);
asf->hdr.file_size = get_le64(pb); asf->hdr.file_size = avio_rl64(pb);
asf->hdr.create_time = get_le64(pb); asf->hdr.create_time = avio_rl64(pb);
get_le64(pb); /* number of packets */ avio_rl64(pb); /* number of packets */
asf->hdr.play_time = get_le64(pb); asf->hdr.play_time = avio_rl64(pb);
asf->hdr.send_time = get_le64(pb); asf->hdr.send_time = avio_rl64(pb);
asf->hdr.preroll = get_le32(pb); asf->hdr.preroll = avio_rl32(pb);
asf->hdr.ignore = get_le32(pb); asf->hdr.ignore = avio_rl32(pb);
asf->hdr.flags = get_le32(pb); asf->hdr.flags = avio_rl32(pb);
asf->hdr.min_pktsize = get_le32(pb); asf->hdr.min_pktsize = avio_rl32(pb);
asf->hdr.max_pktsize = get_le32(pb); asf->hdr.max_pktsize = avio_rl32(pb);
asf->hdr.max_bitrate = get_le32(pb); asf->hdr.max_bitrate = avio_rl32(pb);
s->packet_size = asf->hdr.max_pktsize; s->packet_size = asf->hdr.max_pktsize;
return 0; return 0;
@ -263,14 +263,14 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
return -1; return -1;
} }
ff_get_guid(pb, &g); ff_get_guid(pb, &g);
total_size = get_le64(pb); total_size = avio_rl64(pb);
type_specific_size = get_le32(pb); type_specific_size = avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
st->id = get_le16(pb) & 0x7f; /* stream id */ st->id = avio_rl16(pb) & 0x7f; /* stream id */
// mapping of asf ID to AV stream ID; // mapping of asf ID to AV stream ID;
asf->asfid2avid[st->id] = s->nb_streams - 1; asf->asfid2avid[st->id] = s->nb_streams - 1;
get_le32(pb); avio_rl32(pb);
if (test_for_ext_stream_audio) { if (test_for_ext_stream_audio) {
ff_get_guid(pb, &g); ff_get_guid(pb, &g);
@ -278,11 +278,11 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
type = AVMEDIA_TYPE_AUDIO; type = AVMEDIA_TYPE_AUDIO;
is_dvr_ms_audio=1; is_dvr_ms_audio=1;
ff_get_guid(pb, &g); ff_get_guid(pb, &g);
get_le32(pb); avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
ff_get_guid(pb, &g); ff_get_guid(pb, &g);
get_le32(pb); avio_rl32(pb);
} }
} }
@ -303,11 +303,11 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
/* We have to init the frame size at some point .... */ /* We have to init the frame size at some point .... */
pos2 = url_ftell(pb); pos2 = url_ftell(pb);
if (size >= (pos2 + 8 - pos1 + 24)) { if (size >= (pos2 + 8 - pos1 + 24)) {
asf_st->ds_span = get_byte(pb); asf_st->ds_span = avio_r8(pb);
asf_st->ds_packet_size = get_le16(pb); asf_st->ds_packet_size = avio_rl16(pb);
asf_st->ds_chunk_size = get_le16(pb); asf_st->ds_chunk_size = avio_rl16(pb);
get_le16(pb); //ds_data_size avio_rl16(pb); //ds_data_size
get_byte(pb); //ds_silence_data avio_r8(pb); //ds_silence_data
} }
//printf("Descrambling: ps:%d cs:%d ds:%d s:%d sd:%d\n", //printf("Descrambling: ps:%d cs:%d ds:%d s:%d sd:%d\n",
// asf_st->ds_packet_size, asf_st->ds_chunk_size, // asf_st->ds_packet_size, asf_st->ds_chunk_size,
@ -339,23 +339,23 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
} }
} else if (type == AVMEDIA_TYPE_VIDEO && } else if (type == AVMEDIA_TYPE_VIDEO &&
size - (url_ftell(pb) - pos1 + 24) >= 51) { size - (url_ftell(pb) - pos1 + 24) >= 51) {
get_le32(pb); avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
get_byte(pb); avio_r8(pb);
get_le16(pb); /* size */ avio_rl16(pb); /* size */
sizeX= get_le32(pb); /* size */ sizeX= avio_rl32(pb); /* size */
st->codec->width = get_le32(pb); st->codec->width = avio_rl32(pb);
st->codec->height = get_le32(pb); st->codec->height = avio_rl32(pb);
/* not available for asf */ /* not available for asf */
get_le16(pb); /* panes */ avio_rl16(pb); /* panes */
st->codec->bits_per_coded_sample = get_le16(pb); /* depth */ st->codec->bits_per_coded_sample = avio_rl16(pb); /* depth */
tag1 = get_le32(pb); tag1 = avio_rl32(pb);
url_fskip(pb, 20); url_fskip(pb, 20);
// av_log(s, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX); // av_log(s, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX);
if (sizeX > 40) { if (sizeX > 40) {
st->codec->extradata_size = sizeX - 40; st->codec->extradata_size = sizeX - 40;
st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(pb, st->codec->extradata, st->codec->extradata_size); avio_read(pb, st->codec->extradata, st->codec->extradata_size);
} }
/* Extract palette from extradata if bpp <= 8 */ /* Extract palette from extradata if bpp <= 8 */
@ -402,39 +402,39 @@ static int asf_read_ext_stream_properties(AVFormatContext *s, int64_t size)
uint32_t ext_d, leak_rate, stream_num; uint32_t ext_d, leak_rate, stream_num;
unsigned int stream_languageid_index; unsigned int stream_languageid_index;
get_le64(pb); // starttime avio_rl64(pb); // starttime
get_le64(pb); // endtime avio_rl64(pb); // endtime
leak_rate = get_le32(pb); // leak-datarate leak_rate = avio_rl32(pb); // leak-datarate
get_le32(pb); // bucket-datasize avio_rl32(pb); // bucket-datasize
get_le32(pb); // init-bucket-fullness avio_rl32(pb); // init-bucket-fullness
get_le32(pb); // alt-leak-datarate avio_rl32(pb); // alt-leak-datarate
get_le32(pb); // alt-bucket-datasize avio_rl32(pb); // alt-bucket-datasize
get_le32(pb); // alt-init-bucket-fullness avio_rl32(pb); // alt-init-bucket-fullness
get_le32(pb); // max-object-size avio_rl32(pb); // max-object-size
get_le32(pb); // flags (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved) avio_rl32(pb); // flags (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved)
stream_num = get_le16(pb); // stream-num stream_num = avio_rl16(pb); // stream-num
stream_languageid_index = get_le16(pb); // stream-language-id-index stream_languageid_index = avio_rl16(pb); // stream-language-id-index
if (stream_num < 128) if (stream_num < 128)
asf->streams[stream_num].stream_language_index = stream_languageid_index; asf->streams[stream_num].stream_language_index = stream_languageid_index;
get_le64(pb); // avg frametime in 100ns units avio_rl64(pb); // avg frametime in 100ns units
stream_ct = get_le16(pb); //stream-name-count stream_ct = avio_rl16(pb); //stream-name-count
payload_ext_ct = get_le16(pb); //payload-extension-system-count payload_ext_ct = avio_rl16(pb); //payload-extension-system-count
if (stream_num < 128) if (stream_num < 128)
asf->stream_bitrates[stream_num] = leak_rate; asf->stream_bitrates[stream_num] = leak_rate;
for (i=0; i<stream_ct; i++){ for (i=0; i<stream_ct; i++){
get_le16(pb); avio_rl16(pb);
ext_len = get_le16(pb); ext_len = avio_rl16(pb);
url_fseek(pb, ext_len, SEEK_CUR); url_fseek(pb, ext_len, SEEK_CUR);
} }
for (i=0; i<payload_ext_ct; i++){ for (i=0; i<payload_ext_ct; i++){
ff_get_guid(pb, &g); ff_get_guid(pb, &g);
ext_d=get_le16(pb); ext_d=avio_rl16(pb);
ext_len=get_le32(pb); ext_len=avio_rl32(pb);
url_fseek(pb, ext_len, SEEK_CUR); url_fseek(pb, ext_len, SEEK_CUR);
} }
@ -446,11 +446,11 @@ static int asf_read_content_desc(AVFormatContext *s, int64_t size)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
int len1, len2, len3, len4, len5; int len1, len2, len3, len4, len5;
len1 = get_le16(pb); len1 = avio_rl16(pb);
len2 = get_le16(pb); len2 = avio_rl16(pb);
len3 = get_le16(pb); len3 = avio_rl16(pb);
len4 = get_le16(pb); len4 = avio_rl16(pb);
len5 = get_le16(pb); len5 = avio_rl16(pb);
get_tag(s, "title" , 0, len1); get_tag(s, "title" , 0, len1);
get_tag(s, "author" , 0, len2); get_tag(s, "author" , 0, len2);
get_tag(s, "copyright", 0, len3); get_tag(s, "copyright", 0, len3);
@ -466,18 +466,18 @@ static int asf_read_ext_content_desc(AVFormatContext *s, int64_t size)
ASFContext *asf = s->priv_data; ASFContext *asf = s->priv_data;
int desc_count, i, ret; int desc_count, i, ret;
desc_count = get_le16(pb); desc_count = avio_rl16(pb);
for(i=0;i<desc_count;i++) { for(i=0;i<desc_count;i++) {
int name_len,value_type,value_len; int name_len,value_type,value_len;
char name[1024]; char name[1024];
name_len = get_le16(pb); name_len = avio_rl16(pb);
if (name_len%2) // must be even, broken lavf versions wrote len-1 if (name_len%2) // must be even, broken lavf versions wrote len-1
name_len += 1; name_len += 1;
if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len) if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)
url_fskip(pb, name_len - ret); url_fskip(pb, name_len - ret);
value_type = get_le16(pb); value_type = avio_rl16(pb);
value_len = get_le16(pb); value_len = avio_rl16(pb);
if (!value_type && value_len%2) if (!value_type && value_len%2)
value_len += 1; value_len += 1;
/** /**
@ -500,10 +500,10 @@ static int asf_read_language_list(AVFormatContext *s, int64_t size)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
ASFContext *asf = s->priv_data; ASFContext *asf = s->priv_data;
int j, ret; int j, ret;
int stream_count = get_le16(pb); int stream_count = avio_rl16(pb);
for(j = 0; j < stream_count; j++) { for(j = 0; j < stream_count; j++) {
char lang[6]; char lang[6];
unsigned int lang_len = get_byte(pb); unsigned int lang_len = avio_r8(pb);
if ((ret = avio_get_str16le(pb, lang_len, lang, sizeof(lang))) < lang_len) if ((ret = avio_get_str16le(pb, lang_len, lang, sizeof(lang))) < lang_len)
url_fskip(pb, lang_len - ret); url_fskip(pb, lang_len - ret);
if (j < 128) if (j < 128)
@ -519,21 +519,21 @@ static int asf_read_metadata(AVFormatContext *s, int64_t size)
ASFContext *asf = s->priv_data; ASFContext *asf = s->priv_data;
int n, stream_num, name_len, value_len, value_type, value_num; int n, stream_num, name_len, value_len, value_type, value_num;
int ret, i; int ret, i;
n = get_le16(pb); n = avio_rl16(pb);
for(i=0;i<n;i++) { for(i=0;i<n;i++) {
char name[1024]; char name[1024];
get_le16(pb); //lang_list_index avio_rl16(pb); //lang_list_index
stream_num= get_le16(pb); stream_num= avio_rl16(pb);
name_len= get_le16(pb); name_len= avio_rl16(pb);
value_type= get_le16(pb); value_type= avio_rl16(pb);
value_len= get_le32(pb); value_len= avio_rl32(pb);
if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len) if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)
url_fskip(pb, name_len - ret); url_fskip(pb, name_len - ret);
//av_log(s, AV_LOG_ERROR, "%d %d %d %d %d <%s>\n", i, stream_num, name_len, value_type, value_len, name); //av_log(s, AV_LOG_ERROR, "%d %d %d %d %d <%s>\n", i, stream_num, name_len, value_type, value_len, name);
value_num= get_le16(pb);//we should use get_value() here but it does not work 2 is le16 here but le32 elsewhere value_num= avio_rl16(pb);//we should use get_value() here but it does not work 2 is le16 here but le32 elsewhere
url_fskip(pb, value_len - 2); url_fskip(pb, value_len - 2);
if(stream_num<128){ if(stream_num<128){
@ -551,25 +551,25 @@ static int asf_read_marker(AVFormatContext *s, int64_t size)
int i, count, name_len, ret; int i, count, name_len, ret;
char name[1024]; char name[1024];
get_le64(pb); // reserved 16 bytes avio_rl64(pb); // reserved 16 bytes
get_le64(pb); // ... avio_rl64(pb); // ...
count = get_le32(pb); // markers count count = avio_rl32(pb); // markers count
get_le16(pb); // reserved 2 bytes avio_rl16(pb); // reserved 2 bytes
name_len = get_le16(pb); // name length name_len = avio_rl16(pb); // name length
for(i=0;i<name_len;i++){ for(i=0;i<name_len;i++){
get_byte(pb); // skip the name avio_r8(pb); // skip the name
} }
for(i=0;i<count;i++){ for(i=0;i<count;i++){
int64_t pres_time; int64_t pres_time;
int name_len; int name_len;
get_le64(pb); // offset, 8 bytes avio_rl64(pb); // offset, 8 bytes
pres_time = get_le64(pb); // presentation time pres_time = avio_rl64(pb); // presentation time
get_le16(pb); // entry length avio_rl16(pb); // entry length
get_le32(pb); // send time avio_rl32(pb); // send time
get_le32(pb); // flags avio_rl32(pb); // flags
name_len = get_le32(pb); // name length name_len = avio_rl32(pb); // name length
if ((ret = avio_get_str16le(pb, name_len * 2, name, sizeof(name))) < name_len) if ((ret = avio_get_str16le(pb, name_len * 2, name, sizeof(name))) < name_len)
url_fskip(pb, name_len - ret); url_fskip(pb, name_len - ret);
ff_new_chapter(s, i, (AVRational){1, 10000000}, pres_time, AV_NOPTS_VALUE, name ); ff_new_chapter(s, i, (AVRational){1, 10000000}, pres_time, AV_NOPTS_VALUE, name );
@ -589,15 +589,15 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
ff_get_guid(pb, &g); ff_get_guid(pb, &g);
if (ff_guidcmp(&g, &ff_asf_header)) if (ff_guidcmp(&g, &ff_asf_header))
return -1; return -1;
get_le64(pb); avio_rl64(pb);
get_le32(pb); avio_rl32(pb);
get_byte(pb); avio_r8(pb);
get_byte(pb); avio_r8(pb);
memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid)); memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid));
for(;;) { for(;;) {
uint64_t gpos= url_ftell(pb); uint64_t gpos= url_ftell(pb);
ff_get_guid(pb, &g); ff_get_guid(pb, &g);
gsize = get_le64(pb); gsize = avio_rl64(pb);
av_dlog(s, "%08"PRIx64": ", gpos); av_dlog(s, "%08"PRIx64": ", gpos);
print_guid(&g); print_guid(&g);
av_dlog(s, " size=0x%"PRIx64"\n", gsize); av_dlog(s, " size=0x%"PRIx64"\n", gsize);
@ -634,8 +634,8 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
} else if (!ff_guidcmp(&g, &ff_asf_head1_guid)) { } else if (!ff_guidcmp(&g, &ff_asf_head1_guid)) {
int v1, v2; int v1, v2;
ff_get_guid(pb, &g); ff_get_guid(pb, &g);
v1 = get_le32(pb); v1 = avio_rl32(pb);
v2 = get_le16(pb); v2 = avio_rl16(pb);
continue; continue;
} else if (!ff_guidcmp(&g, &ff_asf_marker_header)) { } else if (!ff_guidcmp(&g, &ff_asf_marker_header)) {
asf_read_marker(s, gsize); asf_read_marker(s, gsize);
@ -657,9 +657,9 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
url_fseek(pb, gpos + gsize, SEEK_SET); url_fseek(pb, gpos + gsize, SEEK_SET);
} }
ff_get_guid(pb, &g); ff_get_guid(pb, &g);
get_le64(pb); avio_rl64(pb);
get_byte(pb); avio_r8(pb);
get_byte(pb); avio_r8(pb);
if (url_feof(pb)) if (url_feof(pb))
return -1; return -1;
asf->data_offset = url_ftell(pb); asf->data_offset = url_ftell(pb);
@ -704,9 +704,9 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
#define DO_2BITS(bits, var, defval) \ #define DO_2BITS(bits, var, defval) \
switch (bits & 3) \ switch (bits & 3) \
{ \ { \
case 3: var = get_le32(pb); rsize += 4; break; \ case 3: var = avio_rl32(pb); rsize += 4; break; \
case 2: var = get_le16(pb); rsize += 2; break; \ case 2: var = avio_rl16(pb); rsize += 2; break; \
case 1: var = get_byte(pb); rsize++; break; \ case 1: var = avio_r8(pb); rsize++; break; \
default: var = defval; break; \ default: var = defval; break; \
} }
@ -731,7 +731,7 @@ static int ff_asf_get_packet(AVFormatContext *s, AVIOContext *pb)
c=d=e=-1; c=d=e=-1;
while(off-- > 0){ while(off-- > 0){
c=d; d=e; c=d; d=e;
e= get_byte(pb); e= avio_r8(pb);
if(c == 0x82 && !d && !e) if(c == 0x82 && !d && !e)
break; break;
} }
@ -754,8 +754,8 @@ static int ff_asf_get_packet(AVFormatContext *s, AVIOContext *pb)
av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n"); av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");
return -1; return -1;
} }
c= get_byte(pb); c= avio_r8(pb);
d= get_byte(pb); d= avio_r8(pb);
rsize+=3; rsize+=3;
}else{ }else{
url_fseek(pb, -1, SEEK_CUR); //FIXME url_fseek(pb, -1, SEEK_CUR); //FIXME
@ -778,12 +778,12 @@ static int ff_asf_get_packet(AVFormatContext *s, AVIOContext *pb)
return -1; return -1;
} }
asf->packet_timestamp = get_le32(pb); asf->packet_timestamp = avio_rl32(pb);
get_le16(pb); /* duration */ avio_rl16(pb); /* duration */
// rsize has at least 11 bytes which have to be present // rsize has at least 11 bytes which have to be present
if (asf->packet_flags & 0x01) { if (asf->packet_flags & 0x01) {
asf->packet_segsizetype = get_byte(pb); rsize++; asf->packet_segsizetype = avio_r8(pb); rsize++;
asf->packet_segments = asf->packet_segsizetype & 0x3f; asf->packet_segments = asf->packet_segsizetype & 0x3f;
} else { } else {
asf->packet_segments = 1; asf->packet_segments = 1;
@ -804,7 +804,7 @@ static int ff_asf_get_packet(AVFormatContext *s, AVIOContext *pb)
static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb){ static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb){
ASFContext *asf = s->priv_data; ASFContext *asf = s->priv_data;
int rsize = 1; int rsize = 1;
int num = get_byte(pb); int num = avio_r8(pb);
int64_t ts0, ts1; int64_t ts0, ts1;
asf->packet_segments--; asf->packet_segments--;
@ -816,21 +816,21 @@ static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb){
DO_2BITS(asf->packet_property, asf->packet_replic_size, 0); DO_2BITS(asf->packet_property, asf->packet_replic_size, 0);
//printf("key:%d stream:%d seq:%d offset:%d replic_size:%d\n", asf->packet_key_frame, asf->stream_index, asf->packet_seq, //asf->packet_frag_offset, asf->packet_replic_size); //printf("key:%d stream:%d seq:%d offset:%d replic_size:%d\n", asf->packet_key_frame, asf->stream_index, asf->packet_seq, //asf->packet_frag_offset, asf->packet_replic_size);
if (asf->packet_replic_size >= 8) { if (asf->packet_replic_size >= 8) {
asf->packet_obj_size = get_le32(pb); asf->packet_obj_size = avio_rl32(pb);
if(asf->packet_obj_size >= (1<<24) || asf->packet_obj_size <= 0){ if(asf->packet_obj_size >= (1<<24) || asf->packet_obj_size <= 0){
av_log(s, AV_LOG_ERROR, "packet_obj_size invalid\n"); av_log(s, AV_LOG_ERROR, "packet_obj_size invalid\n");
return -1; return -1;
} }
asf->packet_frag_timestamp = get_le32(pb); // timestamp asf->packet_frag_timestamp = avio_rl32(pb); // timestamp
if(asf->packet_replic_size >= 8+38+4){ if(asf->packet_replic_size >= 8+38+4){
// for(i=0; i<asf->packet_replic_size-8; i++) // for(i=0; i<asf->packet_replic_size-8; i++)
// av_log(s, AV_LOG_DEBUG, "%02X ",get_byte(pb)); // av_log(s, AV_LOG_DEBUG, "%02X ",avio_r8(pb));
// av_log(s, AV_LOG_DEBUG, "\n"); // av_log(s, AV_LOG_DEBUG, "\n");
url_fskip(pb, 10); url_fskip(pb, 10);
ts0= get_le64(pb); ts0= avio_rl64(pb);
ts1= get_le64(pb); ts1= avio_rl64(pb);
url_fskip(pb, 12); url_fskip(pb, 12);
get_le32(pb); avio_rl32(pb);
url_fskip(pb, asf->packet_replic_size - 8 - 38 - 4); url_fskip(pb, asf->packet_replic_size - 8 - 38 - 4);
if(ts0!= -1) asf->packet_frag_timestamp= ts0/10000; if(ts0!= -1) asf->packet_frag_timestamp= ts0/10000;
else asf->packet_frag_timestamp= AV_NOPTS_VALUE; else asf->packet_frag_timestamp= AV_NOPTS_VALUE;
@ -843,7 +843,7 @@ static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb){
asf->packet_frag_offset = 0; asf->packet_frag_offset = 0;
asf->packet_frag_timestamp = asf->packet_timestamp; asf->packet_frag_timestamp = asf->packet_timestamp;
asf->packet_time_delta = get_byte(pb); asf->packet_time_delta = avio_r8(pb);
rsize++; rsize++;
}else if(asf->packet_replic_size!=0){ }else if(asf->packet_replic_size!=0){
av_log(s, AV_LOG_ERROR, "unexpected packet_replic_size of %d\n", asf->packet_replic_size); av_log(s, AV_LOG_ERROR, "unexpected packet_replic_size of %d\n", asf->packet_replic_size);
@ -928,7 +928,7 @@ static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pk
// frag_offset is here used as the beginning timestamp // frag_offset is here used as the beginning timestamp
asf->packet_frag_timestamp = asf->packet_time_start; asf->packet_frag_timestamp = asf->packet_time_start;
asf->packet_time_start += asf->packet_time_delta; asf->packet_time_start += asf->packet_time_delta;
asf->packet_obj_size = asf->packet_frag_size = get_byte(pb); asf->packet_obj_size = asf->packet_frag_size = avio_r8(pb);
asf->packet_size_left--; asf->packet_size_left--;
asf->packet_multi_size--; asf->packet_multi_size--;
if (asf->packet_multi_size < asf->packet_obj_size) if (asf->packet_multi_size < asf->packet_obj_size)
@ -988,7 +988,7 @@ static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pk
continue; continue;
} }
ret = get_buffer(pb, asf_st->pkt.data + asf->packet_frag_offset, ret = avio_read(pb, asf_st->pkt.data + asf->packet_frag_offset,
asf->packet_frag_size); asf->packet_frag_size);
if (ret != asf->packet_frag_size) { if (ret != asf->packet_frag_size) {
if (ret < 0 || asf->packet_frag_offset + ret == 0) if (ret < 0 || asf->packet_frag_offset + ret == 0)
@ -1194,7 +1194,7 @@ static void asf_build_simple_index(AVFormatContext *s, int stream_index)
/* the data object can be followed by other top-level objects, /* the data object can be followed by other top-level objects,
skip them until the simple index object is reached */ skip them until the simple index object is reached */
while (ff_guidcmp(&g, &index_guid)) { while (ff_guidcmp(&g, &index_guid)) {
int64_t gsize= get_le64(s->pb); int64_t gsize= avio_rl64(s->pb);
if (gsize < 24 || url_feof(s->pb)) { if (gsize < 24 || url_feof(s->pb)) {
url_fseek(s->pb, current_pos, SEEK_SET); url_fseek(s->pb, current_pos, SEEK_SET);
return; return;
@ -1206,16 +1206,16 @@ static void asf_build_simple_index(AVFormatContext *s, int stream_index)
{ {
int64_t itime, last_pos=-1; int64_t itime, last_pos=-1;
int pct, ict; int pct, ict;
int64_t av_unused gsize= get_le64(s->pb); int64_t av_unused gsize= avio_rl64(s->pb);
ff_get_guid(s->pb, &g); ff_get_guid(s->pb, &g);
itime=get_le64(s->pb); itime=avio_rl64(s->pb);
pct=get_le32(s->pb); pct=avio_rl32(s->pb);
ict=get_le32(s->pb); ict=avio_rl32(s->pb);
av_log(s, AV_LOG_DEBUG, "itime:0x%"PRIx64", pct:%d, ict:%d\n",itime,pct,ict); av_log(s, AV_LOG_DEBUG, "itime:0x%"PRIx64", pct:%d, ict:%d\n",itime,pct,ict);
for (i=0;i<ict;i++){ for (i=0;i<ict;i++){
int pktnum=get_le32(s->pb); int pktnum=avio_rl32(s->pb);
int pktct =get_le16(s->pb); int pktct =avio_rl16(s->pb);
int64_t pos = s->data_offset + s->packet_size*(int64_t)pktnum; int64_t pos = s->data_offset + s->packet_size*(int64_t)pktnum;
int64_t index_pts= av_rescale(itime, i, 10000); int64_t index_pts= av_rescale(itime, i, 10000);

12
libavformat/au.c
View File

@ -127,15 +127,15 @@ static int au_read_header(AVFormatContext *s,
AVStream *st; AVStream *st;
/* check ".snd" header */ /* check ".snd" header */
tag = get_le32(pb); tag = avio_rl32(pb);
if (tag != MKTAG('.', 's', 'n', 'd')) if (tag != MKTAG('.', 's', 'n', 'd'))
return -1; return -1;
size = get_be32(pb); /* header size */ size = avio_rb32(pb); /* header size */
get_be32(pb); /* data size */ avio_rb32(pb); /* data size */
id = get_be32(pb); id = avio_rb32(pb);
rate = get_be32(pb); rate = avio_rb32(pb);
channels = get_be32(pb); channels = avio_rb32(pb);
codec = ff_codec_get_id(codec_au_tags, id); codec = ff_codec_get_id(codec_au_tags, id);

156
libavformat/avidec.c
View File

@ -107,10 +107,10 @@ static int get_riff(AVFormatContext *s, AVIOContext *pb)
int i; int i;
/* check RIFF header */ /* check RIFF header */
get_buffer(pb, header, 4); avio_read(pb, header, 4);
avi->riff_end = get_le32(pb); /* RIFF chunk size */ avi->riff_end = avio_rl32(pb); /* RIFF chunk size */
avi->riff_end += url_ftell(pb); /* RIFF chunk end */ avi->riff_end += url_ftell(pb); /* RIFF chunk end */
get_buffer(pb, header+4, 4); avio_read(pb, header+4, 4);
for(i=0; avi_headers[i][0]; i++) for(i=0; avi_headers[i][0]; i++)
if(!memcmp(header, avi_headers[i], 8)) if(!memcmp(header, avi_headers[i], 8))
@ -127,12 +127,12 @@ static int get_riff(AVFormatContext *s, AVIOContext *pb)
static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){ static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){
AVIContext *avi = s->priv_data; AVIContext *avi = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
int longs_pre_entry= get_le16(pb); int longs_pre_entry= avio_rl16(pb);
int index_sub_type = get_byte(pb); int index_sub_type = avio_r8(pb);
int index_type = get_byte(pb); int index_type = avio_r8(pb);
int entries_in_use = get_le32(pb); int entries_in_use = avio_rl32(pb);
int chunk_id = get_le32(pb); int chunk_id = avio_rl32(pb);
int64_t base = get_le64(pb); int64_t base = avio_rl64(pb);
int stream_id= 10*((chunk_id&0xFF) - '0') + (((chunk_id>>8)&0xFF) - '0'); int stream_id= 10*((chunk_id&0xFF) - '0') + (((chunk_id>>8)&0xFF) - '0');
AVStream *st; AVStream *st;
AVIStream *ast; AVIStream *ast;
@ -153,7 +153,7 @@ static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){
if(index_sub_type) if(index_sub_type)
return -1; return -1;
get_le32(pb); avio_rl32(pb);
if(index_type && longs_pre_entry != 2) if(index_type && longs_pre_entry != 2)
return -1; return -1;
@ -170,8 +170,8 @@ static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){
for(i=0; i<entries_in_use; i++){ for(i=0; i<entries_in_use; i++){
if(index_type){ if(index_type){
int64_t pos= get_le32(pb) + base - 8; int64_t pos= avio_rl32(pb) + base - 8;
int len = get_le32(pb); int len = avio_rl32(pb);
int key= len >= 0; int key= len >= 0;
len &= 0x7FFFFFFF; len &= 0x7FFFFFFF;
@ -191,9 +191,9 @@ static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){
}else{ }else{
int64_t offset, pos; int64_t offset, pos;
int duration; int duration;
offset = get_le64(pb); offset = avio_rl64(pb);
get_le32(pb); /* size */ avio_rl32(pb); /* size */
duration = get_le32(pb); duration = avio_rl32(pb);
if(url_feof(pb)) if(url_feof(pb))
return -1; return -1;
@ -256,7 +256,7 @@ static int avi_read_tag(AVFormatContext *s, AVStream *st, uint32_t tag, uint32_t
value = av_malloc(size+1); value = av_malloc(size+1);
if (!value) if (!value)
return -1; return -1;
get_buffer(pb, value, size); avio_read(pb, value, size);
value[size]=0; value[size]=0;
AV_WL32(key, tag); AV_WL32(key, tag);
@ -268,8 +268,8 @@ static int avi_read_tag(AVFormatContext *s, AVStream *st, uint32_t tag, uint32_t
static void avi_read_info(AVFormatContext *s, uint64_t end) static void avi_read_info(AVFormatContext *s, uint64_t end)
{ {
while (url_ftell(s->pb) < end) { while (url_ftell(s->pb) < end) {
uint32_t tag = get_le32(s->pb); uint32_t tag = avio_rl32(s->pb);
uint32_t size = get_le32(s->pb); uint32_t size = avio_rl32(s->pb);
avi_read_tag(s, NULL, tag, size); avi_read_tag(s, NULL, tag, size);
} }
} }
@ -299,17 +299,17 @@ static void avi_metadata_creation_time(AVMetadata **metadata, char *date)
static void avi_read_nikon(AVFormatContext *s, uint64_t end) static void avi_read_nikon(AVFormatContext *s, uint64_t end)
{ {
while (url_ftell(s->pb) < end) { while (url_ftell(s->pb) < end) {
uint32_t tag = get_le32(s->pb); uint32_t tag = avio_rl32(s->pb);
uint32_t size = get_le32(s->pb); uint32_t size = avio_rl32(s->pb);
switch (tag) { switch (tag) {
case MKTAG('n', 'c', 't', 'g'): { /* Nikon Tags */ case MKTAG('n', 'c', 't', 'g'): { /* Nikon Tags */
uint64_t tag_end = url_ftell(s->pb) + size; uint64_t tag_end = url_ftell(s->pb) + size;
while (url_ftell(s->pb) < tag_end) { while (url_ftell(s->pb) < tag_end) {
uint16_t tag = get_le16(s->pb); uint16_t tag = avio_rl16(s->pb);
uint16_t size = get_le16(s->pb); uint16_t size = avio_rl16(s->pb);
const char *name = NULL; const char *name = NULL;
char buffer[64] = {0}; char buffer[64] = {0};
size -= get_buffer(s->pb, buffer, size -= avio_read(s->pb, buffer,
FFMIN(size, sizeof(buffer)-1)); FFMIN(size, sizeof(buffer)-1));
switch (tag) { switch (tag) {
case 0x03: name = "maker"; break; case 0x03: name = "maker"; break;
@ -362,8 +362,8 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
for(;;) { for(;;) {
if (url_feof(pb)) if (url_feof(pb))
goto fail; goto fail;
tag = get_le32(pb); tag = avio_rl32(pb);
size = get_le32(pb); size = avio_rl32(pb);
print_tag("tag", tag, size); print_tag("tag", tag, size);
@ -371,7 +371,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
case MKTAG('L', 'I', 'S', 'T'): case MKTAG('L', 'I', 'S', 'T'):
list_end = url_ftell(pb) + size; list_end = url_ftell(pb) + size;
/* Ignored, except at start of video packets. */ /* Ignored, except at start of video packets. */
tag1 = get_le32(pb); tag1 = avio_rl32(pb);
print_tag("list", tag1, 0); print_tag("list", tag1, 0);
@ -391,7 +391,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
case MKTAG('I', 'D', 'I', 'T'): { case MKTAG('I', 'D', 'I', 'T'): {
unsigned char date[64] = {0}; unsigned char date[64] = {0};
size += (size & 1); size += (size & 1);
size -= get_buffer(pb, date, FFMIN(size, sizeof(date)-1)); size -= avio_read(pb, date, FFMIN(size, sizeof(date)-1));
url_fskip(pb, size); url_fskip(pb, size);
avi_metadata_creation_time(&s->metadata, date); avi_metadata_creation_time(&s->metadata, date);
break; break;
@ -405,24 +405,24 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
case MKTAG('a', 'v', 'i', 'h'): case MKTAG('a', 'v', 'i', 'h'):
/* AVI header */ /* AVI header */
/* using frame_period is bad idea */ /* using frame_period is bad idea */
frame_period = get_le32(pb); frame_period = avio_rl32(pb);
bit_rate = get_le32(pb) * 8; bit_rate = avio_rl32(pb) * 8;
get_le32(pb); avio_rl32(pb);
avi->non_interleaved |= get_le32(pb) & AVIF_MUSTUSEINDEX; avi->non_interleaved |= avio_rl32(pb) & AVIF_MUSTUSEINDEX;
url_fskip(pb, 2 * 4); url_fskip(pb, 2 * 4);
get_le32(pb); avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
avih_width=get_le32(pb); avih_width=avio_rl32(pb);
avih_height=get_le32(pb); avih_height=avio_rl32(pb);
url_fskip(pb, size - 10 * 4); url_fskip(pb, size - 10 * 4);
break; break;
case MKTAG('s', 't', 'r', 'h'): case MKTAG('s', 't', 'r', 'h'):
/* stream header */ /* stream header */
tag1 = get_le32(pb); tag1 = avio_rl32(pb);
handler = get_le32(pb); /* codec tag */ handler = avio_rl32(pb); /* codec tag */
if(tag1 == MKTAG('p', 'a', 'd', 's')){ if(tag1 == MKTAG('p', 'a', 'd', 's')){
url_fskip(pb, size - 8); url_fskip(pb, size - 8);
@ -470,11 +470,11 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
} }
s->streams[0]->priv_data = ast; s->streams[0]->priv_data = ast;
url_fskip(pb, 3 * 4); url_fskip(pb, 3 * 4);
ast->scale = get_le32(pb); ast->scale = avio_rl32(pb);
ast->rate = get_le32(pb); ast->rate = avio_rl32(pb);
url_fskip(pb, 4); /* start time */ url_fskip(pb, 4); /* start time */
dv_dur = get_le32(pb); dv_dur = avio_rl32(pb);
if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) { if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {
dv_dur *= AV_TIME_BASE; dv_dur *= AV_TIME_BASE;
s->duration = av_rescale(dv_dur, ast->scale, ast->rate); s->duration = av_rescale(dv_dur, ast->scale, ast->rate);
@ -492,12 +492,12 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
assert(stream_index < s->nb_streams); assert(stream_index < s->nb_streams);
st->codec->stream_codec_tag= handler; st->codec->stream_codec_tag= handler;
get_le32(pb); /* flags */ avio_rl32(pb); /* flags */
get_le16(pb); /* priority */ avio_rl16(pb); /* priority */
get_le16(pb); /* language */ avio_rl16(pb); /* language */
get_le32(pb); /* initial frame */ avio_rl32(pb); /* initial frame */
ast->scale = get_le32(pb); ast->scale = avio_rl32(pb);
ast->rate = get_le32(pb); ast->rate = avio_rl32(pb);
if(!(ast->scale && ast->rate)){ if(!(ast->scale && ast->rate)){
av_log(s, AV_LOG_WARNING, "scale/rate is %u/%u which is invalid. (This file has been generated by broken software.)\n", ast->scale, ast->rate); av_log(s, AV_LOG_WARNING, "scale/rate is %u/%u which is invalid. (This file has been generated by broken software.)\n", ast->scale, ast->rate);
if(frame_period){ if(frame_period){
@ -510,13 +510,13 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
} }
av_set_pts_info(st, 64, ast->scale, ast->rate); av_set_pts_info(st, 64, ast->scale, ast->rate);
ast->cum_len=get_le32(pb); /* start */ ast->cum_len=avio_rl32(pb); /* start */
st->nb_frames = get_le32(pb); st->nb_frames = avio_rl32(pb);
st->start_time = 0; st->start_time = 0;
get_le32(pb); /* buffer size */ avio_rl32(pb); /* buffer size */
get_le32(pb); /* quality */ avio_rl32(pb); /* quality */
ast->sample_size = get_le32(pb); /* sample ssize */ ast->sample_size = avio_rl32(pb); /* sample ssize */
ast->cum_len *= FFMAX(1, ast->sample_size); ast->cum_len *= FFMAX(1, ast->sample_size);
// av_log(s, AV_LOG_DEBUG, "%d %d %d %d\n", ast->rate, ast->scale, ast->start, ast->sample_size); // av_log(s, AV_LOG_DEBUG, "%d %d %d %d\n", ast->rate, ast->scale, ast->start, ast->sample_size);
@ -579,11 +579,11 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
st->codec->extradata_size= 0; st->codec->extradata_size= 0;
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
get_buffer(pb, st->codec->extradata, st->codec->extradata_size); avio_read(pb, st->codec->extradata, st->codec->extradata_size);
} }
if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly
get_byte(pb); avio_r8(pb);
/* Extract palette from extradata if bpp <= 8. */ /* Extract palette from extradata if bpp <= 8. */
/* This code assumes that extradata contains only palette. */ /* This code assumes that extradata contains only palette. */
@ -675,17 +675,17 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
AVRational active, active_aspect; AVRational active, active_aspect;
st = s->streams[stream_index]; st = s->streams[stream_index];
get_le32(pb); avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
active_aspect.den= get_le16(pb); active_aspect.den= avio_rl16(pb);
active_aspect.num= get_le16(pb); active_aspect.num= avio_rl16(pb);
active.num = get_le32(pb); active.num = avio_rl32(pb);
active.den = get_le32(pb); active.den = avio_rl32(pb);
get_le32(pb); //nbFieldsPerFrame avio_rl32(pb); //nbFieldsPerFrame
if(active_aspect.num && active_aspect.den && active.num && active.den){ if(active_aspect.num && active_aspect.den && active.num && active.den){
st->sample_aspect_ratio= av_div_q(active_aspect, active); st->sample_aspect_ratio= av_div_q(active_aspect, active);
@ -756,7 +756,7 @@ static int read_gab2_sub(AVStream *st, AVPacket *pkt) {
pkt->size - 7, pkt->size - 7,
0, NULL, NULL, NULL, NULL); 0, NULL, NULL, NULL, NULL);
AVProbeData pd; AVProbeData pd;
unsigned int desc_len = get_le32(pb); unsigned int desc_len = avio_rl32(pb);
if (desc_len > pb->buf_end - pb->buf_ptr) if (desc_len > pb->buf_end - pb->buf_ptr)
goto error; goto error;
@ -766,8 +766,8 @@ static int read_gab2_sub(AVStream *st, AVPacket *pkt) {
if (*desc) if (*desc)
av_metadata_set2(&st->metadata, "title", desc, 0); av_metadata_set2(&st->metadata, "title", desc, 0);
get_le16(pb); /* flags? */ avio_rl16(pb); /* flags? */
get_le32(pb); /* data size */ avio_rl32(pb); /* data size */
pd = (AVProbeData) { .buf = pb->buf_ptr, .buf_size = pb->buf_end - pb->buf_ptr }; pd = (AVProbeData) { .buf = pb->buf_ptr, .buf_size = pb->buf_end - pb->buf_ptr };
if (!(sub_demuxer = av_probe_input_format2(&pd, 1, &score))) if (!(sub_demuxer = av_probe_input_format2(&pd, 1, &score)))
@ -994,7 +994,7 @@ resync:
for(j=0; j<7; j++) for(j=0; j<7; j++)
d[j]= d[j+1]; d[j]= d[j+1];
d[7]= get_byte(pb); d[7]= avio_r8(pb);
size= d[4] + (d[5]<<8) + (d[6]<<16) + (d[7]<<24); size= d[4] + (d[5]<<8) + (d[6]<<16) + (d[7]<<24);
@ -1065,13 +1065,13 @@ resync:
} }
if (d[2] == 'p' && d[3] == 'c' && size<=4*256+4) { if (d[2] == 'p' && d[3] == 'c' && size<=4*256+4) {
int k = get_byte(pb); int k = avio_r8(pb);
int last = (k + get_byte(pb) - 1) & 0xFF; int last = (k + avio_r8(pb) - 1) & 0xFF;
get_le16(pb); //flags avio_rl16(pb); //flags
for (; k <= last; k++) for (; k <= last; k++)
ast->pal[k] = get_be32(pb)>>8;// b + (g << 8) + (r << 16); ast->pal[k] = avio_rb32(pb)>>8;// b + (g << 8) + (r << 16);
ast->has_pal= 1; ast->has_pal= 1;
goto resync; goto resync;
} else if( ((ast->prefix_count<5 || sync+9 > i) && d[2]<128 && d[3]<128) || } else if( ((ast->prefix_count<5 || sync+9 > i) && d[2]<128 && d[3]<128) ||
@ -1123,10 +1123,10 @@ static int avi_read_idx1(AVFormatContext *s, int size)
/* Read the entries and sort them in each stream component. */ /* Read the entries and sort them in each stream component. */
for(i = 0; i < nb_index_entries; i++) { for(i = 0; i < nb_index_entries; i++) {
tag = get_le32(pb); tag = avio_rl32(pb);
flags = get_le32(pb); flags = avio_rl32(pb);
pos = get_le32(pb); pos = avio_rl32(pb);
len = get_le32(pb); len = avio_rl32(pb);
#if defined(DEBUG_SEEK) #if defined(DEBUG_SEEK)
av_log(s, AV_LOG_DEBUG, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/", av_log(s, AV_LOG_DEBUG, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/",
i, tag, flags, pos, len); i, tag, flags, pos, len);
@ -1175,7 +1175,7 @@ static int guess_ni_flag(AVFormatContext *s){
if(n >= 2){ if(n >= 2){
int64_t pos= st->index_entries[0].pos; int64_t pos= st->index_entries[0].pos;
url_fseek(s->pb, pos + 4, SEEK_SET); url_fseek(s->pb, pos + 4, SEEK_SET);
size= get_le32(s->pb); size= avio_rl32(s->pb);
if(pos + size > st->index_entries[1].pos) if(pos + size > st->index_entries[1].pos)
last_start= INT64_MAX; last_start= INT64_MAX;
} }
@ -1205,8 +1205,8 @@ static int avi_load_index(AVFormatContext *s)
for(;;) { for(;;) {
if (url_feof(pb)) if (url_feof(pb))
break; break;
tag = get_le32(pb); tag = avio_rl32(pb);
size = get_le32(pb); size = avio_rl32(pb);
#ifdef DEBUG_SEEK #ifdef DEBUG_SEEK
printf("tag=%c%c%c%c size=0x%x\n", printf("tag=%c%c%c%c size=0x%x\n",
tag & 0xff, tag & 0xff,

39
libavformat/avio.h
View File

@ -378,6 +378,25 @@ attribute_deprecated AVIOContext *av_alloc_put_byte(
int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
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));
/**
* @defgroup old_avio_funcs Old put_/get_*() functions
* @deprecated use the avio_ -prefixed functions instead.
* @{
*/
attribute_deprecated int get_buffer(AVIOContext *s, unsigned char *buf, int size);
attribute_deprecated int get_byte(AVIOContext *s);
attribute_deprecated unsigned int get_le16(AVIOContext *s);
attribute_deprecated unsigned int get_le24(AVIOContext *s);
attribute_deprecated unsigned int get_le32(AVIOContext *s);
attribute_deprecated uint64_t get_le64(AVIOContext *s);
attribute_deprecated unsigned int get_be16(AVIOContext *s);
attribute_deprecated unsigned int get_be24(AVIOContext *s);
attribute_deprecated unsigned int get_be32(AVIOContext *s);
attribute_deprecated uint64_t get_be64(AVIOContext *s);
/**
* @}
*/
#endif #endif
AVIOContext *avio_alloc_context( AVIOContext *avio_alloc_context(
@ -477,7 +496,7 @@ void put_flush_packet(AVIOContext *s);
* Read size bytes from AVIOContext into buf. * Read size bytes from AVIOContext into buf.
* @return number of bytes read or AVERROR * @return number of bytes read or AVERROR
*/ */
int get_buffer(AVIOContext *s, unsigned char *buf, int size); int avio_read(AVIOContext *s, unsigned char *buf, int size);
/** /**
* Read size bytes from AVIOContext into buf. * Read size bytes from AVIOContext into buf.
@ -489,11 +508,11 @@ int get_partial_buffer(AVIOContext *s, unsigned char *buf, int size);
/** @note return 0 if EOF, so you cannot use it if EOF handling is /** @note return 0 if EOF, so you cannot use it if EOF handling is
necessary */ necessary */
int get_byte(AVIOContext *s); int avio_r8 (AVIOContext *s);
unsigned int get_le24(AVIOContext *s); unsigned int avio_rl16(AVIOContext *s);
unsigned int get_le32(AVIOContext *s); unsigned int avio_rl24(AVIOContext *s);
uint64_t get_le64(AVIOContext *s); unsigned int avio_rl32(AVIOContext *s);
unsigned int get_le16(AVIOContext *s); uint64_t avio_rl64(AVIOContext *s);
/** /**
* Read a UTF-16 string from pb and convert it to UTF-8. * Read a UTF-16 string from pb and convert it to UTF-8.
@ -505,10 +524,10 @@ int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen);
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen); int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen);
char *get_strz(AVIOContext *s, char *buf, int maxlen); char *get_strz(AVIOContext *s, char *buf, int maxlen);
unsigned int get_be16(AVIOContext *s); unsigned int avio_rb16(AVIOContext *s);
unsigned int get_be24(AVIOContext *s); unsigned int avio_rb24(AVIOContext *s);
unsigned int get_be32(AVIOContext *s); unsigned int avio_rb32(AVIOContext *s);
uint64_t get_be64(AVIOContext *s); uint64_t avio_rb64(AVIOContext *s);
uint64_t ff_get_v(AVIOContext *bc); uint64_t ff_get_v(AVIOContext *bc);

88
libavformat/aviobuf.c
View File

@ -298,6 +298,32 @@ void put_strz(AVIOContext *s, const char *str)
{ {
avio_put_str(s, str); avio_put_str(s, str);
} }
#define GET(name, type) \
type get_be ##name(AVIOContext *s) \
{\
return avio_rb ##name(s);\
}\
type get_le ##name(AVIOContext *s) \
{\
return avio_rl ##name(s);\
}
GET(16, unsigned int)
GET(24, unsigned int)
GET(32, unsigned int)
GET(64, uint64_t)
#undef GET
int get_byte(AVIOContext *s)
{
return avio_r8(s);
}
int get_buffer(AVIOContext *s, unsigned char *buf, int size)
{
return avio_read(s, buf, size);
}
#endif #endif
int avio_put_str(AVIOContext *s, const char *str) int avio_put_str(AVIOContext *s, const char *str)
@ -457,7 +483,7 @@ void init_checksum(AVIOContext *s,
} }
/* XXX: put an inline version */ /* XXX: put an inline version */
int get_byte(AVIOContext *s) int avio_r8(AVIOContext *s)
{ {
if (s->buf_ptr >= s->buf_end) if (s->buf_ptr >= s->buf_end)
fill_buffer(s); fill_buffer(s);
@ -475,7 +501,7 @@ int url_fgetc(AVIOContext *s)
return URL_EOF; return URL_EOF;
} }
int get_buffer(AVIOContext *s, unsigned char *buf, int size) int avio_read(AVIOContext *s, unsigned char *buf, int size)
{ {
int len, size1; int len, size1;
@ -545,58 +571,58 @@ int get_partial_buffer(AVIOContext *s, unsigned char *buf, int size)
return len; return len;
} }
unsigned int get_le16(AVIOContext *s) unsigned int avio_rl16(AVIOContext *s)
{ {
unsigned int val; unsigned int val;
val = get_byte(s); val = avio_r8(s);
val |= get_byte(s) << 8; val |= avio_r8(s) << 8;
return val; return val;
} }
unsigned int get_le24(AVIOContext *s) unsigned int avio_rl24(AVIOContext *s)
{ {
unsigned int val; unsigned int val;
val = get_le16(s); val = avio_rl16(s);
val |= get_byte(s) << 16; val |= avio_r8(s) << 16;
return val; return val;
} }
unsigned int get_le32(AVIOContext *s) unsigned int avio_rl32(AVIOContext *s)
{ {
unsigned int val; unsigned int val;
val = get_le16(s); val = avio_rl16(s);
val |= get_le16(s) << 16; val |= avio_rl16(s) << 16;
return val; return val;
} }
uint64_t get_le64(AVIOContext *s) uint64_t avio_rl64(AVIOContext *s)
{ {
uint64_t val; uint64_t val;
val = (uint64_t)get_le32(s); val = (uint64_t)avio_rl32(s);
val |= (uint64_t)get_le32(s) << 32; val |= (uint64_t)avio_rl32(s) << 32;
return val; return val;
} }
unsigned int get_be16(AVIOContext *s) unsigned int avio_rb16(AVIOContext *s)
{ {
unsigned int val; unsigned int val;
val = get_byte(s) << 8; val = avio_r8(s) << 8;
val |= get_byte(s); val |= avio_r8(s);
return val; return val;
} }
unsigned int get_be24(AVIOContext *s) unsigned int avio_rb24(AVIOContext *s)
{ {
unsigned int val; unsigned int val;
val = get_be16(s) << 8; val = avio_rb16(s) << 8;
val |= get_byte(s); val |= avio_r8(s);
return val; return val;
} }
unsigned int get_be32(AVIOContext *s) unsigned int avio_rb32(AVIOContext *s)
{ {
unsigned int val; unsigned int val;
val = get_be16(s) << 16; val = avio_rb16(s) << 16;
val |= get_be16(s); val |= avio_rb16(s);
return val; return val;
} }
@ -605,7 +631,7 @@ char *get_strz(AVIOContext *s, char *buf, int maxlen)
int i = 0; int i = 0;
char c; char c;
while ((c = get_byte(s))) { while ((c = avio_r8(s))) {
if (i < maxlen-1) if (i < maxlen-1)
buf[i++] = c; buf[i++] = c;
} }
@ -621,7 +647,7 @@ int ff_get_line(AVIOContext *s, char *buf, int maxlen)
char c; char c;
do { do {
c = get_byte(s); c = avio_r8(s);
if (c && i < maxlen-1) if (c && i < maxlen-1)
buf[i++] = c; buf[i++] = c;
} while (c != '\n' && c); } while (c != '\n' && c);
@ -647,16 +673,16 @@ int ff_get_line(AVIOContext *s, char *buf, int maxlen)
return ret;\ return ret;\
}\ }\
GET_STR16(le, get_le16) GET_STR16(le, avio_rl16)
GET_STR16(be, get_be16) GET_STR16(be, avio_rb16)
#undef GET_STR16 #undef GET_STR16
uint64_t get_be64(AVIOContext *s) uint64_t avio_rb64(AVIOContext *s)
{ {
uint64_t val; uint64_t val;
val = (uint64_t)get_be32(s) << 32; val = (uint64_t)avio_rb32(s) << 32;
val |= (uint64_t)get_be32(s); val |= (uint64_t)avio_rb32(s);
return val; return val;
} }
@ -665,7 +691,7 @@ uint64_t ff_get_v(AVIOContext *bc){
int tmp; int tmp;
do{ do{
tmp = get_byte(bc); tmp = avio_r8(bc);
val= (val<<7) + (tmp&127); val= (val<<7) + (tmp&127);
}while(tmp&128); }while(tmp&128);
return val; return val;

24
libavformat/avs.c
View File

@ -62,11 +62,11 @@ static int avs_read_header(AVFormatContext * s, AVFormatParameters * ap)
s->ctx_flags |= AVFMTCTX_NOHEADER; s->ctx_flags |= AVFMTCTX_NOHEADER;
url_fskip(s->pb, 4); url_fskip(s->pb, 4);
avs->width = get_le16(s->pb); avs->width = avio_rl16(s->pb);
avs->height = get_le16(s->pb); avs->height = avio_rl16(s->pb);
avs->bits_per_sample = get_le16(s->pb); avs->bits_per_sample = avio_rl16(s->pb);
avs->fps = get_le16(s->pb); avs->fps = avio_rl16(s->pb);
avs->nb_frames = get_le32(s->pb); avs->nb_frames = avio_rl32(s->pb);
avs->remaining_frame_size = 0; avs->remaining_frame_size = 0;
avs->remaining_audio_size = 0; avs->remaining_audio_size = 0;
@ -104,7 +104,7 @@ avs_read_video_packet(AVFormatContext * s, AVPacket * pkt,
pkt->data[palette_size + 1] = type; pkt->data[palette_size + 1] = type;
pkt->data[palette_size + 2] = size & 0xFF; pkt->data[palette_size + 2] = size & 0xFF;
pkt->data[palette_size + 3] = (size >> 8) & 0xFF; pkt->data[palette_size + 3] = (size >> 8) & 0xFF;
ret = get_buffer(s->pb, pkt->data + palette_size + 4, size - 4) + 4; ret = avio_read(s->pb, pkt->data + palette_size + 4, size - 4) + 4;
if (ret < size) { if (ret < size) {
av_free_packet(pkt); av_free_packet(pkt);
return AVERROR(EIO); return AVERROR(EIO);
@ -154,20 +154,20 @@ static int avs_read_packet(AVFormatContext * s, AVPacket * pkt)
while (1) { while (1) {
if (avs->remaining_frame_size <= 0) { if (avs->remaining_frame_size <= 0) {
if (!get_le16(s->pb)) /* found EOF */ if (!avio_rl16(s->pb)) /* found EOF */
return AVERROR(EIO); return AVERROR(EIO);
avs->remaining_frame_size = get_le16(s->pb) - 4; avs->remaining_frame_size = avio_rl16(s->pb) - 4;
} }
while (avs->remaining_frame_size > 0) { while (avs->remaining_frame_size > 0) {
sub_type = get_byte(s->pb); sub_type = avio_r8(s->pb);
type = get_byte(s->pb); type = avio_r8(s->pb);
size = get_le16(s->pb); size = avio_rl16(s->pb);
avs->remaining_frame_size -= size; avs->remaining_frame_size -= size;
switch (type) { switch (type) {
case AVS_PALETTE: case AVS_PALETTE:
ret = get_buffer(s->pb, palette, size - 4); ret = avio_read(s->pb, palette, size - 4);
if (ret < size - 4) if (ret < size - 4)
return AVERROR(EIO); return AVERROR(EIO);
palette_size = size; palette_size = size;

30
libavformat/bethsoftvid.c
View File

@ -68,7 +68,7 @@ static int vid_read_header(AVFormatContext *s,
* int16s: always_512, nframes, width, height, delay, always_14 * int16s: always_512, nframes, width, height, delay, always_14
*/ */
url_fseek(pb, 5, SEEK_CUR); url_fseek(pb, 5, SEEK_CUR);
vid->nframes = get_le16(pb); vid->nframes = avio_rl16(pb);
stream = av_new_stream(s, 0); stream = av_new_stream(s, 0);
if (!stream) if (!stream)
@ -76,11 +76,11 @@ static int vid_read_header(AVFormatContext *s,
av_set_pts_info(stream, 32, 1, 60); // 16 ms increments, i.e. 60 fps av_set_pts_info(stream, 32, 1, 60); // 16 ms increments, i.e. 60 fps
stream->codec->codec_type = AVMEDIA_TYPE_VIDEO; stream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
stream->codec->codec_id = CODEC_ID_BETHSOFTVID; stream->codec->codec_id = CODEC_ID_BETHSOFTVID;
stream->codec->width = get_le16(pb); stream->codec->width = avio_rl16(pb);
stream->codec->height = get_le16(pb); stream->codec->height = avio_rl16(pb);
stream->codec->pix_fmt = PIX_FMT_PAL8; stream->codec->pix_fmt = PIX_FMT_PAL8;
vid->bethsoft_global_delay = get_le16(pb); vid->bethsoft_global_delay = avio_rl16(pb);
get_le16(pb); avio_rl16(pb);
// done with video codec, set up audio codec // done with video codec, set up audio codec
stream = av_new_stream(s, 0); stream = av_new_stream(s, 0);
@ -117,11 +117,11 @@ static int read_frame(BVID_DemuxContext *vid, AVIOContext *pb, AVPacket *pkt,
vidbuf_start[vidbuf_nbytes++] = block_type; vidbuf_start[vidbuf_nbytes++] = block_type;
// get the video delay (next int16), and set the presentation time // get the video delay (next int16), and set the presentation time
vid->video_pts += vid->bethsoft_global_delay + get_le16(pb); vid->video_pts += vid->bethsoft_global_delay + avio_rl16(pb);
// set the y offset if it exists (decoder header data should be in data section) // set the y offset if it exists (decoder header data should be in data section)
if(block_type == VIDEO_YOFF_P_FRAME){ if(block_type == VIDEO_YOFF_P_FRAME){
if(get_buffer(pb, &vidbuf_start[vidbuf_nbytes], 2) != 2) if(avio_read(pb, &vidbuf_start[vidbuf_nbytes], 2) != 2)
goto fail; goto fail;
vidbuf_nbytes += 2; vidbuf_nbytes += 2;
} }
@ -131,21 +131,21 @@ static int read_frame(BVID_DemuxContext *vid, AVIOContext *pb, AVPacket *pkt,
if(!vidbuf_start) if(!vidbuf_start)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
code = get_byte(pb); code = avio_r8(pb);
vidbuf_start[vidbuf_nbytes++] = code; vidbuf_start[vidbuf_nbytes++] = code;
if(code >= 0x80){ // rle sequence if(code >= 0x80){ // rle sequence
if(block_type == VIDEO_I_FRAME) if(block_type == VIDEO_I_FRAME)
vidbuf_start[vidbuf_nbytes++] = get_byte(pb); vidbuf_start[vidbuf_nbytes++] = avio_r8(pb);
} else if(code){ // plain sequence } else if(code){ // plain sequence
if(get_buffer(pb, &vidbuf_start[vidbuf_nbytes], code) != code) if(avio_read(pb, &vidbuf_start[vidbuf_nbytes], code) != code)
goto fail; goto fail;
vidbuf_nbytes += code; vidbuf_nbytes += code;
} }
bytes_copied += code & 0x7F; bytes_copied += code & 0x7F;
if(bytes_copied == npixels){ // sometimes no stop character is given, need to keep track of bytes copied if(bytes_copied == npixels){ // sometimes no stop character is given, need to keep track of bytes copied
// may contain a 0 byte even if read all pixels // may contain a 0 byte even if read all pixels
if(get_byte(pb)) if(avio_r8(pb))
url_fseek(pb, -1, SEEK_CUR); url_fseek(pb, -1, SEEK_CUR);
break; break;
} }
@ -182,7 +182,7 @@ static int vid_read_packet(AVFormatContext *s,
if(vid->is_finished || url_feof(pb)) if(vid->is_finished || url_feof(pb))
return AVERROR(EIO); return AVERROR(EIO);
block_type = get_byte(pb); block_type = avio_r8(pb);
switch(block_type){ switch(block_type){
case PALETTE_BLOCK: case PALETTE_BLOCK:
url_fseek(pb, -1, SEEK_CUR); // include block type url_fseek(pb, -1, SEEK_CUR); // include block type
@ -195,12 +195,12 @@ static int vid_read_packet(AVFormatContext *s,
return ret_value; return ret_value;
case FIRST_AUDIO_BLOCK: case FIRST_AUDIO_BLOCK:
get_le16(pb); avio_rl16(pb);
// soundblaster DAC used for sample rate, as on specification page (link above) // soundblaster DAC used for sample rate, as on specification page (link above)
s->streams[1]->codec->sample_rate = 1000000 / (256 - get_byte(pb)); s->streams[1]->codec->sample_rate = 1000000 / (256 - avio_r8(pb));
s->streams[1]->codec->bit_rate = s->streams[1]->codec->channels * s->streams[1]->codec->sample_rate * s->streams[1]->codec->bits_per_coded_sample; s->streams[1]->codec->bit_rate = s->streams[1]->codec->channels * s->streams[1]->codec->sample_rate * s->streams[1]->codec->bits_per_coded_sample;
case AUDIO_BLOCK: case AUDIO_BLOCK:
audio_length = get_le16(pb); audio_length = avio_rl16(pb);
ret_value = av_get_packet(pb, pkt, audio_length); ret_value = av_get_packet(pb, pkt, audio_length);
pkt->stream_index = 1; pkt->stream_index = 1;
return ret_value != audio_length ? AVERROR(EIO) : ret_value; return ret_value != audio_length ? AVERROR(EIO) : ret_value;

32
libavformat/bfi.c
View File

@ -66,24 +66,24 @@ static int bfi_read_header(AVFormatContext * s, AVFormatParameters * ap)
/* Set the total number of frames. */ /* Set the total number of frames. */
url_fskip(pb, 8); url_fskip(pb, 8);
chunk_header = get_le32(pb); chunk_header = avio_rl32(pb);
bfi->nframes = get_le32(pb); bfi->nframes = avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
fps = get_le32(pb); fps = avio_rl32(pb);
url_fskip(pb, 12); url_fskip(pb, 12);
vstream->codec->width = get_le32(pb); vstream->codec->width = avio_rl32(pb);
vstream->codec->height = get_le32(pb); vstream->codec->height = avio_rl32(pb);
/*Load the palette to extradata */ /*Load the palette to extradata */
url_fskip(pb, 8); url_fskip(pb, 8);
vstream->codec->extradata = av_malloc(768); vstream->codec->extradata = av_malloc(768);
vstream->codec->extradata_size = 768; vstream->codec->extradata_size = 768;
get_buffer(pb, vstream->codec->extradata, avio_read(pb, vstream->codec->extradata,
vstream->codec->extradata_size); vstream->codec->extradata_size);
astream->codec->sample_rate = get_le32(pb); astream->codec->sample_rate = avio_rl32(pb);
/* Set up the video codec... */ /* Set up the video codec... */
av_set_pts_info(vstream, 32, 1, fps); av_set_pts_info(vstream, 32, 1, fps);
@ -119,14 +119,14 @@ static int bfi_read_packet(AVFormatContext * s, AVPacket * pkt)
while(state != MKTAG('S','A','V','I')){ while(state != MKTAG('S','A','V','I')){
if (url_feof(pb)) if (url_feof(pb))
return AVERROR(EIO); return AVERROR(EIO);
state = 256*state + get_byte(pb); state = 256*state + avio_r8(pb);
} }
/* Now that the chunk's location is confirmed, we proceed... */ /* Now that the chunk's location is confirmed, we proceed... */
chunk_size = get_le32(pb); chunk_size = avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
audio_offset = get_le32(pb); audio_offset = avio_rl32(pb);
get_le32(pb); avio_rl32(pb);
video_offset = get_le32(pb); video_offset = avio_rl32(pb);
audio_size = video_offset - audio_offset; audio_size = video_offset - audio_offset;
bfi->video_size = chunk_size - video_offset; bfi->video_size = chunk_size - video_offset;

30
libavformat/bink.c
View File

@ -82,17 +82,17 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
if (!vst) if (!vst)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
vst->codec->codec_tag = get_le32(pb); vst->codec->codec_tag = avio_rl32(pb);
bink->file_size = get_le32(pb) + 8; bink->file_size = avio_rl32(pb) + 8;
vst->duration = get_le32(pb); vst->duration = avio_rl32(pb);
if (vst->duration > 1000000) { if (vst->duration > 1000000) {
av_log(s, AV_LOG_ERROR, "invalid header: more than 1000000 frames\n"); av_log(s, AV_LOG_ERROR, "invalid header: more than 1000000 frames\n");
return AVERROR(EIO); return AVERROR(EIO);
} }
if (get_le32(pb) > bink->file_size) { if (avio_rl32(pb) > bink->file_size) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"invalid header: largest frame size greater than file size\n"); "invalid header: largest frame size greater than file size\n");
return AVERROR(EIO); return AVERROR(EIO);
@ -100,11 +100,11 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
url_fskip(pb, 4); url_fskip(pb, 4);
vst->codec->width = get_le32(pb); vst->codec->width = avio_rl32(pb);
vst->codec->height = get_le32(pb); vst->codec->height = avio_rl32(pb);
fps_num = get_le32(pb); fps_num = avio_rl32(pb);
fps_den = get_le32(pb); fps_den = avio_rl32(pb);
if (fps_num == 0 || fps_den == 0) { if (fps_num == 0 || fps_den == 0) {
av_log(s, AV_LOG_ERROR, "invalid header: invalid fps (%d/%d)\n", fps_num, fps_den); av_log(s, AV_LOG_ERROR, "invalid header: invalid fps (%d/%d)\n", fps_num, fps_den);
return AVERROR(EIO); return AVERROR(EIO);
@ -115,9 +115,9 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
vst->codec->codec_id = CODEC_ID_BINKVIDEO; vst->codec->codec_id = CODEC_ID_BINKVIDEO;
vst->codec->extradata = av_mallocz(4 + FF_INPUT_BUFFER_PADDING_SIZE); vst->codec->extradata = av_mallocz(4 + FF_INPUT_BUFFER_PADDING_SIZE);
vst->codec->extradata_size = 4; vst->codec->extradata_size = 4;
get_buffer(pb, vst->codec->extradata, 4); avio_read(pb, vst->codec->extradata, 4);
bink->num_audio_tracks = get_le32(pb); bink->num_audio_tracks = avio_rl32(pb);
if (bink->num_audio_tracks > BINK_MAX_AUDIO_TRACKS) { if (bink->num_audio_tracks > BINK_MAX_AUDIO_TRACKS) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
@ -135,9 +135,9 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO; ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_tag = 0; ast->codec->codec_tag = 0;
ast->codec->sample_rate = get_le16(pb); ast->codec->sample_rate = avio_rl16(pb);
av_set_pts_info(ast, 64, 1, ast->codec->sample_rate); av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
flags = get_le16(pb); flags = avio_rl16(pb);
ast->codec->codec_id = flags & BINK_AUD_USEDCT ? ast->codec->codec_id = flags & BINK_AUD_USEDCT ?
CODEC_ID_BINKAUDIO_DCT : CODEC_ID_BINKAUDIO_RDFT; CODEC_ID_BINKAUDIO_DCT : CODEC_ID_BINKAUDIO_RDFT;
ast->codec->channels = flags & BINK_AUD_STEREO ? 2 : 1; ast->codec->channels = flags & BINK_AUD_STEREO ? 2 : 1;
@ -147,14 +147,14 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
} }
/* frame index table */ /* frame index table */
next_pos = get_le32(pb); next_pos = avio_rl32(pb);
for (i = 0; i < vst->duration; i++) { for (i = 0; i < vst->duration; i++) {
pos = next_pos; pos = next_pos;
if (i == vst->duration - 1) { if (i == vst->duration - 1) {
next_pos = bink->file_size; next_pos = bink->file_size;
keyframe = 0; keyframe = 0;
} else { } else {
next_pos = get_le32(pb); next_pos = avio_rl32(pb);
keyframe = pos & 1; keyframe = pos & 1;
} }
pos &= ~1; pos &= ~1;
@ -201,7 +201,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
} }
while (bink->current_track < bink->num_audio_tracks) { while (bink->current_track < bink->num_audio_tracks) {
uint32_t audio_size = get_le32(pb); uint32_t audio_size = avio_rl32(pb);
if (audio_size > bink->remain_packet_size - 4) { if (audio_size > bink->remain_packet_size - 4) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"frame %"PRId64": audio size in header (%u) > size of packet left (%u)\n", "frame %"PRId64": audio size in header (%u) > size of packet left (%u)\n",

18
libavformat/c93.c
View File

@ -66,9 +66,9 @@ static int read_header(AVFormatContext *s,
int framecount = 0; int framecount = 0;
for (i = 0; i < 512; i++) { for (i = 0; i < 512; i++) {
c93->block_records[i].index = get_le16(pb); c93->block_records[i].index = avio_rl16(pb);
c93->block_records[i].length = get_byte(pb); c93->block_records[i].length = avio_r8(pb);
c93->block_records[i].frames = get_byte(pb); c93->block_records[i].frames = avio_r8(pb);
if (c93->block_records[i].frames > 32) { if (c93->block_records[i].frames > 32) {
av_log(s, AV_LOG_ERROR, "too many frames in block\n"); av_log(s, AV_LOG_ERROR, "too many frames in block\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -114,7 +114,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
if (c93->next_pkt_is_audio) { if (c93->next_pkt_is_audio) {
c93->current_frame++; c93->current_frame++;
c93->next_pkt_is_audio = 0; c93->next_pkt_is_audio = 0;
datasize = get_le16(pb); datasize = avio_rl16(pb);
if (datasize > 42) { if (datasize > 42) {
if (!c93->audio) { if (!c93->audio) {
c93->audio = av_new_stream(s, 1); c93->audio = av_new_stream(s, 1);
@ -142,13 +142,13 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
if (c93->current_frame == 0) { if (c93->current_frame == 0) {
url_fseek(pb, br->index * 2048, SEEK_SET); url_fseek(pb, br->index * 2048, SEEK_SET);
for (i = 0; i < 32; i++) { for (i = 0; i < 32; i++) {
c93->frame_offsets[i] = get_le32(pb); c93->frame_offsets[i] = avio_rl32(pb);
} }
} }
url_fseek(pb,br->index * 2048 + url_fseek(pb,br->index * 2048 +
c93->frame_offsets[c93->current_frame], SEEK_SET); c93->frame_offsets[c93->current_frame], SEEK_SET);
datasize = get_le16(pb); /* video frame size */ datasize = avio_rl16(pb); /* video frame size */
ret = av_new_packet(pkt, datasize + 768 + 1); ret = av_new_packet(pkt, datasize + 768 + 1);
if (ret < 0) if (ret < 0)
@ -156,13 +156,13 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
pkt->data[0] = 0; pkt->data[0] = 0;
pkt->size = datasize + 1; pkt->size = datasize + 1;
ret = get_buffer(pb, pkt->data + 1, datasize); ret = avio_read(pb, pkt->data + 1, datasize);
if (ret < datasize) { if (ret < datasize) {
ret = AVERROR(EIO); ret = AVERROR(EIO);
goto fail; goto fail;
} }
datasize = get_le16(pb); /* palette size */ datasize = avio_rl16(pb); /* palette size */
if (datasize) { if (datasize) {
if (datasize != 768) { if (datasize != 768) {
av_log(s, AV_LOG_ERROR, "invalid palette size %u\n", datasize); av_log(s, AV_LOG_ERROR, "invalid palette size %u\n", datasize);
@ -170,7 +170,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
goto fail; goto fail;
} }
pkt->data[0] |= C93_HAS_PALETTE; pkt->data[0] |= C93_HAS_PALETTE;
ret = get_buffer(pb, pkt->data + pkt->size, datasize); ret = avio_read(pb, pkt->data + pkt->size, datasize);
if (ret < datasize) { if (ret < datasize) {
ret = AVERROR(EIO); ret = AVERROR(EIO);
goto fail; goto fail;

36
libavformat/cafdec.c
View File

@ -65,14 +65,14 @@ static int read_desc_chunk(AVFormatContext *s)
/* parse format description */ /* parse format description */
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->sample_rate = av_int2dbl(get_be64(pb)); st->codec->sample_rate = av_int2dbl(avio_rb64(pb));
st->codec->codec_tag = get_be32(pb); st->codec->codec_tag = avio_rb32(pb);
flags = get_be32(pb); flags = avio_rb32(pb);
caf->bytes_per_packet = get_be32(pb); caf->bytes_per_packet = avio_rb32(pb);
st->codec->block_align = caf->bytes_per_packet; st->codec->block_align = caf->bytes_per_packet;
caf->frames_per_packet = get_be32(pb); caf->frames_per_packet = avio_rb32(pb);
st->codec->channels = get_be32(pb); st->codec->channels = avio_rb32(pb);
st->codec->bits_per_coded_sample = get_be32(pb); st->codec->bits_per_coded_sample = avio_rb32(pb);
/* calculate bit rate for constant size packets */ /* calculate bit rate for constant size packets */
if (caf->frames_per_packet > 0 && caf->bytes_per_packet > 0) { if (caf->frames_per_packet > 0 && caf->bytes_per_packet > 0) {
@ -127,14 +127,14 @@ static int read_kuki_chunk(AVFormatContext *s, int64_t size)
st->codec->extradata = av_mallocz(ALAC_HEADER + FF_INPUT_BUFFER_PADDING_SIZE); st->codec->extradata = av_mallocz(ALAC_HEADER + FF_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codec->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
get_buffer(pb, st->codec->extradata, ALAC_HEADER); avio_read(pb, st->codec->extradata, ALAC_HEADER);
st->codec->extradata_size = ALAC_HEADER; st->codec->extradata_size = ALAC_HEADER;
url_fskip(pb, size - ALAC_PREAMBLE - ALAC_HEADER); url_fskip(pb, size - ALAC_PREAMBLE - ALAC_HEADER);
} else { } else {
st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE); st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codec->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
get_buffer(pb, st->codec->extradata, size); avio_read(pb, st->codec->extradata, size);
st->codec->extradata_size = size; st->codec->extradata_size = size;
} }
@ -152,13 +152,13 @@ static int read_pakt_chunk(AVFormatContext *s, int64_t size)
ccount = url_ftell(pb); ccount = url_ftell(pb);
num_packets = get_be64(pb); num_packets = avio_rb64(pb);
if (num_packets < 0 || INT32_MAX / sizeof(AVIndexEntry) < num_packets) if (num_packets < 0 || INT32_MAX / sizeof(AVIndexEntry) < num_packets)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
st->nb_frames = get_be64(pb); /* valid frames */ st->nb_frames = avio_rb64(pb); /* valid frames */
st->nb_frames += get_be32(pb); /* priming frames */ st->nb_frames += avio_rb32(pb); /* priming frames */
st->nb_frames += get_be32(pb); /* remainder frames */ st->nb_frames += avio_rb32(pb); /* remainder frames */
st->duration = 0; st->duration = 0;
for (i = 0; i < num_packets; i++) { for (i = 0; i < num_packets; i++) {
@ -181,7 +181,7 @@ static void read_info_chunk(AVFormatContext *s, int64_t size)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
unsigned int i; unsigned int i;
unsigned int nb_entries = get_be32(pb); unsigned int nb_entries = avio_rb32(pb);
for (i = 0; i < nb_entries; i++) { for (i = 0; i < nb_entries; i++) {
char key[32]; char key[32];
char value[1024]; char value[1024];
@ -204,11 +204,11 @@ static int read_header(AVFormatContext *s,
url_fskip(pb, 8); /* magic, version, file flags */ url_fskip(pb, 8); /* magic, version, file flags */
/* audio description chunk */ /* audio description chunk */
if (get_be32(pb) != MKBETAG('d','e','s','c')) { if (avio_rb32(pb) != MKBETAG('d','e','s','c')) {
av_log(s, AV_LOG_ERROR, "desc chunk not present\n"); av_log(s, AV_LOG_ERROR, "desc chunk not present\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
size = get_be64(pb); size = avio_rb64(pb);
if (size != 32) if (size != 32)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -226,8 +226,8 @@ static int read_header(AVFormatContext *s,
if (found_data && (caf->data_size < 0 || url_is_streamed(pb))) if (found_data && (caf->data_size < 0 || url_is_streamed(pb)))
break; break;
tag = get_be32(pb); tag = avio_rb32(pb);
size = get_be64(pb); size = avio_rb64(pb);
if (url_feof(pb)) if (url_feof(pb))
break; break;

4
libavformat/daud.c
View File

@ -40,8 +40,8 @@ static int daud_packet(AVFormatContext *s, AVPacket *pkt) {
int ret, size; int ret, size;
if (url_feof(pb)) if (url_feof(pb))
return AVERROR(EIO); return AVERROR(EIO);
size = get_be16(pb); size = avio_rb16(pb);
get_be16(pb); // unknown avio_rb16(pb); // unknown
ret = av_get_packet(pb, pkt, size); ret = av_get_packet(pb, pkt, size);
pkt->stream_index = 0; pkt->stream_index = 0;
return ret; return ret;

30
libavformat/dsicin.c
View File

@ -73,16 +73,16 @@ static int cin_probe(AVProbeData *p)
static int cin_read_file_header(CinDemuxContext *cin, AVIOContext *pb) { static int cin_read_file_header(CinDemuxContext *cin, AVIOContext *pb) {
CinFileHeader *hdr = &cin->file_header; CinFileHeader *hdr = &cin->file_header;
if (get_le32(pb) != 0x55AA0000) if (avio_rl32(pb) != 0x55AA0000)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
hdr->video_frame_size = get_le32(pb); hdr->video_frame_size = avio_rl32(pb);
hdr->video_frame_width = get_le16(pb); hdr->video_frame_width = avio_rl16(pb);
hdr->video_frame_height = get_le16(pb); hdr->video_frame_height = avio_rl16(pb);
hdr->audio_frequency = get_le32(pb); hdr->audio_frequency = avio_rl32(pb);
hdr->audio_bits = get_byte(pb); hdr->audio_bits = avio_r8(pb);
hdr->audio_stereo = get_byte(pb); hdr->audio_stereo = avio_r8(pb);
hdr->audio_frame_size = get_le16(pb); hdr->audio_frame_size = avio_rl16(pb);
if (hdr->audio_frequency != 22050 || hdr->audio_bits != 16 || hdr->audio_stereo != 0) if (hdr->audio_frequency != 22050 || hdr->audio_bits != 16 || hdr->audio_stereo != 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -141,16 +141,16 @@ static int cin_read_header(AVFormatContext *s, AVFormatParameters *ap)
static int cin_read_frame_header(CinDemuxContext *cin, AVIOContext *pb) { static int cin_read_frame_header(CinDemuxContext *cin, AVIOContext *pb) {
CinFrameHeader *hdr = &cin->frame_header; CinFrameHeader *hdr = &cin->frame_header;
hdr->video_frame_type = get_byte(pb); hdr->video_frame_type = avio_r8(pb);
hdr->audio_frame_type = get_byte(pb); hdr->audio_frame_type = avio_r8(pb);
hdr->pal_colors_count = get_le16(pb); hdr->pal_colors_count = avio_rl16(pb);
hdr->video_frame_size = get_le32(pb); hdr->video_frame_size = avio_rl32(pb);
hdr->audio_frame_size = get_le32(pb); hdr->audio_frame_size = avio_rl32(pb);
if (url_feof(pb) || url_ferror(pb)) if (url_feof(pb) || url_ferror(pb))
return AVERROR(EIO); return AVERROR(EIO);
if (get_le32(pb) != 0xAA55AA55) if (avio_rl32(pb) != 0xAA55AA55)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
return 0; return 0;
@ -191,7 +191,7 @@ static int cin_read_packet(AVFormatContext *s, AVPacket *pkt)
pkt->data[2] = hdr->pal_colors_count >> 8; pkt->data[2] = hdr->pal_colors_count >> 8;
pkt->data[3] = hdr->video_frame_type; pkt->data[3] = hdr->video_frame_type;
ret = get_buffer(pb, &pkt->data[4], pkt_size); ret = avio_read(pb, &pkt->data[4], pkt_size);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_free_packet(pkt);
return ret; return ret;

10
libavformat/dv.c
View File

@ -410,7 +410,7 @@ static int dv_read_header(AVFormatContext *s,
if (!c->dv_demux) if (!c->dv_demux)
return -1; return -1;
state = get_be32(s->pb); state = avio_rb32(s->pb);
while ((state & 0xffffff7f) != 0x1f07003f) { while ((state & 0xffffff7f) != 0x1f07003f) {
if (url_feof(s->pb)) { if (url_feof(s->pb)) {
av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n"); av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");
@ -420,14 +420,14 @@ static int dv_read_header(AVFormatContext *s,
marker_pos = url_ftell(s->pb); marker_pos = url_ftell(s->pb);
if (state == 0xff3f0701 && url_ftell(s->pb) - marker_pos == 80) { if (state == 0xff3f0701 && url_ftell(s->pb) - marker_pos == 80) {
url_fseek(s->pb, -163, SEEK_CUR); url_fseek(s->pb, -163, SEEK_CUR);
state = get_be32(s->pb); state = avio_rb32(s->pb);
break; break;
} }
state = (state << 8) | get_byte(s->pb); state = (state << 8) | avio_r8(s->pb);
} }
AV_WB32(c->buf, state); AV_WB32(c->buf, state);
if (get_buffer(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) <= 0 || if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) <= 0 ||
url_fseek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0) url_fseek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0)
return AVERROR(EIO); return AVERROR(EIO);
@ -455,7 +455,7 @@ static int dv_read_packet(AVFormatContext *s, AVPacket *pkt)
if (!c->dv_demux->sys) if (!c->dv_demux->sys)
return AVERROR(EIO); return AVERROR(EIO);
size = c->dv_demux->sys->frame_size; size = c->dv_demux->sys->frame_size;
if (get_buffer(s->pb, c->buf, size) <= 0) if (avio_read(s->pb, c->buf, size) <= 0)
return AVERROR(EIO); return AVERROR(EIO);
size = dv_produce_packet(c->dv_demux, pkt, c->buf, size); size = dv_produce_packet(c->dv_demux, pkt, c->buf, size);

30
libavformat/dxa.c
View File

@ -61,17 +61,17 @@ static int dxa_read_header(AVFormatContext *s, AVFormatParameters *ap)
int num, den; int num, den;
int flags; int flags;
tag = get_le32(pb); tag = avio_rl32(pb);
if (tag != MKTAG('D', 'E', 'X', 'A')) if (tag != MKTAG('D', 'E', 'X', 'A'))
return -1; return -1;
flags = get_byte(pb); flags = avio_r8(pb);
c->frames = get_be16(pb); c->frames = avio_rb16(pb);
if(!c->frames){ if(!c->frames){
av_log(s, AV_LOG_ERROR, "File contains no frames ???\n"); av_log(s, AV_LOG_ERROR, "File contains no frames ???\n");
return -1; return -1;
} }
fps = get_be32(pb); fps = avio_rb32(pb);
if(fps > 0){ if(fps > 0){
den = 1000; den = 1000;
num = fps; num = fps;
@ -82,8 +82,8 @@ static int dxa_read_header(AVFormatContext *s, AVFormatParameters *ap)
den = 10; den = 10;
num = 1; num = 1;
} }
w = get_be16(pb); w = avio_rb16(pb);
h = get_be16(pb); h = avio_rb16(pb);
c->has_sound = 0; c->has_sound = 0;
st = av_new_stream(s, 0); st = av_new_stream(s, 0);
@ -91,13 +91,13 @@ static int dxa_read_header(AVFormatContext *s, AVFormatParameters *ap)
return -1; return -1;
// Parse WAV data header // Parse WAV data header
if(get_le32(pb) == MKTAG('W', 'A', 'V', 'E')){ if(avio_rl32(pb) == MKTAG('W', 'A', 'V', 'E')){
uint32_t size, fsize; uint32_t size, fsize;
c->has_sound = 1; c->has_sound = 1;
size = get_be32(pb); size = avio_rb32(pb);
c->vidpos = url_ftell(pb) + size; c->vidpos = url_ftell(pb) + size;
url_fskip(pb, 16); url_fskip(pb, 16);
fsize = get_le32(pb); fsize = avio_rl32(pb);
ast = av_new_stream(s, 0); ast = av_new_stream(s, 0);
if (!ast) if (!ast)
@ -105,8 +105,8 @@ static int dxa_read_header(AVFormatContext *s, AVFormatParameters *ap)
ff_get_wav_header(pb, ast->codec, fsize); ff_get_wav_header(pb, ast->codec, fsize);
// find 'data' chunk // find 'data' chunk
while(url_ftell(pb) < c->vidpos && !url_feof(pb)){ while(url_ftell(pb) < c->vidpos && !url_feof(pb)){
tag = get_le32(pb); tag = avio_rl32(pb);
fsize = get_le32(pb); fsize = avio_rl32(pb);
if(tag == MKTAG('d', 'a', 't', 'a')) break; if(tag == MKTAG('d', 'a', 't', 'a')) break;
url_fskip(pb, fsize); url_fskip(pb, fsize);
} }
@ -163,7 +163,7 @@ static int dxa_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
url_fseek(s->pb, c->vidpos, SEEK_SET); url_fseek(s->pb, c->vidpos, SEEK_SET);
while(!url_feof(s->pb) && c->frames){ while(!url_feof(s->pb) && c->frames){
get_buffer(s->pb, buf, 4); avio_read(s->pb, buf, 4);
switch(AV_RL32(buf)){ switch(AV_RL32(buf)){
case MKTAG('N', 'U', 'L', 'L'): case MKTAG('N', 'U', 'L', 'L'):
if(av_new_packet(pkt, 4 + pal_size) < 0) if(av_new_packet(pkt, 4 + pal_size) < 0)
@ -178,10 +178,10 @@ static int dxa_read_packet(AVFormatContext *s, AVPacket *pkt)
case MKTAG('C', 'M', 'A', 'P'): case MKTAG('C', 'M', 'A', 'P'):
pal_size = 768+4; pal_size = 768+4;
memcpy(pal, buf, 4); memcpy(pal, buf, 4);
get_buffer(s->pb, pal + 4, 768); avio_read(s->pb, pal + 4, 768);
break; break;
case MKTAG('F', 'R', 'A', 'M'): case MKTAG('F', 'R', 'A', 'M'):
get_buffer(s->pb, buf + 4, DXA_EXTRA_SIZE - 4); avio_read(s->pb, buf + 4, DXA_EXTRA_SIZE - 4);
size = AV_RB32(buf + 5); size = AV_RB32(buf + 5);
if(size > 0xFFFFFF){ if(size > 0xFFFFFF){
av_log(s, AV_LOG_ERROR, "Frame size is too big: %d\n", size); av_log(s, AV_LOG_ERROR, "Frame size is too big: %d\n", size);
@ -190,7 +190,7 @@ static int dxa_read_packet(AVFormatContext *s, AVPacket *pkt)
if(av_new_packet(pkt, size + DXA_EXTRA_SIZE + pal_size) < 0) if(av_new_packet(pkt, size + DXA_EXTRA_SIZE + pal_size) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
memcpy(pkt->data + pal_size, buf, DXA_EXTRA_SIZE); memcpy(pkt->data + pal_size, buf, DXA_EXTRA_SIZE);
ret = get_buffer(s->pb, pkt->data + DXA_EXTRA_SIZE + pal_size, size); ret = avio_read(s->pb, pkt->data + DXA_EXTRA_SIZE + pal_size, size);
if(ret != size){ if(ret != size){
av_free_packet(pkt); av_free_packet(pkt);
return AVERROR(EIO); return AVERROR(EIO);

4
libavformat/eacdata.c
View File

@ -51,7 +51,7 @@ static int cdata_read_header(AVFormatContext *s, AVFormatParameters *ap)
unsigned int sample_rate, header; unsigned int sample_rate, header;
AVStream *st; AVStream *st;
header = get_be16(pb); header = avio_rb16(pb);
switch (header) { switch (header) {
case 0x0400: cdata->channels = 1; break; case 0x0400: cdata->channels = 1; break;
case 0x0404: cdata->channels = 2; break; case 0x0404: cdata->channels = 2; break;
@ -61,7 +61,7 @@ static int cdata_read_header(AVFormatContext *s, AVFormatParameters *ap)
return -1; return -1;
}; };
sample_rate = get_be16(pb); sample_rate = avio_rb16(pb);
url_fskip(pb, 12); url_fskip(pb, 12);
st = av_new_stream(s, 0); st = av_new_stream(s, 0);

44
libavformat/electronicarts.c
View File

@ -82,11 +82,11 @@ static uint32_t read_arbitary(AVIOContext *pb) {
int i; int i;
uint32_t word; uint32_t word;
size = get_byte(pb); size = avio_r8(pb);
word = 0; word = 0;
for (i = 0; i < size; i++) { for (i = 0; i < size; i++) {
byte = get_byte(pb); byte = avio_r8(pb);
word <<= 8; word <<= 8;
word |= byte; word |= byte;
} }
@ -112,7 +112,7 @@ static int process_audio_header_elements(AVFormatContext *s)
while (!url_feof(pb) && inHeader) { while (!url_feof(pb) && inHeader) {
int inSubheader; int inSubheader;
uint8_t byte; uint8_t byte;
byte = get_byte(pb); byte = avio_r8(pb);
switch (byte) { switch (byte) {
case 0xFD: case 0xFD:
@ -120,7 +120,7 @@ static int process_audio_header_elements(AVFormatContext *s)
inSubheader = 1; inSubheader = 1;
while (!url_feof(pb) && inSubheader) { while (!url_feof(pb) && inSubheader) {
uint8_t subbyte; uint8_t subbyte;
subbyte = get_byte(pb); subbyte = avio_r8(pb);
switch (subbyte) { switch (subbyte) {
case 0x80: case 0x80:
@ -218,10 +218,10 @@ static int process_audio_header_eacs(AVFormatContext *s)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
int compression_type; int compression_type;
ea->sample_rate = ea->big_endian ? get_be32(pb) : get_le32(pb); ea->sample_rate = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);
ea->bytes = get_byte(pb); /* 1=8-bit, 2=16-bit */ ea->bytes = avio_r8(pb); /* 1=8-bit, 2=16-bit */
ea->num_channels = get_byte(pb); ea->num_channels = avio_r8(pb);
compression_type = get_byte(pb); compression_type = avio_r8(pb);
url_fskip(pb, 13); url_fskip(pb, 13);
switch (compression_type) { switch (compression_type) {
@ -249,9 +249,9 @@ static int process_audio_header_sead(AVFormatContext *s)
EaDemuxContext *ea = s->priv_data; EaDemuxContext *ea = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
ea->sample_rate = get_le32(pb); ea->sample_rate = avio_rl32(pb);
ea->bytes = get_le32(pb); /* 1=8-bit, 2=16-bit */ ea->bytes = avio_rl32(pb); /* 1=8-bit, 2=16-bit */
ea->num_channels = get_le32(pb); ea->num_channels = avio_rl32(pb);
ea->audio_codec = CODEC_ID_ADPCM_IMA_EA_SEAD; ea->audio_codec = CODEC_ID_ADPCM_IMA_EA_SEAD;
return 1; return 1;
@ -262,8 +262,8 @@ static int process_video_header_mdec(AVFormatContext *s)
EaDemuxContext *ea = s->priv_data; EaDemuxContext *ea = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
url_fskip(pb, 4); url_fskip(pb, 4);
ea->width = get_le16(pb); ea->width = avio_rl16(pb);
ea->height = get_le16(pb); ea->height = avio_rl16(pb);
ea->time_base = (AVRational){1,15}; ea->time_base = (AVRational){1,15};
ea->video_codec = CODEC_ID_MDEC; ea->video_codec = CODEC_ID_MDEC;
return 1; return 1;
@ -275,8 +275,8 @@ static int process_video_header_vp6(AVFormatContext *s)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
url_fskip(pb, 16); url_fskip(pb, 16);
ea->time_base.den = get_le32(pb); ea->time_base.den = avio_rl32(pb);
ea->time_base.num = get_le32(pb); ea->time_base.num = avio_rl32(pb);
ea->video_codec = CODEC_ID_VP6; ea->video_codec = CODEC_ID_VP6;
return 1; return 1;
@ -296,8 +296,8 @@ static int process_ea_header(AVFormatContext *s) {
unsigned int startpos = url_ftell(pb); unsigned int startpos = url_ftell(pb);
int err = 0; int err = 0;
blockid = get_le32(pb); blockid = avio_rl32(pb);
size = get_le32(pb); size = avio_rl32(pb);
if (i == 0) if (i == 0)
ea->big_endian = size > 0x000FFFFF; ea->big_endian = size > 0x000FFFFF;
if (ea->big_endian) if (ea->big_endian)
@ -305,7 +305,7 @@ static int process_ea_header(AVFormatContext *s) {
switch (blockid) { switch (blockid) {
case ISNh_TAG: case ISNh_TAG:
if (get_le32(pb) != EACS_TAG) { if (avio_rl32(pb) != EACS_TAG) {
av_log (s, AV_LOG_ERROR, "unknown 1SNh headerid\n"); av_log (s, AV_LOG_ERROR, "unknown 1SNh headerid\n");
return 0; return 0;
} }
@ -314,7 +314,7 @@ static int process_ea_header(AVFormatContext *s) {
case SCHl_TAG : case SCHl_TAG :
case SHEN_TAG : case SHEN_TAG :
blockid = get_le32(pb); blockid = avio_rl32(pb);
if (blockid == GSTR_TAG) { if (blockid == GSTR_TAG) {
url_fskip(pb, 4); url_fskip(pb, 4);
} else if ((blockid & 0xFFFF)!=PT00_TAG) { } else if ((blockid & 0xFFFF)!=PT00_TAG) {
@ -467,8 +467,8 @@ static int ea_read_packet(AVFormatContext *s,
int av_uninit(num_samples); int av_uninit(num_samples);
while (!packet_read) { while (!packet_read) {
chunk_type = get_le32(pb); chunk_type = avio_rl32(pb);
chunk_size = (ea->big_endian ? get_be32(pb) : get_le32(pb)) - 8; chunk_size = (ea->big_endian ? avio_rb32(pb) : avio_rl32(pb)) - 8;
switch (chunk_type) { switch (chunk_type) {
/* audio data */ /* audio data */
@ -485,7 +485,7 @@ static int ea_read_packet(AVFormatContext *s,
break; break;
} else if (ea->audio_codec == CODEC_ID_PCM_S16LE_PLANAR || } else if (ea->audio_codec == CODEC_ID_PCM_S16LE_PLANAR ||
ea->audio_codec == CODEC_ID_MP3) { ea->audio_codec == CODEC_ID_MP3) {
num_samples = get_le32(pb); num_samples = avio_rl32(pb);
url_fskip(pb, 8); url_fskip(pb, 8);
chunk_size -= 12; chunk_size -= 12;
} }

144
libavformat/ffmdec.c
View File

@ -95,7 +95,7 @@ static int ffm_resync(AVFormatContext *s, int state)
av_log(s, AV_LOG_ERROR, "cannot find FFM syncword\n"); av_log(s, AV_LOG_ERROR, "cannot find FFM syncword\n");
return -1; return -1;
} }
state = (state << 8) | get_byte(s->pb); state = (state << 8) | avio_r8(s->pb);
} }
return 0; return 0;
} }
@ -120,14 +120,14 @@ static int ffm_read_data(AVFormatContext *s,
if (url_ftell(pb) == ffm->file_size) if (url_ftell(pb) == ffm->file_size)
url_fseek(pb, ffm->packet_size, SEEK_SET); url_fseek(pb, ffm->packet_size, SEEK_SET);
retry_read: retry_read:
id = get_be16(pb); /* PACKET_ID */ id = avio_rb16(pb); /* PACKET_ID */
if (id != PACKET_ID) if (id != PACKET_ID)
if (ffm_resync(s, id) < 0) if (ffm_resync(s, id) < 0)
return -1; return -1;
fill_size = get_be16(pb); fill_size = avio_rb16(pb);
ffm->dts = get_be64(pb); ffm->dts = avio_rb64(pb);
frame_offset = get_be16(pb); frame_offset = avio_rb16(pb);
get_buffer(pb, ffm->packet, ffm->packet_size - FFM_HEADER_SIZE); avio_read(pb, ffm->packet, ffm->packet_size - FFM_HEADER_SIZE);
ffm->packet_end = ffm->packet + (ffm->packet_size - FFM_HEADER_SIZE - fill_size); ffm->packet_end = ffm->packet + (ffm->packet_size - FFM_HEADER_SIZE - fill_size);
if (ffm->packet_end < ffm->packet || frame_offset < 0) if (ffm->packet_end < ffm->packet || frame_offset < 0)
return -1; return -1;
@ -188,7 +188,7 @@ static int64_t get_dts(AVFormatContext *s, int64_t pos)
ffm_seek1(s, pos); ffm_seek1(s, pos);
url_fskip(pb, 4); url_fskip(pb, 4);
dts = get_be64(pb); dts = avio_rb64(pb);
#ifdef DEBUG_SEEK #ifdef DEBUG_SEEK
av_log(s, AV_LOG_DEBUG, "dts=%0.6f\n", dts / 1000000.0); av_log(s, AV_LOG_DEBUG, "dts=%0.6f\n", dts / 1000000.0);
#endif #endif
@ -273,13 +273,13 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
uint32_t tag; uint32_t tag;
/* header */ /* header */
tag = get_le32(pb); tag = avio_rl32(pb);
if (tag != MKTAG('F', 'F', 'M', '1')) if (tag != MKTAG('F', 'F', 'M', '1'))
goto fail; goto fail;
ffm->packet_size = get_be32(pb); ffm->packet_size = avio_rb32(pb);
if (ffm->packet_size != FFM_PACKET_SIZE) if (ffm->packet_size != FFM_PACKET_SIZE)
goto fail; goto fail;
ffm->write_index = get_be64(pb); ffm->write_index = avio_rb64(pb);
/* get also filesize */ /* get also filesize */
if (!url_is_streamed(pb)) { if (!url_is_streamed(pb)) {
ffm->file_size = url_fsize(pb); ffm->file_size = url_fsize(pb);
@ -289,8 +289,8 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
ffm->file_size = (UINT64_C(1) << 63) - 1; ffm->file_size = (UINT64_C(1) << 63) - 1;
} }
nb_streams = get_be32(pb); nb_streams = avio_rb32(pb);
get_be32(pb); /* total bitrate */ avio_rb32(pb); /* total bitrate */
/* read each stream */ /* read each stream */
for(i=0;i<nb_streams;i++) { for(i=0;i<nb_streams;i++) {
char rc_eq_buf[128]; char rc_eq_buf[128];
@ -303,85 +303,85 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
codec = st->codec; codec = st->codec;
/* generic info */ /* generic info */
codec->codec_id = get_be32(pb); codec->codec_id = avio_rb32(pb);
codec->codec_type = get_byte(pb); /* codec_type */ codec->codec_type = avio_r8(pb); /* codec_type */
codec->bit_rate = get_be32(pb); codec->bit_rate = avio_rb32(pb);
st->quality = get_be32(pb); st->quality = avio_rb32(pb);
codec->flags = get_be32(pb); codec->flags = avio_rb32(pb);
codec->flags2 = get_be32(pb); codec->flags2 = avio_rb32(pb);
codec->debug = get_be32(pb); codec->debug = avio_rb32(pb);
/* specific info */ /* specific info */
switch(codec->codec_type) { switch(codec->codec_type) {
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
codec->time_base.num = get_be32(pb); codec->time_base.num = avio_rb32(pb);
codec->time_base.den = get_be32(pb); codec->time_base.den = avio_rb32(pb);
codec->width = get_be16(pb); codec->width = avio_rb16(pb);
codec->height = get_be16(pb); codec->height = avio_rb16(pb);
codec->gop_size = get_be16(pb); codec->gop_size = avio_rb16(pb);
codec->pix_fmt = get_be32(pb); codec->pix_fmt = avio_rb32(pb);
codec->qmin = get_byte(pb); codec->qmin = avio_r8(pb);
codec->qmax = get_byte(pb); codec->qmax = avio_r8(pb);
codec->max_qdiff = get_byte(pb); codec->max_qdiff = avio_r8(pb);
codec->qcompress = get_be16(pb) / 10000.0; codec->qcompress = avio_rb16(pb) / 10000.0;
codec->qblur = get_be16(pb) / 10000.0; codec->qblur = avio_rb16(pb) / 10000.0;
codec->bit_rate_tolerance = get_be32(pb); codec->bit_rate_tolerance = avio_rb32(pb);
codec->rc_eq = av_strdup(get_strz(pb, rc_eq_buf, sizeof(rc_eq_buf))); codec->rc_eq = av_strdup(get_strz(pb, rc_eq_buf, sizeof(rc_eq_buf)));
codec->rc_max_rate = get_be32(pb); codec->rc_max_rate = avio_rb32(pb);
codec->rc_min_rate = get_be32(pb); codec->rc_min_rate = avio_rb32(pb);
codec->rc_buffer_size = get_be32(pb); codec->rc_buffer_size = avio_rb32(pb);
codec->i_quant_factor = av_int2dbl(get_be64(pb)); codec->i_quant_factor = av_int2dbl(avio_rb64(pb));
codec->b_quant_factor = av_int2dbl(get_be64(pb)); codec->b_quant_factor = av_int2dbl(avio_rb64(pb));
codec->i_quant_offset = av_int2dbl(get_be64(pb)); codec->i_quant_offset = av_int2dbl(avio_rb64(pb));
codec->b_quant_offset = av_int2dbl(get_be64(pb)); codec->b_quant_offset = av_int2dbl(avio_rb64(pb));
codec->dct_algo = get_be32(pb); codec->dct_algo = avio_rb32(pb);
codec->strict_std_compliance = get_be32(pb); codec->strict_std_compliance = avio_rb32(pb);
codec->max_b_frames = get_be32(pb); codec->max_b_frames = avio_rb32(pb);
codec->luma_elim_threshold = get_be32(pb); codec->luma_elim_threshold = avio_rb32(pb);
codec->chroma_elim_threshold = get_be32(pb); codec->chroma_elim_threshold = avio_rb32(pb);
codec->mpeg_quant = get_be32(pb); codec->mpeg_quant = avio_rb32(pb);
codec->intra_dc_precision = get_be32(pb); codec->intra_dc_precision = avio_rb32(pb);
codec->me_method = get_be32(pb); codec->me_method = avio_rb32(pb);
codec->mb_decision = get_be32(pb); codec->mb_decision = avio_rb32(pb);
codec->nsse_weight = get_be32(pb); codec->nsse_weight = avio_rb32(pb);
codec->frame_skip_cmp = get_be32(pb); codec->frame_skip_cmp = avio_rb32(pb);
codec->rc_buffer_aggressivity = av_int2dbl(get_be64(pb)); codec->rc_buffer_aggressivity = av_int2dbl(avio_rb64(pb));
codec->codec_tag = get_be32(pb); codec->codec_tag = avio_rb32(pb);
codec->thread_count = get_byte(pb); codec->thread_count = avio_r8(pb);
codec->coder_type = get_be32(pb); codec->coder_type = avio_rb32(pb);
codec->me_cmp = get_be32(pb); codec->me_cmp = avio_rb32(pb);
codec->partitions = get_be32(pb); codec->partitions = avio_rb32(pb);
codec->me_subpel_quality = get_be32(pb); codec->me_subpel_quality = avio_rb32(pb);
codec->me_range = get_be32(pb); codec->me_range = avio_rb32(pb);
codec->keyint_min = get_be32(pb); codec->keyint_min = avio_rb32(pb);
codec->scenechange_threshold = get_be32(pb); codec->scenechange_threshold = avio_rb32(pb);
codec->b_frame_strategy = get_be32(pb); codec->b_frame_strategy = avio_rb32(pb);
codec->qcompress = av_int2dbl(get_be64(pb)); codec->qcompress = av_int2dbl(avio_rb64(pb));
codec->qblur = av_int2dbl(get_be64(pb)); codec->qblur = av_int2dbl(avio_rb64(pb));
codec->max_qdiff = get_be32(pb); codec->max_qdiff = avio_rb32(pb);
codec->refs = get_be32(pb); codec->refs = avio_rb32(pb);
codec->directpred = get_be32(pb); codec->directpred = avio_rb32(pb);
break; break;
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
codec->sample_rate = get_be32(pb); codec->sample_rate = avio_rb32(pb);
codec->channels = get_le16(pb); codec->channels = avio_rl16(pb);
codec->frame_size = get_le16(pb); codec->frame_size = avio_rl16(pb);
codec->sample_fmt = (int16_t) get_le16(pb); codec->sample_fmt = (int16_t) avio_rl16(pb);
break; break;
default: default:
goto fail; goto fail;
} }
if (codec->flags & CODEC_FLAG_GLOBAL_HEADER) { if (codec->flags & CODEC_FLAG_GLOBAL_HEADER) {
codec->extradata_size = get_be32(pb); codec->extradata_size = avio_rb32(pb);
codec->extradata = av_malloc(codec->extradata_size); codec->extradata = av_malloc(codec->extradata_size);
if (!codec->extradata) if (!codec->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
get_buffer(pb, codec->extradata, codec->extradata_size); avio_read(pb, codec->extradata, codec->extradata_size);
} }
} }
/* get until end of block reached */ /* get until end of block reached */
while ((url_ftell(pb) % ffm->packet_size) != 0) while ((url_ftell(pb) % ffm->packet_size) != 0)
get_byte(pb); avio_r8(pb);
/* init packet demux */ /* init packet demux */
ffm->packet_ptr = ffm->packet; ffm->packet_ptr = ffm->packet;

4
libavformat/ffmetadec.c
View File

@ -36,11 +36,11 @@ static void get_line(AVIOContext *s, uint8_t *buf, int size)
uint8_t c; uint8_t c;
int i = 0; int i = 0;
while ((c = get_byte(s))) { while ((c = avio_r8(s))) {
if (c == '\\') { if (c == '\\') {
if (i < size - 1) if (i < size - 1)
buf[i++] = c; buf[i++] = c;
c = get_byte(s); c = avio_r8(s);
} else if (c == '\n') } else if (c == '\n')
break; break;

14
libavformat/filmstripdec.c
View File

@ -44,7 +44,7 @@ static int read_header(AVFormatContext *s,
return AVERROR(EIO); return AVERROR(EIO);
url_fseek(pb, url_fsize(pb) - 36, SEEK_SET); url_fseek(pb, url_fsize(pb) - 36, SEEK_SET);
if (get_be32(pb) != RAND_TAG) { if (avio_rb32(pb) != RAND_TAG) {
av_log(s, AV_LOG_ERROR, "magic number not found"); av_log(s, AV_LOG_ERROR, "magic number not found");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -53,8 +53,8 @@ static int read_header(AVFormatContext *s,
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->nb_frames = get_be32(pb); st->nb_frames = avio_rb32(pb);
if (get_be16(pb) != 0) { if (avio_rb16(pb) != 0) {
av_log_ask_for_sample(s, "unsupported packing method\n"); av_log_ask_for_sample(s, "unsupported packing method\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -64,10 +64,10 @@ static int read_header(AVFormatContext *s,
st->codec->codec_id = CODEC_ID_RAWVIDEO; st->codec->codec_id = CODEC_ID_RAWVIDEO;
st->codec->pix_fmt = PIX_FMT_RGBA; st->codec->pix_fmt = PIX_FMT_RGBA;
st->codec->codec_tag = 0; /* no fourcc */ st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = get_be16(pb); st->codec->width = avio_rb16(pb);
st->codec->height = get_be16(pb); st->codec->height = avio_rb16(pb);
film->leading = get_be16(pb); film->leading = avio_rb16(pb);
av_set_pts_info(st, 64, 1, get_be16(pb)); av_set_pts_info(st, 64, 1, avio_rb16(pb));
url_fseek(pb, 0, SEEK_SET); url_fseek(pb, 0, SEEK_SET);

6
libavformat/flacdec.c
View File

@ -40,14 +40,14 @@ static int flac_read_header(AVFormatContext *s,
/* the parameters will be extracted from the compressed bitstream */ /* the parameters will be extracted from the compressed bitstream */
/* if fLaC marker is not found, assume there is no header */ /* if fLaC marker is not found, assume there is no header */
if (get_le32(s->pb) != MKTAG('f','L','a','C')) { if (avio_rl32(s->pb) != MKTAG('f','L','a','C')) {
url_fseek(s->pb, -4, SEEK_CUR); url_fseek(s->pb, -4, SEEK_CUR);
return 0; return 0;
} }
/* process metadata blocks */ /* process metadata blocks */
while (!url_feof(s->pb) && !metadata_last) { while (!url_feof(s->pb) && !metadata_last) {
get_buffer(s->pb, header, 4); avio_read(s->pb, header, 4);
ff_flac_parse_block_header(header, &metadata_last, &metadata_type, ff_flac_parse_block_header(header, &metadata_last, &metadata_type,
&metadata_size); &metadata_size);
switch (metadata_type) { switch (metadata_type) {
@ -58,7 +58,7 @@ static int flac_read_header(AVFormatContext *s,
if (!buffer) { if (!buffer) {
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if (get_buffer(s->pb, buffer, metadata_size) != metadata_size) { if (avio_read(s->pb, buffer, metadata_size) != metadata_size) {
av_freep(&buffer); av_freep(&buffer);
return AVERROR(EIO); return AVERROR(EIO);
} }

10
libavformat/flic.c
View File

@ -96,7 +96,7 @@ static int flic_read_header(AVFormatContext *s,
flic->frame_number = 0; flic->frame_number = 0;
/* load the whole header and pull out the width and height */ /* load the whole header and pull out the width and height */
if (get_buffer(pb, header, FLIC_HEADER_SIZE) != FLIC_HEADER_SIZE) if (avio_read(pb, header, FLIC_HEADER_SIZE) != FLIC_HEADER_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
magic_number = AV_RL16(&header[4]); magic_number = AV_RL16(&header[4]);
@ -130,7 +130,7 @@ static int flic_read_header(AVFormatContext *s,
memcpy(st->codec->extradata, header, FLIC_HEADER_SIZE); memcpy(st->codec->extradata, header, FLIC_HEADER_SIZE);
/* peek at the preamble to detect TFTD videos - they seem to always start with an audio chunk */ /* peek at the preamble to detect TFTD videos - they seem to always start with an audio chunk */
if (get_buffer(pb, preamble, FLIC_PREAMBLE_SIZE) != FLIC_PREAMBLE_SIZE) { if (avio_read(pb, preamble, FLIC_PREAMBLE_SIZE) != FLIC_PREAMBLE_SIZE) {
av_log(s, AV_LOG_ERROR, "Failed to peek at preamble\n"); av_log(s, AV_LOG_ERROR, "Failed to peek at preamble\n");
return AVERROR(EIO); return AVERROR(EIO);
} }
@ -207,7 +207,7 @@ static int flic_read_packet(AVFormatContext *s,
while (!packet_read) { while (!packet_read) {
if ((ret = get_buffer(pb, preamble, FLIC_PREAMBLE_SIZE)) != if ((ret = avio_read(pb, preamble, FLIC_PREAMBLE_SIZE)) !=
FLIC_PREAMBLE_SIZE) { FLIC_PREAMBLE_SIZE) {
ret = AVERROR(EIO); ret = AVERROR(EIO);
break; break;
@ -225,7 +225,7 @@ static int flic_read_packet(AVFormatContext *s,
pkt->pts = flic->frame_number++; pkt->pts = flic->frame_number++;
pkt->pos = url_ftell(pb); pkt->pos = url_ftell(pb);
memcpy(pkt->data, preamble, FLIC_PREAMBLE_SIZE); memcpy(pkt->data, preamble, FLIC_PREAMBLE_SIZE);
ret = get_buffer(pb, pkt->data + FLIC_PREAMBLE_SIZE, ret = avio_read(pb, pkt->data + FLIC_PREAMBLE_SIZE,
size - FLIC_PREAMBLE_SIZE); size - FLIC_PREAMBLE_SIZE);
if (ret != size - FLIC_PREAMBLE_SIZE) { if (ret != size - FLIC_PREAMBLE_SIZE) {
av_free_packet(pkt); av_free_packet(pkt);
@ -243,7 +243,7 @@ static int flic_read_packet(AVFormatContext *s,
pkt->stream_index = flic->audio_stream_index; pkt->stream_index = flic->audio_stream_index;
pkt->pos = url_ftell(pb); pkt->pos = url_ftell(pb);
ret = get_buffer(pb, pkt->data, size); ret = avio_read(pb, pkt->data, size);
if (ret != size) { if (ret != size) {
av_free_packet(pkt); av_free_packet(pkt);

52
libavformat/flvdec.c
View File

@ -97,7 +97,7 @@ static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, int flv_co
vcodec->extradata_size = 1; vcodec->extradata_size = 1;
vcodec->extradata = av_malloc(1); vcodec->extradata = av_malloc(1);
} }
vcodec->extradata[0] = get_byte(s->pb); vcodec->extradata[0] = avio_r8(s->pb);
return 1; // 1 byte body size adjustment for flv_read_packet() return 1; // 1 byte body size adjustment for flv_read_packet()
case FLV_CODECID_H264: case FLV_CODECID_H264:
vcodec->codec_id = CODEC_ID_H264; vcodec->codec_id = CODEC_ID_H264;
@ -111,13 +111,13 @@ static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, int flv_co
} }
static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize) { static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize) {
int length = get_be16(ioc); int length = avio_rb16(ioc);
if(length >= buffsize) { if(length >= buffsize) {
url_fskip(ioc, length); url_fskip(ioc, length);
return -1; return -1;
} }
get_buffer(ioc, buffer, length); avio_read(ioc, buffer, length);
buffer[length] = '\0'; buffer[length] = '\0';
@ -134,13 +134,13 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst
num_val = 0; num_val = 0;
ioc = s->pb; ioc = s->pb;
amf_type = get_byte(ioc); amf_type = avio_r8(ioc);
switch(amf_type) { switch(amf_type) {
case AMF_DATA_TYPE_NUMBER: case AMF_DATA_TYPE_NUMBER:
num_val = av_int2dbl(get_be64(ioc)); break; num_val = av_int2dbl(avio_rb64(ioc)); break;
case AMF_DATA_TYPE_BOOL: case AMF_DATA_TYPE_BOOL:
num_val = get_byte(ioc); break; num_val = avio_r8(ioc); break;
case AMF_DATA_TYPE_STRING: case AMF_DATA_TYPE_STRING:
if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0) if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
return -1; return -1;
@ -148,12 +148,12 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst
case AMF_DATA_TYPE_OBJECT: { case AMF_DATA_TYPE_OBJECT: {
unsigned int keylen; unsigned int keylen;
while(url_ftell(ioc) < max_pos - 2 && (keylen = get_be16(ioc))) { while(url_ftell(ioc) < max_pos - 2 && (keylen = avio_rb16(ioc))) {
url_fskip(ioc, keylen); //skip key string url_fskip(ioc, keylen); //skip key string
if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0) if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
return -1; //if we couldn't skip, bomb out. return -1; //if we couldn't skip, bomb out.
} }
if(get_byte(ioc) != AMF_END_OF_OBJECT) if(avio_r8(ioc) != AMF_END_OF_OBJECT)
return -1; return -1;
} }
break; break;
@ -168,13 +168,13 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst
if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0) if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0)
return -1; return -1;
} }
if(get_byte(ioc) != AMF_END_OF_OBJECT) if(avio_r8(ioc) != AMF_END_OF_OBJECT)
return -1; return -1;
break; break;
case AMF_DATA_TYPE_ARRAY: { case AMF_DATA_TYPE_ARRAY: {
unsigned int arraylen, i; unsigned int arraylen, i;
arraylen = get_be32(ioc); arraylen = avio_rb32(ioc);
for(i = 0; i < arraylen && url_ftell(ioc) < max_pos - 1; i++) { for(i = 0; i < arraylen && url_ftell(ioc) < max_pos - 1; i++) {
if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0) if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
return -1; //if we couldn't skip, bomb out. return -1; //if we couldn't skip, bomb out.
@ -222,7 +222,7 @@ static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {
ioc = s->pb; ioc = s->pb;
//first object needs to be "onMetaData" string //first object needs to be "onMetaData" string
type = get_byte(ioc); type = avio_r8(ioc);
if(type != AMF_DATA_TYPE_STRING || amf_get_string(ioc, buffer, sizeof(buffer)) < 0 || strcmp(buffer, "onMetaData")) if(type != AMF_DATA_TYPE_STRING || amf_get_string(ioc, buffer, sizeof(buffer)) < 0 || strcmp(buffer, "onMetaData"))
return -1; return -1;
@ -255,7 +255,7 @@ static int flv_read_header(AVFormatContext *s,
int offset, flags; int offset, flags;
url_fskip(s->pb, 4); url_fskip(s->pb, 4);
flags = get_byte(s->pb); flags = avio_r8(s->pb);
/* old flvtool cleared this field */ /* old flvtool cleared this field */
/* FIXME: better fix needed */ /* FIXME: better fix needed */
if (!flags) { if (!flags) {
@ -276,7 +276,7 @@ static int flv_read_header(AVFormatContext *s,
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
offset = get_be32(s->pb); offset = avio_rb32(s->pb);
url_fseek(s->pb, offset, SEEK_SET); url_fseek(s->pb, offset, SEEK_SET);
url_fskip(s->pb, 4); url_fskip(s->pb, 4);
@ -292,7 +292,7 @@ static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)
if (!st->codec->extradata) if (!st->codec->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata_size = size; st->codec->extradata_size = size;
get_buffer(s->pb, st->codec->extradata, st->codec->extradata_size); avio_read(s->pb, st->codec->extradata, st->codec->extradata_size);
return 0; return 0;
} }
@ -306,10 +306,10 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
for(;;url_fskip(s->pb, 4)){ /* pkt size is repeated at end. skip it */ for(;;url_fskip(s->pb, 4)){ /* pkt size is repeated at end. skip it */
pos = url_ftell(s->pb); pos = url_ftell(s->pb);
type = get_byte(s->pb); type = avio_r8(s->pb);
size = get_be24(s->pb); size = avio_rb24(s->pb);
dts = get_be24(s->pb); dts = avio_rb24(s->pb);
dts |= get_byte(s->pb) << 24; dts |= avio_r8(s->pb) << 24;
// av_log(s, AV_LOG_DEBUG, "type:%d, size:%d, dts:%d\n", type, size, dts); // av_log(s, AV_LOG_DEBUG, "type:%d, size:%d, dts:%d\n", type, size, dts);
if (url_feof(s->pb)) if (url_feof(s->pb))
return AVERROR_EOF; return AVERROR_EOF;
@ -323,11 +323,11 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
if (type == FLV_TAG_TYPE_AUDIO) { if (type == FLV_TAG_TYPE_AUDIO) {
is_audio=1; is_audio=1;
flags = get_byte(s->pb); flags = avio_r8(s->pb);
size--; size--;
} else if (type == FLV_TAG_TYPE_VIDEO) { } else if (type == FLV_TAG_TYPE_VIDEO) {
is_audio=0; is_audio=0;
flags = get_byte(s->pb); flags = avio_r8(s->pb);
size--; size--;
if ((flags & 0xf0) == 0x50) /* video info / command frame */ if ((flags & 0xf0) == 0x50) /* video info / command frame */
goto skip; goto skip;
@ -375,11 +375,11 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
const int64_t pos= url_ftell(s->pb); const int64_t pos= url_ftell(s->pb);
const int64_t fsize= url_fsize(s->pb); const int64_t fsize= url_fsize(s->pb);
url_fseek(s->pb, fsize-4, SEEK_SET); url_fseek(s->pb, fsize-4, SEEK_SET);
size= get_be32(s->pb); size= avio_rb32(s->pb);
url_fseek(s->pb, fsize-3-size, SEEK_SET); url_fseek(s->pb, fsize-3-size, SEEK_SET);
if(size == get_be24(s->pb) + 11){ if(size == avio_rb24(s->pb) + 11){
uint32_t ts = get_be24(s->pb); uint32_t ts = avio_rb24(s->pb);
ts |= get_byte(s->pb) << 24; ts |= avio_r8(s->pb) << 24;
s->duration = ts * (int64_t)AV_TIME_BASE / 1000; s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
} }
url_fseek(s->pb, pos, SEEK_SET); url_fseek(s->pb, pos, SEEK_SET);
@ -400,10 +400,10 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
if (st->codec->codec_id == CODEC_ID_AAC || if (st->codec->codec_id == CODEC_ID_AAC ||
st->codec->codec_id == CODEC_ID_H264) { st->codec->codec_id == CODEC_ID_H264) {
int type = get_byte(s->pb); int type = avio_r8(s->pb);
size--; size--;
if (st->codec->codec_id == CODEC_ID_H264) { if (st->codec->codec_id == CODEC_ID_H264) {
int32_t cts = (get_be24(s->pb)+0xff800000)^0xff800000; // sign extension int32_t cts = (avio_rb24(s->pb)+0xff800000)^0xff800000; // sign extension
pts = dts + cts; pts = dts + cts;
if (cts < 0) { // dts are wrong if (cts < 0) { // dts are wrong
flv->wrong_dts = 1; flv->wrong_dts = 1;

70
libavformat/gxf.c
View File

@ -39,20 +39,20 @@ struct gxf_stream_info {
* \return 0 if header not found or contains invalid data, 1 otherwise * \return 0 if header not found or contains invalid data, 1 otherwise
*/ */
static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length) { static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length) {
if (get_be32(pb)) if (avio_rb32(pb))
return 0; return 0;
if (get_byte(pb) != 1) if (avio_r8(pb) != 1)
return 0; return 0;
*type = get_byte(pb); *type = avio_r8(pb);
*length = get_be32(pb); *length = avio_rb32(pb);
if ((*length >> 24) || *length < 16) if ((*length >> 24) || *length < 16)
return 0; return 0;
*length -= 16; *length -= 16;
if (get_be32(pb)) if (avio_rb32(pb))
return 0; return 0;
if (get_byte(pb) != 0xe1) if (avio_r8(pb) != 0xe1)
return 0; return 0;
if (get_byte(pb) != 0xe2) if (avio_r8(pb) != 0xe2)
return 0; return 0;
return 1; return 1;
} }
@ -161,14 +161,14 @@ static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info
si->first_field = AV_NOPTS_VALUE; si->first_field = AV_NOPTS_VALUE;
si->last_field = AV_NOPTS_VALUE; si->last_field = AV_NOPTS_VALUE;
while (*len >= 2) { while (*len >= 2) {
GXFMatTag tag = get_byte(pb); GXFMatTag tag = avio_r8(pb);
int tlen = get_byte(pb); int tlen = avio_r8(pb);
*len -= 2; *len -= 2;
if (tlen > *len) if (tlen > *len)
return; return;
*len -= tlen; *len -= tlen;
if (tlen == 4) { if (tlen == 4) {
uint32_t value = get_be32(pb); uint32_t value = avio_rb32(pb);
if (tag == MAT_FIRST_FIELD) if (tag == MAT_FIRST_FIELD)
si->first_field = value; si->first_field = value;
else if (tag == MAT_LAST_FIELD) else if (tag == MAT_LAST_FIELD)
@ -210,14 +210,14 @@ static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si
si->frames_per_second = (AVRational){0, 0}; si->frames_per_second = (AVRational){0, 0};
si->fields_per_frame = 0; si->fields_per_frame = 0;
while (*len >= 2) { while (*len >= 2) {
GXFTrackTag tag = get_byte(pb); GXFTrackTag tag = avio_r8(pb);
int tlen = get_byte(pb); int tlen = avio_r8(pb);
*len -= 2; *len -= 2;
if (tlen > *len) if (tlen > *len)
return; return;
*len -= tlen; *len -= tlen;
if (tlen == 4) { if (tlen == 4) {
uint32_t value = get_be32(pb); uint32_t value = avio_rb32(pb);
if (tag == TRACK_FPS) if (tag == TRACK_FPS)
si->frames_per_second = fps_tag2avr(value); si->frames_per_second = fps_tag2avr(value);
else if (tag == TRACK_FPF && (value == 1 || value == 2)) else if (tag == TRACK_FPF && (value == 1 || value == 2))
@ -233,8 +233,8 @@ static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si
static void gxf_read_index(AVFormatContext *s, int pkt_len) { static void gxf_read_index(AVFormatContext *s, int pkt_len) {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVStream *st = s->streams[0]; AVStream *st = s->streams[0];
uint32_t fields_per_map = get_le32(pb); uint32_t fields_per_map = avio_rl32(pb);
uint32_t map_cnt = get_le32(pb); uint32_t map_cnt = avio_rl32(pb);
int i; int i;
pkt_len -= 8; pkt_len -= 8;
if (s->flags & AVFMT_FLAG_IGNIDX) { if (s->flags & AVFMT_FLAG_IGNIDX) {
@ -253,7 +253,7 @@ static void gxf_read_index(AVFormatContext *s, int pkt_len) {
pkt_len -= 4 * map_cnt; pkt_len -= 4 * map_cnt;
av_add_index_entry(st, 0, 0, 0, 0, 0); av_add_index_entry(st, 0, 0, 0, 0, 0);
for (i = 0; i < map_cnt; i++) for (i = 0; i < map_cnt; i++)
av_add_index_entry(st, (uint64_t)get_le32(pb) * 1024, av_add_index_entry(st, (uint64_t)avio_rl32(pb) * 1024,
i * (uint64_t)fields_per_map + 1, 0, 0, 0); i * (uint64_t)fields_per_map + 1, 0, 0, 0);
url_fskip(pb, pkt_len); url_fskip(pb, pkt_len);
} }
@ -271,12 +271,12 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {
return 0; return 0;
} }
map_len -= 2; map_len -= 2;
if (get_byte(pb) != 0x0e0 || get_byte(pb) != 0xff) { if (avio_r8(pb) != 0x0e0 || avio_r8(pb) != 0xff) {
av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n"); av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n");
return 0; return 0;
} }
map_len -= 2; map_len -= 2;
len = get_be16(pb); // length of material data section len = avio_rb16(pb); // length of material data section
if (len > map_len) { if (len > map_len) {
av_log(s, AV_LOG_ERROR, "material data longer than map data\n"); av_log(s, AV_LOG_ERROR, "material data longer than map data\n");
return 0; return 0;
@ -285,7 +285,7 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {
gxf_material_tags(pb, &len, &si); gxf_material_tags(pb, &len, &si);
url_fskip(pb, len); url_fskip(pb, len);
map_len -= 2; map_len -= 2;
len = get_be16(pb); // length of track description len = avio_rb16(pb); // length of track description
if (len > map_len) { if (len > map_len) {
av_log(s, AV_LOG_ERROR, "track description longer than map data\n"); av_log(s, AV_LOG_ERROR, "track description longer than map data\n");
return 0; return 0;
@ -296,9 +296,9 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {
AVStream *st; AVStream *st;
int idx; int idx;
len -= 4; len -= 4;
track_type = get_byte(pb); track_type = avio_r8(pb);
track_id = get_byte(pb); track_id = avio_r8(pb);
track_len = get_be16(pb); track_len = avio_rb16(pb);
len -= track_len; len -= track_len;
gxf_track_tags(pb, &track_len, &si); gxf_track_tags(pb, &track_len, &si);
url_fskip(pb, track_len); url_fskip(pb, track_len);
@ -344,7 +344,7 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {
len -= 0x39; len -= 0x39;
url_fskip(pb, 5); // preamble url_fskip(pb, 5); // preamble
url_fskip(pb, 0x30); // payload description url_fskip(pb, 0x30); // payload description
fps = fps_umf2avr(get_le32(pb)); fps = fps_umf2avr(avio_rl32(pb));
if (!main_timebase.num || !main_timebase.den) { if (!main_timebase.num || !main_timebase.den) {
// this may not always be correct, but simply the best we can get // this may not always be correct, but simply the best we can get
main_timebase.num = fps.den; main_timebase.num = fps.den;
@ -370,7 +370,7 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {
{ \ { \
if (!max_interval-- || url_feof(pb)) \ if (!max_interval-- || url_feof(pb)) \
goto out; \ goto out; \
tmp = tmp << 8 | get_byte(pb); \ tmp = tmp << 8 | avio_r8(pb); \
} }
/** /**
@ -389,7 +389,7 @@ static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int t
int len; int len;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
GXFPktType type; GXFPktType type;
tmp = get_be32(pb); tmp = avio_rb32(pb);
start: start:
while (tmp) while (tmp)
READ_ONE(); READ_ONE();
@ -404,9 +404,9 @@ start:
goto out; goto out;
goto start; goto start;
} }
get_byte(pb); avio_r8(pb);
cur_track = get_byte(pb); cur_track = avio_r8(pb);
cur_timestamp = get_be32(pb); cur_timestamp = avio_rb32(pb);
last_found_pos = url_ftell(pb) - 16 - 6; last_found_pos = url_ftell(pb) - 16 - 6;
if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) { if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {
if (url_fseek(pb, last_pos, SEEK_SET) >= 0) if (url_fseek(pb, last_pos, SEEK_SET) >= 0)
@ -445,17 +445,17 @@ static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
continue; continue;
} }
pkt_len -= 16; pkt_len -= 16;
track_type = get_byte(pb); track_type = avio_r8(pb);
track_id = get_byte(pb); track_id = avio_r8(pb);
stream_index = get_sindex(s, track_id, track_type); stream_index = get_sindex(s, track_id, track_type);
if (stream_index < 0) if (stream_index < 0)
return stream_index; return stream_index;
st = s->streams[stream_index]; st = s->streams[stream_index];
field_nr = get_be32(pb); field_nr = avio_rb32(pb);
field_info = get_be32(pb); field_info = avio_rb32(pb);
get_be32(pb); // "timeline" field number avio_rb32(pb); // "timeline" field number
get_byte(pb); // flags avio_r8(pb); // flags
get_byte(pb); // reserved avio_r8(pb); // reserved
if (st->codec->codec_id == CODEC_ID_PCM_S24LE || if (st->codec->codec_id == CODEC_ID_PCM_S24LE ||
st->codec->codec_id == CODEC_ID_PCM_S16LE) { st->codec->codec_id == CODEC_ID_PCM_S16LE) {
int first = field_info >> 16; int first = field_info >> 16;

2
libavformat/id3v1.c
View File

@ -233,7 +233,7 @@ void ff_id3v1_read(AVFormatContext *s)
filesize = url_fsize(s->pb); filesize = url_fsize(s->pb);
if (filesize > 128) { if (filesize > 128) {
url_fseek(s->pb, filesize - 128, SEEK_SET); url_fseek(s->pb, filesize - 128, SEEK_SET);
ret = get_buffer(s->pb, buf, ID3v1_TAG_SIZE); ret = avio_read(s->pb, buf, ID3v1_TAG_SIZE);
if (ret == ID3v1_TAG_SIZE) { if (ret == ID3v1_TAG_SIZE) {
parse_tag(s, buf); parse_tag(s, buf);
} }

30
libavformat/id3v2.c
View File

@ -55,7 +55,7 @@ static unsigned int get_size(AVIOContext *s, int len)
{ {
int v = 0; int v = 0;
while (len--) while (len--)
v = (v << 7) + (get_byte(s) & 0x7F); v = (v << 7) + (avio_r8(s) & 0x7F);
return v; return v;
} }
@ -65,7 +65,7 @@ static void read_ttag(AVFormatContext *s, AVIOContext *pb, int taglen, const cha
const char *val = NULL; const char *val = NULL;
int len, dstlen = sizeof(dst) - 1; int len, dstlen = sizeof(dst) - 1;
unsigned genre; unsigned genre;
unsigned int (*get)(AVIOContext*) = get_be16; unsigned int (*get)(AVIOContext*) = avio_rb16;
dst[0] = 0; dst[0] = 0;
if (taglen < 1) if (taglen < 1)
@ -73,22 +73,22 @@ static void read_ttag(AVFormatContext *s, AVIOContext *pb, int taglen, const cha
taglen--; /* account for encoding type byte */ taglen--; /* account for encoding type byte */
switch (get_byte(pb)) { /* encoding type */ switch (avio_r8(pb)) { /* encoding type */
case ID3v2_ENCODING_ISO8859: case ID3v2_ENCODING_ISO8859:
q = dst; q = dst;
while (taglen-- && q - dst < dstlen - 7) { while (taglen-- && q - dst < dstlen - 7) {
uint8_t tmp; uint8_t tmp;
PUT_UTF8(get_byte(pb), tmp, *q++ = tmp;) PUT_UTF8(avio_r8(pb), tmp, *q++ = tmp;)
} }
*q = 0; *q = 0;
break; break;
case ID3v2_ENCODING_UTF16BOM: case ID3v2_ENCODING_UTF16BOM:
taglen -= 2; taglen -= 2;
switch (get_be16(pb)) { switch (avio_rb16(pb)) {
case 0xfffe: case 0xfffe:
get = get_le16; get = avio_rl16;
case 0xfeff: case 0xfeff:
break; break;
default: default:
@ -111,7 +111,7 @@ static void read_ttag(AVFormatContext *s, AVIOContext *pb, int taglen, const cha
case ID3v2_ENCODING_UTF8: case ID3v2_ENCODING_UTF8:
len = FFMIN(taglen, dstlen); len = FFMIN(taglen, dstlen);
get_buffer(pb, dst, len); avio_read(pb, dst, len);
dst[len] = 0; dst[len] = 0;
break; break;
default: default:
@ -178,18 +178,18 @@ static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t
int tunsync = 0; int tunsync = 0;
if (isv34) { if (isv34) {
get_buffer(s->pb, tag, 4); avio_read(s->pb, tag, 4);
tag[4] = 0; tag[4] = 0;
if(version==3){ if(version==3){
tlen = get_be32(s->pb); tlen = avio_rb32(s->pb);
}else }else
tlen = get_size(s->pb, 4); tlen = get_size(s->pb, 4);
tflags = get_be16(s->pb); tflags = avio_rb16(s->pb);
tunsync = tflags & ID3v2_FLAG_UNSYNCH; tunsync = tflags & ID3v2_FLAG_UNSYNCH;
} else { } else {
get_buffer(s->pb, tag, 3); avio_read(s->pb, tag, 3);
tag[3] = 0; tag[3] = 0;
tlen = get_be24(s->pb); tlen = avio_rb24(s->pb);
} }
len -= taghdrlen + tlen; len -= taghdrlen + tlen;
@ -199,7 +199,7 @@ static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t
next = url_ftell(s->pb) + tlen; next = url_ftell(s->pb) + tlen;
if (tflags & ID3v2_FLAG_DATALEN) { if (tflags & ID3v2_FLAG_DATALEN) {
get_be32(s->pb); avio_rb32(s->pb);
tlen -= 4; tlen -= 4;
} }
@ -211,7 +211,7 @@ static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t
int i, j; int i, j;
av_fast_malloc(&buffer, &buffer_size, tlen); av_fast_malloc(&buffer, &buffer_size, tlen);
for (i = 0, j = 0; i < tlen; i++, j++) { for (i = 0, j = 0; i < tlen; i++, j++) {
buffer[j] = get_byte(s->pb); buffer[j] = avio_r8(s->pb);
if (j > 0 && !buffer[j] && buffer[j - 1] == 0xff) { if (j > 0 && !buffer[j] && buffer[j - 1] == 0xff) {
/* Unsynchronised byte, skip it */ /* Unsynchronised byte, skip it */
j--; j--;
@ -259,7 +259,7 @@ void ff_id3v2_read(AVFormatContext *s, const char *magic)
do { do {
/* save the current offset in case there's nothing to read/skip */ /* save the current offset in case there's nothing to read/skip */
off = url_ftell(s->pb); off = url_ftell(s->pb);
ret = get_buffer(s->pb, buf, ID3v2_HEADER_SIZE); ret = avio_read(s->pb, buf, ID3v2_HEADER_SIZE);
if (ret != ID3v2_HEADER_SIZE) if (ret != ID3v2_HEADER_SIZE)
break; break;
found_header = ff_id3v2_match(buf, magic); found_header = ff_id3v2_match(buf, magic);

18
libavformat/idcin.c
View File

@ -149,11 +149,11 @@ static int idcin_read_header(AVFormatContext *s,
unsigned int sample_rate, bytes_per_sample, channels; unsigned int sample_rate, bytes_per_sample, channels;
/* get the 5 header parameters */ /* get the 5 header parameters */
width = get_le32(pb); width = avio_rl32(pb);
height = get_le32(pb); height = avio_rl32(pb);
sample_rate = get_le32(pb); sample_rate = avio_rl32(pb);
bytes_per_sample = get_le32(pb); bytes_per_sample = avio_rl32(pb);
channels = get_le32(pb); channels = avio_rl32(pb);
st = av_new_stream(s, 0); st = av_new_stream(s, 0);
if (!st) if (!st)
@ -169,7 +169,7 @@ static int idcin_read_header(AVFormatContext *s,
/* load up the Huffman tables into extradata */ /* load up the Huffman tables into extradata */
st->codec->extradata_size = HUFFMAN_TABLE_SIZE; st->codec->extradata_size = HUFFMAN_TABLE_SIZE;
st->codec->extradata = av_malloc(HUFFMAN_TABLE_SIZE); st->codec->extradata = av_malloc(HUFFMAN_TABLE_SIZE);
if (get_buffer(pb, st->codec->extradata, HUFFMAN_TABLE_SIZE) != if (avio_read(pb, st->codec->extradata, HUFFMAN_TABLE_SIZE) !=
HUFFMAN_TABLE_SIZE) HUFFMAN_TABLE_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
/* save a reference in order to transport the palette */ /* save a reference in order to transport the palette */
@ -231,13 +231,13 @@ static int idcin_read_packet(AVFormatContext *s,
return AVERROR(EIO); return AVERROR(EIO);
if (idcin->next_chunk_is_video) { if (idcin->next_chunk_is_video) {
command = get_le32(pb); command = avio_rl32(pb);
if (command == 2) { if (command == 2) {
return AVERROR(EIO); return AVERROR(EIO);
} else if (command == 1) { } else if (command == 1) {
/* trigger a palette change */ /* trigger a palette change */
idcin->palctrl.palette_changed = 1; idcin->palctrl.palette_changed = 1;
if (get_buffer(pb, palette_buffer, 768) != 768) if (avio_read(pb, palette_buffer, 768) != 768)
return AVERROR(EIO); return AVERROR(EIO);
/* scale the palette as necessary */ /* scale the palette as necessary */
palette_scale = 2; palette_scale = 2;
@ -255,7 +255,7 @@ static int idcin_read_packet(AVFormatContext *s,
} }
} }
chunk_size = get_le32(pb); chunk_size = avio_rl32(pb);
/* skip the number of decoded bytes (always equal to width * height) */ /* skip the number of decoded bytes (always equal to width * height) */
url_fseek(pb, 4, SEEK_CUR); url_fseek(pb, 4, SEEK_CUR);
chunk_size -= 4; chunk_size -= 4;

10
libavformat/idroqdec.c
View File

@ -74,7 +74,7 @@ static int roq_read_header(AVFormatContext *s,
unsigned char preamble[RoQ_CHUNK_PREAMBLE_SIZE]; unsigned char preamble[RoQ_CHUNK_PREAMBLE_SIZE];
/* get the main header */ /* get the main header */
if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != if (avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) !=
RoQ_CHUNK_PREAMBLE_SIZE) RoQ_CHUNK_PREAMBLE_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
framerate = AV_RL16(&preamble[6]); framerate = AV_RL16(&preamble[6]);
@ -115,7 +115,7 @@ static int roq_read_packet(AVFormatContext *s,
return AVERROR(EIO); return AVERROR(EIO);
/* get the next chunk preamble */ /* get the next chunk preamble */
if ((ret = get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE)) != if ((ret = avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE)) !=
RoQ_CHUNK_PREAMBLE_SIZE) RoQ_CHUNK_PREAMBLE_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
@ -129,7 +129,7 @@ static int roq_read_packet(AVFormatContext *s,
case RoQ_INFO: case RoQ_INFO:
if (!roq->width || !roq->height) { if (!roq->width || !roq->height) {
AVStream *st = s->streams[roq->video_stream_index]; AVStream *st = s->streams[roq->video_stream_index];
if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != RoQ_CHUNK_PREAMBLE_SIZE) if (avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != RoQ_CHUNK_PREAMBLE_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
st->codec->width = roq->width = AV_RL16(preamble); st->codec->width = roq->width = AV_RL16(preamble);
st->codec->height = roq->height = AV_RL16(preamble + 2); st->codec->height = roq->height = AV_RL16(preamble + 2);
@ -144,7 +144,7 @@ static int roq_read_packet(AVFormatContext *s,
codebook_offset = url_ftell(pb) - RoQ_CHUNK_PREAMBLE_SIZE; codebook_offset = url_ftell(pb) - RoQ_CHUNK_PREAMBLE_SIZE;
codebook_size = chunk_size; codebook_size = chunk_size;
url_fseek(pb, codebook_size, SEEK_CUR); url_fseek(pb, codebook_size, SEEK_CUR);
if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != if (avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) !=
RoQ_CHUNK_PREAMBLE_SIZE) RoQ_CHUNK_PREAMBLE_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
chunk_size = AV_RL32(&preamble[2]) + RoQ_CHUNK_PREAMBLE_SIZE * 2 + chunk_size = AV_RL32(&preamble[2]) + RoQ_CHUNK_PREAMBLE_SIZE * 2 +
@ -198,7 +198,7 @@ static int roq_read_packet(AVFormatContext *s,
} }
pkt->pos= url_ftell(pb); pkt->pos= url_ftell(pb);
ret = get_buffer(pb, pkt->data + RoQ_CHUNK_PREAMBLE_SIZE, ret = avio_read(pb, pkt->data + RoQ_CHUNK_PREAMBLE_SIZE,
chunk_size); chunk_size);
if (ret != chunk_size) if (ret != chunk_size)
ret = AVERROR(EIO); ret = AVERROR(EIO);

30
libavformat/iff.c
View File

@ -101,7 +101,7 @@ static int get_metadata(AVFormatContext *s,
if (!buf) if (!buf)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (get_buffer(s->pb, buf, data_size) < 0) { if (avio_read(s->pb, buf, data_size) < 0) {
av_free(buf); av_free(buf);
return AVERROR(EIO); return AVERROR(EIO);
} }
@ -136,14 +136,14 @@ static int iff_read_header(AVFormatContext *s,
st->codec->channels = 1; st->codec->channels = 1;
url_fskip(pb, 8); url_fskip(pb, 8);
// codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content // codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content
st->codec->codec_tag = get_le32(pb); st->codec->codec_tag = avio_rl32(pb);
while(!url_feof(pb)) { while(!url_feof(pb)) {
uint64_t orig_pos; uint64_t orig_pos;
int res; int res;
const char *metadata_tag = NULL; const char *metadata_tag = NULL;
chunk_id = get_le32(pb); chunk_id = avio_rl32(pb);
data_size = get_be32(pb); data_size = avio_rb32(pb);
orig_pos = url_ftell(pb); orig_pos = url_ftell(pb);
switch(chunk_id) { switch(chunk_id) {
@ -153,10 +153,10 @@ static int iff_read_header(AVFormatContext *s,
if (data_size < 14) if (data_size < 14)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
url_fskip(pb, 12); url_fskip(pb, 12);
st->codec->sample_rate = get_be16(pb); st->codec->sample_rate = avio_rb16(pb);
if (data_size >= 16) { if (data_size >= 16) {
url_fskip(pb, 1); url_fskip(pb, 1);
compression = get_byte(pb); compression = avio_r8(pb);
} }
break; break;
@ -168,7 +168,7 @@ static int iff_read_header(AVFormatContext *s,
case ID_CHAN: case ID_CHAN:
if (data_size < 4) if (data_size < 4)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
st->codec->channels = (get_be32(pb) < 6) ? 1 : 2; st->codec->channels = (avio_rb32(pb) < 6) ? 1 : 2;
break; break;
case ID_CMAP: case ID_CMAP:
@ -176,7 +176,7 @@ static int iff_read_header(AVFormatContext *s,
st->codec->extradata = av_malloc(data_size); st->codec->extradata = av_malloc(data_size);
if (!st->codec->extradata) if (!st->codec->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (get_buffer(pb, st->codec->extradata, data_size) < 0) if (avio_read(pb, st->codec->extradata, data_size) < 0)
return AVERROR(EIO); return AVERROR(EIO);
break; break;
@ -184,18 +184,18 @@ static int iff_read_header(AVFormatContext *s,
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
if (data_size <= 8) if (data_size <= 8)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
st->codec->width = get_be16(pb); st->codec->width = avio_rb16(pb);
st->codec->height = get_be16(pb); st->codec->height = avio_rb16(pb);
url_fskip(pb, 4); // x, y offset url_fskip(pb, 4); // x, y offset
st->codec->bits_per_coded_sample = get_byte(pb); st->codec->bits_per_coded_sample = avio_r8(pb);
if (data_size >= 11) { if (data_size >= 11) {
url_fskip(pb, 1); // masking url_fskip(pb, 1); // masking
compression = get_byte(pb); compression = avio_r8(pb);
} }
if (data_size >= 16) { if (data_size >= 16) {
url_fskip(pb, 3); // paddding, transparent url_fskip(pb, 3); // paddding, transparent
st->sample_aspect_ratio.num = get_byte(pb); st->sample_aspect_ratio.num = avio_r8(pb);
st->sample_aspect_ratio.den = get_byte(pb); st->sample_aspect_ratio.den = avio_r8(pb);
} }
break; break;
@ -286,7 +286,7 @@ static int iff_read_packet(AVFormatContext *s,
if(st->codec->channels == 2) { if(st->codec->channels == 2) {
uint8_t sample_buffer[PACKET_SIZE]; uint8_t sample_buffer[PACKET_SIZE];
ret = get_buffer(pb, sample_buffer, PACKET_SIZE); ret = avio_read(pb, sample_buffer, PACKET_SIZE);
if(av_new_packet(pkt, PACKET_SIZE) < 0) { if(av_new_packet(pkt, PACKET_SIZE) < 0) {
av_log(s, AV_LOG_ERROR, "cannot allocate packet\n"); av_log(s, AV_LOG_ERROR, "cannot allocate packet\n");
return AVERROR(ENOMEM); return AVERROR(ENOMEM);

2
libavformat/img2.c
View File

@ -298,7 +298,7 @@ static int read_packet(AVFormatContext *s1, AVPacket *pkt)
pkt->size= 0; pkt->size= 0;
for(i=0; i<3; i++){ for(i=0; i<3; i++){
if(size[i]){ if(size[i]){
ret[i]= get_buffer(f[i], pkt->data + pkt->size, size[i]); ret[i]= avio_read(f[i], pkt->data + pkt->size, size[i]);
if (!s->is_pipe) if (!s->is_pipe)
url_fclose(f[i]); url_fclose(f[i]);
if(ret[i]>0) if(ret[i]>0)

14
libavformat/ingenientdec.c
View File

@ -27,18 +27,18 @@ static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
{ {
int ret, size, w, h, unk1, unk2; int ret, size, w, h, unk1, unk2;
if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G')) if (avio_rl32(s->pb) != MKTAG('M', 'J', 'P', 'G'))
return AVERROR(EIO); // FIXME return AVERROR(EIO); // FIXME
size = get_le32(s->pb); size = avio_rl32(s->pb);
w = get_le16(s->pb); w = avio_rl16(s->pb);
h = get_le16(s->pb); h = avio_rl16(s->pb);
url_fskip(s->pb, 8); // zero + size (padded?) url_fskip(s->pb, 8); // zero + size (padded?)
url_fskip(s->pb, 2); url_fskip(s->pb, 2);
unk1 = get_le16(s->pb); unk1 = avio_rl16(s->pb);
unk2 = get_le16(s->pb); unk2 = avio_rl16(s->pb);
url_fskip(s->pb, 22); // ASCII timestamp url_fskip(s->pb, 22); // ASCII timestamp
av_log(s, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n", av_log(s, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
@ -49,7 +49,7 @@ static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
pkt->pos = url_ftell(s->pb); pkt->pos = url_ftell(s->pb);
pkt->stream_index = 0; pkt->stream_index = 0;
ret = get_buffer(s->pb, pkt->data, size); ret = avio_read(s->pb, pkt->data, size);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_free_packet(pkt);
return ret; return ret;

22
libavformat/ipmovie.c
View File

@ -166,7 +166,7 @@ static int load_ipmovie_packet(IPMVEContext *s, AVIOContext *pb,
url_fseek(pb, s->decode_map_chunk_offset, SEEK_SET); url_fseek(pb, s->decode_map_chunk_offset, SEEK_SET);
s->decode_map_chunk_offset = 0; s->decode_map_chunk_offset = 0;
if (get_buffer(pb, pkt->data, s->decode_map_chunk_size) != if (avio_read(pb, pkt->data, s->decode_map_chunk_size) !=
s->decode_map_chunk_size) { s->decode_map_chunk_size) {
av_free_packet(pkt); av_free_packet(pkt);
return CHUNK_EOF; return CHUNK_EOF;
@ -175,7 +175,7 @@ static int load_ipmovie_packet(IPMVEContext *s, AVIOContext *pb,
url_fseek(pb, s->video_chunk_offset, SEEK_SET); url_fseek(pb, s->video_chunk_offset, SEEK_SET);
s->video_chunk_offset = 0; s->video_chunk_offset = 0;
if (get_buffer(pb, pkt->data + s->decode_map_chunk_size, if (avio_read(pb, pkt->data + s->decode_map_chunk_size,
s->video_chunk_size) != s->video_chunk_size) { s->video_chunk_size) != s->video_chunk_size) {
av_free_packet(pkt); av_free_packet(pkt);
return CHUNK_EOF; return CHUNK_EOF;
@ -227,7 +227,7 @@ static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,
/* read the next chunk, wherever the file happens to be pointing */ /* read the next chunk, wherever the file happens to be pointing */
if (url_feof(pb)) if (url_feof(pb))
return CHUNK_EOF; return CHUNK_EOF;
if (get_buffer(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) != if (avio_read(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) !=
CHUNK_PREAMBLE_SIZE) CHUNK_PREAMBLE_SIZE)
return CHUNK_BAD; return CHUNK_BAD;
chunk_size = AV_RL16(&chunk_preamble[0]); chunk_size = AV_RL16(&chunk_preamble[0]);
@ -275,7 +275,7 @@ static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,
chunk_type = CHUNK_EOF; chunk_type = CHUNK_EOF;
break; break;
} }
if (get_buffer(pb, opcode_preamble, CHUNK_PREAMBLE_SIZE) != if (avio_read(pb, opcode_preamble, CHUNK_PREAMBLE_SIZE) !=
CHUNK_PREAMBLE_SIZE) { CHUNK_PREAMBLE_SIZE) {
chunk_type = CHUNK_BAD; chunk_type = CHUNK_BAD;
break; break;
@ -314,7 +314,7 @@ static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,
chunk_type = CHUNK_BAD; chunk_type = CHUNK_BAD;
break; break;
} }
if (get_buffer(pb, scratch, opcode_size) != if (avio_read(pb, scratch, opcode_size) !=
opcode_size) { opcode_size) {
chunk_type = CHUNK_BAD; chunk_type = CHUNK_BAD;
break; break;
@ -331,7 +331,7 @@ static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,
chunk_type = CHUNK_BAD; chunk_type = CHUNK_BAD;
break; break;
} }
if (get_buffer(pb, scratch, opcode_size) != if (avio_read(pb, scratch, opcode_size) !=
opcode_size) { opcode_size) {
chunk_type = CHUNK_BAD; chunk_type = CHUNK_BAD;
break; break;
@ -369,7 +369,7 @@ static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,
chunk_type = CHUNK_BAD; chunk_type = CHUNK_BAD;
break; break;
} }
if (get_buffer(pb, scratch, opcode_size) != if (avio_read(pb, scratch, opcode_size) !=
opcode_size) { opcode_size) {
chunk_type = CHUNK_BAD; chunk_type = CHUNK_BAD;
break; break;
@ -434,7 +434,7 @@ static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,
chunk_type = CHUNK_BAD; chunk_type = CHUNK_BAD;
break; break;
} }
if (get_buffer(pb, scratch, opcode_size) != opcode_size) { if (avio_read(pb, scratch, opcode_size) != opcode_size) {
chunk_type = CHUNK_BAD; chunk_type = CHUNK_BAD;
break; break;
} }
@ -528,10 +528,10 @@ static int ipmovie_read_header(AVFormatContext *s,
int chunk_type; int chunk_type;
uint8_t signature_buffer[sizeof(signature)]; uint8_t signature_buffer[sizeof(signature)];
get_buffer(pb, signature_buffer, sizeof(signature_buffer)); avio_read(pb, signature_buffer, sizeof(signature_buffer));
while (memcmp(signature_buffer, signature, sizeof(signature))) { while (memcmp(signature_buffer, signature, sizeof(signature))) {
memmove(signature_buffer, signature_buffer + 1, sizeof(signature_buffer) - 1); memmove(signature_buffer, signature_buffer + 1, sizeof(signature_buffer) - 1);
signature_buffer[sizeof(signature_buffer) - 1] = get_byte(pb); signature_buffer[sizeof(signature_buffer) - 1] = avio_r8(pb);
if (url_feof(pb)) if (url_feof(pb))
return AVERROR_EOF; return AVERROR_EOF;
} }
@ -549,7 +549,7 @@ static int ipmovie_read_header(AVFormatContext *s,
/* peek ahead to the next chunk-- if it is an init audio chunk, process /* peek ahead to the next chunk-- if it is an init audio chunk, process
* it; if it is the first video chunk, this is a silent file */ * it; if it is the first video chunk, this is a silent file */
if (get_buffer(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) != if (avio_read(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) !=
CHUNK_PREAMBLE_SIZE) CHUNK_PREAMBLE_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
chunk_type = AV_RL16(&chunk_preamble[2]); chunk_type = AV_RL16(&chunk_preamble[2]);

16
libavformat/isom.c
View File

@ -346,7 +346,7 @@ int ff_mp4_read_descr_len(AVIOContext *pb)
int len = 0; int len = 0;
int count = 4; int count = 4;
while (count--) { while (count--) {
int c = get_byte(pb); int c = avio_r8(pb);
len = (len << 7) | (c & 0x7f); len = (len << 7) | (c & 0x7f);
if (!(c & 0x80)) if (!(c & 0x80))
break; break;
@ -357,7 +357,7 @@ int ff_mp4_read_descr_len(AVIOContext *pb)
int ff_mp4_read_descr(AVFormatContext *fc, AVIOContext *pb, int *tag) int ff_mp4_read_descr(AVFormatContext *fc, AVIOContext *pb, int *tag)
{ {
int len; int len;
*tag = get_byte(pb); *tag = avio_r8(pb);
len = ff_mp4_read_descr_len(pb); len = ff_mp4_read_descr_len(pb);
av_dlog(fc, "MPEG4 description: tag=0x%02x len=%d\n", *tag, len); av_dlog(fc, "MPEG4 description: tag=0x%02x len=%d\n", *tag, len);
return len; return len;
@ -375,11 +375,11 @@ static const AVCodecTag mp4_audio_types[] = {
int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, AVIOContext *pb) int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, AVIOContext *pb)
{ {
int len, tag; int len, tag;
int object_type_id = get_byte(pb); int object_type_id = avio_r8(pb);
get_byte(pb); /* stream type */ avio_r8(pb); /* stream type */
get_be24(pb); /* buffer size db */ avio_rb24(pb); /* buffer size db */
get_be32(pb); /* max bitrate */ avio_rb32(pb); /* max bitrate */
get_be32(pb); /* avg bitrate */ avio_rb32(pb); /* avg bitrate */
st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id); st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id);
av_dlog(fc, "esds object type id 0x%02x\n", object_type_id); av_dlog(fc, "esds object type id 0x%02x\n", object_type_id);
@ -392,7 +392,7 @@ int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, AVIOContext
st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE); st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codec->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
get_buffer(pb, st->codec->extradata, len); avio_read(pb, st->codec->extradata, len);
st->codec->extradata_size = len; st->codec->extradata_size = len;
if (st->codec->codec_id == CODEC_ID_AAC) { if (st->codec->codec_id == CODEC_ID_AAC) {
MPEG4AudioConfig cfg; MPEG4AudioConfig cfg;

4
libavformat/iss.c
View File

@ -44,7 +44,7 @@ static void get_token(AVIOContext *s, char *buf, int maxlen)
int i = 0; int i = 0;
char c; char c;
while ((c = get_byte(s))) { while ((c = avio_r8(s))) {
if(c == ' ') if(c == ' ')
break; break;
if (i < maxlen-1) if (i < maxlen-1)
@ -52,7 +52,7 @@ static void get_token(AVIOContext *s, char *buf, int maxlen)
} }
if(!c) if(!c)
get_byte(s); avio_r8(s);
buf[i] = 0; /* Ensure null terminated, but may be truncated */ buf[i] = 0; /* Ensure null terminated, but may be truncated */
} }

12
libavformat/iv8.c
View File

@ -57,13 +57,13 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
{ {
int ret, size, pts, type; int ret, size, pts, type;
retry: retry:
type= get_be16(s->pb); // 257 or 258 type= avio_rb16(s->pb); // 257 or 258
size= get_be16(s->pb); size= avio_rb16(s->pb);
get_be16(s->pb); //some flags, 0x80 indicates end of frame avio_rb16(s->pb); //some flags, 0x80 indicates end of frame
get_be16(s->pb); //packet number avio_rb16(s->pb); //packet number
pts=get_be32(s->pb); pts=avio_rb32(s->pb);
get_be32(s->pb); //6A 13 E3 88 avio_rb32(s->pb); //6A 13 E3 88
size -= 12; size -= 12;
if(size<1) if(size<1)

22
libavformat/ivfdec.c
View File

@ -36,9 +36,9 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
AVStream *st; AVStream *st;
AVRational time_base; AVRational time_base;
get_le32(s->pb); // DKIF avio_rl32(s->pb); // DKIF
get_le16(s->pb); // version avio_rl16(s->pb); // version
get_le16(s->pb); // header size avio_rl16(s->pb); // header size
st = av_new_stream(s, 0); st = av_new_stream(s, 0);
if (!st) if (!st)
@ -46,13 +46,13 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_tag = get_le32(s->pb); st->codec->codec_tag = avio_rl32(s->pb);
st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, st->codec->codec_tag); st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, st->codec->codec_tag);
st->codec->width = get_le16(s->pb); st->codec->width = avio_rl16(s->pb);
st->codec->height = get_le16(s->pb); st->codec->height = avio_rl16(s->pb);
time_base.den = get_le32(s->pb); time_base.den = avio_rl32(s->pb);
time_base.num = get_le32(s->pb); time_base.num = avio_rl32(s->pb);
st->duration = get_le64(s->pb); st->duration = avio_rl64(s->pb);
st->need_parsing = AVSTREAM_PARSE_HEADERS; st->need_parsing = AVSTREAM_PARSE_HEADERS;
@ -68,8 +68,8 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
static int read_packet(AVFormatContext *s, AVPacket *pkt) static int read_packet(AVFormatContext *s, AVPacket *pkt)
{ {
int ret, size = get_le32(s->pb); int ret, size = avio_rl32(s->pb);
int64_t pts = get_le64(s->pb); int64_t pts = avio_rl64(s->pb);
ret = av_get_packet(s->pb, pkt, size); ret = av_get_packet(s->pb, pkt, size);
pkt->stream_index = 0; pkt->stream_index = 0;

2
libavformat/libnut.c
View File

@ -173,7 +173,7 @@ static int nut_probe(AVProbeData *p) {
static size_t av_read(void * h, size_t len, uint8_t * buf) { static size_t av_read(void * h, size_t len, uint8_t * buf) {
AVIOContext * bc = h; AVIOContext * bc = h;
return get_buffer(bc, buf, len); return avio_read(bc, buf, len);
} }
static off_t av_seek(void * h, long long pos, int whence) { static off_t av_seek(void * h, long long pos, int whence) {

6
libavformat/lmlm4.c
View File

@ -82,9 +82,9 @@ static int lmlm4_read_packet(AVFormatContext *s, AVPacket *pkt) {
int ret; int ret;
unsigned int frame_type, packet_size, padding, frame_size; unsigned int frame_type, packet_size, padding, frame_size;
get_be16(pb); /* channel number */ avio_rb16(pb); /* channel number */
frame_type = get_be16(pb); frame_type = avio_rb16(pb);
packet_size = get_be32(pb); packet_size = avio_rb32(pb);
padding = -packet_size & 511; padding = -packet_size & 511;
frame_size = packet_size - 8; frame_size = packet_size - 8;

10
libavformat/lxfdec.c
View File

@ -86,7 +86,7 @@ static int sync(AVFormatContext *s, uint8_t *header)
uint8_t buf[LXF_IDENT_LENGTH]; uint8_t buf[LXF_IDENT_LENGTH];
int ret; int ret;
if ((ret = get_buffer(s->pb, buf, LXF_IDENT_LENGTH)) != LXF_IDENT_LENGTH) if ((ret = avio_read(s->pb, buf, LXF_IDENT_LENGTH)) != LXF_IDENT_LENGTH)
return ret < 0 ? ret : AVERROR_EOF; return ret < 0 ? ret : AVERROR_EOF;
while (memcmp(buf, LXF_IDENT, LXF_IDENT_LENGTH)) { while (memcmp(buf, LXF_IDENT, LXF_IDENT_LENGTH)) {
@ -94,7 +94,7 @@ static int sync(AVFormatContext *s, uint8_t *header)
return AVERROR_EOF; return AVERROR_EOF;
memmove(buf, &buf[1], LXF_IDENT_LENGTH-1); memmove(buf, &buf[1], LXF_IDENT_LENGTH-1);
buf[LXF_IDENT_LENGTH-1] = get_byte(s->pb); buf[LXF_IDENT_LENGTH-1] = avio_r8(s->pb);
} }
memcpy(header, LXF_IDENT, LXF_IDENT_LENGTH); memcpy(header, LXF_IDENT, LXF_IDENT_LENGTH);
@ -120,7 +120,7 @@ static int get_packet_header(AVFormatContext *s, uint8_t *header, uint32_t *form
return ret; return ret;
//read the rest of the packet header //read the rest of the packet header
if ((ret = get_buffer(pb, header + LXF_IDENT_LENGTH, if ((ret = avio_read(pb, header + LXF_IDENT_LENGTH,
LXF_PACKET_HEADER_SIZE - LXF_IDENT_LENGTH)) != LXF_PACKET_HEADER_SIZE - LXF_IDENT_LENGTH)) !=
LXF_PACKET_HEADER_SIZE - LXF_IDENT_LENGTH) { LXF_PACKET_HEADER_SIZE - LXF_IDENT_LENGTH) {
return ret < 0 ? ret : AVERROR_EOF; return ret < 0 ? ret : AVERROR_EOF;
@ -214,7 +214,7 @@ static int lxf_read_header(AVFormatContext *s, AVFormatParameters *ap)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if ((ret = get_buffer(pb, header_data, LXF_HEADER_DATA_SIZE)) != LXF_HEADER_DATA_SIZE) if ((ret = avio_read(pb, header_data, LXF_HEADER_DATA_SIZE)) != LXF_HEADER_DATA_SIZE)
return ret < 0 ? ret : AVERROR_EOF; return ret < 0 ? ret : AVERROR_EOF;
if (!(st = av_new_stream(s, 0))) if (!(st = av_new_stream(s, 0)))
@ -315,7 +315,7 @@ static int lxf_read_packet(AVFormatContext *s, AVPacket *pkt)
//read non-20-bit audio data into lxf->temp so we can deplanarize it //read non-20-bit audio data into lxf->temp so we can deplanarize it
buf = ast && ast->codec->codec_id != CODEC_ID_PCM_LXF ? lxf->temp : pkt->data; buf = ast && ast->codec->codec_id != CODEC_ID_PCM_LXF ? lxf->temp : pkt->data;
if ((ret2 = get_buffer(pb, buf, ret)) != ret) { if ((ret2 = avio_read(pb, buf, ret)) != ret) {
av_free_packet(pkt); av_free_packet(pkt);
return ret2 < 0 ? ret2 : AVERROR_EOF; return ret2 < 0 ? ret2 : AVERROR_EOF;
} }

26
libavformat/matroskadec.c
View File

@ -543,10 +543,10 @@ static int ebml_read_num(MatroskaDemuxContext *matroska, AVIOContext *pb,
int read = 1, n = 1; int read = 1, n = 1;
uint64_t total = 0; uint64_t total = 0;
/* The first byte tells us the length in bytes - get_byte() can normally /* The first byte tells us the length in bytes - avio_r8() can normally
* return 0, but since that's not a valid first ebmlID byte, we can * return 0, but since that's not a valid first ebmlID byte, we can
* use it safely here to catch EOS. */ * use it safely here to catch EOS. */
if (!(total = get_byte(pb))) { if (!(total = avio_r8(pb))) {
/* we might encounter EOS here */ /* we might encounter EOS here */
if (!url_feof(pb)) { if (!url_feof(pb)) {
int64_t pos = url_ftell(pb); int64_t pos = url_ftell(pb);
@ -570,7 +570,7 @@ static int ebml_read_num(MatroskaDemuxContext *matroska, AVIOContext *pb,
/* read out length */ /* read out length */
total ^= 1 << ff_log2_tab[total]; total ^= 1 << ff_log2_tab[total];
while (n++ < read) while (n++ < read)
total = (total << 8) | get_byte(pb); total = (total << 8) | avio_r8(pb);
*number = total; *number = total;
@ -605,7 +605,7 @@ static int ebml_read_uint(AVIOContext *pb, int size, uint64_t *num)
/* big-endian ordering; build up number */ /* big-endian ordering; build up number */
*num = 0; *num = 0;
while (n++ < size) while (n++ < size)
*num = (*num << 8) | get_byte(pb); *num = (*num << 8) | avio_r8(pb);
return 0; return 0;
} }
@ -619,9 +619,9 @@ static int ebml_read_float(AVIOContext *pb, int size, double *num)
if (size == 0) { if (size == 0) {
*num = 0; *num = 0;
} else if (size == 4) { } else if (size == 4) {
*num= av_int2flt(get_be32(pb)); *num= av_int2flt(avio_rb32(pb));
} else if(size==8){ } else if(size==8){
*num= av_int2dbl(get_be64(pb)); *num= av_int2dbl(avio_rb64(pb));
} else } else
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -639,7 +639,7 @@ static int ebml_read_ascii(AVIOContext *pb, int size, char **str)
* byte more, read the string and NULL-terminate it ourselves. */ * byte more, read the string and NULL-terminate it ourselves. */
if (!(*str = av_malloc(size + 1))) if (!(*str = av_malloc(size + 1)))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (get_buffer(pb, (uint8_t *) *str, size) != size) { if (avio_read(pb, (uint8_t *) *str, size) != size) {
av_freep(str); av_freep(str);
return AVERROR(EIO); return AVERROR(EIO);
} }
@ -660,7 +660,7 @@ static int ebml_read_binary(AVIOContext *pb, int length, EbmlBin *bin)
bin->size = length; bin->size = length;
bin->pos = url_ftell(pb); bin->pos = url_ftell(pb);
if (get_buffer(pb, bin->data, length) != length) { if (avio_read(pb, bin->data, length) != length) {
av_freep(&bin->data); av_freep(&bin->data);
return AVERROR(EIO); return AVERROR(EIO);
} }
@ -1394,12 +1394,12 @@ static int matroska_read_header(AVFormatContext *s, AVFormatParameters *ap)
ffio_init_context(&b, track->codec_priv.data,track->codec_priv.size, ffio_init_context(&b, track->codec_priv.data,track->codec_priv.size,
0, NULL, NULL, NULL, NULL); 0, NULL, NULL, NULL, NULL);
url_fskip(&b, 22); url_fskip(&b, 22);
flavor = get_be16(&b); flavor = avio_rb16(&b);
track->audio.coded_framesize = get_be32(&b); track->audio.coded_framesize = avio_rb32(&b);
url_fskip(&b, 12); url_fskip(&b, 12);
track->audio.sub_packet_h = get_be16(&b); track->audio.sub_packet_h = avio_rb16(&b);
track->audio.frame_size = get_be16(&b); track->audio.frame_size = avio_rb16(&b);
track->audio.sub_packet_size = get_be16(&b); track->audio.sub_packet_size = avio_rb16(&b);
track->audio.buf = av_malloc(track->audio.frame_size * track->audio.sub_packet_h); track->audio.buf = av_malloc(track->audio.frame_size * track->audio.sub_packet_h);
if (codec_id == CODEC_ID_RA_288) { if (codec_id == CODEC_ID_RA_288) {
st->codec->block_align = track->audio.coded_framesize; st->codec->block_align = track->audio.coded_framesize;

18
libavformat/mm.c
View File

@ -90,18 +90,18 @@ static int read_header(AVFormatContext *s,
unsigned int type, length; unsigned int type, length;
unsigned int frame_rate, width, height; unsigned int frame_rate, width, height;
type = get_le16(pb); type = avio_rl16(pb);
length = get_le32(pb); length = avio_rl32(pb);
if (type != MM_TYPE_HEADER) if (type != MM_TYPE_HEADER)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
/* read header */ /* read header */
get_le16(pb); /* total number of chunks */ avio_rl16(pb); /* total number of chunks */
frame_rate = get_le16(pb); frame_rate = avio_rl16(pb);
get_le16(pb); /* ibm-pc video bios mode */ avio_rl16(pb); /* ibm-pc video bios mode */
width = get_le16(pb); width = avio_rl16(pb);
height = get_le16(pb); height = avio_rl16(pb);
url_fseek(pb, length - 10, SEEK_CUR); /* unknown data */ url_fseek(pb, length - 10, SEEK_CUR); /* unknown data */
/* video stream */ /* video stream */
@ -143,7 +143,7 @@ static int read_packet(AVFormatContext *s,
while(1) { while(1) {
if (get_buffer(pb, preamble, MM_PREAMBLE_SIZE) != MM_PREAMBLE_SIZE) { if (avio_read(pb, preamble, MM_PREAMBLE_SIZE) != MM_PREAMBLE_SIZE) {
return AVERROR(EIO); return AVERROR(EIO);
} }
@ -162,7 +162,7 @@ static int read_packet(AVFormatContext *s,
if (av_new_packet(pkt, length + MM_PREAMBLE_SIZE)) if (av_new_packet(pkt, length + MM_PREAMBLE_SIZE))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
memcpy(pkt->data, preamble, MM_PREAMBLE_SIZE); memcpy(pkt->data, preamble, MM_PREAMBLE_SIZE);
if (get_buffer(pb, pkt->data + MM_PREAMBLE_SIZE, length) != length) if (avio_read(pb, pkt->data + MM_PREAMBLE_SIZE, length) != length)
return AVERROR(EIO); return AVERROR(EIO);
pkt->size = length + MM_PREAMBLE_SIZE; pkt->size = length + MM_PREAMBLE_SIZE;
pkt->stream_index = 0; pkt->stream_index = 0;

26
libavformat/mmf.c
View File

@ -188,15 +188,15 @@ static int mmf_read_header(AVFormatContext *s,
int64_t file_size, size; int64_t file_size, size;
int rate, params; int rate, params;
tag = get_le32(pb); tag = avio_rl32(pb);
if (tag != MKTAG('M', 'M', 'M', 'D')) if (tag != MKTAG('M', 'M', 'M', 'D'))
return -1; return -1;
file_size = get_be32(pb); file_size = avio_rb32(pb);
/* Skip some unused chunks that may or may not be present */ /* Skip some unused chunks that may or may not be present */
for(;; url_fseek(pb, size, SEEK_CUR)) { for(;; url_fseek(pb, size, SEEK_CUR)) {
tag = get_le32(pb); tag = avio_rl32(pb);
size = get_be32(pb); size = avio_rb32(pb);
if(tag == MKTAG('C','N','T','I')) continue; if(tag == MKTAG('C','N','T','I')) continue;
if(tag == MKTAG('O','P','D','A')) continue; if(tag == MKTAG('O','P','D','A')) continue;
break; break;
@ -212,22 +212,22 @@ static int mmf_read_header(AVFormatContext *s,
return -1; return -1;
} }
get_byte(pb); /* format type */ avio_r8(pb); /* format type */
get_byte(pb); /* sequence type */ avio_r8(pb); /* sequence type */
params = get_byte(pb); /* (channel << 7) | (format << 4) | rate */ params = avio_r8(pb); /* (channel << 7) | (format << 4) | rate */
rate = mmf_rate(params & 0x0f); rate = mmf_rate(params & 0x0f);
if(rate < 0) { if(rate < 0) {
av_log(s, AV_LOG_ERROR, "Invalid sample rate\n"); av_log(s, AV_LOG_ERROR, "Invalid sample rate\n");
return -1; return -1;
} }
get_byte(pb); /* wave base bit */ avio_r8(pb); /* wave base bit */
get_byte(pb); /* time base d */ avio_r8(pb); /* time base d */
get_byte(pb); /* time base g */ avio_r8(pb); /* time base g */
/* Skip some unused chunks that may or may not be present */ /* Skip some unused chunks that may or may not be present */
for(;; url_fseek(pb, size, SEEK_CUR)) { for(;; url_fseek(pb, size, SEEK_CUR)) {
tag = get_le32(pb); tag = avio_rl32(pb);
size = get_be32(pb); size = avio_rb32(pb);
if(tag == MKTAG('A','t','s','q')) continue; if(tag == MKTAG('A','t','s','q')) continue;
if(tag == MKTAG('A','s','p','I')) continue; if(tag == MKTAG('A','s','p','I')) continue;
break; break;
@ -280,7 +280,7 @@ static int mmf_read_packet(AVFormatContext *s,
return AVERROR(EIO); return AVERROR(EIO);
pkt->stream_index = 0; pkt->stream_index = 0;
ret = get_buffer(s->pb, pkt->data, pkt->size); ret = avio_read(s->pb, pkt->data, pkt->size);
if (ret < 0) if (ret < 0)
av_free_packet(pkt); av_free_packet(pkt);

474
libavformat/mov.c
View File

@ -83,11 +83,11 @@ static int mov_metadata_trkn(MOVContext *c, AVIOContext *pb, unsigned len)
{ {
char buf[16]; char buf[16];
get_be16(pb); // unknown avio_rb16(pb); // unknown
snprintf(buf, sizeof(buf), "%d", get_be16(pb)); snprintf(buf, sizeof(buf), "%d", avio_rb16(pb));
av_metadata_set2(&c->fc->metadata, "track", buf, 0); av_metadata_set2(&c->fc->metadata, "track", buf, 0);
get_be16(pb); // total tracks avio_rb16(pb); // total tracks
return 0; return 0;
} }
@ -119,7 +119,7 @@ static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len,
int i; int i;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
uint8_t t, c = get_byte(pb); uint8_t t, c = avio_r8(pb);
if (c < 0x80 && p < end) if (c < 0x80 && p < end)
*p++ = c; *p++ = c;
else else
@ -165,17 +165,17 @@ static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
} }
if (c->itunes_metadata && atom.size > 8) { if (c->itunes_metadata && atom.size > 8) {
int data_size = get_be32(pb); int data_size = avio_rb32(pb);
int tag = get_le32(pb); int tag = avio_rl32(pb);
if (tag == MKTAG('d','a','t','a')) { if (tag == MKTAG('d','a','t','a')) {
data_type = get_be32(pb); // type data_type = avio_rb32(pb); // type
get_be32(pb); // unknown avio_rb32(pb); // unknown
str_size = data_size - 16; str_size = data_size - 16;
atom.size -= 16; atom.size -= 16;
} else return 0; } else return 0;
} else if (atom.size > 4 && key && !c->itunes_metadata) { } else if (atom.size > 4 && key && !c->itunes_metadata) {
str_size = get_be16(pb); // string length str_size = avio_rb16(pb); // string length
langcode = get_be16(pb); langcode = avio_rb16(pb);
ff_mov_lang_to_iso639(langcode, language); ff_mov_lang_to_iso639(langcode, language);
atom.size -= 4; atom.size -= 4;
} else } else
@ -201,7 +201,7 @@ static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (data_type == 3 || (data_type == 0 && langcode < 0x800)) { // MAC Encoded if (data_type == 3 || (data_type == 0 && langcode < 0x800)) { // MAC Encoded
mov_read_mac_string(c, pb, str_size, str, sizeof(str)); mov_read_mac_string(c, pb, str_size, str, sizeof(str));
} else { } else {
get_buffer(pb, str, str_size); avio_read(pb, str, str_size);
str[str_size] = 0; str[str_size] = 0;
} }
av_metadata_set2(&c->fc->metadata, key, str, 0); av_metadata_set2(&c->fc->metadata, key, str, 0);
@ -228,23 +228,23 @@ static int mov_read_chpl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if ((atom.size -= 5) < 0) if ((atom.size -= 5) < 0)
return 0; return 0;
version = get_byte(pb); version = avio_r8(pb);
get_be24(pb); avio_rb24(pb);
if (version) if (version)
get_be32(pb); // ??? avio_rb32(pb); // ???
nb_chapters = get_byte(pb); nb_chapters = avio_r8(pb);
for (i = 0; i < nb_chapters; i++) { for (i = 0; i < nb_chapters; i++) {
if (atom.size < 9) if (atom.size < 9)
return 0; return 0;
start = get_be64(pb); start = avio_rb64(pb);
str_len = get_byte(pb); str_len = avio_r8(pb);
if ((atom.size -= 9+str_len) < 0) if ((atom.size -= 9+str_len) < 0)
return 0; return 0;
get_buffer(pb, str, str_len); avio_read(pb, str, str_len);
str[str_len] = 0; str[str_len] = 0;
ff_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str); ff_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);
} }
@ -264,14 +264,14 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
a.size = atom.size; a.size = atom.size;
a.type=0; a.type=0;
if(atom.size >= 8) { if(atom.size >= 8) {
a.size = get_be32(pb); a.size = avio_rb32(pb);
a.type = get_le32(pb); a.type = avio_rl32(pb);
} }
av_dlog(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n", av_dlog(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size); a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size);
total_size += 8; total_size += 8;
if (a.size == 1) { /* 64 bit extended size */ if (a.size == 1) { /* 64 bit extended size */
a.size = get_be64(pb) - 8; a.size = avio_rb64(pb) - 8;
total_size += 8; total_size += 8;
} }
if (a.size == 0) { if (a.size == 0) {
@ -331,8 +331,8 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data; sc = st->priv_data;
get_be32(pb); // version + flags avio_rb32(pb); // version + flags
entries = get_be32(pb); entries = avio_rb32(pb);
if (entries >= UINT_MAX / sizeof(*sc->drefs)) if (entries >= UINT_MAX / sizeof(*sc->drefs))
return -1; return -1;
sc->drefs = av_mallocz(entries * sizeof(*sc->drefs)); sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
@ -342,14 +342,14 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
for (i = 0; i < sc->drefs_count; i++) { for (i = 0; i < sc->drefs_count; i++) {
MOVDref *dref = &sc->drefs[i]; MOVDref *dref = &sc->drefs[i];
uint32_t size = get_be32(pb); uint32_t size = avio_rb32(pb);
int64_t next = url_ftell(pb) + size - 4; int64_t next = url_ftell(pb) + size - 4;
if (size < 12) if (size < 12)
return -1; return -1;
dref->type = get_le32(pb); dref->type = avio_rl32(pb);
get_be32(pb); // version + flags avio_rb32(pb); // version + flags
av_dlog(c->fc, "type %.4s size %d\n", (char*)&dref->type, size); av_dlog(c->fc, "type %.4s size %d\n", (char*)&dref->type, size);
if (dref->type == MKTAG('a','l','i','s') && size > 150) { if (dref->type == MKTAG('a','l','i','s') && size > 150) {
@ -359,33 +359,33 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
url_fskip(pb, 10); url_fskip(pb, 10);
volume_len = get_byte(pb); volume_len = avio_r8(pb);
volume_len = FFMIN(volume_len, 27); volume_len = FFMIN(volume_len, 27);
get_buffer(pb, dref->volume, 27); avio_read(pb, dref->volume, 27);
dref->volume[volume_len] = 0; dref->volume[volume_len] = 0;
av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len); av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
url_fskip(pb, 12); url_fskip(pb, 12);
len = get_byte(pb); len = avio_r8(pb);
len = FFMIN(len, 63); len = FFMIN(len, 63);
get_buffer(pb, dref->filename, 63); avio_read(pb, dref->filename, 63);
dref->filename[len] = 0; dref->filename[len] = 0;
av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len); av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
url_fskip(pb, 16); url_fskip(pb, 16);
/* read next level up_from_alias/down_to_target */ /* read next level up_from_alias/down_to_target */
dref->nlvl_from = get_be16(pb); dref->nlvl_from = avio_rb16(pb);
dref->nlvl_to = get_be16(pb); dref->nlvl_to = avio_rb16(pb);
av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n", av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
dref->nlvl_from, dref->nlvl_to); dref->nlvl_from, dref->nlvl_to);
url_fskip(pb, 16); url_fskip(pb, 16);
for (type = 0; type != -1 && url_ftell(pb) < next; ) { for (type = 0; type != -1 && url_ftell(pb) < next; ) {
type = get_be16(pb); type = avio_rb16(pb);
len = get_be16(pb); len = avio_rb16(pb);
av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len); av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
if (len&1) if (len&1)
len += 1; len += 1;
@ -394,7 +394,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
dref->path = av_mallocz(len+1); dref->path = av_mallocz(len+1);
if (!dref->path) if (!dref->path)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
get_buffer(pb, dref->path, len); avio_read(pb, dref->path, len);
if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) { if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
len -= volume_len; len -= volume_len;
memmove(dref->path, dref->path+volume_len, len); memmove(dref->path, dref->path+volume_len, len);
@ -409,7 +409,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
dref->dir = av_malloc(len+1); dref->dir = av_malloc(len+1);
if (!dref->dir) if (!dref->dir)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
get_buffer(pb, dref->dir, len); avio_read(pb, dref->dir, len);
dref->dir[len] = 0; dref->dir[len] = 0;
for (j = 0; j < len; j++) for (j = 0; j < len; j++)
if (dref->dir[j] == ':') if (dref->dir[j] == ':')
@ -435,12 +435,12 @@ static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
get_byte(pb); /* version */ avio_r8(pb); /* version */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
/* component type */ /* component type */
ctype = get_le32(pb); ctype = avio_rl32(pb);
type = get_le32(pb); /* component subtype */ type = avio_rl32(pb); /* component subtype */
av_dlog(c->fc, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype); av_dlog(c->fc, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype);
av_dlog(c->fc, "stype= %.4s\n", (char*)&type); av_dlog(c->fc, "stype= %.4s\n", (char*)&type);
@ -454,9 +454,9 @@ static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
else if(type == MKTAG('s','u','b','p')) else if(type == MKTAG('s','u','b','p'))
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE; st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
get_be32(pb); /* component manufacture */ avio_rb32(pb); /* component manufacture */
get_be32(pb); /* component flags */ avio_rb32(pb); /* component flags */
get_be32(pb); /* component flags mask */ avio_rb32(pb); /* component flags mask */
return 0; return 0;
} }
@ -470,13 +470,13 @@ int ff_mov_read_esds(AVFormatContext *fc, AVIOContext *pb, MOVAtom atom)
return 0; return 0;
st = fc->streams[fc->nb_streams-1]; st = fc->streams[fc->nb_streams-1];
get_be32(pb); /* version + flags */ avio_rb32(pb); /* version + flags */
len = ff_mp4_read_descr(fc, pb, &tag); len = ff_mp4_read_descr(fc, pb, &tag);
if (tag == MP4ESDescrTag) { if (tag == MP4ESDescrTag) {
get_be16(pb); /* ID */ avio_rb16(pb); /* ID */
get_byte(pb); /* priority */ avio_r8(pb); /* priority */
} else } else
get_be16(pb); /* ID */ avio_rb16(pb); /* ID */
len = ff_mp4_read_descr(fc, pb, &tag); len = ff_mp4_read_descr(fc, pb, &tag);
if (tag == MP4DecConfigDescrTag) if (tag == MP4DecConfigDescrTag)
@ -498,7 +498,7 @@ static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
return 0; return 0;
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
ac3info = get_be24(pb); ac3info = avio_rb24(pb);
acmod = (ac3info >> 11) & 0x7; acmod = (ac3info >> 11) & 0x7;
lfeon = (ac3info >> 10) & 0x1; lfeon = (ac3info >> 10) & 0x1;
st->codec->channels = ((int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon; st->codec->channels = ((int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;
@ -508,8 +508,8 @@ static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom) static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{ {
const int num = get_be32(pb); const int num = avio_rb32(pb);
const int den = get_be32(pb); const int den = avio_rb32(pb);
AVStream *st; AVStream *st;
if (c->fc->nb_streams < 1) if (c->fc->nb_streams < 1)
@ -547,12 +547,12 @@ static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
char* comp_brands_str; char* comp_brands_str;
uint8_t type[5] = {0}; uint8_t type[5] = {0};
get_buffer(pb, type, 4); avio_read(pb, type, 4);
if (strcmp(type, "qt ")) if (strcmp(type, "qt "))
c->isom = 1; c->isom = 1;
av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type); av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
av_metadata_set2(&c->fc->metadata, "major_brand", type, 0); av_metadata_set2(&c->fc->metadata, "major_brand", type, 0);
minor_ver = get_be32(pb); /* minor version */ minor_ver = avio_rb32(pb); /* minor version */
snprintf(minor_ver_str, sizeof(minor_ver_str), "%d", minor_ver); snprintf(minor_ver_str, sizeof(minor_ver_str), "%d", minor_ver);
av_metadata_set2(&c->fc->metadata, "minor_version", minor_ver_str, 0); av_metadata_set2(&c->fc->metadata, "minor_version", minor_ver_str, 0);
@ -562,7 +562,7 @@ static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */ comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
if (!comp_brands_str) if (!comp_brands_str)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
get_buffer(pb, comp_brands_str, comp_brand_size); avio_read(pb, comp_brands_str, comp_brand_size);
comp_brands_str[comp_brand_size] = 0; comp_brands_str[comp_brand_size] = 0;
av_metadata_set2(&c->fc->metadata, "compatible_brands", comp_brands_str, 0); av_metadata_set2(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);
av_freep(&comp_brands_str); av_freep(&comp_brands_str);
@ -615,27 +615,27 @@ static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data; sc = st->priv_data;
version = get_byte(pb); version = avio_r8(pb);
if (version > 1) if (version > 1)
return -1; /* unsupported */ return -1; /* unsupported */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
if (version == 1) { if (version == 1) {
creation_time = get_be64(pb); creation_time = avio_rb64(pb);
get_be64(pb); avio_rb64(pb);
} else { } else {
creation_time = get_be32(pb); creation_time = avio_rb32(pb);
get_be32(pb); /* modification time */ avio_rb32(pb); /* modification time */
} }
mov_metadata_creation_time(&st->metadata, creation_time); mov_metadata_creation_time(&st->metadata, creation_time);
sc->time_scale = get_be32(pb); sc->time_scale = avio_rb32(pb);
st->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */ st->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
lang = get_be16(pb); /* language */ lang = avio_rb16(pb); /* language */
if (ff_mov_lang_to_iso639(lang, language)) if (ff_mov_lang_to_iso639(lang, language))
av_metadata_set2(&st->metadata, "language", language, 0); av_metadata_set2(&st->metadata, "language", language, 0);
get_be16(pb); /* quality */ avio_rb16(pb); /* quality */
return 0; return 0;
} }
@ -643,37 +643,37 @@ static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom) static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{ {
time_t creation_time; time_t creation_time;
int version = get_byte(pb); /* version */ int version = avio_r8(pb); /* version */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
if (version == 1) { if (version == 1) {
creation_time = get_be64(pb); creation_time = avio_rb64(pb);
get_be64(pb); avio_rb64(pb);
} else { } else {
creation_time = get_be32(pb); creation_time = avio_rb32(pb);
get_be32(pb); /* modification time */ avio_rb32(pb); /* modification time */
} }
mov_metadata_creation_time(&c->fc->metadata, creation_time); mov_metadata_creation_time(&c->fc->metadata, creation_time);
c->time_scale = get_be32(pb); /* time scale */ c->time_scale = avio_rb32(pb); /* time scale */
av_dlog(c->fc, "time scale = %i\n", c->time_scale); av_dlog(c->fc, "time scale = %i\n", c->time_scale);
c->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */ c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
get_be32(pb); /* preferred scale */ avio_rb32(pb); /* preferred scale */
get_be16(pb); /* preferred volume */ avio_rb16(pb); /* preferred volume */
url_fskip(pb, 10); /* reserved */ url_fskip(pb, 10); /* reserved */
url_fskip(pb, 36); /* display matrix */ url_fskip(pb, 36); /* display matrix */
get_be32(pb); /* preview time */ avio_rb32(pb); /* preview time */
get_be32(pb); /* preview duration */ avio_rb32(pb); /* preview duration */
get_be32(pb); /* poster time */ avio_rb32(pb); /* poster time */
get_be32(pb); /* selection time */ avio_rb32(pb); /* selection time */
get_be32(pb); /* selection duration */ avio_rb32(pb); /* selection duration */
get_be32(pb); /* current time */ avio_rb32(pb); /* current time */
get_be32(pb); /* next track ID */ avio_rb32(pb); /* next track ID */
return 0; return 0;
} }
@ -697,7 +697,7 @@ static int mov_read_smi(MOVContext *c, AVIOContext *pb, MOVAtom atom)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata_size = 0x5a + atom.size; st->codec->extradata_size = 0x5a + atom.size;
memcpy(st->codec->extradata, "SVQ3", 4); // fake memcpy(st->codec->extradata, "SVQ3", 4); // fake
get_buffer(pb, st->codec->extradata + 0x5a, atom.size); avio_read(pb, st->codec->extradata + 0x5a, atom.size);
av_dlog(c->fc, "Reading SMI %"PRId64" %s\n", atom.size, st->codec->extradata + 0x5a); av_dlog(c->fc, "Reading SMI %"PRId64" %s\n", atom.size, st->codec->extradata + 0x5a);
return 0; return 0;
} }
@ -711,7 +711,7 @@ static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
return 0; return 0;
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
little_endian = get_be16(pb); little_endian = avio_rb16(pb);
av_dlog(c->fc, "enda %d\n", little_endian); av_dlog(c->fc, "enda %d\n", little_endian);
if (little_endian == 1) { if (little_endian == 1) {
switch (st->codec->codec_id) { switch (st->codec->codec_id) {
@ -755,7 +755,7 @@ static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE; st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;
AV_WB32( buf , atom.size + 8); AV_WB32( buf , atom.size + 8);
AV_WL32( buf + 4, atom.type); AV_WL32( buf + 4, atom.type);
get_buffer(pb, buf + 8, atom.size); avio_read(pb, buf + 8, atom.size);
return 0; return 0;
} }
@ -777,7 +777,7 @@ static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (!st->codec->extradata) if (!st->codec->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata_size = atom.size; st->codec->extradata_size = atom.size;
get_buffer(pb, st->codec->extradata, atom.size); avio_read(pb, st->codec->extradata, atom.size);
} else if (atom.size > 8) { /* to read frma, esds atoms */ } else if (atom.size > 8) { /* to read frma, esds atoms */
if (mov_read_default(c, pb, atom) < 0) if (mov_read_default(c, pb, atom) < 0)
return -1; return -1;
@ -806,7 +806,7 @@ static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (!st->codec->extradata) if (!st->codec->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata_size = atom.size; st->codec->extradata_size = atom.size;
get_buffer(pb, st->codec->extradata, atom.size); avio_read(pb, st->codec->extradata, atom.size);
return 0; return 0;
} }
@ -834,7 +834,7 @@ static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata_size = atom.size - 40; st->codec->extradata_size = atom.size - 40;
url_fskip(pb, 40); url_fskip(pb, 40);
get_buffer(pb, st->codec->extradata, atom.size - 40); avio_read(pb, st->codec->extradata, atom.size - 40);
return 0; return 0;
} }
@ -849,10 +849,10 @@ static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data; sc = st->priv_data;
get_byte(pb); /* version */ avio_r8(pb); /* version */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
entries = get_be32(pb); entries = avio_rb32(pb);
if(entries >= UINT_MAX/sizeof(int64_t)) if(entries >= UINT_MAX/sizeof(int64_t))
return -1; return -1;
@ -864,10 +864,10 @@ static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (atom.type == MKTAG('s','t','c','o')) if (atom.type == MKTAG('s','t','c','o'))
for(i=0; i<entries; i++) for(i=0; i<entries; i++)
sc->chunk_offsets[i] = get_be32(pb); sc->chunk_offsets[i] = avio_rb32(pb);
else if (atom.type == MKTAG('c','o','6','4')) else if (atom.type == MKTAG('c','o','6','4'))
for(i=0; i<entries; i++) for(i=0; i<entries; i++)
sc->chunk_offsets[i] = get_be64(pb); sc->chunk_offsets[i] = avio_rb64(pb);
else else
return -1; return -1;
@ -926,13 +926,13 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
int dref_id = 1; int dref_id = 1;
MOVAtom a = { AV_RL32("stsd") }; MOVAtom a = { AV_RL32("stsd") };
int64_t start_pos = url_ftell(pb); int64_t start_pos = url_ftell(pb);
int size = get_be32(pb); /* size */ int size = avio_rb32(pb); /* size */
uint32_t format = get_le32(pb); /* data format */ uint32_t format = avio_rl32(pb); /* data format */
if (size >= 16) { if (size >= 16) {
get_be32(pb); /* reserved */ avio_rb32(pb); /* reserved */
get_be16(pb); /* reserved */ avio_rb16(pb); /* reserved */
dref_id = get_be16(pb); dref_id = avio_rb16(pb);
} }
if (st->codec->codec_tag && if (st->codec->codec_tag &&
@ -984,21 +984,21 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
int color_greyscale; int color_greyscale;
st->codec->codec_id = id; st->codec->codec_id = id;
get_be16(pb); /* version */ avio_rb16(pb); /* version */
get_be16(pb); /* revision level */ avio_rb16(pb); /* revision level */
get_be32(pb); /* vendor */ avio_rb32(pb); /* vendor */
get_be32(pb); /* temporal quality */ avio_rb32(pb); /* temporal quality */
get_be32(pb); /* spatial quality */ avio_rb32(pb); /* spatial quality */
st->codec->width = get_be16(pb); /* width */ st->codec->width = avio_rb16(pb); /* width */
st->codec->height = get_be16(pb); /* height */ st->codec->height = avio_rb16(pb); /* height */
get_be32(pb); /* horiz resolution */ avio_rb32(pb); /* horiz resolution */
get_be32(pb); /* vert resolution */ avio_rb32(pb); /* vert resolution */
get_be32(pb); /* data size, always 0 */ avio_rb32(pb); /* data size, always 0 */
get_be16(pb); /* frames per samples */ avio_rb16(pb); /* frames per samples */
len = get_byte(pb); /* codec name, pascal string */ len = avio_r8(pb); /* codec name, pascal string */
if (len > 31) if (len > 31)
len = 31; len = 31;
mov_read_mac_string(c, pb, len, st->codec->codec_name, 32); mov_read_mac_string(c, pb, len, st->codec->codec_name, 32);
@ -1008,8 +1008,8 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
if (!memcmp(st->codec->codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) if (!memcmp(st->codec->codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25))
st->codec->codec_tag=MKTAG('I', '4', '2', '0'); st->codec->codec_tag=MKTAG('I', '4', '2', '0');
st->codec->bits_per_coded_sample = get_be16(pb); /* depth */ st->codec->bits_per_coded_sample = avio_rb16(pb); /* depth */
st->codec->color_table_id = get_be16(pb); /* colortable id */ st->codec->color_table_id = avio_rb16(pb); /* colortable id */
av_dlog(c->fc, "depth %d, ctab id %d\n", av_dlog(c->fc, "depth %d, ctab id %d\n",
st->codec->bits_per_coded_sample, st->codec->color_table_id); st->codec->bits_per_coded_sample, st->codec->color_table_id);
/* figure out the palette situation */ /* figure out the palette situation */
@ -1059,23 +1059,23 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
} }
} else { } else {
/* load the palette from the file */ /* load the palette from the file */
color_start = get_be32(pb); color_start = avio_rb32(pb);
color_count = get_be16(pb); color_count = avio_rb16(pb);
color_end = get_be16(pb); color_end = avio_rb16(pb);
if ((color_start <= 255) && if ((color_start <= 255) &&
(color_end <= 255)) { (color_end <= 255)) {
for (j = color_start; j <= color_end; j++) { for (j = color_start; j <= color_end; j++) {
/* each R, G, or B component is 16 bits; /* each R, G, or B component is 16 bits;
* only use the top 8 bits; skip alpha bytes * only use the top 8 bits; skip alpha bytes
* up front */ * up front */
get_byte(pb); avio_r8(pb);
get_byte(pb); avio_r8(pb);
r = get_byte(pb); r = avio_r8(pb);
get_byte(pb); avio_r8(pb);
g = get_byte(pb); g = avio_r8(pb);
get_byte(pb); avio_r8(pb);
b = get_byte(pb); b = avio_r8(pb);
get_byte(pb); avio_r8(pb);
st->codec->palctrl->palette[j] = st->codec->palctrl->palette[j] =
(r << 16) | (g << 8) | (b); (r << 16) | (g << 8) | (b);
} }
@ -1085,38 +1085,38 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
} }
} else if(st->codec->codec_type==AVMEDIA_TYPE_AUDIO) { } else if(st->codec->codec_type==AVMEDIA_TYPE_AUDIO) {
int bits_per_sample, flags; int bits_per_sample, flags;
uint16_t version = get_be16(pb); uint16_t version = avio_rb16(pb);
st->codec->codec_id = id; st->codec->codec_id = id;
get_be16(pb); /* revision level */ avio_rb16(pb); /* revision level */
get_be32(pb); /* vendor */ avio_rb32(pb); /* vendor */
st->codec->channels = get_be16(pb); /* channel count */ st->codec->channels = avio_rb16(pb); /* channel count */
av_dlog(c->fc, "audio channels %d\n", st->codec->channels); av_dlog(c->fc, "audio channels %d\n", st->codec->channels);
st->codec->bits_per_coded_sample = get_be16(pb); /* sample size */ st->codec->bits_per_coded_sample = avio_rb16(pb); /* sample size */
sc->audio_cid = get_be16(pb); sc->audio_cid = avio_rb16(pb);
get_be16(pb); /* packet size = 0 */ avio_rb16(pb); /* packet size = 0 */
st->codec->sample_rate = ((get_be32(pb) >> 16)); st->codec->sample_rate = ((avio_rb32(pb) >> 16));
//Read QT version 1 fields. In version 0 these do not exist. //Read QT version 1 fields. In version 0 these do not exist.
av_dlog(c->fc, "version =%d, isom =%d\n",version,c->isom); av_dlog(c->fc, "version =%d, isom =%d\n",version,c->isom);
if(!c->isom) { if(!c->isom) {
if(version==1) { if(version==1) {
sc->samples_per_frame = get_be32(pb); sc->samples_per_frame = avio_rb32(pb);
get_be32(pb); /* bytes per packet */ avio_rb32(pb); /* bytes per packet */
sc->bytes_per_frame = get_be32(pb); sc->bytes_per_frame = avio_rb32(pb);
get_be32(pb); /* bytes per sample */ avio_rb32(pb); /* bytes per sample */
} else if(version==2) { } else if(version==2) {
get_be32(pb); /* sizeof struct only */ avio_rb32(pb); /* sizeof struct only */
st->codec->sample_rate = av_int2dbl(get_be64(pb)); /* float 64 */ st->codec->sample_rate = av_int2dbl(avio_rb64(pb)); /* float 64 */
st->codec->channels = get_be32(pb); st->codec->channels = avio_rb32(pb);
get_be32(pb); /* always 0x7F000000 */ avio_rb32(pb); /* always 0x7F000000 */
st->codec->bits_per_coded_sample = get_be32(pb); /* bits per channel if sound is uncompressed */ st->codec->bits_per_coded_sample = avio_rb32(pb); /* bits per channel if sound is uncompressed */
flags = get_be32(pb); /* lpcm format specific flag */ flags = avio_rb32(pb); /* lpcm format specific flag */
sc->bytes_per_frame = get_be32(pb); /* bytes per audio packet if constant */ sc->bytes_per_frame = avio_rb32(pb); /* bytes per audio packet if constant */
sc->samples_per_frame = get_be32(pb); /* lpcm frames per audio packet if constant */ sc->samples_per_frame = avio_rb32(pb); /* lpcm frames per audio packet if constant */
if (format == MKTAG('l','p','c','m')) if (format == MKTAG('l','p','c','m'))
st->codec->codec_id = ff_mov_get_lpcm_codec_id(st->codec->bits_per_coded_sample, flags); st->codec->codec_id = ff_mov_get_lpcm_codec_id(st->codec->bits_per_coded_sample, flags);
} }
@ -1249,9 +1249,9 @@ static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{ {
int entries; int entries;
get_byte(pb); /* version */ avio_r8(pb); /* version */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
entries = get_be32(pb); entries = avio_rb32(pb);
return ff_mov_read_stsd_entries(c, pb, entries); return ff_mov_read_stsd_entries(c, pb, entries);
} }
@ -1267,10 +1267,10 @@ static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data; sc = st->priv_data;
get_byte(pb); /* version */ avio_r8(pb); /* version */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
entries = get_be32(pb); entries = avio_rb32(pb);
av_dlog(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries); av_dlog(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
@ -1282,9 +1282,9 @@ static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
sc->stsc_count = entries; sc->stsc_count = entries;
for(i=0; i<entries; i++) { for(i=0; i<entries; i++) {
sc->stsc_data[i].first = get_be32(pb); sc->stsc_data[i].first = avio_rb32(pb);
sc->stsc_data[i].count = get_be32(pb); sc->stsc_data[i].count = avio_rb32(pb);
sc->stsc_data[i].id = get_be32(pb); sc->stsc_data[i].id = avio_rb32(pb);
} }
return 0; return 0;
} }
@ -1300,9 +1300,9 @@ static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data; sc = st->priv_data;
get_be32(pb); // version + flags avio_rb32(pb); // version + flags
entries = get_be32(pb); entries = avio_rb32(pb);
if (entries >= UINT_MAX / sizeof(*sc->stps_data)) if (entries >= UINT_MAX / sizeof(*sc->stps_data))
return -1; return -1;
sc->stps_data = av_malloc(entries * sizeof(*sc->stps_data)); sc->stps_data = av_malloc(entries * sizeof(*sc->stps_data));
@ -1311,7 +1311,7 @@ static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
sc->stps_count = entries; sc->stps_count = entries;
for (i = 0; i < entries; i++) { for (i = 0; i < entries; i++) {
sc->stps_data[i] = get_be32(pb); sc->stps_data[i] = avio_rb32(pb);
//av_dlog(c->fc, "stps %d\n", sc->stps_data[i]); //av_dlog(c->fc, "stps %d\n", sc->stps_data[i]);
} }
@ -1329,10 +1329,10 @@ static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data; sc = st->priv_data;
get_byte(pb); /* version */ avio_r8(pb); /* version */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
entries = get_be32(pb); entries = avio_rb32(pb);
av_dlog(c->fc, "keyframe_count = %d\n", entries); av_dlog(c->fc, "keyframe_count = %d\n", entries);
@ -1344,7 +1344,7 @@ static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
sc->keyframe_count = entries; sc->keyframe_count = entries;
for(i=0; i<entries; i++) { for(i=0; i<entries; i++) {
sc->keyframes[i] = get_be32(pb); sc->keyframes[i] = avio_rb32(pb);
//av_dlog(c->fc, "keyframes[]=%d\n", sc->keyframes[i]); //av_dlog(c->fc, "keyframes[]=%d\n", sc->keyframes[i]);
} }
return 0; return 0;
@ -1363,20 +1363,20 @@ static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data; sc = st->priv_data;
get_byte(pb); /* version */ avio_r8(pb); /* version */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
if (atom.type == MKTAG('s','t','s','z')) { if (atom.type == MKTAG('s','t','s','z')) {
sample_size = get_be32(pb); sample_size = avio_rb32(pb);
if (!sc->sample_size) /* do not overwrite value computed in stsd */ if (!sc->sample_size) /* do not overwrite value computed in stsd */
sc->sample_size = sample_size; sc->sample_size = sample_size;
field_size = 32; field_size = 32;
} else { } else {
sample_size = 0; sample_size = 0;
get_be24(pb); /* reserved */ avio_rb24(pb); /* reserved */
field_size = get_byte(pb); field_size = avio_r8(pb);
} }
entries = get_be32(pb); entries = avio_rb32(pb);
av_dlog(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, entries); av_dlog(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, entries);
@ -1403,7 +1403,7 @@ static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if (get_buffer(pb, buf, num_bytes) < num_bytes) { if (avio_read(pb, buf, num_bytes) < num_bytes) {
av_freep(&sc->sample_sizes); av_freep(&sc->sample_sizes);
av_free(buf); av_free(buf);
return -1; return -1;
@ -1431,9 +1431,9 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data; sc = st->priv_data;
get_byte(pb); /* version */ avio_r8(pb); /* version */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
entries = get_be32(pb); entries = avio_rb32(pb);
av_dlog(c->fc, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries); av_dlog(c->fc, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries);
@ -1448,8 +1448,8 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int sample_duration; int sample_duration;
int sample_count; int sample_count;
sample_count=get_be32(pb); sample_count=avio_rb32(pb);
sample_duration = get_be32(pb); sample_duration = avio_rb32(pb);
sc->stts_data[i].count= sample_count; sc->stts_data[i].count= sample_count;
sc->stts_data[i].duration= sample_duration; sc->stts_data[i].duration= sample_duration;
@ -1476,9 +1476,9 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data; sc = st->priv_data;
get_byte(pb); /* version */ avio_r8(pb); /* version */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
entries = get_be32(pb); entries = avio_rb32(pb);
av_dlog(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries); av_dlog(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);
@ -1490,8 +1490,8 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
sc->ctts_count = entries; sc->ctts_count = entries;
for(i=0; i<entries; i++) { for(i=0; i<entries; i++) {
int count =get_be32(pb); int count =avio_rb32(pb);
int duration =get_be32(pb); int duration =avio_rb32(pb);
sc->ctts_data[i].count = count; sc->ctts_data[i].count = count;
sc->ctts_data[i].duration= duration; sc->ctts_data[i].duration= duration;
@ -1837,7 +1837,7 @@ static int mov_read_ilst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom) static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{ {
while (atom.size > 8) { while (atom.size > 8) {
uint32_t tag = get_le32(pb); uint32_t tag = avio_rl32(pb);
atom.size -= 4; atom.size -= 4;
if (tag == MKTAG('h','d','l','r')) { if (tag == MKTAG('h','d','l','r')) {
url_fseek(pb, -8, SEEK_CUR); url_fseek(pb, -8, SEEK_CUR);
@ -1864,8 +1864,8 @@ static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data; sc = st->priv_data;
version = get_byte(pb); version = avio_r8(pb);
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
/* /*
MOV_TRACK_ENABLED 0x0001 MOV_TRACK_ENABLED 0x0001
MOV_TRACK_IN_MOVIE 0x0002 MOV_TRACK_IN_MOVIE 0x0002
@ -1874,36 +1874,36 @@ static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
*/ */
if (version == 1) { if (version == 1) {
get_be64(pb); avio_rb64(pb);
get_be64(pb); avio_rb64(pb);
} else { } else {
get_be32(pb); /* creation time */ avio_rb32(pb); /* creation time */
get_be32(pb); /* modification time */ avio_rb32(pb); /* modification time */
} }
st->id = (int)get_be32(pb); /* track id (NOT 0 !)*/ st->id = (int)avio_rb32(pb); /* track id (NOT 0 !)*/
get_be32(pb); /* reserved */ avio_rb32(pb); /* reserved */
/* highlevel (considering edits) duration in movie timebase */ /* highlevel (considering edits) duration in movie timebase */
(version == 1) ? get_be64(pb) : get_be32(pb); (version == 1) ? avio_rb64(pb) : avio_rb32(pb);
get_be32(pb); /* reserved */ avio_rb32(pb); /* reserved */
get_be32(pb); /* reserved */ avio_rb32(pb); /* reserved */
get_be16(pb); /* layer */ avio_rb16(pb); /* layer */
get_be16(pb); /* alternate group */ avio_rb16(pb); /* alternate group */
get_be16(pb); /* volume */ avio_rb16(pb); /* volume */
get_be16(pb); /* reserved */ avio_rb16(pb); /* reserved */
//read in the display matrix (outlined in ISO 14496-12, Section 6.2.2) //read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
// they're kept in fixed point format through all calculations // they're kept in fixed point format through all calculations
// ignore u,v,z b/c we don't need the scale factor to calc aspect ratio // ignore u,v,z b/c we don't need the scale factor to calc aspect ratio
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
display_matrix[i][0] = get_be32(pb); // 16.16 fixed point display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
display_matrix[i][1] = get_be32(pb); // 16.16 fixed point display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
get_be32(pb); // 2.30 fixed point (not used) avio_rb32(pb); // 2.30 fixed point (not used)
} }
width = get_be32(pb); // 16.16 fixed point track width width = avio_rb32(pb); // 16.16 fixed point track width
height = get_be32(pb); // 16.16 fixed point track height height = avio_rb32(pb); // 16.16 fixed point track height
sc->width = width >> 16; sc->width = width >> 16;
sc->height = height >> 16; sc->height = height >> 16;
@ -1937,10 +1937,10 @@ static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
MOVTrackExt *trex = NULL; MOVTrackExt *trex = NULL;
int flags, track_id, i; int flags, track_id, i;
get_byte(pb); /* version */ avio_r8(pb); /* version */
flags = get_be24(pb); flags = avio_rb24(pb);
track_id = get_be32(pb); track_id = avio_rb32(pb);
if (!track_id) if (!track_id)
return -1; return -1;
frag->track_id = track_id; frag->track_id = track_id;
@ -1954,21 +1954,21 @@ static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
return -1; return -1;
} }
if (flags & 0x01) frag->base_data_offset = get_be64(pb); if (flags & 0x01) frag->base_data_offset = avio_rb64(pb);
else frag->base_data_offset = frag->moof_offset; else frag->base_data_offset = frag->moof_offset;
if (flags & 0x02) frag->stsd_id = get_be32(pb); if (flags & 0x02) frag->stsd_id = avio_rb32(pb);
else frag->stsd_id = trex->stsd_id; else frag->stsd_id = trex->stsd_id;
frag->duration = flags & 0x08 ? get_be32(pb) : trex->duration; frag->duration = flags & 0x08 ? avio_rb32(pb) : trex->duration;
frag->size = flags & 0x10 ? get_be32(pb) : trex->size; frag->size = flags & 0x10 ? avio_rb32(pb) : trex->size;
frag->flags = flags & 0x20 ? get_be32(pb) : trex->flags; frag->flags = flags & 0x20 ? avio_rb32(pb) : trex->flags;
av_dlog(c->fc, "frag flags 0x%x\n", frag->flags); av_dlog(c->fc, "frag flags 0x%x\n", frag->flags);
return 0; return 0;
} }
static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom) static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{ {
c->chapter_track = get_be32(pb); c->chapter_track = avio_rb32(pb);
return 0; return 0;
} }
@ -1983,13 +1983,13 @@ static int mov_read_trex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
c->trex_data = trex; c->trex_data = trex;
trex = &c->trex_data[c->trex_count++]; trex = &c->trex_data[c->trex_count++];
get_byte(pb); /* version */ avio_r8(pb); /* version */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
trex->track_id = get_be32(pb); trex->track_id = avio_rb32(pb);
trex->stsd_id = get_be32(pb); trex->stsd_id = avio_rb32(pb);
trex->duration = get_be32(pb); trex->duration = avio_rb32(pb);
trex->size = get_be32(pb); trex->size = avio_rb32(pb);
trex->flags = get_be32(pb); trex->flags = avio_rb32(pb);
return 0; return 0;
} }
@ -2017,12 +2017,12 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
sc = st->priv_data; sc = st->priv_data;
if (sc->pseudo_stream_id+1 != frag->stsd_id) if (sc->pseudo_stream_id+1 != frag->stsd_id)
return 0; return 0;
get_byte(pb); /* version */ avio_r8(pb); /* version */
flags = get_be24(pb); flags = avio_rb24(pb);
entries = get_be32(pb); entries = avio_rb32(pb);
av_dlog(c->fc, "flags 0x%x entries %d\n", flags, entries); av_dlog(c->fc, "flags 0x%x entries %d\n", flags, entries);
if (flags & 0x001) data_offset = get_be32(pb); if (flags & 0x001) data_offset = avio_rb32(pb);
if (flags & 0x004) first_sample_flags = get_be32(pb); if (flags & 0x004) first_sample_flags = avio_rb32(pb);
if (flags & 0x800) { if (flags & 0x800) {
MOVStts *ctts_data; MOVStts *ctts_data;
if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data)) if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
@ -2043,12 +2043,12 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
unsigned sample_duration = frag->duration; unsigned sample_duration = frag->duration;
int keyframe; int keyframe;
if (flags & 0x100) sample_duration = get_be32(pb); if (flags & 0x100) sample_duration = avio_rb32(pb);
if (flags & 0x200) sample_size = get_be32(pb); if (flags & 0x200) sample_size = avio_rb32(pb);
if (flags & 0x400) sample_flags = get_be32(pb); if (flags & 0x400) sample_flags = avio_rb32(pb);
if (flags & 0x800) { if (flags & 0x800) {
sc->ctts_data[sc->ctts_count].count = 1; sc->ctts_data[sc->ctts_count].count = 1;
sc->ctts_data[sc->ctts_count].duration = get_be32(pb); sc->ctts_data[sc->ctts_count].duration = avio_rb32(pb);
sc->ctts_count++; sc->ctts_count++;
} }
if ((keyframe = st->codec->codec_type == AVMEDIA_TYPE_AUDIO || if ((keyframe = st->codec->codec_type == AVMEDIA_TYPE_AUDIO ||
@ -2077,11 +2077,11 @@ static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (atom.size < 8) if (atom.size < 8)
return 0; /* continue */ return 0; /* continue */
if (get_be32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */ if (avio_rb32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
url_fskip(pb, atom.size - 4); url_fskip(pb, atom.size - 4);
return 0; return 0;
} }
atom.type = get_le32(pb); atom.type = avio_rl32(pb);
atom.size -= 8; atom.size -= 8;
if (atom.type != MKTAG('m','d','a','t')) { if (atom.type != MKTAG('m','d','a','t')) {
url_fskip(pb, atom.size); url_fskip(pb, atom.size);
@ -2100,17 +2100,17 @@ static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
long cmov_len, moov_len; long cmov_len, moov_len;
int ret = -1; int ret = -1;
get_be32(pb); /* dcom atom */ avio_rb32(pb); /* dcom atom */
if (get_le32(pb) != MKTAG('d','c','o','m')) if (avio_rl32(pb) != MKTAG('d','c','o','m'))
return -1; return -1;
if (get_le32(pb) != MKTAG('z','l','i','b')) { if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !"); av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !");
return -1; return -1;
} }
get_be32(pb); /* cmvd atom */ avio_rb32(pb); /* cmvd atom */
if (get_le32(pb) != MKTAG('c','m','v','d')) if (avio_rl32(pb) != MKTAG('c','m','v','d'))
return -1; return -1;
moov_len = get_be32(pb); /* uncompressed size */ moov_len = avio_rb32(pb); /* uncompressed size */
cmov_len = atom.size - 6 * 4; cmov_len = atom.size - 6 * 4;
cmov_data = av_malloc(cmov_len); cmov_data = av_malloc(cmov_len);
@ -2121,7 +2121,7 @@ static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
av_free(cmov_data); av_free(cmov_data);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
get_buffer(pb, cmov_data, cmov_len); avio_read(pb, cmov_data, cmov_len);
if(uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK) if(uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
goto free_and_return; goto free_and_return;
if(ffio_init_context(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0) if(ffio_init_context(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)
@ -2152,18 +2152,18 @@ static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
return 0; return 0;
sc = c->fc->streams[c->fc->nb_streams-1]->priv_data; sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
get_byte(pb); /* version */ avio_r8(pb); /* version */
get_be24(pb); /* flags */ avio_rb24(pb); /* flags */
edit_count = get_be32(pb); /* entries */ edit_count = avio_rb32(pb); /* entries */
if((uint64_t)edit_count*12+8 > atom.size) if((uint64_t)edit_count*12+8 > atom.size)
return -1; return -1;
for(i=0; i<edit_count; i++){ for(i=0; i<edit_count; i++){
int time; int time;
int duration = get_be32(pb); /* Track duration */ int duration = avio_rb32(pb); /* Track duration */
time = get_be32(pb); /* Media time */ time = avio_rb32(pb); /* Media time */
get_be32(pb); /* Media rate */ avio_rb32(pb); /* Media rate */
if (i == 0 && time >= -1) { if (i == 0 && time >= -1) {
sc->time_offset = time != -1 ? time : -duration; sc->time_offset = time != -1 ? time : -duration;
} }
@ -2314,7 +2314,7 @@ static void mov_read_chapters(AVFormatContext *s)
} }
// the first two bytes are the length of the title // the first two bytes are the length of the title
len = get_be16(sc->pb); len = avio_rb16(sc->pb);
if (len > sample->size-2) if (len > sample->size-2)
continue; continue;
title_len = 2*len + 1; title_len = 2*len + 1;
@ -2324,7 +2324,7 @@ static void mov_read_chapters(AVFormatContext *s)
// The samples could theoretically be in any encoding if there's an encd // The samples could theoretically be in any encoding if there's an encd
// atom following, but in practice are only utf-8 or utf-16, distinguished // atom following, but in practice are only utf-8 or utf-16, distinguished
// instead by the presence of a BOM // instead by the presence of a BOM
ch = get_be16(sc->pb); ch = avio_rb16(sc->pb);
if (ch == 0xfeff) if (ch == 0xfeff)
avio_get_str16be(sc->pb, len, title, title_len); avio_get_str16be(sc->pb, len, title, title_len);
else if (ch == 0xfffe) else if (ch == 0xfffe)

18
libavformat/mp3dec.c
View File

@ -80,7 +80,7 @@ static int mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, int64_t base)
MPADecodeHeader c; MPADecodeHeader c;
int vbrtag_size = 0; int vbrtag_size = 0;
v = get_be32(s->pb); v = avio_rb32(s->pb);
if(ff_mpa_check_header(v) < 0) if(ff_mpa_check_header(v) < 0)
return -1; return -1;
@ -91,25 +91,25 @@ static int mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, int64_t base)
/* Check for Xing / Info tag */ /* Check for Xing / Info tag */
url_fseek(s->pb, xing_offtbl[c.lsf == 1][c.nb_channels == 1], SEEK_CUR); url_fseek(s->pb, xing_offtbl[c.lsf == 1][c.nb_channels == 1], SEEK_CUR);
v = get_be32(s->pb); v = avio_rb32(s->pb);
if(v == MKBETAG('X', 'i', 'n', 'g') || v == MKBETAG('I', 'n', 'f', 'o')) { if(v == MKBETAG('X', 'i', 'n', 'g') || v == MKBETAG('I', 'n', 'f', 'o')) {
v = get_be32(s->pb); v = avio_rb32(s->pb);
if(v & 0x1) if(v & 0x1)
frames = get_be32(s->pb); frames = avio_rb32(s->pb);
if(v & 0x2) if(v & 0x2)
size = get_be32(s->pb); size = avio_rb32(s->pb);
} }
/* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */ /* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */
url_fseek(s->pb, base + 4 + 32, SEEK_SET); url_fseek(s->pb, base + 4 + 32, SEEK_SET);
v = get_be32(s->pb); v = avio_rb32(s->pb);
if(v == MKBETAG('V', 'B', 'R', 'I')) { if(v == MKBETAG('V', 'B', 'R', 'I')) {
/* Check tag version */ /* Check tag version */
if(get_be16(s->pb) == 1) { if(avio_rb16(s->pb) == 1) {
/* skip delay and quality */ /* skip delay and quality */
url_fseek(s->pb, 4, SEEK_CUR); url_fseek(s->pb, 4, SEEK_CUR);
frames = get_be32(s->pb); frames = avio_rb32(s->pb);
size = get_be32(s->pb); size = avio_rb32(s->pb);
} }
} }

14
libavformat/mpc.c
View File

@ -55,16 +55,16 @@ static int mpc_read_header(AVFormatContext *s, AVFormatParameters *ap)
MPCContext *c = s->priv_data; MPCContext *c = s->priv_data;
AVStream *st; AVStream *st;
if(get_le24(s->pb) != MKTAG('M', 'P', '+', 0)){ if(avio_rl24(s->pb) != MKTAG('M', 'P', '+', 0)){
av_log(s, AV_LOG_ERROR, "Not a Musepack file\n"); av_log(s, AV_LOG_ERROR, "Not a Musepack file\n");
return -1; return -1;
} }
c->ver = get_byte(s->pb); c->ver = avio_r8(s->pb);
if(c->ver != 0x07 && c->ver != 0x17){ if(c->ver != 0x07 && c->ver != 0x17){
av_log(s, AV_LOG_ERROR, "Can demux Musepack SV7, got version %02X\n", c->ver); av_log(s, AV_LOG_ERROR, "Can demux Musepack SV7, got version %02X\n", c->ver);
return -1; return -1;
} }
c->fcount = get_le32(s->pb); c->fcount = avio_rl32(s->pb);
if((int64_t)c->fcount * sizeof(MPCFrame) >= UINT_MAX){ if((int64_t)c->fcount * sizeof(MPCFrame) >= UINT_MAX){
av_log(s, AV_LOG_ERROR, "Too many frames, seeking is not possible\n"); av_log(s, AV_LOG_ERROR, "Too many frames, seeking is not possible\n");
return -1; return -1;
@ -85,7 +85,7 @@ static int mpc_read_header(AVFormatContext *s, AVFormatParameters *ap)
st->codec->extradata_size = 16; st->codec->extradata_size = 16;
st->codec->extradata = av_mallocz(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE); st->codec->extradata = av_mallocz(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(s->pb, st->codec->extradata, 16); avio_read(s->pb, st->codec->extradata, 16);
st->codec->sample_rate = mpc_rate[st->codec->extradata[2] & 3]; st->codec->sample_rate = mpc_rate[st->codec->extradata[2] & 3];
av_set_pts_info(st, 32, MPC_FRAMESIZE, st->codec->sample_rate); av_set_pts_info(st, 32, MPC_FRAMESIZE, st->codec->sample_rate);
/* scan for seekpoints */ /* scan for seekpoints */
@ -121,11 +121,11 @@ static int mpc_read_packet(AVFormatContext *s, AVPacket *pkt)
c->curframe++; c->curframe++;
curbits = c->curbits; curbits = c->curbits;
pos = url_ftell(s->pb); pos = url_ftell(s->pb);
tmp = get_le32(s->pb); tmp = avio_rl32(s->pb);
if(curbits <= 12){ if(curbits <= 12){
size2 = (tmp >> (12 - curbits)) & 0xFFFFF; size2 = (tmp >> (12 - curbits)) & 0xFFFFF;
}else{ }else{
tmp = (tmp << 32) | get_le32(s->pb); tmp = (tmp << 32) | avio_rl32(s->pb);
size2 = (tmp >> (44 - curbits)) & 0xFFFFF; size2 = (tmp >> (44 - curbits)) & 0xFFFFF;
} }
curbits += 20; curbits += 20;
@ -151,7 +151,7 @@ static int mpc_read_packet(AVFormatContext *s, AVPacket *pkt)
pkt->stream_index = 0; pkt->stream_index = 0;
pkt->pts = cur; pkt->pts = cur;
ret = get_buffer(s->pb, pkt->data + 4, size); ret = avio_read(s->pb, pkt->data + 4, size);
if(c->curbits) if(c->curbits)
url_fseek(s->pb, -4, SEEK_CUR); url_fseek(s->pb, -4, SEEK_CUR);
if(ret < size){ if(ret < size){

10
libavformat/mpc8.c
View File

@ -121,7 +121,7 @@ static void mpc8_get_chunk_header(AVIOContext *pb, int *tag, int64_t *size)
{ {
int64_t pos; int64_t pos;
pos = url_ftell(pb); pos = url_ftell(pb);
*tag = get_le16(pb); *tag = avio_rl16(pb);
*size = ff_get_v(pb); *size = ff_get_v(pb);
*size -= url_ftell(pb) - pos; *size -= url_ftell(pb) - pos;
} }
@ -143,7 +143,7 @@ static void mpc8_parse_seektable(AVFormatContext *s, int64_t off)
} }
if(!(buf = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE))) if(!(buf = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE)))
return; return;
get_buffer(s->pb, buf, size); avio_read(s->pb, buf, size);
init_get_bits(&gb, buf, size * 8); init_get_bits(&gb, buf, size * 8);
size = gb_get_v(&gb); size = gb_get_v(&gb);
if(size > UINT_MAX/4 || size > c->samples/1152){ if(size > UINT_MAX/4 || size > c->samples/1152){
@ -195,7 +195,7 @@ static int mpc8_read_header(AVFormatContext *s, AVFormatParameters *ap)
int64_t size, pos; int64_t size, pos;
c->header_pos = url_ftell(pb); c->header_pos = url_ftell(pb);
if(get_le32(pb) != TAG_MPCK){ if(avio_rl32(pb) != TAG_MPCK){
av_log(s, AV_LOG_ERROR, "Not a Musepack8 file\n"); av_log(s, AV_LOG_ERROR, "Not a Musepack8 file\n");
return -1; return -1;
} }
@ -213,7 +213,7 @@ static int mpc8_read_header(AVFormatContext *s, AVFormatParameters *ap)
} }
pos = url_ftell(pb); pos = url_ftell(pb);
url_fskip(pb, 4); //CRC url_fskip(pb, 4); //CRC
c->ver = get_byte(pb); c->ver = avio_r8(pb);
if(c->ver != 8){ if(c->ver != 8){
av_log(s, AV_LOG_ERROR, "Unknown stream version %d\n", c->ver); av_log(s, AV_LOG_ERROR, "Unknown stream version %d\n", c->ver);
return -1; return -1;
@ -230,7 +230,7 @@ static int mpc8_read_header(AVFormatContext *s, AVFormatParameters *ap)
st->codec->extradata_size = 2; st->codec->extradata_size = 2;
st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(pb, st->codec->extradata, st->codec->extradata_size); avio_read(pb, st->codec->extradata, st->codec->extradata_size);
st->codec->channels = (st->codec->extradata[1] >> 4) + 1; st->codec->channels = (st->codec->extradata[1] >> 4) + 1;
st->codec->sample_rate = mpc8_rate[st->codec->extradata[0] >> 5]; st->codec->sample_rate = mpc8_rate[st->codec->extradata[0] >> 5];

78
libavformat/mpeg.c
View File

@ -113,7 +113,7 @@ static int mpegps_read_header(AVFormatContext *s,
m->sofdec = -1; m->sofdec = -1;
do { do {
v = get_byte(s->pb); v = avio_r8(s->pb);
m->header_state = m->header_state << 8 | v; m->header_state = m->header_state << 8 | v;
m->sofdec++; m->sofdec++;
} while (v == sofdec[i] && i++ < 6); } while (v == sofdec[i] && i++ < 6);
@ -128,8 +128,8 @@ static int64_t get_pts(AVIOContext *pb, int c)
{ {
uint8_t buf[5]; uint8_t buf[5];
buf[0] = c<0 ? get_byte(pb) : c; buf[0] = c<0 ? avio_r8(pb) : c;
get_buffer(pb, buf+1, 4); avio_read(pb, buf+1, 4);
return ff_parse_pes_pts(buf); return ff_parse_pes_pts(buf);
} }
@ -145,7 +145,7 @@ static int find_next_start_code(AVIOContext *pb, int *size_ptr,
while (n > 0) { while (n > 0) {
if (url_feof(pb)) if (url_feof(pb))
break; break;
v = get_byte(pb); v = avio_r8(pb);
n--; n--;
if (state == 0x000001) { if (state == 0x000001) {
state = ((state << 8) | v) & 0xffffff; state = ((state << 8) | v) & 0xffffff;
@ -176,7 +176,7 @@ static int find_prev_start_code(AVIOContext *pb, int *size_ptr)
if (pos < 0) if (pos < 0)
pos = 0; pos = 0;
url_fseek(pb, pos, SEEK_SET); url_fseek(pb, pos, SEEK_SET);
get_byte(pb); avio_r8(pb);
pos = pos_start; pos = pos_start;
for(;;) { for(;;) {
@ -186,7 +186,7 @@ static int find_prev_start_code(AVIOContext *pb, int *size_ptr)
goto the_end; goto the_end;
} }
url_fseek(pb, pos, SEEK_SET); url_fseek(pb, pos, SEEK_SET);
start_code = get_be32(pb); start_code = avio_rb32(pb);
if ((start_code & 0xffffff00) == 0x100) if ((start_code & 0xffffff00) == 0x100)
break; break;
} }
@ -206,27 +206,27 @@ static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb)
{ {
int psm_length, ps_info_length, es_map_length; int psm_length, ps_info_length, es_map_length;
psm_length = get_be16(pb); psm_length = avio_rb16(pb);
get_byte(pb); avio_r8(pb);
get_byte(pb); avio_r8(pb);
ps_info_length = get_be16(pb); ps_info_length = avio_rb16(pb);
/* skip program_stream_info */ /* skip program_stream_info */
url_fskip(pb, ps_info_length); url_fskip(pb, ps_info_length);
es_map_length = get_be16(pb); es_map_length = avio_rb16(pb);
/* at least one es available? */ /* at least one es available? */
while (es_map_length >= 4){ while (es_map_length >= 4){
unsigned char type = get_byte(pb); unsigned char type = avio_r8(pb);
unsigned char es_id = get_byte(pb); unsigned char es_id = avio_r8(pb);
uint16_t es_info_length = get_be16(pb); uint16_t es_info_length = avio_rb16(pb);
/* remember mapping from stream id to stream type */ /* remember mapping from stream id to stream type */
m->psm_es_type[es_id] = type; m->psm_es_type[es_id] = type;
/* skip program_stream_info */ /* skip program_stream_info */
url_fskip(pb, es_info_length); url_fskip(pb, es_info_length);
es_map_length -= 4 + es_info_length; es_map_length -= 4 + es_info_length;
} }
get_be32(pb); /* crc32 */ avio_rb32(pb); /* crc32 */
return 2 + psm_length; return 2 + psm_length;
} }
@ -264,16 +264,16 @@ static int mpegps_read_pes_header(AVFormatContext *s,
if (startcode == SYSTEM_HEADER_START_CODE) if (startcode == SYSTEM_HEADER_START_CODE)
goto redo; goto redo;
if (startcode == PADDING_STREAM) { if (startcode == PADDING_STREAM) {
url_fskip(s->pb, get_be16(s->pb)); url_fskip(s->pb, avio_rb16(s->pb));
goto redo; goto redo;
} }
if (startcode == PRIVATE_STREAM_2) { if (startcode == PRIVATE_STREAM_2) {
len = get_be16(s->pb); len = avio_rb16(s->pb);
if (!m->sofdec) { if (!m->sofdec) {
while (len-- >= 6) { while (len-- >= 6) {
if (get_byte(s->pb) == 'S') { if (avio_r8(s->pb) == 'S') {
uint8_t buf[5]; uint8_t buf[5];
get_buffer(s->pb, buf, sizeof(buf)); avio_read(s->pb, buf, sizeof(buf));
m->sofdec = !memcmp(buf, "ofdec", 5); m->sofdec = !memcmp(buf, "ofdec", 5);
len -= sizeof(buf); len -= sizeof(buf);
break; break;
@ -297,14 +297,14 @@ static int mpegps_read_pes_header(AVFormatContext *s,
if (ppos) { if (ppos) {
*ppos = url_ftell(s->pb) - 4; *ppos = url_ftell(s->pb) - 4;
} }
len = get_be16(s->pb); len = avio_rb16(s->pb);
pts = pts =
dts = AV_NOPTS_VALUE; dts = AV_NOPTS_VALUE;
/* stuffing */ /* stuffing */
for(;;) { for(;;) {
if (len < 1) if (len < 1)
goto error_redo; goto error_redo;
c = get_byte(s->pb); c = avio_r8(s->pb);
len--; len--;
/* XXX: for mpeg1, should test only bit 7 */ /* XXX: for mpeg1, should test only bit 7 */
if (c != 0xff) if (c != 0xff)
@ -312,8 +312,8 @@ static int mpegps_read_pes_header(AVFormatContext *s,
} }
if ((c & 0xc0) == 0x40) { if ((c & 0xc0) == 0x40) {
/* buffer scale & size */ /* buffer scale & size */
get_byte(s->pb); avio_r8(s->pb);
c = get_byte(s->pb); c = avio_r8(s->pb);
len -= 2; len -= 2;
} }
if ((c & 0xe0) == 0x20) { if ((c & 0xe0) == 0x20) {
@ -331,8 +331,8 @@ static int mpegps_read_pes_header(AVFormatContext *s,
goto redo; goto redo;
} }
#endif #endif
flags = get_byte(s->pb); flags = avio_r8(s->pb);
header_len = get_byte(s->pb); header_len = avio_r8(s->pb);
len -= 2; len -= 2;
if (header_len > len) if (header_len > len)
goto error_redo; goto error_redo;
@ -350,7 +350,7 @@ static int mpegps_read_pes_header(AVFormatContext *s,
av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n"); av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
} }
if (flags & 0x01) { /* PES extension */ if (flags & 0x01) { /* PES extension */
pes_ext = get_byte(s->pb); pes_ext = avio_r8(s->pb);
header_len--; header_len--;
/* Skip PES private data, program packet sequence counter and P-STD buffer */ /* Skip PES private data, program packet sequence counter and P-STD buffer */
skip = (pes_ext >> 4) & 0xb; skip = (pes_ext >> 4) & 0xb;
@ -363,10 +363,10 @@ static int mpegps_read_pes_header(AVFormatContext *s,
header_len -= skip; header_len -= skip;
if (pes_ext & 0x01) { /* PES extension 2 */ if (pes_ext & 0x01) { /* PES extension 2 */
ext2_len = get_byte(s->pb); ext2_len = avio_r8(s->pb);
header_len--; header_len--;
if ((ext2_len & 0x7f) > 0) { if ((ext2_len & 0x7f) > 0) {
id_ext = get_byte(s->pb); id_ext = avio_r8(s->pb);
if ((id_ext & 0x80) == 0) if ((id_ext & 0x80) == 0)
startcode = ((startcode & 0xff) << 8) | id_ext; startcode = ((startcode & 0xff) << 8) | id_ext;
header_len--; header_len--;
@ -381,17 +381,17 @@ static int mpegps_read_pes_header(AVFormatContext *s,
goto redo; goto redo;
if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) { if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
startcode = get_byte(s->pb); startcode = avio_r8(s->pb);
len--; len--;
if (startcode >= 0x80 && startcode <= 0xcf) { if (startcode >= 0x80 && startcode <= 0xcf) {
/* audio: skip header */ /* audio: skip header */
get_byte(s->pb); avio_r8(s->pb);
get_byte(s->pb); avio_r8(s->pb);
get_byte(s->pb); avio_r8(s->pb);
len -= 3; len -= 3;
if (startcode >= 0xb0 && startcode <= 0xbf) { if (startcode >= 0xb0 && startcode <= 0xbf) {
/* MLP/TrueHD audio has a 4-byte header */ /* MLP/TrueHD audio has a 4-byte header */
get_byte(s->pb); avio_r8(s->pb);
len--; len--;
} }
} }
@ -432,7 +432,7 @@ static int mpegps_read_packet(AVFormatContext *s,
return len; return len;
if(startcode == 0x1bd) { if(startcode == 0x1bd) {
dvdaudio_substream_type = get_byte(s->pb); dvdaudio_substream_type = avio_r8(s->pb);
url_fskip(s->pb, 3); url_fskip(s->pb, 3);
len -= 4; len -= 4;
} }
@ -474,7 +474,7 @@ static int mpegps_read_packet(AVFormatContext *s,
} else if (startcode >= 0x1e0 && startcode <= 0x1ef) { } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 }; static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
unsigned char buf[8]; unsigned char buf[8];
get_buffer(s->pb, buf, 8); avio_read(s->pb, buf, 8);
url_fseek(s->pb, -8, SEEK_CUR); url_fseek(s->pb, -8, SEEK_CUR);
if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1)) if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
codec_id = CODEC_ID_CAVS; codec_id = CODEC_ID_CAVS;
@ -547,9 +547,9 @@ static int mpegps_read_packet(AVFormatContext *s,
audio data */ audio data */
if (len <= 3) if (len <= 3)
goto skip; goto skip;
get_byte(s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */ avio_r8(s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
b1 = get_byte(s->pb); /* quant (2), freq(2), reserved(1), channels(3) */ b1 = avio_r8(s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
get_byte(s->pb); /* dynamic range control (0x80 = off) */ avio_r8(s->pb); /* dynamic range control (0x80 = off) */
len -= 3; len -= 3;
freq = (b1 >> 4) & 3; freq = (b1 >> 4) & 3;
st->codec->sample_rate = lpcm_freq_tab[freq]; st->codec->sample_rate = lpcm_freq_tab[freq];
@ -564,7 +564,7 @@ static int mpegps_read_packet(AVFormatContext *s,
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
av_new_packet(pkt, len); av_new_packet(pkt, len);
get_buffer(s->pb, pkt->data, pkt->size); avio_read(s->pb, pkt->data, pkt->size);
pkt->pts = pts; pkt->pts = pts;
pkt->dts = dts; pkt->dts = dts;
pkt->pos = dummy_pos; pkt->pos = dummy_pos;

30
libavformat/mpegts.c
View File

@ -860,24 +860,24 @@ static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size,
len = ff_mp4_read_descr(s, &pb, &tag); len = ff_mp4_read_descr(s, &pb, &tag);
if (tag == MP4IODescrTag) { if (tag == MP4IODescrTag) {
get_be16(&pb); // ID avio_rb16(&pb); // ID
get_byte(&pb); avio_r8(&pb);
get_byte(&pb); avio_r8(&pb);
get_byte(&pb); avio_r8(&pb);
get_byte(&pb); avio_r8(&pb);
get_byte(&pb); avio_r8(&pb);
len = ff_mp4_read_descr(s, &pb, &tag); len = ff_mp4_read_descr(s, &pb, &tag);
if (tag == MP4ESDescrTag) { if (tag == MP4ESDescrTag) {
*es_id = get_be16(&pb); /* ES_ID */ *es_id = avio_rb16(&pb); /* ES_ID */
av_dlog(s, "ES_ID %#x\n", *es_id); av_dlog(s, "ES_ID %#x\n", *es_id);
get_byte(&pb); /* priority */ avio_r8(&pb); /* priority */
len = ff_mp4_read_descr(s, &pb, &tag); len = ff_mp4_read_descr(s, &pb, &tag);
if (tag == MP4DecConfigDescrTag) { if (tag == MP4DecConfigDescrTag) {
*dec_config_descr = av_malloc(len); *dec_config_descr = av_malloc(len);
if (!*dec_config_descr) if (!*dec_config_descr)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
*dec_config_descr_size = len; *dec_config_descr_size = len;
get_buffer(&pb, *dec_config_descr, len); avio_read(&pb, *dec_config_descr, len);
} }
} }
} }
@ -1332,7 +1332,7 @@ static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size)
int skip, len; int skip, len;
for(;;) { for(;;) {
len = get_buffer(pb, buf, TS_PACKET_SIZE); len = avio_read(pb, buf, TS_PACKET_SIZE);
if (len != TS_PACKET_SIZE) if (len != TS_PACKET_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
/* check paquet sync byte */ /* check paquet sync byte */
@ -1455,7 +1455,7 @@ static int mpegts_read_header(AVFormatContext *s,
/* read the first 1024 bytes to get packet size */ /* read the first 1024 bytes to get packet size */
pos = url_ftell(pb); pos = url_ftell(pb);
len = get_buffer(pb, buf, sizeof(buf)); len = avio_read(pb, buf, sizeof(buf));
if (len != sizeof(buf)) if (len != sizeof(buf))
goto fail; goto fail;
ts->raw_packet_size = get_packet_size(buf, sizeof(buf)); ts->raw_packet_size = get_packet_size(buf, sizeof(buf));
@ -1565,7 +1565,7 @@ static int mpegts_raw_read_packet(AVFormatContext *s,
pos = url_ftell(s->pb); pos = url_ftell(s->pb);
for(i = 0; i < MAX_PACKET_READAHEAD; i++) { for(i = 0; i < MAX_PACKET_READAHEAD; i++) {
url_fseek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET); url_fseek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
get_buffer(s->pb, pcr_buf, 12); avio_read(s->pb, pcr_buf, 12);
if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) { if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
/* XXX: not precise enough */ /* XXX: not precise enough */
ts->pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) / ts->pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
@ -1650,7 +1650,7 @@ static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
if (find_next) { if (find_next) {
for(;;) { for(;;) {
url_fseek(s->pb, pos, SEEK_SET); url_fseek(s->pb, pos, SEEK_SET);
if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE) if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
return AV_NOPTS_VALUE; return AV_NOPTS_VALUE;
if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) && if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
parse_pcr(&timestamp, &pcr_l, buf) == 0) { parse_pcr(&timestamp, &pcr_l, buf) == 0) {
@ -1664,7 +1664,7 @@ static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
if (pos < 0) if (pos < 0)
return AV_NOPTS_VALUE; return AV_NOPTS_VALUE;
url_fseek(s->pb, pos, SEEK_SET); url_fseek(s->pb, pos, SEEK_SET);
if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE) if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
return AV_NOPTS_VALUE; return AV_NOPTS_VALUE;
if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) && if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
parse_pcr(&timestamp, &pcr_l, buf) == 0) { parse_pcr(&timestamp, &pcr_l, buf) == 0) {
@ -1775,7 +1775,7 @@ static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, in
for(;;) { for(;;) {
url_fseek(s->pb, pos, SEEK_SET); url_fseek(s->pb, pos, SEEK_SET);
if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE) if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
return -1; return -1;
// pid = AV_RB16(buf + 1) & 0x1fff; // pid = AV_RB16(buf + 1) & 0x1fff;
if(buf[1] & 0x40) break; if(buf[1] & 0x40) break;

8
libavformat/msnwc_tcp.c
View File

@ -88,7 +88,7 @@ static int msnwc_tcp_read_header(AVFormatContext *ctx, AVFormatParameters *ap)
/* Some files start with "connected\r\n\r\n". /* Some files start with "connected\r\n\r\n".
* So skip until we find the first byte of struct size */ * So skip until we find the first byte of struct size */
while(get_byte(pb) != HEADER_SIZE && !url_feof(pb)); while(avio_r8(pb) != HEADER_SIZE && !url_feof(pb));
if(url_feof(pb)) { if(url_feof(pb)) {
av_log(ctx, AV_LOG_ERROR, "Could not find valid start."); av_log(ctx, AV_LOG_ERROR, "Could not find valid start.");
@ -107,11 +107,11 @@ static int msnwc_tcp_read_packet(AVFormatContext *ctx, AVPacket *pkt)
url_fskip(pb, 1); /* one byte has been read ahead */ url_fskip(pb, 1); /* one byte has been read ahead */
url_fskip(pb, 2); url_fskip(pb, 2);
url_fskip(pb, 2); url_fskip(pb, 2);
keyframe = get_le16(pb); keyframe = avio_rl16(pb);
size = get_le32(pb); size = avio_rl32(pb);
url_fskip(pb, 4); url_fskip(pb, 4);
url_fskip(pb, 4); url_fskip(pb, 4);
timestamp = get_le32(pb); timestamp = avio_rl32(pb);
if(!size || av_get_packet(pb, pkt, size) != size) if(!size || av_get_packet(pb, pkt, size) != size)
return -1; return -1;

20
libavformat/mtv.c
View File

@ -84,16 +84,16 @@ static int mtv_read_header(AVFormatContext *s, AVFormatParameters *ap)
unsigned int audio_subsegments; unsigned int audio_subsegments;
url_fskip(pb, 3); url_fskip(pb, 3);
mtv->file_size = get_le32(pb); mtv->file_size = avio_rl32(pb);
mtv->segments = get_le32(pb); mtv->segments = avio_rl32(pb);
url_fskip(pb, 32); url_fskip(pb, 32);
mtv->audio_identifier = get_le24(pb); mtv->audio_identifier = avio_rl24(pb);
mtv->audio_br = get_le16(pb); mtv->audio_br = avio_rl16(pb);
mtv->img_colorfmt = get_le24(pb); mtv->img_colorfmt = avio_rl24(pb);
mtv->img_bpp = get_byte(pb); mtv->img_bpp = avio_r8(pb);
mtv->img_width = get_le16(pb); mtv->img_width = avio_rl16(pb);
mtv->img_height = get_le16(pb); mtv->img_height = avio_rl16(pb);
mtv->img_segment_size = get_le16(pb); mtv->img_segment_size = avio_rl16(pb);
/* Calculate width and height if missing from header */ /* Calculate width and height if missing from header */
@ -106,7 +106,7 @@ static int mtv_read_header(AVFormatContext *s, AVFormatParameters *ap)
/ mtv->img_width; / mtv->img_width;
url_fskip(pb, 4); url_fskip(pb, 4);
audio_subsegments = get_le16(pb); audio_subsegments = avio_rl16(pb);
mtv->full_segment_size = mtv->full_segment_size =
audio_subsegments * (MTV_AUDIO_PADDING_SIZE + MTV_ASUBCHUNK_DATA_SIZE) + audio_subsegments * (MTV_AUDIO_PADDING_SIZE + MTV_ASUBCHUNK_DATA_SIZE) +
mtv->img_segment_size; mtv->img_segment_size;

30
libavformat/mvi.c
View File

@ -53,20 +53,20 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
vst->codec->extradata_size = 2; vst->codec->extradata_size = 2;
vst->codec->extradata = av_mallocz(2 + FF_INPUT_BUFFER_PADDING_SIZE); vst->codec->extradata = av_mallocz(2 + FF_INPUT_BUFFER_PADDING_SIZE);
version = get_byte(pb); version = avio_r8(pb);
vst->codec->extradata[0] = get_byte(pb); vst->codec->extradata[0] = avio_r8(pb);
vst->codec->extradata[1] = get_byte(pb); vst->codec->extradata[1] = avio_r8(pb);
frames_count = get_le32(pb); frames_count = avio_rl32(pb);
msecs_per_frame = get_le32(pb); msecs_per_frame = avio_rl32(pb);
vst->codec->width = get_le16(pb); vst->codec->width = avio_rl16(pb);
vst->codec->height = get_le16(pb); vst->codec->height = avio_rl16(pb);
get_byte(pb); avio_r8(pb);
ast->codec->sample_rate = get_le16(pb); ast->codec->sample_rate = avio_rl16(pb);
mvi->audio_data_size = get_le32(pb); mvi->audio_data_size = avio_rl32(pb);
get_byte(pb); avio_r8(pb);
player_version = get_le32(pb); player_version = avio_rl32(pb);
get_le16(pb); avio_rl16(pb);
get_byte(pb); avio_r8(pb);
if (frames_count == 0 || mvi->audio_data_size == 0) if (frames_count == 0 || mvi->audio_data_size == 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -87,7 +87,7 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_MOTIONPIXELS; vst->codec->codec_id = CODEC_ID_MOTIONPIXELS;
mvi->get_int = (vst->codec->width * vst->codec->height < (1 << 16)) ? get_le16 : get_le24; mvi->get_int = (vst->codec->width * vst->codec->height < (1 << 16)) ? avio_rl16 : avio_rl24;
mvi->audio_frame_size = ((uint64_t)mvi->audio_data_size << MVI_FRAC_BITS) / frames_count; mvi->audio_frame_size = ((uint64_t)mvi->audio_data_size << MVI_FRAC_BITS) / frames_count;
mvi->audio_size_counter = (ast->codec->sample_rate * 830 / mvi->audio_frame_size - 1) * mvi->audio_frame_size; mvi->audio_size_counter = (ast->codec->sample_rate * 830 / mvi->audio_frame_size - 1) * mvi->audio_frame_size;

122
libavformat/mxfdec.c
View File

@ -163,7 +163,7 @@ static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x
static int64_t klv_decode_ber_length(AVIOContext *pb) static int64_t klv_decode_ber_length(AVIOContext *pb)
{ {
uint64_t size = get_byte(pb); uint64_t size = avio_r8(pb);
if (size & 0x80) { /* long form */ if (size & 0x80) { /* long form */
int bytes_num = size & 0x7f; int bytes_num = size & 0x7f;
/* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */ /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
@ -171,7 +171,7 @@ static int64_t klv_decode_ber_length(AVIOContext *pb)
return -1; return -1;
size = 0; size = 0;
while (bytes_num--) while (bytes_num--)
size = size << 8 | get_byte(pb); size = size << 8 | avio_r8(pb);
} }
return size; return size;
} }
@ -180,7 +180,7 @@ static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
{ {
int i, b; int i, b;
for (i = 0; i < size && !url_feof(pb); i++) { for (i = 0; i < size && !url_feof(pb); i++) {
b = get_byte(pb); b = avio_r8(pb);
if (b == key[0]) if (b == key[0])
i = 0; i = 0;
else if (b != key[i]) else if (b != key[i])
@ -195,7 +195,7 @@ static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
return -1; return -1;
klv->offset = url_ftell(pb) - 4; klv->offset = url_ftell(pb) - 4;
memcpy(klv->key, mxf_klv_key, 4); memcpy(klv->key, mxf_klv_key, 4);
get_buffer(pb, klv->key + 4, 12); avio_read(pb, klv->key + 4, 12);
klv->length = klv_decode_ber_length(pb); klv->length = klv_decode_ber_length(pb);
return klv->length == -1 ? -1 : 0; return klv->length == -1 ? -1 : 0;
} }
@ -224,7 +224,7 @@ static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt,
if (length > 61444) /* worst case PAL 1920 samples 8 channels */ if (length > 61444) /* worst case PAL 1920 samples 8 channels */
return -1; return -1;
av_new_packet(pkt, length); av_new_packet(pkt, length);
get_buffer(pb, pkt->data, length); avio_read(pb, pkt->data, length);
data_ptr = pkt->data; data_ptr = pkt->data;
end_ptr = pkt->data + length; end_ptr = pkt->data + length;
buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */ buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
@ -265,10 +265,10 @@ static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv
url_fskip(pb, klv_decode_ber_length(pb)); url_fskip(pb, klv_decode_ber_length(pb));
// plaintext offset // plaintext offset
klv_decode_ber_length(pb); klv_decode_ber_length(pb);
plaintext_size = get_be64(pb); plaintext_size = avio_rb64(pb);
// source klv key // source klv key
klv_decode_ber_length(pb); klv_decode_ber_length(pb);
get_buffer(pb, klv->key, 16); avio_read(pb, klv->key, 16);
if (!IS_KLV_KEY(klv, mxf_essence_element_key)) if (!IS_KLV_KEY(klv, mxf_essence_element_key))
return -1; return -1;
index = mxf_get_stream_index(s, klv); index = mxf_get_stream_index(s, klv);
@ -276,15 +276,15 @@ static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv
return -1; return -1;
// source size // source size
klv_decode_ber_length(pb); klv_decode_ber_length(pb);
orig_size = get_be64(pb); orig_size = avio_rb64(pb);
if (orig_size < plaintext_size) if (orig_size < plaintext_size)
return -1; return -1;
// enc. code // enc. code
size = klv_decode_ber_length(pb); size = klv_decode_ber_length(pb);
if (size < 32 || size - 32 < orig_size) if (size < 32 || size - 32 < orig_size)
return -1; return -1;
get_buffer(pb, ivec, 16); avio_read(pb, ivec, 16);
get_buffer(pb, tmpbuf, 16); avio_read(pb, tmpbuf, 16);
if (mxf->aesc) if (mxf->aesc)
av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1); av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
if (memcmp(tmpbuf, checkv, 16)) if (memcmp(tmpbuf, checkv, 16))
@ -347,8 +347,8 @@ static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid) static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid)
{ {
MXFContext *mxf = arg; MXFContext *mxf = arg;
int item_num = get_be32(pb); int item_num = avio_rb32(pb);
int item_len = get_be32(pb); int item_len = avio_rb32(pb);
if (item_len != 18) { if (item_len != 18) {
av_log(mxf->fc, AV_LOG_ERROR, "unsupported primer pack item length\n"); av_log(mxf->fc, AV_LOG_ERROR, "unsupported primer pack item length\n");
@ -360,7 +360,7 @@ static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, U
mxf->local_tags = av_malloc(item_num*item_len); mxf->local_tags = av_malloc(item_num*item_len);
if (!mxf->local_tags) if (!mxf->local_tags)
return -1; return -1;
get_buffer(pb, mxf->local_tags, item_num*item_len); avio_read(pb, mxf->local_tags, item_num*item_len);
return 0; return 0;
} }
@ -382,7 +382,7 @@ static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, i
if (size != 16) if (size != 16)
return -1; return -1;
if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul)) if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
get_buffer(pb, cryptocontext->source_container_ul, 16); avio_read(pb, cryptocontext->source_container_ul, 16);
return 0; return 0;
} }
@ -391,14 +391,14 @@ static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int siz
MXFContext *mxf = arg; MXFContext *mxf = arg;
switch (tag) { switch (tag) {
case 0x1901: case 0x1901:
mxf->packages_count = get_be32(pb); mxf->packages_count = avio_rb32(pb);
if (mxf->packages_count >= UINT_MAX / sizeof(UID)) if (mxf->packages_count >= UINT_MAX / sizeof(UID))
return -1; return -1;
mxf->packages_refs = av_malloc(mxf->packages_count * sizeof(UID)); mxf->packages_refs = av_malloc(mxf->packages_count * sizeof(UID));
if (!mxf->packages_refs) if (!mxf->packages_refs)
return -1; return -1;
url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */ url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
get_buffer(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID)); avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
break; break;
} }
return 0; return 0;
@ -409,18 +409,18 @@ static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, U
MXFStructuralComponent *source_clip = arg; MXFStructuralComponent *source_clip = arg;
switch(tag) { switch(tag) {
case 0x0202: case 0x0202:
source_clip->duration = get_be64(pb); source_clip->duration = avio_rb64(pb);
break; break;
case 0x1201: case 0x1201:
source_clip->start_position = get_be64(pb); source_clip->start_position = avio_rb64(pb);
break; break;
case 0x1101: case 0x1101:
/* UMID, only get last 16 bytes */ /* UMID, only get last 16 bytes */
url_fskip(pb, 16); url_fskip(pb, 16);
get_buffer(pb, source_clip->source_package_uid, 16); avio_read(pb, source_clip->source_package_uid, 16);
break; break;
case 0x1102: case 0x1102:
source_clip->source_track_id = get_be32(pb); source_clip->source_track_id = avio_rb32(pb);
break; break;
} }
return 0; return 0;
@ -431,14 +431,14 @@ static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int si
MXFPackage *package = arg; MXFPackage *package = arg;
switch(tag) { switch(tag) {
case 0x4403: case 0x4403:
package->tracks_count = get_be32(pb); package->tracks_count = avio_rb32(pb);
if (package->tracks_count >= UINT_MAX / sizeof(UID)) if (package->tracks_count >= UINT_MAX / sizeof(UID))
return -1; return -1;
package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID)); package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID));
if (!package->tracks_refs) if (!package->tracks_refs)
return -1; return -1;
url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */ url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
get_buffer(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID)); avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
break; break;
} }
return 0; return 0;
@ -449,17 +449,17 @@ static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid
MXFTrack *track = arg; MXFTrack *track = arg;
switch(tag) { switch(tag) {
case 0x4801: case 0x4801:
track->track_id = get_be32(pb); track->track_id = avio_rb32(pb);
break; break;
case 0x4804: case 0x4804:
get_buffer(pb, track->track_number, 4); avio_read(pb, track->track_number, 4);
break; break;
case 0x4B01: case 0x4B01:
track->edit_rate.den = get_be32(pb); track->edit_rate.den = avio_rb32(pb);
track->edit_rate.num = get_be32(pb); track->edit_rate.num = avio_rb32(pb);
break; break;
case 0x4803: case 0x4803:
get_buffer(pb, track->sequence_ref, 16); avio_read(pb, track->sequence_ref, 16);
break; break;
} }
return 0; return 0;
@ -470,20 +470,20 @@ static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID
MXFSequence *sequence = arg; MXFSequence *sequence = arg;
switch(tag) { switch(tag) {
case 0x0202: case 0x0202:
sequence->duration = get_be64(pb); sequence->duration = avio_rb64(pb);
break; break;
case 0x0201: case 0x0201:
get_buffer(pb, sequence->data_definition_ul, 16); avio_read(pb, sequence->data_definition_ul, 16);
break; break;
case 0x1001: case 0x1001:
sequence->structural_components_count = get_be32(pb); sequence->structural_components_count = avio_rb32(pb);
if (sequence->structural_components_count >= UINT_MAX / sizeof(UID)) if (sequence->structural_components_count >= UINT_MAX / sizeof(UID))
return -1; return -1;
sequence->structural_components_refs = av_malloc(sequence->structural_components_count * sizeof(UID)); sequence->structural_components_refs = av_malloc(sequence->structural_components_count * sizeof(UID));
if (!sequence->structural_components_refs) if (!sequence->structural_components_refs)
return -1; return -1;
url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */ url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
get_buffer(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID)); avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
break; break;
} }
return 0; return 0;
@ -494,22 +494,22 @@ static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size
MXFPackage *package = arg; MXFPackage *package = arg;
switch(tag) { switch(tag) {
case 0x4403: case 0x4403:
package->tracks_count = get_be32(pb); package->tracks_count = avio_rb32(pb);
if (package->tracks_count >= UINT_MAX / sizeof(UID)) if (package->tracks_count >= UINT_MAX / sizeof(UID))
return -1; return -1;
package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID)); package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID));
if (!package->tracks_refs) if (!package->tracks_refs)
return -1; return -1;
url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */ url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
get_buffer(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID)); avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
break; break;
case 0x4401: case 0x4401:
/* UMID, only get last 16 bytes */ /* UMID, only get last 16 bytes */
url_fskip(pb, 16); url_fskip(pb, 16);
get_buffer(pb, package->package_uid, 16); avio_read(pb, package->package_uid, 16);
break; break;
case 0x4701: case 0x4701:
get_buffer(pb, package->descriptor_ref, 16); avio_read(pb, package->descriptor_ref, 16);
break; break;
} }
return 0; return 0;
@ -518,12 +518,12 @@ static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size
static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid) static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid)
{ {
switch(tag) { switch(tag) {
case 0x3F05: av_dlog(NULL, "EditUnitByteCount %d\n", get_be32(pb)); break; case 0x3F05: av_dlog(NULL, "EditUnitByteCount %d\n", avio_rb32(pb)); break;
case 0x3F06: av_dlog(NULL, "IndexSID %d\n", get_be32(pb)); break; case 0x3F06: av_dlog(NULL, "IndexSID %d\n", avio_rb32(pb)); break;
case 0x3F07: av_dlog(NULL, "BodySID %d\n", get_be32(pb)); break; case 0x3F07: av_dlog(NULL, "BodySID %d\n", avio_rb32(pb)); break;
case 0x3F0B: av_dlog(NULL, "IndexEditRate %d/%d\n", get_be32(pb), get_be32(pb)); break; case 0x3F0B: av_dlog(NULL, "IndexEditRate %d/%d\n", avio_rb32(pb), avio_rb32(pb)); break;
case 0x3F0C: av_dlog(NULL, "IndexStartPosition %lld\n", get_be64(pb)); break; case 0x3F0C: av_dlog(NULL, "IndexStartPosition %lld\n", avio_rb64(pb)); break;
case 0x3F0D: av_dlog(NULL, "IndexDuration %lld\n", get_be64(pb)); break; case 0x3F0D: av_dlog(NULL, "IndexDuration %lld\n", avio_rb64(pb)); break;
} }
return 0; return 0;
} }
@ -534,8 +534,8 @@ static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
char layout[16] = {0}; char layout[16] = {0};
do { do {
code = get_byte(pb); code = avio_r8(pb);
value = get_byte(pb); value = avio_r8(pb);
av_dlog(NULL, "pixel layout: code %#x\n", code); av_dlog(NULL, "pixel layout: code %#x\n", code);
if (ofs < 16) { if (ofs < 16) {
@ -552,46 +552,46 @@ static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int
MXFDescriptor *descriptor = arg; MXFDescriptor *descriptor = arg;
switch(tag) { switch(tag) {
case 0x3F01: case 0x3F01:
descriptor->sub_descriptors_count = get_be32(pb); descriptor->sub_descriptors_count = avio_rb32(pb);
if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID)) if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID))
return -1; return -1;
descriptor->sub_descriptors_refs = av_malloc(descriptor->sub_descriptors_count * sizeof(UID)); descriptor->sub_descriptors_refs = av_malloc(descriptor->sub_descriptors_count * sizeof(UID));
if (!descriptor->sub_descriptors_refs) if (!descriptor->sub_descriptors_refs)
return -1; return -1;
url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */ url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
get_buffer(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID)); avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
break; break;
case 0x3004: case 0x3004:
get_buffer(pb, descriptor->essence_container_ul, 16); avio_read(pb, descriptor->essence_container_ul, 16);
break; break;
case 0x3006: case 0x3006:
descriptor->linked_track_id = get_be32(pb); descriptor->linked_track_id = avio_rb32(pb);
break; break;
case 0x3201: /* PictureEssenceCoding */ case 0x3201: /* PictureEssenceCoding */
get_buffer(pb, descriptor->essence_codec_ul, 16); avio_read(pb, descriptor->essence_codec_ul, 16);
break; break;
case 0x3203: case 0x3203:
descriptor->width = get_be32(pb); descriptor->width = avio_rb32(pb);
break; break;
case 0x3202: case 0x3202:
descriptor->height = get_be32(pb); descriptor->height = avio_rb32(pb);
break; break;
case 0x320E: case 0x320E:
descriptor->aspect_ratio.num = get_be32(pb); descriptor->aspect_ratio.num = avio_rb32(pb);
descriptor->aspect_ratio.den = get_be32(pb); descriptor->aspect_ratio.den = avio_rb32(pb);
break; break;
case 0x3D03: case 0x3D03:
descriptor->sample_rate.num = get_be32(pb); descriptor->sample_rate.num = avio_rb32(pb);
descriptor->sample_rate.den = get_be32(pb); descriptor->sample_rate.den = avio_rb32(pb);
break; break;
case 0x3D06: /* SoundEssenceCompression */ case 0x3D06: /* SoundEssenceCompression */
get_buffer(pb, descriptor->essence_codec_ul, 16); avio_read(pb, descriptor->essence_codec_ul, 16);
break; break;
case 0x3D07: case 0x3D07:
descriptor->channels = get_be32(pb); descriptor->channels = avio_rb32(pb);
break; break;
case 0x3D01: case 0x3D01:
descriptor->bits_per_sample = get_be32(pb); descriptor->bits_per_sample = avio_rb32(pb);
break; break;
case 0x3401: case 0x3401:
mxf_read_pixel_layout(pb, descriptor); mxf_read_pixel_layout(pb, descriptor);
@ -603,7 +603,7 @@ static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int
if (!descriptor->extradata) if (!descriptor->extradata)
return -1; return -1;
descriptor->extradata_size = size; descriptor->extradata_size = size;
get_buffer(pb, descriptor->extradata, size); avio_read(pb, descriptor->extradata, size);
} }
break; break;
} }
@ -871,8 +871,8 @@ static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadF
if (!ctx) if (!ctx)
return -1; return -1;
while (url_ftell(pb) + 4 < klv_end) { while (url_ftell(pb) + 4 < klv_end) {
int tag = get_be16(pb); int tag = avio_rb16(pb);
int size = get_be16(pb); /* KLV specified by 0x53 */ int size = avio_rb16(pb); /* KLV specified by 0x53 */
uint64_t next = url_ftell(pb) + size; uint64_t next = url_ftell(pb) + size;
UID uid = {0}; UID uid = {0};
@ -893,7 +893,7 @@ static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadF
} }
} }
if (ctx_size && tag == 0x3C0A) if (ctx_size && tag == 0x3C0A)
get_buffer(pb, ctx->uid, 16); avio_read(pb, ctx->uid, 16);
else if (read_child(ctx, pb, tag, size, uid) < 0) else if (read_child(ctx, pb, tag, size, uid) < 0)
return -1; return -1;

2
libavformat/mxg.c
View File

@ -115,7 +115,7 @@ static int mxg_update_cache(AVFormatContext *s, unsigned int cache_size)
if (mxg->soi_ptr) mxg->soi_ptr = mxg->buffer + soi_pos; if (mxg->soi_ptr) mxg->soi_ptr = mxg->buffer + soi_pos;
/* get data */ /* get data */
ret = get_buffer(s->pb, mxg->buffer_ptr + mxg->cache_size, ret = avio_read(s->pb, mxg->buffer_ptr + mxg->cache_size,
cache_size - mxg->cache_size); cache_size - mxg->cache_size);
if (ret < 0) if (ret < 0)
return ret; return ret;

6
libavformat/ncdec.c
View File

@ -68,11 +68,11 @@ static int nc_read_packet(AVFormatContext *s, AVPacket *pkt)
while (state != NC_VIDEO_FLAG) { while (state != NC_VIDEO_FLAG) {
if (url_feof(s->pb)) if (url_feof(s->pb))
return AVERROR(EIO); return AVERROR(EIO);
state = (state<<8) + get_byte(s->pb); state = (state<<8) + avio_r8(s->pb);
} }
get_byte(s->pb); avio_r8(s->pb);
size = get_le16(s->pb); size = avio_rl16(s->pb);
url_fskip(s->pb, 9); url_fskip(s->pb, 9);
if (size == 0) { if (size == 0) {

54
libavformat/nsvdec.c
View File

@ -236,7 +236,7 @@ static int nsv_resync(AVFormatContext *s)
return -1; return -1;
} }
v <<= 8; v <<= 8;
v |= get_byte(pb); v |= avio_r8(pb);
if (i < 8) { if (i < 8) {
av_dlog(s, "NSV resync: [%d] = %02x\n", i, v & 0x0FF); av_dlog(s, "NSV resync: [%d] = %02x\n", i, v & 0x0FF);
} }
@ -277,23 +277,23 @@ static int nsv_parse_NSVf_header(AVFormatContext *s, AVFormatParameters *ap)
nsv->state = NSV_UNSYNC; /* in case we fail */ nsv->state = NSV_UNSYNC; /* in case we fail */
size = get_le32(pb); size = avio_rl32(pb);
if (size < 28) if (size < 28)
return -1; return -1;
nsv->NSVf_end = size; nsv->NSVf_end = size;
//s->file_size = (uint32_t)get_le32(pb); //s->file_size = (uint32_t)avio_rl32(pb);
file_size = (uint32_t)get_le32(pb); file_size = (uint32_t)avio_rl32(pb);
av_dlog(s, "NSV NSVf chunk_size %u\n", size); av_dlog(s, "NSV NSVf chunk_size %u\n", size);
av_dlog(s, "NSV NSVf file_size %u\n", file_size); av_dlog(s, "NSV NSVf file_size %u\n", file_size);
nsv->duration = duration = get_le32(pb); /* in ms */ nsv->duration = duration = avio_rl32(pb); /* in ms */
av_dlog(s, "NSV NSVf duration %"PRId64" ms\n", duration); av_dlog(s, "NSV NSVf duration %"PRId64" ms\n", duration);
// XXX: store it in AVStreams // XXX: store it in AVStreams
strings_size = get_le32(pb); strings_size = avio_rl32(pb);
table_entries = get_le32(pb); table_entries = avio_rl32(pb);
table_entries_used = get_le32(pb); table_entries_used = avio_rl32(pb);
av_dlog(s, "NSV NSVf info-strings size: %d, table entries: %d, bis %d\n", av_dlog(s, "NSV NSVf info-strings size: %d, table entries: %d, bis %d\n",
strings_size, table_entries, table_entries_used); strings_size, table_entries, table_entries_used);
if (url_feof(pb)) if (url_feof(pb))
@ -309,7 +309,7 @@ static int nsv_parse_NSVf_header(AVFormatContext *s, AVFormatParameters *ap)
p = strings = av_mallocz(strings_size + 1); p = strings = av_mallocz(strings_size + 1);
endp = strings + strings_size; endp = strings + strings_size;
get_buffer(pb, strings, strings_size); avio_read(pb, strings, strings_size);
while (p < endp) { while (p < endp) {
while (*p == ' ') while (*p == ' ')
p++; /* strip out spaces */ p++; /* strip out spaces */
@ -344,13 +344,13 @@ static int nsv_parse_NSVf_header(AVFormatContext *s, AVFormatParameters *ap)
nsv->nsvs_file_offset = av_malloc((unsigned)table_entries_used * sizeof(uint32_t)); nsv->nsvs_file_offset = av_malloc((unsigned)table_entries_used * sizeof(uint32_t));
for(i=0;i<table_entries_used;i++) for(i=0;i<table_entries_used;i++)
nsv->nsvs_file_offset[i] = get_le32(pb) + size; nsv->nsvs_file_offset[i] = avio_rl32(pb) + size;
if(table_entries > table_entries_used && if(table_entries > table_entries_used &&
get_le32(pb) == MKTAG('T','O','C','2')) { avio_rl32(pb) == MKTAG('T','O','C','2')) {
nsv->nsvs_timestamps = av_malloc((unsigned)table_entries_used*sizeof(uint32_t)); nsv->nsvs_timestamps = av_malloc((unsigned)table_entries_used*sizeof(uint32_t));
for(i=0;i<table_entries_used;i++) { for(i=0;i<table_entries_used;i++) {
nsv->nsvs_timestamps[i] = get_le32(pb); nsv->nsvs_timestamps[i] = avio_rl32(pb);
} }
} }
} }
@ -365,7 +365,7 @@ static int nsv_parse_NSVf_header(AVFormatContext *s, AVFormatParameters *ap)
for (i = 0; i < table_entries; i++) { for (i = 0; i < table_entries; i++) {
unsigned char b[8]; unsigned char b[8];
url_fseek(pb, size + nsv->nsvs_file_offset[i], SEEK_SET); url_fseek(pb, size + nsv->nsvs_file_offset[i], SEEK_SET);
get_buffer(pb, b, 8); avio_read(pb, b, 8);
av_dlog(s, "NSV [0x%08lx][0x%08lx]: %02x %02x %02x %02x %02x %02x %02x %02x" av_dlog(s, "NSV [0x%08lx][0x%08lx]: %02x %02x %02x %02x %02x %02x %02x %02x"
"%c%c%c%c%c%c%c%c\n", "%c%c%c%c%c%c%c%c\n",
nsv->nsvs_file_offset[i], size + nsv->nsvs_file_offset[i], nsv->nsvs_file_offset[i], size + nsv->nsvs_file_offset[i],
@ -396,11 +396,11 @@ static int nsv_parse_NSVs_header(AVFormatContext *s, AVFormatParameters *ap)
NSVStream *nst; NSVStream *nst;
av_dlog(s, "%s()\n", __FUNCTION__); av_dlog(s, "%s()\n", __FUNCTION__);
vtag = get_le32(pb); vtag = avio_rl32(pb);
atag = get_le32(pb); atag = avio_rl32(pb);
vwidth = get_le16(pb); vwidth = avio_rl16(pb);
vheight = get_le16(pb); vheight = avio_rl16(pb);
i = get_byte(pb); i = avio_r8(pb);
av_dlog(s, "NSV NSVs framerate code %2x\n", i); av_dlog(s, "NSV NSVs framerate code %2x\n", i);
if(i&0x80) { /* odd way of giving native framerates from docs */ if(i&0x80) { /* odd way of giving native framerates from docs */
@ -420,7 +420,7 @@ static int nsv_parse_NSVs_header(AVFormatContext *s, AVFormatParameters *ap)
else else
framerate= (AVRational){i, 1}; framerate= (AVRational){i, 1};
nsv->avsync = get_le16(pb); nsv->avsync = avio_rl16(pb);
nsv->framerate = framerate; nsv->framerate = framerate;
print_tag("NSV NSVs vtag", vtag, 0); print_tag("NSV NSVs vtag", vtag, 0);
@ -568,16 +568,16 @@ null_chunk_retry:
if (nsv->state != NSV_HAS_READ_NSVS && nsv->state != NSV_FOUND_BEEF) if (nsv->state != NSV_HAS_READ_NSVS && nsv->state != NSV_FOUND_BEEF)
return -1; return -1;
auxcount = get_byte(pb); auxcount = avio_r8(pb);
vsize = get_le16(pb); vsize = avio_rl16(pb);
asize = get_le16(pb); asize = avio_rl16(pb);
vsize = (vsize << 4) | (auxcount >> 4); vsize = (vsize << 4) | (auxcount >> 4);
auxcount &= 0x0f; auxcount &= 0x0f;
av_dlog(s, "NSV CHUNK %d aux, %u bytes video, %d bytes audio\n", auxcount, vsize, asize); av_dlog(s, "NSV CHUNK %d aux, %u bytes video, %d bytes audio\n", auxcount, vsize, asize);
/* skip aux stuff */ /* skip aux stuff */
for (i = 0; i < auxcount; i++) { for (i = 0; i < auxcount; i++) {
auxsize = get_le16(pb); auxsize = avio_rl16(pb);
auxtag = get_le32(pb); auxtag = avio_rl32(pb);
av_dlog(s, "NSV aux data: '%c%c%c%c', %d bytes\n", av_dlog(s, "NSV aux data: '%c%c%c%c', %d bytes\n",
(auxtag & 0x0ff), (auxtag & 0x0ff),
((auxtag >> 8) & 0x0ff), ((auxtag >> 8) & 0x0ff),
@ -623,9 +623,9 @@ null_chunk_retry:
uint8_t bps; uint8_t bps;
uint8_t channels; uint8_t channels;
uint16_t samplerate; uint16_t samplerate;
bps = get_byte(pb); bps = avio_r8(pb);
channels = get_byte(pb); channels = avio_r8(pb);
samplerate = get_le16(pb); samplerate = avio_rl16(pb);
asize-=4; asize-=4;
av_dlog(s, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate); av_dlog(s, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate);
if (fill_header) { if (fill_header) {

32
libavformat/nutdec.c
View File

@ -39,9 +39,9 @@ static int get_str(AVIOContext *bc, char *string, unsigned int maxlen){
unsigned int len= ff_get_v(bc); unsigned int len= ff_get_v(bc);
if(len && maxlen) if(len && maxlen)
get_buffer(bc, string, FFMIN(len, maxlen)); avio_read(bc, string, FFMIN(len, maxlen));
while(len > maxlen){ while(len > maxlen){
get_byte(bc); avio_r8(bc);
len--; len--;
} }
@ -64,8 +64,8 @@ static int64_t get_s(AVIOContext *bc){
static uint64_t get_fourcc(AVIOContext *bc){ static uint64_t get_fourcc(AVIOContext *bc){
unsigned int len= ff_get_v(bc); unsigned int len= ff_get_v(bc);
if (len==2) return get_le16(bc); if (len==2) return avio_rl16(bc);
else if(len==4) return get_le32(bc); else if(len==4) return avio_rl32(bc);
else return -1; else return -1;
} }
@ -106,7 +106,7 @@ static int get_packetheader(NUTContext *nut, AVIOContext *bc, int calculate_chec
init_checksum(bc, ff_crc04C11DB7_update, startcode); init_checksum(bc, ff_crc04C11DB7_update, startcode);
size= ff_get_v(bc); size= ff_get_v(bc);
if(size > 4096) if(size > 4096)
get_be32(bc); avio_rb32(bc);
if(get_checksum(bc) && size > 4096) if(get_checksum(bc) && size > 4096)
return -1; return -1;
@ -122,7 +122,7 @@ static uint64_t find_any_startcode(AVIOContext *bc, int64_t pos){
url_fseek(bc, pos, SEEK_SET); //note, this may fail if the stream is not seekable, but that should not matter, as in this case we simply start where we currently are url_fseek(bc, pos, SEEK_SET); //note, this may fail if the stream is not seekable, but that should not matter, as in this case we simply start where we currently are
while(!url_feof(bc)){ while(!url_feof(bc)){
state= (state<<8) | get_byte(bc); state= (state<<8) | avio_r8(bc);
if((state>>56) != 'N') if((state>>56) != 'N')
continue; continue;
switch(state){ switch(state){
@ -182,7 +182,7 @@ static int skip_reserved(AVIOContext *bc, int64_t pos){
return -1; return -1;
}else{ }else{
while(pos--) while(pos--)
get_byte(bc); avio_r8(bc);
return 0; return 0;
} }
} }
@ -279,7 +279,7 @@ static int decode_main_header(NUTContext *nut){
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
nut->header[i]= av_malloc(nut->header_len[i]); nut->header[i]= av_malloc(nut->header_len[i]);
get_buffer(bc, nut->header[i], nut->header_len[i]); avio_read(bc, nut->header[i], nut->header_len[i]);
} }
assert(nut->header_len[0]==0); assert(nut->header_len[0]==0);
} }
@ -355,7 +355,7 @@ static int decode_stream_header(NUTContext *nut){
GET_V(st->codec->extradata_size, tmp < (1<<30)); GET_V(st->codec->extradata_size, tmp < (1<<30));
if(st->codec->extradata_size){ if(st->codec->extradata_size){
st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(bc, st->codec->extradata, st->codec->extradata_size); avio_read(bc, st->codec->extradata, st->codec->extradata_size);
} }
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO){ if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
@ -514,8 +514,8 @@ static int find_and_decode_index(NUTContext *nut){
int ret= -1; int ret= -1;
url_fseek(bc, filesize-12, SEEK_SET); url_fseek(bc, filesize-12, SEEK_SET);
url_fseek(bc, filesize-get_be64(bc), SEEK_SET); url_fseek(bc, filesize-avio_rb64(bc), SEEK_SET);
if(get_be64(bc) != INDEX_STARTCODE){ if(avio_rb64(bc) != INDEX_STARTCODE){
av_log(s, AV_LOG_ERROR, "no index at the end\n"); av_log(s, AV_LOG_ERROR, "no index at the end\n");
return -1; return -1;
} }
@ -722,7 +722,7 @@ static int decode_frame_header(NUTContext *nut, int64_t *pts, int *stream_id, ui
size -= nut->header_len[*header_idx]; size -= nut->header_len[*header_idx];
if(flags&FLAG_CHECKSUM){ if(flags&FLAG_CHECKSUM){
get_be32(bc); //FIXME check this avio_rb32(bc); //FIXME check this
}else if(size > 2*nut->max_distance || FFABS(stc->last_pts - *pts) > stc->max_pts_distance){ }else if(size > 2*nut->max_distance || FFABS(stc->last_pts - *pts) > stc->max_pts_distance){
av_log(s, AV_LOG_ERROR, "frame size > 2max_distance and no checksum\n"); av_log(s, AV_LOG_ERROR, "frame size > 2max_distance and no checksum\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -764,7 +764,7 @@ static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code){
av_new_packet(pkt, size + nut->header_len[header_idx]); av_new_packet(pkt, size + nut->header_len[header_idx]);
memcpy(pkt->data, nut->header[header_idx], nut->header_len[header_idx]); memcpy(pkt->data, nut->header[header_idx], nut->header_len[header_idx]);
pkt->pos= url_ftell(bc); //FIXME pkt->pos= url_ftell(bc); //FIXME
get_buffer(bc, pkt->data + nut->header_len[header_idx], size); avio_read(bc, pkt->data + nut->header_len[header_idx], size);
pkt->stream_index = stream_id; pkt->stream_index = stream_id;
if (stc->last_flags & FLAG_KEY) if (stc->last_flags & FLAG_KEY)
@ -789,13 +789,13 @@ static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)
if(tmp){ if(tmp){
pos-=8; pos-=8;
}else{ }else{
frame_code = get_byte(bc); frame_code = avio_r8(bc);
if(url_feof(bc)) if(url_feof(bc))
return -1; return -1;
if(frame_code == 'N'){ if(frame_code == 'N'){
tmp= frame_code; tmp= frame_code;
for(i=1; i<8; i++) for(i=1; i<8; i++)
tmp = (tmp<<8) + get_byte(bc); tmp = (tmp<<8) + avio_r8(bc);
} }
} }
switch(tmp){ switch(tmp){
@ -812,7 +812,7 @@ static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)
case SYNCPOINT_STARTCODE: case SYNCPOINT_STARTCODE:
if(decode_syncpoint(nut, &ts, &back_ptr)<0) if(decode_syncpoint(nut, &ts, &back_ptr)<0)
goto resync; goto resync;
frame_code = get_byte(bc); frame_code = avio_r8(bc);
case 0: case 0:
ret= decode_frame(nut, pkt, frame_code); ret= decode_frame(nut, pkt, frame_code);
if(ret==0) if(ret==0)

52
libavformat/nuv.c
View File

@ -62,16 +62,16 @@ static int get_codec_data(AVIOContext *pb, AVStream *vst,
return 1; // no codec data needed return 1; // no codec data needed
while (!url_feof(pb)) { while (!url_feof(pb)) {
int size, subtype; int size, subtype;
frametype = get_byte(pb); frametype = avio_r8(pb);
switch (frametype) { switch (frametype) {
case NUV_EXTRADATA: case NUV_EXTRADATA:
subtype = get_byte(pb); subtype = avio_r8(pb);
url_fskip(pb, 6); url_fskip(pb, 6);
size = PKTSIZE(get_le32(pb)); size = PKTSIZE(avio_rl32(pb));
if (vst && subtype == 'R') { if (vst && subtype == 'R') {
vst->codec->extradata_size = size; vst->codec->extradata_size = size;
vst->codec->extradata = av_malloc(size); vst->codec->extradata = av_malloc(size);
get_buffer(pb, vst->codec->extradata, size); avio_read(pb, vst->codec->extradata, size);
size = 0; size = 0;
if (!myth) if (!myth)
return 1; return 1;
@ -79,12 +79,12 @@ static int get_codec_data(AVIOContext *pb, AVStream *vst,
break; break;
case NUV_MYTHEXT: case NUV_MYTHEXT:
url_fskip(pb, 7); url_fskip(pb, 7);
size = PKTSIZE(get_le32(pb)); size = PKTSIZE(avio_rl32(pb));
if (size != 128 * 4) if (size != 128 * 4)
break; break;
get_le32(pb); // version avio_rl32(pb); // version
if (vst) { if (vst) {
vst->codec->codec_tag = get_le32(pb); vst->codec->codec_tag = avio_rl32(pb);
vst->codec->codec_id = vst->codec->codec_id =
ff_codec_get_id(ff_codec_bmp_tags, vst->codec->codec_tag); ff_codec_get_id(ff_codec_bmp_tags, vst->codec->codec_tag);
if (vst->codec->codec_tag == MKTAG('R', 'J', 'P', 'G')) if (vst->codec->codec_tag == MKTAG('R', 'J', 'P', 'G'))
@ -93,10 +93,10 @@ static int get_codec_data(AVIOContext *pb, AVStream *vst,
url_fskip(pb, 4); url_fskip(pb, 4);
if (ast) { if (ast) {
ast->codec->codec_tag = get_le32(pb); ast->codec->codec_tag = avio_rl32(pb);
ast->codec->sample_rate = get_le32(pb); ast->codec->sample_rate = avio_rl32(pb);
ast->codec->bits_per_coded_sample = get_le32(pb); ast->codec->bits_per_coded_sample = avio_rl32(pb);
ast->codec->channels = get_le32(pb); ast->codec->channels = avio_rl32(pb);
ast->codec->codec_id = ast->codec->codec_id =
ff_wav_codec_get_id(ast->codec->codec_tag, ff_wav_codec_get_id(ast->codec->codec_tag,
ast->codec->bits_per_coded_sample); ast->codec->bits_per_coded_sample);
@ -112,7 +112,7 @@ static int get_codec_data(AVIOContext *pb, AVStream *vst,
break; break;
default: default:
url_fskip(pb, 7); url_fskip(pb, 7);
size = PKTSIZE(get_le32(pb)); size = PKTSIZE(avio_rl32(pb));
break; break;
} }
url_fskip(pb, size); url_fskip(pb, size);
@ -128,27 +128,27 @@ static int nuv_header(AVFormatContext *s, AVFormatParameters *ap) {
int is_mythtv, width, height, v_packs, a_packs; int is_mythtv, width, height, v_packs, a_packs;
int stream_nr = 0; int stream_nr = 0;
AVStream *vst = NULL, *ast = NULL; AVStream *vst = NULL, *ast = NULL;
get_buffer(pb, id_string, 12); avio_read(pb, id_string, 12);
is_mythtv = !memcmp(id_string, "MythTVVideo", 12); is_mythtv = !memcmp(id_string, "MythTVVideo", 12);
url_fskip(pb, 5); // version string url_fskip(pb, 5); // version string
url_fskip(pb, 3); // padding url_fskip(pb, 3); // padding
width = get_le32(pb); width = avio_rl32(pb);
height = get_le32(pb); height = avio_rl32(pb);
get_le32(pb); // unused, "desiredwidth" avio_rl32(pb); // unused, "desiredwidth"
get_le32(pb); // unused, "desiredheight" avio_rl32(pb); // unused, "desiredheight"
get_byte(pb); // 'P' == progressive, 'I' == interlaced avio_r8(pb); // 'P' == progressive, 'I' == interlaced
url_fskip(pb, 3); // padding url_fskip(pb, 3); // padding
aspect = av_int2dbl(get_le64(pb)); aspect = av_int2dbl(avio_rl64(pb));
if (aspect > 0.9999 && aspect < 1.0001) if (aspect > 0.9999 && aspect < 1.0001)
aspect = 4.0 / 3.0; aspect = 4.0 / 3.0;
fps = av_int2dbl(get_le64(pb)); fps = av_int2dbl(avio_rl64(pb));
// number of packets per stream type, -1 means unknown, e.g. streaming // number of packets per stream type, -1 means unknown, e.g. streaming
v_packs = get_le32(pb); v_packs = avio_rl32(pb);
a_packs = get_le32(pb); a_packs = avio_rl32(pb);
get_le32(pb); // text avio_rl32(pb); // text
get_le32(pb); // keyframe distance (?) avio_rl32(pb); // keyframe distance (?)
if (v_packs) { if (v_packs) {
ctx->v_id = stream_nr++; ctx->v_id = stream_nr++;
@ -198,7 +198,7 @@ static int nuv_packet(AVFormatContext *s, AVPacket *pkt) {
while (!url_feof(pb)) { while (!url_feof(pb)) {
int copyhdrsize = ctx->rtjpg_video ? HDRSIZE : 0; int copyhdrsize = ctx->rtjpg_video ? HDRSIZE : 0;
uint64_t pos = url_ftell(pb); uint64_t pos = url_ftell(pb);
ret = get_buffer(pb, hdr, HDRSIZE); ret = avio_read(pb, hdr, HDRSIZE);
if (ret < HDRSIZE) if (ret < HDRSIZE)
return ret < 0 ? ret : AVERROR(EIO); return ret < 0 ? ret : AVERROR(EIO);
frametype = hdr[0]; frametype = hdr[0];
@ -225,7 +225,7 @@ static int nuv_packet(AVFormatContext *s, AVPacket *pkt) {
pkt->pts = AV_RL32(&hdr[4]); pkt->pts = AV_RL32(&hdr[4]);
pkt->stream_index = ctx->v_id; pkt->stream_index = ctx->v_id;
memcpy(pkt->data, hdr, copyhdrsize); memcpy(pkt->data, hdr, copyhdrsize);
ret = get_buffer(pb, pkt->data + copyhdrsize, size); ret = avio_read(pb, pkt->data + copyhdrsize, size);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_free_packet(pkt);
return ret; return ret;

14
libavformat/oggdec.c
View File

@ -207,7 +207,7 @@ ogg_read_page (AVFormatContext * s, int *str)
uint8_t sync[4]; uint8_t sync[4];
int sp = 0; int sp = 0;
if (get_buffer (bc, sync, 4) < 4) if (avio_read (bc, sync, 4) < 4)
return -1; return -1;
do{ do{
@ -233,10 +233,10 @@ ogg_read_page (AVFormatContext * s, int *str)
return -1; return -1;
flags = url_fgetc (bc); flags = url_fgetc (bc);
gp = get_le64 (bc); gp = avio_rl64 (bc);
serial = get_le32 (bc); serial = avio_rl32 (bc);
seq = get_le32 (bc); seq = avio_rl32 (bc);
crc = get_le32 (bc); crc = avio_rl32 (bc);
nsegs = url_fgetc (bc); nsegs = url_fgetc (bc);
idx = ogg_find_stream (ogg, serial); idx = ogg_find_stream (ogg, serial);
@ -252,7 +252,7 @@ ogg_read_page (AVFormatContext * s, int *str)
if(os->psize > 0) if(os->psize > 0)
ogg_new_buf(ogg, idx); ogg_new_buf(ogg, idx);
if (get_buffer (bc, os->segments, nsegs) < nsegs) if (avio_read (bc, os->segments, nsegs) < nsegs)
return -1; return -1;
os->nsegs = nsegs; os->nsegs = nsegs;
@ -284,7 +284,7 @@ ogg_read_page (AVFormatContext * s, int *str)
os->buf = nb; os->buf = nb;
} }
if (get_buffer (bc, os->buf + os->bufpos, size) < size) if (avio_read (bc, os->buf + os->bufpos, size) < size)
return -1; return -1;
os->bufpos += size; os->bufpos += size;

2
libavformat/oma.c
View File

@ -79,7 +79,7 @@ static int oma_read_header(AVFormatContext *s,
AVStream *st; AVStream *st;
ff_id3v2_read(s, ID3v2_EA3_MAGIC); ff_id3v2_read(s, ID3v2_EA3_MAGIC);
ret = get_buffer(s->pb, buf, EA3_HEADER_SIZE); ret = avio_read(s->pb, buf, EA3_HEADER_SIZE);
if (memcmp(buf, ((const uint8_t[]){'E', 'A', '3'}),3) || buf[4] != 0 || buf[5] != EA3_HEADER_SIZE) { if (memcmp(buf, ((const uint8_t[]){'E', 'A', '3'}),3) || buf[4] != 0 || buf[5] != EA3_HEADER_SIZE) {
av_log(s, AV_LOG_ERROR, "Couldn't find the EA3 header !\n"); av_log(s, AV_LOG_ERROR, "Couldn't find the EA3 header !\n");

4
libavformat/psxstr.c
View File

@ -105,7 +105,7 @@ static int str_read_header(AVFormatContext *s,
int i; int i;
/* skip over any RIFF header */ /* skip over any RIFF header */
if (get_buffer(pb, sector, RIFF_HEADER_SIZE) != RIFF_HEADER_SIZE) if (avio_read(pb, sector, RIFF_HEADER_SIZE) != RIFF_HEADER_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
if (AV_RL32(&sector[0]) == RIFF_TAG) if (AV_RL32(&sector[0]) == RIFF_TAG)
start = RIFF_HEADER_SIZE; start = RIFF_HEADER_SIZE;
@ -136,7 +136,7 @@ static int str_read_packet(AVFormatContext *s,
while (1) { while (1) {
if (get_buffer(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE) if (avio_read(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
channel = sector[0x11]; channel = sector[0x11];

26
libavformat/pva.c
View File

@ -75,12 +75,12 @@ static int read_part_of_packet(AVFormatContext *s, int64_t *pts,
recover: recover:
startpos = url_ftell(pb); startpos = url_ftell(pb);
syncword = get_be16(pb); syncword = avio_rb16(pb);
streamid = get_byte(pb); streamid = avio_r8(pb);
get_byte(pb); /* counter not used */ avio_r8(pb); /* counter not used */
reserved = get_byte(pb); reserved = avio_r8(pb);
flags = get_byte(pb); flags = avio_r8(pb);
length = get_be16(pb); length = avio_rb16(pb);
pts_flag = flags & 0x10; pts_flag = flags & 0x10;
@ -101,7 +101,7 @@ recover:
} }
if (streamid == PVA_VIDEO_PAYLOAD && pts_flag) { if (streamid == PVA_VIDEO_PAYLOAD && pts_flag) {
pva_pts = get_be32(pb); pva_pts = avio_rb32(pb);
length -= 4; length -= 4;
} else if (streamid == PVA_AUDIO_PAYLOAD) { } else if (streamid == PVA_AUDIO_PAYLOAD) {
/* PVA Audio Packets either start with a signaled PES packet or /* PVA Audio Packets either start with a signaled PES packet or
@ -113,11 +113,11 @@ recover:
pes_flags; pes_flags;
unsigned char pes_header_data[256]; unsigned char pes_header_data[256];
pes_signal = get_be24(pb); pes_signal = avio_rb24(pb);
get_byte(pb); avio_r8(pb);
pes_packet_length = get_be16(pb); pes_packet_length = avio_rb16(pb);
pes_flags = get_be16(pb); pes_flags = avio_rb16(pb);
pes_header_data_length = get_byte(pb); pes_header_data_length = avio_r8(pb);
if (pes_signal != 1) { if (pes_signal != 1) {
pva_log(s, AV_LOG_WARNING, "expected signaled PES packet, " pva_log(s, AV_LOG_WARNING, "expected signaled PES packet, "
@ -128,7 +128,7 @@ recover:
goto recover; goto recover;
} }
get_buffer(pb, pes_header_data, pes_header_data_length); avio_read(pb, pes_header_data, pes_header_data_length);
length -= 9 + pes_header_data_length; length -= 9 + pes_header_data_length;
pes_packet_length -= 3 + pes_header_data_length; pes_packet_length -= 3 + pes_header_data_length;

28
libavformat/qcp.c
View File

@ -91,13 +91,13 @@ static int qcp_read_header(AVFormatContext *s, AVFormatParameters *ap)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
get_be32(pb); // "RIFF" avio_rb32(pb); // "RIFF"
s->file_size = get_le32(pb) + 8; s->file_size = avio_rl32(pb) + 8;
url_fskip(pb, 8 + 4 + 1 + 1); // "QLCMfmt " + chunk-size + major-version + minor-version url_fskip(pb, 8 + 4 + 1 + 1); // "QLCMfmt " + chunk-size + major-version + minor-version
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->channels = 1; st->codec->channels = 1;
get_buffer(pb, buf, 16); avio_read(pb, buf, 16);
if (is_qcelp_13k_guid(buf)) { if (is_qcelp_13k_guid(buf)) {
st->codec->codec_id = CODEC_ID_QCELP; st->codec->codec_id = CODEC_ID_QCELP;
} else if (!memcmp(buf, guid_evrc, 16)) { } else if (!memcmp(buf, guid_evrc, 16)) {
@ -111,19 +111,19 @@ static int qcp_read_header(AVFormatContext *s, AVFormatParameters *ap)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
url_fskip(pb, 2 + 80); // codec-version + codec-name url_fskip(pb, 2 + 80); // codec-version + codec-name
st->codec->bit_rate = get_le16(pb); st->codec->bit_rate = avio_rl16(pb);
s->packet_size = get_le16(pb); s->packet_size = avio_rl16(pb);
url_fskip(pb, 2); // block-size url_fskip(pb, 2); // block-size
st->codec->sample_rate = get_le16(pb); st->codec->sample_rate = avio_rl16(pb);
url_fskip(pb, 2); // sample-size url_fskip(pb, 2); // sample-size
memset(c->rates_per_mode, -1, sizeof(c->rates_per_mode)); memset(c->rates_per_mode, -1, sizeof(c->rates_per_mode));
nb_rates = get_le32(pb); nb_rates = avio_rl32(pb);
nb_rates = FFMIN(nb_rates, 8); nb_rates = FFMIN(nb_rates, 8);
for (i=0; i<nb_rates; i++) { for (i=0; i<nb_rates; i++) {
int size = get_byte(pb); int size = avio_r8(pb);
int mode = get_byte(pb); int mode = avio_r8(pb);
if (mode > QCP_MAX_MODE) { if (mode > QCP_MAX_MODE) {
av_log(s, AV_LOG_WARNING, "Unknown entry %d=>%d in rate-map-table.\n ", mode, size); av_log(s, AV_LOG_WARNING, "Unknown entry %d=>%d in rate-map-table.\n ", mode, size);
} else } else
@ -142,7 +142,7 @@ static int qcp_read_packet(AVFormatContext *s, AVPacket *pkt)
while(!url_feof(pb)) { while(!url_feof(pb)) {
if (c->data_size) { if (c->data_size) {
int pkt_size, ret, mode = get_byte(pb); int pkt_size, ret, mode = avio_r8(pb);
if (s->packet_size) { if (s->packet_size) {
pkt_size = s->packet_size - 1; pkt_size = s->packet_size - 1;
@ -165,14 +165,14 @@ static int qcp_read_packet(AVFormatContext *s, AVPacket *pkt)
return ret; return ret;
} }
if (url_ftell(pb) & 1 && get_byte(pb)) if (url_ftell(pb) & 1 && avio_r8(pb))
av_log(s, AV_LOG_WARNING, "Padding should be 0.\n"); av_log(s, AV_LOG_WARNING, "Padding should be 0.\n");
tag = get_le32(pb); tag = avio_rl32(pb);
chunk_size = get_le32(pb); chunk_size = avio_rl32(pb);
switch (tag) { switch (tag) {
case MKTAG('v', 'r', 'a', 't'): case MKTAG('v', 'r', 'a', 't'):
if (get_le32(pb)) // var-rate-flag if (avio_rl32(pb)) // var-rate-flag
s->packet_size = 0; s->packet_size = 0;
url_fskip(pb, 4); // size-in-packets url_fskip(pb, 4); // size-in-packets
break; break;

78
libavformat/r3d.c
View File

@ -39,10 +39,10 @@ typedef struct {
static int read_atom(AVFormatContext *s, Atom *atom) static int read_atom(AVFormatContext *s, Atom *atom)
{ {
atom->offset = url_ftell(s->pb); atom->offset = url_ftell(s->pb);
atom->size = get_be32(s->pb); atom->size = avio_rb32(s->pb);
if (atom->size < 8) if (atom->size < 8)
return -1; return -1;
atom->tag = get_le32(s->pb); atom->tag = avio_rl32(s->pb);
av_dlog(s, "atom %d %.4s offset %#llx\n", av_dlog(s, "atom %d %.4s offset %#llx\n",
atom->size, (char*)&atom->tag, atom->offset); atom->size, (char*)&atom->tag, atom->offset);
return atom->size; return atom->size;
@ -59,31 +59,31 @@ static int r3d_read_red1(AVFormatContext *s)
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_JPEG2000; st->codec->codec_id = CODEC_ID_JPEG2000;
tmp = get_byte(s->pb); // major version tmp = avio_r8(s->pb); // major version
tmp2 = get_byte(s->pb); // minor version tmp2 = avio_r8(s->pb); // minor version
av_dlog(s, "version %d.%d\n", tmp, tmp2); av_dlog(s, "version %d.%d\n", tmp, tmp2);
tmp = get_be16(s->pb); // unknown tmp = avio_rb16(s->pb); // unknown
av_dlog(s, "unknown1 %d\n", tmp); av_dlog(s, "unknown1 %d\n", tmp);
tmp = get_be32(s->pb); tmp = avio_rb32(s->pb);
av_set_pts_info(st, 32, 1, tmp); av_set_pts_info(st, 32, 1, tmp);
tmp = get_be32(s->pb); // filenum tmp = avio_rb32(s->pb); // filenum
av_dlog(s, "filenum %d\n", tmp); av_dlog(s, "filenum %d\n", tmp);
url_fskip(s->pb, 32); // unknown url_fskip(s->pb, 32); // unknown
st->codec->width = get_be32(s->pb); st->codec->width = avio_rb32(s->pb);
st->codec->height = get_be32(s->pb); st->codec->height = avio_rb32(s->pb);
tmp = get_be16(s->pb); // unknown tmp = avio_rb16(s->pb); // unknown
av_dlog(s, "unknown2 %d\n", tmp); av_dlog(s, "unknown2 %d\n", tmp);
st->codec->time_base.den = get_be16(s->pb); st->codec->time_base.den = avio_rb16(s->pb);
st->codec->time_base.num = get_be16(s->pb); st->codec->time_base.num = avio_rb16(s->pb);
tmp = get_byte(s->pb); // audio channels tmp = avio_r8(s->pb); // audio channels
av_dlog(s, "audio channels %d\n", tmp); av_dlog(s, "audio channels %d\n", tmp);
if (tmp > 0) { if (tmp > 0) {
AVStream *ast = av_new_stream(s, 1); AVStream *ast = av_new_stream(s, 1);
@ -95,7 +95,7 @@ static int r3d_read_red1(AVFormatContext *s)
av_set_pts_info(ast, 32, 1, st->time_base.den); av_set_pts_info(ast, 32, 1, st->time_base.den);
} }
get_buffer(s->pb, filename, 257); avio_read(s->pb, filename, 257);
filename[sizeof(filename)-1] = 0; filename[sizeof(filename)-1] = 0;
av_metadata_set2(&st->metadata, "filename", filename, 0); av_metadata_set2(&st->metadata, "filename", filename, 0);
@ -120,7 +120,7 @@ static int r3d_read_rdvo(AVFormatContext *s, Atom *atom)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
for (i = 0; i < r3d->video_offsets_count; i++) { for (i = 0; i < r3d->video_offsets_count; i++) {
r3d->video_offsets[i] = get_be32(s->pb); r3d->video_offsets[i] = avio_rb32(s->pb);
if (!r3d->video_offsets[i]) { if (!r3d->video_offsets[i]) {
r3d->video_offsets_count = i; r3d->video_offsets_count = i;
break; break;
@ -141,15 +141,15 @@ static void r3d_read_reos(AVFormatContext *s)
R3DContext *r3d = s->priv_data; R3DContext *r3d = s->priv_data;
int tmp; int tmp;
r3d->rdvo_offset = get_be32(s->pb); r3d->rdvo_offset = avio_rb32(s->pb);
get_be32(s->pb); // rdvs offset avio_rb32(s->pb); // rdvs offset
get_be32(s->pb); // rdao offset avio_rb32(s->pb); // rdao offset
get_be32(s->pb); // rdas offset avio_rb32(s->pb); // rdas offset
tmp = get_be32(s->pb); tmp = avio_rb32(s->pb);
av_dlog(s, "num video chunks %d\n", tmp); av_dlog(s, "num video chunks %d\n", tmp);
tmp = get_be32(s->pb); tmp = avio_rb32(s->pb);
av_dlog(s, "num audio chunks %d\n", tmp); av_dlog(s, "num audio chunks %d\n", tmp);
url_fskip(s->pb, 6*4); url_fskip(s->pb, 6*4);
@ -214,31 +214,31 @@ static int r3d_read_redv(AVFormatContext *s, AVPacket *pkt, Atom *atom)
unsigned dts; unsigned dts;
int ret; int ret;
dts = get_be32(s->pb); dts = avio_rb32(s->pb);
tmp = get_be32(s->pb); tmp = avio_rb32(s->pb);
av_dlog(s, "frame num %d\n", tmp); av_dlog(s, "frame num %d\n", tmp);
tmp = get_byte(s->pb); // major version tmp = avio_r8(s->pb); // major version
tmp2 = get_byte(s->pb); // minor version tmp2 = avio_r8(s->pb); // minor version
av_dlog(s, "version %d.%d\n", tmp, tmp2); av_dlog(s, "version %d.%d\n", tmp, tmp2);
tmp = get_be16(s->pb); // unknown tmp = avio_rb16(s->pb); // unknown
av_dlog(s, "unknown %d\n", tmp); av_dlog(s, "unknown %d\n", tmp);
if (tmp > 4) { if (tmp > 4) {
tmp = get_be16(s->pb); // unknown tmp = avio_rb16(s->pb); // unknown
av_dlog(s, "unknown %d\n", tmp); av_dlog(s, "unknown %d\n", tmp);
tmp = get_be16(s->pb); // unknown tmp = avio_rb16(s->pb); // unknown
av_dlog(s, "unknown %d\n", tmp); av_dlog(s, "unknown %d\n", tmp);
tmp = get_be32(s->pb); tmp = avio_rb32(s->pb);
av_dlog(s, "width %d\n", tmp); av_dlog(s, "width %d\n", tmp);
tmp = get_be32(s->pb); tmp = avio_rb32(s->pb);
av_dlog(s, "height %d\n", tmp); av_dlog(s, "height %d\n", tmp);
tmp = get_be32(s->pb); tmp = avio_rb32(s->pb);
av_dlog(s, "metadata len %d\n", tmp); av_dlog(s, "metadata len %d\n", tmp);
} }
tmp = atom->size - 8 - (url_ftell(s->pb) - pos); tmp = atom->size - 8 - (url_ftell(s->pb) - pos);
@ -268,23 +268,23 @@ static int r3d_read_reda(AVFormatContext *s, AVPacket *pkt, Atom *atom)
unsigned dts; unsigned dts;
int ret; int ret;
dts = get_be32(s->pb); dts = avio_rb32(s->pb);
st->codec->sample_rate = get_be32(s->pb); st->codec->sample_rate = avio_rb32(s->pb);
samples = get_be32(s->pb); samples = avio_rb32(s->pb);
tmp = get_be32(s->pb); tmp = avio_rb32(s->pb);
av_dlog(s, "packet num %d\n", tmp); av_dlog(s, "packet num %d\n", tmp);
tmp = get_be16(s->pb); // unkown tmp = avio_rb16(s->pb); // unkown
av_dlog(s, "unknown %d\n", tmp); av_dlog(s, "unknown %d\n", tmp);
tmp = get_byte(s->pb); // major version tmp = avio_r8(s->pb); // major version
tmp2 = get_byte(s->pb); // minor version tmp2 = avio_r8(s->pb); // minor version
av_dlog(s, "version %d.%d\n", tmp, tmp2); av_dlog(s, "version %d.%d\n", tmp, tmp2);
tmp = get_be32(s->pb); // unknown tmp = avio_rb32(s->pb); // unknown
av_dlog(s, "unknown %d\n", tmp); av_dlog(s, "unknown %d\n", tmp);
size = atom->size - 8 - (url_ftell(s->pb) - pos); size = atom->size - 8 - (url_ftell(s->pb) - pos);

12
libavformat/rdt.c
View File

@ -153,25 +153,25 @@ rdt_load_mdpr (PayloadContext *rdt, AVStream *st, int rule_nr)
return -1; return -1;
ffio_init_context(&pb, rdt->mlti_data, rdt->mlti_data_size, 0, ffio_init_context(&pb, rdt->mlti_data, rdt->mlti_data_size, 0,
NULL, NULL, NULL, NULL); NULL, NULL, NULL, NULL);
tag = get_le32(&pb); tag = avio_rl32(&pb);
if (tag == MKTAG('M', 'L', 'T', 'I')) { if (tag == MKTAG('M', 'L', 'T', 'I')) {
int num, chunk_nr; int num, chunk_nr;
/* read index of MDPR chunk numbers */ /* read index of MDPR chunk numbers */
num = get_be16(&pb); num = avio_rb16(&pb);
if (rule_nr < 0 || rule_nr >= num) if (rule_nr < 0 || rule_nr >= num)
return -1; return -1;
url_fskip(&pb, rule_nr * 2); url_fskip(&pb, rule_nr * 2);
chunk_nr = get_be16(&pb); chunk_nr = avio_rb16(&pb);
url_fskip(&pb, (num - 1 - rule_nr) * 2); url_fskip(&pb, (num - 1 - rule_nr) * 2);
/* read MDPR chunks */ /* read MDPR chunks */
num = get_be16(&pb); num = avio_rb16(&pb);
if (chunk_nr >= num) if (chunk_nr >= num)
return -1; return -1;
while (chunk_nr--) while (chunk_nr--)
url_fskip(&pb, get_be32(&pb)); url_fskip(&pb, avio_rb32(&pb));
size = get_be32(&pb); size = avio_rb32(&pb);
} else { } else {
size = rdt->mlti_data_size; size = rdt->mlti_data_size;
url_fseek(&pb, 0, SEEK_SET); url_fseek(&pb, 0, SEEK_SET);

44
libavformat/riff.c
View File

@ -481,25 +481,25 @@ void ff_get_wav_header(AVIOContext *pb, AVCodecContext *codec, int size)
{ {
int id; int id;
id = get_le16(pb); id = avio_rl16(pb);
codec->codec_type = AVMEDIA_TYPE_AUDIO; codec->codec_type = AVMEDIA_TYPE_AUDIO;
codec->codec_tag = id; codec->codec_tag = id;
codec->channels = get_le16(pb); codec->channels = avio_rl16(pb);
codec->sample_rate = get_le32(pb); codec->sample_rate = avio_rl32(pb);
codec->bit_rate = get_le32(pb) * 8; codec->bit_rate = avio_rl32(pb) * 8;
codec->block_align = get_le16(pb); codec->block_align = avio_rl16(pb);
if (size == 14) { /* We're dealing with plain vanilla WAVEFORMAT */ if (size == 14) { /* We're dealing with plain vanilla WAVEFORMAT */
codec->bits_per_coded_sample = 8; codec->bits_per_coded_sample = 8;
}else }else
codec->bits_per_coded_sample = get_le16(pb); codec->bits_per_coded_sample = avio_rl16(pb);
if (size >= 18) { /* We're obviously dealing with WAVEFORMATEX */ if (size >= 18) { /* We're obviously dealing with WAVEFORMATEX */
int cbSize = get_le16(pb); /* cbSize */ int cbSize = avio_rl16(pb); /* cbSize */
size -= 18; size -= 18;
cbSize = FFMIN(size, cbSize); cbSize = FFMIN(size, cbSize);
if (cbSize >= 22 && id == 0xfffe) { /* WAVEFORMATEXTENSIBLE */ if (cbSize >= 22 && id == 0xfffe) { /* WAVEFORMATEXTENSIBLE */
codec->bits_per_coded_sample = get_le16(pb); codec->bits_per_coded_sample = avio_rl16(pb);
codec->channel_layout = get_le32(pb); /* dwChannelMask */ codec->channel_layout = avio_rl32(pb); /* dwChannelMask */
id = get_le32(pb); /* 4 first bytes of GUID */ id = avio_rl32(pb); /* 4 first bytes of GUID */
url_fskip(pb, 12); /* skip end of GUID */ url_fskip(pb, 12); /* skip end of GUID */
cbSize -= 22; cbSize -= 22;
size -= 22; size -= 22;
@ -507,7 +507,7 @@ void ff_get_wav_header(AVIOContext *pb, AVCodecContext *codec, int size)
codec->extradata_size = cbSize; codec->extradata_size = cbSize;
if (cbSize > 0) { if (cbSize > 0) {
codec->extradata = av_mallocz(codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); codec->extradata = av_mallocz(codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(pb, codec->extradata, codec->extradata_size); avio_read(pb, codec->extradata, codec->extradata_size);
size -= cbSize; size -= cbSize;
} }
@ -547,17 +547,17 @@ enum CodecID ff_wav_codec_get_id(unsigned int tag, int bps)
int ff_get_bmp_header(AVIOContext *pb, AVStream *st) int ff_get_bmp_header(AVIOContext *pb, AVStream *st)
{ {
int tag1; int tag1;
get_le32(pb); /* size */ avio_rl32(pb); /* size */
st->codec->width = get_le32(pb); st->codec->width = avio_rl32(pb);
st->codec->height = (int32_t)get_le32(pb); st->codec->height = (int32_t)avio_rl32(pb);
get_le16(pb); /* planes */ avio_rl16(pb); /* planes */
st->codec->bits_per_coded_sample= get_le16(pb); /* depth */ st->codec->bits_per_coded_sample= avio_rl16(pb); /* depth */
tag1 = get_le32(pb); tag1 = avio_rl32(pb);
get_le32(pb); /* ImageSize */ avio_rl32(pb); /* ImageSize */
get_le32(pb); /* XPelsPerMeter */ avio_rl32(pb); /* XPelsPerMeter */
get_le32(pb); /* YPelsPerMeter */ avio_rl32(pb); /* YPelsPerMeter */
get_le32(pb); /* ClrUsed */ avio_rl32(pb); /* ClrUsed */
get_le32(pb); /* ClrImportant */ avio_rl32(pb); /* ClrImportant */
return tag1; return tag1;
} }
#endif // CONFIG_DEMUXERS #endif // CONFIG_DEMUXERS

26
libavformat/rl2.c
View File

@ -96,20 +96,20 @@ static av_cold int rl2_read_header(AVFormatContext *s,
int ret = 0; int ret = 0;
url_fskip(pb,4); /* skip FORM tag */ url_fskip(pb,4); /* skip FORM tag */
back_size = get_le32(pb); /**< get size of the background frame */ back_size = avio_rl32(pb); /**< get size of the background frame */
signature = get_be32(pb); signature = avio_rb32(pb);
data_size = get_be32(pb); data_size = avio_rb32(pb);
frame_count = get_le32(pb); frame_count = avio_rl32(pb);
/* disallow back_sizes and frame_counts that may lead to overflows later */ /* disallow back_sizes and frame_counts that may lead to overflows later */
if(back_size > INT_MAX/2 || frame_count > INT_MAX / sizeof(uint32_t)) if(back_size > INT_MAX/2 || frame_count > INT_MAX / sizeof(uint32_t))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
encoding_method = get_le16(pb); encoding_method = avio_rl16(pb);
sound_rate = get_le16(pb); sound_rate = avio_rl16(pb);
rate = get_le16(pb); rate = avio_rl16(pb);
channels = get_le16(pb); channels = avio_rl16(pb);
def_sound_size = get_le16(pb); def_sound_size = avio_rl16(pb);
/** setup video stream */ /** setup video stream */
st = av_new_stream(s, 0); st = av_new_stream(s, 0);
@ -133,7 +133,7 @@ static av_cold int rl2_read_header(AVFormatContext *s,
if(!st->codec->extradata) if(!st->codec->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if(get_buffer(pb,st->codec->extradata,st->codec->extradata_size) != if(avio_read(pb,st->codec->extradata,st->codec->extradata_size) !=
st->codec->extradata_size) st->codec->extradata_size)
return AVERROR(EIO); return AVERROR(EIO);
@ -173,11 +173,11 @@ static av_cold int rl2_read_header(AVFormatContext *s,
/** read offset and size tables */ /** read offset and size tables */
for(i=0; i < frame_count;i++) for(i=0; i < frame_count;i++)
chunk_size[i] = get_le32(pb); chunk_size[i] = avio_rl32(pb);
for(i=0; i < frame_count;i++) for(i=0; i < frame_count;i++)
chunk_offset[i] = get_le32(pb); chunk_offset[i] = avio_rl32(pb);
for(i=0; i < frame_count;i++) for(i=0; i < frame_count;i++)
audio_size[i] = get_le32(pb) & 0xFFFF; audio_size[i] = avio_rl32(pb) & 0xFFFF;
/** build the sample index */ /** build the sample index */
for(i=0;i<frame_count;i++){ for(i=0;i<frame_count;i++){

206
libavformat/rmdec.c
View File

@ -71,7 +71,7 @@ static inline void get_strl(AVIOContext *pb, char *buf, int buf_size, int len)
q = buf; q = buf;
for(i=0;i<len;i++) { for(i=0;i<len;i++) {
r = get_byte(pb); r = avio_r8(pb);
if (i < buf_size - 1) if (i < buf_size - 1)
*q++ = r; *q++ = r;
} }
@ -80,7 +80,7 @@ static inline void get_strl(AVIOContext *pb, char *buf, int buf_size, int len)
static void get_str8(AVIOContext *pb, char *buf, int buf_size) static void get_str8(AVIOContext *pb, char *buf, int buf_size)
{ {
get_strl(pb, buf, buf_size, get_byte(pb)); get_strl(pb, buf, buf_size, avio_r8(pb));
} }
static int rm_read_extradata(AVIOContext *pb, AVCodecContext *avctx, unsigned size) static int rm_read_extradata(AVIOContext *pb, AVCodecContext *avctx, unsigned size)
@ -90,7 +90,7 @@ static int rm_read_extradata(AVIOContext *pb, AVCodecContext *avctx, unsigned si
avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
if (!avctx->extradata) if (!avctx->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avctx->extradata_size = get_buffer(pb, avctx->extradata, size); avctx->extradata_size = avio_read(pb, avctx->extradata, size);
memset(avctx->extradata + avctx->extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE); memset(avctx->extradata + avctx->extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
if (avctx->extradata_size != size) if (avctx->extradata_size != size)
return AVERROR(EIO); return AVERROR(EIO);
@ -102,7 +102,7 @@ static void rm_read_metadata(AVFormatContext *s, int wide)
char buf[1024]; char buf[1024];
int i; int i;
for (i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) { for (i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
int len = wide ? get_be16(s->pb) : get_byte(s->pb); int len = wide ? avio_rb16(s->pb) : avio_r8(s->pb);
get_strl(s->pb, buf, sizeof(buf), len); get_strl(s->pb, buf, sizeof(buf), len);
av_metadata_set2(&s->metadata, ff_rm_metadata[i], buf, 0); av_metadata_set2(&s->metadata, ff_rm_metadata[i], buf, 0);
} }
@ -128,15 +128,15 @@ static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb,
int ret; int ret;
/* ra type header */ /* ra type header */
version = get_be16(pb); /* version */ version = avio_rb16(pb); /* version */
if (version == 3) { if (version == 3) {
int header_size = get_be16(pb); int header_size = avio_rb16(pb);
int64_t startpos = url_ftell(pb); int64_t startpos = url_ftell(pb);
url_fskip(pb, 14); url_fskip(pb, 14);
rm_read_metadata(s, 0); rm_read_metadata(s, 0);
if ((startpos + header_size) >= url_ftell(pb) + 2) { if ((startpos + header_size) >= url_ftell(pb) + 2) {
// fourcc (should always be "lpcJ") // fourcc (should always be "lpcJ")
get_byte(pb); avio_r8(pb);
get_str8(pb, buf, sizeof(buf)); get_str8(pb, buf, sizeof(buf));
} }
// Skip extra header crap (this should never happen) // Skip extra header crap (this should never happen)
@ -151,28 +151,28 @@ static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb,
int codecdata_length; int codecdata_length;
/* old version (4) */ /* old version (4) */
url_fskip(pb, 2); /* unused */ url_fskip(pb, 2); /* unused */
get_be32(pb); /* .ra4 */ avio_rb32(pb); /* .ra4 */
get_be32(pb); /* data size */ avio_rb32(pb); /* data size */
get_be16(pb); /* version2 */ avio_rb16(pb); /* version2 */
get_be32(pb); /* header size */ avio_rb32(pb); /* header size */
flavor= get_be16(pb); /* add codec info / flavor */ flavor= avio_rb16(pb); /* add codec info / flavor */
ast->coded_framesize = coded_framesize = get_be32(pb); /* coded frame size */ ast->coded_framesize = coded_framesize = avio_rb32(pb); /* coded frame size */
get_be32(pb); /* ??? */ avio_rb32(pb); /* ??? */
get_be32(pb); /* ??? */ avio_rb32(pb); /* ??? */
get_be32(pb); /* ??? */ avio_rb32(pb); /* ??? */
ast->sub_packet_h = sub_packet_h = get_be16(pb); /* 1 */ ast->sub_packet_h = sub_packet_h = avio_rb16(pb); /* 1 */
st->codec->block_align= get_be16(pb); /* frame size */ st->codec->block_align= avio_rb16(pb); /* frame size */
ast->sub_packet_size = sub_packet_size = get_be16(pb); /* sub packet size */ ast->sub_packet_size = sub_packet_size = avio_rb16(pb); /* sub packet size */
get_be16(pb); /* ??? */ avio_rb16(pb); /* ??? */
if (version == 5) { if (version == 5) {
get_be16(pb); get_be16(pb); get_be16(pb); avio_rb16(pb); avio_rb16(pb); avio_rb16(pb);
} }
st->codec->sample_rate = get_be16(pb); st->codec->sample_rate = avio_rb16(pb);
get_be32(pb); avio_rb32(pb);
st->codec->channels = get_be16(pb); st->codec->channels = avio_rb16(pb);
if (version == 5) { if (version == 5) {
get_be32(pb); avio_rb32(pb);
get_buffer(pb, buf, 4); avio_read(pb, buf, 4);
buf[4] = 0; buf[4] = 0;
} else { } else {
get_str8(pb, buf, sizeof(buf)); /* desc */ get_str8(pb, buf, sizeof(buf)); /* desc */
@ -201,10 +201,10 @@ static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb,
case CODEC_ID_COOK: case CODEC_ID_COOK:
case CODEC_ID_ATRAC3: case CODEC_ID_ATRAC3:
case CODEC_ID_SIPR: case CODEC_ID_SIPR:
get_be16(pb); get_byte(pb); avio_rb16(pb); avio_r8(pb);
if (version == 5) if (version == 5)
get_byte(pb); avio_r8(pb);
codecdata_length = get_be32(pb); codecdata_length = avio_rb32(pb);
if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){ if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){
av_log(s, AV_LOG_ERROR, "codecdata_length too large\n"); av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");
return -1; return -1;
@ -236,16 +236,16 @@ static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb,
av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h); av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h);
break; break;
case CODEC_ID_AAC: case CODEC_ID_AAC:
get_be16(pb); get_byte(pb); avio_rb16(pb); avio_r8(pb);
if (version == 5) if (version == 5)
get_byte(pb); avio_r8(pb);
codecdata_length = get_be32(pb); codecdata_length = avio_rb32(pb);
if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){ if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){
av_log(s, AV_LOG_ERROR, "codecdata_length too large\n"); av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");
return -1; return -1;
} }
if (codecdata_length >= 1) { if (codecdata_length >= 1) {
get_byte(pb); avio_r8(pb);
if ((ret = rm_read_extradata(pb, st->codec, codecdata_length - 1)) < 0) if ((ret = rm_read_extradata(pb, st->codec, codecdata_length - 1)) < 0)
return ret; return ret;
} }
@ -254,9 +254,9 @@ static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb,
av_strlcpy(st->codec->codec_name, buf, sizeof(st->codec->codec_name)); av_strlcpy(st->codec->codec_name, buf, sizeof(st->codec->codec_name));
} }
if (read_all) { if (read_all) {
get_byte(pb); avio_r8(pb);
get_byte(pb); avio_r8(pb);
get_byte(pb); avio_r8(pb);
rm_read_metadata(s, 0); rm_read_metadata(s, 0);
} }
} }
@ -274,32 +274,32 @@ ff_rm_read_mdpr_codecdata (AVFormatContext *s, AVIOContext *pb,
av_set_pts_info(st, 64, 1, 1000); av_set_pts_info(st, 64, 1, 1000);
codec_pos = url_ftell(pb); codec_pos = url_ftell(pb);
v = get_be32(pb); v = avio_rb32(pb);
if (v == MKTAG(0xfd, 'a', 'r', '.')) { if (v == MKTAG(0xfd, 'a', 'r', '.')) {
/* ra type header */ /* ra type header */
if (rm_read_audio_stream_info(s, pb, st, rst, 0)) if (rm_read_audio_stream_info(s, pb, st, rst, 0))
return -1; return -1;
} else { } else {
int fps, fps2; int fps, fps2;
if (get_le32(pb) != MKTAG('V', 'I', 'D', 'O')) { if (avio_rl32(pb) != MKTAG('V', 'I', 'D', 'O')) {
fail1: fail1:
av_log(st->codec, AV_LOG_ERROR, "Unsupported video codec\n"); av_log(st->codec, AV_LOG_ERROR, "Unsupported video codec\n");
goto skip; goto skip;
} }
st->codec->codec_tag = get_le32(pb); st->codec->codec_tag = avio_rl32(pb);
st->codec->codec_id = ff_codec_get_id(ff_rm_codec_tags, st->codec->codec_id = ff_codec_get_id(ff_rm_codec_tags,
st->codec->codec_tag); st->codec->codec_tag);
// av_log(s, AV_LOG_DEBUG, "%X %X\n", st->codec->codec_tag, MKTAG('R', 'V', '2', '0')); // av_log(s, AV_LOG_DEBUG, "%X %X\n", st->codec->codec_tag, MKTAG('R', 'V', '2', '0'));
if (st->codec->codec_id == CODEC_ID_NONE) if (st->codec->codec_id == CODEC_ID_NONE)
goto fail1; goto fail1;
st->codec->width = get_be16(pb); st->codec->width = avio_rb16(pb);
st->codec->height = get_be16(pb); st->codec->height = avio_rb16(pb);
st->codec->time_base.num= 1; st->codec->time_base.num= 1;
fps= get_be16(pb); fps= avio_rb16(pb);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
get_be32(pb); avio_rb32(pb);
fps2= get_be16(pb); fps2= avio_rb16(pb);
get_be16(pb); avio_rb16(pb);
if ((ret = rm_read_extradata(pb, st->codec, codec_data_size - (url_ftell(pb) - codec_pos))) < 0) if ((ret = rm_read_extradata(pb, st->codec, codec_data_size - (url_ftell(pb) - codec_pos))) < 0)
return ret; return ret;
@ -335,15 +335,15 @@ static int rm_read_index(AVFormatContext *s)
AVStream *st; AVStream *st;
do { do {
if (get_le32(pb) != MKTAG('I','N','D','X')) if (avio_rl32(pb) != MKTAG('I','N','D','X'))
return -1; return -1;
size = get_be32(pb); size = avio_rb32(pb);
if (size < 20) if (size < 20)
return -1; return -1;
url_fskip(pb, 2); url_fskip(pb, 2);
n_pkts = get_be32(pb); n_pkts = avio_rb32(pb);
str_id = get_be16(pb); str_id = avio_rb16(pb);
next_off = get_be32(pb); next_off = avio_rb32(pb);
for (n = 0; n < s->nb_streams; n++) for (n = 0; n < s->nb_streams; n++)
if (s->streams[n]->id == str_id) { if (s->streams[n]->id == str_id) {
st = s->streams[n]; st = s->streams[n];
@ -354,8 +354,8 @@ static int rm_read_index(AVFormatContext *s)
for (n = 0; n < n_pkts; n++) { for (n = 0; n < n_pkts; n++) {
url_fskip(pb, 2); url_fskip(pb, 2);
pts = get_be32(pb); pts = avio_rb32(pb);
pos = get_be32(pb); pos = avio_rb32(pb);
url_fskip(pb, 4); /* packet no. */ url_fskip(pb, 4); /* packet no. */
av_add_index_entry(st, pos, pts, 0, 0, AVINDEX_KEYFRAME); av_add_index_entry(st, pos, pts, 0, 0, AVINDEX_KEYFRAME);
@ -395,7 +395,7 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
char buf[128]; char buf[128];
int flags = 0; int flags = 0;
tag = get_le32(pb); tag = avio_rl32(pb);
if (tag == MKTAG('.', 'r', 'a', 0xfd)) { if (tag == MKTAG('.', 'r', 'a', 0xfd)) {
/* very old .ra format */ /* very old .ra format */
return rm_read_header_old(s, ap); return rm_read_header_old(s, ap);
@ -403,17 +403,17 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
return AVERROR(EIO); return AVERROR(EIO);
} }
get_be32(pb); /* header size */ avio_rb32(pb); /* header size */
get_be16(pb); avio_rb16(pb);
get_be32(pb); avio_rb32(pb);
get_be32(pb); /* number of headers */ avio_rb32(pb); /* number of headers */
for(;;) { for(;;) {
if (url_feof(pb)) if (url_feof(pb))
return -1; return -1;
tag = get_le32(pb); tag = avio_rl32(pb);
tag_size = get_be32(pb); tag_size = avio_rb32(pb);
get_be16(pb); avio_rb16(pb);
#if 0 #if 0
printf("tag=%c%c%c%c (%08x) size=%d\n", printf("tag=%c%c%c%c (%08x) size=%d\n",
(tag) & 0xff, (tag) & 0xff,
@ -428,17 +428,17 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
switch(tag) { switch(tag) {
case MKTAG('P', 'R', 'O', 'P'): case MKTAG('P', 'R', 'O', 'P'):
/* file header */ /* file header */
get_be32(pb); /* max bit rate */ avio_rb32(pb); /* max bit rate */
get_be32(pb); /* avg bit rate */ avio_rb32(pb); /* avg bit rate */
get_be32(pb); /* max packet size */ avio_rb32(pb); /* max packet size */
get_be32(pb); /* avg packet size */ avio_rb32(pb); /* avg packet size */
get_be32(pb); /* nb packets */ avio_rb32(pb); /* nb packets */
get_be32(pb); /* duration */ avio_rb32(pb); /* duration */
get_be32(pb); /* preroll */ avio_rb32(pb); /* preroll */
indx_off = get_be32(pb); /* index offset */ indx_off = avio_rb32(pb); /* index offset */
data_off = get_be32(pb); /* data offset */ data_off = avio_rb32(pb); /* data offset */
get_be16(pb); /* nb streams */ avio_rb16(pb); /* nb streams */
flags = get_be16(pb); /* flags */ flags = avio_rb16(pb); /* flags */
break; break;
case MKTAG('C', 'O', 'N', 'T'): case MKTAG('C', 'O', 'N', 'T'):
rm_read_metadata(s, 1); rm_read_metadata(s, 1);
@ -447,14 +447,14 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
st = av_new_stream(s, 0); st = av_new_stream(s, 0);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->id = get_be16(pb); st->id = avio_rb16(pb);
get_be32(pb); /* max bit rate */ avio_rb32(pb); /* max bit rate */
st->codec->bit_rate = get_be32(pb); /* bit rate */ st->codec->bit_rate = avio_rb32(pb); /* bit rate */
get_be32(pb); /* max packet size */ avio_rb32(pb); /* max packet size */
get_be32(pb); /* avg packet size */ avio_rb32(pb); /* avg packet size */
start_time = get_be32(pb); /* start time */ start_time = avio_rb32(pb); /* start time */
get_be32(pb); /* preroll */ avio_rb32(pb); /* preroll */
duration = get_be32(pb); /* duration */ duration = avio_rb32(pb); /* duration */
st->start_time = start_time; st->start_time = start_time;
st->duration = duration; st->duration = duration;
get_str8(pb, buf, sizeof(buf)); /* desc */ get_str8(pb, buf, sizeof(buf)); /* desc */
@ -462,7 +462,7 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
st->codec->codec_type = AVMEDIA_TYPE_DATA; st->codec->codec_type = AVMEDIA_TYPE_DATA;
st->priv_data = ff_rm_alloc_rmstream(); st->priv_data = ff_rm_alloc_rmstream();
if (ff_rm_read_mdpr_codecdata(s, s->pb, st, st->priv_data, if (ff_rm_read_mdpr_codecdata(s, s->pb, st, st->priv_data,
get_be32(pb)) < 0) avio_rb32(pb)) < 0)
return -1; return -1;
break; break;
case MKTAG('D', 'A', 'T', 'A'): case MKTAG('D', 'A', 'T', 'A'):
@ -474,10 +474,10 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
} }
} }
header_end: header_end:
rm->nb_packets = get_be32(pb); /* number of packets */ rm->nb_packets = avio_rb32(pb); /* number of packets */
if (!rm->nb_packets && (flags & 4)) if (!rm->nb_packets && (flags & 4))
rm->nb_packets = 3600 * 25; rm->nb_packets = 3600 * 25;
get_be32(pb); /* next data header */ avio_rb32(pb); /* next data header */
if (!data_off) if (!data_off)
data_off = url_ftell(pb) - 18; data_off = url_ftell(pb) - 18;
@ -494,13 +494,13 @@ static int get_num(AVIOContext *pb, int *len)
{ {
int n, n1; int n, n1;
n = get_be16(pb); n = avio_rb16(pb);
(*len)-=2; (*len)-=2;
n &= 0x7FFF; n &= 0x7FFF;
if (n >= 0x4000) { if (n >= 0x4000) {
return n - 0x4000; return n - 0x4000;
} else { } else {
n1 = get_be16(pb); n1 = avio_rb16(pb);
(*len)-=2; (*len)-=2;
return (n << 16) | n1; return (n << 16) | n1;
} }
@ -524,13 +524,13 @@ static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_
*timestamp = AV_NOPTS_VALUE; *timestamp = AV_NOPTS_VALUE;
*flags= 0; *flags= 0;
}else{ }else{
state= (state<<8) + get_byte(pb); state= (state<<8) + avio_r8(pb);
if(state == MKBETAG('I', 'N', 'D', 'X')){ if(state == MKBETAG('I', 'N', 'D', 'X')){
int n_pkts, expected_len; int n_pkts, expected_len;
len = get_be32(pb); len = avio_rb32(pb);
url_fskip(pb, 2); url_fskip(pb, 2);
n_pkts = get_be32(pb); n_pkts = avio_rb32(pb);
expected_len = 20 + n_pkts * 14; expected_len = 20 + n_pkts * 14;
if (len == 20) if (len == 20)
/* some files don't add index entries to chunk size... */ /* some files don't add index entries to chunk size... */
@ -553,10 +553,10 @@ static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_
len=state - 12; len=state - 12;
state= 0xFFFFFFFF; state= 0xFFFFFFFF;
num = get_be16(pb); num = avio_rb16(pb);
*timestamp = get_be32(pb); *timestamp = avio_rb32(pb);
get_byte(pb); /* reserved */ avio_r8(pb); /* reserved */
*flags = get_byte(pb); /* flags */ *flags = avio_r8(pb); /* flags */
} }
for(i=0;i<s->nb_streams;i++) { for(i=0;i<s->nb_streams;i++) {
st = s->streams[i]; st = s->streams[i];
@ -584,16 +584,16 @@ static int rm_assemble_video_frame(AVFormatContext *s, AVIOContext *pb,
int hdr, seq, pic_num, len2, pos; int hdr, seq, pic_num, len2, pos;
int type; int type;
hdr = get_byte(pb); len--; hdr = avio_r8(pb); len--;
type = hdr >> 6; type = hdr >> 6;
if(type != 3){ // not frame as a part of packet if(type != 3){ // not frame as a part of packet
seq = get_byte(pb); len--; seq = avio_r8(pb); len--;
} }
if(type != 1){ // not whole frame if(type != 1){ // not whole frame
len2 = get_num(pb, &len); len2 = get_num(pb, &len);
pos = get_num(pb, &len); pos = get_num(pb, &len);
pic_num = get_byte(pb); len--; pic_num = avio_r8(pb); len--;
} }
if(len<0) if(len<0)
return -1; return -1;
@ -609,7 +609,7 @@ static int rm_assemble_video_frame(AVFormatContext *s, AVIOContext *pb,
pkt->data[0] = 0; pkt->data[0] = 0;
AV_WL32(pkt->data + 1, 1); AV_WL32(pkt->data + 1, 1);
AV_WL32(pkt->data + 5, 0); AV_WL32(pkt->data + 5, 0);
get_buffer(pb, pkt->data + 9, len); avio_read(pb, pkt->data + 9, len);
return 0; return 0;
} }
//now we have to deal with single slice //now we have to deal with single slice
@ -635,7 +635,7 @@ static int rm_assemble_video_frame(AVFormatContext *s, AVIOContext *pb,
AV_WL32(vst->pkt.data - 3 + 8*vst->cur_slice, vst->videobufpos - 8*vst->slices - 1); AV_WL32(vst->pkt.data - 3 + 8*vst->cur_slice, vst->videobufpos - 8*vst->slices - 1);
if(vst->videobufpos + len > vst->videobufsize) if(vst->videobufpos + len > vst->videobufsize)
return 1; return 1;
if (get_buffer(pb, vst->pkt.data + vst->videobufpos, len) != len) if (avio_read(pb, vst->pkt.data + vst->videobufpos, len) != len)
return AVERROR(EIO); return AVERROR(EIO);
vst->videobufpos += len; vst->videobufpos += len;
rm->remaining_len-= len; rm->remaining_len-= len;
@ -730,15 +730,15 @@ ff_rm_parse_packet (AVFormatContext *s, AVIOContext *pb,
switch(st->codec->codec_id) { switch(st->codec->codec_id) {
case CODEC_ID_RA_288: case CODEC_ID_RA_288:
for (x = 0; x < h/2; x++) for (x = 0; x < h/2; x++)
get_buffer(pb, ast->pkt.data+x*2*w+y*cfs, cfs); avio_read(pb, ast->pkt.data+x*2*w+y*cfs, cfs);
break; break;
case CODEC_ID_ATRAC3: case CODEC_ID_ATRAC3:
case CODEC_ID_COOK: case CODEC_ID_COOK:
for (x = 0; x < w/sps; x++) for (x = 0; x < w/sps; x++)
get_buffer(pb, ast->pkt.data+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), sps); avio_read(pb, ast->pkt.data+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), sps);
break; break;
case CODEC_ID_SIPR: case CODEC_ID_SIPR:
get_buffer(pb, ast->pkt.data + y * w, w); avio_read(pb, ast->pkt.data + y * w, w);
break; break;
} }
@ -753,10 +753,10 @@ ff_rm_parse_packet (AVFormatContext *s, AVIOContext *pb,
} else if (st->codec->codec_id == CODEC_ID_AAC) { } else if (st->codec->codec_id == CODEC_ID_AAC) {
int x; int x;
rm->audio_stream_num = st->index; rm->audio_stream_num = st->index;
ast->sub_packet_cnt = (get_be16(pb) & 0xf0) >> 4; ast->sub_packet_cnt = (avio_rb16(pb) & 0xf0) >> 4;
if (ast->sub_packet_cnt) { if (ast->sub_packet_cnt) {
for (x = 0; x < ast->sub_packet_cnt; x++) for (x = 0; x < ast->sub_packet_cnt; x++)
ast->sub_packet_lengths[x] = get_be16(pb); ast->sub_packet_lengths[x] = avio_rb16(pb);
rm->audio_pkt_cnt = ast->sub_packet_cnt; rm->audio_pkt_cnt = ast->sub_packet_cnt;
ast->audiotimestamp = timestamp; ast->audiotimestamp = timestamp;
} else } else
@ -916,9 +916,9 @@ static int64_t rm_read_dts(AVFormatContext *s, int stream_index,
st = s->streams[stream_index2]; st = s->streams[stream_index2];
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
h= get_byte(s->pb); len--; h= avio_r8(s->pb); len--;
if(!(h & 0x40)){ if(!(h & 0x40)){
seq = get_byte(s->pb); len--; seq = avio_r8(s->pb); len--;
} }
} }

6
libavformat/rpl.c
View File

@ -51,7 +51,7 @@ static int read_line(AVIOContext * pb, char* line, int bufsize)
{ {
int i; int i;
for (i = 0; i < bufsize - 1; i++) { for (i = 0; i < bufsize - 1; i++) {
int b = get_byte(pb); int b = avio_r8(pb);
if (b == 0) if (b == 0)
break; break;
if (b == '\n') { if (b == '\n') {
@ -301,8 +301,8 @@ static int rpl_read_packet(AVFormatContext *s, AVPacket *pkt)
// multiple frames per chunk in Escape 124 samples. // multiple frames per chunk in Escape 124 samples.
uint32_t frame_size, frame_flags; uint32_t frame_size, frame_flags;
frame_flags = get_le32(pb); frame_flags = avio_rl32(pb);
frame_size = get_le32(pb); frame_size = avio_rl32(pb);
if (url_fseek(pb, -8, SEEK_CUR) < 0) if (url_fseek(pb, -8, SEEK_CUR) < 0)
return AVERROR(EIO); return AVERROR(EIO);

8
libavformat/rsodec.c
View File

@ -35,10 +35,10 @@ static int rso_read_header(AVFormatContext *s, AVFormatParameters *ap)
enum CodecID codec; enum CodecID codec;
AVStream *st; AVStream *st;
id = get_be16(pb); id = avio_rb16(pb);
size = get_be16(pb); size = avio_rb16(pb);
rate = get_be16(pb); rate = avio_rb16(pb);
get_be16(pb); /* play mode ? (0x0000 = don't loop) */ avio_rb16(pb); /* play mode ? (0x0000 = don't loop) */
codec = ff_codec_get_id(ff_codec_rso_tags, id); codec = ff_codec_get_id(ff_codec_rso_tags, id);

4
libavformat/rtpdec_asf.c
View File

@ -182,10 +182,10 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf,
while (url_ftell(pb) + 4 < len) { while (url_ftell(pb) + 4 < len) {
int start_off = url_ftell(pb); int start_off = url_ftell(pb);
mflags = get_byte(pb); mflags = avio_r8(pb);
if (mflags & 0x80) if (mflags & 0x80)
flags |= RTP_FLAG_KEY; flags |= RTP_FLAG_KEY;
len_off = get_be24(pb); len_off = avio_rb24(pb);
if (mflags & 0x20) /**< relative timestamp */ if (mflags & 0x20) /**< relative timestamp */
url_fskip(pb, 4); url_fskip(pb, 4);
if (mflags & 0x10) /**< has duration */ if (mflags & 0x10) /**< has duration */

8
libavformat/rtpdec_qt.c
View File

@ -104,20 +104,20 @@ static int qt_rtp_parse_packet(AVFormatContext *s, PayloadContext *qt,
data_len = get_bits(&gb, 16); data_len = get_bits(&gb, 16);
url_fseek(&pb, pos + 4, SEEK_SET); url_fseek(&pb, pos + 4, SEEK_SET);
tag = get_le32(&pb); tag = avio_rl32(&pb);
if ((st->codec->codec_type == AVMEDIA_TYPE_VIDEO && if ((st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
tag != MKTAG('v','i','d','e')) || tag != MKTAG('v','i','d','e')) ||
(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
tag != MKTAG('s','o','u','n'))) tag != MKTAG('s','o','u','n')))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
av_set_pts_info(st, 32, 1, get_be32(&pb)); av_set_pts_info(st, 32, 1, avio_rb32(&pb));
if (pos + data_len > len) if (pos + data_len > len)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
/* TLVs */ /* TLVs */
while (url_ftell(&pb) + 4 < pos + data_len) { while (url_ftell(&pb) + 4 < pos + data_len) {
int tlv_len = get_be16(&pb); int tlv_len = avio_rb16(&pb);
tag = get_le16(&pb); tag = avio_rl16(&pb);
if (url_ftell(&pb) + tlv_len > pos + data_len) if (url_ftell(&pb) + tlv_len > pos + data_len)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;

2
libavformat/rtsp.c
View File

@ -1784,7 +1784,7 @@ static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap)
/* read the whole sdp file */ /* read the whole sdp file */
/* XXX: better loading */ /* XXX: better loading */
content = av_malloc(SDP_MAX_SIZE); content = av_malloc(SDP_MAX_SIZE);
size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1); size = avio_read(s->pb, content, SDP_MAX_SIZE - 1);
if (size <= 0) { if (size <= 0) {
av_free(content); av_free(content);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;

20
libavformat/sauce.c
View File

@ -36,13 +36,13 @@ int ff_sauce_read(AVFormatContext *avctx, uint64_t *fsize, int *got_width, int g
uint64_t start_pos = url_fsize(pb) - 128; uint64_t start_pos = url_fsize(pb) - 128;
url_fseek(pb, start_pos, SEEK_SET); url_fseek(pb, start_pos, SEEK_SET);
if (get_buffer(pb, buf, 7) != 7) if (avio_read(pb, buf, 7) != 7)
return -1; return -1;
if (memcmp(buf, "SAUCE00", 7)) if (memcmp(buf, "SAUCE00", 7))
return -1; return -1;
#define GET_SAUCE_META(name,size) \ #define GET_SAUCE_META(name,size) \
if (get_buffer(pb, buf, size) == size && buf[0]) { \ if (avio_read(pb, buf, size) == size && buf[0]) { \
buf[size] = 0; \ buf[size] = 0; \
av_metadata_set2(&avctx->metadata, name, buf, 0); \ av_metadata_set2(&avctx->metadata, name, buf, 0); \
} }
@ -52,12 +52,12 @@ int ff_sauce_read(AVFormatContext *avctx, uint64_t *fsize, int *got_width, int g
GET_SAUCE_META("publisher", 20) GET_SAUCE_META("publisher", 20)
GET_SAUCE_META("date", 8) GET_SAUCE_META("date", 8)
url_fskip(pb, 4); url_fskip(pb, 4);
datatype = get_byte(pb); datatype = avio_r8(pb);
filetype = get_byte(pb); filetype = avio_r8(pb);
t1 = get_le16(pb); t1 = avio_rl16(pb);
t2 = get_le16(pb); t2 = avio_rl16(pb);
nb_comments = get_byte(pb); nb_comments = avio_r8(pb);
flags = get_byte(pb); flags = avio_r8(pb);
url_fskip(pb, 4); url_fskip(pb, 4);
GET_SAUCE_META("encoder", 22); GET_SAUCE_META("encoder", 22);
@ -83,14 +83,14 @@ int ff_sauce_read(AVFormatContext *avctx, uint64_t *fsize, int *got_width, int g
if (nb_comments > 0) { if (nb_comments > 0) {
url_fseek(pb, start_pos - 64*nb_comments - 5, SEEK_SET); url_fseek(pb, start_pos - 64*nb_comments - 5, SEEK_SET);
if (get_buffer(pb, buf, 5) == 5 && !memcmp(buf, "COMNT", 5)) { if (avio_read(pb, buf, 5) == 5 && !memcmp(buf, "COMNT", 5)) {
int i; int i;
char *str = av_malloc(65*nb_comments + 1); char *str = av_malloc(65*nb_comments + 1);
*fsize -= 64*nb_comments + 5; *fsize -= 64*nb_comments + 5;
if (!str) if (!str)
return 0; return 0;
for (i = 0; i < nb_comments; i++) { for (i = 0; i < nb_comments; i++) {
if (get_buffer(pb, str + 65*i, 64) != 64) if (avio_read(pb, str + 65*i, 64) != 64)
break; break;
str[65*i + 64] = '\n'; str[65*i + 64] = '\n';
} }

14
libavformat/segafilm.c
View File

@ -89,7 +89,7 @@ static int film_read_header(AVFormatContext *s,
film->stereo_buffer_size = 0; film->stereo_buffer_size = 0;
/* load the main FILM header */ /* load the main FILM header */
if (get_buffer(pb, scratch, 16) != 16) if (avio_read(pb, scratch, 16) != 16)
return AVERROR(EIO); return AVERROR(EIO);
data_offset = AV_RB32(&scratch[4]); data_offset = AV_RB32(&scratch[4]);
film->version = AV_RB32(&scratch[8]); film->version = AV_RB32(&scratch[8]);
@ -97,7 +97,7 @@ static int film_read_header(AVFormatContext *s,
/* load the FDSC chunk */ /* load the FDSC chunk */
if (film->version == 0) { if (film->version == 0) {
/* special case for Lemmings .film files; 20-byte header */ /* special case for Lemmings .film files; 20-byte header */
if (get_buffer(pb, scratch, 20) != 20) if (avio_read(pb, scratch, 20) != 20)
return AVERROR(EIO); return AVERROR(EIO);
/* make some assumptions about the audio parameters */ /* make some assumptions about the audio parameters */
film->audio_type = CODEC_ID_PCM_S8; film->audio_type = CODEC_ID_PCM_S8;
@ -106,7 +106,7 @@ static int film_read_header(AVFormatContext *s,
film->audio_bits = 8; film->audio_bits = 8;
} else { } else {
/* normal Saturn .cpk files; 32-byte header */ /* normal Saturn .cpk files; 32-byte header */
if (get_buffer(pb, scratch, 32) != 32) if (avio_read(pb, scratch, 32) != 32)
return AVERROR(EIO); return AVERROR(EIO);
film->audio_samplerate = AV_RB16(&scratch[24]); film->audio_samplerate = AV_RB16(&scratch[24]);
film->audio_channels = scratch[21]; film->audio_channels = scratch[21];
@ -158,7 +158,7 @@ static int film_read_header(AVFormatContext *s,
} }
/* load the sample table */ /* load the sample table */
if (get_buffer(pb, scratch, 16) != 16) if (avio_read(pb, scratch, 16) != 16)
return AVERROR(EIO); return AVERROR(EIO);
if (AV_RB32(&scratch[0]) != STAB_TAG) if (AV_RB32(&scratch[0]) != STAB_TAG)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -174,7 +174,7 @@ static int film_read_header(AVFormatContext *s,
audio_frame_counter = 0; audio_frame_counter = 0;
for (i = 0; i < film->sample_count; i++) { for (i = 0; i < film->sample_count; i++) {
/* load the next sample record and transfer it to an internal struct */ /* load the next sample record and transfer it to an internal struct */
if (get_buffer(pb, scratch, 16) != 16) { if (avio_read(pb, scratch, 16) != 16) {
av_free(film->sample_table); av_free(film->sample_table);
return AVERROR(EIO); return AVERROR(EIO);
} }
@ -225,7 +225,7 @@ static int film_read_packet(AVFormatContext *s,
pkt->pos= url_ftell(pb); pkt->pos= url_ftell(pb);
if (av_new_packet(pkt, sample->sample_size)) if (av_new_packet(pkt, sample->sample_size))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
get_buffer(pb, pkt->data, sample->sample_size); avio_read(pb, pkt->data, sample->sample_size);
} else if ((sample->stream == film->audio_stream_index) && } else if ((sample->stream == film->audio_stream_index) &&
(film->audio_channels == 2)) { (film->audio_channels == 2)) {
/* stereo PCM needs to be interleaved */ /* stereo PCM needs to be interleaved */
@ -241,7 +241,7 @@ static int film_read_packet(AVFormatContext *s,
} }
pkt->pos= url_ftell(pb); pkt->pos= url_ftell(pb);
ret = get_buffer(pb, film->stereo_buffer, sample->sample_size); ret = avio_read(pb, film->stereo_buffer, sample->sample_size);
if (ret != sample->sample_size) if (ret != sample->sample_size)
ret = AVERROR(EIO); ret = AVERROR(EIO);

10
libavformat/sierravmd.c
View File

@ -96,7 +96,7 @@ static int vmd_read_header(AVFormatContext *s,
/* fetch the main header, including the 2 header length bytes */ /* fetch the main header, including the 2 header length bytes */
url_fseek(pb, 0, SEEK_SET); url_fseek(pb, 0, SEEK_SET);
if (get_buffer(pb, vmd->vmd_header, VMD_HEADER_SIZE) != VMD_HEADER_SIZE) if (avio_read(pb, vmd->vmd_header, VMD_HEADER_SIZE) != VMD_HEADER_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
if(vmd->vmd_header[16] == 'i' && vmd->vmd_header[17] == 'v' && vmd->vmd_header[18] == '3') if(vmd->vmd_header[16] == 'i' && vmd->vmd_header[17] == 'v' && vmd->vmd_header[18] == '3')
@ -172,7 +172,7 @@ static int vmd_read_header(AVFormatContext *s,
av_free(vmd->frame_table); av_free(vmd->frame_table);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if (get_buffer(pb, raw_frame_table, raw_frame_table_size) != if (avio_read(pb, raw_frame_table, raw_frame_table_size) !=
raw_frame_table_size) { raw_frame_table_size) {
av_free(raw_frame_table); av_free(raw_frame_table);
av_free(vmd->frame_table); av_free(vmd->frame_table);
@ -189,7 +189,7 @@ static int vmd_read_header(AVFormatContext *s,
int type; int type;
uint32_t size; uint32_t size;
get_buffer(pb, chunk, BYTES_PER_FRAME_RECORD); avio_read(pb, chunk, BYTES_PER_FRAME_RECORD);
type = chunk[0]; type = chunk[0];
size = AV_RL32(&chunk[2]); size = AV_RL32(&chunk[2]);
if(!size && type != 1) if(!size && type != 1)
@ -250,9 +250,9 @@ static int vmd_read_packet(AVFormatContext *s,
pkt->pos= url_ftell(pb); pkt->pos= url_ftell(pb);
memcpy(pkt->data, frame->frame_record, BYTES_PER_FRAME_RECORD); memcpy(pkt->data, frame->frame_record, BYTES_PER_FRAME_RECORD);
if(vmd->is_indeo3) if(vmd->is_indeo3)
ret = get_buffer(pb, pkt->data, frame->frame_size); ret = avio_read(pb, pkt->data, frame->frame_size);
else else
ret = get_buffer(pb, pkt->data + BYTES_PER_FRAME_RECORD, ret = avio_read(pb, pkt->data + BYTES_PER_FRAME_RECORD,
frame->frame_size); frame->frame_size);
if (ret != frame->frame_size) { if (ret != frame->frame_size) {

40
libavformat/siff.c
View File

@ -89,28 +89,28 @@ static int siff_parse_vbv1(AVFormatContext *s, SIFFContext *c, AVIOContext *pb)
AVStream *st; AVStream *st;
int width, height; int width, height;
if (get_le32(pb) != TAG_VBHD){ if (avio_rl32(pb) != TAG_VBHD){
av_log(s, AV_LOG_ERROR, "Header chunk is missing\n"); av_log(s, AV_LOG_ERROR, "Header chunk is missing\n");
return -1; return -1;
} }
if(get_be32(pb) != 32){ if(avio_rb32(pb) != 32){
av_log(s, AV_LOG_ERROR, "Header chunk size is incorrect\n"); av_log(s, AV_LOG_ERROR, "Header chunk size is incorrect\n");
return -1; return -1;
} }
if(get_le16(pb) != 1){ if(avio_rl16(pb) != 1){
av_log(s, AV_LOG_ERROR, "Incorrect header version\n"); av_log(s, AV_LOG_ERROR, "Incorrect header version\n");
return -1; return -1;
} }
width = get_le16(pb); width = avio_rl16(pb);
height = get_le16(pb); height = avio_rl16(pb);
url_fskip(pb, 4); url_fskip(pb, 4);
c->frames = get_le16(pb); c->frames = avio_rl16(pb);
if(!c->frames){ if(!c->frames){
av_log(s, AV_LOG_ERROR, "File contains no frames ???\n"); av_log(s, AV_LOG_ERROR, "File contains no frames ???\n");
return -1; return -1;
} }
c->bits = get_le16(pb); c->bits = avio_rl16(pb);
c->rate = get_le16(pb); c->rate = avio_rl16(pb);
c->block_align = c->rate * (c->bits >> 3); c->block_align = c->rate * (c->bits >> 3);
url_fskip(pb, 16); //zeroes url_fskip(pb, 16); //zeroes
@ -137,17 +137,17 @@ static int siff_parse_vbv1(AVFormatContext *s, SIFFContext *c, AVIOContext *pb)
static int siff_parse_soun(AVFormatContext *s, SIFFContext *c, AVIOContext *pb) static int siff_parse_soun(AVFormatContext *s, SIFFContext *c, AVIOContext *pb)
{ {
if (get_le32(pb) != TAG_SHDR){ if (avio_rl32(pb) != TAG_SHDR){
av_log(s, AV_LOG_ERROR, "Header chunk is missing\n"); av_log(s, AV_LOG_ERROR, "Header chunk is missing\n");
return -1; return -1;
} }
if(get_be32(pb) != 8){ if(avio_rb32(pb) != 8){
av_log(s, AV_LOG_ERROR, "Header chunk size is incorrect\n"); av_log(s, AV_LOG_ERROR, "Header chunk size is incorrect\n");
return -1; return -1;
} }
url_fskip(pb, 4); //unknown value url_fskip(pb, 4); //unknown value
c->rate = get_le16(pb); c->rate = avio_rl16(pb);
c->bits = get_le16(pb); c->bits = avio_rl16(pb);
c->block_align = c->rate * (c->bits >> 3); c->block_align = c->rate * (c->bits >> 3);
return create_audio_stream(s, c); return create_audio_stream(s, c);
} }
@ -158,10 +158,10 @@ static int siff_read_header(AVFormatContext *s, AVFormatParameters *ap)
SIFFContext *c = s->priv_data; SIFFContext *c = s->priv_data;
uint32_t tag; uint32_t tag;
if (get_le32(pb) != TAG_SIFF) if (avio_rl32(pb) != TAG_SIFF)
return -1; return -1;
url_fskip(pb, 4); //ignore size url_fskip(pb, 4); //ignore size
tag = get_le32(pb); tag = avio_rl32(pb);
if (tag != TAG_VBV1 && tag != TAG_SOUN){ if (tag != TAG_VBV1 && tag != TAG_SOUN){
av_log(s, AV_LOG_ERROR, "Not a VBV file\n"); av_log(s, AV_LOG_ERROR, "Not a VBV file\n");
@ -172,7 +172,7 @@ static int siff_read_header(AVFormatContext *s, AVFormatParameters *ap)
return -1; return -1;
if (tag == TAG_SOUN && siff_parse_soun(s, c, pb) < 0) if (tag == TAG_SOUN && siff_parse_soun(s, c, pb) < 0)
return -1; return -1;
if (get_le32(pb) != MKTAG('B', 'O', 'D', 'Y')){ if (avio_rl32(pb) != MKTAG('B', 'O', 'D', 'Y')){
av_log(s, AV_LOG_ERROR, "'BODY' chunk is missing\n"); av_log(s, AV_LOG_ERROR, "'BODY' chunk is missing\n");
return -1; return -1;
} }
@ -190,12 +190,12 @@ static int siff_read_packet(AVFormatContext *s, AVPacket *pkt)
if (c->cur_frame >= c->frames) if (c->cur_frame >= c->frames)
return AVERROR(EIO); return AVERROR(EIO);
if (c->curstrm == -1){ if (c->curstrm == -1){
c->pktsize = get_le32(s->pb) - 4; c->pktsize = avio_rl32(s->pb) - 4;
c->flags = get_le16(s->pb); c->flags = avio_rl16(s->pb);
c->gmcsize = (c->flags & VB_HAS_GMC) ? 4 : 0; c->gmcsize = (c->flags & VB_HAS_GMC) ? 4 : 0;
if (c->gmcsize) if (c->gmcsize)
get_buffer(s->pb, c->gmc, c->gmcsize); avio_read(s->pb, c->gmc, c->gmcsize);
c->sndsize = (c->flags & VB_HAS_AUDIO) ? get_le32(s->pb): 0; c->sndsize = (c->flags & VB_HAS_AUDIO) ? avio_rl32(s->pb): 0;
c->curstrm = !!(c->flags & VB_HAS_AUDIO); c->curstrm = !!(c->flags & VB_HAS_AUDIO);
} }
@ -206,7 +206,7 @@ static int siff_read_packet(AVFormatContext *s, AVPacket *pkt)
AV_WL16(pkt->data, c->flags); AV_WL16(pkt->data, c->flags);
if (c->gmcsize) if (c->gmcsize)
memcpy(pkt->data + 2, c->gmc, c->gmcsize); memcpy(pkt->data + 2, c->gmc, c->gmcsize);
get_buffer(s->pb, pkt->data + 2 + c->gmcsize, size - c->gmcsize - 2); avio_read(s->pb, pkt->data + 2 + c->gmcsize, size - c->gmcsize - 2);
pkt->stream_index = 0; pkt->stream_index = 0;
c->curstrm = -1; c->curstrm = -1;
}else{ }else{

50
libavformat/smacker.c
View File

@ -105,19 +105,19 @@ static int smacker_read_header(AVFormatContext *s, AVFormatParameters *ap)
int tbase; int tbase;
/* read and check header */ /* read and check header */
smk->magic = get_le32(pb); smk->magic = avio_rl32(pb);
if (smk->magic != MKTAG('S', 'M', 'K', '2') && smk->magic != MKTAG('S', 'M', 'K', '4')) if (smk->magic != MKTAG('S', 'M', 'K', '2') && smk->magic != MKTAG('S', 'M', 'K', '4'))
return -1; return -1;
smk->width = get_le32(pb); smk->width = avio_rl32(pb);
smk->height = get_le32(pb); smk->height = avio_rl32(pb);
smk->frames = get_le32(pb); smk->frames = avio_rl32(pb);
smk->pts_inc = (int32_t)get_le32(pb); smk->pts_inc = (int32_t)avio_rl32(pb);
smk->flags = get_le32(pb); smk->flags = avio_rl32(pb);
if(smk->flags & SMACKER_FLAG_RING_FRAME) if(smk->flags & SMACKER_FLAG_RING_FRAME)
smk->frames++; smk->frames++;
for(i = 0; i < 7; i++) for(i = 0; i < 7; i++)
smk->audio[i] = get_le32(pb); smk->audio[i] = avio_rl32(pb);
smk->treesize = get_le32(pb); smk->treesize = avio_rl32(pb);
if(smk->treesize >= UINT_MAX/4){ // smk->treesize + 16 must not overflow (this check is probably redundant) if(smk->treesize >= UINT_MAX/4){ // smk->treesize + 16 must not overflow (this check is probably redundant)
av_log(s, AV_LOG_ERROR, "treesize too large\n"); av_log(s, AV_LOG_ERROR, "treesize too large\n");
@ -125,13 +125,13 @@ static int smacker_read_header(AVFormatContext *s, AVFormatParameters *ap)
} }
//FIXME remove extradata "rebuilding" //FIXME remove extradata "rebuilding"
smk->mmap_size = get_le32(pb); smk->mmap_size = avio_rl32(pb);
smk->mclr_size = get_le32(pb); smk->mclr_size = avio_rl32(pb);
smk->full_size = get_le32(pb); smk->full_size = avio_rl32(pb);
smk->type_size = get_le32(pb); smk->type_size = avio_rl32(pb);
for(i = 0; i < 7; i++) for(i = 0; i < 7; i++)
smk->rates[i] = get_le32(pb); smk->rates[i] = avio_rl32(pb);
smk->pad = get_le32(pb); smk->pad = avio_rl32(pb);
/* setup data */ /* setup data */
if(smk->frames > 0xFFFFFF) { if(smk->frames > 0xFFFFFF) {
av_log(s, AV_LOG_ERROR, "Too many frames: %i\n", smk->frames); av_log(s, AV_LOG_ERROR, "Too many frames: %i\n", smk->frames);
@ -144,10 +144,10 @@ static int smacker_read_header(AVFormatContext *s, AVFormatParameters *ap)
/* read frame info */ /* read frame info */
for(i = 0; i < smk->frames; i++) { for(i = 0; i < smk->frames; i++) {
smk->frm_size[i] = get_le32(pb); smk->frm_size[i] = avio_rl32(pb);
} }
for(i = 0; i < smk->frames; i++) { for(i = 0; i < smk->frames; i++) {
smk->frm_flags[i] = get_byte(pb); smk->frm_flags[i] = avio_r8(pb);
} }
/* init video codec */ /* init video codec */
@ -207,7 +207,7 @@ static int smacker_read_header(AVFormatContext *s, AVFormatParameters *ap)
av_free(smk->frm_flags); av_free(smk->frm_flags);
return -1; return -1;
} }
ret = get_buffer(pb, st->codec->extradata + 16, st->codec->extradata_size - 16); ret = avio_read(pb, st->codec->extradata + 16, st->codec->extradata_size - 16);
if(ret != st->codec->extradata_size - 16){ if(ret != st->codec->extradata_size - 16){
av_free(smk->frm_size); av_free(smk->frm_size);
av_free(smk->frm_flags); av_free(smk->frm_flags);
@ -251,19 +251,19 @@ static int smacker_read_packet(AVFormatContext *s, AVPacket *pkt)
uint8_t oldpal[768]; uint8_t oldpal[768];
memcpy(oldpal, pal, 768); memcpy(oldpal, pal, 768);
size = get_byte(s->pb); size = avio_r8(s->pb);
size = size * 4 - 1; size = size * 4 - 1;
frame_size -= size; frame_size -= size;
frame_size--; frame_size--;
sz = 0; sz = 0;
pos = url_ftell(s->pb) + size; pos = url_ftell(s->pb) + size;
while(sz < 256){ while(sz < 256){
t = get_byte(s->pb); t = avio_r8(s->pb);
if(t & 0x80){ /* skip palette entries */ if(t & 0x80){ /* skip palette entries */
sz += (t & 0x7F) + 1; sz += (t & 0x7F) + 1;
pal += ((t & 0x7F) + 1) * 3; pal += ((t & 0x7F) + 1) * 3;
} else if(t & 0x40){ /* copy with offset */ } else if(t & 0x40){ /* copy with offset */
off = get_byte(s->pb) * 3; off = avio_r8(s->pb) * 3;
j = (t & 0x3F) + 1; j = (t & 0x3F) + 1;
while(j-- && sz < 256) { while(j-- && sz < 256) {
*pal++ = oldpal[off + 0]; *pal++ = oldpal[off + 0];
@ -274,8 +274,8 @@ static int smacker_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
} else { /* new entries */ } else { /* new entries */
*pal++ = smk_pal[t]; *pal++ = smk_pal[t];
*pal++ = smk_pal[get_byte(s->pb) & 0x3F]; *pal++ = smk_pal[avio_r8(s->pb) & 0x3F];
*pal++ = smk_pal[get_byte(s->pb) & 0x3F]; *pal++ = smk_pal[avio_r8(s->pb) & 0x3F];
sz++; sz++;
} }
} }
@ -288,13 +288,13 @@ static int smacker_read_packet(AVFormatContext *s, AVPacket *pkt)
for(i = 0; i < 7; i++) { for(i = 0; i < 7; i++) {
if(flags & 1) { if(flags & 1) {
int size; int size;
size = get_le32(s->pb) - 4; size = avio_rl32(s->pb) - 4;
frame_size -= size; frame_size -= size;
frame_size -= 4; frame_size -= 4;
smk->curstream++; smk->curstream++;
smk->bufs[smk->curstream] = av_realloc(smk->bufs[smk->curstream], size); smk->bufs[smk->curstream] = av_realloc(smk->bufs[smk->curstream], size);
smk->buf_sizes[smk->curstream] = size; smk->buf_sizes[smk->curstream] = size;
ret = get_buffer(s->pb, smk->bufs[smk->curstream], size); ret = avio_read(s->pb, smk->bufs[smk->curstream], size);
if(ret != size) if(ret != size)
return AVERROR(EIO); return AVERROR(EIO);
smk->stream_id[smk->curstream] = smk->indexes[i]; smk->stream_id[smk->curstream] = smk->indexes[i];
@ -307,7 +307,7 @@ static int smacker_read_packet(AVFormatContext *s, AVPacket *pkt)
palchange |= 2; palchange |= 2;
pkt->data[0] = palchange; pkt->data[0] = palchange;
memcpy(pkt->data + 1, smk->pal, 768); memcpy(pkt->data + 1, smk->pal, 768);
ret = get_buffer(s->pb, pkt->data + 769, frame_size); ret = avio_read(s->pb, pkt->data + 769, frame_size);
if(ret != frame_size) if(ret != frame_size)
return AVERROR(EIO); return AVERROR(EIO);
pkt->stream_index = smk->videoindex; pkt->stream_index = smk->videoindex;

12
libavformat/sol.c
View File

@ -93,15 +93,15 @@ static int sol_read_header(AVFormatContext *s,
AVStream *st; AVStream *st;
/* check ".snd" header */ /* check ".snd" header */
magic = get_le16(pb); magic = avio_rl16(pb);
tag = get_le32(pb); tag = avio_rl32(pb);
if (tag != MKTAG('S', 'O', 'L', 0)) if (tag != MKTAG('S', 'O', 'L', 0))
return -1; return -1;
rate = get_le16(pb); rate = avio_rl16(pb);
type = get_byte(pb); type = avio_r8(pb);
size = get_le32(pb); size = avio_rl32(pb);
if (magic != 0x0B8D) if (magic != 0x0B8D)
get_byte(pb); /* newer SOLs contain padding byte */ avio_r8(pb); /* newer SOLs contain padding byte */
codec = sol_codec_id(magic, type); codec = sol_codec_id(magic, type);
channels = sol_channels(magic, type); channels = sol_channels(magic, type);

20
libavformat/soxdec.c
View File

@ -55,20 +55,20 @@ static int sox_read_header(AVFormatContext *s,
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
if (get_le32(pb) == SOX_TAG) { if (avio_rl32(pb) == SOX_TAG) {
st->codec->codec_id = CODEC_ID_PCM_S32LE; st->codec->codec_id = CODEC_ID_PCM_S32LE;
header_size = get_le32(pb); header_size = avio_rl32(pb);
url_fskip(pb, 8); /* sample count */ url_fskip(pb, 8); /* sample count */
sample_rate = av_int2dbl(get_le64(pb)); sample_rate = av_int2dbl(avio_rl64(pb));
st->codec->channels = get_le32(pb); st->codec->channels = avio_rl32(pb);
comment_size = get_le32(pb); comment_size = avio_rl32(pb);
} else { } else {
st->codec->codec_id = CODEC_ID_PCM_S32BE; st->codec->codec_id = CODEC_ID_PCM_S32BE;
header_size = get_be32(pb); header_size = avio_rb32(pb);
url_fskip(pb, 8); /* sample count */ url_fskip(pb, 8); /* sample count */
sample_rate = av_int2dbl(get_be64(pb)); sample_rate = av_int2dbl(avio_rb64(pb));
st->codec->channels = get_be32(pb); st->codec->channels = avio_rb32(pb);
comment_size = get_be32(pb); comment_size = avio_rb32(pb);
} }
if (comment_size > 0xFFFFFFFFU - SOX_FIXED_HDR - 4U) { if (comment_size > 0xFFFFFFFFU - SOX_FIXED_HDR - 4U) {
@ -95,7 +95,7 @@ static int sox_read_header(AVFormatContext *s,
if (comment_size && comment_size < UINT_MAX) { if (comment_size && comment_size < UINT_MAX) {
char *comment = av_malloc(comment_size+1); char *comment = av_malloc(comment_size+1);
if (get_buffer(pb, comment, comment_size) != comment_size) { if (avio_read(pb, comment, comment_size) != comment_size) {
av_freep(&comment); av_freep(&comment);
return AVERROR(EIO); return AVERROR(EIO);
} }

8
libavformat/spdifdec.c
View File

@ -170,13 +170,13 @@ static int spdif_read_packet(AVFormatContext *s, AVPacket *pkt)
int pkt_size_bits, offset, ret; int pkt_size_bits, offset, ret;
while (state != (AV_BSWAP16C(SYNCWORD1) << 16 | AV_BSWAP16C(SYNCWORD2))) { while (state != (AV_BSWAP16C(SYNCWORD1) << 16 | AV_BSWAP16C(SYNCWORD2))) {
state = (state << 8) | get_byte(pb); state = (state << 8) | avio_r8(pb);
if (url_feof(pb)) if (url_feof(pb))
return AVERROR_EOF; return AVERROR_EOF;
} }
data_type = get_le16(pb); data_type = avio_rl16(pb);
pkt_size_bits = get_le16(pb); pkt_size_bits = avio_rl16(pb);
if (pkt_size_bits % 16) if (pkt_size_bits % 16)
av_log_ask_for_sample(s, "Packet does not end to a 16-bit boundary."); av_log_ask_for_sample(s, "Packet does not end to a 16-bit boundary.");
@ -187,7 +187,7 @@ static int spdif_read_packet(AVFormatContext *s, AVPacket *pkt)
pkt->pos = url_ftell(pb) - BURST_HEADER_SIZE; pkt->pos = url_ftell(pb) - BURST_HEADER_SIZE;
if (get_buffer(pb, pkt->data, pkt->size) < pkt->size) { if (avio_read(pb, pkt->data, pkt->size) < pkt->size) {
av_free_packet(pkt); av_free_packet(pkt);
return AVERROR_EOF; return AVERROR_EOF;
} }

44
libavformat/swfdec.c
View File

@ -30,11 +30,11 @@ static int get_swf_tag(AVIOContext *pb, int *len_ptr)
if (url_feof(pb)) if (url_feof(pb))
return -1; return -1;
tag = get_le16(pb); tag = avio_rl16(pb);
len = tag & 0x3f; len = tag & 0x3f;
tag = tag >> 6; tag = tag >> 6;
if (len == 0x3f) { if (len == 0x3f) {
len = get_le32(pb); len = avio_rl32(pb);
} }
// av_log(NULL, AV_LOG_DEBUG, "Tag: %d - Len: %d\n", tag, len); // av_log(NULL, AV_LOG_DEBUG, "Tag: %d - Len: %d\n", tag, len);
*len_ptr = len; *len_ptr = len;
@ -58,7 +58,7 @@ static int swf_read_header(AVFormatContext *s, AVFormatParameters *ap)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
int nbits, len, tag; int nbits, len, tag;
tag = get_be32(pb) & 0xffffff00; tag = avio_rb32(pb) & 0xffffff00;
if (tag == MKBETAG('C', 'W', 'S', 0)) { if (tag == MKBETAG('C', 'W', 'S', 0)) {
av_log(s, AV_LOG_ERROR, "Compressed SWF format not supported\n"); av_log(s, AV_LOG_ERROR, "Compressed SWF format not supported\n");
@ -66,13 +66,13 @@ static int swf_read_header(AVFormatContext *s, AVFormatParameters *ap)
} }
if (tag != MKBETAG('F', 'W', 'S', 0)) if (tag != MKBETAG('F', 'W', 'S', 0))
return AVERROR(EIO); return AVERROR(EIO);
get_le32(pb); avio_rl32(pb);
/* skip rectangle size */ /* skip rectangle size */
nbits = get_byte(pb) >> 3; nbits = avio_r8(pb) >> 3;
len = (4 * nbits - 3 + 7) / 8; len = (4 * nbits - 3 + 7) / 8;
url_fskip(pb, len); url_fskip(pb, len);
swf->frame_rate = get_le16(pb); /* 8.8 fixed */ swf->frame_rate = avio_rl16(pb); /* 8.8 fixed */
get_le16(pb); /* frame count */ avio_rl16(pb); /* frame count */
swf->samples_per_frame = 0; swf->samples_per_frame = 0;
s->ctx_flags |= AVFMTCTX_NOHEADER; s->ctx_flags |= AVFMTCTX_NOHEADER;
@ -92,7 +92,7 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
if (tag < 0) if (tag < 0)
return AVERROR(EIO); return AVERROR(EIO);
if (tag == TAG_VIDEOSTREAM) { if (tag == TAG_VIDEOSTREAM) {
int ch_id = get_le16(pb); int ch_id = avio_rl16(pb);
len -= 2; len -= 2;
for (i=0; i<s->nb_streams; i++) { for (i=0; i<s->nb_streams; i++) {
@ -101,16 +101,16 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
goto skip; goto skip;
} }
get_le16(pb); avio_rl16(pb);
get_le16(pb); avio_rl16(pb);
get_le16(pb); avio_rl16(pb);
get_byte(pb); avio_r8(pb);
/* Check for FLV1 */ /* Check for FLV1 */
vst = av_new_stream(s, ch_id); vst = av_new_stream(s, ch_id);
if (!vst) if (!vst)
return -1; return -1;
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = ff_codec_get_id(swf_codec_tags, get_byte(pb)); vst->codec->codec_id = ff_codec_get_id(swf_codec_tags, avio_r8(pb));
av_set_pts_info(vst, 16, 256, swf->frame_rate); av_set_pts_info(vst, 16, 256, swf->frame_rate);
vst->codec->time_base = (AVRational){ 256, swf->frame_rate }; vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
len -= 8; len -= 8;
@ -124,9 +124,9 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
goto skip; goto skip;
} }
get_byte(pb); avio_r8(pb);
v = get_byte(pb); v = avio_r8(pb);
swf->samples_per_frame = get_le16(pb); swf->samples_per_frame = avio_rl16(pb);
ast = av_new_stream(s, -1); /* -1 to avoid clash with video stream ch_id */ ast = av_new_stream(s, -1); /* -1 to avoid clash with video stream ch_id */
if (!ast) if (!ast)
return -1; return -1;
@ -141,12 +141,12 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
av_set_pts_info(ast, 64, 1, ast->codec->sample_rate); av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
len -= 4; len -= 4;
} else if (tag == TAG_VIDEOFRAME) { } else if (tag == TAG_VIDEOFRAME) {
int ch_id = get_le16(pb); int ch_id = avio_rl16(pb);
len -= 2; len -= 2;
for(i=0; i<s->nb_streams; i++) { for(i=0; i<s->nb_streams; i++) {
st = s->streams[i]; st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) { if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {
frame = get_le16(pb); frame = avio_rl16(pb);
av_get_packet(pb, pkt, len-2); av_get_packet(pb, pkt, len-2);
pkt->pos = pos; pkt->pos = pos;
pkt->pts = frame; pkt->pts = frame;
@ -185,17 +185,17 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
vst->codec->time_base = (AVRational){ 256, swf->frame_rate }; vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
st = vst; st = vst;
} }
get_le16(pb); /* BITMAP_ID */ avio_rl16(pb); /* BITMAP_ID */
av_new_packet(pkt, len-2); av_new_packet(pkt, len-2);
get_buffer(pb, pkt->data, 4); avio_read(pb, pkt->data, 4);
if (AV_RB32(pkt->data) == 0xffd8ffd9 || if (AV_RB32(pkt->data) == 0xffd8ffd9 ||
AV_RB32(pkt->data) == 0xffd9ffd8) { AV_RB32(pkt->data) == 0xffd9ffd8) {
/* old SWF files containing SOI/EOI as data start */ /* old SWF files containing SOI/EOI as data start */
/* files created by swink have reversed tag */ /* files created by swink have reversed tag */
pkt->size -= 4; pkt->size -= 4;
get_buffer(pb, pkt->data, pkt->size); avio_read(pb, pkt->data, pkt->size);
} else { } else {
get_buffer(pb, pkt->data + 4, pkt->size - 4); avio_read(pb, pkt->data + 4, pkt->size - 4);
} }
pkt->pos = pos; pkt->pos = pos;
pkt->stream_index = st->index; pkt->stream_index = st->index;

46
libavformat/thp.c
View File

@ -61,31 +61,31 @@ static int thp_read_header(AVFormatContext *s,
int i; int i;
/* Read the file header. */ /* Read the file header. */
get_be32(pb); /* Skip Magic. */ avio_rb32(pb); /* Skip Magic. */
thp->version = get_be32(pb); thp->version = avio_rb32(pb);
get_be32(pb); /* Max buf size. */ avio_rb32(pb); /* Max buf size. */
get_be32(pb); /* Max samples. */ avio_rb32(pb); /* Max samples. */
thp->fps = av_d2q(av_int2flt(get_be32(pb)), INT_MAX); thp->fps = av_d2q(av_int2flt(avio_rb32(pb)), INT_MAX);
thp->framecnt = get_be32(pb); thp->framecnt = avio_rb32(pb);
thp->first_framesz = get_be32(pb); thp->first_framesz = avio_rb32(pb);
get_be32(pb); /* Data size. */ avio_rb32(pb); /* Data size. */
thp->compoff = get_be32(pb); thp->compoff = avio_rb32(pb);
get_be32(pb); /* offsetDataOffset. */ avio_rb32(pb); /* offsetDataOffset. */
thp->first_frame = get_be32(pb); thp->first_frame = avio_rb32(pb);
thp->last_frame = get_be32(pb); thp->last_frame = avio_rb32(pb);
thp->next_framesz = thp->first_framesz; thp->next_framesz = thp->first_framesz;
thp->next_frame = thp->first_frame; thp->next_frame = thp->first_frame;
/* Read the component structure. */ /* Read the component structure. */
url_fseek (pb, thp->compoff, SEEK_SET); url_fseek (pb, thp->compoff, SEEK_SET);
thp->compcount = get_be32(pb); thp->compcount = avio_rb32(pb);
/* Read the list of component types. */ /* Read the list of component types. */
get_buffer(pb, thp->components, 16); avio_read(pb, thp->components, 16);
for (i = 0; i < thp->compcount; i++) { for (i = 0; i < thp->compcount; i++) {
if (thp->components[i] == 0) { if (thp->components[i] == 0) {
@ -103,14 +103,14 @@ static int thp_read_header(AVFormatContext *s,
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_THP; st->codec->codec_id = CODEC_ID_THP;
st->codec->codec_tag = 0; /* no fourcc */ st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = get_be32(pb); st->codec->width = avio_rb32(pb);
st->codec->height = get_be32(pb); st->codec->height = avio_rb32(pb);
st->codec->sample_rate = av_q2d(thp->fps); st->codec->sample_rate = av_q2d(thp->fps);
thp->vst = st; thp->vst = st;
thp->video_stream_index = st->index; thp->video_stream_index = st->index;
if (thp->version == 0x11000) if (thp->version == 0x11000)
get_be32(pb); /* Unknown. */ avio_rb32(pb); /* Unknown. */
} else if (thp->components[i] == 1) { } else if (thp->components[i] == 1) {
if (thp->has_audio != 0) if (thp->has_audio != 0)
break; break;
@ -123,8 +123,8 @@ static int thp_read_header(AVFormatContext *s,
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_ADPCM_THP; st->codec->codec_id = CODEC_ID_ADPCM_THP;
st->codec->codec_tag = 0; /* no fourcc */ st->codec->codec_tag = 0; /* no fourcc */
st->codec->channels = get_be32(pb); /* numChannels. */ st->codec->channels = avio_rb32(pb); /* numChannels. */
st->codec->sample_rate = get_be32(pb); /* Frequency. */ st->codec->sample_rate = avio_rb32(pb); /* Frequency. */
av_set_pts_info(st, 64, 1, st->codec->sample_rate); av_set_pts_info(st, 64, 1, st->codec->sample_rate);
@ -153,15 +153,15 @@ static int thp_read_packet(AVFormatContext *s,
/* Locate the next frame and read out its size. */ /* Locate the next frame and read out its size. */
thp->next_frame += thp->next_framesz; thp->next_frame += thp->next_framesz;
thp->next_framesz = get_be32(pb); thp->next_framesz = avio_rb32(pb);
get_be32(pb); /* Previous total size. */ avio_rb32(pb); /* Previous total size. */
size = get_be32(pb); /* Total size of this frame. */ size = avio_rb32(pb); /* Total size of this frame. */
/* Store the audiosize so the next time this function is called, /* Store the audiosize so the next time this function is called,
the audio can be read. */ the audio can be read. */
if (thp->has_audio) if (thp->has_audio)
thp->audiosize = get_be32(pb); /* Audio size. */ thp->audiosize = avio_rb32(pb); /* Audio size. */
else else
thp->frame++; thp->frame++;

14
libavformat/tiertexseq.c
View File

@ -86,7 +86,7 @@ static int seq_init_frame_buffers(SeqDemuxContext *seq, AVIOContext *pb)
url_fseek(pb, 256, SEEK_SET); url_fseek(pb, 256, SEEK_SET);
for (i = 0; i < SEQ_NUM_FRAME_BUFFERS; i++) { for (i = 0; i < SEQ_NUM_FRAME_BUFFERS; i++) {
sz = get_le16(pb); sz = avio_rl16(pb);
if (sz == 0) if (sz == 0)
break; break;
else { else {
@ -114,7 +114,7 @@ static int seq_fill_buffer(SeqDemuxContext *seq, AVIOContext *pb, int buffer_num
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
url_fseek(pb, seq->current_frame_offs + data_offs, SEEK_SET); url_fseek(pb, seq->current_frame_offs + data_offs, SEEK_SET);
if (get_buffer(pb, seq_buffer->data + seq_buffer->fill_size, data_size) != data_size) if (avio_read(pb, seq_buffer->data + seq_buffer->fill_size, data_size) != data_size)
return AVERROR(EIO); return AVERROR(EIO);
seq_buffer->fill_size += data_size; seq_buffer->fill_size += data_size;
@ -131,7 +131,7 @@ static int seq_parse_frame_data(SeqDemuxContext *seq, AVIOContext *pb)
url_fseek(pb, seq->current_frame_offs, SEEK_SET); url_fseek(pb, seq->current_frame_offs, SEEK_SET);
/* sound data */ /* sound data */
seq->current_audio_data_offs = get_le16(pb); seq->current_audio_data_offs = avio_rl16(pb);
if (seq->current_audio_data_offs) { if (seq->current_audio_data_offs) {
seq->current_audio_data_size = SEQ_AUDIO_BUFFER_SIZE * 2; seq->current_audio_data_size = SEQ_AUDIO_BUFFER_SIZE * 2;
} else { } else {
@ -139,7 +139,7 @@ static int seq_parse_frame_data(SeqDemuxContext *seq, AVIOContext *pb)
} }
/* palette data */ /* palette data */
seq->current_pal_data_offs = get_le16(pb); seq->current_pal_data_offs = avio_rl16(pb);
if (seq->current_pal_data_offs) { if (seq->current_pal_data_offs) {
seq->current_pal_data_size = 768; seq->current_pal_data_size = 768;
} else { } else {
@ -148,10 +148,10 @@ static int seq_parse_frame_data(SeqDemuxContext *seq, AVIOContext *pb)
/* video data */ /* video data */
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
buffer_num[i] = get_byte(pb); buffer_num[i] = avio_r8(pb);
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
offset_table[i] = get_le16(pb); offset_table[i] = avio_rl16(pb);
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
if (offset_table[i]) { if (offset_table[i]) {
@ -257,7 +257,7 @@ static int seq_read_packet(AVFormatContext *s, AVPacket *pkt)
if (seq->current_pal_data_size) { if (seq->current_pal_data_size) {
pkt->data[0] |= 1; pkt->data[0] |= 1;
url_fseek(pb, seq->current_frame_offs + seq->current_pal_data_offs, SEEK_SET); url_fseek(pb, seq->current_frame_offs + seq->current_pal_data_offs, SEEK_SET);
if (get_buffer(pb, &pkt->data[1], seq->current_pal_data_size) != seq->current_pal_data_size) if (avio_read(pb, &pkt->data[1], seq->current_pal_data_size) != seq->current_pal_data_size)
return AVERROR(EIO); return AVERROR(EIO);
} }
if (seq->current_video_data_size) { if (seq->current_video_data_size) {

14
libavformat/tmv.c
View File

@ -70,7 +70,7 @@ static int tmv_read_header(AVFormatContext *s, AVFormatParameters *ap)
AVRational fps; AVRational fps;
unsigned comp_method, char_cols, char_rows, features; unsigned comp_method, char_cols, char_rows, features;
if (get_le32(pb) != TMV_TAG) if (avio_rl32(pb) != TMV_TAG)
return -1; return -1;
if (!(vst = av_new_stream(s, 0))) if (!(vst = av_new_stream(s, 0)))
@ -79,30 +79,30 @@ static int tmv_read_header(AVFormatContext *s, AVFormatParameters *ap)
if (!(ast = av_new_stream(s, 0))) if (!(ast = av_new_stream(s, 0)))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ast->codec->sample_rate = get_le16(pb); ast->codec->sample_rate = avio_rl16(pb);
if (!ast->codec->sample_rate) { if (!ast->codec->sample_rate) {
av_log(s, AV_LOG_ERROR, "invalid sample rate\n"); av_log(s, AV_LOG_ERROR, "invalid sample rate\n");
return -1; return -1;
} }
tmv->audio_chunk_size = get_le16(pb); tmv->audio_chunk_size = avio_rl16(pb);
if (!tmv->audio_chunk_size) { if (!tmv->audio_chunk_size) {
av_log(s, AV_LOG_ERROR, "invalid audio chunk size\n"); av_log(s, AV_LOG_ERROR, "invalid audio chunk size\n");
return -1; return -1;
} }
comp_method = get_byte(pb); comp_method = avio_r8(pb);
if (comp_method) { if (comp_method) {
av_log(s, AV_LOG_ERROR, "unsupported compression method %d\n", av_log(s, AV_LOG_ERROR, "unsupported compression method %d\n",
comp_method); comp_method);
return -1; return -1;
} }
char_cols = get_byte(pb); char_cols = avio_r8(pb);
char_rows = get_byte(pb); char_rows = avio_r8(pb);
tmv->video_chunk_size = char_cols * char_rows * 2; tmv->video_chunk_size = char_cols * char_rows * 2;
features = get_byte(pb); features = avio_r8(pb);
if (features & ~(TMV_PADDING | TMV_STEREO)) { if (features & ~(TMV_PADDING | TMV_STEREO)) {
av_log(s, AV_LOG_ERROR, "unsupported features 0x%02x\n", av_log(s, AV_LOG_ERROR, "unsupported features 0x%02x\n",
features & ~(TMV_PADDING | TMV_STEREO)); features & ~(TMV_PADDING | TMV_STEREO));

16
libavformat/tta.c
View File

@ -47,19 +47,19 @@ static int tta_read_header(AVFormatContext *s, AVFormatParameters *ap)
ff_id3v1_read(s); ff_id3v1_read(s);
start_offset = url_ftell(s->pb); start_offset = url_ftell(s->pb);
if (get_le32(s->pb) != AV_RL32("TTA1")) if (avio_rl32(s->pb) != AV_RL32("TTA1"))
return -1; // not tta file return -1; // not tta file
url_fskip(s->pb, 2); // FIXME: flags url_fskip(s->pb, 2); // FIXME: flags
channels = get_le16(s->pb); channels = avio_rl16(s->pb);
bps = get_le16(s->pb); bps = avio_rl16(s->pb);
samplerate = get_le32(s->pb); samplerate = avio_rl32(s->pb);
if(samplerate <= 0 || samplerate > 1000000){ if(samplerate <= 0 || samplerate > 1000000){
av_log(s, AV_LOG_ERROR, "nonsense samplerate\n"); av_log(s, AV_LOG_ERROR, "nonsense samplerate\n");
return -1; return -1;
} }
datalen = get_le32(s->pb); datalen = avio_rl32(s->pb);
if(datalen < 0){ if(datalen < 0){
av_log(s, AV_LOG_ERROR, "nonsense datalen\n"); av_log(s, AV_LOG_ERROR, "nonsense datalen\n");
return -1; return -1;
@ -87,7 +87,7 @@ static int tta_read_header(AVFormatContext *s, AVFormatParameters *ap)
framepos = url_ftell(s->pb) + 4*c->totalframes + 4; framepos = url_ftell(s->pb) + 4*c->totalframes + 4;
for (i = 0; i < c->totalframes; i++) { for (i = 0; i < c->totalframes; i++) {
uint32_t size = get_le32(s->pb); uint32_t size = avio_rl32(s->pb);
av_add_index_entry(st, framepos, i*framelen, size, 0, AVINDEX_KEYFRAME); av_add_index_entry(st, framepos, i*framelen, size, 0, AVINDEX_KEYFRAME);
framepos += size; framepos += size;
} }
@ -101,13 +101,13 @@ static int tta_read_header(AVFormatContext *s, AVFormatParameters *ap)
st->codec->extradata_size = url_ftell(s->pb) - start_offset; st->codec->extradata_size = url_ftell(s->pb) - start_offset;
if(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)st->codec->extradata_size){ if(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)st->codec->extradata_size){
//this check is redundant as get_buffer should fail //this check is redundant as avio_read should fail
av_log(s, AV_LOG_ERROR, "extradata_size too large\n"); av_log(s, AV_LOG_ERROR, "extradata_size too large\n");
return -1; return -1;
} }
st->codec->extradata = av_mallocz(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE); st->codec->extradata = av_mallocz(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE);
url_fseek(s->pb, start_offset, SEEK_SET); url_fseek(s->pb, start_offset, SEEK_SET);
get_buffer(s->pb, st->codec->extradata, st->codec->extradata_size); avio_read(s->pb, st->codec->extradata, st->codec->extradata_size);
return 0; return 0;
} }

6
libavformat/tty.c
View File

@ -47,14 +47,14 @@ static int efi_read(AVFormatContext *avctx, uint64_t start_pos)
int len; int len;
url_fseek(pb, start_pos, SEEK_SET); url_fseek(pb, start_pos, SEEK_SET);
if (get_byte(pb) != 0x1A) if (avio_r8(pb) != 0x1A)
return -1; return -1;
#define GET_EFI_META(name,size) \ #define GET_EFI_META(name,size) \
len = get_byte(pb); \ len = avio_r8(pb); \
if (len < 1 || len > size) \ if (len < 1 || len > size) \
return -1; \ return -1; \
if (get_buffer(pb, buf, size) == size) { \ if (avio_read(pb, buf, size) == size) { \
buf[len] = 0; \ buf[len] = 0; \
av_metadata_set2(&avctx->metadata, name, buf, 0); \ av_metadata_set2(&avctx->metadata, name, buf, 0); \
} }

6
libavformat/txd.c
View File

@ -57,9 +57,9 @@ static int txd_read_packet(AVFormatContext *s, AVPacket *pkt) {
int ret; int ret;
next_chunk: next_chunk:
id = get_le32(pb); id = avio_rl32(pb);
chunk_size = get_le32(pb); chunk_size = avio_rl32(pb);
marker = get_le32(pb); marker = avio_rl32(pb);
if (url_feof(s->pb)) if (url_feof(s->pb))
return AVERROR_EOF; return AVERROR_EOF;

6
libavformat/utils.c
View File

@ -332,7 +332,7 @@ int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
pkt->pos= url_ftell(s); pkt->pos= url_ftell(s);
ret= get_buffer(s, pkt->data, size); ret= avio_read(s, pkt->data, size);
if(ret<=0) if(ret<=0)
av_free_packet(pkt); av_free_packet(pkt);
else else
@ -351,7 +351,7 @@ int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
ret = av_grow_packet(pkt, size); ret = av_grow_packet(pkt, size);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = get_buffer(s, pkt->data + old_size, size); ret = avio_read(s, pkt->data + old_size, size);
av_shrink_packet(pkt, old_size + FFMAX(ret, 0)); av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
return ret; return ret;
} }
@ -555,7 +555,7 @@ int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
/* read probe data */ /* read probe data */
buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE); buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
if ((ret = get_buffer(pb, buf + buf_offset, probe_size - buf_offset)) < 0) { if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
/* fail if error was not end of file, otherwise, lower score */ /* fail if error was not end of file, otherwise, lower score */
if (ret != AVERROR_EOF) { if (ret != AVERROR_EOF) {
av_free(buf); av_free(buf);

20
libavformat/vc1test.c
View File

@ -49,8 +49,8 @@ static int vc1t_read_header(AVFormatContext *s,
int frames; int frames;
uint32_t fps; uint32_t fps;
frames = get_le24(pb); frames = avio_rl24(pb);
if(get_byte(pb) != 0xC5 || get_le32(pb) != 4) if(avio_r8(pb) != 0xC5 || avio_rl32(pb) != 4)
return -1; return -1;
/* init video codec */ /* init video codec */
@ -63,13 +63,13 @@ static int vc1t_read_header(AVFormatContext *s,
st->codec->extradata = av_malloc(VC1_EXTRADATA_SIZE); st->codec->extradata = av_malloc(VC1_EXTRADATA_SIZE);
st->codec->extradata_size = VC1_EXTRADATA_SIZE; st->codec->extradata_size = VC1_EXTRADATA_SIZE;
get_buffer(pb, st->codec->extradata, VC1_EXTRADATA_SIZE); avio_read(pb, st->codec->extradata, VC1_EXTRADATA_SIZE);
st->codec->height = get_le32(pb); st->codec->height = avio_rl32(pb);
st->codec->width = get_le32(pb); st->codec->width = avio_rl32(pb);
if(get_le32(pb) != 0xC) if(avio_rl32(pb) != 0xC)
return -1; return -1;
url_fskip(pb, 8); url_fskip(pb, 8);
fps = get_le32(pb); fps = avio_rl32(pb);
if(fps == 0xFFFFFFFF) if(fps == 0xFFFFFFFF)
av_set_pts_info(st, 32, 1, 1000); av_set_pts_info(st, 32, 1, 1000);
else{ else{
@ -95,10 +95,10 @@ static int vc1t_read_packet(AVFormatContext *s,
if(url_feof(pb)) if(url_feof(pb))
return AVERROR(EIO); return AVERROR(EIO);
frame_size = get_le24(pb); frame_size = avio_rl24(pb);
if(get_byte(pb) & 0x80) if(avio_r8(pb) & 0x80)
keyframe = 1; keyframe = 1;
pts = get_le32(pb); pts = avio_rl32(pb);
if(av_get_packet(pb, pkt, frame_size) < 0) if(av_get_packet(pb, pkt, frame_size) < 0)
return AVERROR(EIO); return AVERROR(EIO);
if(s->streams[0]->time_base.den == 1000) if(s->streams[0]->time_base.den == 1000)

24
libavformat/vocdec.c
View File

@ -46,7 +46,7 @@ static int voc_read_header(AVFormatContext *s, AVFormatParameters *ap)
AVStream *st; AVStream *st;
url_fskip(pb, 20); url_fskip(pb, 20);
header_size = get_le16(pb) - 22; header_size = avio_rl16(pb) - 22;
if (header_size != 4) { if (header_size != 4) {
av_log(s, AV_LOG_ERROR, "unknown header size: %d\n", header_size); av_log(s, AV_LOG_ERROR, "unknown header size: %d\n", header_size);
return AVERROR(ENOSYS); return AVERROR(ENOSYS);
@ -73,10 +73,10 @@ voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
int channels = 1; int channels = 1;
while (!voc->remaining_size) { while (!voc->remaining_size) {
type = get_byte(pb); type = avio_r8(pb);
if (type == VOC_TYPE_EOF) if (type == VOC_TYPE_EOF)
return AVERROR(EIO); return AVERROR(EIO);
voc->remaining_size = get_le24(pb); voc->remaining_size = avio_rl24(pb);
if (!voc->remaining_size) { if (!voc->remaining_size) {
if (url_is_streamed(s->pb)) if (url_is_streamed(s->pb))
return AVERROR(EIO); return AVERROR(EIO);
@ -86,11 +86,11 @@ voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
switch (type) { switch (type) {
case VOC_TYPE_VOICE_DATA: case VOC_TYPE_VOICE_DATA:
dec->sample_rate = 1000000 / (256 - get_byte(pb)); dec->sample_rate = 1000000 / (256 - avio_r8(pb));
if (sample_rate) if (sample_rate)
dec->sample_rate = sample_rate; dec->sample_rate = sample_rate;
dec->channels = channels; dec->channels = channels;
tmp_codec = get_byte(pb); tmp_codec = avio_r8(pb);
dec->bits_per_coded_sample = av_get_bits_per_sample(dec->codec_id); dec->bits_per_coded_sample = av_get_bits_per_sample(dec->codec_id);
voc->remaining_size -= 2; voc->remaining_size -= 2;
max_size -= 2; max_size -= 2;
@ -101,19 +101,19 @@ voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
break; break;
case VOC_TYPE_EXTENDED: case VOC_TYPE_EXTENDED:
sample_rate = get_le16(pb); sample_rate = avio_rl16(pb);
get_byte(pb); avio_r8(pb);
channels = get_byte(pb) + 1; channels = avio_r8(pb) + 1;
sample_rate = 256000000 / (channels * (65536 - sample_rate)); sample_rate = 256000000 / (channels * (65536 - sample_rate));
voc->remaining_size = 0; voc->remaining_size = 0;
max_size -= 4; max_size -= 4;
break; break;
case VOC_TYPE_NEW_VOICE_DATA: case VOC_TYPE_NEW_VOICE_DATA:
dec->sample_rate = get_le32(pb); dec->sample_rate = avio_rl32(pb);
dec->bits_per_coded_sample = get_byte(pb); dec->bits_per_coded_sample = avio_r8(pb);
dec->channels = get_byte(pb); dec->channels = avio_r8(pb);
tmp_codec = get_le16(pb); tmp_codec = avio_rl16(pb);
url_fskip(pb, 4); url_fskip(pb, 4);
voc->remaining_size -= 12; voc->remaining_size -= 12;
max_size -= 12; max_size -= 12;

16
libavformat/vqf.c
View File

@ -54,7 +54,7 @@ static void add_metadata(AVFormatContext *s, const char *tag,
buf = av_malloc(len+1); buf = av_malloc(len+1);
if (!buf) if (!buf)
return; return;
get_buffer(s->pb, buf, len); avio_read(s->pb, buf, len);
buf[len] = 0; buf[len] = 0;
av_metadata_set2(&s->metadata, tag, buf, AV_METADATA_DONT_STRDUP_VAL); av_metadata_set2(&s->metadata, tag, buf, AV_METADATA_DONT_STRDUP_VAL);
} }
@ -74,7 +74,7 @@ static int vqf_read_header(AVFormatContext *s, AVFormatParameters *ap)
url_fskip(s->pb, 12); url_fskip(s->pb, 12);
header_size = get_be32(s->pb); header_size = avio_rb32(s->pb);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_TWINVQ; st->codec->codec_id = CODEC_ID_TWINVQ;
@ -82,12 +82,12 @@ static int vqf_read_header(AVFormatContext *s, AVFormatParameters *ap)
do { do {
int len; int len;
chunk_tag = get_le32(s->pb); chunk_tag = avio_rl32(s->pb);
if (chunk_tag == MKTAG('D','A','T','A')) if (chunk_tag == MKTAG('D','A','T','A'))
break; break;
len = get_be32(s->pb); len = avio_rb32(s->pb);
if ((unsigned) len > INT_MAX/2) { if ((unsigned) len > INT_MAX/2) {
av_log(s, AV_LOG_ERROR, "Malformed header\n"); av_log(s, AV_LOG_ERROR, "Malformed header\n");
@ -98,9 +98,9 @@ static int vqf_read_header(AVFormatContext *s, AVFormatParameters *ap)
switch(chunk_tag){ switch(chunk_tag){
case MKTAG('C','O','M','M'): case MKTAG('C','O','M','M'):
st->codec->channels = get_be32(s->pb) + 1; st->codec->channels = avio_rb32(s->pb) + 1;
read_bitrate = get_be32(s->pb); read_bitrate = avio_rb32(s->pb);
rate_flag = get_be32(s->pb); rate_flag = avio_rb32(s->pb);
url_fskip(s->pb, len-12); url_fskip(s->pb, len-12);
st->codec->bit_rate = read_bitrate*1000; st->codec->bit_rate = read_bitrate*1000;
@ -208,7 +208,7 @@ static int vqf_read_packet(AVFormatContext *s, AVPacket *pkt)
pkt->data[0] = 8 - c->remaining_bits; // Number of bits to skip pkt->data[0] = 8 - c->remaining_bits; // Number of bits to skip
pkt->data[1] = c->last_frame_bits; pkt->data[1] = c->last_frame_bits;
ret = get_buffer(s->pb, pkt->data+2, size); ret = avio_read(s->pb, pkt->data+2, size);
if (ret<=0) { if (ret<=0) {
av_free_packet(pkt); av_free_packet(pkt);

32
libavformat/wav.c
View File

@ -143,8 +143,8 @@ AVOutputFormat ff_wav_muxer = {
static int64_t next_tag(AVIOContext *pb, unsigned int *tag) static int64_t next_tag(AVIOContext *pb, unsigned int *tag)
{ {
*tag = get_le32(pb); *tag = avio_rl32(pb);
return get_le32(pb); return avio_rl32(pb);
} }
/* return the size of the found tag */ /* return the size of the found tag */
@ -197,25 +197,25 @@ static int wav_read_header(AVFormatContext *s,
WAVContext *wav = s->priv_data; WAVContext *wav = s->priv_data;
/* check RIFF header */ /* check RIFF header */
tag = get_le32(pb); tag = avio_rl32(pb);
rf64 = tag == MKTAG('R', 'F', '6', '4'); rf64 = tag == MKTAG('R', 'F', '6', '4');
if (!rf64 && tag != MKTAG('R', 'I', 'F', 'F')) if (!rf64 && tag != MKTAG('R', 'I', 'F', 'F'))
return -1; return -1;
get_le32(pb); /* file size */ avio_rl32(pb); /* file size */
tag = get_le32(pb); tag = avio_rl32(pb);
if (tag != MKTAG('W', 'A', 'V', 'E')) if (tag != MKTAG('W', 'A', 'V', 'E'))
return -1; return -1;
if (rf64) { if (rf64) {
if (get_le32(pb) != MKTAG('d', 's', '6', '4')) if (avio_rl32(pb) != MKTAG('d', 's', '6', '4'))
return -1; return -1;
size = get_le32(pb); size = avio_rl32(pb);
if (size < 16) if (size < 16)
return -1; return -1;
get_le64(pb); /* RIFF size */ avio_rl64(pb); /* RIFF size */
data_size = get_le64(pb); data_size = avio_rl64(pb);
sample_count = get_le64(pb); sample_count = avio_rl64(pb);
url_fskip(pb, size - 16); /* skip rest of ds64 chunk */ url_fskip(pb, size - 16); /* skip rest of ds64 chunk */
} }
@ -239,7 +239,7 @@ static int wav_read_header(AVFormatContext *s,
if (tag == MKTAG('d', 'a', 't', 'a')){ if (tag == MKTAG('d', 'a', 't', 'a')){
break; break;
}else if (tag == MKTAG('f','a','c','t') && !sample_count){ }else if (tag == MKTAG('f','a','c','t') && !sample_count){
sample_count = get_le32(pb); sample_count = avio_rl32(pb);
size -= 4; size -= 4;
} }
url_fseek(pb, size, SEEK_CUR); url_fseek(pb, size, SEEK_CUR);
@ -269,8 +269,8 @@ static int64_t find_guid(AVIOContext *pb, const uint8_t guid1[16])
int64_t size; int64_t size;
while (!url_feof(pb)) { while (!url_feof(pb)) {
get_buffer(pb, guid, 16); avio_read(pb, guid, 16);
size = get_le64(pb); size = avio_rl64(pb);
if (size <= 24) if (size <= 24)
return -1; return -1;
if (!memcmp(guid, guid1, 16)) if (!memcmp(guid, guid1, 16))
@ -384,14 +384,14 @@ static int w64_read_header(AVFormatContext *s, AVFormatParameters *ap)
AVStream *st; AVStream *st;
uint8_t guid[16]; uint8_t guid[16];
get_buffer(pb, guid, 16); avio_read(pb, guid, 16);
if (memcmp(guid, guid_riff, 16)) if (memcmp(guid, guid_riff, 16))
return -1; return -1;
if (get_le64(pb) < 16 + 8 + 16 + 8 + 16 + 8) /* riff + wave + fmt + sizes */ if (avio_rl64(pb) < 16 + 8 + 16 + 8 + 16 + 8) /* riff + wave + fmt + sizes */
return -1; return -1;
get_buffer(pb, guid, 16); avio_read(pb, guid, 16);
if (memcmp(guid, guid_wave, 16)) { if (memcmp(guid, guid_wave, 16)) {
av_log(s, AV_LOG_ERROR, "could not find wave guid\n"); av_log(s, AV_LOG_ERROR, "could not find wave guid\n");
return -1; return -1;

Some files were not shown because too many files have changed in this diff Show More