sigrid/ffmpeg

avconv.c+11−11

@@ -1337,7 +1337,7 @@ static void do_subtitle_out(AVFormatContext *s, · 1336 unmodified lines
1337	1337	/* Note: DVB subtitle need one packet to draw them and one other
1338	1338	packet to clear them */
1339	1339	/* XXX: signal it in the codec context ? */
1340		− if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
	1340	+ if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
1341	1341	nb = 2;
1342	1342	else
1343	1343	nb = 1;
@@ -1363,7 +1363,7 @@ static void do_subtitle_out(AVFormatContext *s, · 19 unmodified lines
1363	1363	pkt.data = subtitle_out;
1364	1364	pkt.size = subtitle_out_size;
1365	1365	pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1366		− if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
	1366	+ if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
1367	1367	/* XXX: the pts correction is handled here. Maybe handling
1368	1368	it in the codec would be better */
1369	1369	if (i == 0)
@@ -1416,7 +1416,7 @@ static void do_video_out(AVFormatContext *s, · 46 unmodified lines
1416	1416	return;
1417	1417
1418	1418	if (s->oformat->flags & AVFMT_RAWPICTURE &&
1419		− enc->codec->id == CODEC_ID_RAWVIDEO) {
	1419	+ enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
1420	1420	/* raw pictures are written as AVPicture structure to
1421	1421	avoid any copies. We support temporarily the older
1422	1422	method. */
@@ -1736,7 +1736,7 @@ static void flush_encoders(void) · 313 unmodified lines
1736	1736
1737	1737	if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1738	1738	continue;
1739		− if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
	1739	+ if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
1740	1740	continue;
1741	1741
1742	1742	for (;;) {
@@ -1850,10 +1850,10 @@ static void do_streamcopy(InputStream ist, OutputStream ost, const AVPacket *p · 107 unmodified lines
1850	1850	opkt.flags = pkt->flags;
1851	1851
1852	1852	// FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1853		− if ( ost->st->codec->codec_id != CODEC_ID_H264
1854		− && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1855		− && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1856		− && ost->st->codec->codec_id != CODEC_ID_VC1
	1853	+ if ( ost->st->codec->codec_id != AV_CODEC_ID_H264
	1854	+ && ost->st->codec->codec_id != AV_CODEC_ID_MPEG1VIDEO
	1855	+ && ost->st->codec->codec_id != AV_CODEC_ID_MPEG2VIDEO
	1856	+ && ost->st->codec->codec_id != AV_CODEC_ID_VC1
1857	1857	) {
1858	1858	if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1859	1859	opkt.destruct = av_destruct_packet;
@@ -4230,7 +4230,7 @@ static void opt_output_file(void optctx, const char filename) · 2370 unmodified lines
4230	4230	}
4231	4231
4232	4232	/* video: highest resolution */
4233		− if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
	4233	+ if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
4234	4234	int area = 0, idx = -1;
4235	4235	for (i = 0; i < nb_input_streams; i++) {
4236	4236	ist = input_streams[i];
@@ -4244,7 +4244,7 @@ static void opt_output_file(void optctx, const char filename) · 7 unmodified lines
4244	4244	}
4245	4245
4246	4246	/* audio: most channels */
4247		− if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
	4247	+ if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
4248	4248	int channels = 0, idx = -1;
4249	4249	for (i = 0; i < nb_input_streams; i++) {
4250	4250	ist = input_streams[i];
@@ -4258,7 +4258,7 @@ static void opt_output_file(void optctx, const char filename) · 7 unmodified lines
4258	4258	}
4259	4259
4260	4260	/* subtitles: pick first */
4261		− if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
	4261	+ if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
4262	4262	for (i = 0; i < nb_input_streams; i++)
4263	4263	if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4264	4264	NEW_STREAM(subtitle, i);

avprobe.c+1−1

@@ -730,7 +730,7 @@ static int open_input_file(AVFormatContext *fmt_ctx_ptr, const char filename) · 729 unmodified lines
730	730	AVStream *stream = fmt_ctx->streams[i];
731	731	AVCodec *codec;
732	732
733		− if (stream->codec->codec_id == CODEC_ID_PROBE) {
	733	+ if (stream->codec->codec_id == AV_CODEC_ID_PROBE) {
734	734	fprintf(stderr, "Failed to probe codec for input stream %d\n",
735	735	stream->index);
736	736	} else if (!(codec = avcodec_find_decoder(stream->codec->codec_id))) {

avserver.c+18−18

@@ -3539,7 +3539,7 @@ static void extract_mpeg4_header(AVFormatContext *infile) · 3538 unmodified lines
3539	3539	mpeg4_count = 0;
3540	3540	for(i=0;i<infile->nb_streams;i++) {
3541	3541	st = infile->streams[i];
3542		− if (st->codec->codec_id == CODEC_ID_MPEG4 &&
	3542	+ if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
3543	3543	st->codec->extradata_size == 0) {
3544	3544	mpeg4_count++;
3545	3545	}
@@ -3552,7 +3552,7 @@ static void extract_mpeg4_header(AVFormatContext *infile) · 6 unmodified lines
3552	3552	if (av_read_packet(infile, &pkt) < 0)
3553	3553	break;
3554	3554	st = infile->streams[pkt.stream_index];
3555		− if (st->codec->codec_id == CODEC_ID_MPEG4 &&
	3555	+ if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
3556	3556	st->codec->extradata_size == 0) {
3557	3557	av_freep(&st->codec->extradata);
3558	3558	/* fill extradata with the header */
@@ -3866,22 +3866,22 @@ static void add_codec(FFStream stream, AVCodecContext av) · 307 unmodified lines
3866	3866	memcpy(st->codec, av, sizeof(AVCodecContext));
3867	3867	}
3868	3868
3869		−static enum CodecID opt_audio_codec(const char *arg)
	3869	+static enum AVCodecID opt_audio_codec(const char *arg)
3870	3870	{
3871	3871	AVCodec *p= avcodec_find_encoder_by_name(arg);
3872	3872
3873	3873	if (p == NULL \|\| p->type != AVMEDIA_TYPE_AUDIO)
3874		− return CODEC_ID_NONE;
	3874	+ return AV_CODEC_ID_NONE;
3875	3875
3876	3876	return p->id;
3877	3877	}
3878	3878
3879		−static enum CodecID opt_video_codec(const char *arg)
	3879	+static enum AVCodecID opt_video_codec(const char *arg)
3880	3880	{
3881	3881	AVCodec *p= avcodec_find_encoder_by_name(arg);
3882	3882
3883	3883	if (p == NULL \|\| p->type != AVMEDIA_TYPE_VIDEO)
3884		− return CODEC_ID_NONE;
	3884	+ return AV_CODEC_ID_NONE;
3885	3885
3886	3886	return p->id;
3887	3887	}
@@ -3924,7 +3924,7 @@ static int avserver_opt_default(const char opt, const char arg, · 36 unmodified lines
3924	3924
3925	3925	static int avserver_opt_preset(const char *arg,
3926	3926	AVCodecContext *avctx, int type,
3927		− enum CodecID audio_id, enum CodecID video_id)
	3927	+ enum AVCodecID audio_id, enum AVCodecID video_id)
3928	3928	{
3929	3929	FILE *f=NULL;
3930	3930	char filename[1000], tmp[1000], tmp2[1000], line[1000];
@@ -4006,7 +4006,7 @@ static int parse_ffconfig(const char *filename) · 75 unmodified lines
4006	4006	FFStream *last_stream, stream, *redirect;
4007	4007	FFStream *last_feed, feed, *s;
4008	4008	AVCodecContext audio_enc, video_enc;
4009		− enum CodecID audio_id, video_id;
	4009	+ enum AVCodecID audio_id, video_id;
4010	4010
4011	4011	f = fopen(filename, "r");
4012	4012	if (!f) {
@@ -4023,8 +4023,8 @@ static int parse_ffconfig(const char *filename) · 10 unmodified lines
4023	4023	stream = NULL;
4024	4024	feed = NULL;
4025	4025	redirect = NULL;
4026		− audio_id = CODEC_ID_NONE;
4027		− video_id = CODEC_ID_NONE;
	4026	+ audio_id = AV_CODEC_ID_NONE;
	4027	+ video_id = AV_CODEC_ID_NONE;
4028	4028
4029	4029	#define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
4030	4030	for(;;) {
@@ -4216,8 +4216,8 @@ static int parse_ffconfig(const char *filename) · 185 unmodified lines
4216	4216	stream->fmt = avserver_guess_format(NULL, stream->filename, NULL);
4217	4217	avcodec_get_context_defaults3(&video_enc, NULL);
4218	4218	avcodec_get_context_defaults3(&audio_enc, NULL);
4219		− audio_id = CODEC_ID_NONE;
4220		− video_id = CODEC_ID_NONE;
	4219	+ audio_id = AV_CODEC_ID_NONE;
	4220	+ video_id = AV_CODEC_ID_NONE;
4221	4221	if (stream->fmt) {
4222	4222	audio_id = stream->fmt->audio_codec;
4223	4223	video_id = stream->fmt->video_codec;
@@ -4299,13 +4299,13 @@ static int parse_ffconfig(const char *filename) · 75 unmodified lines
4299	4299	} else if (!av_strcasecmp(cmd, "AudioCodec")) {
4300	4300	get_arg(arg, sizeof(arg), &p);
4301	4301	audio_id = opt_audio_codec(arg);
4302		− if (audio_id == CODEC_ID_NONE) {
	4302	+ if (audio_id == AV_CODEC_ID_NONE) {
4303	4303	ERROR("Unknown AudioCodec: %s\n", arg);
4304	4304	}
4305	4305	} else if (!av_strcasecmp(cmd, "VideoCodec")) {
4306	4306	get_arg(arg, sizeof(arg), &p);
4307	4307	video_id = opt_video_codec(arg);
4308		− if (video_id == CODEC_ID_NONE) {
	4308	+ if (video_id == AV_CODEC_ID_NONE) {
4309	4309	ERROR("Unknown VideoCodec: %s\n", arg);
4310	4310	}
4311	4311	} else if (!av_strcasecmp(cmd, "MaxTime")) {
@@ -4496,9 +4496,9 @@ static int parse_ffconfig(const char *filename) · 184 unmodified lines
4496	4496	if (stream)
4497	4497	video_enc.dark_masking = atof(arg);
4498	4498	} else if (!av_strcasecmp(cmd, "NoVideo")) {
4499		− video_id = CODEC_ID_NONE;
	4499	+ video_id = AV_CODEC_ID_NONE;
4500	4500	} else if (!av_strcasecmp(cmd, "NoAudio")) {
4501		− audio_id = CODEC_ID_NONE;
	4501	+ audio_id = AV_CODEC_ID_NONE;
4502	4502	} else if (!av_strcasecmp(cmd, "ACL")) {
4503	4503	parse_acl_row(stream, feed, NULL, p, filename, line_num);
4504	4504	} else if (!av_strcasecmp(cmd, "DynamicACL")) {
@@ -4536,12 +4536,12 @@ static int parse_ffconfig(const char *filename) · 31 unmodified lines
4536	4536	ERROR("No corresponding <Stream> for </Stream>\n");
4537	4537	} else {
4538	4538	if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4539		− if (audio_id != CODEC_ID_NONE) {
	4539	+ if (audio_id != AV_CODEC_ID_NONE) {
4540	4540	audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
4541	4541	audio_enc.codec_id = audio_id;
4542	4542	add_codec(stream, &audio_enc);
4543	4543	}
4544		− if (video_id != CODEC_ID_NONE) {
	4544	+ if (video_id != AV_CODEC_ID_NONE) {
4545	4545	video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
4546	4546	video_enc.codec_id = video_id;
4547	4547	add_codec(stream, &video_enc);

cmdutils.c+1−1

@@ -948,7 +948,7 @@ int check_stream_specifier(AVFormatContext s, AVStream st, const char *spec) · 947 unmodified lines
948	948	return AVERROR(EINVAL);
949	949	}
950	950
951		−AVDictionary filter_codec_opts(AVDictionary opts, enum CodecID codec_id,
	951	+AVDictionary filter_codec_opts(AVDictionary opts, enum AVCodecID codec_id,
952	952	AVFormatContext s, AVStream st, AVCodec *codec)
953	953	{
954	954	AVDictionary *ret = NULL;

cmdutils.h+1−1

@@ -218,7 +218,7 @@ int check_stream_specifier(AVFormatContext s, AVStream st, const char *spec); · 217 unmodified lines
218	218	* If null, the default one is looked up according to the codec id.
219	219	* @return a pointer to the created dictionary
220	220	*/
221		−AVDictionary filter_codec_opts(AVDictionary opts, enum CodecID codec_id,
	221	+AVDictionary filter_codec_opts(AVDictionary opts, enum AVCodecID codec_id,
222	222	AVFormatContext s, AVStream st, AVCodec *codec);
223	223
224	224	/**

doc/developer.texi+1−1

@@ -403,7 +403,7 @@ send a reminder by email. Your patch should eventually be dealt with. · 402 unmodified lines
403	403	@item
404	404	Did you register it in @file{allcodecs.c} or @file{allformats.c}?
405	405	@item
406		− Did you add the CodecID to @file{avcodec.h}?
	406	+ Did you add the AVCodecID to @file{avcodec.h}?
407	407	@item
408	408	If it has a fourcc, did you add it to @file{libavformat/riff.c},
409	409	even if it is only a decoder?

libavcodec/4xm.c+1−1

@@ -931,7 +931,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 930 unmodified lines
931	931	AVCodec ff_fourxm_decoder = {
932	932	.name = "4xm",
933	933	.type = AVMEDIA_TYPE_VIDEO,
934		− .id = CODEC_ID_4XM,
	934	+ .id = AV_CODEC_ID_4XM,
935	935	.priv_data_size = sizeof(FourXContext),
936	936	.init = decode_init,
937	937	.close = decode_end,

libavcodec/8bps.c+1−1

@@ -226,7 +226,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 225 unmodified lines
226	226	AVCodec ff_eightbps_decoder = {
227	227	.name = "8bps",
228	228	.type = AVMEDIA_TYPE_VIDEO,
229		− .id = CODEC_ID_8BPS,
	229	+ .id = AV_CODEC_ID_8BPS,
230	230	.priv_data_size = sizeof(EightBpsContext),
231	231	.init = decode_init,
232	232	.close = decode_end,

libavcodec/8svx.c+7−7

@@ -91,7 +91,7 @@ static int eightsvx_decode_frame(AVCodecContext avctx, void data, · 90 unmodified lines
91	91	int buf_size;
92	92	uint8_t *out_data;
93	93	int ret;
94		− int is_compr = (avctx->codec_id != CODEC_ID_PCM_S8_PLANAR);
	94	+ int is_compr = (avctx->codec_id != AV_CODEC_ID_PCM_S8_PLANAR);
95	95
96	96	/* for the first packet, copy data to buffer */
97	97	if (avpkt->data) {
@@ -180,13 +180,13 @@ static av_cold int eightsvx_decode_init(AVCodecContext *avctx) · 82 unmodified lines
180	180	}
181	181
182	182	switch(avctx->codec->id) {
183		− case CODEC_ID_8SVX_FIB:
	183	+ case AV_CODEC_ID_8SVX_FIB:
184	184	esc->table = fibonacci;
185	185	break;
186		− case CODEC_ID_8SVX_EXP:
	186	+ case AV_CODEC_ID_8SVX_EXP:
187	187	esc->table = exponential;
188	188	break;
189		− case CODEC_ID_PCM_S8_PLANAR:
	189	+ case AV_CODEC_ID_PCM_S8_PLANAR:
190	190	break;
191	191	default:
192	192	return -1;
@@ -212,7 +212,7 @@ static av_cold int eightsvx_decode_close(AVCodecContext *avctx) · 19 unmodified lines
212	212	AVCodec ff_eightsvx_fib_decoder = {
213	213	.name = "8svx_fib",
214	214	.type = AVMEDIA_TYPE_AUDIO,
215		− .id = CODEC_ID_8SVX_FIB,
	215	+ .id = AV_CODEC_ID_8SVX_FIB,
216	216	.priv_data_size = sizeof (EightSvxContext),
217	217	.init = eightsvx_decode_init,
218	218	.close = eightsvx_decode_close,
@@ -224,7 +224,7 @@ AVCodec ff_eightsvx_fib_decoder = { · 5 unmodified lines
224	224	AVCodec ff_eightsvx_exp_decoder = {
225	225	.name = "8svx_exp",
226	226	.type = AVMEDIA_TYPE_AUDIO,
227		− .id = CODEC_ID_8SVX_EXP,
	227	+ .id = AV_CODEC_ID_8SVX_EXP,
228	228	.priv_data_size = sizeof (EightSvxContext),
229	229	.init = eightsvx_decode_init,
230	230	.close = eightsvx_decode_close,
@@ -236,7 +236,7 @@ AVCodec ff_eightsvx_exp_decoder = { · 5 unmodified lines
236	236	AVCodec ff_pcm_s8_planar_decoder = {
237	237	.name = "pcm_s8_planar",
238	238	.type = AVMEDIA_TYPE_AUDIO,
239		− .id = CODEC_ID_PCM_S8_PLANAR,
	239	+ .id = AV_CODEC_ID_PCM_S8_PLANAR,
240	240	.priv_data_size = sizeof(EightSvxContext),
241	241	.init = eightsvx_decode_init,
242	242	.close = eightsvx_decode_close,

libavcodec/a64multienc.c+3−3

@@ -187,7 +187,7 @@ static av_cold int a64multi_init_encoder(AVCodecContext *avctx) · 186 unmodified lines
187	187	av_log(avctx, AV_LOG_INFO, "charset lifetime set to %d frame(s)\n", c->mc_lifetime);
188	188
189	189	c->mc_frame_counter = 0;
190		− c->mc_use_5col = avctx->codec->id == CODEC_ID_A64_MULTI5;
	190	+ c->mc_use_5col = avctx->codec->id == AV_CODEC_ID_A64_MULTI5;
191	191	c->mc_pal_size = 4 + c->mc_use_5col;
192	192
193	193	/* precalc luma values for later use */
@@ -373,7 +373,7 @@ static int a64multi_encode_frame(AVCodecContext avctx, AVPacket pkt, · 179 unmodified lines
373	373	AVCodec ff_a64multi_encoder = {
374	374	.name = "a64multi",
375	375	.type = AVMEDIA_TYPE_VIDEO,
376		− .id = CODEC_ID_A64_MULTI,
	376	+ .id = AV_CODEC_ID_A64_MULTI,
377	377	.priv_data_size = sizeof(A64Context),
378	378	.init = a64multi_init_encoder,
379	379	.encode2 = a64multi_encode_frame,
@@ -386,7 +386,7 @@ AVCodec ff_a64multi_encoder = { · 6 unmodified lines
386	386	AVCodec ff_a64multi5_encoder = {
387	387	.name = "a64multi5",
388	388	.type = AVMEDIA_TYPE_VIDEO,
389		− .id = CODEC_ID_A64_MULTI5,
	389	+ .id = AV_CODEC_ID_A64_MULTI5,
390	390	.priv_data_size = sizeof(A64Context),
391	391	.init = a64multi_init_encoder,
392	392	.encode2 = a64multi_encode_frame,

libavcodec/aac_ac3_parser.c+3−3

@@ -78,7 +78,7 @@ get_next: · 77 unmodified lines
78	78	and total number of samples found in an AAC ADTS header are not
79	79	reliable. Bit rate is still accurate because the total frame duration in
80	80	seconds is still correct (as is the number of bits in the frame). */
81		− if (avctx->codec_id != CODEC_ID_AAC) {
	81	+ if (avctx->codec_id != AV_CODEC_ID_AAC) {
82	82	avctx->sample_rate = s->sample_rate;
83	83
84	84	/* allow downmixing to stereo (or mono for AC-3) */
@@ -86,8 +86,8 @@ get_next: · 1 unmodified line
86	86	avctx->request_channels < s->channels &&
87	87	(avctx->request_channels <= 2 \|\|
88	88	(avctx->request_channels == 1 &&
89		− (avctx->codec_id == CODEC_ID_AC3 \|\|
90		− avctx->codec_id == CODEC_ID_EAC3)))) {
	89	+ (avctx->codec_id == AV_CODEC_ID_AC3 \|\|
	90	+ avctx->codec_id == AV_CODEC_ID_EAC3)))) {
91	91	avctx->channels = avctx->request_channels;
92	92	} else {
93	93	avctx->channels = s->channels;

libavcodec/aac_ac3_parser.h+1−1

@@ -55,7 +55,7 @@ typedef struct AACAC3ParseContext { · 54 unmodified lines
55	55	uint64_t state;
56	56
57	57	int need_next_header;
58		− enum CodecID codec_id;
	58	+ enum AVCodecID codec_id;
59	59	} AACAC3ParseContext;
60	60
61	61	int ff_aac_ac3_parse(AVCodecParserContext *s1,

libavcodec/aac_parser.c+1−1

@@ -61,7 +61,7 @@ static av_cold int aac_parse_init(AVCodecParserContext *s1) · 60 unmodified lines
61	61
62	62
63	63	AVCodecParser ff_aac_parser = {
64		− .codec_ids = { CODEC_ID_AAC },
	64	+ .codec_ids = { AV_CODEC_ID_AAC },
65	65	.priv_data_size = sizeof(AACAC3ParseContext),
66	66	.parser_init = aac_parse_init,
67	67	.parser_parse = ff_aac_ac3_parse,

libavcodec/aacdec.c+2−2

@@ -2841,7 +2841,7 @@ static av_cold int latm_decode_init(AVCodecContext *avctx) · 2840 unmodified lines
2841	2841	AVCodec ff_aac_decoder = {
2842	2842	.name = "aac",
2843	2843	.type = AVMEDIA_TYPE_AUDIO,
2844		− .id = CODEC_ID_AAC,
	2844	+ .id = AV_CODEC_ID_AAC,
2845	2845	.priv_data_size = sizeof(AACContext),
2846	2846	.init = aac_decode_init,
2847	2847	.close = aac_decode_close,
@@ -2862,7 +2862,7 @@ AVCodec ff_aac_decoder = { · 14 unmodified lines
2862	2862	AVCodec ff_aac_latm_decoder = {
2863	2863	.name = "aac_latm",
2864	2864	.type = AVMEDIA_TYPE_AUDIO,
2865		− .id = CODEC_ID_AAC_LATM,
	2865	+ .id = AV_CODEC_ID_AAC_LATM,
2866	2866	.priv_data_size = sizeof(struct LATMContext),
2867	2867	.init = latm_decode_init,
2868	2868	.close = aac_decode_close,

libavcodec/aacenc.c+1−1

@@ -819,7 +819,7 @@ static const AVClass aacenc_class = { · 818 unmodified lines
819	819	AVCodec ff_aac_encoder = {
820	820	.name = "aac",
821	821	.type = AVMEDIA_TYPE_AUDIO,
822		− .id = CODEC_ID_AAC,
	822	+ .id = AV_CODEC_ID_AAC,
823	823	.priv_data_size = sizeof(AACEncContext),
824	824	.init = aac_encode_init,
825	825	.encode2 = aac_encode_frame,

libavcodec/aasc.c+1−1

@@ -106,7 +106,7 @@ static av_cold int aasc_decode_end(AVCodecContext *avctx) · 105 unmodified lines
106	106	AVCodec ff_aasc_decoder = {
107	107	.name = "aasc",
108	108	.type = AVMEDIA_TYPE_VIDEO,
109		− .id = CODEC_ID_AASC,
	109	+ .id = AV_CODEC_ID_AASC,
110	110	.priv_data_size = sizeof(AascContext),
111	111	.init = aasc_decode_init,
112	112	.close = aasc_decode_end,

libavcodec/ac3_parser.c+4−4

@@ -167,9 +167,9 @@ static int ac3_sync(uint64_t state, AACAC3ParseContext *hdr_info, · 166 unmodified lines
167	167	if (hdr.bitstream_mode == 0x7 && hdr.channels > 1)
168	168	hdr_info->service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
169	169	if(hdr.bitstream_id>10)
170		− hdr_info->codec_id = CODEC_ID_EAC3;
171		− else if (hdr_info->codec_id == CODEC_ID_NONE)
172		− hdr_info->codec_id = CODEC_ID_AC3;
	170	+ hdr_info->codec_id = AV_CODEC_ID_EAC3;
	171	+ else if (hdr_info->codec_id == AV_CODEC_ID_NONE)
	172	+ hdr_info->codec_id = AV_CODEC_ID_AC3;
173	173
174	174	*need_next_header = (hdr.frame_type != EAC3_FRAME_TYPE_AC3_CONVERT);
175	175	*new_frame_start = (hdr.frame_type != EAC3_FRAME_TYPE_DEPENDENT);
@@ -186,7 +186,7 @@ static av_cold int ac3_parse_init(AVCodecParserContext *s1) · 10 unmodified lines
186	186
187	187
188	188	AVCodecParser ff_ac3_parser = {
189		− .codec_ids = { CODEC_ID_AC3, CODEC_ID_EAC3 },
	189	+ .codec_ids = { AV_CODEC_ID_AC3, AV_CODEC_ID_EAC3 },
190	190	.priv_data_size = sizeof(AACAC3ParseContext),
191	191	.parser_init = ac3_parse_init,
192	192	.parser_parse = ff_aac_ac3_parse,

libavcodec/ac3dec.c+2−2

@@ -1460,7 +1460,7 @@ static const AVClass ac3_decoder_class = { · 1459 unmodified lines
1460	1460	AVCodec ff_ac3_decoder = {
1461	1461	.name = "ac3",
1462	1462	.type = AVMEDIA_TYPE_AUDIO,
1463		− .id = CODEC_ID_AC3,
	1463	+ .id = AV_CODEC_ID_AC3,
1464	1464	.priv_data_size = sizeof (AC3DecodeContext),
1465	1465	.init = ac3_decode_init,
1466	1466	.close = ac3_decode_end,
@@ -1484,7 +1484,7 @@ static const AVClass eac3_decoder_class = { · 17 unmodified lines
1484	1484	AVCodec ff_eac3_decoder = {
1485	1485	.name = "eac3",
1486	1486	.type = AVMEDIA_TYPE_AUDIO,
1487		− .id = CODEC_ID_EAC3,
	1487	+ .id = AV_CODEC_ID_EAC3,
1488	1488	.priv_data_size = sizeof (AC3DecodeContext),
1489	1489	.init = ac3_decode_init,
1490	1490	.close = ac3_decode_end,

libavcodec/ac3enc.c+1−1

@@ -2430,7 +2430,7 @@ av_cold int ff_ac3_encode_init(AVCodecContext *avctx) · 2429 unmodified lines
2430	2430
2431	2431	s->avctx = avctx;
2432	2432
2433		− s->eac3 = avctx->codec_id == CODEC_ID_EAC3;
	2433	+ s->eac3 = avctx->codec_id == AV_CODEC_ID_EAC3;
2434	2434
2435	2435	ff_ac3_common_init();
2436	2436

libavcodec/ac3enc_fixed.c+1−1

@@ -144,7 +144,7 @@ static av_cold int ac3_fixed_encode_init(AVCodecContext *avctx) · 143 unmodified lines
144	144	AVCodec ff_ac3_fixed_encoder = {
145	145	.name = "ac3_fixed",
146	146	.type = AVMEDIA_TYPE_AUDIO,
147		− .id = CODEC_ID_AC3,
	147	+ .id = AV_CODEC_ID_AC3,
148	148	.priv_data_size = sizeof(AC3EncodeContext),
149	149	.init = ac3_fixed_encode_init,
150	150	.encode2 = ff_ac3_fixed_encode_frame,

libavcodec/ac3enc_float.c+1−1

@@ -143,7 +143,7 @@ static CoefType calc_cpl_coord(CoefSumType energy_ch, CoefSumType energy_cpl) · 142 unmodified lines
143	143	AVCodec ff_ac3_encoder = {
144	144	.name = "ac3",
145	145	.type = AVMEDIA_TYPE_AUDIO,
146		− .id = CODEC_ID_AC3,
	146	+ .id = AV_CODEC_ID_AC3,
147	147	.priv_data_size = sizeof(AC3EncodeContext),
148	148	.init = ff_ac3_encode_init,
149	149	.encode2 = ff_ac3_float_encode_frame,

libavcodec/adpcm.c+103−103

@@ -96,13 +96,13 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx) · 95 unmodified lines
96	96	unsigned int max_channels = 2;
97	97
98	98	switch(avctx->codec->id) {
99		− case CODEC_ID_ADPCM_EA:
	99	+ case AV_CODEC_ID_ADPCM_EA:
100	100	min_channels = 2;
101	101	break;
102		− case CODEC_ID_ADPCM_EA_R1:
103		− case CODEC_ID_ADPCM_EA_R2:
104		− case CODEC_ID_ADPCM_EA_R3:
105		− case CODEC_ID_ADPCM_EA_XAS:
	102	+ case AV_CODEC_ID_ADPCM_EA_R1:
	103	+ case AV_CODEC_ID_ADPCM_EA_R2:
	104	+ case AV_CODEC_ID_ADPCM_EA_R3:
	105	+ case AV_CODEC_ID_ADPCM_EA_XAS:
106	106	max_channels = 6;
107	107	break;
108	108	}
@@ -112,22 +112,22 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx) · 3 unmodified lines
112	112	}
113	113
114	114	switch(avctx->codec->id) {
115		− case CODEC_ID_ADPCM_CT:
	115	+ case AV_CODEC_ID_ADPCM_CT:
116	116	c->status[0].step = c->status[1].step = 511;
117	117	break;
118		− case CODEC_ID_ADPCM_IMA_WAV:
	118	+ case AV_CODEC_ID_ADPCM_IMA_WAV:
119	119	if (avctx->bits_per_coded_sample != 4) {
120	120	av_log(avctx, AV_LOG_ERROR, "Only 4-bit ADPCM IMA WAV files are supported\n");
121	121	return -1;
122	122	}
123	123	break;
124		− case CODEC_ID_ADPCM_IMA_APC:
	124	+ case AV_CODEC_ID_ADPCM_IMA_APC:
125	125	if (avctx->extradata && avctx->extradata_size >= 8) {
126	126	c->status[0].predictor = AV_RL32(avctx->extradata);
127	127	c->status[1].predictor = AV_RL32(avctx->extradata + 4);
128	128	}
129	129	break;
130		− case CODEC_ID_ADPCM_IMA_WS:
	130	+ case AV_CODEC_ID_ADPCM_IMA_WS:
131	131	if (avctx->extradata && avctx->extradata_size >= 2)
132	132	c->vqa_version = AV_RL16(avctx->extradata);
133	133	break;
@@ -423,22 +423,22 @@ static int get_nb_samples(AVCodecContext avctx, GetByteContext gb, · 289 unmodified lines
423	423
424	424	switch (avctx->codec->id) {
425	425	/* constant, only check buf_size */
426		− case CODEC_ID_ADPCM_EA_XAS:
	426	+ case AV_CODEC_ID_ADPCM_EA_XAS:
427	427	if (buf_size < 76 * ch)
428	428	return 0;
429	429	nb_samples = 128;
430	430	break;
431		− case CODEC_ID_ADPCM_IMA_QT:
	431	+ case AV_CODEC_ID_ADPCM_IMA_QT:
432	432	if (buf_size < 34 * ch)
433	433	return 0;
434	434	nb_samples = 64;
435	435	break;
436	436	/* simple 4-bit adpcm */
437		− case CODEC_ID_ADPCM_CT:
438		− case CODEC_ID_ADPCM_IMA_APC:
439		− case CODEC_ID_ADPCM_IMA_EA_SEAD:
440		− case CODEC_ID_ADPCM_IMA_WS:
441		− case CODEC_ID_ADPCM_YAMAHA:
	437	+ case AV_CODEC_ID_ADPCM_CT:
	438	+ case AV_CODEC_ID_ADPCM_IMA_APC:
	439	+ case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
	440	+ case AV_CODEC_ID_ADPCM_IMA_WS:
	441	+ case AV_CODEC_ID_ADPCM_YAMAHA:
442	442	nb_samples = buf_size * 2 / ch;
443	443	break;
444	444	}
@@ -448,46 +448,46 @@ static int get_nb_samples(AVCodecContext avctx, GetByteContext gb, · 3 unmodified lines
448	448	/* simple 4-bit adpcm, with header */
449	449	header_size = 0;
450	450	switch (avctx->codec->id) {
451		− case CODEC_ID_ADPCM_4XM:
452		− case CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break;
453		− case CODEC_ID_ADPCM_IMA_AMV: header_size = 8; break;
454		− case CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4; break;
	451	+ case AV_CODEC_ID_ADPCM_4XM:
	452	+ case AV_CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break;
	453	+ case AV_CODEC_ID_ADPCM_IMA_AMV: header_size = 8; break;
	454	+ case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4; break;
455	455	}
456	456	if (header_size > 0)
457	457	return (buf_size - header_size) * 2 / ch;
458	458
459	459	/* more complex formats */
460	460	switch (avctx->codec->id) {
461		− case CODEC_ID_ADPCM_EA:
	461	+ case AV_CODEC_ID_ADPCM_EA:
462	462	has_coded_samples = 1;
463	463	*coded_samples = bytestream2_get_le32(gb);
464	464	coded_samples -= coded_samples % 28;
465	465	nb_samples = (buf_size - 12) / 30 * 28;
466	466	break;
467		− case CODEC_ID_ADPCM_IMA_EA_EACS:
	467	+ case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
468	468	has_coded_samples = 1;
469	469	*coded_samples = bytestream2_get_le32(gb);
470	470	nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
471	471	break;
472		− case CODEC_ID_ADPCM_EA_MAXIS_XA:
	472	+ case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
473	473	nb_samples = (buf_size - ch) / ch * 2;
474	474	break;
475		− case CODEC_ID_ADPCM_EA_R1:
476		− case CODEC_ID_ADPCM_EA_R2:
477		− case CODEC_ID_ADPCM_EA_R3:
	475	+ case AV_CODEC_ID_ADPCM_EA_R1:
	476	+ case AV_CODEC_ID_ADPCM_EA_R2:
	477	+ case AV_CODEC_ID_ADPCM_EA_R3:
478	478	/* maximum number of samples */
479	479	/* has internal offsets and a per-frame switch to signal raw 16-bit */
480	480	has_coded_samples = 1;
481	481	switch (avctx->codec->id) {
482		− case CODEC_ID_ADPCM_EA_R1:
	482	+ case AV_CODEC_ID_ADPCM_EA_R1:
483	483	header_size = 4 + 9 * ch;
484	484	*coded_samples = bytestream2_get_le32(gb);
485	485	break;
486		− case CODEC_ID_ADPCM_EA_R2:
	486	+ case AV_CODEC_ID_ADPCM_EA_R2:
487	487	header_size = 4 + 5 * ch;
488	488	*coded_samples = bytestream2_get_le32(gb);
489	489	break;
490		− case CODEC_ID_ADPCM_EA_R3:
	490	+ case AV_CODEC_ID_ADPCM_EA_R3:
491	491	header_size = 4 + 5 * ch;
492	492	*coded_samples = bytestream2_get_be32(gb);
493	493	break;
@@ -496,35 +496,35 @@ static int get_nb_samples(AVCodecContext avctx, GetByteContext gb, · 2 unmodified lines
496	496	nb_samples = (buf_size - header_size) * 2 / ch;
497	497	nb_samples -= nb_samples % 28;
498	498	break;
499		− case CODEC_ID_ADPCM_IMA_DK3:
	499	+ case AV_CODEC_ID_ADPCM_IMA_DK3:
500	500	if (avctx->block_align > 0)
501	501	buf_size = FFMIN(buf_size, avctx->block_align);
502	502	nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
503	503	break;
504		− case CODEC_ID_ADPCM_IMA_DK4:
	504	+ case AV_CODEC_ID_ADPCM_IMA_DK4:
505	505	if (avctx->block_align > 0)
506	506	buf_size = FFMIN(buf_size, avctx->block_align);
507	507	nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
508	508	break;
509		− case CODEC_ID_ADPCM_IMA_WAV:
	509	+ case AV_CODEC_ID_ADPCM_IMA_WAV:
510	510	if (avctx->block_align > 0)
511	511	buf_size = FFMIN(buf_size, avctx->block_align);
512	512	nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8;
513	513	break;
514		− case CODEC_ID_ADPCM_MS:
	514	+ case AV_CODEC_ID_ADPCM_MS:
515	515	if (avctx->block_align > 0)
516	516	buf_size = FFMIN(buf_size, avctx->block_align);
517	517	nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
518	518	break;
519		− case CODEC_ID_ADPCM_SBPRO_2:
520		− case CODEC_ID_ADPCM_SBPRO_3:
521		− case CODEC_ID_ADPCM_SBPRO_4:
	519	+ case AV_CODEC_ID_ADPCM_SBPRO_2:
	520	+ case AV_CODEC_ID_ADPCM_SBPRO_3:
	521	+ case AV_CODEC_ID_ADPCM_SBPRO_4:
522	522	{
523	523	int samples_per_byte;
524	524	switch (avctx->codec->id) {
525		− case CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
526		− case CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
527		− case CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
	525	+ case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
	526	+ case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
	527	+ case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
528	528	}
529	529	if (!s->status[0].step_index) {
530	530	nb_samples++;
@@ -533,7 +533,7 @@ static int get_nb_samples(AVCodecContext avctx, GetByteContext gb, · 2 unmodified lines
533	533	nb_samples += buf_size * samples_per_byte / ch;
534	534	break;
535	535	}
536		− case CODEC_ID_ADPCM_SWF:
	536	+ case AV_CODEC_ID_ADPCM_SWF:
537	537	{
538	538	int buf_bits = buf_size * 8 - 2;
539	539	int nbits = (bytestream2_get_byte(gb) >> 6) + 2;
@@ -546,14 +546,14 @@ static int get_nb_samples(AVCodecContext avctx, GetByteContext gb, · 6 unmodified lines
546	546	nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
547	547	break;
548	548	}
549		− case CODEC_ID_ADPCM_THP:
	549	+ case AV_CODEC_ID_ADPCM_THP:
550	550	has_coded_samples = 1;
551	551	bytestream2_skip(gb, 4); // channel size
552	552	*coded_samples = bytestream2_get_be32(gb);
553	553	coded_samples -= coded_samples % 14;
554	554	nb_samples = (buf_size - 80) / (8 * ch) * 14;
555	555	break;
556		− case CODEC_ID_ADPCM_XA:
	556	+ case AV_CODEC_ID_ADPCM_XA:
557	557	nb_samples = (buf_size / 128) * 224 / ch;
558	558	break;
559	559	}
@@ -605,7 +605,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 45 unmodified lines
605	605	st = avctx->channels == 2 ? 1 : 0;
606	606
607	607	switch(avctx->codec->id) {
608		− case CODEC_ID_ADPCM_IMA_QT:
	608	+ case AV_CODEC_ID_ADPCM_IMA_QT:
609	609	/* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
610	610	Channel data is interleaved per-chunk. */
611	611	for (channel = 0; channel < avctx->channels; channel++) {
@@ -648,7 +648,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 36 unmodified lines
648	648	}
649	649	}
650	650	break;
651		− case CODEC_ID_ADPCM_IMA_WAV:
	651	+ case AV_CODEC_ID_ADPCM_IMA_WAV:
652	652	for(i=0; i<avctx->channels; i++){
653	653	cs = &(c->status[i]);
654	654	cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
@@ -676,7 +676,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 21 unmodified lines
676	676	samples += 7 * avctx->channels;
677	677	}
678	678	break;
679		− case CODEC_ID_ADPCM_4XM:
	679	+ case AV_CODEC_ID_ADPCM_4XM:
680	680	for (i = 0; i < avctx->channels; i++)
681	681	c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
682	682
@@ -701,7 +701,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 18 unmodified lines
701	701	}
702	702	}
703	703	break;
704		− case CODEC_ID_ADPCM_MS:
	704	+ case AV_CODEC_ID_ADPCM_MS:
705	705	{
706	706	int block_predictor;
707	707
@@ -744,7 +744,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 36 unmodified lines
744	744	}
745	745	break;
746	746	}
747		− case CODEC_ID_ADPCM_IMA_DK4:
	747	+ case AV_CODEC_ID_ADPCM_IMA_DK4:
748	748	for (channel = 0; channel < avctx->channels; channel++) {
749	749	cs = &c->status[channel];
750	750	cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
@@ -761,7 +761,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 10 unmodified lines
761	761	*samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
762	762	}
763	763	break;
764		− case CODEC_ID_ADPCM_IMA_DK3:
	764	+ case AV_CODEC_ID_ADPCM_IMA_DK3:
765	765	{
766	766	int last_byte = 0;
767	767	int nibble;
@@ -822,7 +822,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 54 unmodified lines
822	822	}
823	823	break;
824	824	}
825		− case CODEC_ID_ADPCM_IMA_ISS:
	825	+ case AV_CODEC_ID_ADPCM_IMA_ISS:
826	826	for (channel = 0; channel < avctx->channels; channel++) {
827	827	cs = &c->status[channel];
828	828	cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
@@ -849,14 +849,14 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 20 unmodified lines
849	849	*samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
850	850	}
851	851	break;
852		− case CODEC_ID_ADPCM_IMA_APC:
	852	+ case AV_CODEC_ID_ADPCM_IMA_APC:
853	853	while (bytestream2_get_bytes_left(&gb) > 0) {
854	854	int v = bytestream2_get_byteu(&gb);
855	855	*samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
856	856	*samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
857	857	}
858	858	break;
859		− case CODEC_ID_ADPCM_IMA_WS:
	859	+ case AV_CODEC_ID_ADPCM_IMA_WS:
860	860	if (c->vqa_version == 3) {
861	861	for (channel = 0; channel < avctx->channels; channel++) {
862	862	int16_t *smp = samples + channel;
@@ -881,7 +881,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 18 unmodified lines
881	881	}
882	882	bytestream2_seek(&gb, 0, SEEK_END);
883	883	break;
884		− case CODEC_ID_ADPCM_XA:
	884	+ case AV_CODEC_ID_ADPCM_XA:
885	885	while (bytestream2_get_bytes_left(&gb) >= 128) {
886	886	if ((ret = xa_decode(avctx, samples, buf + bytestream2_tell(&gb), &c->status[0],
887	887	&c->status[1], avctx->channels)) < 0)
@@ -890,7 +890,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 2 unmodified lines
890	890	samples += 28 * 8;
891	891	}
892	892	break;
893		− case CODEC_ID_ADPCM_IMA_EA_EACS:
	893	+ case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
894	894	for (i=0; i<=st; i++) {
895	895	c->status[i].step_index = bytestream2_get_le32u(&gb);
896	896	if (c->status[i].step_index > 88u) {
@@ -908,14 +908,14 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 11 unmodified lines
908	908	*samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
909	909	}
910	910	break;
911		− case CODEC_ID_ADPCM_IMA_EA_SEAD:
	911	+ case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
912	912	for (n = nb_samples >> (1 - st); n > 0; n--) {
913	913	int byte = bytestream2_get_byteu(&gb);
914	914	*samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6);
915	915	*samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
916	916	}
917	917	break;
918		− case CODEC_ID_ADPCM_EA:
	918	+ case AV_CODEC_ID_ADPCM_EA:
919	919	{
920	920	int previous_left_sample, previous_right_sample;
921	921	int current_left_sample, current_right_sample;
@@ -967,7 +967,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 45 unmodified lines
967	967
968	968	break;
969	969	}
970		− case CODEC_ID_ADPCM_EA_MAXIS_XA:
	970	+ case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
971	971	{
972	972	int coeff[2][2], shift[2];
973	973
@@ -997,14 +997,14 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 23 unmodified lines
997	997	bytestream2_seek(&gb, 0, SEEK_END);
998	998	break;
999	999	}
1000		− case CODEC_ID_ADPCM_EA_R1:
1001		− case CODEC_ID_ADPCM_EA_R2:
1002		− case CODEC_ID_ADPCM_EA_R3: {
	1000	+ case AV_CODEC_ID_ADPCM_EA_R1:
	1001	+ case AV_CODEC_ID_ADPCM_EA_R2:
	1002	+ case AV_CODEC_ID_ADPCM_EA_R3: {
1003	1003	/* channel numbering
1004	1004	2chan: 0=fl, 1=fr
1005	1005	4chan: 0=fl, 1=rl, 2=fr, 3=rr
1006	1006	6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */
1007		− const int big_endian = avctx->codec->id == CODEC_ID_ADPCM_EA_R3;
	1007	+ const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
1008	1008	int previous_sample, current_sample, next_sample;
1009	1009	int coeff1, coeff2;
1010	1010	int shift;
@@ -1022,7 +1022,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 11 unmodified lines
1022	1022	bytestream2_seek(&gb, offsets[channel], SEEK_SET);
1023	1023	samplesC = samples + channel;
1024	1024
1025		− if (avctx->codec->id == CODEC_ID_ADPCM_EA_R1) {
	1025	+ if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
1026	1026	current_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1027	1027	previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1028	1028	} else {
@@ -1071,7 +1071,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 42 unmodified lines
1071	1071	count = FFMAX(count, count1);
1072	1072	}
1073	1073
1074		− if (avctx->codec->id != CODEC_ID_ADPCM_EA_R1) {
	1074	+ if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
1075	1075	c->status[channel].predictor = current_sample;
1076	1076	c->status[channel].prev_sample = previous_sample;
1077	1077	}
@@ -1081,7 +1081,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 3 unmodified lines
1081	1081	bytestream2_seek(&gb, 0, SEEK_END);
1082	1082	break;
1083	1083	}
1084		− case CODEC_ID_ADPCM_EA_XAS:
	1084	+ case AV_CODEC_ID_ADPCM_EA_XAS:
1085	1085	for (channel=0; channel<avctx->channels; channel++) {
1086	1086	int coeff[2][4], shift[4];
1087	1087	short s2, s = &samples[channel];
@@ -1110,9 +1110,9 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 22 unmodified lines
1110	1110	}
1111	1111	}
1112	1112	break;
1113		− case CODEC_ID_ADPCM_IMA_AMV:
1114		− case CODEC_ID_ADPCM_IMA_SMJPEG:
1115		− if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV) {
	1113	+ case AV_CODEC_ID_ADPCM_IMA_AMV:
	1114	+ case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
	1115	+ if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
1116	1116	c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1117	1117	c->status[0].step_index = bytestream2_get_le16u(&gb);
1118	1118	bytestream2_skipu(&gb, 4);
@@ -1130,7 +1130,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 11 unmodified lines
1130	1130	for (n = nb_samples >> (1 - st); n > 0; n--) {
1131	1131	int hi, lo, v = bytestream2_get_byteu(&gb);
1132	1132
1133		− if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV) {
	1133	+ if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
1134	1134	hi = v & 0x0F;
1135	1135	lo = v >> 4;
1136	1136	} else {
@@ -1142,16 +1142,16 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 5 unmodified lines
1142	1142	*samples++ = adpcm_ima_expand_nibble(&c->status[0], hi, 3);
1143	1143	}
1144	1144	break;
1145		− case CODEC_ID_ADPCM_CT:
	1145	+ case AV_CODEC_ID_ADPCM_CT:
1146	1146	for (n = nb_samples >> (1 - st); n > 0; n--) {
1147	1147	int v = bytestream2_get_byteu(&gb);
1148	1148	*samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );
1149	1149	*samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1150	1150	}
1151	1151	break;
1152		− case CODEC_ID_ADPCM_SBPRO_4:
1153		− case CODEC_ID_ADPCM_SBPRO_3:
1154		− case CODEC_ID_ADPCM_SBPRO_2:
	1152	+ case AV_CODEC_ID_ADPCM_SBPRO_4:
	1153	+ case AV_CODEC_ID_ADPCM_SBPRO_3:
	1154	+ case AV_CODEC_ID_ADPCM_SBPRO_2:
1155	1155	if (!c->status[0].step_index) {
1156	1156	/* the first byte is a raw sample */
1157	1157	samples++ = 128 (bytestream2_get_byteu(&gb) - 0x80);
@@ -1160,7 +1160,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 2 unmodified lines
1160	1160	c->status[0].step_index = 1;
1161	1161	nb_samples--;
1162	1162	}
1163		− if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) {
	1163	+ if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
1164	1164	for (n = nb_samples >> (1 - st); n > 0; n--) {
1165	1165	int byte = bytestream2_get_byteu(&gb);
1166	1166	*samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
@@ -1168,7 +1168,7 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 1 unmodified line
1168	1168	*samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1169	1169	byte & 0x0F, 4, 0);
1170	1170	}
1171		− } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) {
	1171	+ } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
1172	1172	for (n = nb_samples / 3; n > 0; n--) {
1173	1173	int byte = bytestream2_get_byteu(&gb);
1174	1174	*samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
@@ -1192,18 +1192,18 @@ static int adpcm_decode_frame(AVCodecContext avctx, void data, · 17 unmodified lines
1192	1192	}
1193	1193	}
1194	1194	break;
1195		− case CODEC_ID_ADPCM_SWF:
	1195	+ case AV_CODEC_ID_ADPCM_SWF:
1196	1196	adpcm_swf_decode(avctx, buf, buf_size, samples);
1197	1197	bytestream2_seek(&gb, 0, SEEK_END);
1198	1198	break;
1199		− case CODEC_ID_ADPCM_YAMAHA:
	1199	+ case AV_CODEC_ID_ADPCM_YAMAHA:
1200	1200	for (n = nb_samples >> (1 - st); n > 0; n--) {
1201	1201	int v = bytestream2_get_byteu(&gb);
1202	1202	*samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
1203	1203	*samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 );
1204	1204	}
1205	1205	break;
1206		− case CODEC_ID_ADPCM_THP:
	1206	+ case AV_CODEC_ID_ADPCM_THP:
1207	1207	{
1208	1208	int table[2][16];
1209	1209	int prev[2][2];
@@ -1279,30 +1279,30 @@ AVCodec ff_ ## name_ ## _decoder = { \ · 69 unmodified lines
1279	1279	}
1280	1280
1281	1281	/* Note: Do not forget to add new entries to the Makefile as well. */
1282		−ADPCM_DECODER(CODEC_ID_ADPCM_4XM, adpcm_4xm, "ADPCM 4X Movie");
1283		−ADPCM_DECODER(CODEC_ID_ADPCM_CT, adpcm_ct, "ADPCM Creative Technology");
1284		−ADPCM_DECODER(CODEC_ID_ADPCM_EA, adpcm_ea, "ADPCM Electronic Arts");
1285		−ADPCM_DECODER(CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
1286		−ADPCM_DECODER(CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1, "ADPCM Electronic Arts R1");
1287		−ADPCM_DECODER(CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2, "ADPCM Electronic Arts R2");
1288		−ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "ADPCM Electronic Arts R3");
1289		−ADPCM_DECODER(CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
1290		−ADPCM_DECODER(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "ADPCM IMA AMV");
1291		−ADPCM_DECODER(CODEC_ID_ADPCM_IMA_APC, adpcm_ima_apc, "ADPCM IMA CRYO APC");
1292		−ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
1293		−ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
1294		−ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
1295		−ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
1296		−ADPCM_DECODER(CODEC_ID_ADPCM_IMA_ISS, adpcm_ima_iss, "ADPCM IMA Funcom ISS");
1297		−ADPCM_DECODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
1298		−ADPCM_DECODER(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");
1299		−ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
1300		−ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws, "ADPCM IMA Westwood");
1301		−ADPCM_DECODER(CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
1302		−ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");
1303		−ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");
1304		−ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");
1305		−ADPCM_DECODER(CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
1306		−ADPCM_DECODER(CODEC_ID_ADPCM_THP, adpcm_thp, "ADPCM Nintendo Gamecube THP");
1307		−ADPCM_DECODER(CODEC_ID_ADPCM_XA, adpcm_xa, "ADPCM CDROM XA");
1308		−ADPCM_DECODER(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");
	1282	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM, adpcm_4xm, "ADPCM 4X Movie");
	1283	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT, adpcm_ct, "ADPCM Creative Technology");
	1284	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA, adpcm_ea, "ADPCM Electronic Arts");
	1285	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
	1286	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1, "ADPCM Electronic Arts R1");
	1287	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2, "ADPCM Electronic Arts R2");
	1288	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "ADPCM Electronic Arts R3");
	1289	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
	1290	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "ADPCM IMA AMV");
	1291	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APC, adpcm_ima_apc, "ADPCM IMA CRYO APC");
	1292	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
	1293	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
	1294	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
	1295	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
	1296	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ISS, adpcm_ima_iss, "ADPCM IMA Funcom ISS");
	1297	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
	1298	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");
	1299	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
	1300	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws, "ADPCM IMA Westwood");
	1301	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
	1302	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");
	1303	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");
	1304	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");
	1305	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
	1306	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP, adpcm_thp, "ADPCM Nintendo Gamecube THP");
	1307	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA, adpcm_xa, "ADPCM CDROM XA");
	1308	+ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");

libavcodec/adpcmenc.c+26−26

@@ -92,7 +92,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) · 91 unmodified lines
92	92	avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
93	93
94	94	switch (avctx->codec->id) {
95		− case CODEC_ID_ADPCM_IMA_WAV:
	95	+ case AV_CODEC_ID_ADPCM_IMA_WAV:
96	96	/* each 16 bits sample gives one nibble
97	97	and we have 4 bytes per channel overhead */
98	98	avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 /
@@ -101,11 +101,11 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) · 2 unmodified lines
101	101	have to buffer the samples :-( */
102	102	avctx->block_align = BLKSIZE;
103	103	break;
104		− case CODEC_ID_ADPCM_IMA_QT:
	104	+ case AV_CODEC_ID_ADPCM_IMA_QT:
105	105	avctx->frame_size = 64;
106	106	avctx->block_align = 34 * avctx->channels;
107	107	break;
108		− case CODEC_ID_ADPCM_MS:
	108	+ case AV_CODEC_ID_ADPCM_MS:
109	109	/* each 16 bits sample gives one nibble
110	110	and we have 7 bytes per channel overhead */
111	111	avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 /
@@ -122,11 +122,11 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) · 10 unmodified lines
122	122	bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff2[i] * 4);
123	123	}
124	124	break;
125		− case CODEC_ID_ADPCM_YAMAHA:
	125	+ case AV_CODEC_ID_ADPCM_YAMAHA:
126	126	avctx->frame_size = BLKSIZE * 2 / avctx->channels;
127	127	avctx->block_align = BLKSIZE;
128	128	break;
129		− case CODEC_ID_ADPCM_SWF:
	129	+ case AV_CODEC_ID_ADPCM_SWF:
130	130	if (avctx->sample_rate != 11025 &&
131	131	avctx->sample_rate != 22050 &&
132	132	avctx->sample_rate != 44100) {
@@ -294,13 +294,13 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, · 161 unmodified lines
294	294	nodes[0]->step = c->step_index;
295	295	nodes[0]->sample1 = c->sample1;
296	296	nodes[0]->sample2 = c->sample2;
297		− if (version == CODEC_ID_ADPCM_IMA_WAV \|\|
298		− version == CODEC_ID_ADPCM_IMA_QT \|\|
299		− version == CODEC_ID_ADPCM_SWF)
	297	+ if (version == AV_CODEC_ID_ADPCM_IMA_WAV \|\|
	298	+ version == AV_CODEC_ID_ADPCM_IMA_QT \|\|
	299	+ version == AV_CODEC_ID_ADPCM_SWF)
300	300	nodes[0]->sample1 = c->prev_sample;
301		− if (version == CODEC_ID_ADPCM_MS)
	301	+ if (version == AV_CODEC_ID_ADPCM_MS)
302	302	nodes[0]->step = c->idelta;
303		− if (version == CODEC_ID_ADPCM_YAMAHA) {
	303	+ if (version == AV_CODEC_ID_ADPCM_YAMAHA) {
304	304	if (c->step == 0) {
305	305	nodes[0]->step = 127;
306	306	nodes[0]->sample1 = 0;
@@ -322,7 +322,7 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, · 15 unmodified lines
322	322	const int range = (j < frontier / 2) ? 1 : 0;
323	323	const int step = nodes[j]->step;
324	324	int nidx;
325		− if (version == CODEC_ID_ADPCM_MS) {
	325	+ if (version == AV_CODEC_ID_ADPCM_MS) {
326	326	const int predictor = ((nodes[j]->sample1 * c->coeff1) +
327	327	(nodes[j]->sample2 * c->coeff2)) / 64;
328	328	const int div = (sample - predictor) / step;
@@ -398,9 +398,9 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, · 69 unmodified lines
398	398	STORE_NODE(ms, FFMAX(16,
399	399	(ff_adpcm_AdaptationTable[nibble] * step) >> 8));
400	400	}
401		− } else if (version == CODEC_ID_ADPCM_IMA_WAV \|\|
402		− version == CODEC_ID_ADPCM_IMA_QT \|\|
403		− version == CODEC_ID_ADPCM_SWF) {
	401	+ } else if (version == AV_CODEC_ID_ADPCM_IMA_WAV \|\|
	402	+ version == AV_CODEC_ID_ADPCM_IMA_QT \|\|
	403	+ version == AV_CODEC_ID_ADPCM_SWF) {
404	404	#define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\
405	405	const int predictor = nodes[j]->sample1;\
406	406	const int div = (sample - predictor) * 4 / STEP_TABLE;\
@@ -419,7 +419,7 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, · 12 unmodified lines
419	419	}
420	420	LOOP_NODES(ima, ff_adpcm_step_table[step],
421	421	av_clip(step + ff_adpcm_index_table[nibble], 0, 88));
422		− } else { //CODEC_ID_ADPCM_YAMAHA
	422	+ } else { //AV_CODEC_ID_ADPCM_YAMAHA
423	423	LOOP_NODES(yamaha, step,
424	424	av_clip((step * ff_adpcm_yamaha_indexscale[nibble]) >> 8,
425	425	127, 24567));
@@ -487,7 +487,7 @@ static int adpcm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 61 unmodified lines
487	487	samples = (const int16_t *)frame->data[0];
488	488	st = avctx->channels == 2;
489	489
490		− if (avctx->codec_id == CODEC_ID_ADPCM_SWF)
	490	+ if (avctx->codec_id == AV_CODEC_ID_ADPCM_SWF)
491	491	pkt_size = (2 + avctx->channels * (22 + 4 * (frame->nb_samples - 1)) + 7) / 8;
492	492	else
493	493	pkt_size = avctx->block_align;
@@ -498,7 +498,7 @@ static int adpcm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 4 unmodified lines
498	498	dst = avpkt->data;
499	499
500	500	switch(avctx->codec->id) {
501		− case CODEC_ID_ADPCM_IMA_WAV:
	501	+ case AV_CODEC_ID_ADPCM_IMA_WAV:
502	502	n = frame->nb_samples / 8;
503	503	c->status[0].prev_sample = samples[0];
504	504	/* c->status[0].step_index = 0;
@@ -563,7 +563,7 @@ static int adpcm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 58 unmodified lines
563	563	}
564	564	}
565	565	break;
566		− case CODEC_ID_ADPCM_IMA_QT:
	566	+ case AV_CODEC_ID_ADPCM_IMA_QT:
567	567	{
568	568	int ch, i;
569	569	PutBitContext pb;
@@ -593,7 +593,7 @@ static int adpcm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 23 unmodified lines
593	593	flush_put_bits(&pb);
594	594	break;
595	595	}
596		− case CODEC_ID_ADPCM_SWF:
	596	+ case AV_CODEC_ID_ADPCM_SWF:
597	597	{
598	598	int i;
599	599	PutBitContext pb;
@@ -637,7 +637,7 @@ static int adpcm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 37 unmodified lines
637	637	flush_put_bits(&pb);
638	638	break;
639	639	}
640		− case CODEC_ID_ADPCM_MS:
	640	+ case AV_CODEC_ID_ADPCM_MS:
641	641	for (i = 0; i < avctx->channels; i++) {
642	642	int predictor = 0;
643	643	*dst++ = predictor;
@@ -681,7 +681,7 @@ static int adpcm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 37 unmodified lines
681	681	}
682	682	}
683	683	break;
684		− case CODEC_ID_ADPCM_YAMAHA:
	684	+ case AV_CODEC_ID_ADPCM_YAMAHA:
685	685	n = frame->nb_samples / 2;
686	686	if (avctx->trellis > 0) {
687	687	FF_ALLOC_OR_GOTO(avctx, buf, 2 * n * 2, error);
@@ -733,8 +733,8 @@ AVCodec ff_ ## name_ ## _encoder = { \ · 45 unmodified lines
733	733	.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
734	734	}
735	735
736		−ADPCM_ENCODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
737		−ADPCM_ENCODER(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
738		−ADPCM_ENCODER(CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
739		−ADPCM_ENCODER(CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
740		−ADPCM_ENCODER(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");
	736	+ADPCM_ENCODER(AV_CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
	737	+ADPCM_ENCODER(AV_CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
	738	+ADPCM_ENCODER(AV_CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
	739	+ADPCM_ENCODER(AV_CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
	740	+ADPCM_ENCODER(AV_CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");

libavcodec/adx_parser.c+1−1

@@ -89,7 +89,7 @@ static int adx_parse(AVCodecParserContext *s1, · 88 unmodified lines
89	89	}
90	90
91	91	AVCodecParser ff_adx_parser = {
92		− .codec_ids = { CODEC_ID_ADPCM_ADX },
	92	+ .codec_ids = { AV_CODEC_ID_ADPCM_ADX },
93	93	.priv_data_size = sizeof(ADXParseContext),
94	94	.parser_parse = adx_parse,
95	95	.parser_close = ff_parse_close,

libavcodec/adxdec.c+1−1

@@ -175,7 +175,7 @@ static void adx_decode_flush(AVCodecContext *avctx) · 174 unmodified lines
175	175	AVCodec ff_adpcm_adx_decoder = {
176	176	.name = "adpcm_adx",
177	177	.type = AVMEDIA_TYPE_AUDIO,
178		− .id = CODEC_ID_ADPCM_ADX,
	178	+ .id = AV_CODEC_ID_ADPCM_ADX,
179	179	.priv_data_size = sizeof(ADXContext),
180	180	.init = adx_decode_init,
181	181	.decode = adx_decode_frame,

libavcodec/adxenc.c+1−1

@@ -166,7 +166,7 @@ static int adx_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 165 unmodified lines
166	166	AVCodec ff_adpcm_adx_encoder = {
167	167	.name = "adpcm_adx",
168	168	.type = AVMEDIA_TYPE_AUDIO,
169		− .id = CODEC_ID_ADPCM_ADX,
	169	+ .id = AV_CODEC_ID_ADPCM_ADX,
170	170	.priv_data_size = sizeof(ADXContext),
171	171	.init = adx_encode_init,
172	172	.encode2 = adx_encode_frame,

libavcodec/alac.c+1−1

@@ -605,7 +605,7 @@ static av_cold int alac_decode_init(AVCodecContext * avctx) · 604 unmodified lines
605	605	AVCodec ff_alac_decoder = {
606	606	.name = "alac",
607	607	.type = AVMEDIA_TYPE_AUDIO,
608		− .id = CODEC_ID_ALAC,
	608	+ .id = AV_CODEC_ID_ALAC,
609	609	.priv_data_size = sizeof(ALACContext),
610	610	.init = alac_decode_init,
611	611	.close = alac_decode_close,

libavcodec/alacenc.c+1−1

@@ -576,7 +576,7 @@ static int alac_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 575 unmodified lines
576	576	AVCodec ff_alac_encoder = {
577	577	.name = "alac",
578	578	.type = AVMEDIA_TYPE_AUDIO,
579		− .id = CODEC_ID_ALAC,
	579	+ .id = AV_CODEC_ID_ALAC,
580	580	.priv_data_size = sizeof(AlacEncodeContext),
581	581	.init = alac_encode_init,
582	582	.encode2 = alac_encode_frame,

libavcodec/alsdec.c+1−1

@@ -1740,7 +1740,7 @@ static av_cold void flush(AVCodecContext *avctx) · 1739 unmodified lines
1740	1740	AVCodec ff_als_decoder = {
1741	1741	.name = "als",
1742	1742	.type = AVMEDIA_TYPE_AUDIO,
1743		− .id = CODEC_ID_MP4ALS,
	1743	+ .id = AV_CODEC_ID_MP4ALS,
1744	1744	.priv_data_size = sizeof(ALSDecContext),
1745	1745	.init = decode_init,
1746	1746	.close = decode_end,

libavcodec/amrnbdec.c+1−1

@@ -1057,7 +1057,7 @@ static int amrnb_decode_frame(AVCodecContext avctx, void data, · 1056 unmodified lines
1057	1057	AVCodec ff_amrnb_decoder = {
1058	1058	.name = "amrnb",
1059	1059	.type = AVMEDIA_TYPE_AUDIO,
1060		− .id = CODEC_ID_AMR_NB,
	1060	+ .id = AV_CODEC_ID_AMR_NB,
1061	1061	.priv_data_size = sizeof(AMRContext),
1062	1062	.init = amrnb_decode_init,
1063	1063	.decode = amrnb_decode_frame,

libavcodec/amrwbdec.c+1−1

@@ -1237,7 +1237,7 @@ static int amrwb_decode_frame(AVCodecContext avctx, void data, · 1236 unmodified lines
1237	1237	AVCodec ff_amrwb_decoder = {
1238	1238	.name = "amrwb",
1239	1239	.type = AVMEDIA_TYPE_AUDIO,
1240		− .id = CODEC_ID_AMR_WB,
	1240	+ .id = AV_CODEC_ID_AMR_WB,
1241	1241	.priv_data_size = sizeof(AMRWBContext),
1242	1242	.init = amrwb_decode_init,
1243	1243	.decode = amrwb_decode_frame,

libavcodec/anm.c+1−1

@@ -186,7 +186,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 185 unmodified lines
186	186	AVCodec ff_anm_decoder = {
187	187	.name = "anm",
188	188	.type = AVMEDIA_TYPE_VIDEO,
189		− .id = CODEC_ID_ANM,
	189	+ .id = AV_CODEC_ID_ANM,
190	190	.priv_data_size = sizeof(AnmContext),
191	191	.init = decode_init,
192	192	.close = decode_end,

libavcodec/ansi.c+1−1

@@ -425,7 +425,7 @@ static av_cold int decode_close(AVCodecContext *avctx) · 424 unmodified lines
425	425	AVCodec ff_ansi_decoder = {
426	426	.name = "ansi",
427	427	.type = AVMEDIA_TYPE_VIDEO,
428		− .id = CODEC_ID_ANSI,
	428	+ .id = AV_CODEC_ID_ANSI,
429	429	.priv_data_size = sizeof(AnsiContext),
430	430	.init = decode_init,
431	431	.close = decode_close,

libavcodec/apedec.c+1−1

@@ -987,7 +987,7 @@ static const AVClass ape_decoder_class = { · 986 unmodified lines
987	987	AVCodec ff_ape_decoder = {
988	988	.name = "ape",
989	989	.type = AVMEDIA_TYPE_AUDIO,
990		− .id = CODEC_ID_APE,
	990	+ .id = AV_CODEC_ID_APE,
991	991	.priv_data_size = sizeof(APEContext),
992	992	.init = ape_decode_init,
993	993	.close = ape_decode_close,

libavcodec/api-example.c+4−4

@@ -60,7 +60,7 @@ static void audio_encode_example(const char *filename) · 59 unmodified lines
60	60	printf("Audio encoding\n");
61	61
62	62	/* find the MP2 encoder */
63		− codec = avcodec_find_encoder(CODEC_ID_MP2);
	63	+ codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
64	64	if (!codec) {
65	65	fprintf(stderr, "codec not found\n");
66	66	exit(1);
@@ -130,7 +130,7 @@ static void audio_decode_example(const char outfilename, const char filename) · 63 unmodified lines
130	130	printf("Audio decoding\n");
131	131
132	132	/* find the mpeg audio decoder */
133		− codec = avcodec_find_decoder(CODEC_ID_MP2);
	133	+ codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
134	134	if (!codec) {
135	135	fprintf(stderr, "codec not found\n");
136	136	exit(1);
@@ -221,7 +221,7 @@ static void video_encode_example(const char *filename) · 84 unmodified lines
221	221	printf("Video encoding\n");
222	222
223	223	/* find the mpeg1 video encoder */
224		− codec = avcodec_find_encoder(CODEC_ID_MPEG1VIDEO);
	224	+ codec = avcodec_find_encoder(AV_CODEC_ID_MPEG1VIDEO);
225	225	if (!codec) {
226	226	fprintf(stderr, "codec not found\n");
227	227	exit(1);
@@ -352,7 +352,7 @@ static void video_decode_example(const char outfilename, const char filename) · 124 unmodified lines
352	352	printf("Video decoding\n");
353	353
354	354	/* find the mpeg1 video decoder */
355		− codec = avcodec_find_decoder(CODEC_ID_MPEG1VIDEO);
	355	+ codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
356	356	if (!codec) {
357	357	fprintf(stderr, "codec not found\n");
358	358	exit(1);

libavcodec/arm/h264pred_init_arm.c+3−3

@@ -52,10 +52,10 @@ static void ff_h264_pred_init_neon(H264PredContext *h, int codec_id, const int b · 51 unmodified lines
52	52
53	53	h->pred8x8[VERT_PRED8x8 ] = ff_pred8x8_vert_neon;
54	54	h->pred8x8[HOR_PRED8x8 ] = ff_pred8x8_hor_neon;
55		− if (codec_id != CODEC_ID_VP8)
	55	+ if (codec_id != AV_CODEC_ID_VP8)
56	56	h->pred8x8[PLANE_PRED8x8] = ff_pred8x8_plane_neon;
57	57	h->pred8x8[DC_128_PRED8x8 ] = ff_pred8x8_128_dc_neon;
58		− if (codec_id != CODEC_ID_RV40 && codec_id != CODEC_ID_VP8) {
	58	+ if (codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP8) {
59	59	h->pred8x8[DC_PRED8x8 ] = ff_pred8x8_dc_neon;
60	60	h->pred8x8[LEFT_DC_PRED8x8] = ff_pred8x8_left_dc_neon;
61	61	h->pred8x8[TOP_DC_PRED8x8 ] = ff_pred8x8_top_dc_neon;
@@ -71,7 +71,7 @@ static void ff_h264_pred_init_neon(H264PredContext *h, int codec_id, const int b · 9 unmodified lines
71	71	h->pred16x16[LEFT_DC_PRED8x8] = ff_pred16x16_left_dc_neon;
72	72	h->pred16x16[TOP_DC_PRED8x8 ] = ff_pred16x16_top_dc_neon;
73	73	h->pred16x16[DC_128_PRED8x8 ] = ff_pred16x16_128_dc_neon;
74		− if (codec_id != CODEC_ID_SVQ3 && codec_id != CODEC_ID_RV40 && codec_id != CODEC_ID_VP8)
	74	+ if (codec_id != AV_CODEC_ID_SVQ3 && codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP8)
75	75	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_plane_neon;
76	76	}
77	77

libavcodec/arm/vp56dsp_init_arm.c+2−2

@@ -27,11 +27,11 @@ · 26 unmodified lines
27	27	void ff_vp6_edge_filter_hor_neon(uint8_t *yuv, int stride, int t);
28	28	void ff_vp6_edge_filter_ver_neon(uint8_t *yuv, int stride, int t);
29	29
30		−void ff_vp56dsp_init_arm(VP56DSPContext *s, enum CodecID codec)
	30	+void ff_vp56dsp_init_arm(VP56DSPContext *s, enum AVCodecID codec)
31	31	{
32	32	int cpu_flags = av_get_cpu_flags();
33	33
34		− if (codec != CODEC_ID_VP5 && have_neon(cpu_flags)) {
	34	+ if (codec != AV_CODEC_ID_VP5 && have_neon(cpu_flags)) {
35	35	s->edge_filter_hor = ff_vp6_edge_filter_hor_neon;
36	36	s->edge_filter_ver = ff_vp6_edge_filter_ver_neon;
37	37	}

libavcodec/assdec.c+1−1

@@ -56,7 +56,7 @@ AVCodec ff_ass_decoder = { · 55 unmodified lines
56	56	.name = "ass",
57	57	.long_name = NULL_IF_CONFIG_SMALL("SSA (SubStation Alpha) subtitle"),
58	58	.type = AVMEDIA_TYPE_SUBTITLE,
59		− .id = CODEC_ID_SSA,
	59	+ .id = AV_CODEC_ID_SSA,
60	60	.init = ass_decode_init,
61	61	.decode = ass_decode_frame,
62	62	};

libavcodec/assenc.c+1−1

@@ -61,7 +61,7 @@ AVCodec ff_ass_encoder = { · 60 unmodified lines
61	61	.name = "ass",
62	62	.long_name = NULL_IF_CONFIG_SMALL("SSA (SubStation Alpha) subtitle"),
63	63	.type = AVMEDIA_TYPE_SUBTITLE,
64		− .id = CODEC_ID_SSA,
	64	+ .id = AV_CODEC_ID_SSA,
65	65	.init = ass_encode_init,
66	66	.encode = ass_encode_frame,
67	67	};

libavcodec/asv1.c+11−11

@@ -311,7 +311,7 @@ static inline int decode_mb(ASV1Context *a, DCTELEM block[6][64]){ · 310 unmodified lines
311	311
312	312	a->dsp.clear_blocks(block[0]);
313	313
314		− if(a->avctx->codec_id == CODEC_ID_ASV1){
	314	+ if(a->avctx->codec_id == AV_CODEC_ID_ASV1){
315	315	for(i=0; i<6; i++){
316	316	if( asv1_decode_block(a, block[i]) < 0)
317	317	return -1;
@@ -335,7 +335,7 @@ static inline int encode_mb(ASV1Context *a, DCTELEM block[6][64]){ · 17 unmodified lines
335	335	return -1;
336	336	}
337	337
338		− if(a->avctx->codec_id == CODEC_ID_ASV1){
	338	+ if(a->avctx->codec_id == AV_CODEC_ID_ASV1){
339	339	for(i=0; i<6; i++)
340	340	asv1_encode_block(a, block[i]);
341	341	}else{
@@ -415,7 +415,7 @@ static int decode_frame(AVCodecContext *avctx, · 73 unmodified lines
415	415	if (!a->bitstream_buffer)
416	416	return AVERROR(ENOMEM);
417	417
418		− if(avctx->codec_id == CODEC_ID_ASV1)
	418	+ if(avctx->codec_id == AV_CODEC_ID_ASV1)
419	419	a->dsp.bswap_buf((uint32_t)a->bitstream_buffer, (const uint32_t)buf, buf_size/4);
420	420	else{
421	421	int i;
@@ -514,7 +514,7 @@ static int encode_frame(AVCodecContext avctx, AVPacket pkt, · 92 unmodified lines
514	514
515	515	size= put_bits_count(&a->pb)/32;
516	516
517		− if(avctx->codec_id == CODEC_ID_ASV1)
	517	+ if(avctx->codec_id == AV_CODEC_ID_ASV1)
518	518	a->dsp.bswap_buf((uint32_t)pkt->data, (uint32_t)pkt->data, size);
519	519	else{
520	520	int i;
@@ -548,7 +548,7 @@ static av_cold int decode_init(AVCodecContext *avctx){ · 27 unmodified lines
548	548	ASV1Context * const a = avctx->priv_data;
549	549	AVFrame *p= &a->picture;
550	550	int i;
551		− const int scale= avctx->codec_id == CODEC_ID_ASV1 ? 1 : 2;
	551	+ const int scale= avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
552	552
553	553	common_init(avctx);
554	554	init_vlcs(a);
@@ -558,7 +558,7 @@ static av_cold int decode_init(AVCodecContext *avctx){ · 3 unmodified lines
558	558	a->inv_qscale= avctx->extradata[0];
559	559	if(a->inv_qscale == 0){
560	560	av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
561		− if(avctx->codec_id == CODEC_ID_ASV1)
	561	+ if(avctx->codec_id == AV_CODEC_ID_ASV1)
562	562	a->inv_qscale= 6;
563	563	else
564	564	a->inv_qscale= 10;
@@ -582,7 +582,7 @@ static av_cold int decode_init(AVCodecContext *avctx){ · 17 unmodified lines
582	582	static av_cold int encode_init(AVCodecContext *avctx){
583	583	ASV1Context * const a = avctx->priv_data;
584	584	int i;
585		− const int scale= avctx->codec_id == CODEC_ID_ASV1 ? 1 : 2;
	585	+ const int scale= avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
586	586
587	587	common_init(avctx);
588	588
@@ -620,7 +620,7 @@ static av_cold int decode_end(AVCodecContext *avctx){ · 31 unmodified lines
620	620	AVCodec ff_asv1_decoder = {
621	621	.name = "asv1",
622	622	.type = AVMEDIA_TYPE_VIDEO,
623		− .id = CODEC_ID_ASV1,
	623	+ .id = AV_CODEC_ID_ASV1,
624	624	.priv_data_size = sizeof(ASV1Context),
625	625	.init = decode_init,
626	626	.close = decode_end,
@@ -632,7 +632,7 @@ AVCodec ff_asv1_decoder = { · 5 unmodified lines
632	632	AVCodec ff_asv2_decoder = {
633	633	.name = "asv2",
634	634	.type = AVMEDIA_TYPE_VIDEO,
635		− .id = CODEC_ID_ASV2,
	635	+ .id = AV_CODEC_ID_ASV2,
636	636	.priv_data_size = sizeof(ASV1Context),
637	637	.init = decode_init,
638	638	.close = decode_end,
@@ -645,7 +645,7 @@ AVCodec ff_asv2_decoder = { · 6 unmodified lines
645	645	AVCodec ff_asv1_encoder = {
646	646	.name = "asv1",
647	647	.type = AVMEDIA_TYPE_VIDEO,
648		− .id = CODEC_ID_ASV1,
	648	+ .id = AV_CODEC_ID_ASV1,
649	649	.priv_data_size = sizeof(ASV1Context),
650	650	.init = encode_init,
651	651	.encode2 = encode_frame,
@@ -658,7 +658,7 @@ AVCodec ff_asv1_encoder = { · 6 unmodified lines
658	658	AVCodec ff_asv2_encoder = {
659	659	.name = "asv2",
660	660	.type = AVMEDIA_TYPE_VIDEO,
661		− .id = CODEC_ID_ASV2,
	661	+ .id = AV_CODEC_ID_ASV2,
662	662	.priv_data_size = sizeof(ASV1Context),
663	663	.init = encode_init,
664	664	.encode2 = encode_frame,

libavcodec/atrac1.c+1−1

@@ -403,7 +403,7 @@ static av_cold int atrac1_decode_init(AVCodecContext *avctx) · 402 unmodified lines
403	403	AVCodec ff_atrac1_decoder = {
404	404	.name = "atrac1",
405	405	.type = AVMEDIA_TYPE_AUDIO,
406		− .id = CODEC_ID_ATRAC1,
	406	+ .id = AV_CODEC_ID_ATRAC1,
407	407	.priv_data_size = sizeof(AT1Ctx),
408	408	.init = atrac1_decode_init,
409	409	.close = atrac1_decode_end,

libavcodec/atrac3.c+1−1

@@ -1068,7 +1068,7 @@ AVCodec ff_atrac3_decoder = · 1067 unmodified lines
1068	1068	{
1069	1069	.name = "atrac3",
1070	1070	.type = AVMEDIA_TYPE_AUDIO,
1071		− .id = CODEC_ID_ATRAC3,
	1071	+ .id = AV_CODEC_ID_ATRAC3,
1072	1072	.priv_data_size = sizeof(ATRAC3Context),
1073	1073	.init = atrac3_decode_init,
1074	1074	.close = atrac3_decode_close,

libavcodec/aura.c+1−1

@@ -125,7 +125,7 @@ static av_cold int aura_decode_end(AVCodecContext *avctx) · 124 unmodified lines
125	125	AVCodec ff_aura2_decoder = {
126	126	.name = "aura2",
127	127	.type = AVMEDIA_TYPE_VIDEO,
128		− .id = CODEC_ID_AURA2,
	128	+ .id = AV_CODEC_ID_AURA2,
129	129	.priv_data_size = sizeof(AuraDecodeContext),
130	130	.init = aura_decode_init,
131	131	.close = aura_decode_end,

libavcodec/avcodec.h+11−11

@@ -1265,7 +1265,7 @@ typedef struct AVCodecContext { · 1264 unmodified lines
1265	1265	enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */
1266	1266	struct AVCodec *codec;
1267	1267	char codec_name[32];
1268		− enum CodecID codec_id; /* see AV_CODEC_ID_xxx */
	1268	+ enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */
1269	1269
1270	1270	/**
1271	1271	* fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
@@ -2869,7 +2869,7 @@ typedef struct AVCodec { · 1597 unmodified lines
2869	2869	*/
2870	2870	const char *long_name;
2871	2871	enum AVMediaType type;
2872		− enum CodecID id;
	2872	+ enum AVCodecID id;
2873	2873	/**
2874	2874	* Codec capabilities.
2875	2875	* see CODEC_CAP_*
@@ -2967,9 +2967,9 @@ typedef struct AVHWAccel { · 91 unmodified lines
2967	2967	/**
2968	2968	* Codec implemented by the hardware accelerator.
2969	2969	*
2970		− * See CODEC_ID_xxx
	2970	+ * See AV_CODEC_ID_xxx
2971	2971	*/
2972		− enum CodecID id;
	2972	+ enum AVCodecID id;
2973	2973
2974	2974	/**
2975	2975	* Supported pixel format.
@@ -3388,10 +3388,10 @@ uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, · 412 unmodified lines
3388	3388	/**
3389	3389	* Find a registered decoder with a matching codec ID.
3390	3390	*
3391		− * @param id CodecID of the requested decoder
	3391	+ * @param id AVCodecID of the requested decoder
3392	3392	* @return A decoder if one was found, NULL otherwise.
3393	3393	*/
3394		−AVCodec *avcodec_find_decoder(enum CodecID id);
	3394	+AVCodec *avcodec_find_decoder(enum AVCodecID id);
3395	3395
3396	3396	/**
3397	3397	* Find a registered decoder with the specified name.
@@ -3810,10 +3810,10 @@ void av_parser_close(AVCodecParserContext *s); · 412 unmodified lines
3810	3810	/**
3811	3811	* Find a registered encoder with a matching codec ID.
3812	3812	*
3813		− * @param id CodecID of the requested encoder
	3813	+ * @param id AVCodecID of the requested encoder
3814	3814	* @return An encoder if one was found, NULL otherwise.
3815	3815	*/
3816		−AVCodec *avcodec_find_encoder(enum CodecID id);
	3816	+AVCodec *avcodec_find_encoder(enum AVCodecID id);
3817	3817
3818	3818	/**
3819	3819	* Find a registered encoder with the specified name.
@@ -4323,7 +4323,7 @@ void avcodec_default_free_buffers(AVCodecContext *s); · 503 unmodified lines
4323	4323	* @param[in] codec_id the codec
4324	4324	* @return Number of bits per sample or zero if unknown for the given codec.
4325	4325	*/
4326		−int av_get_bits_per_sample(enum CodecID codec_id);
	4326	+int av_get_bits_per_sample(enum AVCodecID codec_id);
4327	4327
4328	4328	/**
4329	4329	* Return codec bits per sample.
@@ -4333,7 +4333,7 @@ int av_get_bits_per_sample(enum CodecID codec_id); · 3 unmodified lines
4333	4333	* @param[in] codec_id the codec
4334	4334	* @return Number of bits per sample or zero if unknown for the given codec.
4335	4335	*/
4336		−int av_get_exact_bits_per_sample(enum CodecID codec_id);
	4336	+int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
4337	4337
4338	4338	/**
4339	4339	* Return audio frame duration.
@@ -4481,7 +4481,7 @@ int av_lockmgr_register(int (cb)(void *mutex, enum AVLockOp op)); · 141 unmodified lines
4481	4481	/**
4482	4482	* Get the type of the given codec.
4483	4483	*/
4484		−enum AVMediaType avcodec_get_type(enum CodecID codec_id);
	4484	+enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
4485	4485
4486	4486	/**
4487	4487	* @return a positive value if s is open (i.e. avcodec_open2() was called on it

libavcodec/avs.c+1−1

@@ -173,7 +173,7 @@ static av_cold int avs_decode_end(AVCodecContext *avctx) · 172 unmodified lines
173	173	AVCodec ff_avs_decoder = {
174	174	.name = "avs",
175	175	.type = AVMEDIA_TYPE_VIDEO,
176		− .id = CODEC_ID_AVS,
	176	+ .id = AV_CODEC_ID_AVS,
177	177	.priv_data_size = sizeof(AvsContext),
178	178	.init = avs_decode_init,
179	179	.decode = avs_decode_frame,

libavcodec/bethsoftvideo.c+1−1

@@ -153,7 +153,7 @@ static av_cold int bethsoftvid_decode_end(AVCodecContext *avctx) · 152 unmodified lines
153	153	AVCodec ff_bethsoftvid_decoder = {
154	154	.name = "bethsoftvid",
155	155	.type = AVMEDIA_TYPE_VIDEO,
156		− .id = CODEC_ID_BETHSOFTVID,
	156	+ .id = AV_CODEC_ID_BETHSOFTVID,
157	157	.priv_data_size = sizeof(BethsoftvidContext),
158	158	.init = bethsoftvid_decode_init,
159	159	.close = bethsoftvid_decode_end,

libavcodec/bfi.c+1−1

@@ -180,7 +180,7 @@ static av_cold int bfi_decode_close(AVCodecContext *avctx) · 179 unmodified lines
180	180	AVCodec ff_bfi_decoder = {
181	181	.name = "bfi",
182	182	.type = AVMEDIA_TYPE_VIDEO,
183		− .id = CODEC_ID_BFI,
	183	+ .id = AV_CODEC_ID_BFI,
184	184	.priv_data_size = sizeof(BFIContext),
185	185	.init = bfi_decode_init,
186	186	.close = bfi_decode_close,

libavcodec/bink.c+1−1

@@ -1330,7 +1330,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 1329 unmodified lines
1330	1330	AVCodec ff_bink_decoder = {
1331	1331	.name = "binkvideo",
1332	1332	.type = AVMEDIA_TYPE_VIDEO,
1333		− .id = CODEC_ID_BINKVIDEO,
	1333	+ .id = AV_CODEC_ID_BINKVIDEO,
1334	1334	.priv_data_size = sizeof(BinkContext),
1335	1335	.init = decode_init,
1336	1336	.close = decode_end,

libavcodec/binkaudio.c+6−6

@@ -98,7 +98,7 @@ static av_cold int decode_init(AVCodecContext *avctx) · 97 unmodified lines
98	98
99	99	s->version_b = avctx->extradata && avctx->extradata[3] == 'b';
100	100
101		− if (avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT) {
	101	+ if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT) {
102	102	// audio is already interleaved for the RDFT format variant
103	103	sample_rate *= avctx->channels;
104	104	s->channels = 1;
@@ -141,7 +141,7 @@ static av_cold int decode_init(AVCodecContext *avctx) · 36 unmodified lines
141	141	s->prev_ptr[i] = s->coeffs_ptr[i] + s->frame_len - s->overlap_len;
142	142	}
143	143
144		− if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT)
	144	+ if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
145	145	ff_rdft_init(&s->trans.rdft, frame_len_bits, DFT_C2R);
146	146	else if (CONFIG_BINKAUDIO_DCT_DECODER)
147	147	ff_dct_init(&s->trans.dct, frame_len_bits, DCT_III);
@@ -293,7 +293,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 145 unmodified lines
293	293	BinkAudioContext * s = avctx->priv_data;
294	294	av_freep(&s->bands);
295	295	av_freep(&s->packet_buffer);
296		− if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT)
	296	+ if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
297	297	ff_rdft_end(&s->trans.rdft);
298	298	else if (CONFIG_BINKAUDIO_DCT_DECODER)
299	299	ff_dct_end(&s->trans.dct);
@@ -346,7 +346,7 @@ static int decode_frame(AVCodecContext avctx, void data, · 46 unmodified lines
346	346	}
347	347	samples = (int16_t *)s->frame.data[0];
348	348
349		− if (decode_block(s, samples, avctx->codec->id == CODEC_ID_BINKAUDIO_DCT)) {
	349	+ if (decode_block(s, samples, avctx->codec->id == AV_CODEC_ID_BINKAUDIO_DCT)) {
350	350	av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n");
351	351	return AVERROR_INVALIDDATA;
352	352	}
@@ -361,7 +361,7 @@ static int decode_frame(AVCodecContext avctx, void data, · 8 unmodified lines
361	361	AVCodec ff_binkaudio_rdft_decoder = {
362	362	.name = "binkaudio_rdft",
363	363	.type = AVMEDIA_TYPE_AUDIO,
364		− .id = CODEC_ID_BINKAUDIO_RDFT,
	364	+ .id = AV_CODEC_ID_BINKAUDIO_RDFT,
365	365	.priv_data_size = sizeof(BinkAudioContext),
366	366	.init = decode_init,
367	367	.close = decode_end,
@@ -373,7 +373,7 @@ AVCodec ff_binkaudio_rdft_decoder = { · 5 unmodified lines
373	373	AVCodec ff_binkaudio_dct_decoder = {
374	374	.name = "binkaudio_dct",
375	375	.type = AVMEDIA_TYPE_AUDIO,
376		− .id = CODEC_ID_BINKAUDIO_DCT,
	376	+ .id = AV_CODEC_ID_BINKAUDIO_DCT,
377	377	.priv_data_size = sizeof(BinkAudioContext),
378	378	.init = decode_init,
379	379	.close = decode_end,

libavcodec/bmp.c+1−1

@@ -364,7 +364,7 @@ static av_cold int bmp_decode_end(AVCodecContext *avctx) · 363 unmodified lines
364	364	AVCodec ff_bmp_decoder = {
365	365	.name = "bmp",
366	366	.type = AVMEDIA_TYPE_VIDEO,
367		− .id = CODEC_ID_BMP,
	367	+ .id = AV_CODEC_ID_BMP,
368	368	.priv_data_size = sizeof(BMPContext),
369	369	.init = bmp_decode_init,
370	370	.close = bmp_decode_end,

libavcodec/bmpenc.c+1−1

@@ -162,7 +162,7 @@ static int bmp_encode_frame(AVCodecContext avctx, AVPacket pkt, · 161 unmodified lines
162	162	AVCodec ff_bmp_encoder = {
163	163	.name = "bmp",
164	164	.type = AVMEDIA_TYPE_VIDEO,
165		− .id = CODEC_ID_BMP,
	165	+ .id = AV_CODEC_ID_BMP,
166	166	.priv_data_size = sizeof(BMPContext),
167	167	.init = bmp_encode_init,
168	168	.encode2 = bmp_encode_frame,

libavcodec/bmv.c+2−2

@@ -360,7 +360,7 @@ static int bmv_aud_decode_frame(AVCodecContext avctx, void data, · 359 unmodified lines
360	360	AVCodec ff_bmv_video_decoder = {
361	361	.name = "bmv_video",
362	362	.type = AVMEDIA_TYPE_VIDEO,
363		− .id = CODEC_ID_BMV_VIDEO,
	363	+ .id = AV_CODEC_ID_BMV_VIDEO,
364	364	.priv_data_size = sizeof(BMVDecContext),
365	365	.init = decode_init,
366	366	.close = decode_end,
@@ -371,7 +371,7 @@ AVCodec ff_bmv_video_decoder = { · 4 unmodified lines
371	371	AVCodec ff_bmv_audio_decoder = {
372	372	.name = "bmv_audio",
373	373	.type = AVMEDIA_TYPE_AUDIO,
374		− .id = CODEC_ID_BMV_AUDIO,
	374	+ .id = AV_CODEC_ID_BMV_AUDIO,
375	375	.priv_data_size = sizeof(BMVAudioDecContext),
376	376	.init = bmv_aud_decode_init,
377	377	.decode = bmv_aud_decode_frame,

libavcodec/c93.c+1−1

@@ -247,7 +247,7 @@ static int decode_frame(AVCodecContext avctx, void data, · 246 unmodified lines
247	247	AVCodec ff_c93_decoder = {
248	248	.name = "c93",
249	249	.type = AVMEDIA_TYPE_VIDEO,
250		− .id = CODEC_ID_C93,
	250	+ .id = AV_CODEC_ID_C93,
251	251	.priv_data_size = sizeof(C93DecoderContext),
252	252	.init = decode_init,
253	253	.close = decode_end,

libavcodec/cavs_parser.c+1−1

@@ -98,7 +98,7 @@ static int cavsvideo_parse(AVCodecParserContext *s, · 97 unmodified lines
98	98	}
99	99
100	100	AVCodecParser ff_cavsvideo_parser = {
101		− .codec_ids = { CODEC_ID_CAVS },
	101	+ .codec_ids = { AV_CODEC_ID_CAVS },
102	102	.priv_data_size = sizeof(ParseContext),
103	103	.parser_parse = cavsvideo_parse,
104	104	.parser_close = ff_parse_close,

libavcodec/cavsdec.c+1−1

@@ -718,7 +718,7 @@ static int cavs_decode_frame(AVCodecContext * avctx,void data, int data_size, · 717 unmodified lines
718	718	AVCodec ff_cavs_decoder = {
719	719	.name = "cavs",
720	720	.type = AVMEDIA_TYPE_VIDEO,
721		− .id = CODEC_ID_CAVS,
	721	+ .id = AV_CODEC_ID_CAVS,
722	722	.priv_data_size = sizeof(AVSContext),
723	723	.init = ff_cavs_init,
724	724	.close = ff_cavs_end,

libavcodec/cdgraphics.c+1−1

@@ -370,7 +370,7 @@ static av_cold int cdg_decode_end(AVCodecContext *avctx) · 369 unmodified lines
370	370	AVCodec ff_cdgraphics_decoder = {
371	371	.name = "cdgraphics",
372	372	.type = AVMEDIA_TYPE_VIDEO,
373		− .id = CODEC_ID_CDGRAPHICS,
	373	+ .id = AV_CODEC_ID_CDGRAPHICS,
374	374	.priv_data_size = sizeof(CDGraphicsContext),
375	375	.init = cdg_decode_init,
376	376	.close = cdg_decode_end,

libavcodec/cdxl.c+1−1

@@ -300,7 +300,7 @@ static av_cold int cdxl_decode_end(AVCodecContext *avctx) · 299 unmodified lines
300	300	AVCodec ff_cdxl_decoder = {
301	301	.name = "cdxl",
302	302	.type = AVMEDIA_TYPE_VIDEO,
303		− .id = CODEC_ID_CDXL,
	303	+ .id = AV_CODEC_ID_CDXL,
304	304	.priv_data_size = sizeof(CDXLVideoContext),
305	305	.init = cdxl_decode_init,
306	306	.close = cdxl_decode_end,

libavcodec/cinepak.c+1−1

@@ -469,7 +469,7 @@ static av_cold int cinepak_decode_end(AVCodecContext *avctx) · 468 unmodified lines
469	469	AVCodec ff_cinepak_decoder = {
470	470	.name = "cinepak",
471	471	.type = AVMEDIA_TYPE_VIDEO,
472		− .id = CODEC_ID_CINEPAK,
	472	+ .id = AV_CODEC_ID_CINEPAK,
473	473	.priv_data_size = sizeof(CinepakContext),
474	474	.init = cinepak_decode_init,
475	475	.close = cinepak_decode_end,

libavcodec/cljr.c+2−2

@@ -118,7 +118,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 117 unmodified lines
118	118	AVCodec ff_cljr_decoder = {
119	119	.name = "cljr",
120	120	.type = AVMEDIA_TYPE_VIDEO,
121		− .id = CODEC_ID_CLJR,
	121	+ .id = AV_CODEC_ID_CLJR,
122	122	.priv_data_size = sizeof(CLJRContext),
123	123	.init = decode_init,
124	124	.close = decode_end,
@@ -171,7 +171,7 @@ static int encode_frame(AVCodecContext avctx, AVPacket pkt, · 46 unmodified lines
171	171	AVCodec ff_cljr_encoder = {
172	172	.name = "cljr",
173	173	.type = AVMEDIA_TYPE_VIDEO,
174		− .id = CODEC_ID_CLJR,
	174	+ .id = AV_CODEC_ID_CLJR,
175	175	.priv_data_size = sizeof(CLJRContext),
176	176	.init = common_init,
177	177	.encode2 = encode_frame,

libavcodec/cllc.c+1−1

@@ -274,7 +274,7 @@ static av_cold int cllc_decode_init(AVCodecContext *avctx) · 273 unmodified lines
274	274	AVCodec ff_cllc_decoder = {
275	275	.name = "cllc",
276	276	.type = AVMEDIA_TYPE_VIDEO,
277		− .id = CODEC_ID_CLLC,
	277	+ .id = AV_CODEC_ID_CLLC,
278	278	.priv_data_size = sizeof(CLLCContext),
279	279	.init = cllc_decode_init,
280	280	.decode = cllc_decode_frame,

libavcodec/cook.c+1−1

@@ -1297,7 +1297,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx) · 1296 unmodified lines
1297	1297	AVCodec ff_cook_decoder = {
1298	1298	.name = "cook",
1299	1299	.type = AVMEDIA_TYPE_AUDIO,
1300		− .id = CODEC_ID_COOK,
	1300	+ .id = AV_CODEC_ID_COOK,
1301	1301	.priv_data_size = sizeof(COOKContext),
1302	1302	.init = cook_decode_init,
1303	1303	.close = cook_decode_close,

libavcodec/cook_parser.c+1−1

@@ -53,7 +53,7 @@ static int cook_parse(AVCodecParserContext s1, AVCodecContext avctx, · 52 unmodified lines
53	53	}
54	54
55	55	AVCodecParser ff_cook_parser = {
56		− .codec_ids = { CODEC_ID_COOK },
	56	+ .codec_ids = { AV_CODEC_ID_COOK },
57	57	.priv_data_size = sizeof(CookParseContext),
58	58	.parser_parse = cook_parse,
59	59	};

libavcodec/cscd.c+1−1

@@ -257,7 +257,7 @@ static av_cold int decode_end(AVCodecContext *avctx) { · 256 unmodified lines
257	257	AVCodec ff_cscd_decoder = {
258	258	.name = "camstudio",
259	259	.type = AVMEDIA_TYPE_VIDEO,
260		− .id = CODEC_ID_CSCD,
	260	+ .id = AV_CODEC_ID_CSCD,
261	261	.priv_data_size = sizeof(CamStudioContext),
262	262	.init = decode_init,
263	263	.close = decode_end,

libavcodec/cyuv.c+3−3

@@ -82,7 +82,7 @@ static int cyuv_decode_frame(AVCodecContext *avctx, · 81 unmodified lines
82	82	unsigned char cur_byte;
83	83	int pixel_groups;
84	84
85		− if (avctx->codec_id == CODEC_ID_AURA) {
	85	+ if (avctx->codec_id == AV_CODEC_ID_AURA) {
86	86	y_table = u_table;
87	87	u_table = v_table;
88	88	}
@@ -181,7 +181,7 @@ static av_cold int cyuv_decode_end(AVCodecContext *avctx) · 92 unmodified lines
181	181	AVCodec ff_aura_decoder = {
182	182	.name = "aura",
183	183	.type = AVMEDIA_TYPE_VIDEO,
184		− .id = CODEC_ID_AURA,
	184	+ .id = AV_CODEC_ID_AURA,
185	185	.priv_data_size = sizeof(CyuvDecodeContext),
186	186	.init = cyuv_decode_init,
187	187	.close = cyuv_decode_end,
@@ -195,7 +195,7 @@ AVCodec ff_aura_decoder = { · 7 unmodified lines
195	195	AVCodec ff_cyuv_decoder = {
196	196	.name = "cyuv",
197	197	.type = AVMEDIA_TYPE_VIDEO,
198		− .id = CODEC_ID_CYUV,
	198	+ .id = AV_CODEC_ID_CYUV,
199	199	.priv_data_size = sizeof(CyuvDecodeContext),
200	200	.init = cyuv_decode_init,
201	201	.close = cyuv_decode_end,

libavcodec/dca_parser.c+1−1

@@ -203,7 +203,7 @@ static int dca_parse(AVCodecParserContext * s, · 202 unmodified lines
203	203	}
204	204
205	205	AVCodecParser ff_dca_parser = {
206		− .codec_ids = { CODEC_ID_DTS },
	206	+ .codec_ids = { AV_CODEC_ID_DTS },
207	207	.priv_data_size = sizeof(DCAParseContext),
208	208	.parser_init = dca_parse_init,
209	209	.parser_parse = dca_parse,

libavcodec/dcadec.c+1−1

@@ -1957,7 +1957,7 @@ static const AVProfile profiles[] = { · 1956 unmodified lines
1957	1957	AVCodec ff_dca_decoder = {
1958	1958	.name = "dca",
1959	1959	.type = AVMEDIA_TYPE_AUDIO,
1960		− .id = CODEC_ID_DTS,
	1960	+ .id = AV_CODEC_ID_DTS,
1961	1961	.priv_data_size = sizeof(DCAContext),
1962	1962	.init = dca_decode_init,
1963	1963	.decode = dca_decode_frame,

libavcodec/dfa.c+1−1

@@ -377,7 +377,7 @@ static av_cold int dfa_decode_end(AVCodecContext *avctx) · 376 unmodified lines
377	377	AVCodec ff_dfa_decoder = {
378	378	.name = "dfa",
379	379	.type = AVMEDIA_TYPE_VIDEO,
380		− .id = CODEC_ID_DFA,
	380	+ .id = AV_CODEC_ID_DFA,
381	381	.priv_data_size = sizeof(DfaContext),
382	382	.init = dfa_decode_init,
383	383	.close = dfa_decode_end,

libavcodec/dirac_parser.c+1−1

@@ -248,7 +248,7 @@ static void dirac_parse_close(AVCodecParserContext *s) · 247 unmodified lines
248	248	}
249	249
250	250	AVCodecParser ff_dirac_parser = {
251		− .codec_ids = { CODEC_ID_DIRAC },
	251	+ .codec_ids = { AV_CODEC_ID_DIRAC },
252	252	.priv_data_size = sizeof(DiracParseContext),
253	253	.parser_parse = dirac_parse,
254	254	.parser_close = dirac_parse_close,

libavcodec/dnxhd_parser.c+1−1

@@ -87,7 +87,7 @@ static int dnxhd_parse(AVCodecParserContext *s, · 86 unmodified lines
87	87	}
88	88
89	89	AVCodecParser ff_dnxhd_parser = {
90		− .codec_ids = { CODEC_ID_DNXHD },
	90	+ .codec_ids = { AV_CODEC_ID_DNXHD },
91	91	.priv_data_size = sizeof(ParseContext),
92	92	.parser_parse = dnxhd_parse,
93	93	.parser_close = ff_parse_close,

libavcodec/dnxhddec.c+1−1

@@ -400,7 +400,7 @@ static av_cold int dnxhd_decode_close(AVCodecContext *avctx) · 399 unmodified lines
400	400	AVCodec ff_dnxhd_decoder = {
401	401	.name = "dnxhd",
402	402	.type = AVMEDIA_TYPE_VIDEO,
403		− .id = CODEC_ID_DNXHD,
	403	+ .id = AV_CODEC_ID_DNXHD,
404	404	.priv_data_size = sizeof(DNXHDContext),
405	405	.init = dnxhd_decode_init,
406	406	.close = dnxhd_decode_close,

libavcodec/dnxhdenc.c+1−1

@@ -1001,7 +1001,7 @@ static int dnxhd_encode_end(AVCodecContext *avctx) · 1000 unmodified lines
1001	1001	AVCodec ff_dnxhd_encoder = {
1002	1002	.name = "dnxhd",
1003	1003	.type = AVMEDIA_TYPE_VIDEO,
1004		− .id = CODEC_ID_DNXHD,
	1004	+ .id = AV_CODEC_ID_DNXHD,
1005	1005	.priv_data_size = sizeof(DNXHDEncContext),
1006	1006	.init = dnxhd_encode_init,
1007	1007	.encode2 = dnxhd_encode_picture,

libavcodec/dpcm.c+15−15

@@ -128,7 +128,7 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx) · 127 unmodified lines
128	128
129	129	switch(avctx->codec->id) {
130	130
131		− case CODEC_ID_ROQ_DPCM:
	131	+ case AV_CODEC_ID_ROQ_DPCM:
132	132	/* initialize square table */
133	133	for (i = 0; i < 128; i++) {
134	134	int16_t square = i * i;
@@ -137,7 +137,7 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx) · 2 unmodified lines
137	137	}
138	138	break;
139	139
140		− case CODEC_ID_SOL_DPCM:
	140	+ case AV_CODEC_ID_SOL_DPCM:
141	141	switch(avctx->codec_tag){
142	142	case 1:
143	143	s->sol_table = sol_table_old;
@@ -159,7 +159,7 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx) · 15 unmodified lines
159	159	break;
160	160	}
161	161
162		− if (avctx->codec->id == CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
	162	+ if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
163	163	avctx->sample_fmt = AV_SAMPLE_FMT_U8;
164	164	else
165	165	avctx->sample_fmt = AV_SAMPLE_FMT_S16;
@@ -189,16 +189,16 @@ static int dpcm_decode_frame(AVCodecContext avctx, void data, · 23 unmodified lines
189	189
190	190	/* calculate output size */
191	191	switch(avctx->codec->id) {
192		− case CODEC_ID_ROQ_DPCM:
	192	+ case AV_CODEC_ID_ROQ_DPCM:
193	193	out = buf_size - 8;
194	194	break;
195		− case CODEC_ID_INTERPLAY_DPCM:
	195	+ case AV_CODEC_ID_INTERPLAY_DPCM:
196	196	out = buf_size - 6 - s->channels;
197	197	break;
198		− case CODEC_ID_XAN_DPCM:
	198	+ case AV_CODEC_ID_XAN_DPCM:
199	199	out = buf_size - 2 * s->channels;
200	200	break;
201		− case CODEC_ID_SOL_DPCM:
	201	+ case AV_CODEC_ID_SOL_DPCM:
202	202	if (avctx->codec_tag != 3)
203	203	out = buf_size * 2;
204	204	else
@@ -221,7 +221,7 @@ static int dpcm_decode_frame(AVCodecContext avctx, void data, · 16 unmodified lines
221	221
222	222	switch(avctx->codec->id) {
223	223
224		− case CODEC_ID_ROQ_DPCM:
	224	+ case AV_CODEC_ID_ROQ_DPCM:
225	225	bytestream2_skipu(&gb, 6);
226	226
227	227	if (stereo) {
@@ -242,7 +242,7 @@ static int dpcm_decode_frame(AVCodecContext avctx, void data, · 14 unmodified lines
242	242	}
243	243	break;
244	244
245		− case CODEC_ID_INTERPLAY_DPCM:
	245	+ case AV_CODEC_ID_INTERPLAY_DPCM:
246	246	bytestream2_skipu(&gb, 6); /* skip over the stream mask and stream length */
247	247
248	248	for (ch = 0; ch < s->channels; ch++) {
@@ -261,7 +261,7 @@ static int dpcm_decode_frame(AVCodecContext avctx, void data, · 12 unmodified lines
261	261	}
262	262	break;
263	263
264		− case CODEC_ID_XAN_DPCM:
	264	+ case AV_CODEC_ID_XAN_DPCM:
265	265	{
266	266	int shift[2] = { 4, 4 };
267	267
@@ -294,7 +294,7 @@ static int dpcm_decode_frame(AVCodecContext avctx, void data, · 26 unmodified lines
294	294	}
295	295	break;
296	296	}
297		− case CODEC_ID_SOL_DPCM:
	297	+ case AV_CODEC_ID_SOL_DPCM:
298	298	if (avctx->codec_tag != 3) {
299	299	uint8_t *output_samples_u8 = s->frame.data[0],
300	300	*samples_end_u8 = output_samples_u8 + out;
@@ -341,7 +341,7 @@ AVCodec ff_ ## name_ ## _decoder = { \ · 40 unmodified lines
341	341	.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
342	342	}
343	343
344		−DPCM_DECODER(CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
345		−DPCM_DECODER(CODEC_ID_ROQ_DPCM, roq_dpcm, "DPCM id RoQ");
346		−DPCM_DECODER(CODEC_ID_SOL_DPCM, sol_dpcm, "DPCM Sol");
347		−DPCM_DECODER(CODEC_ID_XAN_DPCM, xan_dpcm, "DPCM Xan");
	344	+DPCM_DECODER(AV_CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
	345	+DPCM_DECODER(AV_CODEC_ID_ROQ_DPCM, roq_dpcm, "DPCM id RoQ");
	346	+DPCM_DECODER(AV_CODEC_ID_SOL_DPCM, sol_dpcm, "DPCM Sol");
	347	+DPCM_DECODER(AV_CODEC_ID_XAN_DPCM, xan_dpcm, "DPCM Xan");

libavcodec/dpx.c+1−1

@@ -237,7 +237,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 236 unmodified lines
237	237	AVCodec ff_dpx_decoder = {
238	238	.name = "dpx",
239	239	.type = AVMEDIA_TYPE_VIDEO,
240		− .id = CODEC_ID_DPX,
	240	+ .id = AV_CODEC_ID_DPX,
241	241	.priv_data_size = sizeof(DPXContext),
242	242	.init = decode_init,
243	243	.close = decode_end,

libavcodec/dpxenc.c+1−1

@@ -175,7 +175,7 @@ static int encode_frame(AVCodecContext avctx, AVPacket pkt, · 174 unmodified lines
175	175	AVCodec ff_dpx_encoder = {
176	176	.name = "dpx",
177	177	.type = AVMEDIA_TYPE_VIDEO,
178		− .id = CODEC_ID_DPX,
	178	+ .id = AV_CODEC_ID_DPX,
179	179	.priv_data_size = sizeof(DPXContext),
180	180	.init = encode_init,
181	181	.encode2 = encode_frame,

libavcodec/dsicinav.c+2−2

@@ -375,7 +375,7 @@ static int cinaudio_decode_frame(AVCodecContext avctx, void data, · 374 unmodified lines
375	375	AVCodec ff_dsicinvideo_decoder = {
376	376	.name = "dsicinvideo",
377	377	.type = AVMEDIA_TYPE_VIDEO,
378		− .id = CODEC_ID_DSICINVIDEO,
	378	+ .id = AV_CODEC_ID_DSICINVIDEO,
379	379	.priv_data_size = sizeof(CinVideoContext),
380	380	.init = cinvideo_decode_init,
381	381	.close = cinvideo_decode_end,
@@ -387,7 +387,7 @@ AVCodec ff_dsicinvideo_decoder = { · 5 unmodified lines
387	387	AVCodec ff_dsicinaudio_decoder = {
388	388	.name = "dsicinaudio",
389	389	.type = AVMEDIA_TYPE_AUDIO,
390		− .id = CODEC_ID_DSICINAUDIO,
	390	+ .id = AV_CODEC_ID_DSICINAUDIO,
391	391	.priv_data_size = sizeof(CinAudioContext),
392	392	.init = cinaudio_decode_init,
393	393	.decode = cinaudio_decode_frame,

libavcodec/dv.c+1−1

@@ -979,7 +979,7 @@ static int dvvideo_encode_frame(AVCodecContext c, AVPacket pkt, · 978 unmodified lines
979	979	AVCodec ff_dvvideo_encoder = {
980	980	.name = "dvvideo",
981	981	.type = AVMEDIA_TYPE_VIDEO,
982		− .id = CODEC_ID_DVVIDEO,
	982	+ .id = AV_CODEC_ID_DVVIDEO,
983	983	.priv_data_size = sizeof(DVVideoContext),
984	984	.init = dvvideo_init_encoder,
985	985	.encode2 = dvvideo_encode_frame,

libavcodec/dvbsub.c+1−1

@@ -405,7 +405,7 @@ static int dvbsub_encode(AVCodecContext *avctx, · 404 unmodified lines
405	405	AVCodec ff_dvbsub_encoder = {
406	406	.name = "dvbsub",
407	407	.type = AVMEDIA_TYPE_SUBTITLE,
408		− .id = CODEC_ID_DVB_SUBTITLE,
	408	+ .id = AV_CODEC_ID_DVB_SUBTITLE,
409	409	.priv_data_size = sizeof(DVBSubtitleContext),
410	410	.encode = dvbsub_encode,
411	411	.long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),

libavcodec/dvbsub_parser.c+1−1

@@ -172,7 +172,7 @@ static av_cold void dvbsub_parse_close(AVCodecParserContext *s) · 171 unmodified lines
172	172	}
173	173
174	174	AVCodecParser ff_dvbsub_parser = {
175		− .codec_ids = { CODEC_ID_DVB_SUBTITLE },
	175	+ .codec_ids = { AV_CODEC_ID_DVB_SUBTITLE },
176	176	.priv_data_size = sizeof(DVBSubParseContext),
177	177	.parser_init = dvbsub_parse_init,
178	178	.parser_parse = dvbsub_parse,

libavcodec/dvbsubdec.c+1−1

@@ -1466,7 +1466,7 @@ static int dvbsub_decode(AVCodecContext *avctx, · 1465 unmodified lines
1466	1466	AVCodec ff_dvbsub_decoder = {
1467	1467	.name = "dvbsub",
1468	1468	.type = AVMEDIA_TYPE_SUBTITLE,
1469		− .id = CODEC_ID_DVB_SUBTITLE,
	1469	+ .id = AV_CODEC_ID_DVB_SUBTITLE,
1470	1470	.priv_data_size = sizeof(DVBSubContext),
1471	1471	.init = dvbsub_init_decoder,
1472	1472	.close = dvbsub_close_decoder,

libavcodec/dvdec.c+1−1

@@ -375,7 +375,7 @@ static int dvvideo_close(AVCodecContext *c) · 374 unmodified lines
375	375	AVCodec ff_dvvideo_decoder = {
376	376	.name = "dvvideo",
377	377	.type = AVMEDIA_TYPE_VIDEO,
378		− .id = CODEC_ID_DVVIDEO,
	378	+ .id = AV_CODEC_ID_DVVIDEO,
379	379	.priv_data_size = sizeof(DVVideoContext),
380	380	.init = ff_dvvideo_init,
381	381	.close = dvvideo_close,

libavcodec/dvdsub_parser.c+1−1

@@ -77,7 +77,7 @@ static av_cold void dvdsub_parse_close(AVCodecParserContext *s) · 76 unmodified lines
77	77	}
78	78
79	79	AVCodecParser ff_dvdsub_parser = {
80		− .codec_ids = { CODEC_ID_DVD_SUBTITLE },
	80	+ .codec_ids = { AV_CODEC_ID_DVD_SUBTITLE },
81	81	.priv_data_size = sizeof(DVDSubParseContext),
82	82	.parser_init = dvdsub_parse_init,
83	83	.parser_parse = dvdsub_parse,

libavcodec/dvdsubdec.c+1−1

@@ -487,7 +487,7 @@ static int dvdsub_decode(AVCodecContext *avctx, · 486 unmodified lines
487	487	AVCodec ff_dvdsub_decoder = {
488	488	.name = "dvdsub",
489	489	.type = AVMEDIA_TYPE_SUBTITLE,
490		− .id = CODEC_ID_DVD_SUBTITLE,
	490	+ .id = AV_CODEC_ID_DVD_SUBTITLE,
491	491	.decode = dvdsub_decode,
492	492	.long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"),
493	493	};

libavcodec/dvdsubenc.c+1−1

@@ -218,7 +218,7 @@ static int dvdsub_encode(AVCodecContext *avctx, · 217 unmodified lines
218	218	AVCodec ff_dvdsub_encoder = {
219	219	.name = "dvdsub",
220	220	.type = AVMEDIA_TYPE_SUBTITLE,
221		− .id = CODEC_ID_DVD_SUBTITLE,
	221	+ .id = AV_CODEC_ID_DVD_SUBTITLE,
222	222	.encode = dvdsub_encode,
223	223	.long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"),
224	224	};

libavcodec/dxa.c+1−1

@@ -318,7 +318,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 317 unmodified lines
318	318	AVCodec ff_dxa_decoder = {
319	319	.name = "dxa",
320	320	.type = AVMEDIA_TYPE_VIDEO,
321		− .id = CODEC_ID_DXA,
	321	+ .id = AV_CODEC_ID_DXA,
322	322	.priv_data_size = sizeof(DxaDecContext),
323	323	.init = decode_init,
324	324	.close = decode_end,

libavcodec/dxtory.c+1−1

@@ -101,7 +101,7 @@ AVCodec ff_dxtory_decoder = { · 100 unmodified lines
101	101	.name = "dxtory",
102	102	.long_name = NULL_IF_CONFIG_SMALL("Dxtory"),
103	103	.type = AVMEDIA_TYPE_VIDEO,
104		− .id = CODEC_ID_DXTORY,
	104	+ .id = AV_CODEC_ID_DXTORY,
105	105	.init = decode_init,
106	106	.close = decode_close,
107	107	.decode = decode_frame,

libavcodec/dxva2_h264.c+1−1

@@ -442,7 +442,7 @@ static int end_frame(AVCodecContext *avctx) · 441 unmodified lines
442	442	AVHWAccel ff_h264_dxva2_hwaccel = {
443	443	.name = "h264_dxva2",
444	444	.type = AVMEDIA_TYPE_VIDEO,
445		− .id = CODEC_ID_H264,
	445	+ .id = AV_CODEC_ID_H264,
446	446	.pix_fmt = PIX_FMT_DXVA2_VLD,
447	447	.start_frame = start_frame,
448	448	.decode_slice = decode_slice,

libavcodec/dxva2_mpeg2.c+1−1

@@ -263,7 +263,7 @@ static int end_frame(AVCodecContext *avctx) · 262 unmodified lines
263	263	AVHWAccel ff_mpeg2_dxva2_hwaccel = {
264	264	.name = "mpeg2_dxva2",
265	265	.type = AVMEDIA_TYPE_VIDEO,
266		− .id = CODEC_ID_MPEG2VIDEO,
	266	+ .id = AV_CODEC_ID_MPEG2VIDEO,
267	267	.pix_fmt = PIX_FMT_DXVA2_VLD,
268	268	.start_frame = start_frame,
269	269	.decode_slice = decode_slice,

libavcodec/dxva2_vc1.c+4−4

@@ -167,7 +167,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx, · 166 unmodified lines
167	167	DXVA_SliceInfo *slice = &ctx_pic->si;
168	168
169	169	static const uint8_t start_code[] = { 0, 0, 1, 0x0d };
170		− const unsigned start_code_size = avctx->codec_id == CODEC_ID_VC1 ? sizeof(start_code) : 0;
	170	+ const unsigned start_code_size = avctx->codec_id == AV_CODEC_ID_VC1 ? sizeof(start_code) : 0;
171	171	const unsigned slice_size = slice->dwSliceBitsInBuffer / 8;
172	172	const unsigned padding = 128 - ((start_code_size + slice_size) & 127);
173	173	const unsigned data_size = start_code_size + slice_size + padding;
@@ -237,7 +237,7 @@ static int decode_slice(AVCodecContext *avctx, · 63 unmodified lines
237	237	if (ctx_pic->bitstream_size > 0)
238	238	return -1;
239	239
240		− if (avctx->codec_id == CODEC_ID_VC1 &&
	240	+ if (avctx->codec_id == AV_CODEC_ID_VC1 &&
241	241	size >= 4 && IS_MARKER(AV_RB32(buffer))) {
242	242	buffer += 4;
243	243	size -= 4;
@@ -268,7 +268,7 @@ static int end_frame(AVCodecContext *avctx) · 24 unmodified lines
268	268	AVHWAccel ff_wmv3_dxva2_hwaccel = {
269	269	.name = "wmv3_dxva2",
270	270	.type = AVMEDIA_TYPE_VIDEO,
271		− .id = CODEC_ID_WMV3,
	271	+ .id = AV_CODEC_ID_WMV3,
272	272	.pix_fmt = PIX_FMT_DXVA2_VLD,
273	273	.start_frame = start_frame,
274	274	.decode_slice = decode_slice,
@@ -280,7 +280,7 @@ AVHWAccel ff_wmv3_dxva2_hwaccel = { · 5 unmodified lines
280	280	AVHWAccel ff_vc1_dxva2_hwaccel = {
281	281	.name = "vc1_dxva2",
282	282	.type = AVMEDIA_TYPE_VIDEO,
283		− .id = CODEC_ID_VC1,
	283	+ .id = AV_CODEC_ID_VC1,
284	284	.pix_fmt = PIX_FMT_DXVA2_VLD,
285	285	.start_frame = start_frame,
286	286	.decode_slice = decode_slice,

libavcodec/eac3enc.c+1−1

@@ -249,7 +249,7 @@ void ff_eac3_output_frame_header(AC3EncodeContext *s) · 248 unmodified lines
249	249	AVCodec ff_eac3_encoder = {
250	250	.name = "eac3",
251	251	.type = AVMEDIA_TYPE_AUDIO,
252		− .id = CODEC_ID_EAC3,
	252	+ .id = AV_CODEC_ID_EAC3,
253	253	.priv_data_size = sizeof(AC3EncodeContext),
254	254	.init = ff_ac3_encode_init,
255	255	.encode2 = ff_ac3_float_encode_frame,

libavcodec/eacmv.c+1−1

@@ -211,7 +211,7 @@ static av_cold int cmv_decode_end(AVCodecContext *avctx){ · 210 unmodified lines
211	211	AVCodec ff_eacmv_decoder = {
212	212	.name = "eacmv",
213	213	.type = AVMEDIA_TYPE_VIDEO,
214		− .id = CODEC_ID_CMV,
	214	+ .id = AV_CODEC_ID_CMV,
215	215	.priv_data_size = sizeof(CmvContext),
216	216	.init = cmv_decode_init,
217	217	.close = cmv_decode_end,

libavcodec/eamad.c+1−1

@@ -296,7 +296,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 295 unmodified lines
296	296	AVCodec ff_eamad_decoder = {
297	297	.name = "eamad",
298	298	.type = AVMEDIA_TYPE_VIDEO,
299		− .id = CODEC_ID_MAD,
	299	+ .id = AV_CODEC_ID_MAD,
300	300	.priv_data_size = sizeof(MadContext),
301	301	.init = decode_init,
302	302	.close = decode_end,

libavcodec/eatgq.c+1−1

@@ -242,7 +242,7 @@ static av_cold int tgq_decode_end(AVCodecContext *avctx){ · 241 unmodified lines
242	242	AVCodec ff_eatgq_decoder = {
243	243	.name = "eatgq",
244	244	.type = AVMEDIA_TYPE_VIDEO,
245		− .id = CODEC_ID_TGQ,
	245	+ .id = AV_CODEC_ID_TGQ,
246	246	.priv_data_size = sizeof(TgqContext),
247	247	.init = tgq_decode_init,
248	248	.close = tgq_decode_end,

libavcodec/eatgv.c+1−1

@@ -345,7 +345,7 @@ static av_cold int tgv_decode_end(AVCodecContext *avctx) · 344 unmodified lines
345	345	AVCodec ff_eatgv_decoder = {
346	346	.name = "eatgv",
347	347	.type = AVMEDIA_TYPE_VIDEO,
348		− .id = CODEC_ID_TGV,
	348	+ .id = AV_CODEC_ID_TGV,
349	349	.priv_data_size = sizeof(TgvContext),
350	350	.init = tgv_decode_init,
351	351	.close = tgv_decode_end,

libavcodec/eatqi.c+1−1

@@ -154,7 +154,7 @@ static av_cold int tqi_decode_end(AVCodecContext *avctx) · 153 unmodified lines
154	154	AVCodec ff_eatqi_decoder = {
155	155	.name = "eatqi",
156	156	.type = AVMEDIA_TYPE_VIDEO,
157		− .id = CODEC_ID_TQI,
	157	+ .id = AV_CODEC_ID_TQI,
158	158	.priv_data_size = sizeof(TqiContext),
159	159	.init = tqi_decode_init,
160	160	.close = tqi_decode_end,

libavcodec/error_resilience.c+6−6

@@ -46,7 +46,7 @@ static void decode_mb(MpegEncContext *s, int ref) · 45 unmodified lines
46	46	s->dest[1] = s->current_picture.f.data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
47	47	s->dest[2] = s->current_picture.f.data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
48	48
49		− if (CONFIG_H264_DECODER && s->codec_id == CODEC_ID_H264) {
	49	+ if (CONFIG_H264_DECODER && s->codec_id == AV_CODEC_ID_H264) {
50	50	H264Context h = (void)s;
51	51	h->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
52	52	memset(h->non_zero_count_cache, 0, sizeof(h->non_zero_count_cache));
@@ -76,7 +76,7 @@ static void decode_mb(MpegEncContext *s, int ref) · 23 unmodified lines
76	76	*/
77	77	static void set_mv_strides(MpegEncContext s, int mv_step, int *stride)
78	78	{
79		− if (s->codec_id == CODEC_ID_H264) {
	79	+ if (s->codec_id == AV_CODEC_ID_H264) {
80	80	H264Context h = (void)s;
81	81	assert(s->quarter_sample);
82	82	*mv_step = 4;
@@ -599,7 +599,7 @@ skip_mean_and_median: · 516 unmodified lines
599	599	pred_count++;
600	600
601	601	if (!fixed[mb_xy]) {
602		− if (s->avctx->codec_id == CODEC_ID_H264) {
	602	+ if (s->avctx->codec_id == AV_CODEC_ID_H264) {
603	603	// FIXME
604	604	} else {
605	605	ff_thread_await_progress(&s->last_picture_ptr->f,
@@ -730,7 +730,7 @@ static int is_intra_more_likely(MpegEncContext *s) · 124 unmodified lines
730	730	undamaged_count++;
731	731	}
732	732
733		− if (s->codec_id == CODEC_ID_H264) {
	733	+ if (s->codec_id == AV_CODEC_ID_H264) {
734	734	H264Context h = (void) s;
735	735	if (h->list_count <= 0 \|\| h->ref_count[0] <= 0 \|\|
736	736	!h->ref_list[0][0].f.data[0])
@@ -770,7 +770,7 @@ static int is_intra_more_likely(MpegEncContext *s) · 33 unmodified lines
770	770	uint8_t *last_mb_ptr = s->last_picture.f.data[0] +
771	771	mb_x * 16 + mb_y * 16 * s->linesize;
772	772
773		− if (s->avctx->codec_id == CODEC_ID_H264) {
	773	+ if (s->avctx->codec_id == AV_CODEC_ID_H264) {
774	774	// FIXME
775	775	} else {
776	776	ff_thread_await_progress(&s->last_picture_ptr->f,
@@ -1161,7 +1161,7 @@ void ff_er_frame_end(MpegEncContext *s) · 384 unmodified lines
1161	1161	int time_pp = s->pp_time;
1162	1162	int time_pb = s->pb_time;
1163	1163
1164		− if (s->avctx->codec_id == CODEC_ID_H264) {
	1164	+ if (s->avctx->codec_id == AV_CODEC_ID_H264) {
1165	1165	// FIXME
1166	1166	} else {
1167	1167	ff_thread_await_progress(&s->next_picture_ptr->f, mb_y, 0);

libavcodec/escape124.c+1−1

@@ -366,7 +366,7 @@ static int escape124_decode_frame(AVCodecContext *avctx, · 365 unmodified lines
366	366	AVCodec ff_escape124_decoder = {
367	367	.name = "escape124",
368	368	.type = AVMEDIA_TYPE_VIDEO,
369		− .id = CODEC_ID_ESCAPE124,
	369	+ .id = AV_CODEC_ID_ESCAPE124,
370	370	.priv_data_size = sizeof(Escape124Context),
371	371	.init = escape124_decode_init,
372	372	.close = escape124_decode_close,

libavcodec/ffv1.c+2−2

@@ -1738,7 +1738,7 @@ static int decode_frame(AVCodecContext avctx, void data, int *data_size, AVPac · 1737 unmodified lines
1738	1738	AVCodec ff_ffv1_decoder = {
1739	1739	.name = "ffv1",
1740	1740	.type = AVMEDIA_TYPE_VIDEO,
1741		− .id = CODEC_ID_FFV1,
	1741	+ .id = AV_CODEC_ID_FFV1,
1742	1742	.priv_data_size = sizeof(FFV1Context),
1743	1743	.init = decode_init,
1744	1744	.close = common_end,
@@ -1752,7 +1752,7 @@ AVCodec ff_ffv1_decoder = { · 7 unmodified lines
1752	1752	AVCodec ff_ffv1_encoder = {
1753	1753	.name = "ffv1",
1754	1754	.type = AVMEDIA_TYPE_VIDEO,
1755		− .id = CODEC_ID_FFV1,
	1755	+ .id = AV_CODEC_ID_FFV1,
1756	1756	.priv_data_size = sizeof(FFV1Context),
1757	1757	.init = encode_init,
1758	1758	.encode2 = encode_frame,

libavcodec/flac_parser.c+1−1

@@ -675,7 +675,7 @@ static void flac_parse_close(AVCodecParserContext *c) · 674 unmodified lines
675	675	}
676	676
677	677	AVCodecParser ff_flac_parser = {
678		− .codec_ids = { CODEC_ID_FLAC },
	678	+ .codec_ids = { AV_CODEC_ID_FLAC },
679	679	.priv_data_size = sizeof(FLACParseContext),
680	680	.parser_init = flac_parse_init,
681	681	.parser_parse = flac_parse,

libavcodec/flacdec.c+1−1

@@ -561,7 +561,7 @@ static av_cold int flac_decode_close(AVCodecContext *avctx) · 560 unmodified lines
561	561	AVCodec ff_flac_decoder = {
562	562	.name = "flac",
563	563	.type = AVMEDIA_TYPE_AUDIO,
564		− .id = CODEC_ID_FLAC,
	564	+ .id = AV_CODEC_ID_FLAC,
565	565	.priv_data_size = sizeof(FLACContext),
566	566	.init = flac_decode_init,
567	567	.close = flac_decode_close,

libavcodec/flacenc.c+1−1

@@ -1304,7 +1304,7 @@ static const AVClass flac_encoder_class = { · 1303 unmodified lines
1304	1304	AVCodec ff_flac_encoder = {
1305	1305	.name = "flac",
1306	1306	.type = AVMEDIA_TYPE_AUDIO,
1307		− .id = CODEC_ID_FLAC,
	1307	+ .id = AV_CODEC_ID_FLAC,
1308	1308	.priv_data_size = sizeof(FlacEncodeContext),
1309	1309	.init = flac_encode_init,
1310	1310	.encode2 = flac_encode_frame,

libavcodec/flashsv.c+2−2

@@ -455,7 +455,7 @@ static av_cold int flashsv_decode_end(AVCodecContext *avctx) · 454 unmodified lines
455	455	AVCodec ff_flashsv_decoder = {
456	456	.name = "flashsv",
457	457	.type = AVMEDIA_TYPE_VIDEO,
458		− .id = CODEC_ID_FLASHSV,
	458	+ .id = AV_CODEC_ID_FLASHSV,
459	459	.priv_data_size = sizeof(FlashSVContext),
460	460	.init = flashsv_decode_init,
461	461	.close = flashsv_decode_end,
@@ -518,7 +518,7 @@ static av_cold int flashsv2_decode_end(AVCodecContext *avctx) · 56 unmodified lines
518	518	AVCodec ff_flashsv2_decoder = {
519	519	.name = "flashsv2",
520	520	.type = AVMEDIA_TYPE_VIDEO,
521		− .id = CODEC_ID_FLASHSV2,
	521	+ .id = AV_CODEC_ID_FLASHSV2,
522	522	.priv_data_size = sizeof(FlashSVContext),
523	523	.init = flashsv2_decode_init,
524	524	.close = flashsv2_decode_end,

libavcodec/flashsvenc.c+1−1

@@ -282,7 +282,7 @@ static av_cold int flashsv_encode_end(AVCodecContext *avctx) · 281 unmodified lines
282	282	AVCodec ff_flashsv_encoder = {
283	283	.name = "flashsv",
284	284	.type = AVMEDIA_TYPE_VIDEO,
285		− .id = CODEC_ID_FLASHSV,
	285	+ .id = AV_CODEC_ID_FLASHSV,
286	286	.priv_data_size = sizeof(FlashSVContext),
287	287	.init = flashsv_encode_init,
288	288	.encode2 = flashsv_encode_frame,

libavcodec/flicvideo.c+1−1

@@ -735,7 +735,7 @@ static av_cold int flic_decode_end(AVCodecContext *avctx) · 734 unmodified lines
735	735	AVCodec ff_flic_decoder = {
736	736	.name = "flic",
737	737	.type = AVMEDIA_TYPE_VIDEO,
738		− .id = CODEC_ID_FLIC,
	738	+ .id = AV_CODEC_ID_FLIC,
739	739	.priv_data_size = sizeof(FlicDecodeContext),
740	740	.init = flic_decode_init,
741	741	.close = flic_decode_end,

libavcodec/flvdec.c+1−1

@@ -121,7 +121,7 @@ int ff_flv_decode_picture_header(MpegEncContext *s) · 120 unmodified lines
121	121	AVCodec ff_flv_decoder = {
122	122	.name = "flv",
123	123	.type = AVMEDIA_TYPE_VIDEO,
124		− .id = CODEC_ID_FLV1,
	124	+ .id = AV_CODEC_ID_FLV1,
125	125	.priv_data_size = sizeof(MpegEncContext),
126	126	.init = ff_h263_decode_init,
127	127	.close = ff_h263_decode_end,

libavcodec/flvenc.c+1−1

@@ -89,7 +89,7 @@ FF_MPV_GENERIC_CLASS(flv) · 88 unmodified lines
89	89	AVCodec ff_flv_encoder = {
90	90	.name = "flv",
91	91	.type = AVMEDIA_TYPE_VIDEO,
92		− .id = CODEC_ID_FLV1,
	92	+ .id = AV_CODEC_ID_FLV1,
93	93	.priv_data_size = sizeof(MpegEncContext),
94	94	.init = ff_MPV_encode_init,
95	95	.encode2 = ff_MPV_encode_picture,

libavcodec/fraps.c+1−1

@@ -369,7 +369,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 368 unmodified lines
369	369	AVCodec ff_fraps_decoder = {
370	370	.name = "fraps",
371	371	.type = AVMEDIA_TYPE_VIDEO,
372		− .id = CODEC_ID_FRAPS,
	372	+ .id = AV_CODEC_ID_FRAPS,
373	373	.priv_data_size = sizeof(FrapsContext),
374	374	.init = decode_init,
375	375	.close = decode_end,

libavcodec/frwu.c+1−1

@@ -115,7 +115,7 @@ static av_cold int decode_close(AVCodecContext *avctx) · 114 unmodified lines
115	115	AVCodec ff_frwu_decoder = {
116	116	.name = "frwu",
117	117	.type = AVMEDIA_TYPE_VIDEO,
118		− .id = CODEC_ID_FRWU,
	118	+ .id = AV_CODEC_ID_FRWU,
119	119	.init = decode_init,
120	120	.close = decode_close,
121	121	.decode = decode_frame,

libavcodec/g722dec.c+1−1

@@ -144,7 +144,7 @@ static int g722_decode_frame(AVCodecContext avctx, void data, · 143 unmodified lines
144	144	AVCodec ff_adpcm_g722_decoder = {
145	145	.name = "g722",
146	146	.type = AVMEDIA_TYPE_AUDIO,
147		− .id = CODEC_ID_ADPCM_G722,
	147	+ .id = AV_CODEC_ID_ADPCM_G722,
148	148	.priv_data_size = sizeof(G722Context),
149	149	.init = g722_decode_init,
150	150	.decode = g722_decode_frame,

libavcodec/g722enc.c+1−1

@@ -393,7 +393,7 @@ static int g722_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 392 unmodified lines
393	393	AVCodec ff_adpcm_g722_encoder = {
394	394	.name = "g722",
395	395	.type = AVMEDIA_TYPE_AUDIO,
396		− .id = CODEC_ID_ADPCM_G722,
	396	+ .id = AV_CODEC_ID_ADPCM_G722,
397	397	.priv_data_size = sizeof(G722Context),
398	398	.init = g722_encode_init,
399	399	.close = g722_encode_close,

libavcodec/g723_1.c+1−1

@@ -1175,7 +1175,7 @@ static const AVClass g723_1dec_class = { · 1174 unmodified lines
1175	1175	AVCodec ff_g723_1_decoder = {
1176	1176	.name = "g723_1",
1177	1177	.type = AVMEDIA_TYPE_AUDIO,
1178		− .id = CODEC_ID_G723_1,
	1178	+ .id = AV_CODEC_ID_G723_1,
1179	1179	.priv_data_size = sizeof(G723_1_Context),
1180	1180	.init = g723_1_decode_init,
1181	1181	.decode = g723_1_decode_frame,

libavcodec/g726.c+2−2

@@ -399,7 +399,7 @@ static const AVCodecDefault defaults[] = { · 398 unmodified lines
399	399	AVCodec ff_adpcm_g726_encoder = {
400	400	.name = "g726",
401	401	.type = AVMEDIA_TYPE_AUDIO,
402		− .id = CODEC_ID_ADPCM_G726,
	402	+ .id = AV_CODEC_ID_ADPCM_G726,
403	403	.priv_data_size = sizeof(G726Context),
404	404	.init = g726_encode_init,
405	405	.encode2 = g726_encode_frame,
@@ -491,7 +491,7 @@ static void g726_decode_flush(AVCodecContext *avctx) · 85 unmodified lines
491	491	AVCodec ff_adpcm_g726_decoder = {
492	492	.name = "g726",
493	493	.type = AVMEDIA_TYPE_AUDIO,
494		− .id = CODEC_ID_ADPCM_G726,
	494	+ .id = AV_CODEC_ID_ADPCM_G726,
495	495	.priv_data_size = sizeof(G726Context),
496	496	.init = g726_decode_init,
497	497	.decode = g726_decode_frame,

libavcodec/gif.c+1−1

@@ -182,7 +182,7 @@ static int gif_encode_close(AVCodecContext *avctx) · 181 unmodified lines
182	182	AVCodec ff_gif_encoder = {
183	183	.name = "gif",
184	184	.type = AVMEDIA_TYPE_VIDEO,
185		− .id = CODEC_ID_GIF,
	185	+ .id = AV_CODEC_ID_GIF,
186	186	.priv_data_size = sizeof(GIFContext),
187	187	.init = gif_encode_init,
188	188	.encode2 = gif_encode_frame,

libavcodec/gifdec.c+1−1

@@ -328,7 +328,7 @@ static av_cold int gif_decode_close(AVCodecContext *avctx) · 327 unmodified lines
328	328	AVCodec ff_gif_decoder = {
329	329	.name = "gif",
330	330	.type = AVMEDIA_TYPE_VIDEO,
331		− .id = CODEC_ID_GIF,
	331	+ .id = AV_CODEC_ID_GIF,
332	332	.priv_data_size = sizeof(GifState),
333	333	.init = gif_decode_init,
334	334	.close = gif_decode_close,

libavcodec/gsm_parser.c+3−3

@@ -45,11 +45,11 @@ static int gsm_parse(AVCodecParserContext s1, AVCodecContext avctx, · 44 unmodified lines
45	45
46	46	if (!s->block_size) {
47	47	switch (avctx->codec_id) {
48		− case CODEC_ID_GSM:
	48	+ case AV_CODEC_ID_GSM:
49	49	s->block_size = GSM_BLOCK_SIZE;
50	50	s->duration = GSM_FRAME_SIZE;
51	51	break;
52		− case CODEC_ID_GSM_MS:
	52	+ case AV_CODEC_ID_GSM_MS:
53	53	s->block_size = GSM_MS_BLOCK_SIZE;
54	54	s->duration = GSM_FRAME_SIZE * 2;
55	55	break;
@@ -82,7 +82,7 @@ static int gsm_parse(AVCodecParserContext s1, AVCodecContext avctx, · 26 unmodified lines
82	82	}
83	83
84	84	AVCodecParser ff_gsm_parser = {
85		− .codec_ids = { CODEC_ID_GSM, CODEC_ID_GSM_MS },
	85	+ .codec_ids = { AV_CODEC_ID_GSM, AV_CODEC_ID_GSM_MS },
86	86	.priv_data_size = sizeof(GSMParseContext),
87	87	.parser_parse = gsm_parse,
88	88	.parser_close = ff_parse_close,

libavcodec/gsmdec.c+6−6

@@ -40,11 +40,11 @@ static av_cold int gsm_init(AVCodecContext *avctx) · 39 unmodified lines
40	40	avctx->sample_fmt = AV_SAMPLE_FMT_S16;
41	41
42	42	switch (avctx->codec_id) {
43		− case CODEC_ID_GSM:
	43	+ case AV_CODEC_ID_GSM:
44	44	avctx->frame_size = GSM_FRAME_SIZE;
45	45	avctx->block_align = GSM_BLOCK_SIZE;
46	46	break;
47		− case CODEC_ID_GSM_MS:
	47	+ case AV_CODEC_ID_GSM_MS:
48	48	avctx->frame_size = 2 * GSM_FRAME_SIZE;
49	49	avctx->block_align = GSM_MS_BLOCK_SIZE;
50	50	}
@@ -79,7 +79,7 @@ static int gsm_decode_frame(AVCodecContext avctx, void data, · 28 unmodified lines
79	79	samples = (int16_t *)s->frame.data[0];
80	80
81	81	switch (avctx->codec_id) {
82		− case CODEC_ID_GSM:
	82	+ case AV_CODEC_ID_GSM:
83	83	init_get_bits(&gb, buf, buf_size * 8);
84	84	if (get_bits(&gb, 4) != 0xd)
85	85	av_log(avctx, AV_LOG_WARNING, "Missing GSM magic!\n");
@@ -87,7 +87,7 @@ static int gsm_decode_frame(AVCodecContext avctx, void data, · 1 unmodified line
87	87	if (res < 0)
88	88	return res;
89	89	break;
90		− case CODEC_ID_GSM_MS:
	90	+ case AV_CODEC_ID_GSM_MS:
91	91	res = ff_msgsm_decode_block(avctx, samples, buf);
92	92	if (res < 0)
93	93	return res;
@@ -108,7 +108,7 @@ static void gsm_flush(AVCodecContext *avctx) · 14 unmodified lines
108	108	AVCodec ff_gsm_decoder = {
109	109	.name = "gsm",
110	110	.type = AVMEDIA_TYPE_AUDIO,
111		− .id = CODEC_ID_GSM,
	111	+ .id = AV_CODEC_ID_GSM,
112	112	.priv_data_size = sizeof(GSMContext),
113	113	.init = gsm_init,
114	114	.decode = gsm_decode_frame,
@@ -120,7 +120,7 @@ AVCodec ff_gsm_decoder = { · 5 unmodified lines
120	120	AVCodec ff_gsm_ms_decoder = {
121	121	.name = "gsm_ms",
122	122	.type = AVMEDIA_TYPE_AUDIO,
123		− .id = CODEC_ID_GSM_MS,
	123	+ .id = AV_CODEC_ID_GSM_MS,
124	124	.priv_data_size = sizeof(GSMContext),
125	125	.init = gsm_init,
126	126	.decode = gsm_decode_frame,

libavcodec/h261_parser.c+1−1

@@ -82,7 +82,7 @@ static int h261_parse(AVCodecParserContext *s, · 81 unmodified lines
82	82	}
83	83
84	84	AVCodecParser ff_h261_parser = {
85		− .codec_ids = { CODEC_ID_H261 },
	85	+ .codec_ids = { AV_CODEC_ID_H261 },
86	86	.priv_data_size = sizeof(ParseContext),
87	87	.parser_parse = h261_parse,
88	88	.parser_close = ff_parse_close,

libavcodec/h261dec.c+1−1

@@ -645,7 +645,7 @@ static av_cold int h261_decode_end(AVCodecContext *avctx) · 644 unmodified lines
645	645	AVCodec ff_h261_decoder = {
646	646	.name = "h261",
647	647	.type = AVMEDIA_TYPE_VIDEO,
648		− .id = CODEC_ID_H261,
	648	+ .id = AV_CODEC_ID_H261,
649	649	.priv_data_size = sizeof(H261Context),
650	650	.init = h261_decode_init,
651	651	.close = h261_decode_end,

libavcodec/h261enc.c+1−1

@@ -326,7 +326,7 @@ FF_MPV_GENERIC_CLASS(h261) · 325 unmodified lines
326	326	AVCodec ff_h261_encoder = {
327	327	.name = "h261",
328	328	.type = AVMEDIA_TYPE_VIDEO,
329		− .id = CODEC_ID_H261,
	329	+ .id = AV_CODEC_ID_H261,
330	330	.priv_data_size = sizeof(H261Context),
331	331	.init = ff_MPV_encode_init,
332	332	.encode2 = ff_MPV_encode_picture,

libavcodec/h263_parser.c+1−1

@@ -84,7 +84,7 @@ static int h263_parse(AVCodecParserContext *s, · 83 unmodified lines
84	84	}
85	85
86	86	AVCodecParser ff_h263_parser = {
87		− .codec_ids = { CODEC_ID_H263 },
	87	+ .codec_ids = { AV_CODEC_ID_H263 },
88	88	.priv_data_size = sizeof(ParseContext),
89	89	.parser_parse = h263_parse,
90	90	.parser_close = ff_parse_close,

libavcodec/h263dec.c+25−25

@@ -63,43 +63,43 @@ av_cold int ff_h263_decode_init(AVCodecContext *avctx) · 62 unmodified lines
63	63
64	64	/* select sub codec */
65	65	switch(avctx->codec->id) {
66		− case CODEC_ID_H263:
	66	+ case AV_CODEC_ID_H263:
67	67	s->unrestricted_mv= 0;
68	68	avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
69	69	break;
70		− case CODEC_ID_MPEG4:
	70	+ case AV_CODEC_ID_MPEG4:
71	71	break;
72		− case CODEC_ID_MSMPEG4V1:
	72	+ case AV_CODEC_ID_MSMPEG4V1:
73	73	s->h263_pred = 1;
74	74	s->msmpeg4_version=1;
75	75	break;
76		− case CODEC_ID_MSMPEG4V2:
	76	+ case AV_CODEC_ID_MSMPEG4V2:
77	77	s->h263_pred = 1;
78	78	s->msmpeg4_version=2;
79	79	break;
80		− case CODEC_ID_MSMPEG4V3:
	80	+ case AV_CODEC_ID_MSMPEG4V3:
81	81	s->h263_pred = 1;
82	82	s->msmpeg4_version=3;
83	83	break;
84		− case CODEC_ID_WMV1:
	84	+ case AV_CODEC_ID_WMV1:
85	85	s->h263_pred = 1;
86	86	s->msmpeg4_version=4;
87	87	break;
88		− case CODEC_ID_WMV2:
	88	+ case AV_CODEC_ID_WMV2:
89	89	s->h263_pred = 1;
90	90	s->msmpeg4_version=5;
91	91	break;
92		− case CODEC_ID_VC1:
93		− case CODEC_ID_WMV3:
94		− case CODEC_ID_VC1IMAGE:
95		− case CODEC_ID_WMV3IMAGE:
	92	+ case AV_CODEC_ID_VC1:
	93	+ case AV_CODEC_ID_WMV3:
	94	+ case AV_CODEC_ID_VC1IMAGE:
	95	+ case AV_CODEC_ID_WMV3IMAGE:
96	96	s->h263_pred = 1;
97	97	s->msmpeg4_version=6;
98	98	avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
99	99	break;
100		− case CODEC_ID_H263I:
	100	+ case AV_CODEC_ID_H263I:
101	101	break;
102		− case CODEC_ID_FLV1:
	102	+ case AV_CODEC_ID_FLV1:
103	103	s->h263_flv = 1;
104	104	break;
105	105	default:
@@ -109,7 +109,7 @@ av_cold int ff_h263_decode_init(AVCodecContext *avctx) · 3 unmodified lines
109	109	avctx->hwaccel= ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
110	110
111	111	/* for h263, we allocate the images after having read the header */
112		− if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4)
	112	+ if (avctx->codec->id != AV_CODEC_ID_H263 && avctx->codec->id != AV_CODEC_ID_MPEG4)
113	113	if (ff_MPV_common_init(s) < 0)
114	114	return -1;
115	115
@@ -168,7 +168,7 @@ static int decode_slice(MpegEncContext *s){ · 52 unmodified lines
168	168	if(s->partitioned_frame){
169	169	const int qscale= s->qscale;
170	170
171		− if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){
	171	+ if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4){
172	172	if(ff_mpeg4_decode_partitions(s) < 0)
173	173	return -1;
174	174	}
@@ -260,7 +260,7 @@ static int decode_slice(MpegEncContext *s){ · 85 unmodified lines
260	260
261	261	assert(s->mb_x==0 && s->mb_y==s->mb_height);
262	262
263		− if(s->codec_id==CODEC_ID_MPEG4
	263	+ if(s->codec_id==AV_CODEC_ID_MPEG4
264	264	&& (s->workaround_bugs&FF_BUG_AUTODETECT)
265	265	&& get_bits_left(&s->gb) >= 48
266	266	&& show_bits(&s->gb, 24)==0x4010
@@ -268,7 +268,7 @@ static int decode_slice(MpegEncContext *s){ · 1 unmodified line
268	268	s->padding_bug_score+=32;
269	269
270	270	/* try to detect the padding bug */
271		− if( s->codec_id==CODEC_ID_MPEG4
	271	+ if( s->codec_id==AV_CODEC_ID_MPEG4
272	272	&& (s->workaround_bugs&FF_BUG_AUTODETECT)
273	273	&& get_bits_left(&s->gb) >=0
274	274	&& get_bits_left(&s->gb) < 48
@@ -367,9 +367,9 @@ uint64_t time= rdtsc(); · 92 unmodified lines
367	367	if(s->flags&CODEC_FLAG_TRUNCATED){
368	368	int next;
369	369
370		− if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){
	370	+ if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4){
371	371	next= ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);
372		− }else if(CONFIG_H263_DECODER && s->codec_id==CODEC_ID_H263){
	372	+ }else if(CONFIG_H263_DECODER && s->codec_id==AV_CODEC_ID_H263){
373	373	next= ff_h263_find_frame_end(&s->parse_context, buf, buf_size);
374	374	}else{
375	375	av_log(s->avctx, AV_LOG_ERROR, "this codec does not support truncated bitstreams\n");
@@ -416,7 +416,7 @@ retry: · 40 unmodified lines
416	416	ret = ff_mpeg4_decode_picture_header(s, &gb);
417	417	}
418	418	ret = ff_mpeg4_decode_picture_header(s, &s->gb);
419		− } else if (CONFIG_H263I_DECODER && s->codec_id == CODEC_ID_H263I) {
	419	+ } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) {
420	420	ret = ff_intel_h263_decode_picture_header(s);
421	421	} else if (CONFIG_FLV_DECODER && s->h263_flv) {
422	422	ret = ff_flv_decode_picture_header(s);
@@ -531,7 +531,7 @@ retry: · 108 unmodified lines
531	531	* Let us hope this at least works.
532	532	*/
533	533	if( s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==-1
534		− && s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)
	534	+ && s->codec_id==AV_CODEC_ID_MPEG4 && s->vo_type==0)
535	535	s->workaround_bugs\|= FF_BUG_NO_PADDING;
536	536
537	537	if(s->lavc_build<4609U) //FIXME not sure about the version num but a 4609 file seems ok
@@ -561,7 +561,7 @@ retry: · 23 unmodified lines
561	561	s->divx_packed ? "p" : "");
562	562
563	563	#if HAVE_MMX
564		− if (s->codec_id == CODEC_ID_MPEG4 && s->xvid_build>=0 && avctx->idct_algo == FF_IDCT_AUTO && (av_get_cpu_flags() & AV_CPU_FLAG_MMX)) {
	564	+ if (s->codec_id == AV_CODEC_ID_MPEG4 && s->xvid_build>=0 && avctx->idct_algo == FF_IDCT_AUTO && (av_get_cpu_flags() & AV_CPU_FLAG_MMX)) {
565	565	avctx->idct_algo= FF_IDCT_XVIDMMX;
566	566	ff_dct_common_init(s);
567	567	s->picture_number=0;
@@ -588,7 +588,7 @@ retry: · 20 unmodified lines
588	588	goto retry;
589	589	}
590	590
591		− if((s->codec_id==CODEC_ID_H263 \|\| s->codec_id==CODEC_ID_H263P \|\| s->codec_id == CODEC_ID_H263I))
	591	+ if((s->codec_id==AV_CODEC_ID_H263 \|\| s->codec_id==AV_CODEC_ID_H263P \|\| s->codec_id == AV_CODEC_ID_H263I))
592	592	s->gob_index = ff_h263_get_gob_height(s);
593	593
594	594	// for skipping the frame
@@ -676,7 +676,7 @@ retry: · 81 unmodified lines
676	676	assert(s->bitstream_buffer_size==0);
677	677	frame_end:
678	678	/* divx 5.01+ bistream reorder stuff */
679		− if(s->codec_id==CODEC_ID_MPEG4 && s->divx_packed){
	679	+ if(s->codec_id==AV_CODEC_ID_MPEG4 && s->divx_packed){
680	680	int current_pos= get_bits_count(&s->gb)>>3;
681	681	int startcode_found=0;
682	682
@@ -739,7 +739,7 @@ av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time); · 56 unmodified lines
739	739	AVCodec ff_h263_decoder = {
740	740	.name = "h263",
741	741	.type = AVMEDIA_TYPE_VIDEO,
742		− .id = CODEC_ID_H263,
	742	+ .id = AV_CODEC_ID_H263,
743	743	.priv_data_size = sizeof(MpegEncContext),
744	744	.init = ff_h263_decode_init,
745	745	.close = ff_h263_decode_end,

libavcodec/h264.c+5−5

@@ -1068,7 +1068,7 @@ av_cold int ff_h264_decode_init(AVCodecContext *avctx) · 1067 unmodified lines
1068	1068	h->prev_poc_msb = 1 << 16;
1069	1069	h->x264_build = -1;
1070	1070	ff_h264_reset_sei(h);
1071		− if (avctx->codec_id == CODEC_ID_H264) {
	1071	+ if (avctx->codec_id == AV_CODEC_ID_H264) {
1072	1072	if (avctx->ticks_per_frame == 1)
1073	1073	s->avctx->time_base.den *= 2;
1074	1074	avctx->ticks_per_frame = 2;
@@ -1290,7 +1290,7 @@ int ff_h264_frame_start(H264Context *h) · 215 unmodified lines
1290	1290	* SVQ3 as well as most other codecs have only last/next/current and thus
1291	1291	* get released even with set reference, besides SVQ3 and others do not
1292	1292	* mark frames as reference later "naturally". */
1293		− if (s->codec_id != CODEC_ID_SVQ3)
	1293	+ if (s->codec_id != AV_CODEC_ID_SVQ3)
1294	1294	s->current_picture_ptr->f.reference = 0;
1295	1295
1296	1296	s->current_picture_ptr->field_poc[0] =
@@ -3447,7 +3447,7 @@ static int decode_slice(struct AVCodecContext avctx, void arg) · 2150 unmodified lines
3447	3447	s->mb_skip_run = -1;
3448	3448
3449	3449	h->is_complex = FRAME_MBAFF \|\| s->picture_structure != PICT_FRAME \|\|
3450		− s->codec_id != CODEC_ID_H264 \|\|
	3450	+ s->codec_id != AV_CODEC_ID_H264 \|\|
3451	3451	(CONFIG_GRAY && (s->flags & CODEC_FLAG_GRAY));
3452	3452
3453	3453	if (h->pps.cabac) {
@@ -4090,7 +4090,7 @@ static const AVProfile profiles[] = { · 636 unmodified lines
4090	4090	AVCodec ff_h264_decoder = {
4091	4091	.name = "h264",
4092	4092	.type = AVMEDIA_TYPE_VIDEO,
4093		− .id = CODEC_ID_H264,
	4093	+ .id = AV_CODEC_ID_H264,
4094	4094	.priv_data_size = sizeof(H264Context),
4095	4095	.init = ff_h264_decode_init,
4096	4096	.close = h264_decode_end,
@@ -4109,7 +4109,7 @@ AVCodec ff_h264_decoder = { · 12 unmodified lines
4109	4109	AVCodec ff_h264_vdpau_decoder = {
4110	4110	.name = "h264_vdpau",
4111	4111	.type = AVMEDIA_TYPE_VIDEO,
4112		− .id = CODEC_ID_H264,
	4112	+ .id = AV_CODEC_ID_H264,
4113	4113	.priv_data_size = sizeof(H264Context),
4114	4114	.init = ff_h264_decode_init,
4115	4115	.close = h264_decode_end,

libavcodec/h264_mb_template.c+1−1

@@ -51,7 +51,7 @@ static av_noinline void FUNC(hl_decode_mb)(H264Context *h) · 50 unmodified lines
51	51	int *block_offset = &h->block_offset[0];
52	52	const int transform_bypass = !SIMPLE && (s->qscale == 0 && h->sps.transform_bypass);
53	53	/* is_h264 should always be true if SVQ3 is disabled. */
54		− const int is_h264 = !CONFIG_SVQ3_DECODER \|\| SIMPLE \|\| s->codec_id == CODEC_ID_H264;
	54	+ const int is_h264 = !CONFIG_SVQ3_DECODER \|\| SIMPLE \|\| s->codec_id == AV_CODEC_ID_H264;
55	55	void (idct_add)(uint8_t dst, DCTELEM *block, int stride);
56	56	const int block_h = 16 >> s->chroma_y_shift;
57	57	const int chroma422 = CHROMA422;

libavcodec/h264_parser.c+1−1

@@ -342,7 +342,7 @@ static int init(AVCodecParserContext *s) · 341 unmodified lines
342	342	}
343	343
344	344	AVCodecParser ff_h264_parser = {
345		− .codec_ids = { CODEC_ID_H264 },
	345	+ .codec_ids = { AV_CODEC_ID_H264 },
346	346	.priv_data_size = sizeof(H264Context),
347	347	.parser_init = init,
348	348	.parser_parse = h264_parse,

libavcodec/h264pred.c+11−11

@@ -371,8 +371,8 @@ void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, co · 370 unmodified lines
371	371	#define FUNCD(a) a ## _c
372	372
373	373	#define H264_PRED(depth) \
374		− if(codec_id != CODEC_ID_RV40){\
375		− if(codec_id == CODEC_ID_VP8) {\
	374	+ if(codec_id != AV_CODEC_ID_RV40){\
	375	+ if(codec_id == AV_CODEC_ID_VP8) {\
376	376	h->pred4x4[VERT_PRED ]= FUNCD(pred4x4_vertical_vp8);\
377	377	h->pred4x4[HOR_PRED ]= FUNCD(pred4x4_horizontal_vp8);\
378	378	} else {\
@@ -380,19 +380,19 @@ void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, co · 1 unmodified line
380	380	h->pred4x4[HOR_PRED ]= FUNCC(pred4x4_horizontal , depth);\
381	381	}\
382	382	h->pred4x4[DC_PRED ]= FUNCC(pred4x4_dc , depth);\
383		− if(codec_id == CODEC_ID_SVQ3)\
	383	+ if(codec_id == AV_CODEC_ID_SVQ3)\
384	384	h->pred4x4[DIAG_DOWN_LEFT_PRED ]= FUNCD(pred4x4_down_left_svq3);\
385	385	else\
386	386	h->pred4x4[DIAG_DOWN_LEFT_PRED ]= FUNCC(pred4x4_down_left , depth);\
387	387	h->pred4x4[DIAG_DOWN_RIGHT_PRED]= FUNCC(pred4x4_down_right , depth);\
388	388	h->pred4x4[VERT_RIGHT_PRED ]= FUNCC(pred4x4_vertical_right , depth);\
389	389	h->pred4x4[HOR_DOWN_PRED ]= FUNCC(pred4x4_horizontal_down , depth);\
390		− if (codec_id == CODEC_ID_VP8) {\
	390	+ if (codec_id == AV_CODEC_ID_VP8) {\
391	391	h->pred4x4[VERT_LEFT_PRED ]= FUNCD(pred4x4_vertical_left_vp8);\
392	392	} else\
393	393	h->pred4x4[VERT_LEFT_PRED ]= FUNCC(pred4x4_vertical_left , depth);\
394	394	h->pred4x4[HOR_UP_PRED ]= FUNCC(pred4x4_horizontal_up , depth);\
395		− if(codec_id != CODEC_ID_VP8) {\
	395	+ if(codec_id != AV_CODEC_ID_VP8) {\
396	396	h->pred4x4[LEFT_DC_PRED ]= FUNCC(pred4x4_left_dc , depth);\
397	397	h->pred4x4[TOP_DC_PRED ]= FUNCC(pred4x4_top_dc , depth);\
398	398	h->pred4x4[DC_128_PRED ]= FUNCC(pred4x4_128_dc , depth);\
@@ -441,7 +441,7 @@ void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, co · 42 unmodified lines
441	441	h->pred8x8[VERT_PRED8x8 ]= FUNCC(pred8x16_vertical , depth);\
442	442	h->pred8x8[HOR_PRED8x8 ]= FUNCC(pred8x16_horizontal , depth);\
443	443	}\
444		− if (codec_id != CODEC_ID_VP8) {\
	444	+ if (codec_id != AV_CODEC_ID_VP8) {\
445	445	if (chroma_format_idc == 1) {\
446	446	h->pred8x8[PLANE_PRED8x8]= FUNCC(pred8x8_plane , depth);\
447	447	} else {\
@@ -449,7 +449,7 @@ void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, co · 1 unmodified line
449	449	}\
450	450	} else\
451	451	h->pred8x8[PLANE_PRED8x8]= FUNCD(pred8x8_tm_vp8);\
452		− if(codec_id != CODEC_ID_RV40 && codec_id != CODEC_ID_VP8){\
	452	+ if(codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP8){\
453	453	if (chroma_format_idc == 1) {\
454	454	h->pred8x8[DC_PRED8x8 ]= FUNCC(pred8x8_dc , depth);\
455	455	h->pred8x8[LEFT_DC_PRED8x8]= FUNCC(pred8x8_left_dc , depth);\
@@ -471,7 +471,7 @@ void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, co · 15 unmodified lines
471	471	h->pred8x8[DC_PRED8x8 ]= FUNCD(pred8x8_dc_rv40);\
472	472	h->pred8x8[LEFT_DC_PRED8x8]= FUNCD(pred8x8_left_dc_rv40);\
473	473	h->pred8x8[TOP_DC_PRED8x8 ]= FUNCD(pred8x8_top_dc_rv40);\
474		− if (codec_id == CODEC_ID_VP8) {\
	474	+ if (codec_id == AV_CODEC_ID_VP8) {\
475	475	h->pred8x8[DC_127_PRED8x8]= FUNCC(pred8x8_127_dc , depth);\
476	476	h->pred8x8[DC_129_PRED8x8]= FUNCC(pred8x8_129_dc , depth);\
477	477	}\
@@ -486,13 +486,13 @@ void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, co · 8 unmodified lines
486	486	h->pred16x16[VERT_PRED8x8 ]= FUNCC(pred16x16_vertical , depth);\
487	487	h->pred16x16[HOR_PRED8x8 ]= FUNCC(pred16x16_horizontal , depth);\
488	488	switch(codec_id){\
489		− case CODEC_ID_SVQ3:\
	489	+ case AV_CODEC_ID_SVQ3:\
490	490	h->pred16x16[PLANE_PRED8x8 ]= FUNCD(pred16x16_plane_svq3);\
491	491	break;\
492		− case CODEC_ID_RV40:\
	492	+ case AV_CODEC_ID_RV40:\
493	493	h->pred16x16[PLANE_PRED8x8 ]= FUNCD(pred16x16_plane_rv40);\
494	494	break;\
495		− case CODEC_ID_VP8:\
	495	+ case AV_CODEC_ID_VP8:\
496	496	h->pred16x16[PLANE_PRED8x8 ]= FUNCD(pred16x16_tm_vp8);\
497	497	h->pred16x16[DC_127_PRED8x8]= FUNCC(pred16x16_127_dc , depth);\
498	498	h->pred16x16[DC_129_PRED8x8]= FUNCC(pred16x16_129_dc , depth);\

libavcodec/huffyuv.c+5−5

@@ -612,7 +612,7 @@ static av_cold int encode_init(AVCodecContext *avctx) · 611 unmodified lines
612	612	}
613	613	}else s->context= 0;
614	614
615		− if(avctx->codec->id==CODEC_ID_HUFFYUV){
	615	+ if(avctx->codec->id==AV_CODEC_ID_HUFFYUV){
616	616	if(avctx->pix_fmt==PIX_FMT_YUV420P){
617	617	av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
618	618	return -1;
@@ -1451,7 +1451,7 @@ static av_cold int encode_end(AVCodecContext *avctx) · 832 unmodified lines
1451	1451	AVCodec ff_huffyuv_decoder = {
1452	1452	.name = "huffyuv",
1453	1453	.type = AVMEDIA_TYPE_VIDEO,
1454		− .id = CODEC_ID_HUFFYUV,
	1454	+ .id = AV_CODEC_ID_HUFFYUV,
1455	1455	.priv_data_size = sizeof(HYuvContext),
1456	1456	.init = decode_init,
1457	1457	.close = decode_end,
@@ -1467,7 +1467,7 @@ AVCodec ff_huffyuv_decoder = { · 9 unmodified lines
1467	1467	AVCodec ff_ffvhuff_decoder = {
1468	1468	.name = "ffvhuff",
1469	1469	.type = AVMEDIA_TYPE_VIDEO,
1470		− .id = CODEC_ID_FFVHUFF,
	1470	+ .id = AV_CODEC_ID_FFVHUFF,
1471	1471	.priv_data_size = sizeof(HYuvContext),
1472	1472	.init = decode_init,
1473	1473	.close = decode_end,
@@ -1483,7 +1483,7 @@ AVCodec ff_ffvhuff_decoder = { · 9 unmodified lines
1483	1483	AVCodec ff_huffyuv_encoder = {
1484	1484	.name = "huffyuv",
1485	1485	.type = AVMEDIA_TYPE_VIDEO,
1486		− .id = CODEC_ID_HUFFYUV,
	1486	+ .id = AV_CODEC_ID_HUFFYUV,
1487	1487	.priv_data_size = sizeof(HYuvContext),
1488	1488	.init = encode_init,
1489	1489	.encode2 = encode_frame,
@@ -1499,7 +1499,7 @@ AVCodec ff_huffyuv_encoder = { · 9 unmodified lines
1499	1499	AVCodec ff_ffvhuff_encoder = {
1500	1500	.name = "ffvhuff",
1501	1501	.type = AVMEDIA_TYPE_VIDEO,
1502		− .id = CODEC_ID_FFVHUFF,
	1502	+ .id = AV_CODEC_ID_FFVHUFF,
1503	1503	.priv_data_size = sizeof(HYuvContext),
1504	1504	.init = encode_init,
1505	1505	.encode2 = encode_frame,

libavcodec/idcinvideo.c+1−1

@@ -256,7 +256,7 @@ static av_cold int idcin_decode_end(AVCodecContext *avctx) · 255 unmodified lines
256	256	AVCodec ff_idcin_decoder = {
257	257	.name = "idcinvideo",
258	258	.type = AVMEDIA_TYPE_VIDEO,
259		− .id = CODEC_ID_IDCIN,
	259	+ .id = AV_CODEC_ID_IDCIN,
260	260	.priv_data_size = sizeof(IdcinContext),
261	261	.init = idcin_decode_init,
262	262	.close = idcin_decode_end,

libavcodec/iff.c+2−2

@@ -370,7 +370,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 369 unmodified lines
370	370	AVCodec ff_iff_ilbm_decoder = {
371	371	.name = "iff_ilbm",
372	372	.type = AVMEDIA_TYPE_VIDEO,
373		− .id = CODEC_ID_IFF_ILBM,
	373	+ .id = AV_CODEC_ID_IFF_ILBM,
374	374	.priv_data_size = sizeof(IffContext),
375	375	.init = decode_init,
376	376	.close = decode_end,
@@ -382,7 +382,7 @@ AVCodec ff_iff_ilbm_decoder = { · 5 unmodified lines
382	382	AVCodec ff_iff_byterun1_decoder = {
383	383	.name = "iff_byterun1",
384	384	.type = AVMEDIA_TYPE_VIDEO,
385		− .id = CODEC_ID_IFF_BYTERUN1,
	385	+ .id = AV_CODEC_ID_IFF_BYTERUN1,
386	386	.priv_data_size = sizeof(IffContext),
387	387	.init = decode_init,
388	388	.close = decode_end,

libavcodec/imc.c+6−6

@@ -175,8 +175,8 @@ static av_cold int imc_decode_init(AVCodecContext *avctx) · 174 unmodified lines
175	175	IMCContext *q = avctx->priv_data;
176	176	double r1, r2;
177	177
178		− if ((avctx->codec_id == CODEC_ID_IMC && avctx->channels != 1)
179		− \|\| (avctx->codec_id == CODEC_ID_IAC && avctx->channels > 2)) {
	178	+ if ((avctx->codec_id == AV_CODEC_ID_IMC && avctx->channels != 1)
	179	+ \|\| (avctx->codec_id == AV_CODEC_ID_IAC && avctx->channels > 2)) {
180	180	av_log_ask_for_sample(avctx, "Number of channels is not supported\n");
181	181	return AVERROR_PATCHWELCOME;
182	182	}
@@ -227,7 +227,7 @@ static av_cold int imc_decode_init(AVCodecContext *avctx) · 44 unmodified lines
227	227	}
228	228	}
229	229
230		− if (avctx->codec_id == CODEC_ID_IAC) {
	230	+ if (avctx->codec_id == AV_CODEC_ID_IAC) {
231	231	iac_generate_tabs(q, avctx->sample_rate);
232	232	} else {
233	233	memcpy(q->cyclTab, cyclTab, sizeof(cyclTab));
@@ -841,7 +841,7 @@ static int imc_decode_block(AVCodecContext avctx, IMCContext q, int ch) · 607 unmodified lines
841	841	}
842	842	}
843	843	}
844		− if (avctx->codec_id == CODEC_ID_IAC) {
	844	+ if (avctx->codec_id == AV_CODEC_ID_IAC) {
845	845	bitscount += !!chctx->bandWidthT[BANDS - 1];
846	846	if (!(stream_format_code & 0x2))
847	847	bitscount += 16;
@@ -990,7 +990,7 @@ static av_cold int imc_decode_close(AVCodecContext * avctx) · 142 unmodified lines
990	990	AVCodec ff_imc_decoder = {
991	991	.name = "imc",
992	992	.type = AVMEDIA_TYPE_AUDIO,
993		− .id = CODEC_ID_IMC,
	993	+ .id = AV_CODEC_ID_IMC,
994	994	.priv_data_size = sizeof(IMCContext),
995	995	.init = imc_decode_init,
996	996	.close = imc_decode_close,
@@ -1002,7 +1002,7 @@ AVCodec ff_imc_decoder = { · 5 unmodified lines
1002	1002	AVCodec ff_iac_decoder = {
1003	1003	.name = "iac",
1004	1004	.type = AVMEDIA_TYPE_AUDIO,
1005		− .id = CODEC_ID_IAC,
	1005	+ .id = AV_CODEC_ID_IAC,
1006	1006	.priv_data_size = sizeof(IMCContext),
1007	1007	.init = imc_decode_init,
1008	1008	.close = imc_decode_close,

libavcodec/imx_dump_header_bsf.c+1−1

@@ -37,7 +37,7 @@ static int imx_dump_header(AVBitStreamFilterContext bsfc, AVCodecContext avctx · 36 unmodified lines
37	37	static const uint8_t imx_header[16] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01,0x05,0x01,0x01,0x00 };
38	38	uint8_t *poutbufp;
39	39
40		− if (avctx->codec_id != CODEC_ID_MPEG2VIDEO) {
	40	+ if (avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
41	41	av_log(avctx, AV_LOG_ERROR, "imx bitstream filter only applies to mpeg2video codec\n");
42	42	return 0;
43	43	}

libavcodec/indeo2.c+1−1

@@ -233,7 +233,7 @@ static av_cold int ir2_decode_end(AVCodecContext *avctx){ · 232 unmodified lines
233	233	AVCodec ff_indeo2_decoder = {
234	234	.name = "indeo2",
235	235	.type = AVMEDIA_TYPE_VIDEO,
236		− .id = CODEC_ID_INDEO2,
	236	+ .id = AV_CODEC_ID_INDEO2,
237	237	.priv_data_size = sizeof(Ir2Context),
238	238	.init = ir2_decode_init,
239	239	.close = ir2_decode_end,

libavcodec/indeo3.c+1−1

@@ -1095,7 +1095,7 @@ static av_cold int decode_close(AVCodecContext *avctx) · 1094 unmodified lines
1095	1095	AVCodec ff_indeo3_decoder = {
1096	1096	.name = "indeo3",
1097	1097	.type = AVMEDIA_TYPE_VIDEO,
1098		− .id = CODEC_ID_INDEO3,
	1098	+ .id = AV_CODEC_ID_INDEO3,
1099	1099	.priv_data_size = sizeof(Indeo3DecodeContext),
1100	1100	.init = decode_init,
1101	1101	.close = decode_close,

libavcodec/indeo4.c+1−1

@@ -601,7 +601,7 @@ static av_cold int decode_init(AVCodecContext *avctx) · 600 unmodified lines
601	601	AVCodec ff_indeo4_decoder = {
602	602	.name = "indeo4",
603	603	.type = AVMEDIA_TYPE_VIDEO,
604		− .id = CODEC_ID_INDEO4,
	604	+ .id = AV_CODEC_ID_INDEO4,
605	605	.priv_data_size = sizeof(IVI45DecContext),
606	606	.init = decode_init,
607	607	.close = ff_ivi_decode_close,

libavcodec/indeo5.c+1−1

@@ -626,7 +626,7 @@ static av_cold int decode_init(AVCodecContext *avctx) · 625 unmodified lines
626	626	AVCodec ff_indeo5_decoder = {
627	627	.name = "indeo5",
628	628	.type = AVMEDIA_TYPE_VIDEO,
629		− .id = CODEC_ID_INDEO5,
	629	+ .id = AV_CODEC_ID_INDEO5,
630	630	.priv_data_size = sizeof(IVI45DecContext),
631	631	.init = decode_init,
632	632	.close = ff_ivi_decode_close,

libavcodec/intelh263dec.c+1−1

@@ -127,7 +127,7 @@ int ff_intel_h263_decode_picture_header(MpegEncContext *s) · 126 unmodified lines
127	127	AVCodec ff_h263i_decoder = {
128	128	.name = "h263i",
129	129	.type = AVMEDIA_TYPE_VIDEO,
130		− .id = CODEC_ID_H263I,
	130	+ .id = AV_CODEC_ID_H263I,
131	131	.priv_data_size = sizeof(MpegEncContext),
132	132	.init = ff_h263_decode_init,
133	133	.close = ff_h263_decode_end,

libavcodec/internal.h+1−1

@@ -96,7 +96,7 @@ int ff_is_hwaccel_pix_fmt(enum PixelFormat pix_fmt); · 95 unmodified lines
96	96	* @param pix_fmt the pixel format to match
97	97	* @return the hardware accelerated codec, or NULL if none was found.
98	98	*/
99		−AVHWAccel *ff_find_hwaccel(enum CodecID codec_id, enum PixelFormat pix_fmt);
	99	+AVHWAccel *ff_find_hwaccel(enum AVCodecID codec_id, enum PixelFormat pix_fmt);
100	100
101	101	/**
102	102	* Return the index into tab at which {a,b} match elements {[0],[1]} of tab.

libavcodec/interplayvideo.c+1−1

@@ -1017,7 +1017,7 @@ static av_cold int ipvideo_decode_end(AVCodecContext *avctx) · 1016 unmodified lines
1017	1017	AVCodec ff_interplay_video_decoder = {
1018	1018	.name = "interplayvideo",
1019	1019	.type = AVMEDIA_TYPE_VIDEO,
1020		− .id = CODEC_ID_INTERPLAY_VIDEO,
	1020	+ .id = AV_CODEC_ID_INTERPLAY_VIDEO,
1021	1021	.priv_data_size = sizeof(IpvideoContext),
1022	1022	.init = ipvideo_decode_init,
1023	1023	.close = ipvideo_decode_end,

libavcodec/ituh263dec.c+5−5

@@ -230,14 +230,14 @@ const uint8_t ff_h263_find_resync_marker(const uint8_t restrict p, const uint8 · 229 unmodified lines
230	230	int ff_h263_resync(MpegEncContext *s){
231	231	int left, pos, ret;
232	232
233		− if(s->codec_id==CODEC_ID_MPEG4){
	233	+ if(s->codec_id==AV_CODEC_ID_MPEG4){
234	234	skip_bits1(&s->gb);
235	235	align_get_bits(&s->gb);
236	236	}
237	237
238	238	if(show_bits(&s->gb, 16)==0){
239	239	pos= get_bits_count(&s->gb);
240		− if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4)
	240	+ if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)
241	241	ret= ff_mpeg4_decode_video_packet_header(s);
242	242	else
243	243	ret= h263_decode_gob_header(s);
@@ -254,7 +254,7 @@ int ff_h263_resync(MpegEncContext *s){ · 10 unmodified lines
254	254	GetBitContext bak= s->gb;
255	255
256	256	pos= get_bits_count(&s->gb);
257		− if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4)
	257	+ if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)
258	258	ret= ff_mpeg4_decode_video_packet_header(s);
259	259	else
260	260	ret= h263_decode_gob_header(s);
@@ -458,7 +458,7 @@ static int h263_decode_block(MpegEncContext * s, DCTELEM * block, · 197 unmodified lines
458	458	}
459	459	} else if (s->mb_intra) {
460	460	/* DC coef */
461		− if(s->codec_id == CODEC_ID_RV10){
	461	+ if(s->codec_id == AV_CODEC_ID_RV10){
462	462	#if CONFIG_RV10_DECODER
463	463	if (s->rv10_version == 3 && s->pict_type == AV_PICTURE_TYPE_I) {
464	464	int component, diff;
@@ -517,7 +517,7 @@ retry: · 52 unmodified lines
517	517	run = get_bits(&s->gb, 6);
518	518	level = (int8_t)get_bits(&s->gb, 8);
519	519	if(level == -128){
520		− if (s->codec_id == CODEC_ID_RV10) {
	520	+ if (s->codec_id == AV_CODEC_ID_RV10) {
521	521	/* XXX: should patch encoder too */
522	522	level = get_sbits(&s->gb, 12);
523	523	}else{

libavcodec/ituh263enc.c+4−4

@@ -288,7 +288,7 @@ void ff_clean_h263_qscales(MpegEncContext *s){ · 287 unmodified lines
288	288	qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
289	289	}
290	290
291		− if(s->codec_id != CODEC_ID_H263P){
	291	+ if(s->codec_id != AV_CODEC_ID_H263P){
292	292	for(i=1; i<s->mb_num; i++){
293	293	int mb_xy= s->mb_index2xy[i];
294	294
@@ -795,10 +795,10 @@ void ff_h263_encode_init(MpegEncContext *s) · 500 unmodified lines
795	795
796	796	// use fcodes >1 only for mpeg4 & h263 & h263p FIXME
797	797	switch(s->codec_id){
798		− case CODEC_ID_MPEG4:
	798	+ case AV_CODEC_ID_MPEG4:
799	799	s->fcode_tab= fcode_tab;
800	800	break;
801		− case CODEC_ID_H263P:
	801	+ case AV_CODEC_ID_H263P:
802	802	if(s->umvplus)
803	803	s->fcode_tab= umv_fcode_tab;
804	804	if(s->modified_quant){
@@ -810,7 +810,7 @@ void ff_h263_encode_init(MpegEncContext *s) · 5 unmodified lines
810	810	}
811	811	break;
812	812	//Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
813		− case CODEC_ID_FLV1:
	813	+ case AV_CODEC_ID_FLV1:
814	814	if (s->h263_flv > 1) {
815	815	s->min_qcoeff= -1023;
816	816	s->max_qcoeff= 1023;

libavcodec/ivi_common.c+3−3

@@ -767,7 +767,7 @@ int ff_ivi_decode_frame(AVCodecContext avctx, void data, int *data_size, · 766 unmodified lines
767	767	/* If the bidirectional mode is enabled, next I and the following P frame will */
768	768	/* be sent together. Unfortunately the approach below seems to be the only way */
769	769	/* to handle the B-frames mode. That's exactly the same Intel decoders do. */
770		− if (avctx->codec_id == CODEC_ID_INDEO4 && ctx->frame_type == 0/FRAMETYPE_INTRA/) {
	770	+ if (avctx->codec_id == AV_CODEC_ID_INDEO4 && ctx->frame_type == 0/FRAMETYPE_INTRA/) {
771	771	while (get_bits(&ctx->gb, 8)); // skip version string
772	772	skip_bits_long(&ctx->gb, 64); // skip padding, TODO: implement correct 8-bytes alignment
773	773	if (get_bits_left(&ctx->gb) > 18 && show_bits(&ctx->gb, 18) == 0x3FFF8)
@@ -784,7 +784,7 @@ int ff_ivi_decode_frame(AVCodecContext avctx, void data, int *data_size, · 10 unmodified lines
784	784	}
785	785
786	786	if (ctx->is_scalable) {
787		− if (avctx->codec_id == CODEC_ID_INDEO4)
	787	+ if (avctx->codec_id == AV_CODEC_ID_INDEO4)
788	788	ff_ivi_recompose_haar(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0], 4);
789	789	else
790	790	ff_ivi_recompose53 (&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0], 4);
@@ -817,7 +817,7 @@ av_cold int ff_ivi_decode_close(AVCodecContext *avctx) · 26 unmodified lines
817	817	avctx->release_buffer(avctx, &ctx->frame);
818	818
819	819	#if IVI4_STREAM_ANALYSER
820		− if (avctx->codec_id == CODEC_ID_INDEO4) {
	820	+ if (avctx->codec_id == AV_CODEC_ID_INDEO4) {
821	821	if (ctx->is_scalable)
822	822	av_log(avctx, AV_LOG_ERROR, "This video uses scalability mode!\n");
823	823	if (ctx->uses_tiling)

libavcodec/jpeglsdec.c+1−1

@@ -365,7 +365,7 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor · 364 unmodified lines
365	365	AVCodec ff_jpegls_decoder = {
366	366	.name = "jpegls",
367	367	.type = AVMEDIA_TYPE_VIDEO,
368		− .id = CODEC_ID_JPEGLS,
	368	+ .id = AV_CODEC_ID_JPEGLS,
369	369	.priv_data_size = sizeof(MJpegDecodeContext),
370	370	.init = ff_mjpeg_decode_init,
371	371	.close = ff_mjpeg_decode_end,

libavcodec/jpeglsenc.c+1−1

@@ -395,7 +395,7 @@ static av_cold int encode_init_ls(AVCodecContext *ctx) { · 394 unmodified lines
395	395	AVCodec ff_jpegls_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
396	396	.name = "jpegls",
397	397	.type = AVMEDIA_TYPE_VIDEO,
398		− .id = CODEC_ID_JPEGLS,
	398	+ .id = AV_CODEC_ID_JPEGLS,
399	399	.priv_data_size = sizeof(JpeglsContext),
400	400	.init = encode_init_ls,
401	401	.encode2 = encode_picture_ls,

libavcodec/jvdec.c+1−1

@@ -206,7 +206,7 @@ AVCodec ff_jv_decoder = { · 205 unmodified lines
206	206	.name = "jv",
207	207	.long_name = NULL_IF_CONFIG_SMALL("Bitmap Brothers JV video"),
208	208	.type = AVMEDIA_TYPE_VIDEO,
209		− .id = CODEC_ID_JV,
	209	+ .id = AV_CODEC_ID_JV,
210	210	.priv_data_size = sizeof(JvContext),
211	211	.init = decode_init,
212	212	.close = decode_close,

libavcodec/kgv1dec.c+1−1

@@ -183,7 +183,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 182 unmodified lines
183	183	AVCodec ff_kgv1_decoder = {
184	184	.name = "kgv1",
185	185	.type = AVMEDIA_TYPE_VIDEO,
186		− .id = CODEC_ID_KGV1,
	186	+ .id = AV_CODEC_ID_KGV1,
187	187	.priv_data_size = sizeof(KgvContext),
188	188	.init = decode_init,
189	189	.close = decode_end,

libavcodec/kmvc.c+1−1

@@ -422,7 +422,7 @@ static av_cold int decode_end(AVCodecContext * avctx) · 421 unmodified lines
422	422	AVCodec ff_kmvc_decoder = {
423	423	.name = "kmvc",
424	424	.type = AVMEDIA_TYPE_VIDEO,
425		− .id = CODEC_ID_KMVC,
	425	+ .id = AV_CODEC_ID_KMVC,
426	426	.priv_data_size = sizeof(KmvcContext),
427	427	.init = decode_init,
428	428	.close = decode_end,

libavcodec/lagarith.c+1−1

@@ -687,7 +687,7 @@ static av_cold int lag_decode_end(AVCodecContext *avctx) · 686 unmodified lines
687	687	AVCodec ff_lagarith_decoder = {
688	688	.name = "lagarith",
689	689	.type = AVMEDIA_TYPE_VIDEO,
690		− .id = CODEC_ID_LAGARITH,
	690	+ .id = AV_CODEC_ID_LAGARITH,
691	691	.priv_data_size = sizeof(LagarithContext),
692	692	.init = lag_decode_init,
693	693	.close = lag_decode_end,

libavcodec/latm_parser.c+1−1

@@ -106,7 +106,7 @@ static int latm_parse(AVCodecParserContext s1, AVCodecContext avctx, · 105 unmodified lines
106	106	}
107	107
108	108	AVCodecParser ff_aac_latm_parser = {
109		− .codec_ids = { CODEC_ID_AAC_LATM },
	109	+ .codec_ids = { AV_CODEC_ID_AAC_LATM },
110	110	.priv_data_size = sizeof(LATMParseContext),
111	111	.parser_parse = latm_parse,
112	112	.parser_close = ff_parse_close

libavcodec/lcldec.c+12−12

@@ -189,7 +189,7 @@ static int decode_frame(AVCodecContext avctx, void data, int *data_size, AVPac · 188 unmodified lines
189	189
190	190	/* Decompress frame */
191	191	switch (avctx->codec_id) {
192		− case CODEC_ID_MSZH:
	192	+ case AV_CODEC_ID_MSZH:
193	193	switch (c->compression) {
194	194	case COMP_MSZH:
195	195	if (c->flags & FLAG_MULTITHREAD) {
@@ -252,7 +252,7 @@ static int decode_frame(AVCodecContext avctx, void data, int *data_size, AVPac · 56 unmodified lines
252	252	}
253	253	break;
254	254	#if CONFIG_ZLIB_DECODER
255		− case CODEC_ID_ZLIB:
	255	+ case AV_CODEC_ID_ZLIB:
256	256	/* Using the original dll with normal compression (-1) and RGB format
257	257	* gives a file with ZLIB fourcc, but frame is really uncompressed.
258	258	* To be sure that's true check also frame size */
@@ -290,7 +290,7 @@ static int decode_frame(AVCodecContext avctx, void data, int *data_size, AVPac · 31 unmodified lines
290	290
291	291
292	292	/* Apply PNG filter */
293		− if (avctx->codec_id == CODEC_ID_ZLIB && (c->flags & FLAG_PNGFILTER)) {
	293	+ if (avctx->codec_id == AV_CODEC_ID_ZLIB && (c->flags & FLAG_PNGFILTER)) {
294	294	switch (c->imgtype) {
295	295	case IMGTYPE_YUV111:
296	296	case IMGTYPE_RGB24:
@@ -485,8 +485,8 @@ static av_cold int decode_init(AVCodecContext *avctx) · 188 unmodified lines
485	485	}
486	486
487	487	/* Check codec type */
488		− if ((avctx->codec_id == CODEC_ID_MSZH && avctx->extradata[7] != CODEC_MSZH) \|\|
489		− (avctx->codec_id == CODEC_ID_ZLIB && avctx->extradata[7] != CODEC_ZLIB)) {
	488	+ if ((avctx->codec_id == AV_CODEC_ID_MSZH && avctx->extradata[7] != CODEC_MSZH) \|\|
	489	+ (avctx->codec_id == AV_CODEC_ID_ZLIB && avctx->extradata[7] != CODEC_ZLIB)) {
490	490	av_log(avctx, AV_LOG_ERROR, "Codec id and codec type mismatch. This should not happen.\n");
491	491	}
492	492
@@ -536,7 +536,7 @@ static av_cold int decode_init(AVCodecContext *avctx) · 43 unmodified lines
536	536	/* Detect compression method */
537	537	c->compression = (int8_t)avctx->extradata[5];
538	538	switch (avctx->codec_id) {
539		− case CODEC_ID_MSZH:
	539	+ case AV_CODEC_ID_MSZH:
540	540	switch (c->compression) {
541	541	case COMP_MSZH:
542	542	av_log(avctx, AV_LOG_DEBUG, "Compression enabled.\n");
@@ -551,7 +551,7 @@ static av_cold int decode_init(AVCodecContext *avctx) · 8 unmodified lines
551	551	}
552	552	break;
553	553	#if CONFIG_ZLIB_DECODER
554		− case CODEC_ID_ZLIB:
	554	+ case AV_CODEC_ID_ZLIB:
555	555	switch (c->compression) {
556	556	case COMP_ZLIB_HISPEED:
557	557	av_log(avctx, AV_LOG_DEBUG, "High speed compression.\n");
@@ -590,14 +590,14 @@ static av_cold int decode_init(AVCodecContext *avctx) · 32 unmodified lines
590	590	av_log(avctx, AV_LOG_DEBUG, "Multithread encoder flag set.\n");
591	591	if (c->flags & FLAG_NULLFRAME)
592	592	av_log(avctx, AV_LOG_DEBUG, "Nullframe insertion flag set.\n");
593		− if (avctx->codec_id == CODEC_ID_ZLIB && (c->flags & FLAG_PNGFILTER))
	593	+ if (avctx->codec_id == AV_CODEC_ID_ZLIB && (c->flags & FLAG_PNGFILTER))
594	594	av_log(avctx, AV_LOG_DEBUG, "PNG filter flag set.\n");
595	595	if (c->flags & FLAGMASK_UNUSED)
596	596	av_log(avctx, AV_LOG_ERROR, "Unknown flag set (%d).\n", c->flags);
597	597
598	598	/* If needed init zlib */
599	599	#if CONFIG_ZLIB_DECODER
600		− if (avctx->codec_id == CODEC_ID_ZLIB) {
	600	+ if (avctx->codec_id == AV_CODEC_ID_ZLIB) {
601	601	int zret;
602	602	c->zstream.zalloc = Z_NULL;
603	603	c->zstream.zfree = Z_NULL;
@@ -627,7 +627,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 23 unmodified lines
627	627	if (c->pic.data[0])
628	628	avctx->release_buffer(avctx, &c->pic);
629	629	#if CONFIG_ZLIB_DECODER
630		− if (avctx->codec_id == CODEC_ID_ZLIB)
	630	+ if (avctx->codec_id == AV_CODEC_ID_ZLIB)
631	631	inflateEnd(&c->zstream);
632	632	#endif
633	633
@@ -638,7 +638,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 4 unmodified lines
638	638	AVCodec ff_mszh_decoder = {
639	639	.name = "mszh",
640	640	.type = AVMEDIA_TYPE_VIDEO,
641		− .id = CODEC_ID_MSZH,
	641	+ .id = AV_CODEC_ID_MSZH,
642	642	.priv_data_size = sizeof(LclDecContext),
643	643	.init = decode_init,
644	644	.close = decode_end,
@@ -652,7 +652,7 @@ AVCodec ff_mszh_decoder = { · 7 unmodified lines
652	652	AVCodec ff_zlib_decoder = {
653	653	.name = "zlib",
654	654	.type = AVMEDIA_TYPE_VIDEO,
655		− .id = CODEC_ID_ZLIB,
	655	+ .id = AV_CODEC_ID_ZLIB,
656	656	.priv_data_size = sizeof(LclDecContext),
657	657	.init = decode_init,
658	658	.close = decode_end,

libavcodec/lclenc.c+1−1

@@ -185,7 +185,7 @@ static av_cold int encode_end(AVCodecContext *avctx) · 184 unmodified lines
185	185	AVCodec ff_zlib_encoder = {
186	186	.name = "zlib",
187	187	.type = AVMEDIA_TYPE_VIDEO,
188		− .id = CODEC_ID_ZLIB,
	188	+ .id = AV_CODEC_ID_ZLIB,
189	189	.priv_data_size = sizeof(LclEncContext),
190	190	.init = encode_init,
191	191	.encode2 = encode_frame,

libavcodec/libfaac.c+1−1

@@ -238,7 +238,7 @@ static const uint64_t faac_channel_layouts[] = { · 237 unmodified lines
238	238	AVCodec ff_libfaac_encoder = {
239	239	.name = "libfaac",
240	240	.type = AVMEDIA_TYPE_AUDIO,
241		− .id = CODEC_ID_AAC,
	241	+ .id = AV_CODEC_ID_AAC,
242	242	.priv_data_size = sizeof(FaacAudioContext),
243	243	.init = Faac_encode_init,
244	244	.encode2 = Faac_encode_frame,

libavcodec/libfdk-aacenc.c+1−1

@@ -395,7 +395,7 @@ static const uint64_t aac_channel_layout[] = { · 394 unmodified lines
395	395	AVCodec ff_libfdk_aac_encoder = {
396	396	.name = "libfdk_aac",
397	397	.type = AVMEDIA_TYPE_AUDIO,
398		− .id = CODEC_ID_AAC,
	398	+ .id = AV_CODEC_ID_AAC,
399	399	.priv_data_size = sizeof(AACContext),
400	400	.init = aac_encode_init,
401	401	.encode2 = aac_encode_frame,

libavcodec/libgsm.c+11−11

@@ -58,11 +58,11 @@ static av_cold int libgsm_encode_init(AVCodecContext *avctx) { · 57 unmodified lines
58	58	avctx->priv_data = gsm_create();
59	59
60	60	switch(avctx->codec_id) {
61		− case CODEC_ID_GSM:
	61	+ case AV_CODEC_ID_GSM:
62	62	avctx->frame_size = GSM_FRAME_SIZE;
63	63	avctx->block_align = GSM_BLOCK_SIZE;
64	64	break;
65		− case CODEC_ID_GSM_MS: {
	65	+ case AV_CODEC_ID_GSM_MS: {
66	66	int one = 1;
67	67	gsm_option(avctx->priv_data, GSM_OPT_WAV49, &one);
68	68	avctx->frame_size = 2*GSM_FRAME_SIZE;
@@ -103,10 +103,10 @@ static int libgsm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 34 unmodified lines
103	103	}
104	104
105	105	switch(avctx->codec_id) {
106		− case CODEC_ID_GSM:
	106	+ case AV_CODEC_ID_GSM:
107	107	gsm_encode(state, samples, avpkt->data);
108	108	break;
109		− case CODEC_ID_GSM_MS:
	109	+ case AV_CODEC_ID_GSM_MS:
110	110	gsm_encode(state, samples, avpkt->data);
111	111	gsm_encode(state, samples + GSM_FRAME_SIZE, avpkt->data + 32);
112	112	}
@@ -119,7 +119,7 @@ static int libgsm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 6 unmodified lines
119	119	AVCodec ff_libgsm_encoder = {
120	120	.name = "libgsm",
121	121	.type = AVMEDIA_TYPE_AUDIO,
122		− .id = CODEC_ID_GSM,
	122	+ .id = AV_CODEC_ID_GSM,
123	123	.init = libgsm_encode_init,
124	124	.encode2 = libgsm_encode_frame,
125	125	.close = libgsm_encode_close,
@@ -131,7 +131,7 @@ AVCodec ff_libgsm_encoder = { · 5 unmodified lines
131	131	AVCodec ff_libgsm_ms_encoder = {
132	132	.name = "libgsm_ms",
133	133	.type = AVMEDIA_TYPE_AUDIO,
134		− .id = CODEC_ID_GSM_MS,
	134	+ .id = AV_CODEC_ID_GSM_MS,
135	135	.init = libgsm_encode_init,
136	136	.encode2 = libgsm_encode_frame,
137	137	.close = libgsm_encode_close,
@@ -165,11 +165,11 @@ static av_cold int libgsm_decode_init(AVCodecContext *avctx) { · 27 unmodified lines
165	165	s->state = gsm_create();
166	166
167	167	switch(avctx->codec_id) {
168		− case CODEC_ID_GSM:
	168	+ case AV_CODEC_ID_GSM:
169	169	avctx->frame_size = GSM_FRAME_SIZE;
170	170	avctx->block_align = GSM_BLOCK_SIZE;
171	171	break;
172		− case CODEC_ID_GSM_MS: {
	172	+ case AV_CODEC_ID_GSM_MS: {
173	173	int one = 1;
174	174	gsm_option(s->state, GSM_OPT_WAV49, &one);
175	175	avctx->frame_size = 2 * GSM_FRAME_SIZE;
@@ -232,14 +232,14 @@ static void libgsm_flush(AVCodecContext *avctx) { · 56 unmodified lines
232	232
233	233	gsm_destroy(s->state);
234	234	s->state = gsm_create();
235		− if (avctx->codec_id == CODEC_ID_GSM_MS)
	235	+ if (avctx->codec_id == AV_CODEC_ID_GSM_MS)
236	236	gsm_option(s->state, GSM_OPT_WAV49, &one);
237	237	}
238	238
239	239	AVCodec ff_libgsm_decoder = {
240	240	.name = "libgsm",
241	241	.type = AVMEDIA_TYPE_AUDIO,
242		− .id = CODEC_ID_GSM,
	242	+ .id = AV_CODEC_ID_GSM,
243	243	.priv_data_size = sizeof(LibGSMDecodeContext),
244	244	.init = libgsm_decode_init,
245	245	.close = libgsm_decode_close,
@@ -252,7 +252,7 @@ AVCodec ff_libgsm_decoder = { · 6 unmodified lines
252	252	AVCodec ff_libgsm_ms_decoder = {
253	253	.name = "libgsm_ms",
254	254	.type = AVMEDIA_TYPE_AUDIO,
255		− .id = CODEC_ID_GSM_MS,
	255	+ .id = AV_CODEC_ID_GSM_MS,
256	256	.priv_data_size = sizeof(LibGSMDecodeContext),
257	257	.init = libgsm_decode_init,
258	258	.close = libgsm_decode_close,

libavcodec/libilbc.c+2−2

@@ -106,7 +106,7 @@ static int ilbc_decode_frame(AVCodecContext avctx, void data, · 105 unmodified lines
106	106	AVCodec ff_libilbc_decoder = {
107	107	.name = "libilbc",
108	108	.type = AVMEDIA_TYPE_AUDIO,
109		− .id = CODEC_ID_ILBC,
	109	+ .id = AV_CODEC_ID_ILBC,
110	110	.priv_data_size = sizeof(ILBCDecContext),
111	111	.init = ilbc_decode_init,
112	112	.decode = ilbc_decode_frame,
@@ -196,7 +196,7 @@ static const AVCodecDefault ilbc_encode_defaults[] = { · 83 unmodified lines
196	196	AVCodec ff_libilbc_encoder = {
197	197	.name = "libilbc",
198	198	.type = AVMEDIA_TYPE_AUDIO,
199		− .id = CODEC_ID_ILBC,
	199	+ .id = AV_CODEC_ID_ILBC,
200	200	.priv_data_size = sizeof(ILBCEncContext),
201	201	.init = ilbc_encode_init,
202	202	.encode2 = ilbc_encode_frame,

libavcodec/libmp3lame.c+1−1

@@ -293,7 +293,7 @@ static const int libmp3lame_sample_rates[] = { · 292 unmodified lines
293	293	AVCodec ff_libmp3lame_encoder = {
294	294	.name = "libmp3lame",
295	295	.type = AVMEDIA_TYPE_AUDIO,
296		− .id = CODEC_ID_MP3,
	296	+ .id = AV_CODEC_ID_MP3,
297	297	.priv_data_size = sizeof(LAMEContext),
298	298	.init = mp3lame_encode_init,
299	299	.encode2 = mp3lame_encode_frame,

libavcodec/libopencore-amr.c+4−4

@@ -27,7 +27,7 @@ · 26 unmodified lines
27	27
28	28	static void amr_decode_fix_avctx(AVCodecContext *avctx)
29	29	{
30		− const int is_amr_wb = 1 + (avctx->codec_id == CODEC_ID_AMR_WB);
	30	+ const int is_amr_wb = 1 + (avctx->codec_id == AV_CODEC_ID_AMR_WB);
31	31
32	32	if (!avctx->sample_rate)
33	33	avctx->sample_rate = 8000 * is_amr_wb;
@@ -174,7 +174,7 @@ static int amr_nb_decode_frame(AVCodecContext avctx, void data, · 140 unmodified lines
174	174	AVCodec ff_libopencore_amrnb_decoder = {
175	175	.name = "libopencore_amrnb",
176	176	.type = AVMEDIA_TYPE_AUDIO,
177		− .id = CODEC_ID_AMR_NB,
	177	+ .id = AV_CODEC_ID_AMR_NB,
178	178	.priv_data_size = sizeof(AMRContext),
179	179	.init = amr_nb_decode_init,
180	180	.close = amr_nb_decode_close,
@@ -291,7 +291,7 @@ static int amr_nb_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 110 unmodified lines
291	291	AVCodec ff_libopencore_amrnb_encoder = {
292	292	.name = "libopencore_amrnb",
293	293	.type = AVMEDIA_TYPE_AUDIO,
294		− .id = CODEC_ID_AMR_NB,
	294	+ .id = AV_CODEC_ID_AMR_NB,
295	295	.priv_data_size = sizeof(AMRContext),
296	296	.init = amr_nb_encode_init,
297	297	.encode2 = amr_nb_encode_frame,
@@ -380,7 +380,7 @@ static int amr_wb_decode_close(AVCodecContext *avctx) · 82 unmodified lines
380	380	AVCodec ff_libopencore_amrwb_decoder = {
381	381	.name = "libopencore_amrwb",
382	382	.type = AVMEDIA_TYPE_AUDIO,
383		− .id = CODEC_ID_AMR_WB,
	383	+ .id = AV_CODEC_ID_AMR_WB,
384	384	.priv_data_size = sizeof(AMRWBContext),
385	385	.init = amr_wb_decode_init,
386	386	.close = amr_wb_decode_close,

libavcodec/libopenjpegdec.c+1−1

@@ -446,7 +446,7 @@ static const AVClass class = { · 445 unmodified lines
446	446	AVCodec ff_libopenjpeg_decoder = {
447	447	.name = "libopenjpeg",
448	448	.type = AVMEDIA_TYPE_VIDEO,
449		− .id = CODEC_ID_JPEG2000,
	449	+ .id = AV_CODEC_ID_JPEG2000,
450	450	.priv_data_size = sizeof(LibOpenJPEGContext),
451	451	.init = libopenjpeg_decode_init,
452	452	.close = libopenjpeg_decode_close,

libavcodec/libopenjpegenc.c+1−1

@@ -414,7 +414,7 @@ static const AVClass class = { · 413 unmodified lines
414	414	AVCodec ff_libopenjpeg_encoder = {
415	415	.name = "libopenjpeg",
416	416	.type = AVMEDIA_TYPE_VIDEO,
417		− .id = CODEC_ID_JPEG2000,
	417	+ .id = AV_CODEC_ID_JPEG2000,
418	418	.priv_data_size = sizeof(LibOpenJPEGContext),
419	419	.init = libopenjpeg_encode_init,
420	420	.encode2 = libopenjpeg_encode_frame,

libavcodec/libschroedingerdec.c+1−1

@@ -385,7 +385,7 @@ static void libschroedinger_flush(AVCodecContext *avccontext) · 384 unmodified lines
385	385	AVCodec ff_libschroedinger_decoder = {
386	386	.name = "libschroedinger",
387	387	.type = AVMEDIA_TYPE_VIDEO,
388		− .id = CODEC_ID_DIRAC,
	388	+ .id = AV_CODEC_ID_DIRAC,
389	389	.priv_data_size = sizeof(SchroDecoderParams),
390	390	.init = libschroedinger_decode_init,
391	391	.close = libschroedinger_decode_close,

libavcodec/libschroedingerenc.c+1−1

@@ -442,7 +442,7 @@ static int libschroedinger_encode_close(AVCodecContext *avccontext) · 441 unmodified lines
442	442	AVCodec ff_libschroedinger_encoder = {
443	443	.name = "libschroedinger",
444	444	.type = AVMEDIA_TYPE_VIDEO,
445		− .id = CODEC_ID_DIRAC,
	445	+ .id = AV_CODEC_ID_DIRAC,
446	446	.priv_data_size = sizeof(SchroEncoderParams),
447	447	.init = libschroedinger_encode_init,
448	448	.encode2 = libschroedinger_encode_frame,

libavcodec/libspeexdec.c+1−1

@@ -161,7 +161,7 @@ static av_cold void libspeex_decode_flush(AVCodecContext *avctx) · 160 unmodified lines
161	161	AVCodec ff_libspeex_decoder = {
162	162	.name = "libspeex",
163	163	.type = AVMEDIA_TYPE_AUDIO,
164		− .id = CODEC_ID_SPEEX,
	164	+ .id = AV_CODEC_ID_SPEEX,
165	165	.priv_data_size = sizeof(LibSpeexContext),
166	166	.init = libspeex_decode_init,
167	167	.close = libspeex_decode_close,

libavcodec/libspeexenc.c+1−1

@@ -328,7 +328,7 @@ static const AVCodecDefault defaults[] = { · 327 unmodified lines
328	328	AVCodec ff_libspeex_encoder = {
329	329	.name = "libspeex",
330	330	.type = AVMEDIA_TYPE_AUDIO,
331		− .id = CODEC_ID_SPEEX,
	331	+ .id = AV_CODEC_ID_SPEEX,
332	332	.priv_data_size = sizeof(LibSpeexEncContext),
333	333	.init = encode_init,
334	334	.encode2 = encode_frame,

libavcodec/libtheoraenc.c+1−1

@@ -363,7 +363,7 @@ static av_cold int encode_close(AVCodecContext* avc_context) · 362 unmodified lines
363	363	AVCodec ff_libtheora_encoder = {
364	364	.name = "libtheora",
365	365	.type = AVMEDIA_TYPE_VIDEO,
366		− .id = CODEC_ID_THEORA,
	366	+ .id = AV_CODEC_ID_THEORA,
367	367	.priv_data_size = sizeof(TheoraContext),
368	368	.init = encode_init,
369	369	.close = encode_close,

libavcodec/libvo-aacenc.c+1−1

@@ -190,7 +190,7 @@ static int aac_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 189 unmodified lines
190	190	AVCodec ff_libvo_aacenc_encoder = {
191	191	.name = "libvo_aacenc",
192	192	.type = AVMEDIA_TYPE_AUDIO,
193		− .id = CODEC_ID_AAC,
	193	+ .id = AV_CODEC_ID_AAC,
194	194	.priv_data_size = sizeof(AACContext),
195	195	.init = aac_encode_init,
196	196	.encode2 = aac_encode_frame,

libavcodec/libvo-amrwbenc.c+1−1

@@ -143,7 +143,7 @@ static int amr_wb_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 142 unmodified lines
143	143	AVCodec ff_libvo_amrwbenc_encoder = {
144	144	.name = "libvo_amrwbenc",
145	145	.type = AVMEDIA_TYPE_AUDIO,
146		− .id = CODEC_ID_AMR_WB,
	146	+ .id = AV_CODEC_ID_AMR_WB,
147	147	.priv_data_size = sizeof(AMRWBContext),
148	148	.init = amr_wb_encode_init,
149	149	.encode2 = amr_wb_encode_frame,

libavcodec/libvorbis.c+1−1

@@ -351,7 +351,7 @@ static int oggvorbis_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 350 unmodified lines
351	351	AVCodec ff_libvorbis_encoder = {
352	352	.name = "libvorbis",
353	353	.type = AVMEDIA_TYPE_AUDIO,
354		− .id = CODEC_ID_VORBIS,
	354	+ .id = AV_CODEC_ID_VORBIS,
355	355	.priv_data_size = sizeof(OggVorbisContext),
356	356	.init = oggvorbis_encode_init,
357	357	.encode2 = oggvorbis_encode_frame,

libavcodec/libvpxdec.c+1−1

@@ -114,7 +114,7 @@ static av_cold int vp8_free(AVCodecContext *avctx) · 113 unmodified lines
114	114	AVCodec ff_libvpx_decoder = {
115	115	.name = "libvpx",
116	116	.type = AVMEDIA_TYPE_VIDEO,
117		− .id = CODEC_ID_VP8,
	117	+ .id = AV_CODEC_ID_VP8,
118	118	.priv_data_size = sizeof(VP8Context),
119	119	.init = vp8_init,
120	120	.close = vp8_free,

libavcodec/libvpxenc.c+1−1

@@ -568,7 +568,7 @@ static const AVCodecDefault defaults[] = { · 567 unmodified lines
568	568	AVCodec ff_libvpx_encoder = {
569	569	.name = "libvpx",
570	570	.type = AVMEDIA_TYPE_VIDEO,
571		− .id = CODEC_ID_VP8,
	571	+ .id = AV_CODEC_ID_VP8,
572	572	.priv_data_size = sizeof(VP8Context),
573	573	.init = vp8_init,
574	574	.encode2 = vp8_encode,

libavcodec/libx264.c+1−1

@@ -554,7 +554,7 @@ static const AVCodecDefault x264_defaults[] = { · 553 unmodified lines
554	554	AVCodec ff_libx264_encoder = {
555	555	.name = "libx264",
556	556	.type = AVMEDIA_TYPE_VIDEO,
557		− .id = CODEC_ID_H264,
	557	+ .id = AV_CODEC_ID_H264,
558	558	.priv_data_size = sizeof(X264Context),
559	559	.init = X264_init,
560	560	.encode2 = X264_frame,

libavcodec/libxavs.c+1−1

@@ -419,7 +419,7 @@ static const AVCodecDefault xavs_defaults[] = { · 418 unmodified lines
419	419	AVCodec ff_libxavs_encoder = {
420	420	.name = "libxavs",
421	421	.type = AVMEDIA_TYPE_VIDEO,
422		− .id = CODEC_ID_CAVS,
	422	+ .id = AV_CODEC_ID_CAVS,
423	423	.priv_data_size = sizeof(XavsContext),
424	424	.init = XAVS_init,
425	425	.encode2 = XAVS_frame,

libavcodec/libxvid.c+2−2

@@ -592,7 +592,7 @@ static av_cold int xvid_encode_init(AVCodecContext *avctx) { · 591 unmodified lines
592	592	if( xvid_flags & CODEC_FLAG_GLOBAL_HEADER ) {
593	593	/* In this case, we are claiming to be MPEG4 */
594	594	x->quicktime_format = 1;
595		− avctx->codec_id = CODEC_ID_MPEG4;
	595	+ avctx->codec_id = AV_CODEC_ID_MPEG4;
596	596	} else {
597	597	/* We are claiming to be Xvid */
598	598	x->quicktime_format = 0;
@@ -778,7 +778,7 @@ static av_cold int xvid_encode_close(AVCodecContext *avctx) { · 179 unmodified lines
778	778	AVCodec ff_libxvid_encoder = {
779	779	.name = "libxvid",
780	780	.type = AVMEDIA_TYPE_VIDEO,
781		− .id = CODEC_ID_MPEG4,
	781	+ .id = AV_CODEC_ID_MPEG4,
782	782	.priv_data_size = sizeof(struct xvid_context),
783	783	.init = xvid_encode_init,
784	784	.encode2 = xvid_encode_frame,

libavcodec/ljpegenc.c+1−1

@@ -207,7 +207,7 @@ static int encode_picture_lossless(AVCodecContext avctx, AVPacket pkt, · 206 unmodified lines
207	207	AVCodec ff_ljpeg_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
208	208	.name = "ljpeg",
209	209	.type = AVMEDIA_TYPE_VIDEO,
210		− .id = CODEC_ID_LJPEG,
	210	+ .id = AV_CODEC_ID_LJPEG,
211	211	.priv_data_size = sizeof(MpegEncContext),
212	212	.init = ff_MPV_encode_init,
213	213	.encode2 = encode_picture_lossless,

libavcodec/loco.c+1−1

@@ -288,7 +288,7 @@ static av_cold int decode_end(AVCodecContext *avctx){ · 287 unmodified lines
288	288	AVCodec ff_loco_decoder = {
289	289	.name = "loco",
290	290	.type = AVMEDIA_TYPE_VIDEO,
291		− .id = CODEC_ID_LOCO,
	291	+ .id = AV_CODEC_ID_LOCO,
292	292	.priv_data_size = sizeof(LOCOContext),
293	293	.init = decode_init,
294	294	.close = decode_end,

libavcodec/mace.c+3−3

@@ -249,7 +249,7 @@ static int mace_decode_frame(AVCodecContext avctx, void data, · 248 unmodified lines
249	249	int16_t *samples;
250	250	MACEContext *ctx = avctx->priv_data;
251	251	int i, j, k, l, ret;
252		− int is_mace3 = (avctx->codec_id == CODEC_ID_MACE3);
	252	+ int is_mace3 = (avctx->codec_id == AV_CODEC_ID_MACE3);
253	253
254	254	/* get output buffer */
255	255	ctx->frame.nb_samples = 3 * (buf_size << (1 - is_mace3)) / avctx->channels;
@@ -292,7 +292,7 @@ static int mace_decode_frame(AVCodecContext avctx, void data, · 36 unmodified lines
292	292	AVCodec ff_mace3_decoder = {
293	293	.name = "mace3",
294	294	.type = AVMEDIA_TYPE_AUDIO,
295		− .id = CODEC_ID_MACE3,
	295	+ .id = AV_CODEC_ID_MACE3,
296	296	.priv_data_size = sizeof(MACEContext),
297	297	.init = mace_decode_init,
298	298	.decode = mace_decode_frame,
@@ -303,7 +303,7 @@ AVCodec ff_mace3_decoder = { · 4 unmodified lines
303	303	AVCodec ff_mace6_decoder = {
304	304	.name = "mace6",
305	305	.type = AVMEDIA_TYPE_AUDIO,
306		− .id = CODEC_ID_MACE6,
	306	+ .id = AV_CODEC_ID_MACE6,
307	307	.priv_data_size = sizeof(MACEContext),
308	308	.init = mace_decode_init,
309	309	.decode = mace_decode_frame,

libavcodec/mdec.c+1−1

@@ -267,7 +267,7 @@ static av_cold int decode_end(AVCodecContext *avctx){ · 266 unmodified lines
267	267	AVCodec ff_mdec_decoder = {
268	268	.name = "mdec",
269	269	.type = AVMEDIA_TYPE_VIDEO,
270		− .id = CODEC_ID_MDEC,
	270	+ .id = AV_CODEC_ID_MDEC,
271	271	.priv_data_size = sizeof(MDECContext),
272	272	.init = decode_init,
273	273	.close = decode_end,

libavcodec/mimic.c+1−1

@@ -423,7 +423,7 @@ static av_cold int mimic_decode_end(AVCodecContext *avctx) · 422 unmodified lines
423	423	AVCodec ff_mimic_decoder = {
424	424	.name = "mimic",
425	425	.type = AVMEDIA_TYPE_VIDEO,
426		− .id = CODEC_ID_MIMIC,
	426	+ .id = AV_CODEC_ID_MIMIC,
427	427	.priv_data_size = sizeof(MimicContext),
428	428	.init = mimic_decode_init,
429	429	.close = mimic_decode_end,

libavcodec/mjpeg_parser.c+1−1

@@ -97,7 +97,7 @@ static int jpeg_parse(AVCodecParserContext *s, · 96 unmodified lines
97	97
98	98
99	99	AVCodecParser ff_mjpeg_parser = {
100		− .codec_ids = { CODEC_ID_MJPEG },
	100	+ .codec_ids = { AV_CODEC_ID_MJPEG },
101	101	.priv_data_size = sizeof(ParseContext),
102	102	.parser_parse = jpeg_parse,
103	103	.parser_close = ff_parse_close,

libavcodec/mjpega_dump_header_bsf.c+1−1

@@ -38,7 +38,7 @@ static int mjpega_dump_header(AVBitStreamFilterContext bsfc, AVCodecContext av · 37 unmodified lines
38	38	unsigned dqt = 0, dht = 0, sof0 = 0;
39	39	int i;
40	40
41		− if (avctx->codec_id != CODEC_ID_MJPEG) {
	41	+ if (avctx->codec_id != AV_CODEC_ID_MJPEG) {
42	42	av_log(avctx, AV_LOG_ERROR, "mjpega bitstream filter only applies to mjpeg codec\n");
43	43	return 0;
44	44	}

libavcodec/mjpegbdec.c+1−1

@@ -155,7 +155,7 @@ read_header: · 154 unmodified lines
155	155	AVCodec ff_mjpegb_decoder = {
156	156	.name = "mjpegb",
157	157	.type = AVMEDIA_TYPE_VIDEO,
158		− .id = CODEC_ID_MJPEGB,
	158	+ .id = AV_CODEC_ID_MJPEGB,
159	159	.priv_data_size = sizeof(MJpegDecodeContext),
160	160	.init = ff_mjpeg_decode_init,
161	161	.close = ff_mjpeg_decode_end,

libavcodec/mjpegdec.c+4−4

@@ -113,7 +113,7 @@ av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx) · 112 unmodified lines
113	113	s->interlace_polarity = 1; /* bottom field first */
114	114	av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n");
115	115	}
116		− if (avctx->codec->id == CODEC_ID_AMV)
	116	+ if (avctx->codec->id == AV_CODEC_ID_AMV)
117	117	s->flipped = 1;
118	118
119	119	return 0;
@@ -1354,7 +1354,7 @@ int ff_mjpeg_find_marker(MJpegDecodeContext *s, · 1234 unmodified lines
1354	1354	uint8_t x = *(src++);
1355	1355
1356	1356	*(dst++) = x;
1357		− if (s->avctx->codec_id != CODEC_ID_THP) {
	1357	+ if (s->avctx->codec_id != AV_CODEC_ID_THP) {
1358	1358	if (x == 0xff) {
1359	1359	while (src < buf_end && x == 0xff)
1360	1360	x = *(src++);
@@ -1645,7 +1645,7 @@ static const AVClass mjpegdec_class = { · 284 unmodified lines
1645	1645	AVCodec ff_mjpeg_decoder = {
1646	1646	.name = "mjpeg",
1647	1647	.type = AVMEDIA_TYPE_VIDEO,
1648		− .id = CODEC_ID_MJPEG,
	1648	+ .id = AV_CODEC_ID_MJPEG,
1649	1649	.priv_data_size = sizeof(MJpegDecodeContext),
1650	1650	.init = ff_mjpeg_decode_init,
1651	1651	.close = ff_mjpeg_decode_end,
@@ -1658,7 +1658,7 @@ AVCodec ff_mjpeg_decoder = { · 6 unmodified lines
1658	1658	AVCodec ff_thp_decoder = {
1659	1659	.name = "thp",
1660	1660	.type = AVMEDIA_TYPE_VIDEO,
1661		− .id = CODEC_ID_THP,
	1661	+ .id = AV_CODEC_ID_THP,
1662	1662	.priv_data_size = sizeof(MJpegDecodeContext),
1663	1663	.init = ff_mjpeg_decode_init,
1664	1664	.close = ff_mjpeg_decode_end,

libavcodec/mjpegenc.c+6−6

@@ -196,7 +196,7 @@ static void jpeg_put_comments(MpegEncContext *s) · 195 unmodified lines
196	196
197	197	void ff_mjpeg_encode_picture_header(MpegEncContext *s)
198	198	{
199		− const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
	199	+ const int lossless= s->avctx->codec_id != AV_CODEC_ID_MJPEG;
200	200
201	201	put_marker(&s->pb, SOI);
202	202
@@ -205,8 +205,8 @@ void ff_mjpeg_encode_picture_header(MpegEncContext *s) · 2 unmodified lines
205	205	jpeg_table_header(s);
206	206
207	207	switch(s->avctx->codec_id){
208		− case CODEC_ID_MJPEG: put_marker(&s->pb, SOF0 ); break;
209		− case CODEC_ID_LJPEG: put_marker(&s->pb, SOF3 ); break;
	208	+ case AV_CODEC_ID_MJPEG: put_marker(&s->pb, SOF0 ); break;
	209	+ case AV_CODEC_ID_LJPEG: put_marker(&s->pb, SOF3 ); break;
210	210	default: assert(0);
211	211	}
212	212
@@ -268,8 +268,8 @@ void ff_mjpeg_encode_picture_header(MpegEncContext *s) · 55 unmodified lines
268	268	put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
269	269
270	270	switch(s->avctx->codec_id){
271		− case CODEC_ID_MJPEG: put_bits(&s->pb, 8, 63); break; /* Se (not used) */
272		− case CODEC_ID_LJPEG: put_bits(&s->pb, 8, 0); break; /* not used */
	271	+ case AV_CODEC_ID_MJPEG: put_bits(&s->pb, 8, 63); break; /* Se (not used) */
	272	+ case AV_CODEC_ID_LJPEG: put_bits(&s->pb, 8, 0); break; /* not used */
273	273	default: assert(0);
274	274	}
275	275
@@ -448,7 +448,7 @@ void ff_mjpeg_encode_mb(MpegEncContext *s, DCTELEM block[6][64]) · 172 unmodified lines
448	448	AVCodec ff_mjpeg_encoder = {
449	449	.name = "mjpeg",
450	450	.type = AVMEDIA_TYPE_VIDEO,
451		− .id = CODEC_ID_MJPEG,
	451	+ .id = AV_CODEC_ID_MJPEG,
452	452	.priv_data_size = sizeof(MpegEncContext),
453	453	.init = ff_MPV_encode_init,
454	454	.encode2 = ff_MPV_encode_picture,

libavcodec/mlp_parser.c+1−1

@@ -346,7 +346,7 @@ lost_sync: · 345 unmodified lines
346	346	}
347	347
348	348	AVCodecParser ff_mlp_parser = {
349		− .codec_ids = { CODEC_ID_MLP, CODEC_ID_TRUEHD },
	349	+ .codec_ids = { AV_CODEC_ID_MLP, AV_CODEC_ID_TRUEHD },
350	350	.priv_data_size = sizeof(MLPParseContext),
351	351	.parser_init = mlp_init,
352	352	.parser_parse = mlp_parse,

libavcodec/mlpdec.c+9−9

@@ -294,7 +294,7 @@ static int read_major_sync(MLPDecodeContext m, GetBitContext gb) · 293 unmodified lines
294	294
295	295	if (mh.num_substreams == 0)
296	296	return AVERROR_INVALIDDATA;
297		− if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
	297	+ if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
298	298	av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
299	299	return AVERROR_INVALIDDATA;
300	300	}
@@ -340,7 +340,7 @@ static int read_restart_header(MLPDecodeContext m, GetBitContext gbp, · 39 unmodified lines
340	340	uint8_t checksum;
341	341	uint8_t lossless_check;
342	342	int start_count = get_bits_count(gbp);
343		− const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
	343	+ const int max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
344	344	? MAX_MATRIX_CHANNEL_MLP
345	345	: MAX_MATRIX_CHANNEL_TRUEHD;
346	346
@@ -354,7 +354,7 @@ static int read_restart_header(MLPDecodeContext m, GetBitContext gbp, · 7 unmodified lines
354	354
355	355	s->noise_type = get_bits1(gbp);
356	356
357		− if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
	357	+ if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
358	358	av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
359	359	return AVERROR_INVALIDDATA;
360	360	}
@@ -549,7 +549,7 @@ static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitCo · 188 unmodified lines
549	549	{
550	550	SubStream *s = &m->substream[substr];
551	551	unsigned int mat, ch;
552		− const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
	552	+ const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
553	553	? MAX_MATRICES_MLP
554	554	: MAX_MATRICES_TRUEHD;
555	555
@@ -1004,7 +1004,7 @@ static int read_access_unit(AVCodecContext avctx, void data, · 448 unmodified lines
1004	1004	substr_header_size += 2;
1005	1005
1006	1006	if (extraword_present) {
1007		− if (m->avctx->codec_id == CODEC_ID_MLP) {
	1007	+ if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1008	1008	av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1009	1009	goto error;
1010	1010	}
@@ -1093,9 +1093,9 @@ static int read_access_unit(AVCodecContext avctx, void data, · 82 unmodified lines
1093	1093	return AVERROR_INVALIDDATA;
1094	1094
1095	1095	shorten_by = get_bits(&gb, 16);
1096		− if (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000)
	1096	+ if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1097	1097	s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1098		− else if (m->avctx->codec_id == CODEC_ID_MLP && shorten_by != 0xD234)
	1098	+ else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1099	1099	return AVERROR_INVALIDDATA;
1100	1100
1101	1101	if (substr == m->max_decoded_substream)
@@ -1147,7 +1147,7 @@ error: · 45 unmodified lines
1147	1147	AVCodec ff_mlp_decoder = {
1148	1148	.name = "mlp",
1149	1149	.type = AVMEDIA_TYPE_AUDIO,
1150		− .id = CODEC_ID_MLP,
	1150	+ .id = AV_CODEC_ID_MLP,
1151	1151	.priv_data_size = sizeof(MLPDecodeContext),
1152	1152	.init = mlp_decode_init,
1153	1153	.decode = read_access_unit,
@@ -1159,7 +1159,7 @@ AVCodec ff_mlp_decoder = { · 5 unmodified lines
1159	1159	AVCodec ff_truehd_decoder = {
1160	1160	.name = "truehd",
1161	1161	.type = AVMEDIA_TYPE_AUDIO,
1162		− .id = CODEC_ID_TRUEHD,
	1162	+ .id = AV_CODEC_ID_TRUEHD,
1163	1163	.priv_data_size = sizeof(MLPDecodeContext),
1164	1164	.init = mlp_decode_init,
1165	1165	.decode = read_access_unit,

libavcodec/mmvideo.c+1−1

@@ -228,7 +228,7 @@ static av_cold int mm_decode_end(AVCodecContext *avctx) · 227 unmodified lines
228	228	AVCodec ff_mmvideo_decoder = {
229	229	.name = "mmvideo",
230	230	.type = AVMEDIA_TYPE_VIDEO,
231		− .id = CODEC_ID_MMVIDEO,
	231	+ .id = AV_CODEC_ID_MMVIDEO,
232	232	.priv_data_size = sizeof(MmContext),
233	233	.init = mm_decode_init,
234	234	.close = mm_decode_end,

libavcodec/motion_est.c+8−8

@@ -305,7 +305,7 @@ int ff_init_me(MpegEncContext *s){ · 304 unmodified lines
305	305	return -1;
306	306	}
307	307	//special case of snow is needed because snow uses its own iterative ME code
308		− if(s->me_method!=ME_ZERO && s->me_method!=ME_EPZS && s->me_method!=ME_X1 && s->avctx->codec_id != CODEC_ID_SNOW){
	308	+ if(s->me_method!=ME_ZERO && s->me_method!=ME_EPZS && s->me_method!=ME_X1 && s->avctx->codec_id != AV_CODEC_ID_SNOW){
309	309	av_log(s->avctx, AV_LOG_ERROR, "me_method is only allowed to be set to zero and epzs; for hex,umh,full and others see dia_size\n");
310	310	return -1;
311	311	}
@@ -356,7 +356,7 @@ int ff_init_me(MpegEncContext *s){ · 44 unmodified lines
356	356	/* 8x8 fullpel search would need a 4x4 chroma compare, which we do
357	357	* not have yet, and even if we had, the motion estimation code
358	358	* does not expect it. */
359		− if(s->codec_id != CODEC_ID_SNOW){
	359	+ if(s->codec_id != AV_CODEC_ID_SNOW){
360	360	if((c->avctx->me_cmp&FF_CMP_CHROMA)/* && !s->dsp.me_cmp[2]*/){
361	361	s->dsp.me_cmp[2]= zero_cmp;
362	362	}
@@ -367,7 +367,7 @@ int ff_init_me(MpegEncContext *s){ · 4 unmodified lines
367	367	c->hpel_put[2][2]= c->hpel_put[2][3]= zero_hpel;
368	368	}
369	369
370		− if(s->codec_id == CODEC_ID_H261){
	370	+ if(s->codec_id == AV_CODEC_ID_H261){
371	371	c->sub_motion_search= no_sub_motion_search;
372	372	}
373	373
@@ -1664,7 +1664,7 @@ void ff_estimate_b_frame_motion(MpegEncContext * s, · 1290 unmodified lines
1664	1664
1665	1665	c->skip=0;
1666	1666
1667		− if (s->codec_id == CODEC_ID_MPEG4 && s->next_picture.f.mbskip_table[xy]) {
	1667	+ if (s->codec_id == AV_CODEC_ID_MPEG4 && s->next_picture.f.mbskip_table[xy]) {
1668	1668	int score= direct_search(s, mb_x, mb_y); //FIXME just check 0,0
1669	1669
1670	1670	score= ((unsigned)(scorescore + 128256))>>16;
@@ -1726,7 +1726,7 @@ void ff_estimate_b_frame_motion(MpegEncContext * s, · 55 unmodified lines
1726	1726	}
1727	1727	}
1728	1728
1729		− if (s->codec_id == CODEC_ID_MPEG4)
	1729	+ if (s->codec_id == AV_CODEC_ID_MPEG4)
1730	1730	dmin= direct_search(s, mb_x, mb_y);
1731	1731	else
1732	1732	dmin= INT_MAX;
@@ -1797,7 +1797,7 @@ void ff_estimate_b_frame_motion(MpegEncContext * s, · 64 unmodified lines
1797	1797	}
1798	1798	//FIXME something smarter
1799	1799	if(dmin>25625616) type&= ~CANDIDATE_MB_TYPE_DIRECT; //do not try direct mode if it is invalid for this MB
1800		− if(s->codec_id == CODEC_ID_MPEG4 && type&CANDIDATE_MB_TYPE_DIRECT && s->flags&CODEC_FLAG_MV0 && (uint32_t)s->b_direct_mv_table[xy])
	1800	+ if(s->codec_id == AV_CODEC_ID_MPEG4 && type&CANDIDATE_MB_TYPE_DIRECT && s->flags&CODEC_FLAG_MV0 && (uint32_t)s->b_direct_mv_table[xy])
1801	1801	type \|= CANDIDATE_MB_TYPE_DIRECT0;
1802	1802	}
1803	1803
@@ -1816,7 +1816,7 @@ int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type) · 12 unmodified lines
1816	1816
1817	1817	if(s->msmpeg4_version)
1818	1818	range= FFMIN(range, 16);
1819		− else if(s->codec_id == CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL)
	1819	+ else if(s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL)
1820	1820	range= FFMIN(range, 256);
1821	1821
1822	1822	for(i=0; i<8; i++) score[i]= s->mb_num*(8-i);
@@ -1874,7 +1874,7 @@ void ff_fix_long_p_mvs(MpegEncContext * s) · 51 unmodified lines
1874	1874	range = (((s->out_format == FMT_MPEG1 \|\| s->msmpeg4_version) ? 8 : 16) << f_code);
1875	1875
1876	1876	assert(range <= 16 \|\| !s->msmpeg4_version);
1877		− assert(range <=256 \|\| !(s->codec_id == CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL));
	1877	+ assert(range <=256 \|\| !(s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL));
1878	1878
1879	1879	if(c->avctx->me_range && range > c->avctx->me_range) range= c->avctx->me_range;
1880	1880

libavcodec/motionpixels.c+1−1

@@ -317,7 +317,7 @@ static av_cold int mp_decode_end(AVCodecContext *avctx) · 316 unmodified lines
317	317	AVCodec ff_motionpixels_decoder = {
318	318	.name = "motionpixels",
319	319	.type = AVMEDIA_TYPE_VIDEO,
320		− .id = CODEC_ID_MOTIONPIXELS,
	320	+ .id = AV_CODEC_ID_MOTIONPIXELS,
321	321	.priv_data_size = sizeof(MotionPixelsContext),
322	322	.init = mp_decode_init,
323	323	.close = mp_decode_end,

libavcodec/mpc7.c+1−1

@@ -332,7 +332,7 @@ static av_cold int mpc7_decode_close(AVCodecContext *avctx) · 331 unmodified lines
332	332	AVCodec ff_mpc7_decoder = {
333	333	.name = "mpc7",
334	334	.type = AVMEDIA_TYPE_AUDIO,
335		− .id = CODEC_ID_MUSEPACK7,
	335	+ .id = AV_CODEC_ID_MUSEPACK7,
336	336	.priv_data_size = sizeof(MPCContext),
337	337	.init = mpc7_decode_init,
338	338	.close = mpc7_decode_close,

libavcodec/mpc8.c+1−1

@@ -429,7 +429,7 @@ static av_cold void mpc8_decode_flush(AVCodecContext *avctx) · 428 unmodified lines
429	429	AVCodec ff_mpc8_decoder = {
430	430	.name = "mpc8",
431	431	.type = AVMEDIA_TYPE_AUDIO,
432		− .id = CODEC_ID_MUSEPACK8,
	432	+ .id = AV_CODEC_ID_MUSEPACK8,
433	433	.priv_data_size = sizeof(MPCContext),
434	434	.init = mpc8_decode_init,
435	435	.decode = mpc8_decode_frame,

libavcodec/mpeg12.c+14−14

@@ -837,7 +837,7 @@ static int mpeg_decode_mb(MpegEncContext *s, DCTELEM block[12][64]) · 836 unmodified lines
837	837	}
838	838	}
839	839
840		− if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
	840	+ if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
841	841	if (s->flags2 & CODEC_FLAG2_FAST) {
842	842	for (i = 0; i < 6; i++) {
843	843	mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i);
@@ -1050,7 +1050,7 @@ static int mpeg_decode_mb(MpegEncContext *s, DCTELEM block[12][64]) · 206 unmodified lines
1050	1050	}
1051	1051	}
1052	1052
1053		− if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
	1053	+ if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1054	1054	if (s->flags2 & CODEC_FLAG2_FAST) {
1055	1055	for (i = 0; i < 6; i++) {
1056	1056	if (cbp & 32) {
@@ -1130,7 +1130,7 @@ static av_cold int mpeg_decode_init(AVCodecContext *avctx) · 73 unmodified lines
1130	1130	s->repeat_field = 0;
1131	1131	s->mpeg_enc_ctx.codec_id = avctx->codec->id;
1132	1132	avctx->color_range = AVCOL_RANGE_MPEG;
1133		− if (avctx->codec->id == CODEC_ID_MPEG1VIDEO)
	1133	+ if (avctx->codec->id == AV_CODEC_ID_MPEG1VIDEO)
1134	1134	avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1135	1135	else
1136	1136	avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
@@ -1184,7 +1184,7 @@ static enum PixelFormat mpeg_get_pixelformat(AVCodecContext *avctx) · 47 unmodified lines
1184	1184	if (avctx->xvmc_acceleration)
1185	1185	return avctx->get_format(avctx, pixfmt_xvmc_mpg2_420);
1186	1186	else if (avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) {
1187		− if (avctx->codec_id == CODEC_ID_MPEG1VIDEO)
	1187	+ if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO)
1188	1188	return PIX_FMT_VDPAU_MPEG1;
1189	1189	else
1190	1190	return PIX_FMT_VDPAU_MPEG2;
@@ -1237,7 +1237,7 @@ static int mpeg_decode_postinit(AVCodecContext *avctx) · 46 unmodified lines
1237	1237	* that behave like P-frames. */
1238	1238	avctx->has_b_frames = !s->low_delay;
1239	1239
1240		− if (avctx->codec_id == CODEC_ID_MPEG1VIDEO) {
	1240	+ if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1241	1241	//MPEG-1 fps
1242	1242	avctx->time_base.den = avpriv_frame_rate_tab[s->frame_rate_index].num;
1243	1243	avctx->time_base.num = avpriv_frame_rate_tab[s->frame_rate_index].den;
@@ -1380,7 +1380,7 @@ static void mpeg_decode_sequence_extension(Mpeg1Context *s1) · 136 unmodified lines
1380	1380	s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1381	1381
1382	1382	av_dlog(s->avctx, "sequence extension\n");
1383		− s->codec_id = s->avctx->codec_id = CODEC_ID_MPEG2VIDEO;
	1383	+ s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1384	1384
1385	1385	if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1386	1386	av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n",
@@ -2001,7 +2001,7 @@ static int mpeg1_decode_sequence(AVCodecContext *avctx, · 614 unmodified lines
2001	2001	s->picture_structure = PICT_FRAME;
2002	2002	s->frame_pred_frame_dct = 1;
2003	2003	s->chroma_format = 1;
2004		− s->codec_id = s->avctx->codec_id = CODEC_ID_MPEG1VIDEO;
	2004	+ s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2005	2005	s->out_format = FMT_MPEG1;
2006	2006	s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2007	2007	if (s->flags & CODEC_FLAG_LOW_DELAY)
@@ -2060,7 +2060,7 @@ static int vcr2_init_sequence(AVCodecContext *avctx) · 52 unmodified lines
2060	2060	s->picture_structure = PICT_FRAME;
2061	2061	s->frame_pred_frame_dct = 1;
2062	2062	s->chroma_format = 1;
2063		− s->codec_id = s->avctx->codec_id = CODEC_ID_MPEG2VIDEO;
	2063	+ s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2064	2064	s1->save_width = s->width;
2065	2065	s1->save_height = s->height;
2066	2066	s1->save_progressive_seq = s->progressive_sequence;
@@ -2401,7 +2401,7 @@ static int decode_chunks(AVCodecContext *avctx, · 334 unmodified lines
2401	2401	if (!s->mpeg_enc_ctx_allocated)
2402	2402	break;
2403	2403
2404		− if (s2->codec_id == CODEC_ID_MPEG2VIDEO) {
	2404	+ if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2405	2405	if (mb_y < avctx->skip_top \|\| mb_y >= s2->mb_height - avctx->skip_bottom)
2406	2406	break;
2407	2407	}
@@ -2499,7 +2499,7 @@ static const AVProfile mpeg2_video_profiles[] = { · 91 unmodified lines
2499	2499	AVCodec ff_mpeg1video_decoder = {
2500	2500	.name = "mpeg1video",
2501	2501	.type = AVMEDIA_TYPE_VIDEO,
2502		− .id = CODEC_ID_MPEG1VIDEO,
	2502	+ .id = AV_CODEC_ID_MPEG1VIDEO,
2503	2503	.priv_data_size = sizeof(Mpeg1Context),
2504	2504	.init = mpeg_decode_init,
2505	2505	.close = mpeg_decode_end,
@@ -2515,7 +2515,7 @@ AVCodec ff_mpeg1video_decoder = { · 9 unmodified lines
2515	2515	AVCodec ff_mpeg2video_decoder = {
2516	2516	.name = "mpeg2video",
2517	2517	.type = AVMEDIA_TYPE_VIDEO,
2518		− .id = CODEC_ID_MPEG2VIDEO,
	2518	+ .id = AV_CODEC_ID_MPEG2VIDEO,
2519	2519	.priv_data_size = sizeof(Mpeg1Context),
2520	2520	.init = mpeg_decode_init,
2521	2521	.close = mpeg_decode_end,
@@ -2549,7 +2549,7 @@ static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx) · 27 unmodified lines
2549	2549	AVCodec ff_mpeg_xvmc_decoder = {
2550	2550	.name = "mpegvideo_xvmc",
2551	2551	.type = AVMEDIA_TYPE_VIDEO,
2552		− .id = CODEC_ID_MPEG2VIDEO_XVMC,
	2552	+ .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2553	2553	.priv_data_size = sizeof(Mpeg1Context),
2554	2554	.init = mpeg_mc_decode_init,
2555	2555	.close = mpeg_decode_end,
@@ -2566,7 +2566,7 @@ AVCodec ff_mpeg_xvmc_decoder = { · 10 unmodified lines
2566	2566	AVCodec ff_mpeg_vdpau_decoder = {
2567	2567	.name = "mpegvideo_vdpau",
2568	2568	.type = AVMEDIA_TYPE_VIDEO,
2569		− .id = CODEC_ID_MPEG2VIDEO,
	2569	+ .id = AV_CODEC_ID_MPEG2VIDEO,
2570	2570	.priv_data_size = sizeof(Mpeg1Context),
2571	2571	.init = mpeg_decode_init,
2572	2572	.close = mpeg_decode_end,
@@ -2582,7 +2582,7 @@ AVCodec ff_mpeg_vdpau_decoder = { · 9 unmodified lines
2582	2582	AVCodec ff_mpeg1_vdpau_decoder = {
2583	2583	.name = "mpeg1video_vdpau",
2584	2584	.type = AVMEDIA_TYPE_VIDEO,
2585		− .id = CODEC_ID_MPEG1VIDEO,
	2585	+ .id = AV_CODEC_ID_MPEG1VIDEO,
2586	2586	.priv_data_size = sizeof(Mpeg1Context),
2587	2587	.init = mpeg_decode_init,
2588	2588	.close = mpeg_decode_end,

libavcodec/mpeg12enc.c+12−12

@@ -205,7 +205,7 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s) · 204 unmodified lines
205	205
206	206	for(i=1; i<15; i++){
207	207	float error= aspect_ratio;
208		− if(s->codec_id == CODEC_ID_MPEG1VIDEO \|\| i <=1)
	208	+ if(s->codec_id == AV_CODEC_ID_MPEG1VIDEO \|\| i <=1)
209	209	error-= 1.0/ff_mpeg1_aspect[i];
210	210	else
211	211	error-= av_q2d(ff_mpeg2_aspect[i])*s->height/s->width;
@@ -223,7 +223,7 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s) · 11 unmodified lines
223	223
224	224	if(s->avctx->rc_max_rate){
225	225	v = (s->avctx->rc_max_rate + 399) / 400;
226		− if (v > 0x3ffff && s->codec_id == CODEC_ID_MPEG1VIDEO)
	226	+ if (v > 0x3ffff && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
227	227	v = 0x3ffff;
228	228	}else{
229	229	v= 0x3FFFF;
@@ -248,14 +248,14 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s) · 18 unmodified lines
248	248	s->avctx->me_range && s->avctx->me_range < 128 &&
249	249	vbv_buffer_size <= 20 &&
250	250	v <= 1856000/400 &&
251		− s->codec_id == CODEC_ID_MPEG1VIDEO;
	251	+ s->codec_id == AV_CODEC_ID_MPEG1VIDEO;
252	252
253	253	put_bits(&s->pb, 1, constraint_parameter_flag);
254	254
255	255	ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
256	256	ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
257	257
258		− if(s->codec_id == CODEC_ID_MPEG2VIDEO){
	258	+ if(s->codec_id == AV_CODEC_ID_MPEG2VIDEO){
259	259	put_header(s, EXT_START_CODE);
260	260	put_bits(&s->pb, 4, 1); //seq ext
261	261
@@ -350,7 +350,7 @@ void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) · 88 unmodified lines
350	350	// RAL: Forward f_code also needed for B frames
351	351	if (s->pict_type == AV_PICTURE_TYPE_P \|\| s->pict_type == AV_PICTURE_TYPE_B) {
352	352	put_bits(&s->pb, 1, 0); /* half pel coordinates */
353		− if(s->codec_id == CODEC_ID_MPEG1VIDEO)
	353	+ if(s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
354	354	put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
355	355	else
356	356	put_bits(&s->pb, 3, 7); /* forward_f_code */
@@ -359,7 +359,7 @@ void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) · 2 unmodified lines
359	359	// RAL: Backward f_code necessary for B frames
360	360	if (s->pict_type == AV_PICTURE_TYPE_B) {
361	361	put_bits(&s->pb, 1, 0); /* half pel coordinates */
362		− if(s->codec_id == CODEC_ID_MPEG1VIDEO)
	362	+ if(s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
363	363	put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
364	364	else
365	365	put_bits(&s->pb, 3, 7); /* backward_f_code */
@@ -368,7 +368,7 @@ void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) · 2 unmodified lines
368	368	put_bits(&s->pb, 1, 0); /* extra bit picture */
369	369
370	370	s->frame_pred_frame_dct = 1;
371		− if(s->codec_id == CODEC_ID_MPEG2VIDEO){
	371	+ if(s->codec_id == AV_CODEC_ID_MPEG2VIDEO){
372	372	put_header(s, EXT_START_CODE);
373	373	put_bits(&s->pb, 4, 8); //pic ext
374	374	if (s->pict_type == AV_PICTURE_TYPE_P \|\| s->pict_type == AV_PICTURE_TYPE_B) {
@@ -449,7 +449,7 @@ static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s, · 74 unmodified lines
449	449	}
450	450
451	451	if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 &&
452		− (mb_x != s->mb_width - 1 \|\| (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) &&
	452	+ (mb_x != s->mb_width - 1 \|\| (mb_y != s->mb_height - 1 && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)) &&
453	453	((s->pict_type == AV_PICTURE_TYPE_P && (motion_x \| motion_y) == 0) \|\|
454	454	(s->pict_type == AV_PICTURE_TYPE_B && s->mv_dir == s->last_mv_dir && (((s->mv_dir & MV_DIR_FORWARD) ? ((s->mv[0][0][0] - s->last_mv[0][0][0])\|(s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) \|
455	455	((s->mv_dir & MV_DIR_BACKWARD) ? ((s->mv[1][0][0] - s->last_mv[1][0][0])\|(s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
@@ -783,7 +783,7 @@ void ff_mpeg1_encode_init(MpegEncContext *s) · 327 unmodified lines
783	783	}
784	784	s->me.mv_penalty= mv_penalty;
785	785	s->fcode_tab= fcode_tab;
786		− if(s->codec_id == CODEC_ID_MPEG1VIDEO){
	786	+ if(s->codec_id == AV_CODEC_ID_MPEG1VIDEO){
787	787	s->min_qcoeff=-255;
788	788	s->max_qcoeff= 255;
789	789	}else{
@@ -897,7 +897,7 @@ static void mpeg1_encode_block(MpegEncContext *s, · 107 unmodified lines
897	897	put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]);
898	898	/* escape: only clip in this case */
899	899	put_bits(&s->pb, 6, run);
900		− if(s->codec_id == CODEC_ID_MPEG1VIDEO){
	900	+ if(s->codec_id == AV_CODEC_ID_MPEG1VIDEO){
901	901	if (alevel < 128) {
902	902	put_sbits(&s->pb, 8, level);
903	903	} else {
@@ -953,7 +953,7 @@ mpeg12_class(2) · 49 unmodified lines
953	953	AVCodec ff_mpeg1video_encoder = {
954	954	.name = "mpeg1video",
955	955	.type = AVMEDIA_TYPE_VIDEO,
956		− .id = CODEC_ID_MPEG1VIDEO,
	956	+ .id = AV_CODEC_ID_MPEG1VIDEO,
957	957	.priv_data_size = sizeof(MpegEncContext),
958	958	.init = encode_init,
959	959	.encode2 = ff_MPV_encode_picture,
@@ -969,7 +969,7 @@ AVCodec ff_mpeg1video_encoder = { · 9 unmodified lines
969	969	AVCodec ff_mpeg2video_encoder = {
970	970	.name = "mpeg2video",
971	971	.type = AVMEDIA_TYPE_VIDEO,
972		− .id = CODEC_ID_MPEG2VIDEO,
	972	+ .id = AV_CODEC_ID_MPEG2VIDEO,
973	973	.priv_data_size = sizeof(MpegEncContext),
974	974	.init = encode_init,
975	975	.encode2 = ff_MPV_encode_picture,

libavcodec/mpeg4video_parser.c+1−1

@@ -133,7 +133,7 @@ static int mpeg4video_parse(AVCodecParserContext *s, · 132 unmodified lines
133	133
134	134
135	135	AVCodecParser ff_mpeg4video_parser = {
136		− .codec_ids = { CODEC_ID_MPEG4 },
	136	+ .codec_ids = { AV_CODEC_ID_MPEG4 },
137	137	.priv_data_size = sizeof(struct Mp4vParseContext),
138	138	.parser_init = mpeg4video_parse_init,
139	139	.parser_parse = mpeg4video_parse,

libavcodec/mpeg4videodec.c+3−3

@@ -1466,7 +1466,7 @@ intra: · 1465 unmodified lines
1466	1466	end:
1467	1467
1468	1468	/* per-MB end of slice check */
1469		− if(s->codec_id==CODEC_ID_MPEG4){
	1469	+ if(s->codec_id==AV_CODEC_ID_MPEG4){
1470	1470	if(mpeg4_is_resync(s)){
1471	1471	const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
1472	1472
@@ -2257,7 +2257,7 @@ static const AVProfile mpeg4_video_profiles[] = { · 784 unmodified lines
2257	2257	AVCodec ff_mpeg4_decoder = {
2258	2258	.name = "mpeg4",
2259	2259	.type = AVMEDIA_TYPE_VIDEO,
2260		− .id = CODEC_ID_MPEG4,
	2260	+ .id = AV_CODEC_ID_MPEG4,
2261	2261	.priv_data_size = sizeof(MpegEncContext),
2262	2262	.init = decode_init,
2263	2263	.close = ff_h263_decode_end,
@@ -2277,7 +2277,7 @@ AVCodec ff_mpeg4_decoder = { · 13 unmodified lines
2277	2277	AVCodec ff_mpeg4_vdpau_decoder = {
2278	2278	.name = "mpeg4_vdpau",
2279	2279	.type = AVMEDIA_TYPE_VIDEO,
2280		− .id = CODEC_ID_MPEG4,
	2280	+ .id = AV_CODEC_ID_MPEG4,
2281	2281	.priv_data_size = sizeof(MpegEncContext),
2282	2282	.init = decode_init,
2283	2283	.close = ff_h263_decode_end,

libavcodec/mpeg4videoenc.c+1−1

@@ -1334,7 +1334,7 @@ static const AVClass mpeg4enc_class = { · 1333 unmodified lines
1334	1334	AVCodec ff_mpeg4_encoder = {
1335	1335	.name = "mpeg4",
1336	1336	.type = AVMEDIA_TYPE_VIDEO,
1337		− .id = CODEC_ID_MPEG4,
	1337	+ .id = AV_CODEC_ID_MPEG4,
1338	1338	.priv_data_size = sizeof(MpegEncContext),
1339	1339	.init = encode_init,
1340	1340	.encode2 = ff_MPV_encode_picture,

libavcodec/mpegaudio_parser.c+1−1

@@ -101,7 +101,7 @@ static int mpegaudio_parse(AVCodecParserContext *s1, · 100 unmodified lines
101	101
102	102
103	103	AVCodecParser ff_mpegaudio_parser = {
104		− .codec_ids = { CODEC_ID_MP1, CODEC_ID_MP2, CODEC_ID_MP3 },
	104	+ .codec_ids = { AV_CODEC_ID_MP1, AV_CODEC_ID_MP2, AV_CODEC_ID_MP3 },
105	105	.priv_data_size = sizeof(MpegAudioParseContext),
106	106	.parser_parse = mpegaudio_parse,
107	107	.parser_close = ff_parse_close,

libavcodec/mpegaudiodec.c+6−6

@@ -437,7 +437,7 @@ static av_cold int decode_init(AVCodecContext * avctx) · 436 unmodified lines
437	437	avctx->sample_fmt= OUT_FMT;
438	438	s->err_recognition = avctx->err_recognition;
439	439
440		− if (avctx->codec_id == CODEC_ID_MP3ADU)
	440	+ if (avctx->codec_id == AV_CODEC_ID_MP3ADU)
441	441	s->adu_mode = 1;
442	442
443	443	avcodec_get_frame_defaults(&s->frame);
@@ -1984,7 +1984,7 @@ static int decode_frame_mp3on4(AVCodecContext avctx, void data, · 1540 unmodified lines
1984	1984	AVCodec ff_mp1_decoder = {
1985	1985	.name = "mp1",
1986	1986	.type = AVMEDIA_TYPE_AUDIO,
1987		− .id = CODEC_ID_MP1,
	1987	+ .id = AV_CODEC_ID_MP1,
1988	1988	.priv_data_size = sizeof(MPADecodeContext),
1989	1989	.init = decode_init,
1990	1990	.decode = decode_frame,
@@ -1997,7 +1997,7 @@ AVCodec ff_mp1_decoder = { · 6 unmodified lines
1997	1997	AVCodec ff_mp2_decoder = {
1998	1998	.name = "mp2",
1999	1999	.type = AVMEDIA_TYPE_AUDIO,
2000		− .id = CODEC_ID_MP2,
	2000	+ .id = AV_CODEC_ID_MP2,
2001	2001	.priv_data_size = sizeof(MPADecodeContext),
2002	2002	.init = decode_init,
2003	2003	.decode = decode_frame,
@@ -2010,7 +2010,7 @@ AVCodec ff_mp2_decoder = { · 6 unmodified lines
2010	2010	AVCodec ff_mp3_decoder = {
2011	2011	.name = "mp3",
2012	2012	.type = AVMEDIA_TYPE_AUDIO,
2013		− .id = CODEC_ID_MP3,
	2013	+ .id = AV_CODEC_ID_MP3,
2014	2014	.priv_data_size = sizeof(MPADecodeContext),
2015	2015	.init = decode_init,
2016	2016	.decode = decode_frame,
@@ -2023,7 +2023,7 @@ AVCodec ff_mp3_decoder = { · 6 unmodified lines
2023	2023	AVCodec ff_mp3adu_decoder = {
2024	2024	.name = "mp3adu",
2025	2025	.type = AVMEDIA_TYPE_AUDIO,
2026		− .id = CODEC_ID_MP3ADU,
	2026	+ .id = AV_CODEC_ID_MP3ADU,
2027	2027	.priv_data_size = sizeof(MPADecodeContext),
2028	2028	.init = decode_init,
2029	2029	.decode = decode_frame_adu,
@@ -2036,7 +2036,7 @@ AVCodec ff_mp3adu_decoder = { · 6 unmodified lines
2036	2036	AVCodec ff_mp3on4_decoder = {
2037	2037	.name = "mp3on4",
2038	2038	.type = AVMEDIA_TYPE_AUDIO,
2039		− .id = CODEC_ID_MP3ON4,
	2039	+ .id = AV_CODEC_ID_MP3ON4,
2040	2040	.priv_data_size = sizeof(MP3On4DecodeContext),
2041	2041	.init = decode_init_mp3on4,
2042	2042	.close = decode_close_mp3on4,

libavcodec/mpegaudiodec_float.c+5−5

@@ -26,7 +26,7 @@ · 25 unmodified lines
26	26	AVCodec ff_mp1float_decoder = {
27	27	.name = "mp1float",
28	28	.type = AVMEDIA_TYPE_AUDIO,
29		− .id = CODEC_ID_MP1,
	29	+ .id = AV_CODEC_ID_MP1,
30	30	.priv_data_size = sizeof(MPADecodeContext),
31	31	.init = decode_init,
32	32	.decode = decode_frame,
@@ -39,7 +39,7 @@ AVCodec ff_mp1float_decoder = { · 6 unmodified lines
39	39	AVCodec ff_mp2float_decoder = {
40	40	.name = "mp2float",
41	41	.type = AVMEDIA_TYPE_AUDIO,
42		− .id = CODEC_ID_MP2,
	42	+ .id = AV_CODEC_ID_MP2,
43	43	.priv_data_size = sizeof(MPADecodeContext),
44	44	.init = decode_init,
45	45	.decode = decode_frame,
@@ -52,7 +52,7 @@ AVCodec ff_mp2float_decoder = { · 6 unmodified lines
52	52	AVCodec ff_mp3float_decoder = {
53	53	.name = "mp3float",
54	54	.type = AVMEDIA_TYPE_AUDIO,
55		− .id = CODEC_ID_MP3,
	55	+ .id = AV_CODEC_ID_MP3,
56	56	.priv_data_size = sizeof(MPADecodeContext),
57	57	.init = decode_init,
58	58	.decode = decode_frame,
@@ -65,7 +65,7 @@ AVCodec ff_mp3float_decoder = { · 6 unmodified lines
65	65	AVCodec ff_mp3adufloat_decoder = {
66	66	.name = "mp3adufloat",
67	67	.type = AVMEDIA_TYPE_AUDIO,
68		− .id = CODEC_ID_MP3ADU,
	68	+ .id = AV_CODEC_ID_MP3ADU,
69	69	.priv_data_size = sizeof(MPADecodeContext),
70	70	.init = decode_init,
71	71	.decode = decode_frame_adu,
@@ -78,7 +78,7 @@ AVCodec ff_mp3adufloat_decoder = { · 6 unmodified lines
78	78	AVCodec ff_mp3on4float_decoder = {
79	79	.name = "mp3on4float",
80	80	.type = AVMEDIA_TYPE_AUDIO,
81		− .id = CODEC_ID_MP3ON4,
	81	+ .id = AV_CODEC_ID_MP3ON4,
82	82	.priv_data_size = sizeof(MP3On4DecodeContext),
83	83	.init = decode_init_mp3on4,
84	84	.close = decode_close_mp3on4,

libavcodec/mpegaudiodecheader.c+3−3

@@ -122,16 +122,16 @@ int avpriv_mpa_decode_header(AVCodecContext avctx, uint32_t head, int sample_r · 121 unmodified lines
122	122
123	123	switch(s->layer) {
124	124	case 1:
125		− avctx->codec_id = CODEC_ID_MP1;
	125	+ avctx->codec_id = AV_CODEC_ID_MP1;
126	126	*frame_size = 384;
127	127	break;
128	128	case 2:
129		− avctx->codec_id = CODEC_ID_MP2;
	129	+ avctx->codec_id = AV_CODEC_ID_MP2;
130	130	*frame_size = 1152;
131	131	break;
132	132	default:
133	133	case 3:
134		− avctx->codec_id = CODEC_ID_MP3;
	134	+ avctx->codec_id = AV_CODEC_ID_MP3;
135	135	if (s->lsf)
136	136	*frame_size = 576;
137	137	else

libavcodec/mpegaudioenc.c+1−1

@@ -784,7 +784,7 @@ static const AVCodecDefault mp2_defaults[] = { · 783 unmodified lines
784	784	AVCodec ff_mp2_encoder = {
785	785	.name = "mp2",
786	786	.type = AVMEDIA_TYPE_AUDIO,
787		− .id = CODEC_ID_MP2,
	787	+ .id = AV_CODEC_ID_MP2,
788	788	.priv_data_size = sizeof(MpegAudioContext),
789	789	.init = MPA_encode_init,
790	790	.encode2 = MPA_encode_frame,

libavcodec/mpegvideo.c+20−20

@@ -230,7 +230,7 @@ static void free_frame_buffer(MpegEncContext s, Picture pic) · 229 unmodified lines
230	230	/* Windows Media Image codecs allocate internal buffers with different
231	231	* dimensions; ignore user defined callbacks for these
232	232	*/
233		− if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
	233	+ if (s->codec_id != AV_CODEC_ID_WMV3IMAGE && s->codec_id != AV_CODEC_ID_VC1IMAGE)
234	234	ff_thread_release_buffer(s->avctx, &pic->f);
235	235	else
236	236	avcodec_default_release_buffer(s->avctx, &pic->f);
@@ -255,7 +255,7 @@ static int alloc_frame_buffer(MpegEncContext s, Picture pic) · 18 unmodified lines
255	255	}
256	256	}
257	257
258		− if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
	258	+ if (s->codec_id != AV_CODEC_ID_WMV3IMAGE && s->codec_id != AV_CODEC_ID_VC1IMAGE)
259	259	r = ff_thread_get_buffer(s->avctx, &pic->f);
260	260	else
261	261	r = avcodec_default_get_buffer(s->avctx, &pic->f);
@@ -662,9 +662,9 @@ av_cold int ff_MPV_common_init(MpegEncContext *s) · 400 unmodified lines
662	662	if (s->encoding && s->avctx->slices)
663	663	nb_slices = s->avctx->slices;
664	664
665		− if (s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
	665	+ if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
666	666	s->mb_height = (s->height + 31) / 32 * 2;
667		− else if (s->codec_id != CODEC_ID_H264)
	667	+ else if (s->codec_id != AV_CODEC_ID_H264)
668	668	s->mb_height = (s->height + 15) / 16;
669	669
670	670	if (s->avctx->pix_fmt == PIX_FMT_NONE) {
@@ -818,7 +818,7 @@ av_cold int ff_MPV_common_init(MpegEncContext *s) · 147 unmodified lines
818	818	FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
819	819	mb_array_size * sizeof(uint8_t), fail);
820	820
821		− if (s->codec_id == CODEC_ID_MPEG4 \|\|
	821	+ if (s->codec_id == AV_CODEC_ID_MPEG4 \|\|
822	822	(s->flags & CODEC_FLAG_INTERLACED_ME)) {
823	823	/* interlaced direct mode decoding tables */
824	824	for (i = 0; i < 2; i++) {
@@ -1174,10 +1174,10 @@ int ff_MPV_frame_start(MpegEncContext s, AVCodecContext avctx) · 349 unmodified lines
1174	1174	s->mb_skipped = 0;
1175	1175
1176	1176	assert(s->last_picture_ptr == NULL \|\| s->out_format != FMT_H264 \|\|
1177		− s->codec_id == CODEC_ID_SVQ3);
	1177	+ s->codec_id == AV_CODEC_ID_SVQ3);
1178	1178
1179	1179	/* mark & release old frames */
1180		− if (s->out_format != FMT_H264 \|\| s->codec_id == CODEC_ID_SVQ3) {
	1180	+ if (s->out_format != FMT_H264 \|\| s->codec_id == AV_CODEC_ID_SVQ3) {
1181	1181	if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1182	1182	s->last_picture_ptr != s->next_picture_ptr &&
1183	1183	s->last_picture_ptr->f.data[0]) {
@@ -1217,7 +1217,7 @@ int ff_MPV_frame_start(MpegEncContext s, AVCodecContext avctx) · 33 unmodified lines
1217	1217
1218	1218	pic->f.reference = 0;
1219	1219	if (!s->dropable) {
1220		− if (s->codec_id == CODEC_ID_H264)
	1220	+ if (s->codec_id == AV_CODEC_ID_H264)
1221	1221	pic->f.reference = s->picture_structure;
1222	1222	else if (s->pict_type != AV_PICTURE_TYPE_B)
1223	1223	pic->f.reference = 3;
@@ -1231,8 +1231,8 @@ int ff_MPV_frame_start(MpegEncContext s, AVCodecContext avctx) · 7 unmodified lines
1231	1231	s->current_picture_ptr = pic;
1232	1232	// FIXME use only the vars from current_pic
1233	1233	s->current_picture_ptr->f.top_field_first = s->top_field_first;
1234		− if (s->codec_id == CODEC_ID_MPEG1VIDEO \|\|
1235		− s->codec_id == CODEC_ID_MPEG2VIDEO) {
	1234	+ if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO \|\|
	1235	+ s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1236	1236	if (s->picture_structure != PICT_FRAME)
1237	1237	s->current_picture_ptr->f.top_field_first =
1238	1238	(s->picture_structure == PICT_TOP_FIELD) == s->first_field;
@@ -1261,7 +1261,7 @@ int ff_MPV_frame_start(MpegEncContext s, AVCodecContext avctx) · 22 unmodified lines
1261	1261	s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1262	1262	s->pict_type, s->dropable); */
1263	1263
1264		− if (s->codec_id != CODEC_ID_H264) {
	1264	+ if (s->codec_id != AV_CODEC_ID_H264) {
1265	1265	if ((s->last_picture_ptr == NULL \|\|
1266	1266	s->last_picture_ptr->f.data[0] == NULL) &&
1267	1267	(s->pict_type != AV_PICTURE_TYPE_I \|\|
@@ -1306,7 +1306,7 @@ int ff_MPV_frame_start(MpegEncContext s, AVCodecContext avctx) · 38 unmodified lines
1306	1306	ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1307	1307
1308	1308	if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME) &&
1309		− (s->out_format != FMT_H264 \|\| s->codec_id == CODEC_ID_SVQ3)) {
	1309	+ (s->out_format != FMT_H264 \|\| s->codec_id == AV_CODEC_ID_SVQ3)) {
1310	1310	if (s->next_picture_ptr)
1311	1311	s->next_picture_ptr->owner2 = s;
1312	1312	if (s->last_picture_ptr)
@@ -1334,7 +1334,7 @@ int ff_MPV_frame_start(MpegEncContext s, AVCodecContext avctx) · 21 unmodified lines
1334	1334	/* set dequantizer, we can't do it during init as
1335	1335	* it might change for mpeg4 and we can't do it in the header
1336	1336	* decode as init is not called for mpeg4 there yet */
1337		− if (s->mpeg_quant \|\| s->codec_id == CODEC_ID_MPEG2VIDEO) {
	1337	+ if (s->mpeg_quant \|\| s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1338	1338	s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1339	1339	s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1340	1340	} else if (s->out_format == FMT_H263 \|\| s->out_format == FMT_H261) {
@@ -1423,7 +1423,7 @@ void ff_MPV_frame_end(MpegEncContext *s) · 82 unmodified lines
1423	1423	#endif
1424	1424	s->avctx->coded_frame = &s->current_picture_ptr->f;
1425	1425
1426		− if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
	1426	+ if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1427	1427	ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1428	1428	}
1429	1429	}
@@ -1625,7 +1625,7 @@ void ff_print_debug_info(MpegEncContext s, AVFrame pict) · 195 unmodified lines
1625	1625	const int height = s->avctx->height;
1626	1626	const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1627	1627	const int mv_stride = (s->mb_width << mv_sample_log2) +
1628		− (s->codec_id == CODEC_ID_H264 ? 0 : 1);
	1628	+ (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1629	1629	s->low_delay = 0; // needed to see the vectors without trashing the buffers
1630	1630
1631	1631	avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
@@ -1814,7 +1814,7 @@ void ff_print_debug_info(MpegEncContext s, AVFrame pict) · 182 unmodified lines
1814	1814	}
1815	1815
1816	1816	if (IS_INTERLACED(mb_type) &&
1817		− s->codec_id == CODEC_ID_H264) {
	1817	+ s->codec_id == AV_CODEC_ID_H264) {
1818	1818	// hmm
1819	1819	}
1820	1820	}
@@ -2053,8 +2053,8 @@ void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], · 232 unmodified lines
2053	2053	}
2054	2054
2055	2055	/* add dct residue */
2056		− if(s->encoding \|\| !( s->msmpeg4_version \|\| s->codec_id==CODEC_ID_MPEG1VIDEO \|\| s->codec_id==CODEC_ID_MPEG2VIDEO
2057		− \|\| (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
	2056	+ if(s->encoding \|\| !( s->msmpeg4_version \|\| s->codec_id==AV_CODEC_ID_MPEG1VIDEO \|\| s->codec_id==AV_CODEC_ID_MPEG2VIDEO
	2057	+ \|\| (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2058	2058	add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2059	2059	add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2060	2060	add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
@@ -2073,7 +2073,7 @@ void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], · 12 unmodified lines
2073	2073	add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2074	2074	}
2075	2075	}
2076		− } else if(is_mpeg12 \|\| (s->codec_id != CODEC_ID_WMV2)){
	2076	+ } else if(is_mpeg12 \|\| (s->codec_id != AV_CODEC_ID_WMV2)){
2077	2077	add_dct(s, block[0], 0, dest_y , dct_linesize);
2078	2078	add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2079	2079	add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
@@ -2106,7 +2106,7 @@ void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], · 26 unmodified lines
2106	2106	}
2107	2107	} else {
2108	2108	/* dct only in intra block */
2109		− if(s->encoding \|\| !(s->codec_id==CODEC_ID_MPEG1VIDEO \|\| s->codec_id==CODEC_ID_MPEG2VIDEO)){
	2109	+ if(s->encoding \|\| !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO \|\| s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2110	2110	put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2111	2111	put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2112	2112	put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);

libavcodec/mpegvideo.h+1−1

@@ -216,7 +216,7 @@ typedef struct MpegEncContext { · 215 unmodified lines
216	216	int h263_plus; ///< h263 plus headers
217	217	int h263_flv; ///< use flv h263 header
218	218
219		− enum CodecID codec_id; /* see CODEC_ID_xxx */
	219	+ enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */
220	220	int fixed_qscale; ///< fixed qscale if non zero
221	221	int encoding; ///< true if we are encoding (vs decoding)
222	222	int flags; ///< AVCodecContext.flags (HQ, MV4, ...)

libavcodec/mpegvideo_common.h+3−3

@@ -302,8 +302,8 @@ if(s->quarter_sample) · 301 unmodified lines
302	302
303	303	if( (unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x&1) - 16, 0)
304	304	\|\| (unsigned)src_y > FFMAX( v_edge_pos - (motion_y&1) - h , 0)){
305		− if(is_mpeg12 \|\| s->codec_id == CODEC_ID_MPEG2VIDEO \|\|
306		− s->codec_id == CODEC_ID_MPEG1VIDEO){
	305	+ if(is_mpeg12 \|\| s->codec_id == AV_CODEC_ID_MPEG2VIDEO \|\|
	306	+ s->codec_id == AV_CODEC_ID_MPEG1VIDEO){
307	307	av_log(s->avctx,AV_LOG_DEBUG,
308	308	"MPEG motion vector out of boundary (%d %d)\n", src_x, src_y);
309	309	return;
@@ -719,7 +719,7 @@ static av_always_inline void MPV_motion_internal(MpegEncContext *s, · 409 unmodified lines
719	719	ref_picture, pix_op, qpix_op,
720	720	s->mv[dir][0][0], s->mv[dir][0][1], 16);
721	721	} else if (!is_mpeg12 && (CONFIG_WMV2_DECODER \|\| CONFIG_WMV2_ENCODER) &&
722		− s->mspel && s->codec_id == CODEC_ID_WMV2) {
	722	+ s->mspel && s->codec_id == AV_CODEC_ID_WMV2) {
723	723	ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
724	724	ref_picture, pix_op,
725	725	s->mv[dir][0][0], s->mv[dir][0][1], 16);

libavcodec/mpegvideo_enc.c+94−94

@@ -278,7 +278,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 277 unmodified lines
278	278	MPV_encode_defaults(s);
279	279
280	280	switch (avctx->codec_id) {
281		− case CODEC_ID_MPEG2VIDEO:
	281	+ case AV_CODEC_ID_MPEG2VIDEO:
282	282	if (avctx->pix_fmt != PIX_FMT_YUV420P &&
283	283	avctx->pix_fmt != PIX_FMT_YUV422P) {
284	284	av_log(avctx, AV_LOG_ERROR,
@@ -286,7 +286,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 1 unmodified line
286	286	return -1;
287	287	}
288	288	break;
289		− case CODEC_ID_LJPEG:
	289	+ case AV_CODEC_ID_LJPEG:
290	290	if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
291	291	avctx->pix_fmt != PIX_FMT_YUVJ422P &&
292	292	avctx->pix_fmt != PIX_FMT_YUVJ444P &&
@@ -299,7 +299,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 6 unmodified lines
299	299	return -1;
300	300	}
301	301	break;
302		− case CODEC_ID_MJPEG:
	302	+ case AV_CODEC_ID_MJPEG:
303	303	if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
304	304	avctx->pix_fmt != PIX_FMT_YUVJ422P &&
305	305	((avctx->pix_fmt != PIX_FMT_YUV420P &&
@@ -430,8 +430,8 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 124 unmodified lines
430	430
431	431	if (s->avctx->rc_max_rate &&
432	432	s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
433		− (s->codec_id == CODEC_ID_MPEG1VIDEO \|\|
434		− s->codec_id == CODEC_ID_MPEG2VIDEO) &&
	433	+ (s->codec_id == AV_CODEC_ID_MPEG1VIDEO \|\|
	434	+ s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
435	435	90000LL * (avctx->rc_buffer_size - 1) >
436	436	s->avctx->rc_max_rate * 0xFFFFLL) {
437	437	av_log(avctx, AV_LOG_INFO,
@@ -439,9 +439,9 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 1 unmodified line
439	439	"specified vbv buffer is too large for the given bitrate!\n");
440	440	}
441	441
442		− if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 &&
443		− s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P &&
444		− s->codec_id != CODEC_ID_FLV1) {
	442	+ if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
	443	+ s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
	444	+ s->codec_id != AV_CODEC_ID_FLV1) {
445	445	av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
446	446	return -1;
447	447	}
@@ -452,22 +452,22 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 4 unmodified lines
452	452	return -1;
453	453	}
454	454
455		− if (s->quarter_sample && s->codec_id != CODEC_ID_MPEG4) {
	455	+ if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
456	456	av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
457	457	return -1;
458	458	}
459	459
460	460	if (s->max_b_frames &&
461		− s->codec_id != CODEC_ID_MPEG4 &&
462		− s->codec_id != CODEC_ID_MPEG1VIDEO &&
463		− s->codec_id != CODEC_ID_MPEG2VIDEO) {
	461	+ s->codec_id != AV_CODEC_ID_MPEG4 &&
	462	+ s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
	463	+ s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
464	464	av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
465	465	return -1;
466	466	}
467	467
468		− if ((s->codec_id == CODEC_ID_MPEG4 \|\|
469		− s->codec_id == CODEC_ID_H263 \|\|
470		− s->codec_id == CODEC_ID_H263P) &&
	468	+ if ((s->codec_id == AV_CODEC_ID_MPEG4 \|\|
	469	+ s->codec_id == AV_CODEC_ID_H263 \|\|
	470	+ s->codec_id == AV_CODEC_ID_H263P) &&
471	471	(avctx->sample_aspect_ratio.num > 255 \|\|
472	472	avctx->sample_aspect_ratio.den > 255)) {
473	473	av_log(avctx, AV_LOG_ERROR,
@@ -477,13 +477,13 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 3 unmodified lines
477	477	}
478	478
479	479	if ((s->flags & (CODEC_FLAG_INTERLACED_DCT \| CODEC_FLAG_INTERLACED_ME)) &&
480		− s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO) {
	480	+ s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
481	481	av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
482	482	return -1;
483	483	}
484	484
485	485	// FIXME mpeg2 uses that too
486		− if (s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4) {
	486	+ if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
487	487	av_log(avctx, AV_LOG_ERROR,
488	488	"mpeg2 style quantization not supported by codec\n");
489	489	return -1;
@@ -514,7 +514,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 24 unmodified lines
514	514	}
515	515
516	516	if (s->flags & CODEC_FLAG_LOW_DELAY) {
517		− if (s->codec_id != CODEC_ID_MPEG2VIDEO) {
	517	+ if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
518	518	av_log(avctx, AV_LOG_ERROR,
519	519	"low delay forcing is only available for mpeg2\n");
520	520	return -1;
@@ -535,10 +535,10 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 14 unmodified lines
535	535	}
536	536
537	537	if (s->avctx->thread_count > 1 &&
538		− s->codec_id != CODEC_ID_MPEG4 &&
539		− s->codec_id != CODEC_ID_MPEG1VIDEO &&
540		− s->codec_id != CODEC_ID_MPEG2VIDEO &&
541		− (s->codec_id != CODEC_ID_H263P)) {
	538	+ s->codec_id != AV_CODEC_ID_MPEG4 &&
	539	+ s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
	540	+ s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
	541	+ (s->codec_id != AV_CODEC_ID_H263P)) {
542	542	av_log(avctx, AV_LOG_ERROR,
543	543	"multi threaded encoding not supported by codec\n");
544	544	return -1;
@@ -585,8 +585,8 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 40 unmodified lines
585	585	//return -1;
586	586	}
587	587
588		− if (s->mpeg_quant \|\| s->codec_id == CODEC_ID_MPEG1VIDEO \|\|
589		− s->codec_id == CODEC_ID_MPEG2VIDEO \|\| s->codec_id == CODEC_ID_MJPEG) {
	588	+ if (s->mpeg_quant \|\| s->codec_id == AV_CODEC_ID_MPEG1VIDEO \|\|
	589	+ s->codec_id == AV_CODEC_ID_MPEG2VIDEO \|\| s->codec_id == AV_CODEC_ID_MJPEG) {
590	590	// (a + x * 3 / 8) / x
591	591	s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
592	592	s->inter_quant_bias = 0;
@@ -604,7 +604,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 11 unmodified lines
604	604	avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
605	605	&chroma_v_shift);
606	606
607		− if (avctx->codec_id == CODEC_ID_MPEG4 &&
	607	+ if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
608	608	s->avctx->time_base.den > (1 << 16) - 1) {
609	609	av_log(avctx, AV_LOG_ERROR,
610	610	"timebase %d/%d not supported by MPEG 4 standard, "
@@ -625,22 +625,22 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 14 unmodified lines
625	625	#endif
626	626
627	627	switch (avctx->codec->id) {
628		− case CODEC_ID_MPEG1VIDEO:
	628	+ case AV_CODEC_ID_MPEG1VIDEO:
629	629	s->out_format = FMT_MPEG1;
630	630	s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
631	631	avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
632	632	break;
633		− case CODEC_ID_MPEG2VIDEO:
	633	+ case AV_CODEC_ID_MPEG2VIDEO:
634	634	s->out_format = FMT_MPEG1;
635	635	s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
636	636	avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
637	637	s->rtp_mode = 1;
638	638	break;
639		− case CODEC_ID_LJPEG:
640		− case CODEC_ID_MJPEG:
	639	+ case AV_CODEC_ID_LJPEG:
	640	+ case AV_CODEC_ID_MJPEG:
641	641	s->out_format = FMT_MJPEG;
642	642	s->intra_only = 1; /* force intra only for jpeg */
643		− if (avctx->codec->id == CODEC_ID_LJPEG &&
	643	+ if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
644	644	avctx->pix_fmt == PIX_FMT_BGRA) {
645	645	s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
646	646	s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
@@ -659,7 +659,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 12 unmodified lines
659	659	avctx->delay = 0;
660	660	s->low_delay = 1;
661	661	break;
662		− case CODEC_ID_H261:
	662	+ case AV_CODEC_ID_H261:
663	663	if (!CONFIG_H261_ENCODER)
664	664	return -1;
665	665	if (ff_h261_get_picture_format(s->width, s->height) < 0) {
@@ -673,7 +673,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 7 unmodified lines
673	673	avctx->delay = 0;
674	674	s->low_delay = 1;
675	675	break;
676		− case CODEC_ID_H263:
	676	+ case AV_CODEC_ID_H263:
677	677	if (!CONFIG_H263_ENCODER)
678	678	return -1;
679	679	if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
@@ -689,7 +689,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 9 unmodified lines
689	689	avctx->delay = 0;
690	690	s->low_delay = 1;
691	691	break;
692		− case CODEC_ID_H263P:
	692	+ case AV_CODEC_ID_H263P:
693	693	s->out_format = FMT_H263;
694	694	s->h263_plus = 1;
695	695	/* Fx */
@@ -703,7 +703,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 7 unmodified lines
703	703	avctx->delay = 0;
704	704	s->low_delay = 1;
705	705	break;
706		− case CODEC_ID_FLV1:
	706	+ case AV_CODEC_ID_FLV1:
707	707	s->out_format = FMT_H263;
708	708	s->h263_flv = 2; /* format = 1; 11-bit codes */
709	709	s->unrestricted_mv = 1;
@@ -711,12 +711,12 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 1 unmodified line
711	711	avctx->delay = 0;
712	712	s->low_delay = 1;
713	713	break;
714		− case CODEC_ID_RV10:
	714	+ case AV_CODEC_ID_RV10:
715	715	s->out_format = FMT_H263;
716	716	avctx->delay = 0;
717	717	s->low_delay = 1;
718	718	break;
719		− case CODEC_ID_RV20:
	719	+ case AV_CODEC_ID_RV20:
720	720	s->out_format = FMT_H263;
721	721	avctx->delay = 0;
722	722	s->low_delay = 1;
@@ -726,14 +726,14 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 3 unmodified lines
726	726	s->loop_filter = 1;
727	727	s->unrestricted_mv = 0;
728	728	break;
729		− case CODEC_ID_MPEG4:
	729	+ case AV_CODEC_ID_MPEG4:
730	730	s->out_format = FMT_H263;
731	731	s->h263_pred = 1;
732	732	s->unrestricted_mv = 1;
733	733	s->low_delay = s->max_b_frames ? 0 : 1;
734	734	avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
735	735	break;
736		− case CODEC_ID_MSMPEG4V2:
	736	+ case AV_CODEC_ID_MSMPEG4V2:
737	737	s->out_format = FMT_H263;
738	738	s->h263_pred = 1;
739	739	s->unrestricted_mv = 1;
@@ -741,7 +741,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 1 unmodified line
741	741	avctx->delay = 0;
742	742	s->low_delay = 1;
743	743	break;
744		− case CODEC_ID_MSMPEG4V3:
	744	+ case AV_CODEC_ID_MSMPEG4V3:
745	745	s->out_format = FMT_H263;
746	746	s->h263_pred = 1;
747	747	s->unrestricted_mv = 1;
@@ -750,7 +750,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 2 unmodified lines
750	750	avctx->delay = 0;
751	751	s->low_delay = 1;
752	752	break;
753		− case CODEC_ID_WMV1:
	753	+ case AV_CODEC_ID_WMV1:
754	754	s->out_format = FMT_H263;
755	755	s->h263_pred = 1;
756	756	s->unrestricted_mv = 1;
@@ -759,7 +759,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 2 unmodified lines
759	759	avctx->delay = 0;
760	760	s->low_delay = 1;
761	761	break;
762		− case CODEC_ID_WMV2:
	762	+ case AV_CODEC_ID_WMV2:
763	763	s->out_format = FMT_H263;
764	764	s->h263_pred = 1;
765	765	s->unrestricted_mv = 1;
@@ -814,7 +814,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) · 48 unmodified lines
814	814	/* init q matrix */
815	815	for (i = 0; i < 64; i++) {
816	816	int j = s->dsp.idct_permutation[i];
817		− if (CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4 &&
	817	+ if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
818	818	s->mpeg_quant) {
819	819	s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
820	820	s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
@@ -1477,8 +1477,8 @@ vbv_retry: · 656 unmodified lines
1477	1477	// done in encode_picture() so we must undo it
1478	1478	if (s->pict_type == AV_PICTURE_TYPE_P) {
1479	1479	if (s->flipflop_rounding \|\|
1480		− s->codec_id == CODEC_ID_H263P \|\|
1481		− s->codec_id == CODEC_ID_MPEG4)
	1480	+ s->codec_id == AV_CODEC_ID_H263P \|\|
	1481	+ s->codec_id == AV_CODEC_ID_MPEG4)
1482	1482	s->no_rounding ^= 1;
1483	1483	}
1484	1484	if (s->pict_type != AV_PICTURE_TYPE_B) {
@@ -1520,13 +1520,13 @@ vbv_retry: · 35 unmodified lines
1520	1520	}
1521	1521
1522	1522	switch (s->codec_id) {
1523		− case CODEC_ID_MPEG1VIDEO:
1524		− case CODEC_ID_MPEG2VIDEO:
	1523	+ case AV_CODEC_ID_MPEG1VIDEO:
	1524	+ case AV_CODEC_ID_MPEG2VIDEO:
1525	1525	while (stuffing_count--) {
1526	1526	put_bits(&s->pb, 8, 0);
1527	1527	}
1528	1528	break;
1529		− case CODEC_ID_MPEG4:
	1529	+ case AV_CODEC_ID_MPEG4:
1530	1530	put_bits(&s->pb, 16, 0);
1531	1531	put_bits(&s->pb, 16, 0x1C3);
1532	1532	stuffing_count -= 4;
@@ -1748,7 +1748,7 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s, · 215 unmodified lines
1748	1748	if (s->out_format == FMT_H263) {
1749	1749	s->dquant = av_clip(s->dquant, -2, 2);
1750	1750
1751		− if (s->codec_id == CODEC_ID_MPEG4) {
	1751	+ if (s->codec_id == AV_CODEC_ID_MPEG4) {
1752	1752	if (!s->mb_intra) {
1753	1753	if (s->pict_type == AV_PICTURE_TYPE_B) {
1754	1754	if (s->dquant & 1 \|\| s->mv_dir & MV_DIRECT)
@@ -2038,38 +2038,38 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s, · 283 unmodified lines
2038	2038
2039	2039	/* huffman encode */
2040	2040	switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2041		− case CODEC_ID_MPEG1VIDEO:
2042		− case CODEC_ID_MPEG2VIDEO:
	2041	+ case AV_CODEC_ID_MPEG1VIDEO:
	2042	+ case AV_CODEC_ID_MPEG2VIDEO:
2043	2043	if (CONFIG_MPEG1VIDEO_ENCODER \|\| CONFIG_MPEG2VIDEO_ENCODER)
2044	2044	ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2045	2045	break;
2046		− case CODEC_ID_MPEG4:
	2046	+ case AV_CODEC_ID_MPEG4:
2047	2047	if (CONFIG_MPEG4_ENCODER)
2048	2048	ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2049	2049	break;
2050		− case CODEC_ID_MSMPEG4V2:
2051		− case CODEC_ID_MSMPEG4V3:
2052		− case CODEC_ID_WMV1:
	2050	+ case AV_CODEC_ID_MSMPEG4V2:
	2051	+ case AV_CODEC_ID_MSMPEG4V3:
	2052	+ case AV_CODEC_ID_WMV1:
2053	2053	if (CONFIG_MSMPEG4_ENCODER)
2054	2054	ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2055	2055	break;
2056		− case CODEC_ID_WMV2:
	2056	+ case AV_CODEC_ID_WMV2:
2057	2057	if (CONFIG_WMV2_ENCODER)
2058	2058	ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2059	2059	break;
2060		− case CODEC_ID_H261:
	2060	+ case AV_CODEC_ID_H261:
2061	2061	if (CONFIG_H261_ENCODER)
2062	2062	ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2063	2063	break;
2064		− case CODEC_ID_H263:
2065		− case CODEC_ID_H263P:
2066		− case CODEC_ID_FLV1:
2067		− case CODEC_ID_RV10:
2068		− case CODEC_ID_RV20:
	2064	+ case AV_CODEC_ID_H263:
	2065	+ case AV_CODEC_ID_H263P:
	2066	+ case AV_CODEC_ID_FLV1:
	2067	+ case AV_CODEC_ID_RV10:
	2068	+ case AV_CODEC_ID_RV20:
2069	2069	if (CONFIG_H263_ENCODER)
2070	2070	ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2071	2071	break;
2072		− case CODEC_ID_MJPEG:
	2072	+ case AV_CODEC_ID_MJPEG:
2073	2073	if (CONFIG_MJPEG_ENCODER)
2074	2074	ff_mjpeg_encode_mb(s, s->block);
2075	2075	break;
@@ -2317,7 +2317,7 @@ static int mb_var_thread(AVCodecContext c, void arg){ · 241 unmodified lines
2317	2317	}
2318	2318
2319	2319	static void write_slice_end(MpegEncContext *s){
2320		− if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4){
	2320	+ if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2321	2321	if(s->partitioned_frame){
2322	2322	ff_mpeg4_merge_partitions(s);
2323	2323	}
@@ -2420,13 +2420,13 @@ static int encode_thread(AVCodecContext c, void arg){ · 96 unmodified lines
2420	2420	s->last_mv_dir = 0;
2421	2421
2422	2422	switch(s->codec_id){
2423		− case CODEC_ID_H263:
2424		− case CODEC_ID_H263P:
2425		− case CODEC_ID_FLV1:
	2423	+ case AV_CODEC_ID_H263:
	2424	+ case AV_CODEC_ID_H263P:
	2425	+ case AV_CODEC_ID_FLV1:
2426	2426	if (CONFIG_H263_ENCODER)
2427	2427	s->gob_index = ff_h263_get_gob_height(s);
2428	2428	break;
2429		− case CODEC_ID_MPEG4:
	2429	+ case AV_CODEC_ID_MPEG4:
2430	2430	if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2431	2431	ff_mpeg4_init_partitions(s);
2432	2432	break;
@@ -2467,7 +2467,7 @@ static int encode_thread(AVCodecContext c, void arg){ · 34 unmodified lines
2467	2467	s->mb_y = mb_y; // moved into loop, can get changed by H.261
2468	2468	ff_update_block_index(s);
2469	2469
2470		− if(CONFIG_H261_ENCODER && s->codec_id == CODEC_ID_H261){
	2470	+ if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2471	2471	ff_h261_reorder_mb_index(s);
2472	2472	xy= s->mb_y*s->mb_stride + s->mb_x;
2473	2473	mb_type= s->mb_type[xy];
@@ -2484,14 +2484,14 @@ static int encode_thread(AVCodecContext c, void arg){ · 10 unmodified lines
2484	2484	if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2485	2485
2486	2486	switch(s->codec_id){
2487		− case CODEC_ID_H263:
2488		− case CODEC_ID_H263P:
	2487	+ case AV_CODEC_ID_H263:
	2488	+ case AV_CODEC_ID_H263P:
2489	2489	if(!s->h263_slice_structured)
2490	2490	if(s->mb_x \|\| s->mb_y%s->gob_index) is_gob_start=0;
2491	2491	break;
2492		− case CODEC_ID_MPEG2VIDEO:
	2492	+ case AV_CODEC_ID_MPEG2VIDEO:
2493	2493	if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2494		− case CODEC_ID_MPEG1VIDEO:
	2494	+ case AV_CODEC_ID_MPEG1VIDEO:
2495	2495	if(s->mb_skip_run) is_gob_start=0;
2496	2496	break;
2497	2497	}
@@ -2500,7 +2500,7 @@ static int encode_thread(AVCodecContext c, void arg){ · 2 unmodified lines
2500	2500	if(s->start_mb_y != mb_y \|\| mb_x!=0){
2501	2501	write_slice_end(s);
2502	2502
2503		− if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
	2503	+ if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2504	2504	ff_mpeg4_init_partitions(s);
2505	2505	}
2506	2506	}
@@ -2525,21 +2525,21 @@ static int encode_thread(AVCodecContext c, void arg){ · 18 unmodified lines
2525	2525	update_mb_info(s, 1);
2526	2526
2527	2527	switch(s->codec_id){
2528		− case CODEC_ID_MPEG4:
	2528	+ case AV_CODEC_ID_MPEG4:
2529	2529	if (CONFIG_MPEG4_ENCODER) {
2530	2530	ff_mpeg4_encode_video_packet_header(s);
2531	2531	ff_mpeg4_clean_buffers(s);
2532	2532	}
2533	2533	break;
2534		− case CODEC_ID_MPEG1VIDEO:
2535		− case CODEC_ID_MPEG2VIDEO:
	2534	+ case AV_CODEC_ID_MPEG1VIDEO:
	2535	+ case AV_CODEC_ID_MPEG2VIDEO:
2536	2536	if (CONFIG_MPEG1VIDEO_ENCODER \|\| CONFIG_MPEG2VIDEO_ENCODER) {
2537	2537	ff_mpeg1_encode_slice_header(s);
2538	2538	ff_mpeg1_clean_buffers(s);
2539	2539	}
2540	2540	break;
2541		− case CODEC_ID_H263:
2542		− case CODEC_ID_H263P:
	2541	+ case AV_CODEC_ID_H263:
	2542	+ case AV_CODEC_ID_H263P:
2543	2543	if (CONFIG_H263_ENCODER)
2544	2544	ff_h263_encode_gob_header(s, mb_y);
2545	2545	break;
@@ -3061,13 +3061,13 @@ static int estimate_qp(MpegEncContext *s, int dry_run){ · 515 unmodified lines
3061	3061
3062	3062	if(s->adaptive_quant){
3063	3063	switch(s->codec_id){
3064		− case CODEC_ID_MPEG4:
	3064	+ case AV_CODEC_ID_MPEG4:
3065	3065	if (CONFIG_MPEG4_ENCODER)
3066	3066	ff_clean_mpeg4_qscales(s);
3067	3067	break;
3068		− case CODEC_ID_H263:
3069		− case CODEC_ID_H263P:
3070		− case CODEC_ID_FLV1:
	3068	+ case AV_CODEC_ID_H263:
	3069	+ case AV_CODEC_ID_H263P:
	3070	+ case AV_CODEC_ID_FLV1:
3071	3071	if (CONFIG_H263_ENCODER)
3072	3072	ff_clean_h263_qscales(s);
3073	3073	break;
@@ -3113,9 +3113,9 @@ static int encode_picture(MpegEncContext *s, int picture_number) · 39 unmodified lines
3113	3113
3114	3114	/* we need to initialize some time vars before we can encode b-frames */
3115	3115	// RAL: Condition added for MPEG1VIDEO
3116		− if (s->codec_id == CODEC_ID_MPEG1VIDEO \|\| s->codec_id == CODEC_ID_MPEG2VIDEO \|\| (s->h263_pred && !s->msmpeg4_version))
	3116	+ if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO \|\| s->codec_id == AV_CODEC_ID_MPEG2VIDEO \|\| (s->h263_pred && !s->msmpeg4_version))
3117	3117	set_frame_distances(s);
3118		− if(CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4)
	3118	+ if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3119	3119	ff_set_mpeg4_time(s);
3120	3120
3121	3121	s->me.scene_change_score=0;
@@ -3126,7 +3126,7 @@ static int encode_picture(MpegEncContext *s, int picture_number) · 4 unmodified lines
3126	3126	if(s->msmpeg4_version >= 3) s->no_rounding=1;
3127	3127	else s->no_rounding=0;
3128	3128	}else if(s->pict_type!=AV_PICTURE_TYPE_B){
3129		− if(s->flipflop_rounding \|\| s->codec_id == CODEC_ID_H263P \|\| s->codec_id == CODEC_ID_MPEG4)
	3129	+ if(s->flipflop_rounding \|\| s->codec_id == AV_CODEC_ID_H263P \|\| s->codec_id == AV_CODEC_ID_MPEG4)
3130	3130	s->no_rounding ^= 1;
3131	3131	}
3132	3132
@@ -3280,17 +3280,17 @@ static int encode_picture(MpegEncContext *s, int picture_number) · 147 unmodified lines
3280	3280	ff_h261_encode_picture_header(s, picture_number);
3281	3281	break;
3282	3282	case FMT_H263:
3283		− if (CONFIG_WMV2_ENCODER && s->codec_id == CODEC_ID_WMV2)
	3283	+ if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3284	3284	ff_wmv2_encode_picture_header(s, picture_number);
3285	3285	else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3286	3286	ff_msmpeg4_encode_picture_header(s, picture_number);
3287	3287	else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3288	3288	ff_mpeg4_encode_picture_header(s, picture_number);
3289		− else if (CONFIG_RV10_ENCODER && s->codec_id == CODEC_ID_RV10)
	3289	+ else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3290	3290	ff_rv10_encode_picture_header(s, picture_number);
3291		− else if (CONFIG_RV20_ENCODER && s->codec_id == CODEC_ID_RV20)
	3291	+ else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3292	3292	ff_rv20_encode_picture_header(s, picture_number);
3293		− else if (CONFIG_FLV_ENCODER && s->codec_id == CODEC_ID_FLV1)
	3293	+ else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3294	3294	ff_flv_encode_picture_header(s, picture_number);
3295	3295	else if (CONFIG_H263_ENCODER)
3296	3296	ff_h263_encode_picture_header(s, picture_number);
@@ -4129,7 +4129,7 @@ static const AVClass h263_class = { · 832 unmodified lines
4129	4129	AVCodec ff_h263_encoder = {
4130	4130	.name = "h263",
4131	4131	.type = AVMEDIA_TYPE_VIDEO,
4132		− .id = CODEC_ID_H263,
	4132	+ .id = AV_CODEC_ID_H263,
4133	4133	.priv_data_size = sizeof(MpegEncContext),
4134	4134	.init = ff_MPV_encode_init,
4135	4135	.encode2 = ff_MPV_encode_picture,
@@ -4157,7 +4157,7 @@ static const AVClass h263p_class = { · 21 unmodified lines
4157	4157	AVCodec ff_h263p_encoder = {
4158	4158	.name = "h263p",
4159	4159	.type = AVMEDIA_TYPE_VIDEO,
4160		− .id = CODEC_ID_H263P,
	4160	+ .id = AV_CODEC_ID_H263P,
4161	4161	.priv_data_size = sizeof(MpegEncContext),
4162	4162	.init = ff_MPV_encode_init,
4163	4163	.encode2 = ff_MPV_encode_picture,
@@ -4173,7 +4173,7 @@ FF_MPV_GENERIC_CLASS(msmpeg4v2) · 9 unmodified lines
4173	4173	AVCodec ff_msmpeg4v2_encoder = {
4174	4174	.name = "msmpeg4v2",
4175	4175	.type = AVMEDIA_TYPE_VIDEO,
4176		− .id = CODEC_ID_MSMPEG4V2,
	4176	+ .id = AV_CODEC_ID_MSMPEG4V2,
4177	4177	.priv_data_size = sizeof(MpegEncContext),
4178	4178	.init = ff_MPV_encode_init,
4179	4179	.encode2 = ff_MPV_encode_picture,
@@ -4188,7 +4188,7 @@ FF_MPV_GENERIC_CLASS(msmpeg4v3) · 8 unmodified lines
4188	4188	AVCodec ff_msmpeg4v3_encoder = {
4189	4189	.name = "msmpeg4",
4190	4190	.type = AVMEDIA_TYPE_VIDEO,
4191		− .id = CODEC_ID_MSMPEG4V3,
	4191	+ .id = AV_CODEC_ID_MSMPEG4V3,
4192	4192	.priv_data_size = sizeof(MpegEncContext),
4193	4193	.init = ff_MPV_encode_init,
4194	4194	.encode2 = ff_MPV_encode_picture,
@@ -4203,7 +4203,7 @@ FF_MPV_GENERIC_CLASS(wmv1) · 8 unmodified lines
4203	4203	AVCodec ff_wmv1_encoder = {
4204	4204	.name = "wmv1",
4205	4205	.type = AVMEDIA_TYPE_VIDEO,
4206		− .id = CODEC_ID_WMV1,
	4206	+ .id = AV_CODEC_ID_WMV1,
4207	4207	.priv_data_size = sizeof(MpegEncContext),
4208	4208	.init = ff_MPV_encode_init,
4209	4209	.encode2 = ff_MPV_encode_picture,

libavcodec/mpegvideo_parser.c+3−3

@@ -68,7 +68,7 @@ static void mpegvideo_extract_headers(AVCodecParserContext *s, · 67 unmodified lines
68	68	pc->frame_rate.den = avctx->time_base.den = avpriv_frame_rate_tab[frame_rate_index].num;
69	69	pc->frame_rate.num = avctx->time_base.num = avpriv_frame_rate_tab[frame_rate_index].den;
70	70	avctx->bit_rate = ((buf[4]<<10) \| (buf[5]<<2) \| (buf[6]>>6))*400;
71		− avctx->codec_id = CODEC_ID_MPEG1VIDEO;
	71	+ avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
72	72	}
73	73	break;
74	74	case EXT_START_CODE:
@@ -92,7 +92,7 @@ static void mpegvideo_extract_headers(AVCodecParserContext *s, · 17 unmodified lines
92	92	avcodec_set_dimensions(avctx, pc->width, pc->height);
93	93	avctx->time_base.den = pc->frame_rate.den * (frame_rate_ext_n + 1) * 2;
94	94	avctx->time_base.num = pc->frame_rate.num * (frame_rate_ext_d + 1);
95		− avctx->codec_id = CODEC_ID_MPEG2VIDEO;
	95	+ avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
96	96	}
97	97	break;
98	98	case 0x8: /* picture coding extension */
@@ -180,7 +180,7 @@ static int mpegvideo_split(AVCodecContext *avctx, · 81 unmodified lines
180	180	}
181	181
182	182	AVCodecParser ff_mpegvideo_parser = {
183		− .codec_ids = { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
	183	+ .codec_ids = { AV_CODEC_ID_MPEG1VIDEO, AV_CODEC_ID_MPEG2VIDEO },
184	184	.priv_data_size = sizeof(struct MpvParseContext),
185	185	.parser_parse = mpegvideo_parse,
186	186	.parser_close = ff_parse_close,

libavcodec/msmpeg4.c+4−4

@@ -1210,7 +1210,7 @@ int ff_msmpeg4_decode_motion(MpegEncContext * s, · 1209 unmodified lines
1210	1210	AVCodec ff_msmpeg4v1_decoder = {
1211	1211	.name = "msmpeg4v1",
1212	1212	.type = AVMEDIA_TYPE_VIDEO,
1213		− .id = CODEC_ID_MSMPEG4V1,
	1213	+ .id = AV_CODEC_ID_MSMPEG4V1,
1214	1214	.priv_data_size = sizeof(MpegEncContext),
1215	1215	.init = ff_msmpeg4_decode_init,
1216	1216	.close = ff_h263_decode_end,
@@ -1223,7 +1223,7 @@ AVCodec ff_msmpeg4v1_decoder = { · 6 unmodified lines
1223	1223	AVCodec ff_msmpeg4v2_decoder = {
1224	1224	.name = "msmpeg4v2",
1225	1225	.type = AVMEDIA_TYPE_VIDEO,
1226		− .id = CODEC_ID_MSMPEG4V2,
	1226	+ .id = AV_CODEC_ID_MSMPEG4V2,
1227	1227	.priv_data_size = sizeof(MpegEncContext),
1228	1228	.init = ff_msmpeg4_decode_init,
1229	1229	.close = ff_h263_decode_end,
@@ -1236,7 +1236,7 @@ AVCodec ff_msmpeg4v2_decoder = { · 6 unmodified lines
1236	1236	AVCodec ff_msmpeg4v3_decoder = {
1237	1237	.name = "msmpeg4",
1238	1238	.type = AVMEDIA_TYPE_VIDEO,
1239		− .id = CODEC_ID_MSMPEG4V3,
	1239	+ .id = AV_CODEC_ID_MSMPEG4V3,
1240	1240	.priv_data_size = sizeof(MpegEncContext),
1241	1241	.init = ff_msmpeg4_decode_init,
1242	1242	.close = ff_h263_decode_end,
@@ -1249,7 +1249,7 @@ AVCodec ff_msmpeg4v3_decoder = { · 6 unmodified lines
1249	1249	AVCodec ff_wmv1_decoder = {
1250	1250	.name = "wmv1",
1251	1251	.type = AVMEDIA_TYPE_VIDEO,
1252		− .id = CODEC_ID_WMV1,
	1252	+ .id = AV_CODEC_ID_WMV1,
1253	1253	.priv_data_size = sizeof(MpegEncContext),
1254	1254	.init = ff_msmpeg4_decode_init,
1255	1255	.close = ff_h263_decode_end,

libavcodec/msrle.c+1−1

@@ -149,7 +149,7 @@ static av_cold int msrle_decode_end(AVCodecContext *avctx) · 148 unmodified lines
149	149	AVCodec ff_msrle_decoder = {
150	150	.name = "msrle",
151	151	.type = AVMEDIA_TYPE_VIDEO,
152		− .id = CODEC_ID_MSRLE,
	152	+ .id = AV_CODEC_ID_MSRLE,
153	153	.priv_data_size = sizeof(MsrleContext),
154	154	.init = msrle_decode_init,
155	155	.close = msrle_decode_end,

libavcodec/mss1.c+1−1

@@ -841,7 +841,7 @@ static av_cold int mss1_decode_end(AVCodecContext *avctx) · 840 unmodified lines
841	841	AVCodec ff_mss1_decoder = {
842	842	.name = "mss1",
843	843	.type = AVMEDIA_TYPE_VIDEO,
844		− .id = CODEC_ID_MSS1,
	844	+ .id = AV_CODEC_ID_MSS1,
845	845	.priv_data_size = sizeof(MSS1Context),
846	846	.init = mss1_decode_init,
847	847	.close = mss1_decode_end,

libavcodec/mss3.c+1−1

@@ -859,7 +859,7 @@ static av_cold int mss3_decode_end(AVCodecContext *avctx) · 858 unmodified lines
859	859	AVCodec ff_msa1_decoder = {
860	860	.name = "msa1",
861	861	.type = AVMEDIA_TYPE_VIDEO,
862		− .id = CODEC_ID_MSA1,
	862	+ .id = AV_CODEC_ID_MSA1,
863	863	.priv_data_size = sizeof(MSS3Context),
864	864	.init = mss3_decode_init,
865	865	.close = mss3_decode_end,

libavcodec/mss4.c+1−1

@@ -672,7 +672,7 @@ static av_cold int mss4_decode_end(AVCodecContext *avctx) · 671 unmodified lines
672	672	AVCodec ff_mts2_decoder = {
673	673	.name = "mts2",
674	674	.type = AVMEDIA_TYPE_VIDEO,
675		− .id = CODEC_ID_MTS2,
	675	+ .id = AV_CODEC_ID_MTS2,
676	676	.priv_data_size = sizeof(MSS4Context),
677	677	.init = mss4_decode_init,
678	678	.close = mss4_decode_end,

libavcodec/msvideo1.c+1−1

@@ -336,7 +336,7 @@ static av_cold int msvideo1_decode_end(AVCodecContext *avctx) · 335 unmodified lines
336	336	AVCodec ff_msvideo1_decoder = {
337	337	.name = "msvideo1",
338	338	.type = AVMEDIA_TYPE_VIDEO,
339		− .id = CODEC_ID_MSVIDEO1,
	339	+ .id = AV_CODEC_ID_MSVIDEO1,
340	340	.priv_data_size = sizeof(Msvideo1Context),
341	341	.init = msvideo1_decode_init,
342	342	.close = msvideo1_decode_end,

libavcodec/mxpegdec.c+1−1

@@ -332,7 +332,7 @@ AVCodec ff_mxpeg_decoder = { · 331 unmodified lines
332	332	.name = "mxpeg",
333	333	.long_name = NULL_IF_CONFIG_SMALL("Mobotix MxPEG video"),
334	334	.type = AVMEDIA_TYPE_VIDEO,
335		− .id = CODEC_ID_MXPEG,
	335	+ .id = AV_CODEC_ID_MXPEG,
336	336	.priv_data_size = sizeof(MXpegDecodeContext),
337	337	.init = mxpeg_decode_init,
338	338	.close = mxpeg_decode_end,

libavcodec/nellymoserdec.c+1−1

@@ -216,7 +216,7 @@ static av_cold int decode_end(AVCodecContext * avctx) { · 215 unmodified lines
216	216	AVCodec ff_nellymoser_decoder = {
217	217	.name = "nellymoser",
218	218	.type = AVMEDIA_TYPE_AUDIO,
219		− .id = CODEC_ID_NELLYMOSER,
	219	+ .id = AV_CODEC_ID_NELLYMOSER,
220	220	.priv_data_size = sizeof(NellyMoserDecodeContext),
221	221	.init = decode_init,
222	222	.close = decode_end,

libavcodec/nellymoserenc.c+1−1

@@ -421,7 +421,7 @@ static int encode_frame(AVCodecContext avctx, AVPacket avpkt, · 420 unmodified lines
421	421	AVCodec ff_nellymoser_encoder = {
422	422	.name = "nellymoser",
423	423	.type = AVMEDIA_TYPE_AUDIO,
424		− .id = CODEC_ID_NELLYMOSER,
	424	+ .id = AV_CODEC_ID_NELLYMOSER,
425	425	.priv_data_size = sizeof(NellyMoserEncodeContext),
426	426	.init = encode_init,
427	427	.encode2 = encode_frame,

libavcodec/nuv.c+1−1

@@ -302,7 +302,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 301 unmodified lines
302	302	AVCodec ff_nuv_decoder = {
303	303	.name = "nuv",
304	304	.type = AVMEDIA_TYPE_VIDEO,
305		− .id = CODEC_ID_NUV,
	305	+ .id = AV_CODEC_ID_NUV,
306	306	.priv_data_size = sizeof(NuvContext),
307	307	.init = decode_init,
308	308	.close = decode_end,

libavcodec/pamenc.c+1−1

@@ -117,7 +117,7 @@ static int pam_encode_frame(AVCodecContext avctx, AVPacket pkt, · 116 unmodified lines
117	117	AVCodec ff_pam_encoder = {
118	118	.name = "pam",
119	119	.type = AVMEDIA_TYPE_VIDEO,
120		− .id = CODEC_ID_PAM,
	120	+ .id = AV_CODEC_ID_PAM,
121	121	.priv_data_size = sizeof(PNMContext),
122	122	.init = ff_pnm_init,
123	123	.encode2 = pam_encode_frame,

libavcodec/parser.c+1−1

@@ -41,7 +41,7 @@ AVCodecParserContext *av_parser_init(int codec_id) · 40 unmodified lines
41	41	AVCodecParser *parser;
42	42	int ret;
43	43
44		− if(codec_id == CODEC_ID_NONE)
	44	+ if(codec_id == AV_CODEC_ID_NONE)
45	45	return NULL;
46	46
47	47	for(parser = av_first_parser; parser != NULL; parser = parser->next) {

libavcodec/pcm-mpeg.c+1−1

@@ -317,7 +317,7 @@ static int pcm_bluray_decode_frame(AVCodecContext avctx, void data, · 316 unmodified lines
317	317	AVCodec ff_pcm_bluray_decoder = {
318	318	.name = "pcm_bluray",
319	319	.type = AVMEDIA_TYPE_AUDIO,
320		− .id = CODEC_ID_PCM_BLURAY,
	320	+ .id = AV_CODEC_ID_PCM_BLURAY,
321	321	.priv_data_size = sizeof(PCMBRDecode),
322	322	.init = pcm_bluray_decode_init,
323	323	.decode = pcm_bluray_decode_frame,

libavcodec/pcm.c+94−94

@@ -36,10 +36,10 @@ static av_cold int pcm_encode_init(AVCodecContext *avctx) · 35 unmodified lines
36	36	{
37	37	avctx->frame_size = 0;
38	38	switch (avctx->codec->id) {
39		− case CODEC_ID_PCM_ALAW:
	39	+ case AV_CODEC_ID_PCM_ALAW:
40	40	pcm_alaw_tableinit();
41	41	break;
42		− case CODEC_ID_PCM_MULAW:
	42	+ case AV_CODEC_ID_PCM_MULAW:
43	43	pcm_ulaw_tableinit();
44	44	break;
45	45	default:
@@ -104,25 +104,25 @@ static int pcm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 58 unmodified lines
104	104	dst = avpkt->data;
105	105
106	106	switch (avctx->codec->id) {
107		− case CODEC_ID_PCM_U32LE:
	107	+ case AV_CODEC_ID_PCM_U32LE:
108	108	ENCODE(uint32_t, le32, samples, dst, n, 0, 0x80000000)
109	109	break;
110		− case CODEC_ID_PCM_U32BE:
	110	+ case AV_CODEC_ID_PCM_U32BE:
111	111	ENCODE(uint32_t, be32, samples, dst, n, 0, 0x80000000)
112	112	break;
113		− case CODEC_ID_PCM_S24LE:
	113	+ case AV_CODEC_ID_PCM_S24LE:
114	114	ENCODE(int32_t, le24, samples, dst, n, 8, 0)
115	115	break;
116		− case CODEC_ID_PCM_S24BE:
	116	+ case AV_CODEC_ID_PCM_S24BE:
117	117	ENCODE(int32_t, be24, samples, dst, n, 8, 0)
118	118	break;
119		− case CODEC_ID_PCM_U24LE:
	119	+ case AV_CODEC_ID_PCM_U24LE:
120	120	ENCODE(uint32_t, le24, samples, dst, n, 8, 0x800000)
121	121	break;
122		− case CODEC_ID_PCM_U24BE:
	122	+ case AV_CODEC_ID_PCM_U24BE:
123	123	ENCODE(uint32_t, be24, samples, dst, n, 8, 0x800000)
124	124	break;
125		− case CODEC_ID_PCM_S24DAUD:
	125	+ case AV_CODEC_ID_PCM_S24DAUD:
126	126	for (; n > 0; n--) {
127	127	uint32_t tmp = av_reverse[(*samples >> 8) & 0xff] +
128	128	(av_reverse[*samples & 0xff] << 8);
@@ -131,13 +131,13 @@ static int pcm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 2 unmodified lines
131	131	samples++;
132	132	}
133	133	break;
134		− case CODEC_ID_PCM_U16LE:
	134	+ case AV_CODEC_ID_PCM_U16LE:
135	135	ENCODE(uint16_t, le16, samples, dst, n, 0, 0x8000)
136	136	break;
137		− case CODEC_ID_PCM_U16BE:
	137	+ case AV_CODEC_ID_PCM_U16BE:
138	138	ENCODE(uint16_t, be16, samples, dst, n, 0, 0x8000)
139	139	break;
140		− case CODEC_ID_PCM_S8:
	140	+ case AV_CODEC_ID_PCM_S8:
141	141	srcu8 = frame->data[0];
142	142	for (; n > 0; n--) {
143	143	v = *srcu8++;
@@ -145,47 +145,47 @@ static int pcm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 1 unmodified line
145	145	}
146	146	break;
147	147	#if HAVE_BIGENDIAN
148		− case CODEC_ID_PCM_F64LE:
	148	+ case AV_CODEC_ID_PCM_F64LE:
149	149	ENCODE(int64_t, le64, samples, dst, n, 0, 0)
150	150	break;
151		− case CODEC_ID_PCM_S32LE:
152		− case CODEC_ID_PCM_F32LE:
	151	+ case AV_CODEC_ID_PCM_S32LE:
	152	+ case AV_CODEC_ID_PCM_F32LE:
153	153	ENCODE(int32_t, le32, samples, dst, n, 0, 0)
154	154	break;
155		− case CODEC_ID_PCM_S16LE:
	155	+ case AV_CODEC_ID_PCM_S16LE:
156	156	ENCODE(int16_t, le16, samples, dst, n, 0, 0)
157	157	break;
158		− case CODEC_ID_PCM_F64BE:
159		− case CODEC_ID_PCM_F32BE:
160		− case CODEC_ID_PCM_S32BE:
161		− case CODEC_ID_PCM_S16BE:
	158	+ case AV_CODEC_ID_PCM_F64BE:
	159	+ case AV_CODEC_ID_PCM_F32BE:
	160	+ case AV_CODEC_ID_PCM_S32BE:
	161	+ case AV_CODEC_ID_PCM_S16BE:
162	162	#else
163		− case CODEC_ID_PCM_F64BE:
	163	+ case AV_CODEC_ID_PCM_F64BE:
164	164	ENCODE(int64_t, be64, samples, dst, n, 0, 0)
165	165	break;
166		− case CODEC_ID_PCM_F32BE:
167		− case CODEC_ID_PCM_S32BE:
	166	+ case AV_CODEC_ID_PCM_F32BE:
	167	+ case AV_CODEC_ID_PCM_S32BE:
168	168	ENCODE(int32_t, be32, samples, dst, n, 0, 0)
169	169	break;
170		− case CODEC_ID_PCM_S16BE:
	170	+ case AV_CODEC_ID_PCM_S16BE:
171	171	ENCODE(int16_t, be16, samples, dst, n, 0, 0)
172	172	break;
173		− case CODEC_ID_PCM_F64LE:
174		− case CODEC_ID_PCM_F32LE:
175		− case CODEC_ID_PCM_S32LE:
176		− case CODEC_ID_PCM_S16LE:
	173	+ case AV_CODEC_ID_PCM_F64LE:
	174	+ case AV_CODEC_ID_PCM_F32LE:
	175	+ case AV_CODEC_ID_PCM_S32LE:
	176	+ case AV_CODEC_ID_PCM_S16LE:
177	177	#endif /* HAVE_BIGENDIAN */
178		− case CODEC_ID_PCM_U8:
	178	+ case AV_CODEC_ID_PCM_U8:
179	179	memcpy(dst, samples, n * sample_size);
180	180	dst += n * sample_size;
181	181	break;
182		− case CODEC_ID_PCM_ALAW:
	182	+ case AV_CODEC_ID_PCM_ALAW:
183	183	for (; n > 0; n--) {
184	184	v = *samples++;
185	185	*dst++ = linear_to_alaw[(v + 32768) >> 2];
186	186	}
187	187	break;
188		− case CODEC_ID_PCM_MULAW:
	188	+ case AV_CODEC_ID_PCM_MULAW:
189	189	for (; n > 0; n--) {
190	190	v = *samples++;
191	191	*dst++ = linear_to_ulaw[(v + 32768) >> 2];
@@ -215,11 +215,11 @@ static av_cold int pcm_decode_init(AVCodecContext *avctx) · 23 unmodified lines
215	215	}
216	216
217	217	switch (avctx->codec->id) {
218		− case CODEC_ID_PCM_ALAW:
	218	+ case AV_CODEC_ID_PCM_ALAW:
219	219	for (i = 0; i < 256; i++)
220	220	s->table[i] = alaw2linear(i);
221	221	break;
222		− case CODEC_ID_PCM_MULAW:
	222	+ case AV_CODEC_ID_PCM_MULAW:
223	223	for (i = 0; i < 256; i++)
224	224	s->table[i] = ulaw2linear(i);
225	225	break;
@@ -267,9 +267,9 @@ static int pcm_decode_frame(AVCodecContext avctx, void data, · 41 unmodified lines
267	267
268	268	sample_size = av_get_bits_per_sample(avctx->codec_id) / 8;
269	269
270		− /* av_get_bits_per_sample returns 0 for CODEC_ID_PCM_DVD */
	270	+ /* av_get_bits_per_sample returns 0 for AV_CODEC_ID_PCM_DVD */
271	271	samples_per_block = 1;
272		− if (CODEC_ID_PCM_DVD == avctx->codec_id) {
	272	+ if (AV_CODEC_ID_PCM_DVD == avctx->codec_id) {
273	273	if (avctx->bits_per_coded_sample != 20 &&
274	274	avctx->bits_per_coded_sample != 24) {
275	275	av_log(avctx, AV_LOG_ERROR, "PCM DVD unsupported sample depth\n");
@@ -278,7 +278,7 @@ static int pcm_decode_frame(AVCodecContext avctx, void data, · 2 unmodified lines
278	278	/* 2 samples are interleaved per block in PCM_DVD */
279	279	samples_per_block = 2;
280	280	sample_size = avctx->bits_per_coded_sample * 2 / 8;
281		− } else if (avctx->codec_id == CODEC_ID_PCM_LXF) {
	281	+ } else if (avctx->codec_id == AV_CODEC_ID_PCM_LXF) {
282	282	/* we process 40-bit blocks per channel for LXF */
283	283	samples_per_block = 2;
284	284	sample_size = 5;
@@ -310,25 +310,25 @@ static int pcm_decode_frame(AVCodecContext avctx, void data, · 25 unmodified lines
310	310	samples = s->frame.data[0];
311	311
312	312	switch (avctx->codec->id) {
313		− case CODEC_ID_PCM_U32LE:
	313	+ case AV_CODEC_ID_PCM_U32LE:
314	314	DECODE(32, le32, src, samples, n, 0, 0x80000000)
315	315	break;
316		− case CODEC_ID_PCM_U32BE:
	316	+ case AV_CODEC_ID_PCM_U32BE:
317	317	DECODE(32, be32, src, samples, n, 0, 0x80000000)
318	318	break;
319		− case CODEC_ID_PCM_S24LE:
	319	+ case AV_CODEC_ID_PCM_S24LE:
320	320	DECODE(32, le24, src, samples, n, 8, 0)
321	321	break;
322		− case CODEC_ID_PCM_S24BE:
	322	+ case AV_CODEC_ID_PCM_S24BE:
323	323	DECODE(32, be24, src, samples, n, 8, 0)
324	324	break;
325		− case CODEC_ID_PCM_U24LE:
	325	+ case AV_CODEC_ID_PCM_U24LE:
326	326	DECODE(32, le24, src, samples, n, 8, 0x800000)
327	327	break;
328		− case CODEC_ID_PCM_U24BE:
	328	+ case AV_CODEC_ID_PCM_U24BE:
329	329	DECODE(32, be24, src, samples, n, 8, 0x800000)
330	330	break;
331		− case CODEC_ID_PCM_S24DAUD:
	331	+ case AV_CODEC_ID_PCM_S24DAUD:
332	332	for (; n > 0; n--) {
333	333	uint32_t v = bytestream_get_be24(&src);
334	334	v >>= 4; // sync flags are here
@@ -337,7 +337,7 @@ static int pcm_decode_frame(AVCodecContext avctx, void data, · 2 unmodified lines
337	337	samples += 2;
338	338	}
339	339	break;
340		− case CODEC_ID_PCM_S16LE_PLANAR:
	340	+ case AV_CODEC_ID_PCM_S16LE_PLANAR:
341	341	{
342	342	const uint8_t *src2[MAX_CHANNELS];
343	343	n /= avctx->channels;
@@ -350,51 +350,51 @@ static int pcm_decode_frame(AVCodecContext avctx, void data, · 6 unmodified lines
350	350	}
351	351	break;
352	352	}
353		− case CODEC_ID_PCM_U16LE:
	353	+ case AV_CODEC_ID_PCM_U16LE:
354	354	DECODE(16, le16, src, samples, n, 0, 0x8000)
355	355	break;
356		− case CODEC_ID_PCM_U16BE:
	356	+ case AV_CODEC_ID_PCM_U16BE:
357	357	DECODE(16, be16, src, samples, n, 0, 0x8000)
358	358	break;
359		− case CODEC_ID_PCM_S8:
	359	+ case AV_CODEC_ID_PCM_S8:
360	360	for (; n > 0; n--)
361	361	samples++ = src++ + 128;
362	362	break;
363	363	#if HAVE_BIGENDIAN
364		− case CODEC_ID_PCM_F64LE:
	364	+ case AV_CODEC_ID_PCM_F64LE:
365	365	DECODE(64, le64, src, samples, n, 0, 0)
366	366	break;
367		− case CODEC_ID_PCM_S32LE:
368		− case CODEC_ID_PCM_F32LE:
	367	+ case AV_CODEC_ID_PCM_S32LE:
	368	+ case AV_CODEC_ID_PCM_F32LE:
369	369	DECODE(32, le32, src, samples, n, 0, 0)
370	370	break;
371		− case CODEC_ID_PCM_S16LE:
	371	+ case AV_CODEC_ID_PCM_S16LE:
372	372	DECODE(16, le16, src, samples, n, 0, 0)
373	373	break;
374		− case CODEC_ID_PCM_F64BE:
375		− case CODEC_ID_PCM_F32BE:
376		− case CODEC_ID_PCM_S32BE:
377		− case CODEC_ID_PCM_S16BE:
	374	+ case AV_CODEC_ID_PCM_F64BE:
	375	+ case AV_CODEC_ID_PCM_F32BE:
	376	+ case AV_CODEC_ID_PCM_S32BE:
	377	+ case AV_CODEC_ID_PCM_S16BE:
378	378	#else
379		− case CODEC_ID_PCM_F64BE:
	379	+ case AV_CODEC_ID_PCM_F64BE:
380	380	DECODE(64, be64, src, samples, n, 0, 0)
381	381	break;
382		− case CODEC_ID_PCM_F32BE:
383		− case CODEC_ID_PCM_S32BE:
	382	+ case AV_CODEC_ID_PCM_F32BE:
	383	+ case AV_CODEC_ID_PCM_S32BE:
384	384	DECODE(32, be32, src, samples, n, 0, 0)
385	385	break;
386		− case CODEC_ID_PCM_S16BE:
	386	+ case AV_CODEC_ID_PCM_S16BE:
387	387	DECODE(16, be16, src, samples, n, 0, 0)
388	388	break;
389		− case CODEC_ID_PCM_F64LE:
390		− case CODEC_ID_PCM_F32LE:
391		− case CODEC_ID_PCM_S32LE:
392		− case CODEC_ID_PCM_S16LE:
	389	+ case AV_CODEC_ID_PCM_F64LE:
	390	+ case AV_CODEC_ID_PCM_F32LE:
	391	+ case AV_CODEC_ID_PCM_S32LE:
	392	+ case AV_CODEC_ID_PCM_S16LE:
393	393	#endif /* HAVE_BIGENDIAN */
394		− case CODEC_ID_PCM_U8:
	394	+ case AV_CODEC_ID_PCM_U8:
395	395	memcpy(samples, src, n * sample_size);
396	396	break;
397		− case CODEC_ID_PCM_ZORK:
	397	+ case AV_CODEC_ID_PCM_ZORK:
398	398	for (; n > 0; n--) {
399	399	int v = *src++;
400	400	if (v < 128)
@@ -402,14 +402,14 @@ static int pcm_decode_frame(AVCodecContext avctx, void data, · 1 unmodified line
402	402	*samples++ = v;
403	403	}
404	404	break;
405		− case CODEC_ID_PCM_ALAW:
406		− case CODEC_ID_PCM_MULAW:
	405	+ case AV_CODEC_ID_PCM_ALAW:
	406	+ case AV_CODEC_ID_PCM_MULAW:
407	407	for (; n > 0; n--) {
408	408	AV_WN16A(samples, s->table[*src++]);
409	409	samples += 2;
410	410	}
411	411	break;
412		− case CODEC_ID_PCM_DVD:
	412	+ case AV_CODEC_ID_PCM_DVD:
413	413	{
414	414	const uint8_t *src8;
415	415	dst_int32_t = (int32_t *)s->frame.data[0];
@@ -440,7 +440,7 @@ static int pcm_decode_frame(AVCodecContext avctx, void data, · 24 unmodified lines
440	440	}
441	441	break;
442	442	}
443		− case CODEC_ID_PCM_LXF:
	443	+ case AV_CODEC_ID_PCM_LXF:
444	444	{
445	445	int i;
446	446	const uint8_t *src8;
@@ -518,28 +518,28 @@ AVCodec ff_ ## name_ ## _decoder = { \ · 71 unmodified lines
518	518	PCM_DECODER(id, sample_fmt_, name, long_name_)
519	519
520	520	/* Note: Do not forget to add new entries to the Makefile as well. */
521		−PCM_CODEC (CODEC_ID_PCM_ALAW, AV_SAMPLE_FMT_S16, pcm_alaw, "PCM A-law");
522		−PCM_DECODER(CODEC_ID_PCM_DVD, AV_SAMPLE_FMT_S32, pcm_dvd, "PCM signed 20\|24-bit big-endian");
523		−PCM_CODEC (CODEC_ID_PCM_F32BE, AV_SAMPLE_FMT_FLT, pcm_f32be, "PCM 32-bit floating point big-endian");
524		−PCM_CODEC (CODEC_ID_PCM_F32LE, AV_SAMPLE_FMT_FLT, pcm_f32le, "PCM 32-bit floating point little-endian");
525		−PCM_CODEC (CODEC_ID_PCM_F64BE, AV_SAMPLE_FMT_DBL, pcm_f64be, "PCM 64-bit floating point big-endian");
526		−PCM_CODEC (CODEC_ID_PCM_F64LE, AV_SAMPLE_FMT_DBL, pcm_f64le, "PCM 64-bit floating point little-endian");
527		−PCM_DECODER(CODEC_ID_PCM_LXF, AV_SAMPLE_FMT_S32, pcm_lxf, "PCM signed 20-bit little-endian planar");
528		−PCM_CODEC (CODEC_ID_PCM_MULAW, AV_SAMPLE_FMT_S16, pcm_mulaw, "PCM mu-law");
529		−PCM_CODEC (CODEC_ID_PCM_S8, AV_SAMPLE_FMT_U8, pcm_s8, "PCM signed 8-bit");
530		−PCM_CODEC (CODEC_ID_PCM_S16BE, AV_SAMPLE_FMT_S16, pcm_s16be, "PCM signed 16-bit big-endian");
531		−PCM_CODEC (CODEC_ID_PCM_S16LE, AV_SAMPLE_FMT_S16, pcm_s16le, "PCM signed 16-bit little-endian");
532		−PCM_DECODER(CODEC_ID_PCM_S16LE_PLANAR, AV_SAMPLE_FMT_S16, pcm_s16le_planar, "PCM 16-bit little-endian planar");
533		−PCM_CODEC (CODEC_ID_PCM_S24BE, AV_SAMPLE_FMT_S32, pcm_s24be, "PCM signed 24-bit big-endian");
534		−PCM_CODEC (CODEC_ID_PCM_S24DAUD, AV_SAMPLE_FMT_S16, pcm_s24daud, "PCM D-Cinema audio signed 24-bit");
535		−PCM_CODEC (CODEC_ID_PCM_S24LE, AV_SAMPLE_FMT_S32, pcm_s24le, "PCM signed 24-bit little-endian");
536		−PCM_CODEC (CODEC_ID_PCM_S32BE, AV_SAMPLE_FMT_S32, pcm_s32be, "PCM signed 32-bit big-endian");
537		−PCM_CODEC (CODEC_ID_PCM_S32LE, AV_SAMPLE_FMT_S32, pcm_s32le, "PCM signed 32-bit little-endian");
538		−PCM_CODEC (CODEC_ID_PCM_U8, AV_SAMPLE_FMT_U8, pcm_u8, "PCM unsigned 8-bit");
539		−PCM_CODEC (CODEC_ID_PCM_U16BE, AV_SAMPLE_FMT_S16, pcm_u16be, "PCM unsigned 16-bit big-endian");
540		−PCM_CODEC (CODEC_ID_PCM_U16LE, AV_SAMPLE_FMT_S16, pcm_u16le, "PCM unsigned 16-bit little-endian");
541		−PCM_CODEC (CODEC_ID_PCM_U24BE, AV_SAMPLE_FMT_S32, pcm_u24be, "PCM unsigned 24-bit big-endian");
542		−PCM_CODEC (CODEC_ID_PCM_U24LE, AV_SAMPLE_FMT_S32, pcm_u24le, "PCM unsigned 24-bit little-endian");
543		−PCM_CODEC (CODEC_ID_PCM_U32BE, AV_SAMPLE_FMT_S32, pcm_u32be, "PCM unsigned 32-bit big-endian");
544		−PCM_CODEC (CODEC_ID_PCM_U32LE, AV_SAMPLE_FMT_S32, pcm_u32le, "PCM unsigned 32-bit little-endian");
545		−PCM_DECODER(CODEC_ID_PCM_ZORK, AV_SAMPLE_FMT_U8, pcm_zork, "PCM Zork");
	521	+PCM_CODEC (AV_CODEC_ID_PCM_ALAW, AV_SAMPLE_FMT_S16, pcm_alaw, "PCM A-law");
	522	+PCM_DECODER(AV_CODEC_ID_PCM_DVD, AV_SAMPLE_FMT_S32, pcm_dvd, "PCM signed 20\|24-bit big-endian");
	523	+PCM_CODEC (AV_CODEC_ID_PCM_F32BE, AV_SAMPLE_FMT_FLT, pcm_f32be, "PCM 32-bit floating point big-endian");
	524	+PCM_CODEC (AV_CODEC_ID_PCM_F32LE, AV_SAMPLE_FMT_FLT, pcm_f32le, "PCM 32-bit floating point little-endian");
	525	+PCM_CODEC (AV_CODEC_ID_PCM_F64BE, AV_SAMPLE_FMT_DBL, pcm_f64be, "PCM 64-bit floating point big-endian");
	526	+PCM_CODEC (AV_CODEC_ID_PCM_F64LE, AV_SAMPLE_FMT_DBL, pcm_f64le, "PCM 64-bit floating point little-endian");
	527	+PCM_DECODER(AV_CODEC_ID_PCM_LXF, AV_SAMPLE_FMT_S32, pcm_lxf, "PCM signed 20-bit little-endian planar");
	528	+PCM_CODEC (AV_CODEC_ID_PCM_MULAW, AV_SAMPLE_FMT_S16, pcm_mulaw, "PCM mu-law");
	529	+PCM_CODEC (AV_CODEC_ID_PCM_S8, AV_SAMPLE_FMT_U8, pcm_s8, "PCM signed 8-bit");
	530	+PCM_CODEC (AV_CODEC_ID_PCM_S16BE, AV_SAMPLE_FMT_S16, pcm_s16be, "PCM signed 16-bit big-endian");
	531	+PCM_CODEC (AV_CODEC_ID_PCM_S16LE, AV_SAMPLE_FMT_S16, pcm_s16le, "PCM signed 16-bit little-endian");
	532	+PCM_DECODER(AV_CODEC_ID_PCM_S16LE_PLANAR, AV_SAMPLE_FMT_S16, pcm_s16le_planar, "PCM 16-bit little-endian planar");
	533	+PCM_CODEC (AV_CODEC_ID_PCM_S24BE, AV_SAMPLE_FMT_S32, pcm_s24be, "PCM signed 24-bit big-endian");
	534	+PCM_CODEC (AV_CODEC_ID_PCM_S24DAUD, AV_SAMPLE_FMT_S16, pcm_s24daud, "PCM D-Cinema audio signed 24-bit");
	535	+PCM_CODEC (AV_CODEC_ID_PCM_S24LE, AV_SAMPLE_FMT_S32, pcm_s24le, "PCM signed 24-bit little-endian");
	536	+PCM_CODEC (AV_CODEC_ID_PCM_S32BE, AV_SAMPLE_FMT_S32, pcm_s32be, "PCM signed 32-bit big-endian");
	537	+PCM_CODEC (AV_CODEC_ID_PCM_S32LE, AV_SAMPLE_FMT_S32, pcm_s32le, "PCM signed 32-bit little-endian");
	538	+PCM_CODEC (AV_CODEC_ID_PCM_U8, AV_SAMPLE_FMT_U8, pcm_u8, "PCM unsigned 8-bit");
	539	+PCM_CODEC (AV_CODEC_ID_PCM_U16BE, AV_SAMPLE_FMT_S16, pcm_u16be, "PCM unsigned 16-bit big-endian");
	540	+PCM_CODEC (AV_CODEC_ID_PCM_U16LE, AV_SAMPLE_FMT_S16, pcm_u16le, "PCM unsigned 16-bit little-endian");
	541	+PCM_CODEC (AV_CODEC_ID_PCM_U24BE, AV_SAMPLE_FMT_S32, pcm_u24be, "PCM unsigned 24-bit big-endian");
	542	+PCM_CODEC (AV_CODEC_ID_PCM_U24LE, AV_SAMPLE_FMT_S32, pcm_u24le, "PCM unsigned 24-bit little-endian");
	543	+PCM_CODEC (AV_CODEC_ID_PCM_U32BE, AV_SAMPLE_FMT_S32, pcm_u32be, "PCM unsigned 32-bit big-endian");
	544	+PCM_CODEC (AV_CODEC_ID_PCM_U32LE, AV_SAMPLE_FMT_S32, pcm_u32le, "PCM unsigned 32-bit little-endian");
	545	+PCM_DECODER(AV_CODEC_ID_PCM_ZORK, AV_SAMPLE_FMT_U8, pcm_zork, "PCM Zork");

libavcodec/pcx.c+1−1

@@ -250,7 +250,7 @@ static av_cold int pcx_end(AVCodecContext *avctx) { · 249 unmodified lines
250	250	AVCodec ff_pcx_decoder = {
251	251	.name = "pcx",
252	252	.type = AVMEDIA_TYPE_VIDEO,
253		− .id = CODEC_ID_PCX,
	253	+ .id = AV_CODEC_ID_PCX,
254	254	.priv_data_size = sizeof(PCXContext),
255	255	.init = pcx_init,
256	256	.close = pcx_end,

libavcodec/pcxenc.c+1−1

@@ -205,7 +205,7 @@ static int pcx_encode_frame(AVCodecContext avctx, AVPacket pkt, · 204 unmodified lines
205	205	AVCodec ff_pcx_encoder = {
206	206	.name = "pcx",
207	207	.type = AVMEDIA_TYPE_VIDEO,
208		− .id = CODEC_ID_PCX,
	208	+ .id = AV_CODEC_ID_PCX,
209	209	.priv_data_size = sizeof(PCXContext),
210	210	.init = pcx_encode_init,
211	211	.encode2 = pcx_encode_frame,

libavcodec/pgssubdec.c+1−1

@@ -471,7 +471,7 @@ static int decode(AVCodecContext avctx, void data, int *data_size, · 470 unmodified lines
471	471	AVCodec ff_pgssub_decoder = {
472	472	.name = "pgssub",
473	473	.type = AVMEDIA_TYPE_SUBTITLE,
474		− .id = CODEC_ID_HDMV_PGS_SUBTITLE,
	474	+ .id = AV_CODEC_ID_HDMV_PGS_SUBTITLE,
475	475	.priv_data_size = sizeof(PGSSubContext),
476	476	.init = init_decoder,
477	477	.close = close_decoder,

libavcodec/pictordec.c+1−1

@@ -253,7 +253,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 252 unmodified lines
253	253	AVCodec ff_pictor_decoder = {
254	254	.name = "pictor",
255	255	.type = AVMEDIA_TYPE_VIDEO,
256		− .id = CODEC_ID_PICTOR,
	256	+ .id = AV_CODEC_ID_PICTOR,
257	257	.priv_data_size = sizeof(PicContext),
258	258	.close = decode_end,
259	259	.decode = decode_frame,

libavcodec/pngdec.c+1−1

@@ -652,7 +652,7 @@ static av_cold int png_dec_end(AVCodecContext *avctx) · 651 unmodified lines
652	652	AVCodec ff_png_decoder = {
653	653	.name = "png",
654	654	.type = AVMEDIA_TYPE_VIDEO,
655		− .id = CODEC_ID_PNG,
	655	+ .id = AV_CODEC_ID_PNG,
656	656	.priv_data_size = sizeof(PNGDecContext),
657	657	.init = png_dec_init,
658	658	.close = png_dec_end,

libavcodec/pngenc.c+1−1

@@ -456,7 +456,7 @@ static av_cold int png_enc_init(AVCodecContext *avctx){ · 455 unmodified lines
456	456	AVCodec ff_png_encoder = {
457	457	.name = "png",
458	458	.type = AVMEDIA_TYPE_VIDEO,
459		− .id = CODEC_ID_PNG,
	459	+ .id = AV_CODEC_ID_PNG,
460	460	.priv_data_size = sizeof(PNGEncContext),
461	461	.init = png_enc_init,
462	462	.encode2 = encode_frame,

libavcodec/pnm.c+1−1

@@ -67,7 +67,7 @@ int ff_pnm_decode_header(AVCodecContext avctx, PNMContext const s) · 66 unmodified lines
67	67	if (s->type==1 \|\| s->type==4) {
68	68	avctx->pix_fmt = PIX_FMT_MONOWHITE;
69	69	} else if (s->type==2 \|\| s->type==5) {
70		− if (avctx->codec_id == CODEC_ID_PGMYUV)
	70	+ if (avctx->codec_id == AV_CODEC_ID_PGMYUV)
71	71	avctx->pix_fmt = PIX_FMT_YUV420P;
72	72	else
73	73	avctx->pix_fmt = PIX_FMT_GRAY8;

libavcodec/pnm_parser.c+2−2

@@ -84,8 +84,8 @@ retry: · 83 unmodified lines
84	84	}
85	85
86	86	AVCodecParser ff_pnm_parser = {
87		− .codec_ids = { CODEC_ID_PGM, CODEC_ID_PGMYUV, CODEC_ID_PPM,
88		− CODEC_ID_PBM, CODEC_ID_PAM },
	87	+ .codec_ids = { AV_CODEC_ID_PGM, AV_CODEC_ID_PGMYUV, AV_CODEC_ID_PPM,
	88	+ AV_CODEC_ID_PBM, AV_CODEC_ID_PAM },
89	89	.priv_data_size = sizeof(ParseContext),
90	90	.parser_parse = pnm_parse,
91	91	.parser_close = ff_parse_close,

libavcodec/pnmdec.c+5−5

@@ -191,7 +191,7 @@ static int pnm_decode_frame(AVCodecContext avctx, void data, · 190 unmodified lines
191	191	AVCodec ff_pgm_decoder = {
192	192	.name = "pgm",
193	193	.type = AVMEDIA_TYPE_VIDEO,
194		− .id = CODEC_ID_PGM,
	194	+ .id = AV_CODEC_ID_PGM,
195	195	.priv_data_size = sizeof(PNMContext),
196	196	.init = ff_pnm_init,
197	197	.close = ff_pnm_end,
@@ -205,7 +205,7 @@ AVCodec ff_pgm_decoder = { · 7 unmodified lines
205	205	AVCodec ff_pgmyuv_decoder = {
206	206	.name = "pgmyuv",
207	207	.type = AVMEDIA_TYPE_VIDEO,
208		− .id = CODEC_ID_PGMYUV,
	208	+ .id = AV_CODEC_ID_PGMYUV,
209	209	.priv_data_size = sizeof(PNMContext),
210	210	.init = ff_pnm_init,
211	211	.close = ff_pnm_end,
@@ -219,7 +219,7 @@ AVCodec ff_pgmyuv_decoder = { · 7 unmodified lines
219	219	AVCodec ff_ppm_decoder = {
220	220	.name = "ppm",
221	221	.type = AVMEDIA_TYPE_VIDEO,
222		− .id = CODEC_ID_PPM,
	222	+ .id = AV_CODEC_ID_PPM,
223	223	.priv_data_size = sizeof(PNMContext),
224	224	.init = ff_pnm_init,
225	225	.close = ff_pnm_end,
@@ -233,7 +233,7 @@ AVCodec ff_ppm_decoder = { · 7 unmodified lines
233	233	AVCodec ff_pbm_decoder = {
234	234	.name = "pbm",
235	235	.type = AVMEDIA_TYPE_VIDEO,
236		− .id = CODEC_ID_PBM,
	236	+ .id = AV_CODEC_ID_PBM,
237	237	.priv_data_size = sizeof(PNMContext),
238	238	.init = ff_pnm_init,
239	239	.close = ff_pnm_end,
@@ -247,7 +247,7 @@ AVCodec ff_pbm_decoder = { · 7 unmodified lines
247	247	AVCodec ff_pam_decoder = {
248	248	.name = "pam",
249	249	.type = AVMEDIA_TYPE_VIDEO,
250		− .id = CODEC_ID_PAM,
	250	+ .id = AV_CODEC_ID_PAM,
251	251	.priv_data_size = sizeof(PNMContext),
252	252	.init = ff_pnm_init,
253	253	.close = ff_pnm_end,

libavcodec/pnmenc.c+4−4

@@ -122,7 +122,7 @@ static int pnm_encode_frame(AVCodecContext avctx, AVPacket pkt, · 121 unmodified lines
122	122	AVCodec ff_pgm_encoder = {
123	123	.name = "pgm",
124	124	.type = AVMEDIA_TYPE_VIDEO,
125		− .id = CODEC_ID_PGM,
	125	+ .id = AV_CODEC_ID_PGM,
126	126	.priv_data_size = sizeof(PNMContext),
127	127	.init = ff_pnm_init,
128	128	.encode2 = pnm_encode_frame,
@@ -137,7 +137,7 @@ AVCodec ff_pgm_encoder = { · 8 unmodified lines
137	137	AVCodec ff_pgmyuv_encoder = {
138	138	.name = "pgmyuv",
139	139	.type = AVMEDIA_TYPE_VIDEO,
140		− .id = CODEC_ID_PGMYUV,
	140	+ .id = AV_CODEC_ID_PGMYUV,
141	141	.priv_data_size = sizeof(PNMContext),
142	142	.init = ff_pnm_init,
143	143	.encode2 = pnm_encode_frame,
@@ -150,7 +150,7 @@ AVCodec ff_pgmyuv_encoder = { · 6 unmodified lines
150	150	AVCodec ff_ppm_encoder = {
151	151	.name = "ppm",
152	152	.type = AVMEDIA_TYPE_VIDEO,
153		− .id = CODEC_ID_PPM,
	153	+ .id = AV_CODEC_ID_PPM,
154	154	.priv_data_size = sizeof(PNMContext),
155	155	.init = ff_pnm_init,
156	156	.encode2 = pnm_encode_frame,
@@ -165,7 +165,7 @@ AVCodec ff_ppm_encoder = { · 8 unmodified lines
165	165	AVCodec ff_pbm_encoder = {
166	166	.name = "pbm",
167	167	.type = AVMEDIA_TYPE_VIDEO,
168		− .id = CODEC_ID_PBM,
	168	+ .id = AV_CODEC_ID_PBM,
169	169	.priv_data_size = sizeof(PNMContext),
170	170	.init = ff_pnm_init,
171	171	.encode2 = pnm_encode_frame,

libavcodec/proresdec.c+1−1

@@ -663,7 +663,7 @@ static av_cold int decode_close(AVCodecContext *avctx) · 662 unmodified lines
663	663	AVCodec ff_prores_decoder = {
664	664	.name = "prores",
665	665	.type = AVMEDIA_TYPE_VIDEO,
666		− .id = CODEC_ID_PRORES,
	666	+ .id = AV_CODEC_ID_PRORES,
667	667	.priv_data_size = sizeof(ProresContext),
668	668	.init = decode_init,
669	669	.close = decode_close,

libavcodec/proresenc.c+1−1

@@ -1021,7 +1021,7 @@ static const AVClass proresenc_class = { · 1020 unmodified lines
1021	1021	AVCodec ff_prores_encoder = {
1022	1022	.name = "prores",
1023	1023	.type = AVMEDIA_TYPE_VIDEO,
1024		− .id = CODEC_ID_PRORES,
	1024	+ .id = AV_CODEC_ID_PRORES,
1025	1025	.priv_data_size = sizeof(ProresContext),
1026	1026	.init = encode_init,
1027	1027	.close = encode_close,

libavcodec/psymodel.c+1−1

@@ -51,7 +51,7 @@ av_cold int ff_psy_init(FFPsyContext ctx, AVCodecContext avctx, int num_lens, · 50 unmodified lines
51	51	}
52	52
53	53	switch (ctx->avctx->codec_id) {
54		− case CODEC_ID_AAC:
	54	+ case AV_CODEC_ID_AAC:
55	55	ctx->model = &ff_aac_psy_model;
56	56	break;
57	57	}

libavcodec/ptx.c+1−1

@@ -119,7 +119,7 @@ static av_cold int ptx_end(AVCodecContext *avctx) { · 118 unmodified lines
119	119	AVCodec ff_ptx_decoder = {
120	120	.name = "ptx",
121	121	.type = AVMEDIA_TYPE_VIDEO,
122		− .id = CODEC_ID_PTX,
	122	+ .id = AV_CODEC_ID_PTX,
123	123	.priv_data_size = sizeof(PTXContext),
124	124	.init = ptx_init,
125	125	.close = ptx_end,

libavcodec/qcelpdec.c+1−1

@@ -793,7 +793,7 @@ erasure: · 792 unmodified lines
793	793	AVCodec ff_qcelp_decoder = {
794	794	.name = "qcelp",
795	795	.type = AVMEDIA_TYPE_AUDIO,
796		− .id = CODEC_ID_QCELP,
	796	+ .id = AV_CODEC_ID_QCELP,
797	797	.init = qcelp_decode_init,
798	798	.decode = qcelp_decode_frame,
799	799	.capabilities = CODEC_CAP_DR1,

libavcodec/qdm2.c+1−1

@@ -1962,7 +1962,7 @@ AVCodec ff_qdm2_decoder = · 1961 unmodified lines
1962	1962	{
1963	1963	.name = "qdm2",
1964	1964	.type = AVMEDIA_TYPE_AUDIO,
1965		− .id = CODEC_ID_QDM2,
	1965	+ .id = AV_CODEC_ID_QDM2,
1966	1966	.priv_data_size = sizeof(QDM2Context),
1967	1967	.init = qdm2_decode_init,
1968	1968	.close = qdm2_decode_close,

libavcodec/qdrw.c+1−1

@@ -165,7 +165,7 @@ static av_cold int decode_end(AVCodecContext *avctx){ · 164 unmodified lines
165	165	AVCodec ff_qdraw_decoder = {
166	166	.name = "qdraw",
167	167	.type = AVMEDIA_TYPE_VIDEO,
168		− .id = CODEC_ID_QDRAW,
	168	+ .id = AV_CODEC_ID_QDRAW,
169	169	.priv_data_size = sizeof(QdrawContext),
170	170	.init = decode_init,
171	171	.close = decode_end,

libavcodec/qpeg.c+1−1

@@ -310,7 +310,7 @@ static av_cold int decode_end(AVCodecContext *avctx){ · 309 unmodified lines
310	310	AVCodec ff_qpeg_decoder = {
311	311	.name = "qpeg",
312	312	.type = AVMEDIA_TYPE_VIDEO,
313		− .id = CODEC_ID_QPEG,
	313	+ .id = AV_CODEC_ID_QPEG,
314	314	.priv_data_size = sizeof(QpegContext),
315	315	.init = decode_init,
316	316	.close = decode_end,

libavcodec/qtrle.c+1−1

@@ -498,7 +498,7 @@ static av_cold int qtrle_decode_end(AVCodecContext *avctx) · 497 unmodified lines
498	498	AVCodec ff_qtrle_decoder = {
499	499	.name = "qtrle",
500	500	.type = AVMEDIA_TYPE_VIDEO,
501		− .id = CODEC_ID_QTRLE,
	501	+ .id = AV_CODEC_ID_QTRLE,
502	502	.priv_data_size = sizeof(QtrleContext),
503	503	.init = qtrle_decode_init,
504	504	.close = qtrle_decode_end,

libavcodec/qtrleenc.c+1−1

@@ -330,7 +330,7 @@ static av_cold int qtrle_encode_end(AVCodecContext *avctx) · 329 unmodified lines
330	330	AVCodec ff_qtrle_encoder = {
331	331	.name = "qtrle",
332	332	.type = AVMEDIA_TYPE_VIDEO,
333		− .id = CODEC_ID_QTRLE,
	333	+ .id = AV_CODEC_ID_QTRLE,
334	334	.priv_data_size = sizeof(QtrleEncContext),
335	335	.init = qtrle_encode_init,
336	336	.encode2 = qtrle_encode_frame,

libavcodec/r210dec.c+3−3

@@ -63,7 +63,7 @@ static int decode_frame(AVCodecContext avctx, void data, int *data_size, · 62 unmodified lines
63	63	for (w = 0; w < avctx->width; w++) {
64	64	uint32_t pixel = av_be2ne32(*src++);
65	65	uint16_t r, g, b;
66		− if (avctx->codec_id==CODEC_ID_R210) {
	66	+ if (avctx->codec_id==AV_CODEC_ID_R210) {
67	67	b = pixel << 6;
68	68	g = (pixel >> 4) & 0xffc0;
69	69	r = (pixel >> 14) & 0xffc0;
@@ -100,7 +100,7 @@ static av_cold int decode_close(AVCodecContext *avctx) · 30 unmodified lines
100	100	AVCodec ff_r210_decoder = {
101	101	.name = "r210",
102	102	.type = AVMEDIA_TYPE_VIDEO,
103		− .id = CODEC_ID_R210,
	103	+ .id = AV_CODEC_ID_R210,
104	104	.init = decode_init,
105	105	.close = decode_close,
106	106	.decode = decode_frame,
@@ -112,7 +112,7 @@ AVCodec ff_r210_decoder = { · 5 unmodified lines
112	112	AVCodec ff_r10k_decoder = {
113	113	.name = "r10k",
114	114	.type = AVMEDIA_TYPE_VIDEO,
115		− .id = CODEC_ID_R10K,
	115	+ .id = AV_CODEC_ID_R10K,
116	116	.init = decode_init,
117	117	.close = decode_close,
118	118	.decode = decode_frame,

libavcodec/ra144dec.c+1−1

@@ -129,7 +129,7 @@ static int ra144_decode_frame(AVCodecContext * avctx, void *data, · 128 unmodified lines
129	129	AVCodec ff_ra_144_decoder = {
130	130	.name = "real_144",
131	131	.type = AVMEDIA_TYPE_AUDIO,
132		− .id = CODEC_ID_RA_144,
	132	+ .id = AV_CODEC_ID_RA_144,
133	133	.priv_data_size = sizeof(RA144Context),
134	134	.init = ra144_decode_init,
135	135	.decode = ra144_decode_frame,

libavcodec/ra144enc.c+1−1

@@ -557,7 +557,7 @@ static int ra144_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 556 unmodified lines
557	557	AVCodec ff_ra_144_encoder = {
558	558	.name = "real_144",
559	559	.type = AVMEDIA_TYPE_AUDIO,
560		− .id = CODEC_ID_RA_144,
	560	+ .id = AV_CODEC_ID_RA_144,
561	561	.priv_data_size = sizeof(RA144Context),
562	562	.init = ra144_encode_init,
563	563	.encode2 = ra144_encode_frame,

libavcodec/ra288.c+1−1

@@ -224,7 +224,7 @@ static int ra288_decode_frame(AVCodecContext * avctx, void *data, · 223 unmodified lines
224	224	AVCodec ff_ra_288_decoder = {
225	225	.name = "real_288",
226	226	.type = AVMEDIA_TYPE_AUDIO,
227		− .id = CODEC_ID_RA_288,
	227	+ .id = AV_CODEC_ID_RA_288,
228	228	.priv_data_size = sizeof(RA288Context),
229	229	.init = ra288_decode_init,
230	230	.decode = ra288_decode_frame,

libavcodec/ralf.c+1−1

@@ -525,7 +525,7 @@ static void decode_flush(AVCodecContext *avctx) · 524 unmodified lines
525	525	AVCodec ff_ralf_decoder = {
526	526	.name = "ralf",
527	527	.type = AVMEDIA_TYPE_AUDIO,
528		− .id = CODEC_ID_RALF,
	528	+ .id = AV_CODEC_ID_RALF,
529	529	.priv_data_size = sizeof(RALFContext),
530	530	.init = decode_init,
531	531	.close = decode_close,

libavcodec/ratecontrol.c+1−1

@@ -286,7 +286,7 @@ int ff_vbv_update(MpegEncContext *s, int frame_size){ · 285 unmodified lines
286	286	if(rcc->buffer_index > buffer_size){
287	287	int stuffing= ceil((rcc->buffer_index - buffer_size)/8);
288	288
289		− if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4)
	289	+ if(stuffing < 4 && s->codec_id == AV_CODEC_ID_MPEG4)
290	290	stuffing=4;
291	291	rcc->buffer_index -= 8*stuffing;
292	292

libavcodec/rawdec.c+1−1

@@ -210,7 +210,7 @@ static av_cold int raw_close_decoder(AVCodecContext *avctx) · 209 unmodified lines
210	210	AVCodec ff_rawvideo_decoder = {
211	211	.name = "rawvideo",
212	212	.type = AVMEDIA_TYPE_VIDEO,
213		− .id = CODEC_ID_RAWVIDEO,
	213	+ .id = AV_CODEC_ID_RAWVIDEO,
214	214	.priv_data_size = sizeof(RawVideoContext),
215	215	.init = raw_init_decoder,
216	216	.close = raw_close_decoder,

libavcodec/rawenc.c+1−1

@@ -69,7 +69,7 @@ static int raw_encode(AVCodecContext avctx, AVPacket pkt, · 68 unmodified lines
69	69	AVCodec ff_rawvideo_encoder = {
70	70	.name = "rawvideo",
71	71	.type = AVMEDIA_TYPE_VIDEO,
72		− .id = CODEC_ID_RAWVIDEO,
	72	+ .id = AV_CODEC_ID_RAWVIDEO,
73	73	.priv_data_size = sizeof(AVFrame),
74	74	.init = raw_init_encoder,
75	75	.encode2 = raw_encode,

libavcodec/rl2.c+1−1

@@ -221,7 +221,7 @@ static av_cold int rl2_decode_end(AVCodecContext *avctx) · 220 unmodified lines
221	221	AVCodec ff_rl2_decoder = {
222	222	.name = "rl2",
223	223	.type = AVMEDIA_TYPE_VIDEO,
224		− .id = CODEC_ID_RL2,
	224	+ .id = AV_CODEC_ID_RL2,
225	225	.priv_data_size = sizeof(Rl2Context),
226	226	.init = rl2_decode_init,
227	227	.close = rl2_decode_end,

libavcodec/roqaudioenc.c+1−1

@@ -205,7 +205,7 @@ static int roq_dpcm_encode_frame(AVCodecContext avctx, AVPacket avpkt, · 204 unmodified lines
205	205	AVCodec ff_roq_dpcm_encoder = {
206	206	.name = "roq_dpcm",
207	207	.type = AVMEDIA_TYPE_AUDIO,
208		− .id = CODEC_ID_ROQ_DPCM,
	208	+ .id = AV_CODEC_ID_ROQ_DPCM,
209	209	.priv_data_size = sizeof(ROQDPCMContext),
210	210	.init = roq_dpcm_encode_init,
211	211	.encode2 = roq_dpcm_encode_frame,

libavcodec/roqvideodec.c+1−1

@@ -215,7 +215,7 @@ static av_cold int roq_decode_end(AVCodecContext *avctx) · 214 unmodified lines
215	215	AVCodec ff_roq_decoder = {
216	216	.name = "roqvideo",
217	217	.type = AVMEDIA_TYPE_VIDEO,
218		− .id = CODEC_ID_ROQ,
	218	+ .id = AV_CODEC_ID_ROQ,
219	219	.priv_data_size = sizeof(RoqContext),
220	220	.init = roq_decode_init,
221	221	.close = roq_decode_end,

libavcodec/roqvideoenc.c+1−1

@@ -1075,7 +1075,7 @@ static int roq_encode_end(AVCodecContext *avctx) · 1074 unmodified lines
1075	1075	AVCodec ff_roq_encoder = {
1076	1076	.name = "roqvideo",
1077	1077	.type = AVMEDIA_TYPE_VIDEO,
1078		− .id = CODEC_ID_ROQ,
	1078	+ .id = AV_CODEC_ID_ROQ,
1079	1079	.priv_data_size = sizeof(RoqContext),
1080	1080	.init = roq_encode_init,
1081	1081	.encode2 = roq_encode_frame,

libavcodec/rpza.c+1−1

@@ -282,7 +282,7 @@ static av_cold int rpza_decode_end(AVCodecContext *avctx) · 281 unmodified lines
282	282	AVCodec ff_rpza_decoder = {
283	283	.name = "rpza",
284	284	.type = AVMEDIA_TYPE_VIDEO,
285		− .id = CODEC_ID_RPZA,
	285	+ .id = AV_CODEC_ID_RPZA,
286	286	.priv_data_size = sizeof(RpzaContext),
287	287	.init = rpza_decode_init,
288	288	.close = rpza_decode_end,

libavcodec/rv10.c+4−4

@@ -510,7 +510,7 @@ static int rv10_decode_packet(AVCodecContext *avctx, · 509 unmodified lines
510	510
511	511	active_bits_size = buf_size * 8;
512	512	init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
513		− if(s->codec_id ==CODEC_ID_RV10)
	513	+ if(s->codec_id ==AV_CODEC_ID_RV10)
514	514	mb_count = rv10_decode_picture_header(s);
515	515	else
516	516	mb_count = rv20_decode_picture_header(rv);
@@ -550,7 +550,7 @@ static int rv10_decode_packet(AVCodecContext *avctx, · 33 unmodified lines
550	550	av_dlog(avctx, "qscale=%d\n", s->qscale);
551	551
552	552	/* default quantization values */
553		− if(s->codec_id== CODEC_ID_RV10){
	553	+ if(s->codec_id== AV_CODEC_ID_RV10){
554	554	if(s->mb_y==0) s->first_slice_line=1;
555	555	}else{
556	556	s->first_slice_line=1;
@@ -720,7 +720,7 @@ static int rv10_decode_frame(AVCodecContext *avctx, · 163 unmodified lines
720	720	AVCodec ff_rv10_decoder = {
721	721	.name = "rv10",
722	722	.type = AVMEDIA_TYPE_VIDEO,
723		− .id = CODEC_ID_RV10,
	723	+ .id = AV_CODEC_ID_RV10,
724	724	.priv_data_size = sizeof(RVDecContext),
725	725	.init = rv10_decode_init,
726	726	.close = rv10_decode_end,
@@ -733,7 +733,7 @@ AVCodec ff_rv10_decoder = { · 6 unmodified lines
733	733	AVCodec ff_rv20_decoder = {
734	734	.name = "rv20",
735	735	.type = AVMEDIA_TYPE_VIDEO,
736		− .id = CODEC_ID_RV20,
	736	+ .id = AV_CODEC_ID_RV20,
737	737	.priv_data_size = sizeof(RVDecContext),
738	738	.init = rv10_decode_init,
739	739	.close = rv10_decode_end,

libavcodec/rv10enc.c+1−1

@@ -61,7 +61,7 @@ FF_MPV_GENERIC_CLASS(rv10) · 60 unmodified lines
61	61	AVCodec ff_rv10_encoder = {
62	62	.name = "rv10",
63	63	.type = AVMEDIA_TYPE_VIDEO,
64		− .id = CODEC_ID_RV10,
	64	+ .id = AV_CODEC_ID_RV10,
65	65	.priv_data_size = sizeof(MpegEncContext),
66	66	.init = ff_MPV_encode_init,
67	67	.encode2 = ff_MPV_encode_picture,

libavcodec/rv20enc.c+1−1

@@ -62,7 +62,7 @@ FF_MPV_GENERIC_CLASS(rv20) · 61 unmodified lines
62	62	AVCodec ff_rv20_encoder = {
63	63	.name = "rv20",
64	64	.type = AVMEDIA_TYPE_VIDEO,
65		− .id = CODEC_ID_RV20,
	65	+ .id = AV_CODEC_ID_RV20,
66	66	.priv_data_size = sizeof(MpegEncContext),
67	67	.init = ff_MPV_encode_init,
68	68	.encode2 = ff_MPV_encode_picture,

libavcodec/rv30.c+1−1

@@ -270,7 +270,7 @@ static av_cold int rv30_decode_init(AVCodecContext *avctx) · 269 unmodified lines
270	270	AVCodec ff_rv30_decoder = {
271	271	.name = "rv30",
272	272	.type = AVMEDIA_TYPE_VIDEO,
273		− .id = CODEC_ID_RV30,
	273	+ .id = AV_CODEC_ID_RV30,
274	274	.priv_data_size = sizeof(RV34DecContext),
275	275	.init = rv30_decode_init,
276	276	.close = ff_rv34_decode_end,

libavcodec/rv34.c+3−3

@@ -1486,14 +1486,14 @@ av_cold int ff_rv34_decode_init(AVCodecContext *avctx) · 1485 unmodified lines
1486	1486	if ((ret = ff_MPV_common_init(s)) < 0)
1487	1487	return ret;
1488	1488
1489		− ff_h264_pred_init(&r->h, CODEC_ID_RV40, 8, 1);
	1489	+ ff_h264_pred_init(&r->h, AV_CODEC_ID_RV40, 8, 1);
1490	1490
1491	1491	#if CONFIG_RV30_DECODER
1492		− if (avctx->codec_id == CODEC_ID_RV30)
	1492	+ if (avctx->codec_id == AV_CODEC_ID_RV30)
1493	1493	ff_rv30dsp_init(&r->rdsp, &r->s.dsp);
1494	1494	#endif
1495	1495	#if CONFIG_RV40_DECODER
1496		− if (avctx->codec_id == CODEC_ID_RV40)
	1496	+ if (avctx->codec_id == AV_CODEC_ID_RV40)
1497	1497	ff_rv40dsp_init(&r->rdsp, &r->s.dsp);
1498	1498	#endif
1499	1499

libavcodec/rv34_parser.c+3−3

@@ -52,7 +52,7 @@ static int rv34_parse(AVCodecParserContext *s, · 51 unmodified lines
52	52	}
53	53
54	54	hdr = AV_RB32(buf + 9 + buf 8);
55		− if (avctx->codec_id == CODEC_ID_RV30) {
	55	+ if (avctx->codec_id == AV_CODEC_ID_RV30) {
56	56	type = (hdr >> 27) & 3;
57	57	pts = (hdr >> 7) & 0x1FFF;
58	58	} else {
@@ -78,7 +78,7 @@ static int rv34_parse(AVCodecParserContext *s, · 19 unmodified lines
78	78
79	79	#ifdef CONFIG_RV30_PARSER
80	80	AVCodecParser ff_rv30_parser = {
81		− .codec_ids = { CODEC_ID_RV30 },
	81	+ .codec_ids = { AV_CODEC_ID_RV30 },
82	82	.priv_data_size = sizeof(RV34ParseContext),
83	83	.parser_parse = rv34_parse,
84	84	};
@@ -86,7 +86,7 @@ AVCodecParser ff_rv30_parser = { · 1 unmodified line
86	86
87	87	#ifdef CONFIG_RV40_PARSER
88	88	AVCodecParser ff_rv40_parser = {
89		− .codec_ids = { CODEC_ID_RV40 },
	89	+ .codec_ids = { AV_CODEC_ID_RV40 },
90	90	.priv_data_size = sizeof(RV34ParseContext),
91	91	.parser_parse = rv34_parse,
92	92	};

libavcodec/rv40.c+1−1

@@ -562,7 +562,7 @@ static av_cold int rv40_decode_init(AVCodecContext *avctx) · 561 unmodified lines
562	562	AVCodec ff_rv40_decoder = {
563	563	.name = "rv40",
564	564	.type = AVMEDIA_TYPE_VIDEO,
565		− .id = CODEC_ID_RV40,
	565	+ .id = AV_CODEC_ID_RV40,
566	566	.priv_data_size = sizeof(RV34DecContext),
567	567	.init = rv40_decode_init,
568	568	.close = ff_rv34_decode_end,

libavcodec/s302m.c+1−1

@@ -156,7 +156,7 @@ static int s302m_decode_init(AVCodecContext *avctx) · 155 unmodified lines
156	156	AVCodec ff_s302m_decoder = {
157	157	.name = "s302m",
158	158	.type = AVMEDIA_TYPE_AUDIO,
159		− .id = CODEC_ID_S302M,
	159	+ .id = AV_CODEC_ID_S302M,
160	160	.priv_data_size = sizeof(S302MDecodeContext),
161	161	.init = s302m_decode_init,
162	162	.decode = s302m_decode_frame,

libavcodec/sgidec.c+1−1

@@ -261,7 +261,7 @@ static av_cold int sgi_end(AVCodecContext *avctx) · 260 unmodified lines
261	261	AVCodec ff_sgi_decoder = {
262	262	.name = "sgi",
263	263	.type = AVMEDIA_TYPE_VIDEO,
264		− .id = CODEC_ID_SGI,
	264	+ .id = AV_CODEC_ID_SGI,
265	265	.priv_data_size = sizeof(SgiState),
266	266	.init = sgi_init,
267	267	.close = sgi_end,

libavcodec/sgienc.c+1−1

@@ -173,7 +173,7 @@ static int encode_frame(AVCodecContext avctx, AVPacket pkt, · 172 unmodified lines
173	173	AVCodec ff_sgi_encoder = {
174	174	.name = "sgi",
175	175	.type = AVMEDIA_TYPE_VIDEO,
176		− .id = CODEC_ID_SGI,
	176	+ .id = AV_CODEC_ID_SGI,
177	177	.priv_data_size = sizeof(SgiContext),
178	178	.init = encode_init,
179	179	.encode2 = encode_frame,

libavcodec/shorten.c+1−1

@@ -630,7 +630,7 @@ static av_cold int shorten_decode_close(AVCodecContext *avctx) · 629 unmodified lines
630	630	AVCodec ff_shorten_decoder = {
631	631	.name = "shorten",
632	632	.type = AVMEDIA_TYPE_AUDIO,
633		− .id = CODEC_ID_SHORTEN,
	633	+ .id = AV_CODEC_ID_SHORTEN,
634	634	.priv_data_size = sizeof(ShortenContext),
635	635	.init = shorten_decode_init,
636	636	.close = shorten_decode_close,

libavcodec/sipr.c+1−1

@@ -561,7 +561,7 @@ static int sipr_decode_frame(AVCodecContext avctx, void data, · 560 unmodified lines
561	561	AVCodec ff_sipr_decoder = {
562	562	.name = "sipr",
563	563	.type = AVMEDIA_TYPE_AUDIO,
564		− .id = CODEC_ID_SIPR,
	564	+ .id = AV_CODEC_ID_SIPR,
565	565	.priv_data_size = sizeof(SiprContext),
566	566	.init = sipr_decoder_init,
567	567	.decode = sipr_decode_frame,

libavcodec/smacker.c+2−2

@@ -724,7 +724,7 @@ static int smka_decode_frame(AVCodecContext avctx, void data, · 723 unmodified lines
724	724	AVCodec ff_smacker_decoder = {
725	725	.name = "smackvid",
726	726	.type = AVMEDIA_TYPE_VIDEO,
727		− .id = CODEC_ID_SMACKVIDEO,
	727	+ .id = AV_CODEC_ID_SMACKVIDEO,
728	728	.priv_data_size = sizeof(SmackVContext),
729	729	.init = decode_init,
730	730	.close = decode_end,
@@ -736,7 +736,7 @@ AVCodec ff_smacker_decoder = { · 5 unmodified lines
736	736	AVCodec ff_smackaud_decoder = {
737	737	.name = "smackaud",
738	738	.type = AVMEDIA_TYPE_AUDIO,
739		− .id = CODEC_ID_SMACKAUDIO,
	739	+ .id = AV_CODEC_ID_SMACKAUDIO,
740	740	.priv_data_size = sizeof(SmackerAudioContext),
741	741	.init = smka_decode_init,
742	742	.decode = smka_decode_frame,

libavcodec/smc.c+1−1

@@ -467,7 +467,7 @@ static av_cold int smc_decode_end(AVCodecContext *avctx) · 466 unmodified lines
467	467	AVCodec ff_smc_decoder = {
468	468	.name = "smc",
469	469	.type = AVMEDIA_TYPE_VIDEO,
470		− .id = CODEC_ID_SMC,
	470	+ .id = AV_CODEC_ID_SMC,
471	471	.priv_data_size = sizeof(SmcContext),
472	472	.init = smc_decode_init,
473	473	.close = smc_decode_end,

libavcodec/snowdec.c+1−1

@@ -563,7 +563,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 562 unmodified lines
563	563	AVCodec ff_snow_decoder = {
564	564	.name = "snow",
565	565	.type = AVMEDIA_TYPE_VIDEO,
566		− .id = CODEC_ID_SNOW,
	566	+ .id = AV_CODEC_ID_SNOW,
567	567	.priv_data_size = sizeof(SnowContext),
568	568	.init = decode_init,
569	569	.close = decode_end,

libavcodec/snowenc.c+1−1

@@ -1928,7 +1928,7 @@ static const AVClass snowenc_class = { · 1927 unmodified lines
1928	1928	AVCodec ff_snow_encoder = {
1929	1929	.name = "snow",
1930	1930	.type = AVMEDIA_TYPE_VIDEO,
1931		− .id = CODEC_ID_SNOW,
	1931	+ .id = AV_CODEC_ID_SNOW,
1932	1932	.priv_data_size = sizeof(SnowContext),
1933	1933	.init = encode_init,
1934	1934	.encode2 = encode_frame,

libavcodec/sp5xdec.c+3−3

@@ -68,7 +68,7 @@ static int sp5x_decode_frame(AVCodecContext *avctx, · 67 unmodified lines
68	68	memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
69	69	j += sizeof(sp5x_data_sos);
70	70
71		− if(avctx->codec_id==CODEC_ID_AMV)
	71	+ if(avctx->codec_id==AV_CODEC_ID_AMV)
72	72	for (i = 2; i < buf_size-2 && j < buf_size+1024-2; i++)
73	73	recoded[j++] = buf[i];
74	74	else
@@ -96,7 +96,7 @@ static int sp5x_decode_frame(AVCodecContext *avctx, · 21 unmodified lines
96	96	AVCodec ff_sp5x_decoder = {
97	97	.name = "sp5x",
98	98	.type = AVMEDIA_TYPE_VIDEO,
99		− .id = CODEC_ID_SP5X,
	99	+ .id = AV_CODEC_ID_SP5X,
100	100	.priv_data_size = sizeof(MJpegDecodeContext),
101	101	.init = ff_mjpeg_decode_init,
102	102	.close = ff_mjpeg_decode_end,
@@ -108,7 +108,7 @@ AVCodec ff_sp5x_decoder = { · 5 unmodified lines
108	108	AVCodec ff_amv_decoder = {
109	109	.name = "amv",
110	110	.type = AVMEDIA_TYPE_VIDEO,
111		− .id = CODEC_ID_AMV,
	111	+ .id = AV_CODEC_ID_AMV,
112	112	.priv_data_size = sizeof(MJpegDecodeContext),
113	113	.init = ff_mjpeg_decode_init,
114	114	.close = ff_mjpeg_decode_end,

libavcodec/srtdec.c+1−1

@@ -235,7 +235,7 @@ AVCodec ff_srt_decoder = { · 234 unmodified lines
235	235	.name = "srt",
236	236	.long_name = NULL_IF_CONFIG_SMALL("SubRip subtitle"),
237	237	.type = AVMEDIA_TYPE_SUBTITLE,
238		− .id = CODEC_ID_SRT,
	238	+ .id = AV_CODEC_ID_SRT,
239	239	.init = ff_ass_subtitle_header_default,
240	240	.decode = srt_decode_frame,
241	241	};

libavcodec/sunrast.c+1−1

@@ -196,7 +196,7 @@ static av_cold int sunrast_end(AVCodecContext *avctx) { · 195 unmodified lines
196	196	AVCodec ff_sunrast_decoder = {
197	197	.name = "sunrast",
198	198	.type = AVMEDIA_TYPE_VIDEO,
199		− .id = CODEC_ID_SUNRAST,
	199	+ .id = AV_CODEC_ID_SUNRAST,
200	200	.priv_data_size = sizeof(SUNRASTContext),
201	201	.init = sunrast_init,
202	202	.close = sunrast_end,

libavcodec/sunrastenc.c+1−1

@@ -215,7 +215,7 @@ static const AVCodecDefault sunrast_defaults[] = { · 214 unmodified lines
215	215	AVCodec ff_sunrast_encoder = {
216	216	.name = "sunrast",
217	217	.type = AVMEDIA_TYPE_VIDEO,
218		− .id = CODEC_ID_SUNRAST,
	218	+ .id = AV_CODEC_ID_SUNRAST,
219	219	.priv_data_size = sizeof(SUNRASTContext),
220	220	.init = sunrast_encode_init,
221	221	.encode2 = sunrast_encode_frame,

libavcodec/svq1dec.c+1−1

@@ -812,7 +812,7 @@ static av_cold int svq1_decode_end(AVCodecContext *avctx) · 811 unmodified lines
812	812	AVCodec ff_svq1_decoder = {
813	813	.name = "svq1",
814	814	.type = AVMEDIA_TYPE_VIDEO,
815		− .id = CODEC_ID_SVQ1,
	815	+ .id = AV_CODEC_ID_SVQ1,
816	816	.priv_data_size = sizeof(MpegEncContext),
817	817	.init = svq1_decode_init,
818	818	.close = svq1_decode_end,

libavcodec/svq1enc.c+1−1

@@ -581,7 +581,7 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx) · 580 unmodified lines
581	581	AVCodec ff_svq1_encoder = {
582	582	.name = "svq1",
583	583	.type = AVMEDIA_TYPE_VIDEO,
584		− .id = CODEC_ID_SVQ1,
	584	+ .id = AV_CODEC_ID_SVQ1,
585	585	.priv_data_size = sizeof(SVQ1Context),
586	586	.init = svq1_encode_init,
587	587	.encode2 = svq1_encode_frame,

libavcodec/svq3.c+1−1

@@ -1104,7 +1104,7 @@ static int svq3_decode_end(AVCodecContext *avctx) · 1103 unmodified lines
1104	1104	AVCodec ff_svq3_decoder = {
1105	1105	.name = "svq3",
1106	1106	.type = AVMEDIA_TYPE_VIDEO,
1107		− .id = CODEC_ID_SVQ3,
	1107	+ .id = AV_CODEC_ID_SVQ3,
1108	1108	.priv_data_size = sizeof(SVQ3Context),
1109	1109	.init = svq3_decode_init,
1110	1110	.close = svq3_decode_end,

libavcodec/targa.c+1−1

@@ -258,7 +258,7 @@ static av_cold int targa_end(AVCodecContext *avctx){ · 257 unmodified lines
258	258	AVCodec ff_targa_decoder = {
259	259	.name = "targa",
260	260	.type = AVMEDIA_TYPE_VIDEO,
261		− .id = CODEC_ID_TARGA,
	261	+ .id = AV_CODEC_ID_TARGA,
262	262	.priv_data_size = sizeof(TargaContext),
263	263	.init = targa_init,
264	264	.close = targa_end,

libavcodec/targaenc.c+1−1

@@ -164,7 +164,7 @@ static av_cold int targa_encode_init(AVCodecContext *avctx) · 163 unmodified lines
164	164	AVCodec ff_targa_encoder = {
165	165	.name = "targa",
166	166	.type = AVMEDIA_TYPE_VIDEO,
167		− .id = CODEC_ID_TARGA,
	167	+ .id = AV_CODEC_ID_TARGA,
168	168	.priv_data_size = sizeof(TargaContext),
169	169	.init = targa_encode_init,
170	170	.encode2 = targa_encode_frame,

libavcodec/tiertexseqv.c+1−1

@@ -259,7 +259,7 @@ static av_cold int seqvideo_decode_end(AVCodecContext *avctx) · 258 unmodified lines
259	259	AVCodec ff_tiertexseqvideo_decoder = {
260	260	.name = "tiertexseqvideo",
261	261	.type = AVMEDIA_TYPE_VIDEO,
262		− .id = CODEC_ID_TIERTEXSEQVIDEO,
	262	+ .id = AV_CODEC_ID_TIERTEXSEQVIDEO,
263	263	.priv_data_size = sizeof(SeqVideoContext),
264	264	.init = seqvideo_decode_init,
265	265	.close = seqvideo_decode_end,

libavcodec/tiff.c+1−1

@@ -685,7 +685,7 @@ static av_cold int tiff_end(AVCodecContext *avctx) · 684 unmodified lines
685	685	AVCodec ff_tiff_decoder = {
686	686	.name = "tiff",
687	687	.type = AVMEDIA_TYPE_VIDEO,
688		− .id = CODEC_ID_TIFF,
	688	+ .id = AV_CODEC_ID_TIFF,
689	689	.priv_data_size = sizeof(TiffContext),
690	690	.init = tiff_init,
691	691	.close = tiff_end,

libavcodec/tiffenc.c+1−1

@@ -469,7 +469,7 @@ static const AVClass tiffenc_class = { · 468 unmodified lines
469	469	AVCodec ff_tiff_encoder = {
470	470	.name = "tiff",
471	471	.type = AVMEDIA_TYPE_VIDEO,
472		− .id = CODEC_ID_TIFF,
	472	+ .id = AV_CODEC_ID_TIFF,
473	473	.priv_data_size = sizeof(TiffEncoderContext),
474	474	.encode2 = encode_frame,
475	475	.pix_fmts = (const enum PixelFormat[]) {

libavcodec/tmv.c+1−1

@@ -101,7 +101,7 @@ static av_cold int tmv_decode_close(AVCodecContext *avctx) · 100 unmodified lines
101	101	AVCodec ff_tmv_decoder = {
102	102	.name = "tmv",
103	103	.type = AVMEDIA_TYPE_VIDEO,
104		− .id = CODEC_ID_TMV,
	104	+ .id = AV_CODEC_ID_TMV,
105	105	.priv_data_size = sizeof(TMVContext),
106	106	.init = tmv_decode_init,
107	107	.close = tmv_decode_close,

libavcodec/truemotion1.c+1−1

@@ -886,7 +886,7 @@ static av_cold int truemotion1_decode_end(AVCodecContext *avctx) · 885 unmodified lines
886	886	AVCodec ff_truemotion1_decoder = {
887	887	.name = "truemotion1",
888	888	.type = AVMEDIA_TYPE_VIDEO,
889		− .id = CODEC_ID_TRUEMOTION1,
	889	+ .id = AV_CODEC_ID_TRUEMOTION1,
890	890	.priv_data_size = sizeof(TrueMotion1Context),
891	891	.init = truemotion1_decode_init,
892	892	.close = truemotion1_decode_end,

libavcodec/truemotion2.c+1−1

@@ -954,7 +954,7 @@ static av_cold int decode_end(AVCodecContext *avctx){ · 953 unmodified lines
954	954	AVCodec ff_truemotion2_decoder = {
955	955	.name = "truemotion2",
956	956	.type = AVMEDIA_TYPE_VIDEO,
957		− .id = CODEC_ID_TRUEMOTION2,
	957	+ .id = AV_CODEC_ID_TRUEMOTION2,
958	958	.priv_data_size = sizeof(TM2Context),
959	959	.init = decode_init,
960	960	.close = decode_end,

libavcodec/truespeech.c+1−1

@@ -360,7 +360,7 @@ static int truespeech_decode_frame(AVCodecContext avctx, void data, · 359 unmodified lines
360	360	AVCodec ff_truespeech_decoder = {
361	361	.name = "truespeech",
362	362	.type = AVMEDIA_TYPE_AUDIO,
363		− .id = CODEC_ID_TRUESPEECH,
	363	+ .id = AV_CODEC_ID_TRUESPEECH,
364	364	.priv_data_size = sizeof(TSContext),
365	365	.init = truespeech_decode_init,
366	366	.decode = truespeech_decode_frame,

libavcodec/tscc.c+1−1

@@ -205,7 +205,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 204 unmodified lines
205	205	AVCodec ff_tscc_decoder = {
206	206	.name = "camtasia",
207	207	.type = AVMEDIA_TYPE_VIDEO,
208		− .id = CODEC_ID_TSCC,
	208	+ .id = AV_CODEC_ID_TSCC,
209	209	.priv_data_size = sizeof(CamtasiaContext),
210	210	.init = decode_init,
211	211	.close = decode_end,

libavcodec/tscc2.c+1−1

@@ -372,7 +372,7 @@ static av_cold int tscc2_decode_end(AVCodecContext *avctx) · 371 unmodified lines
372	372	AVCodec ff_tscc2_decoder = {
373	373	.name = "tscc2",
374	374	.type = AVMEDIA_TYPE_VIDEO,
375		− .id = CODEC_ID_TSCC2,
	375	+ .id = AV_CODEC_ID_TSCC2,
376	376	.priv_data_size = sizeof(TSCC2Context),
377	377	.init = tscc2_decode_init,
378	378	.close = tscc2_decode_end,

libavcodec/tta.c+1−1

@@ -469,7 +469,7 @@ static av_cold int tta_decode_close(AVCodecContext *avctx) { · 468 unmodified lines
469	469	AVCodec ff_tta_decoder = {
470	470	.name = "tta",
471	471	.type = AVMEDIA_TYPE_AUDIO,
472		− .id = CODEC_ID_TTA,
	472	+ .id = AV_CODEC_ID_TTA,
473	473	.priv_data_size = sizeof(TTAContext),
474	474	.init = tta_decode_init,
475	475	.close = tta_decode_close,

libavcodec/twinvq.c+1−1

@@ -1177,7 +1177,7 @@ static av_cold int twin_decode_init(AVCodecContext *avctx) · 1176 unmodified lines
1177	1177	AVCodec ff_twinvq_decoder = {
1178	1178	.name = "twinvq",
1179	1179	.type = AVMEDIA_TYPE_AUDIO,
1180		− .id = CODEC_ID_TWINVQ,
	1180	+ .id = AV_CODEC_ID_TWINVQ,
1181	1181	.priv_data_size = sizeof(TwinContext),
1182	1182	.init = twin_decode_init,
1183	1183	.close = twin_decode_close,

libavcodec/txd.c+1−1

@@ -155,7 +155,7 @@ static av_cold int txd_end(AVCodecContext *avctx) { · 154 unmodified lines
155	155	AVCodec ff_txd_decoder = {
156	156	.name = "txd",
157	157	.type = AVMEDIA_TYPE_VIDEO,
158		− .id = CODEC_ID_TXD,
	158	+ .id = AV_CODEC_ID_TXD,
159	159	.priv_data_size = sizeof(TXDContext),
160	160	.init = txd_init,
161	161	.close = txd_end,

libavcodec/ulti.c+1−1

@@ -420,7 +420,7 @@ err: · 419 unmodified lines
420	420	AVCodec ff_ulti_decoder = {
421	421	.name = "ultimotion",
422	422	.type = AVMEDIA_TYPE_VIDEO,
423		− .id = CODEC_ID_ULTI,
	423	+ .id = AV_CODEC_ID_ULTI,
424	424	.priv_data_size = sizeof(UltimotionDecodeContext),
425	425	.init = ulti_decode_init,
426	426	.close = ulti_decode_end,

libavcodec/utils.c+96−96

@@ -197,25 +197,25 @@ void avcodec_align_dimensions2(AVCodecContext s, int width, int *height, · 196 unmodified lines
197	197	h_align=8;
198	198	break;
199	199	case PIX_FMT_YUV410P:
200		− if(s->codec_id == CODEC_ID_SVQ1){
	200	+ if(s->codec_id == AV_CODEC_ID_SVQ1){
201	201	w_align=64;
202	202	h_align=64;
203	203	}
204	204	case PIX_FMT_RGB555:
205		− if(s->codec_id == CODEC_ID_RPZA){
	205	+ if(s->codec_id == AV_CODEC_ID_RPZA){
206	206	w_align=4;
207	207	h_align=4;
208	208	}
209	209	case PIX_FMT_PAL8:
210	210	case PIX_FMT_BGR8:
211	211	case PIX_FMT_RGB8:
212		− if(s->codec_id == CODEC_ID_SMC){
	212	+ if(s->codec_id == AV_CODEC_ID_SMC){
213	213	w_align=4;
214	214	h_align=4;
215	215	}
216	216	break;
217	217	case PIX_FMT_BGR24:
218		− if((s->codec_id == CODEC_ID_MSZH) \|\| (s->codec_id == CODEC_ID_ZLIB)){
	218	+ if((s->codec_id == AV_CODEC_ID_MSZH) \|\| (s->codec_id == AV_CODEC_ID_ZLIB)){
219	219	w_align=4;
220	220	h_align=4;
221	221	}
@@ -228,7 +228,7 @@ void avcodec_align_dimensions2(AVCodecContext s, int width, int *height, · 6 unmodified lines
228	228
229	229	width = FFALIGN(width , w_align);
230	230	height= FFALIGN(height, h_align);
231		− if (s->codec_id == CODEC_ID_H264)
	231	+ if (s->codec_id == AV_CODEC_ID_H264)
232	232	*height+=2; // some of the optimized chroma MC reads one line too much
233	233
234	234	for (i = 0; i < 4; i++)
@@ -717,7 +717,7 @@ int attribute_align_arg avcodec_open2(AVCodecContext avctx, AVCodec codec, AVD · 482 unmodified lines
717	717
718	718	avctx->codec = codec;
719	719	if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN \|\| avctx->codec_type == codec->type) &&
720		− avctx->codec_id == CODEC_ID_NONE) {
	720	+ avctx->codec_id == AV_CODEC_ID_NONE) {
721	721	avctx->codec_type = codec->type;
722	722	avctx->codec_id = codec->id;
723	723	}
@@ -1410,7 +1410,7 @@ av_cold int avcodec_close(AVCodecContext *avctx) · 686 unmodified lines
1410	1410	return 0;
1411	1411	}
1412	1412
1413		−AVCodec *avcodec_find_encoder(enum CodecID id)
	1413	+AVCodec *avcodec_find_encoder(enum AVCodecID id)
1414	1414	{
1415	1415	AVCodec p, experimental=NULL;
1416	1416	p = first_avcodec;
@@ -1440,7 +1440,7 @@ AVCodec avcodec_find_encoder_by_name(const char name) · 23 unmodified lines
1440	1440	return NULL;
1441	1441	}
1442	1442
1443		−AVCodec *avcodec_find_decoder(enum CodecID id)
	1443	+AVCodec *avcodec_find_decoder(enum AVCodecID id)
1444	1444	{
1445	1445	AVCodec *p;
1446	1446	p = first_avcodec;
@@ -1523,7 +1523,7 @@ void avcodec_string(char buf, int buf_size, AVCodecContext enc, int encode) · 76 unmodified lines
1523	1523	if (p) {
1524	1524	codec_name = p->name;
1525	1525	profile = av_get_profile_name(p, enc->profile);
1526		− } else if (enc->codec_id == CODEC_ID_MPEG2TS) {
	1526	+ } else if (enc->codec_id == AV_CODEC_ID_MPEG2TS) {
1527	1527	/* fake mpeg2 transport stream codec (currently not
1528	1528	registered) */
1529	1529	codec_name = "mpeg2ts";
@@ -1713,61 +1713,61 @@ void avcodec_default_free_buffers(AVCodecContext *avctx) · 183 unmodified lines
1713	1713	}
1714	1714	}
1715	1715
1716		−int av_get_exact_bits_per_sample(enum CodecID codec_id)
	1716	+int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
1717	1717	{
1718	1718	switch(codec_id){
1719		− case CODEC_ID_ADPCM_CT:
1720		− case CODEC_ID_ADPCM_IMA_APC:
1721		− case CODEC_ID_ADPCM_IMA_EA_SEAD:
1722		− case CODEC_ID_ADPCM_IMA_WS:
1723		− case CODEC_ID_ADPCM_G722:
1724		− case CODEC_ID_ADPCM_YAMAHA:
	1719	+ case AV_CODEC_ID_ADPCM_CT:
	1720	+ case AV_CODEC_ID_ADPCM_IMA_APC:
	1721	+ case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
	1722	+ case AV_CODEC_ID_ADPCM_IMA_WS:
	1723	+ case AV_CODEC_ID_ADPCM_G722:
	1724	+ case AV_CODEC_ID_ADPCM_YAMAHA:
1725	1725	return 4;
1726		− case CODEC_ID_PCM_ALAW:
1727		− case CODEC_ID_PCM_MULAW:
1728		− case CODEC_ID_PCM_S8:
1729		− case CODEC_ID_PCM_U8:
1730		− case CODEC_ID_PCM_ZORK:
	1726	+ case AV_CODEC_ID_PCM_ALAW:
	1727	+ case AV_CODEC_ID_PCM_MULAW:
	1728	+ case AV_CODEC_ID_PCM_S8:
	1729	+ case AV_CODEC_ID_PCM_U8:
	1730	+ case AV_CODEC_ID_PCM_ZORK:
1731	1731	return 8;
1732		− case CODEC_ID_PCM_S16BE:
1733		− case CODEC_ID_PCM_S16LE:
1734		− case CODEC_ID_PCM_S16LE_PLANAR:
1735		− case CODEC_ID_PCM_U16BE:
1736		− case CODEC_ID_PCM_U16LE:
	1732	+ case AV_CODEC_ID_PCM_S16BE:
	1733	+ case AV_CODEC_ID_PCM_S16LE:
	1734	+ case AV_CODEC_ID_PCM_S16LE_PLANAR:
	1735	+ case AV_CODEC_ID_PCM_U16BE:
	1736	+ case AV_CODEC_ID_PCM_U16LE:
1737	1737	return 16;
1738		− case CODEC_ID_PCM_S24DAUD:
1739		− case CODEC_ID_PCM_S24BE:
1740		− case CODEC_ID_PCM_S24LE:
1741		− case CODEC_ID_PCM_U24BE:
1742		− case CODEC_ID_PCM_U24LE:
	1738	+ case AV_CODEC_ID_PCM_S24DAUD:
	1739	+ case AV_CODEC_ID_PCM_S24BE:
	1740	+ case AV_CODEC_ID_PCM_S24LE:
	1741	+ case AV_CODEC_ID_PCM_U24BE:
	1742	+ case AV_CODEC_ID_PCM_U24LE:
1743	1743	return 24;
1744		− case CODEC_ID_PCM_S32BE:
1745		− case CODEC_ID_PCM_S32LE:
1746		− case CODEC_ID_PCM_U32BE:
1747		− case CODEC_ID_PCM_U32LE:
1748		− case CODEC_ID_PCM_F32BE:
1749		− case CODEC_ID_PCM_F32LE:
	1744	+ case AV_CODEC_ID_PCM_S32BE:
	1745	+ case AV_CODEC_ID_PCM_S32LE:
	1746	+ case AV_CODEC_ID_PCM_U32BE:
	1747	+ case AV_CODEC_ID_PCM_U32LE:
	1748	+ case AV_CODEC_ID_PCM_F32BE:
	1749	+ case AV_CODEC_ID_PCM_F32LE:
1750	1750	return 32;
1751		− case CODEC_ID_PCM_F64BE:
1752		− case CODEC_ID_PCM_F64LE:
	1751	+ case AV_CODEC_ID_PCM_F64BE:
	1752	+ case AV_CODEC_ID_PCM_F64LE:
1753	1753	return 64;
1754	1754	default:
1755	1755	return 0;
1756	1756	}
1757	1757	}
1758	1758
1759		−int av_get_bits_per_sample(enum CodecID codec_id)
	1759	+int av_get_bits_per_sample(enum AVCodecID codec_id)
1760	1760	{
1761	1761	switch (codec_id) {
1762		− case CODEC_ID_ADPCM_SBPRO_2:
	1762	+ case AV_CODEC_ID_ADPCM_SBPRO_2:
1763	1763	return 2;
1764		− case CODEC_ID_ADPCM_SBPRO_3:
	1764	+ case AV_CODEC_ID_ADPCM_SBPRO_3:
1765	1765	return 3;
1766		− case CODEC_ID_ADPCM_SBPRO_4:
1767		− case CODEC_ID_ADPCM_IMA_WAV:
1768		− case CODEC_ID_ADPCM_IMA_QT:
1769		− case CODEC_ID_ADPCM_SWF:
1770		− case CODEC_ID_ADPCM_MS:
	1766	+ case AV_CODEC_ID_ADPCM_SBPRO_4:
	1767	+ case AV_CODEC_ID_ADPCM_IMA_WAV:
	1768	+ case AV_CODEC_ID_ADPCM_IMA_QT:
	1769	+ case AV_CODEC_ID_ADPCM_SWF:
	1770	+ case AV_CODEC_ID_ADPCM_MS:
1771	1771	return 4;
1772	1772	default:
1773	1773	return av_get_exact_bits_per_sample(codec_id);
@@ -1792,47 +1792,47 @@ int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes) · 18 unmodified lines
1792	1792
1793	1793	/* codecs with a fixed packet duration */
1794	1794	switch (id) {
1795		− case CODEC_ID_ADPCM_ADX: return 32;
1796		− case CODEC_ID_ADPCM_IMA_QT: return 64;
1797		− case CODEC_ID_ADPCM_EA_XAS: return 128;
1798		− case CODEC_ID_AMR_NB:
1799		− case CODEC_ID_GSM:
1800		− case CODEC_ID_QCELP:
1801		− case CODEC_ID_RA_144:
1802		− case CODEC_ID_RA_288: return 160;
1803		− case CODEC_ID_IMC: return 256;
1804		− case CODEC_ID_AMR_WB:
1805		− case CODEC_ID_GSM_MS: return 320;
1806		− case CODEC_ID_MP1: return 384;
1807		− case CODEC_ID_ATRAC1: return 512;
1808		− case CODEC_ID_ATRAC3: return 1024;
1809		− case CODEC_ID_MP2:
1810		− case CODEC_ID_MUSEPACK7: return 1152;
1811		− case CODEC_ID_AC3: return 1536;
	1795	+ case AV_CODEC_ID_ADPCM_ADX: return 32;
	1796	+ case AV_CODEC_ID_ADPCM_IMA_QT: return 64;
	1797	+ case AV_CODEC_ID_ADPCM_EA_XAS: return 128;
	1798	+ case AV_CODEC_ID_AMR_NB:
	1799	+ case AV_CODEC_ID_GSM:
	1800	+ case AV_CODEC_ID_QCELP:
	1801	+ case AV_CODEC_ID_RA_144:
	1802	+ case AV_CODEC_ID_RA_288: return 160;
	1803	+ case AV_CODEC_ID_IMC: return 256;
	1804	+ case AV_CODEC_ID_AMR_WB:
	1805	+ case AV_CODEC_ID_GSM_MS: return 320;
	1806	+ case AV_CODEC_ID_MP1: return 384;
	1807	+ case AV_CODEC_ID_ATRAC1: return 512;
	1808	+ case AV_CODEC_ID_ATRAC3: return 1024;
	1809	+ case AV_CODEC_ID_MP2:
	1810	+ case AV_CODEC_ID_MUSEPACK7: return 1152;
	1811	+ case AV_CODEC_ID_AC3: return 1536;
1812	1812	}
1813	1813
1814	1814	if (sr > 0) {
1815	1815	/* calc from sample rate */
1816		− if (id == CODEC_ID_TTA)
	1816	+ if (id == AV_CODEC_ID_TTA)
1817	1817	return 256 * sr / 245;
1818	1818
1819	1819	if (ch > 0) {
1820	1820	/* calc from sample rate and channels */
1821		− if (id == CODEC_ID_BINKAUDIO_DCT)
	1821	+ if (id == AV_CODEC_ID_BINKAUDIO_DCT)
1822	1822	return (480 << (sr / 22050)) / ch;
1823	1823	}
1824	1824	}
1825	1825
1826	1826	if (ba > 0) {
1827	1827	/* calc from block_align */
1828		− if (id == CODEC_ID_SIPR) {
	1828	+ if (id == AV_CODEC_ID_SIPR) {
1829	1829	switch (ba) {
1830	1830	case 20: return 160;
1831	1831	case 19: return 144;
1832	1832	case 29: return 288;
1833	1833	case 37: return 480;
1834	1834	}
1835		− } else if (id == CODEC_ID_ILBC) {
	1835	+ } else if (id == AV_CODEC_ID_ILBC) {
1836	1836	switch (ba) {
1837	1837	case 38: return 160;
1838	1838	case 50: return 240;
@@ -1842,46 +1842,46 @@ int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes) · 3 unmodified lines
1842	1842
1843	1843	if (frame_bytes > 0) {
1844	1844	/* calc from frame_bytes only */
1845		− if (id == CODEC_ID_TRUESPEECH)
	1845	+ if (id == AV_CODEC_ID_TRUESPEECH)
1846	1846	return 240 * (frame_bytes / 32);
1847		− if (id == CODEC_ID_NELLYMOSER)
	1847	+ if (id == AV_CODEC_ID_NELLYMOSER)
1848	1848	return 256 * (frame_bytes / 64);
1849	1849
1850	1850	if (bps > 0) {
1851	1851	/* calc from frame_bytes and bits_per_coded_sample */
1852		− if (id == CODEC_ID_ADPCM_G726)
	1852	+ if (id == AV_CODEC_ID_ADPCM_G726)
1853	1853	return frame_bytes * 8 / bps;
1854	1854	}
1855	1855
1856	1856	if (ch > 0) {
1857	1857	/* calc from frame_bytes and channels */
1858	1858	switch (id) {
1859		− case CODEC_ID_ADPCM_4XM:
1860		− case CODEC_ID_ADPCM_IMA_ISS:
	1859	+ case AV_CODEC_ID_ADPCM_4XM:
	1860	+ case AV_CODEC_ID_ADPCM_IMA_ISS:
1861	1861	return (frame_bytes - 4 * ch) * 2 / ch;
1862		− case CODEC_ID_ADPCM_IMA_SMJPEG:
	1862	+ case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
1863	1863	return (frame_bytes - 4) * 2 / ch;
1864		− case CODEC_ID_ADPCM_IMA_AMV:
	1864	+ case AV_CODEC_ID_ADPCM_IMA_AMV:
1865	1865	return (frame_bytes - 8) * 2 / ch;
1866		− case CODEC_ID_ADPCM_XA:
	1866	+ case AV_CODEC_ID_ADPCM_XA:
1867	1867	return (frame_bytes / 128) * 224 / ch;
1868		− case CODEC_ID_INTERPLAY_DPCM:
	1868	+ case AV_CODEC_ID_INTERPLAY_DPCM:
1869	1869	return (frame_bytes - 6 - ch) / ch;
1870		− case CODEC_ID_ROQ_DPCM:
	1870	+ case AV_CODEC_ID_ROQ_DPCM:
1871	1871	return (frame_bytes - 8) / ch;
1872		− case CODEC_ID_XAN_DPCM:
	1872	+ case AV_CODEC_ID_XAN_DPCM:
1873	1873	return (frame_bytes - 2 * ch) / ch;
1874		− case CODEC_ID_MACE3:
	1874	+ case AV_CODEC_ID_MACE3:
1875	1875	return 3 * frame_bytes / ch;
1876		− case CODEC_ID_MACE6:
	1876	+ case AV_CODEC_ID_MACE6:
1877	1877	return 6 * frame_bytes / ch;
1878		− case CODEC_ID_PCM_LXF:
	1878	+ case AV_CODEC_ID_PCM_LXF:
1879	1879	return 2 * (frame_bytes / (5 * ch));
1880	1880	}
1881	1881
1882	1882	if (tag) {
1883	1883	/* calc from frame_bytes, channels, and codec_tag */
1884		− if (id == CODEC_ID_SOL_DPCM) {
	1884	+ if (id == AV_CODEC_ID_SOL_DPCM) {
1885	1885	if (tag == 3)
1886	1886	return frame_bytes / ch;
1887	1887	else
@@ -1893,13 +1893,13 @@ int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes) · 5 unmodified lines
1893	1893	/* calc from frame_bytes, channels, and block_align */
1894	1894	int blocks = frame_bytes / ba;
1895	1895	switch (avctx->codec_id) {
1896		− case CODEC_ID_ADPCM_IMA_WAV:
	1896	+ case AV_CODEC_ID_ADPCM_IMA_WAV:
1897	1897	return blocks * (1 + (ba - 4 * ch) / (4 * ch) * 8);
1898		− case CODEC_ID_ADPCM_IMA_DK3:
	1898	+ case AV_CODEC_ID_ADPCM_IMA_DK3:
1899	1899	return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
1900		− case CODEC_ID_ADPCM_IMA_DK4:
	1900	+ case AV_CODEC_ID_ADPCM_IMA_DK4:
1901	1901	return blocks * (1 + (ba - 4 * ch) * 2 / ch);
1902		− case CODEC_ID_ADPCM_MS:
	1902	+ case AV_CODEC_ID_ADPCM_MS:
1903	1903	return blocks * (2 + (ba - 7 * ch) * 2 / ch);
1904	1904	}
1905	1905	}
@@ -1907,11 +1907,11 @@ int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes) · 1 unmodified line
1907	1907	if (bps > 0) {
1908	1908	/* calc from frame_bytes, channels, and bits_per_coded_sample */
1909	1909	switch (avctx->codec_id) {
1910		− case CODEC_ID_PCM_DVD:
	1910	+ case AV_CODEC_ID_PCM_DVD:
1911	1911	return 2 * (frame_bytes / ((bps * 2 / 8) * ch));
1912		− case CODEC_ID_PCM_BLURAY:
	1912	+ case AV_CODEC_ID_PCM_BLURAY:
1913	1913	return frame_bytes / ((FFALIGN(ch, 2) * bps) / 8);
1914		− case CODEC_ID_S302M:
	1914	+ case AV_CODEC_ID_S302M:
1915	1915	return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
1916	1916	}
1917	1917	}
@@ -1988,7 +1988,7 @@ AVHWAccel av_hwaccel_next(AVHWAccel hwaccel) · 70 unmodified lines
1988	1988	return hwaccel ? hwaccel->next : first_hwaccel;
1989	1989	}
1990	1990
1991		−AVHWAccel *ff_find_hwaccel(enum CodecID codec_id, enum PixelFormat pix_fmt)
	1991	+AVHWAccel *ff_find_hwaccel(enum AVCodecID codec_id, enum PixelFormat pix_fmt)
1992	1992	{
1993	1993	AVHWAccel *hwaccel=NULL;
1994	1994
@@ -2073,15 +2073,15 @@ void ff_thread_await_progress(AVFrame *f, int progress, int field) · 78 unmodified lines
2073	2073
2074	2074	#endif
2075	2075
2076		−enum AVMediaType avcodec_get_type(enum CodecID codec_id)
	2076	+enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
2077	2077	{
2078		− if (codec_id <= CODEC_ID_NONE)
	2078	+ if (codec_id <= AV_CODEC_ID_NONE)
2079	2079	return AVMEDIA_TYPE_UNKNOWN;
2080		− else if (codec_id < CODEC_ID_FIRST_AUDIO)
	2080	+ else if (codec_id < AV_CODEC_ID_FIRST_AUDIO)
2081	2081	return AVMEDIA_TYPE_VIDEO;
2082		− else if (codec_id < CODEC_ID_FIRST_SUBTITLE)
	2082	+ else if (codec_id < AV_CODEC_ID_FIRST_SUBTITLE)
2083	2083	return AVMEDIA_TYPE_AUDIO;
2084		− else if (codec_id < CODEC_ID_FIRST_UNKNOWN)
	2084	+ else if (codec_id < AV_CODEC_ID_FIRST_UNKNOWN)
2085	2085	return AVMEDIA_TYPE_SUBTITLE;
2086	2086
2087	2087	return AVMEDIA_TYPE_UNKNOWN;

libavcodec/utvideo.c+1−1

@@ -581,7 +581,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 580 unmodified lines
581	581	AVCodec ff_utvideo_decoder = {
582	582	.name = "utvideo",
583	583	.type = AVMEDIA_TYPE_VIDEO,
584		− .id = CODEC_ID_UTVIDEO,
	584	+ .id = AV_CODEC_ID_UTVIDEO,
585	585	.priv_data_size = sizeof(UtvideoContext),
586	586	.init = decode_init,
587	587	.close = decode_end,

libavcodec/v210dec.c+1−1

@@ -125,7 +125,7 @@ static av_cold int decode_close(AVCodecContext *avctx) · 124 unmodified lines
125	125	AVCodec ff_v210_decoder = {
126	126	.name = "v210",
127	127	.type = AVMEDIA_TYPE_VIDEO,
128		− .id = CODEC_ID_V210,
	128	+ .id = AV_CODEC_ID_V210,
129	129	.init = decode_init,
130	130	.close = decode_close,
131	131	.decode = decode_frame,

libavcodec/v210enc.c+1−1

@@ -119,7 +119,7 @@ static av_cold int encode_close(AVCodecContext *avctx) · 118 unmodified lines
119	119	AVCodec ff_v210_encoder = {
120	120	.name = "v210",
121	121	.type = AVMEDIA_TYPE_VIDEO,
122		− .id = CODEC_ID_V210,
	122	+ .id = AV_CODEC_ID_V210,
123	123	.init = encode_init,
124	124	.encode2 = encode_frame,
125	125	.close = encode_close,

libavcodec/v210x.c+1−1

@@ -135,7 +135,7 @@ static av_cold int decode_close(AVCodecContext *avctx) · 134 unmodified lines
135	135	AVCodec ff_v210x_decoder = {
136	136	.name = "v210x",
137	137	.type = AVMEDIA_TYPE_VIDEO,
138		− .id = CODEC_ID_V210X,
	138	+ .id = AV_CODEC_ID_V210X,
139	139	.init = decode_init,
140	140	.close = decode_close,
141	141	.decode = decode_frame,

libavcodec/v410dec.c+1−1

@@ -113,7 +113,7 @@ static av_cold int v410_decode_close(AVCodecContext *avctx) · 112 unmodified lines
113	113	AVCodec ff_v410_decoder = {
114	114	.name = "v410",
115	115	.type = AVMEDIA_TYPE_VIDEO,
116		− .id = CODEC_ID_V410,
	116	+ .id = AV_CODEC_ID_V410,
117	117	.init = v410_decode_init,
118	118	.decode = v410_decode_frame,
119	119	.close = v410_decode_close,

libavcodec/v410enc.c+1−1

@@ -91,7 +91,7 @@ static av_cold int v410_encode_close(AVCodecContext *avctx) · 90 unmodified lines
91	91	AVCodec ff_v410_encoder = {
92	92	.name = "v410",
93	93	.type = AVMEDIA_TYPE_VIDEO,
94		− .id = CODEC_ID_V410,
	94	+ .id = AV_CODEC_ID_V410,
95	95	.init = v410_encode_init,
96	96	.encode2 = v410_encode_frame,
97	97	.close = v410_encode_close,

libavcodec/vaapi_h264.c+1−1

@@ -339,7 +339,7 @@ static int decode_slice(AVCodecContext *avctx, · 338 unmodified lines
339	339	AVHWAccel ff_h264_vaapi_hwaccel = {
340	340	.name = "h264_vaapi",
341	341	.type = AVMEDIA_TYPE_VIDEO,
342		− .id = CODEC_ID_H264,
	342	+ .id = AV_CODEC_ID_H264,
343	343	.pix_fmt = PIX_FMT_VAAPI_VLD,
344	344	.start_frame = start_frame,
345	345	.end_frame = end_frame,

libavcodec/vaapi_mpeg2.c+1−1

@@ -141,7 +141,7 @@ static int vaapi_mpeg2_decode_slice(AVCodecContext avctx, const uint8_t buffer · 140 unmodified lines
141	141	AVHWAccel ff_mpeg2_vaapi_hwaccel = {
142	142	.name = "mpeg2_vaapi",
143	143	.type = AVMEDIA_TYPE_VIDEO,
144		− .id = CODEC_ID_MPEG2VIDEO,
	144	+ .id = AV_CODEC_ID_MPEG2VIDEO,
145	145	.pix_fmt = PIX_FMT_VAAPI_VLD,
146	146	.start_frame = vaapi_mpeg2_start_frame,
147	147	.end_frame = vaapi_mpeg2_end_frame,

libavcodec/vaapi_mpeg4.c+5−5

@@ -60,7 +60,7 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_ · 59 unmodified lines
60	60	pic_param->forward_reference_picture = VA_INVALID_ID;
61	61	pic_param->backward_reference_picture = VA_INVALID_ID;
62	62	pic_param->vol_fields.value = 0; /* reset all bits */
63		− pic_param->vol_fields.bits.short_video_header = avctx->codec->id == CODEC_ID_H263;
	63	+ pic_param->vol_fields.bits.short_video_header = avctx->codec->id == AV_CODEC_ID_H263;
64	64	pic_param->vol_fields.bits.chroma_format = CHROMA_420;
65	65	pic_param->vol_fields.bits.interlaced = !s->progressive_sequence;
66	66	pic_param->vol_fields.bits.obmc_disable = 1;
@@ -132,7 +132,7 @@ static int vaapi_mpeg4_decode_slice(AVCodecContext avctx, const uint8_t buffer · 65 unmodified lines
132	132	* a single slice param. So fake macroblock_number for Libav so
133	133	* that we don't call vaapi_mpeg4_decode_slice() again
134	134	*/
135		− if (avctx->codec->id == CODEC_ID_H263)
	135	+ if (avctx->codec->id == AV_CODEC_ID_H263)
136	136	size = s->gb.buffer_end - buffer;
137	137
138	138	/* Fill in VASliceParameterBufferMPEG4 */
@@ -143,7 +143,7 @@ static int vaapi_mpeg4_decode_slice(AVCodecContext avctx, const uint8_t buffer · 4 unmodified lines
143	143	slice_param->macroblock_number = s->mb_y * s->mb_width + s->mb_x;
144	144	slice_param->quant_scale = s->qscale;
145	145
146		− if (avctx->codec->id == CODEC_ID_H263)
	146	+ if (avctx->codec->id == AV_CODEC_ID_H263)
147	147	s->mb_y = s->mb_height;
148	148
149	149	return 0;
@@ -153,7 +153,7 @@ static int vaapi_mpeg4_decode_slice(AVCodecContext avctx, const uint8_t buffer · 3 unmodified lines
153	153	AVHWAccel ff_mpeg4_vaapi_hwaccel = {
154	154	.name = "mpeg4_vaapi",
155	155	.type = AVMEDIA_TYPE_VIDEO,
156		− .id = CODEC_ID_MPEG4,
	156	+ .id = AV_CODEC_ID_MPEG4,
157	157	.pix_fmt = PIX_FMT_VAAPI_VLD,
158	158	.start_frame = vaapi_mpeg4_start_frame,
159	159	.end_frame = vaapi_mpeg4_end_frame,
@@ -165,7 +165,7 @@ AVHWAccel ff_mpeg4_vaapi_hwaccel = { · 5 unmodified lines
165	165	AVHWAccel ff_h263_vaapi_hwaccel = {
166	166	.name = "h263_vaapi",
167	167	.type = AVMEDIA_TYPE_VIDEO,
168		− .id = CODEC_ID_H263,
	168	+ .id = AV_CODEC_ID_H263,
169	169	.pix_fmt = PIX_FMT_VAAPI_VLD,
170	170	.start_frame = vaapi_mpeg4_start_frame,
171	171	.end_frame = vaapi_mpeg4_end_frame,

libavcodec/vaapi_vc1.c+3−3

@@ -326,7 +326,7 @@ static int vaapi_vc1_decode_slice(AVCodecContext avctx, const uint8_t buffer, · 325 unmodified lines
326	326	av_dlog(avctx, "vaapi_vc1_decode_slice(): buffer %p, size %d\n", buffer, size);
327	327
328	328	/* Current bit buffer is beyond any marker for VC-1, so skip it */
329		− if (avctx->codec_id == CODEC_ID_VC1 && IS_MARKER(AV_RB32(buffer))) {
	329	+ if (avctx->codec_id == AV_CODEC_ID_VC1 && IS_MARKER(AV_RB32(buffer))) {
330	330	buffer += 4;
331	331	size -= 4;
332	332	}
@@ -344,7 +344,7 @@ static int vaapi_vc1_decode_slice(AVCodecContext avctx, const uint8_t buffer, · 11 unmodified lines
344	344	AVHWAccel ff_wmv3_vaapi_hwaccel = {
345	345	.name = "wmv3_vaapi",
346	346	.type = AVMEDIA_TYPE_VIDEO,
347		− .id = CODEC_ID_WMV3,
	347	+ .id = AV_CODEC_ID_WMV3,
348	348	.pix_fmt = PIX_FMT_VAAPI_VLD,
349	349	.start_frame = vaapi_vc1_start_frame,
350	350	.end_frame = vaapi_vc1_end_frame,
@@ -355,7 +355,7 @@ AVHWAccel ff_wmv3_vaapi_hwaccel = { · 4 unmodified lines
355	355	AVHWAccel ff_vc1_vaapi_hwaccel = {
356	356	.name = "vc1_vaapi",
357	357	.type = AVMEDIA_TYPE_VIDEO,
358		− .id = CODEC_ID_VC1,
	358	+ .id = AV_CODEC_ID_VC1,
359	359	.pix_fmt = PIX_FMT_VAAPI_VLD,
360	360	.start_frame = vaapi_vc1_start_frame,
361	361	.end_frame = vaapi_vc1_end_frame,

libavcodec/vb.c+1−1

@@ -269,7 +269,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 268 unmodified lines
269	269	AVCodec ff_vb_decoder = {
270	270	.name = "vb",
271	271	.type = AVMEDIA_TYPE_VIDEO,
272		− .id = CODEC_ID_VB,
	272	+ .id = AV_CODEC_ID_VB,
273	273	.priv_data_size = sizeof(VBDecContext),
274	274	.init = decode_init,
275	275	.close = decode_end,

libavcodec/vble.c+1−1

@@ -219,7 +219,7 @@ static av_cold int vble_decode_init(AVCodecContext *avctx) · 218 unmodified lines
219	219	AVCodec ff_vble_decoder = {
220	220	.name = "vble",
221	221	.type = AVMEDIA_TYPE_VIDEO,
222		− .id = CODEC_ID_VBLE,
	222	+ .id = AV_CODEC_ID_VBLE,
223	223	.priv_data_size = sizeof(VBLEContext),
224	224	.init = vble_decode_init,
225	225	.close = vble_decode_close,

libavcodec/vc1_parser.c+1−1

@@ -192,7 +192,7 @@ static int vc1_parse_init(AVCodecParserContext *s) · 191 unmodified lines
192	192	}
193	193
194	194	AVCodecParser ff_vc1_parser = {
195		− .codec_ids = { CODEC_ID_VC1 },
	195	+ .codec_ids = { AV_CODEC_ID_VC1 },
196	196	.priv_data_size = sizeof(VC1ParseContext),
197	197	.parser_init = vc1_parse_init,
198	198	.parser_parse = vc1_parse,

libavcodec/vc1dec.c+16−16

@@ -4890,7 +4890,7 @@ static void vc1_parse_sprites(VC1Context v, GetBitContext gb, SpriteData* sd) · 4889 unmodified lines
4890	4890	av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4891	4891
4892	4892	if (get_bits_count(gb) >= gb->size_in_bits +
4893		− (avctx->codec_id == CODEC_ID_WMV3IMAGE ? 64 : 0))
	4893	+ (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
4894	4894	av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4895	4895	if (get_bits_count(gb) < gb->size_in_bits - 8)
4896	4896	av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
@@ -5099,7 +5099,7 @@ static av_cold int vc1_decode_init_alloc_tables(VC1Context *v) · 202 unmodified lines
5099	5099
5100	5100	ff_intrax8_common_init(&v->x8,s);
5101	5101
5102		− if (s->avctx->codec_id == CODEC_ID_WMV3IMAGE \|\| s->avctx->codec_id == CODEC_ID_VC1IMAGE) {
	5102	+ if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE \|\| s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5103	5103	for (i = 0; i < 4; i++)
5104	5104	if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5105	5105	}
@@ -5146,7 +5146,7 @@ static av_cold int vc1_decode_init(AVCodecContext *avctx) · 40 unmodified lines
5146	5146	return -1;
5147	5147	ff_vc1dsp_init(&v->vc1dsp);
5148	5148
5149		− if (avctx->codec_id == CODEC_ID_WMV3 \|\| avctx->codec_id == CODEC_ID_WMV3IMAGE) {
	5149	+ if (avctx->codec_id == AV_CODEC_ID_WMV3 \|\| avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5150	5150	int count = 0;
5151	5151
5152	5152	// looks like WMV3 has a sequence header stored in the extradata
@@ -5240,7 +5240,7 @@ static av_cold int vc1_decode_init(AVCodecContext *avctx) · 87 unmodified lines
5240	5240	v->top_blk_sh = 0;
5241	5241	}
5242	5242
5243		− if (avctx->codec_id == CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == CODEC_ID_VC1IMAGE) {
	5243	+ if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5244	5244	v->sprite_width = avctx->coded_width;
5245	5245	v->sprite_height = avctx->coded_height;
5246	5246
@@ -5264,7 +5264,7 @@ static av_cold int vc1_decode_end(AVCodecContext *avctx) · 17 unmodified lines
5264	5264	VC1Context *v = avctx->priv_data;
5265	5265	int i;
5266	5266
5267		− if ((avctx->codec_id == CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == CODEC_ID_VC1IMAGE)
	5267	+ if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5268	5268	&& v->sprite_output_frame.data[0])
5269	5269	avctx->release_buffer(avctx, &v->sprite_output_frame);
5270	5270	for (i = 0; i < 4; i++)
@@ -5334,7 +5334,7 @@ static int vc1_decode_frame(AVCodecContext avctx, void data, · 63 unmodified lines
5334	5334	}
5335	5335
5336	5336	//for advanced profile we may need to parse and unescape data
5337		− if (avctx->codec_id == CODEC_ID_VC1 \|\| avctx->codec_id == CODEC_ID_VC1IMAGE) {
	5337	+ if (avctx->codec_id == AV_CODEC_ID_VC1 \|\| avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5338	5338	int buf_size2 = 0;
5339	5339	buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5340	5340
@@ -5430,11 +5430,11 @@ static int vc1_decode_frame(AVCodecContext avctx, void data, · 89 unmodified lines
5430	5430	if (v->res_sprite) {
5431	5431	v->new_sprite = !get_bits1(&s->gb);
5432	5432	v->two_sprites = get_bits1(&s->gb);
5433		− /* res_sprite means a Windows Media Image stream, CODEC_ID_*IMAGE means
	5433	+ /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5434	5434	we're using the sprite compositor. These are intentionally kept separate
5435	5435	so you can get the raw sprites by using the wmv3 decoder for WMVP or
5436	5436	the vc1 one for WVP2 */
5437		− if (avctx->codec_id == CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == CODEC_ID_VC1IMAGE) {
	5437	+ if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5438	5438	if (v->new_sprite) {
5439	5439	// switch AVCodecContext parameters to those of the sprites
5440	5440	avctx->width = avctx->coded_width = v->sprite_width;
@@ -5484,7 +5484,7 @@ static int vc1_decode_frame(AVCodecContext avctx, void data, · 43 unmodified lines
5484	5484	}
5485	5485	}
5486	5486
5487		− if ((avctx->codec_id == CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == CODEC_ID_VC1IMAGE)
	5487	+ if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5488	5488	&& s->pict_type != AV_PICTURE_TYPE_I) {
5489	5489	av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5490	5490	goto err;
@@ -5621,7 +5621,7 @@ static int vc1_decode_frame(AVCodecContext avctx, void data, · 130 unmodified lines
5621	5621
5622	5622	ff_MPV_frame_end(s);
5623	5623
5624		− if (avctx->codec_id == CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == CODEC_ID_VC1IMAGE) {
	5624	+ if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5625	5625	image:
5626	5626	avctx->width = avctx->coded_width = v->output_width;
5627	5627	avctx->height = avctx->coded_height = v->output_height;
@@ -5672,7 +5672,7 @@ static const AVProfile profiles[] = { · 44 unmodified lines
5672	5672	AVCodec ff_vc1_decoder = {
5673	5673	.name = "vc1",
5674	5674	.type = AVMEDIA_TYPE_VIDEO,
5675		− .id = CODEC_ID_VC1,
	5675	+ .id = AV_CODEC_ID_VC1,
5676	5676	.priv_data_size = sizeof(VC1Context),
5677	5677	.init = vc1_decode_init,
5678	5678	.close = vc1_decode_end,
@@ -5687,7 +5687,7 @@ AVCodec ff_vc1_decoder = { · 8 unmodified lines
5687	5687	AVCodec ff_wmv3_decoder = {
5688	5688	.name = "wmv3",
5689	5689	.type = AVMEDIA_TYPE_VIDEO,
5690		− .id = CODEC_ID_WMV3,
	5690	+ .id = AV_CODEC_ID_WMV3,
5691	5691	.priv_data_size = sizeof(VC1Context),
5692	5692	.init = vc1_decode_init,
5693	5693	.close = vc1_decode_end,
@@ -5703,7 +5703,7 @@ AVCodec ff_wmv3_decoder = { · 9 unmodified lines
5703	5703	AVCodec ff_wmv3_vdpau_decoder = {
5704	5704	.name = "wmv3_vdpau",
5705	5705	.type = AVMEDIA_TYPE_VIDEO,
5706		− .id = CODEC_ID_WMV3,
	5706	+ .id = AV_CODEC_ID_WMV3,
5707	5707	.priv_data_size = sizeof(VC1Context),
5708	5708	.init = vc1_decode_init,
5709	5709	.close = vc1_decode_end,
@@ -5719,7 +5719,7 @@ AVCodec ff_wmv3_vdpau_decoder = { · 9 unmodified lines
5719	5719	AVCodec ff_vc1_vdpau_decoder = {
5720	5720	.name = "vc1_vdpau",
5721	5721	.type = AVMEDIA_TYPE_VIDEO,
5722		− .id = CODEC_ID_VC1,
	5722	+ .id = AV_CODEC_ID_VC1,
5723	5723	.priv_data_size = sizeof(VC1Context),
5724	5724	.init = vc1_decode_init,
5725	5725	.close = vc1_decode_end,
@@ -5735,7 +5735,7 @@ AVCodec ff_vc1_vdpau_decoder = { · 9 unmodified lines
5735	5735	AVCodec ff_wmv3image_decoder = {
5736	5736	.name = "wmv3image",
5737	5737	.type = AVMEDIA_TYPE_VIDEO,
5738		− .id = CODEC_ID_WMV3IMAGE,
	5738	+ .id = AV_CODEC_ID_WMV3IMAGE,
5739	5739	.priv_data_size = sizeof(VC1Context),
5740	5740	.init = vc1_decode_init,
5741	5741	.close = vc1_decode_end,
@@ -5751,7 +5751,7 @@ AVCodec ff_wmv3image_decoder = { · 9 unmodified lines
5751	5751	AVCodec ff_vc1image_decoder = {
5752	5752	.name = "vc1image",
5753	5753	.type = AVMEDIA_TYPE_VIDEO,
5754		− .id = CODEC_ID_VC1IMAGE,
	5754	+ .id = AV_CODEC_ID_VC1IMAGE,
5755	5755	.priv_data_size = sizeof(VC1Context),
5756	5756	.init = vc1_decode_init,
5757	5757	.close = vc1_decode_end,

libavcodec/vcr1.c+2−2

@@ -139,7 +139,7 @@ static int vcr1_decode_frame(AVCodecContext avctx, void data, · 138 unmodified lines
139	139	AVCodec ff_vcr1_decoder = {
140	140	.name = "vcr1",
141	141	.type = AVMEDIA_TYPE_VIDEO,
142		− .id = CODEC_ID_VCR1,
	142	+ .id = AV_CODEC_ID_VCR1,
143	143	.priv_data_size = sizeof(VCR1Context),
144	144	.init = vcr1_decode_init,
145	145	.close = vcr1_decode_end,
@@ -179,7 +179,7 @@ static int vcr1_encode_frame(AVCodecContext avctx, unsigned char buf, · 33 unmodified lines
179	179	AVCodec ff_vcr1_encoder = {
180	180	.name = "vcr1",
181	181	.type = AVMEDIA_TYPE_VIDEO,
182		− .id = CODEC_ID_VCR1,
	182	+ .id = AV_CODEC_ID_VCR1,
183	183	.priv_data_size = sizeof(VCR1Context),
184	184	.init = vcr1_common_init,
185	185	.encode = vcr1_encode_frame,

libavcodec/vda_h264.c+1−1

@@ -100,7 +100,7 @@ static int end_frame(AVCodecContext *avctx) · 99 unmodified lines
100	100	AVHWAccel ff_h264_vda_hwaccel = {
101	101	.name = "h264_vda",
102	102	.type = AVMEDIA_TYPE_VIDEO,
103		− .id = CODEC_ID_H264,
	103	+ .id = AV_CODEC_ID_H264,
104	104	.pix_fmt = PIX_FMT_VDA_VLD,
105	105	.start_frame = start_frame,
106	106	.decode_slice = decode_slice,

libavcodec/vdpau.c+1−1

@@ -340,7 +340,7 @@ void ff_vdpau_mpeg4_decode_picture(MpegEncContext s, const uint8_t buf, · 339 unmodified lines
340	340	render->info.mpeg4.interlaced = !s->progressive_sequence;
341	341	render->info.mpeg4.quant_type = s->mpeg_quant;
342	342	render->info.mpeg4.quarter_sample = s->quarter_sample;
343		− render->info.mpeg4.short_video_header = s->avctx->codec->id == CODEC_ID_H263;
	343	+ render->info.mpeg4.short_video_header = s->avctx->codec->id == AV_CODEC_ID_H263;
344	344	render->info.mpeg4.rounding_control = s->no_rounding;
345	345	render->info.mpeg4.alternate_vertical_scan_flag = s->alternate_scan;
346	346	render->info.mpeg4.top_field_first = s->top_field_first;

libavcodec/vmdav.c+2−2

@@ -652,7 +652,7 @@ static int vmdaudio_decode_frame(AVCodecContext avctx, void data, · 651 unmodified lines
652	652	AVCodec ff_vmdvideo_decoder = {
653	653	.name = "vmdvideo",
654	654	.type = AVMEDIA_TYPE_VIDEO,
655		− .id = CODEC_ID_VMDVIDEO,
	655	+ .id = AV_CODEC_ID_VMDVIDEO,
656	656	.priv_data_size = sizeof(VmdVideoContext),
657	657	.init = vmdvideo_decode_init,
658	658	.close = vmdvideo_decode_end,
@@ -664,7 +664,7 @@ AVCodec ff_vmdvideo_decoder = { · 5 unmodified lines
664	664	AVCodec ff_vmdaudio_decoder = {
665	665	.name = "vmdaudio",
666	666	.type = AVMEDIA_TYPE_AUDIO,
667		− .id = CODEC_ID_VMDAUDIO,
	667	+ .id = AV_CODEC_ID_VMDAUDIO,
668	668	.priv_data_size = sizeof(VmdAudioContext),
669	669	.init = vmdaudio_decode_init,
670	670	.decode = vmdaudio_decode_frame,

libavcodec/vmnc.c+1−1

@@ -512,7 +512,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 511 unmodified lines
512	512	AVCodec ff_vmnc_decoder = {
513	513	.name = "vmnc",
514	514	.type = AVMEDIA_TYPE_VIDEO,
515		− .id = CODEC_ID_VMNC,
	515	+ .id = AV_CODEC_ID_VMNC,
516	516	.priv_data_size = sizeof(VmncContext),
517	517	.init = decode_init,
518	518	.close = decode_end,

libavcodec/vorbis_parser.c+1−1

@@ -263,7 +263,7 @@ end: · 262 unmodified lines
263	263	}
264	264
265	265	AVCodecParser ff_vorbis_parser = {
266		− .codec_ids = { CODEC_ID_VORBIS },
	266	+ .codec_ids = { AV_CODEC_ID_VORBIS },
267	267	.priv_data_size = sizeof(VorbisParseContext),
268	268	.parser_parse = vorbis_parse,
269	269	};

libavcodec/vorbisdec.c+1−1

@@ -1730,7 +1730,7 @@ static av_cold void vorbis_decode_flush(AVCodecContext *avccontext) · 1729 unmodified lines
1730	1730	AVCodec ff_vorbis_decoder = {
1731	1731	.name = "vorbis",
1732	1732	.type = AVMEDIA_TYPE_AUDIO,
1733		− .id = CODEC_ID_VORBIS,
	1733	+ .id = AV_CODEC_ID_VORBIS,
1734	1734	.priv_data_size = sizeof(vorbis_context),
1735	1735	.init = vorbis_decode_init,
1736	1736	.close = vorbis_decode_close,

libavcodec/vorbisenc.c+1−1

@@ -1209,7 +1209,7 @@ error: · 1208 unmodified lines
1209	1209	AVCodec ff_vorbis_encoder = {
1210	1210	.name = "vorbis",
1211	1211	.type = AVMEDIA_TYPE_AUDIO,
1212		− .id = CODEC_ID_VORBIS,
	1212	+ .id = AV_CODEC_ID_VORBIS,
1213	1213	.priv_data_size = sizeof(vorbis_enc_context),
1214	1214	.init = vorbis_encode_init,
1215	1215	.encode2 = vorbis_encode_frame,

libavcodec/vp3.c+2−2

@@ -2377,7 +2377,7 @@ static av_cold int theora_decode_init(AVCodecContext *avctx) · 2376 unmodified lines
2377	2377	AVCodec ff_theora_decoder = {
2378	2378	.name = "theora",
2379	2379	.type = AVMEDIA_TYPE_VIDEO,
2380		− .id = CODEC_ID_THEORA,
	2380	+ .id = AV_CODEC_ID_THEORA,
2381	2381	.priv_data_size = sizeof(Vp3DecodeContext),
2382	2382	.init = theora_decode_init,
2383	2383	.close = vp3_decode_end,
@@ -2394,7 +2394,7 @@ AVCodec ff_theora_decoder = { · 10 unmodified lines
2394	2394	AVCodec ff_vp3_decoder = {
2395	2395	.name = "vp3",
2396	2396	.type = AVMEDIA_TYPE_VIDEO,
2397		− .id = CODEC_ID_VP3,
	2397	+ .id = AV_CODEC_ID_VP3,
2398	2398	.priv_data_size = sizeof(Vp3DecodeContext),
2399	2399	.init = vp3_decode_init,
2400	2400	.close = vp3_decode_end,

libavcodec/vp3_parser.c+3−3

@@ -25,7 +25,7 @@ static int parse(AVCodecParserContext *s, · 24 unmodified lines
25	25	const uint8_t *poutbuf, int poutbuf_size,
26	26	const uint8_t *buf, int buf_size)
27	27	{
28		− if(avctx->codec_id == CODEC_ID_THEORA)
	28	+ if(avctx->codec_id == AV_CODEC_ID_THEORA)
29	29	s->pict_type= (buf[0]&0x40) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
30	30	else
31	31	s->pict_type= (buf[0]&0x80) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
@@ -36,7 +36,7 @@ static int parse(AVCodecParserContext *s, · 4 unmodified lines
36	36	}
37	37
38	38	AVCodecParser ff_vp3_parser = {
39		− .codec_ids = { CODEC_ID_THEORA, CODEC_ID_VP3, CODEC_ID_VP6,
40		− CODEC_ID_VP6F, CODEC_ID_VP6A },
	39	+ .codec_ids = { AV_CODEC_ID_THEORA, AV_CODEC_ID_VP3, AV_CODEC_ID_VP6,
	40	+ AV_CODEC_ID_VP6F, AV_CODEC_ID_VP6A },
41	41	.parser_parse = parse,
42	42	};

libavcodec/vp5.c+1−1

@@ -281,7 +281,7 @@ static av_cold int vp5_decode_init(AVCodecContext *avctx) · 280 unmodified lines
281	281	AVCodec ff_vp5_decoder = {
282	282	.name = "vp5",
283	283	.type = AVMEDIA_TYPE_VIDEO,
284		− .id = CODEC_ID_VP5,
	284	+ .id = AV_CODEC_ID_VP5,
285	285	.priv_data_size = sizeof(VP56Context),
286	286	.init = vp5_decode_init,
287	287	.close = ff_vp56_free,

libavcodec/vp56.c+2−2

@@ -196,7 +196,7 @@ static void vp56_decode_4mv(VP56Context *s, int row, int col) · 195 unmodified lines
196	196	s->macroblocks[row * s->mb_width + col].mv = s->mv[3];
197	197
198	198	/* chroma vectors are average luma vectors */
199		− if (s->avctx->codec->id == CODEC_ID_VP5) {
	199	+ if (s->avctx->codec->id == AV_CODEC_ID_VP5) {
200	200	s->mv[4].x = s->mv[5].x = RSHIFT(mv.x,2);
201	201	s->mv[4].y = s->mv[5].y = RSHIFT(mv.y,2);
202	202	} else {
@@ -281,7 +281,7 @@ static void vp56_add_predictors_dc(VP56Context *s, VP56Frame ref_frame) · 78 unmodified lines
281	281	dc += ab->dc_coeff;
282	282	count++;
283	283	}
284		− if (s->avctx->codec->id == CODEC_ID_VP5)
	284	+ if (s->avctx->codec->id == AV_CODEC_ID_VP5)
285	285	for (i=0; i<2; i++)
286	286	if (count < 2 && ref_frame == ab[-1+2*i].ref_frame) {
287	287	dc += ab[-1+2*i].dc_coeff;

libavcodec/vp56dsp.c+2−2

@@ -74,9 +74,9 @@ VP56_EDGE_FILTER(vp5, ver, stride, 1) · 73 unmodified lines
74	74	VP56_EDGE_FILTER(vp6, hor, 1, stride)
75	75	VP56_EDGE_FILTER(vp6, ver, stride, 1)
76	76
77		−void ff_vp56dsp_init(VP56DSPContext *s, enum CodecID codec)
	77	+void ff_vp56dsp_init(VP56DSPContext *s, enum AVCodecID codec)
78	78	{
79		− if (codec == CODEC_ID_VP5) {
	79	+ if (codec == AV_CODEC_ID_VP5) {
80	80	s->edge_filter_hor = vp5_edge_filter_hor;
81	81	s->edge_filter_ver = vp5_edge_filter_ver;
82	82	} else {

libavcodec/vp56dsp.h+3−3

@@ -35,8 +35,8 @@ typedef struct VP56DSPContext { · 34 unmodified lines
35	35	void ff_vp6_filter_diag4_c(uint8_t dst, uint8_t src, int stride,
36	36	const int16_t h_weights, const int16_t v_weights);
37	37
38		−void ff_vp56dsp_init(VP56DSPContext *s, enum CodecID codec);
39		−void ff_vp56dsp_init_arm(VP56DSPContext *s, enum CodecID codec);
40		−void ff_vp56dsp_init_x86(VP56DSPContext* c, enum CodecID codec);
	38	+void ff_vp56dsp_init(VP56DSPContext *s, enum AVCodecID codec);
	39	+void ff_vp56dsp_init_arm(VP56DSPContext *s, enum AVCodecID codec);
	40	+void ff_vp56dsp_init_x86(VP56DSPContext* c, enum AVCodecID codec);
41	41
42	42	#endif /* AVCODEC_VP56DSP_H */

libavcodec/vp6.c+5−5

@@ -594,8 +594,8 @@ static av_cold int vp6_decode_init(AVCodecContext *avctx) · 593 unmodified lines
594	594	{
595	595	VP56Context *s = avctx->priv_data;
596	596
597		− ff_vp56_init(avctx, avctx->codec->id == CODEC_ID_VP6,
598		− avctx->codec->id == CODEC_ID_VP6A);
	597	+ ff_vp56_init(avctx, avctx->codec->id == AV_CODEC_ID_VP6,
	598	+ avctx->codec->id == AV_CODEC_ID_VP6A);
599	599	s->vp56_coord_div = vp6_coord_div;
600	600	s->parse_vector_adjustment = vp6_parse_vector_adjustment;
601	601	s->filter = vp6_filter;
@@ -627,7 +627,7 @@ static av_cold int vp6_decode_free(AVCodecContext *avctx) · 25 unmodified lines
627	627	AVCodec ff_vp6_decoder = {
628	628	.name = "vp6",
629	629	.type = AVMEDIA_TYPE_VIDEO,
630		− .id = CODEC_ID_VP6,
	630	+ .id = AV_CODEC_ID_VP6,
631	631	.priv_data_size = sizeof(VP56Context),
632	632	.init = vp6_decode_init,
633	633	.close = vp6_decode_free,
@@ -640,7 +640,7 @@ AVCodec ff_vp6_decoder = { · 6 unmodified lines
640	640	AVCodec ff_vp6f_decoder = {
641	641	.name = "vp6f",
642	642	.type = AVMEDIA_TYPE_VIDEO,
643		− .id = CODEC_ID_VP6F,
	643	+ .id = AV_CODEC_ID_VP6F,
644	644	.priv_data_size = sizeof(VP56Context),
645	645	.init = vp6_decode_init,
646	646	.close = vp6_decode_free,
@@ -653,7 +653,7 @@ AVCodec ff_vp6f_decoder = { · 6 unmodified lines
653	653	AVCodec ff_vp6a_decoder = {
654	654	.name = "vp6a",
655	655	.type = AVMEDIA_TYPE_VIDEO,
656		− .id = CODEC_ID_VP6A,
	656	+ .id = AV_CODEC_ID_VP6A,
657	657	.priv_data_size = sizeof(VP56Context),
658	658	.init = vp6_decode_init,
659	659	.close = vp6_decode_free,

libavcodec/vp8.c+2−2

@@ -2019,7 +2019,7 @@ static av_cold int vp8_decode_init(AVCodecContext *avctx) · 2018 unmodified lines
2019	2019	avctx->pix_fmt = PIX_FMT_YUV420P;
2020	2020
2021	2021	ff_dsputil_init(&s->dsp, avctx);
2022		− ff_h264_pred_init(&s->hpc, CODEC_ID_VP8, 8, 1);
	2022	+ ff_h264_pred_init(&s->hpc, AV_CODEC_ID_VP8, 8, 1);
2023	2023	ff_vp8dsp_init(&s->vp8dsp);
2024	2024
2025	2025	return 0;
@@ -2073,7 +2073,7 @@ static int vp8_decode_update_thread_context(AVCodecContext *dst, const AVCodecCo · 47 unmodified lines
2073	2073	AVCodec ff_vp8_decoder = {
2074	2074	.name = "vp8",
2075	2075	.type = AVMEDIA_TYPE_VIDEO,
2076		− .id = CODEC_ID_VP8,
	2076	+ .id = AV_CODEC_ID_VP8,
2077	2077	.priv_data_size = sizeof(VP8Context),
2078	2078	.init = vp8_decode_init,
2079	2079	.close = vp8_decode_free,

libavcodec/vp8_parser.c+1−1

@@ -33,6 +33,6 @@ static int parse(AVCodecParserContext *s, · 32 unmodified lines
33	33	}
34	34
35	35	AVCodecParser ff_vp8_parser = {
36		− .codec_ids = { CODEC_ID_VP8 },
	36	+ .codec_ids = { AV_CODEC_ID_VP8 },
37	37	.parser_parse = parse,
38	38	};

libavcodec/vqavideo.c+1−1

@@ -625,7 +625,7 @@ static av_cold int vqa_decode_end(AVCodecContext *avctx) · 624 unmodified lines
625	625	AVCodec ff_vqa_decoder = {
626	626	.name = "vqavideo",
627	627	.type = AVMEDIA_TYPE_VIDEO,
628		− .id = CODEC_ID_WS_VQA,
	628	+ .id = AV_CODEC_ID_WS_VQA,
629	629	.priv_data_size = sizeof(VqaContext),
630	630	.init = vqa_decode_init,
631	631	.close = vqa_decode_end,

libavcodec/wavpack.c+1−1

@@ -1249,7 +1249,7 @@ static int wavpack_decode_frame(AVCodecContext avctx, void data, · 1248 unmodified lines
1249	1249	AVCodec ff_wavpack_decoder = {
1250	1250	.name = "wavpack",
1251	1251	.type = AVMEDIA_TYPE_AUDIO,
1252		− .id = CODEC_ID_WAVPACK,
	1252	+ .id = AV_CODEC_ID_WAVPACK,
1253	1253	.priv_data_size = sizeof(WavpackContext),
1254	1254	.init = wavpack_decode_init,
1255	1255	.close = wavpack_decode_end,

libavcodec/wma.c+1−1

@@ -90,7 +90,7 @@ int ff_wma_init(AVCodecContext *avctx, int flags2) · 89 unmodified lines
90	90	ff_dsputil_init(&s->dsp, avctx);
91	91	ff_fmt_convert_init(&s->fmt_conv, avctx);
92	92
93		− if (avctx->codec->id == CODEC_ID_WMAV1) {
	93	+ if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
94	94	s->version = 1;
95	95	} else {
96	96	s->version = 2;

libavcodec/wmadec.c+4−4

@@ -90,9 +90,9 @@ static int wma_decode_init(AVCodecContext * avctx) · 89 unmodified lines
90	90	/* extract flag infos */
91	91	flags2 = 0;
92	92	extradata = avctx->extradata;
93		− if (avctx->codec->id == CODEC_ID_WMAV1 && avctx->extradata_size >= 4) {
	93	+ if (avctx->codec->id == AV_CODEC_ID_WMAV1 && avctx->extradata_size >= 4) {
94	94	flags2 = AV_RL16(extradata+2);
95		− } else if (avctx->codec->id == CODEC_ID_WMAV2 && avctx->extradata_size >= 6) {
	95	+ } else if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 6) {
96	96	flags2 = AV_RL16(extradata+4);
97	97	}
98	98	// for(i=0; i<avctx->extradata_size; i++)
@@ -939,7 +939,7 @@ static av_cold void flush(AVCodecContext *avctx) · 840 unmodified lines
939	939	AVCodec ff_wmav1_decoder = {
940	940	.name = "wmav1",
941	941	.type = AVMEDIA_TYPE_AUDIO,
942		− .id = CODEC_ID_WMAV1,
	942	+ .id = AV_CODEC_ID_WMAV1,
943	943	.priv_data_size = sizeof(WMACodecContext),
944	944	.init = wma_decode_init,
945	945	.close = ff_wma_end,
@@ -952,7 +952,7 @@ AVCodec ff_wmav1_decoder = { · 6 unmodified lines
952	952	AVCodec ff_wmav2_decoder = {
953	953	.name = "wmav2",
954	954	.type = AVMEDIA_TYPE_AUDIO,
955		− .id = CODEC_ID_WMAV2,
	955	+ .id = AV_CODEC_ID_WMAV2,
956	956	.priv_data_size = sizeof(WMACodecContext),
957	957	.init = wma_decode_init,
958	958	.close = ff_wma_end,

libavcodec/wmaenc.c+4−4

@@ -55,12 +55,12 @@ static int encode_init(AVCodecContext * avctx){ · 54 unmodified lines
55	55	/* extract flag infos */
56	56	flags1 = 0;
57	57	flags2 = 1;
58		− if (avctx->codec->id == CODEC_ID_WMAV1) {
	58	+ if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
59	59	extradata= av_malloc(4);
60	60	avctx->extradata_size= 4;
61	61	AV_WL16(extradata, flags1);
62	62	AV_WL16(extradata+2, flags2);
63		− } else if (avctx->codec->id == CODEC_ID_WMAV2) {
	63	+ } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
64	64	extradata= av_mallocz(10);
65	65	avctx->extradata_size= 10;
66	66	AV_WL32(extradata, flags1);
@@ -422,7 +422,7 @@ static int encode_superframe(AVCodecContext avctx, AVPacket avpkt, · 355 unmodified lines
422	422	AVCodec ff_wmav1_encoder = {
423	423	.name = "wmav1",
424	424	.type = AVMEDIA_TYPE_AUDIO,
425		− .id = CODEC_ID_WMAV1,
	425	+ .id = AV_CODEC_ID_WMAV1,
426	426	.priv_data_size = sizeof(WMACodecContext),
427	427	.init = encode_init,
428	428	.encode2 = encode_superframe,
@@ -435,7 +435,7 @@ AVCodec ff_wmav1_encoder = { · 6 unmodified lines
435	435	AVCodec ff_wmav2_encoder = {
436	436	.name = "wmav2",
437	437	.type = AVMEDIA_TYPE_AUDIO,
438		− .id = CODEC_ID_WMAV2,
	438	+ .id = AV_CODEC_ID_WMAV2,
439	439	.priv_data_size = sizeof(WMACodecContext),
440	440	.init = encode_init,
441	441	.encode2 = encode_superframe,

libavcodec/wmalosslessdec.c+1−1

@@ -1283,7 +1283,7 @@ static void flush(AVCodecContext *avctx) · 1282 unmodified lines
1283	1283	AVCodec ff_wmalossless_decoder = {
1284	1284	.name = "wmalossless",
1285	1285	.type = AVMEDIA_TYPE_AUDIO,
1286		− .id = CODEC_ID_WMALOSSLESS,
	1286	+ .id = AV_CODEC_ID_WMALOSSLESS,
1287	1287	.priv_data_size = sizeof(WmallDecodeCtx),
1288	1288	.init = decode_init,
1289	1289	.decode = decode_packet,

libavcodec/wmaprodec.c+1−1

@@ -1623,7 +1623,7 @@ static void flush(AVCodecContext *avctx) · 1622 unmodified lines
1623	1623	AVCodec ff_wmapro_decoder = {
1624	1624	.name = "wmapro",
1625	1625	.type = AVMEDIA_TYPE_AUDIO,
1626		− .id = CODEC_ID_WMAPRO,
	1626	+ .id = AV_CODEC_ID_WMAPRO,
1627	1627	.priv_data_size = sizeof(WMAProDecodeCtx),
1628	1628	.init = decode_init,
1629	1629	.close = decode_end,

libavcodec/wmavoice.c+1−1

@@ -2046,7 +2046,7 @@ static av_cold void wmavoice_flush(AVCodecContext *ctx) · 2045 unmodified lines
2046	2046	AVCodec ff_wmavoice_decoder = {
2047	2047	.name = "wmavoice",
2048	2048	.type = AVMEDIA_TYPE_AUDIO,
2049		− .id = CODEC_ID_WMAVOICE,
	2049	+ .id = AV_CODEC_ID_WMAVOICE,
2050	2050	.priv_data_size = sizeof(WMAVoiceContext),
2051	2051	.init = wmavoice_decode_init,
2052	2052	.close = wmavoice_decode_end,

libavcodec/wmv2dec.c+1−1

@@ -473,7 +473,7 @@ static av_cold int wmv2_decode_end(AVCodecContext *avctx) · 472 unmodified lines
473	473	AVCodec ff_wmv2_decoder = {
474	474	.name = "wmv2",
475	475	.type = AVMEDIA_TYPE_VIDEO,
476		− .id = CODEC_ID_WMV2,
	476	+ .id = AV_CODEC_ID_WMV2,
477	477	.priv_data_size = sizeof(Wmv2Context),
478	478	.init = wmv2_decode_init,
479	479	.close = wmv2_decode_end,

libavcodec/wmv2enc.c+1−1

@@ -214,7 +214,7 @@ void ff_wmv2_encode_mb(MpegEncContext * s, · 213 unmodified lines
214	214	AVCodec ff_wmv2_encoder = {
215	215	.name = "wmv2",
216	216	.type = AVMEDIA_TYPE_VIDEO,
217		− .id = CODEC_ID_WMV2,
	217	+ .id = AV_CODEC_ID_WMV2,
218	218	.priv_data_size = sizeof(Wmv2Context),
219	219	.init = wmv2_encode_init,
220	220	.encode2 = ff_MPV_encode_picture,

libavcodec/wnv1.c+1−1

@@ -159,7 +159,7 @@ static av_cold int decode_end(AVCodecContext *avctx){ · 158 unmodified lines
159	159	AVCodec ff_wnv1_decoder = {
160	160	.name = "wnv1",
161	161	.type = AVMEDIA_TYPE_VIDEO,
162		− .id = CODEC_ID_WNV1,
	162	+ .id = AV_CODEC_ID_WNV1,
163	163	.priv_data_size = sizeof(WNV1Context),
164	164	.init = decode_init,
165	165	.close = decode_end,

libavcodec/ws-snd1.c+1−1

@@ -185,7 +185,7 @@ static int ws_snd_decode_frame(AVCodecContext avctx, void data, · 184 unmodified lines
185	185	AVCodec ff_ws_snd1_decoder = {
186	186	.name = "ws_snd1",
187	187	.type = AVMEDIA_TYPE_AUDIO,
188		− .id = CODEC_ID_WESTWOOD_SND1,
	188	+ .id = AV_CODEC_ID_WESTWOOD_SND1,
189	189	.priv_data_size = sizeof(WSSndContext),
190	190	.init = ws_snd_decode_init,
191	191	.decode = ws_snd_decode_frame,

libavcodec/x86/dsputil_mmx.c+4−4

@@ -2656,8 +2656,8 @@ static void dsputil_init_mmx2(DSPContext c, AVCodecContext avctx, · 2655 unmodified lines
2656	2656	}
2657	2657	}
2658	2658
2659		− if (CONFIG_VP3_DECODER && (avctx->codec_id == CODEC_ID_VP3 \|\|
2660		− avctx->codec_id == CODEC_ID_THEORA)) {
	2659	+ if (CONFIG_VP3_DECODER && (avctx->codec_id == AV_CODEC_ID_VP3 \|\|
	2660	+ avctx->codec_id == AV_CODEC_ID_THEORA)) {
2661	2661	c->put_no_rnd_pixels_tab[1][1] = put_no_rnd_pixels8_x2_exact_mmx2;
2662	2662	c->put_no_rnd_pixels_tab[1][2] = put_no_rnd_pixels8_y2_exact_mmx2;
2663	2663	}
@@ -2764,8 +2764,8 @@ static void dsputil_init_3dnow(DSPContext c, AVCodecContext avctx, · 100 unmodified lines
2764	2764	}
2765	2765	}
2766	2766
2767		− if (CONFIG_VP3_DECODER && (avctx->codec_id == CODEC_ID_VP3 \|\|
2768		− avctx->codec_id == CODEC_ID_THEORA)) {
	2767	+ if (CONFIG_VP3_DECODER && (avctx->codec_id == AV_CODEC_ID_VP3 \|\|
	2768	+ avctx->codec_id == AV_CODEC_ID_THEORA)) {
2769	2769	c->put_no_rnd_pixels_tab[1][1] = put_no_rnd_pixels8_x2_exact_3dnow;
2770	2770	c->put_no_rnd_pixels_tab[1][2] = put_no_rnd_pixels8_y2_exact_3dnow;
2771	2771	}

libavcodec/x86/h264_intrapred_init.c+16−16

@@ -180,17 +180,17 @@ void ff_h264_pred_init_x86(H264PredContext *h, int codec_id, const int bit_depth · 179 unmodified lines
180	180	h->pred8x8 [VERT_PRED8x8 ] = ff_pred8x8_vertical_mmx;
181	181	h->pred8x8 [HOR_PRED8x8 ] = ff_pred8x8_horizontal_mmx;
182	182	}
183		− if (codec_id == CODEC_ID_VP8) {
	183	+ if (codec_id == AV_CODEC_ID_VP8) {
184	184	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_tm_vp8_mmx;
185	185	h->pred8x8 [PLANE_PRED8x8 ] = ff_pred8x8_tm_vp8_mmx;
186	186	h->pred4x4 [TM_VP8_PRED ] = ff_pred4x4_tm_vp8_mmx;
187	187	} else {
188	188	if (chroma_format_idc == 1)
189	189	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_plane_mmx;
190		− if (codec_id == CODEC_ID_SVQ3) {
	190	+ if (codec_id == AV_CODEC_ID_SVQ3) {
191	191	if (mm_flags & AV_CPU_FLAG_CMOV)
192	192	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_svq3_mmx;
193		− } else if (codec_id == CODEC_ID_RV40) {
	193	+ } else if (codec_id == AV_CODEC_ID_RV40) {
194	194	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_rv40_mmx;
195	195	} else {
196	196	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_h264_mmx;
@@ -216,22 +216,22 @@ void ff_h264_pred_init_x86(H264PredContext *h, int codec_id, const int bit_depth · 19 unmodified lines
216	216	h->pred4x4 [VERT_RIGHT_PRED ] = ff_pred4x4_vertical_right_mmxext;
217	217	h->pred4x4 [HOR_DOWN_PRED ] = ff_pred4x4_horizontal_down_mmxext;
218	218	h->pred4x4 [DC_PRED ] = ff_pred4x4_dc_mmxext;
219		− if (codec_id == CODEC_ID_VP8 \|\| codec_id == CODEC_ID_H264) {
	219	+ if (codec_id == AV_CODEC_ID_VP8 \|\| codec_id == AV_CODEC_ID_H264) {
220	220	h->pred4x4 [DIAG_DOWN_LEFT_PRED] = ff_pred4x4_down_left_mmxext;
221	221	}
222		− if (codec_id == CODEC_ID_SVQ3 \|\| codec_id == CODEC_ID_H264) {
	222	+ if (codec_id == AV_CODEC_ID_SVQ3 \|\| codec_id == AV_CODEC_ID_H264) {
223	223	h->pred4x4 [VERT_LEFT_PRED ] = ff_pred4x4_vertical_left_mmxext;
224	224	}
225		− if (codec_id != CODEC_ID_RV40) {
	225	+ if (codec_id != AV_CODEC_ID_RV40) {
226	226	h->pred4x4 [HOR_UP_PRED ] = ff_pred4x4_horizontal_up_mmxext;
227	227	}
228		− if (codec_id == CODEC_ID_SVQ3 \|\| codec_id == CODEC_ID_H264) {
	228	+ if (codec_id == AV_CODEC_ID_SVQ3 \|\| codec_id == AV_CODEC_ID_H264) {
229	229	if (chroma_format_idc == 1) {
230	230	h->pred8x8[TOP_DC_PRED8x8 ] = ff_pred8x8_top_dc_mmxext;
231	231	h->pred8x8[DC_PRED8x8 ] = ff_pred8x8_dc_mmxext;
232	232	}
233	233	}
234		− if (codec_id == CODEC_ID_VP8) {
	234	+ if (codec_id == AV_CODEC_ID_VP8) {
235	235	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_tm_vp8_mmx2;
236	236	h->pred8x8 [DC_PRED8x8 ] = ff_pred8x8_dc_rv40_mmxext;
237	237	h->pred8x8 [PLANE_PRED8x8 ] = ff_pred8x8_tm_vp8_mmx2;
@@ -240,9 +240,9 @@ void ff_h264_pred_init_x86(H264PredContext *h, int codec_id, const int bit_depth · 2 unmodified lines
240	240	} else {
241	241	if (chroma_format_idc == 1)
242	242	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_plane_mmx2;
243		− if (codec_id == CODEC_ID_SVQ3) {
	243	+ if (codec_id == AV_CODEC_ID_SVQ3) {
244	244	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_plane_svq3_mmx2;
245		− } else if (codec_id == CODEC_ID_RV40) {
	245	+ } else if (codec_id == AV_CODEC_ID_RV40) {
246	246	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_plane_rv40_mmx2;
247	247	} else {
248	248	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_plane_h264_mmx2;
@@ -261,15 +261,15 @@ void ff_h264_pred_init_x86(H264PredContext *h, int codec_id, const int bit_depth · 12 unmodified lines
261	261	h->pred8x8l [VERT_RIGHT_PRED ] = ff_pred8x8l_vertical_right_sse2;
262	262	h->pred8x8l [VERT_LEFT_PRED ] = ff_pred8x8l_vertical_left_sse2;
263	263	h->pred8x8l [HOR_DOWN_PRED ] = ff_pred8x8l_horizontal_down_sse2;
264		− if (codec_id == CODEC_ID_VP8) {
	264	+ if (codec_id == AV_CODEC_ID_VP8) {
265	265	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_tm_vp8_sse2;
266	266	h->pred8x8 [PLANE_PRED8x8 ] = ff_pred8x8_tm_vp8_sse2;
267	267	} else {
268	268	if (chroma_format_idc == 1)
269	269	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_plane_sse2;
270		− if (codec_id == CODEC_ID_SVQ3) {
	270	+ if (codec_id == AV_CODEC_ID_SVQ3) {
271	271	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_svq3_sse2;
272		− } else if (codec_id == CODEC_ID_RV40) {
	272	+ } else if (codec_id == AV_CODEC_ID_RV40) {
273	273	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_rv40_sse2;
274	274	} else {
275	275	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_h264_sse2;
@@ -292,15 +292,15 @@ void ff_h264_pred_init_x86(H264PredContext *h, int codec_id, const int bit_depth · 16 unmodified lines
292	292	h->pred8x8l [VERT_LEFT_PRED ] = ff_pred8x8l_vertical_left_ssse3;
293	293	h->pred8x8l [HOR_UP_PRED ] = ff_pred8x8l_horizontal_up_ssse3;
294	294	h->pred8x8l [HOR_DOWN_PRED ] = ff_pred8x8l_horizontal_down_ssse3;
295		− if (codec_id == CODEC_ID_VP8) {
	295	+ if (codec_id == AV_CODEC_ID_VP8) {
296	296	h->pred8x8 [PLANE_PRED8x8 ] = ff_pred8x8_tm_vp8_ssse3;
297	297	h->pred4x4 [TM_VP8_PRED ] = ff_pred4x4_tm_vp8_ssse3;
298	298	} else {
299	299	if (chroma_format_idc == 1)
300	300	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_plane_ssse3;
301		− if (codec_id == CODEC_ID_SVQ3) {
	301	+ if (codec_id == AV_CODEC_ID_SVQ3) {
302	302	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_svq3_ssse3;
303		− } else if (codec_id == CODEC_ID_RV40) {
	303	+ } else if (codec_id == AV_CODEC_ID_RV40) {
304	304	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_rv40_ssse3;
305	305	} else {
306	306	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_h264_ssse3;

libavcodec/x86/motion_est_mmx.c+1−1

@@ -460,7 +460,7 @@ void ff_dsputil_init_pix_mmx(DSPContext* c, AVCodecContext *avctx) · 459 unmodified lines
460	460	c->pix_abs[1][3] = sad8_xy2_mmx2;
461	461	}
462	462	}
463		− if ((mm_flags & AV_CPU_FLAG_SSE2) && !(mm_flags & AV_CPU_FLAG_3DNOW) && avctx->codec_id != CODEC_ID_SNOW) {
	463	+ if ((mm_flags & AV_CPU_FLAG_SSE2) && !(mm_flags & AV_CPU_FLAG_3DNOW) && avctx->codec_id != AV_CODEC_ID_SNOW) {
464	464	c->sad[0]= sad16_sse2;
465	465	}
466	466	#endif /* HAVE_INLINE_ASM */

libavcodec/x86/vp56dsp_init.c+2−2

@@ -30,12 +30,12 @@ void ff_vp6_filter_diag4_mmx(uint8_t dst, uint8_t src, int stride, · 29 unmodified lines
30	30	void ff_vp6_filter_diag4_sse2(uint8_t dst, uint8_t src, int stride,
31	31	const int16_t h_weights,const int16_t v_weights);
32	32
33		−av_cold void ff_vp56dsp_init_x86(VP56DSPContext* c, enum CodecID codec)
	33	+av_cold void ff_vp56dsp_init_x86(VP56DSPContext* c, enum AVCodecID codec)
34	34	{
35	35	#if HAVE_YASM
36	36	int mm_flags = av_get_cpu_flags();
37	37
38		− if (CONFIG_VP6_DECODER && codec == CODEC_ID_VP6) {
	38	+ if (CONFIG_VP6_DECODER && codec == AV_CODEC_ID_VP6) {
39	39	#if ARCH_X86_32
40	40	if (mm_flags & AV_CPU_FLAG_MMX) {
41	41	c->vp6_filter_diag4 = ff_vp6_filter_diag4_mmx;

libavcodec/xan.c+2−2

@@ -500,7 +500,7 @@ static int xan_decode_frame(AVCodecContext *avctx, · 499 unmodified lines
500	500	int ret, buf_size = avpkt->size;
501	501	XanContext *s = avctx->priv_data;
502	502
503		− if (avctx->codec->id == CODEC_ID_XAN_WC3) {
	503	+ if (avctx->codec->id == AV_CODEC_ID_XAN_WC3) {
504	504	const uint8_t *buf_end = buf + buf_size;
505	505	int tag = 0;
506	506	while (buf_end - buf > 8 && tag != VGA__TAG) {
@@ -612,7 +612,7 @@ static av_cold int xan_decode_end(AVCodecContext *avctx) · 105 unmodified lines
612	612	AVCodec ff_xan_wc3_decoder = {
613	613	.name = "xan_wc3",
614	614	.type = AVMEDIA_TYPE_VIDEO,
615		− .id = CODEC_ID_XAN_WC3,
	615	+ .id = AV_CODEC_ID_XAN_WC3,
616	616	.priv_data_size = sizeof(XanContext),
617	617	.init = xan_decode_init,
618	618	.close = xan_decode_end,

libavcodec/xbmenc.c+1−1

@@ -76,7 +76,7 @@ static av_cold int xbm_encode_close(AVCodecContext *avctx) · 75 unmodified lines
76	76	AVCodec ff_xbm_encoder = {
77	77	.name = "xbm",
78	78	.type = AVMEDIA_TYPE_VIDEO,
79		− .id = CODEC_ID_XBM,
	79	+ .id = AV_CODEC_ID_XBM,
80	80	.init = xbm_encode_init,
81	81	.encode2 = xbm_encode_frame,
82	82	.close = xbm_encode_close,

libavcodec/xl.c+1−1

@@ -147,7 +147,7 @@ static av_cold int decode_end(AVCodecContext *avctx){ · 146 unmodified lines
147	147	AVCodec ff_xl_decoder = {
148	148	.name = "xl",
149	149	.type = AVMEDIA_TYPE_VIDEO,
150		− .id = CODEC_ID_VIXL,
	150	+ .id = AV_CODEC_ID_VIXL,
151	151	.priv_data_size = sizeof(VideoXLContext),
152	152	.init = decode_init,
153	153	.close = decode_end,

libavcodec/xsubdec.c+1−1

@@ -136,7 +136,7 @@ static int decode_frame(AVCodecContext avctx, void data, int *data_size, · 135 unmodified lines
136	136	AVCodec ff_xsub_decoder = {
137	137	.name = "xsub",
138	138	.type = AVMEDIA_TYPE_SUBTITLE,
139		− .id = CODEC_ID_XSUB,
	139	+ .id = AV_CODEC_ID_XSUB,
140	140	.init = decode_init,
141	141	.decode = decode_frame,
142	142	.long_name = NULL_IF_CONFIG_SMALL("XSUB"),

libavcodec/xsubenc.c+1−1

@@ -213,7 +213,7 @@ static av_cold int xsub_encoder_init(AVCodecContext *avctx) · 212 unmodified lines
213	213	AVCodec ff_xsub_encoder = {
214	214	.name = "xsub",
215	215	.type = AVMEDIA_TYPE_SUBTITLE,
216		− .id = CODEC_ID_XSUB,
	216	+ .id = AV_CODEC_ID_XSUB,
217	217	.init = xsub_encoder_init,
218	218	.encode = xsub_encode,
219	219	.long_name = NULL_IF_CONFIG_SMALL("DivX subtitles (XSUB)"),

libavcodec/xwddec.c+1−1

@@ -260,7 +260,7 @@ static av_cold int xwd_decode_close(AVCodecContext *avctx) · 259 unmodified lines
260	260	AVCodec ff_xwd_decoder = {
261	261	.name = "xwd",
262	262	.type = AVMEDIA_TYPE_VIDEO,
263		− .id = CODEC_ID_XWD,
	263	+ .id = AV_CODEC_ID_XWD,
264	264	.init = xwd_decode_init,
265	265	.close = xwd_decode_close,
266	266	.decode = xwd_decode_frame,

libavcodec/xwdenc.c+1−1

@@ -222,7 +222,7 @@ static av_cold int xwd_encode_close(AVCodecContext *avctx) · 221 unmodified lines
222	222	AVCodec ff_xwd_encoder = {
223	223	.name = "xwd",
224	224	.type = AVMEDIA_TYPE_VIDEO,
225		− .id = CODEC_ID_XWD,
	225	+ .id = AV_CODEC_ID_XWD,
226	226	.init = xwd_encode_init,
227	227	.encode2 = xwd_encode_frame,
228	228	.close = xwd_encode_close,

libavcodec/xxan.c+1−1

@@ -412,7 +412,7 @@ static av_cold int xan_decode_end(AVCodecContext *avctx) · 411 unmodified lines
412	412	AVCodec ff_xan_wc4_decoder = {
413	413	.name = "xan_wc4",
414	414	.type = AVMEDIA_TYPE_VIDEO,
415		− .id = CODEC_ID_XAN_WC4,
	415	+ .id = AV_CODEC_ID_XAN_WC4,
416	416	.priv_data_size = sizeof(XanContext),
417	417	.init = xan_decode_init,
418	418	.close = xan_decode_end,

libavcodec/yop.c+1−1

@@ -250,7 +250,7 @@ static int yop_decode_frame(AVCodecContext avctx, void data, int *data_size, · 249 unmodified lines
250	250	AVCodec ff_yop_decoder = {
251	251	.name = "yop",
252	252	.type = AVMEDIA_TYPE_VIDEO,
253		− .id = CODEC_ID_YOP,
	253	+ .id = AV_CODEC_ID_YOP,
254	254	.priv_data_size = sizeof(YopDecContext),
255	255	.init = yop_decode_init,
256	256	.close = yop_decode_close,

libavcodec/zerocodec.c+1−1

@@ -157,7 +157,7 @@ static av_cold int zerocodec_decode_init(AVCodecContext *avctx) · 156 unmodified lines
157	157	AVCodec ff_zerocodec_decoder = {
158	158	.type = AVMEDIA_TYPE_VIDEO,
159	159	.name = "zerocodec",
160		− .id = CODEC_ID_ZEROCODEC,
	160	+ .id = AV_CODEC_ID_ZEROCODEC,
161	161	.priv_data_size = sizeof(ZeroCodecContext),
162	162	.init = zerocodec_decode_init,
163	163	.decode = zerocodec_decode_frame,

libavcodec/zmbv.c+1−1

@@ -675,7 +675,7 @@ static av_cold int decode_end(AVCodecContext *avctx) · 674 unmodified lines
675	675	AVCodec ff_zmbv_decoder = {
676	676	.name = "zmbv",
677	677	.type = AVMEDIA_TYPE_VIDEO,
678		− .id = CODEC_ID_ZMBV,
	678	+ .id = AV_CODEC_ID_ZMBV,
679	679	.priv_data_size = sizeof(ZmbvContext),
680	680	.init = decode_init,
681	681	.close = decode_end,

libavcodec/zmbvenc.c+1−1

@@ -339,7 +339,7 @@ static av_cold int encode_end(AVCodecContext *avctx) · 338 unmodified lines
339	339	AVCodec ff_zmbv_encoder = {
340	340	.name = "zmbv",
341	341	.type = AVMEDIA_TYPE_VIDEO,
342		− .id = CODEC_ID_ZMBV,
	342	+ .id = AV_CODEC_ID_ZMBV,
343	343	.priv_data_size = sizeof(ZmbvEncContext),
344	344	.init = encode_init,
345	345	.encode2 = encode_frame,

libavdevice/alsa-audio-common.c+36−36

@@ -38,26 +38,26 @@ · 37 unmodified lines
38	38	static av_cold snd_pcm_format_t codec_id_to_pcm_format(int codec_id)
39	39	{
40	40	switch(codec_id) {
41		− case CODEC_ID_PCM_F64LE: return SND_PCM_FORMAT_FLOAT64_LE;
42		− case CODEC_ID_PCM_F64BE: return SND_PCM_FORMAT_FLOAT64_BE;
43		− case CODEC_ID_PCM_F32LE: return SND_PCM_FORMAT_FLOAT_LE;
44		− case CODEC_ID_PCM_F32BE: return SND_PCM_FORMAT_FLOAT_BE;
45		− case CODEC_ID_PCM_S32LE: return SND_PCM_FORMAT_S32_LE;
46		− case CODEC_ID_PCM_S32BE: return SND_PCM_FORMAT_S32_BE;
47		− case CODEC_ID_PCM_U32LE: return SND_PCM_FORMAT_U32_LE;
48		− case CODEC_ID_PCM_U32BE: return SND_PCM_FORMAT_U32_BE;
49		− case CODEC_ID_PCM_S24LE: return SND_PCM_FORMAT_S24_3LE;
50		− case CODEC_ID_PCM_S24BE: return SND_PCM_FORMAT_S24_3BE;
51		− case CODEC_ID_PCM_U24LE: return SND_PCM_FORMAT_U24_3LE;
52		− case CODEC_ID_PCM_U24BE: return SND_PCM_FORMAT_U24_3BE;
53		− case CODEC_ID_PCM_S16LE: return SND_PCM_FORMAT_S16_LE;
54		− case CODEC_ID_PCM_S16BE: return SND_PCM_FORMAT_S16_BE;
55		− case CODEC_ID_PCM_U16LE: return SND_PCM_FORMAT_U16_LE;
56		− case CODEC_ID_PCM_U16BE: return SND_PCM_FORMAT_U16_BE;
57		− case CODEC_ID_PCM_S8: return SND_PCM_FORMAT_S8;
58		− case CODEC_ID_PCM_U8: return SND_PCM_FORMAT_U8;
59		− case CODEC_ID_PCM_MULAW: return SND_PCM_FORMAT_MU_LAW;
60		− case CODEC_ID_PCM_ALAW: return SND_PCM_FORMAT_A_LAW;
	41	+ case AV_CODEC_ID_PCM_F64LE: return SND_PCM_FORMAT_FLOAT64_LE;
	42	+ case AV_CODEC_ID_PCM_F64BE: return SND_PCM_FORMAT_FLOAT64_BE;
	43	+ case AV_CODEC_ID_PCM_F32LE: return SND_PCM_FORMAT_FLOAT_LE;
	44	+ case AV_CODEC_ID_PCM_F32BE: return SND_PCM_FORMAT_FLOAT_BE;
	45	+ case AV_CODEC_ID_PCM_S32LE: return SND_PCM_FORMAT_S32_LE;
	46	+ case AV_CODEC_ID_PCM_S32BE: return SND_PCM_FORMAT_S32_BE;
	47	+ case AV_CODEC_ID_PCM_U32LE: return SND_PCM_FORMAT_U32_LE;
	48	+ case AV_CODEC_ID_PCM_U32BE: return SND_PCM_FORMAT_U32_BE;
	49	+ case AV_CODEC_ID_PCM_S24LE: return SND_PCM_FORMAT_S24_3LE;
	50	+ case AV_CODEC_ID_PCM_S24BE: return SND_PCM_FORMAT_S24_3BE;
	51	+ case AV_CODEC_ID_PCM_U24LE: return SND_PCM_FORMAT_U24_3LE;
	52	+ case AV_CODEC_ID_PCM_U24BE: return SND_PCM_FORMAT_U24_3BE;
	53	+ case AV_CODEC_ID_PCM_S16LE: return SND_PCM_FORMAT_S16_LE;
	54	+ case AV_CODEC_ID_PCM_S16BE: return SND_PCM_FORMAT_S16_BE;
	55	+ case AV_CODEC_ID_PCM_U16LE: return SND_PCM_FORMAT_U16_LE;
	56	+ case AV_CODEC_ID_PCM_U16BE: return SND_PCM_FORMAT_U16_BE;
	57	+ case AV_CODEC_ID_PCM_S8: return SND_PCM_FORMAT_S8;
	58	+ case AV_CODEC_ID_PCM_U8: return SND_PCM_FORMAT_U8;
	59	+ case AV_CODEC_ID_PCM_MULAW: return SND_PCM_FORMAT_MU_LAW;
	60	+ case AV_CODEC_ID_PCM_ALAW: return SND_PCM_FORMAT_A_LAW;
61	61	default: return SND_PCM_FORMAT_UNKNOWN;
62	62	}
63	63	}
@@ -156,20 +156,20 @@ static av_cold int find_reorder_func(AlsaData *s, int codec_id, uint64_t layout, · 92 unmodified lines
156	156	return 0;
157	157
158	158	switch (codec_id) {
159		− case CODEC_ID_PCM_S8:
160		− case CODEC_ID_PCM_U8:
161		− case CODEC_ID_PCM_ALAW:
162		− case CODEC_ID_PCM_MULAW: format = FORMAT_I8; break;
163		− case CODEC_ID_PCM_S16LE:
164		− case CODEC_ID_PCM_S16BE:
165		− case CODEC_ID_PCM_U16LE:
166		− case CODEC_ID_PCM_U16BE: format = FORMAT_I16; break;
167		− case CODEC_ID_PCM_S32LE:
168		− case CODEC_ID_PCM_S32BE:
169		− case CODEC_ID_PCM_U32LE:
170		− case CODEC_ID_PCM_U32BE: format = FORMAT_I32; break;
171		− case CODEC_ID_PCM_F32LE:
172		− case CODEC_ID_PCM_F32BE: format = FORMAT_F32; break;
	159	+ case AV_CODEC_ID_PCM_S8:
	160	+ case AV_CODEC_ID_PCM_U8:
	161	+ case AV_CODEC_ID_PCM_ALAW:
	162	+ case AV_CODEC_ID_PCM_MULAW: format = FORMAT_I8; break;
	163	+ case AV_CODEC_ID_PCM_S16LE:
	164	+ case AV_CODEC_ID_PCM_S16BE:
	165	+ case AV_CODEC_ID_PCM_U16LE:
	166	+ case AV_CODEC_ID_PCM_U16BE: format = FORMAT_I16; break;
	167	+ case AV_CODEC_ID_PCM_S32LE:
	168	+ case AV_CODEC_ID_PCM_S32BE:
	169	+ case AV_CODEC_ID_PCM_U32LE:
	170	+ case AV_CODEC_ID_PCM_U32BE: format = FORMAT_I32; break;
	171	+ case AV_CODEC_ID_PCM_F32LE:
	172	+ case AV_CODEC_ID_PCM_F32BE: format = FORMAT_F32; break;
173	173	default: return AVERROR(ENOSYS);
174	174	}
175	175
@@ -185,7 +185,7 @@ static av_cold int find_reorder_func(AlsaData *s, int codec_id, uint64_t layout, · 9 unmodified lines
185	185
186	186	av_cold int ff_alsa_open(AVFormatContext *ctx, snd_pcm_stream_t mode,
187	187	unsigned int *sample_rate,
188		− int channels, enum CodecID *codec_id)
	188	+ int channels, enum AVCodecID *codec_id)
189	189	{
190	190	AlsaData *s = ctx->priv_data;
191	191	const char *audio_device;
@@ -199,7 +199,7 @@ av_cold int ff_alsa_open(AVFormatContext *ctx, snd_pcm_stream_t mode, · 7 unmodified lines
199	199	if (ctx->filename[0] == 0) audio_device = "default";
200	200	else audio_device = ctx->filename;
201	201
202		− if (*codec_id == CODEC_ID_NONE)
	202	+ if (*codec_id == AV_CODEC_ID_NONE)
203	203	*codec_id = DEFAULT_CODEC_ID;
204	204	format = codec_id_to_pcm_format(*codec_id);
205	205	if (format == SND_PCM_FORMAT_UNKNOWN) {

libavdevice/alsa-audio-dec.c+1−1

@@ -57,7 +57,7 @@ static av_cold int audio_read_header(AVFormatContext *s1) · 56 unmodified lines
57	57	AlsaData *s = s1->priv_data;
58	58	AVStream *st;
59	59	int ret;
60		− enum CodecID codec_id;
	60	+ enum AVCodecID codec_id;
61	61	snd_pcm_sw_params_t *sw_params;
62	62
63	63	st = avformat_new_stream(s1, NULL);

libavdevice/alsa-audio-enc.c+2−2

@@ -47,7 +47,7 @@ static av_cold int audio_write_header(AVFormatContext *s1) · 46 unmodified lines
47	47	AlsaData *s = s1->priv_data;
48	48	AVStream *st;
49	49	unsigned int sample_rate;
50		− enum CodecID codec_id;
	50	+ enum AVCodecID codec_id;
51	51	int res;
52	52
53	53	st = s1->streams[0];
@@ -106,7 +106,7 @@ AVOutputFormat ff_alsa_muxer = { · 52 unmodified lines
106	106	.long_name = NULL_IF_CONFIG_SMALL("ALSA audio output"),
107	107	.priv_data_size = sizeof(AlsaData),
108	108	.audio_codec = DEFAULT_CODEC_ID,
109		− .video_codec = CODEC_ID_NONE,
	109	+ .video_codec = AV_CODEC_ID_NONE,
110	110	.write_header = audio_write_header,
111	111	.write_packet = audio_write_packet,
112	112	.write_trailer = ff_alsa_close,

libavdevice/alsa-audio.h+5−5

@@ -38,7 +38,7 @@ · 37 unmodified lines
38	38	/* XXX: we make the assumption that the soundcard accepts this format */
39	39	/* XXX: find better solution with "preinit" method, needed also in
40	40	other formats */
41		−#define DEFAULT_CODEC_ID AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE)
	41	+#define DEFAULT_CODEC_ID AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE)
42	42
43	43	#define ALSA_BUFFER_SIZE_MAX 32768
44	44
@@ -62,15 +62,15 @@ typedef struct { · 17 unmodified lines
62	62	* @param sample_rate in: requested sample rate;
63	63	* out: actually selected sample rate
64	64	* @param channels number of channels
65		− * @param codec_id in: requested CodecID or CODEC_ID_NONE;
66		− * out: actually selected CodecID, changed only if
67		− * CODEC_ID_NONE was requested
	65	+ * @param codec_id in: requested AVCodecID or AV_CODEC_ID_NONE;
	66	+ * out: actually selected AVCodecID, changed only if
	67	+ * AV_CODEC_ID_NONE was requested
68	68	*
69	69	* @return 0 if OK, AVERROR_xxx on error
70	70	*/
71	71	int ff_alsa_open(AVFormatContext *s, snd_pcm_stream_t mode,
72	72	unsigned int *sample_rate,
73		− int channels, enum CodecID *codec_id);
	73	+ int channels, enum AVCodecID *codec_id);
74	74
75	75	/**
76	76	* Close the ALSA PCM.

libavdevice/bktr.c+1−1

@@ -283,7 +283,7 @@ static int grab_read_header(AVFormatContext *s1) · 282 unmodified lines
283	283
284	284	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
285	285	st->codec->pix_fmt = PIX_FMT_YUV420P;
286		− st->codec->codec_id = CODEC_ID_RAWVIDEO;
	286	+ st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
287	287	st->codec->width = width;
288	288	st->codec->height = height;
289	289	st->codec->time_base.den = framerate.num;

libavdevice/fbdev.c+1−1

@@ -160,7 +160,7 @@ static av_cold int fbdev_read_header(AVFormatContext *avctx) · 159 unmodified lines
160	160	}
161	161
162	162	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
163		− st->codec->codec_id = CODEC_ID_RAWVIDEO;
	163	+ st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
164	164	st->codec->width = fbdev->width;
165	165	st->codec->height = fbdev->height;
166	166	st->codec->pix_fmt = pix_fmt;

libavdevice/jack_audio.c+2−2

@@ -245,9 +245,9 @@ static int audio_read_header(AVFormatContext *context) · 244 unmodified lines
245	245
246	246	stream->codec->codec_type = AVMEDIA_TYPE_AUDIO;
247	247	#if HAVE_BIGENDIAN
248		− stream->codec->codec_id = CODEC_ID_PCM_F32BE;
	248	+ stream->codec->codec_id = AV_CODEC_ID_PCM_F32BE;
249	249	#else
250		− stream->codec->codec_id = CODEC_ID_PCM_F32LE;
	250	+ stream->codec->codec_id = AV_CODEC_ID_PCM_F32LE;
251	251	#endif
252	252	stream->codec->sample_rate = self->sample_rate;
253	253	stream->codec->channels = self->nports;

libavdevice/libcdio.c+2−2

@@ -83,9 +83,9 @@ static av_cold int read_header(AVFormatContext *ctx) · 82 unmodified lines
83	83
84	84	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
85	85	if (s->drive->bigendianp)
86		− st->codec->codec_id = CODEC_ID_PCM_S16BE;
	86	+ st->codec->codec_id = AV_CODEC_ID_PCM_S16BE;
87	87	else
88		− st->codec->codec_id = CODEC_ID_PCM_S16LE;
	88	+ st->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
89	89	st->codec->sample_rate = 44100;
90	90	st->codec->channels = 2;
91	91	if (s->drive->audio_last_sector != CDIO_INVALID_LSN &&

libavdevice/libdc1394.c+1−1

@@ -168,7 +168,7 @@ static inline int dc1394_read_common(AVFormatContext *c, · 167 unmodified lines
168	168	}
169	169	avpriv_set_pts_info(vst, 64, 1, 1000);
170	170	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
171		− vst->codec->codec_id = CODEC_ID_RAWVIDEO;
	171	+ vst->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
172	172	vst->codec->time_base.den = framerate.num;
173	173	vst->codec->time_base.num = framerate.den;
174	174	vst->codec->width = fmt->width;

libavdevice/oss_audio.c+5−5

@@ -49,7 +49,7 @@ typedef struct { · 48 unmodified lines
49	49	int sample_rate;
50	50	int channels;
51	51	int frame_size; /* in bytes ! */
52		− enum CodecID codec_id;
	52	+ enum AVCodecID codec_id;
53	53	unsigned int flip_left : 1;
54	54	uint8_t buffer[AUDIO_BLOCK_SIZE];
55	55	int buffer_ptr;
@@ -104,10 +104,10 @@ static int audio_open(AVFormatContext s1, int is_output, const char audio_devi · 48 unmodified lines
104	104
105	105	switch(tmp) {
106	106	case AFMT_S16_LE:
107		− s->codec_id = CODEC_ID_PCM_S16LE;
	107	+ s->codec_id = AV_CODEC_ID_PCM_S16LE;
108	108	break;
109	109	case AFMT_S16_BE:
110		− s->codec_id = CODEC_ID_PCM_S16BE;
	110	+ s->codec_id = AV_CODEC_ID_PCM_S16BE;
111	111	break;
112	112	default:
113	113	av_log(s1, AV_LOG_ERROR, "Soundcard does not support 16 bit sample format\n");
@@ -314,8 +314,8 @@ AVOutputFormat ff_oss_muxer = { · 200 unmodified lines
314	314	/* XXX: we make the assumption that the soundcard accepts this format */
315	315	/* XXX: find better solution with "preinit" method, needed also in
316	316	other formats */
317		− .audio_codec = AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),
318		− .video_codec = CODEC_ID_NONE,
	317	+ .audio_codec = AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE),
	318	+ .video_codec = AV_CODEC_ID_NONE,
319	319	.write_header = audio_write_header,
320	320	.write_packet = audio_write_packet,
321	321	.write_trailer = audio_write_trailer,

libavdevice/pulse.c+14−14

@@ -33,7 +33,7 @@ · 32 unmodified lines
33	33	#include "libavformat/internal.h"
34	34	#include "libavutil/opt.h"
35	35
36		−#define DEFAULT_CODEC_ID AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE)
	36	+#define DEFAULT_CODEC_ID AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE)
37	37
38	38	typedef struct PulseData {
39	39	AVClass *class;
@@ -51,17 +51,17 @@ typedef struct PulseData { · 11 unmodified lines
51	51
52	52	static pa_sample_format_t codec_id_to_pulse_format(int codec_id) {
53	53	switch (codec_id) {
54		− case CODEC_ID_PCM_U8: return PA_SAMPLE_U8;
55		− case CODEC_ID_PCM_ALAW: return PA_SAMPLE_ALAW;
56		− case CODEC_ID_PCM_MULAW: return PA_SAMPLE_ULAW;
57		− case CODEC_ID_PCM_S16LE: return PA_SAMPLE_S16LE;
58		− case CODEC_ID_PCM_S16BE: return PA_SAMPLE_S16BE;
59		− case CODEC_ID_PCM_F32LE: return PA_SAMPLE_FLOAT32LE;
60		− case CODEC_ID_PCM_F32BE: return PA_SAMPLE_FLOAT32BE;
61		− case CODEC_ID_PCM_S32LE: return PA_SAMPLE_S32LE;
62		− case CODEC_ID_PCM_S32BE: return PA_SAMPLE_S32BE;
63		− case CODEC_ID_PCM_S24LE: return PA_SAMPLE_S24LE;
64		− case CODEC_ID_PCM_S24BE: return PA_SAMPLE_S24BE;
	54	+ case AV_CODEC_ID_PCM_U8: return PA_SAMPLE_U8;
	55	+ case AV_CODEC_ID_PCM_ALAW: return PA_SAMPLE_ALAW;
	56	+ case AV_CODEC_ID_PCM_MULAW: return PA_SAMPLE_ULAW;
	57	+ case AV_CODEC_ID_PCM_S16LE: return PA_SAMPLE_S16LE;
	58	+ case AV_CODEC_ID_PCM_S16BE: return PA_SAMPLE_S16BE;
	59	+ case AV_CODEC_ID_PCM_F32LE: return PA_SAMPLE_FLOAT32LE;
	60	+ case AV_CODEC_ID_PCM_F32BE: return PA_SAMPLE_FLOAT32BE;
	61	+ case AV_CODEC_ID_PCM_S32LE: return PA_SAMPLE_S32LE;
	62	+ case AV_CODEC_ID_PCM_S32BE: return PA_SAMPLE_S32BE;
	63	+ case AV_CODEC_ID_PCM_S24LE: return PA_SAMPLE_S24LE;
	64	+ case AV_CODEC_ID_PCM_S24BE: return PA_SAMPLE_S24BE;
65	65	default: return PA_SAMPLE_INVALID;
66	66	}
67	67	}
@@ -72,8 +72,8 @@ static av_cold int pulse_read_header(AVFormatContext *s) · 4 unmodified lines
72	72	AVStream *st;
73	73	char *device = NULL;
74	74	int ret;
75		− enum CodecID codec_id =
76		− s->audio_codec_id == CODEC_ID_NONE ? DEFAULT_CODEC_ID : s->audio_codec_id;
	75	+ enum AVCodecID codec_id =
	76	+ s->audio_codec_id == AV_CODEC_ID_NONE ? DEFAULT_CODEC_ID : s->audio_codec_id;
77	77	const pa_sample_spec ss = { codec_id_to_pulse_format(codec_id),
78	78	pd->sample_rate,
79	79	pd->channels };

libavdevice/sndio_common.c+1−1

@@ -84,7 +84,7 @@ av_cold int ff_sndio_open(AVFormatContext *s1, int is_output, · 83 unmodified lines
84	84	}
85	85	}
86	86
87		− s->codec_id = par.le ? CODEC_ID_PCM_S16LE : CODEC_ID_PCM_S16BE;
	87	+ s->codec_id = par.le ? AV_CODEC_ID_PCM_S16LE : AV_CODEC_ID_PCM_S16BE;
88	88	s->channels = is_output ? par.pchan : par.rchan;
89	89	s->sample_rate = par.rate;
90	90	s->bps = par.bps;

libavdevice/sndio_common.h+1−1

@@ -31,7 +31,7 @@ · 30 unmodified lines
31	31	typedef struct {
32	32	AVClass *class;
33	33	struct sio_hdl *hdl;
34		− enum CodecID codec_id;
	34	+ enum AVCodecID codec_id;
35	35	int64_t hwpos;
36	36	int64_t softpos;
37	37	uint8_t *buffer;

libavdevice/sndio_enc.c+2−2

@@ -84,8 +84,8 @@ AVOutputFormat ff_sndio_muxer = { · 83 unmodified lines
84	84	/* XXX: we make the assumption that the soundcard accepts this format */
85	85	/* XXX: find better solution with "preinit" method, needed also in
86	86	other formats */
87		− .audio_codec = AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),
88		− .video_codec = CODEC_ID_NONE,
	87	+ .audio_codec = AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE),
	88	+ .video_codec = AV_CODEC_ID_NONE,
89	89	.write_header = audio_write_header,
90	90	.write_packet = audio_write_packet,
91	91	.write_trailer = audio_write_trailer,

libavdevice/v4l2.c+27−27

@@ -85,27 +85,27 @@ struct buff_data { · 84 unmodified lines
85	85
86	86	struct fmt_map {
87	87	enum PixelFormat ff_fmt;
88		− enum CodecID codec_id;
	88	+ enum AVCodecID codec_id;
89	89	uint32_t v4l2_fmt;
90	90	};
91	91
92	92	static struct fmt_map fmt_conversion_table[] = {
93	93	//ff_fmt codec_id v4l2_fmt
94		− { PIX_FMT_YUV420P, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV420 },
95		− { PIX_FMT_YUV422P, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV422P },
96		− { PIX_FMT_YUYV422, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUYV },
97		− { PIX_FMT_UYVY422, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_UYVY },
98		− { PIX_FMT_YUV411P, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV411P },
99		− { PIX_FMT_YUV410P, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV410 },
100		− { PIX_FMT_RGB555, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB555 },
101		− { PIX_FMT_RGB565, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB565 },
102		− { PIX_FMT_BGR24, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_BGR24 },
103		− { PIX_FMT_RGB24, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB24 },
104		− { PIX_FMT_BGRA, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_BGR32 },
105		− { PIX_FMT_GRAY8, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_GREY },
106		− { PIX_FMT_NV12, CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_NV12 },
107		− { PIX_FMT_NONE, CODEC_ID_MJPEG, V4L2_PIX_FMT_MJPEG },
108		− { PIX_FMT_NONE, CODEC_ID_MJPEG, V4L2_PIX_FMT_JPEG },
	94	+ { PIX_FMT_YUV420P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV420 },
	95	+ { PIX_FMT_YUV422P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV422P },
	96	+ { PIX_FMT_YUYV422, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUYV },
	97	+ { PIX_FMT_UYVY422, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_UYVY },
	98	+ { PIX_FMT_YUV411P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV411P },
	99	+ { PIX_FMT_YUV410P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV410 },
	100	+ { PIX_FMT_RGB555, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB555 },
	101	+ { PIX_FMT_RGB565, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB565 },
	102	+ { PIX_FMT_BGR24, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_BGR24 },
	103	+ { PIX_FMT_RGB24, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB24 },
	104	+ { PIX_FMT_BGRA, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_BGR32 },
	105	+ { PIX_FMT_GRAY8, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_GREY },
	106	+ { PIX_FMT_NV12, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_NV12 },
	107	+ { PIX_FMT_NONE, AV_CODEC_ID_MJPEG, V4L2_PIX_FMT_MJPEG },
	108	+ { PIX_FMT_NONE, AV_CODEC_ID_MJPEG, V4L2_PIX_FMT_JPEG },
109	109	};
110	110
111	111	static int device_open(AVFormatContext *ctx)
@@ -220,12 +220,12 @@ static int first_field(int fd) · 108 unmodified lines
220	220	return 1;
221	221	}
222	222
223		−static uint32_t fmt_ff2v4l(enum PixelFormat pix_fmt, enum CodecID codec_id)
	223	+static uint32_t fmt_ff2v4l(enum PixelFormat pix_fmt, enum AVCodecID codec_id)
224	224	{
225	225	int i;
226	226
227	227	for (i = 0; i < FF_ARRAY_ELEMS(fmt_conversion_table); i++) {
228		− if ((codec_id == CODEC_ID_NONE \|\|
	228	+ if ((codec_id == AV_CODEC_ID_NONE \|\|
229	229	fmt_conversion_table[i].codec_id == codec_id) &&
230	230	(pix_fmt == PIX_FMT_NONE \|\|
231	231	fmt_conversion_table[i].ff_fmt == pix_fmt)) {
@@ -236,7 +236,7 @@ static uint32_t fmt_ff2v4l(enum PixelFormat pix_fmt, enum CodecID codec_id) · 4 unmodified lines
236	236	return 0;
237	237	}
238	238
239		−static enum PixelFormat fmt_v4l2ff(uint32_t v4l2_fmt, enum CodecID codec_id)
	239	+static enum PixelFormat fmt_v4l2ff(uint32_t v4l2_fmt, enum AVCodecID codec_id)
240	240	{
241	241	int i;
242	242
@@ -250,7 +250,7 @@ static enum PixelFormat fmt_v4l2ff(uint32_t v4l2_fmt, enum CodecID codec_id) · 7 unmodified lines
250	250	return PIX_FMT_NONE;
251	251	}
252	252
253		−static enum CodecID fmt_v4l2codec(uint32_t v4l2_fmt)
	253	+static enum AVCodecID fmt_v4l2codec(uint32_t v4l2_fmt)
254	254	{
255	255	int i;
256	256
@@ -260,7 +260,7 @@ static enum CodecID fmt_v4l2codec(uint32_t v4l2_fmt) · 3 unmodified lines
260	260	}
261	261	}
262	262
263		− return CODEC_ID_NONE;
	263	+ return AV_CODEC_ID_NONE;
264	264	}
265	265
266	266	#if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE
@@ -294,7 +294,7 @@ static void list_formats(AVFormatContext *ctx, int fd, int type) · 27 unmodified lines
294	294	struct v4l2_fmtdesc vfd = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
295	295
296	296	while(!ioctl(fd, VIDIOC_ENUM_FMT, &vfd)) {
297		− enum CodecID codec_id = fmt_v4l2codec(vfd.pixelformat);
	297	+ enum AVCodecID codec_id = fmt_v4l2codec(vfd.pixelformat);
298	298	enum PixelFormat pix_fmt = fmt_v4l2ff(vfd.pixelformat, codec_id);
299	299
300	300	vfd.index++;
@@ -648,7 +648,7 @@ static uint32_t device_try_init(AVFormatContext *s1, · 347 unmodified lines
648	648	enum PixelFormat pix_fmt,
649	649	int *width,
650	650	int *height,
651		− enum CodecID *codec_id)
	651	+ enum AVCodecID *codec_id)
652	652	{
653	653	uint32_t desired_format = fmt_ff2v4l(pix_fmt, s1->video_codec_id);
654	654
@@ -658,7 +658,7 @@ static uint32_t device_try_init(AVFormatContext *s1, · 3 unmodified lines
658	658
659	659	desired_format = 0;
660	660	for (i = 0; i<FF_ARRAY_ELEMS(fmt_conversion_table); i++) {
661		− if (s1->video_codec_id == CODEC_ID_NONE \|\|
	661	+ if (s1->video_codec_id == AV_CODEC_ID_NONE \|\|
662	662	fmt_conversion_table[i].codec_id == s1->video_codec_id) {
663	663	desired_format = fmt_conversion_table[i].v4l2_fmt;
664	664	if (device_init(s1, width, height, desired_format) >= 0) {
@@ -671,7 +671,7 @@ static uint32_t device_try_init(AVFormatContext *s1, · 6 unmodified lines
671	671
672	672	if (desired_format != 0) {
673	673	*codec_id = fmt_v4l2codec(desired_format);
674		− assert(*codec_id != CODEC_ID_NONE);
	674	+ assert(*codec_id != AV_CODEC_ID_NONE);
675	675	}
676	676
677	677	return desired_format;
@@ -683,7 +683,7 @@ static int v4l2_read_header(AVFormatContext *s1) · 5 unmodified lines
683	683	AVStream *st;
684	684	int res = 0;
685	685	uint32_t desired_format;
686		− enum CodecID codec_id;
	686	+ enum AVCodecID codec_id;
687	687	enum PixelFormat pix_fmt = PIX_FMT_NONE;
688	688
689	689	st = avformat_new_stream(s1, NULL);
@@ -782,7 +782,7 @@ static int v4l2_read_header(AVFormatContext *s1) · 92 unmodified lines
782	782
783	783	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
784	784	st->codec->codec_id = codec_id;
785		− if (codec_id == CODEC_ID_RAWVIDEO)
	785	+ if (codec_id == AV_CODEC_ID_RAWVIDEO)
786	786	st->codec->codec_tag =
787	787	avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
788	788	st->codec->width = s->width;

libavdevice/vfwcap.c+6−6

@@ -75,16 +75,16 @@ static enum PixelFormat vfw_pixfmt(DWORD biCompression, WORD biBitCount) · 74 unmodified lines
75	75	return PIX_FMT_NONE;
76	76	}
77	77
78		−static enum CodecID vfw_codecid(DWORD biCompression)
	78	+static enum AVCodecID vfw_codecid(DWORD biCompression)
79	79	{
80	80	switch(biCompression) {
81	81	case MKTAG('d', 'v', 's', 'd'):
82		− return CODEC_ID_DVVIDEO;
	82	+ return AV_CODEC_ID_DVVIDEO;
83	83	case MKTAG('M', 'J', 'P', 'G'):
84	84	case MKTAG('m', 'j', 'p', 'g'):
85		− return CODEC_ID_MJPEG;
	85	+ return AV_CODEC_ID_MJPEG;
86	86	}
87		− return CODEC_ID_NONE;
	87	+ return AV_CODEC_ID_NONE;
88	88	}
89	89
90	90	#define dstruct(pctx, sname, var, type) \
@@ -378,7 +378,7 @@ static int vfw_read_header(AVFormatContext *s) · 287 unmodified lines
378	378	codec->pix_fmt = vfw_pixfmt(biCompression, biBitCount);
379	379	if(codec->pix_fmt == PIX_FMT_NONE) {
380	380	codec->codec_id = vfw_codecid(biCompression);
381		− if(codec->codec_id == CODEC_ID_NONE) {
	381	+ if(codec->codec_id == AV_CODEC_ID_NONE) {
382	382	av_log(s, AV_LOG_ERROR, "Unknown compression type. "
383	383	"Please report verbose (-v 9) debug information.\n");
384	384	vfw_read_close(s);
@@ -386,7 +386,7 @@ static int vfw_read_header(AVFormatContext *s) · 1 unmodified line
386	386	}
387	387	codec->bits_per_coded_sample = biBitCount;
388	388	} else {
389		− codec->codec_id = CODEC_ID_RAWVIDEO;
	389	+ codec->codec_id = AV_CODEC_ID_RAWVIDEO;
390	390	if(biCompression == BI_RGB) {
391	391	codec->bits_per_coded_sample = biBitCount;
392	392	codec->extradata = av_malloc(9 + FF_INPUT_BUFFER_PADDING_SIZE);

libavdevice/x11grab.c+1−1

@@ -314,7 +314,7 @@ x11grab_read_header(AVFormatContext *s1) · 313 unmodified lines
314	314	x11grab->use_shm = use_shm;
315	315
316	316	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
317		− st->codec->codec_id = CODEC_ID_RAWVIDEO;
	317	+ st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
318	318	st->codec->width = x11grab->width;
319	319	st->codec->height = x11grab->height;
320	320	st->codec->pix_fmt = input_pixfmt;

libavformat/4xm.c+4−4

@@ -151,7 +151,7 @@ static int fourxm_read_header(AVFormatContext *s) · 150 unmodified lines
151	151	fourxm->video_stream_index = st->index;
152	152
153	153	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
154		− st->codec->codec_id = CODEC_ID_4XM;
	154	+ st->codec->codec_id = AV_CODEC_ID_4XM;
155	155	st->codec->extradata_size = 4;
156	156	st->codec->extradata = av_malloc(4);
157	157	AV_WL32(st->codec->extradata, AV_RL32(&header[i + 16]));
@@ -218,11 +218,11 @@ static int fourxm_read_header(AVFormatContext *s) · 60 unmodified lines
218	218	st->codec->bits_per_coded_sample;
219	219	st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample;
220	220	if (fourxm->tracks[current_track].adpcm){
221		− st->codec->codec_id = CODEC_ID_ADPCM_4XM;
	221	+ st->codec->codec_id = AV_CODEC_ID_ADPCM_4XM;
222	222	}else if (st->codec->bits_per_coded_sample == 8){
223		− st->codec->codec_id = CODEC_ID_PCM_U8;
	223	+ st->codec->codec_id = AV_CODEC_ID_PCM_U8;
224	224	}else
225		− st->codec->codec_id = CODEC_ID_PCM_S16LE;
	225	+ st->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
226	226	}
227	227	}
228	228

libavformat/a64.c+5−5

@@ -43,12 +43,12 @@ static int a64_write_header(struct AVFormatContext *s) · 42 unmodified lines
43	43	};
44	44	c->interleaved = 0;
45	45	switch (avctx->codec->id) {
46		− case CODEC_ID_A64_MULTI:
	46	+ case AV_CODEC_ID_A64_MULTI:
47	47	header[2] = 0x00;
48	48	header[3] = AV_RB32(avctx->extradata+0);
49	49	header[4] = 2;
50	50	break;
51		− case CODEC_ID_A64_MULTI5:
	51	+ case AV_CODEC_ID_A64_MULTI5:
52	52	header[2] = 0x01;
53	53	header[3] = AV_RB32(avctx->extradata+0);
54	54	header[4] = 3;
@@ -76,8 +76,8 @@ static int a64_write_packet(struct AVFormatContext s, AVPacket pkt) · 21 unmodified lines
76	76
77	77	/* fetch values from extradata */
78	78	switch (avctx->codec->id) {
79		− case CODEC_ID_A64_MULTI:
80		− case CODEC_ID_A64_MULTI5:
	79	+ case AV_CODEC_ID_A64_MULTI:
	80	+ case AV_CODEC_ID_A64_MULTI5:
81	81	if(c->interleaved) {
82	82	/* Write interleaved, means we insert chunks of the future charset before each current frame.
83	83	* Reason: if we load 1 charset + corresponding frames in one block on c64, we need to store
@@ -168,7 +168,7 @@ AVOutputFormat ff_a64_muxer = { · 84 unmodified lines
168	168	.long_name = NULL_IF_CONFIG_SMALL("a64 - video for Commodore 64"),
169	169	.extensions = "a64, A64",
170	170	.priv_data_size = sizeof (A64Context),
171		− .video_codec = CODEC_ID_A64_MULTI,
	171	+ .video_codec = AV_CODEC_ID_A64_MULTI,
172	172	.write_header = a64_write_header,
173	173	.write_packet = a64_write_packet,
174	174	.write_trailer = a64_write_trailer,

libavformat/aacdec.c+1−1

@@ -89,5 +89,5 @@ AVInputFormat ff_aac_demuxer = { · 88 unmodified lines
89	89	.read_packet = ff_raw_read_partial_packet,
90	90	.flags = AVFMT_GENERIC_INDEX,
91	91	.extensions = "aac",
92		− .raw_codec_id = CODEC_ID_AAC,
	92	+ .raw_codec_id = AV_CODEC_ID_AAC,
93	93	};

libavformat/ac3dec.c+7−7

@@ -24,13 +24,13 @@ · 23 unmodified lines
24	24	#include "avformat.h"
25	25	#include "rawdec.h"
26	26
27		−static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id)
	27	+static int ac3_eac3_probe(AVProbeData *p, enum AVCodecID expected_codec_id)
28	28	{
29	29	int max_frames, first_frames = 0, frames;
30	30	uint8_t buf, buf2, *end;
31	31	AC3HeaderInfo hdr;
32	32	GetBitContext gbc;
33		− enum CodecID codec_id = CODEC_ID_AC3;
	33	+ enum AVCodecID codec_id = AV_CODEC_ID_AC3;
34	34
35	35	max_frames = 0;
36	36	buf = p->buf;
@@ -47,7 +47,7 @@ static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id) · 10 unmodified lines
47	47	av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2))
48	48	break;
49	49	if (hdr.bitstream_id > 10)
50		− codec_id = CODEC_ID_EAC3;
	50	+ codec_id = AV_CODEC_ID_EAC3;
51	51	buf2 += hdr.frame_size;
52	52	}
53	53	max_frames = FFMAX(max_frames, frames);
@@ -87,7 +87,7 @@ static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id) · 33 unmodified lines
87	87	#if CONFIG_AC3_DEMUXER
88	88	static int ac3_probe(AVProbeData *p)
89	89	{
90		− return ac3_eac3_probe(p, CODEC_ID_AC3);
	90	+ return ac3_eac3_probe(p, AV_CODEC_ID_AC3);
91	91	}
92	92
93	93	AVInputFormat ff_ac3_demuxer = {
@@ -98,14 +98,14 @@ AVInputFormat ff_ac3_demuxer = { · 4 unmodified lines
98	98	.read_packet = ff_raw_read_partial_packet,
99	99	.flags= AVFMT_GENERIC_INDEX,
100	100	.extensions = "ac3",
101		− .raw_codec_id = CODEC_ID_AC3,
	101	+ .raw_codec_id = AV_CODEC_ID_AC3,
102	102	};
103	103	#endif
104	104
105	105	#if CONFIG_EAC3_DEMUXER
106	106	static int eac3_probe(AVProbeData *p)
107	107	{
108		− return ac3_eac3_probe(p, CODEC_ID_EAC3);
	108	+ return ac3_eac3_probe(p, AV_CODEC_ID_EAC3);
109	109	}
110	110
111	111	AVInputFormat ff_eac3_demuxer = {
@@ -116,6 +116,6 @@ AVInputFormat ff_eac3_demuxer = { · 4 unmodified lines
116	116	.read_packet = ff_raw_read_partial_packet,
117	117	.flags = AVFMT_GENERIC_INDEX,
118	118	.extensions = "eac3",
119		− .raw_codec_id = CODEC_ID_EAC3,
	119	+ .raw_codec_id = AV_CODEC_ID_EAC3,
120	120	};
121	121	#endif

libavformat/adtsenc.c+2−2

@@ -169,8 +169,8 @@ AVOutputFormat ff_adts_muxer = { · 168 unmodified lines
169	169	.mime_type = "audio/aac",
170	170	.extensions = "aac,adts",
171	171	.priv_data_size = sizeof(ADTSContext),
172		− .audio_codec = CODEC_ID_AAC,
173		− .video_codec = CODEC_ID_NONE,
	172	+ .audio_codec = AV_CODEC_ID_AAC,
	173	+ .video_codec = AV_CODEC_ID_NONE,
174	174	.write_header = adts_write_header,
175	175	.write_packet = adts_write_packet,
176	176	};

libavformat/adxdec.c+1−1

@@ -108,6 +108,6 @@ AVInputFormat ff_adx_demuxer = { · 107 unmodified lines
108	108	.read_header = adx_read_header,
109	109	.read_packet = adx_read_packet,
110	110	.extensions = "adx",
111		− .raw_codec_id = CODEC_ID_ADPCM_ADX,
	111	+ .raw_codec_id = AV_CODEC_ID_ADPCM_ADX,
112	112	.flags = AVFMT_GENERIC_INDEX,
113	113	};

libavformat/aea.c+1−1

@@ -67,7 +67,7 @@ static int aea_read_header(AVFormatContext *s) · 66 unmodified lines
67	67
68	68
69	69	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
70		− st->codec->codec_id = CODEC_ID_ATRAC1;
	70	+ st->codec->codec_id = AV_CODEC_ID_ATRAC1;
71	71	st->codec->sample_rate = 44100;
72	72	st->codec->bit_rate = 292000;
73	73

libavformat/aiff.h+18−18

@@ -31,24 +31,24 @@ · 30 unmodified lines
31	31	#include "riff.h"
32	32
33	33	static const AVCodecTag ff_codec_aiff_tags[] = {
34		− { CODEC_ID_PCM_S16BE, MKTAG('N','O','N','E') },
35		− { CODEC_ID_PCM_S8, MKTAG('N','O','N','E') },
36		− { CODEC_ID_PCM_S24BE, MKTAG('N','O','N','E') },
37		− { CODEC_ID_PCM_S32BE, MKTAG('N','O','N','E') },
38		− { CODEC_ID_PCM_F32BE, MKTAG('f','l','3','2') },
39		− { CODEC_ID_PCM_F64BE, MKTAG('f','l','6','4') },
40		− { CODEC_ID_PCM_ALAW, MKTAG('a','l','a','w') },
41		− { CODEC_ID_PCM_MULAW, MKTAG('u','l','a','w') },
42		− { CODEC_ID_MACE3, MKTAG('M','A','C','3') },
43		− { CODEC_ID_MACE6, MKTAG('M','A','C','6') },
44		− { CODEC_ID_GSM, MKTAG('G','S','M',' ') },
45		− { CODEC_ID_ADPCM_G726, MKTAG('G','7','2','6') },
46		− { CODEC_ID_PCM_S16BE, MKTAG('t','w','o','s') },
47		− { CODEC_ID_PCM_S16LE, MKTAG('s','o','w','t') },
48		− { CODEC_ID_ADPCM_IMA_QT, MKTAG('i','m','a','4') },
49		− { CODEC_ID_QDM2, MKTAG('Q','D','M','2') },
50		− { CODEC_ID_QCELP, MKTAG('Q','c','l','p') },
51		− { CODEC_ID_NONE, 0 },
	34	+ { AV_CODEC_ID_PCM_S16BE, MKTAG('N','O','N','E') },
	35	+ { AV_CODEC_ID_PCM_S8, MKTAG('N','O','N','E') },
	36	+ { AV_CODEC_ID_PCM_S24BE, MKTAG('N','O','N','E') },
	37	+ { AV_CODEC_ID_PCM_S32BE, MKTAG('N','O','N','E') },
	38	+ { AV_CODEC_ID_PCM_F32BE, MKTAG('f','l','3','2') },
	39	+ { AV_CODEC_ID_PCM_F64BE, MKTAG('f','l','6','4') },
	40	+ { AV_CODEC_ID_PCM_ALAW, MKTAG('a','l','a','w') },
	41	+ { AV_CODEC_ID_PCM_MULAW, MKTAG('u','l','a','w') },
	42	+ { AV_CODEC_ID_MACE3, MKTAG('M','A','C','3') },
	43	+ { AV_CODEC_ID_MACE6, MKTAG('M','A','C','6') },
	44	+ { AV_CODEC_ID_GSM, MKTAG('G','S','M',' ') },
	45	+ { AV_CODEC_ID_ADPCM_G726, MKTAG('G','7','2','6') },
	46	+ { AV_CODEC_ID_PCM_S16BE, MKTAG('t','w','o','s') },
	47	+ { AV_CODEC_ID_PCM_S16LE, MKTAG('s','o','w','t') },
	48	+ { AV_CODEC_ID_ADPCM_IMA_QT, MKTAG('i','m','a','4') },
	49	+ { AV_CODEC_ID_QDM2, MKTAG('Q','D','M','2') },
	50	+ { AV_CODEC_ID_QCELP, MKTAG('Q','c','l','p') },
	51	+ { AV_CODEC_ID_NONE, 0 },
52	52	};
53	53
54	54	#endif /* AVFORMAT_AIFF_H */

libavformat/aiffdec.c+17−17

@@ -34,19 +34,19 @@ typedef struct { · 33 unmodified lines
34	34	int block_duration;
35	35	} AIFFInputContext;
36	36
37		−static enum CodecID aiff_codec_get_id(int bps)
	37	+static enum AVCodecID aiff_codec_get_id(int bps)
38	38	{
39	39	if (bps <= 8)
40		− return CODEC_ID_PCM_S8;
	40	+ return AV_CODEC_ID_PCM_S8;
41	41	if (bps <= 16)
42		− return CODEC_ID_PCM_S16BE;
	42	+ return AV_CODEC_ID_PCM_S16BE;
43	43	if (bps <= 24)
44		− return CODEC_ID_PCM_S24BE;
	44	+ return AV_CODEC_ID_PCM_S24BE;
45	45	if (bps <= 32)
46		− return CODEC_ID_PCM_S32BE;
	46	+ return AV_CODEC_ID_PCM_S32BE;
47	47
48	48	/* bigger than 32 isn't allowed */
49		− return CODEC_ID_NONE;
	49	+ return AV_CODEC_ID_NONE;
50	50	}
51	51
52	52	/* returns the size of the found tag */
@@ -117,32 +117,32 @@ static unsigned int get_aiff_header(AVFormatContext *s, int size, · 64 unmodified lines
117	117	size -= 4;
118	118	}
119	119
120		− if (version != AIFF_C_VERSION1 \|\| codec->codec_id == CODEC_ID_PCM_S16BE) {
	120	+ if (version != AIFF_C_VERSION1 \|\| codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
121	121	codec->codec_id = aiff_codec_get_id(codec->bits_per_coded_sample);
122	122	codec->bits_per_coded_sample = av_get_bits_per_sample(codec->codec_id);
123	123	aiff->block_duration = 1;
124	124	} else {
125	125	switch (codec->codec_id) {
126		− case CODEC_ID_PCM_F32BE:
127		− case CODEC_ID_PCM_F64BE:
128		− case CODEC_ID_PCM_S16LE:
129		− case CODEC_ID_PCM_ALAW:
130		− case CODEC_ID_PCM_MULAW:
	126	+ case AV_CODEC_ID_PCM_F32BE:
	127	+ case AV_CODEC_ID_PCM_F64BE:
	128	+ case AV_CODEC_ID_PCM_S16LE:
	129	+ case AV_CODEC_ID_PCM_ALAW:
	130	+ case AV_CODEC_ID_PCM_MULAW:
131	131	aiff->block_duration = 1;
132	132	break;
133		− case CODEC_ID_ADPCM_IMA_QT:
	133	+ case AV_CODEC_ID_ADPCM_IMA_QT:
134	134	codec->block_align = 34*codec->channels;
135	135	break;
136		− case CODEC_ID_MACE3:
	136	+ case AV_CODEC_ID_MACE3:
137	137	codec->block_align = 2*codec->channels;
138	138	break;
139		− case CODEC_ID_MACE6:
	139	+ case AV_CODEC_ID_MACE6:
140	140	codec->block_align = 1*codec->channels;
141	141	break;
142		− case CODEC_ID_GSM:
	142	+ case AV_CODEC_ID_GSM:
143	143	codec->block_align = 33;
144	144	break;
145		− case CODEC_ID_QCELP:
	145	+ case AV_CODEC_ID_QCELP:
146	146	codec->block_align = 35;
147	147	break;
148	148	default:

libavformat/aiffenc.c+2−2

@@ -155,8 +155,8 @@ AVOutputFormat ff_aiff_muxer = { · 154 unmodified lines
155	155	.mime_type = "audio/aiff",
156	156	.extensions = "aif,aiff,afc,aifc",
157	157	.priv_data_size = sizeof(AIFFOutputContext),
158		− .audio_codec = CODEC_ID_PCM_S16BE,
159		− .video_codec = CODEC_ID_NONE,
	158	+ .audio_codec = AV_CODEC_ID_PCM_S16BE,
	159	+ .video_codec = AV_CODEC_ID_NONE,
160	160	.write_header = aiff_write_header,
161	161	.write_packet = aiff_write_packet,
162	162	.write_trailer = aiff_write_trailer,

libavformat/amr.c+9−9

@@ -39,9 +39,9 @@ static int amr_write_header(AVFormatContext *s) · 38 unmodified lines
39	39
40	40	s->priv_data = NULL;
41	41
42		− if (enc->codec_id == CODEC_ID_AMR_NB) {
	42	+ if (enc->codec_id == AV_CODEC_ID_AMR_NB) {
43	43	avio_write(pb, AMR_header, sizeof(AMR_header) - 1); /* magic number */
44		− } else if (enc->codec_id == CODEC_ID_AMR_WB) {
	44	+ } else if (enc->codec_id == AV_CODEC_ID_AMR_WB) {
45	45	avio_write(pb, AMRWB_header, sizeof(AMRWB_header) - 1); /* magic number */
46	46	} else {
47	47	return -1;
@@ -89,11 +89,11 @@ static int amr_read_header(AVFormatContext *s) · 41 unmodified lines
89	89	}
90	90
91	91	st->codec->codec_tag = MKTAG('s', 'a', 'w', 'b');
92		− st->codec->codec_id = CODEC_ID_AMR_WB;
	92	+ st->codec->codec_id = AV_CODEC_ID_AMR_WB;
93	93	st->codec->sample_rate = 16000;
94	94	} else {
95	95	st->codec->codec_tag = MKTAG('s', 'a', 'm', 'r');
96		− st->codec->codec_id = CODEC_ID_AMR_NB;
	96	+ st->codec->codec_id = AV_CODEC_ID_AMR_NB;
97	97	st->codec->sample_rate = 8000;
98	98	}
99	99	st->codec->channels = 1;
@@ -117,13 +117,13 @@ static int amr_read_packet(AVFormatContext s, AVPacket pkt) · 17 unmodified lines
117	117	toc = avio_r8(s->pb);
118	118	mode = (toc >> 3) & 0x0F;
119	119
120		− if (enc->codec_id == CODEC_ID_AMR_NB) {
	120	+ if (enc->codec_id == AV_CODEC_ID_AMR_NB) {
121	121	static const uint8_t packed_size[16] = {
122	122	12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0
123	123	};
124	124
125	125	size = packed_size[mode] + 1;
126		− } else if (enc->codec_id == CODEC_ID_AMR_WB) {
	126	+ } else if (enc->codec_id == AV_CODEC_ID_AMR_WB) {
127	127	static const uint8_t packed_size[16] = {
128	128	18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1
129	129	};
@@ -142,7 +142,7 @@ static int amr_read_packet(AVFormatContext s, AVPacket pkt) · 12 unmodified lines
142	142	pkt->stream_index = 0;
143	143	pkt->pos = pos;
144	144	pkt->data[0] = toc;
145		− pkt->duration = enc->codec_id == CODEC_ID_AMR_NB ? 160 : 320;
	145	+ pkt->duration = enc->codec_id == AV_CODEC_ID_AMR_NB ? 160 : 320;
146	146	read = avio_read(s->pb, pkt->data + 1, size - 1);
147	147
148	148	if (read != size - 1) {
@@ -170,8 +170,8 @@ AVOutputFormat ff_amr_muxer = { · 21 unmodified lines
170	170	.long_name = NULL_IF_CONFIG_SMALL("3GPP AMR"),
171	171	.mime_type = "audio/amr",
172	172	.extensions = "amr",
173		− .audio_codec = CODEC_ID_AMR_NB,
174		− .video_codec = CODEC_ID_NONE,
	173	+ .audio_codec = AV_CODEC_ID_AMR_NB,
	174	+ .video_codec = AV_CODEC_ID_NONE,
175	175	.write_header = amr_write_header,
176	176	.write_packet = amr_write_packet,
177	177	};

libavformat/anm.c+1−1

@@ -101,7 +101,7 @@ static int read_header(AVFormatContext *s) · 100 unmodified lines
101	101	if (!st)
102	102	return AVERROR(ENOMEM);
103	103	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
104		− st->codec->codec_id = CODEC_ID_ANM;
	104	+ st->codec->codec_id = AV_CODEC_ID_ANM;
105	105	st->codec->codec_tag = 0; /* no fourcc */
106	106	st->codec->width = avio_rl16(pb);
107	107	st->codec->height = avio_rl16(pb);

libavformat/apc.c+1−1

@@ -44,7 +44,7 @@ static int apc_read_header(AVFormatContext *s) · 43 unmodified lines
44	44	return AVERROR(ENOMEM);
45	45
46	46	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
47		− st->codec->codec_id = CODEC_ID_ADPCM_IMA_APC;
	47	+ st->codec->codec_id = AV_CODEC_ID_ADPCM_IMA_APC;
48	48
49	49	avio_rl32(pb); /* number of samples */
50	50	st->codec->sample_rate = avio_rl32(pb);

libavformat/ape.c+1−1

@@ -324,7 +324,7 @@ static int ape_read_header(AVFormatContext * s) · 323 unmodified lines
324	324	total_blocks = (ape->totalframes == 0) ? 0 : ((ape->totalframes - 1) * ape->blocksperframe) + ape->finalframeblocks;
325	325
326	326	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
327		− st->codec->codec_id = CODEC_ID_APE;
	327	+ st->codec->codec_id = AV_CODEC_ID_APE;
328	328	st->codec->codec_tag = MKTAG('A', 'P', 'E', ' ');
329	329	st->codec->channels = ape->channels;
330	330	st->codec->sample_rate = ape->samplerate;

libavformat/apetag.c+2−2

@@ -57,7 +57,7 @@ static int ape_tag_read_field(AVFormatContext *s) · 56 unmodified lines
57	57	return -1;
58	58	if (flags & APE_TAG_FLAG_IS_BINARY) {
59	59	uint8_t filename[1024];
60		− enum CodecID id;
	60	+ enum AVCodecID id;
61	61	AVStream *st = avformat_new_stream(s, NULL);
62	62	if (!st)
63	63	return AVERROR(ENOMEM);
@@ -70,7 +70,7 @@ static int ape_tag_read_field(AVFormatContext *s) · 6 unmodified lines
70	70
71	71	av_dict_set(&st->metadata, key, filename, 0);
72	72
73		− if ((id = ff_guess_image2_codec(filename)) != CODEC_ID_NONE) {
	73	+ if ((id = ff_guess_image2_codec(filename)) != AV_CODEC_ID_NONE) {
74	74	AVPacket pkt;
75	75	int ret;
76	76

libavformat/asfdec.c+8−8

@@ -180,7 +180,7 @@ static int asf_read_picture(AVFormatContext *s, int len) · 179 unmodified lines
180	180	{
181	181	AVPacket pkt = { 0 };
182	182	const CodecMime *mime = ff_id3v2_mime_tags;
183		− enum CodecID id = CODEC_ID_NONE;
	183	+ enum AVCodecID id = AV_CODEC_ID_NONE;
184	184	char mimetype[64];
185	185	uint8_t *desc = NULL;
186	186	ASFStream *ast = NULL;
@@ -207,14 +207,14 @@ static int asf_read_picture(AVFormatContext *s, int len) · 20 unmodified lines
207	207
208	208	/* picture MIME type */
209	209	len -= avio_get_str16le(s->pb, len, mimetype, sizeof(mimetype));
210		− while (mime->id != CODEC_ID_NONE) {
	210	+ while (mime->id != AV_CODEC_ID_NONE) {
211	211	if (!strncmp(mime->str, mimetype, sizeof(mimetype))) {
212	212	id = mime->id;
213	213	break;
214	214	}
215	215	mime++;
216	216	}
217		− if (id == CODEC_ID_NONE) {
	217	+ if (id == AV_CODEC_ID_NONE) {
218	218	av_log(s, AV_LOG_ERROR, "Unknown attached picture mimetype: %s.\n",
219	219	mimetype);
220	220	return 0;
@@ -370,7 +370,7 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size) · 149 unmodified lines
370	370	type = AVMEDIA_TYPE_VIDEO;
371	371	} else if (!ff_guidcmp(&g, &ff_asf_jfif_media)) {
372	372	type = AVMEDIA_TYPE_VIDEO;
373		− st->codec->codec_id = CODEC_ID_MJPEG;
	373	+ st->codec->codec_id = AV_CODEC_ID_MJPEG;
374	374	} else if (!ff_guidcmp(&g, &ff_asf_command_stream)) {
375	375	type = AVMEDIA_TYPE_DATA;
376	376	} else if (!ff_guidcmp(&g, &ff_asf_ext_stream_embed_stream_header)) {
@@ -411,10 +411,10 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size) · 34 unmodified lines
411	411	if (is_dvr_ms_audio) {
412	412	// codec_id and codec_tag are unreliable in dvr_ms
413	413	// files. Set them later by probing stream.
414		− st->codec->codec_id = CODEC_ID_PROBE;
	414	+ st->codec->codec_id = AV_CODEC_ID_PROBE;
415	415	st->codec->codec_tag = 0;
416	416	}
417		− if (st->codec->codec_id == CODEC_ID_AAC) {
	417	+ if (st->codec->codec_id == AV_CODEC_ID_AAC) {
418	418	st->need_parsing = AVSTREAM_PARSE_NONE;
419	419	} else {
420	420	st->need_parsing = AVSTREAM_PARSE_FULL;
@@ -483,7 +483,7 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size) · 62 unmodified lines
483	483	av_freep(&st->codec->extradata);
484	484	st->codec->extradata_size=0;
485	485	}
486		− if(st->codec->codec_id == CODEC_ID_H264)
	486	+ if(st->codec->codec_id == AV_CODEC_ID_H264)
487	487	st->need_parsing = AVSTREAM_PARSE_FULL_ONCE;
488	488	}
489	489	pos2 = avio_tell(pb);
@@ -1143,7 +1143,7 @@ static int ff_asf_parse_packet(AVFormatContext s, AVIOContext pb, AVPacket *pk · 653 unmodified lines
1143	1143	/* test if whole packet is read */
1144	1144	if (asf_st->frag_offset == asf_st->pkt.size) {
1145	1145	//workaround for macroshit radio DVR-MS files
1146		− if( s->streams[asf->stream_index]->codec->codec_id == CODEC_ID_MPEG2VIDEO
	1146	+ if( s->streams[asf->stream_index]->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO
1147	1147	&& asf_st->pkt.size > 100){
1148	1148	int i;
1149	1149	for(i=0; i<asf_st->pkt.size && !asf_st->pkt.data[i]; i++);

libavformat/asfenc.c+10−10

@@ -216,10 +216,10 @@ typedef struct { · 215 unmodified lines
216	216	} ASFContext;
217	217
218	218	static const AVCodecTag codec_asf_bmp_tags[] = {
219		− { CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
220		− { CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },
221		− { CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
222		− { CODEC_ID_NONE, 0 },
	219	+ { AV_CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
	220	+ { AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },
	221	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
	222	+ { AV_CODEC_ID_NONE, 0 },
223	223	};
224	224
225	225	#define PREROLL_TIME 3100
@@ -446,7 +446,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data · 220 unmodified lines
446	446	}
447	447	/* ERROR Correction */
448	448	avio_w8(pb, 0x01);
449		− if(enc->codec_id == CODEC_ID_ADPCM_G726 \|\| !enc->block_align){
	449	+ if(enc->codec_id == AV_CODEC_ID_ADPCM_G726 \|\| !enc->block_align){
450	450	avio_wl16(pb, 0x0190);
451	451	avio_wl16(pb, 0x0190);
452	452	}else{
@@ -489,7 +489,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data · 36 unmodified lines
489	489	else
490	490	avio_wl16(pb, -1);
491	491
492		− if(enc->codec_id == CODEC_ID_WMAV2)
	492	+ if(enc->codec_id == AV_CODEC_ID_WMAV2)
493	493	desc = "Windows Media Audio V8";
494	494	else
495	495	desc = p ? p->name : enc->codec_name;
@@ -884,8 +884,8 @@ AVOutputFormat ff_asf_muxer = { · 388 unmodified lines
884	884	.mime_type = "video/x-ms-asf",
885	885	.extensions = "asf,wmv,wma",
886	886	.priv_data_size = sizeof(ASFContext),
887		− .audio_codec = CONFIG_LIBMP3LAME ? CODEC_ID_MP3 : CODEC_ID_MP2,
888		− .video_codec = CODEC_ID_MSMPEG4V3,
	887	+ .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_MP2,
	888	+ .video_codec = AV_CODEC_ID_MSMPEG4V3,
889	889	.write_header = asf_write_header,
890	890	.write_packet = asf_write_packet,
891	891	.write_trailer = asf_write_trailer,
@@ -903,8 +903,8 @@ AVOutputFormat ff_asf_stream_muxer = { · 11 unmodified lines
903	903	.mime_type = "video/x-ms-asf",
904	904	.extensions = "asf,wmv,wma",
905	905	.priv_data_size = sizeof(ASFContext),
906		− .audio_codec = CONFIG_LIBMP3LAME ? CODEC_ID_MP3 : CODEC_ID_MP2,
907		− .video_codec = CODEC_ID_MSMPEG4V3,
	906	+ .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_MP2,
	907	+ .video_codec = AV_CODEC_ID_MSMPEG4V3,
908	908	.write_header = asf_write_stream_header,
909	909	.write_packet = asf_write_packet,
910	910	.write_trailer = asf_write_trailer,

libavformat/assdec.c+1−1

@@ -88,7 +88,7 @@ static int read_header(AVFormatContext *s) · 87 unmodified lines
88	88	return -1;
89	89	avpriv_set_pts_info(st, 64, 1, 100);
90	90	st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
91		− st->codec->codec_id= CODEC_ID_SSA;
	91	+ st->codec->codec_id= AV_CODEC_ID_SSA;
92	92
93	93	header_remaining= INT_MAX;
94	94	dst[0] = &st->codec->extradata;

libavformat/assenc.c+2−2

@@ -31,7 +31,7 @@ static int write_header(AVFormatContext *s) · 30 unmodified lines
31	31	AVCodecContext *avctx= s->streams[0]->codec;
32	32	uint8_t *last= NULL;
33	33
34		− if(s->nb_streams != 1 \|\| avctx->codec_id != CODEC_ID_SSA){
	34	+ if(s->nb_streams != 1 \|\| avctx->codec_id != AV_CODEC_ID_SSA){
35	35	av_log(s, AV_LOG_ERROR, "Exactly one ASS/SSA stream is needed.\n");
36	36	return -1;
37	37	}
@@ -83,7 +83,7 @@ AVOutputFormat ff_ass_muxer = { · 45 unmodified lines
83	83	.mime_type = "text/x-ssa",
84	84	.extensions = "ass,ssa",
85	85	.priv_data_size = sizeof(ASSContext),
86		− .subtitle_codec = CODEC_ID_SSA,
	86	+ .subtitle_codec = AV_CODEC_ID_SSA,
87	87	.write_header = write_header,
88	88	.write_packet = write_packet,
89	89	.write_trailer = write_trailer,

libavformat/au.c+12−12

@@ -38,15 +38,15 @@ · 37 unmodified lines
38	38
39	39	/* The libavcodec codecs we support, and the IDs they have in the file */
40	40	static const AVCodecTag codec_au_tags[] = {
41		− { CODEC_ID_PCM_MULAW, 1 },
42		− { CODEC_ID_PCM_S8, 2 },
43		− { CODEC_ID_PCM_S16BE, 3 },
44		− { CODEC_ID_PCM_S24BE, 4 },
45		− { CODEC_ID_PCM_S32BE, 5 },
46		− { CODEC_ID_PCM_F32BE, 6 },
47		− { CODEC_ID_PCM_F64BE, 7 },
48		− { CODEC_ID_PCM_ALAW, 27 },
49		− { CODEC_ID_NONE, 0 },
	41	+ { AV_CODEC_ID_PCM_MULAW, 1 },
	42	+ { AV_CODEC_ID_PCM_S8, 2 },
	43	+ { AV_CODEC_ID_PCM_S16BE, 3 },
	44	+ { AV_CODEC_ID_PCM_S24BE, 4 },
	45	+ { AV_CODEC_ID_PCM_S32BE, 5 },
	46	+ { AV_CODEC_ID_PCM_F32BE, 6 },
	47	+ { AV_CODEC_ID_PCM_F64BE, 7 },
	48	+ { AV_CODEC_ID_PCM_ALAW, 27 },
	49	+ { AV_CODEC_ID_NONE, 0 },
50	50	};
51	51
52	52	#if CONFIG_AU_MUXER
@@ -124,7 +124,7 @@ static int au_read_header(AVFormatContext *s) · 71 unmodified lines
124	124	unsigned int tag;
125	125	AVIOContext *pb = s->pb;
126	126	unsigned int id, channels, rate;
127		− enum CodecID codec;
	127	+ enum AVCodecID codec;
128	128	AVStream *st;
129	129
130	130	/* check ".snd" header */
@@ -206,8 +206,8 @@ AVOutputFormat ff_au_muxer = { · 75 unmodified lines
206	206	.long_name = NULL_IF_CONFIG_SMALL("Sun AU"),
207	207	.mime_type = "audio/basic",
208	208	.extensions = "au",
209		− .audio_codec = CODEC_ID_PCM_S16BE,
210		− .video_codec = CODEC_ID_NONE,
	209	+ .audio_codec = AV_CODEC_ID_PCM_S16BE,
	210	+ .video_codec = AV_CODEC_ID_NONE,
211	211	.write_header = au_write_header,
212	212	.write_packet = au_write_packet,
213	213	.write_trailer = au_write_trailer,

libavformat/avformat.h+18−18

@@ -374,9 +374,9 @@ typedef struct AVOutputFormat { · 373 unmodified lines
374	374	const char *mime_type;
375	375	const char extensions; /< comma-separated filename extensions /
376	376	/* output support */
377		− enum CodecID audio_codec; /*< default audio codec /
378		− enum CodecID video_codec; /*< default video codec /
379		− enum CodecID subtitle_codec; /*< default subtitle codec /
	377	+ enum AVCodecID audio_codec; /*< default audio codec /
	378	+ enum AVCodecID video_codec; /*< default video codec /
	379	+ enum AVCodecID subtitle_codec; /*< default subtitle codec /
380	380	/**
381	381	* can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_RAWPICTURE,
382	382	* AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS,
@@ -387,7 +387,7 @@ typedef struct AVOutputFormat { · 4 unmodified lines
387	387
388	388	/**
389	389	* List of supported codec_id-codec_tag pairs, ordered by "better
390		− * choice first". The arrays are all terminated by CODEC_ID_NONE.
	390	+ * choice first". The arrays are all terminated by AV_CODEC_ID_NONE.
391	391	*/
392	392	const struct AVCodecTag * const *codec_tag;
393	393
@@ -428,7 +428,7 @@ typedef struct AVOutputFormat { · 34 unmodified lines
428	428	* @return 1 if the codec is supported, 0 if it is not.
429	429	* A negative number if unknown.
430	430	*/
431		− int (*query_codec)(enum CodecID id, int std_compliance);
	431	+ int (*query_codec)(enum AVCodecID id, int std_compliance);
432	432	} AVOutputFormat;
433	433	/**
434	434	* @}
@@ -924,19 +924,19 @@ typedef struct AVFormatContext { · 489 unmodified lines
924	924	* Forced video codec_id.
925	925	* Demuxing: Set by user.
926	926	*/
927		− enum CodecID video_codec_id;
	927	+ enum AVCodecID video_codec_id;
928	928
929	929	/**
930	930	* Forced audio codec_id.
931	931	* Demuxing: Set by user.
932	932	*/
933		− enum CodecID audio_codec_id;
	933	+ enum AVCodecID audio_codec_id;
934	934
935	935	/**
936	936	* Forced subtitle codec_id.
937	937	* Demuxing: Set by user.
938	938	*/
939		− enum CodecID subtitle_codec_id;
	939	+ enum AVCodecID subtitle_codec_id;
940	940
941	941	/**
942	942	* Maximum amount of memory in bytes to use for the index of each stream.
@@ -1512,7 +1512,7 @@ AVOutputFormat av_guess_format(const char short_name, · 569 unmodified lines
1512	1512	/**
1513	1513	* Guess the codec ID based upon muxer and filename.
1514	1514	*/
1515		−enum CodecID av_guess_codec(AVOutputFormat fmt, const char short_name,
	1515	+enum AVCodecID av_guess_codec(AVOutputFormat fmt, const char short_name,
1516	1516	const char filename, const char mime_type,
1517	1517	enum AVMediaType type);
1518	1518
@@ -1581,13 +1581,13 @@ void av_pkt_dump_log2(void avcl, int level, AVPacket pkt, int dump_payload, · 62 unmodified lines
1581	1581	AVStream *st);
1582	1582
1583	1583	/**
1584		− * Get the CodecID for the given codec tag tag.
1585		− * If no codec id is found returns CODEC_ID_NONE.
	1584	+ * Get the AVCodecID for the given codec tag tag.
	1585	+ * If no codec id is found returns AV_CODEC_ID_NONE.
1586	1586	*
1587	1587	* @param tags list of supported codec_id-codec_tag pairs, as stored
1588	1588	* in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
1589	1589	*/
1590		−enum CodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int tag);
	1590	+enum AVCodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int tag);
1591	1591
1592	1592	/**
1593	1593	* Get the codec tag for the given codec id id.
@@ -1596,7 +1596,7 @@ enum CodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int · 2 unmodified lines
1596	1596	* @param tags list of supported codec_id-codec_tag pairs, as stored
1597	1597	* in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
1598	1598	*/
1599		−unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum CodecID id);
	1599	+unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum AVCodecID id);
1600	1600
1601	1601	int av_find_default_stream_index(AVFormatContext *s);
1602	1602
@@ -1707,26 +1707,26 @@ int av_match_ext(const char filename, const char extensions); · 104 unmodified lines
1707	1707	* @return 1 if codec with ID codec_id can be stored in ofmt, 0 if it cannot.
1708	1708	* A negative number if this information is not available.
1709	1709	*/
1710		−int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance);
	1710	+int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance);
1711	1711
1712	1712	/**
1713	1713	* @defgroup riff_fourcc RIFF FourCCs
1714	1714	* @{
1715		− * Get the tables mapping RIFF FourCCs to libavcodec CodecIDs. The tables are
	1715	+ * Get the tables mapping RIFF FourCCs to libavcodec AVCodecIDs. The tables are
1716	1716	* meant to be passed to av_codec_get_id()/av_codec_get_tag() as in the
1717	1717	* following code:
1718	1718	* @code
1719	1719	* uint32_t tag = MKTAG('H', '2', '6', '4');
1720	1720	* const struct AVCodecTag *table[] = { avformat_get_riff_video_tags(), 0 };
1721		− * enum CodecID id = av_codec_get_id(table, tag);
	1721	+ * enum AVCodecID id = av_codec_get_id(table, tag);
1722	1722	* @endcode
1723	1723	*/
1724	1724	/**
1725		− * @return the table mapping RIFF FourCCs for video to libavcodec CodecID.
	1725	+ * @return the table mapping RIFF FourCCs for video to libavcodec AVCodecID.
1726	1726	*/
1727	1727	const struct AVCodecTag *avformat_get_riff_video_tags(void);
1728	1728	/**
1729		− * @return the table mapping RIFF FourCCs for audio to CodecID.
	1729	+ * @return the table mapping RIFF FourCCs for audio to AVCodecID.
1730	1730	*/
1731	1731	const struct AVCodecTag *avformat_get_riff_audio_tags(void);
1732	1732	/**

libavformat/avidec.c+8−8

@@ -554,7 +554,7 @@ static int avi_read_header(AVFormatContext *s) · 553 unmodified lines
554	554	st->codec->width=avih_width;
555	555	st->codec->height=avih_height;
556	556	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
557		− st->codec->codec_id = CODEC_ID_AMV;
	557	+ st->codec->codec_id = AV_CODEC_ID_AMV;
558	558	avio_skip(pb, size);
559	559	break;
560	560	}
@@ -563,7 +563,7 @@ static int avi_read_header(AVFormatContext *s) · 2 unmodified lines
563	563	if (tag1 == MKTAG('D', 'X', 'S', 'B') \|\| tag1 == MKTAG('D','X','S','A')) {
564	564	st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
565	565	st->codec->codec_tag = tag1;
566		− st->codec->codec_id = CODEC_ID_XSUB;
	566	+ st->codec->codec_id = AV_CODEC_ID_XSUB;
567	567	break;
568	568	}
569	569
@@ -608,7 +608,7 @@ static int avi_read_header(AVFormatContext *s) · 38 unmodified lines
608	608	if(tag1 == MKTAG('A', 'V', 'R', 'n') &&
609	609	st->codec->extradata_size >= 31 &&
610	610	!memcmp(&st->codec->extradata[28], "1:1", 3))
611		− st->codec->codec_id = CODEC_ID_RAWVIDEO;
	611	+ st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
612	612
613	613	if(st->codec->codec_tag==0 && st->codec->height > 0 && st->codec->extradata_size < 1U<<30){
614	614	st->codec->extradata_size+= 9;
@@ -637,26 +637,26 @@ static int avi_read_header(AVFormatContext *s) · 22 unmodified lines
637	637	/* ADTS header is in extradata, AAC without header must be
638	638	* stored as exact frames. Parser not needed and it will
639	639	* fail. */
640		− if (st->codec->codec_id == CODEC_ID_AAC && st->codec->extradata_size)
	640	+ if (st->codec->codec_id == AV_CODEC_ID_AAC && st->codec->extradata_size)
641	641	st->need_parsing = AVSTREAM_PARSE_NONE;
642	642	/* AVI files with Xan DPCM audio (wrongly) declare PCM
643	643	* audio in the header but have Axan as stream_code_tag. */
644	644	if (st->codec->stream_codec_tag == AV_RL32("Axan")){
645		− st->codec->codec_id = CODEC_ID_XAN_DPCM;
	645	+ st->codec->codec_id = AV_CODEC_ID_XAN_DPCM;
646	646	st->codec->codec_tag = 0;
647	647	}
648	648	if (amv_file_format){
649		− st->codec->codec_id = CODEC_ID_ADPCM_IMA_AMV;
	649	+ st->codec->codec_id = AV_CODEC_ID_ADPCM_IMA_AMV;
650	650	ast->dshow_block_align = 0;
651	651	}
652	652	break;
653	653	case AVMEDIA_TYPE_SUBTITLE:
654	654	st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
655		− st->codec->codec_id = CODEC_ID_PROBE;
	655	+ st->codec->codec_id = AV_CODEC_ID_PROBE;
656	656	break;
657	657	default:
658	658	st->codec->codec_type = AVMEDIA_TYPE_DATA;
659		− st->codec->codec_id= CODEC_ID_NONE;
	659	+ st->codec->codec_id= AV_CODEC_ID_NONE;
660	660	st->codec->codec_tag= 0;
661	661	avio_skip(pb, size);
662	662	break;

libavformat/avienc.c+6−6

@@ -234,7 +234,7 @@ static int avi_write_header(AVFormatContext *s) · 233 unmodified lines
234	234	case AVMEDIA_TYPE_SUBTITLE:
235	235	// XSUB subtitles behave like video tracks, other subtitles
236	236	// are not (yet) supported.
237		− if (stream->codec_id != CODEC_ID_XSUB) {
	237	+ if (stream->codec_id != AV_CODEC_ID_XSUB) {
238	238	av_log(s, AV_LOG_ERROR, "Subtitle streams other than DivX XSUB are not supported by the AVI muxer.\n");
239	239	return AVERROR_PATCHWELCOME;
240	240	}
@@ -244,7 +244,7 @@ static int avi_write_header(AVFormatContext *s) · 3 unmodified lines
244	244	case AVMEDIA_TYPE_DATA : ffio_wfourcc(pb, "dats"); break;
245	245	}
246	246	if(stream->codec_type == AVMEDIA_TYPE_VIDEO \|\|
247		− stream->codec_id == CODEC_ID_XSUB)
	247	+ stream->codec_id == AV_CODEC_ID_XSUB)
248	248	avio_wl32(pb, stream->codec_tag);
249	249	else
250	250	avio_wl32(pb, 1);
@@ -286,7 +286,7 @@ static int avi_write_header(AVFormatContext *s) · 35 unmodified lines
286	286	case AVMEDIA_TYPE_SUBTITLE:
287	287	// XSUB subtitles behave like video tracks, other subtitles
288	288	// are not (yet) supported.
289		− if (stream->codec_id != CODEC_ID_XSUB) break;
	289	+ if (stream->codec_id != AV_CODEC_ID_XSUB) break;
290	290	case AVMEDIA_TYPE_VIDEO:
291	291	ff_put_bmp_header(pb, stream, ff_codec_bmp_tags, 0);
292	292	break;
@@ -615,7 +615,7 @@ static int avi_write_trailer(AVFormatContext *s) · 322 unmodified lines
615	615	if (nb_frames < avist->packet_count)
616	616	nb_frames = avist->packet_count;
617	617	} else {
618		− if (stream->codec_id == CODEC_ID_MP2 \|\| stream->codec_id == CODEC_ID_MP3) {
	618	+ if (stream->codec_id == AV_CODEC_ID_MP2 \|\| stream->codec_id == AV_CODEC_ID_MP3) {
619	619	nb_frames += avist->packet_count;
620	620	}
621	621	}
@@ -645,8 +645,8 @@ AVOutputFormat ff_avi_muxer = { · 23 unmodified lines
645	645	.mime_type = "video/x-msvideo",
646	646	.extensions = "avi",
647	647	.priv_data_size = sizeof(AVIContext),
648		− .audio_codec = CONFIG_LIBMP3LAME ? CODEC_ID_MP3 : CODEC_ID_AC3,
649		− .video_codec = CODEC_ID_MPEG4,
	648	+ .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_AC3,
	649	+ .video_codec = AV_CODEC_ID_MPEG4,
650	650	.write_header = avi_write_header,
651	651	.write_packet = avi_write_packet,
652	652	.write_trailer = avi_write_trailer,

libavformat/avs.c+1−1

@@ -183,7 +183,7 @@ static int avs_read_packet(AVFormatContext * s, AVPacket * pkt) · 182 unmodified lines
183	183	if (avs->st_video == NULL)
184	184	return AVERROR(ENOMEM);
185	185	avs->st_video->codec->codec_type = AVMEDIA_TYPE_VIDEO;
186		− avs->st_video->codec->codec_id = CODEC_ID_AVS;
	186	+ avs->st_video->codec->codec_id = AV_CODEC_ID_AVS;
187	187	avs->st_video->codec->width = avs->width;
188	188	avs->st_video->codec->height = avs->height;
189	189	avs->st_video->codec->bits_per_coded_sample=avs->bits_per_sample;

libavformat/bethsoftvid.c+2−2

@@ -112,7 +112,7 @@ static int read_frame(BVID_DemuxContext vid, AVIOContext pb, AVPacket *pkt, · 111 unmodified lines
112	112	}
113	113	avpriv_set_pts_info(st, 64, 185, vid->sample_rate);
114	114	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
115		− st->codec->codec_id = CODEC_ID_BETHSOFTVID;
	115	+ st->codec->codec_id = AV_CODEC_ID_BETHSOFTVID;
116	116	st->codec->width = vid->width;
117	117	st->codec->height = vid->height;
118	118	}
@@ -237,7 +237,7 @@ static int vid_read_packet(AVFormatContext *s, · 118 unmodified lines
237	237	return AVERROR(ENOMEM);
238	238	vid->audio_index = st->index;
239	239	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
240		− st->codec->codec_id = CODEC_ID_PCM_U8;
	240	+ st->codec->codec_id = AV_CODEC_ID_PCM_U8;
241	241	st->codec->channels = 1;
242	242	st->codec->bits_per_coded_sample = 8;
243	243	st->codec->sample_rate = vid->sample_rate;

libavformat/bfi.c+2−2

@@ -89,12 +89,12 @@ static int bfi_read_header(AVFormatContext * s) · 88 unmodified lines
89	89	/* Set up the video codec... */
90	90	avpriv_set_pts_info(vstream, 32, 1, fps);
91	91	vstream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
92		− vstream->codec->codec_id = CODEC_ID_BFI;
	92	+ vstream->codec->codec_id = AV_CODEC_ID_BFI;
93	93	vstream->codec->pix_fmt = PIX_FMT_PAL8;
94	94
95	95	/* Set up the audio codec now... */
96	96	astream->codec->codec_type = AVMEDIA_TYPE_AUDIO;
97		− astream->codec->codec_id = CODEC_ID_PCM_U8;
	97	+ astream->codec->codec_id = AV_CODEC_ID_PCM_U8;
98	98	astream->codec->channels = 1;
99	99	astream->codec->bits_per_coded_sample = 8;
100	100	astream->codec->bit_rate =

libavformat/bink.c+2−2

@@ -113,7 +113,7 @@ static int read_header(AVFormatContext *s) · 112 unmodified lines
113	113	avpriv_set_pts_info(vst, 64, fps_den, fps_num);
114	114
115	115	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
116		− vst->codec->codec_id = CODEC_ID_BINKVIDEO;
	116	+ vst->codec->codec_id = AV_CODEC_ID_BINKVIDEO;
117	117	vst->codec->extradata = av_mallocz(4 + FF_INPUT_BUFFER_PADDING_SIZE);
118	118	vst->codec->extradata_size = 4;
119	119	avio_read(pb, vst->codec->extradata, 4);
@@ -140,7 +140,7 @@ static int read_header(AVFormatContext *s) · 20 unmodified lines
140	140	avpriv_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
141	141	flags = avio_rl16(pb);
142	142	ast->codec->codec_id = flags & BINK_AUD_USEDCT ?
143		− CODEC_ID_BINKAUDIO_DCT : CODEC_ID_BINKAUDIO_RDFT;
	143	+ AV_CODEC_ID_BINKAUDIO_DCT : AV_CODEC_ID_BINKAUDIO_RDFT;
144	144	ast->codec->channels = flags & BINK_AUD_STEREO ? 2 : 1;
145	145	ast->codec->extradata = av_mallocz(4 + FF_INPUT_BUFFER_PADDING_SIZE);
146	146	if (!ast->codec->extradata)

libavformat/bmv.c+2−2

@@ -47,7 +47,7 @@ static int bmv_read_header(AVFormatContext *s) · 46 unmodified lines
47	47	if (!st)
48	48	return AVERROR(ENOMEM);
49	49	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
50		− st->codec->codec_id = CODEC_ID_BMV_VIDEO;
	50	+ st->codec->codec_id = AV_CODEC_ID_BMV_VIDEO;
51	51	st->codec->width = 640;
52	52	st->codec->height = 429;
53	53	st->codec->pix_fmt = PIX_FMT_PAL8;
@@ -56,7 +56,7 @@ static int bmv_read_header(AVFormatContext *s) · 2 unmodified lines
56	56	if (!ast)
57	57	return AVERROR(ENOMEM);
58	58	ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
59		− ast->codec->codec_id = CODEC_ID_BMV_AUDIO;
	59	+ ast->codec->codec_id = AV_CODEC_ID_BMV_AUDIO;
60	60	ast->codec->channels = 2;
61	61	ast->codec->sample_rate = 22050;
62	62	avpriv_set_pts_info(ast, 16, 1, 22050);

libavformat/c93.c+1−1

@@ -84,7 +84,7 @@ static int read_header(AVFormatContext *s) · 83 unmodified lines
84	84	return AVERROR(ENOMEM);
85	85
86	86	video->codec->codec_type = AVMEDIA_TYPE_VIDEO;
87		− video->codec->codec_id = CODEC_ID_C93;
	87	+ video->codec->codec_id = AV_CODEC_ID_C93;
88	88	video->codec->width = 320;
89	89	video->codec->height = 192;
90	90	/* 4:3 320x200 with 8 empty lines */

libavformat/caf.c+17−17

@@ -32,27 +32,27 @@ · 31 unmodified lines
32	32	* Known codec tags for CAF
33	33	*/
34	34	const AVCodecTag ff_codec_caf_tags[] = {
35		− { CODEC_ID_AAC, MKBETAG('a','a','c',' ') },
36		− { CODEC_ID_AC3, MKBETAG('a','c','-','3') },
37		− { CODEC_ID_ALAC, MKBETAG('a','l','a','c') },
	35	+ { AV_CODEC_ID_AAC, MKBETAG('a','a','c',' ') },
	36	+ { AV_CODEC_ID_AC3, MKBETAG('a','c','-','3') },
	37	+ { AV_CODEC_ID_ALAC, MKBETAG('a','l','a','c') },
38	38	/* FIXME: use DV demuxer, as done in MOV */
39		− /{ CODEC_ID_DVAUDIO, MKBETAG('v','d','v','a') },/
40		− /{ CODEC_ID_DVAUDIO, MKBETAG('d','v','c','a') },/
41		− { CODEC_ID_ADPCM_IMA_QT, MKBETAG('i','m','a','4') },
42		− { CODEC_ID_MACE3, MKBETAG('M','A','C','3') },
43		− { CODEC_ID_MACE6, MKBETAG('M','A','C','6') },
44		− { CODEC_ID_MP3, MKBETAG('.','m','p','3') },
45		− { CODEC_ID_MP2, MKBETAG('.','m','p','2') },
46		− { CODEC_ID_MP1, MKBETAG('.','m','p','1') },
47		− { CODEC_ID_PCM_ALAW, MKBETAG('a','l','a','w') },
48		− { CODEC_ID_PCM_MULAW, MKBETAG('u','l','a','w') },
49		− { CODEC_ID_QCELP, MKBETAG('Q','c','l','p') },
50		− { CODEC_ID_QDM2, MKBETAG('Q','D','M','2') },
51		− { CODEC_ID_QDM2, MKBETAG('Q','D','M','C') },
	39	+ /{ AV_CODEC_ID_DVAUDIO, MKBETAG('v','d','v','a') },/
	40	+ /{ AV_CODEC_ID_DVAUDIO, MKBETAG('d','v','c','a') },/
	41	+ { AV_CODEC_ID_ADPCM_IMA_QT, MKBETAG('i','m','a','4') },
	42	+ { AV_CODEC_ID_MACE3, MKBETAG('M','A','C','3') },
	43	+ { AV_CODEC_ID_MACE6, MKBETAG('M','A','C','6') },
	44	+ { AV_CODEC_ID_MP3, MKBETAG('.','m','p','3') },
	45	+ { AV_CODEC_ID_MP2, MKBETAG('.','m','p','2') },
	46	+ { AV_CODEC_ID_MP1, MKBETAG('.','m','p','1') },
	47	+ { AV_CODEC_ID_PCM_ALAW, MKBETAG('a','l','a','w') },
	48	+ { AV_CODEC_ID_PCM_MULAW, MKBETAG('u','l','a','w') },
	49	+ { AV_CODEC_ID_QCELP, MKBETAG('Q','c','l','p') },
	50	+ { AV_CODEC_ID_QDM2, MKBETAG('Q','D','M','2') },
	51	+ { AV_CODEC_ID_QDM2, MKBETAG('Q','D','M','C') },
52	52	/* currently unsupported codecs */
53	53	/{ AC-3 over S/PDIF MKBETAG('c','a','c','3') },/
54	54	/{ MPEG4CELP MKBETAG('c','e','l','p') },/
55	55	/{ MPEG4HVXC MKBETAG('h','v','x','c') },/
56	56	/{ MPEG4TwinVQ MKBETAG('t','w','v','q') },/
57		− { CODEC_ID_NONE, 0 },
	57	+ { AV_CODEC_ID_NONE, 0 },
58	58	};

libavformat/cafdec.c+3−3

@@ -103,7 +103,7 @@ static int read_kuki_chunk(AVFormatContext *s, int64_t size) · 102 unmodified lines
103	103	if (size < 0 \|\| size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)
104	104	return -1;
105	105
106		− if (st->codec->codec_id == CODEC_ID_AAC) {
	106	+ if (st->codec->codec_id == AV_CODEC_ID_AAC) {
107	107	/* The magic cookie format for AAC is an mp4 esds atom.
108	108	The lavc AAC decoder requires the data from the codec specific
109	109	description as extradata input. */
@@ -114,12 +114,12 @@ static int read_kuki_chunk(AVFormatContext *s, int64_t size) · 4 unmodified lines
114	114	ff_mov_read_esds(s, pb, atom);
115	115	skip = size - (avio_tell(pb) - strt);
116	116	if (skip < 0 \|\| !st->codec->extradata \|\|
117		− st->codec->codec_id != CODEC_ID_AAC) {
	117	+ st->codec->codec_id != AV_CODEC_ID_AAC) {
118	118	av_log(s, AV_LOG_ERROR, "invalid AAC magic cookie\n");
119	119	return AVERROR_INVALIDDATA;
120	120	}
121	121	avio_skip(pb, skip);
122		− } else if (st->codec->codec_id == CODEC_ID_ALAC) {
	122	+ } else if (st->codec->codec_id == AV_CODEC_ID_ALAC) {
123	123	#define ALAC_PREAMBLE 12
124	124	#define ALAC_HEADER 36
125	125	#define ALAC_NEW_KUKI 24

libavformat/cavsvideodec.c+1−1

@@ -65,4 +65,4 @@ static int cavsvideo_probe(AVProbeData *p) · 64 unmodified lines
65	65	return 0;
66	66	}
67	67
68		−FF_DEF_RAWVIDEO_DEMUXER(cavsvideo, "raw Chinese AVS (Audio Video Standard)", cavsvideo_probe, NULL, CODEC_ID_CAVS)
	68	+FF_DEF_RAWVIDEO_DEMUXER(cavsvideo, "raw Chinese AVS (Audio Video Standard)", cavsvideo_probe, NULL, AV_CODEC_ID_CAVS)

libavformat/cdg.c+1−1

@@ -36,7 +36,7 @@ static int read_header(AVFormatContext *s) · 35 unmodified lines
36	36	return AVERROR(ENOMEM);
37	37
38	38	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
39		− vst->codec->codec_id = CODEC_ID_CDGRAPHICS;
	39	+ vst->codec->codec_id = AV_CODEC_ID_CDGRAPHICS;
40	40
41	41	/// 75 sectors/sec * 4 packets/sector = 300 packets/sec
42	42	avpriv_set_pts_info(vst, 32, 1, 300);

libavformat/cdxl.c+2−2

@@ -100,7 +100,7 @@ static int cdxl_read_packet(AVFormatContext s, AVPacket pkt) · 99 unmodified lines
100	100
101	101	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
102	102	st->codec->codec_tag = 0;
103		− st->codec->codec_id = CODEC_ID_PCM_S8;
	103	+ st->codec->codec_id = AV_CODEC_ID_PCM_S8;
104	104	st->codec->channels = cdxl->header[1] & 0x10 ? 2 : 1;
105	105	st->codec->sample_rate = cdxl->sample_rate;
106	106	st->start_time = 0;
@@ -123,7 +123,7 @@ static int cdxl_read_packet(AVFormatContext s, AVPacket pkt) · 16 unmodified lines
123	123
124	124	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
125	125	st->codec->codec_tag = 0;
126		− st->codec->codec_id = CODEC_ID_CDXL;
	126	+ st->codec->codec_id = AV_CODEC_ID_CDXL;
127	127	st->codec->width = width;
128	128	st->codec->height = height;
129	129	st->start_time = 0;

libavformat/crcenc.c+2−2

@@ -59,8 +59,8 @@ AVOutputFormat ff_crc_muxer = { · 58 unmodified lines
59	59	.long_name = NULL_IF_CONFIG_SMALL("CRC testing"),
60	60	.extensions = "",
61	61	.priv_data_size = sizeof(CRCState),
62		− .audio_codec = CODEC_ID_PCM_S16LE,
63		− .video_codec = CODEC_ID_RAWVIDEO,
	62	+ .audio_codec = AV_CODEC_ID_PCM_S16LE,
	63	+ .video_codec = AV_CODEC_ID_RAWVIDEO,
64	64	.write_header = crc_write_header,
65	65	.write_packet = crc_write_packet,
66	66	.write_trailer = crc_write_trailer,

libavformat/daud.c+3−3

@@ -25,7 +25,7 @@ static int daud_header(AVFormatContext *s) { · 24 unmodified lines
25	25	if (!st)
26	26	return AVERROR(ENOMEM);
27	27	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
28		− st->codec->codec_id = CODEC_ID_PCM_S24DAUD;
	28	+ st->codec->codec_id = AV_CODEC_ID_PCM_S24DAUD;
29	29	st->codec->codec_tag = MKTAG('d', 'a', 'u', 'd');
30	30	st->codec->channels = 6;
31	31	st->codec->sample_rate = 96000;
@@ -84,8 +84,8 @@ AVOutputFormat ff_daud_muxer = { · 52 unmodified lines
84	84	.name = "daud",
85	85	.long_name = NULL_IF_CONFIG_SMALL("D-Cinema audio"),
86	86	.extensions = "302",
87		− .audio_codec = CODEC_ID_PCM_S24DAUD,
88		− .video_codec = CODEC_ID_NONE,
	87	+ .audio_codec = AV_CODEC_ID_PCM_S24DAUD,
	88	+ .video_codec = AV_CODEC_ID_NONE,
89	89	.write_header = daud_write_header,
90	90	.write_packet = daud_write_packet,
91	91	.flags = AVFMT_NOTIMESTAMPS,

libavformat/dfa.c+1−1

@@ -50,7 +50,7 @@ static int dfa_read_header(AVFormatContext *s) · 49 unmodified lines
50	50	return AVERROR(ENOMEM);
51	51
52	52	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
53		− st->codec->codec_id = CODEC_ID_DFA;
	53	+ st->codec->codec_id = AV_CODEC_ID_DFA;
54	54	st->codec->width = avio_rl16(pb);
55	55	st->codec->height = avio_rl16(pb);
56	56	mspf = avio_rl32(pb);

libavformat/diracdec.c+1−1

@@ -31,4 +31,4 @@ static int dirac_probe(AVProbeData *p) · 30 unmodified lines
31	31	return 0;
32	32	}
33	33
34		−FF_DEF_RAWVIDEO_DEMUXER(dirac, "raw Dirac", dirac_probe, NULL, CODEC_ID_DIRAC)
	34	+FF_DEF_RAWVIDEO_DEMUXER(dirac, "raw Dirac", dirac_probe, NULL, AV_CODEC_ID_DIRAC)

libavformat/dnxhddec.c+1−1

@@ -42,4 +42,4 @@ static int dnxhd_probe(AVProbeData *p) · 41 unmodified lines
42	42	return AVPROBE_SCORE_MAX;
43	43	}
44	44
45		−FF_DEF_RAWVIDEO_DEMUXER(dnxhd, "raw DNxHD (SMPTE VC-3)", dnxhd_probe, NULL, CODEC_ID_DNXHD)
	45	+FF_DEF_RAWVIDEO_DEMUXER(dnxhd, "raw DNxHD (SMPTE VC-3)", dnxhd_probe, NULL, AV_CODEC_ID_DNXHD)

libavformat/dsicin.c+2−2

@@ -115,7 +115,7 @@ static int cin_read_header(AVFormatContext *s) · 114 unmodified lines
115	115	avpriv_set_pts_info(st, 32, 1, 12);
116	116	cin->video_stream_index = st->index;
117	117	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
118		− st->codec->codec_id = CODEC_ID_DSICINVIDEO;
	118	+ st->codec->codec_id = AV_CODEC_ID_DSICINVIDEO;
119	119	st->codec->codec_tag = 0; /* no fourcc */
120	120	st->codec->width = hdr->video_frame_width;
121	121	st->codec->height = hdr->video_frame_height;
@@ -128,7 +128,7 @@ static int cin_read_header(AVFormatContext *s) · 6 unmodified lines
128	128	avpriv_set_pts_info(st, 32, 1, 22050);
129	129	cin->audio_stream_index = st->index;
130	130	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
131		− st->codec->codec_id = CODEC_ID_DSICINAUDIO;
	131	+ st->codec->codec_id = AV_CODEC_ID_DSICINAUDIO;
132	132	st->codec->codec_tag = 0; /* no tag */
133	133	st->codec->channels = 1;
134	134	st->codec->sample_rate = 22050;

libavformat/dtsdec.c+1−1

@@ -73,5 +73,5 @@ AVInputFormat ff_dts_demuxer = { · 72 unmodified lines
73	73	.read_packet = ff_raw_read_partial_packet,
74	74	.flags = AVFMT_GENERIC_INDEX,
75	75	.extensions = "dts",
76		− .raw_codec_id = CODEC_ID_DTS,
	76	+ .raw_codec_id = AV_CODEC_ID_DTS,
77	77	};

libavformat/dv.c+2−2

@@ -236,7 +236,7 @@ static int dv_extract_audio_info(DVDemuxContext* c, uint8_t* frame) · 235 unmodified lines
236	236	break;
237	237	avpriv_set_pts_info(c->ast[i], 64, 1, 30000);
238	238	c->ast[i]->codec->codec_type = AVMEDIA_TYPE_AUDIO;
239		− c->ast[i]->codec->codec_id = CODEC_ID_PCM_S16LE;
	239	+ c->ast[i]->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
240	240
241	241	av_init_packet(&c->audio_pkt[i]);
242	242	c->audio_pkt[i].size = 0;
@@ -306,7 +306,7 @@ DVDemuxContext* avpriv_dv_init_demux(AVFormatContext *s) · 63 unmodified lines
306	306
307	307	c->fctx = s;
308	308	c->vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
309		− c->vst->codec->codec_id = CODEC_ID_DVVIDEO;
	309	+ c->vst->codec->codec_id = AV_CODEC_ID_DVVIDEO;
310	310	c->vst->codec->bit_rate = 25000000;
311	311	c->vst->start_time = 0;
312	312

libavformat/dvenc.c+4−4

@@ -318,10 +318,10 @@ static DVMuxContext* dv_init_mux(AVFormatContext* s) · 317 unmodified lines
318	318	}
319	319
320	320	/* Some checks -- DV format is very picky about its incoming streams */
321		− if (!vst \|\| vst->codec->codec_id != CODEC_ID_DVVIDEO)
	321	+ if (!vst \|\| vst->codec->codec_id != AV_CODEC_ID_DVVIDEO)
322	322	goto bail_out;
323	323	for (i=0; i<c->n_ast; i++) {
324		− if (c->ast[i] && (c->ast[i]->codec->codec_id != CODEC_ID_PCM_S16LE \|\|
	324	+ if (c->ast[i] && (c->ast[i]->codec->codec_id != AV_CODEC_ID_PCM_S16LE \|\|
325	325	c->ast[i]->codec->sample_rate != 48000 \|\|
326	326	c->ast[i]->codec->channels != 2))
327	327	goto bail_out;
@@ -408,8 +408,8 @@ AVOutputFormat ff_dv_muxer = { · 80 unmodified lines
408	408	.long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
409	409	.extensions = "dv",
410	410	.priv_data_size = sizeof(DVMuxContext),
411		− .audio_codec = CODEC_ID_PCM_S16LE,
412		− .video_codec = CODEC_ID_DVVIDEO,
	411	+ .audio_codec = AV_CODEC_ID_PCM_S16LE,
	412	+ .video_codec = AV_CODEC_ID_DVVIDEO,
413	413	.write_header = dv_write_header,
414	414	.write_packet = dv_write_packet,
415	415	.write_trailer = dv_write_trailer,

libavformat/dxa.c+1−1

@@ -126,7 +126,7 @@ static int dxa_read_header(AVFormatContext *s) · 125 unmodified lines
126	126
127	127	/* now we are ready: build format streams */
128	128	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
129		− st->codec->codec_id = CODEC_ID_DXA;
	129	+ st->codec->codec_id = AV_CODEC_ID_DXA;
130	130	st->codec->width = w;
131	131	st->codec->height = h;
132	132	av_reduce(&den, &num, den, num, (1UL<<31)-1);

libavformat/eacdata.c+1−1

@@ -70,7 +70,7 @@ static int cdata_read_header(AVFormatContext *s) · 69 unmodified lines
70	70	return AVERROR(ENOMEM);
71	71	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
72	72	st->codec->codec_tag = 0; /* no fourcc */
73		− st->codec->codec_id = CODEC_ID_ADPCM_EA_XAS;
	73	+ st->codec->codec_id = AV_CODEC_ID_ADPCM_EA_XAS;
74	74	st->codec->channels = cdata->channels;
75	75	st->codec->sample_rate = sample_rate;
76	76	avpriv_set_pts_info(st, 64, 1, sample_rate);

libavformat/electronicarts.c+35−35

@@ -63,12 +63,12 @@ · 62 unmodified lines
63	63	typedef struct EaDemuxContext {
64	64	int big_endian;
65	65
66		− enum CodecID video_codec;
	66	+ enum AVCodecID video_codec;
67	67	AVRational time_base;
68	68	int width, height;
69	69	int video_stream_index;
70	70
71		− enum CodecID audio_codec;
	71	+ enum AVCodecID audio_codec;
72	72	int audio_stream_index;
73	73
74	74	int bytes;
@@ -174,25 +174,25 @@ static int process_audio_header_elements(AVFormatContext *s) · 99 unmodified lines
174	174	}
175	175
176	176	switch (compression_type) {
177		− case 0: ea->audio_codec = CODEC_ID_PCM_S16LE; break;
178		− case 7: ea->audio_codec = CODEC_ID_ADPCM_EA; break;
	177	+ case 0: ea->audio_codec = AV_CODEC_ID_PCM_S16LE; break;
	178	+ case 7: ea->audio_codec = AV_CODEC_ID_ADPCM_EA; break;
179	179	case -1:
180	180	switch (revision) {
181		− case 1: ea->audio_codec = CODEC_ID_ADPCM_EA_R1; break;
182		− case 2: ea->audio_codec = CODEC_ID_ADPCM_EA_R2; break;
183		− case 3: ea->audio_codec = CODEC_ID_ADPCM_EA_R3; break;
	181	+ case 1: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R1; break;
	182	+ case 2: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2; break;
	183	+ case 3: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R3; break;
184	184	case -1: break;
185	185	default:
186	186	av_log(s, AV_LOG_ERROR, "unsupported stream type; revision=%i\n", revision);
187	187	return 0;
188	188	}
189	189	switch (revision2) {
190		− case 8: ea->audio_codec = CODEC_ID_PCM_S16LE_PLANAR; break;
191		− case 10: ea->audio_codec = CODEC_ID_ADPCM_EA_R2; break;
192		− case 16: ea->audio_codec = CODEC_ID_MP3; break;
	190	+ case 8: ea->audio_codec = AV_CODEC_ID_PCM_S16LE_PLANAR; break;
	191	+ case 10: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2; break;
	192	+ case 16: ea->audio_codec = AV_CODEC_ID_MP3; break;
193	193	case -1: break;
194	194	default:
195		− ea->audio_codec = CODEC_ID_NONE;
	195	+ ea->audio_codec = AV_CODEC_ID_NONE;
196	196	av_log(s, AV_LOG_ERROR, "unsupported stream type; revision2=%i\n", revision2);
197	197	return 0;
198	198	}
@@ -227,12 +227,12 @@ static int process_audio_header_eacs(AVFormatContext *s) · 28 unmodified lines
227	227	switch (compression_type) {
228	228	case 0:
229	229	switch (ea->bytes) {
230		− case 1: ea->audio_codec = CODEC_ID_PCM_S8; break;
231		− case 2: ea->audio_codec = CODEC_ID_PCM_S16LE; break;
	230	+ case 1: ea->audio_codec = AV_CODEC_ID_PCM_S8; break;
	231	+ case 2: ea->audio_codec = AV_CODEC_ID_PCM_S16LE; break;
232	232	}
233	233	break;
234		− case 1: ea->audio_codec = CODEC_ID_PCM_MULAW; ea->bytes = 1; break;
235		− case 2: ea->audio_codec = CODEC_ID_ADPCM_IMA_EA_EACS; break;
	234	+ case 1: ea->audio_codec = AV_CODEC_ID_PCM_MULAW; ea->bytes = 1; break;
	235	+ case 2: ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_EACS; break;
236	236	default:
237	237	av_log (s, AV_LOG_ERROR, "unsupported stream type; audio compression_type=%i\n", compression_type);
238	238	}
@@ -252,7 +252,7 @@ static int process_audio_header_sead(AVFormatContext *s) · 13 unmodified lines
252	252	ea->sample_rate = avio_rl32(pb);
253	253	ea->bytes = avio_rl32(pb); /* 1=8-bit, 2=16-bit */
254	254	ea->num_channels = avio_rl32(pb);
255		− ea->audio_codec = CODEC_ID_ADPCM_IMA_EA_SEAD;
	255	+ ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_SEAD;
256	256
257	257	return 1;
258	258	}
@@ -265,7 +265,7 @@ static int process_video_header_mdec(AVFormatContext *s) · 6 unmodified lines
265	265	ea->width = avio_rl16(pb);
266	266	ea->height = avio_rl16(pb);
267	267	ea->time_base = (AVRational){1,15};
268		− ea->video_codec = CODEC_ID_MDEC;
	268	+ ea->video_codec = AV_CODEC_ID_MDEC;
269	269	return 1;
270	270	}
271	271
@@ -277,7 +277,7 @@ static int process_video_header_vp6(AVFormatContext *s) · 5 unmodified lines
277	277	avio_skip(pb, 16);
278	278	ea->time_base.den = avio_rl32(pb);
279	279	ea->time_base.num = avio_rl32(pb);
280		− ea->video_codec = CODEC_ID_VP6;
	280	+ ea->video_codec = AV_CODEC_ID_VP6;
281	281
282	282	return 1;
283	283	}
@@ -291,7 +291,7 @@ static int process_video_header_cmv(AVFormatContext *s) · 7 unmodified lines
291	291	fps = avio_rl16(s->pb);
292	292	if (fps)
293	293	ea->time_base = (AVRational){1, fps};
294		− ea->video_codec = CODEC_ID_CMV;
	294	+ ea->video_codec = AV_CODEC_ID_CMV;
295	295
296	296	return 0;
297	297	}
@@ -347,7 +347,7 @@ static int process_ea_header(AVFormatContext *s) { · 49 unmodified lines
347	347	break;
348	348
349	349	case kVGT_TAG:
350		− ea->video_codec = CODEC_ID_TGV;
	350	+ ea->video_codec = AV_CODEC_ID_TGV;
351	351	ea->time_base = (AVRational){1, 15};
352	352	break;
353	353
@@ -356,20 +356,20 @@ static int process_ea_header(AVFormatContext *s) { · 2 unmodified lines
356	356	break;
357	357
358	358	case MPCh_TAG:
359		− ea->video_codec = CODEC_ID_MPEG2VIDEO;
	359	+ ea->video_codec = AV_CODEC_ID_MPEG2VIDEO;
360	360	break;
361	361
362	362	case pQGT_TAG:
363	363	case TGQs_TAG:
364		− ea->video_codec = CODEC_ID_TGQ;
	364	+ ea->video_codec = AV_CODEC_ID_TGQ;
365	365	break;
366	366
367	367	case pIQT_TAG:
368		− ea->video_codec = CODEC_ID_TQI;
	368	+ ea->video_codec = AV_CODEC_ID_TQI;
369	369	break;
370	370
371	371	case MADk_TAG :
372		− ea->video_codec = CODEC_ID_MAD;
	372	+ ea->video_codec = AV_CODEC_ID_MAD;
373	373	break;
374	374
375	375	case MVhd_TAG :
@@ -451,7 +451,7 @@ static int ea_read_header(AVFormatContext *s) · 75 unmodified lines
451	451	}
452	452	if (ea->bytes <= 0) {
453	453	av_log(s, AV_LOG_ERROR, "Invalid number of bytes per sample: %d\n", ea->bytes);
454		− ea->audio_codec = CODEC_ID_NONE;
	454	+ ea->audio_codec = AV_CODEC_ID_NONE;
455	455	return 1;
456	456	}
457	457
@@ -509,8 +509,8 @@ static int ea_read_packet(AVFormatContext *s, · 51 unmodified lines
509	509	if (!ea->audio_codec) {
510	510	avio_skip(pb, chunk_size);
511	511	break;
512		− } else if (ea->audio_codec == CODEC_ID_PCM_S16LE_PLANAR \|\|
513		− ea->audio_codec == CODEC_ID_MP3) {
	512	+ } else if (ea->audio_codec == AV_CODEC_ID_PCM_S16LE_PLANAR \|\|
	513	+ ea->audio_codec == AV_CODEC_ID_MP3) {
514	514	num_samples = avio_rl32(pb);
515	515	avio_skip(pb, 8);
516	516	chunk_size -= 12;
@@ -521,20 +521,20 @@ static int ea_read_packet(AVFormatContext *s, · 4 unmodified lines
521	521	pkt->stream_index = ea->audio_stream_index;
522	522
523	523	switch (ea->audio_codec) {
524		− case CODEC_ID_ADPCM_EA:
525		− case CODEC_ID_ADPCM_EA_R1:
526		− case CODEC_ID_ADPCM_EA_R2:
527		− case CODEC_ID_ADPCM_IMA_EA_EACS:
	524	+ case AV_CODEC_ID_ADPCM_EA:
	525	+ case AV_CODEC_ID_ADPCM_EA_R1:
	526	+ case AV_CODEC_ID_ADPCM_EA_R2:
	527	+ case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
528	528	pkt->duration = AV_RL32(pkt->data);
529	529	break;
530		− case CODEC_ID_ADPCM_EA_R3:
	530	+ case AV_CODEC_ID_ADPCM_EA_R3:
531	531	pkt->duration = AV_RB32(pkt->data);
532	532	break;
533		− case CODEC_ID_ADPCM_IMA_EA_SEAD:
	533	+ case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
534	534	pkt->duration = ret * 2 / ea->num_channels;
535	535	break;
536		− case CODEC_ID_PCM_S16LE_PLANAR:
537		− case CODEC_ID_MP3:
	536	+ case AV_CODEC_ID_PCM_S16LE_PLANAR:
	537	+ case AV_CODEC_ID_MP3:
538	538	pkt->duration = num_samples;
539	539	break;
540	540	default:

libavformat/ffmenc.c+2−2

@@ -243,8 +243,8 @@ AVOutputFormat ff_ffm_muxer = { · 242 unmodified lines
243	243	.mime_type = "",
244	244	.extensions = "ffm",
245	245	.priv_data_size = sizeof(FFMContext),
246		− .audio_codec = CODEC_ID_MP2,
247		− .video_codec = CODEC_ID_MPEG1VIDEO,
	246	+ .audio_codec = AV_CODEC_ID_MP2,
	247	+ .video_codec = AV_CODEC_ID_MPEG1VIDEO,
248	248	.write_header = ffm_write_header,
249	249	.write_packet = ffm_write_packet,
250	250	.write_trailer = ffm_write_trailer,

libavformat/ffmetadec.c+1−1

@@ -138,7 +138,7 @@ static int read_header(AVFormatContext *s) · 137 unmodified lines
138	138	return -1;
139	139
140	140	st->codec->codec_type = AVMEDIA_TYPE_DATA;
141		− st->codec->codec_id = CODEC_ID_FFMETADATA;
	141	+ st->codec->codec_id = AV_CODEC_ID_FFMETADATA;
142	142
143	143	m = &st->metadata;
144	144	} else if (!memcmp(line, ID_CHAPTER, strlen(ID_CHAPTER))) {

libavformat/filmstripdec.c+1−1

@@ -61,7 +61,7 @@ static int read_header(AVFormatContext *s) · 60 unmodified lines
61	61
62	62	avio_skip(pb, 2);
63	63	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
64		− st->codec->codec_id = CODEC_ID_RAWVIDEO;
	64	+ st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
65	65	st->codec->pix_fmt = PIX_FMT_RGBA;
66	66	st->codec->codec_tag = 0; /* no fourcc */
67	67	st->codec->width = avio_rb16(pb);

libavformat/filmstripenc.c+2−2

@@ -76,8 +76,8 @@ AVOutputFormat ff_filmstrip_muxer = { · 75 unmodified lines
76	76	.long_name = NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
77	77	.extensions = "flm",
78	78	.priv_data_size = sizeof(FilmstripMuxContext),
79		− .audio_codec = CODEC_ID_NONE,
80		− .video_codec = CODEC_ID_RAWVIDEO,
	79	+ .audio_codec = AV_CODEC_ID_NONE,
	80	+ .video_codec = AV_CODEC_ID_RAWVIDEO,
81	81	.write_header = write_header,
82	82	.write_packet = write_packet,
83	83	.write_trailer = write_trailer,

libavformat/flacdec.c+5−5

@@ -31,7 +31,7 @@ · 30 unmodified lines
31	31	static int parse_picture(AVFormatContext s, uint8_t buf, int buf_size)
32	32	{
33	33	const CodecMime *mime = ff_id3v2_mime_tags;
34		− enum CodecID id = CODEC_ID_NONE;
	34	+ enum AVCodecID id = AV_CODEC_ID_NONE;
35	35	uint8_t mimetype[64], desc = NULL, data = NULL;
36	36	AVIOContext *pb = NULL;
37	37	AVStream *st;
@@ -65,14 +65,14 @@ static int parse_picture(AVFormatContext s, uint8_t buf, int buf_size) · 27 unmodified lines
65	65	}
66	66	mimetype[len] = 0;
67	67
68		− while (mime->id != CODEC_ID_NONE) {
	68	+ while (mime->id != AV_CODEC_ID_NONE) {
69	69	if (!strncmp(mime->str, mimetype, sizeof(mimetype))) {
70	70	id = mime->id;
71	71	break;
72	72	}
73	73	mime++;
74	74	}
75		− if (id == CODEC_ID_NONE) {
	75	+ if (id == AV_CODEC_ID_NONE) {
76	76	av_log(s, AV_LOG_ERROR, "Unknown attached picture mimetype: %s.\n",
77	77	mimetype);
78	78	if (s->error_recognition & AV_EF_EXPLODE)
@@ -164,7 +164,7 @@ static int flac_read_header(AVFormatContext *s) · 85 unmodified lines
164	164	if (!st)
165	165	return AVERROR(ENOMEM);
166	166	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
167		− st->codec->codec_id = CODEC_ID_FLAC;
	167	+ st->codec->codec_id = AV_CODEC_ID_FLAC;
168	168	st->need_parsing = AVSTREAM_PARSE_FULL;
169	169	/* the parameters will be extracted from the compressed bitstream */
170	170
@@ -293,5 +293,5 @@ AVInputFormat ff_flac_demuxer = { · 122 unmodified lines
293	293	.read_packet = ff_raw_read_partial_packet,
294	294	.flags = AVFMT_GENERIC_INDEX,
295	295	.extensions = "flac",
296		− .raw_codec_id = CODEC_ID_FLAC,
	296	+ .raw_codec_id = AV_CODEC_ID_FLAC,
297	297	};

libavformat/flacenc.c+2−2

@@ -122,8 +122,8 @@ AVOutputFormat ff_flac_muxer = { · 121 unmodified lines
122	122	.long_name = NULL_IF_CONFIG_SMALL("raw FLAC"),
123	123	.mime_type = "audio/x-flac",
124	124	.extensions = "flac",
125		− .audio_codec = CODEC_ID_FLAC,
126		− .video_codec = CODEC_ID_NONE,
	125	+ .audio_codec = AV_CODEC_ID_FLAC,
	126	+ .video_codec = AV_CODEC_ID_NONE,
127	127	.write_header = flac_write_header,
128	128	.write_packet = flac_write_packet,
129	129	.write_trailer = flac_write_trailer,

libavformat/flic.c+2−2

@@ -110,7 +110,7 @@ static int flic_read_header(AVFormatContext *s) · 109 unmodified lines
110	110	return AVERROR(ENOMEM);
111	111	flic->video_stream_index = st->index;
112	112	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
113		− st->codec->codec_id = CODEC_ID_FLIC;
	113	+ st->codec->codec_id = AV_CODEC_ID_FLIC;
114	114	st->codec->codec_tag = 0; /* no fourcc */
115	115	st->codec->width = AV_RL16(&header[0x08]);
116	116	st->codec->height = AV_RL16(&header[0x0A]);
@@ -154,7 +154,7 @@ static int flic_read_header(AVFormatContext *s) · 37 unmodified lines
154	154	/* all audio frames are the same size, so use the size of the first chunk for block_align */
155	155	ast->codec->block_align = AV_RL32(&preamble[0]);
156	156	ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
157		− ast->codec->codec_id = CODEC_ID_PCM_U8;
	157	+ ast->codec->codec_id = AV_CODEC_ID_PCM_U8;
158	158	ast->codec->codec_tag = 0;
159	159	ast->codec->sample_rate = FLIC_TFTD_SAMPLE_RATE;
160	160	ast->codec->channels = 1;

libavformat/flvdec.c+42−42

@@ -93,34 +93,34 @@ static int flv_same_audio_codec(AVCodecContext *acodec, int flags) · 92 unmodified lines
93	93	switch(flv_codecid) {
94	94	//no distinction between S16 and S8 PCM codec flags
95	95	case FLV_CODECID_PCM:
96		− codec_id = bits_per_coded_sample == 8 ? CODEC_ID_PCM_U8 :
	96	+ codec_id = bits_per_coded_sample == 8 ? AV_CODEC_ID_PCM_U8 :
97	97	#if HAVE_BIGENDIAN
98		− CODEC_ID_PCM_S16BE;
	98	+ AV_CODEC_ID_PCM_S16BE;
99	99	#else
100		− CODEC_ID_PCM_S16LE;
	100	+ AV_CODEC_ID_PCM_S16LE;
101	101	#endif
102	102	return codec_id == acodec->codec_id;
103	103	case FLV_CODECID_PCM_LE:
104		− codec_id = bits_per_coded_sample == 8 ? CODEC_ID_PCM_U8 : CODEC_ID_PCM_S16LE;
	104	+ codec_id = bits_per_coded_sample == 8 ? AV_CODEC_ID_PCM_U8 : AV_CODEC_ID_PCM_S16LE;
105	105	return codec_id == acodec->codec_id;
106	106	case FLV_CODECID_AAC:
107		− return acodec->codec_id == CODEC_ID_AAC;
	107	+ return acodec->codec_id == AV_CODEC_ID_AAC;
108	108	case FLV_CODECID_ADPCM:
109		− return acodec->codec_id == CODEC_ID_ADPCM_SWF;
	109	+ return acodec->codec_id == AV_CODEC_ID_ADPCM_SWF;
110	110	case FLV_CODECID_SPEEX:
111		− return acodec->codec_id == CODEC_ID_SPEEX;
	111	+ return acodec->codec_id == AV_CODEC_ID_SPEEX;
112	112	case FLV_CODECID_MP3:
113		− return acodec->codec_id == CODEC_ID_MP3;
	113	+ return acodec->codec_id == AV_CODEC_ID_MP3;
114	114	case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
115	115	case FLV_CODECID_NELLYMOSER_16KHZ_MONO:
116	116	case FLV_CODECID_NELLYMOSER:
117		− return acodec->codec_id == CODEC_ID_NELLYMOSER;
	117	+ return acodec->codec_id == AV_CODEC_ID_NELLYMOSER;
118	118	case FLV_CODECID_PCM_MULAW:
119	119	return acodec->sample_rate == 8000 &&
120		− acodec->codec_id == CODEC_ID_PCM_MULAW;
	120	+ acodec->codec_id == AV_CODEC_ID_PCM_MULAW;
121	121	case FLV_CODECID_PCM_ALAW:
122	122	return acodec->sample_rate = 8000 &&
123		− acodec->codec_id == CODEC_ID_PCM_ALAW;
	123	+ acodec->codec_id == AV_CODEC_ID_PCM_ALAW;
124	124	default:
125	125	return acodec->codec_tag == (flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
126	126	}
@@ -132,40 +132,40 @@ static void flv_set_audio_codec(AVFormatContext s, AVStream astream, AVCodecCo · 5 unmodified lines
132	132	switch(flv_codecid) {
133	133	//no distinction between S16 and S8 PCM codec flags
134	134	case FLV_CODECID_PCM:
135		− acodec->codec_id = acodec->bits_per_coded_sample == 8 ? CODEC_ID_PCM_U8 :
	135	+ acodec->codec_id = acodec->bits_per_coded_sample == 8 ? AV_CODEC_ID_PCM_U8 :
136	136	#if HAVE_BIGENDIAN
137		− CODEC_ID_PCM_S16BE;
	137	+ AV_CODEC_ID_PCM_S16BE;
138	138	#else
139		− CODEC_ID_PCM_S16LE;
	139	+ AV_CODEC_ID_PCM_S16LE;
140	140	#endif
141	141	break;
142	142	case FLV_CODECID_PCM_LE:
143		− acodec->codec_id = acodec->bits_per_coded_sample == 8 ? CODEC_ID_PCM_U8 : CODEC_ID_PCM_S16LE; break;
144		− case FLV_CODECID_AAC : acodec->codec_id = CODEC_ID_AAC; break;
145		− case FLV_CODECID_ADPCM: acodec->codec_id = CODEC_ID_ADPCM_SWF; break;
	143	+ acodec->codec_id = acodec->bits_per_coded_sample == 8 ? AV_CODEC_ID_PCM_U8 : AV_CODEC_ID_PCM_S16LE; break;
	144	+ case FLV_CODECID_AAC : acodec->codec_id = AV_CODEC_ID_AAC; break;
	145	+ case FLV_CODECID_ADPCM: acodec->codec_id = AV_CODEC_ID_ADPCM_SWF; break;
146	146	case FLV_CODECID_SPEEX:
147		− acodec->codec_id = CODEC_ID_SPEEX;
	147	+ acodec->codec_id = AV_CODEC_ID_SPEEX;
148	148	acodec->sample_rate = 16000;
149	149	break;
150		− case FLV_CODECID_MP3 : acodec->codec_id = CODEC_ID_MP3 ; astream->need_parsing = AVSTREAM_PARSE_FULL; break;
	150	+ case FLV_CODECID_MP3 : acodec->codec_id = AV_CODEC_ID_MP3 ; astream->need_parsing = AVSTREAM_PARSE_FULL; break;
151	151	case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
152	152	acodec->sample_rate = 8000; //in case metadata does not otherwise declare samplerate
153		− acodec->codec_id = CODEC_ID_NELLYMOSER;
	153	+ acodec->codec_id = AV_CODEC_ID_NELLYMOSER;
154	154	break;
155	155	case FLV_CODECID_NELLYMOSER_16KHZ_MONO:
156	156	acodec->sample_rate = 16000;
157		− acodec->codec_id = CODEC_ID_NELLYMOSER;
	157	+ acodec->codec_id = AV_CODEC_ID_NELLYMOSER;
158	158	break;
159	159	case FLV_CODECID_NELLYMOSER:
160		− acodec->codec_id = CODEC_ID_NELLYMOSER;
	160	+ acodec->codec_id = AV_CODEC_ID_NELLYMOSER;
161	161	break;
162	162	case FLV_CODECID_PCM_MULAW:
163	163	acodec->sample_rate = 8000;
164		− acodec->codec_id = CODEC_ID_PCM_MULAW;
	164	+ acodec->codec_id = AV_CODEC_ID_PCM_MULAW;
165	165	break;
166	166	case FLV_CODECID_PCM_ALAW:
167	167	acodec->sample_rate = 8000;
168		− acodec->codec_id = CODEC_ID_PCM_ALAW;
	168	+ acodec->codec_id = AV_CODEC_ID_PCM_ALAW;
169	169	break;
170	170	default:
171	171	av_log(s, AV_LOG_INFO, "Unsupported audio codec (%x)\n", flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
@@ -182,17 +182,17 @@ static int flv_same_video_codec(AVCodecContext *vcodec, int flags) · 10 unmodified lines
182	182
183	183	switch (flv_codecid) {
184	184	case FLV_CODECID_H263:
185		− return vcodec->codec_id == CODEC_ID_FLV1;
	185	+ return vcodec->codec_id == AV_CODEC_ID_FLV1;
186	186	case FLV_CODECID_SCREEN:
187		− return vcodec->codec_id == CODEC_ID_FLASHSV;
	187	+ return vcodec->codec_id == AV_CODEC_ID_FLASHSV;
188	188	case FLV_CODECID_SCREEN2:
189		− return vcodec->codec_id == CODEC_ID_FLASHSV2;
	189	+ return vcodec->codec_id == AV_CODEC_ID_FLASHSV2;
190	190	case FLV_CODECID_VP6:
191		− return vcodec->codec_id == CODEC_ID_VP6F;
	191	+ return vcodec->codec_id == AV_CODEC_ID_VP6F;
192	192	case FLV_CODECID_VP6A:
193		− return vcodec->codec_id == CODEC_ID_VP6A;
	193	+ return vcodec->codec_id == AV_CODEC_ID_VP6A;
194	194	case FLV_CODECID_H264:
195		− return vcodec->codec_id == CODEC_ID_H264;
	195	+ return vcodec->codec_id == AV_CODEC_ID_H264;
196	196	default:
197	197	return vcodec->codec_tag == flv_codecid;
198	198	}
@@ -203,13 +203,13 @@ static int flv_same_video_codec(AVCodecContext *vcodec, int flags) · 4 unmodified lines
203	203	static int flv_set_video_codec(AVFormatContext s, AVStream vstream, int flv_codecid) {
204	204	AVCodecContext *vcodec = vstream->codec;
205	205	switch(flv_codecid) {
206		− case FLV_CODECID_H263 : vcodec->codec_id = CODEC_ID_FLV1 ; break;
207		− case FLV_CODECID_SCREEN: vcodec->codec_id = CODEC_ID_FLASHSV; break;
208		− case FLV_CODECID_SCREEN2: vcodec->codec_id = CODEC_ID_FLASHSV2; break;
209		− case FLV_CODECID_VP6 : vcodec->codec_id = CODEC_ID_VP6F ;
	206	+ case FLV_CODECID_H263 : vcodec->codec_id = AV_CODEC_ID_FLV1 ; break;
	207	+ case FLV_CODECID_SCREEN: vcodec->codec_id = AV_CODEC_ID_FLASHSV; break;
	208	+ case FLV_CODECID_SCREEN2: vcodec->codec_id = AV_CODEC_ID_FLASHSV2; break;
	209	+ case FLV_CODECID_VP6 : vcodec->codec_id = AV_CODEC_ID_VP6F ;
210	210	case FLV_CODECID_VP6A :
211	211	if(flv_codecid == FLV_CODECID_VP6A)
212		− vcodec->codec_id = CODEC_ID_VP6A;
	212	+ vcodec->codec_id = AV_CODEC_ID_VP6A;
213	213	if(vcodec->extradata_size != 1) {
214	214	vcodec->extradata_size = 1;
215	215	vcodec->extradata = av_malloc(1);
@@ -217,7 +217,7 @@ static int flv_set_video_codec(AVFormatContext s, AVStream vstream, int flv_co · 1 unmodified line
217	217	vcodec->extradata[0] = avio_r8(s->pb);
218	218	return 1; // 1 byte body size adjustment for flv_read_packet()
219	219	case FLV_CODECID_H264:
220		− vcodec->codec_id = CODEC_ID_H264;
	220	+ vcodec->codec_id = AV_CODEC_ID_H264;
221	221	return 3; // not 4, reading packet type will consume one byte
222	222	default:
223	223	av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid);
@@ -404,7 +404,7 @@ static int amf_parse_object(AVFormatContext s, AVStream astream, AVStream *vst · 180 unmodified lines
404	404	AVStream *st = create_stream(s, AVMEDIA_TYPE_DATA);
405	405	if (!st)
406	406	return AVERROR(ENOMEM);
407		− st->codec->codec_id = CODEC_ID_TEXT;
	407	+ st->codec->codec_id = AV_CODEC_ID_TEXT;
408	408	} else if (flv->trust_metadata) {
409	409	if (!strcmp(key, "videocodecid") && vcodec) {
410	410	flv_set_video_codec(s, vstream, num_val);
@@ -614,7 +614,7 @@ static int flv_data_packet(AVFormatContext s, AVPacket pkt, · 203 unmodified lines
614	614	st = create_stream(s, AVMEDIA_TYPE_DATA);
615	615	if (!st)
616	616	goto out;
617		− st->codec->codec_id = CODEC_ID_TEXT;
	617	+ st->codec->codec_id = AV_CODEC_ID_TEXT;
618	618	}
619	619
620	620	pkt->dts = dts;
@@ -769,11 +769,11 @@ static int flv_read_packet(AVFormatContext s, AVPacket pkt) · 148 unmodified lines
769	769	size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK);
770	770	}
771	771
772		− if (st->codec->codec_id == CODEC_ID_AAC \|\|
773		− st->codec->codec_id == CODEC_ID_H264) {
	772	+ if (st->codec->codec_id == AV_CODEC_ID_AAC \|\|
	773	+ st->codec->codec_id == AV_CODEC_ID_H264) {
774	774	int type = avio_r8(s->pb);
775	775	size--;
776		− if (st->codec->codec_id == CODEC_ID_H264) {
	776	+ if (st->codec->codec_id == AV_CODEC_ID_H264) {
777	777	int32_t cts = (avio_rb24(s->pb)+0xff800000)^0xff800000; // sign extension
778	778	pts = dts + cts;
779	779	if (cts < 0) { // dts are wrong
@@ -792,7 +792,7 @@ static int flv_read_packet(AVFormatContext s, AVPacket pkt) · 12 unmodified lines
792	792	}
793	793	if ((ret = flv_get_extradata(s, st, size)) < 0)
794	794	return ret;
795		− if (st->codec->codec_id == CODEC_ID_AAC) {
	795	+ if (st->codec->codec_id == AV_CODEC_ID_AAC) {
796	796	MPEG4AudioConfig cfg;
797	797	avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata,
798	798	st->codec->extradata_size * 8, 1);

libavformat/flvenc.c+45−45

@@ -31,27 +31,27 @@ · 30 unmodified lines
31	31	#include <assert.h>
32	32
33	33	static const AVCodecTag flv_video_codec_ids[] = {
34		− { CODEC_ID_FLV1, FLV_CODECID_H263 },
35		− { CODEC_ID_FLASHSV, FLV_CODECID_SCREEN },
36		− { CODEC_ID_FLASHSV2, FLV_CODECID_SCREEN2 },
37		− { CODEC_ID_VP6F, FLV_CODECID_VP6 },
38		− { CODEC_ID_VP6, FLV_CODECID_VP6 },
39		− { CODEC_ID_H264, FLV_CODECID_H264 },
40		− { CODEC_ID_NONE, 0 }
	34	+ { AV_CODEC_ID_FLV1, FLV_CODECID_H263 },
	35	+ { AV_CODEC_ID_FLASHSV, FLV_CODECID_SCREEN },
	36	+ { AV_CODEC_ID_FLASHSV2, FLV_CODECID_SCREEN2 },
	37	+ { AV_CODEC_ID_VP6F, FLV_CODECID_VP6 },
	38	+ { AV_CODEC_ID_VP6, FLV_CODECID_VP6 },
	39	+ { AV_CODEC_ID_H264, FLV_CODECID_H264 },
	40	+ { AV_CODEC_ID_NONE, 0 }
41	41	};
42	42
43	43	static const AVCodecTag flv_audio_codec_ids[] = {
44		− { CODEC_ID_MP3, FLV_CODECID_MP3 >> FLV_AUDIO_CODECID_OFFSET },
45		− { CODEC_ID_PCM_U8, FLV_CODECID_PCM >> FLV_AUDIO_CODECID_OFFSET },
46		− { CODEC_ID_PCM_S16BE, FLV_CODECID_PCM >> FLV_AUDIO_CODECID_OFFSET },
47		− { CODEC_ID_PCM_S16LE, FLV_CODECID_PCM_LE >> FLV_AUDIO_CODECID_OFFSET },
48		− { CODEC_ID_ADPCM_SWF, FLV_CODECID_ADPCM >> FLV_AUDIO_CODECID_OFFSET },
49		− { CODEC_ID_AAC, FLV_CODECID_AAC >> FLV_AUDIO_CODECID_OFFSET },
50		− { CODEC_ID_NELLYMOSER, FLV_CODECID_NELLYMOSER >> FLV_AUDIO_CODECID_OFFSET },
51		− { CODEC_ID_PCM_MULAW, FLV_CODECID_PCM_MULAW >> FLV_AUDIO_CODECID_OFFSET },
52		− { CODEC_ID_PCM_ALAW, FLV_CODECID_PCM_ALAW >> FLV_AUDIO_CODECID_OFFSET },
53		− { CODEC_ID_SPEEX, FLV_CODECID_SPEEX >> FLV_AUDIO_CODECID_OFFSET },
54		− { CODEC_ID_NONE, 0 }
	44	+ { AV_CODEC_ID_MP3, FLV_CODECID_MP3 >> FLV_AUDIO_CODECID_OFFSET },
	45	+ { AV_CODEC_ID_PCM_U8, FLV_CODECID_PCM >> FLV_AUDIO_CODECID_OFFSET },
	46	+ { AV_CODEC_ID_PCM_S16BE, FLV_CODECID_PCM >> FLV_AUDIO_CODECID_OFFSET },
	47	+ { AV_CODEC_ID_PCM_S16LE, FLV_CODECID_PCM_LE >> FLV_AUDIO_CODECID_OFFSET },
	48	+ { AV_CODEC_ID_ADPCM_SWF, FLV_CODECID_ADPCM >> FLV_AUDIO_CODECID_OFFSET },
	49	+ { AV_CODEC_ID_AAC, FLV_CODECID_AAC >> FLV_AUDIO_CODECID_OFFSET },
	50	+ { AV_CODEC_ID_NELLYMOSER, FLV_CODECID_NELLYMOSER >> FLV_AUDIO_CODECID_OFFSET },
	51	+ { AV_CODEC_ID_PCM_MULAW, FLV_CODECID_PCM_MULAW >> FLV_AUDIO_CODECID_OFFSET },
	52	+ { AV_CODEC_ID_PCM_ALAW, FLV_CODECID_PCM_ALAW >> FLV_AUDIO_CODECID_OFFSET },
	53	+ { AV_CODEC_ID_SPEEX, FLV_CODECID_SPEEX >> FLV_AUDIO_CODECID_OFFSET },
	54	+ { AV_CODEC_ID_NONE, 0 }
55	55	};
56	56
57	57	typedef struct FLVContext {
@@ -71,10 +71,10 @@ static int get_audio_flags(AVFormatContext s, AVCodecContext enc) · 13 unmodified lines
71	71	int flags = (enc->bits_per_coded_sample == 16) ? FLV_SAMPLESSIZE_16BIT
72	72	: FLV_SAMPLESSIZE_8BIT;
73	73
74		− if (enc->codec_id == CODEC_ID_AAC) // specs force these parameters
	74	+ if (enc->codec_id == AV_CODEC_ID_AAC) // specs force these parameters
75	75	return FLV_CODECID_AAC \| FLV_SAMPLERATE_44100HZ \|
76	76	FLV_SAMPLESSIZE_16BIT \| FLV_STEREO;
77		− else if (enc->codec_id == CODEC_ID_SPEEX) {
	77	+ else if (enc->codec_id == AV_CODEC_ID_SPEEX) {
78	78	if (enc->sample_rate != 16000) {
79	79	av_log(s, AV_LOG_ERROR,
80	80	"flv only supports wideband (16kHz) Speex audio\n");
@@ -99,7 +99,7 @@ static int get_audio_flags(AVFormatContext s, AVCodecContext enc) · 18 unmodified lines
99	99	case 16000: // nellymoser only
100	100	case 8000: // nellymoser only
101	101	case 5512: // not MP3
102		− if (enc->codec_id != CODEC_ID_MP3) {
	102	+ if (enc->codec_id != AV_CODEC_ID_MP3) {
103	103	flags \|= FLV_SAMPLERATE_SPECIAL;
104	104	break;
105	105	}
@@ -115,22 +115,22 @@ static int get_audio_flags(AVFormatContext s, AVCodecContext enc) · 9 unmodified lines
115	115	flags \|= FLV_STEREO;
116	116
117	117	switch (enc->codec_id) {
118		− case CODEC_ID_MP3:
	118	+ case AV_CODEC_ID_MP3:
119	119	flags \|= FLV_CODECID_MP3 \| FLV_SAMPLESSIZE_16BIT;
120	120	break;
121		− case CODEC_ID_PCM_U8:
	121	+ case AV_CODEC_ID_PCM_U8:
122	122	flags \|= FLV_CODECID_PCM \| FLV_SAMPLESSIZE_8BIT;
123	123	break;
124		− case CODEC_ID_PCM_S16BE:
	124	+ case AV_CODEC_ID_PCM_S16BE:
125	125	flags \|= FLV_CODECID_PCM \| FLV_SAMPLESSIZE_16BIT;
126	126	break;
127		− case CODEC_ID_PCM_S16LE:
	127	+ case AV_CODEC_ID_PCM_S16LE:
128	128	flags \|= FLV_CODECID_PCM_LE \| FLV_SAMPLESSIZE_16BIT;
129	129	break;
130		− case CODEC_ID_ADPCM_SWF:
	130	+ case AV_CODEC_ID_ADPCM_SWF:
131	131	flags \|= FLV_CODECID_ADPCM \| FLV_SAMPLESSIZE_16BIT;
132	132	break;
133		− case CODEC_ID_NELLYMOSER:
	133	+ case AV_CODEC_ID_NELLYMOSER:
134	134	if (enc->sample_rate == 8000)
135	135	flags \|= FLV_CODECID_NELLYMOSER_8KHZ_MONO \| FLV_SAMPLESSIZE_16BIT;
136	136	else if (enc->sample_rate == 16000)
@@ -138,10 +138,10 @@ static int get_audio_flags(AVFormatContext s, AVCodecContext enc) · 1 unmodified line
138	138	else
139	139	flags \|= FLV_CODECID_NELLYMOSER \| FLV_SAMPLESSIZE_16BIT;
140	140	break;
141		− case CODEC_ID_PCM_MULAW:
	141	+ case AV_CODEC_ID_PCM_MULAW:
142	142	flags = FLV_CODECID_PCM_MULAW \| FLV_SAMPLERATE_SPECIAL \| FLV_SAMPLESSIZE_16BIT;
143	143	break;
144		− case CODEC_ID_PCM_ALAW:
	144	+ case AV_CODEC_ID_PCM_ALAW:
145	145	flags = FLV_CODECID_PCM_ALAW \| FLV_SAMPLERATE_SPECIAL \| FLV_SAMPLESSIZE_16BIT;
146	146	break;
147	147	case 0:
@@ -220,7 +220,7 @@ static int flv_write_header(AVFormatContext *s) · 72 unmodified lines
220	220	return AVERROR_INVALIDDATA;
221	221	break;
222	222	case AVMEDIA_TYPE_DATA:
223		− if (enc->codec_id != CODEC_ID_TEXT) {
	223	+ if (enc->codec_id != AV_CODEC_ID_TEXT) {
224	224	av_log(s, AV_LOG_ERROR, "codec not compatible with flv\n");
225	225	return AVERROR_INVALIDDATA;
226	226	}
@@ -312,7 +312,7 @@ static int flv_write_header(AVFormatContext *s) · 85 unmodified lines
312	312	put_amf_double(pb, audio_enc->sample_rate);
313	313
314	314	put_amf_string(pb, "audiosamplesize");
315		− put_amf_double(pb, audio_enc->codec_id == CODEC_ID_PCM_U8 ? 8 : 16);
	315	+ put_amf_double(pb, audio_enc->codec_id == AV_CODEC_ID_PCM_U8 ? 8 : 16);
316	316
317	317	put_amf_string(pb, "stereo");
318	318	put_amf_bool(pb, audio_enc->channels == 2);
@@ -353,7 +353,7 @@ static int flv_write_header(AVFormatContext *s) · 34 unmodified lines
353	353
354	354	for (i = 0; i < s->nb_streams; i++) {
355	355	AVCodecContext *enc = s->streams[i]->codec;
356		− if (enc->codec_id == CODEC_ID_AAC \|\| enc->codec_id == CODEC_ID_H264) {
	356	+ if (enc->codec_id == AV_CODEC_ID_AAC \|\| enc->codec_id == AV_CODEC_ID_H264) {
357	357	int64_t pos;
358	358	avio_w8(pb, enc->codec_type == AVMEDIA_TYPE_VIDEO ?
359	359	FLV_TAG_TYPE_VIDEO : FLV_TAG_TYPE_AUDIO);
@@ -362,7 +362,7 @@ static int flv_write_header(AVFormatContext *s) · 2 unmodified lines
362	362	avio_w8(pb, 0); // ts ext
363	363	avio_wb24(pb, 0); // streamid
364	364	pos = avio_tell(pb);
365		− if (enc->codec_id == CODEC_ID_AAC) {
	365	+ if (enc->codec_id == AV_CODEC_ID_AAC) {
366	366	avio_w8(pb, get_audio_flags(s, enc));
367	367	avio_w8(pb, 0); // AAC sequence header
368	368	avio_write(pb, enc->extradata, enc->extradata_size);
@@ -396,7 +396,7 @@ static int flv_write_trailer(AVFormatContext *s) · 27 unmodified lines
396	396	AVCodecContext *enc = s->streams[i]->codec;
397	397	FLVStreamContext *sc = s->streams[i]->priv_data;
398	398	if (enc->codec_type == AVMEDIA_TYPE_VIDEO &&
399		− enc->codec_id == CODEC_ID_H264)
	399	+ enc->codec_id == AV_CODEC_ID_H264)
400	400	put_avc_eos_tag(pb, sc->last_ts);
401	401	}
402	402
@@ -426,10 +426,10 @@ static int flv_write_packet(AVFormatContext s, AVPacket pkt) · 23 unmodified lines
426	426	// av_log(s, AV_LOG_DEBUG, "type:%d pts: %"PRId64" size:%d\n",
427	427	// enc->codec_type, timestamp, size);
428	428
429		− if (enc->codec_id == CODEC_ID_VP6 \|\| enc->codec_id == CODEC_ID_VP6F \|\|
430		− enc->codec_id == CODEC_ID_AAC)
	429	+ if (enc->codec_id == AV_CODEC_ID_VP6 \|\| enc->codec_id == AV_CODEC_ID_VP6F \|\|
	430	+ enc->codec_id == AV_CODEC_ID_AAC)
431	431	flags_size = 2;
432		− else if (enc->codec_id == CODEC_ID_H264)
	432	+ else if (enc->codec_id == AV_CODEC_ID_H264)
433	433	flags_size = 5;
434	434	else
435	435	flags_size = 1;
@@ -462,7 +462,7 @@ static int flv_write_packet(AVFormatContext s, AVPacket pkt) · 26 unmodified lines
462	462	return AVERROR(EINVAL);
463	463	}
464	464
465		− if (enc->codec_id == CODEC_ID_H264)
	465	+ if (enc->codec_id == AV_CODEC_ID_H264)
466	466	/* check if extradata looks like MP4 */
467	467	if (enc->extradata_size > 0 && (uint8_t)enc->extradata != 1)
468	468	if (ff_avc_parse_nal_units_buf(pkt->data, &data, &size) < 0)
@@ -480,7 +480,7 @@ static int flv_write_packet(AVFormatContext s, AVPacket pkt) · 11 unmodified lines
480	480	ts = pkt->dts + flv->delay; // add delay to force positive dts
481	481
482	482	/* check Speex packet duration */
483		− if (enc->codec_id == CODEC_ID_SPEEX && ts - sc->last_ts > 160)
	483	+ if (enc->codec_id == AV_CODEC_ID_SPEEX && ts - sc->last_ts > 160)
484	484	av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
485	485	"8 frames per packet. Adobe Flash "
486	486	"Player cannot handle this!\n");
@@ -516,13 +516,13 @@ static int flv_write_packet(AVFormatContext s, AVPacket pkt) · 29 unmodified lines
516	516	avio_wb32(pb, data_size + 11);
517	517	} else {
518	518	avio_w8(pb,flags);
519		− if (enc->codec_id == CODEC_ID_VP6)
	519	+ if (enc->codec_id == AV_CODEC_ID_VP6)
520	520	avio_w8(pb, 0);
521		− if (enc->codec_id == CODEC_ID_VP6F)
	521	+ if (enc->codec_id == AV_CODEC_ID_VP6F)
522	522	avio_w8(pb, enc->extradata_size ? enc->extradata[0] : 0);
523		− else if (enc->codec_id == CODEC_ID_AAC)
	523	+ else if (enc->codec_id == AV_CODEC_ID_AAC)
524	524	avio_w8(pb, 1); // AAC raw
525		− else if (enc->codec_id == CODEC_ID_H264) {
	525	+ else if (enc->codec_id == AV_CODEC_ID_H264) {
526	526	avio_w8(pb, 1); // AVC NALU
527	527	avio_wb24(pb, pkt->pts - pkt->dts);
528	528	}
@@ -546,8 +546,8 @@ AVOutputFormat ff_flv_muxer = { · 17 unmodified lines
546	546	.mime_type = "video/x-flv",
547	547	.extensions = "flv",
548	548	.priv_data_size = sizeof(FLVContext),
549		− .audio_codec = CONFIG_LIBMP3LAME ? CODEC_ID_MP3 : CODEC_ID_ADPCM_SWF,
550		− .video_codec = CODEC_ID_FLV1,
	549	+ .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF,
	550	+ .video_codec = AV_CODEC_ID_FLV1,
551	551	.write_header = flv_write_header,
552	552	.write_packet = flv_write_packet,
553	553	.write_trailer = flv_write_trailer,

libavformat/framecrcenc.c+2−2

@@ -39,8 +39,8 @@ AVOutputFormat ff_framecrc_muxer = { · 38 unmodified lines
39	39	.name = "framecrc",
40	40	.long_name = NULL_IF_CONFIG_SMALL("framecrc testing"),
41	41	.extensions = "",
42		− .audio_codec = CODEC_ID_PCM_S16LE,
43		− .video_codec = CODEC_ID_RAWVIDEO,
	42	+ .audio_codec = AV_CODEC_ID_PCM_S16LE,
	43	+ .video_codec = AV_CODEC_ID_RAWVIDEO,
44	44	.write_header = ff_framehash_write_header,
45	45	.write_packet = framecrc_write_packet,
46	46	.flags = AVFMT_VARIABLE_FPS \| AVFMT_TS_NONSTRICT,

libavformat/g723_1.c+1−1

@@ -39,7 +39,7 @@ static int g723_1_init(AVFormatContext *s) · 38 unmodified lines
39	39	return AVERROR(ENOMEM);
40	40
41	41	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
42		− st->codec->codec_id = CODEC_ID_G723_1;
	42	+ st->codec->codec_id = AV_CODEC_ID_G723_1;
43	43	st->codec->channel_layout = AV_CH_LAYOUT_MONO;
44	44	st->codec->channels = 1;
45	45	st->codec->sample_rate = 8000;

libavformat/gif.c+2−2

@@ -372,8 +372,8 @@ AVOutputFormat ff_gif_muxer = { · 371 unmodified lines
372	372	.mime_type = "image/gif",
373	373	.extensions = "gif",
374	374	.priv_data_size = sizeof(GIFContext),
375		− .audio_codec = CODEC_ID_NONE,
376		− .video_codec = CODEC_ID_RAWVIDEO,
	375	+ .audio_codec = AV_CODEC_ID_NONE,
	376	+ .video_codec = AV_CODEC_ID_RAWVIDEO,
377	377	.write_header = gif_write_header,
378	378	.write_packet = gif_write_packet,
379	379	.write_trailer = gif_write_trailer,

libavformat/gsmdec.c+1−1

@@ -94,6 +94,6 @@ AVInputFormat ff_gsm_demuxer = { · 93 unmodified lines
94	94	.read_packet = gsm_read_packet,
95	95	.flags = AVFMT_GENERIC_INDEX,
96	96	.extensions = "gsm",
97		− .raw_codec_id = CODEC_ID_GSM,
	97	+ .raw_codec_id = AV_CODEC_ID_GSM,
98	98	.priv_class = &class,
99	99	};

libavformat/gxf.c+13−13

@@ -89,34 +89,34 @@ static int get_sindex(AVFormatContext *s, int id, int format) { · 88 unmodified lines
89	89	case 3:
90	90	case 4:
91	91	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
92		− st->codec->codec_id = CODEC_ID_MJPEG;
	92	+ st->codec->codec_id = AV_CODEC_ID_MJPEG;
93	93	break;
94	94	case 13:
95	95	case 15:
96	96	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
97		− st->codec->codec_id = CODEC_ID_DVVIDEO;
	97	+ st->codec->codec_id = AV_CODEC_ID_DVVIDEO;
98	98	break;
99	99	case 14:
100	100	case 16:
101	101	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
102		− st->codec->codec_id = CODEC_ID_DVVIDEO;
	102	+ st->codec->codec_id = AV_CODEC_ID_DVVIDEO;
103	103	break;
104	104	case 11:
105	105	case 12:
106	106	case 20:
107	107	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
108		− st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
	108	+ st->codec->codec_id = AV_CODEC_ID_MPEG2VIDEO;
109	109	st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
110	110	break;
111	111	case 22:
112	112	case 23:
113	113	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
114		− st->codec->codec_id = CODEC_ID_MPEG1VIDEO;
	114	+ st->codec->codec_id = AV_CODEC_ID_MPEG1VIDEO;
115	115	st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
116	116	break;
117	117	case 9:
118	118	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
119		− st->codec->codec_id = CODEC_ID_PCM_S24LE;
	119	+ st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
120	120	st->codec->channels = 1;
121	121	st->codec->sample_rate = 48000;
122	122	st->codec->bit_rate = 3 * 1 * 48000 * 8;
@@ -125,7 +125,7 @@ static int get_sindex(AVFormatContext *s, int id, int format) { · 2 unmodified lines
125	125	break;
126	126	case 10:
127	127	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
128		− st->codec->codec_id = CODEC_ID_PCM_S16LE;
	128	+ st->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
129	129	st->codec->channels = 1;
130	130	st->codec->sample_rate = 48000;
131	131	st->codec->bit_rate = 2 * 1 * 48000 * 8;
@@ -134,7 +134,7 @@ static int get_sindex(AVFormatContext *s, int id, int format) { · 2 unmodified lines
134	134	break;
135	135	case 17:
136	136	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
137		− st->codec->codec_id = CODEC_ID_AC3;
	137	+ st->codec->codec_id = AV_CODEC_ID_AC3;
138	138	st->codec->channels = 2;
139	139	st->codec->sample_rate = 48000;
140	140	break;
@@ -143,11 +143,11 @@ static int get_sindex(AVFormatContext *s, int id, int format) { · 2 unmodified lines
143	143	case 8:
144	144	case 24:
145	145	st->codec->codec_type = AVMEDIA_TYPE_DATA;
146		− st->codec->codec_id = CODEC_ID_NONE;
	146	+ st->codec->codec_id = AV_CODEC_ID_NONE;
147	147	break;
148	148	default:
149	149	st->codec->codec_type = AVMEDIA_TYPE_UNKNOWN;
150		− st->codec->codec_id = CODEC_ID_NONE;
	150	+ st->codec->codec_id = AV_CODEC_ID_NONE;
151	151	break;
152	152	}
153	153	return s->nb_streams - 1;
@@ -459,8 +459,8 @@ static int gxf_packet(AVFormatContext s, AVPacket pkt) { · 305 unmodified lines
459	459	avio_rb32(pb); // "timeline" field number
460	460	avio_r8(pb); // flags
461	461	avio_r8(pb); // reserved
462		− if (st->codec->codec_id == CODEC_ID_PCM_S24LE \|\|
463		− st->codec->codec_id == CODEC_ID_PCM_S16LE) {
	462	+ if (st->codec->codec_id == AV_CODEC_ID_PCM_S24LE \|\|
	463	+ st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
464	464	int first = field_info >> 16;
465	465	int last = field_info & 0xffff; // last is exclusive
466	466	int bps = av_get_bits_per_sample(st->codec->codec_id)>>3;
@@ -478,7 +478,7 @@ static int gxf_packet(AVFormatContext s, AVPacket pkt) { · 11 unmodified lines
478	478	pkt->dts = field_nr;
479	479
480	480	//set duration manually for DV or else lavf misdetects the frame rate
481		− if (st->codec->codec_id == CODEC_ID_DVVIDEO)
	481	+ if (st->codec->codec_id == AV_CODEC_ID_DVVIDEO)
482	482	pkt->duration = si->fields_per_frame;
483	483
484	484	return ret;

libavformat/gxfenc.c+32−32

@@ -81,22 +81,22 @@ static const struct { · 80 unmodified lines
81	81	};
82	82
83	83	static const AVCodecTag gxf_media_types[] = {
84		− { CODEC_ID_MJPEG , 3 }, /* NTSC */
85		− { CODEC_ID_MJPEG , 4 }, /* PAL */
86		− { CODEC_ID_PCM_S24LE , 9 },
87		− { CODEC_ID_PCM_S16LE , 10 },
88		− { CODEC_ID_MPEG2VIDEO, 11 }, /* NTSC */
89		− { CODEC_ID_MPEG2VIDEO, 12 }, /* PAL */
90		− { CODEC_ID_DVVIDEO , 13 }, /* NTSC */
91		− { CODEC_ID_DVVIDEO , 14 }, /* PAL */
92		− { CODEC_ID_DVVIDEO , 15 }, /* 50M NTSC */
93		− { CODEC_ID_DVVIDEO , 16 }, /* 50M PAL */
94		− { CODEC_ID_AC3 , 17 },
95		− //{ CODEC_ID_NONE, , 18 }, /* Non compressed 24 bit audio */
96		− { CODEC_ID_MPEG2VIDEO, 20 }, /* MPEG HD */
97		− { CODEC_ID_MPEG1VIDEO, 22 }, /* NTSC */
98		− { CODEC_ID_MPEG1VIDEO, 23 }, /* PAL */
99		− { CODEC_ID_NONE, 0 },
	84	+ { AV_CODEC_ID_MJPEG , 3 }, /* NTSC */
	85	+ { AV_CODEC_ID_MJPEG , 4 }, /* PAL */
	86	+ { AV_CODEC_ID_PCM_S24LE , 9 },
	87	+ { AV_CODEC_ID_PCM_S16LE , 10 },
	88	+ { AV_CODEC_ID_MPEG2VIDEO, 11 }, /* NTSC */
	89	+ { AV_CODEC_ID_MPEG2VIDEO, 12 }, /* PAL */
	90	+ { AV_CODEC_ID_DVVIDEO , 13 }, /* NTSC */
	91	+ { AV_CODEC_ID_DVVIDEO , 14 }, /* PAL */
	92	+ { AV_CODEC_ID_DVVIDEO , 15 }, /* 50M NTSC */
	93	+ { AV_CODEC_ID_DVVIDEO , 16 }, /* 50M PAL */
	94	+ { AV_CODEC_ID_AC3 , 17 },
	95	+ //{ AV_CODEC_ID_NONE, , 18 }, /* Non compressed 24 bit audio */
	96	+ { AV_CODEC_ID_MPEG2VIDEO, 20 }, /* MPEG HD */
	97	+ { AV_CODEC_ID_MPEG1VIDEO, 22 }, /* NTSC */
	98	+ { AV_CODEC_ID_MPEG1VIDEO, 23 }, /* PAL */
	99	+ { AV_CODEC_ID_NONE, 0 },
100	100	};
101	101
102	102	#define SERVER_PATH "EXT:/PDR/default/"
@@ -480,9 +480,9 @@ static int gxf_write_umf_media_mpeg(AVIOContext pb, AVStream st) · 377 unmodified lines
480	480	avio_wl32(pb, 1); /* I picture per GOP */
481	481	avio_wl32(pb, sc->p_per_gop);
482	482	avio_wl32(pb, sc->b_per_i_or_p);
483		− if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
	483	+ if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO)
484	484	avio_wl32(pb, 2);
485		− else if (st->codec->codec_id == CODEC_ID_MPEG1VIDEO)
	485	+ else if (st->codec->codec_id == AV_CODEC_ID_MPEG1VIDEO)
486	486	avio_wl32(pb, 1);
487	487	else
488	488	avio_wl32(pb, 0);
@@ -565,14 +565,14 @@ static int gxf_write_umf_media_description(AVFormatContext *s) · 76 unmodified lines
565	565	else {
566	566	AVStream *st = s->streams[i];
567	567	switch (st->codec->codec_id) {
568		− case CODEC_ID_MPEG1VIDEO:
569		− case CODEC_ID_MPEG2VIDEO:
	568	+ case AV_CODEC_ID_MPEG1VIDEO:
	569	+ case AV_CODEC_ID_MPEG2VIDEO:
570	570	gxf_write_umf_media_mpeg(pb, st);
571	571	break;
572		− case CODEC_ID_PCM_S16LE:
	572	+ case AV_CODEC_ID_PCM_S16LE:
573	573	gxf_write_umf_media_audio(pb, sc);
574	574	break;
575		− case CODEC_ID_DVVIDEO:
	575	+ case AV_CODEC_ID_DVVIDEO:
576	576	gxf_write_umf_media_dv(pb, sc);
577	577	break;
578	578	}
@@ -647,7 +647,7 @@ static int gxf_write_header(AVFormatContext *s) · 68 unmodified lines
647	647
648	648	sc->media_type = ff_codec_get_tag(gxf_media_types, st->codec->codec_id);
649	649	if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
650		− if (st->codec->codec_id != CODEC_ID_PCM_S16LE) {
	650	+ if (st->codec->codec_id != AV_CODEC_ID_PCM_S16LE) {
651	651	av_log(s, AV_LOG_ERROR, "only 16 BIT PCM LE allowed for now\n");
652	652	return -1;
653	653	}
@@ -700,24 +700,24 @@ static int gxf_write_header(AVFormatContext *s) · 46 unmodified lines
700	700	vsc = sc;
701	701
702	702	switch (st->codec->codec_id) {
703		− case CODEC_ID_MJPEG:
	703	+ case AV_CODEC_ID_MJPEG:
704	704	sc->track_type = 1;
705	705	gxf->flags \|= 0x00004000;
706	706	media_info = 'J';
707	707	break;
708		− case CODEC_ID_MPEG1VIDEO:
	708	+ case AV_CODEC_ID_MPEG1VIDEO:
709	709	sc->track_type = 9;
710	710	gxf->mpeg_tracks++;
711	711	media_info = 'L';
712	712	break;
713		− case CODEC_ID_MPEG2VIDEO:
	713	+ case AV_CODEC_ID_MPEG2VIDEO:
714	714	sc->first_gop_closed = -1;
715	715	sc->track_type = 4;
716	716	gxf->mpeg_tracks++;
717	717	gxf->flags \|= 0x00008000;
718	718	media_info = 'M';
719	719	break;
720		− case CODEC_ID_DVVIDEO:
	720	+ case AV_CODEC_ID_DVVIDEO:
721	721	if (st->codec->pix_fmt == PIX_FMT_YUV422P) {
722	722	sc->media_type += 2;
723	723	sc->track_type = 6;
@@ -830,7 +830,7 @@ static int gxf_write_media_preamble(AVFormatContext s, AVPacket pkt, int size) · 106 unmodified lines
830	830	if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
831	831	avio_wb16(pb, 0);
832	832	avio_wb16(pb, size / 2);
833		− } else if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO) {
	833	+ } else if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
834	834	int frame_type = gxf_parse_mpeg_frame(sc, pkt->data, pkt->size);
835	835	if (frame_type == AV_PICTURE_TYPE_I) {
836	836	avio_w8(pb, 0x0d);
@@ -843,7 +843,7 @@ static int gxf_write_media_preamble(AVFormatContext s, AVPacket pkt, int size) · 6 unmodified lines
843	843	sc->pframes++;
844	844	}
845	845	avio_wb24(pb, size);
846		− } else if (st->codec->codec_id == CODEC_ID_DVVIDEO) {
	846	+ } else if (st->codec->codec_id == AV_CODEC_ID_DVVIDEO) {
847	847	avio_w8(pb, size / 4096);
848	848	avio_wb24(pb, 0);
849	849	} else
@@ -864,7 +864,7 @@ static int gxf_write_packet(AVFormatContext s, AVPacket pkt) · 14 unmodified lines
864	864	int packet_start_offset = avio_tell(pb) / 1024;
865	865
866	866	gxf_write_packet_header(pb, PKT_MEDIA);
867		− if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO && pkt->size % 4) /* MPEG-2 frames must be padded */
	867	+ if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO && pkt->size % 4) /* MPEG-2 frames must be padded */
868	868	padding = 4 - pkt->size % 4;
869	869	else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
870	870	padding = GXF_AUDIO_PACKET_SIZE - pkt->size;
@@ -933,8 +933,8 @@ AVOutputFormat ff_gxf_muxer = { · 62 unmodified lines
933	933	.long_name = NULL_IF_CONFIG_SMALL("GXF (General eXchange Format)"),
934	934	.extensions = "gxf",
935	935	.priv_data_size = sizeof(GXFContext),
936		− .audio_codec = CODEC_ID_PCM_S16LE,
937		− .video_codec = CODEC_ID_MPEG2VIDEO,
	936	+ .audio_codec = AV_CODEC_ID_PCM_S16LE,
	937	+ .video_codec = AV_CODEC_ID_MPEG2VIDEO,
938	938	.write_header = gxf_write_header,
939	939	.write_packet = gxf_write_packet,
940	940	.write_trailer = gxf_write_trailer,

libavformat/h261dec.c+1−1

@@ -62,4 +62,4 @@ static int h261_probe(AVProbeData *p) · 61 unmodified lines
62	62	return 0;
63	63	}
64	64
65		−FF_DEF_RAWVIDEO_DEMUXER(h261, "raw H.261", h261_probe, "h261", CODEC_ID_H261)
	65	+FF_DEF_RAWVIDEO_DEMUXER(h261, "raw H.261", h261_probe, "h261", AV_CODEC_ID_H261)

libavformat/h263dec.c+1−1

@@ -64,4 +64,4 @@ static int h263_probe(AVProbeData *p) · 63 unmodified lines
64	64	return 0;
65	65	}
66	66
67		−FF_DEF_RAWVIDEO_DEMUXER(h263, "raw H.263", h263_probe, NULL, CODEC_ID_H263)
	67	+FF_DEF_RAWVIDEO_DEMUXER(h263, "raw H.263", h263_probe, NULL, AV_CODEC_ID_H263)

libavformat/h264dec.c+1−1

@@ -67,4 +67,4 @@ static int h264_probe(AVProbeData *p) · 66 unmodified lines
67	67	return 0;
68	68	}
69	69
70		−FF_DEF_RAWVIDEO_DEMUXER(h264 , "raw H.264 video", h264_probe, "h26l,h264,264", CODEC_ID_H264)
	70	+FF_DEF_RAWVIDEO_DEMUXER(h264 , "raw H.264 video", h264_probe, "h26l,h264,264", AV_CODEC_ID_H264)

libavformat/id3v2.c+10−10

@@ -112,13 +112,13 @@ const char *ff_id3v2_picture_types[21] = { · 111 unmodified lines
112	112	};
113	113
114	114	const CodecMime ff_id3v2_mime_tags[] = {
115		− {"image/gif" , CODEC_ID_GIF},
116		− {"image/jpeg", CODEC_ID_MJPEG},
117		− {"image/jpg", CODEC_ID_MJPEG},
118		− {"image/png" , CODEC_ID_PNG},
119		− {"image/tiff", CODEC_ID_TIFF},
120		− {"image/bmp", CODEC_ID_BMP},
121		− {"", CODEC_ID_NONE},
	115	+ {"image/gif" , AV_CODEC_ID_GIF},
	116	+ {"image/jpeg", AV_CODEC_ID_MJPEG},
	117	+ {"image/jpg", AV_CODEC_ID_MJPEG},
	118	+ {"image/png" , AV_CODEC_ID_PNG},
	119	+ {"image/tiff", AV_CODEC_ID_TIFF},
	120	+ {"image/bmp", AV_CODEC_ID_BMP},
	121	+ {"", AV_CODEC_ID_NONE},
122	122	};
123	123
124	124	int ff_id3v2_match(const uint8_t buf, const char magic)
@@ -429,7 +429,7 @@ static void read_apic(AVFormatContext s, AVIOContext pb, int taglen, char *tag · 304 unmodified lines
429	429	int enc, pic_type;
430	430	char mimetype[64];
431	431	const CodecMime *mime = ff_id3v2_mime_tags;
432		− enum CodecID id = CODEC_ID_NONE;
	432	+ enum AVCodecID id = AV_CODEC_ID_NONE;
433	433	ID3v2ExtraMetaAPIC *apic = NULL;
434	434	ID3v2ExtraMeta *new_extra = NULL;
435	435	int64_t end = avio_tell(pb) + taglen;
@@ -447,14 +447,14 @@ static void read_apic(AVFormatContext s, AVIOContext pb, int taglen, char *tag · 11 unmodified lines
447	447
448	448	/* mimetype */
449	449	taglen -= avio_get_str(pb, taglen, mimetype, sizeof(mimetype));
450		− while (mime->id != CODEC_ID_NONE) {
	450	+ while (mime->id != AV_CODEC_ID_NONE) {
451	451	if (!strncmp(mime->str, mimetype, sizeof(mimetype))) {
452	452	id = mime->id;
453	453	break;
454	454	}
455	455	mime++;
456	456	}
457		− if (id == CODEC_ID_NONE) {
	457	+ if (id == AV_CODEC_ID_NONE) {
458	458	av_log(s, AV_LOG_WARNING, "Unknown attached picture mimetype: %s, skipping.\n", mimetype);
459	459	goto fail;
460	460	}

libavformat/id3v2.h+1−1

@@ -71,7 +71,7 @@ typedef struct ID3v2ExtraMetaAPIC { · 70 unmodified lines
71	71	int len;
72	72	const char *type;
73	73	uint8_t *description;
74		− enum CodecID id;
	74	+ enum AVCodecID id;
75	75	} ID3v2ExtraMetaAPIC;
76	76
77	77	/**

libavformat/id3v2enc.c+1−1

@@ -169,7 +169,7 @@ int ff_id3v2_write_apic(AVFormatContext s, ID3v2EncContext id3, AVPacket *pkt) · 168 unmodified lines
169	169	int i, len, type = 0;
170	170
171	171	/* get the mimetype*/
172		− while (mime->id != CODEC_ID_NONE) {
	172	+ while (mime->id != AV_CODEC_ID_NONE) {
173	173	if (mime->id == st->codec->codec_id) {
174	174	mimetype = mime->str;
175	175	break;

libavformat/idcin.c+3−3

@@ -159,7 +159,7 @@ static int idcin_read_header(AVFormatContext *s) · 158 unmodified lines
159	159	avpriv_set_pts_info(st, 33, 1, IDCIN_FPS);
160	160	idcin->video_stream_index = st->index;
161	161	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
162		− st->codec->codec_id = CODEC_ID_IDCIN;
	162	+ st->codec->codec_id = AV_CODEC_ID_IDCIN;
163	163	st->codec->codec_tag = 0; /* no fourcc */
164	164	st->codec->width = width;
165	165	st->codec->height = height;
@@ -187,9 +187,9 @@ static int idcin_read_header(AVFormatContext *s) · 21 unmodified lines
187	187	st->codec->bit_rate = sample_rate * bytes_per_sample * 8 * channels;
188	188	st->codec->block_align = bytes_per_sample * channels;
189	189	if (bytes_per_sample == 1)
190		− st->codec->codec_id = CODEC_ID_PCM_U8;
	190	+ st->codec->codec_id = AV_CODEC_ID_PCM_U8;
191	191	else
192		− st->codec->codec_id = CODEC_ID_PCM_S16LE;
	192	+ st->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
193	193
194	194	if (sample_rate % 14 != 0) {
195	195	idcin->audio_chunk_size1 = (sample_rate / 14) *

libavformat/idroqdec.c+2−2

@@ -127,7 +127,7 @@ static int roq_read_packet(AVFormatContext *s, · 126 unmodified lines
127	127	avpriv_set_pts_info(st, 63, 1, roq->frame_rate);
128	128	roq->video_stream_index = st->index;
129	129	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
130		− st->codec->codec_id = CODEC_ID_ROQ;
	130	+ st->codec->codec_id = AV_CODEC_ID_ROQ;
131	131	st->codec->codec_tag = 0; /* no fourcc */
132	132
133	133	if (avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != RoQ_CHUNK_PREAMBLE_SIZE)
@@ -173,7 +173,7 @@ static int roq_read_packet(AVFormatContext *s, · 39 unmodified lines
173	173	avpriv_set_pts_info(st, 32, 1, RoQ_AUDIO_SAMPLE_RATE);
174	174	roq->audio_stream_index = st->index;
175	175	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
176		− st->codec->codec_id = CODEC_ID_ROQ_DPCM;
	176	+ st->codec->codec_id = AV_CODEC_ID_ROQ_DPCM;
177	177	st->codec->codec_tag = 0; /* no tag */
178	178	st->codec->channels = roq->audio_channels = chunk_type == RoQ_SOUND_STEREO ? 2 : 1;
179	179	st->codec->sample_rate = RoQ_AUDIO_SAMPLE_RATE;

libavformat/idroqenc.c+2−2

@@ -39,8 +39,8 @@ AVOutputFormat ff_roq_muxer = { · 38 unmodified lines
39	39	.name = "roq",
40	40	.long_name = NULL_IF_CONFIG_SMALL("raw id RoQ"),
41	41	.extensions = "roq",
42		− .audio_codec = CODEC_ID_ROQ_DPCM,
43		− .video_codec = CODEC_ID_ROQ,
	42	+ .audio_codec = AV_CODEC_ID_ROQ_DPCM,
	43	+ .video_codec = AV_CODEC_ID_ROQ,
44	44	.write_header = roq_write_header,
45	45	.write_packet = ff_raw_write_packet,
46	46	};

libavformat/iff.c+5−5

@@ -220,13 +220,13 @@ static int iff_read_header(AVFormatContext *s) · 219 unmodified lines
220	220
221	221	switch(compression) {
222	222	case COMP_NONE:
223		− st->codec->codec_id = CODEC_ID_PCM_S8_PLANAR;
	223	+ st->codec->codec_id = AV_CODEC_ID_PCM_S8_PLANAR;
224	224	break;
225	225	case COMP_FIB:
226		− st->codec->codec_id = CODEC_ID_8SVX_FIB;
	226	+ st->codec->codec_id = AV_CODEC_ID_8SVX_FIB;
227	227	break;
228	228	case COMP_EXP:
229		− st->codec->codec_id = CODEC_ID_8SVX_EXP;
	229	+ st->codec->codec_id = AV_CODEC_ID_8SVX_EXP;
230	230	break;
231	231	default:
232	232	av_log(s, AV_LOG_ERROR, "unknown compression method\n");
@@ -241,10 +241,10 @@ static int iff_read_header(AVFormatContext *s) · 8 unmodified lines
241	241	case AVMEDIA_TYPE_VIDEO:
242	242	switch (compression) {
243	243	case BITMAP_RAW:
244		− st->codec->codec_id = CODEC_ID_IFF_ILBM;
	244	+ st->codec->codec_id = AV_CODEC_ID_IFF_ILBM;
245	245	break;
246	246	case BITMAP_BYTERUN1:
247		− st->codec->codec_id = CODEC_ID_IFF_BYTERUN1;
	247	+ st->codec->codec_id = AV_CODEC_ID_IFF_BYTERUN1;
248	248	break;
249	249	default:
250	250	av_log(s, AV_LOG_ERROR, "unknown compression method\n");

libavformat/ilbc.c+3−3

@@ -36,7 +36,7 @@ static int ilbc_write_header(AVFormatContext *s) · 35 unmodified lines
36	36	}
37	37	enc = s->streams[0]->codec;
38	38
39		− if (enc->codec_id != CODEC_ID_ILBC) {
	39	+ if (enc->codec_id != AV_CODEC_ID_ILBC) {
40	40	av_log(s, AV_LOG_ERROR, "Unsupported codec\n");
41	41	return AVERROR(EINVAL);
42	42	}
@@ -80,7 +80,7 @@ static int ilbc_read_header(AVFormatContext *s) · 37 unmodified lines
80	80	st = avformat_new_stream(s, NULL);
81	81	if (!st)
82	82	return AVERROR(ENOMEM);
83		− st->codec->codec_id = CODEC_ID_ILBC;
	83	+ st->codec->codec_id = AV_CODEC_ID_ILBC;
84	84	st->codec->sample_rate = 8000;
85	85	st->codec->channels = 1;
86	86	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
@@ -134,7 +134,7 @@ AVOutputFormat ff_ilbc_muxer = { · 47 unmodified lines
134	134	.long_name = NULL_IF_CONFIG_SMALL("iLBC storage"),
135	135	.mime_type = "audio/iLBC",
136	136	.extensions = "lbc",
137		− .audio_codec = CODEC_ID_ILBC,
	137	+ .audio_codec = AV_CODEC_ID_ILBC,
138	138	.write_header = ilbc_write_header,
139	139	.write_packet = ilbc_write_packet,
140	140	.flags = AVFMT_NOTIMESTAMPS,

libavformat/img2.c+43−43

@@ -24,55 +24,55 @@ · 23 unmodified lines
24	24	#include "internal.h"
25	25
26	26	typedef struct {
27		− enum CodecID id;
	27	+ enum AVCodecID id;
28	28	const char *str;
29	29	} IdStrMap;
30	30
31	31	static const IdStrMap img_tags[] = {
32		− { CODEC_ID_MJPEG , "jpeg"},
33		− { CODEC_ID_MJPEG , "jpg"},
34		− { CODEC_ID_LJPEG , "ljpg"},
35		− { CODEC_ID_PNG , "png"},
36		− { CODEC_ID_PNG , "mng"},
37		− { CODEC_ID_PPM , "ppm"},
38		− { CODEC_ID_PPM , "pnm"},
39		− { CODEC_ID_PGM , "pgm"},
40		− { CODEC_ID_PGMYUV , "pgmyuv"},
41		− { CODEC_ID_PBM , "pbm"},
42		− { CODEC_ID_PAM , "pam"},
43		− { CODEC_ID_MPEG1VIDEO, "mpg1-img"},
44		− { CODEC_ID_MPEG2VIDEO, "mpg2-img"},
45		− { CODEC_ID_MPEG4 , "mpg4-img"},
46		− { CODEC_ID_FFV1 , "ffv1-img"},
47		− { CODEC_ID_RAWVIDEO , "y"},
48		− { CODEC_ID_BMP , "bmp"},
49		− { CODEC_ID_GIF , "gif"},
50		− { CODEC_ID_TARGA , "tga"},
51		− { CODEC_ID_TIFF , "tiff"},
52		− { CODEC_ID_TIFF , "tif"},
53		− { CODEC_ID_SGI , "sgi"},
54		− { CODEC_ID_PTX , "ptx"},
55		− { CODEC_ID_PCX , "pcx"},
56		− { CODEC_ID_SUNRAST , "sun"},
57		− { CODEC_ID_SUNRAST , "ras"},
58		− { CODEC_ID_SUNRAST , "rs"},
59		− { CODEC_ID_SUNRAST , "im1"},
60		− { CODEC_ID_SUNRAST , "im8"},
61		− { CODEC_ID_SUNRAST , "im24"},
62		− { CODEC_ID_SUNRAST , "sunras"},
63		− { CODEC_ID_JPEG2000 , "jp2"},
64		− { CODEC_ID_JPEG2000 , "jpc"},
65		− { CODEC_ID_DPX , "dpx"},
66		− { CODEC_ID_PICTOR , "pic"},
67		− { CODEC_ID_XBM , "xbm"},
68		− { CODEC_ID_XWD , "xwd"},
69		− { CODEC_ID_NONE , NULL}
	32	+ { AV_CODEC_ID_MJPEG , "jpeg"},
	33	+ { AV_CODEC_ID_MJPEG , "jpg"},
	34	+ { AV_CODEC_ID_LJPEG , "ljpg"},
	35	+ { AV_CODEC_ID_PNG , "png"},
	36	+ { AV_CODEC_ID_PNG , "mng"},
	37	+ { AV_CODEC_ID_PPM , "ppm"},
	38	+ { AV_CODEC_ID_PPM , "pnm"},
	39	+ { AV_CODEC_ID_PGM , "pgm"},
	40	+ { AV_CODEC_ID_PGMYUV , "pgmyuv"},
	41	+ { AV_CODEC_ID_PBM , "pbm"},
	42	+ { AV_CODEC_ID_PAM , "pam"},
	43	+ { AV_CODEC_ID_MPEG1VIDEO, "mpg1-img"},
	44	+ { AV_CODEC_ID_MPEG2VIDEO, "mpg2-img"},
	45	+ { AV_CODEC_ID_MPEG4 , "mpg4-img"},
	46	+ { AV_CODEC_ID_FFV1 , "ffv1-img"},
	47	+ { AV_CODEC_ID_RAWVIDEO , "y"},
	48	+ { AV_CODEC_ID_BMP , "bmp"},
	49	+ { AV_CODEC_ID_GIF , "gif"},
	50	+ { AV_CODEC_ID_TARGA , "tga"},
	51	+ { AV_CODEC_ID_TIFF , "tiff"},
	52	+ { AV_CODEC_ID_TIFF , "tif"},
	53	+ { AV_CODEC_ID_SGI , "sgi"},
	54	+ { AV_CODEC_ID_PTX , "ptx"},
	55	+ { AV_CODEC_ID_PCX , "pcx"},
	56	+ { AV_CODEC_ID_SUNRAST , "sun"},
	57	+ { AV_CODEC_ID_SUNRAST , "ras"},
	58	+ { AV_CODEC_ID_SUNRAST , "rs"},
	59	+ { AV_CODEC_ID_SUNRAST , "im1"},
	60	+ { AV_CODEC_ID_SUNRAST , "im8"},
	61	+ { AV_CODEC_ID_SUNRAST , "im24"},
	62	+ { AV_CODEC_ID_SUNRAST , "sunras"},
	63	+ { AV_CODEC_ID_JPEG2000 , "jp2"},
	64	+ { AV_CODEC_ID_JPEG2000 , "jpc"},
	65	+ { AV_CODEC_ID_DPX , "dpx"},
	66	+ { AV_CODEC_ID_PICTOR , "pic"},
	67	+ { AV_CODEC_ID_XBM , "xbm"},
	68	+ { AV_CODEC_ID_XWD , "xwd"},
	69	+ { AV_CODEC_ID_NONE , NULL}
70	70	};
71	71
72		−static enum CodecID av_str2id(const IdStrMap tags, const char str)
	72	+static enum AVCodecID av_str2id(const IdStrMap tags, const char str)
73	73	{
74	74	str= strrchr(str, '.');
75		− if(!str) return CODEC_ID_NONE;
	75	+ if(!str) return AV_CODEC_ID_NONE;
76	76	str++;
77	77
78	78	while (tags->id) {
@@ -81,10 +81,10 @@ static enum CodecID av_str2id(const IdStrMap tags, const char str) · 2 unmodified lines
81	81
82	82	tags++;
83	83	}
84		− return CODEC_ID_NONE;
	84	+ return AV_CODEC_ID_NONE;
85	85	}
86	86
87		−enum CodecID ff_guess_image2_codec(const char *filename)
	87	+enum AVCodecID ff_guess_image2_codec(const char *filename)
88	88	{
89	89	return av_str2id(img_tags, filename);
90	90	}

libavformat/img2dec.c+2−2

@@ -239,12 +239,12 @@ static int read_packet(AVFormatContext s1, AVPacket pkt) · 238 unmodified lines
239	239	}
240	240	size[i]= avio_size(f[i]);
241	241
242		− if(codec->codec_id != CODEC_ID_RAWVIDEO)
	242	+ if(codec->codec_id != AV_CODEC_ID_RAWVIDEO)
243	243	break;
244	244	filename[ strlen(filename) - 1 ]= 'U' + i;
245	245	}
246	246
247		− if(codec->codec_id == CODEC_ID_RAWVIDEO && !codec->width)
	247	+ if(codec->codec_id == AV_CODEC_ID_RAWVIDEO && !codec->width)
248	248	infer_size(&codec->width, &codec->height, size[0]);
249	249	} else {
250	250	f[0] = s1->pb;

libavformat/img2enc.c+5−5

@@ -73,7 +73,7 @@ static int write_packet(AVFormatContext s, AVPacket pkt) · 72 unmodified lines
73	73	return AVERROR(EIO);
74	74	}
75	75
76		− if(codec->codec_id != CODEC_ID_RAWVIDEO)
	76	+ if(codec->codec_id != AV_CODEC_ID_RAWVIDEO)
77	77	break;
78	78	filename[ strlen(filename) - 1 ]= 'U' + i;
79	79	}
@@ -81,7 +81,7 @@ static int write_packet(AVFormatContext s, AVPacket pkt) · 1 unmodified line
81	81	pb[0] = s->pb;
82	82	}
83	83
84		− if(codec->codec_id == CODEC_ID_RAWVIDEO){
	84	+ if(codec->codec_id == AV_CODEC_ID_RAWVIDEO){
85	85	int ysize = codec->width * codec->height;
86	86	avio_write(pb[0], pkt->data , ysize);
87	87	avio_write(pb[1], pkt->data + ysize, (pkt->size - ysize)/2);
@@ -91,7 +91,7 @@ static int write_packet(AVFormatContext s, AVPacket pkt) · 3 unmodified lines
91	91	avio_close(pb[1]);
92	92	avio_close(pb[2]);
93	93	}else{
94		− if(ff_guess_image2_codec(s->filename) == CODEC_ID_JPEG2000){
	94	+ if(ff_guess_image2_codec(s->filename) == AV_CODEC_ID_JPEG2000){
95	95	AVStream *st = s->streams[0];
96	96	if(st->codec->extradata_size > 8 &&
97	97	AV_RL32(st->codec->extradata+4) == MKTAG('j','p','2','h')){
@@ -147,7 +147,7 @@ AVOutputFormat ff_image2_muxer = { · 49 unmodified lines
147	147	"ppm,sgi,tga,tif,tiff,jp2,xwd,sun,ras,rs,im1,im8,im24,"
148	148	"sunras,xbm",
149	149	.priv_data_size = sizeof(VideoMuxData),
150		− .video_codec = CODEC_ID_MJPEG,
	150	+ .video_codec = AV_CODEC_ID_MJPEG,
151	151	.write_header = write_header,
152	152	.write_packet = write_packet,
153	153	.flags = AVFMT_NOTIMESTAMPS \| AVFMT_NODIMENSIONS \| AVFMT_NOFILE,
@@ -159,7 +159,7 @@ AVOutputFormat ff_image2pipe_muxer = { · 5 unmodified lines
159	159	.name = "image2pipe",
160	160	.long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
161	161	.priv_data_size = sizeof(VideoMuxData),
162		− .video_codec = CODEC_ID_MJPEG,
	162	+ .video_codec = AV_CODEC_ID_MJPEG,
163	163	.write_header = write_header,
164	164	.write_packet = write_packet,
165	165	.flags = AVFMT_NOTIMESTAMPS \| AVFMT_NODIMENSIONS

libavformat/ingenientdec.c+1−1

@@ -68,6 +68,6 @@ AVInputFormat ff_ingenient_demuxer = { · 67 unmodified lines
68	68	.read_packet = ingenient_read_packet,
69	69	.flags = AVFMT_GENERIC_INDEX,
70	70	.extensions = "cgi", // FIXME
71		− .raw_codec_id = CODEC_ID_MJPEG,
	71	+ .raw_codec_id = AV_CODEC_ID_MJPEG,
72	72	.priv_class = &ingenient_demuxer_class,
73	73	};

libavformat/internal.h+3−3

@@ -33,13 +33,13 @@ · 32 unmodified lines
33	33	#endif
34	34
35	35	typedef struct AVCodecTag {
36		− enum CodecID id;
	36	+ enum AVCodecID id;
37	37	unsigned int tag;
38	38	} AVCodecTag;
39	39
40	40	typedef struct CodecMime{
41	41	char str[32];
42		− enum CodecID id;
	42	+ enum AVCodecID id;
43	43	} CodecMime;
44	44
45	45	void ff_dynarray_add(intptr_t *tab_ptr, int nb_ptr, intptr_t elem);
@@ -251,7 +251,7 @@ void ff_reduce_index(AVFormatContext *s, int stream_index); · 205 unmodified lines
251	251	void ff_make_absolute_url(char buf, int size, const char base,
252	252	const char *rel);
253	253
254		−enum CodecID ff_guess_image2_codec(const char *filename);
	254	+enum AVCodecID ff_guess_image2_codec(const char *filename);
255	255
256	256	/**
257	257	* Convert a date string in ISO8601 format to Unix timestamp.

libavformat/ipmovie.c+11−11

@@ -94,7 +94,7 @@ typedef struct IPMVEContext { · 93 unmodified lines
94	94	unsigned int audio_bits;
95	95	unsigned int audio_channels;
96	96	unsigned int audio_sample_rate;
97		− enum CodecID audio_type;
	97	+ enum AVCodecID audio_type;
98	98	unsigned int audio_frame_count;
99	99
100	100	int video_stream_index;
@@ -117,14 +117,14 @@ static int load_ipmovie_packet(IPMVEContext s, AVIOContext pb, · 16 unmodified lines
117	117	int chunk_type;
118	118
119	119	if (s->audio_chunk_offset) {
120		− if (s->audio_type == CODEC_ID_NONE) {
	120	+ if (s->audio_type == AV_CODEC_ID_NONE) {
121	121	av_log(NULL, AV_LOG_ERROR, "Can not read audio packet before"
122	122	"audio codec is known\n");
123	123	return CHUNK_BAD;
124	124	}
125	125
126	126	/* adjust for PCM audio by skipping chunk header */
127		− if (s->audio_type != CODEC_ID_INTERPLAY_DPCM) {
	127	+ if (s->audio_type != AV_CODEC_ID_INTERPLAY_DPCM) {
128	128	s->audio_chunk_offset += 6;
129	129	s->audio_chunk_size -= 6;
130	130	}
@@ -139,7 +139,7 @@ static int load_ipmovie_packet(IPMVEContext s, AVIOContext pb, · 8 unmodified lines
139	139	pkt->pts = s->audio_frame_count;
140	140
141	141	/* audio frame maintenance */
142		− if (s->audio_type != CODEC_ID_INTERPLAY_DPCM)
	142	+ if (s->audio_type != AV_CODEC_ID_INTERPLAY_DPCM)
143	143	s->audio_frame_count +=
144	144	(s->audio_chunk_size / s->audio_channels / (s->audio_bits / 8));
145	145	else
@@ -356,15 +356,15 @@ static int process_ipmovie_chunk(IPMVEContext s, AVIOContext pb, · 210 unmodified lines
356	356	s->audio_bits = (((audio_flags >> 1) & 1) + 1) * 8;
357	357	/* bit 2 indicates compressed audio in version 1 opcode */
358	358	if ((opcode_version == 1) && (audio_flags & 0x4))
359		− s->audio_type = CODEC_ID_INTERPLAY_DPCM;
	359	+ s->audio_type = AV_CODEC_ID_INTERPLAY_DPCM;
360	360	else if (s->audio_bits == 16)
361		− s->audio_type = CODEC_ID_PCM_S16LE;
	361	+ s->audio_type = AV_CODEC_ID_PCM_S16LE;
362	362	else
363		− s->audio_type = CODEC_ID_PCM_U8;
	363	+ s->audio_type = AV_CODEC_ID_PCM_U8;
364	364	av_dlog(NULL, "audio: %d bits, %d Hz, %s, %s format\n",
365	365	s->audio_bits, s->audio_sample_rate,
366	366	(s->audio_channels == 2) ? "stereo" : "mono",
367		− (s->audio_type == CODEC_ID_INTERPLAY_DPCM) ?
	367	+ (s->audio_type == AV_CODEC_ID_INTERPLAY_DPCM) ?
368	368	"Interplay audio" : "PCM");
369	369	break;
370	370
@@ -573,7 +573,7 @@ static int ipmovie_read_header(AVFormatContext *s) · 202 unmodified lines
573	573	avio_seek(pb, -CHUNK_PREAMBLE_SIZE, SEEK_CUR);
574	574
575	575	if (chunk_type == CHUNK_VIDEO)
576		− ipmovie->audio_type = CODEC_ID_NONE; /* no audio */
	576	+ ipmovie->audio_type = AV_CODEC_ID_NONE; /* no audio */
577	577	else if (process_ipmovie_chunk(ipmovie, pb, &pkt) != CHUNK_INIT_AUDIO)
578	578	return AVERROR_INVALIDDATA;
579	579
@@ -584,7 +584,7 @@ static int ipmovie_read_header(AVFormatContext *s) · 4 unmodified lines
584	584	avpriv_set_pts_info(st, 63, 1, 1000000);
585	585	ipmovie->video_stream_index = st->index;
586	586	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
587		− st->codec->codec_id = CODEC_ID_INTERPLAY_VIDEO;
	587	+ st->codec->codec_id = AV_CODEC_ID_INTERPLAY_VIDEO;
588	588	st->codec->codec_tag = 0; /* no fourcc */
589	589	st->codec->width = ipmovie->video_width;
590	590	st->codec->height = ipmovie->video_height;
@@ -604,7 +604,7 @@ static int ipmovie_read_header(AVFormatContext *s) · 13 unmodified lines
604	604	st->codec->bits_per_coded_sample = ipmovie->audio_bits;
605	605	st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
606	606	st->codec->bits_per_coded_sample;
607		− if (st->codec->codec_id == CODEC_ID_INTERPLAY_DPCM)
	607	+ if (st->codec->codec_id == AV_CODEC_ID_INTERPLAY_DPCM)
608	608	st->codec->bit_rate /= 2;
609	609	st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample;
610	610	}

libavformat/isom.c+248−248

@@ -33,255 +33,255 @@ · 32 unmodified lines
33	33	/* http://www.mp4ra.org */
34	34	/* ordered by muxing preference */
35	35	const AVCodecTag ff_mp4_obj_type[] = {
36		− { CODEC_ID_MOV_TEXT , 0x08 },
37		− { CODEC_ID_MPEG4 , 0x20 },
38		− { CODEC_ID_H264 , 0x21 },
39		− { CODEC_ID_AAC , 0x40 },
40		− { CODEC_ID_MP4ALS , 0x40 }, /* 14496-3 ALS */
41		− { CODEC_ID_MPEG2VIDEO, 0x61 }, /* MPEG2 Main */
42		− { CODEC_ID_MPEG2VIDEO, 0x60 }, /* MPEG2 Simple */
43		− { CODEC_ID_MPEG2VIDEO, 0x62 }, /* MPEG2 SNR */
44		− { CODEC_ID_MPEG2VIDEO, 0x63 }, /* MPEG2 Spatial */
45		− { CODEC_ID_MPEG2VIDEO, 0x64 }, /* MPEG2 High */
46		− { CODEC_ID_MPEG2VIDEO, 0x65 }, /* MPEG2 422 */
47		− { CODEC_ID_AAC , 0x66 }, /* MPEG2 AAC Main */
48		− { CODEC_ID_AAC , 0x67 }, /* MPEG2 AAC Low */
49		− { CODEC_ID_AAC , 0x68 }, /* MPEG2 AAC SSR */
50		− { CODEC_ID_MP3 , 0x69 }, /* 13818-3 */
51		− { CODEC_ID_MP2 , 0x69 }, /* 11172-3 */
52		− { CODEC_ID_MPEG1VIDEO, 0x6A }, /* 11172-2 */
53		− { CODEC_ID_MP3 , 0x6B }, /* 11172-3 */
54		− { CODEC_ID_MJPEG , 0x6C }, /* 10918-1 */
55		− { CODEC_ID_PNG , 0x6D },
56		− { CODEC_ID_JPEG2000 , 0x6E }, /* 15444-1 */
57		− { CODEC_ID_VC1 , 0xA3 },
58		− { CODEC_ID_DIRAC , 0xA4 },
59		− { CODEC_ID_AC3 , 0xA5 },
60		− { CODEC_ID_DTS , 0xA9 }, /* mp4ra.org */
61		− { CODEC_ID_VORBIS , 0xDD }, /* non standard, gpac uses it */
62		− { CODEC_ID_DVD_SUBTITLE, 0xE0 }, /* non standard, see unsupported-embedded-subs-2.mp4 */
63		− { CODEC_ID_QCELP , 0xE1 },
64		− { CODEC_ID_MPEG4SYSTEMS, 0x01 },
65		− { CODEC_ID_MPEG4SYSTEMS, 0x02 },
66		− { CODEC_ID_NONE , 0 },
	36	+ { AV_CODEC_ID_MOV_TEXT , 0x08 },
	37	+ { AV_CODEC_ID_MPEG4 , 0x20 },
	38	+ { AV_CODEC_ID_H264 , 0x21 },
	39	+ { AV_CODEC_ID_AAC , 0x40 },
	40	+ { AV_CODEC_ID_MP4ALS , 0x40 }, /* 14496-3 ALS */
	41	+ { AV_CODEC_ID_MPEG2VIDEO , 0x61 }, /* MPEG2 Main */
	42	+ { AV_CODEC_ID_MPEG2VIDEO , 0x60 }, /* MPEG2 Simple */
	43	+ { AV_CODEC_ID_MPEG2VIDEO , 0x62 }, /* MPEG2 SNR */
	44	+ { AV_CODEC_ID_MPEG2VIDEO , 0x63 }, /* MPEG2 Spatial */
	45	+ { AV_CODEC_ID_MPEG2VIDEO , 0x64 }, /* MPEG2 High */
	46	+ { AV_CODEC_ID_MPEG2VIDEO , 0x65 }, /* MPEG2 422 */
	47	+ { AV_CODEC_ID_AAC , 0x66 }, /* MPEG2 AAC Main */
	48	+ { AV_CODEC_ID_AAC , 0x67 }, /* MPEG2 AAC Low */
	49	+ { AV_CODEC_ID_AAC , 0x68 }, /* MPEG2 AAC SSR */
	50	+ { AV_CODEC_ID_MP3 , 0x69 }, /* 13818-3 */
	51	+ { AV_CODEC_ID_MP2 , 0x69 }, /* 11172-3 */
	52	+ { AV_CODEC_ID_MPEG1VIDEO , 0x6A }, /* 11172-2 */
	53	+ { AV_CODEC_ID_MP3 , 0x6B }, /* 11172-3 */
	54	+ { AV_CODEC_ID_MJPEG , 0x6C }, /* 10918-1 */
	55	+ { AV_CODEC_ID_PNG , 0x6D },
	56	+ { AV_CODEC_ID_JPEG2000 , 0x6E }, /* 15444-1 */
	57	+ { AV_CODEC_ID_VC1 , 0xA3 },
	58	+ { AV_CODEC_ID_DIRAC , 0xA4 },
	59	+ { AV_CODEC_ID_AC3 , 0xA5 },
	60	+ { AV_CODEC_ID_DTS , 0xA9 }, /* mp4ra.org */
	61	+ { AV_CODEC_ID_VORBIS , 0xDD }, /* non standard, gpac uses it */
	62	+ { AV_CODEC_ID_DVD_SUBTITLE, 0xE0 }, /* non standard, see unsupported-embedded-subs-2.mp4 */
	63	+ { AV_CODEC_ID_QCELP , 0xE1 },
	64	+ { AV_CODEC_ID_MPEG4SYSTEMS, 0x01 },
	65	+ { AV_CODEC_ID_MPEG4SYSTEMS, 0x02 },
	66	+ { AV_CODEC_ID_NONE , 0 },
67	67	};
68	68
69	69	const AVCodecTag ff_codec_movvideo_tags[] = {
70		−/* { CODEC_ID_, MKTAG('I', 'V', '5', '0') }, // Indeo 5.0 */
71		−
72		− { CODEC_ID_RAWVIDEO, MKTAG('r', 'a', 'w', ' ') }, /* Uncompressed RGB */
73		− { CODEC_ID_RAWVIDEO, MKTAG('y', 'u', 'v', '2') }, /* Uncompressed YUV422 */
74		− { CODEC_ID_RAWVIDEO, MKTAG('A', 'V', 'U', 'I') }, /* YUV with alpha-channel (AVID Uncompressed) */
75		− { CODEC_ID_RAWVIDEO, MKTAG('2', 'v', 'u', 'y') }, /* UNCOMPRESSED 8BIT 4:2:2 */
76		− { CODEC_ID_RAWVIDEO, MKTAG('y', 'u', 'v', 's') }, /* same as 2vuy but byte swapped */
77		−
78		− { CODEC_ID_RAWVIDEO, MKTAG('L', '5', '5', '5') },
79		− { CODEC_ID_RAWVIDEO, MKTAG('L', '5', '6', '5') },
80		− { CODEC_ID_RAWVIDEO, MKTAG('B', '5', '6', '5') },
81		− { CODEC_ID_RAWVIDEO, MKTAG('2', '4', 'B', 'G') },
82		− { CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 'A') },
83		− { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 'A') },
84		− { CODEC_ID_RAWVIDEO, MKTAG('A', 'B', 'G', 'R') },
85		− { CODEC_ID_RAWVIDEO, MKTAG('b', '1', '6', 'g') },
86		− { CODEC_ID_RAWVIDEO, MKTAG('b', '4', '8', 'r') },
87		− { CODEC_ID_RAWVIDEO, MKTAG('D', 'V', 'O', 'O') }, /* Digital Voodoo SD 8 Bit */
88		−
89		− { CODEC_ID_R10K, MKTAG('R', '1', '0', 'k') }, /* UNCOMPRESSED 10BIT RGB */
90		− { CODEC_ID_R10K, MKTAG('R', '1', '0', 'g') }, /* UNCOMPRESSED 10BIT RGB */
91		− { CODEC_ID_R210, MKTAG('r', '2', '1', '0') }, /* UNCOMPRESSED 10BIT RGB */
92		− { CODEC_ID_V210, MKTAG('v', '2', '1', '0') }, /* UNCOMPRESSED 10BIT 4:2:2 */
93		− { CODEC_ID_V410, MKTAG('v', '4', '1', '0') }, /* UNCOMPRESSED 10BIT 4:4:4 */
94		−
95		− { CODEC_ID_MJPEG, MKTAG('j', 'p', 'e', 'g') }, /* PhotoJPEG */
96		− { CODEC_ID_MJPEG, MKTAG('m', 'j', 'p', 'a') }, /* Motion-JPEG (format A) */
97		− { CODEC_ID_MJPEG, MKTAG('A', 'V', 'D', 'J') }, /* MJPEG with alpha-channel (AVID JFIF meridien compressed) */
98		−/* { CODEC_ID_MJPEG, MKTAG('A', 'V', 'R', 'n') }, // MJPEG with alpha-channel (AVID ABVB/Truevision NuVista) */
99		− { CODEC_ID_MJPEG, MKTAG('d', 'm', 'b', '1') }, /* Motion JPEG OpenDML */
100		− { CODEC_ID_MJPEGB, MKTAG('m', 'j', 'p', 'b') }, /* Motion-JPEG (format B) */
101		−
102		− { CODEC_ID_SVQ1, MKTAG('S', 'V', 'Q', '1') }, /* Sorenson Video v1 */
103		− { CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', '1') }, /* Sorenson Video v1 */
104		− { CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', 'i') }, /* Sorenson Video v1 (from QT specs)*/
105		− { CODEC_ID_SVQ3, MKTAG('S', 'V', 'Q', '3') }, /* Sorenson Video v3 */
106		−
107		− { CODEC_ID_MPEG4, MKTAG('m', 'p', '4', 'v') },
108		− { CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', 'X') }, /* OpenDiVX // sample files at http://heroinewarrior.com/xmovie.php3 use this tag */
109		− { CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') },
110		− { CODEC_ID_MPEG4, MKTAG('3', 'I', 'V', '2') }, /* experimental: 3IVX files before ivx D4 4.5.1 */
111		−
112		− { CODEC_ID_H263, MKTAG('h', '2', '6', '3') }, /* H263 */
113		− { CODEC_ID_H263, MKTAG('s', '2', '6', '3') }, /* H263 ?? works */
114		−
115		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', 'p') }, /* DV PAL */
116		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') }, /* DV NTSC */
117		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'p', 'p') }, /* DVCPRO PAL produced by FCP */
118		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', 'p') }, /* DVCPRO50 PAL produced by FCP */
119		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', 'n') }, /* DVCPRO50 NTSC produced by FCP */
120		− { CODEC_ID_DVVIDEO, MKTAG('A', 'V', 'd', 'v') }, /* AVID DV */
121		− { CODEC_ID_DVVIDEO, MKTAG('A', 'V', 'd', '1') }, /* AVID DV100 */
122		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', 'q') }, /* DVCPRO HD 720p50 */
123		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', 'p') }, /* DVCPRO HD 720p60 */
124		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '1') },
125		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '2') },
126		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '4') },
127		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '5') }, /* DVCPRO HD 50i produced by FCP */
128		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '6') }, /* DVCPRO HD 60i produced by FCP */
129		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '3') }, /* DVCPRO HD 30p produced by FCP */
130		−
131		− { CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') }, /* On2 VP3 */
132		− { CODEC_ID_RPZA, MKTAG('r', 'p', 'z', 'a') }, /* Apple Video (RPZA) */
133		− { CODEC_ID_CINEPAK, MKTAG('c', 'v', 'i', 'd') }, /* Cinepak */
134		− { CODEC_ID_8BPS, MKTAG('8', 'B', 'P', 'S') }, /* Planar RGB (8BPS) */
135		− { CODEC_ID_SMC, MKTAG('s', 'm', 'c', ' ') }, /* Apple Graphics (SMC) */
136		− { CODEC_ID_QTRLE, MKTAG('r', 'l', 'e', ' ') }, /* Apple Animation (RLE) */
137		− { CODEC_ID_MSRLE, MKTAG('W', 'R', 'L', 'E') },
138		− { CODEC_ID_QDRAW, MKTAG('q', 'd', 'r', 'w') }, /* QuickDraw */
139		−
140		− { CODEC_ID_RAWVIDEO, MKTAG('W', 'R', 'A', 'W') },
141		−
142		− { CODEC_ID_H264, MKTAG('a', 'v', 'c', '1') }, /* AVC-1/H.264 */
143		− { CODEC_ID_H264, MKTAG('a', 'i', '5', 'p') }, /* AVC-Intra 50M 720p24/30/60 */
144		− { CODEC_ID_H264, MKTAG('a', 'i', '5', 'q') }, /* AVC-Intra 50M 720p25/50 */
145		− { CODEC_ID_H264, MKTAG('a', 'i', '5', '2') }, /* AVC-Intra 50M 1080p25/50 */
146		− { CODEC_ID_H264, MKTAG('a', 'i', '5', '3') }, /* AVC-Intra 50M 1080p24/30/60 */
147		− { CODEC_ID_H264, MKTAG('a', 'i', '5', '5') }, /* AVC-Intra 50M 1080i50 */
148		− { CODEC_ID_H264, MKTAG('a', 'i', '5', '6') }, /* AVC-Intra 50M 1080i60 */
149		− { CODEC_ID_H264, MKTAG('a', 'i', '1', 'p') }, /* AVC-Intra 100M 720p24/30/60 */
150		− { CODEC_ID_H264, MKTAG('a', 'i', '1', 'q') }, /* AVC-Intra 100M 720p25/50 */
151		− { CODEC_ID_H264, MKTAG('a', 'i', '1', '2') }, /* AVC-Intra 100M 1080p25/50 */
152		− { CODEC_ID_H264, MKTAG('a', 'i', '1', '3') }, /* AVC-Intra 100M 1080p24/30/60 */
153		− { CODEC_ID_H264, MKTAG('a', 'i', '1', '5') }, /* AVC-Intra 100M 1080i50 */
154		− { CODEC_ID_H264, MKTAG('a', 'i', '1', '6') }, /* AVC-Intra 100M 1080i60 */
155		−
156		− { CODEC_ID_MPEG1VIDEO, MKTAG('m', '1', 'v', '1') }, /* Apple MPEG-1 Camcorder */
157		− { CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'e', 'g') }, /* MPEG */
158		− { CODEC_ID_MPEG2VIDEO, MKTAG('m', '2', 'v', '1') }, /* Apple MPEG-2 Camcorder */
159		− { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '1') }, /* MPEG2 HDV 720p30 */
160		− { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '2') }, /* MPEG2 HDV 1080i60 */
161		− { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '3') }, /* MPEG2 HDV 1080i50 */
162		− { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '4') }, /* MPEG2 HDV 720p24 */
163		− { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '5') }, /* MPEG2 HDV 720p25 */
164		− { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '6') }, /* MPEG2 HDV 1080p24 */
165		− { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '7') }, /* MPEG2 HDV 1080p25 */
166		− { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '8') }, /* MPEG2 HDV 1080p30 */
167		− { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '9') }, /* MPEG2 HDV 720p60 JVC */
168		− { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', 'a') }, /* MPEG2 HDV 720p50 */
169		− { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '5', 'n') }, /* MPEG2 IMX NTSC 525/60 50mb/s produced by FCP */
170		− { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '5', 'p') }, /* MPEG2 IMX PAL 625/50 50mb/s produced by FCP */
171		− { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '4', 'n') }, /* MPEG2 IMX NTSC 525/60 40mb/s produced by FCP */
172		− { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '4', 'p') }, /* MPEG2 IMX PAL 625/50 40mb/s produced by FCP */
173		− { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '3', 'n') }, /* MPEG2 IMX NTSC 525/60 30mb/s produced by FCP */
174		− { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '3', 'p') }, /* MPEG2 IMX PAL 625/50 30mb/s produced by FCP */
175		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', '4') }, /* XDCAM HD422 720p24 CBR */
176		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', '5') }, /* XDCAM HD422 720p25 CBR */
177		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', '9') }, /* XDCAM HD422 720p60 CBR */
178		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'a') }, /* XDCAM HD422 720p50 CBR */
179		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'b') }, /* XDCAM HD422 1080i60 CBR */
180		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'c') }, /* XDCAM HD422 1080i50 CBR */
181		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'd') }, /* XDCAM HD422 1080p24 CBR */
182		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'e') }, /* XDCAM HD422 1080p25 CBR */
183		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'f') }, /* XDCAM HD422 1080p30 CBR */
184		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '1') }, /* XDCAM EX 720p30 VBR */
185		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '2') }, /* XDCAM HD 1080i60 */
186		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '3') }, /* XDCAM HD 1080i50 VBR */
187		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '4') }, /* XDCAM EX 720p24 VBR */
188		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '5') }, /* XDCAM EX 720p25 VBR */
189		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '6') }, /* XDCAM HD 1080p24 VBR */
190		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '7') }, /* XDCAM HD 1080p25 VBR */
191		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '8') }, /* XDCAM HD 1080p30 VBR */
192		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '9') }, /* XDCAM EX 720p60 VBR */
193		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'a') }, /* XDCAM EX 720p50 VBR */
194		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'b') }, /* XDCAM EX 1080i60 VBR */
195		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'c') }, /* XDCAM EX 1080i50 VBR */
196		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'd') }, /* XDCAM EX 1080p24 VBR */
197		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'e') }, /* XDCAM EX 1080p25 VBR */
198		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'f') }, /* XDCAM EX 1080p30 VBR */
199		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'h', 'd') }, /* XDCAM HD 540p */
200		− { CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'h', '2') }, /* XDCAM HD422 540p */
201		− { CODEC_ID_MPEG2VIDEO, MKTAG('A', 'V', 'm', 'p') }, /* AVID IMX PAL */
202		−
203		− { CODEC_ID_JPEG2000, MKTAG('m', 'j', 'p', '2') }, /* JPEG 2000 produced by FCP */
204		−
205		− { CODEC_ID_TARGA, MKTAG('t', 'g', 'a', ' ') }, /* Truevision Targa */
206		− { CODEC_ID_TIFF, MKTAG('t', 'i', 'f', 'f') }, /* TIFF embedded in MOV */
207		− { CODEC_ID_GIF, MKTAG('g', 'i', 'f', ' ') }, /* embedded gif files as frames (usually one "click to play movie" frame) */
208		− { CODEC_ID_PNG, MKTAG('p', 'n', 'g', ' ') },
209		−
210		− { CODEC_ID_VC1, MKTAG('v', 'c', '-', '1') }, /* SMPTE RP 2025 */
211		− { CODEC_ID_CAVS, MKTAG('a', 'v', 's', '2') },
212		−
213		− { CODEC_ID_DIRAC, MKTAG('d', 'r', 'a', 'c') },
214		− { CODEC_ID_DNXHD, MKTAG('A', 'V', 'd', 'n') }, /* AVID DNxHD */
215		− { CODEC_ID_FLV1, MKTAG('H', '2', '6', '3') }, /* Flash Media Server */
216		− { CODEC_ID_MSMPEG4V3, MKTAG('3', 'I', 'V', 'D') }, /* 3ivx DivX Doctor */
217		− { CODEC_ID_RAWVIDEO, MKTAG('A', 'V', '1', 'x') }, /* AVID 1:1x */
218		− { CODEC_ID_RAWVIDEO, MKTAG('A', 'V', 'u', 'p') },
219		− { CODEC_ID_SGI, MKTAG('s', 'g', 'i', ' ') }, /* SGI */
220		− { CODEC_ID_DPX, MKTAG('d', 'p', 'x', ' ') }, /* DPX */
221		−
222		− { CODEC_ID_PRORES, MKTAG('a', 'p', 'c', 'h') }, /* Apple ProRes 422 High Quality */
223		− { CODEC_ID_PRORES, MKTAG('a', 'p', 'c', 'n') }, /* Apple ProRes 422 Standard Definition */
224		− { CODEC_ID_PRORES, MKTAG('a', 'p', 'c', 's') }, /* Apple ProRes 422 LT */
225		− { CODEC_ID_PRORES, MKTAG('a', 'p', 'c', 'o') }, /* Apple ProRes 422 Proxy */
226		− { CODEC_ID_PRORES, MKTAG('a', 'p', '4', 'h') }, /* Apple ProRes 4444 */
227		−
228		− { CODEC_ID_NONE, 0 },
	70	+/* { AV_CODEC_ID_, MKTAG('I', 'V', '5', '0') }, // Indeo 5.0 */
	71	+
	72	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('r', 'a', 'w', ' ') }, /* Uncompressed RGB */
	73	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('y', 'u', 'v', '2') }, /* Uncompressed YUV422 */
	74	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('A', 'V', 'U', 'I') }, /* YUV with alpha-channel (AVID Uncompressed) */
	75	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('2', 'v', 'u', 'y') }, /* UNCOMPRESSED 8BIT 4:2:2 */
	76	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('y', 'u', 'v', 's') }, /* same as 2vuy but byte swapped */
	77	+
	78	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('L', '5', '5', '5') },
	79	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('L', '5', '6', '5') },
	80	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', '5', '6', '5') },
	81	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('2', '4', 'B', 'G') },
	82	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 'A') },
	83	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 'A') },
	84	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('A', 'B', 'G', 'R') },
	85	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('b', '1', '6', 'g') },
	86	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('b', '4', '8', 'r') },
	87	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('D', 'V', 'O', 'O') }, /* Digital Voodoo SD 8 Bit */
	88	+
	89	+ { AV_CODEC_ID_R10K, MKTAG('R', '1', '0', 'k') }, /* UNCOMPRESSED 10BIT RGB */
	90	+ { AV_CODEC_ID_R10K, MKTAG('R', '1', '0', 'g') }, /* UNCOMPRESSED 10BIT RGB */
	91	+ { AV_CODEC_ID_R210, MKTAG('r', '2', '1', '0') }, /* UNCOMPRESSED 10BIT RGB */
	92	+ { AV_CODEC_ID_V210, MKTAG('v', '2', '1', '0') }, /* UNCOMPRESSED 10BIT 4:2:2 */
	93	+ { AV_CODEC_ID_V410, MKTAG('v', '4', '1', '0') }, /* UNCOMPRESSED 10BIT 4:4:4 */
	94	+
	95	+ { AV_CODEC_ID_MJPEG, MKTAG('j', 'p', 'e', 'g') }, /* PhotoJPEG */
	96	+ { AV_CODEC_ID_MJPEG, MKTAG('m', 'j', 'p', 'a') }, /* Motion-JPEG (format A) */
	97	+ { AV_CODEC_ID_MJPEG, MKTAG('A', 'V', 'D', 'J') }, /* MJPEG with alpha-channel (AVID JFIF meridien compressed) */
	98	+/* { AV_CODEC_ID_MJPEG, MKTAG('A', 'V', 'R', 'n') }, // MJPEG with alpha-channel (AVID ABVB/Truevision NuVista) */
	99	+ { AV_CODEC_ID_MJPEG, MKTAG('d', 'm', 'b', '1') }, /* Motion JPEG OpenDML */
	100	+ { AV_CODEC_ID_MJPEGB, MKTAG('m', 'j', 'p', 'b') }, /* Motion-JPEG (format B) */
	101	+
	102	+ { AV_CODEC_ID_SVQ1, MKTAG('S', 'V', 'Q', '1') }, /* Sorenson Video v1 */
	103	+ { AV_CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', '1') }, /* Sorenson Video v1 */
	104	+ { AV_CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', 'i') }, /* Sorenson Video v1 (from QT specs)*/
	105	+ { AV_CODEC_ID_SVQ3, MKTAG('S', 'V', 'Q', '3') }, /* Sorenson Video v3 */
	106	+
	107	+ { AV_CODEC_ID_MPEG4, MKTAG('m', 'p', '4', 'v') },
	108	+ { AV_CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', 'X') }, /* OpenDiVX // sample files at http://heroinewarrior.com/xmovie.php3 use this tag */
	109	+ { AV_CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') },
	110	+ { AV_CODEC_ID_MPEG4, MKTAG('3', 'I', 'V', '2') }, /* experimental: 3IVX files before ivx D4 4.5.1 */
	111	+
	112	+ { AV_CODEC_ID_H263, MKTAG('h', '2', '6', '3') }, /* H263 */
	113	+ { AV_CODEC_ID_H263, MKTAG('s', '2', '6', '3') }, /* H263 ?? works */
	114	+
	115	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', 'p') }, /* DV PAL */
	116	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') }, /* DV NTSC */
	117	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'p', 'p') }, /* DVCPRO PAL produced by FCP */
	118	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', 'p') }, /* DVCPRO50 PAL produced by FCP */
	119	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', 'n') }, /* DVCPRO50 NTSC produced by FCP */
	120	+ { AV_CODEC_ID_DVVIDEO, MKTAG('A', 'V', 'd', 'v') }, /* AVID DV */
	121	+ { AV_CODEC_ID_DVVIDEO, MKTAG('A', 'V', 'd', '1') }, /* AVID DV100 */
	122	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', 'q') }, /* DVCPRO HD 720p50 */
	123	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', 'p') }, /* DVCPRO HD 720p60 */
	124	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '1') },
	125	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '2') },
	126	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '4') },
	127	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '5') }, /* DVCPRO HD 50i produced by FCP */
	128	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '6') }, /* DVCPRO HD 60i produced by FCP */
	129	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '3') }, /* DVCPRO HD 30p produced by FCP */
	130	+
	131	+ { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') }, /* On2 VP3 */
	132	+ { AV_CODEC_ID_RPZA, MKTAG('r', 'p', 'z', 'a') }, /* Apple Video (RPZA) */
	133	+ { AV_CODEC_ID_CINEPAK, MKTAG('c', 'v', 'i', 'd') }, /* Cinepak */
	134	+ { AV_CODEC_ID_8BPS, MKTAG('8', 'B', 'P', 'S') }, /* Planar RGB (8BPS) */
	135	+ { AV_CODEC_ID_SMC, MKTAG('s', 'm', 'c', ' ') }, /* Apple Graphics (SMC) */
	136	+ { AV_CODEC_ID_QTRLE, MKTAG('r', 'l', 'e', ' ') }, /* Apple Animation (RLE) */
	137	+ { AV_CODEC_ID_MSRLE, MKTAG('W', 'R', 'L', 'E') },
	138	+ { AV_CODEC_ID_QDRAW, MKTAG('q', 'd', 'r', 'w') }, /* QuickDraw */
	139	+
	140	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('W', 'R', 'A', 'W') },
	141	+
	142	+ { AV_CODEC_ID_H264, MKTAG('a', 'v', 'c', '1') }, /* AVC-1/H.264 */
	143	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '5', 'p') }, /* AVC-Intra 50M 720p24/30/60 */
	144	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '5', 'q') }, /* AVC-Intra 50M 720p25/50 */
	145	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '5', '2') }, /* AVC-Intra 50M 1080p25/50 */
	146	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '5', '3') }, /* AVC-Intra 50M 1080p24/30/60 */
	147	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '5', '5') }, /* AVC-Intra 50M 1080i50 */
	148	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '5', '6') }, /* AVC-Intra 50M 1080i60 */
	149	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '1', 'p') }, /* AVC-Intra 100M 720p24/30/60 */
	150	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '1', 'q') }, /* AVC-Intra 100M 720p25/50 */
	151	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '1', '2') }, /* AVC-Intra 100M 1080p25/50 */
	152	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '1', '3') }, /* AVC-Intra 100M 1080p24/30/60 */
	153	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '1', '5') }, /* AVC-Intra 100M 1080i50 */
	154	+ { AV_CODEC_ID_H264, MKTAG('a', 'i', '1', '6') }, /* AVC-Intra 100M 1080i60 */
	155	+
	156	+ { AV_CODEC_ID_MPEG1VIDEO, MKTAG('m', '1', 'v', '1') }, /* Apple MPEG-1 Camcorder */
	157	+ { AV_CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'e', 'g') }, /* MPEG */
	158	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('m', '2', 'v', '1') }, /* Apple MPEG-2 Camcorder */
	159	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '1') }, /* MPEG2 HDV 720p30 */
	160	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '2') }, /* MPEG2 HDV 1080i60 */
	161	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '3') }, /* MPEG2 HDV 1080i50 */
	162	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '4') }, /* MPEG2 HDV 720p24 */
	163	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '5') }, /* MPEG2 HDV 720p25 */
	164	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '6') }, /* MPEG2 HDV 1080p24 */
	165	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '7') }, /* MPEG2 HDV 1080p25 */
	166	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '8') }, /* MPEG2 HDV 1080p30 */
	167	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '9') }, /* MPEG2 HDV 720p60 JVC */
	168	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', 'a') }, /* MPEG2 HDV 720p50 */
	169	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '5', 'n') }, /* MPEG2 IMX NTSC 525/60 50mb/s produced by FCP */
	170	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '5', 'p') }, /* MPEG2 IMX PAL 625/50 50mb/s produced by FCP */
	171	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '4', 'n') }, /* MPEG2 IMX NTSC 525/60 40mb/s produced by FCP */
	172	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '4', 'p') }, /* MPEG2 IMX PAL 625/50 40mb/s produced by FCP */
	173	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '3', 'n') }, /* MPEG2 IMX NTSC 525/60 30mb/s produced by FCP */
	174	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '3', 'p') }, /* MPEG2 IMX PAL 625/50 30mb/s produced by FCP */
	175	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', '4') }, /* XDCAM HD422 720p24 CBR */
	176	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', '5') }, /* XDCAM HD422 720p25 CBR */
	177	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', '9') }, /* XDCAM HD422 720p60 CBR */
	178	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'a') }, /* XDCAM HD422 720p50 CBR */
	179	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'b') }, /* XDCAM HD422 1080i60 CBR */
	180	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'c') }, /* XDCAM HD422 1080i50 CBR */
	181	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'd') }, /* XDCAM HD422 1080p24 CBR */
	182	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'e') }, /* XDCAM HD422 1080p25 CBR */
	183	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', '5', 'f') }, /* XDCAM HD422 1080p30 CBR */
	184	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '1') }, /* XDCAM EX 720p30 VBR */
	185	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '2') }, /* XDCAM HD 1080i60 */
	186	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '3') }, /* XDCAM HD 1080i50 VBR */
	187	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '4') }, /* XDCAM EX 720p24 VBR */
	188	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '5') }, /* XDCAM EX 720p25 VBR */
	189	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '6') }, /* XDCAM HD 1080p24 VBR */
	190	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '7') }, /* XDCAM HD 1080p25 VBR */
	191	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '8') }, /* XDCAM HD 1080p30 VBR */
	192	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', '9') }, /* XDCAM EX 720p60 VBR */
	193	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'a') }, /* XDCAM EX 720p50 VBR */
	194	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'b') }, /* XDCAM EX 1080i60 VBR */
	195	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'c') }, /* XDCAM EX 1080i50 VBR */
	196	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'd') }, /* XDCAM EX 1080p24 VBR */
	197	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'e') }, /* XDCAM EX 1080p25 VBR */
	198	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'v', 'f') }, /* XDCAM EX 1080p30 VBR */
	199	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'h', 'd') }, /* XDCAM HD 540p */
	200	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('x', 'd', 'h', '2') }, /* XDCAM HD422 540p */
	201	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('A', 'V', 'm', 'p') }, /* AVID IMX PAL */
	202	+
	203	+ { AV_CODEC_ID_JPEG2000, MKTAG('m', 'j', 'p', '2') }, /* JPEG 2000 produced by FCP */
	204	+
	205	+ { AV_CODEC_ID_TARGA, MKTAG('t', 'g', 'a', ' ') }, /* Truevision Targa */
	206	+ { AV_CODEC_ID_TIFF, MKTAG('t', 'i', 'f', 'f') }, /* TIFF embedded in MOV */
	207	+ { AV_CODEC_ID_GIF, MKTAG('g', 'i', 'f', ' ') }, /* embedded gif files as frames (usually one "click to play movie" frame) */
	208	+ { AV_CODEC_ID_PNG, MKTAG('p', 'n', 'g', ' ') },
	209	+
	210	+ { AV_CODEC_ID_VC1, MKTAG('v', 'c', '-', '1') }, /* SMPTE RP 2025 */
	211	+ { AV_CODEC_ID_CAVS, MKTAG('a', 'v', 's', '2') },
	212	+
	213	+ { AV_CODEC_ID_DIRAC, MKTAG('d', 'r', 'a', 'c') },
	214	+ { AV_CODEC_ID_DNXHD, MKTAG('A', 'V', 'd', 'n') }, /* AVID DNxHD */
	215	+ { AV_CODEC_ID_FLV1, MKTAG('H', '2', '6', '3') }, /* Flash Media Server */
	216	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('3', 'I', 'V', 'D') }, /* 3ivx DivX Doctor */
	217	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('A', 'V', '1', 'x') }, /* AVID 1:1x */
	218	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('A', 'V', 'u', 'p') },
	219	+ { AV_CODEC_ID_SGI, MKTAG('s', 'g', 'i', ' ') }, /* SGI */
	220	+ { AV_CODEC_ID_DPX, MKTAG('d', 'p', 'x', ' ') }, /* DPX */
	221	+
	222	+ { AV_CODEC_ID_PRORES, MKTAG('a', 'p', 'c', 'h') }, /* Apple ProRes 422 High Quality */
	223	+ { AV_CODEC_ID_PRORES, MKTAG('a', 'p', 'c', 'n') }, /* Apple ProRes 422 Standard Definition */
	224	+ { AV_CODEC_ID_PRORES, MKTAG('a', 'p', 'c', 's') }, /* Apple ProRes 422 LT */
	225	+ { AV_CODEC_ID_PRORES, MKTAG('a', 'p', 'c', 'o') }, /* Apple ProRes 422 Proxy */
	226	+ { AV_CODEC_ID_PRORES, MKTAG('a', 'p', '4', 'h') }, /* Apple ProRes 4444 */
	227	+
	228	+ { AV_CODEC_ID_NONE, 0 },
229	229	};
230	230
231	231	const AVCodecTag ff_codec_movaudio_tags[] = {
232		− { CODEC_ID_AAC, MKTAG('m', 'p', '4', 'a') },
233		− { CODEC_ID_AC3, MKTAG('a', 'c', '-', '3') }, /* ETSI TS 102 366 Annex F */
234		− { CODEC_ID_AC3, MKTAG('s', 'a', 'c', '3') }, /* Nero Recode */
235		− { CODEC_ID_ADPCM_IMA_QT, MKTAG('i', 'm', 'a', '4') },
236		− { CODEC_ID_ALAC, MKTAG('a', 'l', 'a', 'c') },
237		− { CODEC_ID_AMR_NB, MKTAG('s', 'a', 'm', 'r') }, /* AMR-NB 3gp */
238		− { CODEC_ID_AMR_WB, MKTAG('s', 'a', 'w', 'b') }, /* AMR-WB 3gp */
239		− { CODEC_ID_DTS, MKTAG('d', 't', 's', 'c') }, /* DTS formats prior to DTS-HD */
240		− { CODEC_ID_DTS, MKTAG('d', 't', 's', 'h') }, /* DTS-HD audio formats */
241		− { CODEC_ID_DTS, MKTAG('d', 't', 's', 'l') }, /* DTS-HD Lossless formats */
242		− { CODEC_ID_DTS, MKTAG('D', 'T', 'S', ' ') }, /* non-standard */
243		− { CODEC_ID_EAC3, MKTAG('e', 'c', '-', '3') }, /* ETSI TS 102 366 Annex F (only valid in ISOBMFF) */
244		− { CODEC_ID_DVAUDIO, MKTAG('v', 'd', 'v', 'a') },
245		− { CODEC_ID_DVAUDIO, MKTAG('d', 'v', 'c', 'a') },
246		− { CODEC_ID_GSM, MKTAG('a', 'g', 's', 'm') },
247		− { CODEC_ID_ILBC, MKTAG('i', 'l', 'b', 'c') },
248		− { CODEC_ID_MACE3, MKTAG('M', 'A', 'C', '3') },
249		− { CODEC_ID_MACE6, MKTAG('M', 'A', 'C', '6') },
250		− { CODEC_ID_MP1, MKTAG('.', 'm', 'p', '1') },
251		− { CODEC_ID_MP2, MKTAG('.', 'm', 'p', '2') },
252		− { CODEC_ID_MP3, MKTAG('.', 'm', 'p', '3') },
253		− { CODEC_ID_MP3, 0x6D730055 },
254		− { CODEC_ID_NELLYMOSER, MKTAG('n', 'm', 'o', 's') }, /* Flash Media Server */
255		− { CODEC_ID_PCM_ALAW, MKTAG('a', 'l', 'a', 'w') },
256		− { CODEC_ID_PCM_F32BE, MKTAG('f', 'l', '3', '2') },
257		− { CODEC_ID_PCM_F32LE, MKTAG('f', 'l', '3', '2') },
258		− { CODEC_ID_PCM_F64BE, MKTAG('f', 'l', '6', '4') },
259		− { CODEC_ID_PCM_F64LE, MKTAG('f', 'l', '6', '4') },
260		− { CODEC_ID_PCM_MULAW, MKTAG('u', 'l', 'a', 'w') },
261		− { CODEC_ID_PCM_S16BE, MKTAG('t', 'w', 'o', 's') },
262		− { CODEC_ID_PCM_S16LE, MKTAG('s', 'o', 'w', 't') },
263		− { CODEC_ID_PCM_S16LE, MKTAG('l', 'p', 'c', 'm') },
264		− { CODEC_ID_PCM_S24BE, MKTAG('i', 'n', '2', '4') },
265		− { CODEC_ID_PCM_S24LE, MKTAG('i', 'n', '2', '4') },
266		− { CODEC_ID_PCM_S32BE, MKTAG('i', 'n', '3', '2') },
267		− { CODEC_ID_PCM_S32LE, MKTAG('i', 'n', '3', '2') },
268		− { CODEC_ID_PCM_S8, MKTAG('s', 'o', 'w', 't') },
269		− { CODEC_ID_PCM_U8, MKTAG('r', 'a', 'w', ' ') },
270		− { CODEC_ID_PCM_U8, MKTAG('N', 'O', 'N', 'E') },
271		− { CODEC_ID_QCELP, MKTAG('Q', 'c', 'l', 'p') },
272		− { CODEC_ID_QCELP, MKTAG('Q', 'c', 'l', 'q') },
273		− { CODEC_ID_QCELP, MKTAG('s', 'q', 'c', 'p') }, /* ISO Media fourcc */
274		− { CODEC_ID_QDM2, MKTAG('Q', 'D', 'M', '2') },
275		− { CODEC_ID_QDMC, MKTAG('Q', 'D', 'M', 'C') },
276		− { CODEC_ID_SPEEX, MKTAG('s', 'p', 'e', 'x') }, /* Flash Media Server */
277		− { CODEC_ID_WMAV2, MKTAG('W', 'M', 'A', '2') },
278		− { CODEC_ID_NONE, 0 },
	232	+ { AV_CODEC_ID_AAC, MKTAG('m', 'p', '4', 'a') },
	233	+ { AV_CODEC_ID_AC3, MKTAG('a', 'c', '-', '3') }, /* ETSI TS 102 366 Annex F */
	234	+ { AV_CODEC_ID_AC3, MKTAG('s', 'a', 'c', '3') }, /* Nero Recode */
	235	+ { AV_CODEC_ID_ADPCM_IMA_QT, MKTAG('i', 'm', 'a', '4') },
	236	+ { AV_CODEC_ID_ALAC, MKTAG('a', 'l', 'a', 'c') },
	237	+ { AV_CODEC_ID_AMR_NB, MKTAG('s', 'a', 'm', 'r') }, /* AMR-NB 3gp */
	238	+ { AV_CODEC_ID_AMR_WB, MKTAG('s', 'a', 'w', 'b') }, /* AMR-WB 3gp */
	239	+ { AV_CODEC_ID_DTS, MKTAG('d', 't', 's', 'c') }, /* DTS formats prior to DTS-HD */
	240	+ { AV_CODEC_ID_DTS, MKTAG('d', 't', 's', 'h') }, /* DTS-HD audio formats */
	241	+ { AV_CODEC_ID_DTS, MKTAG('d', 't', 's', 'l') }, /* DTS-HD Lossless formats */
	242	+ { AV_CODEC_ID_DTS, MKTAG('D', 'T', 'S', ' ') }, /* non-standard */
	243	+ { AV_CODEC_ID_EAC3, MKTAG('e', 'c', '-', '3') }, /* ETSI TS 102 366 Annex F (only valid in ISOBMFF) */
	244	+ { AV_CODEC_ID_DVAUDIO, MKTAG('v', 'd', 'v', 'a') },
	245	+ { AV_CODEC_ID_DVAUDIO, MKTAG('d', 'v', 'c', 'a') },
	246	+ { AV_CODEC_ID_GSM, MKTAG('a', 'g', 's', 'm') },
	247	+ { AV_CODEC_ID_ILBC, MKTAG('i', 'l', 'b', 'c') },
	248	+ { AV_CODEC_ID_MACE3, MKTAG('M', 'A', 'C', '3') },
	249	+ { AV_CODEC_ID_MACE6, MKTAG('M', 'A', 'C', '6') },
	250	+ { AV_CODEC_ID_MP1, MKTAG('.', 'm', 'p', '1') },
	251	+ { AV_CODEC_ID_MP2, MKTAG('.', 'm', 'p', '2') },
	252	+ { AV_CODEC_ID_MP3, MKTAG('.', 'm', 'p', '3') },
	253	+ { AV_CODEC_ID_MP3, 0x6D730055 },
	254	+ { AV_CODEC_ID_NELLYMOSER, MKTAG('n', 'm', 'o', 's') }, /* Flash Media Server */
	255	+ { AV_CODEC_ID_PCM_ALAW, MKTAG('a', 'l', 'a', 'w') },
	256	+ { AV_CODEC_ID_PCM_F32BE, MKTAG('f', 'l', '3', '2') },
	257	+ { AV_CODEC_ID_PCM_F32LE, MKTAG('f', 'l', '3', '2') },
	258	+ { AV_CODEC_ID_PCM_F64BE, MKTAG('f', 'l', '6', '4') },
	259	+ { AV_CODEC_ID_PCM_F64LE, MKTAG('f', 'l', '6', '4') },
	260	+ { AV_CODEC_ID_PCM_MULAW, MKTAG('u', 'l', 'a', 'w') },
	261	+ { AV_CODEC_ID_PCM_S16BE, MKTAG('t', 'w', 'o', 's') },
	262	+ { AV_CODEC_ID_PCM_S16LE, MKTAG('s', 'o', 'w', 't') },
	263	+ { AV_CODEC_ID_PCM_S16LE, MKTAG('l', 'p', 'c', 'm') },
	264	+ { AV_CODEC_ID_PCM_S24BE, MKTAG('i', 'n', '2', '4') },
	265	+ { AV_CODEC_ID_PCM_S24LE, MKTAG('i', 'n', '2', '4') },
	266	+ { AV_CODEC_ID_PCM_S32BE, MKTAG('i', 'n', '3', '2') },
	267	+ { AV_CODEC_ID_PCM_S32LE, MKTAG('i', 'n', '3', '2') },
	268	+ { AV_CODEC_ID_PCM_S8, MKTAG('s', 'o', 'w', 't') },
	269	+ { AV_CODEC_ID_PCM_U8, MKTAG('r', 'a', 'w', ' ') },
	270	+ { AV_CODEC_ID_PCM_U8, MKTAG('N', 'O', 'N', 'E') },
	271	+ { AV_CODEC_ID_QCELP, MKTAG('Q', 'c', 'l', 'p') },
	272	+ { AV_CODEC_ID_QCELP, MKTAG('Q', 'c', 'l', 'q') },
	273	+ { AV_CODEC_ID_QCELP, MKTAG('s', 'q', 'c', 'p') }, /* ISO Media fourcc */
	274	+ { AV_CODEC_ID_QDM2, MKTAG('Q', 'D', 'M', '2') },
	275	+ { AV_CODEC_ID_QDMC, MKTAG('Q', 'D', 'M', 'C') },
	276	+ { AV_CODEC_ID_SPEEX, MKTAG('s', 'p', 'e', 'x') }, /* Flash Media Server */
	277	+ { AV_CODEC_ID_WMAV2, MKTAG('W', 'M', 'A', '2') },
	278	+ { AV_CODEC_ID_NONE, 0 },
279	279	};
280	280
281	281	const AVCodecTag ff_codec_movsubtitle_tags[] = {
282		− { CODEC_ID_MOV_TEXT, MKTAG('t', 'e', 'x', 't') },
283		− { CODEC_ID_MOV_TEXT, MKTAG('t', 'x', '3', 'g') },
284		− { CODEC_ID_NONE, 0 },
	282	+ { AV_CODEC_ID_MOV_TEXT, MKTAG('t', 'e', 'x', 't') },
	283	+ { AV_CODEC_ID_MOV_TEXT, MKTAG('t', 'x', '3', 'g') },
	284	+ { AV_CODEC_ID_NONE, 0 },
285	285	};
286	286
287	287	/* map numeric codes from mdhd atom to ISO 639 */
@@ -398,12 +398,12 @@ void ff_mp4_parse_es_descr(AVIOContext pb, int es_id) · 110 unmodified lines
398	398	}
399	399
400	400	static const AVCodecTag mp4_audio_types[] = {
401		− { CODEC_ID_MP3ON4, AOT_PS }, /* old mp3on4 draft */
402		− { CODEC_ID_MP3ON4, AOT_L1 }, /* layer 1 */
403		− { CODEC_ID_MP3ON4, AOT_L2 }, /* layer 2 */
404		− { CODEC_ID_MP3ON4, AOT_L3 }, /* layer 3 */
405		− { CODEC_ID_MP4ALS, AOT_ALS }, /* MPEG-4 ALS */
406		− { CODEC_ID_NONE, AOT_NULL },
	401	+ { AV_CODEC_ID_MP3ON4, AOT_PS }, /* old mp3on4 draft */
	402	+ { AV_CODEC_ID_MP3ON4, AOT_L1 }, /* layer 1 */
	403	+ { AV_CODEC_ID_MP3ON4, AOT_L2 }, /* layer 2 */
	404	+ { AV_CODEC_ID_MP3ON4, AOT_L3 }, /* layer 3 */
	405	+ { AV_CODEC_ID_MP4ALS, AOT_ALS }, /* MPEG-4 ALS */
	406	+ { AV_CODEC_ID_NONE, AOT_NULL },
407	407	};
408	408
409	409	int ff_mp4_read_dec_config_descr(AVFormatContext fc, AVStream st, AVIOContext *pb)
@@ -428,7 +428,7 @@ int ff_mp4_read_dec_config_descr(AVFormatContext fc, AVStream st, AVIOContext · 18 unmodified lines
428	428	return AVERROR(ENOMEM);
429	429	avio_read(pb, st->codec->extradata, len);
430	430	st->codec->extradata_size = len;
431		− if (st->codec->codec_id == CODEC_ID_AAC) {
	431	+ if (st->codec->codec_id == AV_CODEC_ID_AAC) {
432	432	MPEG4AudioConfig cfg;
433	433	avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata,
434	434	st->codec->extradata_size * 8, 1);
@@ -445,7 +445,7 @@ int ff_mp4_read_dec_config_descr(AVFormatContext fc, AVStream st, AVIOContext · 10 unmodified lines
445	445	cfg.sample_rate, cfg.ext_sample_rate);
446	446	if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types,
447	447	cfg.object_type)))
448		− st->codec->codec_id = CODEC_ID_AAC;
	448	+ st->codec->codec_id = AV_CODEC_ID_AAC;
449	449	}
450	450	}
451	451	return 0;

libavformat/isom.h+1−1

@@ -184,7 +184,7 @@ void ff_mp4_parse_es_descr(AVIOContext pb, int es_id); · 183 unmodified lines
184	184	#define MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES 0x01000000
185	185
186	186	int ff_mov_read_esds(AVFormatContext fc, AVIOContext pb, MOVAtom atom);
187		−enum CodecID ff_mov_get_lpcm_codec_id(int bps, int flags);
	187	+enum AVCodecID ff_mov_get_lpcm_codec_id(int bps, int flags);
188	188
189	189	int ff_mov_read_stsd_entries(MOVContext c, AVIOContext pb, int entries);
190	190

libavformat/iss.c+1−1

@@ -93,7 +93,7 @@ static av_cold int iss_read_header(AVFormatContext *s) · 92 unmodified lines
93	93	if (!st)
94	94	return AVERROR(ENOMEM);
95	95	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
96		− st->codec->codec_id = CODEC_ID_ADPCM_IMA_ISS;
	96	+ st->codec->codec_id = AV_CODEC_ID_ADPCM_IMA_ISS;
97	97	st->codec->channels = stereo ? 2 : 1;
98	98	st->codec->sample_rate = 44100;
99	99	if(rate_divisor > 0)

libavformat/iv8.c+1−1

@@ -46,7 +46,7 @@ static int read_header(AVFormatContext *s) · 45 unmodified lines
46	46	return AVERROR(ENOMEM);
47	47
48	48	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
49		− st->codec->codec_id = CODEC_ID_MPEG4;
	49	+ st->codec->codec_id = AV_CODEC_ID_MPEG4;
50	50	st->need_parsing = AVSTREAM_PARSE_FULL;
51	51	avpriv_set_pts_info(st, 64, 1, 90000);
52	52

libavformat/ivfenc.c+3−3

@@ -30,7 +30,7 @@ static int ivf_write_header(AVFormatContext *s) · 29 unmodified lines
30	30	return AVERROR(EINVAL);
31	31	}
32	32	ctx = s->streams[0]->codec;
33		− if (ctx->codec_type != AVMEDIA_TYPE_VIDEO \|\| ctx->codec_id != CODEC_ID_VP8) {
	33	+ if (ctx->codec_type != AVMEDIA_TYPE_VIDEO \|\| ctx->codec_id != AV_CODEC_ID_VP8) {
34	34	av_log(s, AV_LOG_ERROR, "Currently only VP8 is supported!\n");
35	35	return AVERROR(EINVAL);
36	36	}
@@ -62,8 +62,8 @@ AVOutputFormat ff_ivf_muxer = { · 25 unmodified lines
62	62	.name = "ivf",
63	63	.long_name = NULL_IF_CONFIG_SMALL("On2 IVF"),
64	64	.extensions = "ivf",
65		− .audio_codec = CODEC_ID_NONE,
66		− .video_codec = CODEC_ID_VP8,
	65	+ .audio_codec = AV_CODEC_ID_NONE,
	66	+ .video_codec = AV_CODEC_ID_VP8,
67	67	.write_header = ivf_write_header,
68	68	.write_packet = ivf_write_packet,
69	69	};

libavformat/jvdec.c+2−2

@@ -75,7 +75,7 @@ static int read_header(AVFormatContext *s) · 74 unmodified lines
75	75	return AVERROR(ENOMEM);
76	76
77	77	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
78		− vst->codec->codec_id = CODEC_ID_JV;
	78	+ vst->codec->codec_id = AV_CODEC_ID_JV;
79	79	vst->codec->codec_tag = 0; /* no fourcc */
80	80	vst->codec->width = avio_rl16(pb);
81	81	vst->codec->height = avio_rl16(pb);
@@ -87,7 +87,7 @@ static int read_header(AVFormatContext *s) · 5 unmodified lines
87	87	avio_skip(pb, 4);
88	88
89	89	ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
90		− ast->codec->codec_id = CODEC_ID_PCM_U8;
	90	+ ast->codec->codec_id = AV_CODEC_ID_PCM_U8;
91	91	ast->codec->codec_tag = 0; /* no fourcc */
92	92	ast->codec->sample_rate = avio_rl16(pb);
93	93	ast->codec->channels = 1;

libavformat/latmenc.c+2−2

@@ -183,8 +183,8 @@ AVOutputFormat ff_latm_muxer = { · 182 unmodified lines
183	183	.mime_type = "audio/MP4A-LATM",
184	184	.extensions = "latm",
185	185	.priv_data_size = sizeof(LATMContext),
186		− .audio_codec = CODEC_ID_AAC,
187		− .video_codec = CODEC_ID_NONE,
	186	+ .audio_codec = AV_CODEC_ID_AAC,
	187	+ .video_codec = AV_CODEC_ID_NONE,
188	188	.write_header = latm_write_header,
189	189	.write_packet = latm_write_packet,
190	190	.priv_class = &latm_muxer_class,

libavformat/lmlm4.c+2−2

@@ -64,14 +64,14 @@ static int lmlm4_read_header(AVFormatContext *s) { · 63 unmodified lines
64	64	if (!(st = avformat_new_stream(s, NULL)))
65	65	return AVERROR(ENOMEM);
66	66	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
67		− st->codec->codec_id = CODEC_ID_MPEG4;
	67	+ st->codec->codec_id = AV_CODEC_ID_MPEG4;
68	68	st->need_parsing = AVSTREAM_PARSE_HEADERS;
69	69	avpriv_set_pts_info(st, 64, 1001, 30000);
70	70
71	71	if (!(st = avformat_new_stream(s, NULL)))
72	72	return AVERROR(ENOMEM);
73	73	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
74		− st->codec->codec_id = CODEC_ID_MP2;
	74	+ st->codec->codec_id = AV_CODEC_ID_MP2;
75	75	st->need_parsing = AVSTREAM_PARSE_HEADERS;
76	76
77	77	/* the parameters will be extracted from the compressed bitstream */

libavformat/lxfdec.c+17−17

@@ -32,17 +32,17 @@ · 31 unmodified lines
32	32	#define LXF_MAX_AUDIO_PACKET (8008154) ///< 15-channel 32-bit NTSC audio frame
33	33
34	34	static const AVCodecTag lxf_tags[] = {
35		− { CODEC_ID_MJPEG, 0 },
36		− { CODEC_ID_MPEG1VIDEO, 1 },
37		− { CODEC_ID_MPEG2VIDEO, 2 }, //MpMl, 4:2:0
38		− { CODEC_ID_MPEG2VIDEO, 3 }, //MpPl, 4:2:2
39		− { CODEC_ID_DVVIDEO, 4 }, //DV25
40		− { CODEC_ID_DVVIDEO, 5 }, //DVCPRO
41		− { CODEC_ID_DVVIDEO, 6 }, //DVCPRO50
42		− { CODEC_ID_RAWVIDEO, 7 }, //PIX_FMT_ARGB, where alpha is used for chroma keying
43		− { CODEC_ID_RAWVIDEO, 8 }, //16-bit chroma key
44		− { CODEC_ID_MPEG2VIDEO, 9 }, //4:2:2 CBP ("Constrained Bytes per Gop")
45		− { CODEC_ID_NONE, 0 },
	35	+ { AV_CODEC_ID_MJPEG, 0 },
	36	+ { AV_CODEC_ID_MPEG1VIDEO, 1 },
	37	+ { AV_CODEC_ID_MPEG2VIDEO, 2 }, //MpMl, 4:2:0
	38	+ { AV_CODEC_ID_MPEG2VIDEO, 3 }, //MpPl, 4:2:2
	39	+ { AV_CODEC_ID_DVVIDEO, 4 }, //DV25
	40	+ { AV_CODEC_ID_DVVIDEO, 5 }, //DVCPRO
	41	+ { AV_CODEC_ID_DVVIDEO, 6 }, //DVCPRO50
	42	+ { AV_CODEC_ID_RAWVIDEO, 7 }, //PIX_FMT_ARGB, where alpha is used for chroma keying
	43	+ { AV_CODEC_ID_RAWVIDEO, 8 }, //16-bit chroma key
	44	+ { AV_CODEC_ID_MPEG2VIDEO, 9 }, //4:2:2 CBP ("Constrained Bytes per Gop")
	45	+ { AV_CODEC_ID_NONE, 0 },
46	46	};
47	47
48	48	typedef struct {
@@ -159,10 +159,10 @@ static int get_packet_header(AVFormatContext s, uint8_t header, uint32_t *form · 110 unmodified lines
159	159	}
160	160
161	161	switch (st->codec->bits_per_coded_sample) {
162		− case 16: st->codec->codec_id = CODEC_ID_PCM_S16LE; break;
163		− case 20: st->codec->codec_id = CODEC_ID_PCM_LXF; break;
164		− case 24: st->codec->codec_id = CODEC_ID_PCM_S24LE; break;
165		− case 32: st->codec->codec_id = CODEC_ID_PCM_S32LE; break;
	162	+ case 16: st->codec->codec_id = AV_CODEC_ID_PCM_S16LE; break;
	163	+ case 20: st->codec->codec_id = AV_CODEC_ID_PCM_LXF; break;
	164	+ case 24: st->codec->codec_id = AV_CODEC_ID_PCM_S24LE; break;
	165	+ case 32: st->codec->codec_id = AV_CODEC_ID_PCM_S32LE; break;
166	166	default:
167	167	av_log(s, AV_LOG_WARNING,
168	168	"only 16-, 20-, 24- and 32-bit PCM currently supported\n");
@@ -314,7 +314,7 @@ static int lxf_read_packet(AVFormatContext s, AVPacket pkt) · 145 unmodified lines
314	314	return ret2;
315	315
316	316	//read non-20-bit audio data into lxf->temp so we can deplanarize it
317		− buf = ast && ast->codec->codec_id != CODEC_ID_PCM_LXF ? lxf->temp : pkt->data;
	317	+ buf = ast && ast->codec->codec_id != AV_CODEC_ID_PCM_LXF ? lxf->temp : pkt->data;
318	318
319	319	if ((ret2 = avio_read(pb, buf, ret)) != ret) {
320	320	av_free_packet(pkt);
@@ -324,7 +324,7 @@ static int lxf_read_packet(AVFormatContext s, AVPacket pkt) · 3 unmodified lines
324	324	pkt->stream_index = stream;
325	325
326	326	if (ast) {
327		− if(ast->codec->codec_id != CODEC_ID_PCM_LXF)
	327	+ if(ast->codec->codec_id != AV_CODEC_ID_PCM_LXF)
328	328	deplanarize(lxf, ast, pkt->data, ret);
329	329	} else {
330	330	//picture type (0 = closed I, 1 = open I, 2 = P, 3 = B)

libavformat/m4vdec.c+1−1

@@ -49,4 +49,4 @@ static int mpeg4video_probe(AVProbeData *probe_packet) · 48 unmodified lines
49	49	return 0;
50	50	}
51	51
52		−FF_DEF_RAWVIDEO_DEMUXER(m4v, "raw MPEG-4 video", mpeg4video_probe, "m4v", CODEC_ID_MPEG4)
	52	+FF_DEF_RAWVIDEO_DEMUXER(m4v, "raw MPEG-4 video", mpeg4video_probe, "m4v", AV_CODEC_ID_MPEG4)

libavformat/matroska.c+63−63

@@ -22,76 +22,76 @@ · 21 unmodified lines
22	22	#include "matroska.h"
23	23
24	24	const CodecTags ff_mkv_codec_tags[]={
25		− {"A_AAC" , CODEC_ID_AAC},
26		− {"A_AC3" , CODEC_ID_AC3},
27		− {"A_DTS" , CODEC_ID_DTS},
28		− {"A_EAC3" , CODEC_ID_EAC3},
29		− {"A_FLAC" , CODEC_ID_FLAC},
30		− {"A_MLP" , CODEC_ID_MLP},
31		− {"A_MPEG/L2" , CODEC_ID_MP2},
32		− {"A_MPEG/L1" , CODEC_ID_MP2},
33		− {"A_MPEG/L3" , CODEC_ID_MP3},
34		− {"A_PCM/FLOAT/IEEE" , CODEC_ID_PCM_F32LE},
35		− {"A_PCM/FLOAT/IEEE" , CODEC_ID_PCM_F64LE},
36		− {"A_PCM/INT/BIG" , CODEC_ID_PCM_S16BE},
37		− {"A_PCM/INT/BIG" , CODEC_ID_PCM_S24BE},
38		− {"A_PCM/INT/BIG" , CODEC_ID_PCM_S32BE},
39		− {"A_PCM/INT/LIT" , CODEC_ID_PCM_S16LE},
40		− {"A_PCM/INT/LIT" , CODEC_ID_PCM_S24LE},
41		− {"A_PCM/INT/LIT" , CODEC_ID_PCM_S32LE},
42		− {"A_PCM/INT/LIT" , CODEC_ID_PCM_U8},
43		− {"A_QUICKTIME/QDM2" , CODEC_ID_QDM2},
44		− {"A_REAL/14_4" , CODEC_ID_RA_144},
45		− {"A_REAL/28_8" , CODEC_ID_RA_288},
46		− {"A_REAL/ATRC" , CODEC_ID_ATRAC3},
47		− {"A_REAL/COOK" , CODEC_ID_COOK},
48		− {"A_REAL/SIPR" , CODEC_ID_SIPR},
49		− {"A_TRUEHD" , CODEC_ID_TRUEHD},
50		− {"A_TTA1" , CODEC_ID_TTA},
51		− {"A_VORBIS" , CODEC_ID_VORBIS},
52		− {"A_WAVPACK4" , CODEC_ID_WAVPACK},
	25	+ {"A_AAC" , AV_CODEC_ID_AAC},
	26	+ {"A_AC3" , AV_CODEC_ID_AC3},
	27	+ {"A_DTS" , AV_CODEC_ID_DTS},
	28	+ {"A_EAC3" , AV_CODEC_ID_EAC3},
	29	+ {"A_FLAC" , AV_CODEC_ID_FLAC},
	30	+ {"A_MLP" , AV_CODEC_ID_MLP},
	31	+ {"A_MPEG/L2" , AV_CODEC_ID_MP2},
	32	+ {"A_MPEG/L1" , AV_CODEC_ID_MP2},
	33	+ {"A_MPEG/L3" , AV_CODEC_ID_MP3},
	34	+ {"A_PCM/FLOAT/IEEE" , AV_CODEC_ID_PCM_F32LE},
	35	+ {"A_PCM/FLOAT/IEEE" , AV_CODEC_ID_PCM_F64LE},
	36	+ {"A_PCM/INT/BIG" , AV_CODEC_ID_PCM_S16BE},
	37	+ {"A_PCM/INT/BIG" , AV_CODEC_ID_PCM_S24BE},
	38	+ {"A_PCM/INT/BIG" , AV_CODEC_ID_PCM_S32BE},
	39	+ {"A_PCM/INT/LIT" , AV_CODEC_ID_PCM_S16LE},
	40	+ {"A_PCM/INT/LIT" , AV_CODEC_ID_PCM_S24LE},
	41	+ {"A_PCM/INT/LIT" , AV_CODEC_ID_PCM_S32LE},
	42	+ {"A_PCM/INT/LIT" , AV_CODEC_ID_PCM_U8},
	43	+ {"A_QUICKTIME/QDM2" , AV_CODEC_ID_QDM2},
	44	+ {"A_REAL/14_4" , AV_CODEC_ID_RA_144},
	45	+ {"A_REAL/28_8" , AV_CODEC_ID_RA_288},
	46	+ {"A_REAL/ATRC" , AV_CODEC_ID_ATRAC3},
	47	+ {"A_REAL/COOK" , AV_CODEC_ID_COOK},
	48	+ {"A_REAL/SIPR" , AV_CODEC_ID_SIPR},
	49	+ {"A_TRUEHD" , AV_CODEC_ID_TRUEHD},
	50	+ {"A_TTA1" , AV_CODEC_ID_TTA},
	51	+ {"A_VORBIS" , AV_CODEC_ID_VORBIS},
	52	+ {"A_WAVPACK4" , AV_CODEC_ID_WAVPACK},
53	53
54		− {"S_TEXT/UTF8" , CODEC_ID_TEXT},
55		− {"S_TEXT/UTF8" , CODEC_ID_SRT},
56		− {"S_TEXT/ASCII" , CODEC_ID_TEXT},
57		− {"S_TEXT/ASS" , CODEC_ID_SSA},
58		− {"S_TEXT/SSA" , CODEC_ID_SSA},
59		− {"S_ASS" , CODEC_ID_SSA},
60		− {"S_SSA" , CODEC_ID_SSA},
61		− {"S_VOBSUB" , CODEC_ID_DVD_SUBTITLE},
62		− {"S_HDMV/PGS" , CODEC_ID_HDMV_PGS_SUBTITLE},
	54	+ {"S_TEXT/UTF8" , AV_CODEC_ID_TEXT},
	55	+ {"S_TEXT/UTF8" , AV_CODEC_ID_SRT},
	56	+ {"S_TEXT/ASCII" , AV_CODEC_ID_TEXT},
	57	+ {"S_TEXT/ASS" , AV_CODEC_ID_SSA},
	58	+ {"S_TEXT/SSA" , AV_CODEC_ID_SSA},
	59	+ {"S_ASS" , AV_CODEC_ID_SSA},
	60	+ {"S_SSA" , AV_CODEC_ID_SSA},
	61	+ {"S_VOBSUB" , AV_CODEC_ID_DVD_SUBTITLE},
	62	+ {"S_HDMV/PGS" , AV_CODEC_ID_HDMV_PGS_SUBTITLE},
63	63
64		− {"V_DIRAC" , CODEC_ID_DIRAC},
65		− {"V_MJPEG" , CODEC_ID_MJPEG},
66		− {"V_MPEG1" , CODEC_ID_MPEG1VIDEO},
67		− {"V_MPEG2" , CODEC_ID_MPEG2VIDEO},
68		− {"V_MPEG4/ISO/ASP" , CODEC_ID_MPEG4},
69		− {"V_MPEG4/ISO/AP" , CODEC_ID_MPEG4},
70		− {"V_MPEG4/ISO/SP" , CODEC_ID_MPEG4},
71		− {"V_MPEG4/ISO/AVC" , CODEC_ID_H264},
72		− {"V_MPEG4/MS/V3" , CODEC_ID_MSMPEG4V3},
73		− {"V_REAL/RV10" , CODEC_ID_RV10},
74		− {"V_REAL/RV20" , CODEC_ID_RV20},
75		− {"V_REAL/RV30" , CODEC_ID_RV30},
76		− {"V_REAL/RV40" , CODEC_ID_RV40},
77		− {"V_SNOW" , CODEC_ID_SNOW},
78		− {"V_THEORA" , CODEC_ID_THEORA},
79		− {"V_UNCOMPRESSED" , CODEC_ID_RAWVIDEO},
80		− {"V_VP8" , CODEC_ID_VP8},
	64	+ {"V_DIRAC" , AV_CODEC_ID_DIRAC},
	65	+ {"V_MJPEG" , AV_CODEC_ID_MJPEG},
	66	+ {"V_MPEG1" , AV_CODEC_ID_MPEG1VIDEO},
	67	+ {"V_MPEG2" , AV_CODEC_ID_MPEG2VIDEO},
	68	+ {"V_MPEG4/ISO/ASP" , AV_CODEC_ID_MPEG4},
	69	+ {"V_MPEG4/ISO/AP" , AV_CODEC_ID_MPEG4},
	70	+ {"V_MPEG4/ISO/SP" , AV_CODEC_ID_MPEG4},
	71	+ {"V_MPEG4/ISO/AVC" , AV_CODEC_ID_H264},
	72	+ {"V_MPEG4/MS/V3" , AV_CODEC_ID_MSMPEG4V3},
	73	+ {"V_REAL/RV10" , AV_CODEC_ID_RV10},
	74	+ {"V_REAL/RV20" , AV_CODEC_ID_RV20},
	75	+ {"V_REAL/RV30" , AV_CODEC_ID_RV30},
	76	+ {"V_REAL/RV40" , AV_CODEC_ID_RV40},
	77	+ {"V_SNOW" , AV_CODEC_ID_SNOW},
	78	+ {"V_THEORA" , AV_CODEC_ID_THEORA},
	79	+ {"V_UNCOMPRESSED" , AV_CODEC_ID_RAWVIDEO},
	80	+ {"V_VP8" , AV_CODEC_ID_VP8},
81	81
82		− {"" , CODEC_ID_NONE}
	82	+ {"" , AV_CODEC_ID_NONE}
83	83	};
84	84
85	85	const CodecMime ff_mkv_mime_tags[] = {
86		− {"text/plain" , CODEC_ID_TEXT},
87		− {"image/gif" , CODEC_ID_GIF},
88		− {"image/jpeg" , CODEC_ID_MJPEG},
89		− {"image/png" , CODEC_ID_PNG},
90		− {"image/tiff" , CODEC_ID_TIFF},
91		− {"application/x-truetype-font", CODEC_ID_TTF},
92		− {"application/x-font" , CODEC_ID_TTF},
	86	+ {"text/plain" , AV_CODEC_ID_TEXT},
	87	+ {"image/gif" , AV_CODEC_ID_GIF},
	88	+ {"image/jpeg" , AV_CODEC_ID_MJPEG},
	89	+ {"image/png" , AV_CODEC_ID_PNG},
	90	+ {"image/tiff" , AV_CODEC_ID_TIFF},
	91	+ {"application/x-truetype-font", AV_CODEC_ID_TTF},
	92	+ {"application/x-font" , AV_CODEC_ID_TTF},
93	93
94		− {"" , CODEC_ID_NONE}
	94	+ {"" , AV_CODEC_ID_NONE}
95	95	};
96	96
97	97	const AVMetadataConv ff_mkv_metadata_conv[] = {

libavformat/matroska.h+1−1

@@ -243,7 +243,7 @@ typedef enum { · 242 unmodified lines
243	243
244	244	typedef struct CodecTags{
245	245	char str[20];
246		− enum CodecID id;
	246	+ enum AVCodecID id;
247	247	}CodecTags;
248	248
249	249	/* max. depth in the EBML tree structure */

libavformat/matroskadec.c+38−38

@@ -1364,7 +1364,7 @@ static int matroska_read_header(AVFormatContext *s) · 1363 unmodified lines
1364	1364	tracks = matroska->tracks.elem;
1365	1365	for (i=0; i < matroska->tracks.nb_elem; i++) {
1366	1366	MatroskaTrack *track = &tracks[i];
1367		− enum CodecID codec_id = CODEC_ID_NONE;
	1367	+ enum AVCodecID codec_id = AV_CODEC_ID_NONE;
1368	1368	EbmlList *encodings_list = &tracks->encodings;
1369	1369	MatroskaTrackEncoding *encodings = encodings_list->elem;
1370	1370	uint8_t *extradata = NULL;
@@ -1434,7 +1434,7 @@ static int matroska_read_header(AVFormatContext *s) · 63 unmodified lines
1434	1434	}
1435	1435	}
1436	1436
1437		− for(j=0; ff_mkv_codec_tags[j].id != CODEC_ID_NONE; j++){
	1437	+ for(j=0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++){
1438	1438	if(!strncmp(ff_mkv_codec_tags[j].str, track->codec_id,
1439	1439	strlen(ff_mkv_codec_tags[j].str))){
1440	1440	codec_id= ff_mkv_codec_tags[j].id;
@@ -1469,21 +1469,21 @@ static int matroska_read_header(AVFormatContext *s) · 28 unmodified lines
1469	1469	&& (track->codec_priv.data != NULL)) {
1470	1470	track->video.fourcc = AV_RL32(track->codec_priv.data);
1471	1471	codec_id=ff_codec_get_id(ff_codec_movvideo_tags, track->video.fourcc);
1472		− } else if (codec_id == CODEC_ID_PCM_S16BE) {
	1472	+ } else if (codec_id == AV_CODEC_ID_PCM_S16BE) {
1473	1473	switch (track->audio.bitdepth) {
1474		− case 8: codec_id = CODEC_ID_PCM_U8; break;
1475		− case 24: codec_id = CODEC_ID_PCM_S24BE; break;
1476		− case 32: codec_id = CODEC_ID_PCM_S32BE; break;
	1474	+ case 8: codec_id = AV_CODEC_ID_PCM_U8; break;
	1475	+ case 24: codec_id = AV_CODEC_ID_PCM_S24BE; break;
	1476	+ case 32: codec_id = AV_CODEC_ID_PCM_S32BE; break;
1477	1477	}
1478		− } else if (codec_id == CODEC_ID_PCM_S16LE) {
	1478	+ } else if (codec_id == AV_CODEC_ID_PCM_S16LE) {
1479	1479	switch (track->audio.bitdepth) {
1480		− case 8: codec_id = CODEC_ID_PCM_U8; break;
1481		− case 24: codec_id = CODEC_ID_PCM_S24LE; break;
1482		− case 32: codec_id = CODEC_ID_PCM_S32LE; break;
	1480	+ case 8: codec_id = AV_CODEC_ID_PCM_U8; break;
	1481	+ case 24: codec_id = AV_CODEC_ID_PCM_S24LE; break;
	1482	+ case 32: codec_id = AV_CODEC_ID_PCM_S32LE; break;
1483	1483	}
1484		− } else if (codec_id==CODEC_ID_PCM_F32LE && track->audio.bitdepth==64) {
1485		− codec_id = CODEC_ID_PCM_F64LE;
1486		− } else if (codec_id == CODEC_ID_AAC && !track->codec_priv.size) {
	1484	+ } else if (codec_id==AV_CODEC_ID_PCM_F32LE && track->audio.bitdepth==64) {
	1485	+ codec_id = AV_CODEC_ID_PCM_F64LE;
	1486	+ } else if (codec_id == AV_CODEC_ID_AAC && !track->codec_priv.size) {
1487	1487	int profile = matroska_aac_profile(track->codec_id);
1488	1488	int sri = matroska_aac_sri(track->audio.samplerate);
1489	1489	extradata = av_mallocz(5 + FF_INPUT_BUFFER_PADDING_SIZE);
@@ -1499,7 +1499,7 @@ static int matroska_read_header(AVFormatContext *s) · 9 unmodified lines
1499	1499	extradata_size = 5;
1500	1500	} else
1501	1501	extradata_size = 2;
1502		− } else if (codec_id == CODEC_ID_TTA) {
	1502	+ } else if (codec_id == AV_CODEC_ID_TTA) {
1503	1503	extradata_size = 30;
1504	1504	extradata = av_mallocz(extradata_size);
1505	1505	if (extradata == NULL)
@@ -1512,14 +1512,14 @@ static int matroska_read_header(AVFormatContext *s) · 6 unmodified lines
1512	1512	avio_wl16(&b, track->audio.bitdepth);
1513	1513	avio_wl32(&b, track->audio.out_samplerate);
1514	1514	avio_wl32(&b, matroska->ctx->duration * track->audio.out_samplerate);
1515		− } else if (codec_id == CODEC_ID_RV10 \|\| codec_id == CODEC_ID_RV20 \|\|
1516		− codec_id == CODEC_ID_RV30 \|\| codec_id == CODEC_ID_RV40) {
	1515	+ } else if (codec_id == AV_CODEC_ID_RV10 \|\| codec_id == AV_CODEC_ID_RV20 \|\|
	1516	+ codec_id == AV_CODEC_ID_RV30 \|\| codec_id == AV_CODEC_ID_RV40) {
1517	1517	extradata_offset = 26;
1518		− } else if (codec_id == CODEC_ID_RA_144) {
	1518	+ } else if (codec_id == AV_CODEC_ID_RA_144) {
1519	1519	track->audio.out_samplerate = 8000;
1520	1520	track->audio.channels = 1;
1521		− } else if (codec_id == CODEC_ID_RA_288 \|\| codec_id == CODEC_ID_COOK \|\|
1522		− codec_id == CODEC_ID_ATRAC3 \|\| codec_id == CODEC_ID_SIPR) {
	1521	+ } else if (codec_id == AV_CODEC_ID_RA_288 \|\| codec_id == AV_CODEC_ID_COOK \|\|
	1522	+ codec_id == AV_CODEC_ID_ATRAC3 \|\| codec_id == AV_CODEC_ID_SIPR) {
1523	1523	int flavor;
1524	1524	ffio_init_context(&b, track->codec_priv.data,track->codec_priv.size,
1525	1525	0, NULL, NULL, NULL, NULL);
@@ -1531,11 +1531,11 @@ static int matroska_read_header(AVFormatContext *s) · 5 unmodified lines
1531	1531	track->audio.frame_size = avio_rb16(&b);
1532	1532	track->audio.sub_packet_size = avio_rb16(&b);
1533	1533	track->audio.buf = av_malloc(track->audio.frame_size * track->audio.sub_packet_h);
1534		− if (codec_id == CODEC_ID_RA_288) {
	1534	+ if (codec_id == AV_CODEC_ID_RA_288) {
1535	1535	st->codec->block_align = track->audio.coded_framesize;
1536	1536	track->codec_priv.size = 0;
1537	1537	} else {
1538		− if (codec_id == CODEC_ID_SIPR && flavor < 4) {
	1538	+ if (codec_id == AV_CODEC_ID_SIPR && flavor < 4) {
1539	1539	const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 };
1540	1540	track->audio.sub_packet_size = ff_sipr_subpk_size[flavor];
1541	1541	st->codec->bit_rate = sipr_bit_rate[flavor];
@@ -1546,9 +1546,9 @@ static int matroska_read_header(AVFormatContext *s) · 4 unmodified lines
1546	1546	}
1547	1547	track->codec_priv.size -= extradata_offset;
1548	1548
1549		− if (codec_id == CODEC_ID_NONE)
	1549	+ if (codec_id == AV_CODEC_ID_NONE)
1550	1550	av_log(matroska->ctx, AV_LOG_INFO,
1551		− "Unknown/unsupported CodecID %s.\n", track->codec_id);
	1551	+ "Unknown/unsupported AVCodecID %s.\n", track->codec_id);
1552	1552
1553	1553	if (track->time_scale < 0.01)
1554	1554	track->time_scale = 1.0;
@@ -1591,7 +1591,7 @@ static int matroska_read_header(AVFormatContext *s) · 36 unmodified lines
1591	1591	st->codec->height * track->video.display_width,
1592	1592	st->codec-> width * track->video.display_height,
1593	1593	255);
1594		− if (st->codec->codec_id != CODEC_ID_H264)
	1594	+ if (st->codec->codec_id != AV_CODEC_ID_H264)
1595	1595	st->need_parsing = AVSTREAM_PARSE_HEADERS;
1596	1596	if (track->default_duration) {
1597	1597	av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
@@ -1604,11 +1604,11 @@ static int matroska_read_header(AVFormatContext *s) · 6 unmodified lines
1604	1604	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
1605	1605	st->codec->sample_rate = track->audio.out_samplerate;
1606	1606	st->codec->channels = track->audio.channels;
1607		− if (st->codec->codec_id != CODEC_ID_AAC)
	1607	+ if (st->codec->codec_id != AV_CODEC_ID_AAC)
1608	1608	st->need_parsing = AVSTREAM_PARSE_HEADERS;
1609	1609	} else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
1610	1610	st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
1611		− if (st->codec->codec_id == CODEC_ID_SSA)
	1611	+ if (st->codec->codec_id == AV_CODEC_ID_SSA)
1612	1612	matroska->contains_ssa = 1;
1613	1613	}
1614	1614	}
@@ -1624,7 +1624,7 @@ static int matroska_read_header(AVFormatContext *s) · 9 unmodified lines
1624	1624	break;
1625	1625	av_dict_set(&st->metadata, "filename",attachements[j].filename, 0);
1626	1626	av_dict_set(&st->metadata, "mimetype", attachements[j].mime, 0);
1627		− st->codec->codec_id = CODEC_ID_NONE;
	1627	+ st->codec->codec_id = AV_CODEC_ID_NONE;
1628	1628	st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
1629	1629	st->codec->extradata = av_malloc(attachements[j].bin.size);
1630	1630	if(st->codec->extradata == NULL)
@@ -1632,7 +1632,7 @@ static int matroska_read_header(AVFormatContext *s) · 1 unmodified line
1632	1632	st->codec->extradata_size = attachements[j].bin.size;
1633	1633	memcpy(st->codec->extradata, attachements[j].bin.data, attachements[j].bin.size);
1634	1634
1635		− for (i=0; ff_mkv_mime_tags[i].id != CODEC_ID_NONE; i++) {
	1635	+ for (i=0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
1636	1636	if (!strncmp(ff_mkv_mime_tags[i].str, attachements[j].mime,
1637	1637	strlen(ff_mkv_mime_tags[i].str))) {
1638	1638	st->codec->codec_id = ff_mkv_mime_tags[i].id;
@@ -1843,10 +1843,10 @@ static int matroska_parse_block(MatroskaDemuxContext matroska, uint8_t data, · 204 unmodified lines
1843	1843
1844	1844	if (res == 0) {
1845	1845	for (n = 0; n < laces; n++) {
1846		− if ((st->codec->codec_id == CODEC_ID_RA_288 \|\|
1847		− st->codec->codec_id == CODEC_ID_COOK \|\|
1848		− st->codec->codec_id == CODEC_ID_SIPR \|\|
1849		− st->codec->codec_id == CODEC_ID_ATRAC3) &&
	1846	+ if ((st->codec->codec_id == AV_CODEC_ID_RA_288 \|\|
	1847	+ st->codec->codec_id == AV_CODEC_ID_COOK \|\|
	1848	+ st->codec->codec_id == AV_CODEC_ID_SIPR \|\|
	1849	+ st->codec->codec_id == AV_CODEC_ID_ATRAC3) &&
1850	1850	st->codec->block_align && track->audio.sub_packet_size) {
1851	1851	int a = st->codec->block_align;
1852	1852	int sps = track->audio.sub_packet_size;
@@ -1859,7 +1859,7 @@ static int matroska_parse_block(MatroskaDemuxContext matroska, uint8_t data, · 6 unmodified lines
1859	1859	if (!track->audio.pkt_cnt) {
1860	1860	if (track->audio.sub_packet_cnt == 0)
1861	1861	track->audio.buf_timecode = timecode;
1862		− if (st->codec->codec_id == CODEC_ID_RA_288) {
	1862	+ if (st->codec->codec_id == AV_CODEC_ID_RA_288) {
1863	1863	if (size < cfs * h / 2) {
1864	1864	av_log(matroska->ctx, AV_LOG_ERROR,
1865	1865	"Corrupt int4 RM-style audio packet size\n");
@@ -1869,7 +1869,7 @@ static int matroska_parse_block(MatroskaDemuxContext matroska, uint8_t data, · 3 unmodified lines
1869	1869	for (x=0; x<h/2; x++)
1870	1870	memcpy(track->audio.buf+x2w+y*cfs,
1871	1871	data+x*cfs, cfs);
1872		− } else if (st->codec->codec_id == CODEC_ID_SIPR) {
	1872	+ } else if (st->codec->codec_id == AV_CODEC_ID_SIPR) {
1873	1873	if (size < w) {
1874	1874	av_log(matroska->ctx, AV_LOG_ERROR,
1875	1875	"Corrupt sipr RM-style audio packet size\n");
@@ -1889,7 +1889,7 @@ static int matroska_parse_block(MatroskaDemuxContext matroska, uint8_t data, · 13 unmodified lines
1889	1889	}
1890	1890
1891	1891	if (++track->audio.sub_packet_cnt >= h) {
1892		− if (st->codec->codec_id == CODEC_ID_SIPR)
	1892	+ if (st->codec->codec_id == AV_CODEC_ID_SIPR)
1893	1893	ff_rm_reorder_sipr_data(track->audio.buf, h, w);
1894	1894	track->audio.sub_packet_cnt = 0;
1895	1895	track->audio.pkt_cnt = h*w / a;
@@ -1945,19 +1945,19 @@ static int matroska_parse_block(MatroskaDemuxContext matroska, uint8_t data, · 49 unmodified lines
1945	1945	else
1946	1946	pkt->pts = timecode;
1947	1947	pkt->pos = pos;
1948		− if (st->codec->codec_id == CODEC_ID_TEXT)
	1948	+ if (st->codec->codec_id == AV_CODEC_ID_TEXT)
1949	1949	pkt->convergence_duration = duration;
1950	1950	else if (track->type != MATROSKA_TRACK_TYPE_SUBTITLE)
1951	1951	pkt->duration = duration;
1952	1952
1953		− if (st->codec->codec_id == CODEC_ID_SSA)
	1953	+ if (st->codec->codec_id == AV_CODEC_ID_SSA)
1954	1954	matroska_fix_ass_packet(matroska, pkt, duration);
1955	1955
1956	1956	if (matroska->prev_pkt &&
1957	1957	timecode != AV_NOPTS_VALUE &&
1958	1958	matroska->prev_pkt->pts == timecode &&
1959	1959	matroska->prev_pkt->stream_index == st->index &&
1960		− st->codec->codec_id == CODEC_ID_SSA)
	1960	+ st->codec->codec_id == AV_CODEC_ID_SSA)
1961	1961	matroska_merge_packets(matroska->prev_pkt, pkt);
1962	1962	else {
1963	1963	dynarray_add(&matroska->packets,&matroska->num_packets,pkt);

libavformat/matroskaenc.c+25−25

@@ -423,7 +423,7 @@ static int put_xiph_codecpriv(AVFormatContext s, AVIOContext pb, AVCodecContex · 422 unmodified lines
423	423	int first_header_size;
424	424	int j;
425	425
426		− if (codec->codec_id == CODEC_ID_VORBIS)
	426	+ if (codec->codec_id == AV_CODEC_ID_VORBIS)
427	427	first_header_size = 30;
428	428	else
429	429	first_header_size = 42;
@@ -469,11 +469,11 @@ static int mkv_write_codecprivate(AVFormatContext s, AVIOContext pb, AVCodecCo · 39 unmodified lines
469	469	return ret;
470	470
471	471	if (native_id) {
472		− if (codec->codec_id == CODEC_ID_VORBIS \|\| codec->codec_id == CODEC_ID_THEORA)
	472	+ if (codec->codec_id == AV_CODEC_ID_VORBIS \|\| codec->codec_id == AV_CODEC_ID_THEORA)
473	473	ret = put_xiph_codecpriv(s, dyn_cp, codec);
474		− else if (codec->codec_id == CODEC_ID_FLAC)
	474	+ else if (codec->codec_id == AV_CODEC_ID_FLAC)
475	475	ret = ff_flac_write_header(dyn_cp, codec, 1);
476		− else if (codec->codec_id == CODEC_ID_H264)
	476	+ else if (codec->codec_id == AV_CODEC_ID_H264)
477	477	ret = ff_isom_write_avcc(dyn_cp, codec->extradata, codec->extradata_size);
478	478	else if (codec->extradata_size)
479	479	avio_write(dyn_cp, codec->extradata, codec->extradata_size);
@@ -544,7 +544,7 @@ static int mkv_write_tracks(AVFormatContext *s) · 64 unmodified lines
544	544	if (!bit_depth)
545	545	bit_depth = av_get_bytes_per_sample(codec->sample_fmt) << 3;
546	546
547		− if (codec->codec_id == CODEC_ID_AAC)
	547	+ if (codec->codec_id == AV_CODEC_ID_AAC)
548	548	get_aac_sample_rates(s, codec, &sample_rate, &output_sample_rate);
549	549
550	550	track = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0);
@@ -562,7 +562,7 @@ static int mkv_write_tracks(AVFormatContext *s) · 11 unmodified lines
562	562
563	563	// look for a codec ID string specific to mkv to use,
564	564	// if none are found, use AVI codes
565		− for (j = 0; ff_mkv_codec_tags[j].id != CODEC_ID_NONE; j++) {
	565	+ for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
566	566	if (ff_mkv_codec_tags[j].id == codec->codec_id) {
567	567	put_ebml_string(pb, MATROSKA_ID_CODECID, ff_mkv_codec_tags[j].str);
568	568	native_id = 1;
@@ -570,8 +570,8 @@ static int mkv_write_tracks(AVFormatContext *s) · 1 unmodified line
570	570	}
571	571	}
572	572
573		− if (mkv->mode == MODE_WEBM && !(codec->codec_id == CODEC_ID_VP8 \|\|
574		− codec->codec_id == CODEC_ID_VORBIS)) {
	573	+ if (mkv->mode == MODE_WEBM && !(codec->codec_id == AV_CODEC_ID_VP8 \|\|
	574	+ codec->codec_id == AV_CODEC_ID_VORBIS)) {
575	575	av_log(s, AV_LOG_ERROR,
576	576	"Only VP8 video and Vorbis audio are supported for WebM.\n");
577	577	return AVERROR(EINVAL);
@@ -585,9 +585,9 @@ static int mkv_write_tracks(AVFormatContext *s) · 7 unmodified lines
585	585	if (!native_id &&
586	586	ff_codec_get_tag(ff_codec_movvideo_tags, codec->codec_id) &&
587	587	(!ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id)
588		− \|\| codec->codec_id == CODEC_ID_SVQ1
589		− \|\| codec->codec_id == CODEC_ID_SVQ3
590		− \|\| codec->codec_id == CODEC_ID_CINEPAK))
	588	+ \|\| codec->codec_id == AV_CODEC_ID_SVQ1
	589	+ \|\| codec->codec_id == AV_CODEC_ID_SVQ3
	590	+ \|\| codec->codec_id == AV_CODEC_ID_CINEPAK))
591	591	qt_id = 1;
592	592
593	593	if (qt_id)
@@ -848,9 +848,9 @@ static int mkv_write_attachments(AVFormatContext *s) · 254 unmodified lines
848	848	put_ebml_string(pb, MATROSKA_ID_FILENAME, t->value);
849	849	if (t = av_dict_get(st->metadata, "mimetype", NULL, 0))
850	850	mimetype = t->value;
851		− else if (st->codec->codec_id != CODEC_ID_NONE ) {
	851	+ else if (st->codec->codec_id != AV_CODEC_ID_NONE ) {
852	852	int i;
853		− for (i = 0; ff_mkv_mime_tags[i].id != CODEC_ID_NONE; i++)
	853	+ for (i = 0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++)
854	854	if (ff_mkv_mime_tags[i].id == st->codec->codec_id) {
855	855	mimetype = ff_mkv_mime_tags[i].str;
856	856	break;
@@ -1046,7 +1046,7 @@ static void mkv_write_block(AVFormatContext s, AVIOContext pb, · 189 unmodified lines
1046	1046	av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, "
1047	1047	"pts %" PRId64 ", dts %" PRId64 ", duration %d, flags %d\n",
1048	1048	avio_tell(pb), pkt->size, pkt->pts, pkt->dts, pkt->duration, flags);
1049		− if (codec->codec_id == CODEC_ID_H264 && codec->extradata_size > 0 &&
	1049	+ if (codec->codec_id == AV_CODEC_ID_H264 && codec->extradata_size > 0 &&
1050	1050	(AV_RB24(codec->extradata) == 1 \|\| AV_RB32(codec->extradata) == 1))
1051	1051	ff_avc_parse_nal_units_buf(pkt->data, &data, &size);
1052	1052	else
@@ -1141,9 +1141,9 @@ static int mkv_write_packet_internal(AVFormatContext s, AVPacket pkt) · 88 unmodified lines
1141	1141
1142	1142	if (codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1143	1143	mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7);
1144		− } else if (codec->codec_id == CODEC_ID_SSA) {
	1144	+ } else if (codec->codec_id == AV_CODEC_ID_SSA) {
1145	1145	duration = mkv_write_ass_blocks(s, pb, pkt);
1146		− } else if (codec->codec_id == CODEC_ID_SRT) {
	1146	+ } else if (codec->codec_id == AV_CODEC_ID_SRT) {
1147	1147	duration = mkv_write_srt_blocks(s, pb, pkt);
1148	1148	} else {
1149	1149	ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(pkt->size));
@@ -1269,10 +1269,10 @@ static int mkv_write_trailer(AVFormatContext *s) · 119 unmodified lines
1269	1269	return 0;
1270	1270	}
1271	1271
1272		−static int mkv_query_codec(enum CodecID codec_id, int std_compliance)
	1272	+static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
1273	1273	{
1274	1274	int i;
1275		− for (i = 0; ff_mkv_codec_tags[i].id != CODEC_ID_NONE; i++)
	1275	+ for (i = 0; ff_mkv_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
1276	1276	if (ff_mkv_codec_tags[i].id == codec_id)
1277	1277	return 1;
1278	1278
@@ -1293,9 +1293,9 @@ AVOutputFormat ff_matroska_muxer = { · 14 unmodified lines
1293	1293	.extensions = "mkv",
1294	1294	.priv_data_size = sizeof(MatroskaMuxContext),
1295	1295	.audio_codec = CONFIG_LIBVORBIS_ENCODER ?
1296		− CODEC_ID_VORBIS : CODEC_ID_AC3,
	1296	+ AV_CODEC_ID_VORBIS : AV_CODEC_ID_AC3,
1297	1297	.video_codec = CONFIG_LIBX264_ENCODER ?
1298		− CODEC_ID_H264 : CODEC_ID_MPEG4,
	1298	+ AV_CODEC_ID_H264 : AV_CODEC_ID_MPEG4,
1299	1299	.write_header = mkv_write_header,
1300	1300	.write_packet = mkv_write_packet,
1301	1301	.write_trailer = mkv_write_trailer,
@@ -1304,7 +1304,7 @@ AVOutputFormat ff_matroska_muxer = { · 2 unmodified lines
1304	1304	.codec_tag = (const AVCodecTag* const []){
1305	1305	ff_codec_bmp_tags, ff_codec_wav_tags, 0
1306	1306	},
1307		− .subtitle_codec = CODEC_ID_SSA,
	1307	+ .subtitle_codec = AV_CODEC_ID_SSA,
1308	1308	.query_codec = mkv_query_codec,
1309	1309	};
1310	1310	#endif
@@ -1316,8 +1316,8 @@ AVOutputFormat ff_webm_muxer = { · 5 unmodified lines
1316	1316	.mime_type = "video/webm",
1317	1317	.extensions = "webm",
1318	1318	.priv_data_size = sizeof(MatroskaMuxContext),
1319		− .audio_codec = CODEC_ID_VORBIS,
1320		− .video_codec = CODEC_ID_VP8,
	1319	+ .audio_codec = AV_CODEC_ID_VORBIS,
	1320	+ .video_codec = AV_CODEC_ID_VP8,
1321	1321	.write_header = mkv_write_header,
1322	1322	.write_packet = mkv_write_packet,
1323	1323	.write_trailer = mkv_write_trailer,
@@ -1334,8 +1334,8 @@ AVOutputFormat ff_matroska_audio_muxer = { · 10 unmodified lines
1334	1334	.extensions = "mka",
1335	1335	.priv_data_size = sizeof(MatroskaMuxContext),
1336	1336	.audio_codec = CONFIG_LIBVORBIS_ENCODER ?
1337		− CODEC_ID_VORBIS : CODEC_ID_AC3,
1338		− .video_codec = CODEC_ID_NONE,
	1337	+ AV_CODEC_ID_VORBIS : AV_CODEC_ID_AC3,
	1338	+ .video_codec = AV_CODEC_ID_NONE,
1339	1339	.write_header = mkv_write_header,
1340	1340	.write_packet = mkv_write_packet,
1341	1341	.write_trailer = mkv_write_trailer,

libavformat/md5enc.c+4−4

@@ -71,8 +71,8 @@ AVOutputFormat ff_md5_muxer = { · 70 unmodified lines
71	71	.long_name = NULL_IF_CONFIG_SMALL("MD5 testing"),
72	72	.extensions = "",
73	73	.priv_data_size = PRIVSIZE,
74		− .audio_codec = CODEC_ID_PCM_S16LE,
75		− .video_codec = CODEC_ID_RAWVIDEO,
	74	+ .audio_codec = AV_CODEC_ID_PCM_S16LE,
	75	+ .video_codec = AV_CODEC_ID_RAWVIDEO,
76	76	.write_header = write_header,
77	77	.write_packet = write_packet,
78	78	.write_trailer = write_trailer,
@@ -102,8 +102,8 @@ AVOutputFormat ff_framemd5_muxer = { · 23 unmodified lines
102	102	.long_name = NULL_IF_CONFIG_SMALL("Per-frame MD5 testing"),
103	103	.extensions = "",
104	104	.priv_data_size = PRIVSIZE,
105		− .audio_codec = CODEC_ID_PCM_S16LE,
106		− .video_codec = CODEC_ID_RAWVIDEO,
	105	+ .audio_codec = AV_CODEC_ID_PCM_S16LE,
	106	+ .video_codec = AV_CODEC_ID_RAWVIDEO,
107	107	.write_header = ff_framehash_write_header,
108	108	.write_packet = framemd5_write_packet,
109	109	.flags = AVFMT_VARIABLE_FPS \| AVFMT_TS_NONSTRICT,

libavformat/mm.c+2−2

@@ -109,7 +109,7 @@ static int read_header(AVFormatContext *s) · 108 unmodified lines
109	109	if (!st)
110	110	return AVERROR(ENOMEM);
111	111	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
112		− st->codec->codec_id = CODEC_ID_MMVIDEO;
	112	+ st->codec->codec_id = AV_CODEC_ID_MMVIDEO;
113	113	st->codec->codec_tag = 0; /* no fourcc */
114	114	st->codec->width = width;
115	115	st->codec->height = height;
@@ -122,7 +122,7 @@ static int read_header(AVFormatContext *s) · 6 unmodified lines
122	122	return AVERROR(ENOMEM);
123	123	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
124	124	st->codec->codec_tag = 0; /* no fourcc */
125		− st->codec->codec_id = CODEC_ID_PCM_U8;
	125	+ st->codec->codec_id = AV_CODEC_ID_PCM_U8;
126	126	st->codec->channels = 1;
127	127	st->codec->sample_rate = 8000;
128	128	avpriv_set_pts_info(st, 64, 1, 8000); /* 8000 hz */

libavformat/mmf.c+3−3

@@ -246,7 +246,7 @@ static int mmf_read_header(AVFormatContext *s) · 245 unmodified lines
246	246	return AVERROR(ENOMEM);
247	247
248	248	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
249		− st->codec->codec_id = CODEC_ID_ADPCM_YAMAHA;
	249	+ st->codec->codec_id = AV_CODEC_ID_ADPCM_YAMAHA;
250	250	st->codec->sample_rate = rate;
251	251	st->codec->channels = 1;
252	252	st->codec->bits_per_coded_sample = 4;
@@ -307,8 +307,8 @@ AVOutputFormat ff_mmf_muxer = { · 54 unmodified lines
307	307	.mime_type = "application/vnd.smaf",
308	308	.extensions = "mmf",
309	309	.priv_data_size = sizeof(MMFContext),
310		− .audio_codec = CODEC_ID_ADPCM_YAMAHA,
311		− .video_codec = CODEC_ID_NONE,
	310	+ .audio_codec = AV_CODEC_ID_ADPCM_YAMAHA,
	311	+ .video_codec = AV_CODEC_ID_NONE,
312	312	.write_header = mmf_write_header,
313	313	.write_packet = mmf_write_packet,
314	314	.write_trailer = mmf_write_trailer,

libavformat/mov.c+59−59

@@ -171,13 +171,13 @@ static int mov_read_covr(MOVContext c, AVIOContext pb, int type, int len) · 170 unmodified lines
171	171	AVPacket pkt;
172	172	AVStream *st;
173	173	MOVStreamContext *sc;
174		− enum CodecID id;
	174	+ enum AVCodecID id;
175	175	int ret;
176	176
177	177	switch (type) {
178		− case 0xd: id = CODEC_ID_MJPEG; break;
179		− case 0xe: id = CODEC_ID_PNG; break;
180		− case 0x1b: id = CODEC_ID_BMP; break;
	178	+ case 0xd: id = AV_CODEC_ID_MJPEG; break;
	179	+ case 0xe: id = AV_CODEC_ID_PNG; break;
	180	+ case 0x1b: id = AV_CODEC_ID_BMP; break;
181	181	default:
182	182	av_log(c->fc, AV_LOG_WARNING, "Unknown cover type: 0x%x.\n", type);
183	183	avio_skip(pb, len);
@@ -482,7 +482,7 @@ static int mov_read_hdlr(MOVContext c, AVIOContext pb, MOVAtom atom) · 298 unmodified lines
482	482	else if (type == MKTAG('s','o','u','n'))
483	483	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
484	484	else if (type == MKTAG('m','1','a',' '))
485		− st->codec->codec_id = CODEC_ID_MP2;
	485	+ st->codec->codec_id = AV_CODEC_ID_MP2;
486	486	else if ((type == MKTAG('s','u','b','p')) \|\| (type == MKTAG('c','l','c','p')))
487	487	st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
488	488
@@ -813,17 +813,17 @@ static int mov_read_enda(MOVContext c, AVIOContext pb, MOVAtom atom) · 324 unmodified lines
813	813	av_dlog(c->fc, "enda %d\n", little_endian);
814	814	if (little_endian == 1) {
815	815	switch (st->codec->codec_id) {
816		− case CODEC_ID_PCM_S24BE:
817		− st->codec->codec_id = CODEC_ID_PCM_S24LE;
	816	+ case AV_CODEC_ID_PCM_S24BE:
	817	+ st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
818	818	break;
819		− case CODEC_ID_PCM_S32BE:
820		− st->codec->codec_id = CODEC_ID_PCM_S32LE;
	819	+ case AV_CODEC_ID_PCM_S32BE:
	820	+ st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
821	821	break;
822		− case CODEC_ID_PCM_F32BE:
823		− st->codec->codec_id = CODEC_ID_PCM_F32LE;
	822	+ case AV_CODEC_ID_PCM_F32BE:
	823	+ st->codec->codec_id = AV_CODEC_ID_PCM_F32LE;
824	824	break;
825		− case CODEC_ID_PCM_F64BE:
826		− st->codec->codec_id = CODEC_ID_PCM_F64LE;
	825	+ case AV_CODEC_ID_PCM_F64BE:
	826	+ st->codec->codec_id = AV_CODEC_ID_PCM_F64LE;
827	827	break;
828	828	default:
829	829	break;
@@ -902,7 +902,7 @@ static int mov_read_wave(MOVContext c, AVIOContext pb, MOVAtom atom) · 72 unmodified lines
902	902	if ((uint64_t)atom.size > (1<<30))
903	903	return AVERROR_INVALIDDATA;
904	904
905		− if (st->codec->codec_id == CODEC_ID_QDM2 \|\| st->codec->codec_id == CODEC_ID_QDMC) {
	905	+ if (st->codec->codec_id == AV_CODEC_ID_QDM2 \|\| st->codec->codec_id == AV_CODEC_ID_QDMC) {
906	906	// pass all frma atom to codec, needed at least for QDMC and QDM2
907	907	av_free(st->codec->extradata);
908	908	st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);
@@ -1048,35 +1048,35 @@ static int mov_read_stco(MOVContext c, AVIOContext pb, MOVAtom atom) · 139 unmodified lines
1048	1048	* Compute codec id for 'lpcm' tag.
1049	1049	* See CoreAudioTypes and AudioStreamBasicDescription at Apple.
1050	1050	*/
1051		−enum CodecID ff_mov_get_lpcm_codec_id(int bps, int flags)
	1051	+enum AVCodecID ff_mov_get_lpcm_codec_id(int bps, int flags)
1052	1052	{
1053	1053	if (flags & 1) { // floating point
1054	1054	if (flags & 2) { // big endian
1055		− if (bps == 32) return CODEC_ID_PCM_F32BE;
1056		− else if (bps == 64) return CODEC_ID_PCM_F64BE;
	1055	+ if (bps == 32) return AV_CODEC_ID_PCM_F32BE;
	1056	+ else if (bps == 64) return AV_CODEC_ID_PCM_F64BE;
1057	1057	} else {
1058		− if (bps == 32) return CODEC_ID_PCM_F32LE;
1059		− else if (bps == 64) return CODEC_ID_PCM_F64LE;
	1058	+ if (bps == 32) return AV_CODEC_ID_PCM_F32LE;
	1059	+ else if (bps == 64) return AV_CODEC_ID_PCM_F64LE;
1060	1060	}
1061	1061	} else {
1062	1062	if (flags & 2) {
1063	1063	if (bps == 8)
1064	1064	// signed integer
1065		− if (flags & 4) return CODEC_ID_PCM_S8;
1066		− else return CODEC_ID_PCM_U8;
1067		− else if (bps == 16) return CODEC_ID_PCM_S16BE;
1068		− else if (bps == 24) return CODEC_ID_PCM_S24BE;
1069		− else if (bps == 32) return CODEC_ID_PCM_S32BE;
	1065	+ if (flags & 4) return AV_CODEC_ID_PCM_S8;
	1066	+ else return AV_CODEC_ID_PCM_U8;
	1067	+ else if (bps == 16) return AV_CODEC_ID_PCM_S16BE;
	1068	+ else if (bps == 24) return AV_CODEC_ID_PCM_S24BE;
	1069	+ else if (bps == 32) return AV_CODEC_ID_PCM_S32BE;
1070	1070	} else {
1071	1071	if (bps == 8)
1072		− if (flags & 4) return CODEC_ID_PCM_S8;
1073		− else return CODEC_ID_PCM_U8;
1074		− else if (bps == 16) return CODEC_ID_PCM_S16LE;
1075		− else if (bps == 24) return CODEC_ID_PCM_S24LE;
1076		− else if (bps == 32) return CODEC_ID_PCM_S32LE;
	1072	+ if (flags & 4) return AV_CODEC_ID_PCM_S8;
	1073	+ else return AV_CODEC_ID_PCM_U8;
	1074	+ else if (bps == 16) return AV_CODEC_ID_PCM_S16LE;
	1075	+ else if (bps == 24) return AV_CODEC_ID_PCM_S24LE;
	1076	+ else if (bps == 32) return AV_CODEC_ID_PCM_S32LE;
1077	1077	}
1078	1078	}
1079		− return CODEC_ID_NONE;
	1079	+ return AV_CODEC_ID_NONE;
1080	1080	}
1081	1081
1082	1082	int ff_mov_read_stsd_entries(MOVContext c, AVIOContext pb, int entries)
@@ -1092,7 +1092,7 @@ int ff_mov_read_stsd_entries(MOVContext c, AVIOContext pb, int entries) · 9 unmodified lines
1092	1092
1093	1093	for (pseudo_stream_id=0; pseudo_stream_id<entries; pseudo_stream_id++) {
1094	1094	//Parsing Sample description table
1095		− enum CodecID id;
	1095	+ enum AVCodecID id;
1096	1096	int dref_id = 1;
1097	1097	MOVAtom a = { AV_RL32("stsd") };
1098	1098	int64_t start_pos = avio_tell(pb);
@@ -1293,34 +1293,34 @@ int ff_mov_read_stsd_entries(MOVContext c, AVIOContext pb, int entries) · 194 unmodified lines
1293	1293	}
1294	1294
1295	1295	switch (st->codec->codec_id) {
1296		− case CODEC_ID_PCM_S8:
1297		− case CODEC_ID_PCM_U8:
	1296	+ case AV_CODEC_ID_PCM_S8:
	1297	+ case AV_CODEC_ID_PCM_U8:
1298	1298	if (st->codec->bits_per_coded_sample == 16)
1299		− st->codec->codec_id = CODEC_ID_PCM_S16BE;
	1299	+ st->codec->codec_id = AV_CODEC_ID_PCM_S16BE;
1300	1300	break;
1301		− case CODEC_ID_PCM_S16LE:
1302		− case CODEC_ID_PCM_S16BE:
	1301	+ case AV_CODEC_ID_PCM_S16LE:
	1302	+ case AV_CODEC_ID_PCM_S16BE:
1303	1303	if (st->codec->bits_per_coded_sample == 8)
1304		− st->codec->codec_id = CODEC_ID_PCM_S8;
	1304	+ st->codec->codec_id = AV_CODEC_ID_PCM_S8;
1305	1305	else if (st->codec->bits_per_coded_sample == 24)
1306	1306	st->codec->codec_id =
1307		− st->codec->codec_id == CODEC_ID_PCM_S16BE ?
1308		− CODEC_ID_PCM_S24BE : CODEC_ID_PCM_S24LE;
	1307	+ st->codec->codec_id == AV_CODEC_ID_PCM_S16BE ?
	1308	+ AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
1309	1309	break;
1310	1310	/* set values for old format before stsd version 1 appeared */
1311		− case CODEC_ID_MACE3:
	1311	+ case AV_CODEC_ID_MACE3:
1312	1312	sc->samples_per_frame = 6;
1313	1313	sc->bytes_per_frame = 2*st->codec->channels;
1314	1314	break;
1315		− case CODEC_ID_MACE6:
	1315	+ case AV_CODEC_ID_MACE6:
1316	1316	sc->samples_per_frame = 6;
1317	1317	sc->bytes_per_frame = 1*st->codec->channels;
1318	1318	break;
1319		− case CODEC_ID_ADPCM_IMA_QT:
	1319	+ case AV_CODEC_ID_ADPCM_IMA_QT:
1320	1320	sc->samples_per_frame = 64;
1321	1321	sc->bytes_per_frame = 34*st->codec->channels;
1322	1322	break;
1323		− case CODEC_ID_GSM:
	1323	+ case AV_CODEC_ID_GSM:
1324	1324	sc->samples_per_frame = 160;
1325	1325	sc->bytes_per_frame = 33;
1326	1326	break;
@@ -1362,7 +1362,7 @@ int ff_mov_read_stsd_entries(MOVContext c, AVIOContext pb, int entries) · 35 unmodified lines
1362	1362	/* special codec parameters handling */
1363	1363	switch (st->codec->codec_id) {
1364	1364	#if CONFIG_DV_DEMUXER
1365		− case CODEC_ID_DVAUDIO:
	1365	+ case AV_CODEC_ID_DVAUDIO:
1366	1366	c->dv_fctx = avformat_alloc_context();
1367	1367	c->dv_demux = avpriv_dv_init_demux(c->dv_fctx);
1368	1368	if (!c->dv_demux) {
@@ -1370,43 +1370,43 @@ int ff_mov_read_stsd_entries(MOVContext c, AVIOContext pb, int entries) · 1 unmodified line
1370	1370	return AVERROR(ENOMEM);
1371	1371	}
1372	1372	sc->dv_audio_container = 1;
1373		− st->codec->codec_id = CODEC_ID_PCM_S16LE;
	1373	+ st->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
1374	1374	break;
1375	1375	#endif
1376	1376	/* no ifdef since parameters are always those */
1377		− case CODEC_ID_QCELP:
	1377	+ case AV_CODEC_ID_QCELP:
1378	1378	// force sample rate for qcelp when not stored in mov
1379	1379	if (st->codec->codec_tag != MKTAG('Q','c','l','p'))
1380	1380	st->codec->sample_rate = 8000;
1381	1381	st->codec->channels= 1; /* really needed */
1382	1382	break;
1383		− case CODEC_ID_AMR_NB:
	1383	+ case AV_CODEC_ID_AMR_NB:
1384	1384	st->codec->channels= 1; /* really needed */
1385	1385	/* force sample rate for amr, stsd in 3gp does not store sample rate */
1386	1386	st->codec->sample_rate = 8000;
1387	1387	break;
1388		− case CODEC_ID_AMR_WB:
	1388	+ case AV_CODEC_ID_AMR_WB:
1389	1389	st->codec->channels = 1;
1390	1390	st->codec->sample_rate = 16000;
1391	1391	break;
1392		− case CODEC_ID_MP2:
1393		− case CODEC_ID_MP3:
	1392	+ case AV_CODEC_ID_MP2:
	1393	+ case AV_CODEC_ID_MP3:
1394	1394	st->codec->codec_type = AVMEDIA_TYPE_AUDIO; /* force type after stsd for m1a hdlr */
1395	1395	st->need_parsing = AVSTREAM_PARSE_FULL;
1396	1396	break;
1397		− case CODEC_ID_GSM:
1398		− case CODEC_ID_ADPCM_MS:
1399		− case CODEC_ID_ADPCM_IMA_WAV:
1400		− case CODEC_ID_ILBC:
	1397	+ case AV_CODEC_ID_GSM:
	1398	+ case AV_CODEC_ID_ADPCM_MS:
	1399	+ case AV_CODEC_ID_ADPCM_IMA_WAV:
	1400	+ case AV_CODEC_ID_ILBC:
1401	1401	st->codec->block_align = sc->bytes_per_frame;
1402	1402	break;
1403		− case CODEC_ID_ALAC:
	1403	+ case AV_CODEC_ID_ALAC:
1404	1404	if (st->codec->extradata_size == 36) {
1405	1405	st->codec->channels = AV_RB8 (st->codec->extradata+21);
1406	1406	st->codec->sample_rate = AV_RB32(st->codec->extradata+32);
1407	1407	}
1408	1408	break;
1409		− case CODEC_ID_VC1:
	1409	+ case AV_CODEC_ID_VC1:
1410	1410	st->need_parsing = AVSTREAM_PARSE_FULL;
1411	1411	break;
1412	1412	default:
@@ -1993,13 +1993,13 @@ static int mov_read_trak(MOVContext c, AVIOContext pb, MOVAtom atom) · 580 unmodified lines
1993	1993
1994	1994	switch (st->codec->codec_id) {
1995	1995	#if CONFIG_H261_DECODER
1996		− case CODEC_ID_H261:
	1996	+ case AV_CODEC_ID_H261:
1997	1997	#endif
1998	1998	#if CONFIG_H263_DECODER
1999		− case CODEC_ID_H263:
	1999	+ case AV_CODEC_ID_H263:
2000	2000	#endif
2001	2001	#if CONFIG_MPEG4_DECODER
2002		− case CODEC_ID_MPEG4:
	2002	+ case AV_CODEC_ID_MPEG4:
2003	2003	#endif
2004	2004	st->codec->width = 0; /* let decoder init width/height */
2005	2005	st->codec->height= 0;

libavformat/mov_chan.c+20−20

@@ -429,25 +429,25 @@ static const enum MovChannelLayoutTag mov_ch_layouts_wav[] = { · 428 unmodified lines
429	429	};
430	430
431	431	static const struct {
432		− enum CodecID codec_id;
	432	+ enum AVCodecID codec_id;
433	433	const enum MovChannelLayoutTag *layouts;
434	434	} mov_codec_ch_layouts[] = {
435		− { CODEC_ID_AAC, mov_ch_layouts_aac },
436		− { CODEC_ID_AC3, mov_ch_layouts_ac3 },
437		− { CODEC_ID_ALAC, mov_ch_layouts_alac },
438		− { CODEC_ID_PCM_U8, mov_ch_layouts_wav },
439		− { CODEC_ID_PCM_S8, mov_ch_layouts_wav },
440		− { CODEC_ID_PCM_S16LE, mov_ch_layouts_wav },
441		− { CODEC_ID_PCM_S16BE, mov_ch_layouts_wav },
442		− { CODEC_ID_PCM_S24LE, mov_ch_layouts_wav },
443		− { CODEC_ID_PCM_S24BE, mov_ch_layouts_wav },
444		− { CODEC_ID_PCM_S32LE, mov_ch_layouts_wav },
445		− { CODEC_ID_PCM_S32BE, mov_ch_layouts_wav },
446		− { CODEC_ID_PCM_F32LE, mov_ch_layouts_wav },
447		− { CODEC_ID_PCM_F32BE, mov_ch_layouts_wav },
448		− { CODEC_ID_PCM_F64LE, mov_ch_layouts_wav },
449		− { CODEC_ID_PCM_F64BE, mov_ch_layouts_wav },
450		− { CODEC_ID_NONE, NULL },
	435	+ { AV_CODEC_ID_AAC, mov_ch_layouts_aac },
	436	+ { AV_CODEC_ID_AC3, mov_ch_layouts_ac3 },
	437	+ { AV_CODEC_ID_ALAC, mov_ch_layouts_alac },
	438	+ { AV_CODEC_ID_PCM_U8, mov_ch_layouts_wav },
	439	+ { AV_CODEC_ID_PCM_S8, mov_ch_layouts_wav },
	440	+ { AV_CODEC_ID_PCM_S16LE, mov_ch_layouts_wav },
	441	+ { AV_CODEC_ID_PCM_S16BE, mov_ch_layouts_wav },
	442	+ { AV_CODEC_ID_PCM_S24LE, mov_ch_layouts_wav },
	443	+ { AV_CODEC_ID_PCM_S24BE, mov_ch_layouts_wav },
	444	+ { AV_CODEC_ID_PCM_S32LE, mov_ch_layouts_wav },
	445	+ { AV_CODEC_ID_PCM_S32BE, mov_ch_layouts_wav },
	446	+ { AV_CODEC_ID_PCM_F32LE, mov_ch_layouts_wav },
	447	+ { AV_CODEC_ID_PCM_F32BE, mov_ch_layouts_wav },
	448	+ { AV_CODEC_ID_PCM_F64LE, mov_ch_layouts_wav },
	449	+ { AV_CODEC_ID_PCM_F64BE, mov_ch_layouts_wav },
	450	+ { AV_CODEC_ID_NONE, NULL },
451	451	};
452	452
453	453	uint64_t ff_mov_get_channel_layout(uint32_t tag, uint32_t bitmap)
@@ -490,7 +490,7 @@ static uint32_t mov_get_channel_label(uint32_t label) · 36 unmodified lines
490	490	return 0;
491	491	}
492	492
493		−uint32_t ff_mov_get_channel_layout_tag(enum CodecID codec_id,
	493	+uint32_t ff_mov_get_channel_layout_tag(enum AVCodecID codec_id,
494	494	uint64_t channel_layout,
495	495	uint32_t *bitmap)
496	496	{
@@ -499,11 +499,11 @@ uint32_t ff_mov_get_channel_layout_tag(enum CodecID codec_id, · 2 unmodified lines
499	499	const enum MovChannelLayoutTag *layouts = NULL;
500	500
501	501	/* find the layout list for the specified codec */
502		− for (i = 0; mov_codec_ch_layouts[i].codec_id != CODEC_ID_NONE; i++) {
	502	+ for (i = 0; mov_codec_ch_layouts[i].codec_id != AV_CODEC_ID_NONE; i++) {
503	503	if (mov_codec_ch_layouts[i].codec_id == codec_id)
504	504	break;
505	505	}
506		− if (mov_codec_ch_layouts[i].codec_id != CODEC_ID_NONE)
	506	+ if (mov_codec_ch_layouts[i].codec_id != AV_CODEC_ID_NONE)
507	507	layouts = mov_codec_ch_layouts[i].layouts;
508	508
509	509	if (layouts) {

libavformat/mov_chan.h+1−1

@@ -49,7 +49,7 @@ uint64_t ff_mov_get_channel_layout(uint32_t tag, uint32_t bitmap); · 48 unmodified lines
49	49	* @param[out] bitmap channel bitmap
50	50	* @return channel layout tag
51	51	*/
52		−uint32_t ff_mov_get_channel_layout_tag(enum CodecID codec_id,
	52	+uint32_t ff_mov_get_channel_layout_tag(enum AVCodecID codec_id,
53	53	uint64_t channel_layout,
54	54	uint32_t *bitmap);
55	55

libavformat/movenc.c+92−92

@@ -291,8 +291,8 @@ static int mov_write_esds_tag(AVIOContext pb, MOVTrack track) // Basic · 290 unmodified lines
291	291	put_descr(pb, 0x04, 13 + decoder_specific_info_len);
292	292
293	293	// Object type indication
294		− if ((track->enc->codec_id == CODEC_ID_MP2 \|\|
295		− track->enc->codec_id == CODEC_ID_MP3) &&
	294	+ if ((track->enc->codec_id == AV_CODEC_ID_MP2 \|\|
	295	+ track->enc->codec_id == AV_CODEC_ID_MP3) &&
296	296	track->enc->sample_rate > 24000)
297	297	avio_w8(pb, 0x6B); // 11172-3
298	298	else
@@ -381,20 +381,20 @@ static int mov_write_wave_tag(AVIOContext pb, MOVTrack track) · 82 unmodified lines
381	381	ffio_wfourcc(pb, "frma");
382	382	avio_wl32(pb, track->tag);
383	383
384		− if (track->enc->codec_id == CODEC_ID_AAC) {
	384	+ if (track->enc->codec_id == AV_CODEC_ID_AAC) {
385	385	/* useless atom needed by mplayer, ipod, not needed by quicktime */
386	386	avio_wb32(pb, 12); /* size */
387	387	ffio_wfourcc(pb, "mp4a");
388	388	avio_wb32(pb, 0);
389	389	mov_write_esds_tag(pb, track);
390		− } else if (track->enc->codec_id == CODEC_ID_AMR_NB) {
	390	+ } else if (track->enc->codec_id == AV_CODEC_ID_AMR_NB) {
391	391	mov_write_amr_tag(pb, track);
392		− } else if (track->enc->codec_id == CODEC_ID_AC3) {
	392	+ } else if (track->enc->codec_id == AV_CODEC_ID_AC3) {
393	393	mov_write_ac3_tag(pb, track);
394		− } else if (track->enc->codec_id == CODEC_ID_ALAC) {
	394	+ } else if (track->enc->codec_id == AV_CODEC_ID_ALAC) {
395	395	mov_write_extradata_tag(pb, track);
396		− } else if (track->enc->codec_id == CODEC_ID_ADPCM_MS \|\|
397		− track->enc->codec_id == CODEC_ID_ADPCM_IMA_WAV) {
	396	+ } else if (track->enc->codec_id == AV_CODEC_ID_ADPCM_MS \|\|
	397	+ track->enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
398	398	mov_write_ms_tag(pb, track);
399	399	}
400	400
@@ -508,25 +508,25 @@ static int mov_write_glbl_tag(AVIOContext pb, MOVTrack track) · 107 unmodified lines
508	508	* Compute flags for 'lpcm' tag.
509	509	* See CoreAudioTypes and AudioStreamBasicDescription at Apple.
510	510	*/
511		−static int mov_get_lpcm_flags(enum CodecID codec_id)
	511	+static int mov_get_lpcm_flags(enum AVCodecID codec_id)
512	512	{
513	513	switch (codec_id) {
514		− case CODEC_ID_PCM_F32BE:
515		− case CODEC_ID_PCM_F64BE:
	514	+ case AV_CODEC_ID_PCM_F32BE:
	515	+ case AV_CODEC_ID_PCM_F64BE:
516	516	return 11;
517		− case CODEC_ID_PCM_F32LE:
518		− case CODEC_ID_PCM_F64LE:
	517	+ case AV_CODEC_ID_PCM_F32LE:
	518	+ case AV_CODEC_ID_PCM_F64LE:
519	519	return 9;
520		− case CODEC_ID_PCM_U8:
	520	+ case AV_CODEC_ID_PCM_U8:
521	521	return 10;
522		− case CODEC_ID_PCM_S16BE:
523		− case CODEC_ID_PCM_S24BE:
524		− case CODEC_ID_PCM_S32BE:
	522	+ case AV_CODEC_ID_PCM_S16BE:
	523	+ case AV_CODEC_ID_PCM_S24BE:
	524	+ case AV_CODEC_ID_PCM_S32BE:
525	525	return 14;
526		− case CODEC_ID_PCM_S8:
527		− case CODEC_ID_PCM_S16LE:
528		− case CODEC_ID_PCM_S24LE:
529		− case CODEC_ID_PCM_S32LE:
	526	+ case AV_CODEC_ID_PCM_S8:
	527	+ case AV_CODEC_ID_PCM_S16LE:
	528	+ case AV_CODEC_ID_PCM_S24LE:
	529	+ case AV_CODEC_ID_PCM_S32LE:
530	530	return 12;
531	531	default:
532	532	return 0;
@@ -617,22 +617,22 @@ static int mov_write_audio_tag(AVIOContext pb, MOVTrack track) · 84 unmodified lines
617	617	}
618	618
619	619	if(track->mode == MODE_MOV &&
620		− (track->enc->codec_id == CODEC_ID_AAC \|\|
621		− track->enc->codec_id == CODEC_ID_AC3 \|\|
622		− track->enc->codec_id == CODEC_ID_AMR_NB \|\|
623		− track->enc->codec_id == CODEC_ID_ALAC \|\|
624		− track->enc->codec_id == CODEC_ID_ADPCM_MS \|\|
625		− track->enc->codec_id == CODEC_ID_ADPCM_IMA_WAV))
	620	+ (track->enc->codec_id == AV_CODEC_ID_AAC \|\|
	621	+ track->enc->codec_id == AV_CODEC_ID_AC3 \|\|
	622	+ track->enc->codec_id == AV_CODEC_ID_AMR_NB \|\|
	623	+ track->enc->codec_id == AV_CODEC_ID_ALAC \|\|
	624	+ track->enc->codec_id == AV_CODEC_ID_ADPCM_MS \|\|
	625	+ track->enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV))
626	626	mov_write_wave_tag(pb, track);
627	627	else if(track->tag == MKTAG('m','p','4','a'))
628	628	mov_write_esds_tag(pb, track);
629		− else if(track->enc->codec_id == CODEC_ID_AMR_NB)
	629	+ else if(track->enc->codec_id == AV_CODEC_ID_AMR_NB)
630	630	mov_write_amr_tag(pb, track);
631		− else if(track->enc->codec_id == CODEC_ID_AC3)
	631	+ else if(track->enc->codec_id == AV_CODEC_ID_AC3)
632	632	mov_write_ac3_tag(pb, track);
633		− else if(track->enc->codec_id == CODEC_ID_ALAC)
	633	+ else if(track->enc->codec_id == AV_CODEC_ID_ALAC)
634	634	mov_write_extradata_tag(pb, track);
635		− else if (track->enc->codec_id == CODEC_ID_WMAPRO)
	635	+ else if (track->enc->codec_id == AV_CODEC_ID_WMAPRO)
636	636	mov_write_wfex_tag(pb, track);
637	637	else if (track->vos_len > 0)
638	638	mov_write_glbl_tag(pb, track);
@@ -733,11 +733,11 @@ static int mp4_get_codec_tag(AVFormatContext s, MOVTrack track) · 94 unmodified lines
733	733	if (!ff_codec_get_tag(ff_mp4_obj_type, track->enc->codec_id))
734	734	return 0;
735	735
736		− if (track->enc->codec_id == CODEC_ID_H264) tag = MKTAG('a','v','c','1');
737		− else if (track->enc->codec_id == CODEC_ID_AC3) tag = MKTAG('a','c','-','3');
738		− else if (track->enc->codec_id == CODEC_ID_DIRAC) tag = MKTAG('d','r','a','c');
739		− else if (track->enc->codec_id == CODEC_ID_MOV_TEXT) tag = MKTAG('t','x','3','g');
740		− else if (track->enc->codec_id == CODEC_ID_VC1) tag = MKTAG('v','c','-','1');
	736	+ if (track->enc->codec_id == AV_CODEC_ID_H264) tag = MKTAG('a','v','c','1');
	737	+ else if (track->enc->codec_id == AV_CODEC_ID_AC3) tag = MKTAG('a','c','-','3');
	738	+ else if (track->enc->codec_id == AV_CODEC_ID_DIRAC) tag = MKTAG('d','r','a','c');
	739	+ else if (track->enc->codec_id == AV_CODEC_ID_MOV_TEXT) tag = MKTAG('t','x','3','g');
	740	+ else if (track->enc->codec_id == AV_CODEC_ID_VC1) tag = MKTAG('v','c','-','1');
741	741	else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) tag = MKTAG('m','p','4','v');
742	742	else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) tag = MKTAG('m','p','4','a');
743	743
@@ -745,14 +745,14 @@ static int mp4_get_codec_tag(AVFormatContext s, MOVTrack track) · 1 unmodified line
745	745	}
746	746
747	747	static const AVCodecTag codec_ipod_tags[] = {
748		− { CODEC_ID_H264, MKTAG('a','v','c','1') },
749		− { CODEC_ID_MPEG4, MKTAG('m','p','4','v') },
750		− { CODEC_ID_AAC, MKTAG('m','p','4','a') },
751		− { CODEC_ID_ALAC, MKTAG('a','l','a','c') },
752		− { CODEC_ID_AC3, MKTAG('a','c','-','3') },
753		− { CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },
754		− { CODEC_ID_MOV_TEXT, MKTAG('t','e','x','t') },
755		− { CODEC_ID_NONE, 0 },
	748	+ { AV_CODEC_ID_H264, MKTAG('a','v','c','1') },
	749	+ { AV_CODEC_ID_MPEG4, MKTAG('m','p','4','v') },
	750	+ { AV_CODEC_ID_AAC, MKTAG('m','p','4','a') },
	751	+ { AV_CODEC_ID_ALAC, MKTAG('a','l','a','c') },
	752	+ { AV_CODEC_ID_AC3, MKTAG('a','c','-','3') },
	753	+ { AV_CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },
	754	+ { AV_CODEC_ID_MOV_TEXT, MKTAG('t','e','x','t') },
	755	+ { AV_CODEC_ID_NONE, 0 },
756	756	};
757	757
758	758	static int ipod_get_codec_tag(AVFormatContext s, MOVTrack track)
@@ -839,13 +839,13 @@ static int mov_get_codec_tag(AVFormatContext s, MOVTrack track) · 80 unmodified lines
839	839	int tag = track->enc->codec_tag;
840	840
841	841	if (!tag \|\| (track->enc->strict_std_compliance >= FF_COMPLIANCE_NORMAL &&
842		− (track->enc->codec_id == CODEC_ID_DVVIDEO \|\|
843		− track->enc->codec_id == CODEC_ID_RAWVIDEO \|\|
844		− track->enc->codec_id == CODEC_ID_H263 \|\|
	842	+ (track->enc->codec_id == AV_CODEC_ID_DVVIDEO \|\|
	843	+ track->enc->codec_id == AV_CODEC_ID_RAWVIDEO \|\|
	844	+ track->enc->codec_id == AV_CODEC_ID_H263 \|\|
845	845	av_get_bits_per_sample(track->enc->codec_id)))) { // pcm audio
846		− if (track->enc->codec_id == CODEC_ID_DVVIDEO)
	846	+ if (track->enc->codec_id == AV_CODEC_ID_DVVIDEO)
847	847	tag = mov_get_dv_codec_tag(s, track);
848		− else if (track->enc->codec_id == CODEC_ID_RAWVIDEO)
	848	+ else if (track->enc->codec_id == AV_CODEC_ID_RAWVIDEO)
849	849	tag = mov_get_rawvideo_codec_tag(s, track);
850	850	else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
851	851	tag = ff_codec_get_tag(ff_codec_movvideo_tags, track->enc->codec_id);
@@ -873,14 +873,14 @@ static int mov_get_codec_tag(AVFormatContext s, MOVTrack track) · 21 unmodified lines
873	873	}
874	874
875	875	static const AVCodecTag codec_3gp_tags[] = {
876		− { CODEC_ID_H263, MKTAG('s','2','6','3') },
877		− { CODEC_ID_H264, MKTAG('a','v','c','1') },
878		− { CODEC_ID_MPEG4, MKTAG('m','p','4','v') },
879		− { CODEC_ID_AAC, MKTAG('m','p','4','a') },
880		− { CODEC_ID_AMR_NB, MKTAG('s','a','m','r') },
881		− { CODEC_ID_AMR_WB, MKTAG('s','a','w','b') },
882		− { CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },
883		− { CODEC_ID_NONE, 0 },
	876	+ { AV_CODEC_ID_H263, MKTAG('s','2','6','3') },
	877	+ { AV_CODEC_ID_H264, MKTAG('a','v','c','1') },
	878	+ { AV_CODEC_ID_MPEG4, MKTAG('m','p','4','v') },
	879	+ { AV_CODEC_ID_AAC, MKTAG('m','p','4','a') },
	880	+ { AV_CODEC_ID_AMR_NB, MKTAG('s','a','m','r') },
	881	+ { AV_CODEC_ID_AMR_WB, MKTAG('s','a','w','b') },
	882	+ { AV_CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },
	883	+ { AV_CODEC_ID_NONE, 0 },
884	884	};
885	885
886	886	static int mov_find_codec_tag(AVFormatContext s, MOVTrack track)
@@ -891,7 +891,7 @@ static int mov_find_codec_tag(AVFormatContext s, MOVTrack track) · 4 unmodified lines
891	891	tag = mp4_get_codec_tag(s, track);
892	892	else if (track->mode == MODE_ISM) {
893	893	tag = mp4_get_codec_tag(s, track);
894		− if (!tag && track->enc->codec_id == CODEC_ID_WMAPRO)
	894	+ if (!tag && track->enc->codec_id == AV_CODEC_ID_WMAPRO)
895	895	tag = MKTAG('w', 'm', 'a', ' ');
896	896	} else if (track->mode == MODE_IPOD)
897	897	tag = ipod_get_codec_tag(s, track);
@@ -979,7 +979,7 @@ static int mov_write_video_tag(AVIOContext pb, MOVTrack track) · 81 unmodified lines
979	979	avio_wb16(pb, 0); /* Codec stream revision (=0) */
980	980	if (track->mode == MODE_MOV) {
981	981	ffio_wfourcc(pb, "FFMP"); /* Vendor */
982		− if(track->enc->codec_id == CODEC_ID_RAWVIDEO) {
	982	+ if(track->enc->codec_id == AV_CODEC_ID_RAWVIDEO) {
983	983	avio_wb32(pb, 0); /* Temporal Quality */
984	984	avio_wb32(pb, 0x400); /* Spatial Quality = lossless*/
985	985	} else {
@@ -1011,19 +1011,19 @@ static int mov_write_video_tag(AVIOContext pb, MOVTrack track) · 25 unmodified lines
1011	1011	avio_wb16(pb, 0xffff); /* Reserved */
1012	1012	if(track->tag == MKTAG('m','p','4','v'))
1013	1013	mov_write_esds_tag(pb, track);
1014		− else if(track->enc->codec_id == CODEC_ID_H263)
	1014	+ else if(track->enc->codec_id == AV_CODEC_ID_H263)
1015	1015	mov_write_d263_tag(pb);
1016		− else if(track->enc->codec_id == CODEC_ID_SVQ3)
	1016	+ else if(track->enc->codec_id == AV_CODEC_ID_SVQ3)
1017	1017	mov_write_svq3_tag(pb);
1018		− else if(track->enc->codec_id == CODEC_ID_DNXHD)
	1018	+ else if(track->enc->codec_id == AV_CODEC_ID_DNXHD)
1019	1019	mov_write_avid_tag(pb, track);
1020		− else if(track->enc->codec_id == CODEC_ID_H264) {
	1020	+ else if(track->enc->codec_id == AV_CODEC_ID_H264) {
1021	1021	mov_write_avcc_tag(pb, track);
1022	1022	if(track->mode == MODE_IPOD)
1023	1023	mov_write_uuid_tag_ipod(pb);
1024	1024	} else if (track->enc->field_order != AV_FIELD_UNKNOWN)
1025	1025	mov_write_fiel_tag(pb, track);
1026		− else if (track->enc->codec_id == CODEC_ID_VC1 && track->vos_len > 0)
	1026	+ else if (track->enc->codec_id == AV_CODEC_ID_VC1 && track->vos_len > 0)
1027	1027	mov_write_dvc1_tag(pb, track);
1028	1028	else if (track->vos_len > 0)
1029	1029	mov_write_glbl_tag(pb, track);
@@ -2120,7 +2120,7 @@ static int mov_write_isml_manifest(AVIOContext pb, MOVMuxContext mov) · 1090 unmodified lines
2120	2120	param_write_int(pb, "systemBitrate", track->enc->bit_rate);
2121	2121	param_write_int(pb, "trackID", track_id);
2122	2122	if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2123		− if (track->enc->codec_id == CODEC_ID_H264) {
	2123	+ if (track->enc->codec_id == AV_CODEC_ID_H264) {
2124	2124	uint8_t *ptr;
2125	2125	int size = track->enc->extradata_size;
2126	2126	if (!ff_avc_write_annexb_extradata(track->enc->extradata, &ptr,
@@ -2131,7 +2131,7 @@ static int mov_write_isml_manifest(AVIOContext pb, MOVMuxContext mov) · 4 unmodified lines
2131	2131	av_free(ptr);
2132	2132	}
2133	2133	param_write_string(pb, "FourCC", "H264");
2134		− } else if (track->enc->codec_id == CODEC_ID_VC1) {
	2134	+ } else if (track->enc->codec_id == AV_CODEC_ID_VC1) {
2135	2135	param_write_string(pb, "FourCC", "WVC1");
2136	2136	param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
2137	2137	track->enc->extradata_size);
@@ -2141,9 +2141,9 @@ static int mov_write_isml_manifest(AVIOContext pb, MOVMuxContext mov) · 3 unmodified lines
2141	2141	param_write_int(pb, "DisplayWidth", track->enc->width);
2142	2142	param_write_int(pb, "DisplayHeight", track->enc->height);
2143	2143	} else {
2144		− if (track->enc->codec_id == CODEC_ID_AAC) {
	2144	+ if (track->enc->codec_id == AV_CODEC_ID_AAC) {
2145	2145	param_write_string(pb, "FourCC", "AACL");
2146		− } else if (track->enc->codec_id == CODEC_ID_WMAPRO) {
	2146	+ } else if (track->enc->codec_id == AV_CODEC_ID_WMAPRO) {
2147	2147	param_write_string(pb, "FourCC", "WMAP");
2148	2148	}
2149	2149	param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
@@ -2475,7 +2475,7 @@ static int mov_write_ftyp_tag(AVIOContext pb, AVFormatContext s) · 325 unmodified lines
2475	2475	AVStream *st = s->streams[i];
2476	2476	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2477	2477	has_video = 1;
2478		− if (st->codec->codec_id == CODEC_ID_H264)
	2478	+ if (st->codec->codec_id == AV_CODEC_ID_H264)
2479	2479	has_h264 = 1;
2480	2480	}
2481	2481
@@ -2566,7 +2566,7 @@ static void mov_write_uuidprof_tag(AVIOContext pb, AVFormatContext s) · 84 unmodified lines
2566	2566	ffio_wfourcc(pb, "VPRF"); /* video */
2567	2567	avio_wb32(pb, 0x0);
2568	2568	avio_wb32(pb, 0x1); /* TrackID */
2569		− if (video_codec->codec_id == CODEC_ID_H264) {
	2569	+ if (video_codec->codec_id == AV_CODEC_ID_H264) {
2570	2570	ffio_wfourcc(pb, "avc1");
2571	2571	avio_wb16(pb, 0x014D);
2572	2572	avio_wb16(pb, 0x0015);
@@ -2816,7 +2816,7 @@ int ff_mov_write_packet(AVFormatContext s, AVPacket pkt) · 243 unmodified lines
2816	2816	}
2817	2817	}
2818	2818
2819		− if (enc->codec_id == CODEC_ID_AMR_NB) {
	2819	+ if (enc->codec_id == AV_CODEC_ID_AMR_NB) {
2820	2820	/* We must find out how many AMR blocks there are in one packet */
2821	2821	static uint16_t packed_size[16] =
2822	2822	{13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 1};
@@ -2842,7 +2842,7 @@ int ff_mov_write_packet(AVFormatContext s, AVPacket pkt) · 19 unmodified lines
2842	2842	memcpy(trk->vos_data, enc->extradata, trk->vos_len);
2843	2843	}
2844	2844
2845		− if (enc->codec_id == CODEC_ID_H264 && trk->vos_len > 0 && (uint8_t )trk->vos_data != 1) {
	2845	+ if (enc->codec_id == AV_CODEC_ID_H264 && trk->vos_len > 0 && (uint8_t )trk->vos_data != 1) {
2846	2846	/* from x264 or from bytestream h264 */
2847	2847	/* nal reformating needed */
2848	2848	if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) {
@@ -2856,8 +2856,8 @@ int ff_mov_write_packet(AVFormatContext s, AVPacket pkt) · 7 unmodified lines
2856	2856	avio_write(pb, pkt->data, size);
2857	2857	}
2858	2858
2859		− if ((enc->codec_id == CODEC_ID_DNXHD \|\|
2860		− enc->codec_id == CODEC_ID_AC3) && !trk->vos_len) {
	2859	+ if ((enc->codec_id == AV_CODEC_ID_DNXHD \|\|
	2860	+ enc->codec_id == AV_CODEC_ID_AC3) && !trk->vos_len) {
2861	2861	/* copy frame to create needed atoms */
2862	2862	trk->vos_len = size;
2863	2863	trk->vos_data = av_malloc(size);
@@ -2896,10 +2896,10 @@ int ff_mov_write_packet(AVFormatContext s, AVPacket pkt) · 32 unmodified lines
2896	2896	trk->flags \|= MOV_TRACK_CTTS;
2897	2897	trk->cluster[trk->entry].cts = pkt->pts - pkt->dts;
2898	2898	trk->cluster[trk->entry].flags = 0;
2899		− if (enc->codec_id == CODEC_ID_VC1) {
	2899	+ if (enc->codec_id == AV_CODEC_ID_VC1) {
2900	2900	mov_parse_vc1_frame(pkt, trk, mov->fragments);
2901	2901	} else if (pkt->flags & AV_PKT_FLAG_KEY) {
2902		− if (mov->mode == MODE_MOV && enc->codec_id == CODEC_ID_MPEG2VIDEO &&
	2902	+ if (mov->mode == MODE_MOV && enc->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
2903	2903	trk->entry > 0) { // force sync sample for the first key frame
2904	2904	mov_parse_mpeg2_frame(pkt, &trk->cluster[trk->entry].flags);
2905	2905	if (trk->cluster[trk->entry].flags & MOV_PARTIAL_SYNC_SAMPLE)
@@ -3096,7 +3096,7 @@ static int mov_write_header(AVFormatContext *s) · 190 unmodified lines
3096	3096	track->timescale = st->codec->sample_rate;
3097	3097	/* set sample_size for PCM and ADPCM */
3098	3098	if (av_get_bits_per_sample(st->codec->codec_id) \|\|
3099		− st->codec->codec_id == CODEC_ID_ILBC) {
	3099	+ st->codec->codec_id == AV_CODEC_ID_ILBC) {
3100	3100	if (!st->codec->block_align) {
3101	3101	av_log(s, AV_LOG_ERROR, "track %d: codec block align is not set\n", i);
3102	3102	goto error;
@@ -3108,7 +3108,7 @@ static int mov_write_header(AVFormatContext *s) · 5 unmodified lines
3108	3108	track->audio_vbr = 1;
3109	3109	}
3110	3110	if (track->mode != MODE_MOV &&
3111		− track->enc->codec_id == CODEC_ID_MP3 && track->timescale < 16000) {
	3111	+ track->enc->codec_id == AV_CODEC_ID_MP3 && track->timescale < 16000) {
3112	3112	av_log(s, AV_LOG_ERROR, "track %d: muxing mp3 at %dhz is not supported\n",
3113	3113	i, track->enc->sample_rate);
3114	3114	goto error;
@@ -3251,9 +3251,9 @@ AVOutputFormat ff_mov_muxer = { · 136 unmodified lines
3251	3251	.long_name = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),
3252	3252	.extensions = "mov",
3253	3253	.priv_data_size = sizeof(MOVMuxContext),
3254		− .audio_codec = CODEC_ID_AAC,
	3254	+ .audio_codec = AV_CODEC_ID_AAC,
3255	3255	.video_codec = CONFIG_LIBX264_ENCODER ?
3256		− CODEC_ID_H264 : CODEC_ID_MPEG4,
	3256	+ AV_CODEC_ID_H264 : AV_CODEC_ID_MPEG4,
3257	3257	.write_header = mov_write_header,
3258	3258	.write_packet = mov_write_packet,
3259	3259	.write_trailer = mov_write_trailer,
@@ -3271,8 +3271,8 @@ AVOutputFormat ff_tgp_muxer = { · 11 unmodified lines
3271	3271	.long_name = NULL_IF_CONFIG_SMALL("3GP (3GPP file format)"),
3272	3272	.extensions = "3gp",
3273	3273	.priv_data_size = sizeof(MOVMuxContext),
3274		− .audio_codec = CODEC_ID_AMR_NB,
3275		− .video_codec = CODEC_ID_H263,
	3274	+ .audio_codec = AV_CODEC_ID_AMR_NB,
	3275	+ .video_codec = AV_CODEC_ID_H263,
3276	3276	.write_header = mov_write_header,
3277	3277	.write_packet = mov_write_packet,
3278	3278	.write_trailer = mov_write_trailer,
@@ -3289,9 +3289,9 @@ AVOutputFormat ff_mp4_muxer = { · 10 unmodified lines
3289	3289	.mime_type = "application/mp4",
3290	3290	.extensions = "mp4",
3291	3291	.priv_data_size = sizeof(MOVMuxContext),
3292		− .audio_codec = CODEC_ID_AAC,
	3292	+ .audio_codec = AV_CODEC_ID_AAC,
3293	3293	.video_codec = CONFIG_LIBX264_ENCODER ?
3294		− CODEC_ID_H264 : CODEC_ID_MPEG4,
	3294	+ AV_CODEC_ID_H264 : AV_CODEC_ID_MPEG4,
3295	3295	.write_header = mov_write_header,
3296	3296	.write_packet = mov_write_packet,
3297	3297	.write_trailer = mov_write_trailer,
@@ -3307,9 +3307,9 @@ AVOutputFormat ff_psp_muxer = { · 9 unmodified lines
3307	3307	.long_name = NULL_IF_CONFIG_SMALL("PSP MP4 (MPEG-4 Part 14)"),
3308	3308	.extensions = "mp4,psp",
3309	3309	.priv_data_size = sizeof(MOVMuxContext),
3310		− .audio_codec = CODEC_ID_AAC,
	3310	+ .audio_codec = AV_CODEC_ID_AAC,
3311	3311	.video_codec = CONFIG_LIBX264_ENCODER ?
3312		− CODEC_ID_H264 : CODEC_ID_MPEG4,
	3312	+ AV_CODEC_ID_H264 : AV_CODEC_ID_MPEG4,
3313	3313	.write_header = mov_write_header,
3314	3314	.write_packet = mov_write_packet,
3315	3315	.write_trailer = mov_write_trailer,
@@ -3325,8 +3325,8 @@ AVOutputFormat ff_tg2_muxer = { · 9 unmodified lines
3325	3325	.long_name = NULL_IF_CONFIG_SMALL("3GP2 (3GPP2 file format)"),
3326	3326	.extensions = "3g2",
3327	3327	.priv_data_size = sizeof(MOVMuxContext),
3328		− .audio_codec = CODEC_ID_AMR_NB,
3329		− .video_codec = CODEC_ID_H263,
	3328	+ .audio_codec = AV_CODEC_ID_AMR_NB,
	3329	+ .video_codec = AV_CODEC_ID_H263,
3330	3330	.write_header = mov_write_header,
3331	3331	.write_packet = mov_write_packet,
3332	3332	.write_trailer = mov_write_trailer,
@@ -3343,8 +3343,8 @@ AVOutputFormat ff_ipod_muxer = { · 10 unmodified lines
3343	3343	.mime_type = "application/mp4",
3344	3344	.extensions = "m4v,m4a",
3345	3345	.priv_data_size = sizeof(MOVMuxContext),
3346		− .audio_codec = CODEC_ID_AAC,
3347		− .video_codec = CODEC_ID_H264,
	3346	+ .audio_codec = AV_CODEC_ID_AAC,
	3347	+ .video_codec = AV_CODEC_ID_H264,
3348	3348	.write_header = mov_write_header,
3349	3349	.write_packet = mov_write_packet,
3350	3350	.write_trailer = mov_write_trailer,
@@ -3361,8 +3361,8 @@ AVOutputFormat ff_ismv_muxer = { · 10 unmodified lines
3361	3361	.mime_type = "application/mp4",
3362	3362	.extensions = "ismv,isma",
3363	3363	.priv_data_size = sizeof(MOVMuxContext),
3364		− .audio_codec = CODEC_ID_AAC,
3365		− .video_codec = CODEC_ID_H264,
	3364	+ .audio_codec = AV_CODEC_ID_AAC,
	3365	+ .video_codec = AV_CODEC_ID_H264,
3366	3366	.write_header = mov_write_header,
3367	3367	.write_packet = mov_write_packet,
3368	3368	.write_trailer = mov_write_trailer,

libavformat/mp3dec.c+1−1

@@ -162,7 +162,7 @@ static int mp3_read_header(AVFormatContext *s) · 161 unmodified lines
162	162	return AVERROR(ENOMEM);
163	163
164	164	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
165		− st->codec->codec_id = CODEC_ID_MP3;
	165	+ st->codec->codec_id = AV_CODEC_ID_MP3;
166	166	st->need_parsing = AVSTREAM_PARSE_FULL;
167	167	st->start_time = 0;
168	168

libavformat/mp3enc.c+5−5

@@ -193,8 +193,8 @@ AVOutputFormat ff_mp2_muxer = { · 192 unmodified lines
193	193	.long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
194	194	.mime_type = "audio/x-mpeg",
195	195	.extensions = "mp2,m2a",
196		− .audio_codec = CODEC_ID_MP2,
197		− .video_codec = CODEC_ID_NONE,
	196	+ .audio_codec = AV_CODEC_ID_MP2,
	197	+ .video_codec = AV_CODEC_ID_NONE,
198	198	.write_packet = ff_raw_write_packet,
199	199	.write_trailer = mp3_write_trailer,
200	200	};
@@ -277,7 +277,7 @@ static int mp3_write_header(struct AVFormatContext *s) · 76 unmodified lines
277	277	for (i = 0; i < s->nb_streams; i++) {
278	278	AVStream *st = s->streams[i];
279	279	if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
280		− if (mp3->audio_stream_idx >= 0 \|\| st->codec->codec_id != CODEC_ID_MP3) {
	280	+ if (mp3->audio_stream_idx >= 0 \|\| st->codec->codec_id != AV_CODEC_ID_MP3) {
281	281	av_log(s, AV_LOG_ERROR, "Invalid audio stream. Exactly one MP3 "
282	282	"audio stream is required.\n");
283	283	return AVERROR(EINVAL);
@@ -313,8 +313,8 @@ AVOutputFormat ff_mp3_muxer = { · 29 unmodified lines
313	313	.mime_type = "audio/x-mpeg",
314	314	.extensions = "mp3",
315	315	.priv_data_size = sizeof(MP3Context),
316		− .audio_codec = CODEC_ID_MP3,
317		− .video_codec = CODEC_ID_PNG,
	316	+ .audio_codec = AV_CODEC_ID_MP3,
	317	+ .video_codec = AV_CODEC_ID_PNG,
318	318	.write_header = mp3_write_header,
319	319	.write_packet = mp3_write_packet,
320	320	.write_trailer = mp3_write_trailer,

libavformat/mpc.c+1−1

@@ -89,7 +89,7 @@ static int mpc_read_header(AVFormatContext *s) · 88 unmodified lines
89	89	if (!st)
90	90	return AVERROR(ENOMEM);
91	91	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
92		− st->codec->codec_id = CODEC_ID_MUSEPACK7;
	92	+ st->codec->codec_id = AV_CODEC_ID_MUSEPACK7;
93	93	st->codec->channels = 2;
94	94	st->codec->bits_per_coded_sample = 16;
95	95

libavformat/mpc8.c+1−1

@@ -229,7 +229,7 @@ static int mpc8_read_header(AVFormatContext *s) · 228 unmodified lines
229	229	if (!st)
230	230	return AVERROR(ENOMEM);
231	231	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
232		− st->codec->codec_id = CODEC_ID_MUSEPACK8;
	232	+ st->codec->codec_id = AV_CODEC_ID_MUSEPACK8;
233	233	st->codec->bits_per_coded_sample = 16;
234	234
235	235	st->codec->extradata_size = 2;

libavformat/mpeg.c+24−24

@@ -382,7 +382,7 @@ static int mpegps_read_packet(AVFormatContext *s, · 381 unmodified lines
382	382	MpegDemuxContext *m = s->priv_data;
383	383	AVStream *st;
384	384	int len, startcode, i, es_type, ret;
385		− enum CodecID codec_id = CODEC_ID_NONE;
	385	+ enum AVCodecID codec_id = AV_CODEC_ID_NONE;
386	386	enum AVMediaType type;
387	387	int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
388	388	uint8_t av_uninit(dvdaudio_substream_type);
@@ -408,26 +408,26 @@ static int mpegps_read_packet(AVFormatContext *s, · 19 unmodified lines
408	408	es_type = m->psm_es_type[startcode & 0xff];
409	409	if(es_type > 0 && es_type != STREAM_TYPE_PRIVATE_DATA){
410	410	if(es_type == STREAM_TYPE_VIDEO_MPEG1){
411		− codec_id = CODEC_ID_MPEG2VIDEO;
	411	+ codec_id = AV_CODEC_ID_MPEG2VIDEO;
412	412	type = AVMEDIA_TYPE_VIDEO;
413	413	} else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
414		− codec_id = CODEC_ID_MPEG2VIDEO;
	414	+ codec_id = AV_CODEC_ID_MPEG2VIDEO;
415	415	type = AVMEDIA_TYPE_VIDEO;
416	416	} else if(es_type == STREAM_TYPE_AUDIO_MPEG1 \|\|
417	417	es_type == STREAM_TYPE_AUDIO_MPEG2){
418		− codec_id = CODEC_ID_MP3;
	418	+ codec_id = AV_CODEC_ID_MP3;
419	419	type = AVMEDIA_TYPE_AUDIO;
420	420	} else if(es_type == STREAM_TYPE_AUDIO_AAC){
421		− codec_id = CODEC_ID_AAC;
	421	+ codec_id = AV_CODEC_ID_AAC;
422	422	type = AVMEDIA_TYPE_AUDIO;
423	423	} else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
424		− codec_id = CODEC_ID_MPEG4;
	424	+ codec_id = AV_CODEC_ID_MPEG4;
425	425	type = AVMEDIA_TYPE_VIDEO;
426	426	} else if(es_type == STREAM_TYPE_VIDEO_H264){
427		− codec_id = CODEC_ID_H264;
	427	+ codec_id = AV_CODEC_ID_H264;
428	428	type = AVMEDIA_TYPE_VIDEO;
429	429	} else if(es_type == STREAM_TYPE_AUDIO_AC3){
430		− codec_id = CODEC_ID_AC3;
	430	+ codec_id = AV_CODEC_ID_AC3;
431	431	type = AVMEDIA_TYPE_AUDIO;
432	432	} else {
433	433	goto skip;
@@ -438,47 +438,47 @@ static int mpegps_read_packet(AVFormatContext *s, · 4 unmodified lines
438	438	avio_read(s->pb, buf, 8);
439	439	avio_seek(s->pb, -8, SEEK_CUR);
440	440	if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 \|\| buf[7] != 1))
441		− codec_id = CODEC_ID_CAVS;
	441	+ codec_id = AV_CODEC_ID_CAVS;
442	442	else
443		− codec_id = CODEC_ID_PROBE;
	443	+ codec_id = AV_CODEC_ID_PROBE;
444	444	type = AVMEDIA_TYPE_VIDEO;
445	445	} else if (startcode >= 0x1c0 && startcode <= 0x1df) {
446	446	type = AVMEDIA_TYPE_AUDIO;
447		− codec_id = m->sofdec > 0 ? CODEC_ID_ADPCM_ADX : CODEC_ID_MP2;
	447	+ codec_id = m->sofdec > 0 ? AV_CODEC_ID_ADPCM_ADX : AV_CODEC_ID_MP2;
448	448	} else if (startcode >= 0x80 && startcode <= 0x87) {
449	449	type = AVMEDIA_TYPE_AUDIO;
450		− codec_id = CODEC_ID_AC3;
	450	+ codec_id = AV_CODEC_ID_AC3;
451	451	} else if ( ( startcode >= 0x88 && startcode <= 0x8f)
452	452	\|\|( startcode >= 0x98 && startcode <= 0x9f)) {
453	453	/* 0x90 - 0x97 is reserved for SDDS in DVD specs */
454	454	type = AVMEDIA_TYPE_AUDIO;
455		− codec_id = CODEC_ID_DTS;
	455	+ codec_id = AV_CODEC_ID_DTS;
456	456	} else if (startcode >= 0xa0 && startcode <= 0xaf) {
457	457	type = AVMEDIA_TYPE_AUDIO;
458		− /* 16 bit form will be handled as CODEC_ID_PCM_S16BE */
459		− codec_id = CODEC_ID_PCM_DVD;
	458	+ /* 16 bit form will be handled as AV_CODEC_ID_PCM_S16BE */
	459	+ codec_id = AV_CODEC_ID_PCM_DVD;
460	460	} else if (startcode >= 0xb0 && startcode <= 0xbf) {
461	461	type = AVMEDIA_TYPE_AUDIO;
462		− codec_id = CODEC_ID_TRUEHD;
	462	+ codec_id = AV_CODEC_ID_TRUEHD;
463	463	} else if (startcode >= 0xc0 && startcode <= 0xcf) {
464	464	/* Used for both AC-3 and E-AC-3 in EVOB files */
465	465	type = AVMEDIA_TYPE_AUDIO;
466		− codec_id = CODEC_ID_AC3;
	466	+ codec_id = AV_CODEC_ID_AC3;
467	467	} else if (startcode >= 0x20 && startcode <= 0x3f) {
468	468	type = AVMEDIA_TYPE_SUBTITLE;
469		− codec_id = CODEC_ID_DVD_SUBTITLE;
	469	+ codec_id = AV_CODEC_ID_DVD_SUBTITLE;
470	470	} else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
471	471	type = AVMEDIA_TYPE_VIDEO;
472		− codec_id = CODEC_ID_VC1;
	472	+ codec_id = AV_CODEC_ID_VC1;
473	473	} else if (startcode == 0x1bd) {
474	474	// check dvd audio substream type
475	475	type = AVMEDIA_TYPE_AUDIO;
476	476	switch(dvdaudio_substream_type & 0xe0) {
477		− case 0xa0: codec_id = CODEC_ID_PCM_DVD;
	477	+ case 0xa0: codec_id = AV_CODEC_ID_PCM_DVD;
478	478	break;
479	479	case 0x80: if((dvdaudio_substream_type & 0xf8) == 0x88)
480		− codec_id = CODEC_ID_DTS;
481		− else codec_id = CODEC_ID_AC3;
	480	+ codec_id = AV_CODEC_ID_DTS;
	481	+ else codec_id = AV_CODEC_ID_AC3;
482	482	break;
483	483	default: av_log(s, AV_LOG_ERROR, "Unknown 0x1bd sub-stream\n");
484	484	goto skip;
@@ -496,7 +496,7 @@ static int mpegps_read_packet(AVFormatContext *s, · 11 unmodified lines
496	496	st->id = startcode;
497	497	st->codec->codec_type = type;
498	498	st->codec->codec_id = codec_id;
499		− if (codec_id != CODEC_ID_PCM_S16BE)
	499	+ if (codec_id != AV_CODEC_ID_PCM_S16BE)
500	500	st->need_parsing = AVSTREAM_PARSE_FULL;
501	501	found:
502	502	if(st->discard >= AVDISCARD_ALL)
@@ -521,7 +521,7 @@ static int mpegps_read_packet(AVFormatContext *s, · 18 unmodified lines
521	521	st->codec->sample_rate *
522	522	st->codec->bits_per_coded_sample;
523	523	if (st->codec->bits_per_coded_sample == 16)
524		− st->codec->codec_id = CODEC_ID_PCM_S16BE;
	524	+ st->codec->codec_id = AV_CODEC_ID_PCM_S16BE;
525	525	else if (st->codec->bits_per_coded_sample == 28)
526	526	return AVERROR(EINVAL);
527	527	}

libavformat/mpegenc.c+13−13

@@ -343,11 +343,11 @@ static int mpeg_mux_init(AVFormatContext *ctx) · 342 unmodified lines
343	343
344	344	switch(st->codec->codec_type) {
345	345	case AVMEDIA_TYPE_AUDIO:
346		− if (st->codec->codec_id == CODEC_ID_AC3) {
	346	+ if (st->codec->codec_id == AV_CODEC_ID_AC3) {
347	347	stream->id = ac3_id++;
348		− } else if (st->codec->codec_id == CODEC_ID_DTS) {
	348	+ } else if (st->codec->codec_id == AV_CODEC_ID_DTS) {
349	349	stream->id = dts_id++;
350		− } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
	350	+ } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
351	351	stream->id = lpcm_id++;
352	352	for(j = 0; j < 4; j++) {
353	353	if (lpcm_freq_tab[j] == st->codec->sample_rate)
@@ -1148,8 +1148,8 @@ AVOutputFormat ff_mpeg1system_muxer = { · 794 unmodified lines
1148	1148	.mime_type = "video/mpeg",
1149	1149	.extensions = "mpg,mpeg",
1150	1150	.priv_data_size = sizeof(MpegMuxContext),
1151		− .audio_codec = CODEC_ID_MP2,
1152		− .video_codec = CODEC_ID_MPEG1VIDEO,
	1151	+ .audio_codec = AV_CODEC_ID_MP2,
	1152	+ .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1153	1153	.write_header = mpeg_mux_init,
1154	1154	.write_packet = mpeg_mux_write_packet,
1155	1155	.write_trailer = mpeg_mux_end,
@@ -1163,8 +1163,8 @@ AVOutputFormat ff_mpeg1vcd_muxer = { · 7 unmodified lines
1163	1163	.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1164	1164	.mime_type = "video/mpeg",
1165	1165	.priv_data_size = sizeof(MpegMuxContext),
1166		− .audio_codec = CODEC_ID_MP2,
1167		− .video_codec = CODEC_ID_MPEG1VIDEO,
	1166	+ .audio_codec = AV_CODEC_ID_MP2,
	1167	+ .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1168	1168	.write_header = mpeg_mux_init,
1169	1169	.write_packet = mpeg_mux_write_packet,
1170	1170	.write_trailer = mpeg_mux_end,
@@ -1179,8 +1179,8 @@ AVOutputFormat ff_mpeg2vob_muxer = { · 8 unmodified lines
1179	1179	.mime_type = "video/mpeg",
1180	1180	.extensions = "vob",
1181	1181	.priv_data_size = sizeof(MpegMuxContext),
1182		− .audio_codec = CODEC_ID_MP2,
1183		− .video_codec = CODEC_ID_MPEG2VIDEO,
	1182	+ .audio_codec = AV_CODEC_ID_MP2,
	1183	+ .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1184	1184	.write_header = mpeg_mux_init,
1185	1185	.write_packet = mpeg_mux_write_packet,
1186	1186	.write_trailer = mpeg_mux_end,
@@ -1197,8 +1197,8 @@ AVOutputFormat ff_mpeg2svcd_muxer = { · 10 unmodified lines
1197	1197	.mime_type = "video/mpeg",
1198	1198	.extensions = "vob",
1199	1199	.priv_data_size = sizeof(MpegMuxContext),
1200		− .audio_codec = CODEC_ID_MP2,
1201		− .video_codec = CODEC_ID_MPEG2VIDEO,
	1200	+ .audio_codec = AV_CODEC_ID_MP2,
	1201	+ .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1202	1202	.write_header = mpeg_mux_init,
1203	1203	.write_packet = mpeg_mux_write_packet,
1204	1204	.write_trailer = mpeg_mux_end,
@@ -1215,8 +1215,8 @@ AVOutputFormat ff_mpeg2dvd_muxer = { · 10 unmodified lines
1215	1215	.mime_type = "video/mpeg",
1216	1216	.extensions = "dvd",
1217	1217	.priv_data_size = sizeof(MpegMuxContext),
1218		− .audio_codec = CODEC_ID_MP2,
1219		− .video_codec = CODEC_ID_MPEG2VIDEO,
	1218	+ .audio_codec = AV_CODEC_ID_MP2,
	1219	+ .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1220	1220	.write_header = mpeg_mux_init,
1221	1221	.write_packet = mpeg_mux_write_packet,
1222	1222	.write_trailer = mpeg_mux_end,

libavformat/mpegts.c+52−52

@@ -509,60 +509,60 @@ static int parse_section_header(SectionHeader *h, · 508 unmodified lines
509	509	typedef struct {
510	510	uint32_t stream_type;
511	511	enum AVMediaType codec_type;
512		− enum CodecID codec_id;
	512	+ enum AVCodecID codec_id;
513	513	} StreamType;
514	514
515	515	static const StreamType ISO_types[] = {
516		− { 0x01, AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
517		− { 0x02, AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
518		− { 0x03, AVMEDIA_TYPE_AUDIO, CODEC_ID_MP3 },
519		− { 0x04, AVMEDIA_TYPE_AUDIO, CODEC_ID_MP3 },
520		− { 0x0f, AVMEDIA_TYPE_AUDIO, CODEC_ID_AAC },
521		− { 0x10, AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG4 },
522		− { 0x11, AVMEDIA_TYPE_AUDIO, CODEC_ID_AAC_LATM }, /* LATM syntax */
523		− { 0x1b, AVMEDIA_TYPE_VIDEO, CODEC_ID_H264 },
524		− { 0xd1, AVMEDIA_TYPE_VIDEO, CODEC_ID_DIRAC },
525		− { 0xea, AVMEDIA_TYPE_VIDEO, CODEC_ID_VC1 },
	516	+ { 0x01, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO },
	517	+ { 0x02, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO },
	518	+ { 0x03, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 },
	519	+ { 0x04, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 },
	520	+ { 0x0f, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC },
	521	+ { 0x10, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG4 },
	522	+ { 0x11, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC_LATM }, /* LATM syntax */
	523	+ { 0x1b, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264 },
	524	+ { 0xd1, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },
	525	+ { 0xea, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 },
526	526	{ 0 },
527	527	};
528	528
529	529	static const StreamType HDMV_types[] = {
530		− { 0x80, AVMEDIA_TYPE_AUDIO, CODEC_ID_PCM_BLURAY },
531		− { 0x81, AVMEDIA_TYPE_AUDIO, CODEC_ID_AC3 },
532		− { 0x82, AVMEDIA_TYPE_AUDIO, CODEC_ID_DTS },
533		− { 0x83, AVMEDIA_TYPE_AUDIO, CODEC_ID_TRUEHD },
534		− { 0x84, AVMEDIA_TYPE_AUDIO, CODEC_ID_EAC3 },
535		− { 0x85, AVMEDIA_TYPE_AUDIO, CODEC_ID_DTS }, /* DTS HD */
536		− { 0x86, AVMEDIA_TYPE_AUDIO, CODEC_ID_DTS }, /* DTS HD MASTER*/
537		− { 0x90, AVMEDIA_TYPE_SUBTITLE, CODEC_ID_HDMV_PGS_SUBTITLE },
	530	+ { 0x80, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_PCM_BLURAY },
	531	+ { 0x81, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
	532	+ { 0x82, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
	533	+ { 0x83, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_TRUEHD },
	534	+ { 0x84, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 },
	535	+ { 0x85, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD */
	536	+ { 0x86, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD MASTER*/
	537	+ { 0x90, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_HDMV_PGS_SUBTITLE },
538	538	{ 0 },
539	539	};
540	540
541	541	/* ATSC ? */
542	542	static const StreamType MISC_types[] = {
543		− { 0x81, AVMEDIA_TYPE_AUDIO, CODEC_ID_AC3 },
544		− { 0x8a, AVMEDIA_TYPE_AUDIO, CODEC_ID_DTS },
	543	+ { 0x81, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
	544	+ { 0x8a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
545	545	{ 0 },
546	546	};
547	547
548	548	static const StreamType REGD_types[] = {
549		− { MKTAG('d','r','a','c'), AVMEDIA_TYPE_VIDEO, CODEC_ID_DIRAC },
550		− { MKTAG('A','C','-','3'), AVMEDIA_TYPE_AUDIO, CODEC_ID_AC3 },
551		− { MKTAG('B','S','S','D'), AVMEDIA_TYPE_AUDIO, CODEC_ID_S302M },
552		− { MKTAG('D','T','S','1'), AVMEDIA_TYPE_AUDIO, CODEC_ID_DTS },
553		− { MKTAG('D','T','S','2'), AVMEDIA_TYPE_AUDIO, CODEC_ID_DTS },
554		− { MKTAG('D','T','S','3'), AVMEDIA_TYPE_AUDIO, CODEC_ID_DTS },
555		− { MKTAG('V','C','-','1'), AVMEDIA_TYPE_VIDEO, CODEC_ID_VC1 },
	549	+ { MKTAG('d','r','a','c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },
	550	+ { MKTAG('A','C','-','3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
	551	+ { MKTAG('B','S','S','D'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_S302M },
	552	+ { MKTAG('D','T','S','1'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
	553	+ { MKTAG('D','T','S','2'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
	554	+ { MKTAG('D','T','S','3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
	555	+ { MKTAG('V','C','-','1'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 },
556	556	{ 0 },
557	557	};
558	558
559	559	/* descriptor present */
560	560	static const StreamType DESC_types[] = {
561		− { 0x6a, AVMEDIA_TYPE_AUDIO, CODEC_ID_AC3 }, /* AC-3 descriptor */
562		− { 0x7a, AVMEDIA_TYPE_AUDIO, CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
563		− { 0x7b, AVMEDIA_TYPE_AUDIO, CODEC_ID_DTS },
564		− { 0x56, AVMEDIA_TYPE_SUBTITLE, CODEC_ID_DVB_TELETEXT },
565		− { 0x59, AVMEDIA_TYPE_SUBTITLE, CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
	561	+ { 0x6a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, /* AC-3 descriptor */
	562	+ { 0x7a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
	563	+ { 0x7b, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
	564	+ { 0x56, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_TELETEXT },
	565	+ { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
566	566	{ 0 },
567	567	};
568	568
@@ -584,7 +584,7 @@ static int mpegts_set_stream_info(AVStream st, PESContext pes, · 15 unmodified lines
584	584	avpriv_set_pts_info(st, 33, 1, 90000);
585	585	st->priv_data = pes;
586	586	st->codec->codec_type = AVMEDIA_TYPE_DATA;
587		− st->codec->codec_id = CODEC_ID_NONE;
	587	+ st->codec->codec_id = AV_CODEC_ID_NONE;
588	588	st->need_parsing = AVSTREAM_PARSE_FULL;
589	589	pes->st = st;
590	590	pes->stream_type = stream_type;
@@ -597,7 +597,7 @@ static int mpegts_set_stream_info(AVStream st, PESContext pes, · 6 unmodified lines
597	597
598	598	mpegts_find_stream_type(st, pes->stream_type, ISO_types);
599	599	if (prog_reg_desc == AV_RL32("HDMV") &&
600		− st->codec->codec_id == CODEC_ID_NONE) {
	600	+ st->codec->codec_id == AV_CODEC_ID_NONE) {
601	601	mpegts_find_stream_type(st, pes->stream_type, HDMV_types);
602	602	if (pes->stream_type == 0x83) {
603	603	// HDMV TrueHD streams also contain an AC3 coded version of the
@@ -619,12 +619,12 @@ static int mpegts_set_stream_info(AVStream st, PESContext pes, · 15 unmodified lines
619	619	avpriv_set_pts_info(sub_st, 33, 1, 90000);
620	620	sub_st->priv_data = sub_pes;
621	621	sub_st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
622		− sub_st->codec->codec_id = CODEC_ID_AC3;
	622	+ sub_st->codec->codec_id = AV_CODEC_ID_AC3;
623	623	sub_st->need_parsing = AVSTREAM_PARSE_FULL;
624	624	sub_pes->sub_st = pes->sub_st = sub_st;
625	625	}
626	626	}
627		− if (st->codec->codec_id == CODEC_ID_NONE)
	627	+ if (st->codec->codec_id == AV_CODEC_ID_NONE)
628	628	mpegts_find_stream_type(st, pes->stream_type, MISC_types);
629	629
630	630	return 0;
@@ -813,10 +813,10 @@ static int mpegts_push_data(MpegTSFilter *filter, · 182 unmodified lines
813	813	code != 0x1ff && code != 0x1f2 && /* program_stream_directory, DSMCC_stream */
814	814	code != 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */
815	815	pes->state = MPEGTS_PESHEADER;
816		− if (pes->st->codec->codec_id == CODEC_ID_NONE) {
	816	+ if (pes->st->codec->codec_id == AV_CODEC_ID_NONE) {
817	817	av_dlog(pes->stream, "pid=%x stream_type=%x probing\n",
818	818	pes->pid, pes->stream_type);
819		− pes->st->codec->codec_id = CODEC_ID_PROBE;
	819	+ pes->st->codec->codec_id = AV_CODEC_ID_PROBE;
820	820	}
821	821	} else {
822	822	pes->state = MPEGTS_PAYLOAD;
@@ -1218,19 +1218,19 @@ static void m4sl_cb(MpegTSFilter filter, const uint8_t section, int section_le · 395 unmodified lines
1218	1218	ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
1219	1219	mp4_descr[i].dec_config_descr_len, 0, NULL, NULL, NULL, NULL);
1220	1220	ff_mp4_read_dec_config_descr(s, st, &pb);
1221		− if (st->codec->codec_id == CODEC_ID_AAC &&
	1221	+ if (st->codec->codec_id == AV_CODEC_ID_AAC &&
1222	1222	st->codec->extradata_size > 0)
1223	1223	st->need_parsing = 0;
1224		− if (st->codec->codec_id == CODEC_ID_H264 &&
	1224	+ if (st->codec->codec_id == AV_CODEC_ID_H264 &&
1225	1225	st->codec->extradata_size > 0)
1226	1226	st->need_parsing = 0;
1227	1227
1228		− if (st->codec->codec_id <= CODEC_ID_NONE) {
1229		− } else if (st->codec->codec_id < CODEC_ID_FIRST_AUDIO) {
	1228	+ if (st->codec->codec_id <= AV_CODEC_ID_NONE) {
	1229	+ } else if (st->codec->codec_id < AV_CODEC_ID_FIRST_AUDIO) {
1230	1230	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
1231		− } else if (st->codec->codec_id < CODEC_ID_FIRST_SUBTITLE) {
	1231	+ } else if (st->codec->codec_id < AV_CODEC_ID_FIRST_SUBTITLE) {
1232	1232	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
1233		− } else if (st->codec->codec_id < CODEC_ID_FIRST_UNKNOWN) {
	1233	+ } else if (st->codec->codec_id < AV_CODEC_ID_FIRST_UNKNOWN) {
1234	1234	st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
1235	1235	}
1236	1236	}
@@ -1261,7 +1261,7 @@ int ff_parse_mpeg2_descriptor(AVFormatContext fc, AVStream st, int stream_type · 24 unmodified lines
1261	1261
1262	1262	av_dlog(fc, "tag: 0x%02x len=%d\n", desc_tag, desc_len);
1263	1263
1264		− if (st->codec->codec_id == CODEC_ID_NONE &&
	1264	+ if (st->codec->codec_id == AV_CODEC_ID_NONE &&
1265	1265	stream_type == STREAM_TYPE_PRIVATE_DATA)
1266	1266	mpegts_find_stream_type(st, desc_tag, DESC_types);
1267	1267
@@ -1277,22 +1277,22 @@ int ff_parse_mpeg2_descriptor(AVFormatContext fc, AVStream st, int stream_type · 9 unmodified lines
1277	1277	ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
1278	1278	mp4_descr[i].dec_config_descr_len, 0, NULL, NULL, NULL, NULL);
1279	1279	ff_mp4_read_dec_config_descr(fc, st, &pb);
1280		− if (st->codec->codec_id == CODEC_ID_AAC &&
	1280	+ if (st->codec->codec_id == AV_CODEC_ID_AAC &&
1281	1281	st->codec->extradata_size > 0)
1282	1282	st->need_parsing = 0;
1283		− if (st->codec->codec_id == CODEC_ID_MPEG4SYSTEMS)
	1283	+ if (st->codec->codec_id == AV_CODEC_ID_MPEG4SYSTEMS)
1284	1284	mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1);
1285	1285	}
1286	1286	break;
1287	1287	case 0x1F: /* FMC descriptor */
1288	1288	get16(pp, desc_end);
1289		− if (mp4_descr_count > 0 && st->codec->codec_id == CODEC_ID_AAC_LATM &&
	1289	+ if (mp4_descr_count > 0 && st->codec->codec_id == AV_CODEC_ID_AAC_LATM &&
1290	1290	mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) {
1291	1291	AVIOContext pb;
1292	1292	ffio_init_context(&pb, mp4_descr->dec_config_descr,
1293	1293	mp4_descr->dec_config_descr_len, 0, NULL, NULL, NULL, NULL);
1294	1294	ff_mp4_read_dec_config_descr(fc, st, &pb);
1295		− if (st->codec->codec_id == CODEC_ID_AAC &&
	1295	+ if (st->codec->codec_id == AV_CODEC_ID_AAC &&
1296	1296	st->codec->extradata_size > 0)
1297	1297	st->need_parsing = 0;
1298	1298	}
@@ -1353,7 +1353,7 @@ int ff_parse_mpeg2_descriptor(AVFormatContext fc, AVStream st, int stream_type · 54 unmodified lines
1353	1353	case 0x05: /* registration descriptor */
1354	1354	st->codec->codec_tag = bytestream_get_le32(pp);
1355	1355	av_dlog(fc, "reg_desc=%.4s\n", (char*)&st->codec->codec_tag);
1356		− if (st->codec->codec_id == CODEC_ID_NONE)
	1356	+ if (st->codec->codec_id == AV_CODEC_ID_NONE)
1357	1357	mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types);
1358	1358	break;
1359	1359	default:
@@ -1924,7 +1924,7 @@ static int mpegts_read_header(AVFormatContext *s) · 564 unmodified lines
1924	1924	goto fail;
1925	1925	avpriv_set_pts_info(st, 60, 1, 27000000);
1926	1926	st->codec->codec_type = AVMEDIA_TYPE_DATA;
1927		− st->codec->codec_id = CODEC_ID_MPEG2TS;
	1927	+ st->codec->codec_id = AV_CODEC_ID_MPEG2TS;
1928	1928
1929	1929	/* we iterate until we find two PCRs to estimate the bitrate */
1930	1930	pcr_pid = -1;

libavformat/mpegtsenc.c+21−21

@@ -269,30 +269,30 @@ static void mpegts_write_pmt(AVFormatContext s, MpegTSService service) · 268 unmodified lines
269	269	MpegTSWriteStream *ts_st = st->priv_data;
270	270	AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0);
271	271	switch(st->codec->codec_id) {
272		− case CODEC_ID_MPEG1VIDEO:
273		− case CODEC_ID_MPEG2VIDEO:
	272	+ case AV_CODEC_ID_MPEG1VIDEO:
	273	+ case AV_CODEC_ID_MPEG2VIDEO:
274	274	stream_type = STREAM_TYPE_VIDEO_MPEG2;
275	275	break;
276		− case CODEC_ID_MPEG4:
	276	+ case AV_CODEC_ID_MPEG4:
277	277	stream_type = STREAM_TYPE_VIDEO_MPEG4;
278	278	break;
279		− case CODEC_ID_H264:
	279	+ case AV_CODEC_ID_H264:
280	280	stream_type = STREAM_TYPE_VIDEO_H264;
281	281	break;
282		− case CODEC_ID_DIRAC:
	282	+ case AV_CODEC_ID_DIRAC:
283	283	stream_type = STREAM_TYPE_VIDEO_DIRAC;
284	284	break;
285		− case CODEC_ID_MP2:
286		− case CODEC_ID_MP3:
	285	+ case AV_CODEC_ID_MP2:
	286	+ case AV_CODEC_ID_MP3:
287	287	stream_type = STREAM_TYPE_AUDIO_MPEG1;
288	288	break;
289		− case CODEC_ID_AAC:
	289	+ case AV_CODEC_ID_AAC:
290	290	stream_type = (ts->flags & MPEGTS_FLAG_AAC_LATM) ? STREAM_TYPE_AUDIO_AAC_LATM : STREAM_TYPE_AUDIO_AAC;
291	291	break;
292		− case CODEC_ID_AAC_LATM:
	292	+ case AV_CODEC_ID_AAC_LATM:
293	293	stream_type = STREAM_TYPE_AUDIO_AAC_LATM;
294	294	break;
295		− case CODEC_ID_AC3:
	295	+ case AV_CODEC_ID_AC3:
296	296	stream_type = STREAM_TYPE_AUDIO_AC3;
297	297	break;
298	298	default:
@@ -556,7 +556,7 @@ static int mpegts_write_header(AVFormatContext *s) · 257 unmodified lines
556	556	service->pcr_pid = ts_st->pid;
557	557	pcr_st = st;
558	558	}
559		− if (st->codec->codec_id == CODEC_ID_AAC &&
	559	+ if (st->codec->codec_id == AV_CODEC_ID_AAC &&
560	560	st->codec->extradata_size > 0)
561	561	{
562	562	AVStream *ast;
@@ -861,14 +861,14 @@ static void mpegts_write_pes(AVFormatContext s, AVStream st, · 298 unmodified lines
861	861	*q++ = 0x01;
862	862	private_code = 0;
863	863	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
864		− if (st->codec->codec_id == CODEC_ID_DIRAC) {
	864	+ if (st->codec->codec_id == AV_CODEC_ID_DIRAC) {
865	865	*q++ = 0xfd;
866	866	} else
867	867	*q++ = 0xe0;
868	868	} else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
869		− (st->codec->codec_id == CODEC_ID_MP2 \|\|
870		− st->codec->codec_id == CODEC_ID_MP3 \|\|
871		− st->codec->codec_id == CODEC_ID_AAC)) {
	869	+ (st->codec->codec_id == AV_CODEC_ID_MP2 \|\|
	870	+ st->codec->codec_id == AV_CODEC_ID_MP3 \|\|
	871	+ st->codec->codec_id == AV_CODEC_ID_AAC)) {
872	872	*q++ = 0xc0;
873	873	} else {
874	874	*q++ = 0xbd;
@@ -887,7 +887,7 @@ static void mpegts_write_pes(AVFormatContext s, AVStream st, · 12 unmodified lines
887	887	flags \|= 0x40;
888	888	}
889	889	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
890		− st->codec->codec_id == CODEC_ID_DIRAC) {
	890	+ st->codec->codec_id == AV_CODEC_ID_DIRAC) {
891	891	/* set PES_extension_flag */
892	892	pes_extension = 1;
893	893	flags \|= 0x01;
@@ -921,7 +921,7 @@ static void mpegts_write_pes(AVFormatContext s, AVStream st, · 27 unmodified lines
921	921	write_pts(q, 1, dts);
922	922	q += 5;
923	923	}
924		− if (pes_extension && st->codec->codec_id == CODEC_ID_DIRAC) {
	924	+ if (pes_extension && st->codec->codec_id == AV_CODEC_ID_DIRAC) {
925	925	flags = 0x01; /* set PES_extension_flag_2 */
926	926	*q++ = flags;
927	927	q++ = 0x80 \| 0x01; / marker bit + extension length */
@@ -1005,7 +1005,7 @@ static int mpegts_write_packet_internal(AVFormatContext s, AVPacket pkt) · 77 unmodified lines
1005	1005	}
1006	1006	ts_st->first_pts_check = 0;
1007	1007
1008		− if (st->codec->codec_id == CODEC_ID_H264) {
	1008	+ if (st->codec->codec_id == AV_CODEC_ID_H264) {
1009	1009	const uint8_t p = buf, buf_end = p+size;
1010	1010	uint32_t state = -1;
1011	1011
@@ -1032,7 +1032,7 @@ static int mpegts_write_packet_internal(AVFormatContext s, AVPacket pkt) · 20 unmodified lines
1032	1032	buf = data;
1033	1033	size = pkt->size+6;
1034	1034	}
1035		− } else if (st->codec->codec_id == CODEC_ID_AAC) {
	1035	+ } else if (st->codec->codec_id == AV_CODEC_ID_AAC) {
1036	1036	if (pkt->size < 2) {
1037	1037	av_log(s, AV_LOG_ERROR, "AAC packet too short\n");
1038	1038	return AVERROR(EINVAL);
@@ -1166,8 +1166,8 @@ AVOutputFormat ff_mpegts_muxer = { · 127 unmodified lines
1166	1166	.mime_type = "video/x-mpegts",
1167	1167	.extensions = "ts,m2t",
1168	1168	.priv_data_size = sizeof(MpegTSWrite),
1169		− .audio_codec = CODEC_ID_MP2,
1170		− .video_codec = CODEC_ID_MPEG2VIDEO,
	1169	+ .audio_codec = AV_CODEC_ID_MP2,
	1170	+ .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1171	1171	.write_header = mpegts_write_header,
1172	1172	.write_packet = mpegts_write_packet,
1173	1173	.write_trailer = mpegts_write_end,

libavformat/mpegvideodec.c+1−1

@@ -55,4 +55,4 @@ static int mpegvideo_probe(AVProbeData *p) · 54 unmodified lines
55	55	return 0;
56	56	}
57	57
58		−FF_DEF_RAWVIDEO_DEMUXER(mpegvideo, "raw MPEG video", mpegvideo_probe, NULL, CODEC_ID_MPEG1VIDEO)
	58	+FF_DEF_RAWVIDEO_DEMUXER(mpegvideo, "raw MPEG video", mpegvideo_probe, NULL, AV_CODEC_ID_MPEG1VIDEO)

libavformat/mpjpeg.c+2−2

@@ -58,8 +58,8 @@ AVOutputFormat ff_mpjpeg_muxer = { · 57 unmodified lines
58	58	.long_name = NULL_IF_CONFIG_SMALL("MIME multipart JPEG"),
59	59	.mime_type = "multipart/x-mixed-replace;boundary=" BOUNDARY_TAG,
60	60	.extensions = "mjpg",
61		− .audio_codec = CODEC_ID_NONE,
62		− .video_codec = CODEC_ID_MJPEG,
	61	+ .audio_codec = AV_CODEC_ID_NONE,
	62	+ .video_codec = AV_CODEC_ID_MJPEG,
63	63	.write_header = mpjpeg_write_header,
64	64	.write_packet = mpjpeg_write_packet,
65	65	.write_trailer = mpjpeg_write_trailer,

libavformat/msnwc_tcp.c+1−1

@@ -82,7 +82,7 @@ static int msnwc_tcp_read_header(AVFormatContext *ctx) · 81 unmodified lines
82	82
83	83	codec = st->codec;
84	84	codec->codec_type = AVMEDIA_TYPE_VIDEO;
85		− codec->codec_id = CODEC_ID_MIMIC;
	85	+ codec->codec_id = AV_CODEC_ID_MIMIC;
86	86	codec->codec_tag = MKTAG('M', 'L', '2', '0');
87	87
88	88	avpriv_set_pts_info(st, 32, 1, 1000);

libavformat/mtv.c+2−2

@@ -129,7 +129,7 @@ static int mtv_read_header(AVFormatContext *s) · 128 unmodified lines
129	129
130	130	avpriv_set_pts_info(st, 64, 1, mtv->video_fps);
131	131	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
132		− st->codec->codec_id = CODEC_ID_RAWVIDEO;
	132	+ st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
133	133	st->codec->pix_fmt = PIX_FMT_RGB565BE;
134	134	st->codec->width = mtv->img_width;
135	135	st->codec->height = mtv->img_height;
@@ -145,7 +145,7 @@ static int mtv_read_header(AVFormatContext *s) · 9 unmodified lines
145	145
146	146	avpriv_set_pts_info(st, 64, 1, AUDIO_SAMPLING_RATE);
147	147	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
148		− st->codec->codec_id = CODEC_ID_MP3;
	148	+ st->codec->codec_id = AV_CODEC_ID_MP3;
149	149	st->codec->bit_rate = mtv->audio_br;
150	150	st->need_parsing = AVSTREAM_PARSE_FULL;
151	151

libavformat/mvi.c+2−2

@@ -79,14 +79,14 @@ static int read_header(AVFormatContext *s) · 78 unmodified lines
79	79
80	80	avpriv_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
81	81	ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
82		− ast->codec->codec_id = CODEC_ID_PCM_U8;
	82	+ ast->codec->codec_id = AV_CODEC_ID_PCM_U8;
83	83	ast->codec->channels = 1;
84	84	ast->codec->bits_per_coded_sample = 8;
85	85	ast->codec->bit_rate = ast->codec->sample_rate * 8;
86	86
87	87	avpriv_set_pts_info(vst, 64, msecs_per_frame, 1000000);
88	88	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
89		− vst->codec->codec_id = CODEC_ID_MOTIONPIXELS;
	89	+ vst->codec->codec_id = AV_CODEC_ID_MOTIONPIXELS;
90	90
91	91	mvi->get_int = (vst->codec->width * vst->codec->height < (1 << 16)) ? avio_rl16 : avio_rl24;
92	92

libavformat/mxf.c+19−19

@@ -33,26 +33,26 @@ const MXFCodecUL ff_mxf_data_definition_uls[] = { · 32 unmodified lines
33	33
34	34	const MXFCodecUL ff_mxf_codec_uls[] = {
35	35	/* PictureEssenceCoding */
36		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, 14, CODEC_ID_MPEG2VIDEO }, /* MP@ML Long GoP */
37		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x01 }, 14, CODEC_ID_MPEG2VIDEO }, /* D-10 50Mbps PAL */
38		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x03,0x00 }, 14, CODEC_ID_MPEG2VIDEO }, /* MP@HL Long GoP */
39		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x02,0x00 }, 14, CODEC_ID_MPEG2VIDEO }, /* 422P@HL I-Frame */
40		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x20,0x02,0x03 }, 14, CODEC_ID_MPEG4 }, /* XDCAM proxy_pal030926.mxf */
41		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x01,0x02,0x00 }, 13, CODEC_ID_DVVIDEO }, /* DV25 IEC PAL */
42		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
43		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x01,0x7F,0x00,0x00,0x00 }, 13, CODEC_ID_RAWVIDEO }, /* Uncompressed */
44		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x03,0x02,0x00,0x00 }, 14, CODEC_ID_DNXHD }, /* SMPTE VC-3/DNxHD */
45		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14, CODEC_ID_H264 }, /* H.264/MPEG-4 AVC Intra */
46		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, 15, CODEC_ID_V210 }, /* V210 */
	36	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MP@ML Long GoP */
	37	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* D-10 50Mbps PAL */
	38	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x03,0x00 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MP@HL Long GoP */
	39	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x02,0x00 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* 422P@HL I-Frame */
	40	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x20,0x02,0x03 }, 14, AV_CODEC_ID_MPEG4 }, /* XDCAM proxy_pal030926.mxf */
	41	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x01,0x02,0x00 }, 13, AV_CODEC_ID_DVVIDEO }, /* DV25 IEC PAL */
	42	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
	43	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x01,0x7F,0x00,0x00,0x00 }, 13, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed */
	44	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x03,0x02,0x00,0x00 }, 14, AV_CODEC_ID_DNXHD }, /* SMPTE VC-3/DNxHD */
	45	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14, AV_CODEC_ID_H264 }, /* H.264/MPEG-4 AVC Intra */
	46	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, 15, AV_CODEC_ID_V210 }, /* V210 */
47	47	/* SoundEssenceCompression */
48		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 }, 13, CODEC_ID_PCM_S16LE }, /* Uncompressed */
49		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x7F,0x00,0x00,0x00 }, 13, CODEC_ID_PCM_S16LE },
50		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x07,0x04,0x02,0x02,0x01,0x7E,0x00,0x00,0x00 }, 13, CODEC_ID_PCM_S16BE }, /* From Omneon MXF file */
51		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x04,0x04,0x02,0x02,0x02,0x03,0x01,0x01,0x00 }, 15, CODEC_ID_PCM_ALAW }, /* XDCAM Proxy C0023S01.mxf */
52		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x02,0x03,0x02,0x01,0x00 }, 15, CODEC_ID_AC3 },
53		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x02,0x03,0x02,0x05,0x00 }, 15, CODEC_ID_MP2 }, /* MP2 or MP3 */
54		− //{ { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x02,0x03,0x02,0x1C,0x00 }, 15, CODEC_ID_DOLBY_E }, /* Dolby-E */
55		− { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, CODEC_ID_NONE },
	48	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 }, 13, AV_CODEC_ID_PCM_S16LE }, /* Uncompressed */
	49	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x7F,0x00,0x00,0x00 }, 13, AV_CODEC_ID_PCM_S16LE },
	50	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x07,0x04,0x02,0x02,0x01,0x7E,0x00,0x00,0x00 }, 13, AV_CODEC_ID_PCM_S16BE }, /* From Omneon MXF file */
	51	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x04,0x04,0x02,0x02,0x02,0x03,0x01,0x01,0x00 }, 15, AV_CODEC_ID_PCM_ALAW }, /* XDCAM Proxy C0023S01.mxf */
	52	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x02,0x03,0x02,0x01,0x00 }, 15, AV_CODEC_ID_AC3 },
	53	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x02,0x03,0x02,0x05,0x00 }, 15, AV_CODEC_ID_MP2 }, /* MP2 or MP3 */
	54	+ //{ { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x02,0x03,0x02,0x1C,0x00 }, 15, AV_CODEC_ID_DOLBY_E }, /* Dolby-E */
	55	+ { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
56	56	};
57	57
58	58	const MXFCodecUL ff_mxf_pixel_format_uls[] = {

libavformat/mxfdec.c+28−28

@@ -912,31 +912,31 @@ static void mxf_resolve_strong_ref(MXFContext mxf, UID *strong_ref, enum MXFMe · 911 unmodified lines
912	912
913	913	static const MXFCodecUL mxf_picture_essence_container_uls[] = {
914	914	// video essence container uls
915		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, CODEC_ID_MPEG2VIDEO }, /* MPEG-ES Frame wrapped */
916		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
917		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
918		− { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, CODEC_ID_NONE },
	915	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MPEG-ES Frame wrapped */
	916	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
	917	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
	918	+ { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
919	919	};
920	920
921	921	/* EC ULs for intra-only formats */
922	922	static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
923		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x00,0x00 }, 14, CODEC_ID_MPEG2VIDEO }, /* MXF-GC SMPTE D-10 Mappings */
924		− { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, CODEC_ID_NONE },
	923	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x00,0x00 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MXF-GC SMPTE D-10 Mappings */
	924	+ { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
925	925	};
926	926
927	927	/* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
928	928	static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
929		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14, CODEC_ID_H264 }, /* H.264/MPEG-4 AVC Intra Profiles */
930		− { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, CODEC_ID_NONE },
	929	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14, AV_CODEC_ID_H264 }, /* H.264/MPEG-4 AVC Intra Profiles */
	930	+ { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
931	931	};
932	932
933	933	static const MXFCodecUL mxf_sound_essence_container_uls[] = {
934	934	// sound essence container uls
935		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, CODEC_ID_PCM_S16LE }, /* BWF Frame wrapped */
936		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, CODEC_ID_MP2 }, /* MPEG-ES Frame wrapped, 0x40 ??? stream id */
937		− { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, CODEC_ID_PCM_S16LE }, /* D-10 Mapping 50Mbps PAL Extended Template */
938		− { { 0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0xFF,0x4B,0x46,0x41,0x41,0x00,0x0D,0x4D,0x4F }, 14, CODEC_ID_PCM_S16LE }, /* 0001GL00.MXF.A1.mxf_opatom.mxf */
939		− { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, CODEC_ID_NONE },
	935	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, AV_CODEC_ID_PCM_S16LE }, /* BWF Frame wrapped */
	936	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, AV_CODEC_ID_MP2 }, /* MPEG-ES Frame wrapped, 0x40 ??? stream id */
	937	+ { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, AV_CODEC_ID_PCM_S16LE }, /* D-10 Mapping 50Mbps PAL Extended Template */
	938	+ { { 0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0xFF,0x4B,0x46,0x41,0x41,0x00,0x0D,0x4D,0x4F }, 14, AV_CODEC_ID_PCM_S16LE }, /* 0001GL00.MXF.A1.mxf_opatom.mxf */
	939	+ { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
940	940	};
941	941
942	942	static int mxf_get_sorted_table_segments(MXFContext mxf, int nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
@@ -1305,9 +1305,9 @@ finish_decoding_index: · 362 unmodified lines
1305	1305	static int mxf_is_intra_only(MXFDescriptor *d)
1306	1306	{
1307	1307	return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1308		− &d->essence_container_ul)->id != CODEC_ID_NONE \|\|
	1308	+ &d->essence_container_ul)->id != AV_CODEC_ID_NONE \|\|
1309	1309	mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1310		− &d->essence_codec_ul)->id != CODEC_ID_NONE;
	1310	+ &d->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1311	1311	}
1312	1312
1313	1313	static int mxf_parse_structural_metadata(MXFContext *mxf)
@@ -1468,7 +1468,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf) · 154 unmodified lines
1468	1468	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1469	1469	source_track->intra_only = mxf_is_intra_only(descriptor);
1470	1470	container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1471		− if (st->codec->codec_id == CODEC_ID_NONE)
	1471	+ if (st->codec->codec_id == AV_CODEC_ID_NONE)
1472	1472	st->codec->codec_id = container_ul->id;
1473	1473	st->codec->width = descriptor->width;
1474	1474	/* Field height, not frame height */
@@ -1499,7 +1499,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf) · 24 unmodified lines
1499	1499	"Unknown frame layout type: %d\n",
1500	1500	descriptor->frame_layout);
1501	1501	}
1502		− if (st->codec->codec_id == CODEC_ID_RAWVIDEO) {
	1502	+ if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1503	1503	st->codec->pix_fmt = descriptor->pix_fmt;
1504	1504	if (st->codec->pix_fmt == PIX_FMT_NONE) {
1505	1505	pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
@@ -1519,7 +1519,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf) · 13 unmodified lines
1519	1519	st->need_parsing = AVSTREAM_PARSE_HEADERS;
1520	1520	} else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1521	1521	container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1522		− if (st->codec->codec_id == CODEC_ID_NONE)
	1522	+ if (st->codec->codec_id == AV_CODEC_ID_NONE)
1523	1523	st->codec->codec_id = container_ul->id;
1524	1524	st->codec->channels = descriptor->channels;
1525	1525	st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
@@ -1527,18 +1527,18 @@ static int mxf_parse_structural_metadata(MXFContext *mxf) · 1 unmodified line
1527	1527	if (descriptor->sample_rate.den > 0)
1528	1528	st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1529	1529
1530		− /* TODO: implement CODEC_ID_RAWAUDIO */
1531		− if (st->codec->codec_id == CODEC_ID_PCM_S16LE) {
	1530	+ /* TODO: implement AV_CODEC_ID_RAWAUDIO */
	1531	+ if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1532	1532	if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1533		− st->codec->codec_id = CODEC_ID_PCM_S24LE;
	1533	+ st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1534	1534	else if (descriptor->bits_per_sample == 32)
1535		− st->codec->codec_id = CODEC_ID_PCM_S32LE;
1536		− } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
	1535	+ st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
	1536	+ } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1537	1537	if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1538		− st->codec->codec_id = CODEC_ID_PCM_S24BE;
	1538	+ st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1539	1539	else if (descriptor->bits_per_sample == 32)
1540		− st->codec->codec_id = CODEC_ID_PCM_S32BE;
1541		− } else if (st->codec->codec_id == CODEC_ID_MP2) {
	1540	+ st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
	1541	+ } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1542	1542	st->need_parsing = AVSTREAM_PARSE_FULL;
1543	1543	}
1544	1544	}
@@ -1779,10 +1779,10 @@ static inline void compute_partition_essence_offset(AVFormatContext *s, · 234 unmodified lines
1779	1779	}
1780	1780	}
1781	1781
1782		−static int is_pcm(enum CodecID codec_id)
	1782	+static int is_pcm(enum AVCodecID codec_id)
1783	1783	{
1784	1784	/* we only care about "normal" PCM codecs until we get samples */
1785		− return codec_id >= CODEC_ID_PCM_S16LE && codec_id < CODEC_ID_PCM_S24DAUD;
	1785	+ return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1786	1786	}
1787	1787
1788	1788	/**

libavformat/mxfenc.c+14−14

@@ -82,13 +82,13 @@ typedef struct { · 81 unmodified lines
82	82	} MXFContainerEssenceEntry;
83	83
84	84	static const struct {
85		− enum CodecID id;
	85	+ enum AVCodecID id;
86	86	int index;
87	87	} mxf_essence_mappings[] = {
88		− { CODEC_ID_MPEG2VIDEO, 0 },
89		− { CODEC_ID_PCM_S24LE, 1 },
90		− { CODEC_ID_PCM_S16LE, 1 },
91		− { CODEC_ID_NONE }
	88	+ { AV_CODEC_ID_MPEG2VIDEO, 0 },
	89	+ { AV_CODEC_ID_PCM_S24LE, 1 },
	90	+ { AV_CODEC_ID_PCM_S16LE, 1 },
	91	+ { AV_CODEC_ID_NONE }
92	92	};
93	93
94	94	static void mxf_write_wav_desc(AVFormatContext s, AVStream st);
@@ -366,7 +366,7 @@ static void klv_encode_ber4_length(AVIOContext *pb, int len) · 271 unmodified lines
366	366	/*
367	367	* Get essence container ul index
368	368	*/
369		−static int mxf_get_essence_container_ul_index(enum CodecID id)
	369	+static int mxf_get_essence_container_ul_index(enum AVCodecID id)
370	370	{
371	371	int i;
372	372	for (i = 0; mxf_essence_mappings[i].id; i++)
@@ -1476,8 +1476,8 @@ static int mxf_write_header(AVFormatContext *s) · 1103 unmodified lines
1476	1476	av_log(s, AV_LOG_ERROR, "MXF D-10 only support one audio track\n");
1477	1477	return -1;
1478	1478	}
1479		− if (st->codec->codec_id != CODEC_ID_PCM_S16LE &&
1480		− st->codec->codec_id != CODEC_ID_PCM_S24LE) {
	1479	+ if (st->codec->codec_id != AV_CODEC_ID_PCM_S16LE &&
	1480	+ st->codec->codec_id != AV_CODEC_ID_PCM_S24LE) {
1481	1481	av_log(s, AV_LOG_ERROR, "MXF D-10 only support 16 or 24 bits le audio\n");
1482	1482	}
1483	1483	sc->index = ((MXFStreamContext*)s->streams[0]->priv_data)->index + 1;
@@ -1652,7 +1652,7 @@ static void mxf_write_d10_audio_packet(AVFormatContext s, AVStream st, AVPacke · 168 unmodified lines
1652	1652	while (samples < end) {
1653	1653	for (i = 0; i < st->codec->channels; i++) {
1654	1654	uint32_t sample;
1655		− if (st->codec->codec_id == CODEC_ID_PCM_S24LE) {
	1655	+ if (st->codec->codec_id == AV_CODEC_ID_PCM_S24LE) {
1656	1656	sample = AV_RL24(samples)<< 4;
1657	1657	samples += 3;
1658	1658	} else {
@@ -1683,7 +1683,7 @@ static int mxf_write_packet(AVFormatContext s, AVPacket pkt) · 24 unmodified lines
1683	1683	}
1684	1684	}
1685	1685
1686		− if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO) {
	1686	+ if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1687	1687	if (!mxf_parse_mpeg2_frame(s, st, pkt, &ie)) {
1688	1688	av_log(s, AV_LOG_ERROR, "could not get mpeg2 profile and level\n");
1689	1689	return -1;
@@ -1894,8 +1894,8 @@ AVOutputFormat ff_mxf_muxer = { · 204 unmodified lines
1894	1894	.mime_type = "application/mxf",
1895	1895	.extensions = "mxf",
1896	1896	.priv_data_size = sizeof(MXFContext),
1897		− .audio_codec = CODEC_ID_PCM_S16LE,
1898		− .video_codec = CODEC_ID_MPEG2VIDEO,
	1897	+ .audio_codec = AV_CODEC_ID_PCM_S16LE,
	1898	+ .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1899	1899	.write_header = mxf_write_header,
1900	1900	.write_packet = mxf_write_packet,
1901	1901	.write_trailer = mxf_write_footer,
@@ -1908,8 +1908,8 @@ AVOutputFormat ff_mxf_d10_muxer = { · 6 unmodified lines
1908	1908	.long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format) D-10 Mapping"),
1909	1909	.mime_type = "application/mxf",
1910	1910	.priv_data_size = sizeof(MXFContext),
1911		− .audio_codec = CODEC_ID_PCM_S16LE,
1912		− .video_codec = CODEC_ID_MPEG2VIDEO,
	1911	+ .audio_codec = AV_CODEC_ID_PCM_S16LE,
	1912	+ .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1913	1913	.write_header = mxf_write_header,
1914	1914	.write_packet = mxf_write_packet,
1915	1915	.write_trailer = mxf_write_footer,

libavformat/mxg.c+2−2

@@ -47,14 +47,14 @@ static int mxg_read_header(AVFormatContext *s) · 46 unmodified lines
47	47	if (!video_st)
48	48	return AVERROR(ENOMEM);
49	49	video_st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
50		− video_st->codec->codec_id = CODEC_ID_MXPEG;
	50	+ video_st->codec->codec_id = AV_CODEC_ID_MXPEG;
51	51	avpriv_set_pts_info(video_st, 64, 1, 1000000);
52	52
53	53	audio_st = avformat_new_stream(s, NULL);
54	54	if (!audio_st)
55	55	return AVERROR(ENOMEM);
56	56	audio_st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
57		− audio_st->codec->codec_id = CODEC_ID_PCM_ALAW;
	57	+ audio_st->codec->codec_id = AV_CODEC_ID_PCM_ALAW;
58	58	audio_st->codec->channels = 1;
59	59	audio_st->codec->sample_rate = 8000;
60	60	audio_st->codec->bits_per_coded_sample = 8;

libavformat/ncdec.c+1−1

@@ -52,7 +52,7 @@ static int nc_read_header(AVFormatContext *s) · 51 unmodified lines
52	52	return AVERROR(ENOMEM);
53	53
54	54	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
55		− st->codec->codec_id = CODEC_ID_MPEG4;
	55	+ st->codec->codec_id = AV_CODEC_ID_MPEG4;
56	56	st->need_parsing = AVSTREAM_PARSE_FULL;
57	57
58	58	avpriv_set_pts_info(st, 64, 1, 100);

libavformat/nsvdec.c+21−21

@@ -187,31 +187,31 @@ typedef struct { · 186 unmodified lines
187	187	} NSVContext;
188	188
189	189	static const AVCodecTag nsv_codec_video_tags[] = {
190		− { CODEC_ID_VP3, MKTAG('V', 'P', '3', ' ') },
191		− { CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') },
192		− { CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') },
193		− { CODEC_ID_VP5, MKTAG('V', 'P', '5', ' ') },
194		− { CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') },
195		− { CODEC_ID_VP6, MKTAG('V', 'P', '6', ' ') },
196		− { CODEC_ID_VP6, MKTAG('V', 'P', '6', '0') },
197		− { CODEC_ID_VP6, MKTAG('V', 'P', '6', '1') },
198		− { CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },
	190	+ { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', ' ') },
	191	+ { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') },
	192	+ { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') },
	193	+ { AV_CODEC_ID_VP5, MKTAG('V', 'P', '5', ' ') },
	194	+ { AV_CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') },
	195	+ { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', ' ') },
	196	+ { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '0') },
	197	+ { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '1') },
	198	+ { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },
199	199	/*
200		− { CODEC_ID_VP4, MKTAG('V', 'P', '4', ' ') },
201		− { CODEC_ID_VP4, MKTAG('V', 'P', '4', '0') },
	200	+ { AV_CODEC_ID_VP4, MKTAG('V', 'P', '4', ' ') },
	201	+ { AV_CODEC_ID_VP4, MKTAG('V', 'P', '4', '0') },
202	202	*/
203		− { CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') }, /* cf sample xvid decoder from nsv_codec_sdk.zip */
204		− { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', '3') },
205		− { CODEC_ID_NONE, 0 },
	203	+ { AV_CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') }, /* cf sample xvid decoder from nsv_codec_sdk.zip */
	204	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', '3') },
	205	+ { AV_CODEC_ID_NONE, 0 },
206	206	};
207	207
208	208	static const AVCodecTag nsv_codec_audio_tags[] = {
209		− { CODEC_ID_MP3, MKTAG('M', 'P', '3', ' ') },
210		− { CODEC_ID_AAC, MKTAG('A', 'A', 'C', ' ') },
211		− { CODEC_ID_AAC, MKTAG('A', 'A', 'C', 'P') },
212		− { CODEC_ID_SPEEX, MKTAG('S', 'P', 'X', ' ') },
213		− { CODEC_ID_PCM_U16LE, MKTAG('P', 'C', 'M', ' ') },
214		− { CODEC_ID_NONE, 0 },
	209	+ { AV_CODEC_ID_MP3, MKTAG('M', 'P', '3', ' ') },
	210	+ { AV_CODEC_ID_AAC, MKTAG('A', 'A', 'C', ' ') },
	211	+ { AV_CODEC_ID_AAC, MKTAG('A', 'A', 'C', 'P') },
	212	+ { AV_CODEC_ID_SPEEX, MKTAG('S', 'P', 'X', ' ') },
	213	+ { AV_CODEC_ID_PCM_U16LE, MKTAG('P', 'C', 'M', ' ') },
	214	+ { AV_CODEC_ID_NONE, 0 },
215	215	};
216	216
217	217	//static int nsv_load_index(AVFormatContext *s);
@@ -656,7 +656,7 @@ null_chunk_retry: · 438 unmodified lines
656	656	}
657	657	bps /= channels; // ???
658	658	if (bps == 8)
659		− st[NSV_ST_AUDIO]->codec->codec_id = CODEC_ID_PCM_U8;
	659	+ st[NSV_ST_AUDIO]->codec->codec_id = AV_CODEC_ID_PCM_U8;
660	660	samplerate /= 4;/* UGH ??? XXX */
661	661	channels = 1;
662	662	st[NSV_ST_AUDIO]->codec->channels = channels;

libavformat/nullenc.c+2−2

@@ -29,8 +29,8 @@ static int null_write_packet(struct AVFormatContext s, AVPacket pkt) · 28 unmodified lines
29	29	AVOutputFormat ff_null_muxer = {
30	30	.name = "null",
31	31	.long_name = NULL_IF_CONFIG_SMALL("raw null video"),
32		− .audio_codec = AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),
33		− .video_codec = CODEC_ID_RAWVIDEO,
	32	+ .audio_codec = AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE),
	33	+ .video_codec = AV_CODEC_ID_RAWVIDEO,
34	34	.write_packet = null_write_packet,
35	35	.flags = AVFMT_NOFILE \| AVFMT_NOTIMESTAMPS \| AVFMT_RAWPICTURE,
36	36	};

libavformat/nut.c+59−59

@@ -25,68 +25,68 @@ · 24 unmodified lines
25	25	#include "internal.h"
26	26
27	27	const AVCodecTag ff_nut_subtitle_tags[] = {
28		− { CODEC_ID_TEXT , MKTAG('U', 'T', 'F', '8') },
29		− { CODEC_ID_SSA , MKTAG('S', 'S', 'A', 0 ) },
30		− { CODEC_ID_DVD_SUBTITLE, MKTAG('D', 'V', 'D', 'S') },
31		− { CODEC_ID_DVB_SUBTITLE, MKTAG('D', 'V', 'B', 'S') },
32		− { CODEC_ID_NONE , 0 }
	28	+ { AV_CODEC_ID_TEXT , MKTAG('U', 'T', 'F', '8') },
	29	+ { AV_CODEC_ID_SSA , MKTAG('S', 'S', 'A', 0 ) },
	30	+ { AV_CODEC_ID_DVD_SUBTITLE, MKTAG('D', 'V', 'D', 'S') },
	31	+ { AV_CODEC_ID_DVB_SUBTITLE, MKTAG('D', 'V', 'B', 'S') },
	32	+ { AV_CODEC_ID_NONE , 0 }
33	33	};
34	34
35	35	const AVCodecTag ff_nut_video_tags[] = {
36		− { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 15 ) },
37		− { CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 15 ) },
38		− { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 16 ) },
39		− { CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 16 ) },
40		− { CODEC_ID_RAWVIDEO, MKTAG(15 , 'B', 'G', 'R') },
41		− { CODEC_ID_RAWVIDEO, MKTAG(15 , 'R', 'G', 'B') },
42		− { CODEC_ID_RAWVIDEO, MKTAG(16 , 'B', 'G', 'R') },
43		− { CODEC_ID_RAWVIDEO, MKTAG(16 , 'R', 'G', 'B') },
44		− { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 12 ) },
45		− { CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 12 ) },
46		− { CODEC_ID_RAWVIDEO, MKTAG(12 , 'B', 'G', 'R') },
47		− { CODEC_ID_RAWVIDEO, MKTAG(12 , 'R', 'G', 'B') },
48		− { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 'A') },
49		− { CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 'A') },
50		− { CODEC_ID_RAWVIDEO, MKTAG('A', 'B', 'G', 'R') },
51		− { CODEC_ID_RAWVIDEO, MKTAG('A', 'R', 'G', 'B') },
52		− { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 24 ) },
53		− { CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 24 ) },
54		− { CODEC_ID_RAWVIDEO, MKTAG('4', '1', '1', 'P') },
55		− { CODEC_ID_RAWVIDEO, MKTAG('4', '2', '2', 'P') },
56		− { CODEC_ID_RAWVIDEO, MKTAG('4', '2', '2', 'P') },
57		− { CODEC_ID_RAWVIDEO, MKTAG('4', '4', '0', 'P') },
58		− { CODEC_ID_RAWVIDEO, MKTAG('4', '4', '0', 'P') },
59		− { CODEC_ID_RAWVIDEO, MKTAG('4', '4', '4', 'P') },
60		− { CODEC_ID_RAWVIDEO, MKTAG('4', '4', '4', 'P') },
61		− { CODEC_ID_RAWVIDEO, MKTAG('B', '1', 'W', '0') },
62		− { CODEC_ID_RAWVIDEO, MKTAG('B', '0', 'W', '1') },
63		− { CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 8 ) },
64		− { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 8 ) },
65		− { CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 4 ) },
66		− { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 4 ) },
67		− { CODEC_ID_RAWVIDEO, MKTAG('B', '4', 'B', 'Y') },
68		− { CODEC_ID_RAWVIDEO, MKTAG('R', '4', 'B', 'Y') },
69		− { CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 48 ) },
70		− { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 48 ) },
71		− { CODEC_ID_RAWVIDEO, MKTAG(48 , 'B', 'G', 'R') },
72		− { CODEC_ID_RAWVIDEO, MKTAG(48 , 'R', 'G', 'B') },
73		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 11 , 10 ) },
74		− { CODEC_ID_RAWVIDEO, MKTAG(10 , 11 , '3', 'Y') },
75		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 10 , 10 ) },
76		− { CODEC_ID_RAWVIDEO, MKTAG(10 , 10 , '3', 'Y') },
77		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 0 , 10 ) },
78		− { CODEC_ID_RAWVIDEO, MKTAG(10 , 0 , '3', 'Y') },
79		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '1', 0 , 16 ) },
80		− { CODEC_ID_RAWVIDEO, MKTAG(16 , 0 , '1', 'Y') },
81		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 11 , 16 ) },
82		− { CODEC_ID_RAWVIDEO, MKTAG(16 , 11 , '3', 'Y') },
83		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 10 , 16 ) },
84		− { CODEC_ID_RAWVIDEO, MKTAG(16 , 10 , '3', 'Y') },
85		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 0 , 16 ) },
86		− { CODEC_ID_RAWVIDEO, MKTAG(16 , 0 , '3', 'Y') },
87		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '4', 11 , 8 ) },
88		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '2', 0 , 8 ) },
89		− { CODEC_ID_NONE , 0 }
	36	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 15 ) },
	37	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 15 ) },
	38	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 16 ) },
	39	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 16 ) },
	40	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(15 , 'B', 'G', 'R') },
	41	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(15 , 'R', 'G', 'B') },
	42	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(16 , 'B', 'G', 'R') },
	43	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(16 , 'R', 'G', 'B') },
	44	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 12 ) },
	45	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 12 ) },
	46	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(12 , 'B', 'G', 'R') },
	47	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(12 , 'R', 'G', 'B') },
	48	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 'A') },
	49	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 'A') },
	50	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('A', 'B', 'G', 'R') },
	51	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('A', 'R', 'G', 'B') },
	52	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 24 ) },
	53	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 24 ) },
	54	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('4', '1', '1', 'P') },
	55	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('4', '2', '2', 'P') },
	56	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('4', '2', '2', 'P') },
	57	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('4', '4', '0', 'P') },
	58	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('4', '4', '0', 'P') },
	59	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('4', '4', '4', 'P') },
	60	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('4', '4', '4', 'P') },
	61	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', '1', 'W', '0') },
	62	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', '0', 'W', '1') },
	63	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 8 ) },
	64	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 8 ) },
	65	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 4 ) },
	66	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 4 ) },
	67	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', '4', 'B', 'Y') },
	68	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('R', '4', 'B', 'Y') },
	69	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('B', 'G', 'R', 48 ) },
	70	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', 48 ) },
	71	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(48 , 'B', 'G', 'R') },
	72	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(48 , 'R', 'G', 'B') },
	73	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 11 , 10 ) },
	74	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(10 , 11 , '3', 'Y') },
	75	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 10 , 10 ) },
	76	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(10 , 10 , '3', 'Y') },
	77	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 0 , 10 ) },
	78	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(10 , 0 , '3', 'Y') },
	79	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '1', 0 , 16 ) },
	80	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(16 , 0 , '1', 'Y') },
	81	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 11 , 16 ) },
	82	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(16 , 11 , '3', 'Y') },
	83	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 10 , 16 ) },
	84	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(16 , 10 , '3', 'Y') },
	85	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '3', 0 , 16 ) },
	86	+ { AV_CODEC_ID_RAWVIDEO, MKTAG(16 , 0 , '3', 'Y') },
	87	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '4', 11 , 8 ) },
	88	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '2', 0 , 8 ) },
	89	+ { AV_CODEC_ID_NONE , 0 }
90	90	};
91	91
92	92	void ff_nut_reset_ts(NUTContext *nut, AVRational time_base, int64_t val){

libavformat/nutdec.c+1−1

@@ -379,7 +379,7 @@ static int decode_stream_header(NUTContext *nut) · 378 unmodified lines
379	379	av_log(s, AV_LOG_ERROR, "unknown stream class (%d)\n", class);
380	380	return -1;
381	381	}
382		− if (class < 3 && st->codec->codec_id == CODEC_ID_NONE)
	382	+ if (class < 3 && st->codec->codec_id == AV_CODEC_ID_NONE)
383	383	av_log(s, AV_LOG_ERROR,
384	384	"Unknown codec tag '0x%04x' for stream number %d\n",
385	385	(unsigned int) tmp, stream_id);

libavformat/nutenc.c+9−9

@@ -36,20 +36,20 @@ static int find_expected_header(AVCodecContext *c, int size, int key_frame, uint · 35 unmodified lines
36	36
37	37	AV_WB24(out, 1);
38	38
39		− if(c->codec_id == CODEC_ID_MPEG4){
	39	+ if(c->codec_id == AV_CODEC_ID_MPEG4){
40	40	if(key_frame){
41	41	return 3;
42	42	}else{
43	43	out[3]= 0xB6;
44	44	return 4;
45	45	}
46		− }else if(c->codec_id == CODEC_ID_MPEG1VIDEO \|\| c->codec_id == CODEC_ID_MPEG2VIDEO){
	46	+ }else if(c->codec_id == AV_CODEC_ID_MPEG1VIDEO \|\| c->codec_id == AV_CODEC_ID_MPEG2VIDEO){
47	47	return 3;
48		− }else if(c->codec_id == CODEC_ID_H264){
	48	+ }else if(c->codec_id == AV_CODEC_ID_H264){
49	49	return 3;
50		− }else if(c->codec_id == CODEC_ID_MP3 \|\| c->codec_id == CODEC_ID_MP2){
	50	+ }else if(c->codec_id == AV_CODEC_ID_MP3 \|\| c->codec_id == AV_CODEC_ID_MP2){
51	51	int lsf, mpeg25, sample_rate_index, bitrate_index, frame_size;
52		− int layer= c->codec_id == CODEC_ID_MP3 ? 3 : 2;
	52	+ int layer= c->codec_id == AV_CODEC_ID_MP3 ? 3 : 2;
53	53	unsigned int header= 0xFFF00000;
54	54
55	55	lsf = sample_rate < (24000+32000)/2;
@@ -208,7 +208,7 @@ static void build_frame_code(AVFormatContext *s){ · 152 unmodified lines
208	208	pred_table[2]=1;
209	209	pred_table[3]=3;
210	210	pred_table[4]=4;
211		− }else if(codec->codec_id == CODEC_ID_VORBIS){
	211	+ }else if(codec->codec_id == AV_CODEC_ID_VORBIS){
212	212	pred_count=3;
213	213	pred_table[0]=2;
214	214	pred_table[1]=9;
@@ -866,9 +866,9 @@ AVOutputFormat ff_nut_muxer = { · 651 unmodified lines
866	866	.mime_type = "video/x-nut",
867	867	.extensions = "nut",
868	868	.priv_data_size = sizeof(NUTContext),
869		− .audio_codec = CONFIG_LIBVORBIS ? CODEC_ID_VORBIS :
870		− CONFIG_LIBMP3LAME ? CODEC_ID_MP3 : CODEC_ID_MP2,
871		− .video_codec = CODEC_ID_MPEG4,
	869	+ .audio_codec = CONFIG_LIBVORBIS ? AV_CODEC_ID_VORBIS :
	870	+ CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_MP2,
	871	+ .video_codec = AV_CODEC_ID_MPEG4,
872	872	.write_header = nut_write_header,
873	873	.write_packet = nut_write_packet,
874	874	.write_trailer = nut_write_trailer,

libavformat/nuv.c+4−4

@@ -90,7 +90,7 @@ static int get_codec_data(AVIOContext pb, AVStream vst, · 89 unmodified lines
90	90	vst->codec->codec_id =
91	91	ff_codec_get_id(ff_codec_bmp_tags, vst->codec->codec_tag);
92	92	if (vst->codec->codec_tag == MKTAG('R', 'J', 'P', 'G'))
93		− vst->codec->codec_id = CODEC_ID_NUV;
	93	+ vst->codec->codec_id = AV_CODEC_ID_NUV;
94	94	} else
95	95	avio_skip(pb, 4);
96	96
@@ -158,7 +158,7 @@ static int nuv_header(AVFormatContext *s) { · 61 unmodified lines
158	158	if (!vst)
159	159	return AVERROR(ENOMEM);
160	160	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
161		− vst->codec->codec_id = CODEC_ID_NUV;
	161	+ vst->codec->codec_id = AV_CODEC_ID_NUV;
162	162	vst->codec->width = width;
163	163	vst->codec->height = height;
164	164	vst->codec->bits_per_coded_sample = 10;
@@ -177,7 +177,7 @@ static int nuv_header(AVFormatContext *s) { · 12 unmodified lines
177	177	if (!ast)
178	178	return AVERROR(ENOMEM);
179	179	ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
180		− ast->codec->codec_id = CODEC_ID_PCM_S16LE;
	180	+ ast->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
181	181	ast->codec->channels = 2;
182	182	ast->codec->sample_rate = 44100;
183	183	ast->codec->bit_rate = 2 * 2 * 44100 * 8;
@@ -188,7 +188,7 @@ static int nuv_header(AVFormatContext *s) { · 4 unmodified lines
188	188	ctx->a_id = -1;
189	189
190	190	get_codec_data(pb, vst, ast, is_mythtv);
191		− ctx->rtjpg_video = vst && vst->codec->codec_id == CODEC_ID_NUV;
	191	+ ctx->rtjpg_video = vst && vst->codec->codec_id == AV_CODEC_ID_NUV;
192	192	return 0;
193	193	}
194	194

libavformat/oggenc.c+17−17

@@ -202,7 +202,7 @@ static int ogg_buffer_data(AVFormatContext s, AVStream st, · 201 unmodified lines
202	202	int i, segments, len, flush = 0;
203	203
204	204	// Handles VFR by flushing page because this frame needs to have a timestamp
205		− if (st->codec->codec_id == CODEC_ID_THEORA && !header &&
	205	+ if (st->codec->codec_id == AV_CODEC_ID_THEORA && !header &&
206	206	ogg_granule_to_timestamp(oggstream, granule) >
207	207	ogg_granule_to_timestamp(oggstream, oggstream->last_granule) + 1) {
208	208	if (oggstream->page.granule != -1)
@@ -349,10 +349,10 @@ static int ogg_write_header(AVFormatContext *s) · 140 unmodified lines
349	349	avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
350	350	else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
351	351	avpriv_set_pts_info(st, 64, st->codec->time_base.num, st->codec->time_base.den);
352		− if (st->codec->codec_id != CODEC_ID_VORBIS &&
353		− st->codec->codec_id != CODEC_ID_THEORA &&
354		− st->codec->codec_id != CODEC_ID_SPEEX &&
355		− st->codec->codec_id != CODEC_ID_FLAC) {
	352	+ if (st->codec->codec_id != AV_CODEC_ID_VORBIS &&
	353	+ st->codec->codec_id != AV_CODEC_ID_THEORA &&
	354	+ st->codec->codec_id != AV_CODEC_ID_SPEEX &&
	355	+ st->codec->codec_id != AV_CODEC_ID_FLAC) {
356	356	av_log(s, AV_LOG_ERROR, "Unsupported codec id in stream %d\n", i);
357	357	return -1;
358	358	}
@@ -376,7 +376,7 @@ static int ogg_write_header(AVFormatContext *s) · 17 unmodified lines
376	376	oggstream->serial_num = serial_num;
377	377
378	378	st->priv_data = oggstream;
379		− if (st->codec->codec_id == CODEC_ID_FLAC) {
	379	+ if (st->codec->codec_id == AV_CODEC_ID_FLAC) {
380	380	int err = ogg_build_flac_headers(st->codec, oggstream,
381	381	st->codec->flags & CODEC_FLAG_BITEXACT,
382	382	&s->metadata);
@@ -385,7 +385,7 @@ static int ogg_write_header(AVFormatContext *s) · 2 unmodified lines
385	385	av_freep(&st->priv_data);
386	386	return err;
387	387	}
388		− } else if (st->codec->codec_id == CODEC_ID_SPEEX) {
	388	+ } else if (st->codec->codec_id == AV_CODEC_ID_SPEEX) {
389	389	int err = ogg_build_speex_headers(st->codec, oggstream,
390	390	st->codec->flags & CODEC_FLAG_BITEXACT,
391	391	&s->metadata);
@@ -396,12 +396,12 @@ static int ogg_write_header(AVFormatContext *s) · 4 unmodified lines
396	396	}
397	397	} else {
398	398	uint8_t *p;
399		− const char *cstr = st->codec->codec_id == CODEC_ID_VORBIS ? "vorbis" : "theora";
400		− int header_type = st->codec->codec_id == CODEC_ID_VORBIS ? 3 : 0x81;
401		− int framing_bit = st->codec->codec_id == CODEC_ID_VORBIS ? 1 : 0;
	399	+ const char *cstr = st->codec->codec_id == AV_CODEC_ID_VORBIS ? "vorbis" : "theora";
	400	+ int header_type = st->codec->codec_id == AV_CODEC_ID_VORBIS ? 3 : 0x81;
	401	+ int framing_bit = st->codec->codec_id == AV_CODEC_ID_VORBIS ? 1 : 0;
402	402
403	403	if (avpriv_split_xiph_headers(st->codec->extradata, st->codec->extradata_size,
404		− st->codec->codec_id == CODEC_ID_VORBIS ? 30 : 42,
	404	+ st->codec->codec_id == AV_CODEC_ID_VORBIS ? 30 : 42,
405	405	oggstream->header, oggstream->header_len) < 0) {
406	406	av_log(s, AV_LOG_ERROR, "Extradata corrupted\n");
407	407	av_freep(&st->priv_data);
@@ -418,7 +418,7 @@ static int ogg_write_header(AVFormatContext *s) · 10 unmodified lines
418	418	bytestream_put_byte(&p, header_type);
419	419	bytestream_put_buffer(&p, cstr, 6);
420	420
421		− if (st->codec->codec_id == CODEC_ID_THEORA) {
	421	+ if (st->codec->codec_id == AV_CODEC_ID_THEORA) {
422	422	/** KFGSHIFT is the width of the less significant section of the granule position
423	423	The less significant section is the frame count since the last keyframe */
424	424	oggstream->kfgshift = ((oggstream->header[0][40]&3)<<3)\|(oggstream->header[0][41]>>5);
@@ -478,7 +478,7 @@ static int ogg_write_packet(AVFormatContext s, AVPacket pkt) · 53 unmodified lines
478	478	int ret;
479	479	int64_t granule;
480	480
481		− if (st->codec->codec_id == CODEC_ID_THEORA) {
	481	+ if (st->codec->codec_id == AV_CODEC_ID_THEORA) {
482	482	int64_t pts = oggstream->vrev < 1 ? pkt->pts : pkt->pts + pkt->duration;
483	483	int pframe_count;
484	484	if (pkt->flags & AV_PKT_FLAG_KEY)
@@ -517,8 +517,8 @@ static int ogg_write_trailer(AVFormatContext *s) · 32 unmodified lines
517	517	for (i = 0; i < s->nb_streams; i++) {
518	518	AVStream *st = s->streams[i];
519	519	OGGStreamContext *oggstream = st->priv_data;
520		− if (st->codec->codec_id == CODEC_ID_FLAC \|\|
521		− st->codec->codec_id == CODEC_ID_SPEEX) {
	520	+ if (st->codec->codec_id == AV_CODEC_ID_FLAC \|\|
	521	+ st->codec->codec_id == AV_CODEC_ID_SPEEX) {
522	522	av_free(oggstream->header[0]);
523	523	}
524	524	av_freep(&oggstream->header[1]);
@@ -533,8 +533,8 @@ AVOutputFormat ff_ogg_muxer = { · 8 unmodified lines
533	533	.mime_type = "application/ogg",
534	534	.extensions = "ogg,ogv,spx",
535	535	.priv_data_size = sizeof(OGGContext),
536		− .audio_codec = CODEC_ID_FLAC,
537		− .video_codec = CODEC_ID_THEORA,
	536	+ .audio_codec = AV_CODEC_ID_FLAC,
	537	+ .video_codec = AV_CODEC_ID_THEORA,
538	538	.write_header = ogg_write_header,
539	539	.write_packet = ogg_write_packet,
540	540	.write_trailer = ogg_write_trailer,

libavformat/oggparsecelt.c+1−1

@@ -65,7 +65,7 @@ static int celt_header(AVFormatContext *s, int idx) · 64 unmodified lines
65	65	av_free(os->private);
66	66	av_free(st->codec->extradata);
67	67	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
68		− st->codec->codec_id = CODEC_ID_CELT;
	68	+ st->codec->codec_id = AV_CODEC_ID_CELT;
69	69	st->codec->sample_rate = sample_rate;
70	70	st->codec->channels = nb_channels;
71	71	st->codec->frame_size = frame_size;

libavformat/oggparsedirac.c+3−3

@@ -33,7 +33,7 @@ static int dirac_header(AVFormatContext *s, int idx) · 32 unmodified lines
33	33	GetBitContext gb;
34	34
35	35	// already parsed the header
36		− if (st->codec->codec_id == CODEC_ID_DIRAC)
	36	+ if (st->codec->codec_id == AV_CODEC_ID_DIRAC)
37	37	return 0;
38	38
39	39	init_get_bits(&gb, os->buf + os->pstart + 13, (os->psize - 13) * 8);
@@ -41,7 +41,7 @@ static int dirac_header(AVFormatContext *s, int idx) · 1 unmodified line
41	41	return -1;
42	42
43	43	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
44		− st->codec->codec_id = CODEC_ID_DIRAC;
	44	+ st->codec->codec_id = AV_CODEC_ID_DIRAC;
45	45	// dirac in ogg always stores timestamps as though the video were interlaced
46	46	avpriv_set_pts_info(st, 64, st->codec->time_base.num, 2*st->codec->time_base.den);
47	47	return 1;
@@ -79,7 +79,7 @@ static int old_dirac_header(AVFormatContext *s, int idx) · 31 unmodified lines
79	79	return 0;
80	80
81	81	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
82		− st->codec->codec_id = CODEC_ID_DIRAC;
	82	+ st->codec->codec_id = AV_CODEC_ID_DIRAC;
83	83	avpriv_set_pts_info(st, 64, AV_RB32(buf+12), AV_RB32(buf+8));
84	84	return 1;
85	85	}

libavformat/oggparseflac.c+2−2

@@ -59,7 +59,7 @@ flac_header (AVFormatContext * s, int idx) · 58 unmodified lines
59	59	avpriv_flac_parse_streaminfo(st->codec, &si, streaminfo_start);
60	60
61	61	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
62		− st->codec->codec_id = CODEC_ID_FLAC;
	62	+ st->codec->codec_id = AV_CODEC_ID_FLAC;
63	63	st->need_parsing = AVSTREAM_PARSE_HEADERS;
64	64
65	65	st->codec->extradata =
@@ -80,7 +80,7 @@ old_flac_header (AVFormatContext * s, int idx) · 14 unmodified lines
80	80	{
81	81	AVStream *st = s->streams[idx];
82	82	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
83		− st->codec->codec_id = CODEC_ID_FLAC;
	83	+ st->codec->codec_id = AV_CODEC_ID_FLAC;
84	84
85	85	return 0;
86	86	}

libavformat/oggparseogm.c+1−1

@@ -56,7 +56,7 @@ ogm_header(AVFormatContext *s, int idx) · 55 unmodified lines
56	56	st->codec->codec_tag = tag;
57	57	} else if (*p == 't') {
58	58	st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
59		− st->codec->codec_id = CODEC_ID_TEXT;
	59	+ st->codec->codec_id = AV_CODEC_ID_TEXT;
60	60	p += 12;
61	61	} else {
62	62	uint8_t acid[5];

libavformat/oggparsespeex.c+1−1

@@ -55,7 +55,7 @@ static int speex_header(AVFormatContext *s, int idx) { · 54 unmodified lines
55	55	if (spxp->seq == 0) {
56	56	int frames_per_packet;
57	57	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
58		− st->codec->codec_id = CODEC_ID_SPEEX;
	58	+ st->codec->codec_id = AV_CODEC_ID_SPEEX;
59	59
60	60	st->codec->sample_rate = AV_RL32(p + 36);
61	61	st->codec->channels = AV_RL32(p + 48);

libavformat/oggparsetheora.c+1−1

@@ -107,7 +107,7 @@ theora_header (AVFormatContext * s, int idx) · 106 unmodified lines
107	107	thp->gpmask = (1 << thp->gpshift) - 1;
108	108
109	109	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
110		− st->codec->codec_id = CODEC_ID_THEORA;
	110	+ st->codec->codec_id = AV_CODEC_ID_THEORA;
111	111	st->need_parsing = AVSTREAM_PARSE_HEADERS;
112	112
113	113	} else if (os->buf[os->pstart] == 0x83) {

libavformat/oggparsevorbis.c+1−1

@@ -254,7 +254,7 @@ vorbis_header (AVFormatContext * s, int idx) · 253 unmodified lines
254	254	return -1;
255	255
256	256	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
257		− st->codec->codec_id = CODEC_ID_VORBIS;
	257	+ st->codec->codec_id = AV_CODEC_ID_VORBIS;
258	258
259	259	if (srate > 0) {
260	260	st->codec->sample_rate = srate;

libavformat/oma.c+4−4

@@ -25,9 +25,9 @@ · 24 unmodified lines
25	25	const uint16_t ff_oma_srate_tab[6] = { 320, 441, 480, 882, 960, 0 };
26	26
27	27	const AVCodecTag ff_oma_codec_tags[] = {
28		− { CODEC_ID_ATRAC3, OMA_CODECID_ATRAC3 },
29		− { CODEC_ID_ATRAC3P, OMA_CODECID_ATRAC3P },
30		− { CODEC_ID_MP3, OMA_CODECID_MP3 },
31		− { CODEC_ID_PCM_S16BE, OMA_CODECID_LPCM },
	28	+ { AV_CODEC_ID_ATRAC3, OMA_CODECID_ATRAC3 },
	29	+ { AV_CODEC_ID_ATRAC3P, OMA_CODECID_ATRAC3P },
	30	+ { AV_CODEC_ID_MP3, OMA_CODECID_MP3 },
	31	+ { AV_CODEC_ID_PCM_S16BE, OMA_CODECID_LPCM },
32	32	{ 0 },
33	33	};

libavformat/omaenc.c+1−1

@@ -98,7 +98,7 @@ AVOutputFormat ff_oma_muxer = { · 97 unmodified lines
98	98	.long_name = NULL_IF_CONFIG_SMALL("Sony OpenMG audio"),
99	99	.mime_type = "audio/x-oma",
100	100	.extensions = "oma",
101		− .audio_codec = CODEC_ID_ATRAC3,
	101	+ .audio_codec = AV_CODEC_ID_ATRAC3,
102	102	.write_header = oma_write_header,
103	103	.write_packet = ff_raw_write_packet,
104	104	.codec_tag = (const AVCodecTag* const []){ff_oma_codec_tags, 0},

libavformat/output-example.c+6−6

@@ -58,7 +58,7 @@ static int audio_input_frame_size; · 57 unmodified lines
58	58	/*
59	59	* add an audio output stream
60	60	*/
61		−static AVStream add_audio_stream(AVFormatContext oc, enum CodecID codec_id)
	61	+static AVStream add_audio_stream(AVFormatContext oc, enum AVCodecID codec_id)
62	62	{
63	63	AVCodecContext *c;
64	64	AVStream *st;
@@ -182,7 +182,7 @@ static uint8_t *video_outbuf; · 117 unmodified lines
182	182	static int frame_count, video_outbuf_size;
183	183
184	184	/* Add a video output stream. */
185		−static AVStream add_video_stream(AVFormatContext oc, enum CodecID codec_id)
	185	+static AVStream add_video_stream(AVFormatContext oc, enum AVCodecID codec_id)
186	186	{
187	187	AVCodecContext *c;
188	188	AVStream *st;
@@ -216,11 +216,11 @@ static AVStream add_video_stream(AVFormatContext oc, enum CodecID codec_id) · 27 unmodified lines
216	216	c->time_base.num = 1;
217	217	c->gop_size = 12; /* emit one intra frame every twelve frames at most */
218	218	c->pix_fmt = STREAM_PIX_FMT;
219		− if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
	219	+ if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
220	220	/* just for testing, we also add B frames */
221	221	c->max_b_frames = 2;
222	222	}
223		− if (c->codec_id == CODEC_ID_MPEG1VIDEO) {
	223	+ if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
224	224	/* Needed to avoid using macroblocks in which some coeffs overflow.
225	225	* This does not happen with normal video, it just happens here as
226	226	* the motion of the chroma plane does not match the luma plane. */
@@ -460,10 +460,10 @@ int main(int argc, char **argv) · 233 unmodified lines
460	460	* and initialize the codecs. */
461	461	video_st = NULL;
462	462	audio_st = NULL;
463		− if (fmt->video_codec != CODEC_ID_NONE) {
	463	+ if (fmt->video_codec != AV_CODEC_ID_NONE) {
464	464	video_st = add_video_stream(oc, fmt->video_codec);
465	465	}
466		− if (fmt->audio_codec != CODEC_ID_NONE) {
	466	+ if (fmt->audio_codec != AV_CODEC_ID_NONE) {
467	467	audio_st = add_audio_stream(oc, fmt->audio_codec);
468	468	}
469	469

libavformat/pcmdec.c+20−20

@@ -75,61 +75,61 @@ AVInputFormat ff_pcm_ ## name_ ## _demuxer = { \ · 74 unmodified lines
75	75	};
76	76
77	77	PCMDEF(f64be, "PCM 64-bit floating-point big-endian",
78		− NULL, CODEC_ID_PCM_F64BE)
	78	+ NULL, AV_CODEC_ID_PCM_F64BE)
79	79
80	80	PCMDEF(f64le, "PCM 64-bit floating-point little-endian",
81		− NULL, CODEC_ID_PCM_F64LE)
	81	+ NULL, AV_CODEC_ID_PCM_F64LE)
82	82
83	83	PCMDEF(f32be, "PCM 32-bit floating-point big-endian",
84		− NULL, CODEC_ID_PCM_F32BE)
	84	+ NULL, AV_CODEC_ID_PCM_F32BE)
85	85
86	86	PCMDEF(f32le, "PCM 32-bit floating-point little-endian",
87		− NULL, CODEC_ID_PCM_F32LE)
	87	+ NULL, AV_CODEC_ID_PCM_F32LE)
88	88
89	89	PCMDEF(s32be, "PCM signed 32-bit big-endian",
90		− NULL, CODEC_ID_PCM_S32BE)
	90	+ NULL, AV_CODEC_ID_PCM_S32BE)
91	91
92	92	PCMDEF(s32le, "PCM signed 32-bit little-endian",
93		− NULL, CODEC_ID_PCM_S32LE)
	93	+ NULL, AV_CODEC_ID_PCM_S32LE)
94	94
95	95	PCMDEF(s24be, "PCM signed 24-bit big-endian",
96		− NULL, CODEC_ID_PCM_S24BE)
	96	+ NULL, AV_CODEC_ID_PCM_S24BE)
97	97
98	98	PCMDEF(s24le, "PCM signed 24-bit little-endian",
99		− NULL, CODEC_ID_PCM_S24LE)
	99	+ NULL, AV_CODEC_ID_PCM_S24LE)
100	100
101	101	PCMDEF(s16be, "PCM signed 16-bit big-endian",
102		− AV_NE("sw", NULL), CODEC_ID_PCM_S16BE)
	102	+ AV_NE("sw", NULL), AV_CODEC_ID_PCM_S16BE)
103	103
104	104	PCMDEF(s16le, "PCM signed 16-bit little-endian",
105		− AV_NE(NULL, "sw"), CODEC_ID_PCM_S16LE)
	105	+ AV_NE(NULL, "sw"), AV_CODEC_ID_PCM_S16LE)
106	106
107	107	PCMDEF(s8, "PCM signed 8-bit",
108		− "sb", CODEC_ID_PCM_S8)
	108	+ "sb", AV_CODEC_ID_PCM_S8)
109	109
110	110	PCMDEF(u32be, "PCM unsigned 32-bit big-endian",
111		− NULL, CODEC_ID_PCM_U32BE)
	111	+ NULL, AV_CODEC_ID_PCM_U32BE)
112	112
113	113	PCMDEF(u32le, "PCM unsigned 32-bit little-endian",
114		− NULL, CODEC_ID_PCM_U32LE)
	114	+ NULL, AV_CODEC_ID_PCM_U32LE)
115	115
116	116	PCMDEF(u24be, "PCM unsigned 24-bit big-endian",
117		− NULL, CODEC_ID_PCM_U24BE)
	117	+ NULL, AV_CODEC_ID_PCM_U24BE)
118	118
119	119	PCMDEF(u24le, "PCM unsigned 24-bit little-endian",
120		− NULL, CODEC_ID_PCM_U24LE)
	120	+ NULL, AV_CODEC_ID_PCM_U24LE)
121	121
122	122	PCMDEF(u16be, "PCM unsigned 16-bit big-endian",
123		− AV_NE("uw", NULL), CODEC_ID_PCM_U16BE)
	123	+ AV_NE("uw", NULL), AV_CODEC_ID_PCM_U16BE)
124	124
125	125	PCMDEF(u16le, "PCM unsigned 16-bit little-endian",
126		− AV_NE(NULL, "uw"), CODEC_ID_PCM_U16LE)
	126	+ AV_NE(NULL, "uw"), AV_CODEC_ID_PCM_U16LE)
127	127
128	128	PCMDEF(u8, "PCM unsigned 8-bit",
129		− "ub", CODEC_ID_PCM_U8)
	129	+ "ub", AV_CODEC_ID_PCM_U8)
130	130
131	131	PCMDEF(alaw, "PCM A-law",
132		− "al", CODEC_ID_PCM_ALAW)
	132	+ "al", AV_CODEC_ID_PCM_ALAW)
133	133
134	134	PCMDEF(mulaw, "PCM mu-law",
135		− "ul", CODEC_ID_PCM_MULAW)
	135	+ "ul", AV_CODEC_ID_PCM_MULAW)

libavformat/pcmenc.c+21−21

@@ -28,67 +28,67 @@ AVOutputFormat ff_pcm_ ## name_ ## _muxer = { \ · 27 unmodified lines
28	28	.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
29	29	.extensions = ext, \
30	30	.audio_codec = codec, \
31		− .video_codec = CODEC_ID_NONE, \
	31	+ .video_codec = AV_CODEC_ID_NONE, \
32	32	.write_packet = ff_raw_write_packet, \
33	33	.flags = AVFMT_NOTIMESTAMPS, \
34	34	};
35	35
36	36	PCMDEF(f64be, "PCM 64-bit floating-point big-endian",
37		− NULL, CODEC_ID_PCM_F64BE)
	37	+ NULL, AV_CODEC_ID_PCM_F64BE)
38	38
39	39	PCMDEF(f64le, "PCM 64-bit floating-point little-endian",
40		− NULL, CODEC_ID_PCM_F64LE)
	40	+ NULL, AV_CODEC_ID_PCM_F64LE)
41	41
42	42	PCMDEF(f32be, "PCM 32-bit floating-point big-endian",
43		− NULL, CODEC_ID_PCM_F32BE)
	43	+ NULL, AV_CODEC_ID_PCM_F32BE)
44	44
45	45	PCMDEF(f32le, "PCM 32-bit floating-point little-endian",
46		− NULL, CODEC_ID_PCM_F32LE)
	46	+ NULL, AV_CODEC_ID_PCM_F32LE)
47	47
48	48	PCMDEF(s32be, "PCM signed 32-bit big-endian",
49		− NULL, CODEC_ID_PCM_S32BE)
	49	+ NULL, AV_CODEC_ID_PCM_S32BE)
50	50
51	51	PCMDEF(s32le, "PCM signed 32-bit little-endian",
52		− NULL, CODEC_ID_PCM_S32LE)
	52	+ NULL, AV_CODEC_ID_PCM_S32LE)
53	53
54	54	PCMDEF(s24be, "PCM signed 24-bit big-endian",
55		− NULL, CODEC_ID_PCM_S24BE)
	55	+ NULL, AV_CODEC_ID_PCM_S24BE)
56	56
57	57	PCMDEF(s24le, "PCM signed 24-bit little-endian",
58		− NULL, CODEC_ID_PCM_S24LE)
	58	+ NULL, AV_CODEC_ID_PCM_S24LE)
59	59
60	60	PCMDEF(s16be, "PCM signed 16-bit big-endian",
61		− AV_NE("sw", NULL), CODEC_ID_PCM_S16BE)
	61	+ AV_NE("sw", NULL), AV_CODEC_ID_PCM_S16BE)
62	62
63	63	PCMDEF(s16le, "PCM signed 16-bit little-endian",
64		− AV_NE(NULL, "sw"), CODEC_ID_PCM_S16LE)
	64	+ AV_NE(NULL, "sw"), AV_CODEC_ID_PCM_S16LE)
65	65
66	66	PCMDEF(s8, "PCM signed 8-bit",
67		− "sb", CODEC_ID_PCM_S8)
	67	+ "sb", AV_CODEC_ID_PCM_S8)
68	68
69	69	PCMDEF(u32be, "PCM unsigned 32-bit big-endian",
70		− NULL, CODEC_ID_PCM_U32BE)
	70	+ NULL, AV_CODEC_ID_PCM_U32BE)
71	71
72	72	PCMDEF(u32le, "PCM unsigned 32-bit little-endian",
73		− NULL, CODEC_ID_PCM_U32LE)
	73	+ NULL, AV_CODEC_ID_PCM_U32LE)
74	74
75	75	PCMDEF(u24be, "PCM unsigned 24-bit big-endian",
76		− NULL, CODEC_ID_PCM_U24BE)
	76	+ NULL, AV_CODEC_ID_PCM_U24BE)
77	77
78	78	PCMDEF(u24le, "PCM unsigned 24-bit little-endian",
79		− NULL, CODEC_ID_PCM_U24LE)
	79	+ NULL, AV_CODEC_ID_PCM_U24LE)
80	80
81	81	PCMDEF(u16be, "PCM unsigned 16-bit big-endian",
82		− AV_NE("uw", NULL), CODEC_ID_PCM_U16BE)
	82	+ AV_NE("uw", NULL), AV_CODEC_ID_PCM_U16BE)
83	83
84	84	PCMDEF(u16le, "PCM unsigned 16-bit little-endian",
85		− AV_NE(NULL, "uw"), CODEC_ID_PCM_U16LE)
	85	+ AV_NE(NULL, "uw"), AV_CODEC_ID_PCM_U16LE)
86	86
87	87	PCMDEF(u8, "PCM unsigned 8-bit",
88		− "ub", CODEC_ID_PCM_U8)
	88	+ "ub", AV_CODEC_ID_PCM_U8)
89	89
90	90	PCMDEF(alaw, "PCM A-law",
91		− "al", CODEC_ID_PCM_ALAW)
	91	+ "al", AV_CODEC_ID_PCM_ALAW)
92	92
93	93	PCMDEF(mulaw, "PCM mu-law",
94		− "ul", CODEC_ID_PCM_MULAW)
	94	+ "ul", AV_CODEC_ID_PCM_MULAW)

libavformat/pmpdec.c+5−5

@@ -45,7 +45,7 @@ static int pmp_header(AVFormatContext *s) · 44 unmodified lines
45	45	AVIOContext *pb = s->pb;
46	46	int tb_num, tb_den;
47	47	int index_cnt;
48		− int audio_codec_id = CODEC_ID_NONE;
	48	+ int audio_codec_id = AV_CODEC_ID_NONE;
49	49	int srate, channels;
50	50	int i;
51	51	uint64_t pos;
@@ -56,10 +56,10 @@ static int pmp_header(AVFormatContext *s) · 4 unmodified lines
56	56	avio_skip(pb, 8);
57	57	switch (avio_rl32(pb)) {
58	58	case 0:
59		− vst->codec->codec_id = CODEC_ID_MPEG4;
	59	+ vst->codec->codec_id = AV_CODEC_ID_MPEG4;
60	60	break;
61	61	case 1:
62		− vst->codec->codec_id = CODEC_ID_H264;
	62	+ vst->codec->codec_id = AV_CODEC_ID_H264;
63	63	break;
64	64	default:
65	65	av_log(s, AV_LOG_ERROR, "Unsupported video format\n");
@@ -77,11 +77,11 @@ static int pmp_header(AVFormatContext *s) · 11 unmodified lines
77	77
78	78	switch (avio_rl32(pb)) {
79	79	case 0:
80		− audio_codec_id = CODEC_ID_MP3;
	80	+ audio_codec_id = AV_CODEC_ID_MP3;
81	81	break;
82	82	case 1:
83	83	av_log(s, AV_LOG_WARNING, "AAC is not yet correctly supported\n");
84		− audio_codec_id = CODEC_ID_AAC;
	84	+ audio_codec_id = AV_CODEC_ID_AAC;
85	85	break;
86	86	default:
87	87	av_log(s, AV_LOG_ERROR, "Unsupported audio format\n");

libavformat/psxstr.c+2−2

@@ -170,7 +170,7 @@ static int str_read_packet(AVFormatContext *s, · 169 unmodified lines
170	170	str->channels[channel].video_stream_index = st->index;
171	171
172	172	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
173		− st->codec->codec_id = CODEC_ID_MDEC;
	173	+ st->codec->codec_id = AV_CODEC_ID_MDEC;
174	174	st->codec->codec_tag = 0; /* no fourcc */
175	175	st->codec->width = AV_RL16(&sector[0x28]);
176	176	st->codec->height = AV_RL16(&sector[0x2A]);
@@ -217,7 +217,7 @@ static int str_read_packet(AVFormatContext *s, · 40 unmodified lines
217	217	str->channels[channel].audio_stream_index = st->index;
218	218
219	219	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
220		− st->codec->codec_id = CODEC_ID_ADPCM_XA;
	220	+ st->codec->codec_id = AV_CODEC_ID_ADPCM_XA;
221	221	st->codec->codec_tag = 0; /* no fourcc */
222	222	st->codec->channels = (fmt&1)?2:1;
223	223	st->codec->sample_rate = (fmt&4)?18900:37800;

libavformat/pva.c+2−2

@@ -47,7 +47,7 @@ static int pva_read_header(AVFormatContext *s) { · 46 unmodified lines
47	47	if (!(st = avformat_new_stream(s, NULL)))
48	48	return AVERROR(ENOMEM);
49	49	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
50		− st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
	50	+ st->codec->codec_id = AV_CODEC_ID_MPEG2VIDEO;
51	51	st->need_parsing = AVSTREAM_PARSE_FULL;
52	52	avpriv_set_pts_info(st, 32, 1, 90000);
53	53	av_add_index_entry(st, 0, 0, 0, 0, AVINDEX_KEYFRAME);
@@ -55,7 +55,7 @@ static int pva_read_header(AVFormatContext *s) { · 1 unmodified line
55	55	if (!(st = avformat_new_stream(s, NULL)))
56	56	return AVERROR(ENOMEM);
57	57	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
58		− st->codec->codec_id = CODEC_ID_MP2;
	58	+ st->codec->codec_id = AV_CODEC_ID_MP2;
59	59	st->need_parsing = AVSTREAM_PARSE_FULL;
60	60	avpriv_set_pts_info(st, 33, 1, 90000);
61	61	av_add_index_entry(st, 0, 0, 0, 0, AVINDEX_KEYFRAME);

libavformat/qcp.c+1−1

@@ -98,7 +98,7 @@ static int qcp_read_header(AVFormatContext *s) · 97 unmodified lines
98	98	st->codec->channels = 1;
99	99	avio_read(pb, buf, 16);
100	100	if (is_qcelp_13k_guid(buf)) {
101		− st->codec->codec_id = CODEC_ID_QCELP;
	101	+ st->codec->codec_id = AV_CODEC_ID_QCELP;
102	102	} else if (!memcmp(buf, guid_evrc, 16)) {
103	103	av_log(s, AV_LOG_ERROR, "EVRC codec is not supported.\n");
104	104	return AVERROR_PATCHWELCOME;

libavformat/r3d.c+2−2

@@ -62,7 +62,7 @@ static int r3d_read_red1(AVFormatContext *s) · 61 unmodified lines
62	62	if (!st)
63	63	return AVERROR(ENOMEM);
64	64	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
65		− st->codec->codec_id = CODEC_ID_JPEG2000;
	65	+ st->codec->codec_id = AV_CODEC_ID_JPEG2000;
66	66
67	67	tmp = avio_r8(s->pb); // major version
68	68	tmp2 = avio_r8(s->pb); // minor version
@@ -101,7 +101,7 @@ static int r3d_read_red1(AVFormatContext *s) · 32 unmodified lines
101	101	if (!ast)
102	102	return AVERROR(ENOMEM);
103	103	ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
104		− ast->codec->codec_id = CODEC_ID_PCM_S32BE;
	104	+ ast->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
105	105	ast->codec->channels = tmp;
106	106	avpriv_set_pts_info(ast, 32, 1, st->time_base.den);
107	107	}

libavformat/rawdec.c+10−10

@@ -32,14 +32,14 @@ · 31 unmodified lines
32	32	int ff_raw_read_header(AVFormatContext *s)
33	33	{
34	34	AVStream *st;
35		− enum CodecID id;
	35	+ enum AVCodecID id;
36	36
37	37	st = avformat_new_stream(s, NULL);
38	38	if (!st)
39	39	return AVERROR(ENOMEM);
40	40
41	41	id = s->iformat->raw_codec_id;
42		− if (id == CODEC_ID_RAWVIDEO) {
	42	+ if (id == AV_CODEC_ID_RAWVIDEO) {
43	43	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
44	44	} else {
45	45	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
@@ -52,7 +52,7 @@ int ff_raw_read_header(AVFormatContext *s) · 6 unmodified lines
52	52
53	53	st->codec->channels = 1;
54	54
55		− if (id == CODEC_ID_ADPCM_G722)
	55	+ if (id == AV_CODEC_ID_ADPCM_G722)
56	56	st->codec->sample_rate = 16000;
57	57
58	58	if (s1 && s1->sample_rate)
@@ -185,7 +185,7 @@ AVInputFormat ff_g722_demuxer = { · 126 unmodified lines
185	185	.read_packet = ff_raw_read_partial_packet,
186	186	.flags = AVFMT_GENERIC_INDEX,
187	187	.extensions = "g722,722",
188		− .raw_codec_id = CODEC_ID_ADPCM_G722,
	188	+ .raw_codec_id = AV_CODEC_ID_ADPCM_G722,
189	189	};
190	190	#endif
191	191
@@ -197,12 +197,12 @@ AVInputFormat ff_latm_demuxer = { · 5 unmodified lines
197	197	.read_packet = ff_raw_read_partial_packet,
198	198	.flags = AVFMT_GENERIC_INDEX,
199	199	.extensions = "latm",
200		− .raw_codec_id = CODEC_ID_AAC_LATM,
	200	+ .raw_codec_id = AV_CODEC_ID_AAC_LATM,
201	201	};
202	202	#endif
203	203
204	204	#if CONFIG_MJPEG_DEMUXER
205		−FF_DEF_RAWVIDEO_DEMUXER(mjpeg, "raw MJPEG video", NULL, "mjpg,mjpeg", CODEC_ID_MJPEG)
	205	+FF_DEF_RAWVIDEO_DEMUXER(mjpeg, "raw MJPEG video", NULL, "mjpg,mjpeg", AV_CODEC_ID_MJPEG)
206	206	#endif
207	207
208	208	#if CONFIG_MLP_DEMUXER
@@ -213,7 +213,7 @@ AVInputFormat ff_mlp_demuxer = { · 4 unmodified lines
213	213	.read_packet = ff_raw_read_partial_packet,
214	214	.flags = AVFMT_GENERIC_INDEX,
215	215	.extensions = "mlp",
216		− .raw_codec_id = CODEC_ID_MLP,
	216	+ .raw_codec_id = AV_CODEC_ID_MLP,
217	217	};
218	218	#endif
219	219
@@ -225,7 +225,7 @@ AVInputFormat ff_truehd_demuxer = { · 5 unmodified lines
225	225	.read_packet = ff_raw_read_partial_packet,
226	226	.flags = AVFMT_GENERIC_INDEX,
227	227	.extensions = "thd",
228		− .raw_codec_id = CODEC_ID_TRUEHD,
	228	+ .raw_codec_id = AV_CODEC_ID_TRUEHD,
229	229	};
230	230	#endif
231	231
@@ -237,10 +237,10 @@ AVInputFormat ff_shorten_demuxer = { · 5 unmodified lines
237	237	.read_packet = ff_raw_read_partial_packet,
238	238	.flags = AVFMT_NOBINSEARCH \| AVFMT_NOGENSEARCH \| AVFMT_NO_BYTE_SEEK,
239	239	.extensions = "shn",
240		− .raw_codec_id = CODEC_ID_SHORTEN,
	240	+ .raw_codec_id = AV_CODEC_ID_SHORTEN,
241	241	};
242	242	#endif
243	243
244	244	#if CONFIG_VC1_DEMUXER
245		−FF_DEF_RAWVIDEO_DEMUXER(vc1, "raw VC-1", NULL, "vc1", CODEC_ID_VC1)
	245	+FF_DEF_RAWVIDEO_DEMUXER(vc1, "raw VC-1", NULL, "vc1", AV_CODEC_ID_VC1)
246	246	#endif

libavformat/rawenc.c+37−37

@@ -38,8 +38,8 @@ AVOutputFormat ff_ac3_muxer = { · 37 unmodified lines
38	38	.long_name = NULL_IF_CONFIG_SMALL("raw AC-3"),
39	39	.mime_type = "audio/x-ac3",
40	40	.extensions = "ac3",
41		− .audio_codec = CODEC_ID_AC3,
42		− .video_codec = CODEC_ID_NONE,
	41	+ .audio_codec = AV_CODEC_ID_AC3,
	42	+ .video_codec = AV_CODEC_ID_NONE,
43	43	.write_packet = ff_raw_write_packet,
44	44	.flags = AVFMT_NOTIMESTAMPS,
45	45	};
@@ -50,8 +50,8 @@ AVOutputFormat ff_adx_muxer = { · 4 unmodified lines
50	50	.name = "adx",
51	51	.long_name = NULL_IF_CONFIG_SMALL("CRI ADX"),
52	52	.extensions = "adx",
53		− .audio_codec = CODEC_ID_ADPCM_ADX,
54		− .video_codec = CODEC_ID_NONE,
	53	+ .audio_codec = AV_CODEC_ID_ADPCM_ADX,
	54	+ .video_codec = AV_CODEC_ID_NONE,
55	55	.write_packet = ff_raw_write_packet,
56	56	.flags = AVFMT_NOTIMESTAMPS,
57	57	};
@@ -62,8 +62,8 @@ AVOutputFormat ff_cavsvideo_muxer = { · 4 unmodified lines
62	62	.name = "cavsvideo",
63	63	.long_name = NULL_IF_CONFIG_SMALL("raw Chinese AVS (Audio Video Standard) video"),
64	64	.extensions = "cavs",
65		− .audio_codec = CODEC_ID_NONE,
66		− .video_codec = CODEC_ID_CAVS,
	65	+ .audio_codec = AV_CODEC_ID_NONE,
	66	+ .video_codec = AV_CODEC_ID_CAVS,
67	67	.write_packet = ff_raw_write_packet,
68	68	.flags = AVFMT_NOTIMESTAMPS,
69	69	};
@@ -74,8 +74,8 @@ AVOutputFormat ff_dirac_muxer = { · 4 unmodified lines
74	74	.name = "dirac",
75	75	.long_name = NULL_IF_CONFIG_SMALL("raw Dirac"),
76	76	.extensions = "drc",
77		− .audio_codec = CODEC_ID_NONE,
78		− .video_codec = CODEC_ID_DIRAC,
	77	+ .audio_codec = AV_CODEC_ID_NONE,
	78	+ .video_codec = AV_CODEC_ID_DIRAC,
79	79	.write_packet = ff_raw_write_packet,
80	80	.flags = AVFMT_NOTIMESTAMPS,
81	81	};
@@ -86,8 +86,8 @@ AVOutputFormat ff_dnxhd_muxer = { · 4 unmodified lines
86	86	.name = "dnxhd",
87	87	.long_name = NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
88	88	.extensions = "dnxhd",
89		− .audio_codec = CODEC_ID_NONE,
90		− .video_codec = CODEC_ID_DNXHD,
	89	+ .audio_codec = AV_CODEC_ID_NONE,
	90	+ .video_codec = AV_CODEC_ID_DNXHD,
91	91	.write_packet = ff_raw_write_packet,
92	92	.flags = AVFMT_NOTIMESTAMPS,
93	93	};
@@ -99,8 +99,8 @@ AVOutputFormat ff_dts_muxer = { · 5 unmodified lines
99	99	.long_name = NULL_IF_CONFIG_SMALL("raw DTS"),
100	100	.mime_type = "audio/x-dca",
101	101	.extensions = "dts",
102		− .audio_codec = CODEC_ID_DTS,
103		− .video_codec = CODEC_ID_NONE,
	102	+ .audio_codec = AV_CODEC_ID_DTS,
	103	+ .video_codec = AV_CODEC_ID_NONE,
104	104	.write_packet = ff_raw_write_packet,
105	105	.flags = AVFMT_NOTIMESTAMPS,
106	106	};
@@ -112,8 +112,8 @@ AVOutputFormat ff_eac3_muxer = { · 5 unmodified lines
112	112	.long_name = NULL_IF_CONFIG_SMALL("raw E-AC-3"),
113	113	.mime_type = "audio/x-eac3",
114	114	.extensions = "eac3",
115		− .audio_codec = CODEC_ID_EAC3,
116		− .video_codec = CODEC_ID_NONE,
	115	+ .audio_codec = AV_CODEC_ID_EAC3,
	116	+ .video_codec = AV_CODEC_ID_NONE,
117	117	.write_packet = ff_raw_write_packet,
118	118	.flags = AVFMT_NOTIMESTAMPS,
119	119	};
@@ -125,8 +125,8 @@ AVOutputFormat ff_g722_muxer = { · 5 unmodified lines
125	125	.long_name = NULL_IF_CONFIG_SMALL("raw G.722"),
126	126	.mime_type = "audio/G722",
127	127	.extensions = "g722",
128		− .audio_codec = CODEC_ID_ADPCM_G722,
129		− .video_codec = CODEC_ID_NONE,
	128	+ .audio_codec = AV_CODEC_ID_ADPCM_G722,
	129	+ .video_codec = AV_CODEC_ID_NONE,
130	130	.write_packet = ff_raw_write_packet,
131	131	.flags = AVFMT_NOTIMESTAMPS,
132	132	};
@@ -138,8 +138,8 @@ AVOutputFormat ff_h261_muxer = { · 5 unmodified lines
138	138	.long_name = NULL_IF_CONFIG_SMALL("raw H.261"),
139	139	.mime_type = "video/x-h261",
140	140	.extensions = "h261",
141		− .audio_codec = CODEC_ID_NONE,
142		− .video_codec = CODEC_ID_H261,
	141	+ .audio_codec = AV_CODEC_ID_NONE,
	142	+ .video_codec = AV_CODEC_ID_H261,
143	143	.write_packet = ff_raw_write_packet,
144	144	.flags = AVFMT_NOTIMESTAMPS,
145	145	};
@@ -151,8 +151,8 @@ AVOutputFormat ff_h263_muxer = { · 5 unmodified lines
151	151	.long_name = NULL_IF_CONFIG_SMALL("raw H.263"),
152	152	.mime_type = "video/x-h263",
153	153	.extensions = "h263",
154		− .audio_codec = CODEC_ID_NONE,
155		− .video_codec = CODEC_ID_H263,
	154	+ .audio_codec = AV_CODEC_ID_NONE,
	155	+ .video_codec = AV_CODEC_ID_H263,
156	156	.write_packet = ff_raw_write_packet,
157	157	.flags = AVFMT_NOTIMESTAMPS,
158	158	};
@@ -163,8 +163,8 @@ AVOutputFormat ff_h264_muxer = { · 4 unmodified lines
163	163	.name = "h264",
164	164	.long_name = NULL_IF_CONFIG_SMALL("raw H.264 video"),
165	165	.extensions = "h264",
166		− .audio_codec = CODEC_ID_NONE,
167		− .video_codec = CODEC_ID_H264,
	166	+ .audio_codec = AV_CODEC_ID_NONE,
	167	+ .video_codec = AV_CODEC_ID_H264,
168	168	.write_packet = ff_raw_write_packet,
169	169	.flags = AVFMT_NOTIMESTAMPS,
170	170	};
@@ -175,8 +175,8 @@ AVOutputFormat ff_m4v_muxer = { · 4 unmodified lines
175	175	.name = "m4v",
176	176	.long_name = NULL_IF_CONFIG_SMALL("raw MPEG-4 video"),
177	177	.extensions = "m4v",
178		− .audio_codec = CODEC_ID_NONE,
179		− .video_codec = CODEC_ID_MPEG4,
	178	+ .audio_codec = AV_CODEC_ID_NONE,
	179	+ .video_codec = AV_CODEC_ID_MPEG4,
180	180	.write_packet = ff_raw_write_packet,
181	181	.flags = AVFMT_NOTIMESTAMPS,
182	182	};
@@ -188,8 +188,8 @@ AVOutputFormat ff_mjpeg_muxer = { · 5 unmodified lines
188	188	.long_name = NULL_IF_CONFIG_SMALL("raw MJPEG video"),
189	189	.mime_type = "video/x-mjpeg",
190	190	.extensions = "mjpg,mjpeg",
191		− .audio_codec = CODEC_ID_NONE,
192		− .video_codec = CODEC_ID_MJPEG,
	191	+ .audio_codec = AV_CODEC_ID_NONE,
	192	+ .video_codec = AV_CODEC_ID_MJPEG,
193	193	.write_packet = ff_raw_write_packet,
194	194	.flags = AVFMT_NOTIMESTAMPS,
195	195	};
@@ -200,8 +200,8 @@ AVOutputFormat ff_mlp_muxer = { · 4 unmodified lines
200	200	.name = "mlp",
201	201	.long_name = NULL_IF_CONFIG_SMALL("raw MLP"),
202	202	.extensions = "mlp",
203		− .audio_codec = CODEC_ID_MLP,
204		− .video_codec = CODEC_ID_NONE,
	203	+ .audio_codec = AV_CODEC_ID_MLP,
	204	+ .video_codec = AV_CODEC_ID_NONE,
205	205	.write_packet = ff_raw_write_packet,
206	206	.flags = AVFMT_NOTIMESTAMPS,
207	207	};
@@ -213,8 +213,8 @@ AVOutputFormat ff_mpeg1video_muxer = { · 5 unmodified lines
213	213	.long_name = NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
214	214	.mime_type = "video/x-mpeg",
215	215	.extensions = "mpg,mpeg,m1v",
216		− .audio_codec = CODEC_ID_NONE,
217		− .video_codec = CODEC_ID_MPEG1VIDEO,
	216	+ .audio_codec = AV_CODEC_ID_NONE,
	217	+ .video_codec = AV_CODEC_ID_MPEG1VIDEO,
218	218	.write_packet = ff_raw_write_packet,
219	219	.flags = AVFMT_NOTIMESTAMPS,
220	220	};
@@ -225,8 +225,8 @@ AVOutputFormat ff_mpeg2video_muxer = { · 4 unmodified lines
225	225	.name = "mpeg2video",
226	226	.long_name = NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
227	227	.extensions = "m2v",
228		− .audio_codec = CODEC_ID_NONE,
229		− .video_codec = CODEC_ID_MPEG2VIDEO,
	228	+ .audio_codec = AV_CODEC_ID_NONE,
	229	+ .video_codec = AV_CODEC_ID_MPEG2VIDEO,
230	230	.write_packet = ff_raw_write_packet,
231	231	.flags = AVFMT_NOTIMESTAMPS,
232	232	};
@@ -237,8 +237,8 @@ AVOutputFormat ff_rawvideo_muxer = { · 4 unmodified lines
237	237	.name = "rawvideo",
238	238	.long_name = NULL_IF_CONFIG_SMALL("raw video"),
239	239	.extensions = "yuv,rgb",
240		− .audio_codec = CODEC_ID_NONE,
241		− .video_codec = CODEC_ID_RAWVIDEO,
	240	+ .audio_codec = AV_CODEC_ID_NONE,
	241	+ .video_codec = AV_CODEC_ID_RAWVIDEO,
242	242	.write_packet = ff_raw_write_packet,
243	243	.flags = AVFMT_NOTIMESTAMPS,
244	244	};
@@ -252,7 +252,7 @@ AVOutputFormat ff_srt_muxer = { · 7 unmodified lines
252	252	.extensions = "srt",
253	253	.write_packet = ff_raw_write_packet,
254	254	.flags = AVFMT_NOTIMESTAMPS,
255		− .subtitle_codec = CODEC_ID_SRT,
	255	+ .subtitle_codec = AV_CODEC_ID_SRT,
256	256	};
257	257	#endif
258	258
@@ -261,8 +261,8 @@ AVOutputFormat ff_truehd_muxer = { · 2 unmodified lines
261	261	.name = "truehd",
262	262	.long_name = NULL_IF_CONFIG_SMALL("raw TrueHD"),
263	263	.extensions = "thd",
264		− .audio_codec = CODEC_ID_TRUEHD,
265		− .video_codec = CODEC_ID_NONE,
	264	+ .audio_codec = AV_CODEC_ID_TRUEHD,
	265	+ .video_codec = AV_CODEC_ID_NONE,
266	266	.write_packet = ff_raw_write_packet,
267	267	.flags = AVFMT_NOTIMESTAMPS,
268	268	};

libavformat/rawvideodec.c+1−1

@@ -68,6 +68,6 @@ AVInputFormat ff_rawvideo_demuxer = { · 67 unmodified lines
68	68	.read_packet = rawvideo_read_packet,
69	69	.flags = AVFMT_GENERIC_INDEX,
70	70	.extensions = "yuv,cif,qcif,rgb",
71		− .raw_codec_id = CODEC_ID_RAWVIDEO,
	71	+ .raw_codec_id = AV_CODEC_ID_RAWVIDEO,
72	72	.priv_class = &rawvideo_demuxer_class,
73	73	};

libavformat/rdt.c+3−3

@@ -309,7 +309,7 @@ rdt_parse_packet (AVFormatContext ctx, PayloadContext rdt, AVStream *st, · 308 unmodified lines
309	309	if (res < 0)
310	310	return res;
311	311	if (res > 0) {
312		− if (st->codec->codec_id == CODEC_ID_AAC) {
	312	+ if (st->codec->codec_id == AV_CODEC_ID_AAC) {
313	313	memcpy (rdt->buffer, buf + pos, len - pos);
314	314	rdt->rmctx->pb = avio_alloc_context (rdt->buffer, len - pos, 0,
315	315	NULL, NULL, NULL, NULL);
@@ -322,7 +322,7 @@ get_cache: · 6 unmodified lines
322	322	ff_rm_retrieve_cache (rdt->rmctx, rdt->rmctx->pb,
323	323	st, rdt->rmst[st->index], pkt);
324	324	if (rdt->audio_pkt_cnt == 0 &&
325		− st->codec->codec_id == CODEC_ID_AAC)
	325	+ st->codec->codec_id == AV_CODEC_ID_AAC)
326	326	av_freep(&rdt->rmctx->pb);
327	327	}
328	328	pkt->stream_index = st->index;
@@ -551,7 +551,7 @@ rdt_free_context (PayloadContext *rdt) · 222 unmodified lines
551	551	static RTPDynamicProtocolHandler ff_rdt_ ## n ## _handler = { \
552	552	.enc_name = s, \
553	553	.codec_type = t, \
554		− .codec_id = CODEC_ID_NONE, \
	554	+ .codec_id = AV_CODEC_ID_NONE, \
555	555	.parse_sdp_a_line = rdt_parse_sdp_line, \
556	556	.alloc = rdt_new_context, \
557	557	.free = rdt_free_context, \

libavformat/riff.c+339−339

@@ -29,325 +29,325 @@ · 28 unmodified lines
29	29	/* Note: when encoding, the first matching tag is used, so order is
30	30	important if multiple tags possible for a given codec. */
31	31	const AVCodecTag ff_codec_bmp_tags[] = {
32		− { CODEC_ID_H264, MKTAG('H', '2', '6', '4') },
33		− { CODEC_ID_H264, MKTAG('h', '2', '6', '4') },
34		− { CODEC_ID_H264, MKTAG('X', '2', '6', '4') },
35		− { CODEC_ID_H264, MKTAG('x', '2', '6', '4') },
36		− { CODEC_ID_H264, MKTAG('a', 'v', 'c', '1') },
37		− { CODEC_ID_H264, MKTAG('D', 'A', 'V', 'C') },
38		− { CODEC_ID_H264, MKTAG('V', 'S', 'S', 'H') },
39		− { CODEC_ID_H263, MKTAG('H', '2', '6', '3') },
40		− { CODEC_ID_H263, MKTAG('X', '2', '6', '3') },
41		− { CODEC_ID_H263, MKTAG('T', '2', '6', '3') },
42		− { CODEC_ID_H263, MKTAG('L', '2', '6', '3') },
43		− { CODEC_ID_H263, MKTAG('V', 'X', '1', 'K') },
44		− { CODEC_ID_H263, MKTAG('Z', 'y', 'G', 'o') },
45		− { CODEC_ID_H263, MKTAG('M', '2', '6', '3') },
46		− { CODEC_ID_H263P, MKTAG('H', '2', '6', '3') },
47		− { CODEC_ID_H263I, MKTAG('I', '2', '6', '3') }, /* intel h263 */
48		− { CODEC_ID_H261, MKTAG('H', '2', '6', '1') },
49		− { CODEC_ID_H263P, MKTAG('U', '2', '6', '3') },
50		− { CODEC_ID_H263P, MKTAG('v', 'i', 'v', '1') },
51		− { CODEC_ID_MPEG4, MKTAG('F', 'M', 'P', '4') },
52		− { CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', 'X') },
53		− { CODEC_ID_MPEG4, MKTAG('D', 'X', '5', '0') },
54		− { CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') },
55		− { CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
56		− { CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },
57		− { CODEC_ID_MPEG4, MKTAG( 4 , 0 , 0 , 0 ) }, /* some broken avi use this */
58		− { CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', '1') },
59		− { CODEC_ID_MPEG4, MKTAG('B', 'L', 'Z', '0') },
60		− { CODEC_ID_MPEG4, MKTAG('m', 'p', '4', 'v') },
61		− { CODEC_ID_MPEG4, MKTAG('U', 'M', 'P', '4') },
62		− { CODEC_ID_MPEG4, MKTAG('W', 'V', '1', 'F') },
63		− { CODEC_ID_MPEG4, MKTAG('S', 'E', 'D', 'G') },
64		− { CODEC_ID_MPEG4, MKTAG('R', 'M', 'P', '4') },
65		− { CODEC_ID_MPEG4, MKTAG('3', 'I', 'V', '2') },
66		− { CODEC_ID_MPEG4, MKTAG('W', 'A', 'W', 'V') }, /* WaWv MPEG-4 Video Codec */
67		− { CODEC_ID_MPEG4, MKTAG('F', 'F', 'D', 'S') },
68		− { CODEC_ID_MPEG4, MKTAG('F', 'V', 'F', 'W') },
69		− { CODEC_ID_MPEG4, MKTAG('D', 'C', 'O', 'D') },
70		− { CODEC_ID_MPEG4, MKTAG('M', 'V', 'X', 'M') },
71		− { CODEC_ID_MPEG4, MKTAG('P', 'M', '4', 'V') },
72		− { CODEC_ID_MPEG4, MKTAG('S', 'M', 'P', '4') },
73		− { CODEC_ID_MPEG4, MKTAG('D', 'X', 'G', 'M') },
74		− { CODEC_ID_MPEG4, MKTAG('V', 'I', 'D', 'M') },
75		− { CODEC_ID_MPEG4, MKTAG('M', '4', 'T', '3') },
76		− { CODEC_ID_MPEG4, MKTAG('G', 'E', 'O', 'X') },
77		− { CODEC_ID_MPEG4, MKTAG('H', 'D', 'X', '4') }, /* flipped video */
78		− { CODEC_ID_MPEG4, MKTAG('D', 'M', 'K', '2') },
79		− { CODEC_ID_MPEG4, MKTAG('D', 'I', 'G', 'I') },
80		− { CODEC_ID_MPEG4, MKTAG('I', 'N', 'M', 'C') },
81		− { CODEC_ID_MPEG4, MKTAG('E', 'P', 'H', 'V') }, /* Ephv MPEG-4 */
82		− { CODEC_ID_MPEG4, MKTAG('E', 'M', '4', 'A') },
83		− { CODEC_ID_MPEG4, MKTAG('M', '4', 'C', 'C') }, /* Divio MPEG-4 */
84		− { CODEC_ID_MPEG4, MKTAG('S', 'N', '4', '0') },
85		− { CODEC_ID_MPEG4, MKTAG('V', 'S', 'P', 'X') },
86		− { CODEC_ID_MPEG4, MKTAG('U', 'L', 'D', 'X') },
87		− { CODEC_ID_MPEG4, MKTAG('G', 'E', 'O', 'V') },
88		− { CODEC_ID_MPEG4, MKTAG('S', 'I', 'P', 'P') }, /* Samsung SHR-6040 */
89		− { CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'X') },
90		− { CODEC_ID_MPEG4, MKTAG('D', 'r', 'e', 'X') },
91		− { CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
92		− { CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '3') },
93		− { CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', 'G', '3') },
94		− { CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '5') },
95		− { CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '6') },
96		− { CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '4') },
97		− { CODEC_ID_MSMPEG4V3, MKTAG('D', 'V', 'X', '3') },
98		− { CODEC_ID_MSMPEG4V3, MKTAG('A', 'P', '4', '1') },
99		− { CODEC_ID_MSMPEG4V3, MKTAG('C', 'O', 'L', '1') },
100		− { CODEC_ID_MSMPEG4V3, MKTAG('C', 'O', 'L', '0') },
101		− { CODEC_ID_MSMPEG4V2, MKTAG('M', 'P', '4', '2') },
102		− { CODEC_ID_MSMPEG4V2, MKTAG('D', 'I', 'V', '2') },
103		− { CODEC_ID_MSMPEG4V1, MKTAG('M', 'P', 'G', '4') },
104		− { CODEC_ID_MSMPEG4V1, MKTAG('M', 'P', '4', '1') },
105		− { CODEC_ID_WMV1, MKTAG('W', 'M', 'V', '1') },
106		− { CODEC_ID_WMV2, MKTAG('W', 'M', 'V', '2') },
107		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 's', 'd') },
108		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', 'd') },
109		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '1') },
110		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 's', 'l') },
111		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '2', '5') },
112		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', '0') },
113		− { CODEC_ID_DVVIDEO, MKTAG('c', 'd', 'v', 'c') }, /* Canopus DV */
114		− { CODEC_ID_DVVIDEO, MKTAG('C', 'D', 'V', 'H') }, /* Canopus DV */
115		− { CODEC_ID_DVVIDEO, MKTAG('C', 'D', 'V', '5') }, /* Canopus DV */
116		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') },
117		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', 's') },
118		− { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '1') },
119		− { CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'g', '1') },
120		− { CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'g', '2') },
121		− { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'p', 'g', '2') },
122		− { CODEC_ID_MPEG2VIDEO, MKTAG('M', 'P', 'E', 'G') },
123		− { CODEC_ID_MPEG1VIDEO, MKTAG('P', 'I', 'M', '1') },
124		− { CODEC_ID_MPEG2VIDEO, MKTAG('P', 'I', 'M', '2') },
125		− { CODEC_ID_MPEG1VIDEO, MKTAG('V', 'C', 'R', '2') },
126		− { CODEC_ID_MPEG1VIDEO, MKTAG( 1 , 0 , 0 , 16) },
127		− { CODEC_ID_MPEG2VIDEO, MKTAG( 2 , 0 , 0 , 16) },
128		− { CODEC_ID_MPEG4, MKTAG( 4 , 0 , 0 , 16) },
129		− { CODEC_ID_MPEG2VIDEO, MKTAG('D', 'V', 'R', ' ') },
130		− { CODEC_ID_MPEG2VIDEO, MKTAG('M', 'M', 'E', 'S') },
131		− { CODEC_ID_MPEG2VIDEO, MKTAG('L', 'M', 'P', '2') }, /* Lead MPEG2 in avi */
132		− { CODEC_ID_MPEG2VIDEO, MKTAG('s', 'l', 'i', 'f') },
133		− { CODEC_ID_MPEG2VIDEO, MKTAG('E', 'M', '2', 'V') },
134		− { CODEC_ID_MPEG2VIDEO, MKTAG('M', '7', '0', '1') }, /* Matrox MPEG2 intra-only */
135		− { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'p', 'g', 'v') },
136		− { CODEC_ID_MJPEG, MKTAG('M', 'J', 'P', 'G') },
137		− { CODEC_ID_MJPEG, MKTAG('L', 'J', 'P', 'G') },
138		− { CODEC_ID_MJPEG, MKTAG('d', 'm', 'b', '1') },
139		− { CODEC_ID_MJPEG, MKTAG('m', 'j', 'p', 'a') },
140		− { CODEC_ID_LJPEG, MKTAG('L', 'J', 'P', 'G') },
141		− { CODEC_ID_MJPEG, MKTAG('J', 'P', 'G', 'L') }, /* Pegasus lossless JPEG */
142		− { CODEC_ID_JPEGLS, MKTAG('M', 'J', 'L', 'S') }, /* JPEG-LS custom FOURCC for avi - encoder */
143		− { CODEC_ID_JPEGLS, MKTAG('M', 'J', 'P', 'G') },
144		− { CODEC_ID_MJPEG, MKTAG('M', 'J', 'L', 'S') }, /* JPEG-LS custom FOURCC for avi - decoder */
145		− { CODEC_ID_MJPEG, MKTAG('j', 'p', 'e', 'g') },
146		− { CODEC_ID_MJPEG, MKTAG('I', 'J', 'P', 'G') },
147		− { CODEC_ID_MJPEG, MKTAG('A', 'V', 'R', 'n') },
148		− { CODEC_ID_MJPEG, MKTAG('A', 'C', 'D', 'V') },
149		− { CODEC_ID_MJPEG, MKTAG('Q', 'I', 'V', 'G') },
150		− { CODEC_ID_MJPEG, MKTAG('S', 'L', 'M', 'J') }, /* SL M-JPEG */
151		− { CODEC_ID_MJPEG, MKTAG('C', 'J', 'P', 'G') }, /* Creative Webcam JPEG */
152		− { CODEC_ID_MJPEG, MKTAG('I', 'J', 'L', 'V') }, /* Intel JPEG Library Video Codec */
153		− { CODEC_ID_MJPEG, MKTAG('M', 'V', 'J', 'P') }, /* Midvid JPEG Video Codec */
154		− { CODEC_ID_MJPEG, MKTAG('A', 'V', 'I', '1') },
155		− { CODEC_ID_MJPEG, MKTAG('A', 'V', 'I', '2') },
156		− { CODEC_ID_MJPEG, MKTAG('M', 'T', 'S', 'J') },
157		− { CODEC_ID_MJPEG, MKTAG('Z', 'J', 'P', 'G') }, /* Paradigm Matrix M-JPEG Codec */
158		− { CODEC_ID_MJPEG, MKTAG('M', 'M', 'J', 'P') },
159		− { CODEC_ID_HUFFYUV, MKTAG('H', 'F', 'Y', 'U') },
160		− { CODEC_ID_FFVHUFF, MKTAG('F', 'F', 'V', 'H') },
161		− { CODEC_ID_CYUV, MKTAG('C', 'Y', 'U', 'V') },
162		− { CODEC_ID_RAWVIDEO, MKTAG( 0 , 0 , 0 , 0 ) },
163		− { CODEC_ID_RAWVIDEO, MKTAG( 3 , 0 , 0 , 0 ) },
164		− { CODEC_ID_RAWVIDEO, MKTAG('I', '4', '2', '0') },
165		− { CODEC_ID_RAWVIDEO, MKTAG('Y', 'U', 'Y', '2') },
166		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '4', '2', '2') },
167		− { CODEC_ID_RAWVIDEO, MKTAG('V', '4', '2', '2') },
168		− { CODEC_ID_RAWVIDEO, MKTAG('Y', 'U', 'N', 'V') },
169		− { CODEC_ID_RAWVIDEO, MKTAG('U', 'Y', 'N', 'V') },
170		− { CODEC_ID_RAWVIDEO, MKTAG('U', 'Y', 'N', 'Y') },
171		− { CODEC_ID_RAWVIDEO, MKTAG('u', 'y', 'v', '1') },
172		− { CODEC_ID_RAWVIDEO, MKTAG('2', 'V', 'u', '1') },
173		− { CODEC_ID_RAWVIDEO, MKTAG('2', 'v', 'u', 'y') },
174		− { CODEC_ID_RAWVIDEO, MKTAG('y', 'u', 'v', 's') },
175		− { CODEC_ID_RAWVIDEO, MKTAG('y', 'u', 'v', '2') },
176		− { CODEC_ID_RAWVIDEO, MKTAG('P', '4', '2', '2') },
177		− { CODEC_ID_RAWVIDEO, MKTAG('Y', 'V', '1', '2') },
178		− { CODEC_ID_RAWVIDEO, MKTAG('Y', 'V', '1', '6') },
179		− { CODEC_ID_RAWVIDEO, MKTAG('Y', 'V', '2', '4') },
180		− { CODEC_ID_RAWVIDEO, MKTAG('U', 'Y', 'V', 'Y') },
181		− { CODEC_ID_RAWVIDEO, MKTAG('V', 'Y', 'U', 'Y') },
182		− { CODEC_ID_RAWVIDEO, MKTAG('I', 'Y', 'U', 'V') },
183		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '8', '0', '0') },
184		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '8', ' ', ' ') },
185		− { CODEC_ID_RAWVIDEO, MKTAG('H', 'D', 'Y', 'C') },
186		− { CODEC_ID_RAWVIDEO, MKTAG('Y', 'V', 'U', '9') },
187		− { CODEC_ID_RAWVIDEO, MKTAG('V', 'D', 'T', 'Z') }, /* SoftLab-NSK VideoTizer */
188		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '4', '1', '1') },
189		− { CODEC_ID_RAWVIDEO, MKTAG('N', 'V', '1', '2') },
190		− { CODEC_ID_RAWVIDEO, MKTAG('N', 'V', '2', '1') },
191		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '4', '1', 'B') },
192		− { CODEC_ID_RAWVIDEO, MKTAG('Y', '4', '2', 'B') },
193		− { CODEC_ID_RAWVIDEO, MKTAG('Y', 'U', 'V', '9') },
194		− { CODEC_ID_RAWVIDEO, MKTAG('Y', 'V', 'U', '9') },
195		− { CODEC_ID_RAWVIDEO, MKTAG('a', 'u', 'v', '2') },
196		− { CODEC_ID_FRWU, MKTAG('F', 'R', 'W', 'U') },
197		− { CODEC_ID_R10K, MKTAG('R', '1', '0', 'k') },
198		− { CODEC_ID_R210, MKTAG('r', '2', '1', '0') },
199		− { CODEC_ID_V210, MKTAG('v', '2', '1', '0') },
200		− { CODEC_ID_V410, MKTAG('v', '4', '1', '0') },
201		− { CODEC_ID_INDEO3, MKTAG('I', 'V', '3', '1') },
202		− { CODEC_ID_INDEO3, MKTAG('I', 'V', '3', '2') },
203		− { CODEC_ID_INDEO4, MKTAG('I', 'V', '4', '1') },
204		− { CODEC_ID_INDEO5, MKTAG('I', 'V', '5', '0') },
205		− { CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') },
206		− { CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') },
207		− { CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') },
208		− { CODEC_ID_VP6, MKTAG('V', 'P', '6', '0') },
209		− { CODEC_ID_VP6, MKTAG('V', 'P', '6', '1') },
210		− { CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },
211		− { CODEC_ID_VP6F, MKTAG('V', 'P', '6', 'F') },
212		− { CODEC_ID_VP6F, MKTAG('F', 'L', 'V', '4') },
213		− { CODEC_ID_VP8, MKTAG('V', 'P', '8', '0') },
214		− { CODEC_ID_ASV1, MKTAG('A', 'S', 'V', '1') },
215		− { CODEC_ID_ASV2, MKTAG('A', 'S', 'V', '2') },
216		− { CODEC_ID_VCR1, MKTAG('V', 'C', 'R', '1') },
217		− { CODEC_ID_FFV1, MKTAG('F', 'F', 'V', '1') },
218		− { CODEC_ID_XAN_WC4, MKTAG('X', 'x', 'a', 'n') },
219		− { CODEC_ID_MIMIC, MKTAG('L', 'M', '2', '0') },
220		− { CODEC_ID_MSRLE, MKTAG('m', 'r', 'l', 'e') },
221		− { CODEC_ID_MSRLE, MKTAG( 1 , 0 , 0 , 0 ) },
222		− { CODEC_ID_MSRLE, MKTAG( 2 , 0 , 0 , 0 ) },
223		− { CODEC_ID_MSVIDEO1, MKTAG('M', 'S', 'V', 'C') },
224		− { CODEC_ID_MSVIDEO1, MKTAG('m', 's', 'v', 'c') },
225		− { CODEC_ID_MSVIDEO1, MKTAG('C', 'R', 'A', 'M') },
226		− { CODEC_ID_MSVIDEO1, MKTAG('c', 'r', 'a', 'm') },
227		− { CODEC_ID_MSVIDEO1, MKTAG('W', 'H', 'A', 'M') },
228		− { CODEC_ID_MSVIDEO1, MKTAG('w', 'h', 'a', 'm') },
229		− { CODEC_ID_CINEPAK, MKTAG('c', 'v', 'i', 'd') },
230		− { CODEC_ID_TRUEMOTION1, MKTAG('D', 'U', 'C', 'K') },
231		− { CODEC_ID_TRUEMOTION1, MKTAG('P', 'V', 'E', 'Z') },
232		− { CODEC_ID_MSZH, MKTAG('M', 'S', 'Z', 'H') },
233		− { CODEC_ID_ZLIB, MKTAG('Z', 'L', 'I', 'B') },
234		− { CODEC_ID_SNOW, MKTAG('S', 'N', 'O', 'W') },
235		− { CODEC_ID_4XM, MKTAG('4', 'X', 'M', 'V') },
236		− { CODEC_ID_FLV1, MKTAG('F', 'L', 'V', '1') },
237		− { CODEC_ID_FLASHSV, MKTAG('F', 'S', 'V', '1') },
238		− { CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', '1') },
239		− { CODEC_ID_TSCC, MKTAG('t', 's', 'c', 'c') },
240		− { CODEC_ID_ULTI, MKTAG('U', 'L', 'T', 'I') },
241		− { CODEC_ID_VIXL, MKTAG('V', 'I', 'X', 'L') },
242		− { CODEC_ID_QPEG, MKTAG('Q', 'P', 'E', 'G') },
243		− { CODEC_ID_QPEG, MKTAG('Q', '1', '.', '0') },
244		− { CODEC_ID_QPEG, MKTAG('Q', '1', '.', '1') },
245		− { CODEC_ID_WMV3, MKTAG('W', 'M', 'V', '3') },
246		− { CODEC_ID_WMV3IMAGE, MKTAG('W', 'M', 'V', 'P') },
247		− { CODEC_ID_VC1, MKTAG('W', 'V', 'C', '1') },
248		− { CODEC_ID_VC1, MKTAG('W', 'M', 'V', 'A') },
249		− { CODEC_ID_VC1IMAGE, MKTAG('W', 'V', 'P', '2') },
250		− { CODEC_ID_LOCO, MKTAG('L', 'O', 'C', 'O') },
251		− { CODEC_ID_WNV1, MKTAG('W', 'N', 'V', '1') },
252		− { CODEC_ID_AASC, MKTAG('A', 'A', 'S', 'C') },
253		− { CODEC_ID_INDEO2, MKTAG('R', 'T', '2', '1') },
254		− { CODEC_ID_FRAPS, MKTAG('F', 'P', 'S', '1') },
255		− { CODEC_ID_THEORA, MKTAG('t', 'h', 'e', 'o') },
256		− { CODEC_ID_TRUEMOTION2, MKTAG('T', 'M', '2', '0') },
257		− { CODEC_ID_CSCD, MKTAG('C', 'S', 'C', 'D') },
258		− { CODEC_ID_ZMBV, MKTAG('Z', 'M', 'B', 'V') },
259		− { CODEC_ID_KMVC, MKTAG('K', 'M', 'V', 'C') },
260		− { CODEC_ID_CAVS, MKTAG('C', 'A', 'V', 'S') },
261		− { CODEC_ID_JPEG2000, MKTAG('m', 'j', 'p', '2') },
262		− { CODEC_ID_JPEG2000, MKTAG('M', 'J', '2', 'C') },
263		− { CODEC_ID_JPEG2000, MKTAG('L', 'J', '2', 'C') },
264		− { CODEC_ID_JPEG2000, MKTAG('L', 'J', '2', 'K') },
265		− { CODEC_ID_VMNC, MKTAG('V', 'M', 'n', 'c') },
266		− { CODEC_ID_TARGA, MKTAG('t', 'g', 'a', ' ') },
267		− { CODEC_ID_PNG, MKTAG('M', 'P', 'N', 'G') },
268		− { CODEC_ID_PNG, MKTAG('P', 'N', 'G', '1') },
269		− { CODEC_ID_CLJR, MKTAG('C', 'L', 'J', 'R') },
270		− { CODEC_ID_DIRAC, MKTAG('d', 'r', 'a', 'c') },
271		− { CODEC_ID_RPZA, MKTAG('a', 'z', 'p', 'r') },
272		− { CODEC_ID_RPZA, MKTAG('R', 'P', 'Z', 'A') },
273		− { CODEC_ID_RPZA, MKTAG('r', 'p', 'z', 'a') },
274		− { CODEC_ID_SP5X, MKTAG('S', 'P', '5', '4') },
275		− { CODEC_ID_AURA, MKTAG('A', 'U', 'R', 'A') },
276		− { CODEC_ID_AURA2, MKTAG('A', 'U', 'R', '2') },
277		− { CODEC_ID_DPX, MKTAG('d', 'p', 'x', ' ') },
278		− { CODEC_ID_KGV1, MKTAG('K', 'G', 'V', '1') },
279		− { CODEC_ID_LAGARITH, MKTAG('L', 'A', 'G', 'S') },
280		− { CODEC_ID_UTVIDEO, MKTAG('U', 'L', 'R', 'A') },
281		− { CODEC_ID_UTVIDEO, MKTAG('U', 'L', 'R', 'G') },
282		− { CODEC_ID_UTVIDEO, MKTAG('U', 'L', 'Y', '0') },
283		− { CODEC_ID_UTVIDEO, MKTAG('U', 'L', 'Y', '2') },
284		− { CODEC_ID_VBLE, MKTAG('V', 'B', 'L', 'E') },
285		− { CODEC_ID_DXTORY, MKTAG('x', 't', 'o', 'r') },
286		− { CODEC_ID_ZEROCODEC, MKTAG('Z', 'E', 'C', 'O') },
287		− { CODEC_ID_MSS1, MKTAG('M', 'S', 'S', '1') },
288		− { CODEC_ID_MSA1, MKTAG('M', 'S', 'A', '1') },
289		− { CODEC_ID_TSCC2, MKTAG('T', 'S', 'C', '2') },
290		− { CODEC_ID_MTS2, MKTAG('M', 'T', 'S', '2') },
291		− { CODEC_ID_CLLC, MKTAG('C', 'L', 'L', 'C') },
292		− { CODEC_ID_NONE, 0 }
	32	+ { AV_CODEC_ID_H264, MKTAG('H', '2', '6', '4') },
	33	+ { AV_CODEC_ID_H264, MKTAG('h', '2', '6', '4') },
	34	+ { AV_CODEC_ID_H264, MKTAG('X', '2', '6', '4') },
	35	+ { AV_CODEC_ID_H264, MKTAG('x', '2', '6', '4') },
	36	+ { AV_CODEC_ID_H264, MKTAG('a', 'v', 'c', '1') },
	37	+ { AV_CODEC_ID_H264, MKTAG('D', 'A', 'V', 'C') },
	38	+ { AV_CODEC_ID_H264, MKTAG('V', 'S', 'S', 'H') },
	39	+ { AV_CODEC_ID_H263, MKTAG('H', '2', '6', '3') },
	40	+ { AV_CODEC_ID_H263, MKTAG('X', '2', '6', '3') },
	41	+ { AV_CODEC_ID_H263, MKTAG('T', '2', '6', '3') },
	42	+ { AV_CODEC_ID_H263, MKTAG('L', '2', '6', '3') },
	43	+ { AV_CODEC_ID_H263, MKTAG('V', 'X', '1', 'K') },
	44	+ { AV_CODEC_ID_H263, MKTAG('Z', 'y', 'G', 'o') },
	45	+ { AV_CODEC_ID_H263, MKTAG('M', '2', '6', '3') },
	46	+ { AV_CODEC_ID_H263P, MKTAG('H', '2', '6', '3') },
	47	+ { AV_CODEC_ID_H263I, MKTAG('I', '2', '6', '3') }, /* intel h263 */
	48	+ { AV_CODEC_ID_H261, MKTAG('H', '2', '6', '1') },
	49	+ { AV_CODEC_ID_H263P, MKTAG('U', '2', '6', '3') },
	50	+ { AV_CODEC_ID_H263P, MKTAG('v', 'i', 'v', '1') },
	51	+ { AV_CODEC_ID_MPEG4, MKTAG('F', 'M', 'P', '4') },
	52	+ { AV_CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', 'X') },
	53	+ { AV_CODEC_ID_MPEG4, MKTAG('D', 'X', '5', '0') },
	54	+ { AV_CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') },
	55	+ { AV_CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
	56	+ { AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },
	57	+ { AV_CODEC_ID_MPEG4, MKTAG( 4 , 0 , 0 , 0 ) }, /* some broken avi use this */
	58	+ { AV_CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', '1') },
	59	+ { AV_CODEC_ID_MPEG4, MKTAG('B', 'L', 'Z', '0') },
	60	+ { AV_CODEC_ID_MPEG4, MKTAG('m', 'p', '4', 'v') },
	61	+ { AV_CODEC_ID_MPEG4, MKTAG('U', 'M', 'P', '4') },
	62	+ { AV_CODEC_ID_MPEG4, MKTAG('W', 'V', '1', 'F') },
	63	+ { AV_CODEC_ID_MPEG4, MKTAG('S', 'E', 'D', 'G') },
	64	+ { AV_CODEC_ID_MPEG4, MKTAG('R', 'M', 'P', '4') },
	65	+ { AV_CODEC_ID_MPEG4, MKTAG('3', 'I', 'V', '2') },
	66	+ { AV_CODEC_ID_MPEG4, MKTAG('W', 'A', 'W', 'V') }, /* WaWv MPEG-4 Video Codec */
	67	+ { AV_CODEC_ID_MPEG4, MKTAG('F', 'F', 'D', 'S') },
	68	+ { AV_CODEC_ID_MPEG4, MKTAG('F', 'V', 'F', 'W') },
	69	+ { AV_CODEC_ID_MPEG4, MKTAG('D', 'C', 'O', 'D') },
	70	+ { AV_CODEC_ID_MPEG4, MKTAG('M', 'V', 'X', 'M') },
	71	+ { AV_CODEC_ID_MPEG4, MKTAG('P', 'M', '4', 'V') },
	72	+ { AV_CODEC_ID_MPEG4, MKTAG('S', 'M', 'P', '4') },
	73	+ { AV_CODEC_ID_MPEG4, MKTAG('D', 'X', 'G', 'M') },
	74	+ { AV_CODEC_ID_MPEG4, MKTAG('V', 'I', 'D', 'M') },
	75	+ { AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'T', '3') },
	76	+ { AV_CODEC_ID_MPEG4, MKTAG('G', 'E', 'O', 'X') },
	77	+ { AV_CODEC_ID_MPEG4, MKTAG('H', 'D', 'X', '4') }, /* flipped video */
	78	+ { AV_CODEC_ID_MPEG4, MKTAG('D', 'M', 'K', '2') },
	79	+ { AV_CODEC_ID_MPEG4, MKTAG('D', 'I', 'G', 'I') },
	80	+ { AV_CODEC_ID_MPEG4, MKTAG('I', 'N', 'M', 'C') },
	81	+ { AV_CODEC_ID_MPEG4, MKTAG('E', 'P', 'H', 'V') }, /* Ephv MPEG-4 */
	82	+ { AV_CODEC_ID_MPEG4, MKTAG('E', 'M', '4', 'A') },
	83	+ { AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'C', 'C') }, /* Divio MPEG-4 */
	84	+ { AV_CODEC_ID_MPEG4, MKTAG('S', 'N', '4', '0') },
	85	+ { AV_CODEC_ID_MPEG4, MKTAG('V', 'S', 'P', 'X') },
	86	+ { AV_CODEC_ID_MPEG4, MKTAG('U', 'L', 'D', 'X') },
	87	+ { AV_CODEC_ID_MPEG4, MKTAG('G', 'E', 'O', 'V') },
	88	+ { AV_CODEC_ID_MPEG4, MKTAG('S', 'I', 'P', 'P') }, /* Samsung SHR-6040 */
	89	+ { AV_CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'X') },
	90	+ { AV_CODEC_ID_MPEG4, MKTAG('D', 'r', 'e', 'X') },
	91	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
	92	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '3') },
	93	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', 'G', '3') },
	94	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '5') },
	95	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '6') },
	96	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '4') },
	97	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('D', 'V', 'X', '3') },
	98	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('A', 'P', '4', '1') },
	99	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('C', 'O', 'L', '1') },
	100	+ { AV_CODEC_ID_MSMPEG4V3, MKTAG('C', 'O', 'L', '0') },
	101	+ { AV_CODEC_ID_MSMPEG4V2, MKTAG('M', 'P', '4', '2') },
	102	+ { AV_CODEC_ID_MSMPEG4V2, MKTAG('D', 'I', 'V', '2') },
	103	+ { AV_CODEC_ID_MSMPEG4V1, MKTAG('M', 'P', 'G', '4') },
	104	+ { AV_CODEC_ID_MSMPEG4V1, MKTAG('M', 'P', '4', '1') },
	105	+ { AV_CODEC_ID_WMV1, MKTAG('W', 'M', 'V', '1') },
	106	+ { AV_CODEC_ID_WMV2, MKTAG('W', 'M', 'V', '2') },
	107	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 's', 'd') },
	108	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', 'd') },
	109	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '1') },
	110	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 's', 'l') },
	111	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', '2', '5') },
	112	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', '0') },
	113	+ { AV_CODEC_ID_DVVIDEO, MKTAG('c', 'd', 'v', 'c') }, /* Canopus DV */
	114	+ { AV_CODEC_ID_DVVIDEO, MKTAG('C', 'D', 'V', 'H') }, /* Canopus DV */
	115	+ { AV_CODEC_ID_DVVIDEO, MKTAG('C', 'D', 'V', '5') }, /* Canopus DV */
	116	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') },
	117	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', 's') },
	118	+ { AV_CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '1') },
	119	+ { AV_CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'g', '1') },
	120	+ { AV_CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'g', '2') },
	121	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('m', 'p', 'g', '2') },
	122	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('M', 'P', 'E', 'G') },
	123	+ { AV_CODEC_ID_MPEG1VIDEO, MKTAG('P', 'I', 'M', '1') },
	124	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('P', 'I', 'M', '2') },
	125	+ { AV_CODEC_ID_MPEG1VIDEO, MKTAG('V', 'C', 'R', '2') },
	126	+ { AV_CODEC_ID_MPEG1VIDEO, MKTAG( 1 , 0 , 0 , 16) },
	127	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG( 2 , 0 , 0 , 16) },
	128	+ { AV_CODEC_ID_MPEG4, MKTAG( 4 , 0 , 0 , 16) },
	129	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('D', 'V', 'R', ' ') },
	130	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('M', 'M', 'E', 'S') },
	131	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('L', 'M', 'P', '2') }, /* Lead MPEG2 in avi */
	132	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('s', 'l', 'i', 'f') },
	133	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('E', 'M', '2', 'V') },
	134	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('M', '7', '0', '1') }, /* Matrox MPEG2 intra-only */
	135	+ { AV_CODEC_ID_MPEG2VIDEO, MKTAG('m', 'p', 'g', 'v') },
	136	+ { AV_CODEC_ID_MJPEG, MKTAG('M', 'J', 'P', 'G') },
	137	+ { AV_CODEC_ID_MJPEG, MKTAG('L', 'J', 'P', 'G') },
	138	+ { AV_CODEC_ID_MJPEG, MKTAG('d', 'm', 'b', '1') },
	139	+ { AV_CODEC_ID_MJPEG, MKTAG('m', 'j', 'p', 'a') },
	140	+ { AV_CODEC_ID_LJPEG, MKTAG('L', 'J', 'P', 'G') },
	141	+ { AV_CODEC_ID_MJPEG, MKTAG('J', 'P', 'G', 'L') }, /* Pegasus lossless JPEG */
	142	+ { AV_CODEC_ID_JPEGLS, MKTAG('M', 'J', 'L', 'S') }, /* JPEG-LS custom FOURCC for avi - encoder */
	143	+ { AV_CODEC_ID_JPEGLS, MKTAG('M', 'J', 'P', 'G') },
	144	+ { AV_CODEC_ID_MJPEG, MKTAG('M', 'J', 'L', 'S') }, /* JPEG-LS custom FOURCC for avi - decoder */
	145	+ { AV_CODEC_ID_MJPEG, MKTAG('j', 'p', 'e', 'g') },
	146	+ { AV_CODEC_ID_MJPEG, MKTAG('I', 'J', 'P', 'G') },
	147	+ { AV_CODEC_ID_MJPEG, MKTAG('A', 'V', 'R', 'n') },
	148	+ { AV_CODEC_ID_MJPEG, MKTAG('A', 'C', 'D', 'V') },
	149	+ { AV_CODEC_ID_MJPEG, MKTAG('Q', 'I', 'V', 'G') },
	150	+ { AV_CODEC_ID_MJPEG, MKTAG('S', 'L', 'M', 'J') }, /* SL M-JPEG */
	151	+ { AV_CODEC_ID_MJPEG, MKTAG('C', 'J', 'P', 'G') }, /* Creative Webcam JPEG */
	152	+ { AV_CODEC_ID_MJPEG, MKTAG('I', 'J', 'L', 'V') }, /* Intel JPEG Library Video Codec */
	153	+ { AV_CODEC_ID_MJPEG, MKTAG('M', 'V', 'J', 'P') }, /* Midvid JPEG Video Codec */
	154	+ { AV_CODEC_ID_MJPEG, MKTAG('A', 'V', 'I', '1') },
	155	+ { AV_CODEC_ID_MJPEG, MKTAG('A', 'V', 'I', '2') },
	156	+ { AV_CODEC_ID_MJPEG, MKTAG('M', 'T', 'S', 'J') },
	157	+ { AV_CODEC_ID_MJPEG, MKTAG('Z', 'J', 'P', 'G') }, /* Paradigm Matrix M-JPEG Codec */
	158	+ { AV_CODEC_ID_MJPEG, MKTAG('M', 'M', 'J', 'P') },
	159	+ { AV_CODEC_ID_HUFFYUV, MKTAG('H', 'F', 'Y', 'U') },
	160	+ { AV_CODEC_ID_FFVHUFF, MKTAG('F', 'F', 'V', 'H') },
	161	+ { AV_CODEC_ID_CYUV, MKTAG('C', 'Y', 'U', 'V') },
	162	+ { AV_CODEC_ID_RAWVIDEO, MKTAG( 0 , 0 , 0 , 0 ) },
	163	+ { AV_CODEC_ID_RAWVIDEO, MKTAG( 3 , 0 , 0 , 0 ) },
	164	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('I', '4', '2', '0') },
	165	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', 'U', 'Y', '2') },
	166	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '4', '2', '2') },
	167	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('V', '4', '2', '2') },
	168	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', 'U', 'N', 'V') },
	169	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('U', 'Y', 'N', 'V') },
	170	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('U', 'Y', 'N', 'Y') },
	171	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('u', 'y', 'v', '1') },
	172	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('2', 'V', 'u', '1') },
	173	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('2', 'v', 'u', 'y') },
	174	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('y', 'u', 'v', 's') },
	175	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('y', 'u', 'v', '2') },
	176	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('P', '4', '2', '2') },
	177	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', 'V', '1', '2') },
	178	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', 'V', '1', '6') },
	179	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', 'V', '2', '4') },
	180	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('U', 'Y', 'V', 'Y') },
	181	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('V', 'Y', 'U', 'Y') },
	182	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('I', 'Y', 'U', 'V') },
	183	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '8', '0', '0') },
	184	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '8', ' ', ' ') },
	185	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('H', 'D', 'Y', 'C') },
	186	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', 'V', 'U', '9') },
	187	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('V', 'D', 'T', 'Z') }, /* SoftLab-NSK VideoTizer */
	188	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '4', '1', '1') },
	189	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('N', 'V', '1', '2') },
	190	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('N', 'V', '2', '1') },
	191	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '4', '1', 'B') },
	192	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', '4', '2', 'B') },
	193	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', 'U', 'V', '9') },
	194	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('Y', 'V', 'U', '9') },
	195	+ { AV_CODEC_ID_RAWVIDEO, MKTAG('a', 'u', 'v', '2') },
	196	+ { AV_CODEC_ID_FRWU, MKTAG('F', 'R', 'W', 'U') },
	197	+ { AV_CODEC_ID_R10K, MKTAG('R', '1', '0', 'k') },
	198	+ { AV_CODEC_ID_R210, MKTAG('r', '2', '1', '0') },
	199	+ { AV_CODEC_ID_V210, MKTAG('v', '2', '1', '0') },
	200	+ { AV_CODEC_ID_V410, MKTAG('v', '4', '1', '0') },
	201	+ { AV_CODEC_ID_INDEO3, MKTAG('I', 'V', '3', '1') },
	202	+ { AV_CODEC_ID_INDEO3, MKTAG('I', 'V', '3', '2') },
	203	+ { AV_CODEC_ID_INDEO4, MKTAG('I', 'V', '4', '1') },
	204	+ { AV_CODEC_ID_INDEO5, MKTAG('I', 'V', '5', '0') },
	205	+ { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') },
	206	+ { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') },
	207	+ { AV_CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') },
	208	+ { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '0') },
	209	+ { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '1') },
	210	+ { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },
	211	+ { AV_CODEC_ID_VP6F, MKTAG('V', 'P', '6', 'F') },
	212	+ { AV_CODEC_ID_VP6F, MKTAG('F', 'L', 'V', '4') },
	213	+ { AV_CODEC_ID_VP8, MKTAG('V', 'P', '8', '0') },
	214	+ { AV_CODEC_ID_ASV1, MKTAG('A', 'S', 'V', '1') },
	215	+ { AV_CODEC_ID_ASV2, MKTAG('A', 'S', 'V', '2') },
	216	+ { AV_CODEC_ID_VCR1, MKTAG('V', 'C', 'R', '1') },
	217	+ { AV_CODEC_ID_FFV1, MKTAG('F', 'F', 'V', '1') },
	218	+ { AV_CODEC_ID_XAN_WC4, MKTAG('X', 'x', 'a', 'n') },
	219	+ { AV_CODEC_ID_MIMIC, MKTAG('L', 'M', '2', '0') },
	220	+ { AV_CODEC_ID_MSRLE, MKTAG('m', 'r', 'l', 'e') },
	221	+ { AV_CODEC_ID_MSRLE, MKTAG( 1 , 0 , 0 , 0 ) },
	222	+ { AV_CODEC_ID_MSRLE, MKTAG( 2 , 0 , 0 , 0 ) },
	223	+ { AV_CODEC_ID_MSVIDEO1, MKTAG('M', 'S', 'V', 'C') },
	224	+ { AV_CODEC_ID_MSVIDEO1, MKTAG('m', 's', 'v', 'c') },
	225	+ { AV_CODEC_ID_MSVIDEO1, MKTAG('C', 'R', 'A', 'M') },
	226	+ { AV_CODEC_ID_MSVIDEO1, MKTAG('c', 'r', 'a', 'm') },
	227	+ { AV_CODEC_ID_MSVIDEO1, MKTAG('W', 'H', 'A', 'M') },
	228	+ { AV_CODEC_ID_MSVIDEO1, MKTAG('w', 'h', 'a', 'm') },
	229	+ { AV_CODEC_ID_CINEPAK, MKTAG('c', 'v', 'i', 'd') },
	230	+ { AV_CODEC_ID_TRUEMOTION1, MKTAG('D', 'U', 'C', 'K') },
	231	+ { AV_CODEC_ID_TRUEMOTION1, MKTAG('P', 'V', 'E', 'Z') },
	232	+ { AV_CODEC_ID_MSZH, MKTAG('M', 'S', 'Z', 'H') },
	233	+ { AV_CODEC_ID_ZLIB, MKTAG('Z', 'L', 'I', 'B') },
	234	+ { AV_CODEC_ID_SNOW, MKTAG('S', 'N', 'O', 'W') },
	235	+ { AV_CODEC_ID_4XM, MKTAG('4', 'X', 'M', 'V') },
	236	+ { AV_CODEC_ID_FLV1, MKTAG('F', 'L', 'V', '1') },
	237	+ { AV_CODEC_ID_FLASHSV, MKTAG('F', 'S', 'V', '1') },
	238	+ { AV_CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', '1') },
	239	+ { AV_CODEC_ID_TSCC, MKTAG('t', 's', 'c', 'c') },
	240	+ { AV_CODEC_ID_ULTI, MKTAG('U', 'L', 'T', 'I') },
	241	+ { AV_CODEC_ID_VIXL, MKTAG('V', 'I', 'X', 'L') },
	242	+ { AV_CODEC_ID_QPEG, MKTAG('Q', 'P', 'E', 'G') },
	243	+ { AV_CODEC_ID_QPEG, MKTAG('Q', '1', '.', '0') },
	244	+ { AV_CODEC_ID_QPEG, MKTAG('Q', '1', '.', '1') },
	245	+ { AV_CODEC_ID_WMV3, MKTAG('W', 'M', 'V', '3') },
	246	+ { AV_CODEC_ID_WMV3IMAGE, MKTAG('W', 'M', 'V', 'P') },
	247	+ { AV_CODEC_ID_VC1, MKTAG('W', 'V', 'C', '1') },
	248	+ { AV_CODEC_ID_VC1, MKTAG('W', 'M', 'V', 'A') },
	249	+ { AV_CODEC_ID_VC1IMAGE, MKTAG('W', 'V', 'P', '2') },
	250	+ { AV_CODEC_ID_LOCO, MKTAG('L', 'O', 'C', 'O') },
	251	+ { AV_CODEC_ID_WNV1, MKTAG('W', 'N', 'V', '1') },
	252	+ { AV_CODEC_ID_AASC, MKTAG('A', 'A', 'S', 'C') },
	253	+ { AV_CODEC_ID_INDEO2, MKTAG('R', 'T', '2', '1') },
	254	+ { AV_CODEC_ID_FRAPS, MKTAG('F', 'P', 'S', '1') },
	255	+ { AV_CODEC_ID_THEORA, MKTAG('t', 'h', 'e', 'o') },
	256	+ { AV_CODEC_ID_TRUEMOTION2, MKTAG('T', 'M', '2', '0') },
	257	+ { AV_CODEC_ID_CSCD, MKTAG('C', 'S', 'C', 'D') },
	258	+ { AV_CODEC_ID_ZMBV, MKTAG('Z', 'M', 'B', 'V') },
	259	+ { AV_CODEC_ID_KMVC, MKTAG('K', 'M', 'V', 'C') },
	260	+ { AV_CODEC_ID_CAVS, MKTAG('C', 'A', 'V', 'S') },
	261	+ { AV_CODEC_ID_JPEG2000, MKTAG('m', 'j', 'p', '2') },
	262	+ { AV_CODEC_ID_JPEG2000, MKTAG('M', 'J', '2', 'C') },
	263	+ { AV_CODEC_ID_JPEG2000, MKTAG('L', 'J', '2', 'C') },
	264	+ { AV_CODEC_ID_JPEG2000, MKTAG('L', 'J', '2', 'K') },
	265	+ { AV_CODEC_ID_VMNC, MKTAG('V', 'M', 'n', 'c') },
	266	+ { AV_CODEC_ID_TARGA, MKTAG('t', 'g', 'a', ' ') },
	267	+ { AV_CODEC_ID_PNG, MKTAG('M', 'P', 'N', 'G') },
	268	+ { AV_CODEC_ID_PNG, MKTAG('P', 'N', 'G', '1') },
	269	+ { AV_CODEC_ID_CLJR, MKTAG('C', 'L', 'J', 'R') },
	270	+ { AV_CODEC_ID_DIRAC, MKTAG('d', 'r', 'a', 'c') },
	271	+ { AV_CODEC_ID_RPZA, MKTAG('a', 'z', 'p', 'r') },
	272	+ { AV_CODEC_ID_RPZA, MKTAG('R', 'P', 'Z', 'A') },
	273	+ { AV_CODEC_ID_RPZA, MKTAG('r', 'p', 'z', 'a') },
	274	+ { AV_CODEC_ID_SP5X, MKTAG('S', 'P', '5', '4') },
	275	+ { AV_CODEC_ID_AURA, MKTAG('A', 'U', 'R', 'A') },
	276	+ { AV_CODEC_ID_AURA2, MKTAG('A', 'U', 'R', '2') },
	277	+ { AV_CODEC_ID_DPX, MKTAG('d', 'p', 'x', ' ') },
	278	+ { AV_CODEC_ID_KGV1, MKTAG('K', 'G', 'V', '1') },
	279	+ { AV_CODEC_ID_LAGARITH, MKTAG('L', 'A', 'G', 'S') },
	280	+ { AV_CODEC_ID_UTVIDEO, MKTAG('U', 'L', 'R', 'A') },
	281	+ { AV_CODEC_ID_UTVIDEO, MKTAG('U', 'L', 'R', 'G') },
	282	+ { AV_CODEC_ID_UTVIDEO, MKTAG('U', 'L', 'Y', '0') },
	283	+ { AV_CODEC_ID_UTVIDEO, MKTAG('U', 'L', 'Y', '2') },
	284	+ { AV_CODEC_ID_VBLE, MKTAG('V', 'B', 'L', 'E') },
	285	+ { AV_CODEC_ID_DXTORY, MKTAG('x', 't', 'o', 'r') },
	286	+ { AV_CODEC_ID_ZEROCODEC, MKTAG('Z', 'E', 'C', 'O') },
	287	+ { AV_CODEC_ID_MSS1, MKTAG('M', 'S', 'S', '1') },
	288	+ { AV_CODEC_ID_MSA1, MKTAG('M', 'S', 'A', '1') },
	289	+ { AV_CODEC_ID_TSCC2, MKTAG('T', 'S', 'C', '2') },
	290	+ { AV_CODEC_ID_MTS2, MKTAG('M', 'T', 'S', '2') },
	291	+ { AV_CODEC_ID_CLLC, MKTAG('C', 'L', 'L', 'C') },
	292	+ { AV_CODEC_ID_NONE, 0 }
293	293	};
294	294
295	295	const AVCodecTag ff_codec_wav_tags[] = {
296		− { CODEC_ID_PCM_S16LE, 0x0001 },
297		− { CODEC_ID_PCM_U8, 0x0001 }, /* must come after s16le in this list */
298		− { CODEC_ID_PCM_S24LE, 0x0001 },
299		− { CODEC_ID_PCM_S32LE, 0x0001 },
300		− { CODEC_ID_ADPCM_MS, 0x0002 },
301		− { CODEC_ID_PCM_F32LE, 0x0003 },
302		− { CODEC_ID_PCM_F64LE, 0x0003 }, /* must come after f32le in this list */
303		− { CODEC_ID_PCM_ALAW, 0x0006 },
304		− { CODEC_ID_PCM_MULAW, 0x0007 },
305		− { CODEC_ID_WMAVOICE, 0x000A },
306		− { CODEC_ID_ADPCM_IMA_WAV, 0x0011 },
307		− { CODEC_ID_PCM_ZORK, 0x0011 }, /* must come after adpcm_ima_wav in this list */
308		− { CODEC_ID_ADPCM_YAMAHA, 0x0020 },
309		− { CODEC_ID_TRUESPEECH, 0x0022 },
310		− { CODEC_ID_GSM_MS, 0x0031 },
311		− { CODEC_ID_ADPCM_G726, 0x0045 },
312		− { CODEC_ID_MP2, 0x0050 },
313		− { CODEC_ID_MP3, 0x0055 },
314		− { CODEC_ID_AMR_NB, 0x0057 },
315		− { CODEC_ID_AMR_WB, 0x0058 },
316		− { CODEC_ID_ADPCM_IMA_DK4, 0x0061 }, /* rogue format number */
317		− { CODEC_ID_ADPCM_IMA_DK3, 0x0062 }, /* rogue format number */
318		− { CODEC_ID_ADPCM_IMA_WAV, 0x0069 },
319		− { CODEC_ID_VOXWARE, 0x0075 },
320		− { CODEC_ID_AAC, 0x00ff },
321		− { CODEC_ID_SIPR, 0x0130 },
322		− { CODEC_ID_WMAV1, 0x0160 },
323		− { CODEC_ID_WMAV2, 0x0161 },
324		− { CODEC_ID_WMAPRO, 0x0162 },
325		− { CODEC_ID_WMALOSSLESS, 0x0163 },
326		− { CODEC_ID_ADPCM_CT, 0x0200 },
327		− { CODEC_ID_ATRAC3, 0x0270 },
328		− { CODEC_ID_ADPCM_G722, 0x028F },
329		− { CODEC_ID_IMC, 0x0401 },
330		− { CODEC_ID_IAC, 0x0402 },
331		− { CODEC_ID_GSM_MS, 0x1500 },
332		− { CODEC_ID_TRUESPEECH, 0x1501 },
333		− { CODEC_ID_AAC, 0x1600 }, /* ADTS AAC */
334		− { CODEC_ID_AAC_LATM, 0x1602 },
335		− { CODEC_ID_AC3, 0x2000 },
336		− { CODEC_ID_DTS, 0x2001 },
337		− { CODEC_ID_PCM_MULAW, 0x6c75 },
338		− { CODEC_ID_AAC, 0x706d },
339		− { CODEC_ID_AAC, 0x4143 },
340		− { CODEC_ID_SPEEX, 0xA109 },
341		− { CODEC_ID_FLAC, 0xF1AC },
342		− { CODEC_ID_ADPCM_SWF, ('S'<<8)+'F' },
343		− { CODEC_ID_VORBIS, ('V'<<8)+'o' }, //HACK/FIXME, does vorbis in WAV/AVI have an (in)official id?
	296	+ { AV_CODEC_ID_PCM_S16LE, 0x0001 },
	297	+ { AV_CODEC_ID_PCM_U8, 0x0001 }, /* must come after s16le in this list */
	298	+ { AV_CODEC_ID_PCM_S24LE, 0x0001 },
	299	+ { AV_CODEC_ID_PCM_S32LE, 0x0001 },
	300	+ { AV_CODEC_ID_ADPCM_MS, 0x0002 },
	301	+ { AV_CODEC_ID_PCM_F32LE, 0x0003 },
	302	+ { AV_CODEC_ID_PCM_F64LE, 0x0003 }, /* must come after f32le in this list */
	303	+ { AV_CODEC_ID_PCM_ALAW, 0x0006 },
	304	+ { AV_CODEC_ID_PCM_MULAW, 0x0007 },
	305	+ { AV_CODEC_ID_WMAVOICE, 0x000A },
	306	+ { AV_CODEC_ID_ADPCM_IMA_WAV, 0x0011 },
	307	+ { AV_CODEC_ID_PCM_ZORK, 0x0011 }, /* must come after adpcm_ima_wav in this list */
	308	+ { AV_CODEC_ID_ADPCM_YAMAHA, 0x0020 },
	309	+ { AV_CODEC_ID_TRUESPEECH, 0x0022 },
	310	+ { AV_CODEC_ID_GSM_MS, 0x0031 },
	311	+ { AV_CODEC_ID_ADPCM_G726, 0x0045 },
	312	+ { AV_CODEC_ID_MP2, 0x0050 },
	313	+ { AV_CODEC_ID_MP3, 0x0055 },
	314	+ { AV_CODEC_ID_AMR_NB, 0x0057 },
	315	+ { AV_CODEC_ID_AMR_WB, 0x0058 },
	316	+ { AV_CODEC_ID_ADPCM_IMA_DK4, 0x0061 }, /* rogue format number */
	317	+ { AV_CODEC_ID_ADPCM_IMA_DK3, 0x0062 }, /* rogue format number */
	318	+ { AV_CODEC_ID_ADPCM_IMA_WAV, 0x0069 },
	319	+ { AV_CODEC_ID_VOXWARE, 0x0075 },
	320	+ { AV_CODEC_ID_AAC, 0x00ff },
	321	+ { AV_CODEC_ID_SIPR, 0x0130 },
	322	+ { AV_CODEC_ID_WMAV1, 0x0160 },
	323	+ { AV_CODEC_ID_WMAV2, 0x0161 },
	324	+ { AV_CODEC_ID_WMAPRO, 0x0162 },
	325	+ { AV_CODEC_ID_WMALOSSLESS, 0x0163 },
	326	+ { AV_CODEC_ID_ADPCM_CT, 0x0200 },
	327	+ { AV_CODEC_ID_ATRAC3, 0x0270 },
	328	+ { AV_CODEC_ID_ADPCM_G722, 0x028F },
	329	+ { AV_CODEC_ID_IMC, 0x0401 },
	330	+ { AV_CODEC_ID_IAC, 0x0402 },
	331	+ { AV_CODEC_ID_GSM_MS, 0x1500 },
	332	+ { AV_CODEC_ID_TRUESPEECH, 0x1501 },
	333	+ { AV_CODEC_ID_AAC, 0x1600 }, /* ADTS AAC */
	334	+ { AV_CODEC_ID_AAC_LATM, 0x1602 },
	335	+ { AV_CODEC_ID_AC3, 0x2000 },
	336	+ { AV_CODEC_ID_DTS, 0x2001 },
	337	+ { AV_CODEC_ID_PCM_MULAW, 0x6c75 },
	338	+ { AV_CODEC_ID_AAC, 0x706d },
	339	+ { AV_CODEC_ID_AAC, 0x4143 },
	340	+ { AV_CODEC_ID_SPEEX, 0xA109 },
	341	+ { AV_CODEC_ID_FLAC, 0xF1AC },
	342	+ { AV_CODEC_ID_ADPCM_SWF, ('S'<<8)+'F' },
	343	+ { AV_CODEC_ID_VORBIS, ('V'<<8)+'o' }, //HACK/FIXME, does vorbis in WAV/AVI have an (in)official id?
344	344
345	345	/* FIXME: All of the IDs below are not 16 bit and thus illegal. */
346	346	// for NuppelVideo (nuv.c)
347		− { CODEC_ID_PCM_S16LE, MKTAG('R', 'A', 'W', 'A') },
348		− { CODEC_ID_MP3, MKTAG('L', 'A', 'M', 'E') },
349		− { CODEC_ID_MP3, MKTAG('M', 'P', '3', ' ') },
350		− { CODEC_ID_NONE, 0 },
	347	+ { AV_CODEC_ID_PCM_S16LE, MKTAG('R', 'A', 'W', 'A') },
	348	+ { AV_CODEC_ID_MP3, MKTAG('L', 'A', 'M', 'E') },
	349	+ { AV_CODEC_ID_MP3, MKTAG('M', 'P', '3', ' ') },
	350	+ { AV_CODEC_ID_NONE, 0 },
351	351	};
352	352
353	353	const AVMetadataConv ff_riff_info_conv[] = {
@@ -422,7 +422,7 @@ int ff_put_wav_header(AVIOContext pb, AVCodecContext enc) · 68 unmodified lines
422	422	}
423	423	avio_wl16(pb, enc->channels);
424	424	avio_wl32(pb, enc->sample_rate);
425		− if (enc->codec_id == CODEC_ID_MP2 \|\| enc->codec_id == CODEC_ID_MP3 \|\| enc->codec_id == CODEC_ID_GSM_MS) {
	425	+ if (enc->codec_id == AV_CODEC_ID_MP2 \|\| enc->codec_id == AV_CODEC_ID_MP3 \|\| enc->codec_id == AV_CODEC_ID_GSM_MS) {
426	426	bps = 0;
427	427	} else {
428	428	if (!(bps = av_get_bits_per_sample(enc->codec_id))) {
@@ -436,23 +436,23 @@ int ff_put_wav_header(AVIOContext pb, AVCodecContext enc) · 7 unmodified lines
436	436	av_log(enc, AV_LOG_WARNING, "requested bits_per_coded_sample (%d) and actually stored (%d) differ\n", enc->bits_per_coded_sample, bps);
437	437	}
438	438
439		− if (enc->codec_id == CODEC_ID_MP2 \|\| enc->codec_id == CODEC_ID_MP3) {
	439	+ if (enc->codec_id == AV_CODEC_ID_MP2 \|\| enc->codec_id == AV_CODEC_ID_MP3) {
440	440	/* this is wrong, but it seems many demuxers do not work if this is set
441	441	correctly */
442	442	blkalign = frame_size;
443	443	//blkalign = 144 * enc->bit_rate/enc->sample_rate;
444		− } else if (enc->codec_id == CODEC_ID_AC3) {
	444	+ } else if (enc->codec_id == AV_CODEC_ID_AC3) {
445	445	blkalign = 3840; //maximum bytes per frame
446	446	} else if (enc->block_align != 0) { /* specified by the codec */
447	447	blkalign = enc->block_align;
448	448	} else
449	449	blkalign = bps * enc->channels / av_gcd(8, bps);
450		− if (enc->codec_id == CODEC_ID_PCM_U8 \|\|
451		− enc->codec_id == CODEC_ID_PCM_S24LE \|\|
452		− enc->codec_id == CODEC_ID_PCM_S32LE \|\|
453		− enc->codec_id == CODEC_ID_PCM_F32LE \|\|
454		− enc->codec_id == CODEC_ID_PCM_F64LE \|\|
455		− enc->codec_id == CODEC_ID_PCM_S16LE) {
	450	+ if (enc->codec_id == AV_CODEC_ID_PCM_U8 \|\|
	451	+ enc->codec_id == AV_CODEC_ID_PCM_S24LE \|\|
	452	+ enc->codec_id == AV_CODEC_ID_PCM_S32LE \|\|
	453	+ enc->codec_id == AV_CODEC_ID_PCM_F32LE \|\|
	454	+ enc->codec_id == AV_CODEC_ID_PCM_F64LE \|\|
	455	+ enc->codec_id == AV_CODEC_ID_PCM_S16LE) {
456	456	bytespersec = enc->sample_rate * blkalign;
457	457	} else {
458	458	bytespersec = enc->bit_rate / 8;
@@ -460,14 +460,14 @@ int ff_put_wav_header(AVIOContext pb, AVCodecContext enc) · 1 unmodified line
460	460	avio_wl32(pb, bytespersec); /* bytes per second */
461	461	avio_wl16(pb, blkalign); /* block align */
462	462	avio_wl16(pb, bps); /* bits per sample */
463		− if (enc->codec_id == CODEC_ID_MP3) {
	463	+ if (enc->codec_id == AV_CODEC_ID_MP3) {
464	464	hdrsize += 12;
465	465	bytestream_put_le16(&riff_extradata, 1); /* wID */
466	466	bytestream_put_le32(&riff_extradata, 2); /* fdwFlags */
467	467	bytestream_put_le16(&riff_extradata, 1152); /* nBlockSize */
468	468	bytestream_put_le16(&riff_extradata, 1); /* nFramesPerBlock */
469	469	bytestream_put_le16(&riff_extradata, 1393); /* nCodecDelay */
470		− } else if (enc->codec_id == CODEC_ID_MP2) {
	470	+ } else if (enc->codec_id == AV_CODEC_ID_MP2) {
471	471	hdrsize += 22;
472	472	bytestream_put_le16(&riff_extradata, 2); /* fwHeadLayer */
473	473	bytestream_put_le32(&riff_extradata, enc->bit_rate); /* dwHeadBitrate */
@@ -477,7 +477,7 @@ int ff_put_wav_header(AVIOContext pb, AVCodecContext enc) · 3 unmodified lines
477	477	bytestream_put_le16(&riff_extradata, 16); /* fwHeadFlags */
478	478	bytestream_put_le32(&riff_extradata, 0); /* dwPTSLow */
479	479	bytestream_put_le32(&riff_extradata, 0); /* dwPTSHigh */
480		− } else if (enc->codec_id == CODEC_ID_GSM_MS \|\| enc->codec_id == CODEC_ID_ADPCM_IMA_WAV) {
	480	+ } else if (enc->codec_id == AV_CODEC_ID_GSM_MS \|\| enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
481	481	hdrsize += 2;
482	482	bytestream_put_le16(&riff_extradata, frame_size); /* wSamplesPerBlock */
483	483	} else if(enc->extradata_size){
@@ -581,36 +581,36 @@ int ff_get_wav_header(AVIOContext pb, AVCodecContext codec, int size) · 97 unmodified lines
581	581	avio_skip(pb, size);
582	582	}
583	583	codec->codec_id = ff_wav_codec_get_id(id, codec->bits_per_coded_sample);
584		− if (codec->codec_id == CODEC_ID_AAC_LATM) {
	584	+ if (codec->codec_id == AV_CODEC_ID_AAC_LATM) {
585	585	/* channels and sample_rate values are those prior to applying SBR and/or PS */
586	586	codec->channels = 0;
587	587	codec->sample_rate = 0;
588	588	}
589	589	/* override bits_per_coded_sample for G.726 */
590		− if (codec->codec_id == CODEC_ID_ADPCM_G726)
	590	+ if (codec->codec_id == AV_CODEC_ID_ADPCM_G726)
591	591	codec->bits_per_coded_sample = codec->bit_rate / codec->sample_rate;
592	592
593	593	return 0;
594	594	}
595	595
596	596
597		−enum CodecID ff_wav_codec_get_id(unsigned int tag, int bps)
	597	+enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
598	598	{
599		− enum CodecID id;
	599	+ enum AVCodecID id;
600	600	id = ff_codec_get_id(ff_codec_wav_tags, tag);
601	601	if (id <= 0)
602	602	return id;
603	603	/* handle specific u8 codec */
604		− if (id == CODEC_ID_PCM_S16LE && bps == 8)
605		− id = CODEC_ID_PCM_U8;
606		− if (id == CODEC_ID_PCM_S16LE && bps == 24)
607		− id = CODEC_ID_PCM_S24LE;
608		− if (id == CODEC_ID_PCM_S16LE && bps == 32)
609		− id = CODEC_ID_PCM_S32LE;
610		− if (id == CODEC_ID_PCM_F32LE && bps == 64)
611		− id = CODEC_ID_PCM_F64LE;
612		− if (id == CODEC_ID_ADPCM_IMA_WAV && bps == 8)
613		− id = CODEC_ID_PCM_ZORK;
	604	+ if (id == AV_CODEC_ID_PCM_S16LE && bps == 8)
	605	+ id = AV_CODEC_ID_PCM_U8;
	606	+ if (id == AV_CODEC_ID_PCM_S16LE && bps == 24)
	607	+ id = AV_CODEC_ID_PCM_S24LE;
	608	+ if (id == AV_CODEC_ID_PCM_S16LE && bps == 32)
	609	+ id = AV_CODEC_ID_PCM_S32LE;
	610	+ if (id == AV_CODEC_ID_PCM_F32LE && bps == 64)
	611	+ id = AV_CODEC_ID_PCM_F64LE;
	612	+ if (id == AV_CODEC_ID_ADPCM_IMA_WAV && bps == 8)
	613	+ id = AV_CODEC_ID_PCM_ZORK;
614	614	return id;
615	615	}
616	616

libavformat/riff.h+3−3

@@ -48,14 +48,14 @@ int ff_get_bmp_header(AVIOContext pb, AVStream st); · 47 unmodified lines
48	48
49	49	void ff_put_bmp_header(AVIOContext pb, AVCodecContext enc, const AVCodecTag *tags, int for_asf);
50	50	int ff_put_wav_header(AVIOContext pb, AVCodecContext enc);
51		−enum CodecID ff_wav_codec_get_id(unsigned int tag, int bps);
	51	+enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps);
52	52	int ff_get_wav_header(AVIOContext pb, AVCodecContext codec, int size);
53	53
54	54	extern const AVCodecTag ff_codec_bmp_tags[];
55	55	extern const AVCodecTag ff_codec_wav_tags[];
56	56
57		−unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id);
58		−enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag);
	57	+unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id);
	58	+enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag);
59	59	void ff_parse_specific_params(AVCodecContext stream, int au_rate, int au_ssize, int au_scale);
60	60
61	61	int ff_read_riff_info(AVFormatContext *s, int64_t size);

libavformat/rl2.c+2−2

@@ -114,7 +114,7 @@ static av_cold int rl2_read_header(AVFormatContext *s) · 113 unmodified lines
114	114	return AVERROR(ENOMEM);
115	115
116	116	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
117		− st->codec->codec_id = CODEC_ID_RL2;
	117	+ st->codec->codec_id = AV_CODEC_ID_RL2;
118	118	st->codec->codec_tag = 0; /* no fourcc */
119	119	st->codec->width = 320;
120	120	st->codec->height = 200;
@@ -143,7 +143,7 @@ static av_cold int rl2_read_header(AVFormatContext *s) · 22 unmodified lines
143	143	if (!st)
144	144	return AVERROR(ENOMEM);
145	145	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
146		− st->codec->codec_id = CODEC_ID_PCM_U8;
	146	+ st->codec->codec_id = AV_CODEC_ID_PCM_U8;
147	147	st->codec->codec_tag = 1;
148	148	st->codec->channels = channels;
149	149	st->codec->bits_per_coded_sample = 8;

libavformat/rm.c+15−15

@@ -29,19 +29,19 @@ const char * const ff_rm_metadata[4] = { · 28 unmodified lines
29	29	};
30	30
31	31	const AVCodecTag ff_rm_codec_tags[] = {
32		− { CODEC_ID_RV10, MKTAG('R','V','1','0') },
33		− { CODEC_ID_RV20, MKTAG('R','V','2','0') },
34		− { CODEC_ID_RV20, MKTAG('R','V','T','R') },
35		− { CODEC_ID_RV30, MKTAG('R','V','3','0') },
36		− { CODEC_ID_RV40, MKTAG('R','V','4','0') },
37		− { CODEC_ID_AC3, MKTAG('d','n','e','t') },
38		− { CODEC_ID_RA_144, MKTAG('l','p','c','J') },
39		− { CODEC_ID_RA_288, MKTAG('2','8','_','8') },
40		− { CODEC_ID_COOK, MKTAG('c','o','o','k') },
41		− { CODEC_ID_ATRAC3, MKTAG('a','t','r','c') },
42		− { CODEC_ID_SIPR, MKTAG('s','i','p','r') },
43		− { CODEC_ID_AAC, MKTAG('r','a','a','c') },
44		− { CODEC_ID_AAC, MKTAG('r','a','c','p') },
45		− { CODEC_ID_RALF, MKTAG('L','S','D',':') },
46		− { CODEC_ID_NONE },
	32	+ { AV_CODEC_ID_RV10, MKTAG('R','V','1','0') },
	33	+ { AV_CODEC_ID_RV20, MKTAG('R','V','2','0') },
	34	+ { AV_CODEC_ID_RV20, MKTAG('R','V','T','R') },
	35	+ { AV_CODEC_ID_RV30, MKTAG('R','V','3','0') },
	36	+ { AV_CODEC_ID_RV40, MKTAG('R','V','4','0') },
	37	+ { AV_CODEC_ID_AC3, MKTAG('d','n','e','t') },
	38	+ { AV_CODEC_ID_RA_144, MKTAG('l','p','c','J') },
	39	+ { AV_CODEC_ID_RA_288, MKTAG('2','8','_','8') },
	40	+ { AV_CODEC_ID_COOK, MKTAG('c','o','o','k') },
	41	+ { AV_CODEC_ID_ATRAC3, MKTAG('a','t','r','c') },
	42	+ { AV_CODEC_ID_SIPR, MKTAG('s','i','p','r') },
	43	+ { AV_CODEC_ID_AAC, MKTAG('r','a','a','c') },
	44	+ { AV_CODEC_ID_AAC, MKTAG('r','a','c','p') },
	45	+ { AV_CODEC_ID_RALF, MKTAG('L','S','D',':') },
	46	+ { AV_CODEC_ID_NONE },
47	47	};

libavformat/rmdec.c+11−11

@@ -155,7 +155,7 @@ static int rm_read_audio_stream_info(AVFormatContext s, AVIOContext pb, · 154 unmodified lines
155	155	st->codec->sample_rate = 8000;
156	156	st->codec->channels = 1;
157	157	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
158		− st->codec->codec_id = CODEC_ID_RA_144;
	158	+ st->codec->codec_id = AV_CODEC_ID_RA_144;
159	159	ast->deint_id = DEINT_ID_INT0;
160	160	} else {
161	161	int flavor, sub_packet_h, coded_framesize, sub_packet_size;
@@ -196,18 +196,18 @@ static int rm_read_audio_stream_info(AVFormatContext s, AVIOContext pb, · 34 unmodified lines
196	196	st->codec->codec_tag);
197	197
198	198	switch (st->codec->codec_id) {
199		− case CODEC_ID_AC3:
	199	+ case AV_CODEC_ID_AC3:
200	200	st->need_parsing = AVSTREAM_PARSE_FULL;
201	201	break;
202		− case CODEC_ID_RA_288:
	202	+ case AV_CODEC_ID_RA_288:
203	203	st->codec->extradata_size= 0;
204	204	ast->audio_framesize = st->codec->block_align;
205	205	st->codec->block_align = coded_framesize;
206	206	break;
207		− case CODEC_ID_COOK:
	207	+ case AV_CODEC_ID_COOK:
208	208	st->need_parsing = AVSTREAM_PARSE_HEADERS;
209		− case CODEC_ID_ATRAC3:
210		− case CODEC_ID_SIPR:
	209	+ case AV_CODEC_ID_ATRAC3:
	210	+ case AV_CODEC_ID_SIPR:
211	211	avio_rb16(pb); avio_r8(pb);
212	212	if (version == 5)
213	213	avio_r8(pb);
@@ -218,7 +218,7 @@ static int rm_read_audio_stream_info(AVFormatContext s, AVIOContext pb, · 4 unmodified lines
218	218	}
219	219
220	220	ast->audio_framesize = st->codec->block_align;
221		− if (st->codec->codec_id == CODEC_ID_SIPR) {
	221	+ if (st->codec->codec_id == AV_CODEC_ID_SIPR) {
222	222	if (flavor > 3) {
223	223	av_log(s, AV_LOG_ERROR, "bad SIPR file flavor %d\n",
224	224	flavor);
@@ -235,7 +235,7 @@ static int rm_read_audio_stream_info(AVFormatContext s, AVIOContext pb, · 10 unmodified lines
235	235	if ((ret = rm_read_extradata(pb, st->codec, codecdata_length)) < 0)
236	236	return ret;
237	237	break;
238		− case CODEC_ID_AAC:
	238	+ case AV_CODEC_ID_AAC:
239	239	avio_rb16(pb); avio_r8(pb);
240	240	if (version == 5)
241	241	avio_r8(pb);
@@ -331,7 +331,7 @@ ff_rm_read_mdpr_codecdata (AVFormatContext s, AVIOContext pb, · 89 unmodified lines
331	331	st->codec->codec_id = ff_codec_get_id(ff_rm_codec_tags,
332	332	st->codec->codec_tag);
333	333	// av_log(s, AV_LOG_DEBUG, "%X %X\n", st->codec->codec_tag, MKTAG('R', 'V', '2', '0'));
334		− if (st->codec->codec_id == CODEC_ID_NONE)
	334	+ if (st->codec->codec_id == AV_CODEC_ID_NONE)
335	335	goto fail1;
336	336	st->codec->width = avio_rb16(pb);
337	337	st->codec->height = avio_rb16(pb);
@@ -710,7 +710,7 @@ rm_ac3_swap_bytes (AVStream st, AVPacket pkt) · 372 unmodified lines
710	710	uint8_t *ptr;
711	711	int j;
712	712
713		− if (st->codec->codec_id == CODEC_ID_AC3) {
	713	+ if (st->codec->codec_id == AV_CODEC_ID_AC3) {
714	714	ptr = pkt->data;
715	715	for (j=0;j<pkt->size;j+=2) {
716	716	FFSWAP(int, ptr[0], ptr[1]);
@@ -817,7 +817,7 @@ ff_rm_parse_packet (AVFormatContext s, AVIOContext pb, · 100 unmodified lines
817	817
818	818	#if 0
819	819	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
820		− if(st->codec->codec_id == CODEC_ID_RV20){
	820	+ if(st->codec->codec_id == AV_CODEC_ID_RV20){
821	821	int seq= 128*(pkt->data[2]&0x7F) + (pkt->data[3]>>1);
822	822	av_log(s, AV_LOG_DEBUG, "%d %"PRId64" %d\n", timestamp, timestamp*512LL/25, seq);
823	823

libavformat/rmenc.c+5−5

@@ -242,7 +242,7 @@ static int rv10_write_header(AVFormatContext *ctx, · 241 unmodified lines
242	242	/* video codec info */
243	243	avio_wb32(s,34); /* size */
244	244	ffio_wfourcc(s, "VIDO");
245		− if(stream->enc->codec_id == CODEC_ID_RV10)
	245	+ if(stream->enc->codec_id == AV_CODEC_ID_RV10)
246	246	ffio_wfourcc(s,"RV10");
247	247	else
248	248	ffio_wfourcc(s,"RV20");
@@ -256,7 +256,7 @@ static int rv10_write_header(AVFormatContext *ctx, · 7 unmodified lines
256	256	/* Seems to be the codec version: only use basic H263. The next
257	257	versions seems to add a diffential DC coding as in
258	258	MPEG... nothing new under the sun */
259		− if(stream->enc->codec_id == CODEC_ID_RV10)
	259	+ if(stream->enc->codec_id == AV_CODEC_ID_RV10)
260	260	avio_wb32(s,0x10000000);
261	261	else
262	262	avio_wb32(s,0x20103001);
@@ -359,7 +359,7 @@ static int rm_write_audio(AVFormatContext s, const uint8_t buf, int size, int · 96 unmodified lines
359	359
360	360	write_packet_header(s, stream, size, !!(flags & AV_PKT_FLAG_KEY));
361	361
362		− if (stream->enc->codec_id == CODEC_ID_AC3) {
	362	+ if (stream->enc->codec_id == AV_CODEC_ID_AC3) {
363	363	/* for AC-3, the words seem to be reversed */
364	364	for(i=0;i<size;i+=2) {
365	365	buf1[i] = buf[i+1];
@@ -466,8 +466,8 @@ AVOutputFormat ff_rm_muxer = { · 100 unmodified lines
466	466	.mime_type = "application/vnd.rn-realmedia",
467	467	.extensions = "rm,ra",
468	468	.priv_data_size = sizeof(RMMuxContext),
469		− .audio_codec = CODEC_ID_AC3,
470		− .video_codec = CODEC_ID_RV10,
	469	+ .audio_codec = AV_CODEC_ID_AC3,
	470	+ .video_codec = AV_CODEC_ID_RV10,
471	471	.write_header = rm_write_header,
472	472	.write_packet = rm_write_packet,
473	473	.write_trailer = rm_write_trailer,

libavformat/rpl.c+9−9

@@ -156,24 +156,24 @@ static int rpl_read_header(AVFormatContext *s) · 155 unmodified lines
156	156	switch (vst->codec->codec_tag) {
157	157	#if 0
158	158	case 122:
159		− vst->codec->codec_id = CODEC_ID_ESCAPE122;
	159	+ vst->codec->codec_id = AV_CODEC_ID_ESCAPE122;
160	160	break;
161	161	#endif
162	162	case 124:
163		− vst->codec->codec_id = CODEC_ID_ESCAPE124;
	163	+ vst->codec->codec_id = AV_CODEC_ID_ESCAPE124;
164	164	// The header is wrong here, at least sometimes
165	165	vst->codec->bits_per_coded_sample = 16;
166	166	break;
167	167	#if 0
168	168	case 130:
169		− vst->codec->codec_id = CODEC_ID_ESCAPE130;
	169	+ vst->codec->codec_id = AV_CODEC_ID_ESCAPE130;
170	170	break;
171	171	#endif
172	172	default:
173	173	av_log(s, AV_LOG_WARNING,
174	174	"RPL video format %i not supported yet!\n",
175	175	vst->codec->codec_tag);
176		− vst->codec->codec_id = CODEC_ID_NONE;
	176	+ vst->codec->codec_id = AV_CODEC_ID_NONE;
177	177	}
178	178
179	179	// Audio headers
@@ -199,12 +199,12 @@ static int rpl_read_header(AVFormatContext *s) · 19 unmodified lines
199	199	ast->codec->bits_per_coded_sample *
200	200	ast->codec->channels;
201	201
202		− ast->codec->codec_id = CODEC_ID_NONE;
	202	+ ast->codec->codec_id = AV_CODEC_ID_NONE;
203	203	switch (audio_format) {
204	204	case 1:
205	205	if (ast->codec->bits_per_coded_sample == 16) {
206	206	// 16-bit audio is always signed
207		− ast->codec->codec_id = CODEC_ID_PCM_S16LE;
	207	+ ast->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
208	208	break;
209	209	}
210	210	// There are some other formats listed as legal per the spec;
@@ -214,15 +214,15 @@ static int rpl_read_header(AVFormatContext *s) · 3 unmodified lines
214	214	if (ast->codec->bits_per_coded_sample == 8) {
215	215	// The samples with this kind of audio that I have
216	216	// are all unsigned.
217		− ast->codec->codec_id = CODEC_ID_PCM_U8;
	217	+ ast->codec->codec_id = AV_CODEC_ID_PCM_U8;
218	218	break;
219	219	} else if (ast->codec->bits_per_coded_sample == 4) {
220		− ast->codec->codec_id = CODEC_ID_ADPCM_IMA_EA_SEAD;
	220	+ ast->codec->codec_id = AV_CODEC_ID_ADPCM_IMA_EA_SEAD;
221	221	break;
222	222	}
223	223	break;
224	224	}
225		− if (ast->codec->codec_id == CODEC_ID_NONE) {
	225	+ if (ast->codec->codec_id == AV_CODEC_ID_NONE) {
226	226	av_log(s, AV_LOG_WARNING,
227	227	"RPL audio format %i not supported yet!\n",
228	228	audio_format);

libavformat/rso.c+3−3

@@ -24,7 +24,7 @@ · 23 unmodified lines
24	24	#include "rso.h"
25	25
26	26	const AVCodecTag ff_codec_rso_tags[] = {
27		− { CODEC_ID_PCM_U8, 0x0100 },
28		− { CODEC_ID_ADPCM_IMA_WAV, 0x0101 },
29		− { CODEC_ID_NONE, 0 },
	27	+ { AV_CODEC_ID_PCM_U8, 0x0100 },
	28	+ { AV_CODEC_ID_ADPCM_IMA_WAV, 0x0101 },
	29	+ { AV_CODEC_ID_NONE, 0 },
30	30	};

libavformat/rsodec.c+2−2

@@ -32,7 +32,7 @@ static int rso_read_header(AVFormatContext *s) · 31 unmodified lines
32	32	AVIOContext *pb = s->pb;
33	33	int id, rate, bps;
34	34	unsigned int size;
35		− enum CodecID codec;
	35	+ enum AVCodecID codec;
36	36	AVStream *st;
37	37
38	38	id = avio_rb16(pb);
@@ -42,7 +42,7 @@ static int rso_read_header(AVFormatContext *s) · 3 unmodified lines
42	42
43	43	codec = ff_codec_get_id(ff_codec_rso_tags, id);
44	44
45		− if (codec == CODEC_ID_ADPCM_IMA_WAV) {
	45	+ if (codec == AV_CODEC_ID_ADPCM_IMA_WAV) {
46	46	av_log(s, AV_LOG_ERROR, "ADPCM in RSO not implemented\n");
47	47	return AVERROR_PATCHWELCOME;
48	48	}

libavformat/rsoenc.c+3−3

@@ -49,7 +49,7 @@ static int rso_write_header(AVFormatContext *s) · 48 unmodified lines
49	49	return AVERROR_INVALIDDATA;
50	50	}
51	51
52		− if (enc->codec_id == CODEC_ID_ADPCM_IMA_WAV) {
	52	+ if (enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
53	53	av_log(s, AV_LOG_ERROR, "ADPCM in RSO not implemented\n");
54	54	return AVERROR_PATCHWELCOME;
55	55	}
@@ -104,8 +104,8 @@ AVOutputFormat ff_rso_muxer = { · 48 unmodified lines
104	104	.name = "rso",
105	105	.long_name = NULL_IF_CONFIG_SMALL("Lego Mindstorms RSO"),
106	106	.extensions = "rso",
107		− .audio_codec = CODEC_ID_PCM_U8,
108		− .video_codec = CODEC_ID_NONE,
	107	+ .audio_codec = AV_CODEC_ID_PCM_U8,
	108	+ .video_codec = AV_CODEC_ID_NONE,
109	109	.write_header = rso_write_header,
110	110	.write_packet = rso_write_packet,
111	111	.write_trailer = rso_write_trailer,

libavformat/rtp.c+33−33

@@ -37,38 +37,38 @@ static const struct · 36 unmodified lines
37	37	int pt;
38	38	const char enc_name[6];
39	39	enum AVMediaType codec_type;
40		− enum CodecID codec_id;
	40	+ enum AVCodecID codec_id;
41	41	int clock_rate;
42	42	int audio_channels;
43	43	} AVRtpPayloadTypes[]=
44	44	{
45		− {0, "PCMU", AVMEDIA_TYPE_AUDIO, CODEC_ID_PCM_MULAW, 8000, 1},
46		− {3, "GSM", AVMEDIA_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
47		− {4, "G723", AVMEDIA_TYPE_AUDIO, CODEC_ID_G723_1, 8000, 1},
48		− {5, "DVI4", AVMEDIA_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
49		− {6, "DVI4", AVMEDIA_TYPE_AUDIO, CODEC_ID_NONE, 16000, 1},
50		− {7, "LPC", AVMEDIA_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
51		− {8, "PCMA", AVMEDIA_TYPE_AUDIO, CODEC_ID_PCM_ALAW, 8000, 1},
52		− {9, "G722", AVMEDIA_TYPE_AUDIO, CODEC_ID_ADPCM_G722, 8000, 1},
53		− {10, "L16", AVMEDIA_TYPE_AUDIO, CODEC_ID_PCM_S16BE, 44100, 2},
54		− {11, "L16", AVMEDIA_TYPE_AUDIO, CODEC_ID_PCM_S16BE, 44100, 1},
55		− {12, "QCELP", AVMEDIA_TYPE_AUDIO, CODEC_ID_QCELP, 8000, 1},
56		− {13, "CN", AVMEDIA_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
57		− {14, "MPA", AVMEDIA_TYPE_AUDIO, CODEC_ID_MP2, -1, -1},
58		− {14, "MPA", AVMEDIA_TYPE_AUDIO, CODEC_ID_MP3, -1, -1},
59		− {15, "G728", AVMEDIA_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
60		− {16, "DVI4", AVMEDIA_TYPE_AUDIO, CODEC_ID_NONE, 11025, 1},
61		− {17, "DVI4", AVMEDIA_TYPE_AUDIO, CODEC_ID_NONE, 22050, 1},
62		− {18, "G729", AVMEDIA_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
63		− {25, "CelB", AVMEDIA_TYPE_VIDEO, CODEC_ID_NONE, 90000, -1},
64		− {26, "JPEG", AVMEDIA_TYPE_VIDEO, CODEC_ID_MJPEG, 90000, -1},
65		− {28, "nv", AVMEDIA_TYPE_VIDEO, CODEC_ID_NONE, 90000, -1},
66		− {31, "H261", AVMEDIA_TYPE_VIDEO, CODEC_ID_H261, 90000, -1},
67		− {32, "MPV", AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG1VIDEO, 90000, -1},
68		− {32, "MPV", AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO, 90000, -1},
69		− {33, "MP2T", AVMEDIA_TYPE_DATA, CODEC_ID_MPEG2TS, 90000, -1},
70		− {34, "H263", AVMEDIA_TYPE_VIDEO, CODEC_ID_H263, 90000, -1},
71		− {-1, "", AVMEDIA_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
	45	+ {0, "PCMU", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_PCM_MULAW, 8000, 1},
	46	+ {3, "GSM", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_NONE, 8000, 1},
	47	+ {4, "G723", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_G723_1, 8000, 1},
	48	+ {5, "DVI4", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_NONE, 8000, 1},
	49	+ {6, "DVI4", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_NONE, 16000, 1},
	50	+ {7, "LPC", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_NONE, 8000, 1},
	51	+ {8, "PCMA", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_PCM_ALAW, 8000, 1},
	52	+ {9, "G722", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_ADPCM_G722, 8000, 1},
	53	+ {10, "L16", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_PCM_S16BE, 44100, 2},
	54	+ {11, "L16", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_PCM_S16BE, 44100, 1},
	55	+ {12, "QCELP", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_QCELP, 8000, 1},
	56	+ {13, "CN", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_NONE, 8000, 1},
	57	+ {14, "MPA", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP2, -1, -1},
	58	+ {14, "MPA", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3, -1, -1},
	59	+ {15, "G728", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_NONE, 8000, 1},
	60	+ {16, "DVI4", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_NONE, 11025, 1},
	61	+ {17, "DVI4", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_NONE, 22050, 1},
	62	+ {18, "G729", AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_NONE, 8000, 1},
	63	+ {25, "CelB", AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_NONE, 90000, -1},
	64	+ {26, "JPEG", AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MJPEG, 90000, -1},
	65	+ {28, "nv", AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_NONE, 90000, -1},
	66	+ {31, "H261", AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H261, 90000, -1},
	67	+ {32, "MPV", AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG1VIDEO, 90000, -1},
	68	+ {32, "MPV", AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO, 90000, -1},
	69	+ {33, "MP2T", AVMEDIA_TYPE_DATA, AV_CODEC_ID_MPEG2TS, 90000, -1},
	70	+ {34, "H263", AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H263, 90000, -1},
	71	+ {-1, "", AVMEDIA_TYPE_UNKNOWN, AV_CODEC_ID_NONE, -1, -1}
72	72	};
73	73
74	74	int ff_rtp_get_codec_info(AVCodecContext *codec, int payload_type)
@@ -77,7 +77,7 @@ int ff_rtp_get_codec_info(AVCodecContext *codec, int payload_type) · 2 unmodified lines
77	77
78	78	for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
79	79	if (AVRtpPayloadTypes[i].pt == payload_type) {
80		− if (AVRtpPayloadTypes[i].codec_id != CODEC_ID_NONE) {
	80	+ if (AVRtpPayloadTypes[i].codec_id != AV_CODEC_ID_NONE) {
81	81	codec->codec_type = AVRtpPayloadTypes[i].codec_type;
82	82	codec->codec_id = AVRtpPayloadTypes[i].codec_id;
83	83	if (AVRtpPayloadTypes[i].audio_channels > 0)
@@ -106,13 +106,13 @@ int ff_rtp_get_payload_type(AVFormatContext fmt, AVCodecContext codec) · 22 unmodified lines
106	106	/* static payload type */
107	107	for (i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i)
108	108	if (AVRtpPayloadTypes[i].codec_id == codec->codec_id) {
109		− if (codec->codec_id == CODEC_ID_H263 && (!fmt \|\|
	109	+ if (codec->codec_id == AV_CODEC_ID_H263 && (!fmt \|\|
110	110	!fmt->oformat->priv_class \|\|
111	111	!av_opt_flag_is_set(fmt->priv_data, "rtpflags", "rfc2190")))
112	112	continue;
113	113	/* G722 has 8000 as nominal rate even if the sample rate is 16000,
114	114	* see section 4.5.2 in RFC 3551. */
115		− if (codec->codec_id == CODEC_ID_ADPCM_G722 &&
	115	+ if (codec->codec_id == AV_CODEC_ID_ADPCM_G722 &&
116	116	codec->sample_rate == 16000 && codec->channels == 1)
117	117	return AVRtpPayloadTypes[i].pt;
118	118	if (codec->codec_type == AVMEDIA_TYPE_AUDIO &&
@@ -140,7 +140,7 @@ const char *ff_rtp_enc_name(int payload_type) · 21 unmodified lines
140	140	return "";
141	141	}
142	142
143		−enum CodecID ff_rtp_codec_id(const char *buf, enum AVMediaType codec_type)
	143	+enum AVCodecID ff_rtp_codec_id(const char *buf, enum AVMediaType codec_type)
144	144	{
145	145	int i;
146	146
@@ -149,5 +149,5 @@ enum CodecID ff_rtp_codec_id(const char *buf, enum AVMediaType codec_type) · 2 unmodified lines
149	149	return AVRtpPayloadTypes[i].codec_id;
150	150	}
151	151
152		− return CODEC_ID_NONE;
	152	+ return AV_CODEC_ID_NONE;
153	153	}

libavformat/rtp.h+2−2

@@ -63,10 +63,10 @@ const char *ff_rtp_enc_name(int payload_type); · 62 unmodified lines
63	63	*
64	64	* @param buf A pointer to the string containing the encoding name
65	65	* @param codec_type The codec type
66		− * @return In case of unknown encoding name, CODEC_ID_NONE is returned;
	66	+ * @return In case of unknown encoding name, AV_CODEC_ID_NONE is returned;
67	67	* otherwise, the codec id is returned
68	68	*/
69		−enum CodecID ff_rtp_codec_id(const char *buf, enum AVMediaType codec_type);
	69	+enum AVCodecID ff_rtp_codec_id(const char *buf, enum AVMediaType codec_type);
70	70
71	71	#define RTP_PT_PRIVATE 96
72	72	#define RTP_VERSION 2

libavformat/rtpdec.c+15−15

@@ -46,7 +46,7 @@ · 45 unmodified lines
46	46	static RTPDynamicProtocolHandler ff_realmedia_mp3_dynamic_handler = {
47	47	.enc_name = "X-MP3-draft-00",
48	48	.codec_type = AVMEDIA_TYPE_AUDIO,
49		− .codec_id = CODEC_ID_MP3ADU,
	49	+ .codec_id = AV_CODEC_ID_MP3ADU,
50	50	};
51	51
52	52	/* statistics functions */
@@ -364,7 +364,7 @@ void ff_rtp_send_punch_packets(URLContext* rtp_handle) · 311 unmodified lines
364	364	/**
365	365	* open a new RTP parse context for stream 'st'. 'st' can be NULL for
366	366	* MPEG2TS streams to indicate that they should be demuxed inside the
367		− * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
	367	+ * rtp demux (otherwise AV_CODEC_ID_MPEG2TS packets are returned)
368	368	*/
369	369	RTPDemuxContext ff_rtp_parse_open(AVFormatContext s1, AVStream st, URLContext rtpc, int payload_type, int queue_size)
370	370	{
@@ -388,19 +388,19 @@ RTPDemuxContext ff_rtp_parse_open(AVFormatContext s1, AVStream *st, URLContext · 17 unmodified lines
388	388	}
389	389	} else if (st) {
390	390	switch(st->codec->codec_id) {
391		− case CODEC_ID_MPEG1VIDEO:
392		− case CODEC_ID_MPEG2VIDEO:
393		− case CODEC_ID_MP2:
394		− case CODEC_ID_MP3:
395		− case CODEC_ID_MPEG4:
396		− case CODEC_ID_H263:
397		− case CODEC_ID_H264:
	391	+ case AV_CODEC_ID_MPEG1VIDEO:
	392	+ case AV_CODEC_ID_MPEG2VIDEO:
	393	+ case AV_CODEC_ID_MP2:
	394	+ case AV_CODEC_ID_MP3:
	395	+ case AV_CODEC_ID_MPEG4:
	396	+ case AV_CODEC_ID_H263:
	397	+ case AV_CODEC_ID_H264:
398	398	st->need_parsing = AVSTREAM_PARSE_FULL;
399	399	break;
400		− case CODEC_ID_VORBIS:
	400	+ case AV_CODEC_ID_VORBIS:
401	401	st->need_parsing = AVSTREAM_PARSE_HEADERS;
402	402	break;
403		− case CODEC_ID_ADPCM_G722:
	403	+ case AV_CODEC_ID_ADPCM_G722:
404	404	/* According to RFC 3551, the stream clock rate is 8000
405	405	* even if the sample rate is 16000. */
406	406	if (st->codec->sample_rate == 8000)
@@ -537,8 +537,8 @@ static int rtp_parse_packet_internal(RTPDemuxContext s, AVPacket pkt, · 130 unmodified lines
537	537	} else {
538	538	// at this point, the RTP header has been stripped; This is ASSUMING that there is only 1 CSRC, which in't wise.
539	539	switch(st->codec->codec_id) {
540		− case CODEC_ID_MP2:
541		− case CODEC_ID_MP3:
	540	+ case AV_CODEC_ID_MP2:
	541	+ case AV_CODEC_ID_MP3:
542	542	/* better than nothing: skip mpeg audio RTP header */
543	543	if (len <= 4)
544	544	return -1;
@@ -548,8 +548,8 @@ static int rtp_parse_packet_internal(RTPDemuxContext s, AVPacket pkt, · 3 unmodified lines
548	548	av_new_packet(pkt, len);
549	549	memcpy(pkt->data, buf, len);
550	550	break;
551		− case CODEC_ID_MPEG1VIDEO:
552		− case CODEC_ID_MPEG2VIDEO:
	551	+ case AV_CODEC_ID_MPEG1VIDEO:
	552	+ case AV_CODEC_ID_MPEG2VIDEO:
553	553	/* better than nothing: skip mpeg video RTP header */
554	554	if (len <= 4)
555	555	return -1;

libavformat/rtpdec.h+1−1

@@ -116,7 +116,7 @@ struct RTPDynamicProtocolHandler_s { · 115 unmodified lines
116	116	// fields from AVRtpDynamicPayloadType_s
117	117	const char enc_name[50]; /* XXX: still why 50 ? ;-) */
118	118	enum AVMediaType codec_type;
119		− enum CodecID codec_id;
	119	+ enum AVCodecID codec_id;
120	120	int static_payload_id; /* 0 means no payload id is set. 0 is a valid
121	121	* payload ID (PCMU), too, but that format doesn't
122	122	* require any custom depacketization code. */

libavformat/rtpdec_amr.c+4−4

@@ -64,9 +64,9 @@ static int amr_handle_packet(AVFormatContext *ctx, · 63 unmodified lines
64	64	const uint8_t *speech_data;
65	65	uint8_t *ptr;
66	66
67		− if (st->codec->codec_id == CODEC_ID_AMR_NB) {
	67	+ if (st->codec->codec_id == AV_CODEC_ID_AMR_NB) {
68	68	frame_sizes = frame_sizes_nb;
69		− } else if (st->codec->codec_id == CODEC_ID_AMR_WB) {
	69	+ } else if (st->codec->codec_id == AV_CODEC_ID_AMR_WB) {
70	70	frame_sizes = frame_sizes_wb;
71	71	} else {
72	72	av_log(ctx, AV_LOG_ERROR, "Bad codec ID\n");
@@ -192,7 +192,7 @@ static int amr_parse_sdp_line(AVFormatContext *s, int st_index, · 119 unmodified lines
192	192	RTPDynamicProtocolHandler ff_amr_nb_dynamic_handler = {
193	193	.enc_name = "AMR",
194	194	.codec_type = AVMEDIA_TYPE_AUDIO,
195		− .codec_id = CODEC_ID_AMR_NB,
	195	+ .codec_id = AV_CODEC_ID_AMR_NB,
196	196	.parse_sdp_a_line = amr_parse_sdp_line,
197	197	.alloc = amr_new_context,
198	198	.free = amr_free_context,
@@ -202,7 +202,7 @@ RTPDynamicProtocolHandler ff_amr_nb_dynamic_handler = { · 3 unmodified lines
202	202	RTPDynamicProtocolHandler ff_amr_wb_dynamic_handler = {
203	203	.enc_name = "AMR-WB",
204	204	.codec_type = AVMEDIA_TYPE_AUDIO,
205		− .codec_id = CODEC_ID_AMR_WB,
	205	+ .codec_id = AV_CODEC_ID_AMR_WB,
206	206	.parse_sdp_a_line = amr_parse_sdp_line,
207	207	.alloc = amr_new_context,
208	208	.free = amr_free_context,

libavformat/rtpdec_asf.c+1−1

@@ -298,7 +298,7 @@ static void asfrtp_free_context(PayloadContext *asf) · 297 unmodified lines
298	298	RTPDynamicProtocolHandler ff_ms_rtp_ ## n ## _handler = { \
299	299	.enc_name = s, \
300	300	.codec_type = t, \
301		− .codec_id = CODEC_ID_NONE, \
	301	+ .codec_id = AV_CODEC_ID_NONE, \
302	302	.parse_sdp_a_line = asfrtp_parse_sdp_line, \
303	303	.alloc = asfrtp_new_context, \
304	304	.free = asfrtp_free_context, \

libavformat/rtpdec_g726.c+1−1

@@ -36,7 +36,7 @@ static int g726_ ## bitrate ##_init(AVFormatContext *s, int st_index, PayloadCon · 35 unmodified lines
36	36	RTPDynamicProtocolHandler ff_g726_ ## bitrate ## _dynamic_handler = { \
37	37	.enc_name = "G726-" #bitrate, \
38	38	.codec_type = AVMEDIA_TYPE_AUDIO, \
39		− .codec_id = CODEC_ID_ADPCM_G726, \
	39	+ .codec_id = AV_CODEC_ID_ADPCM_G726, \
40	40	.init = g726_ ## bitrate ## _init, \
41	41	}
42	42

libavformat/rtpdec_h263.c+2−2

@@ -91,13 +91,13 @@ int ff_h263_handle_packet(AVFormatContext ctx, PayloadContext data, · 90 unmodified lines
91	91	RTPDynamicProtocolHandler ff_h263_1998_dynamic_handler = {
92	92	.enc_name = "H263-1998",
93	93	.codec_type = AVMEDIA_TYPE_VIDEO,
94		− .codec_id = CODEC_ID_H263,
	94	+ .codec_id = AV_CODEC_ID_H263,
95	95	.parse_packet = ff_h263_handle_packet,
96	96	};
97	97
98	98	RTPDynamicProtocolHandler ff_h263_2000_dynamic_handler = {
99	99	.enc_name = "H263-2000",
100	100	.codec_type = AVMEDIA_TYPE_VIDEO,
101		− .codec_id = CODEC_ID_H263,
	101	+ .codec_id = AV_CODEC_ID_H263,
102	102	.parse_packet = ff_h263_handle_packet,
103	103	};

libavformat/rtpdec_h263_rfc2190.c+1−1

@@ -198,7 +198,7 @@ static int h263_handle_packet(AVFormatContext ctx, PayloadContext data, · 197 unmodified lines
198	198
199	199	RTPDynamicProtocolHandler ff_h263_rfc2190_dynamic_handler = {
200	200	.codec_type = AVMEDIA_TYPE_VIDEO,
201		− .codec_id = CODEC_ID_H263,
	201	+ .codec_id = AV_CODEC_ID_H263,
202	202	.parse_packet = h263_handle_packet,
203	203	.alloc = h263_new_context,
204	204	.free = h263_free_context,

libavformat/rtpdec_h264.c+2−2

@@ -69,7 +69,7 @@ static int sdp_parse_fmtp_config_h264(AVStream *stream, · 68 unmodified lines
69	69	char attr, char value)
70	70	{
71	71	AVCodecContext *codec = stream->codec;
72		− assert(codec->codec_id == CODEC_ID_H264);
	72	+ assert(codec->codec_id == AV_CODEC_ID_H264);
73	73	assert(h264_data != NULL);
74	74
75	75	if (!strcmp(attr, "packetization-mode")) {
@@ -383,7 +383,7 @@ static int parse_h264_sdp_line(AVFormatContext *s, int st_index, · 307 unmodified lines
383	383	RTPDynamicProtocolHandler ff_h264_dynamic_handler = {
384	384	.enc_name = "H264",
385	385	.codec_type = AVMEDIA_TYPE_VIDEO,
386		− .codec_id = CODEC_ID_H264,
	386	+ .codec_id = AV_CODEC_ID_H264,
387	387	.parse_sdp_a_line = parse_h264_sdp_line,
388	388	.alloc = h264_new_context,
389	389	.free = h264_free_context,

libavformat/rtpdec_ilbc.c+1−1

@@ -68,6 +68,6 @@ static int ilbc_parse_sdp_line(AVFormatContext *s, int st_index, · 67 unmodified lines
68	68	RTPDynamicProtocolHandler ff_ilbc_dynamic_handler = {
69	69	.enc_name = "iLBC",
70	70	.codec_type = AVMEDIA_TYPE_AUDIO,
71		− .codec_id = CODEC_ID_ILBC,
	71	+ .codec_id = AV_CODEC_ID_ILBC,
72	72	.parse_sdp_a_line = ilbc_parse_sdp_line,
73	73	};

libavformat/rtpdec_latm.c+1−1

@@ -180,7 +180,7 @@ static int latm_parse_sdp_line(AVFormatContext *s, int st_index, · 179 unmodified lines
180	180	RTPDynamicProtocolHandler ff_mp4a_latm_dynamic_handler = {
181	181	.enc_name = "MP4A-LATM",
182	182	.codec_type = AVMEDIA_TYPE_AUDIO,
183		− .codec_id = CODEC_ID_AAC,
	183	+ .codec_id = AV_CODEC_ID_AAC,
184	184	.parse_sdp_a_line = latm_parse_sdp_line,
185	185	.alloc = latm_new_context,
186	186	.free = latm_free_context,

libavformat/rtpdec_mpeg4.c+3−3

@@ -202,7 +202,7 @@ static int parse_fmtp(AVStream stream, PayloadContext data, · 201 unmodified lines
202	202	return res;
203	203	}
204	204
205		− if (codec->codec_id == CODEC_ID_AAC) {
	205	+ if (codec->codec_id == AV_CODEC_ID_AAC) {
206	206	/* Looking for a known attribute */
207	207	for (i = 0; attr_names[i].str; ++i) {
208	208	if (!av_strcasecmp(attr, attr_names[i].str)) {
@@ -235,14 +235,14 @@ static int parse_sdp_line(AVFormatContext *s, int st_index, · 26 unmodified lines
235	235	RTPDynamicProtocolHandler ff_mp4v_es_dynamic_handler = {
236	236	.enc_name = "MP4V-ES",
237	237	.codec_type = AVMEDIA_TYPE_VIDEO,
238		− .codec_id = CODEC_ID_MPEG4,
	238	+ .codec_id = AV_CODEC_ID_MPEG4,
239	239	.parse_sdp_a_line = parse_sdp_line,
240	240	};
241	241
242	242	RTPDynamicProtocolHandler ff_mpeg4_generic_dynamic_handler = {
243	243	.enc_name = "mpeg4-generic",
244	244	.codec_type = AVMEDIA_TYPE_AUDIO,
245		− .codec_id = CODEC_ID_AAC,
	245	+ .codec_id = AV_CODEC_ID_AAC,
246	246	.parse_sdp_a_line = parse_sdp_line,
247	247	.alloc = new_context,
248	248	.free = free_context,

libavformat/rtpdec_qcelp.c+1−1

@@ -221,7 +221,7 @@ static int qcelp_parse_packet(AVFormatContext ctx, PayloadContext data, · 220 unmodified lines
221	221	RTPDynamicProtocolHandler ff_qcelp_dynamic_handler = {
222	222	.enc_name = "x-Purevoice",
223	223	.codec_type = AVMEDIA_TYPE_AUDIO,
224		− .codec_id = CODEC_ID_QCELP,
	224	+ .codec_id = AV_CODEC_ID_QCELP,
225	225	.static_payload_id = 12,
226	226	.alloc = qcelp_new_context,
227	227	.free = qcelp_free_context,

libavformat/rtpdec_qdm2.c+5−5

@@ -259,14 +259,14 @@ static int qdm2_parse_packet(AVFormatContext s, PayloadContext qdm, · 258 unmodified lines
259	259	return res;
260	260	p += res;
261	261
262		− /* We set codec_id to CODEC_ID_NONE initially to
	262	+ /* We set codec_id to AV_CODEC_ID_NONE initially to
263	263	* delay decoder initialization since extradata is
264	264	* carried within the RTP stream, not SDP. Here,
265		− * by setting codec_id to CODEC_ID_QDM2, we are signalling
	265	+ * by setting codec_id to AV_CODEC_ID_QDM2, we are signalling
266	266	* to the decoder that it is OK to initialize. */
267		− st->codec->codec_id = CODEC_ID_QDM2;
	267	+ st->codec->codec_id = AV_CODEC_ID_QDM2;
268	268	}
269		− if (st->codec->codec_id == CODEC_ID_NONE)
	269	+ if (st->codec->codec_id == AV_CODEC_ID_NONE)
270	270	return AVERROR(EAGAIN);
271	271
272	272	/* subpackets */
@@ -310,7 +310,7 @@ static void qdm2_extradata_free(PayloadContext *qdm) · 37 unmodified lines
310	310	RTPDynamicProtocolHandler ff_qdm2_dynamic_handler = {
311	311	.enc_name = "X-QDM",
312	312	.codec_type = AVMEDIA_TYPE_AUDIO,
313		− .codec_id = CODEC_ID_NONE,
	313	+ .codec_id = AV_CODEC_ID_NONE,
314	314	.alloc = qdm2_extradata_new,
315	315	.free = qdm2_extradata_free,
316	316	.parse_packet = qdm2_parse_packet,

libavformat/rtpdec_qt.c+1−1

@@ -244,7 +244,7 @@ static void qt_rtp_free(PayloadContext *qt) · 243 unmodified lines
244	244	RTPDynamicProtocolHandler ff_ ## m ## _rtp_ ## n ## _handler = { \
245	245	.enc_name = s, \
246	246	.codec_type = t, \
247		− .codec_id = CODEC_ID_NONE, \
	247	+ .codec_id = AV_CODEC_ID_NONE, \
248	248	.alloc = qt_rtp_new, \
249	249	.free = qt_rtp_free, \
250	250	.parse_packet = qt_rtp_parse_packet, \

libavformat/rtpdec_svq3.c+4−4

@@ -68,12 +68,12 @@ static int svq3_parse_packet (AVFormatContext s, PayloadContext sv, · 67 unmodified lines
68	68	AV_WB32(st->codec->extradata + 4, len);
69	69	memcpy(st->codec->extradata + 8, buf, len);
70	70
71		− /* We set codec_id to CODEC_ID_NONE initially to
	71	+ /* We set codec_id to AV_CODEC_ID_NONE initially to
72	72	* delay decoder initialization since extradata is
73	73	* carried within the RTP stream, not SDP. Here,
74		− * by setting codec_id to CODEC_ID_SVQ3, we are signalling
	74	+ * by setting codec_id to AV_CODEC_ID_SVQ3, we are signalling
75	75	* to the decoder that it is OK to initialize. */
76		− st->codec->codec_id = CODEC_ID_SVQ3;
	76	+ st->codec->codec_id = AV_CODEC_ID_SVQ3;
77	77
78	78	return AVERROR(EAGAIN);
79	79	}
@@ -127,7 +127,7 @@ static void svq3_extradata_free(PayloadContext *sv) · 47 unmodified lines
127	127	RTPDynamicProtocolHandler ff_svq3_dynamic_handler = {
128	128	.enc_name = "X-SV3V-ES",
129	129	.codec_type = AVMEDIA_TYPE_VIDEO,
130		− .codec_id = CODEC_ID_NONE, // see if (config_packet) above
	130	+ .codec_id = AV_CODEC_ID_NONE, // see if (config_packet) above
131	131	.alloc = svq3_extradata_new,
132	132	.free = svq3_extradata_free,
133	133	.parse_packet = svq3_parse_packet,

libavformat/rtpdec_vp8.c+1−1

@@ -147,7 +147,7 @@ static void vp8_free_context(PayloadContext *vp8) · 146 unmodified lines
147	147	RTPDynamicProtocolHandler ff_vp8_dynamic_handler = {
148	148	.enc_name = "VP8",
149	149	.codec_type = AVMEDIA_TYPE_VIDEO,
150		− .codec_id = CODEC_ID_VP8,
	150	+ .codec_id = AV_CODEC_ID_VP8,
151	151	.alloc = vp8_new_context,
152	152	.free = vp8_free_context,
153	153	.parse_packet = vp8_handle_packet,

libavformat/rtpdec_xiph.c+2−2

@@ -390,7 +390,7 @@ static int xiph_parse_sdp_line(AVFormatContext *s, int st_index, · 389 unmodified lines
390	390	RTPDynamicProtocolHandler ff_theora_dynamic_handler = {
391	391	.enc_name = "theora",
392	392	.codec_type = AVMEDIA_TYPE_VIDEO,
393		− .codec_id = CODEC_ID_THEORA,
	393	+ .codec_id = AV_CODEC_ID_THEORA,
394	394	.parse_sdp_a_line = xiph_parse_sdp_line,
395	395	.alloc = xiph_new_context,
396	396	.free = xiph_free_context,
@@ -400,7 +400,7 @@ RTPDynamicProtocolHandler ff_theora_dynamic_handler = { · 3 unmodified lines
400	400	RTPDynamicProtocolHandler ff_vorbis_dynamic_handler = {
401	401	.enc_name = "vorbis",
402	402	.codec_type = AVMEDIA_TYPE_AUDIO,
403		− .codec_id = CODEC_ID_VORBIS,
	403	+ .codec_id = AV_CODEC_ID_VORBIS,
404	404	.parse_sdp_a_line = xiph_parse_sdp_line,
405	405	.alloc = xiph_new_context,
406	406	.free = xiph_free_context,

libavformat/rtpenc.c+69−69

@@ -46,35 +46,35 @@ static const AVClass rtp_muxer_class = { · 45 unmodified lines
46	46
47	47	#define RTCP_SR_SIZE 28
48	48
49		−static int is_supported(enum CodecID id)
	49	+static int is_supported(enum AVCodecID id)
50	50	{
51	51	switch(id) {
52		− case CODEC_ID_H263:
53		− case CODEC_ID_H263P:
54		− case CODEC_ID_H264:
55		− case CODEC_ID_MPEG1VIDEO:
56		− case CODEC_ID_MPEG2VIDEO:
57		− case CODEC_ID_MPEG4:
58		− case CODEC_ID_AAC:
59		− case CODEC_ID_MP2:
60		− case CODEC_ID_MP3:
61		− case CODEC_ID_PCM_ALAW:
62		− case CODEC_ID_PCM_MULAW:
63		− case CODEC_ID_PCM_S8:
64		− case CODEC_ID_PCM_S16BE:
65		− case CODEC_ID_PCM_S16LE:
66		− case CODEC_ID_PCM_U16BE:
67		− case CODEC_ID_PCM_U16LE:
68		− case CODEC_ID_PCM_U8:
69		− case CODEC_ID_MPEG2TS:
70		− case CODEC_ID_AMR_NB:
71		− case CODEC_ID_AMR_WB:
72		− case CODEC_ID_VORBIS:
73		− case CODEC_ID_THEORA:
74		− case CODEC_ID_VP8:
75		− case CODEC_ID_ADPCM_G722:
76		− case CODEC_ID_ADPCM_G726:
77		− case CODEC_ID_ILBC:
	52	+ case AV_CODEC_ID_H263:
	53	+ case AV_CODEC_ID_H263P:
	54	+ case AV_CODEC_ID_H264:
	55	+ case AV_CODEC_ID_MPEG1VIDEO:
	56	+ case AV_CODEC_ID_MPEG2VIDEO:
	57	+ case AV_CODEC_ID_MPEG4:
	58	+ case AV_CODEC_ID_AAC:
	59	+ case AV_CODEC_ID_MP2:
	60	+ case AV_CODEC_ID_MP3:
	61	+ case AV_CODEC_ID_PCM_ALAW:
	62	+ case AV_CODEC_ID_PCM_MULAW:
	63	+ case AV_CODEC_ID_PCM_S8:
	64	+ case AV_CODEC_ID_PCM_S16BE:
	65	+ case AV_CODEC_ID_PCM_S16LE:
	66	+ case AV_CODEC_ID_PCM_U16BE:
	67	+ case AV_CODEC_ID_PCM_U16LE:
	68	+ case AV_CODEC_ID_PCM_U8:
	69	+ case AV_CODEC_ID_MPEG2TS:
	70	+ case AV_CODEC_ID_AMR_NB:
	71	+ case AV_CODEC_ID_AMR_WB:
	72	+ case AV_CODEC_ID_VORBIS:
	73	+ case AV_CODEC_ID_THEORA:
	74	+ case AV_CODEC_ID_VP8:
	75	+ case AV_CODEC_ID_ADPCM_G722:
	76	+ case AV_CODEC_ID_ADPCM_G726:
	77	+ case AV_CODEC_ID_ILBC:
78	78	return 1;
79	79	default:
80	80	return 0;
@@ -152,43 +152,43 @@ static int rtp_write_header(AVFormatContext *s1) · 71 unmodified lines
152	152
153	153	avpriv_set_pts_info(st, 32, 1, 90000);
154	154	switch(st->codec->codec_id) {
155		− case CODEC_ID_MP2:
156		− case CODEC_ID_MP3:
	155	+ case AV_CODEC_ID_MP2:
	156	+ case AV_CODEC_ID_MP3:
157	157	s->buf_ptr = s->buf + 4;
158	158	break;
159		− case CODEC_ID_MPEG1VIDEO:
160		− case CODEC_ID_MPEG2VIDEO:
	159	+ case AV_CODEC_ID_MPEG1VIDEO:
	160	+ case AV_CODEC_ID_MPEG2VIDEO:
161	161	break;
162		− case CODEC_ID_MPEG2TS:
	162	+ case AV_CODEC_ID_MPEG2TS:
163	163	n = s->max_payload_size / TS_PACKET_SIZE;
164	164	if (n < 1)
165	165	n = 1;
166	166	s->max_payload_size = n * TS_PACKET_SIZE;
167	167	s->buf_ptr = s->buf;
168	168	break;
169		− case CODEC_ID_H264:
	169	+ case AV_CODEC_ID_H264:
170	170	/* check for H.264 MP4 syntax */
171	171	if (st->codec->extradata_size > 4 && st->codec->extradata[0] == 1) {
172	172	s->nal_length_size = (st->codec->extradata[4] & 0x03) + 1;
173	173	}
174	174	break;
175		− case CODEC_ID_VORBIS:
176		− case CODEC_ID_THEORA:
	175	+ case AV_CODEC_ID_VORBIS:
	176	+ case AV_CODEC_ID_THEORA:
177	177	if (!s->max_frames_per_packet) s->max_frames_per_packet = 15;
178	178	s->max_frames_per_packet = av_clip(s->max_frames_per_packet, 1, 15);
179	179	s->max_payload_size -= 6; // ident+frag+tdt/vdt+pkt_num+pkt_length
180	180	s->num_frames = 0;
181	181	goto defaultcase;
182		− case CODEC_ID_VP8:
	182	+ case AV_CODEC_ID_VP8:
183	183	av_log(s1, AV_LOG_ERROR, "RTP VP8 payload implementation is "
184	184	"incompatible with the latest spec drafts.\n");
185	185	break;
186		− case CODEC_ID_ADPCM_G722:
	186	+ case AV_CODEC_ID_ADPCM_G722:
187	187	/* Due to a historical error, the clock rate for G722 in RTP is
188	188	* 8000, even if the sample rate is 16000. See RFC 3551. */
189	189	avpriv_set_pts_info(st, 32, 1, 8000);
190	190	break;
191		− case CODEC_ID_ILBC:
	191	+ case AV_CODEC_ID_ILBC:
192	192	if (st->codec->block_align != 38 && st->codec->block_align != 50) {
193	193	av_log(s1, AV_LOG_ERROR, "Incorrect iLBC block size specified\n");
194	194	goto fail;
@@ -198,11 +198,11 @@ static int rtp_write_header(AVFormatContext *s1) · 3 unmodified lines
198	198	s->max_frames_per_packet = FFMIN(s->max_frames_per_packet,
199	199	s->max_payload_size / st->codec->block_align);
200	200	goto defaultcase;
201		− case CODEC_ID_AMR_NB:
202		− case CODEC_ID_AMR_WB:
	201	+ case AV_CODEC_ID_AMR_NB:
	202	+ case AV_CODEC_ID_AMR_WB:
203	203	if (!s->max_frames_per_packet)
204	204	s->max_frames_per_packet = 12;
205		− if (st->codec->codec_id == CODEC_ID_AMR_NB)
	205	+ if (st->codec->codec_id == AV_CODEC_ID_AMR_NB)
206	206	n = 31;
207	207	else
208	208	n = 61;
@@ -215,7 +215,7 @@ static int rtp_write_header(AVFormatContext *s1) · 6 unmodified lines
215	215	av_log(s1, AV_LOG_ERROR, "Only mono is supported\n");
216	216	goto fail;
217	217	}
218		− case CODEC_ID_AAC:
	218	+ case AV_CODEC_ID_AAC:
219	219	s->num_frames = 0;
220	220	default:
221	221	defaultcase:
@@ -457,54 +457,54 @@ static int rtp_write_packet(AVFormatContext s1, AVPacket pkt) · 235 unmodified lines
457	457	s->cur_timestamp = s->base_timestamp + pkt->pts;
458	458
459	459	switch(st->codec->codec_id) {
460		− case CODEC_ID_PCM_MULAW:
461		− case CODEC_ID_PCM_ALAW:
462		− case CODEC_ID_PCM_U8:
463		− case CODEC_ID_PCM_S8:
	460	+ case AV_CODEC_ID_PCM_MULAW:
	461	+ case AV_CODEC_ID_PCM_ALAW:
	462	+ case AV_CODEC_ID_PCM_U8:
	463	+ case AV_CODEC_ID_PCM_S8:
464	464	rtp_send_samples(s1, pkt->data, size, 8 * st->codec->channels);
465	465	break;
466		− case CODEC_ID_PCM_U16BE:
467		− case CODEC_ID_PCM_U16LE:
468		− case CODEC_ID_PCM_S16BE:
469		− case CODEC_ID_PCM_S16LE:
	466	+ case AV_CODEC_ID_PCM_U16BE:
	467	+ case AV_CODEC_ID_PCM_U16LE:
	468	+ case AV_CODEC_ID_PCM_S16BE:
	469	+ case AV_CODEC_ID_PCM_S16LE:
470	470	rtp_send_samples(s1, pkt->data, size, 16 * st->codec->channels);
471	471	break;
472		− case CODEC_ID_ADPCM_G722:
	472	+ case AV_CODEC_ID_ADPCM_G722:
473	473	/* The actual sample size is half a byte per sample, but since the
474	474	* stream clock rate is 8000 Hz while the sample rate is 16000 Hz,
475	475	* the correct parameter for send_samples_bits is 8 bits per stream
476	476	* clock. */
477	477	rtp_send_samples(s1, pkt->data, size, 8 * st->codec->channels);
478	478	break;
479		− case CODEC_ID_ADPCM_G726:
	479	+ case AV_CODEC_ID_ADPCM_G726:
480	480	rtp_send_samples(s1, pkt->data, size,
481	481	st->codec->bits_per_coded_sample * st->codec->channels);
482	482	break;
483		− case CODEC_ID_MP2:
484		− case CODEC_ID_MP3:
	483	+ case AV_CODEC_ID_MP2:
	484	+ case AV_CODEC_ID_MP3:
485	485	rtp_send_mpegaudio(s1, pkt->data, size);
486	486	break;
487		− case CODEC_ID_MPEG1VIDEO:
488		− case CODEC_ID_MPEG2VIDEO:
	487	+ case AV_CODEC_ID_MPEG1VIDEO:
	488	+ case AV_CODEC_ID_MPEG2VIDEO:
489	489	ff_rtp_send_mpegvideo(s1, pkt->data, size);
490	490	break;
491		− case CODEC_ID_AAC:
	491	+ case AV_CODEC_ID_AAC:
492	492	if (s->flags & FF_RTP_FLAG_MP4A_LATM)
493	493	ff_rtp_send_latm(s1, pkt->data, size);
494	494	else
495	495	ff_rtp_send_aac(s1, pkt->data, size);
496	496	break;
497		− case CODEC_ID_AMR_NB:
498		− case CODEC_ID_AMR_WB:
	497	+ case AV_CODEC_ID_AMR_NB:
	498	+ case AV_CODEC_ID_AMR_WB:
499	499	ff_rtp_send_amr(s1, pkt->data, size);
500	500	break;
501		− case CODEC_ID_MPEG2TS:
	501	+ case AV_CODEC_ID_MPEG2TS:
502	502	rtp_send_mpegts_raw(s1, pkt->data, size);
503	503	break;
504		− case CODEC_ID_H264:
	504	+ case AV_CODEC_ID_H264:
505	505	ff_rtp_send_h264(s1, pkt->data, size);
506	506	break;
507		− case CODEC_ID_H263:
	507	+ case AV_CODEC_ID_H263:
508	508	if (s->flags & FF_RTP_FLAG_RFC2190) {
509	509	int mb_info_size = 0;
510	510	const uint8_t *mb_info =
@@ -514,17 +514,17 @@ static int rtp_write_packet(AVFormatContext s1, AVPacket pkt) · 3 unmodified lines
514	514	break;
515	515	}
516	516	/* Fallthrough */
517		− case CODEC_ID_H263P:
	517	+ case AV_CODEC_ID_H263P:
518	518	ff_rtp_send_h263(s1, pkt->data, size);
519	519	break;
520		− case CODEC_ID_VORBIS:
521		− case CODEC_ID_THEORA:
	520	+ case AV_CODEC_ID_VORBIS:
	521	+ case AV_CODEC_ID_THEORA:
522	522	ff_rtp_send_xiph(s1, pkt->data, size);
523	523	break;
524		− case CODEC_ID_VP8:
	524	+ case AV_CODEC_ID_VP8:
525	525	ff_rtp_send_vp8(s1, pkt->data, size);
526	526	break;
527		− case CODEC_ID_ILBC:
	527	+ case AV_CODEC_ID_ILBC:
528	528	rtp_send_ilbc(s1, pkt->data, size);
529	529	break;
530	530	default:
@@ -548,8 +548,8 @@ AVOutputFormat ff_rtp_muxer = { · 17 unmodified lines
548	548	.name = "rtp",
549	549	.long_name = NULL_IF_CONFIG_SMALL("RTP output"),
550	550	.priv_data_size = sizeof(RTPMuxContext),
551		− .audio_codec = CODEC_ID_PCM_MULAW,
552		− .video_codec = CODEC_ID_MPEG4,
	551	+ .audio_codec = AV_CODEC_ID_PCM_MULAW,
	552	+ .video_codec = AV_CODEC_ID_MPEG4,
553	553	.write_header = rtp_write_header,
554	554	.write_packet = rtp_write_packet,
555	555	.write_trailer = rtp_write_trailer,

libavformat/rtsp.c+1−1

@@ -207,7 +207,7 @@ static int sdp_parse_rtpmap(AVFormatContext *s, · 206 unmodified lines
207	207	codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
208	208	}
209	209
210		− if (codec->codec_id == CODEC_ID_NONE) {
	210	+ if (codec->codec_id == AV_CODEC_ID_NONE) {
211	211	RTPDynamicProtocolHandler *handler =
212	212	ff_rtp_handler_find_by_name(buf, codec->codec_type);
213	213	init_rtp_handler(handler, rtsp_st, codec);

libavformat/rtspenc.c+2−2

@@ -237,8 +237,8 @@ AVOutputFormat ff_rtsp_muxer = { · 236 unmodified lines
237	237	.name = "rtsp",
238	238	.long_name = NULL_IF_CONFIG_SMALL("RTSP output"),
239	239	.priv_data_size = sizeof(RTSPState),
240		− .audio_codec = CODEC_ID_AAC,
241		− .video_codec = CODEC_ID_MPEG4,
	240	+ .audio_codec = AV_CODEC_ID_AAC,
	241	+ .video_codec = AV_CODEC_ID_MPEG4,
242	242	.write_header = rtsp_write_header,
243	243	.write_packet = rtsp_write_packet,
244	244	.write_trailer = rtsp_write_close,

libavformat/sapenc.c+2−2

@@ -256,8 +256,8 @@ AVOutputFormat ff_sap_muxer = { · 255 unmodified lines
256	256	.name = "sap",
257	257	.long_name = NULL_IF_CONFIG_SMALL("SAP output"),
258	258	.priv_data_size = sizeof(struct SAPState),
259		− .audio_codec = CODEC_ID_AAC,
260		− .video_codec = CODEC_ID_MPEG4,
	259	+ .audio_codec = AV_CODEC_ID_AAC,
	260	+ .video_codec = AV_CODEC_ID_MPEG4,
261	261	.write_header = sap_write_header,
262	262	.write_packet = sap_write_packet,
263	263	.write_trailer = sap_write_close,

libavformat/sdp.c+19−19

@@ -257,10 +257,10 @@ static char xiph_extradata2config(AVCodecContext c) · 256 unmodified lines
257	257	int first_header_size;
258	258
259	259	switch (c->codec_id) {
260		− case CODEC_ID_THEORA:
	260	+ case AV_CODEC_ID_THEORA:
261	261	first_header_size = 42;
262	262	break;
263		− case CODEC_ID_VORBIS:
	263	+ case AV_CODEC_ID_VORBIS:
264	264	first_header_size = 30;
265	265	break;
266	266	default:
@@ -388,7 +388,7 @@ static char sdp_write_media_attributes(char buff, int size, AVCodecContext *c, · 121 unmodified lines
388	388	char *config = NULL;
389	389
390	390	switch (c->codec_id) {
391		− case CODEC_ID_H264: {
	391	+ case AV_CODEC_ID_H264: {
392	392	int mode = 1;
393	393	if (fmt && fmt->oformat->priv_class &&
394	394	av_opt_flag_is_set(fmt->priv_data, "rtpflags", "h264_mode0"))
@@ -402,21 +402,21 @@ static char sdp_write_media_attributes(char buff, int size, AVCodecContext *c, · 7 unmodified lines
402	402	payload_type, mode, config ? config : "");
403	403	break;
404	404	}
405		− case CODEC_ID_H263:
406		− case CODEC_ID_H263P:
	405	+ case AV_CODEC_ID_H263:
	406	+ case AV_CODEC_ID_H263P:
407	407	/* a=framesize is required by 3GPP TS 26.234 (PSS). It
408	408	* actually specifies the maximum video size, but we only know
409	409	* the current size. This is required for playback on Android
410	410	* stagefright and on Samsung bada. */
411	411	if (!fmt \|\| !fmt->oformat->priv_class \|\|
412	412	!av_opt_flag_is_set(fmt->priv_data, "rtpflags", "rfc2190") \|\|
413		− c->codec_id == CODEC_ID_H263P)
	413	+ c->codec_id == AV_CODEC_ID_H263P)
414	414	av_strlcatf(buff, size, "a=rtpmap:%d H263-2000/90000\r\n"
415	415	"a=framesize:%d %d-%d\r\n",
416	416	payload_type,
417	417	payload_type, c->width, c->height);
418	418	break;
419		− case CODEC_ID_MPEG4:
	419	+ case AV_CODEC_ID_MPEG4:
420	420	if (c->extradata_size) {
421	421	config = extradata2config(c);
422	422	}
@@ -425,7 +425,7 @@ static char sdp_write_media_attributes(char buff, int size, AVCodecContext *c, · 2 unmodified lines
425	425	payload_type,
426	426	payload_type, config ? config : "");
427	427	break;
428		− case CODEC_ID_AAC:
	428	+ case AV_CODEC_ID_AAC:
429	429	if (fmt && fmt->oformat->priv_class &&
430	430	av_opt_flag_is_set(fmt->priv_data, "rtpflags", "latm")) {
431	431	config = latm_context2config(c);
@@ -456,37 +456,37 @@ static char sdp_write_media_attributes(char buff, int size, AVCodecContext *c, · 24 unmodified lines
456	456	payload_type, config);
457	457	}
458	458	break;
459		− case CODEC_ID_PCM_S16BE:
	459	+ case AV_CODEC_ID_PCM_S16BE:
460	460	if (payload_type >= RTP_PT_PRIVATE)
461	461	av_strlcatf(buff, size, "a=rtpmap:%d L16/%d/%d\r\n",
462	462	payload_type,
463	463	c->sample_rate, c->channels);
464	464	break;
465		− case CODEC_ID_PCM_MULAW:
	465	+ case AV_CODEC_ID_PCM_MULAW:
466	466	if (payload_type >= RTP_PT_PRIVATE)
467	467	av_strlcatf(buff, size, "a=rtpmap:%d PCMU/%d/%d\r\n",
468	468	payload_type,
469	469	c->sample_rate, c->channels);
470	470	break;
471		− case CODEC_ID_PCM_ALAW:
	471	+ case AV_CODEC_ID_PCM_ALAW:
472	472	if (payload_type >= RTP_PT_PRIVATE)
473	473	av_strlcatf(buff, size, "a=rtpmap:%d PCMA/%d/%d\r\n",
474	474	payload_type,
475	475	c->sample_rate, c->channels);
476	476	break;
477		− case CODEC_ID_AMR_NB:
	477	+ case AV_CODEC_ID_AMR_NB:
478	478	av_strlcatf(buff, size, "a=rtpmap:%d AMR/%d/%d\r\n"
479	479	"a=fmtp:%d octet-align=1\r\n",
480	480	payload_type, c->sample_rate, c->channels,
481	481	payload_type);
482	482	break;
483		− case CODEC_ID_AMR_WB:
	483	+ case AV_CODEC_ID_AMR_WB:
484	484	av_strlcatf(buff, size, "a=rtpmap:%d AMR-WB/%d/%d\r\n"
485	485	"a=fmtp:%d octet-align=1\r\n",
486	486	payload_type, c->sample_rate, c->channels,
487	487	payload_type);
488	488	break;
489		− case CODEC_ID_VORBIS:
	489	+ case AV_CODEC_ID_VORBIS:
490	490	if (c->extradata_size)
491	491	config = xiph_extradata2config(c);
492	492	else
@@ -499,7 +499,7 @@ static char sdp_write_media_attributes(char buff, int size, AVCodecContext *c, · 6 unmodified lines
499	499	payload_type, c->sample_rate, c->channels,
500	500	payload_type, config);
501	501	break;
502		− case CODEC_ID_THEORA: {
	502	+ case AV_CODEC_ID_THEORA: {
503	503	const char *pix_fmt;
504	504	if (c->extradata_size)
505	505	config = xiph_extradata2config(c);
@@ -531,17 +531,17 @@ static char sdp_write_media_attributes(char buff, int size, AVCodecContext *c, · 25 unmodified lines
531	531	c->width, c->height, pix_fmt, config);
532	532	break;
533	533	}
534		− case CODEC_ID_VP8:
	534	+ case AV_CODEC_ID_VP8:
535	535	av_strlcatf(buff, size, "a=rtpmap:%d VP8/90000\r\n",
536	536	payload_type);
537	537	break;
538		− case CODEC_ID_ADPCM_G722:
	538	+ case AV_CODEC_ID_ADPCM_G722:
539	539	if (payload_type >= RTP_PT_PRIVATE)
540	540	av_strlcatf(buff, size, "a=rtpmap:%d G722/%d/%d\r\n",
541	541	payload_type,
542	542	8000, c->channels);
543	543	break;
544		− case CODEC_ID_ADPCM_G726: {
	544	+ case AV_CODEC_ID_ADPCM_G726: {
545	545	if (payload_type >= RTP_PT_PRIVATE)
546	546	av_strlcatf(buff, size, "a=rtpmap:%d G726-%d/%d\r\n",
547	547	payload_type,
@@ -549,7 +549,7 @@ static char sdp_write_media_attributes(char buff, int size, AVCodecContext *c, · 1 unmodified line
549	549	c->sample_rate);
550	550	break;
551	551	}
552		− case CODEC_ID_ILBC:
	552	+ case AV_CODEC_ID_ILBC:
553	553	av_strlcatf(buff, size, "a=rtpmap:%d iLBC/%d\r\n"
554	554	"a=fmtp:%d mode=%d\r\n",
555	555	payload_type, c->sample_rate,

libavformat/segafilm.c+17−17

@@ -49,12 +49,12 @@ typedef struct FilmDemuxContext { · 48 unmodified lines
49	49	int video_stream_index;
50	50	int audio_stream_index;
51	51
52		− enum CodecID audio_type;
	52	+ enum AVCodecID audio_type;
53	53	unsigned int audio_samplerate;
54	54	unsigned int audio_bits;
55	55	unsigned int audio_channels;
56	56
57		− enum CodecID video_type;
	57	+ enum AVCodecID video_type;
58	58	unsigned int sample_count;
59	59	film_sample *sample_table;
60	60	unsigned int current_sample;
@@ -101,7 +101,7 @@ static int film_read_header(AVFormatContext *s) · 40 unmodified lines
101	101	if (avio_read(pb, scratch, 20) != 20)
102	102	return AVERROR(EIO);
103	103	/* make some assumptions about the audio parameters */
104		− film->audio_type = CODEC_ID_PCM_S8;
	104	+ film->audio_type = AV_CODEC_ID_PCM_S8;
105	105	film->audio_samplerate = 22050;
106	106	film->audio_channels = 1;
107	107	film->audio_bits = 8;
@@ -113,27 +113,27 @@ static int film_read_header(AVFormatContext *s) · 5 unmodified lines
113	113	film->audio_channels = scratch[21];
114	114	film->audio_bits = scratch[22];
115	115	if (scratch[23] == 2)
116		− film->audio_type = CODEC_ID_ADPCM_ADX;
	116	+ film->audio_type = AV_CODEC_ID_ADPCM_ADX;
117	117	else if (film->audio_channels > 0) {
118	118	if (film->audio_bits == 8)
119		− film->audio_type = CODEC_ID_PCM_S8;
	119	+ film->audio_type = AV_CODEC_ID_PCM_S8;
120	120	else if (film->audio_bits == 16)
121		− film->audio_type = CODEC_ID_PCM_S16BE;
	121	+ film->audio_type = AV_CODEC_ID_PCM_S16BE;
122	122	else
123		− film->audio_type = CODEC_ID_NONE;
	123	+ film->audio_type = AV_CODEC_ID_NONE;
124	124	} else
125		− film->audio_type = CODEC_ID_NONE;
	125	+ film->audio_type = AV_CODEC_ID_NONE;
126	126	}
127	127
128	128	if (AV_RB32(&scratch[0]) != FDSC_TAG)
129	129	return AVERROR_INVALIDDATA;
130	130
131	131	if (AV_RB32(&scratch[8]) == CVID_TAG) {
132		− film->video_type = CODEC_ID_CINEPAK;
	132	+ film->video_type = AV_CODEC_ID_CINEPAK;
133	133	} else if (AV_RB32(&scratch[8]) == RAW_TAG) {
134		− film->video_type = CODEC_ID_RAWVIDEO;
	134	+ film->video_type = AV_CODEC_ID_RAWVIDEO;
135	135	} else {
136		− film->video_type = CODEC_ID_NONE;
	136	+ film->video_type = AV_CODEC_ID_NONE;
137	137	}
138	138
139	139	/* initialize the decoder streams */
@@ -148,7 +148,7 @@ static int film_read_header(AVFormatContext *s) · 8 unmodified lines
148	148	st->codec->width = AV_RB32(&scratch[16]);
149	149	st->codec->height = AV_RB32(&scratch[12]);
150	150
151		− if (film->video_type == CODEC_ID_RAWVIDEO) {
	151	+ if (film->video_type == AV_CODEC_ID_RAWVIDEO) {
152	152	if (scratch[20] == 24) {
153	153	st->codec->pix_fmt = PIX_FMT_RGB24;
154	154	} else {
@@ -169,7 +169,7 @@ static int film_read_header(AVFormatContext *s) · 14 unmodified lines
169	169	st->codec->channels = film->audio_channels;
170	170	st->codec->sample_rate = film->audio_samplerate;
171	171
172		− if (film->audio_type == CODEC_ID_ADPCM_ADX) {
	172	+ if (film->audio_type == AV_CODEC_ID_ADPCM_ADX) {
173	173	st->codec->bits_per_coded_sample = 18 * 8 / 32;
174	174	st->codec->block_align = st->codec->channels * 18;
175	175	st->need_parsing = AVSTREAM_PARSE_FULL;
@@ -218,10 +218,10 @@ static int film_read_header(AVFormatContext *s) · 42 unmodified lines
218	218	film->sample_table[i].stream = film->audio_stream_index;
219	219	film->sample_table[i].pts = audio_frame_counter;
220	220
221		− if (film->audio_type == CODEC_ID_ADPCM_ADX)
	221	+ if (film->audio_type == AV_CODEC_ID_ADPCM_ADX)
222	222	audio_frame_counter += (film->sample_table[i].sample_size * 32 /
223	223	(18 * film->audio_channels));
224		− else if (film->audio_type != CODEC_ID_NONE)
	224	+ else if (film->audio_type != AV_CODEC_ID_NONE)
225	225	audio_frame_counter += (film->sample_table[i].sample_size /
226	226	(film->audio_channels * film->audio_bits / 8));
227	227	} else {
@@ -256,14 +256,14 @@ static int film_read_packet(AVFormatContext *s, · 28 unmodified lines
256	256
257	257	/* do a special song and dance when loading FILM Cinepak chunks */
258	258	if ((sample->stream == film->video_stream_index) &&
259		− (film->video_type == CODEC_ID_CINEPAK)) {
	259	+ (film->video_type == AV_CODEC_ID_CINEPAK)) {
260	260	pkt->pos= avio_tell(pb);
261	261	if (av_new_packet(pkt, sample->sample_size))
262	262	return AVERROR(ENOMEM);
263	263	avio_read(pb, pkt->data, sample->sample_size);
264	264	} else if ((sample->stream == film->audio_stream_index) &&
265	265	(film->audio_channels == 2) &&
266		− (film->audio_type != CODEC_ID_ADPCM_ADX)) {
	266	+ (film->audio_type != AV_CODEC_ID_ADPCM_ADX)) {
267	267	/* stereo PCM needs to be interleaved */
268	268
269	269	if (av_new_packet(pkt, sample->sample_size))

libavformat/sierravmd.c+2−2

@@ -110,7 +110,7 @@ static int vmd_read_header(AVFormatContext *s) · 109 unmodified lines
110	110	avpriv_set_pts_info(vst, 33, 1, 10);
111	111	vmd->video_stream_index = vst->index;
112	112	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
113		− vst->codec->codec_id = vmd->is_indeo3 ? CODEC_ID_INDEO3 : CODEC_ID_VMDVIDEO;
	113	+ vst->codec->codec_id = vmd->is_indeo3 ? AV_CODEC_ID_INDEO3 : AV_CODEC_ID_VMDVIDEO;
114	114	vst->codec->codec_tag = 0; /* no fourcc */
115	115	vst->codec->width = AV_RL16(&vmd->vmd_header[12]);
116	116	vst->codec->height = AV_RL16(&vmd->vmd_header[14]);
@@ -130,7 +130,7 @@ static int vmd_read_header(AVFormatContext *s) · 13 unmodified lines
130	130	return AVERROR(ENOMEM);
131	131	vmd->audio_stream_index = st->index;
132	132	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
133		− st->codec->codec_id = CODEC_ID_VMDAUDIO;
	133	+ st->codec->codec_id = AV_CODEC_ID_VMDAUDIO;
134	134	st->codec->codec_tag = 0; /* no fourcc */
135	135	st->codec->channels = (vmd->vmd_header[811] & 0x80) ? 2 : 1;
136	136	st->codec->sample_rate = vmd->sample_rate;

libavformat/siff.c+2−2

@@ -76,7 +76,7 @@ static int create_audio_stream(AVFormatContext s, SIFFContext c) · 75 unmodified lines
76	76	if (!ast)
77	77	return -1;
78	78	ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
79		− ast->codec->codec_id = CODEC_ID_PCM_U8;
	79	+ ast->codec->codec_id = AV_CODEC_ID_PCM_U8;
80	80	ast->codec->channels = 1;
81	81	ast->codec->bits_per_coded_sample = 8;
82	82	ast->codec->sample_rate = c->rate;
@@ -120,7 +120,7 @@ static int siff_parse_vbv1(AVFormatContext s, SIFFContext c, AVIOContext *pb) · 37 unmodified lines
120	120	if (!st)
121	121	return -1;
122	122	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
123		− st->codec->codec_id = CODEC_ID_VB;
	123	+ st->codec->codec_id = AV_CODEC_ID_VB;
124	124	st->codec->codec_tag = MKTAG('V', 'B', 'V', '1');
125	125	st->codec->width = width;
126	126	st->codec->height = height;

libavformat/smacker.c+7−7

@@ -163,7 +163,7 @@ static int smacker_read_header(AVFormatContext *s) · 162 unmodified lines
163	163	st->codec->height = smk->height;
164	164	st->codec->pix_fmt = PIX_FMT_PAL8;
165	165	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
166		− st->codec->codec_id = CODEC_ID_SMACKVIDEO;
	166	+ st->codec->codec_id = AV_CODEC_ID_SMACKVIDEO;
167	167	st->codec->codec_tag = smk->magic;
168	168	/* Smacker uses 100000 as internal timebase */
169	169	if(smk->pts_inc < 0)
@@ -182,20 +182,20 @@ static int smacker_read_header(AVFormatContext *s) · 12 unmodified lines
182	182	smk->indexes[i] = ast[i]->index;
183	183	ast[i]->codec->codec_type = AVMEDIA_TYPE_AUDIO;
184	184	if (smk->aflags[i] & SMK_AUD_BINKAUD) {
185		− ast[i]->codec->codec_id = CODEC_ID_BINKAUDIO_RDFT;
	185	+ ast[i]->codec->codec_id = AV_CODEC_ID_BINKAUDIO_RDFT;
186	186	} else if (smk->aflags[i] & SMK_AUD_USEDCT) {
187		− ast[i]->codec->codec_id = CODEC_ID_BINKAUDIO_DCT;
	187	+ ast[i]->codec->codec_id = AV_CODEC_ID_BINKAUDIO_DCT;
188	188	} else if (smk->aflags[i] & SMK_AUD_PACKED){
189		− ast[i]->codec->codec_id = CODEC_ID_SMACKAUDIO;
	189	+ ast[i]->codec->codec_id = AV_CODEC_ID_SMACKAUDIO;
190	190	ast[i]->codec->codec_tag = MKTAG('S', 'M', 'K', 'A');
191	191	} else {
192		− ast[i]->codec->codec_id = CODEC_ID_PCM_U8;
	192	+ ast[i]->codec->codec_id = AV_CODEC_ID_PCM_U8;
193	193	}
194	194	ast[i]->codec->channels = (smk->aflags[i] & SMK_AUD_STEREO) ? 2 : 1;
195	195	ast[i]->codec->sample_rate = smk->rates[i];
196	196	ast[i]->codec->bits_per_coded_sample = (smk->aflags[i] & SMK_AUD_16BITS) ? 16 : 8;
197		− if(ast[i]->codec->bits_per_coded_sample == 16 && ast[i]->codec->codec_id == CODEC_ID_PCM_U8)
198		− ast[i]->codec->codec_id = CODEC_ID_PCM_S16LE;
	197	+ if(ast[i]->codec->bits_per_coded_sample == 16 && ast[i]->codec->codec_id == AV_CODEC_ID_PCM_U8)
	198	+ ast[i]->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
199	199	avpriv_set_pts_info(ast[i], 64, 1, ast[i]->codec->sample_rate
200	200	* ast[i]->codec->channels * ast[i]->codec->bits_per_coded_sample / 8);
201	201	}

libavformat/smjpeg.c+5−5

@@ -29,12 +29,12 @@ · 28 unmodified lines
29	29	#include "smjpeg.h"
30	30
31	31	const AVCodecTag ff_codec_smjpeg_video_tags[] = {
32		− { CODEC_ID_MJPEG, MKTAG('J', 'F', 'I', 'F') },
33		− { CODEC_ID_NONE, 0 },
	32	+ { AV_CODEC_ID_MJPEG, MKTAG('J', 'F', 'I', 'F') },
	33	+ { AV_CODEC_ID_NONE, 0 },
34	34	};
35	35
36	36	const AVCodecTag ff_codec_smjpeg_audio_tags[] = {
37		− { CODEC_ID_ADPCM_IMA_SMJPEG, MKTAG('A', 'P', 'C', 'M') },
38		− { CODEC_ID_PCM_S16LE, MKTAG('N', 'O', 'N', 'E') },
39		− { CODEC_ID_NONE, 0 },
	37	+ { AV_CODEC_ID_ADPCM_IMA_SMJPEG, MKTAG('A', 'P', 'C', 'M') },
	38	+ { AV_CODEC_ID_PCM_S16LE, MKTAG('N', 'O', 'N', 'E') },
	39	+ { AV_CODEC_ID_NONE, 0 },
40	40	};

libavformat/smjpegenc.c+2−2

@@ -139,8 +139,8 @@ AVOutputFormat ff_smjpeg_muxer = { · 138 unmodified lines
139	139	.name = "smjpeg",
140	140	.long_name = NULL_IF_CONFIG_SMALL("Loki SDL MJPEG"),
141	141	.priv_data_size = sizeof(SMJPEGMuxContext),
142		− .audio_codec = CODEC_ID_PCM_S16LE,
143		− .video_codec = CODEC_ID_MJPEG,
	142	+ .audio_codec = AV_CODEC_ID_PCM_S16LE,
	143	+ .video_codec = AV_CODEC_ID_MJPEG,
144	144	.write_header = smjpeg_write_header,
145	145	.write_packet = smjpeg_write_packet,
146	146	.write_trailer = smjpeg_write_trailer,

libavformat/sol.c+10−10

@@ -47,21 +47,21 @@ static int sol_probe(AVProbeData *p) · 46 unmodified lines
47	47	#define SOL_16BIT 4
48	48	#define SOL_STEREO 16
49	49
50		−static enum CodecID sol_codec_id(int magic, int type)
	50	+static enum AVCodecID sol_codec_id(int magic, int type)
51	51	{
52	52	if (magic == 0x0B8D)
53	53	{
54		− if (type & SOL_DPCM) return CODEC_ID_SOL_DPCM;
55		− else return CODEC_ID_PCM_U8;
	54	+ if (type & SOL_DPCM) return AV_CODEC_ID_SOL_DPCM;
	55	+ else return AV_CODEC_ID_PCM_U8;
56	56	}
57	57	if (type & SOL_DPCM)
58	58	{
59		− if (type & SOL_16BIT) return CODEC_ID_SOL_DPCM;
60		− else if (magic == 0x0C8D) return CODEC_ID_SOL_DPCM;
61		− else return CODEC_ID_SOL_DPCM;
	59	+ if (type & SOL_16BIT) return AV_CODEC_ID_SOL_DPCM;
	60	+ else if (magic == 0x0C8D) return AV_CODEC_ID_SOL_DPCM;
	61	+ else return AV_CODEC_ID_SOL_DPCM;
62	62	}
63		− if (type & SOL_16BIT) return CODEC_ID_PCM_S16LE;
64		− return CODEC_ID_PCM_U8;
	63	+ if (type & SOL_16BIT) return AV_CODEC_ID_PCM_S16LE;
	64	+ return AV_CODEC_ID_PCM_U8;
65	65	}
66	66
67	67	static int sol_codec_type(int magic, int type)
@@ -87,7 +87,7 @@ static int sol_read_header(AVFormatContext *s) · 19 unmodified lines
87	87	unsigned int magic,tag;
88	88	AVIOContext *pb = s->pb;
89	89	unsigned int id, channels, rate, type;
90		− enum CodecID codec;
	90	+ enum AVCodecID codec;
91	91	AVStream *st;
92	92
93	93	/* check ".snd" header */
@@ -104,7 +104,7 @@ static int sol_read_header(AVFormatContext *s) · 10 unmodified lines
104	104	codec = sol_codec_id(magic, type);
105	105	channels = sol_channels(magic, type);
106	106
107		− if (codec == CODEC_ID_SOL_DPCM)
	107	+ if (codec == AV_CODEC_ID_SOL_DPCM)
108	108	id = sol_codec_type(magic, type);
109	109	else id = 0;
110	110

libavformat/soxdec.c+2−2

@@ -58,14 +58,14 @@ static int sox_read_header(AVFormatContext *s) · 57 unmodified lines
58	58	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
59	59
60	60	if (avio_rl32(pb) == SOX_TAG) {
61		− st->codec->codec_id = CODEC_ID_PCM_S32LE;
	61	+ st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
62	62	header_size = avio_rl32(pb);
63	63	avio_skip(pb, 8); /* sample count */
64	64	sample_rate = av_int2double(avio_rl64(pb));
65	65	st->codec->channels = avio_rl32(pb);
66	66	comment_size = avio_rl32(pb);
67	67	} else {
68		− st->codec->codec_id = CODEC_ID_PCM_S32BE;
	68	+ st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
69	69	header_size = avio_rb32(pb);
70	70	avio_skip(pb, 8); /* sample count */
71	71	sample_rate = av_int2double(avio_rb64(pb));

libavformat/soxenc.c+5−5

@@ -55,14 +55,14 @@ static int sox_write_header(AVFormatContext *s) · 54 unmodified lines
55	55
56	56	sox->header_size = SOX_FIXED_HDR + comment_size;
57	57
58		− if (enc->codec_id == CODEC_ID_PCM_S32LE) {
	58	+ if (enc->codec_id == AV_CODEC_ID_PCM_S32LE) {
59	59	ffio_wfourcc(pb, ".SoX");
60	60	avio_wl32(pb, sox->header_size);
61	61	avio_wl64(pb, 0); /* number of samples */
62	62	avio_wl64(pb, av_double2int(enc->sample_rate));
63	63	avio_wl32(pb, enc->channels);
64	64	avio_wl32(pb, comment_size);
65		− } else if (enc->codec_id == CODEC_ID_PCM_S32BE) {
	65	+ } else if (enc->codec_id == AV_CODEC_ID_PCM_S32BE) {
66	66	ffio_wfourcc(pb, "XoS.");
67	67	avio_wb32(pb, sox->header_size);
68	68	avio_wb64(pb, 0); /* number of samples */
@@ -103,7 +103,7 @@ static int sox_write_trailer(AVFormatContext *s) · 34 unmodified lines
103	103	int64_t file_size = avio_tell(pb);
104	104	int64_t num_samples = (file_size - sox->header_size - 4LL) >> 2LL;
105	105	avio_seek(pb, 8, SEEK_SET);
106		− if (enc->codec_id == CODEC_ID_PCM_S32LE) {
	106	+ if (enc->codec_id == AV_CODEC_ID_PCM_S32LE) {
107	107	avio_wl64(pb, num_samples);
108	108	} else
109	109	avio_wb64(pb, num_samples);
@@ -120,8 +120,8 @@ AVOutputFormat ff_sox_muxer = { · 10 unmodified lines
120	120	.long_name = NULL_IF_CONFIG_SMALL("SoX native"),
121	121	.extensions = "sox",
122	122	.priv_data_size = sizeof(SoXContext),
123		− .audio_codec = CODEC_ID_PCM_S32LE,
124		− .video_codec = CODEC_ID_NONE,
	123	+ .audio_codec = AV_CODEC_ID_PCM_S32LE,
	124	+ .video_codec = AV_CODEC_ID_NONE,
125	125	.write_header = sox_write_header,
126	126	.write_packet = sox_write_packet,
127	127	.write_trailer = sox_write_trailer,

libavformat/spdifdec.c+14−14

@@ -33,7 +33,7 @@ · 32 unmodified lines
33	33	static int spdif_get_offset_and_codec(AVFormatContext *s,
34	34	enum IEC61937DataType data_type,
35	35	const char buf, int offset,
36		− enum CodecID *codec)
	36	+ enum AVCodecID *codec)
37	37	{
38	38	AACADTSHeaderInfo aac_hdr;
39	39	GetBitContext gbc;
@@ -41,19 +41,19 @@ static int spdif_get_offset_and_codec(AVFormatContext *s, · 1 unmodified line
41	41	switch (data_type & 0xff) {
42	42	case IEC61937_AC3:
43	43	*offset = AC3_FRAME_SIZE << 2;
44		− *codec = CODEC_ID_AC3;
	44	+ *codec = AV_CODEC_ID_AC3;
45	45	break;
46	46	case IEC61937_MPEG1_LAYER1:
47	47	*offset = spdif_mpeg_pkt_offset[1][0];
48		− *codec = CODEC_ID_MP1;
	48	+ *codec = AV_CODEC_ID_MP1;
49	49	break;
50	50	case IEC61937_MPEG1_LAYER23:
51	51	*offset = spdif_mpeg_pkt_offset[1][0];
52		− *codec = CODEC_ID_MP3;
	52	+ *codec = AV_CODEC_ID_MP3;
53	53	break;
54	54	case IEC61937_MPEG2_EXT:
55	55	*offset = 4608;
56		− *codec = CODEC_ID_MP3;
	56	+ *codec = AV_CODEC_ID_MP3;
57	57	break;
58	58	case IEC61937_MPEG2_AAC:
59	59	init_get_bits(&gbc, buf, AAC_ADTS_HEADER_SIZE * 8);
@@ -63,31 +63,31 @@ static int spdif_get_offset_and_codec(AVFormatContext *s, · 3 unmodified lines
63	63	return AVERROR_INVALIDDATA;
64	64	}
65	65	*offset = aac_hdr.samples << 2;
66		− *codec = CODEC_ID_AAC;
	66	+ *codec = AV_CODEC_ID_AAC;
67	67	break;
68	68	case IEC61937_MPEG2_LAYER1_LSF:
69	69	*offset = spdif_mpeg_pkt_offset[0][0];
70		− *codec = CODEC_ID_MP1;
	70	+ *codec = AV_CODEC_ID_MP1;
71	71	break;
72	72	case IEC61937_MPEG2_LAYER2_LSF:
73	73	*offset = spdif_mpeg_pkt_offset[0][1];
74		− *codec = CODEC_ID_MP2;
	74	+ *codec = AV_CODEC_ID_MP2;
75	75	break;
76	76	case IEC61937_MPEG2_LAYER3_LSF:
77	77	*offset = spdif_mpeg_pkt_offset[0][2];
78		− *codec = CODEC_ID_MP3;
	78	+ *codec = AV_CODEC_ID_MP3;
79	79	break;
80	80	case IEC61937_DTS1:
81	81	*offset = 2048;
82		− *codec = CODEC_ID_DTS;
	82	+ *codec = AV_CODEC_ID_DTS;
83	83	break;
84	84	case IEC61937_DTS2:
85	85	*offset = 4096;
86		− *codec = CODEC_ID_DTS;
	86	+ *codec = AV_CODEC_ID_DTS;
87	87	break;
88	88	case IEC61937_DTS3:
89	89	*offset = 8192;
90		− *codec = CODEC_ID_DTS;
	90	+ *codec = AV_CODEC_ID_DTS;
91	91	break;
92	92	default:
93	93	if (s) { /* be silent during a probe */
@@ -112,7 +112,7 @@ static int spdif_probe(AVProbeData *p) · 18 unmodified lines
112	112	int sync_codes = 0;
113	113	int consecutive_codes = 0;
114	114	int offset;
115		− enum CodecID codec;
	115	+ enum AVCodecID codec;
116	116
117	117	for (; buf < probe_end; buf++) {
118	118	state = (state << 8) \| *buf;
@@ -165,7 +165,7 @@ static int spdif_read_packet(AVFormatContext s, AVPacket pkt) · 46 unmodified lines
165	165	{
166	166	AVIOContext *pb = s->pb;
167	167	enum IEC61937DataType data_type;
168		− enum CodecID codec_id;
	168	+ enum AVCodecID codec_id;
169	169	uint32_t state = 0;
170	170	int pkt_size_bits, offset, ret;
171	171

libavformat/spdifenc.c+10−10

@@ -442,24 +442,24 @@ static int spdif_write_header(AVFormatContext *s) · 441 unmodified lines
442	442	IEC61937Context *ctx = s->priv_data;
443	443
444	444	switch (s->streams[0]->codec->codec_id) {
445		− case CODEC_ID_AC3:
	445	+ case AV_CODEC_ID_AC3:
446	446	ctx->header_info = spdif_header_ac3;
447	447	break;
448		− case CODEC_ID_EAC3:
	448	+ case AV_CODEC_ID_EAC3:
449	449	ctx->header_info = spdif_header_eac3;
450	450	break;
451		− case CODEC_ID_MP1:
452		− case CODEC_ID_MP2:
453		− case CODEC_ID_MP3:
	451	+ case AV_CODEC_ID_MP1:
	452	+ case AV_CODEC_ID_MP2:
	453	+ case AV_CODEC_ID_MP3:
454	454	ctx->header_info = spdif_header_mpeg;
455	455	break;
456		− case CODEC_ID_DTS:
	456	+ case AV_CODEC_ID_DTS:
457	457	ctx->header_info = spdif_header_dts;
458	458	break;
459		− case CODEC_ID_AAC:
	459	+ case AV_CODEC_ID_AAC:
460	460	ctx->header_info = spdif_header_aac;
461	461	break;
462		− case CODEC_ID_TRUEHD:
	462	+ case AV_CODEC_ID_TRUEHD:
463	463	ctx->header_info = spdif_header_truehd;
464	464	ctx->hd_buf = av_malloc(MAT_FRAME_SIZE);
465	465	if (!ctx->hd_buf)
@@ -547,8 +547,8 @@ AVOutputFormat ff_spdif_muxer = { · 81 unmodified lines
547	547	.long_name = NULL_IF_CONFIG_SMALL("IEC 61937 (used on S/PDIF - IEC958)"),
548	548	.extensions = "spdif",
549	549	.priv_data_size = sizeof(IEC61937Context),
550		− .audio_codec = CODEC_ID_AC3,
551		− .video_codec = CODEC_ID_NONE,
	550	+ .audio_codec = AV_CODEC_ID_AC3,
	551	+ .video_codec = AV_CODEC_ID_NONE,
552	552	.write_header = spdif_write_header,
553	553	.write_packet = spdif_write_packet,
554	554	.write_trailer = spdif_write_trailer,

libavformat/srtdec.c+1−1

@@ -47,7 +47,7 @@ static int srt_read_header(AVFormatContext *s) · 46 unmodified lines
47	47	return -1;
48	48	avpriv_set_pts_info(st, 64, 1, 1000);
49	49	st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
50		− st->codec->codec_id = CODEC_ID_SRT;
	50	+ st->codec->codec_id = AV_CODEC_ID_SRT;
51	51	return 0;
52	52	}
53	53

libavformat/swf.h+9−9

@@ -79,18 +79,18 @@ typedef struct { · 78 unmodified lines
79	79	} SWFContext;
80	80
81	81	static const AVCodecTag swf_codec_tags[] = {
82		− {CODEC_ID_FLV1, 0x02},
83		− {CODEC_ID_VP6F, 0x04},
84		− {CODEC_ID_NONE, 0},
	82	+ { AV_CODEC_ID_FLV1, 0x02},
	83	+ { AV_CODEC_ID_VP6F, 0x04},
	84	+ { AV_CODEC_ID_NONE, 0},
85	85	};
86	86
87	87	static const AVCodecTag swf_audio_codec_tags[] = {
88		− {CODEC_ID_PCM_S16LE, 0x00},
89		− {CODEC_ID_ADPCM_SWF, 0x01},
90		− {CODEC_ID_MP3, 0x02},
91		− {CODEC_ID_PCM_S16LE, 0x03},
92		− //{CODEC_ID_NELLYMOSER, 0x06},
93		− {CODEC_ID_NONE, 0},
	88	+ { AV_CODEC_ID_PCM_S16LE, 0x00},
	89	+ { AV_CODEC_ID_ADPCM_SWF, 0x01},
	90	+ { AV_CODEC_ID_MP3, 0x02},
	91	+ { AV_CODEC_ID_PCM_S16LE, 0x03},
	92	+ //{ AV_CODEC_ID_NELLYMOSER, 0x06},
	93	+ { AV_CODEC_ID_NONE, 0},
94	94	};
95	95
96	96	#endif /* AVFORMAT_SWF_H */

libavformat/swfdec.c+3−3

@@ -158,7 +158,7 @@ static int swf_read_packet(AVFormatContext s, AVPacket pkt) · 157 unmodified lines
158	158	for (i = 0; i < s->nb_streams; i++) {
159	159	st = s->streams[i];
160	160	if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {
161		− if (st->codec->codec_id == CODEC_ID_MP3) {
	161	+ if (st->codec->codec_id == AV_CODEC_ID_MP3) {
162	162	avio_skip(pb, 4);
163	163	if ((res = av_get_packet(pb, pkt, len-4)) < 0)
164	164	return res;
@@ -174,7 +174,7 @@ static int swf_read_packet(AVFormatContext s, AVPacket pkt) · 9 unmodified lines
174	174	} else if (tag == TAG_JPEG2) {
175	175	for (i=0; i<s->nb_streams; i++) {
176	176	st = s->streams[i];
177		− if (st->codec->codec_id == CODEC_ID_MJPEG && st->id == -2)
	177	+ if (st->codec->codec_id == AV_CODEC_ID_MJPEG && st->id == -2)
178	178	break;
179	179	}
180	180	if (i == s->nb_streams) {
@@ -183,7 +183,7 @@ static int swf_read_packet(AVFormatContext s, AVPacket pkt) · 2 unmodified lines
183	183	return -1;
184	184	vst->id = -2; /* -2 to avoid clash with video stream and audio stream */
185	185	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
186		− vst->codec->codec_id = CODEC_ID_MJPEG;
	186	+ vst->codec->codec_id = AV_CODEC_ID_MJPEG;
187	187	avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
188	188	st = vst;
189	189	}

libavformat/swfenc.c+15−15

@@ -186,7 +186,7 @@ static int swf_write_header(AVFormatContext *s) · 185 unmodified lines
186	186	for(i=0;i<s->nb_streams;i++) {
187	187	AVCodecContext *enc = s->streams[i]->codec;
188	188	if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
189		− if (enc->codec_id == CODEC_ID_MP3) {
	189	+ if (enc->codec_id == AV_CODEC_ID_MP3) {
190	190	swf->audio_enc = enc;
191	191	swf->audio_fifo= av_fifo_alloc(AUDIO_FIFO_SIZE);
192	192	if (!swf->audio_fifo)
@@ -196,9 +196,9 @@ static int swf_write_header(AVFormatContext *s) · 3 unmodified lines
196	196	return -1;
197	197	}
198	198	} else {
199		− if (enc->codec_id == CODEC_ID_VP6F \|\|
200		− enc->codec_id == CODEC_ID_FLV1 \|\|
201		− enc->codec_id == CODEC_ID_MJPEG) {
	199	+ if (enc->codec_id == AV_CODEC_ID_VP6F \|\|
	200	+ enc->codec_id == AV_CODEC_ID_FLV1 \|\|
	201	+ enc->codec_id == AV_CODEC_ID_MJPEG) {
202	202	swf->video_enc = enc;
203	203	} else {
204	204	av_log(s, AV_LOG_ERROR, "SWF muxer only supports VP6, FLV1 and MJPEG\n");
@@ -229,9 +229,9 @@ static int swf_write_header(AVFormatContext *s) · 24 unmodified lines
229	229
230	230	if (!strcmp("avm2", s->oformat->name))
231	231	version = 9;
232		− else if (swf->video_enc && swf->video_enc->codec_id == CODEC_ID_VP6F)
	232	+ else if (swf->video_enc && swf->video_enc->codec_id == AV_CODEC_ID_VP6F)
233	233	version = 8; /* version 8 and above support VP6 codec */
234		− else if (swf->video_enc && swf->video_enc->codec_id == CODEC_ID_FLV1)
	234	+ else if (swf->video_enc && swf->video_enc->codec_id == AV_CODEC_ID_FLV1)
235	235	version = 6; /* version 6 and above support FLV1 codec */
236	236	else
237	237	version = 4; /* version 4 for mpeg audio support */
@@ -253,7 +253,7 @@ static int swf_write_header(AVFormatContext *s) · 15 unmodified lines
253	253	}
254	254
255	255	/* define a shape with the jpeg inside */
256		− if (swf->video_enc && swf->video_enc->codec_id == CODEC_ID_MJPEG) {
	256	+ if (swf->video_enc && swf->video_enc->codec_id == AV_CODEC_ID_MJPEG) {
257	257	put_swf_tag(s, TAG_DEFINESHAPE);
258	258
259	259	avio_wl16(pb, SHAPE_ID); /* ID of shape */
@@ -296,7 +296,7 @@ static int swf_write_header(AVFormatContext *s) · 36 unmodified lines
296	296	put_swf_end_tag(s);
297	297	}
298	298
299		− if (swf->audio_enc && swf->audio_enc->codec_id == CODEC_ID_MP3) {
	299	+ if (swf->audio_enc && swf->audio_enc->codec_id == AV_CODEC_ID_MP3) {
300	300	int v = 0;
301	301
302	302	/* start sound */
@@ -336,8 +336,8 @@ static int swf_write_video(AVFormatContext *s, · 33 unmodified lines
336	336	if (swf->swf_frame_number == 16000)
337	337	av_log(enc, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
338	338
339		− if (enc->codec_id == CODEC_ID_VP6F \|\|
340		− enc->codec_id == CODEC_ID_FLV1) {
	339	+ if (enc->codec_id == AV_CODEC_ID_VP6F \|\|
	340	+ enc->codec_id == AV_CODEC_ID_FLV1) {
341	341	if (swf->video_frame_number == 0) {
342	342	/* create a new video object */
343	343	put_swf_tag(s, TAG_VIDEOSTREAM);
@@ -375,7 +375,7 @@ static int swf_write_video(AVFormatContext *s, · 31 unmodified lines
375	375	avio_wl16(pb, swf->video_frame_number++);
376	376	avio_write(pb, buf, size);
377	377	put_swf_end_tag(s);
378		− } else if (enc->codec_id == CODEC_ID_MJPEG) {
	378	+ } else if (enc->codec_id == AV_CODEC_ID_MJPEG) {
379	379	if (swf->swf_frame_number > 0) {
380	380	/* remove the shape */
381	381	put_swf_tag(s, TAG_REMOVEOBJECT);
@@ -508,8 +508,8 @@ AVOutputFormat ff_swf_muxer = { · 126 unmodified lines
508	508	.mime_type = "application/x-shockwave-flash",
509	509	.extensions = "swf",
510	510	.priv_data_size = sizeof(SWFContext),
511		− .audio_codec = CODEC_ID_MP3,
512		− .video_codec = CODEC_ID_FLV1,
	511	+ .audio_codec = AV_CODEC_ID_MP3,
	512	+ .video_codec = AV_CODEC_ID_FLV1,
513	513	.write_header = swf_write_header,
514	514	.write_packet = swf_write_packet,
515	515	.write_trailer = swf_write_trailer,
@@ -522,8 +522,8 @@ AVOutputFormat ff_avm2_muxer = { · 6 unmodified lines
522	522	.long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash) (AVM2)"),
523	523	.mime_type = "application/x-shockwave-flash",
524	524	.priv_data_size = sizeof(SWFContext),
525		− .audio_codec = CODEC_ID_MP3,
526		− .video_codec = CODEC_ID_FLV1,
	525	+ .audio_codec = AV_CODEC_ID_MP3,
	526	+ .video_codec = AV_CODEC_ID_FLV1,
527	527	.write_header = swf_write_header,
528	528	.write_packet = swf_write_packet,
529	529	.write_trailer = swf_write_trailer,

libavformat/thp.c+2−2

@@ -102,7 +102,7 @@ static int thp_read_header(AVFormatContext *s) · 101 unmodified lines
102	102	is required. */
103	103	avpriv_set_pts_info(st, 64, thp->fps.den, thp->fps.num);
104	104	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
105		− st->codec->codec_id = CODEC_ID_THP;
	105	+ st->codec->codec_id = AV_CODEC_ID_THP;
106	106	st->codec->codec_tag = 0; /* no fourcc */
107	107	st->codec->width = avio_rb32(pb);
108	108	st->codec->height = avio_rb32(pb);
@@ -122,7 +122,7 @@ static int thp_read_header(AVFormatContext *s) · 13 unmodified lines
122	122	return AVERROR(ENOMEM);
123	123
124	124	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
125		− st->codec->codec_id = CODEC_ID_ADPCM_THP;
	125	+ st->codec->codec_id = AV_CODEC_ID_ADPCM_THP;
126	126	st->codec->codec_tag = 0; /* no fourcc */
127	127	st->codec->channels = avio_rb32(pb); /* numChannels. */
128	128	st->codec->sample_rate = avio_rb32(pb); /* Frequency. */

libavformat/tiertexseq.c+2−2

@@ -214,7 +214,7 @@ static int seq_read_header(AVFormatContext *s) · 213 unmodified lines
214	214	avpriv_set_pts_info(st, 32, 1, SEQ_FRAME_RATE);
215	215	seq->video_stream_index = st->index;
216	216	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
217		− st->codec->codec_id = CODEC_ID_TIERTEXSEQVIDEO;
	217	+ st->codec->codec_id = AV_CODEC_ID_TIERTEXSEQVIDEO;
218	218	st->codec->codec_tag = 0; /* no fourcc */
219	219	st->codec->width = SEQ_FRAME_W;
220	220	st->codec->height = SEQ_FRAME_H;
@@ -228,7 +228,7 @@ static int seq_read_header(AVFormatContext *s) · 7 unmodified lines
228	228	avpriv_set_pts_info(st, 32, 1, SEQ_SAMPLE_RATE);
229	229	seq->audio_stream_index = st->index;
230	230	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
231		− st->codec->codec_id = CODEC_ID_PCM_S16BE;
	231	+ st->codec->codec_id = AV_CODEC_ID_PCM_S16BE;
232	232	st->codec->codec_tag = 0; /* no tag */
233	233	st->codec->channels = 1;
234	234	st->codec->sample_rate = SEQ_SAMPLE_RATE;

libavformat/tmv.c+2−2

@@ -111,7 +111,7 @@ static int tmv_read_header(AVFormatContext *s) · 110 unmodified lines
111	111	}
112	112
113	113	ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
114		− ast->codec->codec_id = CODEC_ID_PCM_U8;
	114	+ ast->codec->codec_id = AV_CODEC_ID_PCM_U8;
115	115	ast->codec->channels = features & TMV_STEREO ? 2 : 1;
116	116	ast->codec->bits_per_coded_sample = 8;
117	117	ast->codec->bit_rate = ast->codec->sample_rate *
@@ -123,7 +123,7 @@ static int tmv_read_header(AVFormatContext *s) · 5 unmodified lines
123	123	av_reduce(&fps.num, &fps.den, fps.num, fps.den, 0xFFFFFFFFLL);
124	124
125	125	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
126		− vst->codec->codec_id = CODEC_ID_TMV;
	126	+ vst->codec->codec_id = AV_CODEC_ID_TMV;
127	127	vst->codec->pix_fmt = PIX_FMT_PAL8;
128	128	vst->codec->width = char_cols * 8;
129	129	vst->codec->height = char_rows * 8;

libavformat/tta.c+1−1

@@ -102,7 +102,7 @@ static int tta_read_header(AVFormatContext *s) · 101 unmodified lines
102	102	avio_skip(s->pb, 4); // seektable crc
103	103
104	104	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
105		− st->codec->codec_id = CODEC_ID_TTA;
	105	+ st->codec->codec_id = AV_CODEC_ID_TTA;
106	106	st->codec->channels = channels;
107	107	st->codec->sample_rate = samplerate;
108	108	st->codec->bits_per_coded_sample = bps;

libavformat/tty.c+1−1

@@ -85,7 +85,7 @@ static int read_header(AVFormatContext *avctx) · 84 unmodified lines
85	85	}
86	86	st->codec->codec_tag = 0;
87	87	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
88		− st->codec->codec_id = CODEC_ID_ANSI;
	88	+ st->codec->codec_id = AV_CODEC_ID_ANSI;
89	89
90	90	if (s->video_size && (ret = av_parse_video_size(&width, &height, s->video_size)) < 0) {
91	91	av_log (avctx, AV_LOG_ERROR, "Couldn't parse video size.\n");

libavformat/txd.c+1−1

@@ -44,7 +44,7 @@ static int txd_read_header(AVFormatContext *s) { · 43 unmodified lines
44	44	if (!st)
45	45	return AVERROR(ENOMEM);
46	46	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
47		− st->codec->codec_id = CODEC_ID_TXD;
	47	+ st->codec->codec_id = AV_CODEC_ID_TXD;
48	48	st->codec->time_base.den = 5;
49	49	st->codec->time_base.num = 1;
50	50	/* the parameters will be extracted from the compressed bitstream */

libavformat/utils.c+54−54

@@ -208,7 +208,7 @@ AVOutputFormat av_guess_format(const char short_name, const char *filename, · 207 unmodified lines
208	208	#if CONFIG_IMAGE2_MUXER
209	209	if (!short_name && filename &&
210	210	av_filename_number_test(filename) &&
211		− ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
	211	+ ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
212	212	return av_guess_format("image2", NULL, NULL);
213	213	}
214	214	#endif
@@ -233,17 +233,17 @@ AVOutputFormat av_guess_format(const char short_name, const char *filename, · 18 unmodified lines
233	233	return fmt_found;
234	234	}
235	235
236		−enum CodecID av_guess_codec(AVOutputFormat fmt, const char short_name,
	236	+enum AVCodecID av_guess_codec(AVOutputFormat fmt, const char short_name,
237	237	const char filename, const char mime_type, enum AVMediaType type){
238	238	if(type == AVMEDIA_TYPE_VIDEO){
239		− enum CodecID codec_id= CODEC_ID_NONE;
	239	+ enum AVCodecID codec_id= AV_CODEC_ID_NONE;
240	240
241	241	#if CONFIG_IMAGE2_MUXER
242	242	if(!strcmp(fmt->name, "image2") \|\| !strcmp(fmt->name, "image2pipe")){
243	243	codec_id= ff_guess_image2_codec(filename);
244	244	}
245	245	#endif
246		− if(codec_id == CODEC_ID_NONE)
	246	+ if(codec_id == AV_CODEC_ID_NONE)
247	247	codec_id= fmt->video_codec;
248	248	return codec_id;
249	249	}else if(type == AVMEDIA_TYPE_AUDIO)
@@ -251,7 +251,7 @@ enum CodecID av_guess_codec(AVOutputFormat fmt, const char short_name, · 1 unmodified line
251	251	else if (type == AVMEDIA_TYPE_SUBTITLE)
252	252	return fmt->subtitle_codec;
253	253	else
254		− return CODEC_ID_NONE;
	254	+ return AV_CODEC_ID_NONE;
255	255	}
256	256
257	257	AVInputFormat av_find_input_format(const char short_name)
@@ -367,16 +367,16 @@ AVInputFormat av_probe_input_format(AVProbeData pd, int is_opened){ · 109 unmodified lines
367	367	static int set_codec_from_probe_data(AVFormatContext s, AVStream st, AVProbeData *pd, int score)
368	368	{
369	369	static const struct {
370		− const char *name; enum CodecID id; enum AVMediaType type;
	370	+ const char *name; enum AVCodecID id; enum AVMediaType type;
371	371	} fmt_id_type[] = {
372		− { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
373		− { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
374		− { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
375		− { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
376		− { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
377		− { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
378		− { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
379		− { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
	372	+ { "aac" , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
	373	+ { "ac3" , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
	374	+ { "dts" , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
	375	+ { "eac3" , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
	376	+ { "h264" , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
	377	+ { "m4v" , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
	378	+ { "mp3" , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
	379	+ { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
380	380	{ 0 }
381	381	};
382	382	AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
@@ -613,7 +613,7 @@ fail: · 230 unmodified lines
613	613
614	614	static void probe_codec(AVFormatContext s, AVStream st, const AVPacket *pkt)
615	615	{
616		− if(st->codec->codec_id == CODEC_ID_PROBE){
	616	+ if(st->codec->codec_id == AV_CODEC_ID_PROBE){
617	617	AVProbeData *pd = &st->probe_data;
618	618	av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
619	619	--st->probe_packets;
@@ -630,7 +630,7 @@ static void probe_codec(AVFormatContext s, AVStream st, const AVPacket *pkt) · 10 unmodified lines
630	630	if (!st->probe_packets \|\|
631	631	av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
632	632	set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
633		− if(st->codec->codec_id != CODEC_ID_PROBE){
	633	+ if(st->codec->codec_id != AV_CODEC_ID_PROBE){
634	634	pd->buf_size=0;
635	635	av_freep(&pd->buf);
636	636	av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
@@ -650,7 +650,7 @@ int ff_read_packet(AVFormatContext s, AVPacket pkt) · 13 unmodified lines
650	650	if (pktl) {
651	651	*pkt = pktl->pkt;
652	652	st = s->streams[pkt->stream_index];
653		− if (st->codec->codec_id != CODEC_ID_PROBE \|\| !st->probe_packets \|\|
	653	+ if (st->codec->codec_id != AV_CODEC_ID_PROBE \|\| !st->probe_packets \|\|
654	654	s->raw_packet_buffer_remaining_size < pkt->size) {
655	655	AVProbeData *pd;
656	656	if (st->probe_packets) {
@@ -703,7 +703,7 @@ int ff_read_packet(AVFormatContext s, AVPacket pkt) · 46 unmodified lines
703	703	break;
704	704	}
705	705
706		− if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE \|\|
	706	+ if(!pktl && (st->codec->codec_id != AV_CODEC_ID_PROBE \|\|
707	707	!st->probe_packets))
708	708	return ret;
709	709
@@ -794,20 +794,20 @@ static int is_intra_only(AVCodecContext *enc){ · 84 unmodified lines
794	794	return 1;
795	795	}else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
796	796	switch(enc->codec_id){
797		− case CODEC_ID_MJPEG:
798		− case CODEC_ID_MJPEGB:
799		− case CODEC_ID_LJPEG:
800		− case CODEC_ID_PRORES:
801		− case CODEC_ID_RAWVIDEO:
802		− case CODEC_ID_DVVIDEO:
803		− case CODEC_ID_HUFFYUV:
804		− case CODEC_ID_FFVHUFF:
805		− case CODEC_ID_ASV1:
806		− case CODEC_ID_ASV2:
807		− case CODEC_ID_VCR1:
808		− case CODEC_ID_DNXHD:
809		− case CODEC_ID_JPEG2000:
810		− case CODEC_ID_MDEC:
	797	+ case AV_CODEC_ID_MJPEG:
	798	+ case AV_CODEC_ID_MJPEGB:
	799	+ case AV_CODEC_ID_LJPEG:
	800	+ case AV_CODEC_ID_PRORES:
	801	+ case AV_CODEC_ID_RAWVIDEO:
	802	+ case AV_CODEC_ID_DVVIDEO:
	803	+ case AV_CODEC_ID_HUFFYUV:
	804	+ case AV_CODEC_ID_FFVHUFF:
	805	+ case AV_CODEC_ID_ASV1:
	806	+ case AV_CODEC_ID_ASV2:
	807	+ case AV_CODEC_ID_VCR1:
	808	+ case AV_CODEC_ID_DNXHD:
	809	+ case AV_CODEC_ID_JPEG2000:
	810	+ case AV_CODEC_ID_MDEC:
811	811	return 1;
812	812	default: break;
813	813	}
@@ -964,7 +964,7 @@ static void compute_pkt_fields(AVFormatContext s, AVStream st, · 150 unmodified lines
964	964	// av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
965	965	/* interpolate PTS and DTS if they are not present */
966	966	//We skip H264 currently because delay and has_b_frames are not reliably set
967		− if((delay==0 \|\| (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
	967	+ if((delay==0 \|\| (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
968	968	if (presentation_delayed) {
969	969	/* DTS = decompression timestamp */
970	970	/* PTS = presentation timestamp */
@@ -1024,7 +1024,7 @@ static void compute_pkt_fields(AVFormatContext s, AVStream st, · 53 unmodified lines
1024	1024	FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1025	1025	if(pkt->dts == AV_NOPTS_VALUE)
1026	1026	pkt->dts= st->pts_buffer[0];
1027		− if(st->codec->codec_id == CODEC_ID_H264){ // we skipped it above so we try here
	1027	+ if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1028	1028	update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1029	1029	}
1030	1030	if(pkt->dts > st->cur_dts)
@@ -2079,12 +2079,12 @@ static int has_codec_parameters(AVStream *st) · 1048 unmodified lines
2079	2079	val = 1;
2080	2080	break;
2081	2081	}
2082		− return avctx->codec_id != CODEC_ID_NONE && val != 0;
	2082	+ return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
2083	2083	}
2084	2084
2085	2085	static int has_decode_delay_been_guessed(AVStream *st)
2086	2086	{
2087		− return st->codec->codec_id != CODEC_ID_H264 \|\|
	2087	+ return st->codec->codec_id != AV_CODEC_ID_H264 \|\|
2088	2088	st->info->nb_decoded_frames >= 6;
2089	2089	}
2090	2090
@@ -2153,9 +2153,9 @@ static int try_decode_frame(AVStream st, AVPacket avpkt, AVDictionary **option · 62 unmodified lines
2153	2153	return ret;
2154	2154	}
2155	2155
2156		−unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
	2156	+unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2157	2157	{
2158		− while (tags->id != CODEC_ID_NONE) {
	2158	+ while (tags->id != AV_CODEC_ID_NONE) {
2159	2159	if (tags->id == id)
2160	2160	return tags->tag;
2161	2161	tags++;
@@ -2163,21 +2163,21 @@ unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id) · 1 unmodified line
2163	2163	return 0;
2164	2164	}
2165	2165
2166		−enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
	2166	+enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2167	2167	{
2168	2168	int i;
2169		− for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
	2169	+ for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2170	2170	if(tag == tags[i].tag)
2171	2171	return tags[i].id;
2172	2172	}
2173		− for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
	2173	+ for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2174	2174	if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2175	2175	return tags[i].id;
2176	2176	}
2177		− return CODEC_ID_NONE;
	2177	+ return AV_CODEC_ID_NONE;
2178	2178	}
2179	2179
2180		−unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
	2180	+unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2181	2181	{
2182	2182	int i;
2183	2183	for(i=0; tags && tags[i]; i++){
@@ -2187,14 +2187,14 @@ unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id) · 3 unmodified lines
2187	2187	return 0;
2188	2188	}
2189	2189
2190		−enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
	2190	+enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2191	2191	{
2192	2192	int i;
2193	2193	for(i=0; tags && tags[i]; i++){
2194		− enum CodecID id= ff_codec_get_id(tags[i], tag);
2195		− if(id!=CODEC_ID_NONE) return id;
	2194	+ enum AVCodecID id= ff_codec_get_id(tags[i], tag);
	2195	+ if(id!=AV_CODEC_ID_NONE) return id;
2196	2196	}
2197		− return CODEC_ID_NONE;
	2197	+ return AV_CODEC_ID_NONE;
2198	2198	}
2199	2199
2200	2200	static void compute_chapters_end(AVFormatContext *s)
@@ -2236,8 +2236,8 @@ static int tb_unreliable(AVCodecContext *c){ · 35 unmodified lines
2236	2236	\|\| c->time_base.den < 5L*c->time_base.num
2237	2237	/* \|\| c->codec_tag == AV_RL32("DIVX")
2238	2238	\|\| c->codec_tag == AV_RL32("XVID")*/
2239		− \|\| c->codec_id == CODEC_ID_MPEG2VIDEO
2240		− \|\| c->codec_id == CODEC_ID_H264
	2239	+ \|\| c->codec_id == AV_CODEC_ID_MPEG2VIDEO
	2240	+ \|\| c->codec_id == AV_CODEC_ID_H264
2241	2241	)
2242	2242	return 1;
2243	2243	return 0;
@@ -2820,7 +2820,7 @@ static int validate_codec_tag(AVFormatContext s, AVStream st) · 576 unmodified lines
2820	2820	{
2821	2821	const AVCodecTag *avctag;
2822	2822	int n;
2823		− enum CodecID id = CODEC_ID_NONE;
	2823	+ enum AVCodecID id = AV_CODEC_ID_NONE;
2824	2824	unsigned int tag = 0;
2825	2825
2826	2826	/**
@@ -2831,7 +2831,7 @@ static int validate_codec_tag(AVFormatContext s, AVStream st) · 4 unmodified lines
2831	2831	*/
2832	2832	for (n = 0; s->oformat->codec_tag[n]; n++) {
2833	2833	avctag = s->oformat->codec_tag[n];
2834		− while (avctag->id != CODEC_ID_NONE) {
	2834	+ while (avctag->id != AV_CODEC_ID_NONE) {
2835	2835	if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2836	2836	id = avctag->id;
2837	2837	if (id == st->codec->codec_id)
@@ -2842,7 +2842,7 @@ static int validate_codec_tag(AVFormatContext s, AVStream st) · 4 unmodified lines
2842	2842	avctag++;
2843	2843	}
2844	2844	}
2845		− if (id != CODEC_ID_NONE)
	2845	+ if (id != AV_CODEC_ID_NONE)
2846	2846	return 0;
2847	2847	if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2848	2848	return 0;
@@ -2905,7 +2905,7 @@ int avformat_write_header(AVFormatContext s, AVDictionary *options) · 56 unmodified lines
2905	2905	}
2906	2906
2907	2907	if(s->oformat->codec_tag){
2908		− if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
	2908	+ if(st->codec->codec_tag && st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
2909	2909	//the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2910	2910	st->codec->codec_tag= 0;
2911	2911	}
@@ -3927,7 +3927,7 @@ int64_t ff_iso8601_to_unix_time(const char *datestr) · 1015 unmodified lines
3927	3927	#endif
3928	3928	}
3929	3929
3930		−int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
	3930	+int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
3931	3931	{
3932	3932	if (ofmt) {
3933	3933	if (ofmt->query_codec)

libavformat/vc1test.c+1−1

@@ -59,7 +59,7 @@ static int vc1t_read_header(AVFormatContext *s) · 58 unmodified lines
59	59	return -1;
60	60
61	61	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
62		− st->codec->codec_id = CODEC_ID_WMV3;
	62	+ st->codec->codec_id = AV_CODEC_ID_WMV3;
63	63
64	64	st->codec->extradata = av_malloc(VC1_EXTRADATA_SIZE);
65	65	st->codec->extradata_size = VC1_EXTRADATA_SIZE;

libavformat/vc1testenc.c+3−3

@@ -30,7 +30,7 @@ static int vc1test_write_header(AVFormatContext *s) · 29 unmodified lines
30	30	AVCodecContext *avc = s->streams[0]->codec;
31	31	AVIOContext *pb = s->pb;
32	32
33		− if (avc->codec_id != CODEC_ID_WMV3) {
	33	+ if (avc->codec_id != AV_CODEC_ID_WMV3) {
34	34	av_log(s, AV_LOG_ERROR, "Only WMV3 is accepted!\n");
35	35	return -1;
36	36	}
@@ -88,8 +88,8 @@ AVOutputFormat ff_vc1t_muxer = { · 51 unmodified lines
88	88	.mime_type = "",
89	89	.extensions = "rcv",
90	90	.priv_data_size = sizeof(RCVContext),
91		− .audio_codec = CODEC_ID_NONE,
92		− .video_codec = CODEC_ID_WMV3,
	91	+ .audio_codec = AV_CODEC_ID_NONE,
	92	+ .video_codec = AV_CODEC_ID_WMV3,
93	93	.write_header = vc1test_write_header,
94	94	.write_packet = vc1test_write_packet,
95	95	.write_trailer = vc1test_write_trailer,

libavformat/voc.c+9−9

@@ -25,13 +25,13 @@ · 24 unmodified lines
25	25	const unsigned char ff_voc_magic[21] = "Creative Voice File\x1A";
26	26
27	27	const AVCodecTag ff_voc_codec_tags[] = {
28		− {CODEC_ID_PCM_U8, 0x00},
29		− {CODEC_ID_ADPCM_SBPRO_4, 0x01},
30		− {CODEC_ID_ADPCM_SBPRO_3, 0x02},
31		− {CODEC_ID_ADPCM_SBPRO_2, 0x03},
32		− {CODEC_ID_PCM_S16LE, 0x04},
33		− {CODEC_ID_PCM_ALAW, 0x06},
34		− {CODEC_ID_PCM_MULAW, 0x07},
35		− {CODEC_ID_ADPCM_CT, 0x0200},
36		− {CODEC_ID_NONE, 0},
	28	+ {AV_CODEC_ID_PCM_U8, 0x00},
	29	+ {AV_CODEC_ID_ADPCM_SBPRO_4, 0x01},
	30	+ {AV_CODEC_ID_ADPCM_SBPRO_3, 0x02},
	31	+ {AV_CODEC_ID_ADPCM_SBPRO_2, 0x03},
	32	+ {AV_CODEC_ID_PCM_S16LE, 0x04},
	33	+ {AV_CODEC_ID_PCM_ALAW, 0x06},
	34	+ {AV_CODEC_ID_PCM_MULAW, 0x07},
	35	+ {AV_CODEC_ID_ADPCM_CT, 0x0200},
	36	+ {AV_CODEC_ID_NONE, 0},
37	37	};

libavformat/vocdec.c+3−3

@@ -137,12 +137,12 @@ ff_voc_get_packet(AVFormatContext s, AVPacket pkt, AVStream *st, int max_size) · 136 unmodified lines
137	137
138	138	if (tmp_codec >= 0) {
139	139	tmp_codec = ff_codec_get_id(ff_voc_codec_tags, tmp_codec);
140		− if (dec->codec_id == CODEC_ID_NONE)
	140	+ if (dec->codec_id == AV_CODEC_ID_NONE)
141	141	dec->codec_id = tmp_codec;
142	142	else if (dec->codec_id != tmp_codec)
143	143	av_log(s, AV_LOG_WARNING, "Ignoring mid-stream change in audio codec\n");
144		− if (dec->codec_id == CODEC_ID_NONE) {
145		− if (s->audio_codec_id == CODEC_ID_NONE) {
	144	+ if (dec->codec_id == AV_CODEC_ID_NONE) {
	145	+ if (s->audio_codec_id == AV_CODEC_ID_NONE) {
146	146	av_log(s, AV_LOG_ERROR, "unknown codec tag\n");
147	147	return AVERROR(EINVAL);
148	148	}

libavformat/vocenc.c+2−2

@@ -95,8 +95,8 @@ AVOutputFormat ff_voc_muxer = { · 94 unmodified lines
95	95	.mime_type = "audio/x-voc",
96	96	.extensions = "voc",
97	97	.priv_data_size = sizeof(VocEncContext),
98		− .audio_codec = CODEC_ID_PCM_U8,
99		− .video_codec = CODEC_ID_NONE,
	98	+ .audio_codec = AV_CODEC_ID_PCM_U8,
	99	+ .video_codec = AV_CODEC_ID_NONE,
100	100	.write_header = voc_write_header,
101	101	.write_packet = voc_write_packet,
102	102	.write_trailer = voc_write_trailer,

libavformat/vqf.c+1−1

@@ -105,7 +105,7 @@ static int vqf_read_header(AVFormatContext *s) · 104 unmodified lines
105	105	header_size = avio_rb32(s->pb);
106	106
107	107	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
108		− st->codec->codec_id = CODEC_ID_TWINVQ;
	108	+ st->codec->codec_id = AV_CODEC_ID_TWINVQ;
109	109	st->start_time = 0;
110	110
111	111	do {

libavformat/wav.c+6−6

@@ -211,8 +211,8 @@ AVOutputFormat ff_wav_muxer = { · 210 unmodified lines
211	211	.mime_type = "audio/x-wav",
212	212	.extensions = "wav",
213	213	.priv_data_size = sizeof(WAVContext),
214		− .audio_codec = CODEC_ID_PCM_S16LE,
215		− .video_codec = CODEC_ID_NONE,
	214	+ .audio_codec = AV_CODEC_ID_PCM_S16LE,
	215	+ .video_codec = AV_CODEC_ID_NONE,
216	216	.write_header = wav_write_header,
217	217	.write_packet = wav_write_packet,
218	218	.write_trailer = wav_write_trailer,
@@ -574,10 +574,10 @@ static int wav_read_seek(AVFormatContext *s, · 355 unmodified lines
574	574
575	575	st = s->streams[0];
576	576	switch (st->codec->codec_id) {
577		− case CODEC_ID_MP2:
578		− case CODEC_ID_MP3:
579		− case CODEC_ID_AC3:
580		− case CODEC_ID_DTS:
	577	+ case AV_CODEC_ID_MP2:
	578	+ case AV_CODEC_ID_MP3:
	579	+ case AV_CODEC_ID_AC3:
	580	+ case AV_CODEC_ID_DTS:
581	581	/* use generic seeking with dynamically generated indexes */
582	582	return -1;
583	583	default:

libavformat/wc3movie.c+2−2

@@ -169,7 +169,7 @@ static int wc3_read_header(AVFormatContext *s) · 168 unmodified lines
169	169	avpriv_set_pts_info(st, 33, 1, WC3_FRAME_FPS);
170	170	wc3->video_stream_index = st->index;
171	171	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
172		− st->codec->codec_id = CODEC_ID_XAN_WC3;
	172	+ st->codec->codec_id = AV_CODEC_ID_XAN_WC3;
173	173	st->codec->codec_tag = 0; /* no fourcc */
174	174	st->codec->width = wc3->width;
175	175	st->codec->height = wc3->height;
@@ -180,7 +180,7 @@ static int wc3_read_header(AVFormatContext *s) · 4 unmodified lines
180	180	avpriv_set_pts_info(st, 33, 1, WC3_FRAME_FPS);
181	181	wc3->audio_stream_index = st->index;
182	182	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
183		− st->codec->codec_id = CODEC_ID_PCM_S16LE;
	183	+ st->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
184	184	st->codec->codec_tag = 1;
185	185	st->codec->channels = WC3_AUDIO_CHANNELS;
186	186	st->codec->bits_per_coded_sample = WC3_AUDIO_BITS;

libavformat/westwood_aud.c+3−3

@@ -106,10 +106,10 @@ static int wsaud_read_header(AVFormatContext *s) · 105 unmodified lines
106	106	av_log_ask_for_sample(s, "Stereo WS-SND1 is not supported.\n");
107	107	return AVERROR_PATCHWELCOME;
108	108	}
109		− st->codec->codec_id = CODEC_ID_WESTWOOD_SND1;
	109	+ st->codec->codec_id = AV_CODEC_ID_WESTWOOD_SND1;
110	110	break;
111	111	case 99:
112		− st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;
	112	+ st->codec->codec_id = AV_CODEC_ID_ADPCM_IMA_WS;
113	113	st->codec->bits_per_coded_sample = 4;
114	114	st->codec->bit_rate = channels * sample_rate * 4;
115	115	break;
@@ -144,7 +144,7 @@ static int wsaud_read_packet(AVFormatContext *s, · 28 unmodified lines
144	144
145	145	chunk_size = AV_RL16(&preamble[0]);
146	146
147		− if (st->codec->codec_id == CODEC_ID_WESTWOOD_SND1) {
	147	+ if (st->codec->codec_id == AV_CODEC_ID_WESTWOOD_SND1) {
148	148	/* For Westwood SND1 audio we need to add the output size and input
149	149	size to the start of the packet to match what is in VQA.
150	150	Specifically, this is needed to signal when a packet should be

libavformat/westwood_vqa.c+5−5

@@ -94,7 +94,7 @@ static int wsvqa_read_header(AVFormatContext *s) · 93 unmodified lines
94	94	st->start_time = 0;
95	95	wsvqa->video_stream_index = st->index;
96	96	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
97		− st->codec->codec_id = CODEC_ID_WS_VQA;
	97	+ st->codec->codec_id = AV_CODEC_ID_WS_VQA;
98	98	st->codec->codec_tag = 0; /* no fourcc */
99	99
100	100	/* skip to the start of the VQA header */
@@ -216,15 +216,15 @@ static int wsvqa_read_packet(AVFormatContext *s, · 115 unmodified lines
216	216	switch (chunk_type) {
217	217	case SND0_TAG:
218	218	if (wsvqa->bps == 16)
219		− st->codec->codec_id = CODEC_ID_PCM_S16LE;
	219	+ st->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
220	220	else
221		− st->codec->codec_id = CODEC_ID_PCM_U8;
	221	+ st->codec->codec_id = AV_CODEC_ID_PCM_U8;
222	222	break;
223	223	case SND1_TAG:
224		− st->codec->codec_id = CODEC_ID_WESTWOOD_SND1;
	224	+ st->codec->codec_id = AV_CODEC_ID_WESTWOOD_SND1;
225	225	break;
226	226	case SND2_TAG:
227		− st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;
	227	+ st->codec->codec_id = AV_CODEC_ID_ADPCM_IMA_WS;
228	228	st->codec->extradata_size = 2;
229	229	st->codec->extradata = av_mallocz(2 + FF_INPUT_BUFFER_PADDING_SIZE);
230	230	if (!st->codec->extradata)

libavformat/wtv.c+18−18

@@ -331,18 +331,18 @@ typedef struct { · 330 unmodified lines
331	331	} WtvContext;
332	332
333	333	typedef struct {
334		− enum CodecID id;
	334	+ enum AVCodecID id;
335	335	ff_asf_guid guid;
336	336	} AVCodecGuid;
337	337
338		−static enum CodecID ff_codec_guid_get_id(const AVCodecGuid *guids, ff_asf_guid guid)
	338	+static enum AVCodecID ff_codec_guid_get_id(const AVCodecGuid *guids, ff_asf_guid guid)
339	339	{
340	340	int i;
341		− for (i = 0; guids[i].id != CODEC_ID_NONE; i++) {
	341	+ for (i = 0; guids[i].id != AV_CODEC_ID_NONE; i++) {
342	342	if (!ff_guidcmp(guids[i].guid, guid))
343	343	return guids[i].id;
344	344	}
345		− return CODEC_ID_NONE;
	345	+ return AV_CODEC_ID_NONE;
346	346	}
347	347
348	348	/* WTV GUIDs */
@@ -421,15 +421,15 @@ static const ff_asf_guid format_none = · 72 unmodified lines
421	421	{0xD6,0x17,0x64,0x0F,0x18,0xC3,0xD0,0x11,0xA4,0x3F,0x00,0xA0,0xC9,0x22,0x31,0x96};
422	422
423	423	static const AVCodecGuid video_guids[] = {
424		− {CODEC_ID_MPEG2VIDEO, {0x26,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA}},
425		− {CODEC_ID_NONE}
	424	+ {AV_CODEC_ID_MPEG2VIDEO, {0x26,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA}},
	425	+ {AV_CODEC_ID_NONE}
426	426	};
427	427
428	428	static const AVCodecGuid audio_guids[] = {
429		− {CODEC_ID_AC3, {0x2C,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA}},
430		− {CODEC_ID_EAC3, {0xAF,0x87,0xFB,0xA7,0x02,0x2D,0xFB,0x42,0xA4,0xD4,0x05,0xCD,0x93,0x84,0x3B,0xDD}},
431		− {CODEC_ID_MP2, {0x2B,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA}},
432		− {CODEC_ID_NONE}
	429	+ {AV_CODEC_ID_AC3, {0x2C,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA}},
	430	+ {AV_CODEC_ID_EAC3, {0xAF,0x87,0xFB,0xA7,0x02,0x2D,0xFB,0x42,0xA4,0xD4,0x05,0xCD,0x93,0x84,0x3B,0xDD}},
	431	+ {AV_CODEC_ID_MP2, {0x2B,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA}},
	432	+ {AV_CODEC_ID_NONE}
433	433	};
434	434
435	435	static int read_probe(AVProbeData *p)
@@ -498,7 +498,7 @@ static void get_attachment(AVFormatContext s, AVIOContext pb, int length) · 62 unmodified lines
498	498	if (!st)
499	499	goto done;
500	500	av_dict_set(&st->metadata, "title", description, 0);
501		− st->codec->codec_id = CODEC_ID_MJPEG;
	501	+ st->codec->codec_id = AV_CODEC_ID_MJPEG;
502	502	st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
503	503	st->codec->extradata = av_mallocz(filesize);
504	504	if (!st->codec->extradata)
@@ -609,9 +609,9 @@ static void parse_mpeg1waveformatex(AVStream *st) · 104 unmodified lines
609	609	{
610	610	/* fwHeadLayer */
611	611	switch (AV_RL16(st->codec->extradata)) {
612		− case 0x0001 : st->codec->codec_id = CODEC_ID_MP1; break;
613		− case 0x0002 : st->codec->codec_id = CODEC_ID_MP2; break;
614		− case 0x0004 : st->codec->codec_id = CODEC_ID_MP3; break;
	612	+ case 0x0001 : st->codec->codec_id = AV_CODEC_ID_MP1; break;
	613	+ case 0x0002 : st->codec->codec_id = AV_CODEC_ID_MP2; break;
	614	+ case 0x0004 : st->codec->codec_id = AV_CODEC_ID_MP3; break;
615	615	}
616	616
617	617	st->codec->bit_rate = AV_RL32(st->codec->extradata + 2); /* dwHeadBitrate */
@@ -708,7 +708,7 @@ static AVStream * parse_media_type(AVFormatContext s, AVStream st, int sid, · 90 unmodified lines
708	708	av_log(s, AV_LOG_WARNING, "MPEG1WAVEFORMATEX underflow\n");
709	709	} else {
710	710	st->codec->codec_id = ff_codec_guid_get_id(audio_guids, subtype);
711		− if (st->codec->codec_id == CODEC_ID_NONE)
	711	+ if (st->codec->codec_id == AV_CODEC_ID_NONE)
712	712	av_log(s, AV_LOG_WARNING, "unknown subtype:"PRI_GUID"\n", ARG_GUID(subtype));
713	713	}
714	714	return st;
@@ -733,7 +733,7 @@ static AVStream * parse_media_type(AVFormatContext s, AVStream st, int sid, · 18 unmodified lines
733	733	} else {
734	734	st->codec->codec_id = ff_codec_guid_get_id(video_guids, subtype);
735	735	}
736		− if (st->codec->codec_id == CODEC_ID_NONE)
	736	+ if (st->codec->codec_id == AV_CODEC_ID_NONE)
737	737	av_log(s, AV_LOG_WARNING, "unknown subtype:"PRI_GUID"\n", ARG_GUID(subtype));
738	738	return st;
739	739	} else if (!ff_guidcmp(mediatype, mediatype_mpeg2_pes) &&
@@ -744,7 +744,7 @@ static AVStream * parse_media_type(AVFormatContext s, AVStream st, int sid, · 4 unmodified lines
744	744	if (ff_guidcmp(formattype, format_none))
745	745	av_log(s, AV_LOG_WARNING, "unknown formattype:"PRI_GUID"\n", ARG_GUID(formattype));
746	746	avio_skip(pb, size);
747		− st->codec->codec_id = CODEC_ID_DVB_SUBTITLE;
	747	+ st->codec->codec_id = AV_CODEC_ID_DVB_SUBTITLE;
748	748	return st;
749	749	} else if (!ff_guidcmp(mediatype, mediatype_mstvcaption) &&
750	750	(!ff_guidcmp(subtype, mediasubtype_teletext) \|\| !ff_guidcmp(subtype, mediasubtype_dtvccdata))) {
@@ -754,7 +754,7 @@ static AVStream * parse_media_type(AVFormatContext s, AVStream st, int sid, · 3 unmodified lines
754	754	if (ff_guidcmp(formattype, format_none))
755	755	av_log(s, AV_LOG_WARNING, "unknown formattype:"PRI_GUID"\n", ARG_GUID(formattype));
756	756	avio_skip(pb, size);
757		− st->codec->codec_id = CODEC_ID_DVB_TELETEXT;
	757	+ st->codec->codec_id = AV_CODEC_ID_DVB_TELETEXT;
758	758	return st;
759	759	} else if (!ff_guidcmp(mediatype, mediatype_mpeg2_sections) &&
760	760	!ff_guidcmp(subtype, mediasubtype_mpeg2_sections)) {

libavformat/wv.c+1−1

@@ -248,7 +248,7 @@ static int wv_read_header(AVFormatContext *s) · 247 unmodified lines
248	248	if (!st)
249	249	return AVERROR(ENOMEM);
250	250	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
251		− st->codec->codec_id = CODEC_ID_WAVPACK;
	251	+ st->codec->codec_id = AV_CODEC_ID_WAVPACK;
252	252	st->codec->channels = wc->chan;
253	253	st->codec->channel_layout = wc->chmask;
254	254	st->codec->sample_rate = wc->rate;

libavformat/xa.c+1−1

@@ -74,7 +74,7 @@ static int xa_read_header(AVFormatContext *s) · 73 unmodified lines
74	74	return AVERROR(ENOMEM);
75	75
76	76	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
77		− st->codec->codec_id = CODEC_ID_ADPCM_EA_MAXIS_XA;
	77	+ st->codec->codec_id = AV_CODEC_ID_ADPCM_EA_MAXIS_XA;
78	78	avio_skip(pb, 4); /* Skip the XA ID */
79	79	xa->out_size = avio_rl32(pb);
80	80	avio_skip(pb, 2); /* Skip the tag */

libavformat/xmv.c+2−2

@@ -53,7 +53,7 @@ typedef struct XMVAudioTrack { · 52 unmodified lines
53	53	uint16_t block_align;
54	54	uint16_t block_samples;
55	55
56		− enum CodecID codec_id;
	56	+ enum AVCodecID codec_id;
57	57	} XMVAudioTrack;
58	58
59	59	typedef struct XMVVideoPacket {
@@ -157,7 +157,7 @@ static int xmv_read_header(AVFormatContext *s) · 97 unmodified lines
157	157	avpriv_set_pts_info(vst, 32, 1, 1000);
158	158
159	159	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
160		− vst->codec->codec_id = CODEC_ID_WMV2;
	160	+ vst->codec->codec_id = AV_CODEC_ID_WMV2;
161	161	vst->codec->codec_tag = MKBETAG('W', 'M', 'V', '2');
162	162	vst->codec->width = avio_rl32(pb);
163	163	vst->codec->height = avio_rl32(pb);

libavformat/xwma.c+1−1

@@ -84,7 +84,7 @@ static int xwma_read_header(AVFormatContext *s) · 83 unmodified lines
84	84	* extradata for that. Thus, ask the user for feedback, but try to go on
85	85	* anyway.
86	86	*/
87		− if (st->codec->codec_id != CODEC_ID_WMAV2) {
	87	+ if (st->codec->codec_id != AV_CODEC_ID_WMAV2) {
88	88	av_log(s, AV_LOG_WARNING, "unexpected codec (tag 0x04%x; id %d)\n",
89	89	st->codec->codec_tag, st->codec->codec_id);
90	90	av_log_ask_for_sample(s, NULL);

libavformat/yop.c+2−2

@@ -72,14 +72,14 @@ static int yop_read_header(AVFormatContext *s) · 71 unmodified lines
72	72	// Audio
73	73	audio_dec = audio_stream->codec;
74	74	audio_dec->codec_type = AVMEDIA_TYPE_AUDIO;
75		− audio_dec->codec_id = CODEC_ID_ADPCM_IMA_APC;
	75	+ audio_dec->codec_id = AV_CODEC_ID_ADPCM_IMA_APC;
76	76	audio_dec->channels = 1;
77	77	audio_dec->sample_rate = 22050;
78	78
79	79	// Video
80	80	video_dec = video_stream->codec;
81	81	video_dec->codec_type = AVMEDIA_TYPE_VIDEO;
82		− video_dec->codec_id = CODEC_ID_YOP;
	82	+ video_dec->codec_id = AV_CODEC_ID_YOP;
83	83
84	84	avio_skip(pb, 6);
85	85

libavformat/yuv4mpeg.c+3−3

@@ -178,8 +178,8 @@ AVOutputFormat ff_yuv4mpegpipe_muxer = { · 177 unmodified lines
178	178	.mime_type = "",
179	179	.extensions = "y4m",
180	180	.priv_data_size = sizeof(int),
181		− .audio_codec = CODEC_ID_NONE,
182		− .video_codec = CODEC_ID_RAWVIDEO,
	181	+ .audio_codec = AV_CODEC_ID_NONE,
	182	+ .video_codec = AV_CODEC_ID_RAWVIDEO,
183	183	.write_header = yuv4_write_header,
184	184	.write_packet = yuv4_write_packet,
185	185	.flags = AVFMT_RAWPICTURE,
@@ -356,7 +356,7 @@ static int yuv4_read_header(AVFormatContext *s) · 170 unmodified lines
356	356	avpriv_set_pts_info(st, 64, rated, raten);
357	357	st->codec->pix_fmt = pix_fmt;
358	358	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
359		− st->codec->codec_id = CODEC_ID_RAWVIDEO;
	359	+ st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
360	360	st->sample_aspect_ratio = (AVRational){ aspectn, aspectd };
361	361	st->codec->chroma_sample_location = chroma_sample_location;
362	362

tools/ismindex.c+5−5

@@ -248,7 +248,7 @@ static int get_video_private_data(struct VideoFile vf, AVCodecContext codec) · 247 unmodified lines
248	248	uint16_t sps_size, pps_size;
249	249	int err = AVERROR(EINVAL);
250	250
251		− if (codec->codec_id == CODEC_ID_VC1)
	251	+ if (codec->codec_id == AV_CODEC_ID_VC1)
252	252	return get_private_data(vf, codec);
253	253
254	254	avio_open_dyn_buf(&io);
@@ -332,11 +332,11 @@ static int handle_file(struct VideoFiles files, const char file, int split) · 77 unmodified lines
332	332	files->nb_audio_files++;
333	333	vf->channels = st->codec->channels;
334	334	vf->sample_rate = st->codec->sample_rate;
335		− if (st->codec->codec_id == CODEC_ID_AAC) {
	335	+ if (st->codec->codec_id == AV_CODEC_ID_AAC) {
336	336	vf->fourcc = "AACL";
337	337	vf->tag = 255;
338	338	vf->blocksize = 4;
339		− } else if (st->codec->codec_id == CODEC_ID_WMAPRO) {
	339	+ } else if (st->codec->codec_id == AV_CODEC_ID_WMAPRO) {
340	340	vf->fourcc = "WMAP";
341	341	vf->tag = st->codec->codec_tag;
342	342	vf->blocksize = st->codec->block_align;
@@ -349,9 +349,9 @@ static int handle_file(struct VideoFiles files, const char file, int split) · 6 unmodified lines
349	349	files->nb_video_files++;
350	350	vf->width = st->codec->width;
351	351	vf->height = st->codec->height;
352		− if (st->codec->codec_id == CODEC_ID_H264)
	352	+ if (st->codec->codec_id == AV_CODEC_ID_H264)
353	353	vf->fourcc = "H264";
354		− else if (st->codec->codec_id == CODEC_ID_VC1)
	354	+ else if (st->codec->codec_id == AV_CODEC_ID_VC1)
355	355	vf->fourcc = "WVC1";
356	356	get_video_private_data(vf, st->codec);
357	357	}

Replace all CODEC_ID_* with AV_CODEC_ID_*

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code