sigrid/ffmpeg

libavformat/4xm.c+9−9

@@ -54,11 +54,11 @@ · 53 unmodified lines
54	#define strk_SIZE 0x28	54	#define strk_SIZE 0x28
55		55
56	#define GET_LIST_HEADER() \	56	#define GET_LIST_HEADER() \
57	fourcc_tag = get_le32(pb); \	57	fourcc_tag = avio_rl32(pb); \
58	size = get_le32(pb); \	58	size = avio_rl32(pb); \
59	if (fourcc_tag != LIST_TAG) \	59	if (fourcc_tag != LIST_TAG) \
60	return AVERROR_INVALIDDATA; \	60	return AVERROR_INVALIDDATA; \
61	fourcc_tag = get_le32(pb);	61	fourcc_tag = avio_rl32(pb);
62		62
63	typedef struct AudioTrack {	63	typedef struct AudioTrack {
64	int sample_rate;	64	int sample_rate;
@@ -118,7 +118,7 @@ static int fourxm_read_header(AVFormatContext *s, · 53 unmodified lines
118	header = av_malloc(header_size);	118	header = av_malloc(header_size);
119	if (!header)	119	if (!header)
120	return AVERROR(ENOMEM);	120	return AVERROR(ENOMEM);
121	if (get_buffer(pb, header, header_size) != header_size){	121	if (avio_read(pb, header, header_size) != header_size){
122	av_free(header);	122	av_free(header);
123	return AVERROR(EIO);	123	return AVERROR(EIO);
124	}	124	}
@@ -255,7 +255,7 @@ static int fourxm_read_packet(AVFormatContext *s, · 130 unmodified lines
255		255
256	while (!packet_read) {	256	while (!packet_read) {
257		257
258	if ((ret = get_buffer(s->pb, header, 8)) < 0)	258	if ((ret = avio_read(s->pb, header, 8)) < 0)
259	return ret;	259	return ret;
260	fourcc_tag = AV_RL32(&header[0]);	260	fourcc_tag = AV_RL32(&header[0]);
261	size = AV_RL32(&header[4]);	261	size = AV_RL32(&header[4]);
@@ -268,7 +268,7 @@ static int fourxm_read_packet(AVFormatContext *s, · 6 unmodified lines
268	fourxm->video_pts ++;	268	fourxm->video_pts ++;
269		269
270	/* skip the LIST-* tag and move on to the next fourcc */	270	/* skip the LIST-* tag and move on to the next fourcc */
271	get_le32(pb);	271	avio_rl32(pb);
272	break;	272	break;
273		273
274	case ifrm_TAG:	274	case ifrm_TAG:
@@ -285,7 +285,7 @@ static int fourxm_read_packet(AVFormatContext *s, · 10 unmodified lines
285	pkt->pts = fourxm->video_pts;	285	pkt->pts = fourxm->video_pts;
286	pkt->pos = url_ftell(s->pb);	286	pkt->pos = url_ftell(s->pb);
287	memcpy(pkt->data, header, 8);	287	memcpy(pkt->data, header, 8);
288	ret = get_buffer(s->pb, &pkt->data[8], size);	288	ret = avio_read(s->pb, &pkt->data[8], size);
289		289
290	if (ret < 0){	290	if (ret < 0){
291	av_free_packet(pkt);	291	av_free_packet(pkt);
@@ -294,8 +294,8 @@ static int fourxm_read_packet(AVFormatContext *s, · 2 unmodified lines
294	break;	294	break;
295		295
296	case snd__TAG:	296	case snd__TAG:
297	track_number = get_le32(pb);	297	track_number = avio_rl32(pb);
298	out_size= get_le32(pb);	298	out_size= avio_rl32(pb);
299	size-=8;	299	size-=8;
300		300
301	if (track_number < fourxm->track_count && fourxm->tracks[track_number].channels>0) {	301	if (track_number < fourxm->track_count && fourxm->tracks[track_number].channels>0) {

libavformat/aea.c+1−1

@@ -63,7 +63,7 @@ static int aea_read_header(AVFormatContext *s, · 62 unmodified lines
63		63
64	/* Parse the amount of channels and skip to pos 2048(0x800) */	64	/* Parse the amount of channels and skip to pos 2048(0x800) */
65	url_fskip(s->pb, 264);	65	url_fskip(s->pb, 264);
66	st->codec->channels = get_byte(s->pb);	66	st->codec->channels = avio_r8(s->pb);
67	url_fskip(s->pb, 1783);	67	url_fskip(s->pb, 1783);
68		68
69		69

libavformat/aiffdec.c+13−13

@@ -54,8 +54,8 @@ static int get_tag(AVIOContext pb, uint32_t tag) · 53 unmodified lines
54	if (url_feof(pb))	54	if (url_feof(pb))
55	return AVERROR(EIO);	55	return AVERROR(EIO);
56		56
57	*tag = get_le32(pb);	57	*tag = avio_rl32(pb);
58	size = get_be32(pb);	58	size = avio_rb32(pb);
59		59
60	if (size < 0)	60	if (size < 0)
61	size = 0x7fffffff;	61	size = 0x7fffffff;
@@ -74,7 +74,7 @@ static void get_meta(AVFormatContext s, const char key, int size) · 12 unmodified lines
74	return;	74	return;
75	}	75	}
76		76
77	res = get_buffer(s->pb, str, size);	77	res = avio_read(s->pb, str, size);
78	if (res < 0)	78	if (res < 0)
79	return;	79	return;
80		80
@@ -93,18 +93,18 @@ static unsigned int get_aiff_header(AVIOContext pb, AVCodecContext codec, · 12 unmodified lines
93	if (size & 1)	93	if (size & 1)
94	size++;	94	size++;
95	codec->codec_type = AVMEDIA_TYPE_AUDIO;	95	codec->codec_type = AVMEDIA_TYPE_AUDIO;
96	codec->channels = get_be16(pb);	96	codec->channels = avio_rb16(pb);
97	num_frames = get_be32(pb);	97	num_frames = avio_rb32(pb);
98	codec->bits_per_coded_sample = get_be16(pb);	98	codec->bits_per_coded_sample = avio_rb16(pb);
99		99
100	get_buffer(pb, (uint8_t)&ext, sizeof(ext));/ Sample rate is in */	100	avio_read(pb, (uint8_t)&ext, sizeof(ext));/ Sample rate is in */
101	sample_rate = av_ext2dbl(ext); /* 80 bits BE IEEE extended float */	101	sample_rate = av_ext2dbl(ext); /* 80 bits BE IEEE extended float */
102	codec->sample_rate = sample_rate;	102	codec->sample_rate = sample_rate;
103	size -= 18;	103	size -= 18;
104		104
105	/* Got an AIFF-C? */	105	/* Got an AIFF-C? */
106	if (version == AIFF_C_VERSION1) {	106	if (version == AIFF_C_VERSION1) {
107	codec->codec_tag = get_le32(pb);	107	codec->codec_tag = avio_rl32(pb);
108	codec->codec_id = ff_codec_get_id(ff_codec_aiff_tags, codec->codec_tag);	108	codec->codec_id = ff_codec_get_id(ff_codec_aiff_tags, codec->codec_tag);
109		109
110	switch (codec->codec_id) {	110	switch (codec->codec_id) {
@@ -187,7 +187,7 @@ static int aiff_read_header(AVFormatContext *s, · 76 unmodified lines
187	return AVERROR_INVALIDDATA;	187	return AVERROR_INVALIDDATA;
188		188
189	/* AIFF data type */	189	/* AIFF data type */
190	tag = get_le32(pb);	190	tag = avio_rl32(pb);
191	if (tag == MKTAG('A', 'I', 'F', 'F')) /* Got an AIFF file */	191	if (tag == MKTAG('A', 'I', 'F', 'F')) /* Got an AIFF file */
192	version = AIFF;	192	version = AIFF;
193	else if (tag != MKTAG('A', 'I', 'F', 'C')) /* An AIFF-C file then */	193	else if (tag != MKTAG('A', 'I', 'F', 'C')) /* An AIFF-C file then */
@@ -217,7 +217,7 @@ static int aiff_read_header(AVFormatContext *s, · 23 unmodified lines
217	goto got_sound;	217	goto got_sound;
218	break;	218	break;
219	case MKTAG('F', 'V', 'E', 'R'): /* Version chunk */	219	case MKTAG('F', 'V', 'E', 'R'): /* Version chunk */
220	version = get_be32(pb);	220	version = avio_rb32(pb);
221	break;	221	break;
222	case MKTAG('N', 'A', 'M', 'E'): /* Sample name chunk */	222	case MKTAG('N', 'A', 'M', 'E'): /* Sample name chunk */
223	get_meta(s, "title" , size);	223	get_meta(s, "title" , size);
@@ -233,8 +233,8 @@ static int aiff_read_header(AVFormatContext *s, · 9 unmodified lines
233	break;	233	break;
234	case MKTAG('S', 'S', 'N', 'D'): /* Sampled sound chunk */	234	case MKTAG('S', 'S', 'N', 'D'): /* Sampled sound chunk */
235	aiff->data_end = url_ftell(pb) + size;	235	aiff->data_end = url_ftell(pb) + size;
236	offset = get_be32(pb); /* Offset of sound data */	236	offset = avio_rb32(pb); /* Offset of sound data */
237	get_be32(pb); /* BlockSize... don't care */	237	avio_rb32(pb); /* BlockSize... don't care */
238	offset += url_ftell(pb); /* Compute absolute data offset */	238	offset += url_ftell(pb); /* Compute absolute data offset */
239	if (st->codec->block_align) /* Assume COMM already parsed */	239	if (st->codec->block_align) /* Assume COMM already parsed */
240	goto got_sound;	240	goto got_sound;
@@ -251,7 +251,7 @@ static int aiff_read_header(AVFormatContext *s, · 10 unmodified lines
251	if (!st->codec->extradata)	251	if (!st->codec->extradata)
252	return AVERROR(ENOMEM);	252	return AVERROR(ENOMEM);
253	st->codec->extradata_size = size;	253	st->codec->extradata_size = size;
254	get_buffer(pb, st->codec->extradata, size);	254	avio_read(pb, st->codec->extradata, size);
255	break;	255	break;
256	default: /* Jump */	256	default: /* Jump */
257	if (size & 1) /* Always even aligned */	257	if (size & 1) /* Always even aligned */

libavformat/amr.c+4−4

@@ -82,7 +82,7 @@ static int amr_read_header(AVFormatContext *s, · 81 unmodified lines
82	AVStream *st;	82	AVStream *st;
83	uint8_t header[9];	83	uint8_t header[9];
84		84
85	get_buffer(pb, header, 6);	85	avio_read(pb, header, 6);
86		86
87	st = av_new_stream(s, 0);	87	st = av_new_stream(s, 0);
88	if (!st)	88	if (!st)
@@ -91,7 +91,7 @@ static int amr_read_header(AVFormatContext *s, · 2 unmodified lines
91	}	91	}
92	if(memcmp(header,AMR_header,6)!=0)	92	if(memcmp(header,AMR_header,6)!=0)
93	{	93	{
94	get_buffer(pb, header+6, 3);	94	avio_read(pb, header+6, 3);
95	if(memcmp(header,AMRWB_header,9)!=0)	95	if(memcmp(header,AMRWB_header,9)!=0)
96	{	96	{
97	return -1;	97	return -1;
@@ -128,7 +128,7 @@ static int amr_read_packet(AVFormatContext *s, · 30 unmodified lines
128	}	128	}
129		129
130	//FIXME this is wrong, this should rather be in a AVParset	130	//FIXME this is wrong, this should rather be in a AVParset
131	toc=get_byte(s->pb);	131	toc=avio_r8(s->pb);
132	mode = (toc >> 3) & 0x0F;	132	mode = (toc >> 3) & 0x0F;
133		133
134	if (enc->codec_id == CODEC_ID_AMR_NB)	134	if (enc->codec_id == CODEC_ID_AMR_NB)
@@ -157,7 +157,7 @@ static int amr_read_packet(AVFormatContext *s, · 22 unmodified lines
157	pkt->pos= url_ftell(s->pb);	157	pkt->pos= url_ftell(s->pb);
158	pkt->data[0]=toc;	158	pkt->data[0]=toc;
159	pkt->duration= enc->codec_id == CODEC_ID_AMR_NB ? 160 : 320;	159	pkt->duration= enc->codec_id == CODEC_ID_AMR_NB ? 160 : 320;
160	read = get_buffer(s->pb, pkt->data+1, size-1);	160	read = avio_read(s->pb, pkt->data+1, size-1);
161		161
162	if (read != size-1)	162	if (read != size-1)
163	{	163	{

libavformat/anm.c+19−19

@@ -84,16 +84,16 @@ static int read_header(AVFormatContext *s, · 83 unmodified lines
84	int i, ret;	84	int i, ret;
85		85
86	url_fskip(pb, 4); /* magic number */	86	url_fskip(pb, 4); /* magic number */
87	if (get_le16(pb) != MAX_PAGES) {	87	if (avio_rl16(pb) != MAX_PAGES) {
88	av_log_ask_for_sample(s, "max_pages != " AV_STRINGIFY(MAX_PAGES) "\n");	88	av_log_ask_for_sample(s, "max_pages != " AV_STRINGIFY(MAX_PAGES) "\n");
89	return AVERROR_INVALIDDATA;	89	return AVERROR_INVALIDDATA;
90	}	90	}
91		91
92	anm->nb_pages = get_le16(pb);	92	anm->nb_pages = avio_rl16(pb);
93	anm->nb_records = get_le32(pb);	93	anm->nb_records = avio_rl32(pb);
94	url_fskip(pb, 2); /* max records per page */	94	url_fskip(pb, 2); /* max records per page */
95	anm->page_table_offset = get_le16(pb);	95	anm->page_table_offset = avio_rl16(pb);
96	if (get_le32(pb) != ANIM_TAG)	96	if (avio_rl32(pb) != ANIM_TAG)
97	return AVERROR_INVALIDDATA;	97	return AVERROR_INVALIDDATA;
98		98
99	/* video stream */	99	/* video stream */
@@ -103,32 +103,32 @@ static int read_header(AVFormatContext *s, · 3 unmodified lines
103	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;	103	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
104	st->codec->codec_id = CODEC_ID_ANM;	104	st->codec->codec_id = CODEC_ID_ANM;
105	st->codec->codec_tag = 0; /* no fourcc */	105	st->codec->codec_tag = 0; /* no fourcc */
106	st->codec->width = get_le16(pb);	106	st->codec->width = avio_rl16(pb);
107	st->codec->height = get_le16(pb);	107	st->codec->height = avio_rl16(pb);
108	if (get_byte(pb) != 0)	108	if (avio_r8(pb) != 0)
109	goto invalid;	109	goto invalid;
110	url_fskip(pb, 1); /* frame rate multiplier info */	110	url_fskip(pb, 1); /* frame rate multiplier info */
111		111
112	/* ignore last delta record (used for looping) */	112	/* ignore last delta record (used for looping) */
113	if (get_byte(pb)) /* has_last_delta */	113	if (avio_r8(pb)) /* has_last_delta */
114	anm->nb_records = FFMAX(anm->nb_records - 1, 0);	114	anm->nb_records = FFMAX(anm->nb_records - 1, 0);
115		115
116	url_fskip(pb, 1); /* last_delta_valid */	116	url_fskip(pb, 1); /* last_delta_valid */
117		117
118	if (get_byte(pb) != 0)	118	if (avio_r8(pb) != 0)
119	goto invalid;	119	goto invalid;
120		120
121	if (get_byte(pb) != 1)	121	if (avio_r8(pb) != 1)
122	goto invalid;	122	goto invalid;
123		123
124	url_fskip(pb, 1); /* other recs per frame */	124	url_fskip(pb, 1); /* other recs per frame */
125		125
126	if (get_byte(pb) != 1)	126	if (avio_r8(pb) != 1)
127	goto invalid;	127	goto invalid;
128		128
129	url_fskip(pb, 32); /* record_types */	129	url_fskip(pb, 32); /* record_types */
130	st->nb_frames = get_le32(pb);	130	st->nb_frames = avio_rl32(pb);
131	av_set_pts_info(st, 64, 1, get_le16(pb));	131	av_set_pts_info(st, 64, 1, avio_rl16(pb));
132	url_fskip(pb, 58);	132	url_fskip(pb, 58);
133		133
134	/* color cycling and palette data */	134	/* color cycling and palette data */
@@ -138,7 +138,7 @@ static int read_header(AVFormatContext *s, · 3 unmodified lines
138	ret = AVERROR(ENOMEM);	138	ret = AVERROR(ENOMEM);
139	goto close_and_return;	139	goto close_and_return;
140	}	140	}
141	ret = get_buffer(pb, st->codec->extradata, st->codec->extradata_size);	141	ret = avio_read(pb, st->codec->extradata, st->codec->extradata_size);
142	if (ret < 0)	142	if (ret < 0)
143	goto close_and_return;	143	goto close_and_return;
144		144
@@ -149,9 +149,9 @@ static int read_header(AVFormatContext *s, · 4 unmodified lines
149		149
150	for (i = 0; i < MAX_PAGES; i++) {	150	for (i = 0; i < MAX_PAGES; i++) {
151	Page *p = &anm->pt[i];	151	Page *p = &anm->pt[i];
152	p->base_record = get_le16(pb);	152	p->base_record = avio_rl16(pb);
153	p->nb_records = get_le16(pb);	153	p->nb_records = avio_rl16(pb);
154	p->size = get_le16(pb);	154	p->size = avio_rl16(pb);
155	}	155	}
156		156
157	/* find page of first frame */	157	/* find page of first frame */
@@ -211,7 +211,7 @@ repeat: · 53 unmodified lines
211	tmp = url_ftell(pb);	211	tmp = url_ftell(pb);
212	url_fseek(pb, anm->page_table_offset + MAX_PAGES*6 + (anm->page<<16) +	212	url_fseek(pb, anm->page_table_offset + MAX_PAGES*6 + (anm->page<<16) +
213	8 + anm->record * 2, SEEK_SET);	213	8 + anm->record * 2, SEEK_SET);
214	record_size = get_le16(pb);	214	record_size = avio_rl16(pb);
215	url_fseek(pb, tmp, SEEK_SET);	215	url_fseek(pb, tmp, SEEK_SET);
216		216
217	/* fetch record */	217	/* fetch record */

libavformat/apc.c+7−7

@@ -35,9 +35,9 @@ static int apc_read_header(AVFormatContext s, AVFormatParameters ap) · 34 unmodified lines
35	AVIOContext *pb = s->pb;	35	AVIOContext *pb = s->pb;
36	AVStream *st;	36	AVStream *st;
37		37
38	get_le32(pb); /* CRYO */	38	avio_rl32(pb); /* CRYO */
39	get_le32(pb); /* _APC */	39	avio_rl32(pb); /* _APC */
40	get_le32(pb); /* 1.20 */	40	avio_rl32(pb); /* 1.20 */
41		41
42	st = av_new_stream(s, 0);	42	st = av_new_stream(s, 0);
43	if (!st)	43	if (!st)
@@ -46,8 +46,8 @@ static int apc_read_header(AVFormatContext s, AVFormatParameters ap) · 2 unmodified lines
46	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;	46	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
47	st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;	47	st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;
48		48
49	get_le32(pb); /* number of samples */	49	avio_rl32(pb); /* number of samples */
50	st->codec->sample_rate = get_le32(pb);	50	st->codec->sample_rate = avio_rl32(pb);
51		51
52	st->codec->extradata_size = 2 * 4;	52	st->codec->extradata_size = 2 * 4;
53	st->codec->extradata = av_malloc(st->codec->extradata_size +	53	st->codec->extradata = av_malloc(st->codec->extradata_size +
@@ -56,10 +56,10 @@ static int apc_read_header(AVFormatContext s, AVFormatParameters ap) · 2 unmodified lines
56	return AVERROR(ENOMEM);	56	return AVERROR(ENOMEM);
57		57
58	/* initial predictor values for adpcm decoder */	58	/* initial predictor values for adpcm decoder */
59	get_buffer(pb, st->codec->extradata, 2 * 4);	59	avio_read(pb, st->codec->extradata, 2 * 4);
60		60
61	st->codec->channels = 1;	61	st->codec->channels = 1;
62	if (get_le32(pb))	62	if (avio_rl32(pb))
63	st->codec->channels = 2;	63	st->codec->channels = 2;
64		64
65	st->codec->bits_per_coded_sample = 4;	65	st->codec->bits_per_coded_sample = 4;

libavformat/ape.c+30−30

@@ -162,11 +162,11 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap) · 161 unmodified lines
162	/* TODO: Skip any leading junk such as id3v2 tags */	162	/* TODO: Skip any leading junk such as id3v2 tags */
163	ape->junklength = 0;	163	ape->junklength = 0;
164		164
165	tag = get_le32(pb);	165	tag = avio_rl32(pb);
166	if (tag != MKTAG('M', 'A', 'C', ' '))	166	if (tag != MKTAG('M', 'A', 'C', ' '))
167	return -1;	167	return -1;
168		168
169	ape->fileversion = get_le16(pb);	169	ape->fileversion = avio_rl16(pb);
170		170
171	if (ape->fileversion < APE_MIN_VERSION \|\| ape->fileversion > APE_MAX_VERSION) {	171	if (ape->fileversion < APE_MIN_VERSION \|\| ape->fileversion > APE_MAX_VERSION) {
172	av_log(s, AV_LOG_ERROR, "Unsupported file version - %d.%02d\n", ape->fileversion / 1000, (ape->fileversion % 1000) / 10);	172	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) · 1 unmodified line
174	}	174	}
175		175
176	if (ape->fileversion >= 3980) {	176	if (ape->fileversion >= 3980) {
177	ape->padding1 = get_le16(pb);	177	ape->padding1 = avio_rl16(pb);
178	ape->descriptorlength = get_le32(pb);	178	ape->descriptorlength = avio_rl32(pb);
179	ape->headerlength = get_le32(pb);	179	ape->headerlength = avio_rl32(pb);
180	ape->seektablelength = get_le32(pb);	180	ape->seektablelength = avio_rl32(pb);
181	ape->wavheaderlength = get_le32(pb);	181	ape->wavheaderlength = avio_rl32(pb);
182	ape->audiodatalength = get_le32(pb);	182	ape->audiodatalength = avio_rl32(pb);
183	ape->audiodatalength_high = get_le32(pb);	183	ape->audiodatalength_high = avio_rl32(pb);
184	ape->wavtaillength = get_le32(pb);	184	ape->wavtaillength = avio_rl32(pb);
185	get_buffer(pb, ape->md5, 16);	185	avio_read(pb, ape->md5, 16);
186		186
187	/* Skip any unknown bytes at the end of the descriptor.	187	/* Skip any unknown bytes at the end of the descriptor.
188	This is for future compatibility */	188	This is for future compatibility */
@@ -190,26 +190,26 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap) · 1 unmodified line
190	url_fseek(pb, ape->descriptorlength - 52, SEEK_CUR);	190	url_fseek(pb, ape->descriptorlength - 52, SEEK_CUR);
191		191
192	/* Read header data */	192	/* Read header data */
193	ape->compressiontype = get_le16(pb);	193	ape->compressiontype = avio_rl16(pb);
194	ape->formatflags = get_le16(pb);	194	ape->formatflags = avio_rl16(pb);
195	ape->blocksperframe = get_le32(pb);	195	ape->blocksperframe = avio_rl32(pb);
196	ape->finalframeblocks = get_le32(pb);	196	ape->finalframeblocks = avio_rl32(pb);
197	ape->totalframes = get_le32(pb);	197	ape->totalframes = avio_rl32(pb);
198	ape->bps = get_le16(pb);	198	ape->bps = avio_rl16(pb);
199	ape->channels = get_le16(pb);	199	ape->channels = avio_rl16(pb);
200	ape->samplerate = get_le32(pb);	200	ape->samplerate = avio_rl32(pb);
201	} else {	201	} else {
202	ape->descriptorlength = 0;	202	ape->descriptorlength = 0;
203	ape->headerlength = 32;	203	ape->headerlength = 32;
204		204
205	ape->compressiontype = get_le16(pb);	205	ape->compressiontype = avio_rl16(pb);
206	ape->formatflags = get_le16(pb);	206	ape->formatflags = avio_rl16(pb);
207	ape->channels = get_le16(pb);	207	ape->channels = avio_rl16(pb);
208	ape->samplerate = get_le32(pb);	208	ape->samplerate = avio_rl32(pb);
209	ape->wavheaderlength = get_le32(pb);	209	ape->wavheaderlength = avio_rl32(pb);
210	ape->wavtaillength = get_le32(pb);	210	ape->wavtaillength = avio_rl32(pb);
211	ape->totalframes = get_le32(pb);	211	ape->totalframes = avio_rl32(pb);
212	ape->finalframeblocks = get_le32(pb);	212	ape->finalframeblocks = avio_rl32(pb);
213		213
214	if (ape->formatflags & MAC_FORMAT_FLAG_HAS_PEAK_LEVEL) {	214	if (ape->formatflags & MAC_FORMAT_FLAG_HAS_PEAK_LEVEL) {
215	url_fseek(pb, 4, SEEK_CUR); /* Skip the peak level */	215	url_fseek(pb, 4, SEEK_CUR); /* Skip the peak level */
@@ -217,7 +217,7 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap) · 1 unmodified line
217	}	217	}
218		218
219	if (ape->formatflags & MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS) {	219	if (ape->formatflags & MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS) {
220	ape->seektablelength = get_le32(pb);	220	ape->seektablelength = avio_rl32(pb);
221	ape->headerlength += 4;	221	ape->headerlength += 4;
222	ape->seektablelength *= sizeof(int32_t);	222	ape->seektablelength *= sizeof(int32_t);
223	} else	223	} else
@@ -260,7 +260,7 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap) · 36 unmodified lines
260	if (ape->seektablelength > 0) {	260	if (ape->seektablelength > 0) {
261	ape->seektable = av_malloc(ape->seektablelength);	261	ape->seektable = av_malloc(ape->seektablelength);
262	for (i = 0; i < ape->seektablelength / sizeof(uint32_t); i++)	262	for (i = 0; i < ape->seektablelength / sizeof(uint32_t); i++)
263	ape->seektable[i] = get_le32(pb);	263	ape->seektable[i] = avio_rl32(pb);
264	}	264	}
265		265
266	ape->frames[0].pos = ape->firstframe;	266	ape->frames[0].pos = ape->firstframe;
@@ -355,7 +355,7 @@ static int ape_read_packet(AVFormatContext * s, AVPacket * pkt) · 88 unmodified lines
355		355
356	AV_WL32(pkt->data , nblocks);	356	AV_WL32(pkt->data , nblocks);
357	AV_WL32(pkt->data + 4, ape->frames[ape->currentframe].skip);	357	AV_WL32(pkt->data + 4, ape->frames[ape->currentframe].skip);
358	ret = get_buffer(s->pb, pkt->data + extra_size, ape->frames[ape->currentframe].size);	358	ret = avio_read(s->pb, pkt->data + extra_size, ape->frames[ape->currentframe].size);
359		359
360	pkt->pts = ape->frames[ape->currentframe].pts;	360	pkt->pts = ape->frames[ape->currentframe].pts;
361	pkt->stream_index = 0;	361	pkt->stream_index = 0;

libavformat/apetag.c+9−9

@@ -38,10 +38,10 @@ static int ape_tag_read_field(AVFormatContext *s) · 37 unmodified lines
38	uint32_t size, flags;	38	uint32_t size, flags;
39	int i, c;	39	int i, c;
40		40
41	size = get_le32(pb); /* field size */	41	size = avio_rl32(pb); /* field size */
42	flags = get_le32(pb); /* field flags */	42	flags = avio_rl32(pb); /* field flags */
43	for (i = 0; i < sizeof(key) - 1; i++) {	43	for (i = 0; i < sizeof(key) - 1; i++) {
44	c = get_byte(pb);	44	c = avio_r8(pb);
45	if (c < 0x20 \|\| c > 0x7E)	45	if (c < 0x20 \|\| c > 0x7E)
46	break;	46	break;
47	else	47	else
@@ -57,7 +57,7 @@ static int ape_tag_read_field(AVFormatContext *s) · 9 unmodified lines
57	value = av_malloc(size+1);	57	value = av_malloc(size+1);
58	if (!value)	58	if (!value)
59	return AVERROR(ENOMEM);	59	return AVERROR(ENOMEM);
60	get_buffer(pb, value, size);	60	avio_read(pb, value, size);
61	value[size] = 0;	61	value[size] = 0;
62	av_metadata_set2(&s->metadata, key, value, AV_METADATA_DONT_STRDUP_VAL);	62	av_metadata_set2(&s->metadata, key, value, AV_METADATA_DONT_STRDUP_VAL);
63	return 0;	63	return 0;
@@ -76,30 +76,30 @@ void ff_ape_parse_tag(AVFormatContext *s) · 12 unmodified lines
76		76
77	url_fseek(pb, file_size - APE_TAG_FOOTER_BYTES, SEEK_SET);	77	url_fseek(pb, file_size - APE_TAG_FOOTER_BYTES, SEEK_SET);
78		78
79	get_buffer(pb, buf, 8); /* APETAGEX */	79	avio_read(pb, buf, 8); /* APETAGEX */
80	if (strncmp(buf, "APETAGEX", 8)) {	80	if (strncmp(buf, "APETAGEX", 8)) {
81	return;	81	return;
82	}	82	}
83		83
84	val = get_le32(pb); /* APE tag version */	84	val = avio_rl32(pb); /* APE tag version */
85	if (val > APE_TAG_VERSION) {	85	if (val > APE_TAG_VERSION) {
86	av_log(s, AV_LOG_ERROR, "Unsupported tag version. (>=%d)\n", APE_TAG_VERSION);	86	av_log(s, AV_LOG_ERROR, "Unsupported tag version. (>=%d)\n", APE_TAG_VERSION);
87	return;	87	return;
88	}	88	}
89		89
90	tag_bytes = get_le32(pb); /* tag size */	90	tag_bytes = avio_rl32(pb); /* tag size */
91	if (tag_bytes - APE_TAG_FOOTER_BYTES > (1024 * 1024 * 16)) {	91	if (tag_bytes - APE_TAG_FOOTER_BYTES > (1024 * 1024 * 16)) {
92	av_log(s, AV_LOG_ERROR, "Tag size is way too big\n");	92	av_log(s, AV_LOG_ERROR, "Tag size is way too big\n");
93	return;	93	return;
94	}	94	}
95		95
96	fields = get_le32(pb); /* number of fields */	96	fields = avio_rl32(pb); /* number of fields */
97	if (fields > 65536) {	97	if (fields > 65536) {
98	av_log(s, AV_LOG_ERROR, "Too many tag fields (%d)\n", fields);	98	av_log(s, AV_LOG_ERROR, "Too many tag fields (%d)\n", fields);
99	return;	99	return;
100	}	100	}
101		101
102	val = get_le32(pb); /* flags */	102	val = avio_rl32(pb); /* flags */
103	if (val & APE_TAG_FLAG_IS_HEADER) {	103	if (val & APE_TAG_FLAG_IS_HEADER) {
104	av_log(s, AV_LOG_ERROR, "APE Tag is a header\n");	104	av_log(s, AV_LOG_ERROR, "APE Tag is a header\n");
105	return;	105	return;

libavformat/asfdec.c+127−127

@@ -135,7 +135,7 @@ static void print_guid(const ff_asf_guid *g) · 134 unmodified lines
135	void ff_get_guid(AVIOContext s, ff_asf_guid g)	135	void ff_get_guid(AVIOContext s, ff_asf_guid g)
136	{	136	{
137	assert(sizeof(*g) == 16);	137	assert(sizeof(*g) == 16);
138	get_buffer(s, g, sizeof(g));	138	avio_read(s, g, sizeof(g));
139	}	139	}
140		140
141	static int asf_probe(AVProbeData *pd)	141	static int asf_probe(AVProbeData *pd)
@@ -149,10 +149,10 @@ static int asf_probe(AVProbeData *pd) · 7 unmodified lines
149		149
150	static int get_value(AVIOContext *pb, int type){	150	static int get_value(AVIOContext *pb, int type){
151	switch(type){	151	switch(type){
152	case 2: return get_le32(pb);	152	case 2: return avio_rl32(pb);
153	case 3: return get_le32(pb);	153	case 3: return avio_rl32(pb);
154	case 4: return get_le64(pb);	154	case 4: return avio_rl64(pb);
155	case 5: return get_le16(pb);	155	case 5: return avio_rl16(pb);
156	default:return INT_MIN;	156	default:return INT_MIN;
157	}	157	}
158	}	158	}
@@ -191,17 +191,17 @@ static int asf_read_file_properties(AVFormatContext *s, int64_t size) · 32 unmodified lines
191	AVIOContext *pb = s->pb;	191	AVIOContext *pb = s->pb;
192		192
193	ff_get_guid(pb, &asf->hdr.guid);	193	ff_get_guid(pb, &asf->hdr.guid);
194	asf->hdr.file_size = get_le64(pb);	194	asf->hdr.file_size = avio_rl64(pb);
195	asf->hdr.create_time = get_le64(pb);	195	asf->hdr.create_time = avio_rl64(pb);
196	get_le64(pb); /* number of packets */	196	avio_rl64(pb); /* number of packets */
197	asf->hdr.play_time = get_le64(pb);	197	asf->hdr.play_time = avio_rl64(pb);
198	asf->hdr.send_time = get_le64(pb);	198	asf->hdr.send_time = avio_rl64(pb);
199	asf->hdr.preroll = get_le32(pb);	199	asf->hdr.preroll = avio_rl32(pb);
200	asf->hdr.ignore = get_le32(pb);	200	asf->hdr.ignore = avio_rl32(pb);
201	asf->hdr.flags = get_le32(pb);	201	asf->hdr.flags = avio_rl32(pb);
202	asf->hdr.min_pktsize = get_le32(pb);	202	asf->hdr.min_pktsize = avio_rl32(pb);
203	asf->hdr.max_pktsize = get_le32(pb);	203	asf->hdr.max_pktsize = avio_rl32(pb);
204	asf->hdr.max_bitrate = get_le32(pb);	204	asf->hdr.max_bitrate = avio_rl32(pb);
205	s->packet_size = asf->hdr.max_pktsize;	205	s->packet_size = asf->hdr.max_pktsize;
206		206
207	return 0;	207	return 0;
@@ -263,14 +263,14 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size) · 55 unmodified lines
263	return -1;	263	return -1;
264	}	264	}
265	ff_get_guid(pb, &g);	265	ff_get_guid(pb, &g);
266	total_size = get_le64(pb);	266	total_size = avio_rl64(pb);
267	type_specific_size = get_le32(pb);	267	type_specific_size = avio_rl32(pb);
268	get_le32(pb);	268	avio_rl32(pb);
269	st->id = get_le16(pb) & 0x7f; /* stream id */	269	st->id = avio_rl16(pb) & 0x7f; /* stream id */
270	// mapping of asf ID to AV stream ID;	270	// mapping of asf ID to AV stream ID;
271	asf->asfid2avid[st->id] = s->nb_streams - 1;	271	asf->asfid2avid[st->id] = s->nb_streams - 1;
272		272
273	get_le32(pb);	273	avio_rl32(pb);
274		274
275	if (test_for_ext_stream_audio) {	275	if (test_for_ext_stream_audio) {
276	ff_get_guid(pb, &g);	276	ff_get_guid(pb, &g);
@@ -278,11 +278,11 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size) · 1 unmodified line
278	type = AVMEDIA_TYPE_AUDIO;	278	type = AVMEDIA_TYPE_AUDIO;
279	is_dvr_ms_audio=1;	279	is_dvr_ms_audio=1;
280	ff_get_guid(pb, &g);	280	ff_get_guid(pb, &g);
281	get_le32(pb);	281	avio_rl32(pb);
282	get_le32(pb);	282	avio_rl32(pb);
283	get_le32(pb);	283	avio_rl32(pb);
284	ff_get_guid(pb, &g);	284	ff_get_guid(pb, &g);
285	get_le32(pb);	285	avio_rl32(pb);
286	}	286	}
287	}	287	}
288		288
@@ -303,11 +303,11 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size) · 14 unmodified lines
303	/* We have to init the frame size at some point .... */	303	/* We have to init the frame size at some point .... */
304	pos2 = url_ftell(pb);	304	pos2 = url_ftell(pb);
305	if (size >= (pos2 + 8 - pos1 + 24)) {	305	if (size >= (pos2 + 8 - pos1 + 24)) {
306	asf_st->ds_span = get_byte(pb);	306	asf_st->ds_span = avio_r8(pb);
307	asf_st->ds_packet_size = get_le16(pb);	307	asf_st->ds_packet_size = avio_rl16(pb);
308	asf_st->ds_chunk_size = get_le16(pb);	308	asf_st->ds_chunk_size = avio_rl16(pb);
309	get_le16(pb); //ds_data_size	309	avio_rl16(pb); //ds_data_size
310	get_byte(pb); //ds_silence_data	310	avio_r8(pb); //ds_silence_data
311	}	311	}
312	//printf("Descrambling: ps:%d cs:%d ds:%d s:%d sd:%d\n",	312	//printf("Descrambling: ps:%d cs:%d ds:%d s:%d sd:%d\n",
313	// asf_st->ds_packet_size, asf_st->ds_chunk_size,	313	// 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) · 25 unmodified lines
339	}	339	}
340	} else if (type == AVMEDIA_TYPE_VIDEO &&	340	} else if (type == AVMEDIA_TYPE_VIDEO &&
341	size - (url_ftell(pb) - pos1 + 24) >= 51) {	341	size - (url_ftell(pb) - pos1 + 24) >= 51) {
342	get_le32(pb);	342	avio_rl32(pb);
343	get_le32(pb);	343	avio_rl32(pb);
344	get_byte(pb);	344	avio_r8(pb);
345	get_le16(pb); /* size */	345	avio_rl16(pb); /* size */
346	sizeX= get_le32(pb); /* size */	346	sizeX= avio_rl32(pb); /* size */
347	st->codec->width = get_le32(pb);	347	st->codec->width = avio_rl32(pb);
348	st->codec->height = get_le32(pb);	348	st->codec->height = avio_rl32(pb);
349	/* not available for asf */	349	/* not available for asf */
350	get_le16(pb); /* panes */	350	avio_rl16(pb); /* panes */
351	st->codec->bits_per_coded_sample = get_le16(pb); /* depth */	351	st->codec->bits_per_coded_sample = avio_rl16(pb); /* depth */
352	tag1 = get_le32(pb);	352	tag1 = avio_rl32(pb);
353	url_fskip(pb, 20);	353	url_fskip(pb, 20);
354	// av_log(s, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX);	354	// av_log(s, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX);
355	if (sizeX > 40) {	355	if (sizeX > 40) {
356	st->codec->extradata_size = sizeX - 40;	356	st->codec->extradata_size = sizeX - 40;
357	st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);	357	st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
358	get_buffer(pb, st->codec->extradata, st->codec->extradata_size);	358	avio_read(pb, st->codec->extradata, st->codec->extradata_size);
359	}	359	}
360		360
361	/* Extract palette from extradata if bpp <= 8 */	361	/* Extract palette from extradata if bpp <= 8 */
@@ -402,39 +402,39 @@ static int asf_read_ext_stream_properties(AVFormatContext *s, int64_t size) · 40 unmodified lines
402	uint32_t ext_d, leak_rate, stream_num;	402	uint32_t ext_d, leak_rate, stream_num;
403	unsigned int stream_languageid_index;	403	unsigned int stream_languageid_index;
404		404
405	get_le64(pb); // starttime	405	avio_rl64(pb); // starttime
406	get_le64(pb); // endtime	406	avio_rl64(pb); // endtime
407	leak_rate = get_le32(pb); // leak-datarate	407	leak_rate = avio_rl32(pb); // leak-datarate
408	get_le32(pb); // bucket-datasize	408	avio_rl32(pb); // bucket-datasize
409	get_le32(pb); // init-bucket-fullness	409	avio_rl32(pb); // init-bucket-fullness
410	get_le32(pb); // alt-leak-datarate	410	avio_rl32(pb); // alt-leak-datarate
411	get_le32(pb); // alt-bucket-datasize	411	avio_rl32(pb); // alt-bucket-datasize
412	get_le32(pb); // alt-init-bucket-fullness	412	avio_rl32(pb); // alt-init-bucket-fullness
413	get_le32(pb); // max-object-size	413	avio_rl32(pb); // max-object-size
414	get_le32(pb); // flags (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved)	414	avio_rl32(pb); // flags (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved)
415	stream_num = get_le16(pb); // stream-num	415	stream_num = avio_rl16(pb); // stream-num
416		416
417	stream_languageid_index = get_le16(pb); // stream-language-id-index	417	stream_languageid_index = avio_rl16(pb); // stream-language-id-index
418	if (stream_num < 128)	418	if (stream_num < 128)
419	asf->streams[stream_num].stream_language_index = stream_languageid_index;	419	asf->streams[stream_num].stream_language_index = stream_languageid_index;
420		420
421	get_le64(pb); // avg frametime in 100ns units	421	avio_rl64(pb); // avg frametime in 100ns units
422	stream_ct = get_le16(pb); //stream-name-count	422	stream_ct = avio_rl16(pb); //stream-name-count
423	payload_ext_ct = get_le16(pb); //payload-extension-system-count	423	payload_ext_ct = avio_rl16(pb); //payload-extension-system-count
424		424
425	if (stream_num < 128)	425	if (stream_num < 128)
426	asf->stream_bitrates[stream_num] = leak_rate;	426	asf->stream_bitrates[stream_num] = leak_rate;
427		427
428	for (i=0; i<stream_ct; i++){	428	for (i=0; i<stream_ct; i++){
429	get_le16(pb);	429	avio_rl16(pb);
430	ext_len = get_le16(pb);	430	ext_len = avio_rl16(pb);
431	url_fseek(pb, ext_len, SEEK_CUR);	431	url_fseek(pb, ext_len, SEEK_CUR);
432	}	432	}
433		433
434	for (i=0; i<payload_ext_ct; i++){	434	for (i=0; i<payload_ext_ct; i++){
435	ff_get_guid(pb, &g);	435	ff_get_guid(pb, &g);
436	ext_d=get_le16(pb);	436	ext_d=avio_rl16(pb);
437	ext_len=get_le32(pb);	437	ext_len=avio_rl32(pb);
438	url_fseek(pb, ext_len, SEEK_CUR);	438	url_fseek(pb, ext_len, SEEK_CUR);
439	}	439	}
440		440
@@ -446,11 +446,11 @@ static int asf_read_content_desc(AVFormatContext *s, int64_t size) · 5 unmodified lines
446	AVIOContext *pb = s->pb;	446	AVIOContext *pb = s->pb;
447	int len1, len2, len3, len4, len5;	447	int len1, len2, len3, len4, len5;
448		448
449	len1 = get_le16(pb);	449	len1 = avio_rl16(pb);
450	len2 = get_le16(pb);	450	len2 = avio_rl16(pb);
451	len3 = get_le16(pb);	451	len3 = avio_rl16(pb);
452	len4 = get_le16(pb);	452	len4 = avio_rl16(pb);
453	len5 = get_le16(pb);	453	len5 = avio_rl16(pb);
454	get_tag(s, "title" , 0, len1);	454	get_tag(s, "title" , 0, len1);
455	get_tag(s, "author" , 0, len2);	455	get_tag(s, "author" , 0, len2);
456	get_tag(s, "copyright", 0, len3);	456	get_tag(s, "copyright", 0, len3);
@@ -466,18 +466,18 @@ static int asf_read_ext_content_desc(AVFormatContext *s, int64_t size) · 9 unmodified lines
466	ASFContext *asf = s->priv_data;	466	ASFContext *asf = s->priv_data;
467	int desc_count, i, ret;	467	int desc_count, i, ret;
468		468
469	desc_count = get_le16(pb);	469	desc_count = avio_rl16(pb);
470	for(i=0;i<desc_count;i++) {	470	for(i=0;i<desc_count;i++) {
471	int name_len,value_type,value_len;	471	int name_len,value_type,value_len;
472	char name[1024];	472	char name[1024];
473		473
474	name_len = get_le16(pb);	474	name_len = avio_rl16(pb);
475	if (name_len%2) // must be even, broken lavf versions wrote len-1	475	if (name_len%2) // must be even, broken lavf versions wrote len-1
476	name_len += 1;	476	name_len += 1;
477	if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)	477	if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)
478	url_fskip(pb, name_len - ret);	478	url_fskip(pb, name_len - ret);
479	value_type = get_le16(pb);	479	value_type = avio_rl16(pb);
480	value_len = get_le16(pb);	480	value_len = avio_rl16(pb);
481	if (!value_type && value_len%2)	481	if (!value_type && value_len%2)
482	value_len += 1;	482	value_len += 1;
483	/**	483	/**
@@ -500,10 +500,10 @@ static int asf_read_language_list(AVFormatContext *s, int64_t size) · 16 unmodified lines
500	AVIOContext *pb = s->pb;	500	AVIOContext *pb = s->pb;
501	ASFContext *asf = s->priv_data;	501	ASFContext *asf = s->priv_data;
502	int j, ret;	502	int j, ret;
503	int stream_count = get_le16(pb);	503	int stream_count = avio_rl16(pb);
504	for(j = 0; j < stream_count; j++) {	504	for(j = 0; j < stream_count; j++) {
505	char lang[6];	505	char lang[6];
506	unsigned int lang_len = get_byte(pb);	506	unsigned int lang_len = avio_r8(pb);
507	if ((ret = avio_get_str16le(pb, lang_len, lang, sizeof(lang))) < lang_len)	507	if ((ret = avio_get_str16le(pb, lang_len, lang, sizeof(lang))) < lang_len)
508	url_fskip(pb, lang_len - ret);	508	url_fskip(pb, lang_len - ret);
509	if (j < 128)	509	if (j < 128)
@@ -519,21 +519,21 @@ static int asf_read_metadata(AVFormatContext *s, int64_t size) · 9 unmodified lines
519	ASFContext *asf = s->priv_data;	519	ASFContext *asf = s->priv_data;
520	int n, stream_num, name_len, value_len, value_type, value_num;	520	int n, stream_num, name_len, value_len, value_type, value_num;
521	int ret, i;	521	int ret, i;
522	n = get_le16(pb);	522	n = avio_rl16(pb);
523		523
524	for(i=0;i<n;i++) {	524	for(i=0;i<n;i++) {
525	char name[1024];	525	char name[1024];
526		526
527	get_le16(pb); //lang_list_index	527	avio_rl16(pb); //lang_list_index
528	stream_num= get_le16(pb);	528	stream_num= avio_rl16(pb);
529	name_len= get_le16(pb);	529	name_len= avio_rl16(pb);
530	value_type= get_le16(pb);	530	value_type= avio_rl16(pb);
531	value_len= get_le32(pb);	531	value_len= avio_rl32(pb);
532		532
533	if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)	533	if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)
534	url_fskip(pb, name_len - ret);	534	url_fskip(pb, name_len - ret);
535	//av_log(s, AV_LOG_ERROR, "%d %d %d %d %d <%s>\n", i, stream_num, name_len, value_type, value_len, name);	535	//av_log(s, AV_LOG_ERROR, "%d %d %d %d %d <%s>\n", i, stream_num, name_len, value_type, value_len, name);
536	value_num= get_le16(pb);//we should use get_value() here but it does not work 2 is le16 here but le32 elsewhere	536	value_num= avio_rl16(pb);//we should use get_value() here but it does not work 2 is le16 here but le32 elsewhere
537	url_fskip(pb, value_len - 2);	537	url_fskip(pb, value_len - 2);
538		538
539	if(stream_num<128){	539	if(stream_num<128){
@@ -551,25 +551,25 @@ static int asf_read_marker(AVFormatContext *s, int64_t size) · 11 unmodified lines
551	int i, count, name_len, ret;	551	int i, count, name_len, ret;
552	char name[1024];	552	char name[1024];
553		553
554	get_le64(pb); // reserved 16 bytes	554	avio_rl64(pb); // reserved 16 bytes
555	get_le64(pb); // ...	555	avio_rl64(pb); // ...
556	count = get_le32(pb); // markers count	556	count = avio_rl32(pb); // markers count
557	get_le16(pb); // reserved 2 bytes	557	avio_rl16(pb); // reserved 2 bytes
558	name_len = get_le16(pb); // name length	558	name_len = avio_rl16(pb); // name length
559	for(i=0;i<name_len;i++){	559	for(i=0;i<name_len;i++){
560	get_byte(pb); // skip the name	560	avio_r8(pb); // skip the name
561	}	561	}
562		562
563	for(i=0;i<count;i++){	563	for(i=0;i<count;i++){
564	int64_t pres_time;	564	int64_t pres_time;
565	int name_len;	565	int name_len;
566		566
567	get_le64(pb); // offset, 8 bytes	567	avio_rl64(pb); // offset, 8 bytes
568	pres_time = get_le64(pb); // presentation time	568	pres_time = avio_rl64(pb); // presentation time
569	get_le16(pb); // entry length	569	avio_rl16(pb); // entry length
570	get_le32(pb); // send time	570	avio_rl32(pb); // send time
571	get_le32(pb); // flags	571	avio_rl32(pb); // flags
572	name_len = get_le32(pb); // name length	572	name_len = avio_rl32(pb); // name length
573	if ((ret = avio_get_str16le(pb, name_len * 2, name, sizeof(name))) < name_len)	573	if ((ret = avio_get_str16le(pb, name_len * 2, name, sizeof(name))) < name_len)
574	url_fskip(pb, name_len - ret);	574	url_fskip(pb, name_len - ret);
575	ff_new_chapter(s, i, (AVRational){1, 10000000}, pres_time, AV_NOPTS_VALUE, name );	575	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) · 13 unmodified lines
589	ff_get_guid(pb, &g);	589	ff_get_guid(pb, &g);
590	if (ff_guidcmp(&g, &ff_asf_header))	590	if (ff_guidcmp(&g, &ff_asf_header))
591	return -1;	591	return -1;
592	get_le64(pb);	592	avio_rl64(pb);
593	get_le32(pb);	593	avio_rl32(pb);
594	get_byte(pb);	594	avio_r8(pb);
595	get_byte(pb);	595	avio_r8(pb);
596	memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid));	596	memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid));
597	for(;;) {	597	for(;;) {
598	uint64_t gpos= url_ftell(pb);	598	uint64_t gpos= url_ftell(pb);
599	ff_get_guid(pb, &g);	599	ff_get_guid(pb, &g);
600	gsize = get_le64(pb);	600	gsize = avio_rl64(pb);
601	av_dlog(s, "%08"PRIx64": ", gpos);	601	av_dlog(s, "%08"PRIx64": ", gpos);
602	print_guid(&g);	602	print_guid(&g);
603	av_dlog(s, " size=0x%"PRIx64"\n", gsize);	603	av_dlog(s, " size=0x%"PRIx64"\n", gsize);
@@ -634,8 +634,8 @@ static int asf_read_header(AVFormatContext s, AVFormatParameters ap) · 30 unmodified lines
634	} else if (!ff_guidcmp(&g, &ff_asf_head1_guid)) {	634	} else if (!ff_guidcmp(&g, &ff_asf_head1_guid)) {
635	int v1, v2;	635	int v1, v2;
636	ff_get_guid(pb, &g);	636	ff_get_guid(pb, &g);
637	v1 = get_le32(pb);	637	v1 = avio_rl32(pb);
638	v2 = get_le16(pb);	638	v2 = avio_rl16(pb);
639	continue;	639	continue;
640	} else if (!ff_guidcmp(&g, &ff_asf_marker_header)) {	640	} else if (!ff_guidcmp(&g, &ff_asf_marker_header)) {
641	asf_read_marker(s, gsize);	641	asf_read_marker(s, gsize);
@@ -657,9 +657,9 @@ static int asf_read_header(AVFormatContext s, AVFormatParameters ap) · 15 unmodified lines
657	url_fseek(pb, gpos + gsize, SEEK_SET);	657	url_fseek(pb, gpos + gsize, SEEK_SET);
658	}	658	}
659	ff_get_guid(pb, &g);	659	ff_get_guid(pb, &g);
660	get_le64(pb);	660	avio_rl64(pb);
661	get_byte(pb);	661	avio_r8(pb);
662	get_byte(pb);	662	avio_r8(pb);
663	if (url_feof(pb))	663	if (url_feof(pb))
664	return -1;	664	return -1;
665	asf->data_offset = url_ftell(pb);	665	asf->data_offset = url_ftell(pb);
@@ -704,9 +704,9 @@ static int asf_read_header(AVFormatContext s, AVFormatParameters ap) · 38 unmodified lines
704	#define DO_2BITS(bits, var, defval) \	704	#define DO_2BITS(bits, var, defval) \
705	switch (bits & 3) \	705	switch (bits & 3) \
706	{ \	706	{ \
707	case 3: var = get_le32(pb); rsize += 4; break; \	707	case 3: var = avio_rl32(pb); rsize += 4; break; \
708	case 2: var = get_le16(pb); rsize += 2; break; \	708	case 2: var = avio_rl16(pb); rsize += 2; break; \
709	case 1: var = get_byte(pb); rsize++; break; \	709	case 1: var = avio_r8(pb); rsize++; break; \
710	default: var = defval; break; \	710	default: var = defval; break; \
711	}	711	}
712		712
@@ -731,7 +731,7 @@ static int ff_asf_get_packet(AVFormatContext s, AVIOContext pb) · 18 unmodified lines
731	c=d=e=-1;	731	c=d=e=-1;
732	while(off-- > 0){	732	while(off-- > 0){
733	c=d; d=e;	733	c=d; d=e;
734	e= get_byte(pb);	734	e= avio_r8(pb);
735	if(c == 0x82 && !d && !e)	735	if(c == 0x82 && !d && !e)
736	break;	736	break;
737	}	737	}
@@ -754,8 +754,8 @@ static int ff_asf_get_packet(AVFormatContext s, AVIOContext pb) · 16 unmodified lines
754	av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");	754	av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");
755	return -1;	755	return -1;
756	}	756	}
757	c= get_byte(pb);	757	c= avio_r8(pb);
758	d= get_byte(pb);	758	d= avio_r8(pb);
759	rsize+=3;	759	rsize+=3;
760	}else{	760	}else{
761	url_fseek(pb, -1, SEEK_CUR); //FIXME	761	url_fseek(pb, -1, SEEK_CUR); //FIXME
@@ -778,12 +778,12 @@ static int ff_asf_get_packet(AVFormatContext s, AVIOContext pb) · 16 unmodified lines
778	return -1;	778	return -1;
779	}	779	}
780		780
781	asf->packet_timestamp = get_le32(pb);	781	asf->packet_timestamp = avio_rl32(pb);
782	get_le16(pb); /* duration */	782	avio_rl16(pb); /* duration */
783	// rsize has at least 11 bytes which have to be present	783	// rsize has at least 11 bytes which have to be present
784		784
785	if (asf->packet_flags & 0x01) {	785	if (asf->packet_flags & 0x01) {
786	asf->packet_segsizetype = get_byte(pb); rsize++;	786	asf->packet_segsizetype = avio_r8(pb); rsize++;
787	asf->packet_segments = asf->packet_segsizetype & 0x3f;	787	asf->packet_segments = asf->packet_segsizetype & 0x3f;
788	} else {	788	} else {
789	asf->packet_segments = 1;	789	asf->packet_segments = 1;
@@ -804,7 +804,7 @@ static int ff_asf_get_packet(AVFormatContext s, AVIOContext pb) · 14 unmodified lines
804	static int asf_read_frame_header(AVFormatContext s, AVIOContext pb){	804	static int asf_read_frame_header(AVFormatContext s, AVIOContext pb){
805	ASFContext *asf = s->priv_data;	805	ASFContext *asf = s->priv_data;
806	int rsize = 1;	806	int rsize = 1;
807	int num = get_byte(pb);	807	int num = avio_r8(pb);
808	int64_t ts0, ts1;	808	int64_t ts0, ts1;
809		809
810	asf->packet_segments--;	810	asf->packet_segments--;
@@ -816,21 +816,21 @@ static int asf_read_frame_header(AVFormatContext s, AVIOContext pb){ · 5 unmodified lines
816	DO_2BITS(asf->packet_property, asf->packet_replic_size, 0);	816	DO_2BITS(asf->packet_property, asf->packet_replic_size, 0);
817	//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);	817	//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);
818	if (asf->packet_replic_size >= 8) {	818	if (asf->packet_replic_size >= 8) {
819	asf->packet_obj_size = get_le32(pb);	819	asf->packet_obj_size = avio_rl32(pb);
820	if(asf->packet_obj_size >= (1<<24) \|\| asf->packet_obj_size <= 0){	820	if(asf->packet_obj_size >= (1<<24) \|\| asf->packet_obj_size <= 0){
821	av_log(s, AV_LOG_ERROR, "packet_obj_size invalid\n");	821	av_log(s, AV_LOG_ERROR, "packet_obj_size invalid\n");
822	return -1;	822	return -1;
823	}	823	}
824	asf->packet_frag_timestamp = get_le32(pb); // timestamp	824	asf->packet_frag_timestamp = avio_rl32(pb); // timestamp
825	if(asf->packet_replic_size >= 8+38+4){	825	if(asf->packet_replic_size >= 8+38+4){
826	// for(i=0; i<asf->packet_replic_size-8; i++)	826	// for(i=0; i<asf->packet_replic_size-8; i++)
827	// av_log(s, AV_LOG_DEBUG, "%02X ",get_byte(pb));	827	// av_log(s, AV_LOG_DEBUG, "%02X ",avio_r8(pb));
828	// av_log(s, AV_LOG_DEBUG, "\n");	828	// av_log(s, AV_LOG_DEBUG, "\n");
829	url_fskip(pb, 10);	829	url_fskip(pb, 10);
830	ts0= get_le64(pb);	830	ts0= avio_rl64(pb);
831	ts1= get_le64(pb);	831	ts1= avio_rl64(pb);
832	url_fskip(pb, 12);	832	url_fskip(pb, 12);
833	get_le32(pb);	833	avio_rl32(pb);
834	url_fskip(pb, asf->packet_replic_size - 8 - 38 - 4);	834	url_fskip(pb, asf->packet_replic_size - 8 - 38 - 4);
835	if(ts0!= -1) asf->packet_frag_timestamp= ts0/10000;	835	if(ts0!= -1) asf->packet_frag_timestamp= ts0/10000;
836	else asf->packet_frag_timestamp= AV_NOPTS_VALUE;	836	else asf->packet_frag_timestamp= AV_NOPTS_VALUE;
@@ -843,7 +843,7 @@ static int asf_read_frame_header(AVFormatContext s, AVIOContext pb){ · 6 unmodified lines
843	asf->packet_frag_offset = 0;	843	asf->packet_frag_offset = 0;
844	asf->packet_frag_timestamp = asf->packet_timestamp;	844	asf->packet_frag_timestamp = asf->packet_timestamp;
845		845
846	asf->packet_time_delta = get_byte(pb);	846	asf->packet_time_delta = avio_r8(pb);
847	rsize++;	847	rsize++;
848	}else if(asf->packet_replic_size!=0){	848	}else if(asf->packet_replic_size!=0){
849	av_log(s, AV_LOG_ERROR, "unexpected packet_replic_size of %d\n", asf->packet_replic_size);	849	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 · 78 unmodified lines
928	// frag_offset is here used as the beginning timestamp	928	// frag_offset is here used as the beginning timestamp
929	asf->packet_frag_timestamp = asf->packet_time_start;	929	asf->packet_frag_timestamp = asf->packet_time_start;
930	asf->packet_time_start += asf->packet_time_delta;	930	asf->packet_time_start += asf->packet_time_delta;
931	asf->packet_obj_size = asf->packet_frag_size = get_byte(pb);	931	asf->packet_obj_size = asf->packet_frag_size = avio_r8(pb);
932	asf->packet_size_left--;	932	asf->packet_size_left--;
933	asf->packet_multi_size--;	933	asf->packet_multi_size--;
934	if (asf->packet_multi_size < asf->packet_obj_size)	934	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 · 53 unmodified lines
988	continue;	988	continue;
989	}	989	}
990		990
991	ret = get_buffer(pb, asf_st->pkt.data + asf->packet_frag_offset,	991	ret = avio_read(pb, asf_st->pkt.data + asf->packet_frag_offset,
992	asf->packet_frag_size);	992	asf->packet_frag_size);
993	if (ret != asf->packet_frag_size) {	993	if (ret != asf->packet_frag_size) {
994	if (ret < 0 \|\| asf->packet_frag_offset + ret == 0)	994	if (ret < 0 \|\| asf->packet_frag_offset + ret == 0)
@@ -1194,7 +1194,7 @@ static void asf_build_simple_index(AVFormatContext *s, int stream_index) · 199 unmodified lines
1194	/* the data object can be followed by other top-level objects,	1194	/* the data object can be followed by other top-level objects,
1195	skip them until the simple index object is reached */	1195	skip them until the simple index object is reached */
1196	while (ff_guidcmp(&g, &index_guid)) {	1196	while (ff_guidcmp(&g, &index_guid)) {
1197	int64_t gsize= get_le64(s->pb);	1197	int64_t gsize= avio_rl64(s->pb);
1198	if (gsize < 24 \|\| url_feof(s->pb)) {	1198	if (gsize < 24 \|\| url_feof(s->pb)) {
1199	url_fseek(s->pb, current_pos, SEEK_SET);	1199	url_fseek(s->pb, current_pos, SEEK_SET);
1200	return;	1200	return;
@@ -1206,16 +1206,16 @@ static void asf_build_simple_index(AVFormatContext *s, int stream_index) · 5 unmodified lines
1206	{	1206	{
1207	int64_t itime, last_pos=-1;	1207	int64_t itime, last_pos=-1;
1208	int pct, ict;	1208	int pct, ict;
1209	int64_t av_unused gsize= get_le64(s->pb);	1209	int64_t av_unused gsize= avio_rl64(s->pb);
1210	ff_get_guid(s->pb, &g);	1210	ff_get_guid(s->pb, &g);
1211	itime=get_le64(s->pb);	1211	itime=avio_rl64(s->pb);
1212	pct=get_le32(s->pb);	1212	pct=avio_rl32(s->pb);
1213	ict=get_le32(s->pb);	1213	ict=avio_rl32(s->pb);
1214	av_log(s, AV_LOG_DEBUG, "itime:0x%"PRIx64", pct:%d, ict:%d\n",itime,pct,ict);	1214	av_log(s, AV_LOG_DEBUG, "itime:0x%"PRIx64", pct:%d, ict:%d\n",itime,pct,ict);
1215		1215
1216	for (i=0;i<ict;i++){	1216	for (i=0;i<ict;i++){
1217	int pktnum=get_le32(s->pb);	1217	int pktnum=avio_rl32(s->pb);
1218	int pktct =get_le16(s->pb);	1218	int pktct =avio_rl16(s->pb);
1219	int64_t pos = s->data_offset + s->packet_size*(int64_t)pktnum;	1219	int64_t pos = s->data_offset + s->packet_size*(int64_t)pktnum;
1220	int64_t index_pts= av_rescale(itime, i, 10000);	1220	int64_t index_pts= av_rescale(itime, i, 10000);
1221		1221

libavformat/au.c+6−6

@@ -127,15 +127,15 @@ static int au_read_header(AVFormatContext *s, · 126 unmodified lines
127	AVStream *st;	127	AVStream *st;
128		128
129	/* check ".snd" header */	129	/* check ".snd" header */
130	tag = get_le32(pb);	130	tag = avio_rl32(pb);
131	if (tag != MKTAG('.', 's', 'n', 'd'))	131	if (tag != MKTAG('.', 's', 'n', 'd'))
132	return -1;	132	return -1;
133	size = get_be32(pb); /* header size */	133	size = avio_rb32(pb); /* header size */
134	get_be32(pb); /* data size */	134	avio_rb32(pb); /* data size */
135		135
136	id = get_be32(pb);	136	id = avio_rb32(pb);
137	rate = get_be32(pb);	137	rate = avio_rb32(pb);
138	channels = get_be32(pb);	138	channels = avio_rb32(pb);
139		139
140	codec = ff_codec_get_id(codec_au_tags, id);	140	codec = ff_codec_get_id(codec_au_tags, id);
141		141

libavformat/avidec.c+79−79

@@ -107,10 +107,10 @@ static int get_riff(AVFormatContext s, AVIOContext pb) · 106 unmodified lines
107	int i;	107	int i;
108		108
109	/* check RIFF header */	109	/* check RIFF header */
110	get_buffer(pb, header, 4);	110	avio_read(pb, header, 4);
111	avi->riff_end = get_le32(pb); /* RIFF chunk size */	111	avi->riff_end = avio_rl32(pb); /* RIFF chunk size */
112	avi->riff_end += url_ftell(pb); /* RIFF chunk end */	112	avi->riff_end += url_ftell(pb); /* RIFF chunk end */
113	get_buffer(pb, header+4, 4);	113	avio_read(pb, header+4, 4);
114		114
115	for(i=0; avi_headers[i][0]; i++)	115	for(i=0; avi_headers[i][0]; i++)
116	if(!memcmp(header, avi_headers[i], 8))	116	if(!memcmp(header, avi_headers[i], 8))
@@ -127,12 +127,12 @@ static int get_riff(AVFormatContext s, AVIOContext pb) · 10 unmodified lines
127	static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){	127	static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){
128	AVIContext *avi = s->priv_data;	128	AVIContext *avi = s->priv_data;
129	AVIOContext *pb = s->pb;	129	AVIOContext *pb = s->pb;
130	int longs_pre_entry= get_le16(pb);	130	int longs_pre_entry= avio_rl16(pb);
131	int index_sub_type = get_byte(pb);	131	int index_sub_type = avio_r8(pb);
132	int index_type = get_byte(pb);	132	int index_type = avio_r8(pb);
133	int entries_in_use = get_le32(pb);	133	int entries_in_use = avio_rl32(pb);
134	int chunk_id = get_le32(pb);	134	int chunk_id = avio_rl32(pb);
135	int64_t base = get_le64(pb);	135	int64_t base = avio_rl64(pb);
136	int stream_id= 10*((chunk_id&0xFF) - '0') + (((chunk_id>>8)&0xFF) - '0');	136	int stream_id= 10*((chunk_id&0xFF) - '0') + (((chunk_id>>8)&0xFF) - '0');
137	AVStream *st;	137	AVStream *st;
138	AVIStream *ast;	138	AVIStream *ast;
@@ -153,7 +153,7 @@ static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){ · 14 unmodified lines
153	if(index_sub_type)	153	if(index_sub_type)
154	return -1;	154	return -1;
155		155
156	get_le32(pb);	156	avio_rl32(pb);
157		157
158	if(index_type && longs_pre_entry != 2)	158	if(index_type && longs_pre_entry != 2)
159	return -1;	159	return -1;
@@ -170,8 +170,8 @@ static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){ · 10 unmodified lines
170		170
171	for(i=0; i<entries_in_use; i++){	171	for(i=0; i<entries_in_use; i++){
172	if(index_type){	172	if(index_type){
173	int64_t pos= get_le32(pb) + base - 8;	173	int64_t pos= avio_rl32(pb) + base - 8;
174	int len = get_le32(pb);	174	int len = avio_rl32(pb);
175	int key= len >= 0;	175	int key= len >= 0;
176	len &= 0x7FFFFFFF;	176	len &= 0x7FFFFFFF;
177		177
@@ -191,9 +191,9 @@ static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){ · 13 unmodified lines
191	}else{	191	}else{
192	int64_t offset, pos;	192	int64_t offset, pos;
193	int duration;	193	int duration;
194	offset = get_le64(pb);	194	offset = avio_rl64(pb);
195	get_le32(pb); /* size */	195	avio_rl32(pb); /* size */
196	duration = get_le32(pb);	196	duration = avio_rl32(pb);
197		197
198	if(url_feof(pb))	198	if(url_feof(pb))
199	return -1;	199	return -1;
@@ -256,7 +256,7 @@ static int avi_read_tag(AVFormatContext s, AVStream st, uint32_t tag, uint32_t · 56 unmodified lines
256	value = av_malloc(size+1);	256	value = av_malloc(size+1);
257	if (!value)	257	if (!value)
258	return -1;	258	return -1;
259	get_buffer(pb, value, size);	259	avio_read(pb, value, size);
260	value[size]=0;	260	value[size]=0;
261		261
262	AV_WL32(key, tag);	262	AV_WL32(key, tag);
@@ -268,8 +268,8 @@ static int avi_read_tag(AVFormatContext s, AVStream st, uint32_t tag, uint32_t · 5 unmodified lines
268	static void avi_read_info(AVFormatContext *s, uint64_t end)	268	static void avi_read_info(AVFormatContext *s, uint64_t end)
269	{	269	{
270	while (url_ftell(s->pb) < end) {	270	while (url_ftell(s->pb) < end) {
271	uint32_t tag = get_le32(s->pb);	271	uint32_t tag = avio_rl32(s->pb);
272	uint32_t size = get_le32(s->pb);	272	uint32_t size = avio_rl32(s->pb);
273	avi_read_tag(s, NULL, tag, size);	273	avi_read_tag(s, NULL, tag, size);
274	}	274	}
275	}	275	}
@@ -299,17 +299,17 @@ static void avi_metadata_creation_time(AVMetadata *metadata, char date) · 23 unmodified lines
299	static void avi_read_nikon(AVFormatContext *s, uint64_t end)	299	static void avi_read_nikon(AVFormatContext *s, uint64_t end)
300	{	300	{
301	while (url_ftell(s->pb) < end) {	301	while (url_ftell(s->pb) < end) {
302	uint32_t tag = get_le32(s->pb);	302	uint32_t tag = avio_rl32(s->pb);
303	uint32_t size = get_le32(s->pb);	303	uint32_t size = avio_rl32(s->pb);
304	switch (tag) {	304	switch (tag) {
305	case MKTAG('n', 'c', 't', 'g'): { /* Nikon Tags */	305	case MKTAG('n', 'c', 't', 'g'): { /* Nikon Tags */
306	uint64_t tag_end = url_ftell(s->pb) + size;	306	uint64_t tag_end = url_ftell(s->pb) + size;
307	while (url_ftell(s->pb) < tag_end) {	307	while (url_ftell(s->pb) < tag_end) {
308	uint16_t tag = get_le16(s->pb);	308	uint16_t tag = avio_rl16(s->pb);
309	uint16_t size = get_le16(s->pb);	309	uint16_t size = avio_rl16(s->pb);
310	const char *name = NULL;	310	const char *name = NULL;
311	char buffer[64] = {0};	311	char buffer[64] = {0};
312	size -= get_buffer(s->pb, buffer,	312	size -= avio_read(s->pb, buffer,
313	FFMIN(size, sizeof(buffer)-1));	313	FFMIN(size, sizeof(buffer)-1));
314	switch (tag) {	314	switch (tag) {
315	case 0x03: name = "maker"; break;	315	case 0x03: name = "maker"; break;
@@ -362,8 +362,8 @@ static int avi_read_header(AVFormatContext s, AVFormatParameters ap) · 46 unmodified lines
362	for(;;) {	362	for(;;) {
363	if (url_feof(pb))	363	if (url_feof(pb))
364	goto fail;	364	goto fail;
365	tag = get_le32(pb);	365	tag = avio_rl32(pb);
366	size = get_le32(pb);	366	size = avio_rl32(pb);
367		367
368	print_tag("tag", tag, size);	368	print_tag("tag", tag, size);
369		369
@@ -371,7 +371,7 @@ static int avi_read_header(AVFormatContext s, AVFormatParameters ap) · 1 unmodified line
371	case MKTAG('L', 'I', 'S', 'T'):	371	case MKTAG('L', 'I', 'S', 'T'):
372	list_end = url_ftell(pb) + size;	372	list_end = url_ftell(pb) + size;
373	/* Ignored, except at start of video packets. */	373	/* Ignored, except at start of video packets. */
374	tag1 = get_le32(pb);	374	tag1 = avio_rl32(pb);
375		375
376	print_tag("list", tag1, 0);	376	print_tag("list", tag1, 0);
377		377
@@ -391,7 +391,7 @@ static int avi_read_header(AVFormatContext s, AVFormatParameters ap) · 13 unmodified lines
391	case MKTAG('I', 'D', 'I', 'T'): {	391	case MKTAG('I', 'D', 'I', 'T'): {
392	unsigned char date[64] = {0};	392	unsigned char date[64] = {0};
393	size += (size & 1);	393	size += (size & 1);
394	size -= get_buffer(pb, date, FFMIN(size, sizeof(date)-1));	394	size -= avio_read(pb, date, FFMIN(size, sizeof(date)-1));
395	url_fskip(pb, size);	395	url_fskip(pb, size);
396	avi_metadata_creation_time(&s->metadata, date);	396	avi_metadata_creation_time(&s->metadata, date);
397	break;	397	break;
@@ -405,24 +405,24 @@ static int avi_read_header(AVFormatContext s, AVFormatParameters ap) · 7 unmodified lines
405	case MKTAG('a', 'v', 'i', 'h'):	405	case MKTAG('a', 'v', 'i', 'h'):
406	/* AVI header */	406	/* AVI header */
407	/* using frame_period is bad idea */	407	/* using frame_period is bad idea */
408	frame_period = get_le32(pb);	408	frame_period = avio_rl32(pb);
409	bit_rate = get_le32(pb) * 8;	409	bit_rate = avio_rl32(pb) * 8;
410	get_le32(pb);	410	avio_rl32(pb);
411	avi->non_interleaved \|= get_le32(pb) & AVIF_MUSTUSEINDEX;	411	avi->non_interleaved \|= avio_rl32(pb) & AVIF_MUSTUSEINDEX;
412		412
413	url_fskip(pb, 2 * 4);	413	url_fskip(pb, 2 * 4);
414	get_le32(pb);	414	avio_rl32(pb);
415	get_le32(pb);	415	avio_rl32(pb);
416	avih_width=get_le32(pb);	416	avih_width=avio_rl32(pb);
417	avih_height=get_le32(pb);	417	avih_height=avio_rl32(pb);
418		418
419	url_fskip(pb, size - 10 * 4);	419	url_fskip(pb, size - 10 * 4);
420	break;	420	break;
421	case MKTAG('s', 't', 'r', 'h'):	421	case MKTAG('s', 't', 'r', 'h'):
422	/* stream header */	422	/* stream header */
423		423
424	tag1 = get_le32(pb);	424	tag1 = avio_rl32(pb);
425	handler = get_le32(pb); /* codec tag */	425	handler = avio_rl32(pb); /* codec tag */
426		426
427	if(tag1 == MKTAG('p', 'a', 'd', 's')){	427	if(tag1 == MKTAG('p', 'a', 'd', 's')){
428	url_fskip(pb, size - 8);	428	url_fskip(pb, size - 8);
@@ -470,11 +470,11 @@ static int avi_read_header(AVFormatContext s, AVFormatParameters ap) · 41 unmodified lines
470	}	470	}
471	s->streams[0]->priv_data = ast;	471	s->streams[0]->priv_data = ast;
472	url_fskip(pb, 3 * 4);	472	url_fskip(pb, 3 * 4);
473	ast->scale = get_le32(pb);	473	ast->scale = avio_rl32(pb);
474	ast->rate = get_le32(pb);	474	ast->rate = avio_rl32(pb);
475	url_fskip(pb, 4); /* start time */	475	url_fskip(pb, 4); /* start time */
476		476
477	dv_dur = get_le32(pb);	477	dv_dur = avio_rl32(pb);
478	if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {	478	if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {
479	dv_dur *= AV_TIME_BASE;	479	dv_dur *= AV_TIME_BASE;
480	s->duration = av_rescale(dv_dur, ast->scale, ast->rate);	480	s->duration = av_rescale(dv_dur, ast->scale, ast->rate);
@@ -492,12 +492,12 @@ static int avi_read_header(AVFormatContext s, AVFormatParameters ap) · 11 unmodified lines
492	assert(stream_index < s->nb_streams);	492	assert(stream_index < s->nb_streams);
493	st->codec->stream_codec_tag= handler;	493	st->codec->stream_codec_tag= handler;
494		494
495	get_le32(pb); /* flags */	495	avio_rl32(pb); /* flags */
496	get_le16(pb); /* priority */	496	avio_rl16(pb); /* priority */
497	get_le16(pb); /* language */	497	avio_rl16(pb); /* language */
498	get_le32(pb); /* initial frame */	498	avio_rl32(pb); /* initial frame */
499	ast->scale = get_le32(pb);	499	ast->scale = avio_rl32(pb);
500	ast->rate = get_le32(pb);	500	ast->rate = avio_rl32(pb);
501	if(!(ast->scale && ast->rate)){	501	if(!(ast->scale && ast->rate)){
502	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);	502	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);
503	if(frame_period){	503	if(frame_period){
@@ -510,13 +510,13 @@ static int avi_read_header(AVFormatContext s, AVFormatParameters ap) · 6 unmodified lines
510	}	510	}
511	av_set_pts_info(st, 64, ast->scale, ast->rate);	511	av_set_pts_info(st, 64, ast->scale, ast->rate);
512		512
513	ast->cum_len=get_le32(pb); /* start */	513	ast->cum_len=avio_rl32(pb); /* start */
514	st->nb_frames = get_le32(pb);	514	st->nb_frames = avio_rl32(pb);
515		515
516	st->start_time = 0;	516	st->start_time = 0;
517	get_le32(pb); /* buffer size */	517	avio_rl32(pb); /* buffer size */
518	get_le32(pb); /* quality */	518	avio_rl32(pb); /* quality */
519	ast->sample_size = get_le32(pb); /* sample ssize */	519	ast->sample_size = avio_rl32(pb); /* sample ssize */
520	ast->cum_len *= FFMAX(1, ast->sample_size);	520	ast->cum_len *= FFMAX(1, ast->sample_size);
521	// av_log(s, AV_LOG_DEBUG, "%d %d %d %d\n", ast->rate, ast->scale, ast->start, ast->sample_size);	521	// av_log(s, AV_LOG_DEBUG, "%d %d %d %d\n", ast->rate, ast->scale, ast->start, ast->sample_size);
522		522
@@ -579,11 +579,11 @@ static int avi_read_header(AVFormatContext s, AVFormatParameters ap) · 56 unmodified lines
579	st->codec->extradata_size= 0;	579	st->codec->extradata_size= 0;
580	return AVERROR(ENOMEM);	580	return AVERROR(ENOMEM);
581	}	581	}
582	get_buffer(pb, st->codec->extradata, st->codec->extradata_size);	582	avio_read(pb, st->codec->extradata, st->codec->extradata_size);
583	}	583	}
584		584
585	if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly	585	if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly
586	get_byte(pb);	586	avio_r8(pb);
587		587
588	/* Extract palette from extradata if bpp <= 8. */	588	/* Extract palette from extradata if bpp <= 8. */
589	/* This code assumes that extradata contains only palette. */	589	/* This code assumes that extradata contains only palette. */
@@ -675,17 +675,17 @@ static int avi_read_header(AVFormatContext s, AVFormatParameters ap) · 85 unmodified lines
675	AVRational active, active_aspect;	675	AVRational active, active_aspect;
676		676
677	st = s->streams[stream_index];	677	st = s->streams[stream_index];
678	get_le32(pb);	678	avio_rl32(pb);
679	get_le32(pb);	679	avio_rl32(pb);
680	get_le32(pb);	680	avio_rl32(pb);
681	get_le32(pb);	681	avio_rl32(pb);
682	get_le32(pb);	682	avio_rl32(pb);
683		683
684	active_aspect.den= get_le16(pb);	684	active_aspect.den= avio_rl16(pb);
685	active_aspect.num= get_le16(pb);	685	active_aspect.num= avio_rl16(pb);
686	active.num = get_le32(pb);	686	active.num = avio_rl32(pb);
687	active.den = get_le32(pb);	687	active.den = avio_rl32(pb);
688	get_le32(pb); //nbFieldsPerFrame	688	avio_rl32(pb); //nbFieldsPerFrame
689		689
690	if(active_aspect.num && active_aspect.den && active.num && active.den){	690	if(active_aspect.num && active_aspect.den && active.num && active.den){
691	st->sample_aspect_ratio= av_div_q(active_aspect, active);	691	st->sample_aspect_ratio= av_div_q(active_aspect, active);
@@ -756,7 +756,7 @@ static int read_gab2_sub(AVStream st, AVPacket pkt) { · 64 unmodified lines
756	pkt->size - 7,	756	pkt->size - 7,
757	0, NULL, NULL, NULL, NULL);	757	0, NULL, NULL, NULL, NULL);
758	AVProbeData pd;	758	AVProbeData pd;
759	unsigned int desc_len = get_le32(pb);	759	unsigned int desc_len = avio_rl32(pb);
760		760
761	if (desc_len > pb->buf_end - pb->buf_ptr)	761	if (desc_len > pb->buf_end - pb->buf_ptr)
762	goto error;	762	goto error;
@@ -766,8 +766,8 @@ static int read_gab2_sub(AVStream st, AVPacket pkt) { · 3 unmodified lines
766	if (*desc)	766	if (*desc)
767	av_metadata_set2(&st->metadata, "title", desc, 0);	767	av_metadata_set2(&st->metadata, "title", desc, 0);
768		768
769	get_le16(pb); /* flags? */	769	avio_rl16(pb); /* flags? */
770	get_le32(pb); /* data size */	770	avio_rl32(pb); /* data size */
771		771
772	pd = (AVProbeData) { .buf = pb->buf_ptr, .buf_size = pb->buf_end - pb->buf_ptr };	772	pd = (AVProbeData) { .buf = pb->buf_ptr, .buf_size = pb->buf_end - pb->buf_ptr };
773	if (!(sub_demuxer = av_probe_input_format2(&pd, 1, &score)))	773	if (!(sub_demuxer = av_probe_input_format2(&pd, 1, &score)))
@@ -994,7 +994,7 @@ resync: · 220 unmodified lines
994		994
995	for(j=0; j<7; j++)	995	for(j=0; j<7; j++)
996	d[j]= d[j+1];	996	d[j]= d[j+1];
997	d[7]= get_byte(pb);	997	d[7]= avio_r8(pb);
998		998
999	size= d[4] + (d[5]<<8) + (d[6]<<16) + (d[7]<<24);	999	size= d[4] + (d[5]<<8) + (d[6]<<16) + (d[7]<<24);
1000		1000
@@ -1065,13 +1065,13 @@ resync: · 64 unmodified lines
1065	}	1065	}
1066		1066
1067	if (d[2] == 'p' && d[3] == 'c' && size<=4*256+4) {	1067	if (d[2] == 'p' && d[3] == 'c' && size<=4*256+4) {
1068	int k = get_byte(pb);	1068	int k = avio_r8(pb);
1069	int last = (k + get_byte(pb) - 1) & 0xFF;	1069	int last = (k + avio_r8(pb) - 1) & 0xFF;
1070		1070
1071	get_le16(pb); //flags	1071	avio_rl16(pb); //flags
1072		1072
1073	for (; k <= last; k++)	1073	for (; k <= last; k++)
1074	ast->pal[k] = get_be32(pb)>>8;// b + (g << 8) + (r << 16);	1074	ast->pal[k] = avio_rb32(pb)>>8;// b + (g << 8) + (r << 16);
1075	ast->has_pal= 1;	1075	ast->has_pal= 1;
1076	goto resync;	1076	goto resync;
1077	} else if( ((ast->prefix_count<5 \|\| sync+9 > i) && d[2]<128 && d[3]<128) \|\|	1077	} 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) · 45 unmodified lines
1123		1123
1124	/* Read the entries and sort them in each stream component. */	1124	/* Read the entries and sort them in each stream component. */
1125	for(i = 0; i < nb_index_entries; i++) {	1125	for(i = 0; i < nb_index_entries; i++) {
1126	tag = get_le32(pb);	1126	tag = avio_rl32(pb);
1127	flags = get_le32(pb);	1127	flags = avio_rl32(pb);
1128	pos = get_le32(pb);	1128	pos = avio_rl32(pb);
1129	len = get_le32(pb);	1129	len = avio_rl32(pb);
1130	#if defined(DEBUG_SEEK)	1130	#if defined(DEBUG_SEEK)
1131	av_log(s, AV_LOG_DEBUG, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/",	1131	av_log(s, AV_LOG_DEBUG, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/",
1132	i, tag, flags, pos, len);	1132	i, tag, flags, pos, len);
@@ -1175,7 +1175,7 @@ static int guess_ni_flag(AVFormatContext *s){ · 42 unmodified lines
1175	if(n >= 2){	1175	if(n >= 2){
1176	int64_t pos= st->index_entries[0].pos;	1176	int64_t pos= st->index_entries[0].pos;
1177	url_fseek(s->pb, pos + 4, SEEK_SET);	1177	url_fseek(s->pb, pos + 4, SEEK_SET);
1178	size= get_le32(s->pb);	1178	size= avio_rl32(s->pb);
1179	if(pos + size > st->index_entries[1].pos)	1179	if(pos + size > st->index_entries[1].pos)
1180	last_start= INT64_MAX;	1180	last_start= INT64_MAX;
1181	}	1181	}
@@ -1205,8 +1205,8 @@ static int avi_load_index(AVFormatContext *s) · 23 unmodified lines
1205	for(;;) {	1205	for(;;) {
1206	if (url_feof(pb))	1206	if (url_feof(pb))
1207	break;	1207	break;
1208	tag = get_le32(pb);	1208	tag = avio_rl32(pb);
1209	size = get_le32(pb);	1209	size = avio_rl32(pb);
1210	#ifdef DEBUG_SEEK	1210	#ifdef DEBUG_SEEK
1211	printf("tag=%c%c%c%c size=0x%x\n",	1211	printf("tag=%c%c%c%c size=0x%x\n",
1212	tag & 0xff,	1212	tag & 0xff,

libavformat/avio.h+29−10

                   int (*read_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));
+/**
+ * @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
 AVIOContext *avio_alloc_context(
  * Read size bytes from AVIOContext into buf.
  * @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.
 /** @note return 0 if EOF, so you cannot use it if EOF handling is
     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.
 int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen);
 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);

libavformat/aviobuf.c+57−31

 {
     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
 int avio_put_str(AVIOContext *s, const char *str)
 }
 /* XXX: put an inline version */
-int get_byte(AVIOContext *s)
+int avio_r8(AVIOContext *s)
 {
     if (s->buf_ptr >= s->buf_end)
         fill_buffer(s);
     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;
     return len;
 }
-unsigned int get_le16(AVIOContext *s)
+unsigned int avio_rl16(AVIOContext *s)
 {
     unsigned int val;
-    val = get_byte(s);
+    val = avio_r8(s);
-    val |= get_byte(s) << 8;
+    val |= avio_r8(s) << 8;
     return val;
 }
-unsigned int get_le24(AVIOContext *s)
+unsigned int avio_rl24(AVIOContext *s)
 {
     unsigned int val;
-    val = get_le16(s);
+    val = avio_rl16(s);
-    val |= get_byte(s) << 16;
+    val |= avio_r8(s) << 16;
     return val;
 }
-unsigned int get_le32(AVIOContext *s)
+unsigned int avio_rl32(AVIOContext *s)
 {
     unsigned int val;
-    val = get_le16(s);
+    val = avio_rl16(s);
-    val |= get_le16(s) << 16;
+    val |= avio_rl16(s) << 16;
     return val;
 }
-uint64_t get_le64(AVIOContext *s)
+uint64_t avio_rl64(AVIOContext *s)
 {
     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;
 }
-unsigned int get_be16(AVIOContext *s)
+unsigned int avio_rb16(AVIOContext *s)
 {
     unsigned int val;
-    val = get_byte(s) << 8;
+    val = avio_r8(s) << 8;
-    val |= get_byte(s);
+    val |= avio_r8(s);
     return val;
 }
-unsigned int get_be24(AVIOContext *s)
+unsigned int avio_rb24(AVIOContext *s)
 {
     unsigned int val;
-    val = get_be16(s) << 8;
+    val = avio_rb16(s) << 8;
-    val |= get_byte(s);
+    val |= avio_r8(s);
     return val;
 }
-unsigned int get_be32(AVIOContext *s)
+unsigned int avio_rb32(AVIOContext *s)
 {
     unsigned int val;
-    val = get_be16(s) << 16;
+    val = avio_rb16(s) << 16;
-    val |= get_be16(s);
+    val |= avio_rb16(s);
     return val;
 }
     int i = 0;
     char c;
-    while ((c = get_byte(s))) {
+    while ((c = avio_r8(s))) {
         if (i < maxlen-1)
             buf[i++] = c;
     }
     char c;
     do {
-        c = get_byte(s);
+        c = avio_r8(s);
         if (c && i < maxlen-1)
             buf[i++] = c;
     } while (c != '\n' && c);
     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
-uint64_t get_be64(AVIOContext *s)
+uint64_t avio_rb64(AVIOContext *s)
 {
     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;
 }
     int tmp;
     do{
-        tmp = get_byte(bc);
+        tmp = avio_r8(bc);
         val= (val<<7) + (tmp&127);
     }while(tmp&128);
     return val;

libavformat/avs.c+12−12

@@ -62,11 +62,11 @@ static int avs_read_header(AVFormatContext * s, AVFormatParameters * ap) · 61 unmodified lines
62	s->ctx_flags \|= AVFMTCTX_NOHEADER;	62	s->ctx_flags \|= AVFMTCTX_NOHEADER;
63		63
64	url_fskip(s->pb, 4);	64	url_fskip(s->pb, 4);
65	avs->width = get_le16(s->pb);	65	avs->width = avio_rl16(s->pb);
66	avs->height = get_le16(s->pb);	66	avs->height = avio_rl16(s->pb);
67	avs->bits_per_sample = get_le16(s->pb);	67	avs->bits_per_sample = avio_rl16(s->pb);
68	avs->fps = get_le16(s->pb);	68	avs->fps = avio_rl16(s->pb);
69	avs->nb_frames = get_le32(s->pb);	69	avs->nb_frames = avio_rl32(s->pb);
70	avs->remaining_frame_size = 0;	70	avs->remaining_frame_size = 0;
71	avs->remaining_audio_size = 0;	71	avs->remaining_audio_size = 0;
72		72
@@ -104,7 +104,7 @@ avs_read_video_packet(AVFormatContext * s, AVPacket * pkt, · 31 unmodified lines
104	pkt->data[palette_size + 1] = type;	104	pkt->data[palette_size + 1] = type;
105	pkt->data[palette_size + 2] = size & 0xFF;	105	pkt->data[palette_size + 2] = size & 0xFF;
106	pkt->data[palette_size + 3] = (size >> 8) & 0xFF;	106	pkt->data[palette_size + 3] = (size >> 8) & 0xFF;
107	ret = get_buffer(s->pb, pkt->data + palette_size + 4, size - 4) + 4;	107	ret = avio_read(s->pb, pkt->data + palette_size + 4, size - 4) + 4;
108	if (ret < size) {	108	if (ret < size) {
109	av_free_packet(pkt);	109	av_free_packet(pkt);
110	return AVERROR(EIO);	110	return AVERROR(EIO);
@@ -154,20 +154,20 @@ static int avs_read_packet(AVFormatContext * s, AVPacket * pkt) · 43 unmodified lines
154		154
155	while (1) {	155	while (1) {
156	if (avs->remaining_frame_size <= 0) {	156	if (avs->remaining_frame_size <= 0) {
157	if (!get_le16(s->pb)) /* found EOF */	157	if (!avio_rl16(s->pb)) /* found EOF */
158	return AVERROR(EIO);	158	return AVERROR(EIO);
159	avs->remaining_frame_size = get_le16(s->pb) - 4;	159	avs->remaining_frame_size = avio_rl16(s->pb) - 4;
160	}	160	}
161		161
162	while (avs->remaining_frame_size > 0) {	162	while (avs->remaining_frame_size > 0) {
163	sub_type = get_byte(s->pb);	163	sub_type = avio_r8(s->pb);
164	type = get_byte(s->pb);	164	type = avio_r8(s->pb);
165	size = get_le16(s->pb);	165	size = avio_rl16(s->pb);
166	avs->remaining_frame_size -= size;	166	avs->remaining_frame_size -= size;
167		167
168	switch (type) {	168	switch (type) {
169	case AVS_PALETTE:	169	case AVS_PALETTE:
170	ret = get_buffer(s->pb, palette, size - 4);	170	ret = avio_read(s->pb, palette, size - 4);
171	if (ret < size - 4)	171	if (ret < size - 4)
172	return AVERROR(EIO);	172	return AVERROR(EIO);
173	palette_size = size;	173	palette_size = size;

libavformat/bethsoftvid.c+15−15

@@ -68,7 +68,7 @@ static int vid_read_header(AVFormatContext *s, · 67 unmodified lines
68	* int16s: always_512, nframes, width, height, delay, always_14	68	* int16s: always_512, nframes, width, height, delay, always_14
69	*/	69	*/
70	url_fseek(pb, 5, SEEK_CUR);	70	url_fseek(pb, 5, SEEK_CUR);
71	vid->nframes = get_le16(pb);	71	vid->nframes = avio_rl16(pb);
72		72
73	stream = av_new_stream(s, 0);	73	stream = av_new_stream(s, 0);
74	if (!stream)	74	if (!stream)
@@ -76,11 +76,11 @@ static int vid_read_header(AVFormatContext *s, · 1 unmodified line
76	av_set_pts_info(stream, 32, 1, 60); // 16 ms increments, i.e. 60 fps	76	av_set_pts_info(stream, 32, 1, 60); // 16 ms increments, i.e. 60 fps
77	stream->codec->codec_type = AVMEDIA_TYPE_VIDEO;	77	stream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
78	stream->codec->codec_id = CODEC_ID_BETHSOFTVID;	78	stream->codec->codec_id = CODEC_ID_BETHSOFTVID;
79	stream->codec->width = get_le16(pb);	79	stream->codec->width = avio_rl16(pb);
80	stream->codec->height = get_le16(pb);	80	stream->codec->height = avio_rl16(pb);
81	stream->codec->pix_fmt = PIX_FMT_PAL8;	81	stream->codec->pix_fmt = PIX_FMT_PAL8;
82	vid->bethsoft_global_delay = get_le16(pb);	82	vid->bethsoft_global_delay = avio_rl16(pb);
83	get_le16(pb);	83	avio_rl16(pb);
84		84
85	// done with video codec, set up audio codec	85	// done with video codec, set up audio codec
86	stream = av_new_stream(s, 0);	86	stream = av_new_stream(s, 0);
@@ -117,11 +117,11 @@ static int read_frame(BVID_DemuxContext vid, AVIOContext pb, AVPacket *pkt, · 30 unmodified lines
117	vidbuf_start[vidbuf_nbytes++] = block_type;	117	vidbuf_start[vidbuf_nbytes++] = block_type;
118		118
119	// get the video delay (next int16), and set the presentation time	119	// get the video delay (next int16), and set the presentation time
120	vid->video_pts += vid->bethsoft_global_delay + get_le16(pb);	120	vid->video_pts += vid->bethsoft_global_delay + avio_rl16(pb);
121		121
122	// set the y offset if it exists (decoder header data should be in data section)	122	// set the y offset if it exists (decoder header data should be in data section)
123	if(block_type == VIDEO_YOFF_P_FRAME){	123	if(block_type == VIDEO_YOFF_P_FRAME){
124	if(get_buffer(pb, &vidbuf_start[vidbuf_nbytes], 2) != 2)	124	if(avio_read(pb, &vidbuf_start[vidbuf_nbytes], 2) != 2)
125	goto fail;	125	goto fail;
126	vidbuf_nbytes += 2;	126	vidbuf_nbytes += 2;
127	}	127	}
@@ -131,21 +131,21 @@ static int read_frame(BVID_DemuxContext vid, AVIOContext pb, AVPacket *pkt, · 3 unmodified lines
131	if(!vidbuf_start)	131	if(!vidbuf_start)
132	return AVERROR(ENOMEM);	132	return AVERROR(ENOMEM);
133		133
134	code = get_byte(pb);	134	code = avio_r8(pb);
135	vidbuf_start[vidbuf_nbytes++] = code;	135	vidbuf_start[vidbuf_nbytes++] = code;
136		136
137	if(code >= 0x80){ // rle sequence	137	if(code >= 0x80){ // rle sequence
138	if(block_type == VIDEO_I_FRAME)	138	if(block_type == VIDEO_I_FRAME)
139	vidbuf_start[vidbuf_nbytes++] = get_byte(pb);	139	vidbuf_start[vidbuf_nbytes++] = avio_r8(pb);
140	} else if(code){ // plain sequence	140	} else if(code){ // plain sequence
141	if(get_buffer(pb, &vidbuf_start[vidbuf_nbytes], code) != code)	141	if(avio_read(pb, &vidbuf_start[vidbuf_nbytes], code) != code)
142	goto fail;	142	goto fail;
143	vidbuf_nbytes += code;	143	vidbuf_nbytes += code;
144	}	144	}
145	bytes_copied += code & 0x7F;	145	bytes_copied += code & 0x7F;
146	if(bytes_copied == npixels){ // sometimes no stop character is given, need to keep track of bytes copied	146	if(bytes_copied == npixels){ // sometimes no stop character is given, need to keep track of bytes copied
147	// may contain a 0 byte even if read all pixels	147	// may contain a 0 byte even if read all pixels
148	if(get_byte(pb))	148	if(avio_r8(pb))
149	url_fseek(pb, -1, SEEK_CUR);	149	url_fseek(pb, -1, SEEK_CUR);
150	break;	150	break;
151	}	151	}
@@ -182,7 +182,7 @@ static int vid_read_packet(AVFormatContext *s, · 30 unmodified lines
182	if(vid->is_finished \|\| url_feof(pb))	182	if(vid->is_finished \|\| url_feof(pb))
183	return AVERROR(EIO);	183	return AVERROR(EIO);
184		184
185	block_type = get_byte(pb);	185	block_type = avio_r8(pb);
186	switch(block_type){	186	switch(block_type){
187	case PALETTE_BLOCK:	187	case PALETTE_BLOCK:
188	url_fseek(pb, -1, SEEK_CUR); // include block type	188	url_fseek(pb, -1, SEEK_CUR); // include block type
@@ -195,12 +195,12 @@ static int vid_read_packet(AVFormatContext *s, · 6 unmodified lines
195	return ret_value;	195	return ret_value;
196		196
197	case FIRST_AUDIO_BLOCK:	197	case FIRST_AUDIO_BLOCK:
198	get_le16(pb);	198	avio_rl16(pb);
199	// soundblaster DAC used for sample rate, as on specification page (link above)	199	// soundblaster DAC used for sample rate, as on specification page (link above)
200	s->streams[1]->codec->sample_rate = 1000000 / (256 - get_byte(pb));	200	s->streams[1]->codec->sample_rate = 1000000 / (256 - avio_r8(pb));
201	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;	201	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;
202	case AUDIO_BLOCK:	202	case AUDIO_BLOCK:
203	audio_length = get_le16(pb);	203	audio_length = avio_rl16(pb);
204	ret_value = av_get_packet(pb, pkt, audio_length);	204	ret_value = av_get_packet(pb, pkt, audio_length);
205	pkt->stream_index = 1;	205	pkt->stream_index = 1;
206	return ret_value != audio_length ? AVERROR(EIO) : ret_value;	206	return ret_value != audio_length ? AVERROR(EIO) : ret_value;

libavformat/bfi.c+16−16

@@ -66,24 +66,24 @@ static int bfi_read_header(AVFormatContext * s, AVFormatParameters * ap) · 65 unmodified lines
66		66
67	/* Set the total number of frames. */	67	/* Set the total number of frames. */
68	url_fskip(pb, 8);	68	url_fskip(pb, 8);
69	chunk_header = get_le32(pb);	69	chunk_header = avio_rl32(pb);
70	bfi->nframes = get_le32(pb);	70	bfi->nframes = avio_rl32(pb);
71	get_le32(pb);	71	avio_rl32(pb);
72	get_le32(pb);	72	avio_rl32(pb);
73	get_le32(pb);	73	avio_rl32(pb);
74	fps = get_le32(pb);	74	fps = avio_rl32(pb);
75	url_fskip(pb, 12);	75	url_fskip(pb, 12);
76	vstream->codec->width = get_le32(pb);	76	vstream->codec->width = avio_rl32(pb);
77	vstream->codec->height = get_le32(pb);	77	vstream->codec->height = avio_rl32(pb);
78		78
79	/Load the palette to extradata /	79	/Load the palette to extradata /
80	url_fskip(pb, 8);	80	url_fskip(pb, 8);
81	vstream->codec->extradata = av_malloc(768);	81	vstream->codec->extradata = av_malloc(768);
82	vstream->codec->extradata_size = 768;	82	vstream->codec->extradata_size = 768;
83	get_buffer(pb, vstream->codec->extradata,	83	avio_read(pb, vstream->codec->extradata,
84	vstream->codec->extradata_size);	84	vstream->codec->extradata_size);
85		85
86	astream->codec->sample_rate = get_le32(pb);	86	astream->codec->sample_rate = avio_rl32(pb);
87		87
88	/* Set up the video codec... */	88	/* Set up the video codec... */
89	av_set_pts_info(vstream, 32, 1, fps);	89	av_set_pts_info(vstream, 32, 1, fps);
@@ -119,14 +119,14 @@ static int bfi_read_packet(AVFormatContext * s, AVPacket * pkt) · 29 unmodified lines
119	while(state != MKTAG('S','A','V','I')){	119	while(state != MKTAG('S','A','V','I')){
120	if (url_feof(pb))	120	if (url_feof(pb))
121	return AVERROR(EIO);	121	return AVERROR(EIO);
122	state = 256*state + get_byte(pb);	122	state = 256*state + avio_r8(pb);
123	}	123	}
124	/* Now that the chunk's location is confirmed, we proceed... */	124	/* Now that the chunk's location is confirmed, we proceed... */
125	chunk_size = get_le32(pb);	125	chunk_size = avio_rl32(pb);
126	get_le32(pb);	126	avio_rl32(pb);
127	audio_offset = get_le32(pb);	127	audio_offset = avio_rl32(pb);
128	get_le32(pb);	128	avio_rl32(pb);
129	video_offset = get_le32(pb);	129	video_offset = avio_rl32(pb);
130	audio_size = video_offset - audio_offset;	130	audio_size = video_offset - audio_offset;
131	bfi->video_size = chunk_size - video_offset;	131	bfi->video_size = chunk_size - video_offset;
132		132

libavformat/bink.c+15−15

@@ -82,17 +82,17 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 81 unmodified lines
82	if (!vst)	82	if (!vst)
83	return AVERROR(ENOMEM);	83	return AVERROR(ENOMEM);
84		84
85	vst->codec->codec_tag = get_le32(pb);	85	vst->codec->codec_tag = avio_rl32(pb);
86		86
87	bink->file_size = get_le32(pb) + 8;	87	bink->file_size = avio_rl32(pb) + 8;
88	vst->duration = get_le32(pb);	88	vst->duration = avio_rl32(pb);
89		89
90	if (vst->duration > 1000000) {	90	if (vst->duration > 1000000) {
91	av_log(s, AV_LOG_ERROR, "invalid header: more than 1000000 frames\n");	91	av_log(s, AV_LOG_ERROR, "invalid header: more than 1000000 frames\n");
92	return AVERROR(EIO);	92	return AVERROR(EIO);
93	}	93	}
94		94
95	if (get_le32(pb) > bink->file_size) {	95	if (avio_rl32(pb) > bink->file_size) {
96	av_log(s, AV_LOG_ERROR,	96	av_log(s, AV_LOG_ERROR,
97	"invalid header: largest frame size greater than file size\n");	97	"invalid header: largest frame size greater than file size\n");
98	return AVERROR(EIO);	98	return AVERROR(EIO);
@@ -100,11 +100,11 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 1 unmodified line
100		100
101	url_fskip(pb, 4);	101	url_fskip(pb, 4);
102		102
103	vst->codec->width = get_le32(pb);	103	vst->codec->width = avio_rl32(pb);
104	vst->codec->height = get_le32(pb);	104	vst->codec->height = avio_rl32(pb);
105		105
106	fps_num = get_le32(pb);	106	fps_num = avio_rl32(pb);
107	fps_den = get_le32(pb);	107	fps_den = avio_rl32(pb);
108	if (fps_num == 0 \|\| fps_den == 0) {	108	if (fps_num == 0 \|\| fps_den == 0) {
109	av_log(s, AV_LOG_ERROR, "invalid header: invalid fps (%d/%d)\n", fps_num, fps_den);	109	av_log(s, AV_LOG_ERROR, "invalid header: invalid fps (%d/%d)\n", fps_num, fps_den);
110	return AVERROR(EIO);	110	return AVERROR(EIO);
@@ -115,9 +115,9 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 4 unmodified lines
115	vst->codec->codec_id = CODEC_ID_BINKVIDEO;	115	vst->codec->codec_id = CODEC_ID_BINKVIDEO;
116	vst->codec->extradata = av_mallocz(4 + FF_INPUT_BUFFER_PADDING_SIZE);	116	vst->codec->extradata = av_mallocz(4 + FF_INPUT_BUFFER_PADDING_SIZE);
117	vst->codec->extradata_size = 4;	117	vst->codec->extradata_size = 4;
118	get_buffer(pb, vst->codec->extradata, 4);	118	avio_read(pb, vst->codec->extradata, 4);
119		119
120	bink->num_audio_tracks = get_le32(pb);	120	bink->num_audio_tracks = avio_rl32(pb);
121		121
122	if (bink->num_audio_tracks > BINK_MAX_AUDIO_TRACKS) {	122	if (bink->num_audio_tracks > BINK_MAX_AUDIO_TRACKS) {
123	av_log(s, AV_LOG_ERROR,	123	av_log(s, AV_LOG_ERROR,
@@ -135,9 +135,9 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 11 unmodified lines
135	return AVERROR(ENOMEM);	135	return AVERROR(ENOMEM);
136	ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;	136	ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
137	ast->codec->codec_tag = 0;	137	ast->codec->codec_tag = 0;
138	ast->codec->sample_rate = get_le16(pb);	138	ast->codec->sample_rate = avio_rl16(pb);
139	av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);	139	av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
140	flags = get_le16(pb);	140	flags = avio_rl16(pb);
141	ast->codec->codec_id = flags & BINK_AUD_USEDCT ?	141	ast->codec->codec_id = flags & BINK_AUD_USEDCT ?
142	CODEC_ID_BINKAUDIO_DCT : CODEC_ID_BINKAUDIO_RDFT;	142	CODEC_ID_BINKAUDIO_DCT : CODEC_ID_BINKAUDIO_RDFT;
143	ast->codec->channels = flags & BINK_AUD_STEREO ? 2 : 1;	143	ast->codec->channels = flags & BINK_AUD_STEREO ? 2 : 1;
@@ -147,14 +147,14 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 3 unmodified lines
147	}	147	}
148		148
149	/* frame index table */	149	/* frame index table */
150	next_pos = get_le32(pb);	150	next_pos = avio_rl32(pb);
151	for (i = 0; i < vst->duration; i++) {	151	for (i = 0; i < vst->duration; i++) {
152	pos = next_pos;	152	pos = next_pos;
153	if (i == vst->duration - 1) {	153	if (i == vst->duration - 1) {
154	next_pos = bink->file_size;	154	next_pos = bink->file_size;
155	keyframe = 0;	155	keyframe = 0;
156	} else {	156	} else {
157	next_pos = get_le32(pb);	157	next_pos = avio_rl32(pb);
158	keyframe = pos & 1;	158	keyframe = pos & 1;
159	}	159	}
160	pos &= ~1;	160	pos &= ~1;
@@ -201,7 +201,7 @@ static int read_packet(AVFormatContext s, AVPacket pkt) · 40 unmodified lines
201	}	201	}
202		202
203	while (bink->current_track < bink->num_audio_tracks) {	203	while (bink->current_track < bink->num_audio_tracks) {
204	uint32_t audio_size = get_le32(pb);	204	uint32_t audio_size = avio_rl32(pb);
205	if (audio_size > bink->remain_packet_size - 4) {	205	if (audio_size > bink->remain_packet_size - 4) {
206	av_log(s, AV_LOG_ERROR,	206	av_log(s, AV_LOG_ERROR,
207	"frame %"PRId64": audio size in header (%u) > size of packet left (%u)\n",	207	"frame %"PRId64": audio size in header (%u) > size of packet left (%u)\n",

libavformat/c93.c+9−9

@@ -66,9 +66,9 @@ static int read_header(AVFormatContext *s, · 65 unmodified lines
66	int framecount = 0;	66	int framecount = 0;
67		67
68	for (i = 0; i < 512; i++) {	68	for (i = 0; i < 512; i++) {
69	c93->block_records[i].index = get_le16(pb);	69	c93->block_records[i].index = avio_rl16(pb);
70	c93->block_records[i].length = get_byte(pb);	70	c93->block_records[i].length = avio_r8(pb);
71	c93->block_records[i].frames = get_byte(pb);	71	c93->block_records[i].frames = avio_r8(pb);
72	if (c93->block_records[i].frames > 32) {	72	if (c93->block_records[i].frames > 32) {
73	av_log(s, AV_LOG_ERROR, "too many frames in block\n");	73	av_log(s, AV_LOG_ERROR, "too many frames in block\n");
74	return AVERROR_INVALIDDATA;	74	return AVERROR_INVALIDDATA;
@@ -114,7 +114,7 @@ static int read_packet(AVFormatContext s, AVPacket pkt) · 39 unmodified lines
114	if (c93->next_pkt_is_audio) {	114	if (c93->next_pkt_is_audio) {
115	c93->current_frame++;	115	c93->current_frame++;
116	c93->next_pkt_is_audio = 0;	116	c93->next_pkt_is_audio = 0;
117	datasize = get_le16(pb);	117	datasize = avio_rl16(pb);
118	if (datasize > 42) {	118	if (datasize > 42) {
119	if (!c93->audio) {	119	if (!c93->audio) {
120	c93->audio = av_new_stream(s, 1);	120	c93->audio = av_new_stream(s, 1);
@@ -142,13 +142,13 @@ static int read_packet(AVFormatContext s, AVPacket pkt) · 21 unmodified lines
142	if (c93->current_frame == 0) {	142	if (c93->current_frame == 0) {
143	url_fseek(pb, br->index * 2048, SEEK_SET);	143	url_fseek(pb, br->index * 2048, SEEK_SET);
144	for (i = 0; i < 32; i++) {	144	for (i = 0; i < 32; i++) {
145	c93->frame_offsets[i] = get_le32(pb);	145	c93->frame_offsets[i] = avio_rl32(pb);
146	}	146	}
147	}	147	}
148		148
149	url_fseek(pb,br->index * 2048 +	149	url_fseek(pb,br->index * 2048 +
150	c93->frame_offsets[c93->current_frame], SEEK_SET);	150	c93->frame_offsets[c93->current_frame], SEEK_SET);
151	datasize = get_le16(pb); /* video frame size */	151	datasize = avio_rl16(pb); /* video frame size */
152		152
153	ret = av_new_packet(pkt, datasize + 768 + 1);	153	ret = av_new_packet(pkt, datasize + 768 + 1);
154	if (ret < 0)	154	if (ret < 0)
@@ -156,13 +156,13 @@ static int read_packet(AVFormatContext s, AVPacket pkt) · 1 unmodified line
156	pkt->data[0] = 0;	156	pkt->data[0] = 0;
157	pkt->size = datasize + 1;	157	pkt->size = datasize + 1;
158		158
159	ret = get_buffer(pb, pkt->data + 1, datasize);	159	ret = avio_read(pb, pkt->data + 1, datasize);
160	if (ret < datasize) {	160	if (ret < datasize) {
161	ret = AVERROR(EIO);	161	ret = AVERROR(EIO);
162	goto fail;	162	goto fail;
163	}	163	}
164		164
165	datasize = get_le16(pb); /* palette size */	165	datasize = avio_rl16(pb); /* palette size */
166	if (datasize) {	166	if (datasize) {
167	if (datasize != 768) {	167	if (datasize != 768) {
168	av_log(s, AV_LOG_ERROR, "invalid palette size %u\n", datasize);	168	av_log(s, AV_LOG_ERROR, "invalid palette size %u\n", datasize);
@@ -170,7 +170,7 @@ static int read_packet(AVFormatContext s, AVPacket pkt) · 1 unmodified line
170	goto fail;	170	goto fail;
171	}	171	}
172	pkt->data[0] \|= C93_HAS_PALETTE;	172	pkt->data[0] \|= C93_HAS_PALETTE;
173	ret = get_buffer(pb, pkt->data + pkt->size, datasize);	173	ret = avio_read(pb, pkt->data + pkt->size, datasize);
174	if (ret < datasize) {	174	if (ret < datasize) {
175	ret = AVERROR(EIO);	175	ret = AVERROR(EIO);
176	goto fail;	176	goto fail;

libavformat/cafdec.c+18−18

@@ -65,14 +65,14 @@ static int read_desc_chunk(AVFormatContext *s) · 64 unmodified lines
65		65
66	/* parse format description */	66	/* parse format description */
67	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;	67	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
68	st->codec->sample_rate = av_int2dbl(get_be64(pb));	68	st->codec->sample_rate = av_int2dbl(avio_rb64(pb));
69	st->codec->codec_tag = get_be32(pb);	69	st->codec->codec_tag = avio_rb32(pb);
70	flags = get_be32(pb);	70	flags = avio_rb32(pb);
71	caf->bytes_per_packet = get_be32(pb);	71	caf->bytes_per_packet = avio_rb32(pb);
72	st->codec->block_align = caf->bytes_per_packet;	72	st->codec->block_align = caf->bytes_per_packet;
73	caf->frames_per_packet = get_be32(pb);	73	caf->frames_per_packet = avio_rb32(pb);
74	st->codec->channels = get_be32(pb);	74	st->codec->channels = avio_rb32(pb);
75	st->codec->bits_per_coded_sample = get_be32(pb);	75	st->codec->bits_per_coded_sample = avio_rb32(pb);
76		76
77	/* calculate bit rate for constant size packets */	77	/* calculate bit rate for constant size packets */
78	if (caf->frames_per_packet > 0 && caf->bytes_per_packet > 0) {	78	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) · 48 unmodified lines
127	st->codec->extradata = av_mallocz(ALAC_HEADER + FF_INPUT_BUFFER_PADDING_SIZE);	127	st->codec->extradata = av_mallocz(ALAC_HEADER + FF_INPUT_BUFFER_PADDING_SIZE);
128	if (!st->codec->extradata)	128	if (!st->codec->extradata)
129	return AVERROR(ENOMEM);	129	return AVERROR(ENOMEM);
130	get_buffer(pb, st->codec->extradata, ALAC_HEADER);	130	avio_read(pb, st->codec->extradata, ALAC_HEADER);
131	st->codec->extradata_size = ALAC_HEADER;	131	st->codec->extradata_size = ALAC_HEADER;
132	url_fskip(pb, size - ALAC_PREAMBLE - ALAC_HEADER);	132	url_fskip(pb, size - ALAC_PREAMBLE - ALAC_HEADER);
133	} else {	133	} else {
134	st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);	134	st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
135	if (!st->codec->extradata)	135	if (!st->codec->extradata)
136	return AVERROR(ENOMEM);	136	return AVERROR(ENOMEM);
137	get_buffer(pb, st->codec->extradata, size);	137	avio_read(pb, st->codec->extradata, size);
138	st->codec->extradata_size = size;	138	st->codec->extradata_size = size;
139	}	139	}
140		140
@@ -152,13 +152,13 @@ static int read_pakt_chunk(AVFormatContext *s, int64_t size) · 11 unmodified lines
152		152
153	ccount = url_ftell(pb);	153	ccount = url_ftell(pb);
154		154
155	num_packets = get_be64(pb);	155	num_packets = avio_rb64(pb);
156	if (num_packets < 0 \|\| INT32_MAX / sizeof(AVIndexEntry) < num_packets)	156	if (num_packets < 0 \|\| INT32_MAX / sizeof(AVIndexEntry) < num_packets)
157	return AVERROR_INVALIDDATA;	157	return AVERROR_INVALIDDATA;
158		158
159	st->nb_frames = get_be64(pb); /* valid frames */	159	st->nb_frames = avio_rb64(pb); /* valid frames */
160	st->nb_frames += get_be32(pb); /* priming frames */	160	st->nb_frames += avio_rb32(pb); /* priming frames */
161	st->nb_frames += get_be32(pb); /* remainder frames */	161	st->nb_frames += avio_rb32(pb); /* remainder frames */
162		162
163	st->duration = 0;	163	st->duration = 0;
164	for (i = 0; i < num_packets; i++) {	164	for (i = 0; i < num_packets; i++) {
@@ -181,7 +181,7 @@ static void read_info_chunk(AVFormatContext *s, int64_t size) · 16 unmodified lines
181	{	181	{
182	AVIOContext *pb = s->pb;	182	AVIOContext *pb = s->pb;
183	unsigned int i;	183	unsigned int i;
184	unsigned int nb_entries = get_be32(pb);	184	unsigned int nb_entries = avio_rb32(pb);
185	for (i = 0; i < nb_entries; i++) {	185	for (i = 0; i < nb_entries; i++) {
186	char key[32];	186	char key[32];
187	char value[1024];	187	char value[1024];
@@ -204,11 +204,11 @@ static int read_header(AVFormatContext *s, · 16 unmodified lines
204	url_fskip(pb, 8); /* magic, version, file flags */	204	url_fskip(pb, 8); /* magic, version, file flags */
205		205
206	/* audio description chunk */	206	/* audio description chunk */
207	if (get_be32(pb) != MKBETAG('d','e','s','c')) {	207	if (avio_rb32(pb) != MKBETAG('d','e','s','c')) {
208	av_log(s, AV_LOG_ERROR, "desc chunk not present\n");	208	av_log(s, AV_LOG_ERROR, "desc chunk not present\n");
209	return AVERROR_INVALIDDATA;	209	return AVERROR_INVALIDDATA;
210	}	210	}
211	size = get_be64(pb);	211	size = avio_rb64(pb);
212	if (size != 32)	212	if (size != 32)
213	return AVERROR_INVALIDDATA;	213	return AVERROR_INVALIDDATA;
214		214
@@ -226,8 +226,8 @@ static int read_header(AVFormatContext *s, · 11 unmodified lines
226	if (found_data && (caf->data_size < 0 \|\| url_is_streamed(pb)))	226	if (found_data && (caf->data_size < 0 \|\| url_is_streamed(pb)))
227	break;	227	break;
228		228
229	tag = get_be32(pb);	229	tag = avio_rb32(pb);
230	size = get_be64(pb);	230	size = avio_rb64(pb);
231	if (url_feof(pb))	231	if (url_feof(pb))
232	break;	232	break;
233		233

libavformat/daud.c+2−2

@@ -40,8 +40,8 @@ static int daud_packet(AVFormatContext s, AVPacket pkt) { · 39 unmodified lines
40	int ret, size;	40	int ret, size;
41	if (url_feof(pb))	41	if (url_feof(pb))
42	return AVERROR(EIO);	42	return AVERROR(EIO);
43	size = get_be16(pb);	43	size = avio_rb16(pb);
44	get_be16(pb); // unknown	44	avio_rb16(pb); // unknown
45	ret = av_get_packet(pb, pkt, size);	45	ret = av_get_packet(pb, pkt, size);
46	pkt->stream_index = 0;	46	pkt->stream_index = 0;
47	return ret;	47	return ret;

libavformat/dsicin.c+15−15

@@ -73,16 +73,16 @@ static int cin_probe(AVProbeData *p) · 72 unmodified lines
73	static int cin_read_file_header(CinDemuxContext cin, AVIOContext pb) {	73	static int cin_read_file_header(CinDemuxContext cin, AVIOContext pb) {
74	CinFileHeader *hdr = &cin->file_header;	74	CinFileHeader *hdr = &cin->file_header;
75		75
76	if (get_le32(pb) != 0x55AA0000)	76	if (avio_rl32(pb) != 0x55AA0000)
77	return AVERROR_INVALIDDATA;	77	return AVERROR_INVALIDDATA;
78		78
79	hdr->video_frame_size = get_le32(pb);	79	hdr->video_frame_size = avio_rl32(pb);
80	hdr->video_frame_width = get_le16(pb);	80	hdr->video_frame_width = avio_rl16(pb);
81	hdr->video_frame_height = get_le16(pb);	81	hdr->video_frame_height = avio_rl16(pb);
82	hdr->audio_frequency = get_le32(pb);	82	hdr->audio_frequency = avio_rl32(pb);
83	hdr->audio_bits = get_byte(pb);	83	hdr->audio_bits = avio_r8(pb);
84	hdr->audio_stereo = get_byte(pb);	84	hdr->audio_stereo = avio_r8(pb);
85	hdr->audio_frame_size = get_le16(pb);	85	hdr->audio_frame_size = avio_rl16(pb);
86		86
87	if (hdr->audio_frequency != 22050 \|\| hdr->audio_bits != 16 \|\| hdr->audio_stereo != 0)	87	if (hdr->audio_frequency != 22050 \|\| hdr->audio_bits != 16 \|\| hdr->audio_stereo != 0)
88	return AVERROR_INVALIDDATA;	88	return AVERROR_INVALIDDATA;
@@ -141,16 +141,16 @@ static int cin_read_header(AVFormatContext s, AVFormatParameters ap) · 52 unmodified lines
141	static int cin_read_frame_header(CinDemuxContext cin, AVIOContext pb) {	141	static int cin_read_frame_header(CinDemuxContext cin, AVIOContext pb) {
142	CinFrameHeader *hdr = &cin->frame_header;	142	CinFrameHeader *hdr = &cin->frame_header;
143		143
144	hdr->video_frame_type = get_byte(pb);	144	hdr->video_frame_type = avio_r8(pb);
145	hdr->audio_frame_type = get_byte(pb);	145	hdr->audio_frame_type = avio_r8(pb);
146	hdr->pal_colors_count = get_le16(pb);	146	hdr->pal_colors_count = avio_rl16(pb);
147	hdr->video_frame_size = get_le32(pb);	147	hdr->video_frame_size = avio_rl32(pb);
148	hdr->audio_frame_size = get_le32(pb);	148	hdr->audio_frame_size = avio_rl32(pb);
149		149
150	if (url_feof(pb) \|\| url_ferror(pb))	150	if (url_feof(pb) \|\| url_ferror(pb))
151	return AVERROR(EIO);	151	return AVERROR(EIO);
152		152
153	if (get_le32(pb) != 0xAA55AA55)	153	if (avio_rl32(pb) != 0xAA55AA55)
154	return AVERROR_INVALIDDATA;	154	return AVERROR_INVALIDDATA;
155		155
156	return 0;	156	return 0;
@@ -191,7 +191,7 @@ static int cin_read_packet(AVFormatContext s, AVPacket pkt) · 34 unmodified lines
191	pkt->data[2] = hdr->pal_colors_count >> 8;	191	pkt->data[2] = hdr->pal_colors_count >> 8;
192	pkt->data[3] = hdr->video_frame_type;	192	pkt->data[3] = hdr->video_frame_type;
193		193
194	ret = get_buffer(pb, &pkt->data[4], pkt_size);	194	ret = avio_read(pb, &pkt->data[4], pkt_size);
195	if (ret < 0) {	195	if (ret < 0) {
196	av_free_packet(pkt);	196	av_free_packet(pkt);
197	return ret;	197	return ret;

libavformat/dv.c+5−5

@@ -410,7 +410,7 @@ static int dv_read_header(AVFormatContext *s, · 409 unmodified lines
410	if (!c->dv_demux)	410	if (!c->dv_demux)
411	return -1;	411	return -1;
412		412
413	state = get_be32(s->pb);	413	state = avio_rb32(s->pb);
414	while ((state & 0xffffff7f) != 0x1f07003f) {	414	while ((state & 0xffffff7f) != 0x1f07003f) {
415	if (url_feof(s->pb)) {	415	if (url_feof(s->pb)) {
416	av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");	416	av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");
@@ -420,14 +420,14 @@ static int dv_read_header(AVFormatContext *s, · 3 unmodified lines
420	marker_pos = url_ftell(s->pb);	420	marker_pos = url_ftell(s->pb);
421	if (state == 0xff3f0701 && url_ftell(s->pb) - marker_pos == 80) {	421	if (state == 0xff3f0701 && url_ftell(s->pb) - marker_pos == 80) {
422	url_fseek(s->pb, -163, SEEK_CUR);	422	url_fseek(s->pb, -163, SEEK_CUR);
423	state = get_be32(s->pb);	423	state = avio_rb32(s->pb);
424	break;	424	break;
425	}	425	}
426	state = (state << 8) \| get_byte(s->pb);	426	state = (state << 8) \| avio_r8(s->pb);
427	}	427	}
428	AV_WB32(c->buf, state);	428	AV_WB32(c->buf, state);
429		429
430	if (get_buffer(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) <= 0 \|\|	430	if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) <= 0 \|\|
431	url_fseek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0)	431	url_fseek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0)
432	return AVERROR(EIO);	432	return AVERROR(EIO);
433		433
@@ -455,7 +455,7 @@ static int dv_read_packet(AVFormatContext s, AVPacket pkt) · 21 unmodified lines
455	if (!c->dv_demux->sys)	455	if (!c->dv_demux->sys)
456	return AVERROR(EIO);	456	return AVERROR(EIO);
457	size = c->dv_demux->sys->frame_size;	457	size = c->dv_demux->sys->frame_size;
458	if (get_buffer(s->pb, c->buf, size) <= 0)	458	if (avio_read(s->pb, c->buf, size) <= 0)
459	return AVERROR(EIO);	459	return AVERROR(EIO);
460		460
461	size = dv_produce_packet(c->dv_demux, pkt, c->buf, size);	461	size = dv_produce_packet(c->dv_demux, pkt, c->buf, size);

libavformat/dxa.c+15−15

@@ -61,17 +61,17 @@ static int dxa_read_header(AVFormatContext s, AVFormatParameters ap) · 60 unmodified lines
61	int num, den;	61	int num, den;
62	int flags;	62	int flags;
63		63
64	tag = get_le32(pb);	64	tag = avio_rl32(pb);
65	if (tag != MKTAG('D', 'E', 'X', 'A'))	65	if (tag != MKTAG('D', 'E', 'X', 'A'))
66	return -1;	66	return -1;
67	flags = get_byte(pb);	67	flags = avio_r8(pb);
68	c->frames = get_be16(pb);	68	c->frames = avio_rb16(pb);
69	if(!c->frames){	69	if(!c->frames){
70	av_log(s, AV_LOG_ERROR, "File contains no frames ???\n");	70	av_log(s, AV_LOG_ERROR, "File contains no frames ???\n");
71	return -1;	71	return -1;
72	}	72	}
73		73
74	fps = get_be32(pb);	74	fps = avio_rb32(pb);
75	if(fps > 0){	75	if(fps > 0){
76	den = 1000;	76	den = 1000;
77	num = fps;	77	num = fps;
@@ -82,8 +82,8 @@ static int dxa_read_header(AVFormatContext s, AVFormatParameters ap) · 4 unmodified lines
82	den = 10;	82	den = 10;
83	num = 1;	83	num = 1;
84	}	84	}
85	w = get_be16(pb);	85	w = avio_rb16(pb);
86	h = get_be16(pb);	86	h = avio_rb16(pb);
87	c->has_sound = 0;	87	c->has_sound = 0;
88		88
89	st = av_new_stream(s, 0);	89	st = av_new_stream(s, 0);
@@ -91,13 +91,13 @@ static int dxa_read_header(AVFormatContext s, AVFormatParameters ap) · 1 unmodified line
91	return -1;	91	return -1;
92		92
93	// Parse WAV data header	93	// Parse WAV data header
94	if(get_le32(pb) == MKTAG('W', 'A', 'V', 'E')){	94	if(avio_rl32(pb) == MKTAG('W', 'A', 'V', 'E')){
95	uint32_t size, fsize;	95	uint32_t size, fsize;
96	c->has_sound = 1;	96	c->has_sound = 1;
97	size = get_be32(pb);	97	size = avio_rb32(pb);
98	c->vidpos = url_ftell(pb) + size;	98	c->vidpos = url_ftell(pb) + size;
99	url_fskip(pb, 16);	99	url_fskip(pb, 16);
100	fsize = get_le32(pb);	100	fsize = avio_rl32(pb);
101		101
102	ast = av_new_stream(s, 0);	102	ast = av_new_stream(s, 0);
103	if (!ast)	103	if (!ast)
@@ -105,8 +105,8 @@ static int dxa_read_header(AVFormatContext s, AVFormatParameters ap) · 1 unmodified line
105	ff_get_wav_header(pb, ast->codec, fsize);	105	ff_get_wav_header(pb, ast->codec, fsize);
106	// find 'data' chunk	106	// find 'data' chunk
107	while(url_ftell(pb) < c->vidpos && !url_feof(pb)){	107	while(url_ftell(pb) < c->vidpos && !url_feof(pb)){
108	tag = get_le32(pb);	108	tag = avio_rl32(pb);
109	fsize = get_le32(pb);	109	fsize = avio_rl32(pb);
110	if(tag == MKTAG('d', 'a', 't', 'a')) break;	110	if(tag == MKTAG('d', 'a', 't', 'a')) break;
111	url_fskip(pb, fsize);	111	url_fskip(pb, fsize);
112	}	112	}
@@ -163,7 +163,7 @@ static int dxa_read_packet(AVFormatContext s, AVPacket pkt) · 50 unmodified lines
163	}	163	}
164	url_fseek(s->pb, c->vidpos, SEEK_SET);	164	url_fseek(s->pb, c->vidpos, SEEK_SET);
165	while(!url_feof(s->pb) && c->frames){	165	while(!url_feof(s->pb) && c->frames){
166	get_buffer(s->pb, buf, 4);	166	avio_read(s->pb, buf, 4);
167	switch(AV_RL32(buf)){	167	switch(AV_RL32(buf)){
168	case MKTAG('N', 'U', 'L', 'L'):	168	case MKTAG('N', 'U', 'L', 'L'):
169	if(av_new_packet(pkt, 4 + pal_size) < 0)	169	if(av_new_packet(pkt, 4 + pal_size) < 0)
@@ -178,10 +178,10 @@ static int dxa_read_packet(AVFormatContext s, AVPacket pkt) · 8 unmodified lines
178	case MKTAG('C', 'M', 'A', 'P'):	178	case MKTAG('C', 'M', 'A', 'P'):
179	pal_size = 768+4;	179	pal_size = 768+4;
180	memcpy(pal, buf, 4);	180	memcpy(pal, buf, 4);
181	get_buffer(s->pb, pal + 4, 768);	181	avio_read(s->pb, pal + 4, 768);
182	break;	182	break;
183	case MKTAG('F', 'R', 'A', 'M'):	183	case MKTAG('F', 'R', 'A', 'M'):
184	get_buffer(s->pb, buf + 4, DXA_EXTRA_SIZE - 4);	184	avio_read(s->pb, buf + 4, DXA_EXTRA_SIZE - 4);
185	size = AV_RB32(buf + 5);	185	size = AV_RB32(buf + 5);
186	if(size > 0xFFFFFF){	186	if(size > 0xFFFFFF){
187	av_log(s, AV_LOG_ERROR, "Frame size is too big: %d\n", size);	187	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) · 2 unmodified lines
190	if(av_new_packet(pkt, size + DXA_EXTRA_SIZE + pal_size) < 0)	190	if(av_new_packet(pkt, size + DXA_EXTRA_SIZE + pal_size) < 0)
191	return AVERROR(ENOMEM);	191	return AVERROR(ENOMEM);
192	memcpy(pkt->data + pal_size, buf, DXA_EXTRA_SIZE);	192	memcpy(pkt->data + pal_size, buf, DXA_EXTRA_SIZE);
193	ret = get_buffer(s->pb, pkt->data + DXA_EXTRA_SIZE + pal_size, size);	193	ret = avio_read(s->pb, pkt->data + DXA_EXTRA_SIZE + pal_size, size);
194	if(ret != size){	194	if(ret != size){
195	av_free_packet(pkt);	195	av_free_packet(pkt);
196	return AVERROR(EIO);	196	return AVERROR(EIO);

libavformat/eacdata.c+2−2

@@ -51,7 +51,7 @@ static int cdata_read_header(AVFormatContext s, AVFormatParameters ap) · 50 unmodified lines
51	unsigned int sample_rate, header;	51	unsigned int sample_rate, header;
52	AVStream *st;	52	AVStream *st;
53		53
54	header = get_be16(pb);	54	header = avio_rb16(pb);
55	switch (header) {	55	switch (header) {
56	case 0x0400: cdata->channels = 1; break;	56	case 0x0400: cdata->channels = 1; break;
57	case 0x0404: cdata->channels = 2; break;	57	case 0x0404: cdata->channels = 2; break;
@@ -61,7 +61,7 @@ static int cdata_read_header(AVFormatContext s, AVFormatParameters ap) · 3 unmodified lines
61	return -1;	61	return -1;
62	};	62	};
63		63
64	sample_rate = get_be16(pb);	64	sample_rate = avio_rb16(pb);
65	url_fskip(pb, 12);	65	url_fskip(pb, 12);
66		66
67	st = av_new_stream(s, 0);	67	st = av_new_stream(s, 0);

libavformat/electronicarts.c+22−22

@@ -82,11 +82,11 @@ static uint32_t read_arbitary(AVIOContext *pb) { · 81 unmodified lines
82	int i;	82	int i;
83	uint32_t word;	83	uint32_t word;
84		84
85	size = get_byte(pb);	85	size = avio_r8(pb);
86		86
87	word = 0;	87	word = 0;
88	for (i = 0; i < size; i++) {	88	for (i = 0; i < size; i++) {
89	byte = get_byte(pb);	89	byte = avio_r8(pb);
90	word <<= 8;	90	word <<= 8;
91	word \|= byte;	91	word \|= byte;
92	}	92	}
@@ -112,7 +112,7 @@ static int process_audio_header_elements(AVFormatContext *s) · 19 unmodified lines
112	while (!url_feof(pb) && inHeader) {	112	while (!url_feof(pb) && inHeader) {
113	int inSubheader;	113	int inSubheader;
114	uint8_t byte;	114	uint8_t byte;
115	byte = get_byte(pb);	115	byte = avio_r8(pb);
116		116
117	switch (byte) {	117	switch (byte) {
118	case 0xFD:	118	case 0xFD:
@@ -120,7 +120,7 @@ static int process_audio_header_elements(AVFormatContext *s) · 1 unmodified line
120	inSubheader = 1;	120	inSubheader = 1;
121	while (!url_feof(pb) && inSubheader) {	121	while (!url_feof(pb) && inSubheader) {
122	uint8_t subbyte;	122	uint8_t subbyte;
123	subbyte = get_byte(pb);	123	subbyte = avio_r8(pb);
124		124
125	switch (subbyte) {	125	switch (subbyte) {
126	case 0x80:	126	case 0x80:
@@ -218,10 +218,10 @@ static int process_audio_header_eacs(AVFormatContext *s) · 91 unmodified lines
218	AVIOContext *pb = s->pb;	218	AVIOContext *pb = s->pb;
219	int compression_type;	219	int compression_type;
220		220
221	ea->sample_rate = ea->big_endian ? get_be32(pb) : get_le32(pb);	221	ea->sample_rate = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);
222	ea->bytes = get_byte(pb); /* 1=8-bit, 2=16-bit */	222	ea->bytes = avio_r8(pb); /* 1=8-bit, 2=16-bit */
223	ea->num_channels = get_byte(pb);	223	ea->num_channels = avio_r8(pb);
224	compression_type = get_byte(pb);	224	compression_type = avio_r8(pb);
225	url_fskip(pb, 13);	225	url_fskip(pb, 13);
226		226
227	switch (compression_type) {	227	switch (compression_type) {
@@ -249,9 +249,9 @@ static int process_audio_header_sead(AVFormatContext *s) · 21 unmodified lines
249	EaDemuxContext *ea = s->priv_data;	249	EaDemuxContext *ea = s->priv_data;
250	AVIOContext *pb = s->pb;	250	AVIOContext *pb = s->pb;
251		251
252	ea->sample_rate = get_le32(pb);	252	ea->sample_rate = avio_rl32(pb);
253	ea->bytes = get_le32(pb); /* 1=8-bit, 2=16-bit */	253	ea->bytes = avio_rl32(pb); /* 1=8-bit, 2=16-bit */
254	ea->num_channels = get_le32(pb);	254	ea->num_channels = avio_rl32(pb);
255	ea->audio_codec = CODEC_ID_ADPCM_IMA_EA_SEAD;	255	ea->audio_codec = CODEC_ID_ADPCM_IMA_EA_SEAD;
256		256
257	return 1;	257	return 1;
@@ -262,8 +262,8 @@ static int process_video_header_mdec(AVFormatContext *s) · 4 unmodified lines
262	EaDemuxContext *ea = s->priv_data;	262	EaDemuxContext *ea = s->priv_data;
263	AVIOContext *pb = s->pb;	263	AVIOContext *pb = s->pb;
264	url_fskip(pb, 4);	264	url_fskip(pb, 4);
265	ea->width = get_le16(pb);	265	ea->width = avio_rl16(pb);
266	ea->height = get_le16(pb);	266	ea->height = avio_rl16(pb);
267	ea->time_base = (AVRational){1,15};	267	ea->time_base = (AVRational){1,15};
268	ea->video_codec = CODEC_ID_MDEC;	268	ea->video_codec = CODEC_ID_MDEC;
269	return 1;	269	return 1;
@@ -275,8 +275,8 @@ static int process_video_header_vp6(AVFormatContext *s) · 5 unmodified lines
275	AVIOContext *pb = s->pb;	275	AVIOContext *pb = s->pb;
276		276
277	url_fskip(pb, 16);	277	url_fskip(pb, 16);
278	ea->time_base.den = get_le32(pb);	278	ea->time_base.den = avio_rl32(pb);
279	ea->time_base.num = get_le32(pb);	279	ea->time_base.num = avio_rl32(pb);
280	ea->video_codec = CODEC_ID_VP6;	280	ea->video_codec = CODEC_ID_VP6;
281		281
282	return 1;	282	return 1;
@@ -296,8 +296,8 @@ static int process_ea_header(AVFormatContext *s) { · 13 unmodified lines
296	unsigned int startpos = url_ftell(pb);	296	unsigned int startpos = url_ftell(pb);
297	int err = 0;	297	int err = 0;
298		298
299	blockid = get_le32(pb);	299	blockid = avio_rl32(pb);
300	size = get_le32(pb);	300	size = avio_rl32(pb);
301	if (i == 0)	301	if (i == 0)
302	ea->big_endian = size > 0x000FFFFF;	302	ea->big_endian = size > 0x000FFFFF;
303	if (ea->big_endian)	303	if (ea->big_endian)
@@ -305,7 +305,7 @@ static int process_ea_header(AVFormatContext *s) { · 1 unmodified line
305		305
306	switch (blockid) {	306	switch (blockid) {
307	case ISNh_TAG:	307	case ISNh_TAG:
308	if (get_le32(pb) != EACS_TAG) {	308	if (avio_rl32(pb) != EACS_TAG) {
309	av_log (s, AV_LOG_ERROR, "unknown 1SNh headerid\n");	309	av_log (s, AV_LOG_ERROR, "unknown 1SNh headerid\n");
310	return 0;	310	return 0;
311	}	311	}
@@ -314,7 +314,7 @@ static int process_ea_header(AVFormatContext *s) { · 2 unmodified lines
314		314
315	case SCHl_TAG :	315	case SCHl_TAG :
316	case SHEN_TAG :	316	case SHEN_TAG :
317	blockid = get_le32(pb);	317	blockid = avio_rl32(pb);
318	if (blockid == GSTR_TAG) {	318	if (blockid == GSTR_TAG) {
319	url_fskip(pb, 4);	319	url_fskip(pb, 4);
320	} else if ((blockid & 0xFFFF)!=PT00_TAG) {	320	} else if ((blockid & 0xFFFF)!=PT00_TAG) {
@@ -467,8 +467,8 @@ static int ea_read_packet(AVFormatContext *s, · 146 unmodified lines
467	int av_uninit(num_samples);	467	int av_uninit(num_samples);
468		468
469	while (!packet_read) {	469	while (!packet_read) {
470	chunk_type = get_le32(pb);	470	chunk_type = avio_rl32(pb);
471	chunk_size = (ea->big_endian ? get_be32(pb) : get_le32(pb)) - 8;	471	chunk_size = (ea->big_endian ? avio_rb32(pb) : avio_rl32(pb)) - 8;
472		472
473	switch (chunk_type) {	473	switch (chunk_type) {
474	/* audio data */	474	/* audio data */
@@ -485,7 +485,7 @@ static int ea_read_packet(AVFormatContext *s, · 10 unmodified lines
485	break;	485	break;
486	} else if (ea->audio_codec == CODEC_ID_PCM_S16LE_PLANAR \|\|	486	} else if (ea->audio_codec == CODEC_ID_PCM_S16LE_PLANAR \|\|
487	ea->audio_codec == CODEC_ID_MP3) {	487	ea->audio_codec == CODEC_ID_MP3) {
488	num_samples = get_le32(pb);	488	num_samples = avio_rl32(pb);
489	url_fskip(pb, 8);	489	url_fskip(pb, 8);
490	chunk_size -= 12;	490	chunk_size -= 12;
491	}	491	}

libavformat/ffmdec.c+72−72

@@ -95,7 +95,7 @@ static int ffm_resync(AVFormatContext *s, int state) · 94 unmodified lines
95	av_log(s, AV_LOG_ERROR, "cannot find FFM syncword\n");	95	av_log(s, AV_LOG_ERROR, "cannot find FFM syncword\n");
96	return -1;	96	return -1;
97	}	97	}
98	state = (state << 8) \| get_byte(s->pb);	98	state = (state << 8) \| avio_r8(s->pb);
99	}	99	}
100	return 0;	100	return 0;
101	}	101	}
@@ -120,14 +120,14 @@ static int ffm_read_data(AVFormatContext *s, · 18 unmodified lines
120	if (url_ftell(pb) == ffm->file_size)	120	if (url_ftell(pb) == ffm->file_size)
121	url_fseek(pb, ffm->packet_size, SEEK_SET);	121	url_fseek(pb, ffm->packet_size, SEEK_SET);
122	retry_read:	122	retry_read:
123	id = get_be16(pb); /* PACKET_ID */	123	id = avio_rb16(pb); /* PACKET_ID */
124	if (id != PACKET_ID)	124	if (id != PACKET_ID)
125	if (ffm_resync(s, id) < 0)	125	if (ffm_resync(s, id) < 0)
126	return -1;	126	return -1;
127	fill_size = get_be16(pb);	127	fill_size = avio_rb16(pb);
128	ffm->dts = get_be64(pb);	128	ffm->dts = avio_rb64(pb);
129	frame_offset = get_be16(pb);	129	frame_offset = avio_rb16(pb);
130	get_buffer(pb, ffm->packet, ffm->packet_size - FFM_HEADER_SIZE);	130	avio_read(pb, ffm->packet, ffm->packet_size - FFM_HEADER_SIZE);
131	ffm->packet_end = ffm->packet + (ffm->packet_size - FFM_HEADER_SIZE - fill_size);	131	ffm->packet_end = ffm->packet + (ffm->packet_size - FFM_HEADER_SIZE - fill_size);
132	if (ffm->packet_end < ffm->packet \|\| frame_offset < 0)	132	if (ffm->packet_end < ffm->packet \|\| frame_offset < 0)
133	return -1;	133	return -1;
@@ -188,7 +188,7 @@ static int64_t get_dts(AVFormatContext *s, int64_t pos) · 54 unmodified lines
188		188
189	ffm_seek1(s, pos);	189	ffm_seek1(s, pos);
190	url_fskip(pb, 4);	190	url_fskip(pb, 4);
191	dts = get_be64(pb);	191	dts = avio_rb64(pb);
192	#ifdef DEBUG_SEEK	192	#ifdef DEBUG_SEEK
193	av_log(s, AV_LOG_DEBUG, "dts=%0.6f\n", dts / 1000000.0);	193	av_log(s, AV_LOG_DEBUG, "dts=%0.6f\n", dts / 1000000.0);
194	#endif	194	#endif
@@ -273,13 +273,13 @@ static int ffm_read_header(AVFormatContext s, AVFormatParameters ap) · 78 unmodified lines
273	uint32_t tag;	273	uint32_t tag;
274		274
275	/* header */	275	/* header */
276	tag = get_le32(pb);	276	tag = avio_rl32(pb);
277	if (tag != MKTAG('F', 'F', 'M', '1'))	277	if (tag != MKTAG('F', 'F', 'M', '1'))
278	goto fail;	278	goto fail;
279	ffm->packet_size = get_be32(pb);	279	ffm->packet_size = avio_rb32(pb);
280	if (ffm->packet_size != FFM_PACKET_SIZE)	280	if (ffm->packet_size != FFM_PACKET_SIZE)
281	goto fail;	281	goto fail;
282	ffm->write_index = get_be64(pb);	282	ffm->write_index = avio_rb64(pb);
283	/* get also filesize */	283	/* get also filesize */
284	if (!url_is_streamed(pb)) {	284	if (!url_is_streamed(pb)) {
285	ffm->file_size = url_fsize(pb);	285	ffm->file_size = url_fsize(pb);
@@ -289,8 +289,8 @@ static int ffm_read_header(AVFormatContext s, AVFormatParameters ap) · 3 unmodified lines
289	ffm->file_size = (UINT64_C(1) << 63) - 1;	289	ffm->file_size = (UINT64_C(1) << 63) - 1;
290	}	290	}
291		291
292	nb_streams = get_be32(pb);	292	nb_streams = avio_rb32(pb);
293	get_be32(pb); /* total bitrate */	293	avio_rb32(pb); /* total bitrate */
294	/* read each stream */	294	/* read each stream */
295	for(i=0;i<nb_streams;i++) {	295	for(i=0;i<nb_streams;i++) {
296	char rc_eq_buf[128];	296	char rc_eq_buf[128];
@@ -303,85 +303,85 @@ static int ffm_read_header(AVFormatContext s, AVFormatParameters ap) · 6 unmodified lines
303		303
304	codec = st->codec;	304	codec = st->codec;
305	/* generic info */	305	/* generic info */
306	codec->codec_id = get_be32(pb);	306	codec->codec_id = avio_rb32(pb);
307	codec->codec_type = get_byte(pb); /* codec_type */	307	codec->codec_type = avio_r8(pb); /* codec_type */
308	codec->bit_rate = get_be32(pb);	308	codec->bit_rate = avio_rb32(pb);
309	st->quality = get_be32(pb);	309	st->quality = avio_rb32(pb);
310	codec->flags = get_be32(pb);	310	codec->flags = avio_rb32(pb);
311	codec->flags2 = get_be32(pb);	311	codec->flags2 = avio_rb32(pb);
312	codec->debug = get_be32(pb);	312	codec->debug = avio_rb32(pb);
313	/* specific info */	313	/* specific info */
314	switch(codec->codec_type) {	314	switch(codec->codec_type) {
315	case AVMEDIA_TYPE_VIDEO:	315	case AVMEDIA_TYPE_VIDEO:
316	codec->time_base.num = get_be32(pb);	316	codec->time_base.num = avio_rb32(pb);
317	codec->time_base.den = get_be32(pb);	317	codec->time_base.den = avio_rb32(pb);
318	codec->width = get_be16(pb);	318	codec->width = avio_rb16(pb);
319	codec->height = get_be16(pb);	319	codec->height = avio_rb16(pb);
320	codec->gop_size = get_be16(pb);	320	codec->gop_size = avio_rb16(pb);
321	codec->pix_fmt = get_be32(pb);	321	codec->pix_fmt = avio_rb32(pb);
322	codec->qmin = get_byte(pb);	322	codec->qmin = avio_r8(pb);
323	codec->qmax = get_byte(pb);	323	codec->qmax = avio_r8(pb);
324	codec->max_qdiff = get_byte(pb);	324	codec->max_qdiff = avio_r8(pb);
325	codec->qcompress = get_be16(pb) / 10000.0;	325	codec->qcompress = avio_rb16(pb) / 10000.0;
326	codec->qblur = get_be16(pb) / 10000.0;	326	codec->qblur = avio_rb16(pb) / 10000.0;
327	codec->bit_rate_tolerance = get_be32(pb);	327	codec->bit_rate_tolerance = avio_rb32(pb);
328	codec->rc_eq = av_strdup(get_strz(pb, rc_eq_buf, sizeof(rc_eq_buf)));	328	codec->rc_eq = av_strdup(get_strz(pb, rc_eq_buf, sizeof(rc_eq_buf)));
329	codec->rc_max_rate = get_be32(pb);	329	codec->rc_max_rate = avio_rb32(pb);
330	codec->rc_min_rate = get_be32(pb);	330	codec->rc_min_rate = avio_rb32(pb);
331	codec->rc_buffer_size = get_be32(pb);	331	codec->rc_buffer_size = avio_rb32(pb);
332	codec->i_quant_factor = av_int2dbl(get_be64(pb));	332	codec->i_quant_factor = av_int2dbl(avio_rb64(pb));
333	codec->b_quant_factor = av_int2dbl(get_be64(pb));	333	codec->b_quant_factor = av_int2dbl(avio_rb64(pb));
334	codec->i_quant_offset = av_int2dbl(get_be64(pb));	334	codec->i_quant_offset = av_int2dbl(avio_rb64(pb));
335	codec->b_quant_offset = av_int2dbl(get_be64(pb));	335	codec->b_quant_offset = av_int2dbl(avio_rb64(pb));
336	codec->dct_algo = get_be32(pb);	336	codec->dct_algo = avio_rb32(pb);
337	codec->strict_std_compliance = get_be32(pb);	337	codec->strict_std_compliance = avio_rb32(pb);
338	codec->max_b_frames = get_be32(pb);	338	codec->max_b_frames = avio_rb32(pb);
339	codec->luma_elim_threshold = get_be32(pb);	339	codec->luma_elim_threshold = avio_rb32(pb);
340	codec->chroma_elim_threshold = get_be32(pb);	340	codec->chroma_elim_threshold = avio_rb32(pb);
341	codec->mpeg_quant = get_be32(pb);	341	codec->mpeg_quant = avio_rb32(pb);
342	codec->intra_dc_precision = get_be32(pb);	342	codec->intra_dc_precision = avio_rb32(pb);
343	codec->me_method = get_be32(pb);	343	codec->me_method = avio_rb32(pb);
344	codec->mb_decision = get_be32(pb);	344	codec->mb_decision = avio_rb32(pb);
345	codec->nsse_weight = get_be32(pb);	345	codec->nsse_weight = avio_rb32(pb);
346	codec->frame_skip_cmp = get_be32(pb);	346	codec->frame_skip_cmp = avio_rb32(pb);
347	codec->rc_buffer_aggressivity = av_int2dbl(get_be64(pb));	347	codec->rc_buffer_aggressivity = av_int2dbl(avio_rb64(pb));
348	codec->codec_tag = get_be32(pb);	348	codec->codec_tag = avio_rb32(pb);
349	codec->thread_count = get_byte(pb);	349	codec->thread_count = avio_r8(pb);
350	codec->coder_type = get_be32(pb);	350	codec->coder_type = avio_rb32(pb);
351	codec->me_cmp = get_be32(pb);	351	codec->me_cmp = avio_rb32(pb);
352	codec->partitions = get_be32(pb);	352	codec->partitions = avio_rb32(pb);
353	codec->me_subpel_quality = get_be32(pb);	353	codec->me_subpel_quality = avio_rb32(pb);
354	codec->me_range = get_be32(pb);	354	codec->me_range = avio_rb32(pb);
355	codec->keyint_min = get_be32(pb);	355	codec->keyint_min = avio_rb32(pb);
356	codec->scenechange_threshold = get_be32(pb);	356	codec->scenechange_threshold = avio_rb32(pb);
357	codec->b_frame_strategy = get_be32(pb);	357	codec->b_frame_strategy = avio_rb32(pb);
358	codec->qcompress = av_int2dbl(get_be64(pb));	358	codec->qcompress = av_int2dbl(avio_rb64(pb));
359	codec->qblur = av_int2dbl(get_be64(pb));	359	codec->qblur = av_int2dbl(avio_rb64(pb));
360	codec->max_qdiff = get_be32(pb);	360	codec->max_qdiff = avio_rb32(pb);
361	codec->refs = get_be32(pb);	361	codec->refs = avio_rb32(pb);
362	codec->directpred = get_be32(pb);	362	codec->directpred = avio_rb32(pb);
363	break;	363	break;
364	case AVMEDIA_TYPE_AUDIO:	364	case AVMEDIA_TYPE_AUDIO:
365	codec->sample_rate = get_be32(pb);	365	codec->sample_rate = avio_rb32(pb);
366	codec->channels = get_le16(pb);	366	codec->channels = avio_rl16(pb);
367	codec->frame_size = get_le16(pb);	367	codec->frame_size = avio_rl16(pb);
368	codec->sample_fmt = (int16_t) get_le16(pb);	368	codec->sample_fmt = (int16_t) avio_rl16(pb);
369	break;	369	break;
370	default:	370	default:
371	goto fail;	371	goto fail;
372	}	372	}
373	if (codec->flags & CODEC_FLAG_GLOBAL_HEADER) {	373	if (codec->flags & CODEC_FLAG_GLOBAL_HEADER) {
374	codec->extradata_size = get_be32(pb);	374	codec->extradata_size = avio_rb32(pb);
375	codec->extradata = av_malloc(codec->extradata_size);	375	codec->extradata = av_malloc(codec->extradata_size);
376	if (!codec->extradata)	376	if (!codec->extradata)
377	return AVERROR(ENOMEM);	377	return AVERROR(ENOMEM);
378	get_buffer(pb, codec->extradata, codec->extradata_size);	378	avio_read(pb, codec->extradata, codec->extradata_size);
379	}	379	}
380	}	380	}
381		381
382	/* get until end of block reached */	382	/* get until end of block reached */
383	while ((url_ftell(pb) % ffm->packet_size) != 0)	383	while ((url_ftell(pb) % ffm->packet_size) != 0)
384	get_byte(pb);	384	avio_r8(pb);
385		385
386	/* init packet demux */	386	/* init packet demux */
387	ffm->packet_ptr = ffm->packet;	387	ffm->packet_ptr = ffm->packet;

libavformat/ffmetadec.c+2−2

@@ -36,11 +36,11 @@ static void get_line(AVIOContext s, uint8_t buf, int size) · 35 unmodified lines
36	uint8_t c;	36	uint8_t c;
37	int i = 0;	37	int i = 0;
38		38
39	while ((c = get_byte(s))) {	39	while ((c = avio_r8(s))) {
40	if (c == '\\') {	40	if (c == '\\') {
41	if (i < size - 1)	41	if (i < size - 1)
42	buf[i++] = c;	42	buf[i++] = c;
43	c = get_byte(s);	43	c = avio_r8(s);
44	} else if (c == '\n')	44	} else if (c == '\n')
45	break;	45	break;
46		46

libavformat/filmstripdec.c+7−7

@@ -44,7 +44,7 @@ static int read_header(AVFormatContext *s, · 43 unmodified lines
44	return AVERROR(EIO);	44	return AVERROR(EIO);
45		45
46	url_fseek(pb, url_fsize(pb) - 36, SEEK_SET);	46	url_fseek(pb, url_fsize(pb) - 36, SEEK_SET);
47	if (get_be32(pb) != RAND_TAG) {	47	if (avio_rb32(pb) != RAND_TAG) {
48	av_log(s, AV_LOG_ERROR, "magic number not found");	48	av_log(s, AV_LOG_ERROR, "magic number not found");
49	return AVERROR_INVALIDDATA;	49	return AVERROR_INVALIDDATA;
50	}	50	}
@@ -53,8 +53,8 @@ static int read_header(AVFormatContext *s, · 2 unmodified lines
53	if (!st)	53	if (!st)
54	return AVERROR(ENOMEM);	54	return AVERROR(ENOMEM);
55		55
56	st->nb_frames = get_be32(pb);	56	st->nb_frames = avio_rb32(pb);
57	if (get_be16(pb) != 0) {	57	if (avio_rb16(pb) != 0) {
58	av_log_ask_for_sample(s, "unsupported packing method\n");	58	av_log_ask_for_sample(s, "unsupported packing method\n");
59	return AVERROR_INVALIDDATA;	59	return AVERROR_INVALIDDATA;
60	}	60	}
@@ -64,10 +64,10 @@ static int read_header(AVFormatContext *s, · 3 unmodified lines
64	st->codec->codec_id = CODEC_ID_RAWVIDEO;	64	st->codec->codec_id = CODEC_ID_RAWVIDEO;
65	st->codec->pix_fmt = PIX_FMT_RGBA;	65	st->codec->pix_fmt = PIX_FMT_RGBA;
66	st->codec->codec_tag = 0; /* no fourcc */	66	st->codec->codec_tag = 0; /* no fourcc */
67	st->codec->width = get_be16(pb);	67	st->codec->width = avio_rb16(pb);
68	st->codec->height = get_be16(pb);	68	st->codec->height = avio_rb16(pb);
69	film->leading = get_be16(pb);	69	film->leading = avio_rb16(pb);
70	av_set_pts_info(st, 64, 1, get_be16(pb));	70	av_set_pts_info(st, 64, 1, avio_rb16(pb));
71		71
72	url_fseek(pb, 0, SEEK_SET);	72	url_fseek(pb, 0, SEEK_SET);
73		73

libavformat/flacdec.c+3−3

@@ -40,14 +40,14 @@ static int flac_read_header(AVFormatContext *s, · 39 unmodified lines
40	/* the parameters will be extracted from the compressed bitstream */	40	/* the parameters will be extracted from the compressed bitstream */
41		41
42	/* if fLaC marker is not found, assume there is no header */	42	/* if fLaC marker is not found, assume there is no header */
43	if (get_le32(s->pb) != MKTAG('f','L','a','C')) {	43	if (avio_rl32(s->pb) != MKTAG('f','L','a','C')) {
44	url_fseek(s->pb, -4, SEEK_CUR);	44	url_fseek(s->pb, -4, SEEK_CUR);
45	return 0;	45	return 0;
46	}	46	}
47		47
48	/* process metadata blocks */	48	/* process metadata blocks */
49	while (!url_feof(s->pb) && !metadata_last) {	49	while (!url_feof(s->pb) && !metadata_last) {
50	get_buffer(s->pb, header, 4);	50	avio_read(s->pb, header, 4);
51	ff_flac_parse_block_header(header, &metadata_last, &metadata_type,	51	ff_flac_parse_block_header(header, &metadata_last, &metadata_type,
52	&metadata_size);	52	&metadata_size);
53	switch (metadata_type) {	53	switch (metadata_type) {
@@ -58,7 +58,7 @@ static int flac_read_header(AVFormatContext *s, · 4 unmodified lines
58	if (!buffer) {	58	if (!buffer) {
59	return AVERROR(ENOMEM);	59	return AVERROR(ENOMEM);
60	}	60	}
61	if (get_buffer(s->pb, buffer, metadata_size) != metadata_size) {	61	if (avio_read(s->pb, buffer, metadata_size) != metadata_size) {
62	av_freep(&buffer);	62	av_freep(&buffer);
63	return AVERROR(EIO);	63	return AVERROR(EIO);
64	}	64	}

libavformat/flic.c+5−5

@@ -96,7 +96,7 @@ static int flic_read_header(AVFormatContext *s, · 95 unmodified lines
96	flic->frame_number = 0;	96	flic->frame_number = 0;
97		97
98	/* load the whole header and pull out the width and height */	98	/* load the whole header and pull out the width and height */
99	if (get_buffer(pb, header, FLIC_HEADER_SIZE) != FLIC_HEADER_SIZE)	99	if (avio_read(pb, header, FLIC_HEADER_SIZE) != FLIC_HEADER_SIZE)
100	return AVERROR(EIO);	100	return AVERROR(EIO);
101		101
102	magic_number = AV_RL16(&header[4]);	102	magic_number = AV_RL16(&header[4]);
@@ -130,7 +130,7 @@ static int flic_read_header(AVFormatContext *s, · 27 unmodified lines
130	memcpy(st->codec->extradata, header, FLIC_HEADER_SIZE);	130	memcpy(st->codec->extradata, header, FLIC_HEADER_SIZE);
131		131
132	/* peek at the preamble to detect TFTD videos - they seem to always start with an audio chunk */	132	/* peek at the preamble to detect TFTD videos - they seem to always start with an audio chunk */
133	if (get_buffer(pb, preamble, FLIC_PREAMBLE_SIZE) != FLIC_PREAMBLE_SIZE) {	133	if (avio_read(pb, preamble, FLIC_PREAMBLE_SIZE) != FLIC_PREAMBLE_SIZE) {
134	av_log(s, AV_LOG_ERROR, "Failed to peek at preamble\n");	134	av_log(s, AV_LOG_ERROR, "Failed to peek at preamble\n");
135	return AVERROR(EIO);	135	return AVERROR(EIO);
136	}	136	}
@@ -207,7 +207,7 @@ static int flic_read_packet(AVFormatContext *s, · 70 unmodified lines
207		207
208	while (!packet_read) {	208	while (!packet_read) {
209		209
210	if ((ret = get_buffer(pb, preamble, FLIC_PREAMBLE_SIZE)) !=	210	if ((ret = avio_read(pb, preamble, FLIC_PREAMBLE_SIZE)) !=
211	FLIC_PREAMBLE_SIZE) {	211	FLIC_PREAMBLE_SIZE) {
212	ret = AVERROR(EIO);	212	ret = AVERROR(EIO);
213	break;	213	break;
@@ -225,7 +225,7 @@ static int flic_read_packet(AVFormatContext *s, · 11 unmodified lines
225	pkt->pts = flic->frame_number++;	225	pkt->pts = flic->frame_number++;
226	pkt->pos = url_ftell(pb);	226	pkt->pos = url_ftell(pb);
227	memcpy(pkt->data, preamble, FLIC_PREAMBLE_SIZE);	227	memcpy(pkt->data, preamble, FLIC_PREAMBLE_SIZE);
228	ret = get_buffer(pb, pkt->data + FLIC_PREAMBLE_SIZE,	228	ret = avio_read(pb, pkt->data + FLIC_PREAMBLE_SIZE,
229	size - FLIC_PREAMBLE_SIZE);	229	size - FLIC_PREAMBLE_SIZE);
230	if (ret != size - FLIC_PREAMBLE_SIZE) {	230	if (ret != size - FLIC_PREAMBLE_SIZE) {
231	av_free_packet(pkt);	231	av_free_packet(pkt);
@@ -243,7 +243,7 @@ static int flic_read_packet(AVFormatContext *s, · 11 unmodified lines
243		243
244	pkt->stream_index = flic->audio_stream_index;	244	pkt->stream_index = flic->audio_stream_index;
245	pkt->pos = url_ftell(pb);	245	pkt->pos = url_ftell(pb);
246	ret = get_buffer(pb, pkt->data, size);	246	ret = avio_read(pb, pkt->data, size);
247		247
248	if (ret != size) {	248	if (ret != size) {
249	av_free_packet(pkt);	249	av_free_packet(pkt);

libavformat/flvdec.c+26−26

@@ -97,7 +97,7 @@ static int flv_set_video_codec(AVFormatContext s, AVStream vstream, int flv_co · 96 unmodified lines
97	vcodec->extradata_size = 1;	97	vcodec->extradata_size = 1;
98	vcodec->extradata = av_malloc(1);	98	vcodec->extradata = av_malloc(1);
99	}	99	}
100	vcodec->extradata[0] = get_byte(s->pb);	100	vcodec->extradata[0] = avio_r8(s->pb);
101	return 1; // 1 byte body size adjustment for flv_read_packet()	101	return 1; // 1 byte body size adjustment for flv_read_packet()
102	case FLV_CODECID_H264:	102	case FLV_CODECID_H264:
103	vcodec->codec_id = CODEC_ID_H264;	103	vcodec->codec_id = CODEC_ID_H264;
@@ -111,13 +111,13 @@ static int flv_set_video_codec(AVFormatContext s, AVStream vstream, int flv_co · 7 unmodified lines
111	}	111	}
112		112
113	static int amf_get_string(AVIOContext ioc, char buffer, int buffsize) {	113	static int amf_get_string(AVIOContext ioc, char buffer, int buffsize) {
114	int length = get_be16(ioc);	114	int length = avio_rb16(ioc);
115	if(length >= buffsize) {	115	if(length >= buffsize) {
116	url_fskip(ioc, length);	116	url_fskip(ioc, length);
117	return -1;	117	return -1;
118	}	118	}
119		119
120	get_buffer(ioc, buffer, length);	120	avio_read(ioc, buffer, length);
121		121
122	buffer[length] = '\0';	122	buffer[length] = '\0';
123		123
@@ -134,13 +134,13 @@ static int amf_parse_object(AVFormatContext s, AVStream astream, AVStream *vst · 10 unmodified lines
134	num_val = 0;	134	num_val = 0;
135	ioc = s->pb;	135	ioc = s->pb;
136		136
137	amf_type = get_byte(ioc);	137	amf_type = avio_r8(ioc);
138		138
139	switch(amf_type) {	139	switch(amf_type) {
140	case AMF_DATA_TYPE_NUMBER:	140	case AMF_DATA_TYPE_NUMBER:
141	num_val = av_int2dbl(get_be64(ioc)); break;	141	num_val = av_int2dbl(avio_rb64(ioc)); break;
142	case AMF_DATA_TYPE_BOOL:	142	case AMF_DATA_TYPE_BOOL:
143	num_val = get_byte(ioc); break;	143	num_val = avio_r8(ioc); break;
144	case AMF_DATA_TYPE_STRING:	144	case AMF_DATA_TYPE_STRING:
145	if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0)	145	if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
146	return -1;	146	return -1;
@@ -148,12 +148,12 @@ static int amf_parse_object(AVFormatContext s, AVStream astream, AVStream *vst · 1 unmodified line
148	case AMF_DATA_TYPE_OBJECT: {	148	case AMF_DATA_TYPE_OBJECT: {
149	unsigned int keylen;	149	unsigned int keylen;
150		150
151	while(url_ftell(ioc) < max_pos - 2 && (keylen = get_be16(ioc))) {	151	while(url_ftell(ioc) < max_pos - 2 && (keylen = avio_rb16(ioc))) {
152	url_fskip(ioc, keylen); //skip key string	152	url_fskip(ioc, keylen); //skip key string
153	if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)	153	if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
154	return -1; //if we couldn't skip, bomb out.	154	return -1; //if we couldn't skip, bomb out.
155	}	155	}
156	if(get_byte(ioc) != AMF_END_OF_OBJECT)	156	if(avio_r8(ioc) != AMF_END_OF_OBJECT)
157	return -1;	157	return -1;
158	}	158	}
159	break;	159	break;
@@ -168,13 +168,13 @@ static int amf_parse_object(AVFormatContext s, AVStream astream, AVStream *vst · 8 unmodified lines
168	if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0)	168	if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0)
169	return -1;	169	return -1;
170	}	170	}
171	if(get_byte(ioc) != AMF_END_OF_OBJECT)	171	if(avio_r8(ioc) != AMF_END_OF_OBJECT)
172	return -1;	172	return -1;
173	break;	173	break;
174	case AMF_DATA_TYPE_ARRAY: {	174	case AMF_DATA_TYPE_ARRAY: {
175	unsigned int arraylen, i;	175	unsigned int arraylen, i;
176		176
177	arraylen = get_be32(ioc);	177	arraylen = avio_rb32(ioc);
178	for(i = 0; i < arraylen && url_ftell(ioc) < max_pos - 1; i++) {	178	for(i = 0; i < arraylen && url_ftell(ioc) < max_pos - 1; i++) {
179	if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)	179	if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
180	return -1; //if we couldn't skip, bomb out.	180	return -1; //if we couldn't skip, bomb out.
@@ -222,7 +222,7 @@ static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) { · 41 unmodified lines
222	ioc = s->pb;	222	ioc = s->pb;
223		223
224	//first object needs to be "onMetaData" string	224	//first object needs to be "onMetaData" string
225	type = get_byte(ioc);	225	type = avio_r8(ioc);
226	if(type != AMF_DATA_TYPE_STRING \|\| amf_get_string(ioc, buffer, sizeof(buffer)) < 0 \|\| strcmp(buffer, "onMetaData"))	226	if(type != AMF_DATA_TYPE_STRING \|\| amf_get_string(ioc, buffer, sizeof(buffer)) < 0 \|\| strcmp(buffer, "onMetaData"))
227	return -1;	227	return -1;
228		228
@@ -255,7 +255,7 @@ static int flv_read_header(AVFormatContext *s, · 26 unmodified lines
255	int offset, flags;	255	int offset, flags;
256		256
257	url_fskip(s->pb, 4);	257	url_fskip(s->pb, 4);
258	flags = get_byte(s->pb);	258	flags = avio_r8(s->pb);
259	/* old flvtool cleared this field */	259	/* old flvtool cleared this field */
260	/* FIXME: better fix needed */	260	/* FIXME: better fix needed */
261	if (!flags) {	261	if (!flags) {
@@ -276,7 +276,7 @@ static int flv_read_header(AVFormatContext *s, · 14 unmodified lines
276	return AVERROR(ENOMEM);	276	return AVERROR(ENOMEM);
277	}	277	}
278		278
279	offset = get_be32(s->pb);	279	offset = avio_rb32(s->pb);
280	url_fseek(s->pb, offset, SEEK_SET);	280	url_fseek(s->pb, offset, SEEK_SET);
281	url_fskip(s->pb, 4);	281	url_fskip(s->pb, 4);
282		282
@@ -292,7 +292,7 @@ static int flv_get_extradata(AVFormatContext s, AVStream st, int size) · 9 unmodified lines
292	if (!st->codec->extradata)	292	if (!st->codec->extradata)
293	return AVERROR(ENOMEM);	293	return AVERROR(ENOMEM);
294	st->codec->extradata_size = size;	294	st->codec->extradata_size = size;
295	get_buffer(s->pb, st->codec->extradata, st->codec->extradata_size);	295	avio_read(s->pb, st->codec->extradata, st->codec->extradata_size);
296	return 0;	296	return 0;
297	}	297	}
298		298
@@ -306,10 +306,10 @@ static int flv_read_packet(AVFormatContext s, AVPacket pkt) · 7 unmodified lines
306		306
307	for(;;url_fskip(s->pb, 4)){ /* pkt size is repeated at end. skip it */	307	for(;;url_fskip(s->pb, 4)){ /* pkt size is repeated at end. skip it */
308	pos = url_ftell(s->pb);	308	pos = url_ftell(s->pb);
309	type = get_byte(s->pb);	309	type = avio_r8(s->pb);
310	size = get_be24(s->pb);	310	size = avio_rb24(s->pb);
311	dts = get_be24(s->pb);	311	dts = avio_rb24(s->pb);
312	dts \|= get_byte(s->pb) << 24;	312	dts \|= avio_r8(s->pb) << 24;
313	// av_log(s, AV_LOG_DEBUG, "type:%d, size:%d, dts:%d\n", type, size, dts);	313	// av_log(s, AV_LOG_DEBUG, "type:%d, size:%d, dts:%d\n", type, size, dts);
314	if (url_feof(s->pb))	314	if (url_feof(s->pb))
315	return AVERROR_EOF;	315	return AVERROR_EOF;
@@ -323,11 +323,11 @@ static int flv_read_packet(AVFormatContext s, AVPacket pkt) · 7 unmodified lines
323		323
324	if (type == FLV_TAG_TYPE_AUDIO) {	324	if (type == FLV_TAG_TYPE_AUDIO) {
325	is_audio=1;	325	is_audio=1;
326	flags = get_byte(s->pb);	326	flags = avio_r8(s->pb);
327	size--;	327	size--;
328	} else if (type == FLV_TAG_TYPE_VIDEO) {	328	} else if (type == FLV_TAG_TYPE_VIDEO) {
329	is_audio=0;	329	is_audio=0;
330	flags = get_byte(s->pb);	330	flags = avio_r8(s->pb);
331	size--;	331	size--;
332	if ((flags & 0xf0) == 0x50) /* video info / command frame */	332	if ((flags & 0xf0) == 0x50) /* video info / command frame */
333	goto skip;	333	goto skip;
@@ -375,11 +375,11 @@ static int flv_read_packet(AVFormatContext s, AVPacket pkt) · 41 unmodified lines
375	const int64_t pos= url_ftell(s->pb);	375	const int64_t pos= url_ftell(s->pb);
376	const int64_t fsize= url_fsize(s->pb);	376	const int64_t fsize= url_fsize(s->pb);
377	url_fseek(s->pb, fsize-4, SEEK_SET);	377	url_fseek(s->pb, fsize-4, SEEK_SET);
378	size= get_be32(s->pb);	378	size= avio_rb32(s->pb);
379	url_fseek(s->pb, fsize-3-size, SEEK_SET);	379	url_fseek(s->pb, fsize-3-size, SEEK_SET);
380	if(size == get_be24(s->pb) + 11){	380	if(size == avio_rb24(s->pb) + 11){
381	uint32_t ts = get_be24(s->pb);	381	uint32_t ts = avio_rb24(s->pb);
382	ts \|= get_byte(s->pb) << 24;	382	ts \|= avio_r8(s->pb) << 24;
383	s->duration = ts * (int64_t)AV_TIME_BASE / 1000;	383	s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
384	}	384	}
385	url_fseek(s->pb, pos, SEEK_SET);	385	url_fseek(s->pb, pos, SEEK_SET);
@@ -400,10 +400,10 @@ static int flv_read_packet(AVFormatContext s, AVPacket pkt) · 14 unmodified lines
400		400
401	if (st->codec->codec_id == CODEC_ID_AAC \|\|	401	if (st->codec->codec_id == CODEC_ID_AAC \|\|
402	st->codec->codec_id == CODEC_ID_H264) {	402	st->codec->codec_id == CODEC_ID_H264) {
403	int type = get_byte(s->pb);	403	int type = avio_r8(s->pb);
404	size--;	404	size--;
405	if (st->codec->codec_id == CODEC_ID_H264) {	405	if (st->codec->codec_id == CODEC_ID_H264) {
406	int32_t cts = (get_be24(s->pb)+0xff800000)^0xff800000; // sign extension	406	int32_t cts = (avio_rb24(s->pb)+0xff800000)^0xff800000; // sign extension
407	pts = dts + cts;	407	pts = dts + cts;
408	if (cts < 0) { // dts are wrong	408	if (cts < 0) { // dts are wrong
409	flv->wrong_dts = 1;	409	flv->wrong_dts = 1;

libavformat/gxf.c+35−35

@@ -39,20 +39,20 @@ struct gxf_stream_info { · 38 unmodified lines
39	* \return 0 if header not found or contains invalid data, 1 otherwise	39	* \return 0 if header not found or contains invalid data, 1 otherwise
40	*/	40	*/
41	static int parse_packet_header(AVIOContext pb, GXFPktType type, int *length) {	41	static int parse_packet_header(AVIOContext pb, GXFPktType type, int *length) {
42	if (get_be32(pb))	42	if (avio_rb32(pb))
43	return 0;	43	return 0;
44	if (get_byte(pb) != 1)	44	if (avio_r8(pb) != 1)
45	return 0;	45	return 0;
46	*type = get_byte(pb);	46	*type = avio_r8(pb);
47	*length = get_be32(pb);	47	*length = avio_rb32(pb);
48	if ((length >> 24) \|\| length < 16)	48	if ((length >> 24) \|\| length < 16)
49	return 0;	49	return 0;
50	*length -= 16;	50	*length -= 16;
51	if (get_be32(pb))	51	if (avio_rb32(pb))
52	return 0;	52	return 0;
53	if (get_byte(pb) != 0xe1)	53	if (avio_r8(pb) != 0xe1)
54	return 0;	54	return 0;
55	if (get_byte(pb) != 0xe2)	55	if (avio_r8(pb) != 0xe2)
56	return 0;	56	return 0;
57	return 1;	57	return 1;
58	}	58	}
@@ -161,14 +161,14 @@ static void gxf_material_tags(AVIOContext pb, int len, struct gxf_stream_info · 102 unmodified lines
161	si->first_field = AV_NOPTS_VALUE;	161	si->first_field = AV_NOPTS_VALUE;
162	si->last_field = AV_NOPTS_VALUE;	162	si->last_field = AV_NOPTS_VALUE;
163	while (*len >= 2) {	163	while (*len >= 2) {
164	GXFMatTag tag = get_byte(pb);	164	GXFMatTag tag = avio_r8(pb);
165	int tlen = get_byte(pb);	165	int tlen = avio_r8(pb);
166	*len -= 2;	166	*len -= 2;
167	if (tlen > *len)	167	if (tlen > *len)
168	return;	168	return;
169	*len -= tlen;	169	*len -= tlen;
170	if (tlen == 4) {	170	if (tlen == 4) {
171	uint32_t value = get_be32(pb);	171	uint32_t value = avio_rb32(pb);
172	if (tag == MAT_FIRST_FIELD)	172	if (tag == MAT_FIRST_FIELD)
173	si->first_field = value;	173	si->first_field = value;
174	else if (tag == MAT_LAST_FIELD)	174	else if (tag == MAT_LAST_FIELD)
@@ -210,14 +210,14 @@ static void gxf_track_tags(AVIOContext pb, int len, struct gxf_stream_info *si · 35 unmodified lines
210	si->frames_per_second = (AVRational){0, 0};	210	si->frames_per_second = (AVRational){0, 0};
211	si->fields_per_frame = 0;	211	si->fields_per_frame = 0;
212	while (*len >= 2) {	212	while (*len >= 2) {
213	GXFTrackTag tag = get_byte(pb);	213	GXFTrackTag tag = avio_r8(pb);
214	int tlen = get_byte(pb);	214	int tlen = avio_r8(pb);
215	*len -= 2;	215	*len -= 2;
216	if (tlen > *len)	216	if (tlen > *len)
217	return;	217	return;
218	*len -= tlen;	218	*len -= tlen;
219	if (tlen == 4) {	219	if (tlen == 4) {
220	uint32_t value = get_be32(pb);	220	uint32_t value = avio_rb32(pb);
221	if (tag == TRACK_FPS)	221	if (tag == TRACK_FPS)
222	si->frames_per_second = fps_tag2avr(value);	222	si->frames_per_second = fps_tag2avr(value);
223	else if (tag == TRACK_FPF && (value == 1 \|\| value == 2))	223	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 · 9 unmodified lines
233	static void gxf_read_index(AVFormatContext *s, int pkt_len) {	233	static void gxf_read_index(AVFormatContext *s, int pkt_len) {
234	AVIOContext *pb = s->pb;	234	AVIOContext *pb = s->pb;
235	AVStream *st = s->streams[0];	235	AVStream *st = s->streams[0];
236	uint32_t fields_per_map = get_le32(pb);	236	uint32_t fields_per_map = avio_rl32(pb);
237	uint32_t map_cnt = get_le32(pb);	237	uint32_t map_cnt = avio_rl32(pb);
238	int i;	238	int i;
239	pkt_len -= 8;	239	pkt_len -= 8;
240	if (s->flags & AVFMT_FLAG_IGNIDX) {	240	if (s->flags & AVFMT_FLAG_IGNIDX) {
@@ -253,7 +253,7 @@ static void gxf_read_index(AVFormatContext *s, int pkt_len) { · 12 unmodified lines
253	pkt_len -= 4 * map_cnt;	253	pkt_len -= 4 * map_cnt;
254	av_add_index_entry(st, 0, 0, 0, 0, 0);	254	av_add_index_entry(st, 0, 0, 0, 0, 0);
255	for (i = 0; i < map_cnt; i++)	255	for (i = 0; i < map_cnt; i++)
256	av_add_index_entry(st, (uint64_t)get_le32(pb) * 1024,	256	av_add_index_entry(st, (uint64_t)avio_rl32(pb) * 1024,
257	i * (uint64_t)fields_per_map + 1, 0, 0, 0);	257	i * (uint64_t)fields_per_map + 1, 0, 0, 0);
258	url_fskip(pb, pkt_len);	258	url_fskip(pb, pkt_len);
259	}	259	}
@@ -271,12 +271,12 @@ static int gxf_header(AVFormatContext s, AVFormatParameters ap) { · 11 unmodified lines
271	return 0;	271	return 0;
272	}	272	}
273	map_len -= 2;	273	map_len -= 2;
274	if (get_byte(pb) != 0x0e0 \|\| get_byte(pb) != 0xff) {	274	if (avio_r8(pb) != 0x0e0 \|\| avio_r8(pb) != 0xff) {
275	av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n");	275	av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n");
276	return 0;	276	return 0;
277	}	277	}
278	map_len -= 2;	278	map_len -= 2;
279	len = get_be16(pb); // length of material data section	279	len = avio_rb16(pb); // length of material data section
280	if (len > map_len) {	280	if (len > map_len) {
281	av_log(s, AV_LOG_ERROR, "material data longer than map data\n");	281	av_log(s, AV_LOG_ERROR, "material data longer than map data\n");
282	return 0;	282	return 0;
@@ -285,7 +285,7 @@ static int gxf_header(AVFormatContext s, AVFormatParameters ap) { · 2 unmodified lines
285	gxf_material_tags(pb, &len, &si);	285	gxf_material_tags(pb, &len, &si);
286	url_fskip(pb, len);	286	url_fskip(pb, len);
287	map_len -= 2;	287	map_len -= 2;
288	len = get_be16(pb); // length of track description	288	len = avio_rb16(pb); // length of track description
289	if (len > map_len) {	289	if (len > map_len) {
290	av_log(s, AV_LOG_ERROR, "track description longer than map data\n");	290	av_log(s, AV_LOG_ERROR, "track description longer than map data\n");
291	return 0;	291	return 0;
@@ -296,9 +296,9 @@ static int gxf_header(AVFormatContext s, AVFormatParameters ap) { · 4 unmodified lines
296	AVStream *st;	296	AVStream *st;
297	int idx;	297	int idx;
298	len -= 4;	298	len -= 4;
299	track_type = get_byte(pb);	299	track_type = avio_r8(pb);
300	track_id = get_byte(pb);	300	track_id = avio_r8(pb);
301	track_len = get_be16(pb);	301	track_len = avio_rb16(pb);
302	len -= track_len;	302	len -= track_len;
303	gxf_track_tags(pb, &track_len, &si);	303	gxf_track_tags(pb, &track_len, &si);
304	url_fskip(pb, track_len);	304	url_fskip(pb, track_len);
@@ -344,7 +344,7 @@ static int gxf_header(AVFormatContext s, AVFormatParameters ap) { · 39 unmodified lines
344	len -= 0x39;	344	len -= 0x39;
345	url_fskip(pb, 5); // preamble	345	url_fskip(pb, 5); // preamble
346	url_fskip(pb, 0x30); // payload description	346	url_fskip(pb, 0x30); // payload description
347	fps = fps_umf2avr(get_le32(pb));	347	fps = fps_umf2avr(avio_rl32(pb));
348	if (!main_timebase.num \|\| !main_timebase.den) {	348	if (!main_timebase.num \|\| !main_timebase.den) {
349	// this may not always be correct, but simply the best we can get	349	// this may not always be correct, but simply the best we can get
350	main_timebase.num = fps.den;	350	main_timebase.num = fps.den;
@@ -370,7 +370,7 @@ static int gxf_header(AVFormatContext s, AVFormatParameters ap) { · 19 unmodified lines
370	{ \	370	{ \
371	if (!max_interval-- \|\| url_feof(pb)) \	371	if (!max_interval-- \|\| url_feof(pb)) \
372	goto out; \	372	goto out; \
373	tmp = tmp << 8 \| get_byte(pb); \	373	tmp = tmp << 8 \| avio_r8(pb); \
374	}	374	}
375		375
376	/**	376	/**
@@ -389,7 +389,7 @@ static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int t · 12 unmodified lines
389	int len;	389	int len;
390	AVIOContext *pb = s->pb;	390	AVIOContext *pb = s->pb;
391	GXFPktType type;	391	GXFPktType type;
392	tmp = get_be32(pb);	392	tmp = avio_rb32(pb);
393	start:	393	start:
394	while (tmp)	394	while (tmp)
395	READ_ONE();	395	READ_ONE();
@@ -404,9 +404,9 @@ start: · 8 unmodified lines
404	goto out;	404	goto out;
405	goto start;	405	goto start;
406	}	406	}
407	get_byte(pb);	407	avio_r8(pb);
408	cur_track = get_byte(pb);	408	cur_track = avio_r8(pb);
409	cur_timestamp = get_be32(pb);	409	cur_timestamp = avio_rb32(pb);
410	last_found_pos = url_ftell(pb) - 16 - 6;	410	last_found_pos = url_ftell(pb) - 16 - 6;
411	if ((track >= 0 && track != cur_track) \|\| (timestamp >= 0 && timestamp > cur_timestamp)) {	411	if ((track >= 0 && track != cur_track) \|\| (timestamp >= 0 && timestamp > cur_timestamp)) {
412	if (url_fseek(pb, last_pos, SEEK_SET) >= 0)	412	if (url_fseek(pb, last_pos, SEEK_SET) >= 0)
@@ -445,17 +445,17 @@ static int gxf_packet(AVFormatContext s, AVPacket pkt) { · 32 unmodified lines
445	continue;	445	continue;
446	}	446	}
447	pkt_len -= 16;	447	pkt_len -= 16;
448	track_type = get_byte(pb);	448	track_type = avio_r8(pb);
449	track_id = get_byte(pb);	449	track_id = avio_r8(pb);
450	stream_index = get_sindex(s, track_id, track_type);	450	stream_index = get_sindex(s, track_id, track_type);
451	if (stream_index < 0)	451	if (stream_index < 0)
452	return stream_index;	452	return stream_index;
453	st = s->streams[stream_index];	453	st = s->streams[stream_index];
454	field_nr = get_be32(pb);	454	field_nr = avio_rb32(pb);
455	field_info = get_be32(pb);	455	field_info = avio_rb32(pb);
456	get_be32(pb); // "timeline" field number	456	avio_rb32(pb); // "timeline" field number
457	get_byte(pb); // flags	457	avio_r8(pb); // flags
458	get_byte(pb); // reserved	458	avio_r8(pb); // reserved
459	if (st->codec->codec_id == CODEC_ID_PCM_S24LE \|\|	459	if (st->codec->codec_id == CODEC_ID_PCM_S24LE \|\|
460	st->codec->codec_id == CODEC_ID_PCM_S16LE) {	460	st->codec->codec_id == CODEC_ID_PCM_S16LE) {
461	int first = field_info >> 16;	461	int first = field_info >> 16;

libavformat/id3v1.c+1−1

@@ -233,7 +233,7 @@ void ff_id3v1_read(AVFormatContext *s) · 232 unmodified lines
233	filesize = url_fsize(s->pb);	233	filesize = url_fsize(s->pb);
234	if (filesize > 128) {	234	if (filesize > 128) {
235	url_fseek(s->pb, filesize - 128, SEEK_SET);	235	url_fseek(s->pb, filesize - 128, SEEK_SET);
236	ret = get_buffer(s->pb, buf, ID3v1_TAG_SIZE);	236	ret = avio_read(s->pb, buf, ID3v1_TAG_SIZE);
237	if (ret == ID3v1_TAG_SIZE) {	237	if (ret == ID3v1_TAG_SIZE) {
238	parse_tag(s, buf);	238	parse_tag(s, buf);
239	}	239	}

libavformat/id3v2.c+15−15

@@ -55,7 +55,7 @@ static unsigned int get_size(AVIOContext *s, int len) · 54 unmodified lines
55	{	55	{
56	int v = 0;	56	int v = 0;
57	while (len--)	57	while (len--)
58	v = (v << 7) + (get_byte(s) & 0x7F);	58	v = (v << 7) + (avio_r8(s) & 0x7F);
59	return v;	59	return v;
60	}	60	}
61		61
@@ -65,7 +65,7 @@ static void read_ttag(AVFormatContext s, AVIOContext pb, int taglen, const cha · 3 unmodified lines
65	const char *val = NULL;	65	const char *val = NULL;
66	int len, dstlen = sizeof(dst) - 1;	66	int len, dstlen = sizeof(dst) - 1;
67	unsigned genre;	67	unsigned genre;
68	unsigned int (get)(AVIOContext) = get_be16;	68	unsigned int (get)(AVIOContext) = avio_rb16;
69		69
70	dst[0] = 0;	70	dst[0] = 0;
71	if (taglen < 1)	71	if (taglen < 1)
@@ -73,22 +73,22 @@ static void read_ttag(AVFormatContext s, AVIOContext pb, int taglen, const cha · 1 unmodified line
73		73
74	taglen--; /* account for encoding type byte */	74	taglen--; /* account for encoding type byte */
75		75
76	switch (get_byte(pb)) { /* encoding type */	76	switch (avio_r8(pb)) { /* encoding type */
77		77
78	case ID3v2_ENCODING_ISO8859:	78	case ID3v2_ENCODING_ISO8859:
79	q = dst;	79	q = dst;
80	while (taglen-- && q - dst < dstlen - 7) {	80	while (taglen-- && q - dst < dstlen - 7) {
81	uint8_t tmp;	81	uint8_t tmp;
82	PUT_UTF8(get_byte(pb), tmp, *q++ = tmp;)	82	PUT_UTF8(avio_r8(pb), tmp, *q++ = tmp;)
83	}	83	}
84	*q = 0;	84	*q = 0;
85	break;	85	break;
86		86
87	case ID3v2_ENCODING_UTF16BOM:	87	case ID3v2_ENCODING_UTF16BOM:
88	taglen -= 2;	88	taglen -= 2;
89	switch (get_be16(pb)) {	89	switch (avio_rb16(pb)) {
90	case 0xfffe:	90	case 0xfffe:
91	get = get_le16;	91	get = avio_rl16;
92	case 0xfeff:	92	case 0xfeff:
93	break;	93	break;
94	default:	94	default:
@@ -111,7 +111,7 @@ static void read_ttag(AVFormatContext s, AVIOContext pb, int taglen, const cha · 16 unmodified lines
111		111
112	case ID3v2_ENCODING_UTF8:	112	case ID3v2_ENCODING_UTF8:
113	len = FFMIN(taglen, dstlen);	113	len = FFMIN(taglen, dstlen);
114	get_buffer(pb, dst, len);	114	avio_read(pb, dst, len);
115	dst[len] = 0;	115	dst[len] = 0;
116	break;	116	break;
117	default:	117	default:
@@ -178,18 +178,18 @@ static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t · 60 unmodified lines
178	int tunsync = 0;	178	int tunsync = 0;
179		179
180	if (isv34) {	180	if (isv34) {
181	get_buffer(s->pb, tag, 4);	181	avio_read(s->pb, tag, 4);
182	tag[4] = 0;	182	tag[4] = 0;
183	if(version==3){	183	if(version==3){
184	tlen = get_be32(s->pb);	184	tlen = avio_rb32(s->pb);
185	}else	185	}else
186	tlen = get_size(s->pb, 4);	186	tlen = get_size(s->pb, 4);
187	tflags = get_be16(s->pb);	187	tflags = avio_rb16(s->pb);
188	tunsync = tflags & ID3v2_FLAG_UNSYNCH;	188	tunsync = tflags & ID3v2_FLAG_UNSYNCH;
189	} else {	189	} else {
190	get_buffer(s->pb, tag, 3);	190	avio_read(s->pb, tag, 3);
191	tag[3] = 0;	191	tag[3] = 0;
192	tlen = get_be24(s->pb);	192	tlen = avio_rb24(s->pb);
193	}	193	}
194	len -= taghdrlen + tlen;	194	len -= taghdrlen + tlen;
195		195
@@ -199,7 +199,7 @@ static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t · 3 unmodified lines
199	next = url_ftell(s->pb) + tlen;	199	next = url_ftell(s->pb) + tlen;
200		200
201	if (tflags & ID3v2_FLAG_DATALEN) {	201	if (tflags & ID3v2_FLAG_DATALEN) {
202	get_be32(s->pb);	202	avio_rb32(s->pb);
203	tlen -= 4;	203	tlen -= 4;
204	}	204	}
205		205
@@ -211,7 +211,7 @@ static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t · 5 unmodified lines
211	int i, j;	211	int i, j;
212	av_fast_malloc(&buffer, &buffer_size, tlen);	212	av_fast_malloc(&buffer, &buffer_size, tlen);
213	for (i = 0, j = 0; i < tlen; i++, j++) {	213	for (i = 0, j = 0; i < tlen; i++, j++) {
214	buffer[j] = get_byte(s->pb);	214	buffer[j] = avio_r8(s->pb);
215	if (j > 0 && !buffer[j] && buffer[j - 1] == 0xff) {	215	if (j > 0 && !buffer[j] && buffer[j - 1] == 0xff) {
216	/* Unsynchronised byte, skip it */	216	/* Unsynchronised byte, skip it */
217	j--;	217	j--;
@@ -259,7 +259,7 @@ void ff_id3v2_read(AVFormatContext s, const char magic) · 41 unmodified lines
259	do {	259	do {
260	/* save the current offset in case there's nothing to read/skip */	260	/* save the current offset in case there's nothing to read/skip */
261	off = url_ftell(s->pb);	261	off = url_ftell(s->pb);
262	ret = get_buffer(s->pb, buf, ID3v2_HEADER_SIZE);	262	ret = avio_read(s->pb, buf, ID3v2_HEADER_SIZE);
263	if (ret != ID3v2_HEADER_SIZE)	263	if (ret != ID3v2_HEADER_SIZE)
264	break;	264	break;
265	found_header = ff_id3v2_match(buf, magic);	265	found_header = ff_id3v2_match(buf, magic);

libavformat/idcin.c+9−9

@@ -149,11 +149,11 @@ static int idcin_read_header(AVFormatContext *s, · 148 unmodified lines
149	unsigned int sample_rate, bytes_per_sample, channels;	149	unsigned int sample_rate, bytes_per_sample, channels;
150		150
151	/* get the 5 header parameters */	151	/* get the 5 header parameters */
152	width = get_le32(pb);	152	width = avio_rl32(pb);
153	height = get_le32(pb);	153	height = avio_rl32(pb);
154	sample_rate = get_le32(pb);	154	sample_rate = avio_rl32(pb);
155	bytes_per_sample = get_le32(pb);	155	bytes_per_sample = avio_rl32(pb);
156	channels = get_le32(pb);	156	channels = avio_rl32(pb);
157		157
158	st = av_new_stream(s, 0);	158	st = av_new_stream(s, 0);
159	if (!st)	159	if (!st)
@@ -169,7 +169,7 @@ static int idcin_read_header(AVFormatContext *s, · 9 unmodified lines
169	/* load up the Huffman tables into extradata */	169	/* load up the Huffman tables into extradata */
170	st->codec->extradata_size = HUFFMAN_TABLE_SIZE;	170	st->codec->extradata_size = HUFFMAN_TABLE_SIZE;
171	st->codec->extradata = av_malloc(HUFFMAN_TABLE_SIZE);	171	st->codec->extradata = av_malloc(HUFFMAN_TABLE_SIZE);
172	if (get_buffer(pb, st->codec->extradata, HUFFMAN_TABLE_SIZE) !=	172	if (avio_read(pb, st->codec->extradata, HUFFMAN_TABLE_SIZE) !=
173	HUFFMAN_TABLE_SIZE)	173	HUFFMAN_TABLE_SIZE)
174	return AVERROR(EIO);	174	return AVERROR(EIO);
175	/* save a reference in order to transport the palette */	175	/* save a reference in order to transport the palette */
@@ -231,13 +231,13 @@ static int idcin_read_packet(AVFormatContext *s, · 55 unmodified lines
231	return AVERROR(EIO);	231	return AVERROR(EIO);
232		232
233	if (idcin->next_chunk_is_video) {	233	if (idcin->next_chunk_is_video) {
234	command = get_le32(pb);	234	command = avio_rl32(pb);
235	if (command == 2) {	235	if (command == 2) {
236	return AVERROR(EIO);	236	return AVERROR(EIO);
237	} else if (command == 1) {	237	} else if (command == 1) {
238	/* trigger a palette change */	238	/* trigger a palette change */
239	idcin->palctrl.palette_changed = 1;	239	idcin->palctrl.palette_changed = 1;
240	if (get_buffer(pb, palette_buffer, 768) != 768)	240	if (avio_read(pb, palette_buffer, 768) != 768)
241	return AVERROR(EIO);	241	return AVERROR(EIO);
242	/* scale the palette as necessary */	242	/* scale the palette as necessary */
243	palette_scale = 2;	243	palette_scale = 2;
@@ -255,7 +255,7 @@ static int idcin_read_packet(AVFormatContext *s, · 11 unmodified lines
255	}	255	}
256	}	256	}
257		257
258	chunk_size = get_le32(pb);	258	chunk_size = avio_rl32(pb);
259	/* skip the number of decoded bytes (always equal to width * height) */	259	/* skip the number of decoded bytes (always equal to width * height) */
260	url_fseek(pb, 4, SEEK_CUR);	260	url_fseek(pb, 4, SEEK_CUR);
261	chunk_size -= 4;	261	chunk_size -= 4;

libavformat/idroqdec.c+5−5

@@ -74,7 +74,7 @@ static int roq_read_header(AVFormatContext *s, · 73 unmodified lines
74	unsigned char preamble[RoQ_CHUNK_PREAMBLE_SIZE];	74	unsigned char preamble[RoQ_CHUNK_PREAMBLE_SIZE];
75		75
76	/* get the main header */	76	/* get the main header */
77	if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) !=	77	if (avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) !=
78	RoQ_CHUNK_PREAMBLE_SIZE)	78	RoQ_CHUNK_PREAMBLE_SIZE)
79	return AVERROR(EIO);	79	return AVERROR(EIO);
80	framerate = AV_RL16(&preamble[6]);	80	framerate = AV_RL16(&preamble[6]);
@@ -115,7 +115,7 @@ static int roq_read_packet(AVFormatContext *s, · 34 unmodified lines
115	return AVERROR(EIO);	115	return AVERROR(EIO);
116		116
117	/* get the next chunk preamble */	117	/* get the next chunk preamble */
118	if ((ret = get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE)) !=	118	if ((ret = avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE)) !=
119	RoQ_CHUNK_PREAMBLE_SIZE)	119	RoQ_CHUNK_PREAMBLE_SIZE)
120	return AVERROR(EIO);	120	return AVERROR(EIO);
121		121
@@ -129,7 +129,7 @@ static int roq_read_packet(AVFormatContext *s, · 7 unmodified lines
129	case RoQ_INFO:	129	case RoQ_INFO:
130	if (!roq->width \|\| !roq->height) {	130	if (!roq->width \|\| !roq->height) {
131	AVStream *st = s->streams[roq->video_stream_index];	131	AVStream *st = s->streams[roq->video_stream_index];
132	if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != RoQ_CHUNK_PREAMBLE_SIZE)	132	if (avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != RoQ_CHUNK_PREAMBLE_SIZE)
133	return AVERROR(EIO);	133	return AVERROR(EIO);
134	st->codec->width = roq->width = AV_RL16(preamble);	134	st->codec->width = roq->width = AV_RL16(preamble);
135	st->codec->height = roq->height = AV_RL16(preamble + 2);	135	st->codec->height = roq->height = AV_RL16(preamble + 2);
@@ -144,7 +144,7 @@ static int roq_read_packet(AVFormatContext *s, · 8 unmodified lines
144	codebook_offset = url_ftell(pb) - RoQ_CHUNK_PREAMBLE_SIZE;	144	codebook_offset = url_ftell(pb) - RoQ_CHUNK_PREAMBLE_SIZE;
145	codebook_size = chunk_size;	145	codebook_size = chunk_size;
146	url_fseek(pb, codebook_size, SEEK_CUR);	146	url_fseek(pb, codebook_size, SEEK_CUR);
147	if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) !=	147	if (avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) !=
148	RoQ_CHUNK_PREAMBLE_SIZE)	148	RoQ_CHUNK_PREAMBLE_SIZE)
149	return AVERROR(EIO);	149	return AVERROR(EIO);
150	chunk_size = AV_RL32(&preamble[2]) + RoQ_CHUNK_PREAMBLE_SIZE * 2 +	150	chunk_size = AV_RL32(&preamble[2]) + RoQ_CHUNK_PREAMBLE_SIZE * 2 +
@@ -198,7 +198,7 @@ static int roq_read_packet(AVFormatContext *s, · 47 unmodified lines
198	}	198	}
199		199
200	pkt->pos= url_ftell(pb);	200	pkt->pos= url_ftell(pb);
201	ret = get_buffer(pb, pkt->data + RoQ_CHUNK_PREAMBLE_SIZE,	201	ret = avio_read(pb, pkt->data + RoQ_CHUNK_PREAMBLE_SIZE,
202	chunk_size);	202	chunk_size);
203	if (ret != chunk_size)	203	if (ret != chunk_size)
204	ret = AVERROR(EIO);	204	ret = AVERROR(EIO);

libavformat/iff.c+15−15

@@ -101,7 +101,7 @@ static int get_metadata(AVFormatContext *s, · 100 unmodified lines
101	if (!buf)	101	if (!buf)
102	return AVERROR(ENOMEM);	102	return AVERROR(ENOMEM);
103		103
104	if (get_buffer(s->pb, buf, data_size) < 0) {	104	if (avio_read(s->pb, buf, data_size) < 0) {
105	av_free(buf);	105	av_free(buf);
106	return AVERROR(EIO);	106	return AVERROR(EIO);
107	}	107	}
@@ -136,14 +136,14 @@ static int iff_read_header(AVFormatContext *s, · 28 unmodified lines
136	st->codec->channels = 1;	136	st->codec->channels = 1;
137	url_fskip(pb, 8);	137	url_fskip(pb, 8);
138	// codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content	138	// codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content
139	st->codec->codec_tag = get_le32(pb);	139	st->codec->codec_tag = avio_rl32(pb);
140		140
141	while(!url_feof(pb)) {	141	while(!url_feof(pb)) {
142	uint64_t orig_pos;	142	uint64_t orig_pos;
143	int res;	143	int res;
144	const char *metadata_tag = NULL;	144	const char *metadata_tag = NULL;
145	chunk_id = get_le32(pb);	145	chunk_id = avio_rl32(pb);
146	data_size = get_be32(pb);	146	data_size = avio_rb32(pb);
147	orig_pos = url_ftell(pb);	147	orig_pos = url_ftell(pb);
148		148
149	switch(chunk_id) {	149	switch(chunk_id) {
@@ -153,10 +153,10 @@ static int iff_read_header(AVFormatContext *s, · 3 unmodified lines
153	if (data_size < 14)	153	if (data_size < 14)
154	return AVERROR_INVALIDDATA;	154	return AVERROR_INVALIDDATA;
155	url_fskip(pb, 12);	155	url_fskip(pb, 12);
156	st->codec->sample_rate = get_be16(pb);	156	st->codec->sample_rate = avio_rb16(pb);
157	if (data_size >= 16) {	157	if (data_size >= 16) {
158	url_fskip(pb, 1);	158	url_fskip(pb, 1);
159	compression = get_byte(pb);	159	compression = avio_r8(pb);
160	}	160	}
161	break;	161	break;
162		162
@@ -168,7 +168,7 @@ static int iff_read_header(AVFormatContext *s, · 5 unmodified lines
168	case ID_CHAN:	168	case ID_CHAN:
169	if (data_size < 4)	169	if (data_size < 4)
170	return AVERROR_INVALIDDATA;	170	return AVERROR_INVALIDDATA;
171	st->codec->channels = (get_be32(pb) < 6) ? 1 : 2;	171	st->codec->channels = (avio_rb32(pb) < 6) ? 1 : 2;
172	break;	172	break;
173		173
174	case ID_CMAP:	174	case ID_CMAP:
@@ -176,7 +176,7 @@ static int iff_read_header(AVFormatContext *s, · 1 unmodified line
176	st->codec->extradata = av_malloc(data_size);	176	st->codec->extradata = av_malloc(data_size);
177	if (!st->codec->extradata)	177	if (!st->codec->extradata)
178	return AVERROR(ENOMEM);	178	return AVERROR(ENOMEM);
179	if (get_buffer(pb, st->codec->extradata, data_size) < 0)	179	if (avio_read(pb, st->codec->extradata, data_size) < 0)
180	return AVERROR(EIO);	180	return AVERROR(EIO);
181	break;	181	break;
182		182
@@ -184,18 +184,18 @@ static int iff_read_header(AVFormatContext *s, · 1 unmodified line
184	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;	184	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
185	if (data_size <= 8)	185	if (data_size <= 8)
186	return AVERROR_INVALIDDATA;	186	return AVERROR_INVALIDDATA;
187	st->codec->width = get_be16(pb);	187	st->codec->width = avio_rb16(pb);
188	st->codec->height = get_be16(pb);	188	st->codec->height = avio_rb16(pb);
189	url_fskip(pb, 4); // x, y offset	189	url_fskip(pb, 4); // x, y offset
190	st->codec->bits_per_coded_sample = get_byte(pb);	190	st->codec->bits_per_coded_sample = avio_r8(pb);
191	if (data_size >= 11) {	191	if (data_size >= 11) {
192	url_fskip(pb, 1); // masking	192	url_fskip(pb, 1); // masking
193	compression = get_byte(pb);	193	compression = avio_r8(pb);
194	}	194	}
195	if (data_size >= 16) {	195	if (data_size >= 16) {
196	url_fskip(pb, 3); // paddding, transparent	196	url_fskip(pb, 3); // paddding, transparent
197	st->sample_aspect_ratio.num = get_byte(pb);	197	st->sample_aspect_ratio.num = avio_r8(pb);
198	st->sample_aspect_ratio.den = get_byte(pb);	198	st->sample_aspect_ratio.den = avio_r8(pb);
199	}	199	}
200	break;	200	break;
201		201
@@ -286,7 +286,7 @@ static int iff_read_packet(AVFormatContext *s, · 84 unmodified lines
286	if(st->codec->channels == 2) {	286	if(st->codec->channels == 2) {
287	uint8_t sample_buffer[PACKET_SIZE];	287	uint8_t sample_buffer[PACKET_SIZE];
288		288
289	ret = get_buffer(pb, sample_buffer, PACKET_SIZE);	289	ret = avio_read(pb, sample_buffer, PACKET_SIZE);
290	if(av_new_packet(pkt, PACKET_SIZE) < 0) {	290	if(av_new_packet(pkt, PACKET_SIZE) < 0) {
291	av_log(s, AV_LOG_ERROR, "cannot allocate packet\n");	291	av_log(s, AV_LOG_ERROR, "cannot allocate packet\n");
292	return AVERROR(ENOMEM);	292	return AVERROR(ENOMEM);

libavformat/img2.c+1−1

@@ -298,7 +298,7 @@ static int read_packet(AVFormatContext s1, AVPacket pkt) · 297 unmodified lines
298	pkt->size= 0;	298	pkt->size= 0;
299	for(i=0; i<3; i++){	299	for(i=0; i<3; i++){
300	if(size[i]){	300	if(size[i]){
301	ret[i]= get_buffer(f[i], pkt->data + pkt->size, size[i]);	301	ret[i]= avio_read(f[i], pkt->data + pkt->size, size[i]);
302	if (!s->is_pipe)	302	if (!s->is_pipe)
303	url_fclose(f[i]);	303	url_fclose(f[i]);
304	if(ret[i]>0)	304	if(ret[i]>0)

libavformat/ingenientdec.c+7−7

@@ -27,18 +27,18 @@ static int ingenient_read_packet(AVFormatContext s, AVPacket pkt) · 26 unmodified lines
27	{	27	{
28	int ret, size, w, h, unk1, unk2;	28	int ret, size, w, h, unk1, unk2;
29		29
30	if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G'))	30	if (avio_rl32(s->pb) != MKTAG('M', 'J', 'P', 'G'))
31	return AVERROR(EIO); // FIXME	31	return AVERROR(EIO); // FIXME
32		32
33	size = get_le32(s->pb);	33	size = avio_rl32(s->pb);
34		34
35	w = get_le16(s->pb);	35	w = avio_rl16(s->pb);
36	h = get_le16(s->pb);	36	h = avio_rl16(s->pb);
37		37
38	url_fskip(s->pb, 8); // zero + size (padded?)	38	url_fskip(s->pb, 8); // zero + size (padded?)
39	url_fskip(s->pb, 2);	39	url_fskip(s->pb, 2);
40	unk1 = get_le16(s->pb);	40	unk1 = avio_rl16(s->pb);
41	unk2 = get_le16(s->pb);	41	unk2 = avio_rl16(s->pb);
42	url_fskip(s->pb, 22); // ASCII timestamp	42	url_fskip(s->pb, 22); // ASCII timestamp
43		43
44	av_log(s, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",	44	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) · 4 unmodified lines
49		49
50	pkt->pos = url_ftell(s->pb);	50	pkt->pos = url_ftell(s->pb);
51	pkt->stream_index = 0;	51	pkt->stream_index = 0;
52	ret = get_buffer(s->pb, pkt->data, size);	52	ret = avio_read(s->pb, pkt->data, size);
53	if (ret < 0) {	53	if (ret < 0) {
54	av_free_packet(pkt);	54	av_free_packet(pkt);
55	return ret;	55	return ret;

libavformat/ipmovie.c+11−11

@@ -166,7 +166,7 @@ static int load_ipmovie_packet(IPMVEContext s, AVIOContext pb, · 165 unmodified lines
166	url_fseek(pb, s->decode_map_chunk_offset, SEEK_SET);	166	url_fseek(pb, s->decode_map_chunk_offset, SEEK_SET);
167	s->decode_map_chunk_offset = 0;	167	s->decode_map_chunk_offset = 0;
168		168
169	if (get_buffer(pb, pkt->data, s->decode_map_chunk_size) !=	169	if (avio_read(pb, pkt->data, s->decode_map_chunk_size) !=
170	s->decode_map_chunk_size) {	170	s->decode_map_chunk_size) {
171	av_free_packet(pkt);	171	av_free_packet(pkt);
172	return CHUNK_EOF;	172	return CHUNK_EOF;
@@ -175,7 +175,7 @@ static int load_ipmovie_packet(IPMVEContext s, AVIOContext pb, · 2 unmodified lines
175	url_fseek(pb, s->video_chunk_offset, SEEK_SET);	175	url_fseek(pb, s->video_chunk_offset, SEEK_SET);
176	s->video_chunk_offset = 0;	176	s->video_chunk_offset = 0;
177		177
178	if (get_buffer(pb, pkt->data + s->decode_map_chunk_size,	178	if (avio_read(pb, pkt->data + s->decode_map_chunk_size,
179	s->video_chunk_size) != s->video_chunk_size) {	179	s->video_chunk_size) != s->video_chunk_size) {
180	av_free_packet(pkt);	180	av_free_packet(pkt);
181	return CHUNK_EOF;	181	return CHUNK_EOF;
@@ -227,7 +227,7 @@ static int process_ipmovie_chunk(IPMVEContext s, AVIOContext pb, · 45 unmodified lines
227	/* read the next chunk, wherever the file happens to be pointing */	227	/* read the next chunk, wherever the file happens to be pointing */
228	if (url_feof(pb))	228	if (url_feof(pb))
229	return CHUNK_EOF;	229	return CHUNK_EOF;
230	if (get_buffer(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) !=	230	if (avio_read(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) !=
231	CHUNK_PREAMBLE_SIZE)	231	CHUNK_PREAMBLE_SIZE)
232	return CHUNK_BAD;	232	return CHUNK_BAD;
233	chunk_size = AV_RL16(&chunk_preamble[0]);	233	chunk_size = AV_RL16(&chunk_preamble[0]);
@@ -275,7 +275,7 @@ static int process_ipmovie_chunk(IPMVEContext s, AVIOContext pb, · 41 unmodified lines
275	chunk_type = CHUNK_EOF;	275	chunk_type = CHUNK_EOF;
276	break;	276	break;
277	}	277	}
278	if (get_buffer(pb, opcode_preamble, CHUNK_PREAMBLE_SIZE) !=	278	if (avio_read(pb, opcode_preamble, CHUNK_PREAMBLE_SIZE) !=
279	CHUNK_PREAMBLE_SIZE) {	279	CHUNK_PREAMBLE_SIZE) {
280	chunk_type = CHUNK_BAD;	280	chunk_type = CHUNK_BAD;
281	break;	281	break;
@@ -314,7 +314,7 @@ static int process_ipmovie_chunk(IPMVEContext s, AVIOContext pb, · 32 unmodified lines
314	chunk_type = CHUNK_BAD;	314	chunk_type = CHUNK_BAD;
315	break;	315	break;
316	}	316	}
317	if (get_buffer(pb, scratch, opcode_size) !=	317	if (avio_read(pb, scratch, opcode_size) !=
318	opcode_size) {	318	opcode_size) {
319	chunk_type = CHUNK_BAD;	319	chunk_type = CHUNK_BAD;
320	break;	320	break;
@@ -331,7 +331,7 @@ static int process_ipmovie_chunk(IPMVEContext s, AVIOContext pb, · 10 unmodified lines
331	chunk_type = CHUNK_BAD;	331	chunk_type = CHUNK_BAD;
332	break;	332	break;
333	}	333	}
334	if (get_buffer(pb, scratch, opcode_size) !=	334	if (avio_read(pb, scratch, opcode_size) !=
335	opcode_size) {	335	opcode_size) {
336	chunk_type = CHUNK_BAD;	336	chunk_type = CHUNK_BAD;
337	break;	337	break;
@@ -369,7 +369,7 @@ static int process_ipmovie_chunk(IPMVEContext s, AVIOContext pb, · 31 unmodified lines
369	chunk_type = CHUNK_BAD;	369	chunk_type = CHUNK_BAD;
370	break;	370	break;
371	}	371	}
372	if (get_buffer(pb, scratch, opcode_size) !=	372	if (avio_read(pb, scratch, opcode_size) !=
373	opcode_size) {	373	opcode_size) {
374	chunk_type = CHUNK_BAD;	374	chunk_type = CHUNK_BAD;
375	break;	375	break;
@@ -434,7 +434,7 @@ static int process_ipmovie_chunk(IPMVEContext s, AVIOContext pb, · 58 unmodified lines
434	chunk_type = CHUNK_BAD;	434	chunk_type = CHUNK_BAD;
435	break;	435	break;
436	}	436	}
437	if (get_buffer(pb, scratch, opcode_size) != opcode_size) {	437	if (avio_read(pb, scratch, opcode_size) != opcode_size) {
438	chunk_type = CHUNK_BAD;	438	chunk_type = CHUNK_BAD;
439	break;	439	break;
440	}	440	}
@@ -528,10 +528,10 @@ static int ipmovie_read_header(AVFormatContext *s, · 87 unmodified lines
528	int chunk_type;	528	int chunk_type;
529	uint8_t signature_buffer[sizeof(signature)];	529	uint8_t signature_buffer[sizeof(signature)];
530		530
531	get_buffer(pb, signature_buffer, sizeof(signature_buffer));	531	avio_read(pb, signature_buffer, sizeof(signature_buffer));
532	while (memcmp(signature_buffer, signature, sizeof(signature))) {	532	while (memcmp(signature_buffer, signature, sizeof(signature))) {
533	memmove(signature_buffer, signature_buffer + 1, sizeof(signature_buffer) - 1);	533	memmove(signature_buffer, signature_buffer + 1, sizeof(signature_buffer) - 1);
534	signature_buffer[sizeof(signature_buffer) - 1] = get_byte(pb);	534	signature_buffer[sizeof(signature_buffer) - 1] = avio_r8(pb);
535	if (url_feof(pb))	535	if (url_feof(pb))
536	return AVERROR_EOF;	536	return AVERROR_EOF;
537	}	537	}
@@ -549,7 +549,7 @@ static int ipmovie_read_header(AVFormatContext *s, · 11 unmodified lines
549		549
550	/* peek ahead to the next chunk-- if it is an init audio chunk, process	550	/* peek ahead to the next chunk-- if it is an init audio chunk, process
551	* it; if it is the first video chunk, this is a silent file */	551	* it; if it is the first video chunk, this is a silent file */
552	if (get_buffer(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) !=	552	if (avio_read(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) !=
553	CHUNK_PREAMBLE_SIZE)	553	CHUNK_PREAMBLE_SIZE)
554	return AVERROR(EIO);	554	return AVERROR(EIO);
555	chunk_type = AV_RL16(&chunk_preamble[2]);	555	chunk_type = AV_RL16(&chunk_preamble[2]);

libavformat/isom.c+8−8

@@ -346,7 +346,7 @@ int ff_mp4_read_descr_len(AVIOContext *pb) · 345 unmodified lines
346	int len = 0;	346	int len = 0;
347	int count = 4;	347	int count = 4;
348	while (count--) {	348	while (count--) {
349	int c = get_byte(pb);	349	int c = avio_r8(pb);
350	len = (len << 7) \| (c & 0x7f);	350	len = (len << 7) \| (c & 0x7f);
351	if (!(c & 0x80))	351	if (!(c & 0x80))
352	break;	352	break;
@@ -357,7 +357,7 @@ int ff_mp4_read_descr_len(AVIOContext *pb) · 4 unmodified lines
357	int ff_mp4_read_descr(AVFormatContext fc, AVIOContext pb, int *tag)	357	int ff_mp4_read_descr(AVFormatContext fc, AVIOContext pb, int *tag)
358	{	358	{
359	int len;	359	int len;
360	*tag = get_byte(pb);	360	*tag = avio_r8(pb);
361	len = ff_mp4_read_descr_len(pb);	361	len = ff_mp4_read_descr_len(pb);
362	av_dlog(fc, "MPEG4 description: tag=0x%02x len=%d\n", *tag, len);	362	av_dlog(fc, "MPEG4 description: tag=0x%02x len=%d\n", *tag, len);
363	return len;	363	return len;
@@ -375,11 +375,11 @@ static const AVCodecTag mp4_audio_types[] = { · 11 unmodified lines
375	int ff_mp4_read_dec_config_descr(AVFormatContext fc, AVStream st, AVIOContext *pb)	375	int ff_mp4_read_dec_config_descr(AVFormatContext fc, AVStream st, AVIOContext *pb)
376	{	376	{
377	int len, tag;	377	int len, tag;
378	int object_type_id = get_byte(pb);	378	int object_type_id = avio_r8(pb);
379	get_byte(pb); /* stream type */	379	avio_r8(pb); /* stream type */
380	get_be24(pb); /* buffer size db */	380	avio_rb24(pb); /* buffer size db */
381	get_be32(pb); /* max bitrate */	381	avio_rb32(pb); /* max bitrate */
382	get_be32(pb); /* avg bitrate */	382	avio_rb32(pb); /* avg bitrate */
383		383
384	st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id);	384	st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id);
385	av_dlog(fc, "esds object type id 0x%02x\n", object_type_id);	385	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 · 6 unmodified lines
392	st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);	392	st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
393	if (!st->codec->extradata)	393	if (!st->codec->extradata)
394	return AVERROR(ENOMEM);	394	return AVERROR(ENOMEM);
395	get_buffer(pb, st->codec->extradata, len);	395	avio_read(pb, st->codec->extradata, len);
396	st->codec->extradata_size = len;	396	st->codec->extradata_size = len;
397	if (st->codec->codec_id == CODEC_ID_AAC) {	397	if (st->codec->codec_id == CODEC_ID_AAC) {
398	MPEG4AudioConfig cfg;	398	MPEG4AudioConfig cfg;

libavformat/iss.c+2−2

@@ -44,7 +44,7 @@ static void get_token(AVIOContext s, char buf, int maxlen) · 43 unmodified lines
44	int i = 0;	44	int i = 0;
45	char c;	45	char c;
46		46
47	while ((c = get_byte(s))) {	47	while ((c = avio_r8(s))) {
48	if(c == ' ')	48	if(c == ' ')
49	break;	49	break;
50	if (i < maxlen-1)	50	if (i < maxlen-1)
@@ -52,7 +52,7 @@ static void get_token(AVIOContext s, char buf, int maxlen) · 1 unmodified line
52	}	52	}
53		53
54	if(!c)	54	if(!c)
55	get_byte(s);	55	avio_r8(s);
56		56
57	buf[i] = 0; /* Ensure null terminated, but may be truncated */	57	buf[i] = 0; /* Ensure null terminated, but may be truncated */
58	}	58	}

libavformat/iv8.c+6−6

@@ -57,13 +57,13 @@ static int read_packet(AVFormatContext s, AVPacket pkt) · 56 unmodified lines
57	{	57	{
58	int ret, size, pts, type;	58	int ret, size, pts, type;
59	retry:	59	retry:
60	type= get_be16(s->pb); // 257 or 258	60	type= avio_rb16(s->pb); // 257 or 258
61	size= get_be16(s->pb);	61	size= avio_rb16(s->pb);
62		62
63	get_be16(s->pb); //some flags, 0x80 indicates end of frame	63	avio_rb16(s->pb); //some flags, 0x80 indicates end of frame
64	get_be16(s->pb); //packet number	64	avio_rb16(s->pb); //packet number
65	pts=get_be32(s->pb);	65	pts=avio_rb32(s->pb);
66	get_be32(s->pb); //6A 13 E3 88	66	avio_rb32(s->pb); //6A 13 E3 88
67		67
68	size -= 12;	68	size -= 12;
69	if(size<1)	69	if(size<1)

libavformat/ivfdec.c+11−11

@@ -36,9 +36,9 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 35 unmodified lines
36	AVStream *st;	36	AVStream *st;
37	AVRational time_base;	37	AVRational time_base;
38		38
39	get_le32(s->pb); // DKIF	39	avio_rl32(s->pb); // DKIF
40	get_le16(s->pb); // version	40	avio_rl16(s->pb); // version
41	get_le16(s->pb); // header size	41	avio_rl16(s->pb); // header size
42		42
43	st = av_new_stream(s, 0);	43	st = av_new_stream(s, 0);
44	if (!st)	44	if (!st)
@@ -46,13 +46,13 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 1 unmodified line
46		46
47		47
48	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;	48	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
49	st->codec->codec_tag = get_le32(s->pb);	49	st->codec->codec_tag = avio_rl32(s->pb);
50	st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, st->codec->codec_tag);	50	st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, st->codec->codec_tag);
51	st->codec->width = get_le16(s->pb);	51	st->codec->width = avio_rl16(s->pb);
52	st->codec->height = get_le16(s->pb);	52	st->codec->height = avio_rl16(s->pb);
53	time_base.den = get_le32(s->pb);	53	time_base.den = avio_rl32(s->pb);
54	time_base.num = get_le32(s->pb);	54	time_base.num = avio_rl32(s->pb);
55	st->duration = get_le64(s->pb);	55	st->duration = avio_rl64(s->pb);
56		56
57	st->need_parsing = AVSTREAM_PARSE_HEADERS;	57	st->need_parsing = AVSTREAM_PARSE_HEADERS;
58		58
@@ -68,8 +68,8 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 9 unmodified lines
68		68
69	static int read_packet(AVFormatContext s, AVPacket pkt)	69	static int read_packet(AVFormatContext s, AVPacket pkt)
70	{	70	{
71	int ret, size = get_le32(s->pb);	71	int ret, size = avio_rl32(s->pb);
72	int64_t pts = get_le64(s->pb);	72	int64_t pts = avio_rl64(s->pb);
73		73
74	ret = av_get_packet(s->pb, pkt, size);	74	ret = av_get_packet(s->pb, pkt, size);
75	pkt->stream_index = 0;	75	pkt->stream_index = 0;

libavformat/libnut.c+1−1

@@ -173,7 +173,7 @@ static int nut_probe(AVProbeData *p) { · 172 unmodified lines
173		173
174	static size_t av_read(void * h, size_t len, uint8_t * buf) {	174	static size_t av_read(void * h, size_t len, uint8_t * buf) {
175	AVIOContext * bc = h;	175	AVIOContext * bc = h;
176	return get_buffer(bc, buf, len);	176	return avio_read(bc, buf, len);
177	}	177	}
178		178
179	static off_t av_seek(void * h, long long pos, int whence) {	179	static off_t av_seek(void * h, long long pos, int whence) {

libavformat/lmlm4.c+3−3

@@ -82,9 +82,9 @@ static int lmlm4_read_packet(AVFormatContext s, AVPacket pkt) { · 81 unmodified lines
82	int ret;	82	int ret;
83	unsigned int frame_type, packet_size, padding, frame_size;	83	unsigned int frame_type, packet_size, padding, frame_size;
84		84
85	get_be16(pb); /* channel number */	85	avio_rb16(pb); /* channel number */
86	frame_type = get_be16(pb);	86	frame_type = avio_rb16(pb);
87	packet_size = get_be32(pb);	87	packet_size = avio_rb32(pb);
88	padding = -packet_size & 511;	88	padding = -packet_size & 511;
89	frame_size = packet_size - 8;	89	frame_size = packet_size - 8;
90		90

libavformat/lxfdec.c+5−5

@@ -86,7 +86,7 @@ static int sync(AVFormatContext s, uint8_t header) · 85 unmodified lines
86	uint8_t buf[LXF_IDENT_LENGTH];	86	uint8_t buf[LXF_IDENT_LENGTH];
87	int ret;	87	int ret;
88		88
89	if ((ret = get_buffer(s->pb, buf, LXF_IDENT_LENGTH)) != LXF_IDENT_LENGTH)	89	if ((ret = avio_read(s->pb, buf, LXF_IDENT_LENGTH)) != LXF_IDENT_LENGTH)
90	return ret < 0 ? ret : AVERROR_EOF;	90	return ret < 0 ? ret : AVERROR_EOF;
91		91
92	while (memcmp(buf, LXF_IDENT, LXF_IDENT_LENGTH)) {	92	while (memcmp(buf, LXF_IDENT, LXF_IDENT_LENGTH)) {
@@ -94,7 +94,7 @@ static int sync(AVFormatContext s, uint8_t header) · 1 unmodified line
94	return AVERROR_EOF;	94	return AVERROR_EOF;
95		95
96	memmove(buf, &buf[1], LXF_IDENT_LENGTH-1);	96	memmove(buf, &buf[1], LXF_IDENT_LENGTH-1);
97	buf[LXF_IDENT_LENGTH-1] = get_byte(s->pb);	97	buf[LXF_IDENT_LENGTH-1] = avio_r8(s->pb);
98	}	98	}
99		99
100	memcpy(header, LXF_IDENT, LXF_IDENT_LENGTH);	100	memcpy(header, LXF_IDENT, LXF_IDENT_LENGTH);
@@ -120,7 +120,7 @@ static int get_packet_header(AVFormatContext s, uint8_t header, uint32_t *form · 19 unmodified lines
120	return ret;	120	return ret;
121		121
122	//read the rest of the packet header	122	//read the rest of the packet header
123	if ((ret = get_buffer(pb, header + LXF_IDENT_LENGTH,	123	if ((ret = avio_read(pb, header + LXF_IDENT_LENGTH,
124	LXF_PACKET_HEADER_SIZE - LXF_IDENT_LENGTH)) !=	124	LXF_PACKET_HEADER_SIZE - LXF_IDENT_LENGTH)) !=
125	LXF_PACKET_HEADER_SIZE - LXF_IDENT_LENGTH) {	125	LXF_PACKET_HEADER_SIZE - LXF_IDENT_LENGTH) {
126	return ret < 0 ? ret : AVERROR_EOF;	126	return ret < 0 ? ret : AVERROR_EOF;
@@ -214,7 +214,7 @@ static int lxf_read_header(AVFormatContext s, AVFormatParameters ap) · 87 unmodified lines
214	return AVERROR_INVALIDDATA;	214	return AVERROR_INVALIDDATA;
215	}	215	}
216		216
217	if ((ret = get_buffer(pb, header_data, LXF_HEADER_DATA_SIZE)) != LXF_HEADER_DATA_SIZE)	217	if ((ret = avio_read(pb, header_data, LXF_HEADER_DATA_SIZE)) != LXF_HEADER_DATA_SIZE)
218	return ret < 0 ? ret : AVERROR_EOF;	218	return ret < 0 ? ret : AVERROR_EOF;
219		219
220	if (!(st = av_new_stream(s, 0)))	220	if (!(st = av_new_stream(s, 0)))
@@ -315,7 +315,7 @@ static int lxf_read_packet(AVFormatContext s, AVPacket pkt) · 94 unmodified lines
315	//read non-20-bit audio data into lxf->temp so we can deplanarize it	315	//read non-20-bit audio data into lxf->temp so we can deplanarize it
316	buf = ast && ast->codec->codec_id != CODEC_ID_PCM_LXF ? lxf->temp : pkt->data;	316	buf = ast && ast->codec->codec_id != CODEC_ID_PCM_LXF ? lxf->temp : pkt->data;
317		317
318	if ((ret2 = get_buffer(pb, buf, ret)) != ret) {	318	if ((ret2 = avio_read(pb, buf, ret)) != ret) {
319	av_free_packet(pkt);	319	av_free_packet(pkt);
320	return ret2 < 0 ? ret2 : AVERROR_EOF;	320	return ret2 < 0 ? ret2 : AVERROR_EOF;
321	}	321	}

libavformat/matroskadec.c+13−13

@@ -543,10 +543,10 @@ static int ebml_read_num(MatroskaDemuxContext matroska, AVIOContext pb, · 542 unmodified lines
543	int read = 1, n = 1;	543	int read = 1, n = 1;
544	uint64_t total = 0;	544	uint64_t total = 0;
545		545
546	/* The first byte tells us the length in bytes - get_byte() can normally	546	/* The first byte tells us the length in bytes - avio_r8() can normally
547	* return 0, but since that's not a valid first ebmlID byte, we can	547	* return 0, but since that's not a valid first ebmlID byte, we can
548	* use it safely here to catch EOS. */	548	* use it safely here to catch EOS. */
549	if (!(total = get_byte(pb))) {	549	if (!(total = avio_r8(pb))) {
550	/* we might encounter EOS here */	550	/* we might encounter EOS here */
551	if (!url_feof(pb)) {	551	if (!url_feof(pb)) {
552	int64_t pos = url_ftell(pb);	552	int64_t pos = url_ftell(pb);
@@ -570,7 +570,7 @@ static int ebml_read_num(MatroskaDemuxContext matroska, AVIOContext pb, · 17 unmodified lines
570	/* read out length */	570	/* read out length */
571	total ^= 1 << ff_log2_tab[total];	571	total ^= 1 << ff_log2_tab[total];
572	while (n++ < read)	572	while (n++ < read)
573	total = (total << 8) \| get_byte(pb);	573	total = (total << 8) \| avio_r8(pb);
574		574
575	*number = total;	575	*number = total;
576		576
@@ -605,7 +605,7 @@ static int ebml_read_uint(AVIOContext pb, int size, uint64_t num) · 28 unmodified lines
605	/* big-endian ordering; build up number */	605	/* big-endian ordering; build up number */
606	*num = 0;	606	*num = 0;
607	while (n++ < size)	607	while (n++ < size)
608	num = (num << 8) \| get_byte(pb);	608	num = (num << 8) \| avio_r8(pb);
609		609
610	return 0;	610	return 0;
611	}	611	}
@@ -619,9 +619,9 @@ static int ebml_read_float(AVIOContext pb, int size, double num) · 7 unmodified lines
619	if (size == 0) {	619	if (size == 0) {
620	*num = 0;	620	*num = 0;
621	} else if (size == 4) {	621	} else if (size == 4) {
622	*num= av_int2flt(get_be32(pb));	622	*num= av_int2flt(avio_rb32(pb));
623	} else if(size==8){	623	} else if(size==8){
624	*num= av_int2dbl(get_be64(pb));	624	*num= av_int2dbl(avio_rb64(pb));
625	} else	625	} else
626	return AVERROR_INVALIDDATA;	626	return AVERROR_INVALIDDATA;
627		627
@@ -639,7 +639,7 @@ static int ebml_read_ascii(AVIOContext pb, int size, char *str) · 11 unmodified lines
639	* byte more, read the string and NULL-terminate it ourselves. */	639	* byte more, read the string and NULL-terminate it ourselves. */
640	if (!(*str = av_malloc(size + 1)))	640	if (!(*str = av_malloc(size + 1)))
641	return AVERROR(ENOMEM);	641	return AVERROR(ENOMEM);
642	if (get_buffer(pb, (uint8_t ) str, size) != size) {	642	if (avio_read(pb, (uint8_t ) str, size) != size) {
643	av_freep(str);	643	av_freep(str);
644	return AVERROR(EIO);	644	return AVERROR(EIO);
645	}	645	}
@@ -660,7 +660,7 @@ static int ebml_read_binary(AVIOContext pb, int length, EbmlBin bin) · 14 unmodified lines
660		660
661	bin->size = length;	661	bin->size = length;
662	bin->pos = url_ftell(pb);	662	bin->pos = url_ftell(pb);
663	if (get_buffer(pb, bin->data, length) != length) {	663	if (avio_read(pb, bin->data, length) != length) {
664	av_freep(&bin->data);	664	av_freep(&bin->data);
665	return AVERROR(EIO);	665	return AVERROR(EIO);
666	}	666	}
@@ -1394,12 +1394,12 @@ static int matroska_read_header(AVFormatContext s, AVFormatParameters ap) · 727 unmodified lines
1394	ffio_init_context(&b, track->codec_priv.data,track->codec_priv.size,	1394	ffio_init_context(&b, track->codec_priv.data,track->codec_priv.size,
1395	0, NULL, NULL, NULL, NULL);	1395	0, NULL, NULL, NULL, NULL);
1396	url_fskip(&b, 22);	1396	url_fskip(&b, 22);
1397	flavor = get_be16(&b);	1397	flavor = avio_rb16(&b);
1398	track->audio.coded_framesize = get_be32(&b);	1398	track->audio.coded_framesize = avio_rb32(&b);
1399	url_fskip(&b, 12);	1399	url_fskip(&b, 12);
1400	track->audio.sub_packet_h = get_be16(&b);	1400	track->audio.sub_packet_h = avio_rb16(&b);
1401	track->audio.frame_size = get_be16(&b);	1401	track->audio.frame_size = avio_rb16(&b);
1402	track->audio.sub_packet_size = get_be16(&b);	1402	track->audio.sub_packet_size = avio_rb16(&b);
1403	track->audio.buf = av_malloc(track->audio.frame_size * track->audio.sub_packet_h);	1403	track->audio.buf = av_malloc(track->audio.frame_size * track->audio.sub_packet_h);
1404	if (codec_id == CODEC_ID_RA_288) {	1404	if (codec_id == CODEC_ID_RA_288) {
1405	st->codec->block_align = track->audio.coded_framesize;	1405	st->codec->block_align = track->audio.coded_framesize;

libavformat/mm.c+9−9

@@ -90,18 +90,18 @@ static int read_header(AVFormatContext *s, · 89 unmodified lines
90	unsigned int type, length;	90	unsigned int type, length;
91	unsigned int frame_rate, width, height;	91	unsigned int frame_rate, width, height;
92		92
93	type = get_le16(pb);	93	type = avio_rl16(pb);
94	length = get_le32(pb);	94	length = avio_rl32(pb);
95		95
96	if (type != MM_TYPE_HEADER)	96	if (type != MM_TYPE_HEADER)
97	return AVERROR_INVALIDDATA;	97	return AVERROR_INVALIDDATA;
98		98
99	/* read header */	99	/* read header */
100	get_le16(pb); /* total number of chunks */	100	avio_rl16(pb); /* total number of chunks */
101	frame_rate = get_le16(pb);	101	frame_rate = avio_rl16(pb);
102	get_le16(pb); /* ibm-pc video bios mode */	102	avio_rl16(pb); /* ibm-pc video bios mode */
103	width = get_le16(pb);	103	width = avio_rl16(pb);
104	height = get_le16(pb);	104	height = avio_rl16(pb);
105	url_fseek(pb, length - 10, SEEK_CUR); /* unknown data */	105	url_fseek(pb, length - 10, SEEK_CUR); /* unknown data */
106		106
107	/* video stream */	107	/* video stream */
@@ -143,7 +143,7 @@ static int read_packet(AVFormatContext *s, · 35 unmodified lines
143		143
144	while(1) {	144	while(1) {
145		145
146	if (get_buffer(pb, preamble, MM_PREAMBLE_SIZE) != MM_PREAMBLE_SIZE) {	146	if (avio_read(pb, preamble, MM_PREAMBLE_SIZE) != MM_PREAMBLE_SIZE) {
147	return AVERROR(EIO);	147	return AVERROR(EIO);
148	}	148	}
149		149
@@ -162,7 +162,7 @@ static int read_packet(AVFormatContext *s, · 12 unmodified lines
162	if (av_new_packet(pkt, length + MM_PREAMBLE_SIZE))	162	if (av_new_packet(pkt, length + MM_PREAMBLE_SIZE))
163	return AVERROR(ENOMEM);	163	return AVERROR(ENOMEM);
164	memcpy(pkt->data, preamble, MM_PREAMBLE_SIZE);	164	memcpy(pkt->data, preamble, MM_PREAMBLE_SIZE);
165	if (get_buffer(pb, pkt->data + MM_PREAMBLE_SIZE, length) != length)	165	if (avio_read(pb, pkt->data + MM_PREAMBLE_SIZE, length) != length)
166	return AVERROR(EIO);	166	return AVERROR(EIO);
167	pkt->size = length + MM_PREAMBLE_SIZE;	167	pkt->size = length + MM_PREAMBLE_SIZE;
168	pkt->stream_index = 0;	168	pkt->stream_index = 0;

libavformat/mmf.c+13−13

@@ -188,15 +188,15 @@ static int mmf_read_header(AVFormatContext *s, · 187 unmodified lines
188	int64_t file_size, size;	188	int64_t file_size, size;
189	int rate, params;	189	int rate, params;
190		190
191	tag = get_le32(pb);	191	tag = avio_rl32(pb);
192	if (tag != MKTAG('M', 'M', 'M', 'D'))	192	if (tag != MKTAG('M', 'M', 'M', 'D'))
193	return -1;	193	return -1;
194	file_size = get_be32(pb);	194	file_size = avio_rb32(pb);
195		195
196	/* Skip some unused chunks that may or may not be present */	196	/* Skip some unused chunks that may or may not be present */
197	for(;; url_fseek(pb, size, SEEK_CUR)) {	197	for(;; url_fseek(pb, size, SEEK_CUR)) {
198	tag = get_le32(pb);	198	tag = avio_rl32(pb);
199	size = get_be32(pb);	199	size = avio_rb32(pb);
200	if(tag == MKTAG('C','N','T','I')) continue;	200	if(tag == MKTAG('C','N','T','I')) continue;
201	if(tag == MKTAG('O','P','D','A')) continue;	201	if(tag == MKTAG('O','P','D','A')) continue;
202	break;	202	break;
@@ -212,22 +212,22 @@ static int mmf_read_header(AVFormatContext *s, · 9 unmodified lines
212	return -1;	212	return -1;
213	}	213	}
214		214
215	get_byte(pb); /* format type */	215	avio_r8(pb); /* format type */
216	get_byte(pb); /* sequence type */	216	avio_r8(pb); /* sequence type */
217	params = get_byte(pb); /* (channel << 7) \| (format << 4) \| rate */	217	params = avio_r8(pb); /* (channel << 7) \| (format << 4) \| rate */
218	rate = mmf_rate(params & 0x0f);	218	rate = mmf_rate(params & 0x0f);
219	if(rate < 0) {	219	if(rate < 0) {
220	av_log(s, AV_LOG_ERROR, "Invalid sample rate\n");	220	av_log(s, AV_LOG_ERROR, "Invalid sample rate\n");
221	return -1;	221	return -1;
222	}	222	}
223	get_byte(pb); /* wave base bit */	223	avio_r8(pb); /* wave base bit */
224	get_byte(pb); /* time base d */	224	avio_r8(pb); /* time base d */
225	get_byte(pb); /* time base g */	225	avio_r8(pb); /* time base g */
226		226
227	/* Skip some unused chunks that may or may not be present */	227	/* Skip some unused chunks that may or may not be present */
228	for(;; url_fseek(pb, size, SEEK_CUR)) {	228	for(;; url_fseek(pb, size, SEEK_CUR)) {
229	tag = get_le32(pb);	229	tag = avio_rl32(pb);
230	size = get_be32(pb);	230	size = avio_rb32(pb);
231	if(tag == MKTAG('A','t','s','q')) continue;	231	if(tag == MKTAG('A','t','s','q')) continue;
232	if(tag == MKTAG('A','s','p','I')) continue;	232	if(tag == MKTAG('A','s','p','I')) continue;
233	break;	233	break;
@@ -280,7 +280,7 @@ static int mmf_read_packet(AVFormatContext *s, · 46 unmodified lines
280	return AVERROR(EIO);	280	return AVERROR(EIO);
281	pkt->stream_index = 0;	281	pkt->stream_index = 0;
282		282
283	ret = get_buffer(s->pb, pkt->data, pkt->size);	283	ret = avio_read(s->pb, pkt->data, pkt->size);
284	if (ret < 0)	284	if (ret < 0)
285	av_free_packet(pkt);	285	av_free_packet(pkt);
286		286

libavformat/mov.c+237−237

@@ -83,11 +83,11 @@ static int mov_metadata_trkn(MOVContext c, AVIOContext pb, unsigned len) · 82 unmodified lines
83	{	83	{
84	char buf[16];	84	char buf[16];
85		85
86	get_be16(pb); // unknown	86	avio_rb16(pb); // unknown
87	snprintf(buf, sizeof(buf), "%d", get_be16(pb));	87	snprintf(buf, sizeof(buf), "%d", avio_rb16(pb));
88	av_metadata_set2(&c->fc->metadata, "track", buf, 0);	88	av_metadata_set2(&c->fc->metadata, "track", buf, 0);
89		89
90	get_be16(pb); // total tracks	90	avio_rb16(pb); // total tracks
91		91
92	return 0;	92	return 0;
93	}	93	}
@@ -119,7 +119,7 @@ static int mov_read_mac_string(MOVContext c, AVIOContext pb, int len, · 25 unmodified lines
119	int i;	119	int i;
120		120
121	for (i = 0; i < len; i++) {	121	for (i = 0; i < len; i++) {
122	uint8_t t, c = get_byte(pb);	122	uint8_t t, c = avio_r8(pb);
123	if (c < 0x80 && p < end)	123	if (c < 0x80 && p < end)
124	*p++ = c;	124	*p++ = c;
125	else	125	else
@@ -165,17 +165,17 @@ static int mov_read_udta_string(MOVContext c, AVIOContext pb, MOVAtom atom) · 39 unmodified lines
165	}	165	}
166		166
167	if (c->itunes_metadata && atom.size > 8) {	167	if (c->itunes_metadata && atom.size > 8) {
168	int data_size = get_be32(pb);	168	int data_size = avio_rb32(pb);
169	int tag = get_le32(pb);	169	int tag = avio_rl32(pb);
170	if (tag == MKTAG('d','a','t','a')) {	170	if (tag == MKTAG('d','a','t','a')) {
171	data_type = get_be32(pb); // type	171	data_type = avio_rb32(pb); // type
172	get_be32(pb); // unknown	172	avio_rb32(pb); // unknown
173	str_size = data_size - 16;	173	str_size = data_size - 16;
174	atom.size -= 16;	174	atom.size -= 16;
175	} else return 0;	175	} else return 0;
176	} else if (atom.size > 4 && key && !c->itunes_metadata) {	176	} else if (atom.size > 4 && key && !c->itunes_metadata) {
177	str_size = get_be16(pb); // string length	177	str_size = avio_rb16(pb); // string length
178	langcode = get_be16(pb);	178	langcode = avio_rb16(pb);
179	ff_mov_lang_to_iso639(langcode, language);	179	ff_mov_lang_to_iso639(langcode, language);
180	atom.size -= 4;	180	atom.size -= 4;
181	} else	181	} else
@@ -201,7 +201,7 @@ static int mov_read_udta_string(MOVContext c, AVIOContext pb, MOVAtom atom) · 19 unmodified lines
201	if (data_type == 3 \|\| (data_type == 0 && langcode < 0x800)) { // MAC Encoded	201	if (data_type == 3 \|\| (data_type == 0 && langcode < 0x800)) { // MAC Encoded
202	mov_read_mac_string(c, pb, str_size, str, sizeof(str));	202	mov_read_mac_string(c, pb, str_size, str, sizeof(str));
203	} else {	203	} else {
204	get_buffer(pb, str, str_size);	204	avio_read(pb, str, str_size);
205	str[str_size] = 0;	205	str[str_size] = 0;
206	}	206	}
207	av_metadata_set2(&c->fc->metadata, key, str, 0);	207	av_metadata_set2(&c->fc->metadata, key, str, 0);
@@ -228,23 +228,23 @@ static int mov_read_chpl(MOVContext c, AVIOContext pb, MOVAtom atom) · 20 unmodified lines
228	if ((atom.size -= 5) < 0)	228	if ((atom.size -= 5) < 0)
229	return 0;	229	return 0;
230		230
231	version = get_byte(pb);	231	version = avio_r8(pb);
232	get_be24(pb);	232	avio_rb24(pb);
233	if (version)	233	if (version)
234	get_be32(pb); // ???	234	avio_rb32(pb); // ???
235	nb_chapters = get_byte(pb);	235	nb_chapters = avio_r8(pb);
236		236
237	for (i = 0; i < nb_chapters; i++) {	237	for (i = 0; i < nb_chapters; i++) {
238	if (atom.size < 9)	238	if (atom.size < 9)
239	return 0;	239	return 0;
240		240
241	start = get_be64(pb);	241	start = avio_rb64(pb);
242	str_len = get_byte(pb);	242	str_len = avio_r8(pb);
243		243
244	if ((atom.size -= 9+str_len) < 0)	244	if ((atom.size -= 9+str_len) < 0)
245	return 0;	245	return 0;
246		246
247	get_buffer(pb, str, str_len);	247	avio_read(pb, str, str_len);
248	str[str_len] = 0;	248	str[str_len] = 0;
249	ff_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);	249	ff_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);
250	}	250	}
@@ -264,14 +264,14 @@ static int mov_read_default(MOVContext c, AVIOContext pb, MOVAtom atom) · 13 unmodified lines
264	a.size = atom.size;	264	a.size = atom.size;
265	a.type=0;	265	a.type=0;
266	if(atom.size >= 8) {	266	if(atom.size >= 8) {
267	a.size = get_be32(pb);	267	a.size = avio_rb32(pb);
268	a.type = get_le32(pb);	268	a.type = avio_rl32(pb);
269	}	269	}
270	av_dlog(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",	270	av_dlog(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
271	a.type, (char)&a.type, (char)&atom.type, a.size, total_size, atom.size);	271	a.type, (char)&a.type, (char)&atom.type, a.size, total_size, atom.size);
272	total_size += 8;	272	total_size += 8;
273	if (a.size == 1) { /* 64 bit extended size */	273	if (a.size == 1) { /* 64 bit extended size */
274	a.size = get_be64(pb) - 8;	274	a.size = avio_rb64(pb) - 8;
275	total_size += 8;	275	total_size += 8;
276	}	276	}
277	if (a.size == 0) {	277	if (a.size == 0) {
@@ -331,8 +331,8 @@ static int mov_read_dref(MOVContext c, AVIOContext pb, MOVAtom atom) · 53 unmodified lines
331	st = c->fc->streams[c->fc->nb_streams-1];	331	st = c->fc->streams[c->fc->nb_streams-1];
332	sc = st->priv_data;	332	sc = st->priv_data;
333		333
334	get_be32(pb); // version + flags	334	avio_rb32(pb); // version + flags
335	entries = get_be32(pb);	335	entries = avio_rb32(pb);
336	if (entries >= UINT_MAX / sizeof(*sc->drefs))	336	if (entries >= UINT_MAX / sizeof(*sc->drefs))
337	return -1;	337	return -1;
338	sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));	338	sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
@@ -342,14 +342,14 @@ static int mov_read_dref(MOVContext c, AVIOContext pb, MOVAtom atom) · 3 unmodified lines
342		342
343	for (i = 0; i < sc->drefs_count; i++) {	343	for (i = 0; i < sc->drefs_count; i++) {
344	MOVDref *dref = &sc->drefs[i];	344	MOVDref *dref = &sc->drefs[i];
345	uint32_t size = get_be32(pb);	345	uint32_t size = avio_rb32(pb);
346	int64_t next = url_ftell(pb) + size - 4;	346	int64_t next = url_ftell(pb) + size - 4;
347		347
348	if (size < 12)	348	if (size < 12)
349	return -1;	349	return -1;
350		350
351	dref->type = get_le32(pb);	351	dref->type = avio_rl32(pb);
352	get_be32(pb); // version + flags	352	avio_rb32(pb); // version + flags
353	av_dlog(c->fc, "type %.4s size %d\n", (char*)&dref->type, size);	353	av_dlog(c->fc, "type %.4s size %d\n", (char*)&dref->type, size);
354		354
355	if (dref->type == MKTAG('a','l','i','s') && size > 150) {	355	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) · 3 unmodified lines
359		359
360	url_fskip(pb, 10);	360	url_fskip(pb, 10);
361		361
362	volume_len = get_byte(pb);	362	volume_len = avio_r8(pb);
363	volume_len = FFMIN(volume_len, 27);	363	volume_len = FFMIN(volume_len, 27);
364	get_buffer(pb, dref->volume, 27);	364	avio_read(pb, dref->volume, 27);
365	dref->volume[volume_len] = 0;	365	dref->volume[volume_len] = 0;
366	av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);	366	av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
367		367
368	url_fskip(pb, 12);	368	url_fskip(pb, 12);
369		369
370	len = get_byte(pb);	370	len = avio_r8(pb);
371	len = FFMIN(len, 63);	371	len = FFMIN(len, 63);
372	get_buffer(pb, dref->filename, 63);	372	avio_read(pb, dref->filename, 63);
373	dref->filename[len] = 0;	373	dref->filename[len] = 0;
374	av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);	374	av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
375		375
376	url_fskip(pb, 16);	376	url_fskip(pb, 16);
377		377
378	/* read next level up_from_alias/down_to_target */	378	/* read next level up_from_alias/down_to_target */
379	dref->nlvl_from = get_be16(pb);	379	dref->nlvl_from = avio_rb16(pb);
380	dref->nlvl_to = get_be16(pb);	380	dref->nlvl_to = avio_rb16(pb);
381	av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",	381	av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
382	dref->nlvl_from, dref->nlvl_to);	382	dref->nlvl_from, dref->nlvl_to);
383		383
384	url_fskip(pb, 16);	384	url_fskip(pb, 16);
385		385
386	for (type = 0; type != -1 && url_ftell(pb) < next; ) {	386	for (type = 0; type != -1 && url_ftell(pb) < next; ) {
387	type = get_be16(pb);	387	type = avio_rb16(pb);
388	len = get_be16(pb);	388	len = avio_rb16(pb);
389	av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);	389	av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
390	if (len&1)	390	if (len&1)
391	len += 1;	391	len += 1;
@@ -394,7 +394,7 @@ static int mov_read_dref(MOVContext c, AVIOContext pb, MOVAtom atom) · 2 unmodified lines
394	dref->path = av_mallocz(len+1);	394	dref->path = av_mallocz(len+1);
395	if (!dref->path)	395	if (!dref->path)
396	return AVERROR(ENOMEM);	396	return AVERROR(ENOMEM);
397	get_buffer(pb, dref->path, len);	397	avio_read(pb, dref->path, len);
398	if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {	398	if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
399	len -= volume_len;	399	len -= volume_len;
400	memmove(dref->path, dref->path+volume_len, len);	400	memmove(dref->path, dref->path+volume_len, len);
@@ -409,7 +409,7 @@ static int mov_read_dref(MOVContext c, AVIOContext pb, MOVAtom atom) · 8 unmodified lines
409	dref->dir = av_malloc(len+1);	409	dref->dir = av_malloc(len+1);
410	if (!dref->dir)	410	if (!dref->dir)
411	return AVERROR(ENOMEM);	411	return AVERROR(ENOMEM);
412	get_buffer(pb, dref->dir, len);	412	avio_read(pb, dref->dir, len);
413	dref->dir[len] = 0;	413	dref->dir[len] = 0;
414	for (j = 0; j < len; j++)	414	for (j = 0; j < len; j++)
415	if (dref->dir[j] == ':')	415	if (dref->dir[j] == ':')
@@ -435,12 +435,12 @@ static int mov_read_hdlr(MOVContext c, AVIOContext pb, MOVAtom atom) · 19 unmodified lines
435		435
436	st = c->fc->streams[c->fc->nb_streams-1];	436	st = c->fc->streams[c->fc->nb_streams-1];
437		437
438	get_byte(pb); /* version */	438	avio_r8(pb); /* version */
439	get_be24(pb); /* flags */	439	avio_rb24(pb); /* flags */
440		440
441	/* component type */	441	/* component type */
442	ctype = get_le32(pb);	442	ctype = avio_rl32(pb);
443	type = get_le32(pb); /* component subtype */	443	type = avio_rl32(pb); /* component subtype */
444		444
445	av_dlog(c->fc, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype);	445	av_dlog(c->fc, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype);
446	av_dlog(c->fc, "stype= %.4s\n", (char*)&type);	446	av_dlog(c->fc, "stype= %.4s\n", (char*)&type);
@@ -454,9 +454,9 @@ static int mov_read_hdlr(MOVContext c, AVIOContext pb, MOVAtom atom) · 7 unmodified lines
454	else if(type == MKTAG('s','u','b','p'))	454	else if(type == MKTAG('s','u','b','p'))
455	st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;	455	st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
456		456
457	get_be32(pb); /* component manufacture */	457	avio_rb32(pb); /* component manufacture */
458	get_be32(pb); /* component flags */	458	avio_rb32(pb); /* component flags */
459	get_be32(pb); /* component flags mask */	459	avio_rb32(pb); /* component flags mask */
460		460
461	return 0;	461	return 0;
462	}	462	}
@@ -470,13 +470,13 @@ int ff_mov_read_esds(AVFormatContext fc, AVIOContext pb, MOVAtom atom) · 7 unmodified lines
470	return 0;	470	return 0;
471	st = fc->streams[fc->nb_streams-1];	471	st = fc->streams[fc->nb_streams-1];
472		472
473	get_be32(pb); /* version + flags */	473	avio_rb32(pb); /* version + flags */
474	len = ff_mp4_read_descr(fc, pb, &tag);	474	len = ff_mp4_read_descr(fc, pb, &tag);
475	if (tag == MP4ESDescrTag) {	475	if (tag == MP4ESDescrTag) {
476	get_be16(pb); /* ID */	476	avio_rb16(pb); /* ID */
477	get_byte(pb); /* priority */	477	avio_r8(pb); /* priority */
478	} else	478	} else
479	get_be16(pb); /* ID */	479	avio_rb16(pb); /* ID */
480		480
481	len = ff_mp4_read_descr(fc, pb, &tag);	481	len = ff_mp4_read_descr(fc, pb, &tag);
482	if (tag == MP4DecConfigDescrTag)	482	if (tag == MP4DecConfigDescrTag)
@@ -498,7 +498,7 @@ static int mov_read_dac3(MOVContext c, AVIOContext pb, MOVAtom atom) · 15 unmodified lines
498	return 0;	498	return 0;
499	st = c->fc->streams[c->fc->nb_streams-1];	499	st = c->fc->streams[c->fc->nb_streams-1];
500		500
501	ac3info = get_be24(pb);	501	ac3info = avio_rb24(pb);
502	acmod = (ac3info >> 11) & 0x7;	502	acmod = (ac3info >> 11) & 0x7;
503	lfeon = (ac3info >> 10) & 0x1;	503	lfeon = (ac3info >> 10) & 0x1;
504	st->codec->channels = ((int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;	504	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) · 3 unmodified lines
508		508
509	static int mov_read_pasp(MOVContext c, AVIOContext pb, MOVAtom atom)	509	static int mov_read_pasp(MOVContext c, AVIOContext pb, MOVAtom atom)
510	{	510	{
511	const int num = get_be32(pb);	511	const int num = avio_rb32(pb);
512	const int den = get_be32(pb);	512	const int den = avio_rb32(pb);
513	AVStream *st;	513	AVStream *st;
514		514
515	if (c->fc->nb_streams < 1)	515	if (c->fc->nb_streams < 1)
@@ -547,12 +547,12 @@ static int mov_read_ftyp(MOVContext c, AVIOContext pb, MOVAtom atom) · 31 unmodified lines
547	char* comp_brands_str;	547	char* comp_brands_str;
548	uint8_t type[5] = {0};	548	uint8_t type[5] = {0};
549		549
550	get_buffer(pb, type, 4);	550	avio_read(pb, type, 4);
551	if (strcmp(type, "qt "))	551	if (strcmp(type, "qt "))
552	c->isom = 1;	552	c->isom = 1;
553	av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);	553	av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
554	av_metadata_set2(&c->fc->metadata, "major_brand", type, 0);	554	av_metadata_set2(&c->fc->metadata, "major_brand", type, 0);
555	minor_ver = get_be32(pb); /* minor version */	555	minor_ver = avio_rb32(pb); /* minor version */
556	snprintf(minor_ver_str, sizeof(minor_ver_str), "%d", minor_ver);	556	snprintf(minor_ver_str, sizeof(minor_ver_str), "%d", minor_ver);
557	av_metadata_set2(&c->fc->metadata, "minor_version", minor_ver_str, 0);	557	av_metadata_set2(&c->fc->metadata, "minor_version", minor_ver_str, 0);
558		558
@@ -562,7 +562,7 @@ static int mov_read_ftyp(MOVContext c, AVIOContext pb, MOVAtom atom) · 3 unmodified lines
562	comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */	562	comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
563	if (!comp_brands_str)	563	if (!comp_brands_str)
564	return AVERROR(ENOMEM);	564	return AVERROR(ENOMEM);
565	get_buffer(pb, comp_brands_str, comp_brand_size);	565	avio_read(pb, comp_brands_str, comp_brand_size);
566	comp_brands_str[comp_brand_size] = 0;	566	comp_brands_str[comp_brand_size] = 0;
567	av_metadata_set2(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);	567	av_metadata_set2(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);
568	av_freep(&comp_brands_str);	568	av_freep(&comp_brands_str);
@@ -615,27 +615,27 @@ static int mov_read_mdhd(MOVContext c, AVIOContext pb, MOVAtom atom) · 46 unmodified lines
615	st = c->fc->streams[c->fc->nb_streams-1];	615	st = c->fc->streams[c->fc->nb_streams-1];
616	sc = st->priv_data;	616	sc = st->priv_data;
617		617
618	version = get_byte(pb);	618	version = avio_r8(pb);
619	if (version > 1)	619	if (version > 1)
620	return -1; /* unsupported */	620	return -1; /* unsupported */
621		621
622	get_be24(pb); /* flags */	622	avio_rb24(pb); /* flags */
623	if (version == 1) {	623	if (version == 1) {
624	creation_time = get_be64(pb);	624	creation_time = avio_rb64(pb);
625	get_be64(pb);	625	avio_rb64(pb);
626	} else {	626	} else {
627	creation_time = get_be32(pb);	627	creation_time = avio_rb32(pb);
628	get_be32(pb); /* modification time */	628	avio_rb32(pb); /* modification time */
629	}	629	}
630	mov_metadata_creation_time(&st->metadata, creation_time);	630	mov_metadata_creation_time(&st->metadata, creation_time);
631		631
632	sc->time_scale = get_be32(pb);	632	sc->time_scale = avio_rb32(pb);
633	st->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */	633	st->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
634		634
635	lang = get_be16(pb); /* language */	635	lang = avio_rb16(pb); /* language */
636	if (ff_mov_lang_to_iso639(lang, language))	636	if (ff_mov_lang_to_iso639(lang, language))
637	av_metadata_set2(&st->metadata, "language", language, 0);	637	av_metadata_set2(&st->metadata, "language", language, 0);
638	get_be16(pb); /* quality */	638	avio_rb16(pb); /* quality */
639		639
640	return 0;	640	return 0;
641	}	641	}
@@ -643,37 +643,37 @@ static int mov_read_mdhd(MOVContext c, AVIOContext pb, MOVAtom atom) · 1 unmodified line
643	static int mov_read_mvhd(MOVContext c, AVIOContext pb, MOVAtom atom)	643	static int mov_read_mvhd(MOVContext c, AVIOContext pb, MOVAtom atom)
644	{	644	{
645	time_t creation_time;	645	time_t creation_time;
646	int version = get_byte(pb); /* version */	646	int version = avio_r8(pb); /* version */
647	get_be24(pb); /* flags */	647	avio_rb24(pb); /* flags */
648		648
649	if (version == 1) {	649	if (version == 1) {
650	creation_time = get_be64(pb);	650	creation_time = avio_rb64(pb);
651	get_be64(pb);	651	avio_rb64(pb);
652	} else {	652	} else {
653	creation_time = get_be32(pb);	653	creation_time = avio_rb32(pb);
654	get_be32(pb); /* modification time */	654	avio_rb32(pb); /* modification time */
655	}	655	}
656	mov_metadata_creation_time(&c->fc->metadata, creation_time);	656	mov_metadata_creation_time(&c->fc->metadata, creation_time);
657	c->time_scale = get_be32(pb); /* time scale */	657	c->time_scale = avio_rb32(pb); /* time scale */
658		658
659	av_dlog(c->fc, "time scale = %i\n", c->time_scale);	659	av_dlog(c->fc, "time scale = %i\n", c->time_scale);
660		660
661	c->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */	661	c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
662	get_be32(pb); /* preferred scale */	662	avio_rb32(pb); /* preferred scale */
663		663
664	get_be16(pb); /* preferred volume */	664	avio_rb16(pb); /* preferred volume */
665		665
666	url_fskip(pb, 10); /* reserved */	666	url_fskip(pb, 10); /* reserved */
667		667
668	url_fskip(pb, 36); /* display matrix */	668	url_fskip(pb, 36); /* display matrix */
669		669
670	get_be32(pb); /* preview time */	670	avio_rb32(pb); /* preview time */
671	get_be32(pb); /* preview duration */	671	avio_rb32(pb); /* preview duration */
672	get_be32(pb); /* poster time */	672	avio_rb32(pb); /* poster time */
673	get_be32(pb); /* selection time */	673	avio_rb32(pb); /* selection time */
674	get_be32(pb); /* selection duration */	674	avio_rb32(pb); /* selection duration */
675	get_be32(pb); /* current time */	675	avio_rb32(pb); /* current time */
676	get_be32(pb); /* next track ID */	676	avio_rb32(pb); /* next track ID */
677		677
678	return 0;	678	return 0;
679	}	679	}
@@ -697,7 +697,7 @@ static int mov_read_smi(MOVContext c, AVIOContext pb, MOVAtom atom) · 17 unmodified lines
697	return AVERROR(ENOMEM);	697	return AVERROR(ENOMEM);
698	st->codec->extradata_size = 0x5a + atom.size;	698	st->codec->extradata_size = 0x5a + atom.size;
699	memcpy(st->codec->extradata, "SVQ3", 4); // fake	699	memcpy(st->codec->extradata, "SVQ3", 4); // fake
700	get_buffer(pb, st->codec->extradata + 0x5a, atom.size);	700	avio_read(pb, st->codec->extradata + 0x5a, atom.size);
701	av_dlog(c->fc, "Reading SMI %"PRId64" %s\n", atom.size, st->codec->extradata + 0x5a);	701	av_dlog(c->fc, "Reading SMI %"PRId64" %s\n", atom.size, st->codec->extradata + 0x5a);
702	return 0;	702	return 0;
703	}	703	}
@@ -711,7 +711,7 @@ static int mov_read_enda(MOVContext c, AVIOContext pb, MOVAtom atom) · 7 unmodified lines
711	return 0;	711	return 0;
712	st = c->fc->streams[c->fc->nb_streams-1];	712	st = c->fc->streams[c->fc->nb_streams-1];
713		713
714	little_endian = get_be16(pb);	714	little_endian = avio_rb16(pb);
715	av_dlog(c->fc, "enda %d\n", little_endian);	715	av_dlog(c->fc, "enda %d\n", little_endian);
716	if (little_endian == 1) {	716	if (little_endian == 1) {
717	switch (st->codec->codec_id) {	717	switch (st->codec->codec_id) {
@@ -755,7 +755,7 @@ static int mov_read_extradata(MOVContext c, AVIOContext pb, MOVAtom atom) · 37 unmodified lines
755	st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;	755	st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;
756	AV_WB32( buf , atom.size + 8);	756	AV_WB32( buf , atom.size + 8);
757	AV_WL32( buf + 4, atom.type);	757	AV_WL32( buf + 4, atom.type);
758	get_buffer(pb, buf + 8, atom.size);	758	avio_read(pb, buf + 8, atom.size);
759	return 0;	759	return 0;
760	}	760	}
761		761
@@ -777,7 +777,7 @@ static int mov_read_wave(MOVContext c, AVIOContext pb, MOVAtom atom) · 15 unmodified lines
777	if (!st->codec->extradata)	777	if (!st->codec->extradata)
778	return AVERROR(ENOMEM);	778	return AVERROR(ENOMEM);
779	st->codec->extradata_size = atom.size;	779	st->codec->extradata_size = atom.size;
780	get_buffer(pb, st->codec->extradata, atom.size);	780	avio_read(pb, st->codec->extradata, atom.size);
781	} else if (atom.size > 8) { /* to read frma, esds atoms */	781	} else if (atom.size > 8) { /* to read frma, esds atoms */
782	if (mov_read_default(c, pb, atom) < 0)	782	if (mov_read_default(c, pb, atom) < 0)
783	return -1;	783	return -1;
@@ -806,7 +806,7 @@ static int mov_read_glbl(MOVContext c, AVIOContext pb, MOVAtom atom) · 22 unmodified lines
806	if (!st->codec->extradata)	806	if (!st->codec->extradata)
807	return AVERROR(ENOMEM);	807	return AVERROR(ENOMEM);
808	st->codec->extradata_size = atom.size;	808	st->codec->extradata_size = atom.size;
809	get_buffer(pb, st->codec->extradata, atom.size);	809	avio_read(pb, st->codec->extradata, atom.size);
810	return 0;	810	return 0;
811	}	811	}
812		812
@@ -834,7 +834,7 @@ static int mov_read_strf(MOVContext c, AVIOContext pb, MOVAtom atom) · 21 unmodified lines
834	return AVERROR(ENOMEM);	834	return AVERROR(ENOMEM);
835	st->codec->extradata_size = atom.size - 40;	835	st->codec->extradata_size = atom.size - 40;
836	url_fskip(pb, 40);	836	url_fskip(pb, 40);
837	get_buffer(pb, st->codec->extradata, atom.size - 40);	837	avio_read(pb, st->codec->extradata, atom.size - 40);
838	return 0;	838	return 0;
839	}	839	}
840		840
@@ -849,10 +849,10 @@ static int mov_read_stco(MOVContext c, AVIOContext pb, MOVAtom atom) · 8 unmodified lines
849	st = c->fc->streams[c->fc->nb_streams-1];	849	st = c->fc->streams[c->fc->nb_streams-1];
850	sc = st->priv_data;	850	sc = st->priv_data;
851		851
852	get_byte(pb); /* version */	852	avio_r8(pb); /* version */
853	get_be24(pb); /* flags */	853	avio_rb24(pb); /* flags */
854		854
855	entries = get_be32(pb);	855	entries = avio_rb32(pb);
856		856
857	if(entries >= UINT_MAX/sizeof(int64_t))	857	if(entries >= UINT_MAX/sizeof(int64_t))
858	return -1;	858	return -1;
@@ -864,10 +864,10 @@ static int mov_read_stco(MOVContext c, AVIOContext pb, MOVAtom atom) · 5 unmodified lines
864		864
865	if (atom.type == MKTAG('s','t','c','o'))	865	if (atom.type == MKTAG('s','t','c','o'))
866	for(i=0; i<entries; i++)	866	for(i=0; i<entries; i++)
867	sc->chunk_offsets[i] = get_be32(pb);	867	sc->chunk_offsets[i] = avio_rb32(pb);
868	else if (atom.type == MKTAG('c','o','6','4'))	868	else if (atom.type == MKTAG('c','o','6','4'))
869	for(i=0; i<entries; i++)	869	for(i=0; i<entries; i++)
870	sc->chunk_offsets[i] = get_be64(pb);	870	sc->chunk_offsets[i] = avio_rb64(pb);
871	else	871	else
872	return -1;	872	return -1;
873		873
@@ -926,13 +926,13 @@ int ff_mov_read_stsd_entries(MOVContext c, AVIOContext pb, int entries) · 52 unmodified lines
926	int dref_id = 1;	926	int dref_id = 1;
927	MOVAtom a = { AV_RL32("stsd") };	927	MOVAtom a = { AV_RL32("stsd") };
928	int64_t start_pos = url_ftell(pb);	928	int64_t start_pos = url_ftell(pb);
929	int size = get_be32(pb); /* size */	929	int size = avio_rb32(pb); /* size */
930	uint32_t format = get_le32(pb); /* data format */	930	uint32_t format = avio_rl32(pb); /* data format */
931		931
932	if (size >= 16) {	932	if (size >= 16) {
933	get_be32(pb); /* reserved */	933	avio_rb32(pb); /* reserved */
934	get_be16(pb); /* reserved */	934	avio_rb16(pb); /* reserved */
935	dref_id = get_be16(pb);	935	dref_id = avio_rb16(pb);
936	}	936	}
937		937
938	if (st->codec->codec_tag &&	938	if (st->codec->codec_tag &&
@@ -984,21 +984,21 @@ int ff_mov_read_stsd_entries(MOVContext c, AVIOContext pb, int entries) · 45 unmodified lines
984	int color_greyscale;	984	int color_greyscale;
985		985
986	st->codec->codec_id = id;	986	st->codec->codec_id = id;
987	get_be16(pb); /* version */	987	avio_rb16(pb); /* version */
988	get_be16(pb); /* revision level */	988	avio_rb16(pb); /* revision level */
989	get_be32(pb); /* vendor */	989	avio_rb32(pb); /* vendor */
990	get_be32(pb); /* temporal quality */	990	avio_rb32(pb); /* temporal quality */
991	get_be32(pb); /* spatial quality */	991	avio_rb32(pb); /* spatial quality */
992		992
993	st->codec->width = get_be16(pb); /* width */	993	st->codec->width = avio_rb16(pb); /* width */
994	st->codec->height = get_be16(pb); /* height */	994	st->codec->height = avio_rb16(pb); /* height */
995		995
996	get_be32(pb); /* horiz resolution */	996	avio_rb32(pb); /* horiz resolution */
997	get_be32(pb); /* vert resolution */	997	avio_rb32(pb); /* vert resolution */
998	get_be32(pb); /* data size, always 0 */	998	avio_rb32(pb); /* data size, always 0 */
999	get_be16(pb); /* frames per samples */	999	avio_rb16(pb); /* frames per samples */
1000		1000
1001	len = get_byte(pb); /* codec name, pascal string */	1001	len = avio_r8(pb); /* codec name, pascal string */
1002	if (len > 31)	1002	if (len > 31)
1003	len = 31;	1003	len = 31;
1004	mov_read_mac_string(c, pb, len, st->codec->codec_name, 32);	1004	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) · 3 unmodified lines
1008	if (!memcmp(st->codec->codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25))	1008	if (!memcmp(st->codec->codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25))
1009	st->codec->codec_tag=MKTAG('I', '4', '2', '0');	1009	st->codec->codec_tag=MKTAG('I', '4', '2', '0');
1010		1010
1011	st->codec->bits_per_coded_sample = get_be16(pb); /* depth */	1011	st->codec->bits_per_coded_sample = avio_rb16(pb); /* depth */
1012	st->codec->color_table_id = get_be16(pb); /* colortable id */	1012	st->codec->color_table_id = avio_rb16(pb); /* colortable id */
1013	av_dlog(c->fc, "depth %d, ctab id %d\n",	1013	av_dlog(c->fc, "depth %d, ctab id %d\n",
1014	st->codec->bits_per_coded_sample, st->codec->color_table_id);	1014	st->codec->bits_per_coded_sample, st->codec->color_table_id);
1015	/* figure out the palette situation */	1015	/* figure out the palette situation */
@@ -1059,23 +1059,23 @@ int ff_mov_read_stsd_entries(MOVContext c, AVIOContext pb, int entries) · 43 unmodified lines
1059	}	1059	}
1060	} else {	1060	} else {
1061	/* load the palette from the file */	1061	/* load the palette from the file */
1062	color_start = get_be32(pb);	1062	color_start = avio_rb32(pb);
1063	color_count = get_be16(pb);	1063	color_count = avio_rb16(pb);
1064	color_end = get_be16(pb);	1064	color_end = avio_rb16(pb);
1065	if ((color_start <= 255) &&	1065	if ((color_start <= 255) &&
1066	(color_end <= 255)) {	1066	(color_end <= 255)) {
1067	for (j = color_start; j <= color_end; j++) {	1067	for (j = color_start; j <= color_end; j++) {
1068	/* each R, G, or B component is 16 bits;	1068	/* each R, G, or B component is 16 bits;
1069	* only use the top 8 bits; skip alpha bytes	1069	* only use the top 8 bits; skip alpha bytes
1070	* up front */	1070	* up front */
1071	get_byte(pb);	1071	avio_r8(pb);
1072	get_byte(pb);	1072	avio_r8(pb);
1073	r = get_byte(pb);	1073	r = avio_r8(pb);
1074	get_byte(pb);	1074	avio_r8(pb);
1075	g = get_byte(pb);	1075	g = avio_r8(pb);
1076	get_byte(pb);	1076	avio_r8(pb);
1077	b = get_byte(pb);	1077	b = avio_r8(pb);
1078	get_byte(pb);	1078	avio_r8(pb);
1079	st->codec->palctrl->palette[j] =	1079	st->codec->palctrl->palette[j] =
1080	(r << 16) \| (g << 8) \| (b);	1080	(r << 16) \| (g << 8) \| (b);
1081	}	1081	}
@@ -1085,38 +1085,38 @@ int ff_mov_read_stsd_entries(MOVContext c, AVIOContext pb, int entries) · 3 unmodified lines
1085	}	1085	}
1086	} else if(st->codec->codec_type==AVMEDIA_TYPE_AUDIO) {	1086	} else if(st->codec->codec_type==AVMEDIA_TYPE_AUDIO) {
1087	int bits_per_sample, flags;	1087	int bits_per_sample, flags;
1088	uint16_t version = get_be16(pb);	1088	uint16_t version = avio_rb16(pb);
1089		1089
1090	st->codec->codec_id = id;	1090	st->codec->codec_id = id;
1091	get_be16(pb); /* revision level */	1091	avio_rb16(pb); /* revision level */
1092	get_be32(pb); /* vendor */	1092	avio_rb32(pb); /* vendor */
1093		1093
1094	st->codec->channels = get_be16(pb); /* channel count */	1094	st->codec->channels = avio_rb16(pb); /* channel count */
1095	av_dlog(c->fc, "audio channels %d\n", st->codec->channels);	1095	av_dlog(c->fc, "audio channels %d\n", st->codec->channels);
1096	st->codec->bits_per_coded_sample = get_be16(pb); /* sample size */	1096	st->codec->bits_per_coded_sample = avio_rb16(pb); /* sample size */
1097		1097
1098	sc->audio_cid = get_be16(pb);	1098	sc->audio_cid = avio_rb16(pb);
1099	get_be16(pb); /* packet size = 0 */	1099	avio_rb16(pb); /* packet size = 0 */
1100		1100
1101	st->codec->sample_rate = ((get_be32(pb) >> 16));	1101	st->codec->sample_rate = ((avio_rb32(pb) >> 16));
1102		1102
1103	//Read QT version 1 fields. In version 0 these do not exist.	1103	//Read QT version 1 fields. In version 0 these do not exist.
1104	av_dlog(c->fc, "version =%d, isom =%d\n",version,c->isom);	1104	av_dlog(c->fc, "version =%d, isom =%d\n",version,c->isom);
1105	if(!c->isom) {	1105	if(!c->isom) {
1106	if(version==1) {	1106	if(version==1) {
1107	sc->samples_per_frame = get_be32(pb);	1107	sc->samples_per_frame = avio_rb32(pb);
1108	get_be32(pb); /* bytes per packet */	1108	avio_rb32(pb); /* bytes per packet */
1109	sc->bytes_per_frame = get_be32(pb);	1109	sc->bytes_per_frame = avio_rb32(pb);
1110	get_be32(pb); /* bytes per sample */	1110	avio_rb32(pb); /* bytes per sample */
1111	} else if(version==2) {	1111	} else if(version==2) {
1112	get_be32(pb); /* sizeof struct only */	1112	avio_rb32(pb); /* sizeof struct only */
1113	st->codec->sample_rate = av_int2dbl(get_be64(pb)); /* float 64 */	1113	st->codec->sample_rate = av_int2dbl(avio_rb64(pb)); /* float 64 */
1114	st->codec->channels = get_be32(pb);	1114	st->codec->channels = avio_rb32(pb);
1115	get_be32(pb); /* always 0x7F000000 */	1115	avio_rb32(pb); /* always 0x7F000000 */
1116	st->codec->bits_per_coded_sample = get_be32(pb); /* bits per channel if sound is uncompressed */	1116	st->codec->bits_per_coded_sample = avio_rb32(pb); /* bits per channel if sound is uncompressed */
1117	flags = get_be32(pb); /* lpcm format specific flag */	1117	flags = avio_rb32(pb); /* lpcm format specific flag */
1118	sc->bytes_per_frame = get_be32(pb); /* bytes per audio packet if constant */	1118	sc->bytes_per_frame = avio_rb32(pb); /* bytes per audio packet if constant */
1119	sc->samples_per_frame = get_be32(pb); /* lpcm frames per audio packet if constant */	1119	sc->samples_per_frame = avio_rb32(pb); /* lpcm frames per audio packet if constant */
1120	if (format == MKTAG('l','p','c','m'))	1120	if (format == MKTAG('l','p','c','m'))
1121	st->codec->codec_id = ff_mov_get_lpcm_codec_id(st->codec->bits_per_coded_sample, flags);	1121	st->codec->codec_id = ff_mov_get_lpcm_codec_id(st->codec->bits_per_coded_sample, flags);
1122	}	1122	}
@@ -1249,9 +1249,9 @@ static int mov_read_stsd(MOVContext c, AVIOContext pb, MOVAtom atom) · 126 unmodified lines
1249	{	1249	{
1250	int entries;	1250	int entries;
1251		1251
1252	get_byte(pb); /* version */	1252	avio_r8(pb); /* version */
1253	get_be24(pb); /* flags */	1253	avio_rb24(pb); /* flags */
1254	entries = get_be32(pb);	1254	entries = avio_rb32(pb);
1255		1255
1256	return ff_mov_read_stsd_entries(c, pb, entries);	1256	return ff_mov_read_stsd_entries(c, pb, entries);
1257	}	1257	}
@@ -1267,10 +1267,10 @@ static int mov_read_stsc(MOVContext c, AVIOContext pb, MOVAtom atom) · 9 unmodified lines
1267	st = c->fc->streams[c->fc->nb_streams-1];	1267	st = c->fc->streams[c->fc->nb_streams-1];
1268	sc = st->priv_data;	1268	sc = st->priv_data;
1269		1269
1270	get_byte(pb); /* version */	1270	avio_r8(pb); /* version */
1271	get_be24(pb); /* flags */	1271	avio_rb24(pb); /* flags */
1272		1272
1273	entries = get_be32(pb);	1273	entries = avio_rb32(pb);
1274		1274
1275	av_dlog(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);	1275	av_dlog(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
1276		1276
@@ -1282,9 +1282,9 @@ static int mov_read_stsc(MOVContext c, AVIOContext pb, MOVAtom atom) · 5 unmodified lines
1282	sc->stsc_count = entries;	1282	sc->stsc_count = entries;
1283		1283
1284	for(i=0; i<entries; i++) {	1284	for(i=0; i<entries; i++) {
1285	sc->stsc_data[i].first = get_be32(pb);	1285	sc->stsc_data[i].first = avio_rb32(pb);
1286	sc->stsc_data[i].count = get_be32(pb);	1286	sc->stsc_data[i].count = avio_rb32(pb);
1287	sc->stsc_data[i].id = get_be32(pb);	1287	sc->stsc_data[i].id = avio_rb32(pb);
1288	}	1288	}
1289	return 0;	1289	return 0;
1290	}	1290	}
@@ -1300,9 +1300,9 @@ static int mov_read_stps(MOVContext c, AVIOContext pb, MOVAtom atom) · 9 unmodified lines
1300	st = c->fc->streams[c->fc->nb_streams-1];	1300	st = c->fc->streams[c->fc->nb_streams-1];
1301	sc = st->priv_data;	1301	sc = st->priv_data;
1302		1302
1303	get_be32(pb); // version + flags	1303	avio_rb32(pb); // version + flags
1304		1304
1305	entries = get_be32(pb);	1305	entries = avio_rb32(pb);
1306	if (entries >= UINT_MAX / sizeof(*sc->stps_data))	1306	if (entries >= UINT_MAX / sizeof(*sc->stps_data))
1307	return -1;	1307	return -1;
1308	sc->stps_data = av_malloc(entries * sizeof(*sc->stps_data));	1308	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) · 2 unmodified lines
1311	sc->stps_count = entries;	1311	sc->stps_count = entries;
1312		1312
1313	for (i = 0; i < entries; i++) {	1313	for (i = 0; i < entries; i++) {
1314	sc->stps_data[i] = get_be32(pb);	1314	sc->stps_data[i] = avio_rb32(pb);
1315	//av_dlog(c->fc, "stps %d\n", sc->stps_data[i]);	1315	//av_dlog(c->fc, "stps %d\n", sc->stps_data[i]);
1316	}	1316	}
1317		1317
@@ -1329,10 +1329,10 @@ static int mov_read_stss(MOVContext c, AVIOContext pb, MOVAtom atom) · 11 unmodified lines
1329	st = c->fc->streams[c->fc->nb_streams-1];	1329	st = c->fc->streams[c->fc->nb_streams-1];
1330	sc = st->priv_data;	1330	sc = st->priv_data;
1331		1331
1332	get_byte(pb); /* version */	1332	avio_r8(pb); /* version */
1333	get_be24(pb); /* flags */	1333	avio_rb24(pb); /* flags */
1334		1334
1335	entries = get_be32(pb);	1335	entries = avio_rb32(pb);
1336		1336
1337	av_dlog(c->fc, "keyframe_count = %d\n", entries);	1337	av_dlog(c->fc, "keyframe_count = %d\n", entries);
1338		1338
@@ -1344,7 +1344,7 @@ static int mov_read_stss(MOVContext c, AVIOContext pb, MOVAtom atom) · 5 unmodified lines
1344	sc->keyframe_count = entries;	1344	sc->keyframe_count = entries;
1345		1345
1346	for(i=0; i<entries; i++) {	1346	for(i=0; i<entries; i++) {
1347	sc->keyframes[i] = get_be32(pb);	1347	sc->keyframes[i] = avio_rb32(pb);
1348	//av_dlog(c->fc, "keyframes[]=%d\n", sc->keyframes[i]);	1348	//av_dlog(c->fc, "keyframes[]=%d\n", sc->keyframes[i]);
1349	}	1349	}
1350	return 0;	1350	return 0;
@@ -1363,20 +1363,20 @@ static int mov_read_stsz(MOVContext c, AVIOContext pb, MOVAtom atom) · 12 unmodified lines
1363	st = c->fc->streams[c->fc->nb_streams-1];	1363	st = c->fc->streams[c->fc->nb_streams-1];
1364	sc = st->priv_data;	1364	sc = st->priv_data;
1365		1365
1366	get_byte(pb); /* version */	1366	avio_r8(pb); /* version */
1367	get_be24(pb); /* flags */	1367	avio_rb24(pb); /* flags */
1368		1368
1369	if (atom.type == MKTAG('s','t','s','z')) {	1369	if (atom.type == MKTAG('s','t','s','z')) {
1370	sample_size = get_be32(pb);	1370	sample_size = avio_rb32(pb);
1371	if (!sc->sample_size) /* do not overwrite value computed in stsd */	1371	if (!sc->sample_size) /* do not overwrite value computed in stsd */
1372	sc->sample_size = sample_size;	1372	sc->sample_size = sample_size;
1373	field_size = 32;	1373	field_size = 32;
1374	} else {	1374	} else {
1375	sample_size = 0;	1375	sample_size = 0;
1376	get_be24(pb); /* reserved */	1376	avio_rb24(pb); /* reserved */
1377	field_size = get_byte(pb);	1377	field_size = avio_r8(pb);
1378	}	1378	}
1379	entries = get_be32(pb);	1379	entries = avio_rb32(pb);
1380		1380
1381	av_dlog(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, entries);	1381	av_dlog(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, entries);
1382		1382
@@ -1403,7 +1403,7 @@ static int mov_read_stsz(MOVContext c, AVIOContext pb, MOVAtom atom) · 20 unmodified lines
1403	return AVERROR(ENOMEM);	1403	return AVERROR(ENOMEM);
1404	}	1404	}
1405		1405
1406	if (get_buffer(pb, buf, num_bytes) < num_bytes) {	1406	if (avio_read(pb, buf, num_bytes) < num_bytes) {
1407	av_freep(&sc->sample_sizes);	1407	av_freep(&sc->sample_sizes);
1408	av_free(buf);	1408	av_free(buf);
1409	return -1;	1409	return -1;
@@ -1431,9 +1431,9 @@ static int mov_read_stts(MOVContext c, AVIOContext pb, MOVAtom atom) · 21 unmodified lines
1431	st = c->fc->streams[c->fc->nb_streams-1];	1431	st = c->fc->streams[c->fc->nb_streams-1];
1432	sc = st->priv_data;	1432	sc = st->priv_data;
1433		1433
1434	get_byte(pb); /* version */	1434	avio_r8(pb); /* version */
1435	get_be24(pb); /* flags */	1435	avio_rb24(pb); /* flags */
1436	entries = get_be32(pb);	1436	entries = avio_rb32(pb);
1437		1437
1438	av_dlog(c->fc, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries);	1438	av_dlog(c->fc, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries);
1439		1439
@@ -1448,8 +1448,8 @@ static int mov_read_stts(MOVContext c, AVIOContext pb, MOVAtom atom) · 8 unmodified lines
1448	int sample_duration;	1448	int sample_duration;
1449	int sample_count;	1449	int sample_count;
1450		1450
1451	sample_count=get_be32(pb);	1451	sample_count=avio_rb32(pb);
1452	sample_duration = get_be32(pb);	1452	sample_duration = avio_rb32(pb);
1453	sc->stts_data[i].count= sample_count;	1453	sc->stts_data[i].count= sample_count;
1454	sc->stts_data[i].duration= sample_duration;	1454	sc->stts_data[i].duration= sample_duration;
1455		1455
@@ -1476,9 +1476,9 @@ static int mov_read_ctts(MOVContext c, AVIOContext pb, MOVAtom atom) · 20 unmodified lines
1476	st = c->fc->streams[c->fc->nb_streams-1];	1476	st = c->fc->streams[c->fc->nb_streams-1];
1477	sc = st->priv_data;	1477	sc = st->priv_data;
1478		1478
1479	get_byte(pb); /* version */	1479	avio_r8(pb); /* version */
1480	get_be24(pb); /* flags */	1480	avio_rb24(pb); /* flags */
1481	entries = get_be32(pb);	1481	entries = avio_rb32(pb);
1482		1482
1483	av_dlog(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);	1483	av_dlog(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);
1484		1484
@@ -1490,8 +1490,8 @@ static int mov_read_ctts(MOVContext c, AVIOContext pb, MOVAtom atom) · 5 unmodified lines
1490	sc->ctts_count = entries;	1490	sc->ctts_count = entries;
1491		1491
1492	for(i=0; i<entries; i++) {	1492	for(i=0; i<entries; i++) {
1493	int count =get_be32(pb);	1493	int count =avio_rb32(pb);
1494	int duration =get_be32(pb);	1494	int duration =avio_rb32(pb);
1495		1495
1496	sc->ctts_data[i].count = count;	1496	sc->ctts_data[i].count = count;
1497	sc->ctts_data[i].duration= duration;	1497	sc->ctts_data[i].duration= duration;
@@ -1837,7 +1837,7 @@ static int mov_read_ilst(MOVContext c, AVIOContext pb, MOVAtom atom) · 339 unmodified lines
1837	static int mov_read_meta(MOVContext c, AVIOContext pb, MOVAtom atom)	1837	static int mov_read_meta(MOVContext c, AVIOContext pb, MOVAtom atom)
1838	{	1838	{
1839	while (atom.size > 8) {	1839	while (atom.size > 8) {
1840	uint32_t tag = get_le32(pb);	1840	uint32_t tag = avio_rl32(pb);
1841	atom.size -= 4;	1841	atom.size -= 4;
1842	if (tag == MKTAG('h','d','l','r')) {	1842	if (tag == MKTAG('h','d','l','r')) {
1843	url_fseek(pb, -8, SEEK_CUR);	1843	url_fseek(pb, -8, SEEK_CUR);
@@ -1864,8 +1864,8 @@ static int mov_read_tkhd(MOVContext c, AVIOContext pb, MOVAtom atom) · 20 unmodified lines
1864	st = c->fc->streams[c->fc->nb_streams-1];	1864	st = c->fc->streams[c->fc->nb_streams-1];
1865	sc = st->priv_data;	1865	sc = st->priv_data;
1866		1866
1867	version = get_byte(pb);	1867	version = avio_r8(pb);
1868	get_be24(pb); /* flags */	1868	avio_rb24(pb); /* flags */
1869	/*	1869	/*
1870	MOV_TRACK_ENABLED 0x0001	1870	MOV_TRACK_ENABLED 0x0001
1871	MOV_TRACK_IN_MOVIE 0x0002	1871	MOV_TRACK_IN_MOVIE 0x0002
@@ -1874,36 +1874,36 @@ static int mov_read_tkhd(MOVContext c, AVIOContext pb, MOVAtom atom) · 2 unmodified lines
1874	*/	1874	*/
1875		1875
1876	if (version == 1) {	1876	if (version == 1) {
1877	get_be64(pb);	1877	avio_rb64(pb);
1878	get_be64(pb);	1878	avio_rb64(pb);
1879	} else {	1879	} else {
1880	get_be32(pb); /* creation time */	1880	avio_rb32(pb); /* creation time */
1881	get_be32(pb); /* modification time */	1881	avio_rb32(pb); /* modification time */
1882	}	1882	}
1883	st->id = (int)get_be32(pb); /* track id (NOT 0 !)*/	1883	st->id = (int)avio_rb32(pb); /* track id (NOT 0 !)*/
1884	get_be32(pb); /* reserved */	1884	avio_rb32(pb); /* reserved */
1885		1885
1886	/* highlevel (considering edits) duration in movie timebase */	1886	/* highlevel (considering edits) duration in movie timebase */
1887	(version == 1) ? get_be64(pb) : get_be32(pb);	1887	(version == 1) ? avio_rb64(pb) : avio_rb32(pb);
1888	get_be32(pb); /* reserved */	1888	avio_rb32(pb); /* reserved */
1889	get_be32(pb); /* reserved */	1889	avio_rb32(pb); /* reserved */
1890		1890
1891	get_be16(pb); /* layer */	1891	avio_rb16(pb); /* layer */
1892	get_be16(pb); /* alternate group */	1892	avio_rb16(pb); /* alternate group */
1893	get_be16(pb); /* volume */	1893	avio_rb16(pb); /* volume */
1894	get_be16(pb); /* reserved */	1894	avio_rb16(pb); /* reserved */
1895		1895
1896	//read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)	1896	//read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
1897	// they're kept in fixed point format through all calculations	1897	// they're kept in fixed point format through all calculations
1898	// ignore u,v,z b/c we don't need the scale factor to calc aspect ratio	1898	// ignore u,v,z b/c we don't need the scale factor to calc aspect ratio
1899	for (i = 0; i < 3; i++) {	1899	for (i = 0; i < 3; i++) {
1900	display_matrix[i][0] = get_be32(pb); // 16.16 fixed point	1900	display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
1901	display_matrix[i][1] = get_be32(pb); // 16.16 fixed point	1901	display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
1902	get_be32(pb); // 2.30 fixed point (not used)	1902	avio_rb32(pb); // 2.30 fixed point (not used)
1903	}	1903	}
1904		1904
1905	width = get_be32(pb); // 16.16 fixed point track width	1905	width = avio_rb32(pb); // 16.16 fixed point track width
1906	height = get_be32(pb); // 16.16 fixed point track height	1906	height = avio_rb32(pb); // 16.16 fixed point track height
1907	sc->width = width >> 16;	1907	sc->width = width >> 16;
1908	sc->height = height >> 16;	1908	sc->height = height >> 16;
1909		1909
@@ -1937,10 +1937,10 @@ static int mov_read_tfhd(MOVContext c, AVIOContext pb, MOVAtom atom) · 27 unmodified lines
1937	MOVTrackExt *trex = NULL;	1937	MOVTrackExt *trex = NULL;
1938	int flags, track_id, i;	1938	int flags, track_id, i;
1939		1939
1940	get_byte(pb); /* version */	1940	avio_r8(pb); /* version */
1941	flags = get_be24(pb);	1941	flags = avio_rb24(pb);
1942		1942
1943	track_id = get_be32(pb);	1943	track_id = avio_rb32(pb);
1944	if (!track_id)	1944	if (!track_id)
1945	return -1;	1945	return -1;
1946	frag->track_id = track_id;	1946	frag->track_id = track_id;
@@ -1954,21 +1954,21 @@ static int mov_read_tfhd(MOVContext c, AVIOContext pb, MOVAtom atom) · 7 unmodified lines
1954	return -1;	1954	return -1;
1955	}	1955	}
1956		1956
1957	if (flags & 0x01) frag->base_data_offset = get_be64(pb);	1957	if (flags & 0x01) frag->base_data_offset = avio_rb64(pb);
1958	else frag->base_data_offset = frag->moof_offset;	1958	else frag->base_data_offset = frag->moof_offset;
1959	if (flags & 0x02) frag->stsd_id = get_be32(pb);	1959	if (flags & 0x02) frag->stsd_id = avio_rb32(pb);
1960	else frag->stsd_id = trex->stsd_id;	1960	else frag->stsd_id = trex->stsd_id;
1961		1961
1962	frag->duration = flags & 0x08 ? get_be32(pb) : trex->duration;	1962	frag->duration = flags & 0x08 ? avio_rb32(pb) : trex->duration;
1963	frag->size = flags & 0x10 ? get_be32(pb) : trex->size;	1963	frag->size = flags & 0x10 ? avio_rb32(pb) : trex->size;
1964	frag->flags = flags & 0x20 ? get_be32(pb) : trex->flags;	1964	frag->flags = flags & 0x20 ? avio_rb32(pb) : trex->flags;
1965	av_dlog(c->fc, "frag flags 0x%x\n", frag->flags);	1965	av_dlog(c->fc, "frag flags 0x%x\n", frag->flags);
1966	return 0;	1966	return 0;
1967	}	1967	}
1968		1968
1969	static int mov_read_chap(MOVContext c, AVIOContext pb, MOVAtom atom)	1969	static int mov_read_chap(MOVContext c, AVIOContext pb, MOVAtom atom)
1970	{	1970	{
1971	c->chapter_track = get_be32(pb);	1971	c->chapter_track = avio_rb32(pb);
1972	return 0;	1972	return 0;
1973	}	1973	}
1974		1974
@@ -1983,13 +1983,13 @@ static int mov_read_trex(MOVContext c, AVIOContext pb, MOVAtom atom) · 8 unmodified lines
1983	return AVERROR(ENOMEM);	1983	return AVERROR(ENOMEM);
1984	c->trex_data = trex;	1984	c->trex_data = trex;
1985	trex = &c->trex_data[c->trex_count++];	1985	trex = &c->trex_data[c->trex_count++];
1986	get_byte(pb); /* version */	1986	avio_r8(pb); /* version */
1987	get_be24(pb); /* flags */	1987	avio_rb24(pb); /* flags */
1988	trex->track_id = get_be32(pb);	1988	trex->track_id = avio_rb32(pb);
1989	trex->stsd_id = get_be32(pb);	1989	trex->stsd_id = avio_rb32(pb);
1990	trex->duration = get_be32(pb);	1990	trex->duration = avio_rb32(pb);
1991	trex->size = get_be32(pb);	1991	trex->size = avio_rb32(pb);
1992	trex->flags = get_be32(pb);	1992	trex->flags = avio_rb32(pb);
1993	return 0;	1993	return 0;
1994	}	1994	}
1995		1995
@@ -2017,12 +2017,12 @@ static int mov_read_trun(MOVContext c, AVIOContext pb, MOVAtom atom) · 21 unmodified lines
2017	sc = st->priv_data;	2017	sc = st->priv_data;
2018	if (sc->pseudo_stream_id+1 != frag->stsd_id)	2018	if (sc->pseudo_stream_id+1 != frag->stsd_id)
2019	return 0;	2019	return 0;
2020	get_byte(pb); /* version */	2020	avio_r8(pb); /* version */
2021	flags = get_be24(pb);	2021	flags = avio_rb24(pb);
2022	entries = get_be32(pb);	2022	entries = avio_rb32(pb);
2023	av_dlog(c->fc, "flags 0x%x entries %d\n", flags, entries);	2023	av_dlog(c->fc, "flags 0x%x entries %d\n", flags, entries);
2024	if (flags & 0x001) data_offset = get_be32(pb);	2024	if (flags & 0x001) data_offset = avio_rb32(pb);
2025	if (flags & 0x004) first_sample_flags = get_be32(pb);	2025	if (flags & 0x004) first_sample_flags = avio_rb32(pb);
2026	if (flags & 0x800) {	2026	if (flags & 0x800) {
2027	MOVStts *ctts_data;	2027	MOVStts *ctts_data;
2028	if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))	2028	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) · 14 unmodified lines
2043	unsigned sample_duration = frag->duration;	2043	unsigned sample_duration = frag->duration;
2044	int keyframe;	2044	int keyframe;
2045		2045
2046	if (flags & 0x100) sample_duration = get_be32(pb);	2046	if (flags & 0x100) sample_duration = avio_rb32(pb);
2047	if (flags & 0x200) sample_size = get_be32(pb);	2047	if (flags & 0x200) sample_size = avio_rb32(pb);
2048	if (flags & 0x400) sample_flags = get_be32(pb);	2048	if (flags & 0x400) sample_flags = avio_rb32(pb);
2049	if (flags & 0x800) {	2049	if (flags & 0x800) {
2050	sc->ctts_data[sc->ctts_count].count = 1;	2050	sc->ctts_data[sc->ctts_count].count = 1;
2051	sc->ctts_data[sc->ctts_count].duration = get_be32(pb);	2051	sc->ctts_data[sc->ctts_count].duration = avio_rb32(pb);
2052	sc->ctts_count++;	2052	sc->ctts_count++;
2053	}	2053	}
2054	if ((keyframe = st->codec->codec_type == AVMEDIA_TYPE_AUDIO \|\|	2054	if ((keyframe = st->codec->codec_type == AVMEDIA_TYPE_AUDIO \|\|
@@ -2077,11 +2077,11 @@ static int mov_read_wide(MOVContext c, AVIOContext pb, MOVAtom atom) · 22 unmodified lines
2077		2077
2078	if (atom.size < 8)	2078	if (atom.size < 8)
2079	return 0; /* continue */	2079	return 0; /* continue */
2080	if (get_be32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */	2080	if (avio_rb32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
2081	url_fskip(pb, atom.size - 4);	2081	url_fskip(pb, atom.size - 4);
2082	return 0;	2082	return 0;
2083	}	2083	}
2084	atom.type = get_le32(pb);	2084	atom.type = avio_rl32(pb);
2085	atom.size -= 8;	2085	atom.size -= 8;
2086	if (atom.type != MKTAG('m','d','a','t')) {	2086	if (atom.type != MKTAG('m','d','a','t')) {
2087	url_fskip(pb, atom.size);	2087	url_fskip(pb, atom.size);
@@ -2100,17 +2100,17 @@ static int mov_read_cmov(MOVContext c, AVIOContext pb, MOVAtom atom) · 12 unmodified lines
2100	long cmov_len, moov_len;	2100	long cmov_len, moov_len;
2101	int ret = -1;	2101	int ret = -1;
2102		2102
2103	get_be32(pb); /* dcom atom */	2103	avio_rb32(pb); /* dcom atom */
2104	if (get_le32(pb) != MKTAG('d','c','o','m'))	2104	if (avio_rl32(pb) != MKTAG('d','c','o','m'))
2105	return -1;	2105	return -1;
2106	if (get_le32(pb) != MKTAG('z','l','i','b')) {	2106	if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
2107	av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !");	2107	av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !");
2108	return -1;	2108	return -1;
2109	}	2109	}
2110	get_be32(pb); /* cmvd atom */	2110	avio_rb32(pb); /* cmvd atom */
2111	if (get_le32(pb) != MKTAG('c','m','v','d'))	2111	if (avio_rl32(pb) != MKTAG('c','m','v','d'))
2112	return -1;	2112	return -1;
2113	moov_len = get_be32(pb); /* uncompressed size */	2113	moov_len = avio_rb32(pb); /* uncompressed size */
2114	cmov_len = atom.size - 6 * 4;	2114	cmov_len = atom.size - 6 * 4;
2115		2115
2116	cmov_data = av_malloc(cmov_len);	2116	cmov_data = av_malloc(cmov_len);
@@ -2121,7 +2121,7 @@ static int mov_read_cmov(MOVContext c, AVIOContext pb, MOVAtom atom) · 4 unmodified lines
2121	av_free(cmov_data);	2121	av_free(cmov_data);
2122	return AVERROR(ENOMEM);	2122	return AVERROR(ENOMEM);
2123	}	2123	}
2124	get_buffer(pb, cmov_data, cmov_len);	2124	avio_read(pb, cmov_data, cmov_len);
2125	if(uncompress (moov_data, (uLongf ) &moov_len, (const Bytef )cmov_data, cmov_len) != Z_OK)	2125	if(uncompress (moov_data, (uLongf ) &moov_len, (const Bytef )cmov_data, cmov_len) != Z_OK)
2126	goto free_and_return;	2126	goto free_and_return;
2127	if(ffio_init_context(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)	2127	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) · 24 unmodified lines
2152	return 0;	2152	return 0;
2153	sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;	2153	sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
2154		2154
2155	get_byte(pb); /* version */	2155	avio_r8(pb); /* version */
2156	get_be24(pb); /* flags */	2156	avio_rb24(pb); /* flags */
2157	edit_count = get_be32(pb); /* entries */	2157	edit_count = avio_rb32(pb); /* entries */
2158		2158
2159	if((uint64_t)edit_count*12+8 > atom.size)	2159	if((uint64_t)edit_count*12+8 > atom.size)
2160	return -1;	2160	return -1;
2161		2161
2162	for(i=0; i<edit_count; i++){	2162	for(i=0; i<edit_count; i++){
2163	int time;	2163	int time;
2164	int duration = get_be32(pb); /* Track duration */	2164	int duration = avio_rb32(pb); /* Track duration */
2165	time = get_be32(pb); /* Media time */	2165	time = avio_rb32(pb); /* Media time */
2166	get_be32(pb); /* Media rate */	2166	avio_rb32(pb); /* Media rate */
2167	if (i == 0 && time >= -1) {	2167	if (i == 0 && time >= -1) {
2168	sc->time_offset = time != -1 ? time : -duration;	2168	sc->time_offset = time != -1 ? time : -duration;
2169	}	2169	}
@@ -2314,7 +2314,7 @@ static void mov_read_chapters(AVFormatContext *s) · 144 unmodified lines
2314	}	2314	}
2315		2315
2316	// the first two bytes are the length of the title	2316	// the first two bytes are the length of the title
2317	len = get_be16(sc->pb);	2317	len = avio_rb16(sc->pb);
2318	if (len > sample->size-2)	2318	if (len > sample->size-2)
2319	continue;	2319	continue;
2320	title_len = 2*len + 1;	2320	title_len = 2*len + 1;
@@ -2324,7 +2324,7 @@ static void mov_read_chapters(AVFormatContext *s) · 3 unmodified lines
2324	// The samples could theoretically be in any encoding if there's an encd	2324	// The samples could theoretically be in any encoding if there's an encd
2325	// atom following, but in practice are only utf-8 or utf-16, distinguished	2325	// atom following, but in practice are only utf-8 or utf-16, distinguished
2326	// instead by the presence of a BOM	2326	// instead by the presence of a BOM
2327	ch = get_be16(sc->pb);	2327	ch = avio_rb16(sc->pb);
2328	if (ch == 0xfeff)	2328	if (ch == 0xfeff)
2329	avio_get_str16be(sc->pb, len, title, title_len);	2329	avio_get_str16be(sc->pb, len, title, title_len);
2330	else if (ch == 0xfffe)	2330	else if (ch == 0xfffe)

libavformat/mp3dec.c+9−9

@@ -80,7 +80,7 @@ static int mp3_parse_vbr_tags(AVFormatContext s, AVStream st, int64_t base) · 79 unmodified lines
80	MPADecodeHeader c;	80	MPADecodeHeader c;
81	int vbrtag_size = 0;	81	int vbrtag_size = 0;
82		82
83	v = get_be32(s->pb);	83	v = avio_rb32(s->pb);
84	if(ff_mpa_check_header(v) < 0)	84	if(ff_mpa_check_header(v) < 0)
85	return -1;	85	return -1;
86		86
@@ -91,25 +91,25 @@ static int mp3_parse_vbr_tags(AVFormatContext s, AVStream st, int64_t base) · 4 unmodified lines
91		91
92	/* Check for Xing / Info tag */	92	/* Check for Xing / Info tag */
93	url_fseek(s->pb, xing_offtbl[c.lsf == 1][c.nb_channels == 1], SEEK_CUR);	93	url_fseek(s->pb, xing_offtbl[c.lsf == 1][c.nb_channels == 1], SEEK_CUR);
94	v = get_be32(s->pb);	94	v = avio_rb32(s->pb);
95	if(v == MKBETAG('X', 'i', 'n', 'g') \|\| v == MKBETAG('I', 'n', 'f', 'o')) {	95	if(v == MKBETAG('X', 'i', 'n', 'g') \|\| v == MKBETAG('I', 'n', 'f', 'o')) {
96	v = get_be32(s->pb);	96	v = avio_rb32(s->pb);
97	if(v & 0x1)	97	if(v & 0x1)
98	frames = get_be32(s->pb);	98	frames = avio_rb32(s->pb);
99	if(v & 0x2)	99	if(v & 0x2)
100	size = get_be32(s->pb);	100	size = avio_rb32(s->pb);
101	}	101	}
102		102
103	/* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */	103	/* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */
104	url_fseek(s->pb, base + 4 + 32, SEEK_SET);	104	url_fseek(s->pb, base + 4 + 32, SEEK_SET);
105	v = get_be32(s->pb);	105	v = avio_rb32(s->pb);
106	if(v == MKBETAG('V', 'B', 'R', 'I')) {	106	if(v == MKBETAG('V', 'B', 'R', 'I')) {
107	/* Check tag version */	107	/* Check tag version */
108	if(get_be16(s->pb) == 1) {	108	if(avio_rb16(s->pb) == 1) {
109	/* skip delay and quality */	109	/* skip delay and quality */
110	url_fseek(s->pb, 4, SEEK_CUR);	110	url_fseek(s->pb, 4, SEEK_CUR);
111	frames = get_be32(s->pb);	111	frames = avio_rb32(s->pb);
112	size = get_be32(s->pb);	112	size = avio_rb32(s->pb);
113	}	113	}
114	}	114	}
115		115

libavformat/mpc.c+7−7

@@ -55,16 +55,16 @@ static int mpc_read_header(AVFormatContext s, AVFormatParameters ap) · 54 unmodified lines
55	MPCContext *c = s->priv_data;	55	MPCContext *c = s->priv_data;
56	AVStream *st;	56	AVStream *st;
57		57
58	if(get_le24(s->pb) != MKTAG('M', 'P', '+', 0)){	58	if(avio_rl24(s->pb) != MKTAG('M', 'P', '+', 0)){
59	av_log(s, AV_LOG_ERROR, "Not a Musepack file\n");	59	av_log(s, AV_LOG_ERROR, "Not a Musepack file\n");
60	return -1;	60	return -1;
61	}	61	}
62	c->ver = get_byte(s->pb);	62	c->ver = avio_r8(s->pb);
63	if(c->ver != 0x07 && c->ver != 0x17){	63	if(c->ver != 0x07 && c->ver != 0x17){
64	av_log(s, AV_LOG_ERROR, "Can demux Musepack SV7, got version %02X\n", c->ver);	64	av_log(s, AV_LOG_ERROR, "Can demux Musepack SV7, got version %02X\n", c->ver);
65	return -1;	65	return -1;
66	}	66	}
67	c->fcount = get_le32(s->pb);	67	c->fcount = avio_rl32(s->pb);
68	if((int64_t)c->fcount * sizeof(MPCFrame) >= UINT_MAX){	68	if((int64_t)c->fcount * sizeof(MPCFrame) >= UINT_MAX){
69	av_log(s, AV_LOG_ERROR, "Too many frames, seeking is not possible\n");	69	av_log(s, AV_LOG_ERROR, "Too many frames, seeking is not possible\n");
70	return -1;	70	return -1;
@@ -85,7 +85,7 @@ static int mpc_read_header(AVFormatContext s, AVFormatParameters ap) · 14 unmodified lines
85		85
86	st->codec->extradata_size = 16;	86	st->codec->extradata_size = 16;
87	st->codec->extradata = av_mallocz(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE);	87	st->codec->extradata = av_mallocz(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE);
88	get_buffer(s->pb, st->codec->extradata, 16);	88	avio_read(s->pb, st->codec->extradata, 16);
89	st->codec->sample_rate = mpc_rate[st->codec->extradata[2] & 3];	89	st->codec->sample_rate = mpc_rate[st->codec->extradata[2] & 3];
90	av_set_pts_info(st, 32, MPC_FRAMESIZE, st->codec->sample_rate);	90	av_set_pts_info(st, 32, MPC_FRAMESIZE, st->codec->sample_rate);
91	/* scan for seekpoints */	91	/* scan for seekpoints */
@@ -121,11 +121,11 @@ static int mpc_read_packet(AVFormatContext s, AVPacket pkt) · 29 unmodified lines
121	c->curframe++;	121	c->curframe++;
122	curbits = c->curbits;	122	curbits = c->curbits;
123	pos = url_ftell(s->pb);	123	pos = url_ftell(s->pb);
124	tmp = get_le32(s->pb);	124	tmp = avio_rl32(s->pb);
125	if(curbits <= 12){	125	if(curbits <= 12){
126	size2 = (tmp >> (12 - curbits)) & 0xFFFFF;	126	size2 = (tmp >> (12 - curbits)) & 0xFFFFF;
127	}else{	127	}else{
128	tmp = (tmp << 32) \| get_le32(s->pb);	128	tmp = (tmp << 32) \| avio_rl32(s->pb);
129	size2 = (tmp >> (44 - curbits)) & 0xFFFFF;	129	size2 = (tmp >> (44 - curbits)) & 0xFFFFF;
130	}	130	}
131	curbits += 20;	131	curbits += 20;
@@ -151,7 +151,7 @@ static int mpc_read_packet(AVFormatContext s, AVPacket pkt) · 19 unmodified lines
151		151
152	pkt->stream_index = 0;	152	pkt->stream_index = 0;
153	pkt->pts = cur;	153	pkt->pts = cur;
154	ret = get_buffer(s->pb, pkt->data + 4, size);	154	ret = avio_read(s->pb, pkt->data + 4, size);
155	if(c->curbits)	155	if(c->curbits)
156	url_fseek(s->pb, -4, SEEK_CUR);	156	url_fseek(s->pb, -4, SEEK_CUR);
157	if(ret < size){	157	if(ret < size){

libavformat/mpc8.c+5−5

@@ -121,7 +121,7 @@ static void mpc8_get_chunk_header(AVIOContext pb, int tag, int64_t *size) · 120 unmodified lines
121	{	121	{
122	int64_t pos;	122	int64_t pos;
123	pos = url_ftell(pb);	123	pos = url_ftell(pb);
124	*tag = get_le16(pb);	124	*tag = avio_rl16(pb);
125	*size = ff_get_v(pb);	125	*size = ff_get_v(pb);
126	*size -= url_ftell(pb) - pos;	126	*size -= url_ftell(pb) - pos;
127	}	127	}
@@ -143,7 +143,7 @@ static void mpc8_parse_seektable(AVFormatContext *s, int64_t off) · 15 unmodified lines
143	}	143	}
144	if(!(buf = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE)))	144	if(!(buf = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE)))
145	return;	145	return;
146	get_buffer(s->pb, buf, size);	146	avio_read(s->pb, buf, size);
147	init_get_bits(&gb, buf, size * 8);	147	init_get_bits(&gb, buf, size * 8);
148	size = gb_get_v(&gb);	148	size = gb_get_v(&gb);
149	if(size > UINT_MAX/4 \|\| size > c->samples/1152){	149	if(size > UINT_MAX/4 \|\| size > c->samples/1152){
@@ -195,7 +195,7 @@ static int mpc8_read_header(AVFormatContext s, AVFormatParameters ap) · 45 unmodified lines
195	int64_t size, pos;	195	int64_t size, pos;
196		196
197	c->header_pos = url_ftell(pb);	197	c->header_pos = url_ftell(pb);
198	if(get_le32(pb) != TAG_MPCK){	198	if(avio_rl32(pb) != TAG_MPCK){
199	av_log(s, AV_LOG_ERROR, "Not a Musepack8 file\n");	199	av_log(s, AV_LOG_ERROR, "Not a Musepack8 file\n");
200	return -1;	200	return -1;
201	}	201	}
@@ -213,7 +213,7 @@ static int mpc8_read_header(AVFormatContext s, AVFormatParameters ap) · 11 unmodified lines
213	}	213	}
214	pos = url_ftell(pb);	214	pos = url_ftell(pb);
215	url_fskip(pb, 4); //CRC	215	url_fskip(pb, 4); //CRC
216	c->ver = get_byte(pb);	216	c->ver = avio_r8(pb);
217	if(c->ver != 8){	217	if(c->ver != 8){
218	av_log(s, AV_LOG_ERROR, "Unknown stream version %d\n", c->ver);	218	av_log(s, AV_LOG_ERROR, "Unknown stream version %d\n", c->ver);
219	return -1;	219	return -1;
@@ -230,7 +230,7 @@ static int mpc8_read_header(AVFormatContext s, AVFormatParameters ap) · 10 unmodified lines
230		230
231	st->codec->extradata_size = 2;	231	st->codec->extradata_size = 2;
232	st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);	232	st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
233	get_buffer(pb, st->codec->extradata, st->codec->extradata_size);	233	avio_read(pb, st->codec->extradata, st->codec->extradata_size);
234		234
235	st->codec->channels = (st->codec->extradata[1] >> 4) + 1;	235	st->codec->channels = (st->codec->extradata[1] >> 4) + 1;
236	st->codec->sample_rate = mpc8_rate[st->codec->extradata[0] >> 5];	236	st->codec->sample_rate = mpc8_rate[st->codec->extradata[0] >> 5];

libavformat/mpeg.c+39−39

@@ -113,7 +113,7 @@ static int mpegps_read_header(AVFormatContext *s, · 112 unmodified lines
113		113
114	m->sofdec = -1;	114	m->sofdec = -1;
115	do {	115	do {
116	v = get_byte(s->pb);	116	v = avio_r8(s->pb);
117	m->header_state = m->header_state << 8 \| v;	117	m->header_state = m->header_state << 8 \| v;
118	m->sofdec++;	118	m->sofdec++;
119	} while (v == sofdec[i] && i++ < 6);	119	} while (v == sofdec[i] && i++ < 6);
@@ -128,8 +128,8 @@ static int64_t get_pts(AVIOContext *pb, int c) · 8 unmodified lines
128	{	128	{
129	uint8_t buf[5];	129	uint8_t buf[5];
130		130
131	buf[0] = c<0 ? get_byte(pb) : c;	131	buf[0] = c<0 ? avio_r8(pb) : c;
132	get_buffer(pb, buf+1, 4);	132	avio_read(pb, buf+1, 4);
133		133
134	return ff_parse_pes_pts(buf);	134	return ff_parse_pes_pts(buf);
135	}	135	}
@@ -145,7 +145,7 @@ static int find_next_start_code(AVIOContext pb, int size_ptr, · 9 unmodified lines
145	while (n > 0) {	145	while (n > 0) {
146	if (url_feof(pb))	146	if (url_feof(pb))
147	break;	147	break;
148	v = get_byte(pb);	148	v = avio_r8(pb);
149	n--;	149	n--;
150	if (state == 0x000001) {	150	if (state == 0x000001) {
151	state = ((state << 8) \| v) & 0xffffff;	151	state = ((state << 8) \| v) & 0xffffff;
@@ -176,7 +176,7 @@ static int find_prev_start_code(AVIOContext pb, int size_ptr) · 24 unmodified lines
176	if (pos < 0)	176	if (pos < 0)
177	pos = 0;	177	pos = 0;
178	url_fseek(pb, pos, SEEK_SET);	178	url_fseek(pb, pos, SEEK_SET);
179	get_byte(pb);	179	avio_r8(pb);
180		180
181	pos = pos_start;	181	pos = pos_start;
182	for(;;) {	182	for(;;) {
@@ -186,7 +186,7 @@ static int find_prev_start_code(AVIOContext pb, int size_ptr) · 3 unmodified lines
186	goto the_end;	186	goto the_end;
187	}	187	}
188	url_fseek(pb, pos, SEEK_SET);	188	url_fseek(pb, pos, SEEK_SET);
189	start_code = get_be32(pb);	189	start_code = avio_rb32(pb);
190	if ((start_code & 0xffffff00) == 0x100)	190	if ((start_code & 0xffffff00) == 0x100)
191	break;	191	break;
192	}	192	}
@@ -206,27 +206,27 @@ static long mpegps_psm_parse(MpegDemuxContext m, AVIOContext pb) · 13 unmodified lines
206	{	206	{
207	int psm_length, ps_info_length, es_map_length;	207	int psm_length, ps_info_length, es_map_length;
208		208
209	psm_length = get_be16(pb);	209	psm_length = avio_rb16(pb);
210	get_byte(pb);	210	avio_r8(pb);
211	get_byte(pb);	211	avio_r8(pb);
212	ps_info_length = get_be16(pb);	212	ps_info_length = avio_rb16(pb);
213		213
214	/* skip program_stream_info */	214	/* skip program_stream_info */
215	url_fskip(pb, ps_info_length);	215	url_fskip(pb, ps_info_length);
216	es_map_length = get_be16(pb);	216	es_map_length = avio_rb16(pb);
217		217
218	/* at least one es available? */	218	/* at least one es available? */
219	while (es_map_length >= 4){	219	while (es_map_length >= 4){
220	unsigned char type = get_byte(pb);	220	unsigned char type = avio_r8(pb);
221	unsigned char es_id = get_byte(pb);	221	unsigned char es_id = avio_r8(pb);
222	uint16_t es_info_length = get_be16(pb);	222	uint16_t es_info_length = avio_rb16(pb);
223	/* remember mapping from stream id to stream type */	223	/* remember mapping from stream id to stream type */
224	m->psm_es_type[es_id] = type;	224	m->psm_es_type[es_id] = type;
225	/* skip program_stream_info */	225	/* skip program_stream_info */
226	url_fskip(pb, es_info_length);	226	url_fskip(pb, es_info_length);
227	es_map_length -= 4 + es_info_length;	227	es_map_length -= 4 + es_info_length;
228	}	228	}
229	get_be32(pb); /* crc32 */	229	avio_rb32(pb); /* crc32 */
230	return 2 + psm_length;	230	return 2 + psm_length;
231	}	231	}
232		232
@@ -264,16 +264,16 @@ static int mpegps_read_pes_header(AVFormatContext *s, · 31 unmodified lines
264	if (startcode == SYSTEM_HEADER_START_CODE)	264	if (startcode == SYSTEM_HEADER_START_CODE)
265	goto redo;	265	goto redo;
266	if (startcode == PADDING_STREAM) {	266	if (startcode == PADDING_STREAM) {
267	url_fskip(s->pb, get_be16(s->pb));	267	url_fskip(s->pb, avio_rb16(s->pb));
268	goto redo;	268	goto redo;
269	}	269	}
270	if (startcode == PRIVATE_STREAM_2) {	270	if (startcode == PRIVATE_STREAM_2) {
271	len = get_be16(s->pb);	271	len = avio_rb16(s->pb);
272	if (!m->sofdec) {	272	if (!m->sofdec) {
273	while (len-- >= 6) {	273	while (len-- >= 6) {
274	if (get_byte(s->pb) == 'S') {	274	if (avio_r8(s->pb) == 'S') {
275	uint8_t buf[5];	275	uint8_t buf[5];
276	get_buffer(s->pb, buf, sizeof(buf));	276	avio_read(s->pb, buf, sizeof(buf));
277	m->sofdec = !memcmp(buf, "ofdec", 5);	277	m->sofdec = !memcmp(buf, "ofdec", 5);
278	len -= sizeof(buf);	278	len -= sizeof(buf);
279	break;	279	break;
@@ -297,14 +297,14 @@ static int mpegps_read_pes_header(AVFormatContext *s, · 17 unmodified lines
297	if (ppos) {	297	if (ppos) {
298	*ppos = url_ftell(s->pb) - 4;	298	*ppos = url_ftell(s->pb) - 4;
299	}	299	}
300	len = get_be16(s->pb);	300	len = avio_rb16(s->pb);
301	pts =	301	pts =
302	dts = AV_NOPTS_VALUE;	302	dts = AV_NOPTS_VALUE;
303	/* stuffing */	303	/* stuffing */
304	for(;;) {	304	for(;;) {
305	if (len < 1)	305	if (len < 1)
306	goto error_redo;	306	goto error_redo;
307	c = get_byte(s->pb);	307	c = avio_r8(s->pb);
308	len--;	308	len--;
309	/* XXX: for mpeg1, should test only bit 7 */	309	/* XXX: for mpeg1, should test only bit 7 */
310	if (c != 0xff)	310	if (c != 0xff)
@@ -312,8 +312,8 @@ static int mpegps_read_pes_header(AVFormatContext *s, · 1 unmodified line
312	}	312	}
313	if ((c & 0xc0) == 0x40) {	313	if ((c & 0xc0) == 0x40) {
314	/* buffer scale & size */	314	/* buffer scale & size */
315	get_byte(s->pb);	315	avio_r8(s->pb);
316	c = get_byte(s->pb);	316	c = avio_r8(s->pb);
317	len -= 2;	317	len -= 2;
318	}	318	}
319	if ((c & 0xe0) == 0x20) {	319	if ((c & 0xe0) == 0x20) {
@@ -331,8 +331,8 @@ static int mpegps_read_pes_header(AVFormatContext *s, · 11 unmodified lines
331	goto redo;	331	goto redo;
332	}	332	}
333	#endif	333	#endif
334	flags = get_byte(s->pb);	334	flags = avio_r8(s->pb);
335	header_len = get_byte(s->pb);	335	header_len = avio_r8(s->pb);
336	len -= 2;	336	len -= 2;
337	if (header_len > len)	337	if (header_len > len)
338	goto error_redo;	338	goto error_redo;
@@ -350,7 +350,7 @@ static int mpegps_read_pes_header(AVFormatContext *s, · 11 unmodified lines
350	av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");	350	av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
351	}	351	}
352	if (flags & 0x01) { /* PES extension */	352	if (flags & 0x01) { /* PES extension */
353	pes_ext = get_byte(s->pb);	353	pes_ext = avio_r8(s->pb);
354	header_len--;	354	header_len--;
355	/* Skip PES private data, program packet sequence counter and P-STD buffer */	355	/* Skip PES private data, program packet sequence counter and P-STD buffer */
356	skip = (pes_ext >> 4) & 0xb;	356	skip = (pes_ext >> 4) & 0xb;
@@ -363,10 +363,10 @@ static int mpegps_read_pes_header(AVFormatContext *s, · 6 unmodified lines
363	header_len -= skip;	363	header_len -= skip;
364		364
365	if (pes_ext & 0x01) { /* PES extension 2 */	365	if (pes_ext & 0x01) { /* PES extension 2 */
366	ext2_len = get_byte(s->pb);	366	ext2_len = avio_r8(s->pb);
367	header_len--;	367	header_len--;
368	if ((ext2_len & 0x7f) > 0) {	368	if ((ext2_len & 0x7f) > 0) {
369	id_ext = get_byte(s->pb);	369	id_ext = avio_r8(s->pb);
370	if ((id_ext & 0x80) == 0)	370	if ((id_ext & 0x80) == 0)
371	startcode = ((startcode & 0xff) << 8) \| id_ext;	371	startcode = ((startcode & 0xff) << 8) \| id_ext;
372	header_len--;	372	header_len--;
@@ -381,17 +381,17 @@ static int mpegps_read_pes_header(AVFormatContext *s, · 8 unmodified lines
381	goto redo;	381	goto redo;
382		382
383	if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {	383	if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
384	startcode = get_byte(s->pb);	384	startcode = avio_r8(s->pb);
385	len--;	385	len--;
386	if (startcode >= 0x80 && startcode <= 0xcf) {	386	if (startcode >= 0x80 && startcode <= 0xcf) {
387	/* audio: skip header */	387	/* audio: skip header */
388	get_byte(s->pb);	388	avio_r8(s->pb);
389	get_byte(s->pb);	389	avio_r8(s->pb);
390	get_byte(s->pb);	390	avio_r8(s->pb);
391	len -= 3;	391	len -= 3;
392	if (startcode >= 0xb0 && startcode <= 0xbf) {	392	if (startcode >= 0xb0 && startcode <= 0xbf) {
393	/* MLP/TrueHD audio has a 4-byte header */	393	/* MLP/TrueHD audio has a 4-byte header */
394	get_byte(s->pb);	394	avio_r8(s->pb);
395	len--;	395	len--;
396	}	396	}
397	}	397	}
@@ -432,7 +432,7 @@ static int mpegps_read_packet(AVFormatContext *s, · 34 unmodified lines
432	return len;	432	return len;
433		433
434	if(startcode == 0x1bd) {	434	if(startcode == 0x1bd) {
435	dvdaudio_substream_type = get_byte(s->pb);	435	dvdaudio_substream_type = avio_r8(s->pb);
436	url_fskip(s->pb, 3);	436	url_fskip(s->pb, 3);
437	len -= 4;	437	len -= 4;
438	}	438	}
@@ -474,7 +474,7 @@ static int mpegps_read_packet(AVFormatContext *s, · 35 unmodified lines
474	} else if (startcode >= 0x1e0 && startcode <= 0x1ef) {	474	} else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
475	static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };	475	static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
476	unsigned char buf[8];	476	unsigned char buf[8];
477	get_buffer(s->pb, buf, 8);	477	avio_read(s->pb, buf, 8);
478	url_fseek(s->pb, -8, SEEK_CUR);	478	url_fseek(s->pb, -8, SEEK_CUR);
479	if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 \|\| buf[7] != 1))	479	if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 \|\| buf[7] != 1))
480	codec_id = CODEC_ID_CAVS;	480	codec_id = CODEC_ID_CAVS;
@@ -547,9 +547,9 @@ static int mpegps_read_packet(AVFormatContext *s, · 66 unmodified lines
547	audio data */	547	audio data */
548	if (len <= 3)	548	if (len <= 3)
549	goto skip;	549	goto skip;
550	get_byte(s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */	550	avio_r8(s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
551	b1 = get_byte(s->pb); /* quant (2), freq(2), reserved(1), channels(3) */	551	b1 = avio_r8(s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
552	get_byte(s->pb); /* dynamic range control (0x80 = off) */	552	avio_r8(s->pb); /* dynamic range control (0x80 = off) */
553	len -= 3;	553	len -= 3;
554	freq = (b1 >> 4) & 3;	554	freq = (b1 >> 4) & 3;
555	st->codec->sample_rate = lpcm_freq_tab[freq];	555	st->codec->sample_rate = lpcm_freq_tab[freq];
@@ -564,7 +564,7 @@ static int mpegps_read_packet(AVFormatContext *s, · 8 unmodified lines
564	return AVERROR(EINVAL);	564	return AVERROR(EINVAL);
565	}	565	}
566	av_new_packet(pkt, len);	566	av_new_packet(pkt, len);
567	get_buffer(s->pb, pkt->data, pkt->size);	567	avio_read(s->pb, pkt->data, pkt->size);
568	pkt->pts = pts;	568	pkt->pts = pts;
569	pkt->dts = dts;	569	pkt->dts = dts;
570	pkt->pos = dummy_pos;	570	pkt->pos = dummy_pos;

libavformat/mpegts.c+15−15

@@ -860,24 +860,24 @@ static int mp4_read_iods(AVFormatContext s, const uint8_t buf, unsigned size, · 859 unmodified lines
860		860
861	len = ff_mp4_read_descr(s, &pb, &tag);	861	len = ff_mp4_read_descr(s, &pb, &tag);
862	if (tag == MP4IODescrTag) {	862	if (tag == MP4IODescrTag) {
863	get_be16(&pb); // ID	863	avio_rb16(&pb); // ID
864	get_byte(&pb);	864	avio_r8(&pb);
865	get_byte(&pb);	865	avio_r8(&pb);
866	get_byte(&pb);	866	avio_r8(&pb);
867	get_byte(&pb);	867	avio_r8(&pb);
868	get_byte(&pb);	868	avio_r8(&pb);
869	len = ff_mp4_read_descr(s, &pb, &tag);	869	len = ff_mp4_read_descr(s, &pb, &tag);
870	if (tag == MP4ESDescrTag) {	870	if (tag == MP4ESDescrTag) {
871	es_id = get_be16(&pb); / ES_ID */	871	es_id = avio_rb16(&pb); / ES_ID */
872	av_dlog(s, "ES_ID %#x\n", *es_id);	872	av_dlog(s, "ES_ID %#x\n", *es_id);
873	get_byte(&pb); /* priority */	873	avio_r8(&pb); /* priority */
874	len = ff_mp4_read_descr(s, &pb, &tag);	874	len = ff_mp4_read_descr(s, &pb, &tag);
875	if (tag == MP4DecConfigDescrTag) {	875	if (tag == MP4DecConfigDescrTag) {
876	*dec_config_descr = av_malloc(len);	876	*dec_config_descr = av_malloc(len);
877	if (!*dec_config_descr)	877	if (!*dec_config_descr)
878	return AVERROR(ENOMEM);	878	return AVERROR(ENOMEM);
879	*dec_config_descr_size = len;	879	*dec_config_descr_size = len;
880	get_buffer(&pb, *dec_config_descr, len);	880	avio_read(&pb, *dec_config_descr, len);
881	}	881	}
882	}	882	}
883	}	883	}
@@ -1332,7 +1332,7 @@ static int read_packet(AVFormatContext s, uint8_t buf, int raw_packet_size) · 448 unmodified lines
1332	int skip, len;	1332	int skip, len;
1333		1333
1334	for(;;) {	1334	for(;;) {
1335	len = get_buffer(pb, buf, TS_PACKET_SIZE);	1335	len = avio_read(pb, buf, TS_PACKET_SIZE);
1336	if (len != TS_PACKET_SIZE)	1336	if (len != TS_PACKET_SIZE)
1337	return AVERROR(EIO);	1337	return AVERROR(EIO);
1338	/* check paquet sync byte */	1338	/* check paquet sync byte */
@@ -1455,7 +1455,7 @@ static int mpegts_read_header(AVFormatContext *s, · 116 unmodified lines
1455		1455
1456	/* read the first 1024 bytes to get packet size */	1456	/* read the first 1024 bytes to get packet size */
1457	pos = url_ftell(pb);	1457	pos = url_ftell(pb);
1458	len = get_buffer(pb, buf, sizeof(buf));	1458	len = avio_read(pb, buf, sizeof(buf));
1459	if (len != sizeof(buf))	1459	if (len != sizeof(buf))
1460	goto fail;	1460	goto fail;
1461	ts->raw_packet_size = get_packet_size(buf, sizeof(buf));	1461	ts->raw_packet_size = get_packet_size(buf, sizeof(buf));
@@ -1565,7 +1565,7 @@ static int mpegts_raw_read_packet(AVFormatContext *s, · 103 unmodified lines
1565	pos = url_ftell(s->pb);	1565	pos = url_ftell(s->pb);
1566	for(i = 0; i < MAX_PACKET_READAHEAD; i++) {	1566	for(i = 0; i < MAX_PACKET_READAHEAD; i++) {
1567	url_fseek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);	1567	url_fseek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
1568	get_buffer(s->pb, pcr_buf, 12);	1568	avio_read(s->pb, pcr_buf, 12);
1569	if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {	1569	if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
1570	/* XXX: not precise enough */	1570	/* XXX: not precise enough */
1571	ts->pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /	1571	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, · 78 unmodified lines
1650	if (find_next) {	1650	if (find_next) {
1651	for(;;) {	1651	for(;;) {
1652	url_fseek(s->pb, pos, SEEK_SET);	1652	url_fseek(s->pb, pos, SEEK_SET);
1653	if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)	1653	if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1654	return AV_NOPTS_VALUE;	1654	return AV_NOPTS_VALUE;
1655	if ((pcr_pid < 0 \|\| (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&	1655	if ((pcr_pid < 0 \|\| (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
1656	parse_pcr(&timestamp, &pcr_l, buf) == 0) {	1656	parse_pcr(&timestamp, &pcr_l, buf) == 0) {
@@ -1664,7 +1664,7 @@ static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index, · 7 unmodified lines
1664	if (pos < 0)	1664	if (pos < 0)
1665	return AV_NOPTS_VALUE;	1665	return AV_NOPTS_VALUE;
1666	url_fseek(s->pb, pos, SEEK_SET);	1666	url_fseek(s->pb, pos, SEEK_SET);
1667	if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)	1667	if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1668	return AV_NOPTS_VALUE;	1668	return AV_NOPTS_VALUE;
1669	if ((pcr_pid < 0 \|\| (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&	1669	if ((pcr_pid < 0 \|\| (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
1670	parse_pcr(&timestamp, &pcr_l, buf) == 0) {	1670	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 · 104 unmodified lines
1775		1775
1776	for(;;) {	1776	for(;;) {
1777	url_fseek(s->pb, pos, SEEK_SET);	1777	url_fseek(s->pb, pos, SEEK_SET);
1778	if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)	1778	if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1779	return -1;	1779	return -1;
1780	// pid = AV_RB16(buf + 1) & 0x1fff;	1780	// pid = AV_RB16(buf + 1) & 0x1fff;
1781	if(buf[1] & 0x40) break;	1781	if(buf[1] & 0x40) break;

libavformat/msnwc_tcp.c+4−4

@@ -88,7 +88,7 @@ static int msnwc_tcp_read_header(AVFormatContext ctx, AVFormatParameters ap) · 87 unmodified lines
88		88
89	/* Some files start with "connected\r\n\r\n".	89	/* Some files start with "connected\r\n\r\n".
90	* So skip until we find the first byte of struct size */	90	* So skip until we find the first byte of struct size */
91	while(get_byte(pb) != HEADER_SIZE && !url_feof(pb));	91	while(avio_r8(pb) != HEADER_SIZE && !url_feof(pb));
92		92
93	if(url_feof(pb)) {	93	if(url_feof(pb)) {
94	av_log(ctx, AV_LOG_ERROR, "Could not find valid start.");	94	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) · 12 unmodified lines
107	url_fskip(pb, 1); /* one byte has been read ahead */	107	url_fskip(pb, 1); /* one byte has been read ahead */
108	url_fskip(pb, 2);	108	url_fskip(pb, 2);
109	url_fskip(pb, 2);	109	url_fskip(pb, 2);
110	keyframe = get_le16(pb);	110	keyframe = avio_rl16(pb);
111	size = get_le32(pb);	111	size = avio_rl32(pb);
112	url_fskip(pb, 4);	112	url_fskip(pb, 4);
113	url_fskip(pb, 4);	113	url_fskip(pb, 4);
114	timestamp = get_le32(pb);	114	timestamp = avio_rl32(pb);
115		115
116	if(!size \|\| av_get_packet(pb, pkt, size) != size)	116	if(!size \|\| av_get_packet(pb, pkt, size) != size)
117	return -1;	117	return -1;

libavformat/mtv.c+10−10

@@ -84,16 +84,16 @@ static int mtv_read_header(AVFormatContext s, AVFormatParameters ap) · 83 unmodified lines
84	unsigned int audio_subsegments;	84	unsigned int audio_subsegments;
85		85
86	url_fskip(pb, 3);	86	url_fskip(pb, 3);
87	mtv->file_size = get_le32(pb);	87	mtv->file_size = avio_rl32(pb);
88	mtv->segments = get_le32(pb);	88	mtv->segments = avio_rl32(pb);
89	url_fskip(pb, 32);	89	url_fskip(pb, 32);
90	mtv->audio_identifier = get_le24(pb);	90	mtv->audio_identifier = avio_rl24(pb);
91	mtv->audio_br = get_le16(pb);	91	mtv->audio_br = avio_rl16(pb);
92	mtv->img_colorfmt = get_le24(pb);	92	mtv->img_colorfmt = avio_rl24(pb);
93	mtv->img_bpp = get_byte(pb);	93	mtv->img_bpp = avio_r8(pb);
94	mtv->img_width = get_le16(pb);	94	mtv->img_width = avio_rl16(pb);
95	mtv->img_height = get_le16(pb);	95	mtv->img_height = avio_rl16(pb);
96	mtv->img_segment_size = get_le16(pb);	96	mtv->img_segment_size = avio_rl16(pb);
97		97
98	/* Calculate width and height if missing from header */	98	/* Calculate width and height if missing from header */
99		99
@@ -106,7 +106,7 @@ static int mtv_read_header(AVFormatContext s, AVFormatParameters ap) · 6 unmodified lines
106	/ mtv->img_width;	106	/ mtv->img_width;
107		107
108	url_fskip(pb, 4);	108	url_fskip(pb, 4);
109	audio_subsegments = get_le16(pb);	109	audio_subsegments = avio_rl16(pb);
110	mtv->full_segment_size =	110	mtv->full_segment_size =
111	audio_subsegments * (MTV_AUDIO_PADDING_SIZE + MTV_ASUBCHUNK_DATA_SIZE) +	111	audio_subsegments * (MTV_AUDIO_PADDING_SIZE + MTV_ASUBCHUNK_DATA_SIZE) +
112	mtv->img_segment_size;	112	mtv->img_segment_size;

libavformat/mvi.c+15−15

@@ -53,20 +53,20 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 52 unmodified lines
53	vst->codec->extradata_size = 2;	53	vst->codec->extradata_size = 2;
54	vst->codec->extradata = av_mallocz(2 + FF_INPUT_BUFFER_PADDING_SIZE);	54	vst->codec->extradata = av_mallocz(2 + FF_INPUT_BUFFER_PADDING_SIZE);
55		55
56	version = get_byte(pb);	56	version = avio_r8(pb);
57	vst->codec->extradata[0] = get_byte(pb);	57	vst->codec->extradata[0] = avio_r8(pb);
58	vst->codec->extradata[1] = get_byte(pb);	58	vst->codec->extradata[1] = avio_r8(pb);
59	frames_count = get_le32(pb);	59	frames_count = avio_rl32(pb);
60	msecs_per_frame = get_le32(pb);	60	msecs_per_frame = avio_rl32(pb);
61	vst->codec->width = get_le16(pb);	61	vst->codec->width = avio_rl16(pb);
62	vst->codec->height = get_le16(pb);	62	vst->codec->height = avio_rl16(pb);
63	get_byte(pb);	63	avio_r8(pb);
64	ast->codec->sample_rate = get_le16(pb);	64	ast->codec->sample_rate = avio_rl16(pb);
65	mvi->audio_data_size = get_le32(pb);	65	mvi->audio_data_size = avio_rl32(pb);
66	get_byte(pb);	66	avio_r8(pb);
67	player_version = get_le32(pb);	67	player_version = avio_rl32(pb);
68	get_le16(pb);	68	avio_rl16(pb);
69	get_byte(pb);	69	avio_r8(pb);
70		70
71	if (frames_count == 0 \|\| mvi->audio_data_size == 0)	71	if (frames_count == 0 \|\| mvi->audio_data_size == 0)
72	return AVERROR_INVALIDDATA;	72	return AVERROR_INVALIDDATA;
@@ -87,7 +87,7 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 14 unmodified lines
87	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;	87	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
88	vst->codec->codec_id = CODEC_ID_MOTIONPIXELS;	88	vst->codec->codec_id = CODEC_ID_MOTIONPIXELS;
89		89
90	mvi->get_int = (vst->codec->width * vst->codec->height < (1 << 16)) ? get_le16 : get_le24;	90	mvi->get_int = (vst->codec->width * vst->codec->height < (1 << 16)) ? avio_rl16 : avio_rl24;
91		91
92	mvi->audio_frame_size = ((uint64_t)mvi->audio_data_size << MVI_FRAC_BITS) / frames_count;	92	mvi->audio_frame_size = ((uint64_t)mvi->audio_data_size << MVI_FRAC_BITS) / frames_count;
93	mvi->audio_size_counter = (ast->codec->sample_rate * 830 / mvi->audio_frame_size - 1) * mvi->audio_frame_size;	93	mvi->audio_size_counter = (ast->codec->sample_rate * 830 / mvi->audio_frame_size - 1) * mvi->audio_frame_size;

libavformat/mxfdec.c+61−61

@@ -163,7 +163,7 @@ static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x · 162 unmodified lines
163		163
164	static int64_t klv_decode_ber_length(AVIOContext *pb)	164	static int64_t klv_decode_ber_length(AVIOContext *pb)
165	{	165	{
166	uint64_t size = get_byte(pb);	166	uint64_t size = avio_r8(pb);
167	if (size & 0x80) { /* long form */	167	if (size & 0x80) { /* long form */
168	int bytes_num = size & 0x7f;	168	int bytes_num = size & 0x7f;
169	/* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */	169	/* 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) · 1 unmodified line
171	return -1;	171	return -1;
172	size = 0;	172	size = 0;
173	while (bytes_num--)	173	while (bytes_num--)
174	size = size << 8 \| get_byte(pb);	174	size = size << 8 \| avio_r8(pb);
175	}	175	}
176	return size;	176	return size;
177	}	177	}
@@ -180,7 +180,7 @@ static int mxf_read_sync(AVIOContext pb, const uint8_t key, unsigned size) · 2 unmodified lines
180	{	180	{
181	int i, b;	181	int i, b;
182	for (i = 0; i < size && !url_feof(pb); i++) {	182	for (i = 0; i < size && !url_feof(pb); i++) {
183	b = get_byte(pb);	183	b = avio_r8(pb);
184	if (b == key[0])	184	if (b == key[0])
185	i = 0;	185	i = 0;
186	else if (b != key[i])	186	else if (b != key[i])
@@ -195,7 +195,7 @@ static int klv_read_packet(KLVPacket klv, AVIOContext pb) · 8 unmodified lines
195	return -1;	195	return -1;
196	klv->offset = url_ftell(pb) - 4;	196	klv->offset = url_ftell(pb) - 4;
197	memcpy(klv->key, mxf_klv_key, 4);	197	memcpy(klv->key, mxf_klv_key, 4);
198	get_buffer(pb, klv->key + 4, 12);	198	avio_read(pb, klv->key + 4, 12);
199	klv->length = klv_decode_ber_length(pb);	199	klv->length = klv_decode_ber_length(pb);
200	return klv->length == -1 ? -1 : 0;	200	return klv->length == -1 ? -1 : 0;
201	}	201	}
@@ -224,7 +224,7 @@ static int mxf_get_d10_aes3_packet(AVIOContext pb, AVStream st, AVPacket *pkt, · 22 unmodified lines
224	if (length > 61444) /* worst case PAL 1920 samples 8 channels */	224	if (length > 61444) /* worst case PAL 1920 samples 8 channels */
225	return -1;	225	return -1;
226	av_new_packet(pkt, length);	226	av_new_packet(pkt, length);
227	get_buffer(pb, pkt->data, length);	227	avio_read(pb, pkt->data, length);
228	data_ptr = pkt->data;	228	data_ptr = pkt->data;
229	end_ptr = pkt->data + length;	229	end_ptr = pkt->data + length;
230	buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */	230	buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
@@ -265,10 +265,10 @@ static int mxf_decrypt_triplet(AVFormatContext s, AVPacket pkt, KLVPacket *klv · 34 unmodified lines
265	url_fskip(pb, klv_decode_ber_length(pb));	265	url_fskip(pb, klv_decode_ber_length(pb));
266	// plaintext offset	266	// plaintext offset
267	klv_decode_ber_length(pb);	267	klv_decode_ber_length(pb);
268	plaintext_size = get_be64(pb);	268	plaintext_size = avio_rb64(pb);
269	// source klv key	269	// source klv key
270	klv_decode_ber_length(pb);	270	klv_decode_ber_length(pb);
271	get_buffer(pb, klv->key, 16);	271	avio_read(pb, klv->key, 16);
272	if (!IS_KLV_KEY(klv, mxf_essence_element_key))	272	if (!IS_KLV_KEY(klv, mxf_essence_element_key))
273	return -1;	273	return -1;
274	index = mxf_get_stream_index(s, klv);	274	index = mxf_get_stream_index(s, klv);
@@ -276,15 +276,15 @@ static int mxf_decrypt_triplet(AVFormatContext s, AVPacket pkt, KLVPacket *klv · 1 unmodified line
276	return -1;	276	return -1;
277	// source size	277	// source size
278	klv_decode_ber_length(pb);	278	klv_decode_ber_length(pb);
279	orig_size = get_be64(pb);	279	orig_size = avio_rb64(pb);
280	if (orig_size < plaintext_size)	280	if (orig_size < plaintext_size)
281	return -1;	281	return -1;
282	// enc. code	282	// enc. code
283	size = klv_decode_ber_length(pb);	283	size = klv_decode_ber_length(pb);
284	if (size < 32 \|\| size - 32 < orig_size)	284	if (size < 32 \|\| size - 32 < orig_size)
285	return -1;	285	return -1;
286	get_buffer(pb, ivec, 16);	286	avio_read(pb, ivec, 16);
287	get_buffer(pb, tmpbuf, 16);	287	avio_read(pb, tmpbuf, 16);
288	if (mxf->aesc)	288	if (mxf->aesc)
289	av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);	289	av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
290	if (memcmp(tmpbuf, checkv, 16))	290	if (memcmp(tmpbuf, checkv, 16))
@@ -347,8 +347,8 @@ static int mxf_read_packet(AVFormatContext s, AVPacket pkt) · 56 unmodified lines
347	static int mxf_read_primer_pack(void arg, AVIOContext pb, int tag, int size, UID uid)	347	static int mxf_read_primer_pack(void arg, AVIOContext pb, int tag, int size, UID uid)
348	{	348	{
349	MXFContext *mxf = arg;	349	MXFContext *mxf = arg;
350	int item_num = get_be32(pb);	350	int item_num = avio_rb32(pb);
351	int item_len = get_be32(pb);	351	int item_len = avio_rb32(pb);
352		352
353	if (item_len != 18) {	353	if (item_len != 18) {
354	av_log(mxf->fc, AV_LOG_ERROR, "unsupported primer pack item length\n");	354	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 · 5 unmodified lines
360	mxf->local_tags = av_malloc(item_num*item_len);	360	mxf->local_tags = av_malloc(item_num*item_len);
361	if (!mxf->local_tags)	361	if (!mxf->local_tags)
362	return -1;	362	return -1;
363	get_buffer(pb, mxf->local_tags, item_num*item_len);	363	avio_read(pb, mxf->local_tags, item_num*item_len);
364	return 0;	364	return 0;
365	}	365	}
366		366
@@ -382,7 +382,7 @@ static int mxf_read_cryptographic_context(void arg, AVIOContext pb, int tag, i · 15 unmodified lines
382	if (size != 16)	382	if (size != 16)
383	return -1;	383	return -1;
384	if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))	384	if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
385	get_buffer(pb, cryptocontext->source_container_ul, 16);	385	avio_read(pb, cryptocontext->source_container_ul, 16);
386	return 0;	386	return 0;
387	}	387	}
388		388
@@ -391,14 +391,14 @@ static int mxf_read_content_storage(void arg, AVIOContext pb, int tag, int siz · 2 unmodified lines
391	MXFContext *mxf = arg;	391	MXFContext *mxf = arg;
392	switch (tag) {	392	switch (tag) {
393	case 0x1901:	393	case 0x1901:
394	mxf->packages_count = get_be32(pb);	394	mxf->packages_count = avio_rb32(pb);
395	if (mxf->packages_count >= UINT_MAX / sizeof(UID))	395	if (mxf->packages_count >= UINT_MAX / sizeof(UID))
396	return -1;	396	return -1;
397	mxf->packages_refs = av_malloc(mxf->packages_count * sizeof(UID));	397	mxf->packages_refs = av_malloc(mxf->packages_count * sizeof(UID));
398	if (!mxf->packages_refs)	398	if (!mxf->packages_refs)
399	return -1;	399	return -1;
400	url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */	400	url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
401	get_buffer(pb, (uint8_t )mxf->packages_refs, mxf->packages_count sizeof(UID));	401	avio_read(pb, (uint8_t )mxf->packages_refs, mxf->packages_count sizeof(UID));
402	break;	402	break;
403	}	403	}
404	return 0;	404	return 0;
@@ -409,18 +409,18 @@ static int mxf_read_source_clip(void arg, AVIOContext pb, int tag, int size, U · 4 unmodified lines
409	MXFStructuralComponent *source_clip = arg;	409	MXFStructuralComponent *source_clip = arg;
410	switch(tag) {	410	switch(tag) {
411	case 0x0202:	411	case 0x0202:
412	source_clip->duration = get_be64(pb);	412	source_clip->duration = avio_rb64(pb);
413	break;	413	break;
414	case 0x1201:	414	case 0x1201:
415	source_clip->start_position = get_be64(pb);	415	source_clip->start_position = avio_rb64(pb);
416	break;	416	break;
417	case 0x1101:	417	case 0x1101:
418	/* UMID, only get last 16 bytes */	418	/* UMID, only get last 16 bytes */
419	url_fskip(pb, 16);	419	url_fskip(pb, 16);
420	get_buffer(pb, source_clip->source_package_uid, 16);	420	avio_read(pb, source_clip->source_package_uid, 16);
421	break;	421	break;
422	case 0x1102:	422	case 0x1102:
423	source_clip->source_track_id = get_be32(pb);	423	source_clip->source_track_id = avio_rb32(pb);
424	break;	424	break;
425	}	425	}
426	return 0;	426	return 0;
@@ -431,14 +431,14 @@ static int mxf_read_material_package(void arg, AVIOContext pb, int tag, int si · 4 unmodified lines
431	MXFPackage *package = arg;	431	MXFPackage *package = arg;
432	switch(tag) {	432	switch(tag) {
433	case 0x4403:	433	case 0x4403:
434	package->tracks_count = get_be32(pb);	434	package->tracks_count = avio_rb32(pb);
435	if (package->tracks_count >= UINT_MAX / sizeof(UID))	435	if (package->tracks_count >= UINT_MAX / sizeof(UID))
436	return -1;	436	return -1;
437	package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID));	437	package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID));
438	if (!package->tracks_refs)	438	if (!package->tracks_refs)
439	return -1;	439	return -1;
440	url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */	440	url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
441	get_buffer(pb, (uint8_t )package->tracks_refs, package->tracks_count sizeof(UID));	441	avio_read(pb, (uint8_t )package->tracks_refs, package->tracks_count sizeof(UID));
442	break;	442	break;
443	}	443	}
444	return 0;	444	return 0;
@@ -449,17 +449,17 @@ static int mxf_read_track(void arg, AVIOContext pb, int tag, int size, UID uid · 4 unmodified lines
449	MXFTrack *track = arg;	449	MXFTrack *track = arg;
450	switch(tag) {	450	switch(tag) {
451	case 0x4801:	451	case 0x4801:
452	track->track_id = get_be32(pb);	452	track->track_id = avio_rb32(pb);
453	break;	453	break;
454	case 0x4804:	454	case 0x4804:
455	get_buffer(pb, track->track_number, 4);	455	avio_read(pb, track->track_number, 4);
456	break;	456	break;
457	case 0x4B01:	457	case 0x4B01:
458	track->edit_rate.den = get_be32(pb);	458	track->edit_rate.den = avio_rb32(pb);
459	track->edit_rate.num = get_be32(pb);	459	track->edit_rate.num = avio_rb32(pb);
460	break;	460	break;
461	case 0x4803:	461	case 0x4803:
462	get_buffer(pb, track->sequence_ref, 16);	462	avio_read(pb, track->sequence_ref, 16);
463	break;	463	break;
464	}	464	}
465	return 0;	465	return 0;
@@ -470,20 +470,20 @@ static int mxf_read_sequence(void arg, AVIOContext pb, int tag, int size, UID · 4 unmodified lines
470	MXFSequence *sequence = arg;	470	MXFSequence *sequence = arg;
471	switch(tag) {	471	switch(tag) {
472	case 0x0202:	472	case 0x0202:
473	sequence->duration = get_be64(pb);	473	sequence->duration = avio_rb64(pb);
474	break;	474	break;
475	case 0x0201:	475	case 0x0201:
476	get_buffer(pb, sequence->data_definition_ul, 16);	476	avio_read(pb, sequence->data_definition_ul, 16);
477	break;	477	break;
478	case 0x1001:	478	case 0x1001:
479	sequence->structural_components_count = get_be32(pb);	479	sequence->structural_components_count = avio_rb32(pb);
480	if (sequence->structural_components_count >= UINT_MAX / sizeof(UID))	480	if (sequence->structural_components_count >= UINT_MAX / sizeof(UID))
481	return -1;	481	return -1;
482	sequence->structural_components_refs = av_malloc(sequence->structural_components_count * sizeof(UID));	482	sequence->structural_components_refs = av_malloc(sequence->structural_components_count * sizeof(UID));
483	if (!sequence->structural_components_refs)	483	if (!sequence->structural_components_refs)
484	return -1;	484	return -1;
485	url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */	485	url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
486	get_buffer(pb, (uint8_t )sequence->structural_components_refs, sequence->structural_components_count sizeof(UID));	486	avio_read(pb, (uint8_t )sequence->structural_components_refs, sequence->structural_components_count sizeof(UID));
487	break;	487	break;
488	}	488	}
489	return 0;	489	return 0;
@@ -494,22 +494,22 @@ static int mxf_read_source_package(void arg, AVIOContext pb, int tag, int size · 4 unmodified lines
494	MXFPackage *package = arg;	494	MXFPackage *package = arg;
495	switch(tag) {	495	switch(tag) {
496	case 0x4403:	496	case 0x4403:
497	package->tracks_count = get_be32(pb);	497	package->tracks_count = avio_rb32(pb);
498	if (package->tracks_count >= UINT_MAX / sizeof(UID))	498	if (package->tracks_count >= UINT_MAX / sizeof(UID))
499	return -1;	499	return -1;
500	package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID));	500	package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID));
501	if (!package->tracks_refs)	501	if (!package->tracks_refs)
502	return -1;	502	return -1;
503	url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */	503	url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
504	get_buffer(pb, (uint8_t )package->tracks_refs, package->tracks_count sizeof(UID));	504	avio_read(pb, (uint8_t )package->tracks_refs, package->tracks_count sizeof(UID));
505	break;	505	break;
506	case 0x4401:	506	case 0x4401:
507	/* UMID, only get last 16 bytes */	507	/* UMID, only get last 16 bytes */
508	url_fskip(pb, 16);	508	url_fskip(pb, 16);
509	get_buffer(pb, package->package_uid, 16);	509	avio_read(pb, package->package_uid, 16);
510	break;	510	break;
511	case 0x4701:	511	case 0x4701:
512	get_buffer(pb, package->descriptor_ref, 16);	512	avio_read(pb, package->descriptor_ref, 16);
513	break;	513	break;
514	}	514	}
515	return 0;	515	return 0;
@@ -518,12 +518,12 @@ static int mxf_read_source_package(void arg, AVIOContext pb, int tag, int size · 2 unmodified lines
518	static int mxf_read_index_table_segment(void arg, AVIOContext pb, int tag, int size, UID uid)	518	static int mxf_read_index_table_segment(void arg, AVIOContext pb, int tag, int size, UID uid)
519	{	519	{
520	switch(tag) {	520	switch(tag) {
521	case 0x3F05: av_dlog(NULL, "EditUnitByteCount %d\n", get_be32(pb)); break;	521	case 0x3F05: av_dlog(NULL, "EditUnitByteCount %d\n", avio_rb32(pb)); break;
522	case 0x3F06: av_dlog(NULL, "IndexSID %d\n", get_be32(pb)); break;	522	case 0x3F06: av_dlog(NULL, "IndexSID %d\n", avio_rb32(pb)); break;
523	case 0x3F07: av_dlog(NULL, "BodySID %d\n", get_be32(pb)); break;	523	case 0x3F07: av_dlog(NULL, "BodySID %d\n", avio_rb32(pb)); break;
524	case 0x3F0B: av_dlog(NULL, "IndexEditRate %d/%d\n", get_be32(pb), get_be32(pb)); break;	524	case 0x3F0B: av_dlog(NULL, "IndexEditRate %d/%d\n", avio_rb32(pb), avio_rb32(pb)); break;
525	case 0x3F0C: av_dlog(NULL, "IndexStartPosition %lld\n", get_be64(pb)); break;	525	case 0x3F0C: av_dlog(NULL, "IndexStartPosition %lld\n", avio_rb64(pb)); break;
526	case 0x3F0D: av_dlog(NULL, "IndexDuration %lld\n", get_be64(pb)); break;	526	case 0x3F0D: av_dlog(NULL, "IndexDuration %lld\n", avio_rb64(pb)); break;
527	}	527	}
528	return 0;	528	return 0;
529	}	529	}
@@ -534,8 +534,8 @@ static void mxf_read_pixel_layout(AVIOContext pb, MXFDescriptor descriptor) · 4 unmodified lines
534	char layout[16] = {0};	534	char layout[16] = {0};
535		535
536	do {	536	do {
537	code = get_byte(pb);	537	code = avio_r8(pb);
538	value = get_byte(pb);	538	value = avio_r8(pb);
539	av_dlog(NULL, "pixel layout: code %#x\n", code);	539	av_dlog(NULL, "pixel layout: code %#x\n", code);
540		540
541	if (ofs < 16) {	541	if (ofs < 16) {
@@ -552,46 +552,46 @@ static int mxf_read_generic_descriptor(void arg, AVIOContext pb, int tag, int · 10 unmodified lines
552	MXFDescriptor *descriptor = arg;	552	MXFDescriptor *descriptor = arg;
553	switch(tag) {	553	switch(tag) {
554	case 0x3F01:	554	case 0x3F01:
555	descriptor->sub_descriptors_count = get_be32(pb);	555	descriptor->sub_descriptors_count = avio_rb32(pb);
556	if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID))	556	if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID))
557	return -1;	557	return -1;
558	descriptor->sub_descriptors_refs = av_malloc(descriptor->sub_descriptors_count * sizeof(UID));	558	descriptor->sub_descriptors_refs = av_malloc(descriptor->sub_descriptors_count * sizeof(UID));
559	if (!descriptor->sub_descriptors_refs)	559	if (!descriptor->sub_descriptors_refs)
560	return -1;	560	return -1;
561	url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */	561	url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
562	get_buffer(pb, (uint8_t )descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count sizeof(UID));	562	avio_read(pb, (uint8_t )descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count sizeof(UID));
563	break;	563	break;
564	case 0x3004:	564	case 0x3004:
565	get_buffer(pb, descriptor->essence_container_ul, 16);	565	avio_read(pb, descriptor->essence_container_ul, 16);
566	break;	566	break;
567	case 0x3006:	567	case 0x3006:
568	descriptor->linked_track_id = get_be32(pb);	568	descriptor->linked_track_id = avio_rb32(pb);
569	break;	569	break;
570	case 0x3201: /* PictureEssenceCoding */	570	case 0x3201: /* PictureEssenceCoding */
571	get_buffer(pb, descriptor->essence_codec_ul, 16);	571	avio_read(pb, descriptor->essence_codec_ul, 16);
572	break;	572	break;
573	case 0x3203:	573	case 0x3203:
574	descriptor->width = get_be32(pb);	574	descriptor->width = avio_rb32(pb);
575	break;	575	break;
576	case 0x3202:	576	case 0x3202:
577	descriptor->height = get_be32(pb);	577	descriptor->height = avio_rb32(pb);
578	break;	578	break;
579	case 0x320E:	579	case 0x320E:
580	descriptor->aspect_ratio.num = get_be32(pb);	580	descriptor->aspect_ratio.num = avio_rb32(pb);
581	descriptor->aspect_ratio.den = get_be32(pb);	581	descriptor->aspect_ratio.den = avio_rb32(pb);
582	break;	582	break;
583	case 0x3D03:	583	case 0x3D03:
584	descriptor->sample_rate.num = get_be32(pb);	584	descriptor->sample_rate.num = avio_rb32(pb);
585	descriptor->sample_rate.den = get_be32(pb);	585	descriptor->sample_rate.den = avio_rb32(pb);
586	break;	586	break;
587	case 0x3D06: /* SoundEssenceCompression */	587	case 0x3D06: /* SoundEssenceCompression */
588	get_buffer(pb, descriptor->essence_codec_ul, 16);	588	avio_read(pb, descriptor->essence_codec_ul, 16);
589	break;	589	break;
590	case 0x3D07:	590	case 0x3D07:
591	descriptor->channels = get_be32(pb);	591	descriptor->channels = avio_rb32(pb);
592	break;	592	break;
593	case 0x3D01:	593	case 0x3D01:
594	descriptor->bits_per_sample = get_be32(pb);	594	descriptor->bits_per_sample = avio_rb32(pb);
595	break;	595	break;
596	case 0x3401:	596	case 0x3401:
597	mxf_read_pixel_layout(pb, descriptor);	597	mxf_read_pixel_layout(pb, descriptor);
@@ -603,7 +603,7 @@ static int mxf_read_generic_descriptor(void arg, AVIOContext pb, int tag, int · 5 unmodified lines
603	if (!descriptor->extradata)	603	if (!descriptor->extradata)
604	return -1;	604	return -1;
605	descriptor->extradata_size = size;	605	descriptor->extradata_size = size;
606	get_buffer(pb, descriptor->extradata, size);	606	avio_read(pb, descriptor->extradata, size);
607	}	607	}
608	break;	608	break;
609	}	609	}
@@ -871,8 +871,8 @@ static int mxf_read_local_tags(MXFContext mxf, KLVPacket klv, MXFMetadataReadF · 261 unmodified lines
871	if (!ctx)	871	if (!ctx)
872	return -1;	872	return -1;
873	while (url_ftell(pb) + 4 < klv_end) {	873	while (url_ftell(pb) + 4 < klv_end) {
874	int tag = get_be16(pb);	874	int tag = avio_rb16(pb);
875	int size = get_be16(pb); /* KLV specified by 0x53 */	875	int size = avio_rb16(pb); /* KLV specified by 0x53 */
876	uint64_t next = url_ftell(pb) + size;	876	uint64_t next = url_ftell(pb) + size;
877	UID uid = {0};	877	UID uid = {0};
878		878
@@ -893,7 +893,7 @@ static int mxf_read_local_tags(MXFContext mxf, KLVPacket klv, MXFMetadataReadF · 14 unmodified lines
893	}	893	}
894	}	894	}
895	if (ctx_size && tag == 0x3C0A)	895	if (ctx_size && tag == 0x3C0A)
896	get_buffer(pb, ctx->uid, 16);	896	avio_read(pb, ctx->uid, 16);
897	else if (read_child(ctx, pb, tag, size, uid) < 0)	897	else if (read_child(ctx, pb, tag, size, uid) < 0)
898	return -1;	898	return -1;
899		899

libavformat/mxg.c+1−1

@@ -115,7 +115,7 @@ static int mxg_update_cache(AVFormatContext *s, unsigned int cache_size) · 114 unmodified lines
115	if (mxg->soi_ptr) mxg->soi_ptr = mxg->buffer + soi_pos;	115	if (mxg->soi_ptr) mxg->soi_ptr = mxg->buffer + soi_pos;
116		116
117	/* get data */	117	/* get data */
118	ret = get_buffer(s->pb, mxg->buffer_ptr + mxg->cache_size,	118	ret = avio_read(s->pb, mxg->buffer_ptr + mxg->cache_size,
119	cache_size - mxg->cache_size);	119	cache_size - mxg->cache_size);
120	if (ret < 0)	120	if (ret < 0)
121	return ret;	121	return ret;

libavformat/ncdec.c+3−3

@@ -68,11 +68,11 @@ static int nc_read_packet(AVFormatContext s, AVPacket pkt) · 67 unmodified lines
68	while (state != NC_VIDEO_FLAG) {	68	while (state != NC_VIDEO_FLAG) {
69	if (url_feof(s->pb))	69	if (url_feof(s->pb))
70	return AVERROR(EIO);	70	return AVERROR(EIO);
71	state = (state<<8) + get_byte(s->pb);	71	state = (state<<8) + avio_r8(s->pb);
72	}	72	}
73		73
74	get_byte(s->pb);	74	avio_r8(s->pb);
75	size = get_le16(s->pb);	75	size = avio_rl16(s->pb);
76	url_fskip(s->pb, 9);	76	url_fskip(s->pb, 9);
77		77
78	if (size == 0) {	78	if (size == 0) {

libavformat/nsvdec.c+27−27

@@ -236,7 +236,7 @@ static int nsv_resync(AVFormatContext *s) · 235 unmodified lines
236	return -1;	236	return -1;
237	}	237	}
238	v <<= 8;	238	v <<= 8;
239	v \|= get_byte(pb);	239	v \|= avio_r8(pb);
240	if (i < 8) {	240	if (i < 8) {
241	av_dlog(s, "NSV resync: [%d] = %02x\n", i, v & 0x0FF);	241	av_dlog(s, "NSV resync: [%d] = %02x\n", i, v & 0x0FF);
242	}	242	}
@@ -277,23 +277,23 @@ static int nsv_parse_NSVf_header(AVFormatContext s, AVFormatParameters ap) · 34 unmodified lines
277		277
278	nsv->state = NSV_UNSYNC; /* in case we fail */	278	nsv->state = NSV_UNSYNC; /* in case we fail */
279		279
280	size = get_le32(pb);	280	size = avio_rl32(pb);
281	if (size < 28)	281	if (size < 28)
282	return -1;	282	return -1;
283	nsv->NSVf_end = size;	283	nsv->NSVf_end = size;
284		284
285	//s->file_size = (uint32_t)get_le32(pb);	285	//s->file_size = (uint32_t)avio_rl32(pb);
286	file_size = (uint32_t)get_le32(pb);	286	file_size = (uint32_t)avio_rl32(pb);
287	av_dlog(s, "NSV NSVf chunk_size %u\n", size);	287	av_dlog(s, "NSV NSVf chunk_size %u\n", size);
288	av_dlog(s, "NSV NSVf file_size %u\n", file_size);	288	av_dlog(s, "NSV NSVf file_size %u\n", file_size);
289		289
290	nsv->duration = duration = get_le32(pb); /* in ms */	290	nsv->duration = duration = avio_rl32(pb); /* in ms */
291	av_dlog(s, "NSV NSVf duration %"PRId64" ms\n", duration);	291	av_dlog(s, "NSV NSVf duration %"PRId64" ms\n", duration);
292	// XXX: store it in AVStreams	292	// XXX: store it in AVStreams
293		293
294	strings_size = get_le32(pb);	294	strings_size = avio_rl32(pb);
295	table_entries = get_le32(pb);	295	table_entries = avio_rl32(pb);
296	table_entries_used = get_le32(pb);	296	table_entries_used = avio_rl32(pb);
297	av_dlog(s, "NSV NSVf info-strings size: %d, table entries: %d, bis %d\n",	297	av_dlog(s, "NSV NSVf info-strings size: %d, table entries: %d, bis %d\n",
298	strings_size, table_entries, table_entries_used);	298	strings_size, table_entries, table_entries_used);
299	if (url_feof(pb))	299	if (url_feof(pb))
@@ -309,7 +309,7 @@ static int nsv_parse_NSVf_header(AVFormatContext s, AVFormatParameters ap) · 9 unmodified lines
309		309
310	p = strings = av_mallocz(strings_size + 1);	310	p = strings = av_mallocz(strings_size + 1);
311	endp = strings + strings_size;	311	endp = strings + strings_size;
312	get_buffer(pb, strings, strings_size);	312	avio_read(pb, strings, strings_size);
313	while (p < endp) {	313	while (p < endp) {
314	while (*p == ' ')	314	while (*p == ' ')
315	p++; /* strip out spaces */	315	p++; /* strip out spaces */
@@ -344,13 +344,13 @@ static int nsv_parse_NSVf_header(AVFormatContext s, AVFormatParameters ap) · 28 unmodified lines
344	nsv->nsvs_file_offset = av_malloc((unsigned)table_entries_used * sizeof(uint32_t));	344	nsv->nsvs_file_offset = av_malloc((unsigned)table_entries_used * sizeof(uint32_t));
345		345
346	for(i=0;i<table_entries_used;i++)	346	for(i=0;i<table_entries_used;i++)
347	nsv->nsvs_file_offset[i] = get_le32(pb) + size;	347	nsv->nsvs_file_offset[i] = avio_rl32(pb) + size;
348		348
349	if(table_entries > table_entries_used &&	349	if(table_entries > table_entries_used &&
350	get_le32(pb) == MKTAG('T','O','C','2')) {	350	avio_rl32(pb) == MKTAG('T','O','C','2')) {
351	nsv->nsvs_timestamps = av_malloc((unsigned)table_entries_used*sizeof(uint32_t));	351	nsv->nsvs_timestamps = av_malloc((unsigned)table_entries_used*sizeof(uint32_t));
352	for(i=0;i<table_entries_used;i++) {	352	for(i=0;i<table_entries_used;i++) {
353	nsv->nsvs_timestamps[i] = get_le32(pb);	353	nsv->nsvs_timestamps[i] = avio_rl32(pb);
354	}	354	}
355	}	355	}
356	}	356	}
@@ -365,7 +365,7 @@ static int nsv_parse_NSVf_header(AVFormatContext s, AVFormatParameters ap) · 8 unmodified lines
365	for (i = 0; i < table_entries; i++) {	365	for (i = 0; i < table_entries; i++) {
366	unsigned char b[8];	366	unsigned char b[8];
367	url_fseek(pb, size + nsv->nsvs_file_offset[i], SEEK_SET);	367	url_fseek(pb, size + nsv->nsvs_file_offset[i], SEEK_SET);
368	get_buffer(pb, b, 8);	368	avio_read(pb, b, 8);
369	av_dlog(s, "NSV [0x%08lx][0x%08lx]: %02x %02x %02x %02x %02x %02x %02x %02x"	369	av_dlog(s, "NSV [0x%08lx][0x%08lx]: %02x %02x %02x %02x %02x %02x %02x %02x"
370	"%c%c%c%c%c%c%c%c\n",	370	"%c%c%c%c%c%c%c%c\n",
371	nsv->nsvs_file_offset[i], size + nsv->nsvs_file_offset[i],	371	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) · 24 unmodified lines
396	NSVStream *nst;	396	NSVStream *nst;
397	av_dlog(s, "%s()\n", __FUNCTION__);	397	av_dlog(s, "%s()\n", __FUNCTION__);
398		398
399	vtag = get_le32(pb);	399	vtag = avio_rl32(pb);
400	atag = get_le32(pb);	400	atag = avio_rl32(pb);
401	vwidth = get_le16(pb);	401	vwidth = avio_rl16(pb);
402	vheight = get_le16(pb);	402	vheight = avio_rl16(pb);
403	i = get_byte(pb);	403	i = avio_r8(pb);
404		404
405	av_dlog(s, "NSV NSVs framerate code %2x\n", i);	405	av_dlog(s, "NSV NSVs framerate code %2x\n", i);
406	if(i&0x80) { /* odd way of giving native framerates from docs */	406	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) · 13 unmodified lines
420	else	420	else
421	framerate= (AVRational){i, 1};	421	framerate= (AVRational){i, 1};
422		422
423	nsv->avsync = get_le16(pb);	423	nsv->avsync = avio_rl16(pb);
424	nsv->framerate = framerate;	424	nsv->framerate = framerate;
425		425
426	print_tag("NSV NSVs vtag", vtag, 0);	426	print_tag("NSV NSVs vtag", vtag, 0);
@@ -568,16 +568,16 @@ null_chunk_retry: · 141 unmodified lines
568	if (nsv->state != NSV_HAS_READ_NSVS && nsv->state != NSV_FOUND_BEEF)	568	if (nsv->state != NSV_HAS_READ_NSVS && nsv->state != NSV_FOUND_BEEF)
569	return -1;	569	return -1;
570		570
571	auxcount = get_byte(pb);	571	auxcount = avio_r8(pb);
572	vsize = get_le16(pb);	572	vsize = avio_rl16(pb);
573	asize = get_le16(pb);	573	asize = avio_rl16(pb);
574	vsize = (vsize << 4) \| (auxcount >> 4);	574	vsize = (vsize << 4) \| (auxcount >> 4);
575	auxcount &= 0x0f;	575	auxcount &= 0x0f;
576	av_dlog(s, "NSV CHUNK %d aux, %u bytes video, %d bytes audio\n", auxcount, vsize, asize);	576	av_dlog(s, "NSV CHUNK %d aux, %u bytes video, %d bytes audio\n", auxcount, vsize, asize);
577	/* skip aux stuff */	577	/* skip aux stuff */
578	for (i = 0; i < auxcount; i++) {	578	for (i = 0; i < auxcount; i++) {
579	auxsize = get_le16(pb);	579	auxsize = avio_rl16(pb);
580	auxtag = get_le32(pb);	580	auxtag = avio_rl32(pb);
581	av_dlog(s, "NSV aux data: '%c%c%c%c', %d bytes\n",	581	av_dlog(s, "NSV aux data: '%c%c%c%c', %d bytes\n",
582	(auxtag & 0x0ff),	582	(auxtag & 0x0ff),
583	((auxtag >> 8) & 0x0ff),	583	((auxtag >> 8) & 0x0ff),
@@ -623,9 +623,9 @@ null_chunk_retry: · 39 unmodified lines
623	uint8_t bps;	623	uint8_t bps;
624	uint8_t channels;	624	uint8_t channels;
625	uint16_t samplerate;	625	uint16_t samplerate;
626	bps = get_byte(pb);	626	bps = avio_r8(pb);
627	channels = get_byte(pb);	627	channels = avio_r8(pb);
628	samplerate = get_le16(pb);	628	samplerate = avio_rl16(pb);
629	asize-=4;	629	asize-=4;
630	av_dlog(s, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate);	630	av_dlog(s, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate);
631	if (fill_header) {	631	if (fill_header) {

libavformat/nutdec.c+16−16

@@ -39,9 +39,9 @@ static int get_str(AVIOContext bc, char string, unsigned int maxlen){ · 38 unmodified lines
39	unsigned int len= ff_get_v(bc);	39	unsigned int len= ff_get_v(bc);
40		40
41	if(len && maxlen)	41	if(len && maxlen)
42	get_buffer(bc, string, FFMIN(len, maxlen));	42	avio_read(bc, string, FFMIN(len, maxlen));
43	while(len > maxlen){	43	while(len > maxlen){
44	get_byte(bc);	44	avio_r8(bc);
45	len--;	45	len--;
46	}	46	}
47		47
@@ -64,8 +64,8 @@ static int64_t get_s(AVIOContext *bc){ · 16 unmodified lines
64	static uint64_t get_fourcc(AVIOContext *bc){	64	static uint64_t get_fourcc(AVIOContext *bc){
65	unsigned int len= ff_get_v(bc);	65	unsigned int len= ff_get_v(bc);
66		66
67	if (len==2) return get_le16(bc);	67	if (len==2) return avio_rl16(bc);
68	else if(len==4) return get_le32(bc);	68	else if(len==4) return avio_rl32(bc);
69	else return -1;	69	else return -1;
70	}	70	}
71		71
@@ -106,7 +106,7 @@ static int get_packetheader(NUTContext nut, AVIOContext bc, int calculate_chec · 34 unmodified lines
106	init_checksum(bc, ff_crc04C11DB7_update, startcode);	106	init_checksum(bc, ff_crc04C11DB7_update, startcode);
107	size= ff_get_v(bc);	107	size= ff_get_v(bc);
108	if(size > 4096)	108	if(size > 4096)
109	get_be32(bc);	109	avio_rb32(bc);
110	if(get_checksum(bc) && size > 4096)	110	if(get_checksum(bc) && size > 4096)
111	return -1;	111	return -1;
112		112
@@ -122,7 +122,7 @@ static uint64_t find_any_startcode(AVIOContext *bc, int64_t pos){ · 9 unmodified lines
122	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	122	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
123		123
124	while(!url_feof(bc)){	124	while(!url_feof(bc)){
125	state= (state<<8) \| get_byte(bc);	125	state= (state<<8) \| avio_r8(bc);
126	if((state>>56) != 'N')	126	if((state>>56) != 'N')
127	continue;	127	continue;
128	switch(state){	128	switch(state){
@@ -182,7 +182,7 @@ static int skip_reserved(AVIOContext *bc, int64_t pos){ · 53 unmodified lines
182	return -1;	182	return -1;
183	}else{	183	}else{
184	while(pos--)	184	while(pos--)
185	get_byte(bc);	185	avio_r8(bc);
186	return 0;	186	return 0;
187	}	187	}
188	}	188	}
@@ -279,7 +279,7 @@ static int decode_main_header(NUTContext *nut){ · 90 unmodified lines
279	return AVERROR_INVALIDDATA;	279	return AVERROR_INVALIDDATA;
280	}	280	}
281	nut->header[i]= av_malloc(nut->header_len[i]);	281	nut->header[i]= av_malloc(nut->header_len[i]);
282	get_buffer(bc, nut->header[i], nut->header_len[i]);	282	avio_read(bc, nut->header[i], nut->header_len[i]);
283	}	283	}
284	assert(nut->header_len[0]==0);	284	assert(nut->header_len[0]==0);
285	}	285	}
@@ -355,7 +355,7 @@ static int decode_stream_header(NUTContext *nut){ · 69 unmodified lines
355	GET_V(st->codec->extradata_size, tmp < (1<<30));	355	GET_V(st->codec->extradata_size, tmp < (1<<30));
356	if(st->codec->extradata_size){	356	if(st->codec->extradata_size){
357	st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);	357	st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
358	get_buffer(bc, st->codec->extradata, st->codec->extradata_size);	358	avio_read(bc, st->codec->extradata, st->codec->extradata_size);
359	}	359	}
360		360
361	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO){	361	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
@@ -514,8 +514,8 @@ static int find_and_decode_index(NUTContext *nut){ · 152 unmodified lines
514	int ret= -1;	514	int ret= -1;
515		515
516	url_fseek(bc, filesize-12, SEEK_SET);	516	url_fseek(bc, filesize-12, SEEK_SET);
517	url_fseek(bc, filesize-get_be64(bc), SEEK_SET);	517	url_fseek(bc, filesize-avio_rb64(bc), SEEK_SET);
518	if(get_be64(bc) != INDEX_STARTCODE){	518	if(avio_rb64(bc) != INDEX_STARTCODE){
519	av_log(s, AV_LOG_ERROR, "no index at the end\n");	519	av_log(s, AV_LOG_ERROR, "no index at the end\n");
520	return -1;	520	return -1;
521	}	521	}
@@ -722,7 +722,7 @@ static int decode_frame_header(NUTContext nut, int64_t pts, int *stream_id, ui · 200 unmodified lines
722	size -= nut->header_len[*header_idx];	722	size -= nut->header_len[*header_idx];
723		723
724	if(flags&FLAG_CHECKSUM){	724	if(flags&FLAG_CHECKSUM){
725	get_be32(bc); //FIXME check this	725	avio_rb32(bc); //FIXME check this
726	}else if(size > 2nut->max_distance \|\| FFABS(stc->last_pts - pts) > stc->max_pts_distance){	726	}else if(size > 2nut->max_distance \|\| FFABS(stc->last_pts - pts) > stc->max_pts_distance){
727	av_log(s, AV_LOG_ERROR, "frame size > 2max_distance and no checksum\n");	727	av_log(s, AV_LOG_ERROR, "frame size > 2max_distance and no checksum\n");
728	return AVERROR_INVALIDDATA;	728	return AVERROR_INVALIDDATA;
@@ -764,7 +764,7 @@ static int decode_frame(NUTContext nut, AVPacket pkt, int frame_code){ · 35 unmodified lines
764	av_new_packet(pkt, size + nut->header_len[header_idx]);	764	av_new_packet(pkt, size + nut->header_len[header_idx]);
765	memcpy(pkt->data, nut->header[header_idx], nut->header_len[header_idx]);	765	memcpy(pkt->data, nut->header[header_idx], nut->header_len[header_idx]);
766	pkt->pos= url_ftell(bc); //FIXME	766	pkt->pos= url_ftell(bc); //FIXME
767	get_buffer(bc, pkt->data + nut->header_len[header_idx], size);	767	avio_read(bc, pkt->data + nut->header_len[header_idx], size);
768		768
769	pkt->stream_index = stream_id;	769	pkt->stream_index = stream_id;
770	if (stc->last_flags & FLAG_KEY)	770	if (stc->last_flags & FLAG_KEY)
@@ -789,13 +789,13 @@ static int nut_read_packet(AVFormatContext s, AVPacket pkt) · 18 unmodified lines
789	if(tmp){	789	if(tmp){
790	pos-=8;	790	pos-=8;
791	}else{	791	}else{
792	frame_code = get_byte(bc);	792	frame_code = avio_r8(bc);
793	if(url_feof(bc))	793	if(url_feof(bc))
794	return -1;	794	return -1;
795	if(frame_code == 'N'){	795	if(frame_code == 'N'){
796	tmp= frame_code;	796	tmp= frame_code;
797	for(i=1; i<8; i++)	797	for(i=1; i<8; i++)
798	tmp = (tmp<<8) + get_byte(bc);	798	tmp = (tmp<<8) + avio_r8(bc);
799	}	799	}
800	}	800	}
801	switch(tmp){	801	switch(tmp){
@@ -812,7 +812,7 @@ static int nut_read_packet(AVFormatContext s, AVPacket pkt) · 10 unmodified lines
812	case SYNCPOINT_STARTCODE:	812	case SYNCPOINT_STARTCODE:
813	if(decode_syncpoint(nut, &ts, &back_ptr)<0)	813	if(decode_syncpoint(nut, &ts, &back_ptr)<0)
814	goto resync;	814	goto resync;
815	frame_code = get_byte(bc);	815	frame_code = avio_r8(bc);
816	case 0:	816	case 0:
817	ret= decode_frame(nut, pkt, frame_code);	817	ret= decode_frame(nut, pkt, frame_code);
818	if(ret==0)	818	if(ret==0)

libavformat/nuv.c+26−26

@@ -62,16 +62,16 @@ static int get_codec_data(AVIOContext pb, AVStream vst, · 61 unmodified lines
62	return 1; // no codec data needed	62	return 1; // no codec data needed
63	while (!url_feof(pb)) {	63	while (!url_feof(pb)) {
64	int size, subtype;	64	int size, subtype;
65	frametype = get_byte(pb);	65	frametype = avio_r8(pb);
66	switch (frametype) {	66	switch (frametype) {
67	case NUV_EXTRADATA:	67	case NUV_EXTRADATA:
68	subtype = get_byte(pb);	68	subtype = avio_r8(pb);
69	url_fskip(pb, 6);	69	url_fskip(pb, 6);
70	size = PKTSIZE(get_le32(pb));	70	size = PKTSIZE(avio_rl32(pb));
71	if (vst && subtype == 'R') {	71	if (vst && subtype == 'R') {
72	vst->codec->extradata_size = size;	72	vst->codec->extradata_size = size;
73	vst->codec->extradata = av_malloc(size);	73	vst->codec->extradata = av_malloc(size);
74	get_buffer(pb, vst->codec->extradata, size);	74	avio_read(pb, vst->codec->extradata, size);
75	size = 0;	75	size = 0;
76	if (!myth)	76	if (!myth)
77	return 1;	77	return 1;
@@ -79,12 +79,12 @@ static int get_codec_data(AVIOContext pb, AVStream vst, · 1 unmodified line
79	break;	79	break;
80	case NUV_MYTHEXT:	80	case NUV_MYTHEXT:
81	url_fskip(pb, 7);	81	url_fskip(pb, 7);
82	size = PKTSIZE(get_le32(pb));	82	size = PKTSIZE(avio_rl32(pb));
83	if (size != 128 * 4)	83	if (size != 128 * 4)
84	break;	84	break;
85	get_le32(pb); // version	85	avio_rl32(pb); // version
86	if (vst) {	86	if (vst) {
87	vst->codec->codec_tag = get_le32(pb);	87	vst->codec->codec_tag = avio_rl32(pb);
88	vst->codec->codec_id =	88	vst->codec->codec_id =
89	ff_codec_get_id(ff_codec_bmp_tags, vst->codec->codec_tag);	89	ff_codec_get_id(ff_codec_bmp_tags, vst->codec->codec_tag);
90	if (vst->codec->codec_tag == MKTAG('R', 'J', 'P', 'G'))	90	if (vst->codec->codec_tag == MKTAG('R', 'J', 'P', 'G'))
@@ -93,10 +93,10 @@ static int get_codec_data(AVIOContext pb, AVStream vst, · 2 unmodified lines
93	url_fskip(pb, 4);	93	url_fskip(pb, 4);
94		94
95	if (ast) {	95	if (ast) {
96	ast->codec->codec_tag = get_le32(pb);	96	ast->codec->codec_tag = avio_rl32(pb);
97	ast->codec->sample_rate = get_le32(pb);	97	ast->codec->sample_rate = avio_rl32(pb);
98	ast->codec->bits_per_coded_sample = get_le32(pb);	98	ast->codec->bits_per_coded_sample = avio_rl32(pb);
99	ast->codec->channels = get_le32(pb);	99	ast->codec->channels = avio_rl32(pb);
100	ast->codec->codec_id =	100	ast->codec->codec_id =
101	ff_wav_codec_get_id(ast->codec->codec_tag,	101	ff_wav_codec_get_id(ast->codec->codec_tag,
102	ast->codec->bits_per_coded_sample);	102	ast->codec->bits_per_coded_sample);
@@ -112,7 +112,7 @@ static int get_codec_data(AVIOContext pb, AVStream vst, · 9 unmodified lines
112	break;	112	break;
113	default:	113	default:
114	url_fskip(pb, 7);	114	url_fskip(pb, 7);
115	size = PKTSIZE(get_le32(pb));	115	size = PKTSIZE(avio_rl32(pb));
116	break;	116	break;
117	}	117	}
118	url_fskip(pb, size);	118	url_fskip(pb, size);
@@ -128,27 +128,27 @@ static int nuv_header(AVFormatContext s, AVFormatParameters ap) { · 9 unmodified lines
128	int is_mythtv, width, height, v_packs, a_packs;	128	int is_mythtv, width, height, v_packs, a_packs;
129	int stream_nr = 0;	129	int stream_nr = 0;
130	AVStream vst = NULL, ast = NULL;	130	AVStream vst = NULL, ast = NULL;
131	get_buffer(pb, id_string, 12);	131	avio_read(pb, id_string, 12);
132	is_mythtv = !memcmp(id_string, "MythTVVideo", 12);	132	is_mythtv = !memcmp(id_string, "MythTVVideo", 12);
133	url_fskip(pb, 5); // version string	133	url_fskip(pb, 5); // version string
134	url_fskip(pb, 3); // padding	134	url_fskip(pb, 3); // padding
135	width = get_le32(pb);	135	width = avio_rl32(pb);
136	height = get_le32(pb);	136	height = avio_rl32(pb);
137	get_le32(pb); // unused, "desiredwidth"	137	avio_rl32(pb); // unused, "desiredwidth"
138	get_le32(pb); // unused, "desiredheight"	138	avio_rl32(pb); // unused, "desiredheight"
139	get_byte(pb); // 'P' == progressive, 'I' == interlaced	139	avio_r8(pb); // 'P' == progressive, 'I' == interlaced
140	url_fskip(pb, 3); // padding	140	url_fskip(pb, 3); // padding
141	aspect = av_int2dbl(get_le64(pb));	141	aspect = av_int2dbl(avio_rl64(pb));
142	if (aspect > 0.9999 && aspect < 1.0001)	142	if (aspect > 0.9999 && aspect < 1.0001)
143	aspect = 4.0 / 3.0;	143	aspect = 4.0 / 3.0;
144	fps = av_int2dbl(get_le64(pb));	144	fps = av_int2dbl(avio_rl64(pb));
145		145
146	// number of packets per stream type, -1 means unknown, e.g. streaming	146	// number of packets per stream type, -1 means unknown, e.g. streaming
147	v_packs = get_le32(pb);	147	v_packs = avio_rl32(pb);
148	a_packs = get_le32(pb);	148	a_packs = avio_rl32(pb);
149	get_le32(pb); // text	149	avio_rl32(pb); // text
150		150
151	get_le32(pb); // keyframe distance (?)	151	avio_rl32(pb); // keyframe distance (?)
152		152
153	if (v_packs) {	153	if (v_packs) {
154	ctx->v_id = stream_nr++;	154	ctx->v_id = stream_nr++;
@@ -198,7 +198,7 @@ static int nuv_packet(AVFormatContext s, AVPacket pkt) { · 43 unmodified lines
198	while (!url_feof(pb)) {	198	while (!url_feof(pb)) {
199	int copyhdrsize = ctx->rtjpg_video ? HDRSIZE : 0;	199	int copyhdrsize = ctx->rtjpg_video ? HDRSIZE : 0;
200	uint64_t pos = url_ftell(pb);	200	uint64_t pos = url_ftell(pb);
201	ret = get_buffer(pb, hdr, HDRSIZE);	201	ret = avio_read(pb, hdr, HDRSIZE);
202	if (ret < HDRSIZE)	202	if (ret < HDRSIZE)
203	return ret < 0 ? ret : AVERROR(EIO);	203	return ret < 0 ? ret : AVERROR(EIO);
204	frametype = hdr[0];	204	frametype = hdr[0];
@@ -225,7 +225,7 @@ static int nuv_packet(AVFormatContext s, AVPacket pkt) { · 20 unmodified lines
225	pkt->pts = AV_RL32(&hdr[4]);	225	pkt->pts = AV_RL32(&hdr[4]);
226	pkt->stream_index = ctx->v_id;	226	pkt->stream_index = ctx->v_id;
227	memcpy(pkt->data, hdr, copyhdrsize);	227	memcpy(pkt->data, hdr, copyhdrsize);
228	ret = get_buffer(pb, pkt->data + copyhdrsize, size);	228	ret = avio_read(pb, pkt->data + copyhdrsize, size);
229	if (ret < 0) {	229	if (ret < 0) {
230	av_free_packet(pkt);	230	av_free_packet(pkt);
231	return ret;	231	return ret;

libavformat/oggdec.c+7−7

@@ -207,7 +207,7 @@ ogg_read_page (AVFormatContext * s, int *str) · 206 unmodified lines
207	uint8_t sync[4];	207	uint8_t sync[4];
208	int sp = 0;	208	int sp = 0;
209		209
210	if (get_buffer (bc, sync, 4) < 4)	210	if (avio_read (bc, sync, 4) < 4)
211	return -1;	211	return -1;
212		212
213	do{	213	do{
@@ -233,10 +233,10 @@ ogg_read_page (AVFormatContext * s, int *str) · 19 unmodified lines
233	return -1;	233	return -1;
234		234
235	flags = url_fgetc (bc);	235	flags = url_fgetc (bc);
236	gp = get_le64 (bc);	236	gp = avio_rl64 (bc);
237	serial = get_le32 (bc);	237	serial = avio_rl32 (bc);
238	seq = get_le32 (bc);	238	seq = avio_rl32 (bc);
239	crc = get_le32 (bc);	239	crc = avio_rl32 (bc);
240	nsegs = url_fgetc (bc);	240	nsegs = url_fgetc (bc);
241		241
242	idx = ogg_find_stream (ogg, serial);	242	idx = ogg_find_stream (ogg, serial);
@@ -252,7 +252,7 @@ ogg_read_page (AVFormatContext * s, int *str) · 9 unmodified lines
252	if(os->psize > 0)	252	if(os->psize > 0)
253	ogg_new_buf(ogg, idx);	253	ogg_new_buf(ogg, idx);
254		254
255	if (get_buffer (bc, os->segments, nsegs) < nsegs)	255	if (avio_read (bc, os->segments, nsegs) < nsegs)
256	return -1;	256	return -1;
257		257
258	os->nsegs = nsegs;	258	os->nsegs = nsegs;
@@ -284,7 +284,7 @@ ogg_read_page (AVFormatContext * s, int *str) · 25 unmodified lines
284	os->buf = nb;	284	os->buf = nb;
285	}	285	}
286		286
287	if (get_buffer (bc, os->buf + os->bufpos, size) < size)	287	if (avio_read (bc, os->buf + os->bufpos, size) < size)
288	return -1;	288	return -1;
289		289
290	os->bufpos += size;	290	os->bufpos += size;

libavformat/oma.c+1−1

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

libavformat/psxstr.c+2−2

@@ -105,7 +105,7 @@ static int str_read_header(AVFormatContext *s, · 104 unmodified lines
105	int i;	105	int i;
106		106
107	/* skip over any RIFF header */	107	/* skip over any RIFF header */
108	if (get_buffer(pb, sector, RIFF_HEADER_SIZE) != RIFF_HEADER_SIZE)	108	if (avio_read(pb, sector, RIFF_HEADER_SIZE) != RIFF_HEADER_SIZE)
109	return AVERROR(EIO);	109	return AVERROR(EIO);
110	if (AV_RL32(&sector[0]) == RIFF_TAG)	110	if (AV_RL32(&sector[0]) == RIFF_TAG)
111	start = RIFF_HEADER_SIZE;	111	start = RIFF_HEADER_SIZE;
@@ -136,7 +136,7 @@ static int str_read_packet(AVFormatContext *s, · 24 unmodified lines
136		136
137	while (1) {	137	while (1) {
138		138
139	if (get_buffer(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)	139	if (avio_read(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)
140	return AVERROR(EIO);	140	return AVERROR(EIO);
141		141
142	channel = sector[0x11];	142	channel = sector[0x11];

libavformat/pva.c+13−13

@@ -75,12 +75,12 @@ static int read_part_of_packet(AVFormatContext s, int64_t pts, · 74 unmodified lines
75	recover:	75	recover:
76	startpos = url_ftell(pb);	76	startpos = url_ftell(pb);
77		77
78	syncword = get_be16(pb);	78	syncword = avio_rb16(pb);
79	streamid = get_byte(pb);	79	streamid = avio_r8(pb);
80	get_byte(pb); /* counter not used */	80	avio_r8(pb); /* counter not used */
81	reserved = get_byte(pb);	81	reserved = avio_r8(pb);
82	flags = get_byte(pb);	82	flags = avio_r8(pb);
83	length = get_be16(pb);	83	length = avio_rb16(pb);
84		84
85	pts_flag = flags & 0x10;	85	pts_flag = flags & 0x10;
86		86
@@ -101,7 +101,7 @@ recover: · 14 unmodified lines
101	}	101	}
102		102
103	if (streamid == PVA_VIDEO_PAYLOAD && pts_flag) {	103	if (streamid == PVA_VIDEO_PAYLOAD && pts_flag) {
104	pva_pts = get_be32(pb);	104	pva_pts = avio_rb32(pb);
105	length -= 4;	105	length -= 4;
106	} else if (streamid == PVA_AUDIO_PAYLOAD) {	106	} else if (streamid == PVA_AUDIO_PAYLOAD) {
107	/* PVA Audio Packets either start with a signaled PES packet or	107	/* PVA Audio Packets either start with a signaled PES packet or
@@ -113,11 +113,11 @@ recover: · 5 unmodified lines
113	pes_flags;	113	pes_flags;
114	unsigned char pes_header_data[256];	114	unsigned char pes_header_data[256];
115		115
116	pes_signal = get_be24(pb);	116	pes_signal = avio_rb24(pb);
117	get_byte(pb);	117	avio_r8(pb);
118	pes_packet_length = get_be16(pb);	118	pes_packet_length = avio_rb16(pb);
119	pes_flags = get_be16(pb);	119	pes_flags = avio_rb16(pb);
120	pes_header_data_length = get_byte(pb);	120	pes_header_data_length = avio_r8(pb);
121		121
122	if (pes_signal != 1) {	122	if (pes_signal != 1) {
123	pva_log(s, AV_LOG_WARNING, "expected signaled PES packet, "	123	pva_log(s, AV_LOG_WARNING, "expected signaled PES packet, "
@@ -128,7 +128,7 @@ recover: · 4 unmodified lines
128	goto recover;	128	goto recover;
129	}	129	}
130		130
131	get_buffer(pb, pes_header_data, pes_header_data_length);	131	avio_read(pb, pes_header_data, pes_header_data_length);
132	length -= 9 + pes_header_data_length;	132	length -= 9 + pes_header_data_length;
133		133
134	pes_packet_length -= 3 + pes_header_data_length;	134	pes_packet_length -= 3 + pes_header_data_length;

libavformat/qcp.c+14−14

@@ -91,13 +91,13 @@ static int qcp_read_header(AVFormatContext s, AVFormatParameters ap) · 90 unmodified lines
91	if (!st)	91	if (!st)
92	return AVERROR(ENOMEM);	92	return AVERROR(ENOMEM);
93		93
94	get_be32(pb); // "RIFF"	94	avio_rb32(pb); // "RIFF"
95	s->file_size = get_le32(pb) + 8;	95	s->file_size = avio_rl32(pb) + 8;
96	url_fskip(pb, 8 + 4 + 1 + 1); // "QLCMfmt " + chunk-size + major-version + minor-version	96	url_fskip(pb, 8 + 4 + 1 + 1); // "QLCMfmt " + chunk-size + major-version + minor-version
97		97
98	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;	98	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
99	st->codec->channels = 1;	99	st->codec->channels = 1;
100	get_buffer(pb, buf, 16);	100	avio_read(pb, buf, 16);
101	if (is_qcelp_13k_guid(buf)) {	101	if (is_qcelp_13k_guid(buf)) {
102	st->codec->codec_id = CODEC_ID_QCELP;	102	st->codec->codec_id = CODEC_ID_QCELP;
103	} else if (!memcmp(buf, guid_evrc, 16)) {	103	} else if (!memcmp(buf, guid_evrc, 16)) {
@@ -111,19 +111,19 @@ static int qcp_read_header(AVFormatContext s, AVFormatParameters ap) · 7 unmodified lines
111	return AVERROR_INVALIDDATA;	111	return AVERROR_INVALIDDATA;
112	}	112	}
113	url_fskip(pb, 2 + 80); // codec-version + codec-name	113	url_fskip(pb, 2 + 80); // codec-version + codec-name
114	st->codec->bit_rate = get_le16(pb);	114	st->codec->bit_rate = avio_rl16(pb);
115		115
116	s->packet_size = get_le16(pb);	116	s->packet_size = avio_rl16(pb);
117	url_fskip(pb, 2); // block-size	117	url_fskip(pb, 2); // block-size
118	st->codec->sample_rate = get_le16(pb);	118	st->codec->sample_rate = avio_rl16(pb);
119	url_fskip(pb, 2); // sample-size	119	url_fskip(pb, 2); // sample-size
120		120
121	memset(c->rates_per_mode, -1, sizeof(c->rates_per_mode));	121	memset(c->rates_per_mode, -1, sizeof(c->rates_per_mode));
122	nb_rates = get_le32(pb);	122	nb_rates = avio_rl32(pb);
123	nb_rates = FFMIN(nb_rates, 8);	123	nb_rates = FFMIN(nb_rates, 8);
124	for (i=0; i<nb_rates; i++) {	124	for (i=0; i<nb_rates; i++) {
125	int size = get_byte(pb);	125	int size = avio_r8(pb);
126	int mode = get_byte(pb);	126	int mode = avio_r8(pb);
127	if (mode > QCP_MAX_MODE) {	127	if (mode > QCP_MAX_MODE) {
128	av_log(s, AV_LOG_WARNING, "Unknown entry %d=>%d in rate-map-table.\n ", mode, size);	128	av_log(s, AV_LOG_WARNING, "Unknown entry %d=>%d in rate-map-table.\n ", mode, size);
129	} else	129	} else
@@ -142,7 +142,7 @@ static int qcp_read_packet(AVFormatContext s, AVPacket pkt) · 12 unmodified lines
142		142
143	while(!url_feof(pb)) {	143	while(!url_feof(pb)) {
144	if (c->data_size) {	144	if (c->data_size) {
145	int pkt_size, ret, mode = get_byte(pb);	145	int pkt_size, ret, mode = avio_r8(pb);
146		146
147	if (s->packet_size) {	147	if (s->packet_size) {
148	pkt_size = s->packet_size - 1;	148	pkt_size = s->packet_size - 1;
@@ -165,14 +165,14 @@ static int qcp_read_packet(AVFormatContext s, AVPacket pkt) · 16 unmodified lines
165	return ret;	165	return ret;
166	}	166	}
167		167
168	if (url_ftell(pb) & 1 && get_byte(pb))	168	if (url_ftell(pb) & 1 && avio_r8(pb))
169	av_log(s, AV_LOG_WARNING, "Padding should be 0.\n");	169	av_log(s, AV_LOG_WARNING, "Padding should be 0.\n");
170		170
171	tag = get_le32(pb);	171	tag = avio_rl32(pb);
172	chunk_size = get_le32(pb);	172	chunk_size = avio_rl32(pb);
173	switch (tag) {	173	switch (tag) {
174	case MKTAG('v', 'r', 'a', 't'):	174	case MKTAG('v', 'r', 'a', 't'):
175	if (get_le32(pb)) // var-rate-flag	175	if (avio_rl32(pb)) // var-rate-flag
176	s->packet_size = 0;	176	s->packet_size = 0;
177	url_fskip(pb, 4); // size-in-packets	177	url_fskip(pb, 4); // size-in-packets
178	break;	178	break;

libavformat/r3d.c+39−39

@@ -39,10 +39,10 @@ typedef struct { · 38 unmodified lines
39	static int read_atom(AVFormatContext s, Atom atom)	39	static int read_atom(AVFormatContext s, Atom atom)
40	{	40	{
41	atom->offset = url_ftell(s->pb);	41	atom->offset = url_ftell(s->pb);
42	atom->size = get_be32(s->pb);	42	atom->size = avio_rb32(s->pb);
43	if (atom->size < 8)	43	if (atom->size < 8)
44	return -1;	44	return -1;
45	atom->tag = get_le32(s->pb);	45	atom->tag = avio_rl32(s->pb);
46	av_dlog(s, "atom %d %.4s offset %#llx\n",	46	av_dlog(s, "atom %d %.4s offset %#llx\n",
47	atom->size, (char*)&atom->tag, atom->offset);	47	atom->size, (char*)&atom->tag, atom->offset);
48	return atom->size;	48	return atom->size;
@@ -59,31 +59,31 @@ static int r3d_read_red1(AVFormatContext *s) · 10 unmodified lines
59	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;	59	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
60	st->codec->codec_id = CODEC_ID_JPEG2000;	60	st->codec->codec_id = CODEC_ID_JPEG2000;
61		61
62	tmp = get_byte(s->pb); // major version	62	tmp = avio_r8(s->pb); // major version
63	tmp2 = get_byte(s->pb); // minor version	63	tmp2 = avio_r8(s->pb); // minor version
64	av_dlog(s, "version %d.%d\n", tmp, tmp2);	64	av_dlog(s, "version %d.%d\n", tmp, tmp2);
65		65
66	tmp = get_be16(s->pb); // unknown	66	tmp = avio_rb16(s->pb); // unknown
67	av_dlog(s, "unknown1 %d\n", tmp);	67	av_dlog(s, "unknown1 %d\n", tmp);
68		68
69	tmp = get_be32(s->pb);	69	tmp = avio_rb32(s->pb);
70	av_set_pts_info(st, 32, 1, tmp);	70	av_set_pts_info(st, 32, 1, tmp);
71		71
72	tmp = get_be32(s->pb); // filenum	72	tmp = avio_rb32(s->pb); // filenum
73	av_dlog(s, "filenum %d\n", tmp);	73	av_dlog(s, "filenum %d\n", tmp);
74		74
75	url_fskip(s->pb, 32); // unknown	75	url_fskip(s->pb, 32); // unknown
76		76
77	st->codec->width = get_be32(s->pb);	77	st->codec->width = avio_rb32(s->pb);
78	st->codec->height = get_be32(s->pb);	78	st->codec->height = avio_rb32(s->pb);
79		79
80	tmp = get_be16(s->pb); // unknown	80	tmp = avio_rb16(s->pb); // unknown
81	av_dlog(s, "unknown2 %d\n", tmp);	81	av_dlog(s, "unknown2 %d\n", tmp);
82		82
83	st->codec->time_base.den = get_be16(s->pb);	83	st->codec->time_base.den = avio_rb16(s->pb);
84	st->codec->time_base.num = get_be16(s->pb);	84	st->codec->time_base.num = avio_rb16(s->pb);
85		85
86	tmp = get_byte(s->pb); // audio channels	86	tmp = avio_r8(s->pb); // audio channels
87	av_dlog(s, "audio channels %d\n", tmp);	87	av_dlog(s, "audio channels %d\n", tmp);
88	if (tmp > 0) {	88	if (tmp > 0) {
89	AVStream *ast = av_new_stream(s, 1);	89	AVStream *ast = av_new_stream(s, 1);
@@ -95,7 +95,7 @@ static int r3d_read_red1(AVFormatContext *s) · 5 unmodified lines
95	av_set_pts_info(ast, 32, 1, st->time_base.den);	95	av_set_pts_info(ast, 32, 1, st->time_base.den);
96	}	96	}
97		97
98	get_buffer(s->pb, filename, 257);	98	avio_read(s->pb, filename, 257);
99	filename[sizeof(filename)-1] = 0;	99	filename[sizeof(filename)-1] = 0;
100	av_metadata_set2(&st->metadata, "filename", filename, 0);	100	av_metadata_set2(&st->metadata, "filename", filename, 0);
101		101
@@ -120,7 +120,7 @@ static int r3d_read_rdvo(AVFormatContext s, Atom atom) · 18 unmodified lines
120	return AVERROR(ENOMEM);	120	return AVERROR(ENOMEM);
121		121
122	for (i = 0; i < r3d->video_offsets_count; i++) {	122	for (i = 0; i < r3d->video_offsets_count; i++) {
123	r3d->video_offsets[i] = get_be32(s->pb);	123	r3d->video_offsets[i] = avio_rb32(s->pb);
124	if (!r3d->video_offsets[i]) {	124	if (!r3d->video_offsets[i]) {
125	r3d->video_offsets_count = i;	125	r3d->video_offsets_count = i;
126	break;	126	break;
@@ -141,15 +141,15 @@ static void r3d_read_reos(AVFormatContext *s) · 14 unmodified lines
141	R3DContext *r3d = s->priv_data;	141	R3DContext *r3d = s->priv_data;
142	int tmp;	142	int tmp;
143		143
144	r3d->rdvo_offset = get_be32(s->pb);	144	r3d->rdvo_offset = avio_rb32(s->pb);
145	get_be32(s->pb); // rdvs offset	145	avio_rb32(s->pb); // rdvs offset
146	get_be32(s->pb); // rdao offset	146	avio_rb32(s->pb); // rdao offset
147	get_be32(s->pb); // rdas offset	147	avio_rb32(s->pb); // rdas offset
148		148
149	tmp = get_be32(s->pb);	149	tmp = avio_rb32(s->pb);
150	av_dlog(s, "num video chunks %d\n", tmp);	150	av_dlog(s, "num video chunks %d\n", tmp);
151		151
152	tmp = get_be32(s->pb);	152	tmp = avio_rb32(s->pb);
153	av_dlog(s, "num audio chunks %d\n", tmp);	153	av_dlog(s, "num audio chunks %d\n", tmp);
154		154
155	url_fskip(s->pb, 6*4);	155	url_fskip(s->pb, 6*4);
@@ -214,31 +214,31 @@ static int r3d_read_redv(AVFormatContext s, AVPacket pkt, Atom *atom) · 58 unmodified lines
214	unsigned dts;	214	unsigned dts;
215	int ret;	215	int ret;
216		216
217	dts = get_be32(s->pb);	217	dts = avio_rb32(s->pb);
218		218
219	tmp = get_be32(s->pb);	219	tmp = avio_rb32(s->pb);
220	av_dlog(s, "frame num %d\n", tmp);	220	av_dlog(s, "frame num %d\n", tmp);
221		221
222	tmp = get_byte(s->pb); // major version	222	tmp = avio_r8(s->pb); // major version
223	tmp2 = get_byte(s->pb); // minor version	223	tmp2 = avio_r8(s->pb); // minor version
224	av_dlog(s, "version %d.%d\n", tmp, tmp2);	224	av_dlog(s, "version %d.%d\n", tmp, tmp2);
225		225
226	tmp = get_be16(s->pb); // unknown	226	tmp = avio_rb16(s->pb); // unknown
227	av_dlog(s, "unknown %d\n", tmp);	227	av_dlog(s, "unknown %d\n", tmp);
228		228
229	if (tmp > 4) {	229	if (tmp > 4) {
230	tmp = get_be16(s->pb); // unknown	230	tmp = avio_rb16(s->pb); // unknown
231	av_dlog(s, "unknown %d\n", tmp);	231	av_dlog(s, "unknown %d\n", tmp);
232		232
233	tmp = get_be16(s->pb); // unknown	233	tmp = avio_rb16(s->pb); // unknown
234	av_dlog(s, "unknown %d\n", tmp);	234	av_dlog(s, "unknown %d\n", tmp);
235		235
236	tmp = get_be32(s->pb);	236	tmp = avio_rb32(s->pb);
237	av_dlog(s, "width %d\n", tmp);	237	av_dlog(s, "width %d\n", tmp);
238	tmp = get_be32(s->pb);	238	tmp = avio_rb32(s->pb);
239	av_dlog(s, "height %d\n", tmp);	239	av_dlog(s, "height %d\n", tmp);
240		240
241	tmp = get_be32(s->pb);	241	tmp = avio_rb32(s->pb);
242	av_dlog(s, "metadata len %d\n", tmp);	242	av_dlog(s, "metadata len %d\n", tmp);
243	}	243	}
244	tmp = atom->size - 8 - (url_ftell(s->pb) - pos);	244	tmp = atom->size - 8 - (url_ftell(s->pb) - pos);
@@ -268,23 +268,23 @@ static int r3d_read_reda(AVFormatContext s, AVPacket pkt, Atom *atom) · 23 unmodified lines
268	unsigned dts;	268	unsigned dts;
269	int ret;	269	int ret;
270		270
271	dts = get_be32(s->pb);	271	dts = avio_rb32(s->pb);
272		272
273	st->codec->sample_rate = get_be32(s->pb);	273	st->codec->sample_rate = avio_rb32(s->pb);
274		274
275	samples = get_be32(s->pb);	275	samples = avio_rb32(s->pb);
276		276
277	tmp = get_be32(s->pb);	277	tmp = avio_rb32(s->pb);
278	av_dlog(s, "packet num %d\n", tmp);	278	av_dlog(s, "packet num %d\n", tmp);
279		279
280	tmp = get_be16(s->pb); // unkown	280	tmp = avio_rb16(s->pb); // unkown
281	av_dlog(s, "unknown %d\n", tmp);	281	av_dlog(s, "unknown %d\n", tmp);
282		282
283	tmp = get_byte(s->pb); // major version	283	tmp = avio_r8(s->pb); // major version
284	tmp2 = get_byte(s->pb); // minor version	284	tmp2 = avio_r8(s->pb); // minor version
285	av_dlog(s, "version %d.%d\n", tmp, tmp2);	285	av_dlog(s, "version %d.%d\n", tmp, tmp2);
286		286
287	tmp = get_be32(s->pb); // unknown	287	tmp = avio_rb32(s->pb); // unknown
288	av_dlog(s, "unknown %d\n", tmp);	288	av_dlog(s, "unknown %d\n", tmp);
289		289
290	size = atom->size - 8 - (url_ftell(s->pb) - pos);	290	size = atom->size - 8 - (url_ftell(s->pb) - pos);

libavformat/rdt.c+6−6

@@ -153,25 +153,25 @@ rdt_load_mdpr (PayloadContext rdt, AVStream st, int rule_nr) · 152 unmodified lines
153	return -1;	153	return -1;
154	ffio_init_context(&pb, rdt->mlti_data, rdt->mlti_data_size, 0,	154	ffio_init_context(&pb, rdt->mlti_data, rdt->mlti_data_size, 0,
155	NULL, NULL, NULL, NULL);	155	NULL, NULL, NULL, NULL);
156	tag = get_le32(&pb);	156	tag = avio_rl32(&pb);
157	if (tag == MKTAG('M', 'L', 'T', 'I')) {	157	if (tag == MKTAG('M', 'L', 'T', 'I')) {
158	int num, chunk_nr;	158	int num, chunk_nr;
159		159
160	/* read index of MDPR chunk numbers */	160	/* read index of MDPR chunk numbers */
161	num = get_be16(&pb);	161	num = avio_rb16(&pb);
162	if (rule_nr < 0 \|\| rule_nr >= num)	162	if (rule_nr < 0 \|\| rule_nr >= num)
163	return -1;	163	return -1;
164	url_fskip(&pb, rule_nr * 2);	164	url_fskip(&pb, rule_nr * 2);
165	chunk_nr = get_be16(&pb);	165	chunk_nr = avio_rb16(&pb);
166	url_fskip(&pb, (num - 1 - rule_nr) * 2);	166	url_fskip(&pb, (num - 1 - rule_nr) * 2);
167		167
168	/* read MDPR chunks */	168	/* read MDPR chunks */
169	num = get_be16(&pb);	169	num = avio_rb16(&pb);
170	if (chunk_nr >= num)	170	if (chunk_nr >= num)
171	return -1;	171	return -1;
172	while (chunk_nr--)	172	while (chunk_nr--)
173	url_fskip(&pb, get_be32(&pb));	173	url_fskip(&pb, avio_rb32(&pb));
174	size = get_be32(&pb);	174	size = avio_rb32(&pb);
175	} else {	175	} else {
176	size = rdt->mlti_data_size;	176	size = rdt->mlti_data_size;
177	url_fseek(&pb, 0, SEEK_SET);	177	url_fseek(&pb, 0, SEEK_SET);

libavformat/riff.c+22−22

@@ -481,25 +481,25 @@ void ff_get_wav_header(AVIOContext pb, AVCodecContext codec, int size) · 480 unmodified lines
481	{	481	{
482	int id;	482	int id;
483		483
484	id = get_le16(pb);	484	id = avio_rl16(pb);
485	codec->codec_type = AVMEDIA_TYPE_AUDIO;	485	codec->codec_type = AVMEDIA_TYPE_AUDIO;
486	codec->codec_tag = id;	486	codec->codec_tag = id;
487	codec->channels = get_le16(pb);	487	codec->channels = avio_rl16(pb);
488	codec->sample_rate = get_le32(pb);	488	codec->sample_rate = avio_rl32(pb);
489	codec->bit_rate = get_le32(pb) * 8;	489	codec->bit_rate = avio_rl32(pb) * 8;
490	codec->block_align = get_le16(pb);	490	codec->block_align = avio_rl16(pb);
491	if (size == 14) { /* We're dealing with plain vanilla WAVEFORMAT */	491	if (size == 14) { /* We're dealing with plain vanilla WAVEFORMAT */
492	codec->bits_per_coded_sample = 8;	492	codec->bits_per_coded_sample = 8;
493	}else	493	}else
494	codec->bits_per_coded_sample = get_le16(pb);	494	codec->bits_per_coded_sample = avio_rl16(pb);
495	if (size >= 18) { /* We're obviously dealing with WAVEFORMATEX */	495	if (size >= 18) { /* We're obviously dealing with WAVEFORMATEX */
496	int cbSize = get_le16(pb); /* cbSize */	496	int cbSize = avio_rl16(pb); /* cbSize */
497	size -= 18;	497	size -= 18;
498	cbSize = FFMIN(size, cbSize);	498	cbSize = FFMIN(size, cbSize);
499	if (cbSize >= 22 && id == 0xfffe) { /* WAVEFORMATEXTENSIBLE */	499	if (cbSize >= 22 && id == 0xfffe) { /* WAVEFORMATEXTENSIBLE */
500	codec->bits_per_coded_sample = get_le16(pb);	500	codec->bits_per_coded_sample = avio_rl16(pb);
501	codec->channel_layout = get_le32(pb); /* dwChannelMask */	501	codec->channel_layout = avio_rl32(pb); /* dwChannelMask */
502	id = get_le32(pb); /* 4 first bytes of GUID */	502	id = avio_rl32(pb); /* 4 first bytes of GUID */
503	url_fskip(pb, 12); /* skip end of GUID */	503	url_fskip(pb, 12); /* skip end of GUID */
504	cbSize -= 22;	504	cbSize -= 22;
505	size -= 22;	505	size -= 22;
@@ -507,7 +507,7 @@ void ff_get_wav_header(AVIOContext pb, AVCodecContext codec, int size) · 1 unmodified line
507	codec->extradata_size = cbSize;	507	codec->extradata_size = cbSize;
508	if (cbSize > 0) {	508	if (cbSize > 0) {
509	codec->extradata = av_mallocz(codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);	509	codec->extradata = av_mallocz(codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
510	get_buffer(pb, codec->extradata, codec->extradata_size);	510	avio_read(pb, codec->extradata, codec->extradata_size);
511	size -= cbSize;	511	size -= cbSize;
512	}	512	}
513		513
@@ -547,17 +547,17 @@ enum CodecID ff_wav_codec_get_id(unsigned int tag, int bps) · 33 unmodified lines
547	int ff_get_bmp_header(AVIOContext pb, AVStream st)	547	int ff_get_bmp_header(AVIOContext pb, AVStream st)
548	{	548	{
549	int tag1;	549	int tag1;
550	get_le32(pb); /* size */	550	avio_rl32(pb); /* size */
551	st->codec->width = get_le32(pb);	551	st->codec->width = avio_rl32(pb);
552	st->codec->height = (int32_t)get_le32(pb);	552	st->codec->height = (int32_t)avio_rl32(pb);
553	get_le16(pb); /* planes */	553	avio_rl16(pb); /* planes */
554	st->codec->bits_per_coded_sample= get_le16(pb); /* depth */	554	st->codec->bits_per_coded_sample= avio_rl16(pb); /* depth */
555	tag1 = get_le32(pb);	555	tag1 = avio_rl32(pb);
556	get_le32(pb); /* ImageSize */	556	avio_rl32(pb); /* ImageSize */
557	get_le32(pb); /* XPelsPerMeter */	557	avio_rl32(pb); /* XPelsPerMeter */
558	get_le32(pb); /* YPelsPerMeter */	558	avio_rl32(pb); /* YPelsPerMeter */
559	get_le32(pb); /* ClrUsed */	559	avio_rl32(pb); /* ClrUsed */
560	get_le32(pb); /* ClrImportant */	560	avio_rl32(pb); /* ClrImportant */
561	return tag1;	561	return tag1;
562	}	562	}
563	#endif // CONFIG_DEMUXERS	563	#endif // CONFIG_DEMUXERS

libavformat/rl2.c+13−13

@@ -96,20 +96,20 @@ static av_cold int rl2_read_header(AVFormatContext *s, · 95 unmodified lines
96	int ret = 0;	96	int ret = 0;
97		97
98	url_fskip(pb,4); /* skip FORM tag */	98	url_fskip(pb,4); /* skip FORM tag */
99	back_size = get_le32(pb); /*< get size of the background frame /	99	back_size = avio_rl32(pb); /*< get size of the background frame /
100	signature = get_be32(pb);	100	signature = avio_rb32(pb);
101	data_size = get_be32(pb);	101	data_size = avio_rb32(pb);
102	frame_count = get_le32(pb);	102	frame_count = avio_rl32(pb);
103		103
104	/* disallow back_sizes and frame_counts that may lead to overflows later */	104	/* disallow back_sizes and frame_counts that may lead to overflows later */
105	if(back_size > INT_MAX/2 \|\| frame_count > INT_MAX / sizeof(uint32_t))	105	if(back_size > INT_MAX/2 \|\| frame_count > INT_MAX / sizeof(uint32_t))
106	return AVERROR_INVALIDDATA;	106	return AVERROR_INVALIDDATA;
107		107
108	encoding_method = get_le16(pb);	108	encoding_method = avio_rl16(pb);
109	sound_rate = get_le16(pb);	109	sound_rate = avio_rl16(pb);
110	rate = get_le16(pb);	110	rate = avio_rl16(pb);
111	channels = get_le16(pb);	111	channels = avio_rl16(pb);
112	def_sound_size = get_le16(pb);	112	def_sound_size = avio_rl16(pb);
113		113
114	/** setup video stream */	114	/** setup video stream */
115	st = av_new_stream(s, 0);	115	st = av_new_stream(s, 0);
@@ -133,7 +133,7 @@ static av_cold int rl2_read_header(AVFormatContext *s, · 17 unmodified lines
133	if(!st->codec->extradata)	133	if(!st->codec->extradata)
134	return AVERROR(ENOMEM);	134	return AVERROR(ENOMEM);
135		135
136	if(get_buffer(pb,st->codec->extradata,st->codec->extradata_size) !=	136	if(avio_read(pb,st->codec->extradata,st->codec->extradata_size) !=
137	st->codec->extradata_size)	137	st->codec->extradata_size)
138	return AVERROR(EIO);	138	return AVERROR(EIO);
139		139
@@ -173,11 +173,11 @@ static av_cold int rl2_read_header(AVFormatContext *s, · 33 unmodified lines
173		173
174	/** read offset and size tables */	174	/** read offset and size tables */
175	for(i=0; i < frame_count;i++)	175	for(i=0; i < frame_count;i++)
176	chunk_size[i] = get_le32(pb);	176	chunk_size[i] = avio_rl32(pb);
177	for(i=0; i < frame_count;i++)	177	for(i=0; i < frame_count;i++)
178	chunk_offset[i] = get_le32(pb);	178	chunk_offset[i] = avio_rl32(pb);
179	for(i=0; i < frame_count;i++)	179	for(i=0; i < frame_count;i++)
180	audio_size[i] = get_le32(pb) & 0xFFFF;	180	audio_size[i] = avio_rl32(pb) & 0xFFFF;
181		181
182	/** build the sample index */	182	/** build the sample index */
183	for(i=0;i<frame_count;i++){	183	for(i=0;i<frame_count;i++){

libavformat/rmdec.c+103−103

@@ -71,7 +71,7 @@ static inline void get_strl(AVIOContext pb, char buf, int buf_size, int len) · 70 unmodified lines
71		71
72	q = buf;	72	q = buf;
73	for(i=0;i<len;i++) {	73	for(i=0;i<len;i++) {
74	r = get_byte(pb);	74	r = avio_r8(pb);
75	if (i < buf_size - 1)	75	if (i < buf_size - 1)
76	*q++ = r;	76	*q++ = r;
77	}	77	}
@@ -80,7 +80,7 @@ static inline void get_strl(AVIOContext pb, char buf, int buf_size, int len) · 2 unmodified lines
80		80
81	static void get_str8(AVIOContext pb, char buf, int buf_size)	81	static void get_str8(AVIOContext pb, char buf, int buf_size)
82	{	82	{
83	get_strl(pb, buf, buf_size, get_byte(pb));	83	get_strl(pb, buf, buf_size, avio_r8(pb));
84	}	84	}
85		85
86	static int rm_read_extradata(AVIOContext pb, AVCodecContext avctx, unsigned size)	86	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 · 3 unmodified lines
90	avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);	90	avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
91	if (!avctx->extradata)	91	if (!avctx->extradata)
92	return AVERROR(ENOMEM);	92	return AVERROR(ENOMEM);
93	avctx->extradata_size = get_buffer(pb, avctx->extradata, size);	93	avctx->extradata_size = avio_read(pb, avctx->extradata, size);
94	memset(avctx->extradata + avctx->extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);	94	memset(avctx->extradata + avctx->extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
95	if (avctx->extradata_size != size)	95	if (avctx->extradata_size != size)
96	return AVERROR(EIO);	96	return AVERROR(EIO);
@@ -102,7 +102,7 @@ static void rm_read_metadata(AVFormatContext *s, int wide) · 5 unmodified lines
102	char buf[1024];	102	char buf[1024];
103	int i;	103	int i;
104	for (i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {	104	for (i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
105	int len = wide ? get_be16(s->pb) : get_byte(s->pb);	105	int len = wide ? avio_rb16(s->pb) : avio_r8(s->pb);
106	get_strl(s->pb, buf, sizeof(buf), len);	106	get_strl(s->pb, buf, sizeof(buf), len);
107	av_metadata_set2(&s->metadata, ff_rm_metadata[i], buf, 0);	107	av_metadata_set2(&s->metadata, ff_rm_metadata[i], buf, 0);
108	}	108	}
@@ -128,15 +128,15 @@ static int rm_read_audio_stream_info(AVFormatContext s, AVIOContext pb, · 19 unmodified lines
128	int ret;	128	int ret;
129		129
130	/* ra type header */	130	/* ra type header */
131	version = get_be16(pb); /* version */	131	version = avio_rb16(pb); /* version */
132	if (version == 3) {	132	if (version == 3) {
133	int header_size = get_be16(pb);	133	int header_size = avio_rb16(pb);
134	int64_t startpos = url_ftell(pb);	134	int64_t startpos = url_ftell(pb);
135	url_fskip(pb, 14);	135	url_fskip(pb, 14);
136	rm_read_metadata(s, 0);	136	rm_read_metadata(s, 0);
137	if ((startpos + header_size) >= url_ftell(pb) + 2) {	137	if ((startpos + header_size) >= url_ftell(pb) + 2) {
138	// fourcc (should always be "lpcJ")	138	// fourcc (should always be "lpcJ")
139	get_byte(pb);	139	avio_r8(pb);
140	get_str8(pb, buf, sizeof(buf));	140	get_str8(pb, buf, sizeof(buf));
141	}	141	}
142	// Skip extra header crap (this should never happen)	142	// Skip extra header crap (this should never happen)
@@ -151,28 +151,28 @@ static int rm_read_audio_stream_info(AVFormatContext s, AVIOContext pb, · 8 unmodified lines
151	int codecdata_length;	151	int codecdata_length;
152	/* old version (4) */	152	/* old version (4) */
153	url_fskip(pb, 2); /* unused */	153	url_fskip(pb, 2); /* unused */
154	get_be32(pb); /* .ra4 */	154	avio_rb32(pb); /* .ra4 */
155	get_be32(pb); /* data size */	155	avio_rb32(pb); /* data size */
156	get_be16(pb); /* version2 */	156	avio_rb16(pb); /* version2 */
157	get_be32(pb); /* header size */	157	avio_rb32(pb); /* header size */
158	flavor= get_be16(pb); /* add codec info / flavor */	158	flavor= avio_rb16(pb); /* add codec info / flavor */
159	ast->coded_framesize = coded_framesize = get_be32(pb); /* coded frame size */	159	ast->coded_framesize = coded_framesize = avio_rb32(pb); /* coded frame size */
160	get_be32(pb); /* ??? */	160	avio_rb32(pb); /* ??? */
161	get_be32(pb); /* ??? */	161	avio_rb32(pb); /* ??? */
162	get_be32(pb); /* ??? */	162	avio_rb32(pb); /* ??? */
163	ast->sub_packet_h = sub_packet_h = get_be16(pb); /* 1 */	163	ast->sub_packet_h = sub_packet_h = avio_rb16(pb); /* 1 */
164	st->codec->block_align= get_be16(pb); /* frame size */	164	st->codec->block_align= avio_rb16(pb); /* frame size */
165	ast->sub_packet_size = sub_packet_size = get_be16(pb); /* sub packet size */	165	ast->sub_packet_size = sub_packet_size = avio_rb16(pb); /* sub packet size */
166	get_be16(pb); /* ??? */	166	avio_rb16(pb); /* ??? */
167	if (version == 5) {	167	if (version == 5) {
168	get_be16(pb); get_be16(pb); get_be16(pb);	168	avio_rb16(pb); avio_rb16(pb); avio_rb16(pb);
169	}	169	}
170	st->codec->sample_rate = get_be16(pb);	170	st->codec->sample_rate = avio_rb16(pb);
171	get_be32(pb);	171	avio_rb32(pb);
172	st->codec->channels = get_be16(pb);	172	st->codec->channels = avio_rb16(pb);
173	if (version == 5) {	173	if (version == 5) {
174	get_be32(pb);	174	avio_rb32(pb);
175	get_buffer(pb, buf, 4);	175	avio_read(pb, buf, 4);
176	buf[4] = 0;	176	buf[4] = 0;
177	} else {	177	} else {
178	get_str8(pb, buf, sizeof(buf)); /* desc */	178	get_str8(pb, buf, sizeof(buf)); /* desc */
@@ -201,10 +201,10 @@ static int rm_read_audio_stream_info(AVFormatContext s, AVIOContext pb, · 22 unmodified lines
201	case CODEC_ID_COOK:	201	case CODEC_ID_COOK:
202	case CODEC_ID_ATRAC3:	202	case CODEC_ID_ATRAC3:
203	case CODEC_ID_SIPR:	203	case CODEC_ID_SIPR:
204	get_be16(pb); get_byte(pb);	204	avio_rb16(pb); avio_r8(pb);
205	if (version == 5)	205	if (version == 5)
206	get_byte(pb);	206	avio_r8(pb);
207	codecdata_length = get_be32(pb);	207	codecdata_length = avio_rb32(pb);
208	if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){	208	if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){
209	av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");	209	av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");
210	return -1;	210	return -1;
@@ -236,16 +236,16 @@ static int rm_read_audio_stream_info(AVFormatContext s, AVIOContext pb, · 25 unmodified lines
236	av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h);	236	av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h);
237	break;	237	break;
238	case CODEC_ID_AAC:	238	case CODEC_ID_AAC:
239	get_be16(pb); get_byte(pb);	239	avio_rb16(pb); avio_r8(pb);
240	if (version == 5)	240	if (version == 5)
241	get_byte(pb);	241	avio_r8(pb);
242	codecdata_length = get_be32(pb);	242	codecdata_length = avio_rb32(pb);
243	if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){	243	if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){
244	av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");	244	av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");
245	return -1;	245	return -1;
246	}	246	}
247	if (codecdata_length >= 1) {	247	if (codecdata_length >= 1) {
248	get_byte(pb);	248	avio_r8(pb);
249	if ((ret = rm_read_extradata(pb, st->codec, codecdata_length - 1)) < 0)	249	if ((ret = rm_read_extradata(pb, st->codec, codecdata_length - 1)) < 0)
250	return ret;	250	return ret;
251	}	251	}
@@ -254,9 +254,9 @@ static int rm_read_audio_stream_info(AVFormatContext s, AVIOContext pb, · 2 unmodified lines
254	av_strlcpy(st->codec->codec_name, buf, sizeof(st->codec->codec_name));	254	av_strlcpy(st->codec->codec_name, buf, sizeof(st->codec->codec_name));
255	}	255	}
256	if (read_all) {	256	if (read_all) {
257	get_byte(pb);	257	avio_r8(pb);
258	get_byte(pb);	258	avio_r8(pb);
259	get_byte(pb);	259	avio_r8(pb);
260	rm_read_metadata(s, 0);	260	rm_read_metadata(s, 0);
261	}	261	}
262	}	262	}
@@ -274,32 +274,32 @@ ff_rm_read_mdpr_codecdata (AVFormatContext s, AVIOContext pb, · 11 unmodified lines
274		274
275	av_set_pts_info(st, 64, 1, 1000);	275	av_set_pts_info(st, 64, 1, 1000);
276	codec_pos = url_ftell(pb);	276	codec_pos = url_ftell(pb);
277	v = get_be32(pb);	277	v = avio_rb32(pb);
278	if (v == MKTAG(0xfd, 'a', 'r', '.')) {	278	if (v == MKTAG(0xfd, 'a', 'r', '.')) {
279	/* ra type header */	279	/* ra type header */
280	if (rm_read_audio_stream_info(s, pb, st, rst, 0))	280	if (rm_read_audio_stream_info(s, pb, st, rst, 0))
281	return -1;	281	return -1;
282	} else {	282	} else {
283	int fps, fps2;	283	int fps, fps2;
284	if (get_le32(pb) != MKTAG('V', 'I', 'D', 'O')) {	284	if (avio_rl32(pb) != MKTAG('V', 'I', 'D', 'O')) {
285	fail1:	285	fail1:
286	av_log(st->codec, AV_LOG_ERROR, "Unsupported video codec\n");	286	av_log(st->codec, AV_LOG_ERROR, "Unsupported video codec\n");
287	goto skip;	287	goto skip;
288	}	288	}
289	st->codec->codec_tag = get_le32(pb);	289	st->codec->codec_tag = avio_rl32(pb);
290	st->codec->codec_id = ff_codec_get_id(ff_rm_codec_tags,	290	st->codec->codec_id = ff_codec_get_id(ff_rm_codec_tags,
291	st->codec->codec_tag);	291	st->codec->codec_tag);
292	// av_log(s, AV_LOG_DEBUG, "%X %X\n", st->codec->codec_tag, MKTAG('R', 'V', '2', '0'));	292	// av_log(s, AV_LOG_DEBUG, "%X %X\n", st->codec->codec_tag, MKTAG('R', 'V', '2', '0'));
293	if (st->codec->codec_id == CODEC_ID_NONE)	293	if (st->codec->codec_id == CODEC_ID_NONE)
294	goto fail1;	294	goto fail1;
295	st->codec->width = get_be16(pb);	295	st->codec->width = avio_rb16(pb);
296	st->codec->height = get_be16(pb);	296	st->codec->height = avio_rb16(pb);
297	st->codec->time_base.num= 1;	297	st->codec->time_base.num= 1;
298	fps= get_be16(pb);	298	fps= avio_rb16(pb);
299	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;	299	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
300	get_be32(pb);	300	avio_rb32(pb);
301	fps2= get_be16(pb);	301	fps2= avio_rb16(pb);
302	get_be16(pb);	302	avio_rb16(pb);
303		303
304	if ((ret = rm_read_extradata(pb, st->codec, codec_data_size - (url_ftell(pb) - codec_pos))) < 0)	304	if ((ret = rm_read_extradata(pb, st->codec, codec_data_size - (url_ftell(pb) - codec_pos))) < 0)
305	return ret;	305	return ret;
@@ -335,15 +335,15 @@ static int rm_read_index(AVFormatContext *s) · 29 unmodified lines
335	AVStream *st;	335	AVStream *st;
336		336
337	do {	337	do {
338	if (get_le32(pb) != MKTAG('I','N','D','X'))	338	if (avio_rl32(pb) != MKTAG('I','N','D','X'))
339	return -1;	339	return -1;
340	size = get_be32(pb);	340	size = avio_rb32(pb);
341	if (size < 20)	341	if (size < 20)
342	return -1;	342	return -1;
343	url_fskip(pb, 2);	343	url_fskip(pb, 2);
344	n_pkts = get_be32(pb);	344	n_pkts = avio_rb32(pb);
345	str_id = get_be16(pb);	345	str_id = avio_rb16(pb);
346	next_off = get_be32(pb);	346	next_off = avio_rb32(pb);
347	for (n = 0; n < s->nb_streams; n++)	347	for (n = 0; n < s->nb_streams; n++)
348	if (s->streams[n]->id == str_id) {	348	if (s->streams[n]->id == str_id) {
349	st = s->streams[n];	349	st = s->streams[n];
@@ -354,8 +354,8 @@ static int rm_read_index(AVFormatContext *s) · 4 unmodified lines
354		354
355	for (n = 0; n < n_pkts; n++) {	355	for (n = 0; n < n_pkts; n++) {
356	url_fskip(pb, 2);	356	url_fskip(pb, 2);
357	pts = get_be32(pb);	357	pts = avio_rb32(pb);
358	pos = get_be32(pb);	358	pos = avio_rb32(pb);
359	url_fskip(pb, 4); /* packet no. */	359	url_fskip(pb, 4); /* packet no. */
360		360
361	av_add_index_entry(st, pos, pts, 0, 0, AVINDEX_KEYFRAME);	361	av_add_index_entry(st, pos, pts, 0, 0, AVINDEX_KEYFRAME);
@@ -395,7 +395,7 @@ static int rm_read_header(AVFormatContext s, AVFormatParameters ap) · 33 unmodified lines
395	char buf[128];	395	char buf[128];
396	int flags = 0;	396	int flags = 0;
397		397
398	tag = get_le32(pb);	398	tag = avio_rl32(pb);
399	if (tag == MKTAG('.', 'r', 'a', 0xfd)) {	399	if (tag == MKTAG('.', 'r', 'a', 0xfd)) {
400	/* very old .ra format */	400	/* very old .ra format */
401	return rm_read_header_old(s, ap);	401	return rm_read_header_old(s, ap);
@@ -403,17 +403,17 @@ static int rm_read_header(AVFormatContext s, AVFormatParameters ap) · 1 unmodified line
403	return AVERROR(EIO);	403	return AVERROR(EIO);
404	}	404	}
405		405
406	get_be32(pb); /* header size */	406	avio_rb32(pb); /* header size */
407	get_be16(pb);	407	avio_rb16(pb);
408	get_be32(pb);	408	avio_rb32(pb);
409	get_be32(pb); /* number of headers */	409	avio_rb32(pb); /* number of headers */
410		410
411	for(;;) {	411	for(;;) {
412	if (url_feof(pb))	412	if (url_feof(pb))
413	return -1;	413	return -1;
414	tag = get_le32(pb);	414	tag = avio_rl32(pb);
415	tag_size = get_be32(pb);	415	tag_size = avio_rb32(pb);
416	get_be16(pb);	416	avio_rb16(pb);
417	#if 0	417	#if 0
418	printf("tag=%c%c%c%c (%08x) size=%d\n",	418	printf("tag=%c%c%c%c (%08x) size=%d\n",
419	(tag) & 0xff,	419	(tag) & 0xff,
@@ -428,17 +428,17 @@ static int rm_read_header(AVFormatContext s, AVFormatParameters ap) · 8 unmodified lines
428	switch(tag) {	428	switch(tag) {
429	case MKTAG('P', 'R', 'O', 'P'):	429	case MKTAG('P', 'R', 'O', 'P'):
430	/* file header */	430	/* file header */
431	get_be32(pb); /* max bit rate */	431	avio_rb32(pb); /* max bit rate */
432	get_be32(pb); /* avg bit rate */	432	avio_rb32(pb); /* avg bit rate */
433	get_be32(pb); /* max packet size */	433	avio_rb32(pb); /* max packet size */
434	get_be32(pb); /* avg packet size */	434	avio_rb32(pb); /* avg packet size */
435	get_be32(pb); /* nb packets */	435	avio_rb32(pb); /* nb packets */
436	get_be32(pb); /* duration */	436	avio_rb32(pb); /* duration */
437	get_be32(pb); /* preroll */	437	avio_rb32(pb); /* preroll */
438	indx_off = get_be32(pb); /* index offset */	438	indx_off = avio_rb32(pb); /* index offset */
439	data_off = get_be32(pb); /* data offset */	439	data_off = avio_rb32(pb); /* data offset */
440	get_be16(pb); /* nb streams */	440	avio_rb16(pb); /* nb streams */
441	flags = get_be16(pb); /* flags */	441	flags = avio_rb16(pb); /* flags */
442	break;	442	break;
443	case MKTAG('C', 'O', 'N', 'T'):	443	case MKTAG('C', 'O', 'N', 'T'):
444	rm_read_metadata(s, 1);	444	rm_read_metadata(s, 1);
@@ -447,14 +447,14 @@ static int rm_read_header(AVFormatContext s, AVFormatParameters ap) · 2 unmodified lines
447	st = av_new_stream(s, 0);	447	st = av_new_stream(s, 0);
448	if (!st)	448	if (!st)
449	return AVERROR(ENOMEM);	449	return AVERROR(ENOMEM);
450	st->id = get_be16(pb);	450	st->id = avio_rb16(pb);
451	get_be32(pb); /* max bit rate */	451	avio_rb32(pb); /* max bit rate */
452	st->codec->bit_rate = get_be32(pb); /* bit rate */	452	st->codec->bit_rate = avio_rb32(pb); /* bit rate */
453	get_be32(pb); /* max packet size */	453	avio_rb32(pb); /* max packet size */
454	get_be32(pb); /* avg packet size */	454	avio_rb32(pb); /* avg packet size */
455	start_time = get_be32(pb); /* start time */	455	start_time = avio_rb32(pb); /* start time */
456	get_be32(pb); /* preroll */	456	avio_rb32(pb); /* preroll */
457	duration = get_be32(pb); /* duration */	457	duration = avio_rb32(pb); /* duration */
458	st->start_time = start_time;	458	st->start_time = start_time;
459	st->duration = duration;	459	st->duration = duration;
460	get_str8(pb, buf, sizeof(buf)); /* desc */	460	get_str8(pb, buf, sizeof(buf)); /* desc */
@@ -462,7 +462,7 @@ static int rm_read_header(AVFormatContext s, AVFormatParameters ap) · 1 unmodified line
462	st->codec->codec_type = AVMEDIA_TYPE_DATA;	462	st->codec->codec_type = AVMEDIA_TYPE_DATA;
463	st->priv_data = ff_rm_alloc_rmstream();	463	st->priv_data = ff_rm_alloc_rmstream();
464	if (ff_rm_read_mdpr_codecdata(s, s->pb, st, st->priv_data,	464	if (ff_rm_read_mdpr_codecdata(s, s->pb, st, st->priv_data,
465	get_be32(pb)) < 0)	465	avio_rb32(pb)) < 0)
466	return -1;	466	return -1;
467	break;	467	break;
468	case MKTAG('D', 'A', 'T', 'A'):	468	case MKTAG('D', 'A', 'T', 'A'):
@@ -474,10 +474,10 @@ static int rm_read_header(AVFormatContext s, AVFormatParameters ap) · 5 unmodified lines
474	}	474	}
475	}	475	}
476	header_end:	476	header_end:
477	rm->nb_packets = get_be32(pb); /* number of packets */	477	rm->nb_packets = avio_rb32(pb); /* number of packets */
478	if (!rm->nb_packets && (flags & 4))	478	if (!rm->nb_packets && (flags & 4))
479	rm->nb_packets = 3600 * 25;	479	rm->nb_packets = 3600 * 25;
480	get_be32(pb); /* next data header */	480	avio_rb32(pb); /* next data header */
481		481
482	if (!data_off)	482	if (!data_off)
483	data_off = url_ftell(pb) - 18;	483	data_off = url_ftell(pb) - 18;
@@ -494,13 +494,13 @@ static int get_num(AVIOContext pb, int len) · 10 unmodified lines
494	{	494	{
495	int n, n1;	495	int n, n1;
496		496
497	n = get_be16(pb);	497	n = avio_rb16(pb);
498	(*len)-=2;	498	(*len)-=2;
499	n &= 0x7FFF;	499	n &= 0x7FFF;
500	if (n >= 0x4000) {	500	if (n >= 0x4000) {
501	return n - 0x4000;	501	return n - 0x4000;
502	} else {	502	} else {
503	n1 = get_be16(pb);	503	n1 = avio_rb16(pb);
504	(*len)-=2;	504	(*len)-=2;
505	return (n << 16) \| n1;	505	return (n << 16) \| n1;
506	}	506	}
@@ -524,13 +524,13 @@ static int sync(AVFormatContext s, int64_t timestamp, int flags, int stream_ · 17 unmodified lines
524	*timestamp = AV_NOPTS_VALUE;	524	*timestamp = AV_NOPTS_VALUE;
525	*flags= 0;	525	*flags= 0;
526	}else{	526	}else{
527	state= (state<<8) + get_byte(pb);	527	state= (state<<8) + avio_r8(pb);
528		528
529	if(state == MKBETAG('I', 'N', 'D', 'X')){	529	if(state == MKBETAG('I', 'N', 'D', 'X')){
530	int n_pkts, expected_len;	530	int n_pkts, expected_len;
531	len = get_be32(pb);	531	len = avio_rb32(pb);
532	url_fskip(pb, 2);	532	url_fskip(pb, 2);
533	n_pkts = get_be32(pb);	533	n_pkts = avio_rb32(pb);
534	expected_len = 20 + n_pkts * 14;	534	expected_len = 20 + n_pkts * 14;
535	if (len == 20)	535	if (len == 20)
536	/* some files don't add index entries to chunk size... */	536	/* 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_ · 16 unmodified lines
553	len=state - 12;	553	len=state - 12;
554	state= 0xFFFFFFFF;	554	state= 0xFFFFFFFF;
555		555
556	num = get_be16(pb);	556	num = avio_rb16(pb);
557	*timestamp = get_be32(pb);	557	*timestamp = avio_rb32(pb);
558	get_byte(pb); /* reserved */	558	avio_r8(pb); /* reserved */
559	flags = get_byte(pb); / flags */	559	flags = avio_r8(pb); / flags */
560	}	560	}
561	for(i=0;i<s->nb_streams;i++) {	561	for(i=0;i<s->nb_streams;i++) {
562	st = s->streams[i];	562	st = s->streams[i];
@@ -584,16 +584,16 @@ static int rm_assemble_video_frame(AVFormatContext s, AVIOContext pb, · 21 unmodified lines
584	int hdr, seq, pic_num, len2, pos;	584	int hdr, seq, pic_num, len2, pos;
585	int type;	585	int type;
586		586
587	hdr = get_byte(pb); len--;	587	hdr = avio_r8(pb); len--;
588	type = hdr >> 6;	588	type = hdr >> 6;
589		589
590	if(type != 3){ // not frame as a part of packet	590	if(type != 3){ // not frame as a part of packet
591	seq = get_byte(pb); len--;	591	seq = avio_r8(pb); len--;
592	}	592	}
593	if(type != 1){ // not whole frame	593	if(type != 1){ // not whole frame
594	len2 = get_num(pb, &len);	594	len2 = get_num(pb, &len);
595	pos = get_num(pb, &len);	595	pos = get_num(pb, &len);
596	pic_num = get_byte(pb); len--;	596	pic_num = avio_r8(pb); len--;
597	}	597	}
598	if(len<0)	598	if(len<0)
599	return -1;	599	return -1;
@@ -609,7 +609,7 @@ static int rm_assemble_video_frame(AVFormatContext s, AVIOContext pb, · 9 unmodified lines
609	pkt->data[0] = 0;	609	pkt->data[0] = 0;
610	AV_WL32(pkt->data + 1, 1);	610	AV_WL32(pkt->data + 1, 1);
611	AV_WL32(pkt->data + 5, 0);	611	AV_WL32(pkt->data + 5, 0);
612	get_buffer(pb, pkt->data + 9, len);	612	avio_read(pb, pkt->data + 9, len);
613	return 0;	613	return 0;
614	}	614	}
615	//now we have to deal with single slice	615	//now we have to deal with single slice
@@ -635,7 +635,7 @@ static int rm_assemble_video_frame(AVFormatContext s, AVIOContext pb, · 19 unmodified lines
635	AV_WL32(vst->pkt.data - 3 + 8vst->cur_slice, vst->videobufpos - 8vst->slices - 1);	635	AV_WL32(vst->pkt.data - 3 + 8vst->cur_slice, vst->videobufpos - 8vst->slices - 1);
636	if(vst->videobufpos + len > vst->videobufsize)	636	if(vst->videobufpos + len > vst->videobufsize)
637	return 1;	637	return 1;
638	if (get_buffer(pb, vst->pkt.data + vst->videobufpos, len) != len)	638	if (avio_read(pb, vst->pkt.data + vst->videobufpos, len) != len)
639	return AVERROR(EIO);	639	return AVERROR(EIO);
640	vst->videobufpos += len;	640	vst->videobufpos += len;
641	rm->remaining_len-= len;	641	rm->remaining_len-= len;
@@ -730,15 +730,15 @@ ff_rm_parse_packet (AVFormatContext s, AVIOContext pb, · 88 unmodified lines
730	switch(st->codec->codec_id) {	730	switch(st->codec->codec_id) {
731	case CODEC_ID_RA_288:	731	case CODEC_ID_RA_288:
732	for (x = 0; x < h/2; x++)	732	for (x = 0; x < h/2; x++)
733	get_buffer(pb, ast->pkt.data+x2w+y*cfs, cfs);	733	avio_read(pb, ast->pkt.data+x2w+y*cfs, cfs);
734	break;	734	break;
735	case CODEC_ID_ATRAC3:	735	case CODEC_ID_ATRAC3:
736	case CODEC_ID_COOK:	736	case CODEC_ID_COOK:
737	for (x = 0; x < w/sps; x++)	737	for (x = 0; x < w/sps; x++)
738	get_buffer(pb, ast->pkt.data+sps(hx+((h+1)/2)*(y&1)+(y>>1)), sps);	738	avio_read(pb, ast->pkt.data+sps(hx+((h+1)/2)*(y&1)+(y>>1)), sps);
739	break;	739	break;
740	case CODEC_ID_SIPR:	740	case CODEC_ID_SIPR:
741	get_buffer(pb, ast->pkt.data + y * w, w);	741	avio_read(pb, ast->pkt.data + y * w, w);
742	break;	742	break;
743	}	743	}
744		744
@@ -753,10 +753,10 @@ ff_rm_parse_packet (AVFormatContext s, AVIOContext pb, · 8 unmodified lines
753	} else if (st->codec->codec_id == CODEC_ID_AAC) {	753	} else if (st->codec->codec_id == CODEC_ID_AAC) {
754	int x;	754	int x;
755	rm->audio_stream_num = st->index;	755	rm->audio_stream_num = st->index;
756	ast->sub_packet_cnt = (get_be16(pb) & 0xf0) >> 4;	756	ast->sub_packet_cnt = (avio_rb16(pb) & 0xf0) >> 4;
757	if (ast->sub_packet_cnt) {	757	if (ast->sub_packet_cnt) {
758	for (x = 0; x < ast->sub_packet_cnt; x++)	758	for (x = 0; x < ast->sub_packet_cnt; x++)
759	ast->sub_packet_lengths[x] = get_be16(pb);	759	ast->sub_packet_lengths[x] = avio_rb16(pb);
760	rm->audio_pkt_cnt = ast->sub_packet_cnt;	760	rm->audio_pkt_cnt = ast->sub_packet_cnt;
761	ast->audiotimestamp = timestamp;	761	ast->audiotimestamp = timestamp;
762	} else	762	} else
@@ -916,9 +916,9 @@ static int64_t rm_read_dts(AVFormatContext *s, int stream_index, · 153 unmodified lines
916		916
917	st = s->streams[stream_index2];	917	st = s->streams[stream_index2];
918	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {	918	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
919	h= get_byte(s->pb); len--;	919	h= avio_r8(s->pb); len--;
920	if(!(h & 0x40)){	920	if(!(h & 0x40)){
921	seq = get_byte(s->pb); len--;	921	seq = avio_r8(s->pb); len--;
922	}	922	}
923	}	923	}
924		924

libavformat/rpl.c+3−3

@@ -51,7 +51,7 @@ static int read_line(AVIOContext * pb, char* line, int bufsize) · 50 unmodified lines
51	{	51	{
52	int i;	52	int i;
53	for (i = 0; i < bufsize - 1; i++) {	53	for (i = 0; i < bufsize - 1; i++) {
54	int b = get_byte(pb);	54	int b = avio_r8(pb);
55	if (b == 0)	55	if (b == 0)
56	break;	56	break;
57	if (b == '\n') {	57	if (b == '\n') {
@@ -301,8 +301,8 @@ static int rpl_read_packet(AVFormatContext s, AVPacket pkt) · 243 unmodified lines
301	// multiple frames per chunk in Escape 124 samples.	301	// multiple frames per chunk in Escape 124 samples.
302	uint32_t frame_size, frame_flags;	302	uint32_t frame_size, frame_flags;
303		303
304	frame_flags = get_le32(pb);	304	frame_flags = avio_rl32(pb);
305	frame_size = get_le32(pb);	305	frame_size = avio_rl32(pb);
306	if (url_fseek(pb, -8, SEEK_CUR) < 0)	306	if (url_fseek(pb, -8, SEEK_CUR) < 0)
307	return AVERROR(EIO);	307	return AVERROR(EIO);
308		308

libavformat/rsodec.c+4−4

@@ -35,10 +35,10 @@ static int rso_read_header(AVFormatContext s, AVFormatParameters ap) · 34 unmodified lines
35	enum CodecID codec;	35	enum CodecID codec;
36	AVStream *st;	36	AVStream *st;
37		37
38	id = get_be16(pb);	38	id = avio_rb16(pb);
39	size = get_be16(pb);	39	size = avio_rb16(pb);
40	rate = get_be16(pb);	40	rate = avio_rb16(pb);
41	get_be16(pb); /* play mode ? (0x0000 = don't loop) */	41	avio_rb16(pb); /* play mode ? (0x0000 = don't loop) */
42		42
43	codec = ff_codec_get_id(ff_codec_rso_tags, id);	43	codec = ff_codec_get_id(ff_codec_rso_tags, id);
44		44

libavformat/rtpdec_asf.c+2−2

@@ -182,10 +182,10 @@ static int asfrtp_parse_packet(AVFormatContext s, PayloadContext asf, · 181 unmodified lines
182	while (url_ftell(pb) + 4 < len) {	182	while (url_ftell(pb) + 4 < len) {
183	int start_off = url_ftell(pb);	183	int start_off = url_ftell(pb);
184		184
185	mflags = get_byte(pb);	185	mflags = avio_r8(pb);
186	if (mflags & 0x80)	186	if (mflags & 0x80)
187	flags \|= RTP_FLAG_KEY;	187	flags \|= RTP_FLAG_KEY;
188	len_off = get_be24(pb);	188	len_off = avio_rb24(pb);
189	if (mflags & 0x20) /*< relative timestamp /	189	if (mflags & 0x20) /*< relative timestamp /
190	url_fskip(pb, 4);	190	url_fskip(pb, 4);
191	if (mflags & 0x10) /*< has duration /	191	if (mflags & 0x10) /*< has duration /

libavformat/rtpdec_qt.c+4−4

@@ -104,20 +104,20 @@ static int qt_rtp_parse_packet(AVFormatContext s, PayloadContext qt, · 103 unmodified lines
104	data_len = get_bits(&gb, 16);	104	data_len = get_bits(&gb, 16);
105		105
106	url_fseek(&pb, pos + 4, SEEK_SET);	106	url_fseek(&pb, pos + 4, SEEK_SET);
107	tag = get_le32(&pb);	107	tag = avio_rl32(&pb);
108	if ((st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&	108	if ((st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
109	tag != MKTAG('v','i','d','e')) \|\|	109	tag != MKTAG('v','i','d','e')) \|\|
110	(st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&	110	(st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
111	tag != MKTAG('s','o','u','n')))	111	tag != MKTAG('s','o','u','n')))
112	return AVERROR_INVALIDDATA;	112	return AVERROR_INVALIDDATA;
113	av_set_pts_info(st, 32, 1, get_be32(&pb));	113	av_set_pts_info(st, 32, 1, avio_rb32(&pb));
114		114
115	if (pos + data_len > len)	115	if (pos + data_len > len)
116	return AVERROR_INVALIDDATA;	116	return AVERROR_INVALIDDATA;
117	/* TLVs */	117	/* TLVs */
118	while (url_ftell(&pb) + 4 < pos + data_len) {	118	while (url_ftell(&pb) + 4 < pos + data_len) {
119	int tlv_len = get_be16(&pb);	119	int tlv_len = avio_rb16(&pb);
120	tag = get_le16(&pb);	120	tag = avio_rl16(&pb);
121	if (url_ftell(&pb) + tlv_len > pos + data_len)	121	if (url_ftell(&pb) + tlv_len > pos + data_len)
122	return AVERROR_INVALIDDATA;	122	return AVERROR_INVALIDDATA;
123		123

libavformat/rtsp.c+1−1

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

libavformat/sauce.c+10−10

@@ -36,13 +36,13 @@ int ff_sauce_read(AVFormatContext avctx, uint64_t fsize, int *got_width, int g · 35 unmodified lines
36	uint64_t start_pos = url_fsize(pb) - 128;	36	uint64_t start_pos = url_fsize(pb) - 128;
37		37
38	url_fseek(pb, start_pos, SEEK_SET);	38	url_fseek(pb, start_pos, SEEK_SET);
39	if (get_buffer(pb, buf, 7) != 7)	39	if (avio_read(pb, buf, 7) != 7)
40	return -1;	40	return -1;
41	if (memcmp(buf, "SAUCE00", 7))	41	if (memcmp(buf, "SAUCE00", 7))
42	return -1;	42	return -1;
43		43
44	#define GET_SAUCE_META(name,size) \	44	#define GET_SAUCE_META(name,size) \
45	if (get_buffer(pb, buf, size) == size && buf[0]) { \	45	if (avio_read(pb, buf, size) == size && buf[0]) { \
46	buf[size] = 0; \	46	buf[size] = 0; \
47	av_metadata_set2(&avctx->metadata, name, buf, 0); \	47	av_metadata_set2(&avctx->metadata, name, buf, 0); \
48	}	48	}
@@ -52,12 +52,12 @@ int ff_sauce_read(AVFormatContext avctx, uint64_t fsize, int *got_width, int g · 3 unmodified lines
52	GET_SAUCE_META("publisher", 20)	52	GET_SAUCE_META("publisher", 20)
53	GET_SAUCE_META("date", 8)	53	GET_SAUCE_META("date", 8)
54	url_fskip(pb, 4);	54	url_fskip(pb, 4);
55	datatype = get_byte(pb);	55	datatype = avio_r8(pb);
56	filetype = get_byte(pb);	56	filetype = avio_r8(pb);
57	t1 = get_le16(pb);	57	t1 = avio_rl16(pb);
58	t2 = get_le16(pb);	58	t2 = avio_rl16(pb);
59	nb_comments = get_byte(pb);	59	nb_comments = avio_r8(pb);
60	flags = get_byte(pb);	60	flags = avio_r8(pb);
61	url_fskip(pb, 4);	61	url_fskip(pb, 4);
62	GET_SAUCE_META("encoder", 22);	62	GET_SAUCE_META("encoder", 22);
63		63
@@ -83,14 +83,14 @@ int ff_sauce_read(AVFormatContext avctx, uint64_t fsize, int *got_width, int g · 19 unmodified lines
83		83
84	if (nb_comments > 0) {	84	if (nb_comments > 0) {
85	url_fseek(pb, start_pos - 64*nb_comments - 5, SEEK_SET);	85	url_fseek(pb, start_pos - 64*nb_comments - 5, SEEK_SET);
86	if (get_buffer(pb, buf, 5) == 5 && !memcmp(buf, "COMNT", 5)) {	86	if (avio_read(pb, buf, 5) == 5 && !memcmp(buf, "COMNT", 5)) {
87	int i;	87	int i;
88	char str = av_malloc(65nb_comments + 1);	88	char str = av_malloc(65nb_comments + 1);
89	fsize -= 64nb_comments + 5;	89	fsize -= 64nb_comments + 5;
90	if (!str)	90	if (!str)
91	return 0;	91	return 0;
92	for (i = 0; i < nb_comments; i++) {	92	for (i = 0; i < nb_comments; i++) {
93	if (get_buffer(pb, str + 65*i, 64) != 64)	93	if (avio_read(pb, str + 65*i, 64) != 64)
94	break;	94	break;
95	str[65*i + 64] = '\n';	95	str[65*i + 64] = '\n';
96	}	96	}

libavformat/segafilm.c+7−7

@@ -89,7 +89,7 @@ static int film_read_header(AVFormatContext *s, · 88 unmodified lines
89	film->stereo_buffer_size = 0;	89	film->stereo_buffer_size = 0;
90		90
91	/* load the main FILM header */	91	/* load the main FILM header */
92	if (get_buffer(pb, scratch, 16) != 16)	92	if (avio_read(pb, scratch, 16) != 16)
93	return AVERROR(EIO);	93	return AVERROR(EIO);
94	data_offset = AV_RB32(&scratch[4]);	94	data_offset = AV_RB32(&scratch[4]);
95	film->version = AV_RB32(&scratch[8]);	95	film->version = AV_RB32(&scratch[8]);
@@ -97,7 +97,7 @@ static int film_read_header(AVFormatContext *s, · 1 unmodified line
97	/* load the FDSC chunk */	97	/* load the FDSC chunk */
98	if (film->version == 0) {	98	if (film->version == 0) {
99	/* special case for Lemmings .film files; 20-byte header */	99	/* special case for Lemmings .film files; 20-byte header */
100	if (get_buffer(pb, scratch, 20) != 20)	100	if (avio_read(pb, scratch, 20) != 20)
101	return AVERROR(EIO);	101	return AVERROR(EIO);
102	/* make some assumptions about the audio parameters */	102	/* make some assumptions about the audio parameters */
103	film->audio_type = CODEC_ID_PCM_S8;	103	film->audio_type = CODEC_ID_PCM_S8;
@@ -106,7 +106,7 @@ static int film_read_header(AVFormatContext *s, · 2 unmodified lines
106	film->audio_bits = 8;	106	film->audio_bits = 8;
107	} else {	107	} else {
108	/* normal Saturn .cpk files; 32-byte header */	108	/* normal Saturn .cpk files; 32-byte header */
109	if (get_buffer(pb, scratch, 32) != 32)	109	if (avio_read(pb, scratch, 32) != 32)
110	return AVERROR(EIO);	110	return AVERROR(EIO);
111	film->audio_samplerate = AV_RB16(&scratch[24]);	111	film->audio_samplerate = AV_RB16(&scratch[24]);
112	film->audio_channels = scratch[21];	112	film->audio_channels = scratch[21];
@@ -158,7 +158,7 @@ static int film_read_header(AVFormatContext *s, · 45 unmodified lines
158	}	158	}
159		159
160	/* load the sample table */	160	/* load the sample table */
161	if (get_buffer(pb, scratch, 16) != 16)	161	if (avio_read(pb, scratch, 16) != 16)
162	return AVERROR(EIO);	162	return AVERROR(EIO);
163	if (AV_RB32(&scratch[0]) != STAB_TAG)	163	if (AV_RB32(&scratch[0]) != STAB_TAG)
164	return AVERROR_INVALIDDATA;	164	return AVERROR_INVALIDDATA;
@@ -174,7 +174,7 @@ static int film_read_header(AVFormatContext *s, · 9 unmodified lines
174	audio_frame_counter = 0;	174	audio_frame_counter = 0;
175	for (i = 0; i < film->sample_count; i++) {	175	for (i = 0; i < film->sample_count; i++) {
176	/* load the next sample record and transfer it to an internal struct */	176	/* load the next sample record and transfer it to an internal struct */
177	if (get_buffer(pb, scratch, 16) != 16) {	177	if (avio_read(pb, scratch, 16) != 16) {
178	av_free(film->sample_table);	178	av_free(film->sample_table);
179	return AVERROR(EIO);	179	return AVERROR(EIO);
180	}	180	}
@@ -225,7 +225,7 @@ static int film_read_packet(AVFormatContext *s, · 44 unmodified lines
225	pkt->pos= url_ftell(pb);	225	pkt->pos= url_ftell(pb);
226	if (av_new_packet(pkt, sample->sample_size))	226	if (av_new_packet(pkt, sample->sample_size))
227	return AVERROR(ENOMEM);	227	return AVERROR(ENOMEM);
228	get_buffer(pb, pkt->data, sample->sample_size);	228	avio_read(pb, pkt->data, sample->sample_size);
229	} else if ((sample->stream == film->audio_stream_index) &&	229	} else if ((sample->stream == film->audio_stream_index) &&
230	(film->audio_channels == 2)) {	230	(film->audio_channels == 2)) {
231	/* stereo PCM needs to be interleaved */	231	/* stereo PCM needs to be interleaved */
@@ -241,7 +241,7 @@ static int film_read_packet(AVFormatContext *s, · 9 unmodified lines
241	}	241	}
242		242
243	pkt->pos= url_ftell(pb);	243	pkt->pos= url_ftell(pb);
244	ret = get_buffer(pb, film->stereo_buffer, sample->sample_size);	244	ret = avio_read(pb, film->stereo_buffer, sample->sample_size);
245	if (ret != sample->sample_size)	245	if (ret != sample->sample_size)
246	ret = AVERROR(EIO);	246	ret = AVERROR(EIO);
247		247

libavformat/sierravmd.c+5−5

@@ -96,7 +96,7 @@ static int vmd_read_header(AVFormatContext *s, · 95 unmodified lines
96		96
97	/* fetch the main header, including the 2 header length bytes */	97	/* fetch the main header, including the 2 header length bytes */
98	url_fseek(pb, 0, SEEK_SET);	98	url_fseek(pb, 0, SEEK_SET);
99	if (get_buffer(pb, vmd->vmd_header, VMD_HEADER_SIZE) != VMD_HEADER_SIZE)	99	if (avio_read(pb, vmd->vmd_header, VMD_HEADER_SIZE) != VMD_HEADER_SIZE)
100	return AVERROR(EIO);	100	return AVERROR(EIO);
101		101
102	if(vmd->vmd_header[16] == 'i' && vmd->vmd_header[17] == 'v' && vmd->vmd_header[18] == '3')	102	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, · 69 unmodified lines
172	av_free(vmd->frame_table);	172	av_free(vmd->frame_table);
173	return AVERROR(ENOMEM);	173	return AVERROR(ENOMEM);
174	}	174	}
175	if (get_buffer(pb, raw_frame_table, raw_frame_table_size) !=	175	if (avio_read(pb, raw_frame_table, raw_frame_table_size) !=
176	raw_frame_table_size) {	176	raw_frame_table_size) {
177	av_free(raw_frame_table);	177	av_free(raw_frame_table);
178	av_free(vmd->frame_table);	178	av_free(vmd->frame_table);
@@ -189,7 +189,7 @@ static int vmd_read_header(AVFormatContext *s, · 10 unmodified lines
189	int type;	189	int type;
190	uint32_t size;	190	uint32_t size;
191		191
192	get_buffer(pb, chunk, BYTES_PER_FRAME_RECORD);	192	avio_read(pb, chunk, BYTES_PER_FRAME_RECORD);
193	type = chunk[0];	193	type = chunk[0];
194	size = AV_RL32(&chunk[2]);	194	size = AV_RL32(&chunk[2]);
195	if(!size && type != 1)	195	if(!size && type != 1)
@@ -250,9 +250,9 @@ static int vmd_read_packet(AVFormatContext *s, · 54 unmodified lines
250	pkt->pos= url_ftell(pb);	250	pkt->pos= url_ftell(pb);
251	memcpy(pkt->data, frame->frame_record, BYTES_PER_FRAME_RECORD);	251	memcpy(pkt->data, frame->frame_record, BYTES_PER_FRAME_RECORD);
252	if(vmd->is_indeo3)	252	if(vmd->is_indeo3)
253	ret = get_buffer(pb, pkt->data, frame->frame_size);	253	ret = avio_read(pb, pkt->data, frame->frame_size);
254	else	254	else
255	ret = get_buffer(pb, pkt->data + BYTES_PER_FRAME_RECORD,	255	ret = avio_read(pb, pkt->data + BYTES_PER_FRAME_RECORD,
256	frame->frame_size);	256	frame->frame_size);
257		257
258	if (ret != frame->frame_size) {	258	if (ret != frame->frame_size) {

libavformat/siff.c+20−20

@@ -89,28 +89,28 @@ static int siff_parse_vbv1(AVFormatContext s, SIFFContext c, AVIOContext *pb) · 88 unmodified lines
89	AVStream *st;	89	AVStream *st;
90	int width, height;	90	int width, height;
91		91
92	if (get_le32(pb) != TAG_VBHD){	92	if (avio_rl32(pb) != TAG_VBHD){
93	av_log(s, AV_LOG_ERROR, "Header chunk is missing\n");	93	av_log(s, AV_LOG_ERROR, "Header chunk is missing\n");
94	return -1;	94	return -1;
95	}	95	}
96	if(get_be32(pb) != 32){	96	if(avio_rb32(pb) != 32){
97	av_log(s, AV_LOG_ERROR, "Header chunk size is incorrect\n");	97	av_log(s, AV_LOG_ERROR, "Header chunk size is incorrect\n");
98	return -1;	98	return -1;
99	}	99	}
100	if(get_le16(pb) != 1){	100	if(avio_rl16(pb) != 1){
101	av_log(s, AV_LOG_ERROR, "Incorrect header version\n");	101	av_log(s, AV_LOG_ERROR, "Incorrect header version\n");
102	return -1;	102	return -1;
103	}	103	}
104	width = get_le16(pb);	104	width = avio_rl16(pb);
105	height = get_le16(pb);	105	height = avio_rl16(pb);
106	url_fskip(pb, 4);	106	url_fskip(pb, 4);
107	c->frames = get_le16(pb);	107	c->frames = avio_rl16(pb);
108	if(!c->frames){	108	if(!c->frames){
109	av_log(s, AV_LOG_ERROR, "File contains no frames ???\n");	109	av_log(s, AV_LOG_ERROR, "File contains no frames ???\n");
110	return -1;	110	return -1;
111	}	111	}
112	c->bits = get_le16(pb);	112	c->bits = avio_rl16(pb);
113	c->rate = get_le16(pb);	113	c->rate = avio_rl16(pb);
114	c->block_align = c->rate * (c->bits >> 3);	114	c->block_align = c->rate * (c->bits >> 3);
115		115
116	url_fskip(pb, 16); //zeroes	116	url_fskip(pb, 16); //zeroes
@@ -137,17 +137,17 @@ static int siff_parse_vbv1(AVFormatContext s, SIFFContext c, AVIOContext *pb) · 20 unmodified lines
137		137
138	static int siff_parse_soun(AVFormatContext s, SIFFContext c, AVIOContext *pb)	138	static int siff_parse_soun(AVFormatContext s, SIFFContext c, AVIOContext *pb)
139	{	139	{
140	if (get_le32(pb) != TAG_SHDR){	140	if (avio_rl32(pb) != TAG_SHDR){
141	av_log(s, AV_LOG_ERROR, "Header chunk is missing\n");	141	av_log(s, AV_LOG_ERROR, "Header chunk is missing\n");
142	return -1;	142	return -1;
143	}	143	}
144	if(get_be32(pb) != 8){	144	if(avio_rb32(pb) != 8){
145	av_log(s, AV_LOG_ERROR, "Header chunk size is incorrect\n");	145	av_log(s, AV_LOG_ERROR, "Header chunk size is incorrect\n");
146	return -1;	146	return -1;
147	}	147	}
148	url_fskip(pb, 4); //unknown value	148	url_fskip(pb, 4); //unknown value
149	c->rate = get_le16(pb);	149	c->rate = avio_rl16(pb);
150	c->bits = get_le16(pb);	150	c->bits = avio_rl16(pb);
151	c->block_align = c->rate * (c->bits >> 3);	151	c->block_align = c->rate * (c->bits >> 3);
152	return create_audio_stream(s, c);	152	return create_audio_stream(s, c);
153	}	153	}
@@ -158,10 +158,10 @@ static int siff_read_header(AVFormatContext s, AVFormatParameters ap) · 4 unmodified lines
158	SIFFContext *c = s->priv_data;	158	SIFFContext *c = s->priv_data;
159	uint32_t tag;	159	uint32_t tag;
160		160
161	if (get_le32(pb) != TAG_SIFF)	161	if (avio_rl32(pb) != TAG_SIFF)
162	return -1;	162	return -1;
163	url_fskip(pb, 4); //ignore size	163	url_fskip(pb, 4); //ignore size
164	tag = get_le32(pb);	164	tag = avio_rl32(pb);
165		165
166	if (tag != TAG_VBV1 && tag != TAG_SOUN){	166	if (tag != TAG_VBV1 && tag != TAG_SOUN){
167	av_log(s, AV_LOG_ERROR, "Not a VBV file\n");	167	av_log(s, AV_LOG_ERROR, "Not a VBV file\n");
@@ -172,7 +172,7 @@ static int siff_read_header(AVFormatContext s, AVFormatParameters ap) · 4 unmodified lines
172	return -1;	172	return -1;
173	if (tag == TAG_SOUN && siff_parse_soun(s, c, pb) < 0)	173	if (tag == TAG_SOUN && siff_parse_soun(s, c, pb) < 0)
174	return -1;	174	return -1;
175	if (get_le32(pb) != MKTAG('B', 'O', 'D', 'Y')){	175	if (avio_rl32(pb) != MKTAG('B', 'O', 'D', 'Y')){
176	av_log(s, AV_LOG_ERROR, "'BODY' chunk is missing\n");	176	av_log(s, AV_LOG_ERROR, "'BODY' chunk is missing\n");
177	return -1;	177	return -1;
178	}	178	}
@@ -190,12 +190,12 @@ static int siff_read_packet(AVFormatContext s, AVPacket pkt) · 11 unmodified lines
190	if (c->cur_frame >= c->frames)	190	if (c->cur_frame >= c->frames)
191	return AVERROR(EIO);	191	return AVERROR(EIO);
192	if (c->curstrm == -1){	192	if (c->curstrm == -1){
193	c->pktsize = get_le32(s->pb) - 4;	193	c->pktsize = avio_rl32(s->pb) - 4;
194	c->flags = get_le16(s->pb);	194	c->flags = avio_rl16(s->pb);
195	c->gmcsize = (c->flags & VB_HAS_GMC) ? 4 : 0;	195	c->gmcsize = (c->flags & VB_HAS_GMC) ? 4 : 0;
196	if (c->gmcsize)	196	if (c->gmcsize)
197	get_buffer(s->pb, c->gmc, c->gmcsize);	197	avio_read(s->pb, c->gmc, c->gmcsize);
198	c->sndsize = (c->flags & VB_HAS_AUDIO) ? get_le32(s->pb): 0;	198	c->sndsize = (c->flags & VB_HAS_AUDIO) ? avio_rl32(s->pb): 0;
199	c->curstrm = !!(c->flags & VB_HAS_AUDIO);	199	c->curstrm = !!(c->flags & VB_HAS_AUDIO);
200	}	200	}
201		201
@@ -206,7 +206,7 @@ static int siff_read_packet(AVFormatContext s, AVPacket pkt) · 4 unmodified lines
206	AV_WL16(pkt->data, c->flags);	206	AV_WL16(pkt->data, c->flags);
207	if (c->gmcsize)	207	if (c->gmcsize)
208	memcpy(pkt->data + 2, c->gmc, c->gmcsize);	208	memcpy(pkt->data + 2, c->gmc, c->gmcsize);
209	get_buffer(s->pb, pkt->data + 2 + c->gmcsize, size - c->gmcsize - 2);	209	avio_read(s->pb, pkt->data + 2 + c->gmcsize, size - c->gmcsize - 2);
210	pkt->stream_index = 0;	210	pkt->stream_index = 0;
211	c->curstrm = -1;	211	c->curstrm = -1;
212	}else{	212	}else{

libavformat/smacker.c+25−25

@@ -105,19 +105,19 @@ static int smacker_read_header(AVFormatContext s, AVFormatParameters ap) · 104 unmodified lines
105	int tbase;	105	int tbase;
106		106
107	/* read and check header */	107	/* read and check header */
108	smk->magic = get_le32(pb);	108	smk->magic = avio_rl32(pb);
109	if (smk->magic != MKTAG('S', 'M', 'K', '2') && smk->magic != MKTAG('S', 'M', 'K', '4'))	109	if (smk->magic != MKTAG('S', 'M', 'K', '2') && smk->magic != MKTAG('S', 'M', 'K', '4'))
110	return -1;	110	return -1;
111	smk->width = get_le32(pb);	111	smk->width = avio_rl32(pb);
112	smk->height = get_le32(pb);	112	smk->height = avio_rl32(pb);
113	smk->frames = get_le32(pb);	113	smk->frames = avio_rl32(pb);
114	smk->pts_inc = (int32_t)get_le32(pb);	114	smk->pts_inc = (int32_t)avio_rl32(pb);
115	smk->flags = get_le32(pb);	115	smk->flags = avio_rl32(pb);
116	if(smk->flags & SMACKER_FLAG_RING_FRAME)	116	if(smk->flags & SMACKER_FLAG_RING_FRAME)
117	smk->frames++;	117	smk->frames++;
118	for(i = 0; i < 7; i++)	118	for(i = 0; i < 7; i++)
119	smk->audio[i] = get_le32(pb);	119	smk->audio[i] = avio_rl32(pb);
120	smk->treesize = get_le32(pb);	120	smk->treesize = avio_rl32(pb);
121		121
122	if(smk->treesize >= UINT_MAX/4){ // smk->treesize + 16 must not overflow (this check is probably redundant)	122	if(smk->treesize >= UINT_MAX/4){ // smk->treesize + 16 must not overflow (this check is probably redundant)
123	av_log(s, AV_LOG_ERROR, "treesize too large\n");	123	av_log(s, AV_LOG_ERROR, "treesize too large\n");
@@ -125,13 +125,13 @@ static int smacker_read_header(AVFormatContext s, AVFormatParameters ap) · 1 unmodified line
125	}	125	}
126		126
127	//FIXME remove extradata "rebuilding"	127	//FIXME remove extradata "rebuilding"
128	smk->mmap_size = get_le32(pb);	128	smk->mmap_size = avio_rl32(pb);
129	smk->mclr_size = get_le32(pb);	129	smk->mclr_size = avio_rl32(pb);
130	smk->full_size = get_le32(pb);	130	smk->full_size = avio_rl32(pb);
131	smk->type_size = get_le32(pb);	131	smk->type_size = avio_rl32(pb);
132	for(i = 0; i < 7; i++)	132	for(i = 0; i < 7; i++)
133	smk->rates[i] = get_le32(pb);	133	smk->rates[i] = avio_rl32(pb);
134	smk->pad = get_le32(pb);	134	smk->pad = avio_rl32(pb);
135	/* setup data */	135	/* setup data */
136	if(smk->frames > 0xFFFFFF) {	136	if(smk->frames > 0xFFFFFF) {
137	av_log(s, AV_LOG_ERROR, "Too many frames: %i\n", smk->frames);	137	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) · 6 unmodified lines
144		144
145	/* read frame info */	145	/* read frame info */
146	for(i = 0; i < smk->frames; i++) {	146	for(i = 0; i < smk->frames; i++) {
147	smk->frm_size[i] = get_le32(pb);	147	smk->frm_size[i] = avio_rl32(pb);
148	}	148	}
149	for(i = 0; i < smk->frames; i++) {	149	for(i = 0; i < smk->frames; i++) {
150	smk->frm_flags[i] = get_byte(pb);	150	smk->frm_flags[i] = avio_r8(pb);
151	}	151	}
152		152
153	/* init video codec */	153	/* init video codec */
@@ -207,7 +207,7 @@ static int smacker_read_header(AVFormatContext s, AVFormatParameters ap) · 53 unmodified lines
207	av_free(smk->frm_flags);	207	av_free(smk->frm_flags);
208	return -1;	208	return -1;
209	}	209	}
210	ret = get_buffer(pb, st->codec->extradata + 16, st->codec->extradata_size - 16);	210	ret = avio_read(pb, st->codec->extradata + 16, st->codec->extradata_size - 16);
211	if(ret != st->codec->extradata_size - 16){	211	if(ret != st->codec->extradata_size - 16){
212	av_free(smk->frm_size);	212	av_free(smk->frm_size);
213	av_free(smk->frm_flags);	213	av_free(smk->frm_flags);
@@ -251,19 +251,19 @@ static int smacker_read_packet(AVFormatContext s, AVPacket pkt) · 37 unmodified lines
251	uint8_t oldpal[768];	251	uint8_t oldpal[768];
252		252
253	memcpy(oldpal, pal, 768);	253	memcpy(oldpal, pal, 768);
254	size = get_byte(s->pb);	254	size = avio_r8(s->pb);
255	size = size * 4 - 1;	255	size = size * 4 - 1;
256	frame_size -= size;	256	frame_size -= size;
257	frame_size--;	257	frame_size--;
258	sz = 0;	258	sz = 0;
259	pos = url_ftell(s->pb) + size;	259	pos = url_ftell(s->pb) + size;
260	while(sz < 256){	260	while(sz < 256){
261	t = get_byte(s->pb);	261	t = avio_r8(s->pb);
262	if(t & 0x80){ /* skip palette entries */	262	if(t & 0x80){ /* skip palette entries */
263	sz += (t & 0x7F) + 1;	263	sz += (t & 0x7F) + 1;
264	pal += ((t & 0x7F) + 1) * 3;	264	pal += ((t & 0x7F) + 1) * 3;
265	} else if(t & 0x40){ /* copy with offset */	265	} else if(t & 0x40){ /* copy with offset */
266	off = get_byte(s->pb) * 3;	266	off = avio_r8(s->pb) * 3;
267	j = (t & 0x3F) + 1;	267	j = (t & 0x3F) + 1;
268	while(j-- && sz < 256) {	268	while(j-- && sz < 256) {
269	*pal++ = oldpal[off + 0];	269	*pal++ = oldpal[off + 0];
@@ -274,8 +274,8 @@ static int smacker_read_packet(AVFormatContext s, AVPacket pkt) · 4 unmodified lines
274	}	274	}
275	} else { /* new entries */	275	} else { /* new entries */
276	*pal++ = smk_pal[t];	276	*pal++ = smk_pal[t];
277	*pal++ = smk_pal[get_byte(s->pb) & 0x3F];	277	*pal++ = smk_pal[avio_r8(s->pb) & 0x3F];
278	*pal++ = smk_pal[get_byte(s->pb) & 0x3F];	278	*pal++ = smk_pal[avio_r8(s->pb) & 0x3F];
279	sz++;	279	sz++;
280	}	280	}
281	}	281	}
@@ -288,13 +288,13 @@ static int smacker_read_packet(AVFormatContext s, AVPacket pkt) · 6 unmodified lines
288	for(i = 0; i < 7; i++) {	288	for(i = 0; i < 7; i++) {
289	if(flags & 1) {	289	if(flags & 1) {
290	int size;	290	int size;
291	size = get_le32(s->pb) - 4;	291	size = avio_rl32(s->pb) - 4;
292	frame_size -= size;	292	frame_size -= size;
293	frame_size -= 4;	293	frame_size -= 4;
294	smk->curstream++;	294	smk->curstream++;
295	smk->bufs[smk->curstream] = av_realloc(smk->bufs[smk->curstream], size);	295	smk->bufs[smk->curstream] = av_realloc(smk->bufs[smk->curstream], size);
296	smk->buf_sizes[smk->curstream] = size;	296	smk->buf_sizes[smk->curstream] = size;
297	ret = get_buffer(s->pb, smk->bufs[smk->curstream], size);	297	ret = avio_read(s->pb, smk->bufs[smk->curstream], size);
298	if(ret != size)	298	if(ret != size)
299	return AVERROR(EIO);	299	return AVERROR(EIO);
300	smk->stream_id[smk->curstream] = smk->indexes[i];	300	smk->stream_id[smk->curstream] = smk->indexes[i];
@@ -307,7 +307,7 @@ static int smacker_read_packet(AVFormatContext s, AVPacket pkt) · 6 unmodified lines
307	palchange \|= 2;	307	palchange \|= 2;
308	pkt->data[0] = palchange;	308	pkt->data[0] = palchange;
309	memcpy(pkt->data + 1, smk->pal, 768);	309	memcpy(pkt->data + 1, smk->pal, 768);
310	ret = get_buffer(s->pb, pkt->data + 769, frame_size);	310	ret = avio_read(s->pb, pkt->data + 769, frame_size);
311	if(ret != frame_size)	311	if(ret != frame_size)
312	return AVERROR(EIO);	312	return AVERROR(EIO);
313	pkt->stream_index = smk->videoindex;	313	pkt->stream_index = smk->videoindex;

libavformat/sol.c+6−6

@@ -93,15 +93,15 @@ static int sol_read_header(AVFormatContext *s, · 92 unmodified lines
93	AVStream *st;	93	AVStream *st;
94		94
95	/* check ".snd" header */	95	/* check ".snd" header */
96	magic = get_le16(pb);	96	magic = avio_rl16(pb);
97	tag = get_le32(pb);	97	tag = avio_rl32(pb);
98	if (tag != MKTAG('S', 'O', 'L', 0))	98	if (tag != MKTAG('S', 'O', 'L', 0))
99	return -1;	99	return -1;
100	rate = get_le16(pb);	100	rate = avio_rl16(pb);
101	type = get_byte(pb);	101	type = avio_r8(pb);
102	size = get_le32(pb);	102	size = avio_rl32(pb);
103	if (magic != 0x0B8D)	103	if (magic != 0x0B8D)
104	get_byte(pb); /* newer SOLs contain padding byte */	104	avio_r8(pb); /* newer SOLs contain padding byte */
105		105
106	codec = sol_codec_id(magic, type);	106	codec = sol_codec_id(magic, type);
107	channels = sol_channels(magic, type);	107	channels = sol_channels(magic, type);

libavformat/soxdec.c+10−10

@@ -55,20 +55,20 @@ static int sox_read_header(AVFormatContext *s, · 54 unmodified lines
55		55
56	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;	56	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
57		57
58	if (get_le32(pb) == SOX_TAG) {	58	if (avio_rl32(pb) == SOX_TAG) {
59	st->codec->codec_id = CODEC_ID_PCM_S32LE;	59	st->codec->codec_id = CODEC_ID_PCM_S32LE;
60	header_size = get_le32(pb);	60	header_size = avio_rl32(pb);
61	url_fskip(pb, 8); /* sample count */	61	url_fskip(pb, 8); /* sample count */
62	sample_rate = av_int2dbl(get_le64(pb));	62	sample_rate = av_int2dbl(avio_rl64(pb));
63	st->codec->channels = get_le32(pb);	63	st->codec->channels = avio_rl32(pb);
64	comment_size = get_le32(pb);	64	comment_size = avio_rl32(pb);
65	} else {	65	} else {
66	st->codec->codec_id = CODEC_ID_PCM_S32BE;	66	st->codec->codec_id = CODEC_ID_PCM_S32BE;
67	header_size = get_be32(pb);	67	header_size = avio_rb32(pb);
68	url_fskip(pb, 8); /* sample count */	68	url_fskip(pb, 8); /* sample count */
69	sample_rate = av_int2dbl(get_be64(pb));	69	sample_rate = av_int2dbl(avio_rb64(pb));
70	st->codec->channels = get_be32(pb);	70	st->codec->channels = avio_rb32(pb);
71	comment_size = get_be32(pb);	71	comment_size = avio_rb32(pb);
72	}	72	}
73		73
74	if (comment_size > 0xFFFFFFFFU - SOX_FIXED_HDR - 4U) {	74	if (comment_size > 0xFFFFFFFFU - SOX_FIXED_HDR - 4U) {
@@ -95,7 +95,7 @@ static int sox_read_header(AVFormatContext *s, · 20 unmodified lines
95		95
96	if (comment_size && comment_size < UINT_MAX) {	96	if (comment_size && comment_size < UINT_MAX) {
97	char *comment = av_malloc(comment_size+1);	97	char *comment = av_malloc(comment_size+1);
98	if (get_buffer(pb, comment, comment_size) != comment_size) {	98	if (avio_read(pb, comment, comment_size) != comment_size) {
99	av_freep(&comment);	99	av_freep(&comment);
100	return AVERROR(EIO);	100	return AVERROR(EIO);
101	}	101	}

libavformat/spdifdec.c+4−4

@@ -170,13 +170,13 @@ static int spdif_read_packet(AVFormatContext s, AVPacket pkt) · 169 unmodified lines
170	int pkt_size_bits, offset, ret;	170	int pkt_size_bits, offset, ret;
171		171
172	while (state != (AV_BSWAP16C(SYNCWORD1) << 16 \| AV_BSWAP16C(SYNCWORD2))) {	172	while (state != (AV_BSWAP16C(SYNCWORD1) << 16 \| AV_BSWAP16C(SYNCWORD2))) {
173	state = (state << 8) \| get_byte(pb);	173	state = (state << 8) \| avio_r8(pb);
174	if (url_feof(pb))	174	if (url_feof(pb))
175	return AVERROR_EOF;	175	return AVERROR_EOF;
176	}	176	}
177		177
178	data_type = get_le16(pb);	178	data_type = avio_rl16(pb);
179	pkt_size_bits = get_le16(pb);	179	pkt_size_bits = avio_rl16(pb);
180		180
181	if (pkt_size_bits % 16)	181	if (pkt_size_bits % 16)
182	av_log_ask_for_sample(s, "Packet does not end to a 16-bit boundary.");	182	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) · 4 unmodified lines
187		187
188	pkt->pos = url_ftell(pb) - BURST_HEADER_SIZE;	188	pkt->pos = url_ftell(pb) - BURST_HEADER_SIZE;
189		189
190	if (get_buffer(pb, pkt->data, pkt->size) < pkt->size) {	190	if (avio_read(pb, pkt->data, pkt->size) < pkt->size) {
191	av_free_packet(pkt);	191	av_free_packet(pkt);
192	return AVERROR_EOF;	192	return AVERROR_EOF;
193	}	193	}

libavformat/swfdec.c+22−22

@@ -30,11 +30,11 @@ static int get_swf_tag(AVIOContext pb, int len_ptr) · 29 unmodified lines
30	if (url_feof(pb))	30	if (url_feof(pb))
31	return -1;	31	return -1;
32		32
33	tag = get_le16(pb);	33	tag = avio_rl16(pb);
34	len = tag & 0x3f;	34	len = tag & 0x3f;
35	tag = tag >> 6;	35	tag = tag >> 6;
36	if (len == 0x3f) {	36	if (len == 0x3f) {
37	len = get_le32(pb);	37	len = avio_rl32(pb);
38	}	38	}
39	// av_log(NULL, AV_LOG_DEBUG, "Tag: %d - Len: %d\n", tag, len);	39	// av_log(NULL, AV_LOG_DEBUG, "Tag: %d - Len: %d\n", tag, len);
40	*len_ptr = len;	40	*len_ptr = len;
@@ -58,7 +58,7 @@ static int swf_read_header(AVFormatContext s, AVFormatParameters ap) · 17 unmodified lines
58	AVIOContext *pb = s->pb;	58	AVIOContext *pb = s->pb;
59	int nbits, len, tag;	59	int nbits, len, tag;
60		60
61	tag = get_be32(pb) & 0xffffff00;	61	tag = avio_rb32(pb) & 0xffffff00;
62		62
63	if (tag == MKBETAG('C', 'W', 'S', 0)) {	63	if (tag == MKBETAG('C', 'W', 'S', 0)) {
64	av_log(s, AV_LOG_ERROR, "Compressed SWF format not supported\n");	64	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) · 1 unmodified line
66	}	66	}
67	if (tag != MKBETAG('F', 'W', 'S', 0))	67	if (tag != MKBETAG('F', 'W', 'S', 0))
68	return AVERROR(EIO);	68	return AVERROR(EIO);
69	get_le32(pb);	69	avio_rl32(pb);
70	/* skip rectangle size */	70	/* skip rectangle size */
71	nbits = get_byte(pb) >> 3;	71	nbits = avio_r8(pb) >> 3;
72	len = (4 * nbits - 3 + 7) / 8;	72	len = (4 * nbits - 3 + 7) / 8;
73	url_fskip(pb, len);	73	url_fskip(pb, len);
74	swf->frame_rate = get_le16(pb); /* 8.8 fixed */	74	swf->frame_rate = avio_rl16(pb); /* 8.8 fixed */
75	get_le16(pb); /* frame count */	75	avio_rl16(pb); /* frame count */
76		76
77	swf->samples_per_frame = 0;	77	swf->samples_per_frame = 0;
78	s->ctx_flags \|= AVFMTCTX_NOHEADER;	78	s->ctx_flags \|= AVFMTCTX_NOHEADER;
@@ -92,7 +92,7 @@ static int swf_read_packet(AVFormatContext s, AVPacket pkt) · 13 unmodified lines
92	if (tag < 0)	92	if (tag < 0)
93	return AVERROR(EIO);	93	return AVERROR(EIO);
94	if (tag == TAG_VIDEOSTREAM) {	94	if (tag == TAG_VIDEOSTREAM) {
95	int ch_id = get_le16(pb);	95	int ch_id = avio_rl16(pb);
96	len -= 2;	96	len -= 2;
97		97
98	for (i=0; i<s->nb_streams; i++) {	98	for (i=0; i<s->nb_streams; i++) {
@@ -101,16 +101,16 @@ static int swf_read_packet(AVFormatContext s, AVPacket pkt) · 2 unmodified lines
101	goto skip;	101	goto skip;
102	}	102	}
103		103
104	get_le16(pb);	104	avio_rl16(pb);
105	get_le16(pb);	105	avio_rl16(pb);
106	get_le16(pb);	106	avio_rl16(pb);
107	get_byte(pb);	107	avio_r8(pb);
108	/* Check for FLV1 */	108	/* Check for FLV1 */
109	vst = av_new_stream(s, ch_id);	109	vst = av_new_stream(s, ch_id);
110	if (!vst)	110	if (!vst)
111	return -1;	111	return -1;
112	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;	112	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
113	vst->codec->codec_id = ff_codec_get_id(swf_codec_tags, get_byte(pb));	113	vst->codec->codec_id = ff_codec_get_id(swf_codec_tags, avio_r8(pb));
114	av_set_pts_info(vst, 16, 256, swf->frame_rate);	114	av_set_pts_info(vst, 16, 256, swf->frame_rate);
115	vst->codec->time_base = (AVRational){ 256, swf->frame_rate };	115	vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
116	len -= 8;	116	len -= 8;
@@ -124,9 +124,9 @@ static int swf_read_packet(AVFormatContext s, AVPacket pkt) · 7 unmodified lines
124	goto skip;	124	goto skip;
125	}	125	}
126		126
127	get_byte(pb);	127	avio_r8(pb);
128	v = get_byte(pb);	128	v = avio_r8(pb);
129	swf->samples_per_frame = get_le16(pb);	129	swf->samples_per_frame = avio_rl16(pb);
130	ast = av_new_stream(s, -1); /* -1 to avoid clash with video stream ch_id */	130	ast = av_new_stream(s, -1); /* -1 to avoid clash with video stream ch_id */
131	if (!ast)	131	if (!ast)
132	return -1;	132	return -1;
@@ -141,12 +141,12 @@ static int swf_read_packet(AVFormatContext s, AVPacket pkt) · 8 unmodified lines
141	av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);	141	av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
142	len -= 4;	142	len -= 4;
143	} else if (tag == TAG_VIDEOFRAME) {	143	} else if (tag == TAG_VIDEOFRAME) {
144	int ch_id = get_le16(pb);	144	int ch_id = avio_rl16(pb);
145	len -= 2;	145	len -= 2;
146	for(i=0; i<s->nb_streams; i++) {	146	for(i=0; i<s->nb_streams; i++) {
147	st = s->streams[i];	147	st = s->streams[i];
148	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {	148	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {
149	frame = get_le16(pb);	149	frame = avio_rl16(pb);
150	av_get_packet(pb, pkt, len-2);	150	av_get_packet(pb, pkt, len-2);
151	pkt->pos = pos;	151	pkt->pos = pos;
152	pkt->pts = frame;	152	pkt->pts = frame;
@@ -185,17 +185,17 @@ static int swf_read_packet(AVFormatContext s, AVPacket pkt) · 32 unmodified lines
185	vst->codec->time_base = (AVRational){ 256, swf->frame_rate };	185	vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
186	st = vst;	186	st = vst;
187	}	187	}
188	get_le16(pb); /* BITMAP_ID */	188	avio_rl16(pb); /* BITMAP_ID */
189	av_new_packet(pkt, len-2);	189	av_new_packet(pkt, len-2);
190	get_buffer(pb, pkt->data, 4);	190	avio_read(pb, pkt->data, 4);
191	if (AV_RB32(pkt->data) == 0xffd8ffd9 \|\|	191	if (AV_RB32(pkt->data) == 0xffd8ffd9 \|\|
192	AV_RB32(pkt->data) == 0xffd9ffd8) {	192	AV_RB32(pkt->data) == 0xffd9ffd8) {
193	/* old SWF files containing SOI/EOI as data start */	193	/* old SWF files containing SOI/EOI as data start */
194	/* files created by swink have reversed tag */	194	/* files created by swink have reversed tag */
195	pkt->size -= 4;	195	pkt->size -= 4;
196	get_buffer(pb, pkt->data, pkt->size);	196	avio_read(pb, pkt->data, pkt->size);
197	} else {	197	} else {
198	get_buffer(pb, pkt->data + 4, pkt->size - 4);	198	avio_read(pb, pkt->data + 4, pkt->size - 4);
199	}	199	}
200	pkt->pos = pos;	200	pkt->pos = pos;
201	pkt->stream_index = st->index;	201	pkt->stream_index = st->index;

libavformat/thp.c+23−23

@@ -61,31 +61,31 @@ static int thp_read_header(AVFormatContext *s, · 60 unmodified lines
61	int i;	61	int i;
62		62
63	/* Read the file header. */	63	/* Read the file header. */
64	get_be32(pb); /* Skip Magic. */	64	avio_rb32(pb); /* Skip Magic. */
65	thp->version = get_be32(pb);	65	thp->version = avio_rb32(pb);
66		66
67	get_be32(pb); /* Max buf size. */	67	avio_rb32(pb); /* Max buf size. */
68	get_be32(pb); /* Max samples. */	68	avio_rb32(pb); /* Max samples. */
69		69
70	thp->fps = av_d2q(av_int2flt(get_be32(pb)), INT_MAX);	70	thp->fps = av_d2q(av_int2flt(avio_rb32(pb)), INT_MAX);
71	thp->framecnt = get_be32(pb);	71	thp->framecnt = avio_rb32(pb);
72	thp->first_framesz = get_be32(pb);	72	thp->first_framesz = avio_rb32(pb);
73	get_be32(pb); /* Data size. */	73	avio_rb32(pb); /* Data size. */
74		74
75	thp->compoff = get_be32(pb);	75	thp->compoff = avio_rb32(pb);
76	get_be32(pb); /* offsetDataOffset. */	76	avio_rb32(pb); /* offsetDataOffset. */
77	thp->first_frame = get_be32(pb);	77	thp->first_frame = avio_rb32(pb);
78	thp->last_frame = get_be32(pb);	78	thp->last_frame = avio_rb32(pb);
79		79
80	thp->next_framesz = thp->first_framesz;	80	thp->next_framesz = thp->first_framesz;
81	thp->next_frame = thp->first_frame;	81	thp->next_frame = thp->first_frame;
82		82
83	/* Read the component structure. */	83	/* Read the component structure. */
84	url_fseek (pb, thp->compoff, SEEK_SET);	84	url_fseek (pb, thp->compoff, SEEK_SET);
85	thp->compcount = get_be32(pb);	85	thp->compcount = avio_rb32(pb);
86		86
87	/* Read the list of component types. */	87	/* Read the list of component types. */
88	get_buffer(pb, thp->components, 16);	88	avio_read(pb, thp->components, 16);
89		89
90	for (i = 0; i < thp->compcount; i++) {	90	for (i = 0; i < thp->compcount; i++) {
91	if (thp->components[i] == 0) {	91	if (thp->components[i] == 0) {
@@ -103,14 +103,14 @@ static int thp_read_header(AVFormatContext *s, · 11 unmodified lines
103	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;	103	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
104	st->codec->codec_id = CODEC_ID_THP;	104	st->codec->codec_id = CODEC_ID_THP;
105	st->codec->codec_tag = 0; /* no fourcc */	105	st->codec->codec_tag = 0; /* no fourcc */
106	st->codec->width = get_be32(pb);	106	st->codec->width = avio_rb32(pb);
107	st->codec->height = get_be32(pb);	107	st->codec->height = avio_rb32(pb);
108	st->codec->sample_rate = av_q2d(thp->fps);	108	st->codec->sample_rate = av_q2d(thp->fps);
109	thp->vst = st;	109	thp->vst = st;
110	thp->video_stream_index = st->index;	110	thp->video_stream_index = st->index;
111		111
112	if (thp->version == 0x11000)	112	if (thp->version == 0x11000)
113	get_be32(pb); /* Unknown. */	113	avio_rb32(pb); /* Unknown. */
114	} else if (thp->components[i] == 1) {	114	} else if (thp->components[i] == 1) {
115	if (thp->has_audio != 0)	115	if (thp->has_audio != 0)
116	break;	116	break;
@@ -123,8 +123,8 @@ static int thp_read_header(AVFormatContext *s, · 6 unmodified lines
123	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;	123	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
124	st->codec->codec_id = CODEC_ID_ADPCM_THP;	124	st->codec->codec_id = CODEC_ID_ADPCM_THP;
125	st->codec->codec_tag = 0; /* no fourcc */	125	st->codec->codec_tag = 0; /* no fourcc */
126	st->codec->channels = get_be32(pb); /* numChannels. */	126	st->codec->channels = avio_rb32(pb); /* numChannels. */
127	st->codec->sample_rate = get_be32(pb); /* Frequency. */	127	st->codec->sample_rate = avio_rb32(pb); /* Frequency. */
128		128
129	av_set_pts_info(st, 64, 1, st->codec->sample_rate);	129	av_set_pts_info(st, 64, 1, st->codec->sample_rate);
130		130
@@ -153,15 +153,15 @@ static int thp_read_packet(AVFormatContext *s, · 22 unmodified lines
153		153
154	/* Locate the next frame and read out its size. */	154	/* Locate the next frame and read out its size. */
155	thp->next_frame += thp->next_framesz;	155	thp->next_frame += thp->next_framesz;
156	thp->next_framesz = get_be32(pb);	156	thp->next_framesz = avio_rb32(pb);
157		157
158	get_be32(pb); /* Previous total size. */	158	avio_rb32(pb); /* Previous total size. */
159	size = get_be32(pb); /* Total size of this frame. */	159	size = avio_rb32(pb); /* Total size of this frame. */
160		160
161	/* Store the audiosize so the next time this function is called,	161	/* Store the audiosize so the next time this function is called,
162	the audio can be read. */	162	the audio can be read. */
163	if (thp->has_audio)	163	if (thp->has_audio)
164	thp->audiosize = get_be32(pb); /* Audio size. */	164	thp->audiosize = avio_rb32(pb); /* Audio size. */
165	else	165	else
166	thp->frame++;	166	thp->frame++;
167		167

libavformat/tiertexseq.c+7−7

@@ -86,7 +86,7 @@ static int seq_init_frame_buffers(SeqDemuxContext seq, AVIOContext pb) · 85 unmodified lines
86	url_fseek(pb, 256, SEEK_SET);	86	url_fseek(pb, 256, SEEK_SET);
87		87
88	for (i = 0; i < SEQ_NUM_FRAME_BUFFERS; i++) {	88	for (i = 0; i < SEQ_NUM_FRAME_BUFFERS; i++) {
89	sz = get_le16(pb);	89	sz = avio_rl16(pb);
90	if (sz == 0)	90	if (sz == 0)
91	break;	91	break;
92	else {	92	else {
@@ -114,7 +114,7 @@ static int seq_fill_buffer(SeqDemuxContext seq, AVIOContext pb, int buffer_num · 21 unmodified lines
114	return AVERROR_INVALIDDATA;	114	return AVERROR_INVALIDDATA;
115		115
116	url_fseek(pb, seq->current_frame_offs + data_offs, SEEK_SET);	116	url_fseek(pb, seq->current_frame_offs + data_offs, SEEK_SET);
117	if (get_buffer(pb, seq_buffer->data + seq_buffer->fill_size, data_size) != data_size)	117	if (avio_read(pb, seq_buffer->data + seq_buffer->fill_size, data_size) != data_size)
118	return AVERROR(EIO);	118	return AVERROR(EIO);
119		119
120	seq_buffer->fill_size += data_size;	120	seq_buffer->fill_size += data_size;
@@ -131,7 +131,7 @@ static int seq_parse_frame_data(SeqDemuxContext seq, AVIOContext pb) · 10 unmodified lines
131	url_fseek(pb, seq->current_frame_offs, SEEK_SET);	131	url_fseek(pb, seq->current_frame_offs, SEEK_SET);
132		132
133	/* sound data */	133	/* sound data */
134	seq->current_audio_data_offs = get_le16(pb);	134	seq->current_audio_data_offs = avio_rl16(pb);
135	if (seq->current_audio_data_offs) {	135	if (seq->current_audio_data_offs) {
136	seq->current_audio_data_size = SEQ_AUDIO_BUFFER_SIZE * 2;	136	seq->current_audio_data_size = SEQ_AUDIO_BUFFER_SIZE * 2;
137	} else {	137	} else {
@@ -139,7 +139,7 @@ static int seq_parse_frame_data(SeqDemuxContext seq, AVIOContext pb) · 1 unmodified line
139	}	139	}
140		140
141	/* palette data */	141	/* palette data */
142	seq->current_pal_data_offs = get_le16(pb);	142	seq->current_pal_data_offs = avio_rl16(pb);
143	if (seq->current_pal_data_offs) {	143	if (seq->current_pal_data_offs) {
144	seq->current_pal_data_size = 768;	144	seq->current_pal_data_size = 768;
145	} else {	145	} else {
@@ -148,10 +148,10 @@ static int seq_parse_frame_data(SeqDemuxContext seq, AVIOContext pb) · 2 unmodified lines
148		148
149	/* video data */	149	/* video data */
150	for (i = 0; i < 4; i++)	150	for (i = 0; i < 4; i++)
151	buffer_num[i] = get_byte(pb);	151	buffer_num[i] = avio_r8(pb);
152		152
153	for (i = 0; i < 4; i++)	153	for (i = 0; i < 4; i++)
154	offset_table[i] = get_le16(pb);	154	offset_table[i] = avio_rl16(pb);
155		155
156	for (i = 0; i < 3; i++) {	156	for (i = 0; i < 3; i++) {
157	if (offset_table[i]) {	157	if (offset_table[i]) {
@@ -257,7 +257,7 @@ static int seq_read_packet(AVFormatContext s, AVPacket pkt) · 99 unmodified lines
257	if (seq->current_pal_data_size) {	257	if (seq->current_pal_data_size) {
258	pkt->data[0] \|= 1;	258	pkt->data[0] \|= 1;
259	url_fseek(pb, seq->current_frame_offs + seq->current_pal_data_offs, SEEK_SET);	259	url_fseek(pb, seq->current_frame_offs + seq->current_pal_data_offs, SEEK_SET);
260	if (get_buffer(pb, &pkt->data[1], seq->current_pal_data_size) != seq->current_pal_data_size)	260	if (avio_read(pb, &pkt->data[1], seq->current_pal_data_size) != seq->current_pal_data_size)
261	return AVERROR(EIO);	261	return AVERROR(EIO);
262	}	262	}
263	if (seq->current_video_data_size) {	263	if (seq->current_video_data_size) {

libavformat/tmv.c+7−7

@@ -70,7 +70,7 @@ static int tmv_read_header(AVFormatContext s, AVFormatParameters ap) · 69 unmodified lines
70	AVRational fps;	70	AVRational fps;
71	unsigned comp_method, char_cols, char_rows, features;	71	unsigned comp_method, char_cols, char_rows, features;
72		72
73	if (get_le32(pb) != TMV_TAG)	73	if (avio_rl32(pb) != TMV_TAG)
74	return -1;	74	return -1;
75		75
76	if (!(vst = av_new_stream(s, 0)))	76	if (!(vst = av_new_stream(s, 0)))
@@ -79,30 +79,30 @@ static int tmv_read_header(AVFormatContext s, AVFormatParameters ap) · 2 unmodified lines
79	if (!(ast = av_new_stream(s, 0)))	79	if (!(ast = av_new_stream(s, 0)))
80	return AVERROR(ENOMEM);	80	return AVERROR(ENOMEM);
81		81
82	ast->codec->sample_rate = get_le16(pb);	82	ast->codec->sample_rate = avio_rl16(pb);
83	if (!ast->codec->sample_rate) {	83	if (!ast->codec->sample_rate) {
84	av_log(s, AV_LOG_ERROR, "invalid sample rate\n");	84	av_log(s, AV_LOG_ERROR, "invalid sample rate\n");
85	return -1;	85	return -1;
86	}	86	}
87		87
88	tmv->audio_chunk_size = get_le16(pb);	88	tmv->audio_chunk_size = avio_rl16(pb);
89	if (!tmv->audio_chunk_size) {	89	if (!tmv->audio_chunk_size) {
90	av_log(s, AV_LOG_ERROR, "invalid audio chunk size\n");	90	av_log(s, AV_LOG_ERROR, "invalid audio chunk size\n");
91	return -1;	91	return -1;
92	}	92	}
93		93
94	comp_method = get_byte(pb);	94	comp_method = avio_r8(pb);
95	if (comp_method) {	95	if (comp_method) {
96	av_log(s, AV_LOG_ERROR, "unsupported compression method %d\n",	96	av_log(s, AV_LOG_ERROR, "unsupported compression method %d\n",
97	comp_method);	97	comp_method);
98	return -1;	98	return -1;
99	}	99	}
100		100
101	char_cols = get_byte(pb);	101	char_cols = avio_r8(pb);
102	char_rows = get_byte(pb);	102	char_rows = avio_r8(pb);
103	tmv->video_chunk_size = char_cols * char_rows * 2;	103	tmv->video_chunk_size = char_cols * char_rows * 2;
104		104
105	features = get_byte(pb);	105	features = avio_r8(pb);
106	if (features & ~(TMV_PADDING \| TMV_STEREO)) {	106	if (features & ~(TMV_PADDING \| TMV_STEREO)) {
107	av_log(s, AV_LOG_ERROR, "unsupported features 0x%02x\n",	107	av_log(s, AV_LOG_ERROR, "unsupported features 0x%02x\n",
108	features & ~(TMV_PADDING \| TMV_STEREO));	108	features & ~(TMV_PADDING \| TMV_STEREO));

libavformat/tta.c+8−8

@@ -47,19 +47,19 @@ static int tta_read_header(AVFormatContext s, AVFormatParameters ap) · 46 unmodified lines
47	ff_id3v1_read(s);	47	ff_id3v1_read(s);
48		48
49	start_offset = url_ftell(s->pb);	49	start_offset = url_ftell(s->pb);
50	if (get_le32(s->pb) != AV_RL32("TTA1"))	50	if (avio_rl32(s->pb) != AV_RL32("TTA1"))
51	return -1; // not tta file	51	return -1; // not tta file
52		52
53	url_fskip(s->pb, 2); // FIXME: flags	53	url_fskip(s->pb, 2); // FIXME: flags
54	channels = get_le16(s->pb);	54	channels = avio_rl16(s->pb);
55	bps = get_le16(s->pb);	55	bps = avio_rl16(s->pb);
56	samplerate = get_le32(s->pb);	56	samplerate = avio_rl32(s->pb);
57	if(samplerate <= 0 \|\| samplerate > 1000000){	57	if(samplerate <= 0 \|\| samplerate > 1000000){
58	av_log(s, AV_LOG_ERROR, "nonsense samplerate\n");	58	av_log(s, AV_LOG_ERROR, "nonsense samplerate\n");
59	return -1;	59	return -1;
60	}	60	}
61		61
62	datalen = get_le32(s->pb);	62	datalen = avio_rl32(s->pb);
63	if(datalen < 0){	63	if(datalen < 0){
64	av_log(s, AV_LOG_ERROR, "nonsense datalen\n");	64	av_log(s, AV_LOG_ERROR, "nonsense datalen\n");
65	return -1;	65	return -1;
@@ -87,7 +87,7 @@ static int tta_read_header(AVFormatContext s, AVFormatParameters ap) · 21 unmodified lines
87	framepos = url_ftell(s->pb) + 4*c->totalframes + 4;	87	framepos = url_ftell(s->pb) + 4*c->totalframes + 4;
88		88
89	for (i = 0; i < c->totalframes; i++) {	89	for (i = 0; i < c->totalframes; i++) {
90	uint32_t size = get_le32(s->pb);	90	uint32_t size = avio_rl32(s->pb);
91	av_add_index_entry(st, framepos, i*framelen, size, 0, AVINDEX_KEYFRAME);	91	av_add_index_entry(st, framepos, i*framelen, size, 0, AVINDEX_KEYFRAME);
92	framepos += size;	92	framepos += size;
93	}	93	}
@@ -101,13 +101,13 @@ static int tta_read_header(AVFormatContext s, AVFormatParameters ap) · 7 unmodified lines
101		101
102	st->codec->extradata_size = url_ftell(s->pb) - start_offset;	102	st->codec->extradata_size = url_ftell(s->pb) - start_offset;
103	if(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)st->codec->extradata_size){	103	if(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)st->codec->extradata_size){
104	//this check is redundant as get_buffer should fail	104	//this check is redundant as avio_read should fail
105	av_log(s, AV_LOG_ERROR, "extradata_size too large\n");	105	av_log(s, AV_LOG_ERROR, "extradata_size too large\n");
106	return -1;	106	return -1;
107	}	107	}
108	st->codec->extradata = av_mallocz(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE);	108	st->codec->extradata = av_mallocz(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE);
109	url_fseek(s->pb, start_offset, SEEK_SET);	109	url_fseek(s->pb, start_offset, SEEK_SET);
110	get_buffer(s->pb, st->codec->extradata, st->codec->extradata_size);	110	avio_read(s->pb, st->codec->extradata, st->codec->extradata_size);
111		111
112	return 0;	112	return 0;
113	}	113	}

libavformat/tty.c+3−3

@@ -47,14 +47,14 @@ static int efi_read(AVFormatContext *avctx, uint64_t start_pos) · 46 unmodified lines
47	int len;	47	int len;
48		48
49	url_fseek(pb, start_pos, SEEK_SET);	49	url_fseek(pb, start_pos, SEEK_SET);
50	if (get_byte(pb) != 0x1A)	50	if (avio_r8(pb) != 0x1A)
51	return -1;	51	return -1;
52		52
53	#define GET_EFI_META(name,size) \	53	#define GET_EFI_META(name,size) \
54	len = get_byte(pb); \	54	len = avio_r8(pb); \
55	if (len < 1 \|\| len > size) \	55	if (len < 1 \|\| len > size) \
56	return -1; \	56	return -1; \
57	if (get_buffer(pb, buf, size) == size) { \	57	if (avio_read(pb, buf, size) == size) { \
58	buf[len] = 0; \	58	buf[len] = 0; \
59	av_metadata_set2(&avctx->metadata, name, buf, 0); \	59	av_metadata_set2(&avctx->metadata, name, buf, 0); \
60	}	60	}

libavformat/txd.c+3−3

@@ -57,9 +57,9 @@ static int txd_read_packet(AVFormatContext s, AVPacket pkt) { · 56 unmodified lines
57	int ret;	57	int ret;
58		58
59	next_chunk:	59	next_chunk:
60	id = get_le32(pb);	60	id = avio_rl32(pb);
61	chunk_size = get_le32(pb);	61	chunk_size = avio_rl32(pb);
62	marker = get_le32(pb);	62	marker = avio_rl32(pb);
63		63
64	if (url_feof(s->pb))	64	if (url_feof(s->pb))
65	return AVERROR_EOF;	65	return AVERROR_EOF;

libavformat/utils.c+3−3

@@ -332,7 +332,7 @@ int av_get_packet(AVIOContext s, AVPacket pkt, int size) · 331 unmodified lines
332		332
333	pkt->pos= url_ftell(s);	333	pkt->pos= url_ftell(s);
334		334
335	ret= get_buffer(s, pkt->data, size);	335	ret= avio_read(s, pkt->data, size);
336	if(ret<=0)	336	if(ret<=0)
337	av_free_packet(pkt);	337	av_free_packet(pkt);
338	else	338	else
@@ -351,7 +351,7 @@ int av_append_packet(AVIOContext s, AVPacket pkt, int size) · 12 unmodified lines
351	ret = av_grow_packet(pkt, size);	351	ret = av_grow_packet(pkt, size);
352	if (ret < 0)	352	if (ret < 0)
353	return ret;	353	return ret;
354	ret = get_buffer(s, pkt->data + old_size, size);	354	ret = avio_read(s, pkt->data + old_size, size);
355	av_shrink_packet(pkt, old_size + FFMAX(ret, 0));	355	av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
356	return ret;	356	return ret;
357	}	357	}
@@ -555,7 +555,7 @@ int av_probe_input_buffer(AVIOContext pb, AVInputFormat *fmt, · 197 unmodified lines
555		555
556	/* read probe data */	556	/* read probe data */
557	buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);	557	buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
558	if ((ret = get_buffer(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {	558	if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
559	/* fail if error was not end of file, otherwise, lower score */	559	/* fail if error was not end of file, otherwise, lower score */
560	if (ret != AVERROR_EOF) {	560	if (ret != AVERROR_EOF) {
561	av_free(buf);	561	av_free(buf);

libavformat/vc1test.c+10−10

@@ -49,8 +49,8 @@ static int vc1t_read_header(AVFormatContext *s, · 48 unmodified lines
49	int frames;	49	int frames;
50	uint32_t fps;	50	uint32_t fps;
51		51
52	frames = get_le24(pb);	52	frames = avio_rl24(pb);
53	if(get_byte(pb) != 0xC5 \|\| get_le32(pb) != 4)	53	if(avio_r8(pb) != 0xC5 \|\| avio_rl32(pb) != 4)
54	return -1;	54	return -1;
55		55
56	/* init video codec */	56	/* init video codec */
@@ -63,13 +63,13 @@ static int vc1t_read_header(AVFormatContext *s, · 6 unmodified lines
63		63
64	st->codec->extradata = av_malloc(VC1_EXTRADATA_SIZE);	64	st->codec->extradata = av_malloc(VC1_EXTRADATA_SIZE);
65	st->codec->extradata_size = VC1_EXTRADATA_SIZE;	65	st->codec->extradata_size = VC1_EXTRADATA_SIZE;
66	get_buffer(pb, st->codec->extradata, VC1_EXTRADATA_SIZE);	66	avio_read(pb, st->codec->extradata, VC1_EXTRADATA_SIZE);
67	st->codec->height = get_le32(pb);	67	st->codec->height = avio_rl32(pb);
68	st->codec->width = get_le32(pb);	68	st->codec->width = avio_rl32(pb);
69	if(get_le32(pb) != 0xC)	69	if(avio_rl32(pb) != 0xC)
70	return -1;	70	return -1;
71	url_fskip(pb, 8);	71	url_fskip(pb, 8);
72	fps = get_le32(pb);	72	fps = avio_rl32(pb);
73	if(fps == 0xFFFFFFFF)	73	if(fps == 0xFFFFFFFF)
74	av_set_pts_info(st, 32, 1, 1000);	74	av_set_pts_info(st, 32, 1, 1000);
75	else{	75	else{
@@ -95,10 +95,10 @@ static int vc1t_read_packet(AVFormatContext *s, · 19 unmodified lines
95	if(url_feof(pb))	95	if(url_feof(pb))
96	return AVERROR(EIO);	96	return AVERROR(EIO);
97		97
98	frame_size = get_le24(pb);	98	frame_size = avio_rl24(pb);
99	if(get_byte(pb) & 0x80)	99	if(avio_r8(pb) & 0x80)
100	keyframe = 1;	100	keyframe = 1;
101	pts = get_le32(pb);	101	pts = avio_rl32(pb);
102	if(av_get_packet(pb, pkt, frame_size) < 0)	102	if(av_get_packet(pb, pkt, frame_size) < 0)
103	return AVERROR(EIO);	103	return AVERROR(EIO);
104	if(s->streams[0]->time_base.den == 1000)	104	if(s->streams[0]->time_base.den == 1000)

libavformat/vocdec.c+12−12

@@ -46,7 +46,7 @@ static int voc_read_header(AVFormatContext s, AVFormatParameters ap) · 45 unmodified lines
46	AVStream *st;	46	AVStream *st;
47		47
48	url_fskip(pb, 20);	48	url_fskip(pb, 20);
49	header_size = get_le16(pb) - 22;	49	header_size = avio_rl16(pb) - 22;
50	if (header_size != 4) {	50	if (header_size != 4) {
51	av_log(s, AV_LOG_ERROR, "unknown header size: %d\n", header_size);	51	av_log(s, AV_LOG_ERROR, "unknown header size: %d\n", header_size);
52	return AVERROR(ENOSYS);	52	return AVERROR(ENOSYS);
@@ -73,10 +73,10 @@ voc_get_packet(AVFormatContext s, AVPacket pkt, AVStream *st, int max_size) · 20 unmodified lines
73	int channels = 1;	73	int channels = 1;
74		74
75	while (!voc->remaining_size) {	75	while (!voc->remaining_size) {
76	type = get_byte(pb);	76	type = avio_r8(pb);
77	if (type == VOC_TYPE_EOF)	77	if (type == VOC_TYPE_EOF)
78	return AVERROR(EIO);	78	return AVERROR(EIO);
79	voc->remaining_size = get_le24(pb);	79	voc->remaining_size = avio_rl24(pb);
80	if (!voc->remaining_size) {	80	if (!voc->remaining_size) {
81	if (url_is_streamed(s->pb))	81	if (url_is_streamed(s->pb))
82	return AVERROR(EIO);	82	return AVERROR(EIO);
@@ -86,11 +86,11 @@ voc_get_packet(AVFormatContext s, AVPacket pkt, AVStream *st, int max_size) · 3 unmodified lines
86		86
87	switch (type) {	87	switch (type) {
88	case VOC_TYPE_VOICE_DATA:	88	case VOC_TYPE_VOICE_DATA:
89	dec->sample_rate = 1000000 / (256 - get_byte(pb));	89	dec->sample_rate = 1000000 / (256 - avio_r8(pb));
90	if (sample_rate)	90	if (sample_rate)
91	dec->sample_rate = sample_rate;	91	dec->sample_rate = sample_rate;
92	dec->channels = channels;	92	dec->channels = channels;
93	tmp_codec = get_byte(pb);	93	tmp_codec = avio_r8(pb);
94	dec->bits_per_coded_sample = av_get_bits_per_sample(dec->codec_id);	94	dec->bits_per_coded_sample = av_get_bits_per_sample(dec->codec_id);
95	voc->remaining_size -= 2;	95	voc->remaining_size -= 2;
96	max_size -= 2;	96	max_size -= 2;
@@ -101,19 +101,19 @@ voc_get_packet(AVFormatContext s, AVPacket pkt, AVStream *st, int max_size) · 4 unmodified lines
101	break;	101	break;
102		102
103	case VOC_TYPE_EXTENDED:	103	case VOC_TYPE_EXTENDED:
104	sample_rate = get_le16(pb);	104	sample_rate = avio_rl16(pb);
105	get_byte(pb);	105	avio_r8(pb);
106	channels = get_byte(pb) + 1;	106	channels = avio_r8(pb) + 1;
107	sample_rate = 256000000 / (channels * (65536 - sample_rate));	107	sample_rate = 256000000 / (channels * (65536 - sample_rate));
108	voc->remaining_size = 0;	108	voc->remaining_size = 0;
109	max_size -= 4;	109	max_size -= 4;
110	break;	110	break;
111		111
112	case VOC_TYPE_NEW_VOICE_DATA:	112	case VOC_TYPE_NEW_VOICE_DATA:
113	dec->sample_rate = get_le32(pb);	113	dec->sample_rate = avio_rl32(pb);
114	dec->bits_per_coded_sample = get_byte(pb);	114	dec->bits_per_coded_sample = avio_r8(pb);
115	dec->channels = get_byte(pb);	115	dec->channels = avio_r8(pb);
116	tmp_codec = get_le16(pb);	116	tmp_codec = avio_rl16(pb);
117	url_fskip(pb, 4);	117	url_fskip(pb, 4);
118	voc->remaining_size -= 12;	118	voc->remaining_size -= 12;
119	max_size -= 12;	119	max_size -= 12;

libavformat/vqf.c+8−8

@@ -54,7 +54,7 @@ static void add_metadata(AVFormatContext s, const char tag, · 53 unmodified lines
54	buf = av_malloc(len+1);	54	buf = av_malloc(len+1);
55	if (!buf)	55	if (!buf)
56	return;	56	return;
57	get_buffer(s->pb, buf, len);	57	avio_read(s->pb, buf, len);
58	buf[len] = 0;	58	buf[len] = 0;
59	av_metadata_set2(&s->metadata, tag, buf, AV_METADATA_DONT_STRDUP_VAL);	59	av_metadata_set2(&s->metadata, tag, buf, AV_METADATA_DONT_STRDUP_VAL);
60	}	60	}
@@ -74,7 +74,7 @@ static int vqf_read_header(AVFormatContext s, AVFormatParameters ap) · 13 unmodified lines
74		74
75	url_fskip(s->pb, 12);	75	url_fskip(s->pb, 12);
76		76
77	header_size = get_be32(s->pb);	77	header_size = avio_rb32(s->pb);
78		78
79	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;	79	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
80	st->codec->codec_id = CODEC_ID_TWINVQ;	80	st->codec->codec_id = CODEC_ID_TWINVQ;
@@ -82,12 +82,12 @@ static int vqf_read_header(AVFormatContext s, AVFormatParameters ap) · 1 unmodified line
82		82
83	do {	83	do {
84	int len;	84	int len;
85	chunk_tag = get_le32(s->pb);	85	chunk_tag = avio_rl32(s->pb);
86		86
87	if (chunk_tag == MKTAG('D','A','T','A'))	87	if (chunk_tag == MKTAG('D','A','T','A'))
88	break;	88	break;
89		89
90	len = get_be32(s->pb);	90	len = avio_rb32(s->pb);
91		91
92	if ((unsigned) len > INT_MAX/2) {	92	if ((unsigned) len > INT_MAX/2) {
93	av_log(s, AV_LOG_ERROR, "Malformed header\n");	93	av_log(s, AV_LOG_ERROR, "Malformed header\n");
@@ -98,9 +98,9 @@ static int vqf_read_header(AVFormatContext s, AVFormatParameters ap) · 4 unmodified lines
98		98
99	switch(chunk_tag){	99	switch(chunk_tag){
100	case MKTAG('C','O','M','M'):	100	case MKTAG('C','O','M','M'):
101	st->codec->channels = get_be32(s->pb) + 1;	101	st->codec->channels = avio_rb32(s->pb) + 1;
102	read_bitrate = get_be32(s->pb);	102	read_bitrate = avio_rb32(s->pb);
103	rate_flag = get_be32(s->pb);	103	rate_flag = avio_rb32(s->pb);
104	url_fskip(s->pb, len-12);	104	url_fskip(s->pb, len-12);
105		105
106	st->codec->bit_rate = read_bitrate*1000;	106	st->codec->bit_rate = read_bitrate*1000;
@@ -208,7 +208,7 @@ static int vqf_read_packet(AVFormatContext s, AVPacket pkt) · 101 unmodified lines
208		208
209	pkt->data[0] = 8 - c->remaining_bits; // Number of bits to skip	209	pkt->data[0] = 8 - c->remaining_bits; // Number of bits to skip
210	pkt->data[1] = c->last_frame_bits;	210	pkt->data[1] = c->last_frame_bits;
211	ret = get_buffer(s->pb, pkt->data+2, size);	211	ret = avio_read(s->pb, pkt->data+2, size);
212		212
213	if (ret<=0) {	213	if (ret<=0) {
214	av_free_packet(pkt);	214	av_free_packet(pkt);

libavformat/wav.c+16−16

@@ -143,8 +143,8 @@ AVOutputFormat ff_wav_muxer = { · 142 unmodified lines
143		143
144	static int64_t next_tag(AVIOContext pb, unsigned int tag)	144	static int64_t next_tag(AVIOContext pb, unsigned int tag)
145	{	145	{
146	*tag = get_le32(pb);	146	*tag = avio_rl32(pb);
147	return get_le32(pb);	147	return avio_rl32(pb);
148	}	148	}
149		149
150	/* return the size of the found tag */	150	/* return the size of the found tag */
@@ -197,25 +197,25 @@ static int wav_read_header(AVFormatContext *s, · 46 unmodified lines
197	WAVContext *wav = s->priv_data;	197	WAVContext *wav = s->priv_data;
198		198
199	/* check RIFF header */	199	/* check RIFF header */
200	tag = get_le32(pb);	200	tag = avio_rl32(pb);
201		201
202	rf64 = tag == MKTAG('R', 'F', '6', '4');	202	rf64 = tag == MKTAG('R', 'F', '6', '4');
203	if (!rf64 && tag != MKTAG('R', 'I', 'F', 'F'))	203	if (!rf64 && tag != MKTAG('R', 'I', 'F', 'F'))
204	return -1;	204	return -1;
205	get_le32(pb); /* file size */	205	avio_rl32(pb); /* file size */
206	tag = get_le32(pb);	206	tag = avio_rl32(pb);
207	if (tag != MKTAG('W', 'A', 'V', 'E'))	207	if (tag != MKTAG('W', 'A', 'V', 'E'))
208	return -1;	208	return -1;
209		209
210	if (rf64) {	210	if (rf64) {
211	if (get_le32(pb) != MKTAG('d', 's', '6', '4'))	211	if (avio_rl32(pb) != MKTAG('d', 's', '6', '4'))
212	return -1;	212	return -1;
213	size = get_le32(pb);	213	size = avio_rl32(pb);
214	if (size < 16)	214	if (size < 16)
215	return -1;	215	return -1;
216	get_le64(pb); /* RIFF size */	216	avio_rl64(pb); /* RIFF size */
217	data_size = get_le64(pb);	217	data_size = avio_rl64(pb);
218	sample_count = get_le64(pb);	218	sample_count = avio_rl64(pb);
219	url_fskip(pb, size - 16); /* skip rest of ds64 chunk */	219	url_fskip(pb, size - 16); /* skip rest of ds64 chunk */
220	}	220	}
221		221
@@ -239,7 +239,7 @@ static int wav_read_header(AVFormatContext *s, · 17 unmodified lines
239	if (tag == MKTAG('d', 'a', 't', 'a')){	239	if (tag == MKTAG('d', 'a', 't', 'a')){
240	break;	240	break;
241	}else if (tag == MKTAG('f','a','c','t') && !sample_count){	241	}else if (tag == MKTAG('f','a','c','t') && !sample_count){
242	sample_count = get_le32(pb);	242	sample_count = avio_rl32(pb);
243	size -= 4;	243	size -= 4;
244	}	244	}
245	url_fseek(pb, size, SEEK_CUR);	245	url_fseek(pb, size, SEEK_CUR);
@@ -269,8 +269,8 @@ static int64_t find_guid(AVIOContext *pb, const uint8_t guid1[16]) · 23 unmodified lines
269	int64_t size;	269	int64_t size;
270		270
271	while (!url_feof(pb)) {	271	while (!url_feof(pb)) {
272	get_buffer(pb, guid, 16);	272	avio_read(pb, guid, 16);
273	size = get_le64(pb);	273	size = avio_rl64(pb);
274	if (size <= 24)	274	if (size <= 24)
275	return -1;	275	return -1;
276	if (!memcmp(guid, guid1, 16))	276	if (!memcmp(guid, guid1, 16))
@@ -384,14 +384,14 @@ static int w64_read_header(AVFormatContext s, AVFormatParameters ap) · 107 unmodified lines
384	AVStream *st;	384	AVStream *st;
385	uint8_t guid[16];	385	uint8_t guid[16];
386		386
387	get_buffer(pb, guid, 16);	387	avio_read(pb, guid, 16);
388	if (memcmp(guid, guid_riff, 16))	388	if (memcmp(guid, guid_riff, 16))
389	return -1;	389	return -1;
390		390
391	if (get_le64(pb) < 16 + 8 + 16 + 8 + 16 + 8) /* riff + wave + fmt + sizes */	391	if (avio_rl64(pb) < 16 + 8 + 16 + 8 + 16 + 8) /* riff + wave + fmt + sizes */
392	return -1;	392	return -1;
393		393
394	get_buffer(pb, guid, 16);	394	avio_read(pb, guid, 16);
395	if (memcmp(guid, guid_wave, 16)) {	395	if (memcmp(guid, guid_wave, 16)) {
396	av_log(s, AV_LOG_ERROR, "could not find wave guid\n");	396	av_log(s, AV_LOG_ERROR, "could not find wave guid\n");
397	return -1;	397	return -1;

libavformat/wc3movie.c+10−10

@@ -105,8 +105,8 @@ static int wc3_read_header(AVFormatContext *s, · 104 unmodified lines
105		105
106	/* traverse through the chunks and load the header information before	106	/* traverse through the chunks and load the header information before
107	* the first BRCH tag */	107	* the first BRCH tag */
108	fourcc_tag = get_le32(pb);	108	fourcc_tag = avio_rl32(pb);
109	size = (get_be32(pb) + 1) & (~1);	109	size = (avio_rb32(pb) + 1) & (~1);
110		110
111	do {	111	do {
112	switch (fourcc_tag) {	112	switch (fourcc_tag) {
@@ -127,7 +127,7 @@ static int wc3_read_header(AVFormatContext *s, · 14 unmodified lines
127	buffer = av_malloc(size+1);	127	buffer = av_malloc(size+1);
128	if (!buffer)	128	if (!buffer)
129	return AVERROR(ENOMEM);	129	return AVERROR(ENOMEM);
130	if ((ret = get_buffer(pb, buffer, size)) != size)	130	if ((ret = avio_read(pb, buffer, size)) != size)
131	return AVERROR(EIO);	131	return AVERROR(EIO);
132	buffer[size] = 0;	132	buffer[size] = 0;
133	av_metadata_set2(&s->metadata, "title", buffer,	133	av_metadata_set2(&s->metadata, "title", buffer,
@@ -136,8 +136,8 @@ static int wc3_read_header(AVFormatContext *s, · 2 unmodified lines
136		136
137	case SIZE_TAG:	137	case SIZE_TAG:
138	/* video resolution override */	138	/* video resolution override */
139	wc3->width = get_le32(pb);	139	wc3->width = avio_rl32(pb);
140	wc3->height = get_le32(pb);	140	wc3->height = avio_rl32(pb);
141	break;	141	break;
142		142
143	case PALT_TAG:	143	case PALT_TAG:
@@ -154,9 +154,9 @@ static int wc3_read_header(AVFormatContext *s, · 10 unmodified lines
154	break;	154	break;
155	}	155	}
156		156
157	fourcc_tag = get_le32(pb);	157	fourcc_tag = avio_rl32(pb);
158	/* chunk sizes are 16-bit aligned */	158	/* chunk sizes are 16-bit aligned */
159	size = (get_be32(pb) + 1) & (~1);	159	size = (avio_rb32(pb) + 1) & (~1);
160	if (url_feof(pb))	160	if (url_feof(pb))
161	return AVERROR(EIO);	161	return AVERROR(EIO);
162		162
@@ -205,9 +205,9 @@ static int wc3_read_packet(AVFormatContext *s, · 42 unmodified lines
205		205
206	while (!packet_read) {	206	while (!packet_read) {
207		207
208	fourcc_tag = get_le32(pb);	208	fourcc_tag = avio_rl32(pb);
209	/* chunk sizes are 16-bit aligned */	209	/* chunk sizes are 16-bit aligned */
210	size = (get_be32(pb) + 1) & (~1);	210	size = (avio_rb32(pb) + 1) & (~1);
211	if (url_feof(pb))	211	if (url_feof(pb))
212	return AVERROR(EIO);	212	return AVERROR(EIO);
213		213
@@ -242,7 +242,7 @@ static int wc3_read_packet(AVFormatContext *s, · 28 unmodified lines
242	#if 0	242	#if 0
243	url_fseek(pb, size, SEEK_CUR);	243	url_fseek(pb, size, SEEK_CUR);
244	#else	244	#else
245	if ((unsigned)size > sizeof(text) \|\| (ret = get_buffer(pb, text, size)) != size)	245	if ((unsigned)size > sizeof(text) \|\| (ret = avio_read(pb, text, size)) != size)
246	ret = AVERROR(EIO);	246	ret = AVERROR(EIO);
247	else {	247	else {
248	int i = 0;	248	int i = 0;

libavformat/westwood.c+6−6

@@ -130,7 +130,7 @@ static int wsaud_read_header(AVFormatContext *s, · 129 unmodified lines
130	AVStream *st;	130	AVStream *st;
131	unsigned char header[AUD_HEADER_SIZE];	131	unsigned char header[AUD_HEADER_SIZE];
132		132
133	if (get_buffer(pb, header, AUD_HEADER_SIZE) != AUD_HEADER_SIZE)	133	if (avio_read(pb, header, AUD_HEADER_SIZE) != AUD_HEADER_SIZE)
134	return AVERROR(EIO);	134	return AVERROR(EIO);
135	wsaud->audio_samplerate = AV_RL16(&header[0]);	135	wsaud->audio_samplerate = AV_RL16(&header[0]);
136	if (header[11] == 99)	136	if (header[11] == 99)
@@ -173,7 +173,7 @@ static int wsaud_read_packet(AVFormatContext *s, · 36 unmodified lines
173	unsigned int chunk_size;	173	unsigned int chunk_size;
174	int ret = 0;	174	int ret = 0;
175		175
176	if (get_buffer(pb, preamble, AUD_CHUNK_PREAMBLE_SIZE) !=	176	if (avio_read(pb, preamble, AUD_CHUNK_PREAMBLE_SIZE) !=
177	AUD_CHUNK_PREAMBLE_SIZE)	177	AUD_CHUNK_PREAMBLE_SIZE)
178	return AVERROR(EIO);	178	return AVERROR(EIO);
179		179
@@ -237,7 +237,7 @@ static int wsvqa_read_header(AVFormatContext *s, · 57 unmodified lines
237	st->codec->extradata_size = VQA_HEADER_SIZE;	237	st->codec->extradata_size = VQA_HEADER_SIZE;
238	st->codec->extradata = av_mallocz(VQA_HEADER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);	238	st->codec->extradata = av_mallocz(VQA_HEADER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
239	header = (unsigned char *)st->codec->extradata;	239	header = (unsigned char *)st->codec->extradata;
240	if (get_buffer(pb, st->codec->extradata, VQA_HEADER_SIZE) !=	240	if (avio_read(pb, st->codec->extradata, VQA_HEADER_SIZE) !=
241	VQA_HEADER_SIZE) {	241	VQA_HEADER_SIZE) {
242	av_free(st->codec->extradata);	242	av_free(st->codec->extradata);
243	return AVERROR(EIO);	243	return AVERROR(EIO);
@@ -277,7 +277,7 @@ static int wsvqa_read_header(AVFormatContext *s, · 33 unmodified lines
277	/* there are 0 or more chunks before the FINF chunk; iterate until	277	/* there are 0 or more chunks before the FINF chunk; iterate until
278	* FINF has been skipped and the file will be ready to be demuxed */	278	* FINF has been skipped and the file will be ready to be demuxed */
279	do {	279	do {
280	if (get_buffer(pb, scratch, VQA_PREAMBLE_SIZE) != VQA_PREAMBLE_SIZE) {	280	if (avio_read(pb, scratch, VQA_PREAMBLE_SIZE) != VQA_PREAMBLE_SIZE) {
281	av_free(st->codec->extradata);	281	av_free(st->codec->extradata);
282	return AVERROR(EIO);	282	return AVERROR(EIO);
283	}	283	}
@@ -320,7 +320,7 @@ static int wsvqa_read_packet(AVFormatContext *s, · 36 unmodified lines
320	unsigned int chunk_size;	320	unsigned int chunk_size;
321	int skip_byte;	321	int skip_byte;
322		322
323	while (get_buffer(pb, preamble, VQA_PREAMBLE_SIZE) == VQA_PREAMBLE_SIZE) {	323	while (avio_read(pb, preamble, VQA_PREAMBLE_SIZE) == VQA_PREAMBLE_SIZE) {
324	chunk_type = AV_RB32(&preamble[0]);	324	chunk_type = AV_RB32(&preamble[0]);
325	chunk_size = AV_RB32(&preamble[4]);	325	chunk_size = AV_RB32(&preamble[4]);
326	skip_byte = chunk_size & 0x01;	326	skip_byte = chunk_size & 0x01;
@@ -329,7 +329,7 @@ static int wsvqa_read_packet(AVFormatContext *s, · 2 unmodified lines
329		329
330	if (av_new_packet(pkt, chunk_size))	330	if (av_new_packet(pkt, chunk_size))
331	return AVERROR(EIO);	331	return AVERROR(EIO);
332	ret = get_buffer(pb, pkt->data, chunk_size);	332	ret = avio_read(pb, pkt->data, chunk_size);
333	if (ret != chunk_size) {	333	if (ret != chunk_size) {
334	av_free_packet(pkt);	334	av_free_packet(pkt);
335	return AVERROR(EIO);	335	return AVERROR(EIO);

libavformat/wtv.c+28−28

@@ -88,7 +88,7 @@ static int wtvfile_read_packet(void opaque, uint8_t buf, int buf_size) · 87 unmodified lines
88	int remaining_in_sector = (1 << wf->sector_bits) - (wf->position & ((1 << wf->sector_bits) - 1));	88	int remaining_in_sector = (1 << wf->sector_bits) - (wf->position & ((1 << wf->sector_bits) - 1));
89	int read_request = FFMIN(buf_size - nread, remaining_in_sector);	89	int read_request = FFMIN(buf_size - nread, remaining_in_sector);
90		90
91	n = get_buffer(pb, buf, read_request);	91	n = avio_read(pb, buf, read_request);
92	if (n <= 0)	92	if (n <= 0)
93	break;	93	break;
94	nread += n;	94	nread += n;
@@ -140,7 +140,7 @@ static int read_ints(AVIOContext pb, uint32_t data, int count) · 45 unmodified lines
140	{	140	{
141	int i, total = 0;	141	int i, total = 0;
142	for (i = 0; i < count; i++) {	142	for (i = 0; i < count; i++) {
143	if ((data[total] = get_le32(pb)))	143	if ((data[total] = avio_rl32(pb)))
144	total++;	144	total++;
145	}	145	}
146	return total;	146	return total;
@@ -474,9 +474,9 @@ static void get_attachment(AVFormatContext s, AVIOContext pb, int length) · 327 unmodified lines
474	if (strcmp(mime, "image/jpeg"))	474	if (strcmp(mime, "image/jpeg"))
475	goto done;	475	goto done;
476		476
477	get_byte(pb);	477	avio_r8(pb);
478	avio_get_str16le(pb, INT_MAX, description, sizeof(description));	478	avio_get_str16le(pb, INT_MAX, description, sizeof(description));
479	filesize = get_le32(pb);	479	filesize = avio_rl32(pb);
480	if (!filesize)	480	if (!filesize)
481	goto done;	481	goto done;
482		482
@@ -490,7 +490,7 @@ static void get_attachment(AVFormatContext s, AVIOContext pb, int length) · 7 unmodified lines
490	if (!st->codec->extradata)	490	if (!st->codec->extradata)
491	goto done;	491	goto done;
492	st->codec->extradata_size = filesize;	492	st->codec->extradata_size = filesize;
493	get_buffer(pb, st->codec->extradata, filesize);	493	avio_read(pb, st->codec->extradata, filesize);
494	done:	494	done:
495	url_fseek(pb, pos + length, SEEK_SET);	495	url_fseek(pb, pos + length, SEEK_SET);
496	}	496	}
@@ -503,7 +503,7 @@ static void get_tag(AVFormatContext s, AVIOContext pb, const char *key, int ty · 6 unmodified lines
503	return;	503	return;
504		504
505	if (type == 0 && length == 4) {	505	if (type == 0 && length == 4) {
506	snprintf(buf, buf_size, "%"PRIi32, get_le32(pb));	506	snprintf(buf, buf_size, "%"PRIi32, avio_rl32(pb));
507	} else if (type == 1) {	507	} else if (type == 1) {
508	avio_get_str16le(pb, length, buf, buf_size);	508	avio_get_str16le(pb, length, buf, buf_size);
509	if (!strlen(buf)) {	509	if (!strlen(buf)) {
@@ -511,9 +511,9 @@ static void get_tag(AVFormatContext s, AVIOContext pb, const char *key, int ty · 1 unmodified line
511	return;	511	return;
512	}	512	}
513	} else if (type == 3 && length == 4) {	513	} else if (type == 3 && length == 4) {
514	strcpy(buf, get_le32(pb) ? "true" : "false");	514	strcpy(buf, avio_rl32(pb) ? "true" : "false");
515	} else if (type == 4 && length == 8) {	515	} else if (type == 4 && length == 8) {
516	int64_t num = get_le64(pb);	516	int64_t num = avio_rl64(pb);
517	if (!strcmp(key, "WM/EncodingTime") \|\|	517	if (!strcmp(key, "WM/EncodingTime") \|\|
518	!strcmp(key, "WM/MediaOriginalBroadcastDateTime"))	518	!strcmp(key, "WM/MediaOriginalBroadcastDateTime"))
519	filetime_to_iso8601(buf, buf_size, num);	519	filetime_to_iso8601(buf, buf_size, num);
@@ -527,10 +527,10 @@ static void get_tag(AVFormatContext s, AVIOContext pb, const char *key, int ty · 7 unmodified lines
527	else	527	else
528	snprintf(buf, buf_size, "%"PRIi64, num);	528	snprintf(buf, buf_size, "%"PRIi64, num);
529	} else if (type == 5 && length == 2) {	529	} else if (type == 5 && length == 2) {
530	snprintf(buf, buf_size, "%"PRIi16, get_le16(pb));	530	snprintf(buf, buf_size, "%"PRIi16, avio_rl16(pb));
531	} else if (type == 6 && length == 16) {	531	} else if (type == 6 && length == 16) {
532	ff_asf_guid guid;	532	ff_asf_guid guid;
533	get_buffer(pb, guid, 16);	533	avio_read(pb, guid, 16);
534	snprintf(buf, buf_size, PRI_PRETTY_GUID, ARG_PRETTY_GUID(guid));	534	snprintf(buf, buf_size, PRI_PRETTY_GUID, ARG_PRETTY_GUID(guid));
535	} else if (type == 2 && !strcmp(key, "WM/Picture")) {	535	} else if (type == 2 && !strcmp(key, "WM/Picture")) {
536	get_attachment(s, pb, length);	536	get_attachment(s, pb, length);
@@ -557,8 +557,8 @@ static void parse_legacy_attrib(AVFormatContext s, AVIOContext pb) · 20 unmodified lines
557	while(!url_feof(pb)) {	557	while(!url_feof(pb)) {
558	char key[1024];	558	char key[1024];
559	ff_get_guid(pb, &guid);	559	ff_get_guid(pb, &guid);
560	type = get_le32(pb);	560	type = avio_rl32(pb);
561	length = get_le32(pb);	561	length = avio_rl32(pb);
562	if (!length)	562	if (!length)
563	break;	563	break;
564	if (ff_guidcmp(&guid, metadata_guid)) {	564	if (ff_guidcmp(&guid, metadata_guid)) {
@@ -775,10 +775,10 @@ static int parse_chunks(AVFormatContext s, int mode, int64_t seekts, int len_p · 210 unmodified lines
775	int len, sid, consumed;	775	int len, sid, consumed;
776		776
777	ff_get_guid(pb, &g);	777	ff_get_guid(pb, &g);
778	len = get_le32(pb);	778	len = avio_rl32(pb);
779	if (len < 32)	779	if (len < 32)
780	break;	780	break;
781	sid = get_le32(pb) & 0x7FFF;	781	sid = avio_rl32(pb) & 0x7FFF;
782	url_fskip(pb, 8);	782	url_fskip(pb, 8);
783	consumed = 32;	783	consumed = 32;
784		784
@@ -791,7 +791,7 @@ static int parse_chunks(AVFormatContext s, int mode, int64_t seekts, int len_p · 6 unmodified lines
791	ff_get_guid(pb, &subtype);	791	ff_get_guid(pb, &subtype);
792	url_fskip(pb, 12);	792	url_fskip(pb, 12);
793	ff_get_guid(pb, &formattype);	793	ff_get_guid(pb, &formattype);
794	size = get_le32(pb);	794	size = avio_rl32(pb);
795	parse_media_type(s, 0, sid, mediatype, subtype, formattype, size);	795	parse_media_type(s, 0, sid, mediatype, subtype, formattype, size);
796	consumed += 92 + size;	796	consumed += 92 + size;
797	}	797	}
@@ -805,7 +805,7 @@ static int parse_chunks(AVFormatContext s, int mode, int64_t seekts, int len_p · 7 unmodified lines
805	ff_get_guid(pb, &subtype);	805	ff_get_guid(pb, &subtype);
806	url_fskip(pb, 12);	806	url_fskip(pb, 12);
807	ff_get_guid(pb, &formattype);	807	ff_get_guid(pb, &formattype);
808	size = get_le32(pb);	808	size = avio_rl32(pb);
809	parse_media_type(s, s->streams[stream_index], sid, mediatype, subtype, formattype, size);	809	parse_media_type(s, s->streams[stream_index], sid, mediatype, subtype, formattype, size);
810	consumed += 76 + size;	810	consumed += 76 + size;
811	}	811	}
@@ -831,7 +831,7 @@ static int parse_chunks(AVFormatContext s, int mode, int64_t seekts, int len_p · 19 unmodified lines
831	}	831	}
832		832
833	buf_size = FFMIN(len - consumed, sizeof(buf));	833	buf_size = FFMIN(len - consumed, sizeof(buf));
834	get_buffer(pb, buf, buf_size);	834	avio_read(pb, buf, buf_size);
835	consumed += buf_size;	835	consumed += buf_size;
836	ff_parse_mpeg2_descriptor(s, st, 0, &pbuf, buf + buf_size, 0, 0, 0, 0);	836	ff_parse_mpeg2_descriptor(s, st, 0, &pbuf, buf + buf_size, 0, 0, 0, 0);
837	}	837	}
@@ -841,7 +841,7 @@ static int parse_chunks(AVFormatContext s, int mode, int64_t seekts, int len_p · 3 unmodified lines
841	AVStream *st = s->streams[stream_index];	841	AVStream *st = s->streams[stream_index];
842	int audio_type;	842	int audio_type;
843	url_fskip(pb, 8);	843	url_fskip(pb, 8);
844	audio_type = get_byte(pb);	844	audio_type = avio_r8(pb);
845	if (audio_type == 2)	845	if (audio_type == 2)
846	st->disposition \|= AV_DISPOSITION_HEARING_IMPAIRED;	846	st->disposition \|= AV_DISPOSITION_HEARING_IMPAIRED;
847	else if (audio_type == 3)	847	else if (audio_type == 3)
@@ -852,7 +852,7 @@ static int parse_chunks(AVFormatContext s, int mode, int64_t seekts, int len_p · 4 unmodified lines
852	int stream_index = ff_find_stream_index(s, sid);	852	int stream_index = ff_find_stream_index(s, sid);
853	if (stream_index >= 0) {	853	if (stream_index >= 0) {
854	url_fskip(pb, 12);	854	url_fskip(pb, 12);
855	if (get_le32(pb))	855	if (avio_rl32(pb))
856	av_log(s, AV_LOG_WARNING, "DVB scrambled stream detected (st:%d), decoding will likely fail\n", stream_index);	856	av_log(s, AV_LOG_WARNING, "DVB scrambled stream detected (st:%d), decoding will likely fail\n", stream_index);
857	consumed += 16;	857	consumed += 16;
858	}	858	}
@@ -862,7 +862,7 @@ static int parse_chunks(AVFormatContext s, int mode, int64_t seekts, int len_p · 3 unmodified lines
862	AVStream *st = s->streams[stream_index];	862	AVStream *st = s->streams[stream_index];
863	uint8_t language[4];	863	uint8_t language[4];
864	url_fskip(pb, 12);	864	url_fskip(pb, 12);
865	get_buffer(pb, language, 3);	865	avio_read(pb, language, 3);
866	if (language[0]) {	866	if (language[0]) {
867	language[3] = 0;	867	language[3] = 0;
868	av_metadata_set2(&st->metadata, "language", language, 0);	868	av_metadata_set2(&st->metadata, "language", language, 0);
@@ -875,7 +875,7 @@ static int parse_chunks(AVFormatContext s, int mode, int64_t seekts, int len_p · 6 unmodified lines
875	int stream_index = ff_find_stream_index(s, sid);	875	int stream_index = ff_find_stream_index(s, sid);
876	if (stream_index >= 0) {	876	if (stream_index >= 0) {
877	url_fskip(pb, 8);	877	url_fskip(pb, 8);
878	wtv->pts = get_le64(pb);	878	wtv->pts = avio_rl64(pb);
879	consumed += 16;	879	consumed += 16;
880	if (wtv->pts == -1)	880	if (wtv->pts == -1)
881	wtv->pts = AV_NOPTS_VALUE;	881	wtv->pts = AV_NOPTS_VALUE;
@@ -955,16 +955,16 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 73 unmodified lines
955		955
956	/* read root directory sector */	956	/* read root directory sector */
957	url_fskip(s->pb, 0x30);	957	url_fskip(s->pb, 0x30);
958	root_size = get_le32(s->pb);	958	root_size = avio_rl32(s->pb);
959	if (root_size > sizeof(root)) {	959	if (root_size > sizeof(root)) {
960	av_log(s, AV_LOG_ERROR, "root directory size exceeds sector size\n");	960	av_log(s, AV_LOG_ERROR, "root directory size exceeds sector size\n");
961	return AVERROR_INVALIDDATA;	961	return AVERROR_INVALIDDATA;
962	}	962	}
963	url_fskip(s->pb, 4);	963	url_fskip(s->pb, 4);
964	root_sector = get_le32(s->pb);	964	root_sector = avio_rl32(s->pb);
965		965
966	url_fseek(s->pb, root_sector << WTV_SECTOR_BITS, SEEK_SET);	966	url_fseek(s->pb, root_sector << WTV_SECTOR_BITS, SEEK_SET);
967	root_size = get_buffer(s->pb, root, root_size);	967	root_size = avio_read(s->pb, root, root_size);
968	if (root_size < 0)	968	if (root_size < 0)
969	return AVERROR_INVALIDDATA;	969	return AVERROR_INVALIDDATA;
970		970
@@ -995,8 +995,8 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 24 unmodified lines
995	pb = wtvfile_open(s, root, root_size, table_0_entries_time_le16);	995	pb = wtvfile_open(s, root, root_size, table_0_entries_time_le16);
996	if (pb) {	996	if (pb) {
997	while(1) {	997	while(1) {
998	uint64_t timestamp = get_le64(pb);	998	uint64_t timestamp = avio_rl64(pb);
999	uint64_t frame_nb = get_le64(pb);	999	uint64_t frame_nb = avio_rl64(pb);
1000	if (url_feof(pb))	1000	if (url_feof(pb))
1001	break;	1001	break;
1002	ff_add_index_entry(&wtv->index_entries, &wtv->nb_index_entries, &wtv->index_entries_allocated_size,	1002	ff_add_index_entry(&wtv->index_entries, &wtv->nb_index_entries, &wtv->index_entries_allocated_size,
@@ -1009,8 +1009,8 @@ static int read_header(AVFormatContext s, AVFormatParameters ap) · 6 unmodified lines
1009	if (pb) {	1009	if (pb) {
1010	int i;	1010	int i;
1011	while (1) {	1011	while (1) {
1012	uint64_t frame_nb = get_le64(pb);	1012	uint64_t frame_nb = avio_rl64(pb);
1013	uint64_t position = get_le64(pb);	1013	uint64_t position = avio_rl64(pb);
1014	if (url_feof(pb))	1014	if (url_feof(pb))
1015	break;	1015	break;
1016	for (i = wtv->nb_index_entries - 1; i >= 0; i--) {	1016	for (i = wtv->nb_index_entries - 1; i >= 0; i--) {

libavformat/wv.c+25−25

@@ -86,25 +86,25 @@ static int wv_read_block_header(AVFormatContext ctx, AVIOContext pb, int appen · 85 unmodified lines
86		86
87	wc->pos = url_ftell(pb);	87	wc->pos = url_ftell(pb);
88	if(!append){	88	if(!append){
89	tag = get_le32(pb);	89	tag = avio_rl32(pb);
90	if (tag != MKTAG('w', 'v', 'p', 'k'))	90	if (tag != MKTAG('w', 'v', 'p', 'k'))
91	return -1;	91	return -1;
92	size = get_le32(pb);	92	size = avio_rl32(pb);
93	if(size < 24 \|\| size > WV_BLOCK_LIMIT){	93	if(size < 24 \|\| size > WV_BLOCK_LIMIT){
94	av_log(ctx, AV_LOG_ERROR, "Incorrect block size %i\n", size);	94	av_log(ctx, AV_LOG_ERROR, "Incorrect block size %i\n", size);
95	return -1;	95	return -1;
96	}	96	}
97	wc->blksize = size;	97	wc->blksize = size;
98	ver = get_le16(pb);	98	ver = avio_rl16(pb);
99	if(ver < 0x402 \|\| ver > 0x410){	99	if(ver < 0x402 \|\| ver > 0x410){
100	av_log(ctx, AV_LOG_ERROR, "Unsupported version %03X\n", ver);	100	av_log(ctx, AV_LOG_ERROR, "Unsupported version %03X\n", ver);
101	return -1;	101	return -1;
102	}	102	}
103	get_byte(pb); // track no	103	avio_r8(pb); // track no
104	get_byte(pb); // track sub index	104	avio_r8(pb); // track sub index
105	wc->samples = get_le32(pb); // total samples in file	105	wc->samples = avio_rl32(pb); // total samples in file
106	wc->soff = get_le32(pb); // offset in samples of current block	106	wc->soff = avio_rl32(pb); // offset in samples of current block
107	get_buffer(pb, wc->extra, WV_EXTRA_SIZE);	107	avio_read(pb, wc->extra, WV_EXTRA_SIZE);
108	}else{	108	}else{
109	size = wc->blksize;	109	size = wc->blksize;
110	}	110	}
@@ -127,8 +127,8 @@ static int wv_read_block_header(AVFormatContext ctx, AVIOContext pb, int appen · 16 unmodified lines
127	}	127	}
128	while(url_ftell(pb) < block_end){	128	while(url_ftell(pb) < block_end){
129	int id, size;	129	int id, size;
130	id = get_byte(pb);	130	id = avio_r8(pb);
131	size = (id & 0x80) ? get_le24(pb) : get_byte(pb);	131	size = (id & 0x80) ? avio_rl24(pb) : avio_r8(pb);
132	size <<= 1;	132	size <<= 1;
133	if(id&0x40)	133	if(id&0x40)
134	size--;	134	size--;
@@ -138,24 +138,24 @@ static int wv_read_block_header(AVFormatContext ctx, AVIOContext pb, int appen · 3 unmodified lines
138	av_log(ctx, AV_LOG_ERROR, "Insufficient channel information\n");	138	av_log(ctx, AV_LOG_ERROR, "Insufficient channel information\n");
139	return -1;	139	return -1;
140	}	140	}
141	chan = get_byte(pb);	141	chan = avio_r8(pb);
142	switch(size - 2){	142	switch(size - 2){
143	case 0:	143	case 0:
144	chmask = get_byte(pb);	144	chmask = avio_r8(pb);
145	break;	145	break;
146	case 1:	146	case 1:
147	chmask = get_le16(pb);	147	chmask = avio_rl16(pb);
148	break;	148	break;
149	case 2:	149	case 2:
150	chmask = get_le24(pb);	150	chmask = avio_rl24(pb);
151	break;	151	break;
152	case 3:	152	case 3:
153	chmask = get_le32(pb);	153	chmask = avio_rl32(pb);
154	break;	154	break;
155	case 5:	155	case 5:
156	url_fskip(pb, 1);	156	url_fskip(pb, 1);
157	chan \|= (get_byte(pb) & 0xF) << 8;	157	chan \|= (avio_r8(pb) & 0xF) << 8;
158	chmask = get_le24(pb);	158	chmask = avio_rl24(pb);
159	break;	159	break;
160	default:	160	default:
161	av_log(ctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);	161	av_log(ctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
@@ -163,7 +163,7 @@ static int wv_read_block_header(AVFormatContext ctx, AVIOContext pb, int appen · 1 unmodified line
163	}	163	}
164	break;	164	break;
165	case 0x27:	165	case 0x27:
166	rate = get_le24(pb);	166	rate = avio_rl24(pb);
167	break;	167	break;
168	default:	168	default:
169	url_fskip(pb, size);	169	url_fskip(pb, size);
@@ -254,13 +254,13 @@ static int wv_read_packet(AVFormatContext *s, · 84 unmodified lines
254	if(wc->multichannel)	254	if(wc->multichannel)
255	AV_WL32(pkt->data, wc->blksize + WV_EXTRA_SIZE + 12);	255	AV_WL32(pkt->data, wc->blksize + WV_EXTRA_SIZE + 12);
256	memcpy(pkt->data + off, wc->extra, WV_EXTRA_SIZE);	256	memcpy(pkt->data + off, wc->extra, WV_EXTRA_SIZE);
257	ret = get_buffer(s->pb, pkt->data + WV_EXTRA_SIZE + off, wc->blksize);	257	ret = avio_read(s->pb, pkt->data + WV_EXTRA_SIZE + off, wc->blksize);
258	if(ret != wc->blksize){	258	if(ret != wc->blksize){
259	av_free_packet(pkt);	259	av_free_packet(pkt);
260	return AVERROR(EIO);	260	return AVERROR(EIO);
261	}	261	}
262	while(!(wc->flags & WV_END_BLOCK)){	262	while(!(wc->flags & WV_END_BLOCK)){
263	if(get_le32(s->pb) != MKTAG('w', 'v', 'p', 'k')){	263	if(avio_rl32(s->pb) != MKTAG('w', 'v', 'p', 'k')){
264	av_free_packet(pkt);	264	av_free_packet(pkt);
265	return -1;	265	return -1;
266	}	266	}
@@ -275,16 +275,16 @@ static int wv_read_packet(AVFormatContext *s, · 8 unmodified lines
275	return -1;	275	return -1;
276	}	276	}
277	wc->blksize = size;	277	wc->blksize = size;
278	ver = get_le16(s->pb);	278	ver = avio_rl16(s->pb);
279	if(ver < 0x402 \|\| ver > 0x410){	279	if(ver < 0x402 \|\| ver > 0x410){
280	av_free_packet(pkt);	280	av_free_packet(pkt);
281	av_log(s, AV_LOG_ERROR, "Unsupported version %03X\n", ver);	281	av_log(s, AV_LOG_ERROR, "Unsupported version %03X\n", ver);
282	return -1;	282	return -1;
283	}	283	}
284	get_byte(s->pb); // track no	284	avio_r8(s->pb); // track no
285	get_byte(s->pb); // track sub index	285	avio_r8(s->pb); // track sub index
286	wc->samples = get_le32(s->pb); // total samples in file	286	wc->samples = avio_rl32(s->pb); // total samples in file
287	wc->soff = get_le32(s->pb); // offset in samples of current block	287	wc->soff = avio_rl32(s->pb); // offset in samples of current block
288	if((ret = av_append_packet(s->pb, pkt, WV_EXTRA_SIZE)) < 0){	288	if((ret = av_append_packet(s->pb, pkt, WV_EXTRA_SIZE)) < 0){
289	av_free_packet(pkt);	289	av_free_packet(pkt);
290	return ret;	290	return ret;

libavformat/xa.c+6−6

@@ -77,14 +77,14 @@ static int xa_read_header(AVFormatContext *s, · 76 unmodified lines
77	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;	77	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
78	st->codec->codec_id = CODEC_ID_ADPCM_EA_MAXIS_XA;	78	st->codec->codec_id = CODEC_ID_ADPCM_EA_MAXIS_XA;
79	url_fskip(pb, 4); /* Skip the XA ID */	79	url_fskip(pb, 4); /* Skip the XA ID */
80	xa->out_size = get_le32(pb);	80	xa->out_size = avio_rl32(pb);
81	url_fskip(pb, 2); /* Skip the tag */	81	url_fskip(pb, 2); /* Skip the tag */
82	st->codec->channels = get_le16(pb);	82	st->codec->channels = avio_rl16(pb);
83	st->codec->sample_rate = get_le32(pb);	83	st->codec->sample_rate = avio_rl32(pb);
84	/* Value in file is average byte rate*/	84	/* Value in file is average byte rate*/
85	st->codec->bit_rate = get_le32(pb) * 8;	85	st->codec->bit_rate = avio_rl32(pb) * 8;
86	st->codec->block_align = get_le16(pb);	86	st->codec->block_align = avio_rl16(pb);
87	st->codec->bits_per_coded_sample = get_le16(pb);	87	st->codec->bits_per_coded_sample = avio_rl16(pb);
88		88
89	av_set_pts_info(st, 64, 1, st->codec->sample_rate);	89	av_set_pts_info(st, 64, 1, st->codec->sample_rate);
90		90

libavformat/yop.c+7−7

@@ -83,14 +83,14 @@ static int yop_read_header(AVFormatContext s, AVFormatParameters ap) · 82 unmodified lines
83		83
84	url_fskip(pb, 6);	84	url_fskip(pb, 6);
85		85
86	frame_rate = get_byte(pb);	86	frame_rate = avio_r8(pb);
87	yop->frame_size = get_byte(pb) * 2048;	87	yop->frame_size = avio_r8(pb) * 2048;
88	video_dec->width = get_le16(pb);	88	video_dec->width = avio_rl16(pb);
89	video_dec->height = get_le16(pb);	89	video_dec->height = avio_rl16(pb);
90		90
91	video_stream->sample_aspect_ratio = (AVRational){1, 2};	91	video_stream->sample_aspect_ratio = (AVRational){1, 2};
92		92
93	ret = get_buffer(pb, video_dec->extradata, 8);	93	ret = avio_read(pb, video_dec->extradata, 8);
94	if (ret < 8)	94	if (ret < 8)
95	return ret < 0 ? ret : AVERROR_EOF;	95	return ret < 0 ? ret : AVERROR_EOF;
96		96
@@ -138,7 +138,7 @@ static int yop_read_packet(AVFormatContext s, AVPacket pkt) · 41 unmodified lines
138		138
139	yop->video_packet.pos = url_ftell(pb);	139	yop->video_packet.pos = url_ftell(pb);
140		140
141	ret = get_buffer(pb, yop->video_packet.data, yop->palette_size);	141	ret = avio_read(pb, yop->video_packet.data, yop->palette_size);
142	if (ret < 0) {	142	if (ret < 0) {
143	goto err_out;	143	goto err_out;
144	}else if (ret < yop->palette_size) {	144	}else if (ret < yop->palette_size) {
@@ -155,7 +155,7 @@ static int yop_read_packet(AVFormatContext s, AVPacket pkt) · 10 unmodified lines
155		155
156	url_fskip(pb, yop->audio_block_length - ret);	156	url_fskip(pb, yop->audio_block_length - ret);
157		157
158	ret = get_buffer(pb, yop->video_packet.data + yop->palette_size,	158	ret = avio_read(pb, yop->video_packet.data + yop->palette_size,
159	actual_video_data_size);	159	actual_video_data_size);
160	if (ret < 0)	160	if (ret < 0)
161	goto err_out;	161	goto err_out;

libavformat/yuv4mpeg.c+2−2

@@ -200,7 +200,7 @@ static int yuv4_read_header(AVFormatContext s, AVFormatParameters ap) · 199 unmodified lines
200	struct frame_attributes *s1 = s->priv_data;	200	struct frame_attributes *s1 = s->priv_data;
201		201
202	for (i=0; i<MAX_YUV4_HEADER; i++) {	202	for (i=0; i<MAX_YUV4_HEADER; i++) {
203	header[i] = get_byte(pb);	203	header[i] = avio_r8(pb);
204	if (header[i] == '\n') {	204	if (header[i] == '\n') {
205	header[i+1] = 0x20; // Add a space after last option. Makes parsing "444" vs "444alpha" easier.	205	header[i+1] = 0x20; // Add a space after last option. Makes parsing "444" vs "444alpha" easier.
206	header[i+2] = 0;	206	header[i+2] = 0;
@@ -352,7 +352,7 @@ static int yuv4_read_packet(AVFormatContext s, AVPacket pkt) · 145 unmodified lines
352	struct frame_attributes *s1 = s->priv_data;	352	struct frame_attributes *s1 = s->priv_data;
353		353
354	for (i=0; i<MAX_FRAME_HEADER; i++) {	354	for (i=0; i<MAX_FRAME_HEADER; i++) {
355	header[i] = get_byte(s->pb);	355	header[i] = avio_r8(s->pb);
356	if (header[i] == '\n') {	356	if (header[i] == '\n') {
357	header[i+1] = 0;	357	header[i+1] = 0;
358	break;	358	break;

avio: avio_ prefixes for get_* functions

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code