virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-01-13 21:28:01 +02:00
Code Issues Releases Activity

Merge commit '36ef5369ee9b336febc2c270f8718cec4476cb85'

Browse Source 
* commit '36ef5369ee9b336febc2c270f8718cec4476cb85':
  Replace all CODEC_ID_* with AV_CODEC_ID_*
  lavc: add AV prefix to codec ids.

Conflicts:
	doc/APIchanges
	doc/examples/decoding_encoding.c
	doc/examples/muxing.c
	ffmpeg.c
	ffprobe.c
	ffserver.c
	libavcodec/8svx.c
	libavcodec/avcodec.h
	libavcodec/dnxhd_parser.c
	libavcodec/dvdsubdec.c
	libavcodec/error_resilience.c
	libavcodec/h263dec.c
	libavcodec/libvorbisenc.c
	libavcodec/mjpeg_parser.c
	libavcodec/mjpegenc.c
	libavcodec/mpeg12.c
	libavcodec/mpeg4videodec.c
	libavcodec/mpegvideo.c
	libavcodec/mpegvideo_enc.c
	libavcodec/pcm.c
	libavcodec/r210dec.c
	libavcodec/utils.c
	libavcodec/v210dec.c
	libavcodec/version.h
	libavdevice/alsa-audio-dec.c
	libavdevice/bktr.c
	libavdevice/v4l2.c
	libavformat/asfdec.c
	libavformat/asfenc.c
	libavformat/avformat.h
	libavformat/avidec.c
	libavformat/caf.c
	libavformat/electronicarts.c
	libavformat/flacdec.c
	libavformat/flvdec.c
	libavformat/flvenc.c
	libavformat/framecrcenc.c
	libavformat/img2.c
	libavformat/img2dec.c
	libavformat/img2enc.c
	libavformat/ipmovie.c
	libavformat/isom.c
	libavformat/matroska.c
	libavformat/matroskadec.c
	libavformat/matroskaenc.c
	libavformat/mov.c
	libavformat/movenc.c
	libavformat/mp3dec.c
	libavformat/mpeg.c
	libavformat/mpegts.c
	libavformat/mxf.c
	libavformat/mxfdec.c
	libavformat/mxfenc.c
	libavformat/nsvdec.c
	libavformat/nut.c
	libavformat/oggenc.c
	libavformat/pmpdec.c
	libavformat/rawdec.c
	libavformat/rawenc.c
	libavformat/riff.c
	libavformat/sdp.c
	libavformat/utils.c
	libavformat/vocenc.c
	libavformat/wtv.c
	libavformat/xmv.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2012-08-07 22:45:46 +02:00
commit 7a72695c05
672 changed files with 4711 additions and 4301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmdutils.c
View File

@ -1094,7 +1094,7 @@ int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
return ret; return ret;
} }
AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, AVDictionary *filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id,
AVFormatContext *s, AVStream *st, AVCodec *codec) AVFormatContext *s, AVStream *st, AVCodec *codec)
{ {
AVDictionary *ret = NULL; AVDictionary *ret = NULL;

2
cmdutils.h
View File

@ -236,7 +236,7 @@ int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec);
* If null, the default one is looked up according to the codec id. * If null, the default one is looked up according to the codec id.
* @return a pointer to the created dictionary * @return a pointer to the created dictionary
*/ */
AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, AVDictionary *filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id,
AVFormatContext *s, AVStream *st, AVCodec *codec); AVFormatContext *s, AVStream *st, AVCodec *codec);
/** /**

3
doc/APIchanges
View File

@ -70,6 +70,9 @@ API changes, most recent first:
2012-03-26 - a67d9cf - lavfi 2.66.100 2012-03-26 - a67d9cf - lavfi 2.66.100
Add avfilter_fill_frame_from_{audio_,}buffer_ref() functions. Add avfilter_fill_frame_from_{audio_,}buffer_ref() functions.
2012-08-xx - xxxxxxx - lavc 54.25 - avcodec.h
Rename CodecID to AVCodecID and all CODEC_ID_* to AV_CODEC_ID_*.
2012-08-03 - xxxxxxx - lavu 51.37.1 - cpu.h 2012-08-03 - xxxxxxx - lavu 51.37.1 - cpu.h
lsws 2.1.1 - swscale.h lsws 2.1.1 - swscale.h
Rename AV_CPU_FLAG_MMX2 ---> AV_CPU_FLAG_MMXEXT. Rename AV_CPU_FLAG_MMX2 ---> AV_CPU_FLAG_MMXEXT.

2
doc/developer.texi
View File

@ -393,7 +393,7 @@ send a reminder by email. Your patch should eventually be dealt with.
@item @item
Did you register it in @file{allcodecs.c} or @file{allformats.c}? Did you register it in @file{allcodecs.c} or @file{allformats.c}?
@item @item
Did you add the CodecID to @file{avcodec.h}? Did you add the AVCodecID to @file{avcodec.h}?
@item @item
If it has a fourCC, did you add it to @file{libavformat/riff.c}, If it has a fourCC, did you add it to @file{libavformat/riff.c},
even if it is only a decoder? even if it is only a decoder?

12
doc/examples/decoding_encoding.c
View File

@ -57,7 +57,7 @@ static void audio_encode_example(const char *filename)
printf("Encode audio file %s\n", filename); printf("Encode audio file %s\n", filename);
/* find the MP2 encoder */ /* find the MP2 encoder */
codec = avcodec_find_encoder(CODEC_ID_MP2); codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
if (!codec) { if (!codec) {
fprintf(stderr, "codec not found\n"); fprintf(stderr, "codec not found\n");
exit(1); exit(1);
@ -128,7 +128,7 @@ static void audio_decode_example(const char *outfilename, const char *filename)
printf("Decode audio file %s\n", filename); printf("Decode audio file %s\n", filename);
/* find the mpeg audio decoder */ /* find the mpeg audio decoder */
codec = avcodec_find_decoder(CODEC_ID_MP2); codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
if (!codec) { if (!codec) {
fprintf(stderr, "codec not found\n"); fprintf(stderr, "codec not found\n");
exit(1); exit(1);
@ -242,7 +242,7 @@ static void video_encode_example(const char *filename, int codec_id)
c->max_b_frames=1; c->max_b_frames=1;
c->pix_fmt = PIX_FMT_YUV420P; c->pix_fmt = PIX_FMT_YUV420P;
if(codec_id == CODEC_ID_H264) if(codec_id == AV_CODEC_ID_H264)
av_opt_set(c->priv_data, "preset", "slow", 0); av_opt_set(c->priv_data, "preset", "slow", 0);
/* open it */ /* open it */
@ -354,7 +354,7 @@ static void video_decode_example(const char *outfilename, const char *filename)
printf("Decode video file %s\n", filename); printf("Decode video file %s\n", filename);
/* find the mpeg1 video decoder */ /* find the mpeg1 video decoder */
codec = avcodec_find_decoder(CODEC_ID_MPEG1VIDEO); codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
if (!codec) { if (!codec) {
fprintf(stderr, "codec not found\n"); fprintf(stderr, "codec not found\n");
exit(1); exit(1);
@ -465,8 +465,8 @@ int main(int argc, char **argv)
audio_encode_example("/tmp/test.mp2"); audio_encode_example("/tmp/test.mp2");
audio_decode_example("/tmp/test.sw", "/tmp/test.mp2"); audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
video_encode_example("/tmp/test.h264", CODEC_ID_H264); video_encode_example("/tmp/test.h264", AV_CODEC_ID_H264);
video_encode_example("/tmp/test.mpg", CODEC_ID_MPEG1VIDEO); video_encode_example("/tmp/test.mpg", AV_CODEC_ID_MPEG1VIDEO);
filename = "/tmp/test.mpg"; filename = "/tmp/test.mpg";
} else { } else {
filename = argv[1]; filename = argv[1];

12
doc/examples/muxing.c
View File

@ -58,7 +58,7 @@ static int audio_input_frame_size;
* add an audio output stream * add an audio output stream
*/ */
static AVStream *add_audio_stream(AVFormatContext *oc, AVCodec **codec, static AVStream *add_audio_stream(AVFormatContext *oc, AVCodec **codec,
enum CodecID codec_id) enum AVCodecID codec_id)
{ {
AVCodecContext *c; AVCodecContext *c;
AVStream *st; AVStream *st;
@ -183,7 +183,7 @@ static int frame_count, video_outbuf_size;
/* Add a video output stream. */ /* Add a video output stream. */
static AVStream *add_video_stream(AVFormatContext *oc, AVCodec **codec, static AVStream *add_video_stream(AVFormatContext *oc, AVCodec **codec,
enum CodecID codec_id) enum AVCodecID codec_id)
{ {
AVCodecContext *c; AVCodecContext *c;
AVStream *st; AVStream *st;
@ -220,11 +220,11 @@ static AVStream *add_video_stream(AVFormatContext *oc, AVCodec **codec,
c->time_base.num = 1; c->time_base.num = 1;
c->gop_size = 12; /* emit one intra frame every twelve frames at most */ c->gop_size = 12; /* emit one intra frame every twelve frames at most */
c->pix_fmt = STREAM_PIX_FMT; c->pix_fmt = STREAM_PIX_FMT;
if (c->codec_id == CODEC_ID_MPEG2VIDEO) { if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
/* just for testing, we also add B frames */ /* just for testing, we also add B frames */
c->max_b_frames = 2; c->max_b_frames = 2;
} }
if (c->codec_id == CODEC_ID_MPEG1VIDEO) { if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
/* Needed to avoid using macroblocks in which some coeffs overflow. /* Needed to avoid using macroblocks in which some coeffs overflow.
* This does not happen with normal video, it just happens here as * This does not happen with normal video, it just happens here as
* the motion of the chroma plane does not match the luma plane. */ * the motion of the chroma plane does not match the luma plane. */
@ -445,10 +445,10 @@ int main(int argc, char **argv)
* and initialize the codecs. */ * and initialize the codecs. */
video_st = NULL; video_st = NULL;
audio_st = NULL; audio_st = NULL;
if (fmt->video_codec != CODEC_ID_NONE) { if (fmt->video_codec != AV_CODEC_ID_NONE) {
video_st = add_video_stream(oc, &video_codec, fmt->video_codec); video_st = add_video_stream(oc, &video_codec, fmt->video_codec);
} }
if (fmt->audio_codec != CODEC_ID_NONE) { if (fmt->audio_codec != AV_CODEC_ID_NONE) {
audio_st = add_audio_stream(oc, &audio_codec, fmt->audio_codec); audio_st = add_audio_stream(oc, &audio_codec, fmt->audio_codec);
} }

40
ffmpeg.c
View File

@ -715,9 +715,9 @@ static enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum Pixe
int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0; int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0;
enum PixelFormat best= PIX_FMT_NONE; enum PixelFormat best= PIX_FMT_NONE;
if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) { if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
if (st->codec->codec_id == CODEC_ID_MJPEG) { if (st->codec->codec_id == AV_CODEC_ID_MJPEG) {
p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE }; p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
} else if (st->codec->codec_id == CODEC_ID_LJPEG) { } else if (st->codec->codec_id == AV_CODEC_ID_LJPEG) {
p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE }; PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
} }
@ -763,9 +763,9 @@ static char *choose_pix_fmts(OutputStream *ost)
p = ost->enc->pix_fmts; p = ost->enc->pix_fmts;
if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) { if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
if (ost->st->codec->codec_id == CODEC_ID_MJPEG) { if (ost->st->codec->codec_id == AV_CODEC_ID_MJPEG) {
p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE }; p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
} else if (ost->st->codec->codec_id == CODEC_ID_LJPEG) { } else if (ost->st->codec->codec_id == AV_CODEC_ID_LJPEG) {
p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE }; PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
} }
@ -1842,7 +1842,7 @@ static void do_subtitle_out(AVFormatContext *s,
/* Note: DVB subtitle need one packet to draw them and one other /* Note: DVB subtitle need one packet to draw them and one other
packet to clear them */ packet to clear them */
/* XXX: signal it in the codec context ? */ /* XXX: signal it in the codec context ? */
if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
nb = 2; nb = 2;
else else
nb = 1; nb = 1;
@ -1872,7 +1872,7 @@ static void do_subtitle_out(AVFormatContext *s,
pkt.size = subtitle_out_size; pkt.size = subtitle_out_size;
pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base); pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base); pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) { if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
/* XXX: the pts correction is handled here. Maybe handling /* XXX: the pts correction is handled here. Maybe handling
it in the codec would be better */ it in the codec would be better */
if (i == 0) if (i == 0)
@ -1964,7 +1964,7 @@ static void do_video_out(AVFormatContext *s,
return; return;
if (s->oformat->flags & AVFMT_RAWPICTURE && if (s->oformat->flags & AVFMT_RAWPICTURE &&
enc->codec->id == CODEC_ID_RAWVIDEO) { enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
/* raw pictures are written as AVPicture structure to /* raw pictures are written as AVPicture structure to
avoid any copies. We support temporarily the older avoid any copies. We support temporarily the older
method. */ method. */
@ -2380,7 +2380,7 @@ static void flush_encoders(void)
if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1) if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
continue; continue;
if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO) if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
continue; continue;
for (;;) { for (;;) {
@ -2499,10 +2499,10 @@ static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *p
opkt.flags = pkt->flags; opkt.flags = pkt->flags;
// FIXME remove the following 2 lines they shall be replaced by the bitstream filters // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
if ( ost->st->codec->codec_id != CODEC_ID_H264 if ( ost->st->codec->codec_id != AV_CODEC_ID_H264
&& ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO && ost->st->codec->codec_id != AV_CODEC_ID_MPEG1VIDEO
&& ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO && ost->st->codec->codec_id != AV_CODEC_ID_MPEG2VIDEO
&& ost->st->codec->codec_id != CODEC_ID_VC1 && ost->st->codec->codec_id != AV_CODEC_ID_VC1
) { ) {
if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY)) if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
opkt.destruct = av_destruct_packet; opkt.destruct = av_destruct_packet;
@ -3205,9 +3205,9 @@ static int transcode_init(void)
codec->frame_size = icodec->frame_size; codec->frame_size = icodec->frame_size;
codec->audio_service_type = icodec->audio_service_type; codec->audio_service_type = icodec->audio_service_type;
codec->block_align = icodec->block_align; codec->block_align = icodec->block_align;
if((codec->block_align == 1 || codec->block_align == 1152) && codec->codec_id == CODEC_ID_MP3) if((codec->block_align == 1 || codec->block_align == 1152) && codec->codec_id == AV_CODEC_ID_MP3)
codec->block_align= 0; codec->block_align= 0;
if(codec->codec_id == CODEC_ID_AC3) if(codec->codec_id == AV_CODEC_ID_AC3)
codec->block_align= 0; codec->block_align= 0;
break; break;
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
@ -4684,11 +4684,11 @@ static int opt_input_file(OptionsContext *o, const char *opt, const char *filena
av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0); av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
ic->video_codec_id = video_codec_name ? ic->video_codec_id = video_codec_name ?
find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE; find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
ic->audio_codec_id = audio_codec_name ? ic->audio_codec_id = audio_codec_name ?
find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE; find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
ic->subtitle_codec_id= subtitle_codec_name ? ic->subtitle_codec_id= subtitle_codec_name ?
find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE; find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
ic->flags |= AVFMT_FLAG_NONBLOCK; ic->flags |= AVFMT_FLAG_NONBLOCK;
ic->interrupt_callback = int_cb; ic->interrupt_callback = int_cb;
@ -5398,7 +5398,7 @@ static void opt_output_file(void *optctx, const char *filename)
/* pick the "best" stream of each type */ /* pick the "best" stream of each type */
/* video: highest resolution */ /* video: highest resolution */
if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) { if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
int area = 0, idx = -1; int area = 0, idx = -1;
for (i = 0; i < nb_input_streams; i++) { for (i = 0; i < nb_input_streams; i++) {
ist = input_streams[i]; ist = input_streams[i];
@ -5413,7 +5413,7 @@ static void opt_output_file(void *optctx, const char *filename)
} }
/* audio: most channels */ /* audio: most channels */
if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) { if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
int channels = 0, idx = -1; int channels = 0, idx = -1;
for (i = 0; i < nb_input_streams; i++) { for (i = 0; i < nb_input_streams; i++) {
ist = input_streams[i]; ist = input_streams[i];
@ -5428,7 +5428,7 @@ static void opt_output_file(void *optctx, const char *filename)
} }
/* subtitles: pick first */ /* subtitles: pick first */
if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) { if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
for (i = 0; i < nb_input_streams; i++) for (i = 0; i < nb_input_streams; i++)
if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) { if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
new_subtitle_stream(o, oc, i); new_subtitle_stream(o, oc, i);

4
ffprobe.c
View File

@ -1923,7 +1923,7 @@ static int open_input_file(AVFormatContext **fmt_ctx_ptr, const char *filename)
AVStream *stream = fmt_ctx->streams[i]; AVStream *stream = fmt_ctx->streams[i];
AVCodec *codec; AVCodec *codec;
if (stream->codec->codec_id == CODEC_ID_PROBE) { if (stream->codec->codec_id == AV_CODEC_ID_PROBE) {
av_log(NULL, AV_LOG_ERROR, av_log(NULL, AV_LOG_ERROR,
"Failed to probe codec for input stream %d\n", "Failed to probe codec for input stream %d\n",
stream->index); stream->index);
@ -1948,7 +1948,7 @@ static void close_input_file(AVFormatContext **ctx_ptr)
/* close decoder for each stream */ /* close decoder for each stream */
for (i = 0; i < fmt_ctx->nb_streams; i++) for (i = 0; i < fmt_ctx->nb_streams; i++)
if (fmt_ctx->streams[i]->codec->codec_id != CODEC_ID_NONE) if (fmt_ctx->streams[i]->codec->codec_id != AV_CODEC_ID_NONE)
avcodec_close(fmt_ctx->streams[i]->codec); avcodec_close(fmt_ctx->streams[i]->codec);
avformat_close_input(ctx_ptr); avformat_close_input(ctx_ptr);

36
ffserver.c
View File

@ -3552,7 +3552,7 @@ static void extract_mpeg4_header(AVFormatContext *infile)
mpeg4_count = 0; mpeg4_count = 0;
for(i=0;i<infile->nb_streams;i++) { for(i=0;i<infile->nb_streams;i++) {
st = infile->streams[i]; st = infile->streams[i];
if (st->codec->codec_id == CODEC_ID_MPEG4 && if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
st->codec->extradata_size == 0) { st->codec->extradata_size == 0) {
mpeg4_count++; mpeg4_count++;
} }
@ -3565,7 +3565,7 @@ static void extract_mpeg4_header(AVFormatContext *infile)
if (av_read_packet(infile, &pkt) < 0) if (av_read_packet(infile, &pkt) < 0)
break; break;
st = infile->streams[pkt.stream_index]; st = infile->streams[pkt.stream_index];
if (st->codec->codec_id == CODEC_ID_MPEG4 && if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
st->codec->extradata_size == 0) { st->codec->extradata_size == 0) {
av_freep(&st->codec->extradata); av_freep(&st->codec->extradata);
/* fill extradata with the header */ /* fill extradata with the header */
@ -3881,22 +3881,22 @@ static void add_codec(FFStream *stream, AVCodecContext *av)
memcpy(st->codec, av, sizeof(AVCodecContext)); memcpy(st->codec, av, sizeof(AVCodecContext));
} }
static enum CodecID opt_audio_codec(const char *arg) static enum AVCodecID opt_audio_codec(const char *arg)
{ {
AVCodec *p= avcodec_find_encoder_by_name(arg); AVCodec *p= avcodec_find_encoder_by_name(arg);
if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO) if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO)
return CODEC_ID_NONE; return AV_CODEC_ID_NONE;
return p->id; return p->id;
} }
static enum CodecID opt_video_codec(const char *arg) static enum AVCodecID opt_video_codec(const char *arg)
{ {
AVCodec *p= avcodec_find_encoder_by_name(arg); AVCodec *p= avcodec_find_encoder_by_name(arg);
if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO) if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO)
return CODEC_ID_NONE; return AV_CODEC_ID_NONE;
return p->id; return p->id;
} }
@ -3939,7 +3939,7 @@ static int ffserver_opt_default(const char *opt, const char *arg,
static int ffserver_opt_preset(const char *arg, static int ffserver_opt_preset(const char *arg,
AVCodecContext *avctx, int type, AVCodecContext *avctx, int type,
enum CodecID *audio_id, enum CodecID *video_id) enum AVCodecID *audio_id, enum AVCodecID *video_id)
{ {
FILE *f=NULL; FILE *f=NULL;
char filename[1000], tmp[1000], tmp2[1000], line[1000]; char filename[1000], tmp[1000], tmp2[1000], line[1000];
@ -4021,7 +4021,7 @@ static int parse_ffconfig(const char *filename)
FFStream **last_stream, *stream, *redirect; FFStream **last_stream, *stream, *redirect;
FFStream **last_feed, *feed, *s; FFStream **last_feed, *feed, *s;
AVCodecContext audio_enc, video_enc; AVCodecContext audio_enc, video_enc;
enum CodecID audio_id, video_id; enum AVCodecID audio_id, video_id;
f = fopen(filename, "r"); f = fopen(filename, "r");
if (!f) { if (!f) {
@ -4038,8 +4038,8 @@ static int parse_ffconfig(const char *filename)
stream = NULL; stream = NULL;
feed = NULL; feed = NULL;
redirect = NULL; redirect = NULL;
audio_id = CODEC_ID_NONE; audio_id = AV_CODEC_ID_NONE;
video_id = CODEC_ID_NONE; video_id = AV_CODEC_ID_NONE;
#define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__) #define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
for(;;) { for(;;) {
@ -4232,8 +4232,8 @@ static int parse_ffconfig(const char *filename)
avcodec_get_context_defaults3(&video_enc, NULL); avcodec_get_context_defaults3(&video_enc, NULL);
avcodec_get_context_defaults3(&audio_enc, NULL); avcodec_get_context_defaults3(&audio_enc, NULL);
audio_id = CODEC_ID_NONE; audio_id = AV_CODEC_ID_NONE;
video_id = CODEC_ID_NONE; video_id = AV_CODEC_ID_NONE;
if (stream->fmt) { if (stream->fmt) {
audio_id = stream->fmt->audio_codec; audio_id = stream->fmt->audio_codec;
video_id = stream->fmt->video_codec; video_id = stream->fmt->video_codec;
@ -4315,13 +4315,13 @@ static int parse_ffconfig(const char *filename)
} else if (!av_strcasecmp(cmd, "AudioCodec")) { } else if (!av_strcasecmp(cmd, "AudioCodec")) {
get_arg(arg, sizeof(arg), &p); get_arg(arg, sizeof(arg), &p);
audio_id = opt_audio_codec(arg); audio_id = opt_audio_codec(arg);
if (audio_id == CODEC_ID_NONE) { if (audio_id == AV_CODEC_ID_NONE) {
ERROR("Unknown AudioCodec: %s\n", arg); ERROR("Unknown AudioCodec: %s\n", arg);
} }
} else if (!av_strcasecmp(cmd, "VideoCodec")) { } else if (!av_strcasecmp(cmd, "VideoCodec")) {
get_arg(arg, sizeof(arg), &p); get_arg(arg, sizeof(arg), &p);
video_id = opt_video_codec(arg); video_id = opt_video_codec(arg);
if (video_id == CODEC_ID_NONE) { if (video_id == AV_CODEC_ID_NONE) {
ERROR("Unknown VideoCodec: %s\n", arg); ERROR("Unknown VideoCodec: %s\n", arg);
} }
} else if (!av_strcasecmp(cmd, "MaxTime")) { } else if (!av_strcasecmp(cmd, "MaxTime")) {
@ -4512,9 +4512,9 @@ static int parse_ffconfig(const char *filename)
if (stream) if (stream)
video_enc.dark_masking = atof(arg); video_enc.dark_masking = atof(arg);
} else if (!av_strcasecmp(cmd, "NoVideo")) { } else if (!av_strcasecmp(cmd, "NoVideo")) {
video_id = CODEC_ID_NONE; video_id = AV_CODEC_ID_NONE;
} else if (!av_strcasecmp(cmd, "NoAudio")) { } else if (!av_strcasecmp(cmd, "NoAudio")) {
audio_id = CODEC_ID_NONE; audio_id = AV_CODEC_ID_NONE;
} else if (!av_strcasecmp(cmd, "ACL")) { } else if (!av_strcasecmp(cmd, "ACL")) {
parse_acl_row(stream, feed, NULL, p, filename, line_num); parse_acl_row(stream, feed, NULL, p, filename, line_num);
} else if (!av_strcasecmp(cmd, "DynamicACL")) { } else if (!av_strcasecmp(cmd, "DynamicACL")) {
@ -4552,12 +4552,12 @@ static int parse_ffconfig(const char *filename)
ERROR("No corresponding <Stream> for </Stream>\n"); ERROR("No corresponding <Stream> for </Stream>\n");
} else { } else {
if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) { if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
if (audio_id != CODEC_ID_NONE) { if (audio_id != AV_CODEC_ID_NONE) {
audio_enc.codec_type = AVMEDIA_TYPE_AUDIO; audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
audio_enc.codec_id = audio_id; audio_enc.codec_id = audio_id;
add_codec(stream, &audio_enc); add_codec(stream, &audio_enc);
} }
if (video_id != CODEC_ID_NONE) { if (video_id != AV_CODEC_ID_NONE) {
video_enc.codec_type = AVMEDIA_TYPE_VIDEO; video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
video_enc.codec_id = video_id; video_enc.codec_id = video_id;
add_codec(stream, &video_enc); add_codec(stream, &video_enc);

2
libavcodec/4xm.c
View File

@ -981,7 +981,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_fourxm_decoder = { AVCodec ff_fourxm_decoder = {
.name = "4xm", .name = "4xm",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_4XM, .id = AV_CODEC_ID_4XM,
.priv_data_size = sizeof(FourXContext), .priv_data_size = sizeof(FourXContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,

2
libavcodec/8bps.c
View File

@ -220,7 +220,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_eightbps_decoder = { AVCodec ff_eightbps_decoder = {
.name = "8bps", .name = "8bps",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_8BPS, .id = AV_CODEC_ID_8BPS,
.priv_data_size = sizeof(EightBpsContext), .priv_data_size = sizeof(EightBpsContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,

14
libavcodec/8svx.c
View File

@ -191,10 +191,10 @@ static av_cold int eightsvx_decode_init(AVCodecContext *avctx)
} }
switch (avctx->codec->id) { switch (avctx->codec->id) {
case CODEC_ID_8SVX_FIB: esc->table = fibonacci; break; case AV_CODEC_ID_8SVX_FIB: esc->table = fibonacci; break;
case CODEC_ID_8SVX_EXP: esc->table = exponential; break; case AV_CODEC_ID_8SVX_EXP: esc->table = exponential; break;
case CODEC_ID_PCM_S8_PLANAR: case AV_CODEC_ID_PCM_S8_PLANAR:
case CODEC_ID_8SVX_RAW: esc->table = NULL; break; case AV_CODEC_ID_8SVX_RAW: esc->table = NULL; break;
default: default:
av_log(avctx, AV_LOG_ERROR, "Invalid codec id %d.\n", avctx->codec->id); av_log(avctx, AV_LOG_ERROR, "Invalid codec id %d.\n", avctx->codec->id);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -222,7 +222,7 @@ static av_cold int eightsvx_decode_close(AVCodecContext *avctx)
AVCodec ff_eightsvx_fib_decoder = { AVCodec ff_eightsvx_fib_decoder = {
.name = "8svx_fib", .name = "8svx_fib",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_8SVX_FIB, .id = AV_CODEC_ID_8SVX_FIB,
.priv_data_size = sizeof (EightSvxContext), .priv_data_size = sizeof (EightSvxContext),
.init = eightsvx_decode_init, .init = eightsvx_decode_init,
.decode = eightsvx_decode_frame, .decode = eightsvx_decode_frame,
@ -235,7 +235,7 @@ AVCodec ff_eightsvx_fib_decoder = {
AVCodec ff_eightsvx_exp_decoder = { AVCodec ff_eightsvx_exp_decoder = {
.name = "8svx_exp", .name = "8svx_exp",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_8SVX_EXP, .id = AV_CODEC_ID_8SVX_EXP,
.priv_data_size = sizeof (EightSvxContext), .priv_data_size = sizeof (EightSvxContext),
.init = eightsvx_decode_init, .init = eightsvx_decode_init,
.decode = eightsvx_decode_frame, .decode = eightsvx_decode_frame,
@ -248,7 +248,7 @@ AVCodec ff_eightsvx_exp_decoder = {
AVCodec ff_pcm_s8_planar_decoder = { AVCodec ff_pcm_s8_planar_decoder = {
.name = "pcm_s8_planar", .name = "pcm_s8_planar",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_PCM_S8_PLANAR, .id = AV_CODEC_ID_PCM_S8_PLANAR,
.priv_data_size = sizeof(EightSvxContext), .priv_data_size = sizeof(EightSvxContext),
.init = eightsvx_decode_init, .init = eightsvx_decode_init,
.close = eightsvx_decode_close, .close = eightsvx_decode_close,

1
libavcodec/Makefile
View File

@ -6,6 +6,7 @@ FFLIBS = avutil
HEADERS = avcodec.h \ HEADERS = avcodec.h \
avfft.h \ avfft.h \
dxva2.h \ dxva2.h \
old_codec_ids.h \
vaapi.h \ vaapi.h \
vda.h \ vda.h \
vdpau.h \ vdpau.h \

6
libavcodec/a64multienc.c
View File

@ -187,7 +187,7 @@ static av_cold int a64multi_init_encoder(AVCodecContext *avctx)
av_log(avctx, AV_LOG_INFO, "charset lifetime set to %d frame(s)\n", c->mc_lifetime); av_log(avctx, AV_LOG_INFO, "charset lifetime set to %d frame(s)\n", c->mc_lifetime);
c->mc_frame_counter = 0; c->mc_frame_counter = 0;
c->mc_use_5col = avctx->codec->id == CODEC_ID_A64_MULTI5; c->mc_use_5col = avctx->codec->id == AV_CODEC_ID_A64_MULTI5;
c->mc_pal_size = 4 + c->mc_use_5col; c->mc_pal_size = 4 + c->mc_use_5col;
/* precalc luma values for later use */ /* precalc luma values for later use */
@ -372,7 +372,7 @@ static int a64multi_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
AVCodec ff_a64multi_encoder = { AVCodec ff_a64multi_encoder = {
.name = "a64multi", .name = "a64multi",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_A64_MULTI, .id = AV_CODEC_ID_A64_MULTI,
.priv_data_size = sizeof(A64Context), .priv_data_size = sizeof(A64Context),
.init = a64multi_init_encoder, .init = a64multi_init_encoder,
.encode2 = a64multi_encode_frame, .encode2 = a64multi_encode_frame,
@ -386,7 +386,7 @@ AVCodec ff_a64multi_encoder = {
AVCodec ff_a64multi5_encoder = { AVCodec ff_a64multi5_encoder = {
.name = "a64multi5", .name = "a64multi5",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_A64_MULTI5, .id = AV_CODEC_ID_A64_MULTI5,
.priv_data_size = sizeof(A64Context), .priv_data_size = sizeof(A64Context),
.init = a64multi_init_encoder, .init = a64multi_init_encoder,
.encode2 = a64multi_encode_frame, .encode2 = a64multi_encode_frame,

6
libavcodec/aac_ac3_parser.c
View File

@ -78,7 +78,7 @@ get_next:
and total number of samples found in an AAC ADTS header are not and total number of samples found in an AAC ADTS header are not
reliable. Bit rate is still accurate because the total frame duration in reliable. Bit rate is still accurate because the total frame duration in
seconds is still correct (as is the number of bits in the frame). */ seconds is still correct (as is the number of bits in the frame). */
if (avctx->codec_id != CODEC_ID_AAC) { if (avctx->codec_id != AV_CODEC_ID_AAC) {
avctx->sample_rate = s->sample_rate; avctx->sample_rate = s->sample_rate;
/* allow downmixing to stereo (or mono for AC-3) */ /* allow downmixing to stereo (or mono for AC-3) */
@ -86,8 +86,8 @@ get_next:
avctx->request_channels < s->channels && avctx->request_channels < s->channels &&
(avctx->request_channels <= 2 || (avctx->request_channels <= 2 ||
(avctx->request_channels == 1 && (avctx->request_channels == 1 &&
(avctx->codec_id == CODEC_ID_AC3 || (avctx->codec_id == AV_CODEC_ID_AC3 ||
avctx->codec_id == CODEC_ID_EAC3)))) { avctx->codec_id == AV_CODEC_ID_EAC3)))) {
avctx->channels = avctx->request_channels; avctx->channels = avctx->request_channels;
} else { } else {
avctx->channels = s->channels; avctx->channels = s->channels;

2
libavcodec/aac_ac3_parser.h
View File

@ -55,7 +55,7 @@ typedef struct AACAC3ParseContext {
uint64_t state; uint64_t state;
int need_next_header; int need_next_header;
enum CodecID codec_id; enum AVCodecID codec_id;
} AACAC3ParseContext; } AACAC3ParseContext;
int ff_aac_ac3_parse(AVCodecParserContext *s1, int ff_aac_ac3_parse(AVCodecParserContext *s1,

2
libavcodec/aac_parser.c
View File

@ -61,7 +61,7 @@ static av_cold int aac_parse_init(AVCodecParserContext *s1)
AVCodecParser ff_aac_parser = { AVCodecParser ff_aac_parser = {
.codec_ids = { CODEC_ID_AAC }, .codec_ids = { AV_CODEC_ID_AAC },
.priv_data_size = sizeof(AACAC3ParseContext), .priv_data_size = sizeof(AACAC3ParseContext),
.parser_init = aac_parse_init, .parser_init = aac_parse_init,
.parser_parse = ff_aac_ac3_parse, .parser_parse = ff_aac_ac3_parse,

4
libavcodec/aacdec.c
View File

@ -2887,7 +2887,7 @@ static av_cold int latm_decode_init(AVCodecContext *avctx)
AVCodec ff_aac_decoder = { AVCodec ff_aac_decoder = {
.name = "aac", .name = "aac",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AAC, .id = AV_CODEC_ID_AAC,
.priv_data_size = sizeof(AACContext), .priv_data_size = sizeof(AACContext),
.init = aac_decode_init, .init = aac_decode_init,
.close = aac_decode_close, .close = aac_decode_close,
@ -2909,7 +2909,7 @@ AVCodec ff_aac_decoder = {
AVCodec ff_aac_latm_decoder = { AVCodec ff_aac_latm_decoder = {
.name = "aac_latm", .name = "aac_latm",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AAC_LATM, .id = AV_CODEC_ID_AAC_LATM,
.priv_data_size = sizeof(struct LATMContext), .priv_data_size = sizeof(struct LATMContext),
.init = latm_decode_init, .init = latm_decode_init,
.close = aac_decode_close, .close = aac_decode_close,

2
libavcodec/aacenc.c
View File

@ -819,7 +819,7 @@ static const AVClass aacenc_class = {
AVCodec ff_aac_encoder = { AVCodec ff_aac_encoder = {
.name = "aac", .name = "aac",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AAC, .id = AV_CODEC_ID_AAC,
.priv_data_size = sizeof(AACEncContext), .priv_data_size = sizeof(AACEncContext),
.init = aac_encode_init, .init = aac_encode_init,
.encode2 = aac_encode_frame, .encode2 = aac_encode_frame,

2
libavcodec/aasc.c
View File

@ -132,7 +132,7 @@ static av_cold int aasc_decode_end(AVCodecContext *avctx)
AVCodec ff_aasc_decoder = { AVCodec ff_aasc_decoder = {
.name = "aasc", .name = "aasc",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_AASC, .id = AV_CODEC_ID_AASC,
.priv_data_size = sizeof(AascContext), .priv_data_size = sizeof(AascContext),
.init = aasc_decode_init, .init = aasc_decode_init,
.close = aasc_decode_end, .close = aasc_decode_end,

8
libavcodec/ac3_parser.c
View File

@ -167,9 +167,9 @@ static int ac3_sync(uint64_t state, AACAC3ParseContext *hdr_info,
if (hdr.bitstream_mode == 0x7 && hdr.channels > 1) if (hdr.bitstream_mode == 0x7 && hdr.channels > 1)
hdr_info->service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE; hdr_info->service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
if(hdr.bitstream_id>10) if(hdr.bitstream_id>10)
hdr_info->codec_id = CODEC_ID_EAC3; hdr_info->codec_id = AV_CODEC_ID_EAC3;
else if (hdr_info->codec_id == CODEC_ID_NONE) else if (hdr_info->codec_id == AV_CODEC_ID_NONE)
hdr_info->codec_id = CODEC_ID_AC3; hdr_info->codec_id = AV_CODEC_ID_AC3;
*need_next_header = (hdr.frame_type != EAC3_FRAME_TYPE_AC3_CONVERT); *need_next_header = (hdr.frame_type != EAC3_FRAME_TYPE_AC3_CONVERT);
*new_frame_start = (hdr.frame_type != EAC3_FRAME_TYPE_DEPENDENT); *new_frame_start = (hdr.frame_type != EAC3_FRAME_TYPE_DEPENDENT);
@ -186,7 +186,7 @@ static av_cold int ac3_parse_init(AVCodecParserContext *s1)
AVCodecParser ff_ac3_parser = { AVCodecParser ff_ac3_parser = {
.codec_ids = { CODEC_ID_AC3, CODEC_ID_EAC3 }, .codec_ids = { AV_CODEC_ID_AC3, AV_CODEC_ID_EAC3 },
.priv_data_size = sizeof(AACAC3ParseContext), .priv_data_size = sizeof(AACAC3ParseContext),
.parser_init = ac3_parse_init, .parser_init = ac3_parse_init,
.parser_parse = ff_aac_ac3_parse, .parser_parse = ff_aac_ac3_parse,

4
libavcodec/ac3dec.c
View File

@ -1477,7 +1477,7 @@ static const AVClass ac3_decoder_class = {
AVCodec ff_ac3_decoder = { AVCodec ff_ac3_decoder = {
.name = "ac3", .name = "ac3",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AC3, .id = AV_CODEC_ID_AC3,
.priv_data_size = sizeof (AC3DecodeContext), .priv_data_size = sizeof (AC3DecodeContext),
.init = ac3_decode_init, .init = ac3_decode_init,
.close = ac3_decode_end, .close = ac3_decode_end,
@ -1501,7 +1501,7 @@ static const AVClass eac3_decoder_class = {
AVCodec ff_eac3_decoder = { AVCodec ff_eac3_decoder = {
.name = "eac3", .name = "eac3",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_EAC3, .id = AV_CODEC_ID_EAC3,
.priv_data_size = sizeof (AC3DecodeContext), .priv_data_size = sizeof (AC3DecodeContext),
.init = ac3_decode_init, .init = ac3_decode_init,
.close = ac3_decode_end, .close = ac3_decode_end,

2
libavcodec/ac3enc.c
View File

@ -2427,7 +2427,7 @@ av_cold int ff_ac3_encode_init(AVCodecContext *avctx)
s->avctx = avctx; s->avctx = avctx;
s->eac3 = avctx->codec_id == CODEC_ID_EAC3; s->eac3 = avctx->codec_id == AV_CODEC_ID_EAC3;
ff_ac3_common_init(); ff_ac3_common_init();

2
libavcodec/ac3enc_fixed.c
View File

@ -155,7 +155,7 @@ static av_cold int ac3_fixed_encode_init(AVCodecContext *avctx)
AVCodec ff_ac3_fixed_encoder = { AVCodec ff_ac3_fixed_encoder = {
.name = "ac3_fixed", .name = "ac3_fixed",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AC3, .id = AV_CODEC_ID_AC3,
.priv_data_size = sizeof(AC3EncodeContext), .priv_data_size = sizeof(AC3EncodeContext),
.init = ac3_fixed_encode_init, .init = ac3_fixed_encode_init,
.encode2 = ff_ac3_fixed_encode_frame, .encode2 = ff_ac3_fixed_encode_frame,

2
libavcodec/ac3enc_float.c
View File

@ -153,7 +153,7 @@ static CoefType calc_cpl_coord(CoefSumType energy_ch, CoefSumType energy_cpl)
AVCodec ff_ac3_encoder = { AVCodec ff_ac3_encoder = {
.name = "ac3", .name = "ac3",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AC3, .id = AV_CODEC_ID_AC3,
.priv_data_size = sizeof(AC3EncodeContext), .priv_data_size = sizeof(AC3EncodeContext),
.init = ff_ac3_encode_init, .init = ff_ac3_encode_init,
.encode2 = ff_ac3_float_encode_frame, .encode2 = ff_ac3_float_encode_frame,

206
libavcodec/adpcm.c
View File

@ -96,13 +96,13 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx)
unsigned int max_channels = 2; unsigned int max_channels = 2;
switch(avctx->codec->id) { switch(avctx->codec->id) {
case CODEC_ID_ADPCM_EA: case AV_CODEC_ID_ADPCM_EA:
min_channels = 2; min_channels = 2;
break; break;
case CODEC_ID_ADPCM_EA_R1: case AV_CODEC_ID_ADPCM_EA_R1:
case CODEC_ID_ADPCM_EA_R2: case AV_CODEC_ID_ADPCM_EA_R2:
case CODEC_ID_ADPCM_EA_R3: case AV_CODEC_ID_ADPCM_EA_R3:
case CODEC_ID_ADPCM_EA_XAS: case AV_CODEC_ID_ADPCM_EA_XAS:
max_channels = 6; max_channels = 6;
break; break;
} }
@ -112,22 +112,22 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx)
} }
switch(avctx->codec->id) { switch(avctx->codec->id) {
case CODEC_ID_ADPCM_CT: case AV_CODEC_ID_ADPCM_CT:
c->status[0].step = c->status[1].step = 511; c->status[0].step = c->status[1].step = 511;
break; break;
case CODEC_ID_ADPCM_IMA_WAV: case AV_CODEC_ID_ADPCM_IMA_WAV:
if (avctx->bits_per_coded_sample != 4) { if (avctx->bits_per_coded_sample != 4) {
av_log(avctx, AV_LOG_ERROR, "Only 4-bit ADPCM IMA WAV files are supported\n"); av_log(avctx, AV_LOG_ERROR, "Only 4-bit ADPCM IMA WAV files are supported\n");
return -1; return -1;
} }
break; break;
case CODEC_ID_ADPCM_IMA_APC: case AV_CODEC_ID_ADPCM_IMA_APC:
if (avctx->extradata && avctx->extradata_size >= 8) { if (avctx->extradata && avctx->extradata_size >= 8) {
c->status[0].predictor = AV_RL32(avctx->extradata); c->status[0].predictor = AV_RL32(avctx->extradata);
c->status[1].predictor = AV_RL32(avctx->extradata + 4); c->status[1].predictor = AV_RL32(avctx->extradata + 4);
} }
break; break;
case CODEC_ID_ADPCM_IMA_WS: case AV_CODEC_ID_ADPCM_IMA_WS:
if (avctx->extradata && avctx->extradata_size >= 2) if (avctx->extradata && avctx->extradata_size >= 2)
c->vqa_version = AV_RL16(avctx->extradata); c->vqa_version = AV_RL16(avctx->extradata);
break; break;
@ -423,22 +423,22 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
switch (avctx->codec->id) { switch (avctx->codec->id) {
/* constant, only check buf_size */ /* constant, only check buf_size */
case CODEC_ID_ADPCM_EA_XAS: case AV_CODEC_ID_ADPCM_EA_XAS:
if (buf_size < 76 * ch) if (buf_size < 76 * ch)
return 0; return 0;
nb_samples = 128; nb_samples = 128;
break; break;
case CODEC_ID_ADPCM_IMA_QT: case AV_CODEC_ID_ADPCM_IMA_QT:
if (buf_size < 34 * ch) if (buf_size < 34 * ch)
return 0; return 0;
nb_samples = 64; nb_samples = 64;
break; break;
/* simple 4-bit adpcm */ /* simple 4-bit adpcm */
case CODEC_ID_ADPCM_CT: case AV_CODEC_ID_ADPCM_CT:
case CODEC_ID_ADPCM_IMA_APC: case AV_CODEC_ID_ADPCM_IMA_APC:
case CODEC_ID_ADPCM_IMA_EA_SEAD: case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
case CODEC_ID_ADPCM_IMA_WS: case AV_CODEC_ID_ADPCM_IMA_WS:
case CODEC_ID_ADPCM_YAMAHA: case AV_CODEC_ID_ADPCM_YAMAHA:
nb_samples = buf_size * 2 / ch; nb_samples = buf_size * 2 / ch;
break; break;
} }
@ -448,46 +448,46 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
/* simple 4-bit adpcm, with header */ /* simple 4-bit adpcm, with header */
header_size = 0; header_size = 0;
switch (avctx->codec->id) { switch (avctx->codec->id) {
case CODEC_ID_ADPCM_4XM: case AV_CODEC_ID_ADPCM_4XM:
case CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break; case AV_CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break;
case CODEC_ID_ADPCM_IMA_AMV: header_size = 8; break; case AV_CODEC_ID_ADPCM_IMA_AMV: header_size = 8; break;
case CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4; break; case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4; break;
} }
if (header_size > 0) if (header_size > 0)
return (buf_size - header_size) * 2 / ch; return (buf_size - header_size) * 2 / ch;
/* more complex formats */ /* more complex formats */
switch (avctx->codec->id) { switch (avctx->codec->id) {
case CODEC_ID_ADPCM_EA: case AV_CODEC_ID_ADPCM_EA:
has_coded_samples = 1; has_coded_samples = 1;
*coded_samples = bytestream2_get_le32(gb); *coded_samples = bytestream2_get_le32(gb);
*coded_samples -= *coded_samples % 28; *coded_samples -= *coded_samples % 28;
nb_samples = (buf_size - 12) / 30 * 28; nb_samples = (buf_size - 12) / 30 * 28;
break; break;
case CODEC_ID_ADPCM_IMA_EA_EACS: case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
has_coded_samples = 1; has_coded_samples = 1;
*coded_samples = bytestream2_get_le32(gb); *coded_samples = bytestream2_get_le32(gb);
nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch; nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
break; break;
case CODEC_ID_ADPCM_EA_MAXIS_XA: case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
nb_samples = (buf_size - ch) / ch * 2; nb_samples = (buf_size - ch) / ch * 2;
break; break;
case CODEC_ID_ADPCM_EA_R1: case AV_CODEC_ID_ADPCM_EA_R1:
case CODEC_ID_ADPCM_EA_R2: case AV_CODEC_ID_ADPCM_EA_R2:
case CODEC_ID_ADPCM_EA_R3: case AV_CODEC_ID_ADPCM_EA_R3:
/* maximum number of samples */ /* maximum number of samples */
/* has internal offsets and a per-frame switch to signal raw 16-bit */ /* has internal offsets and a per-frame switch to signal raw 16-bit */
has_coded_samples = 1; has_coded_samples = 1;
switch (avctx->codec->id) { switch (avctx->codec->id) {
case CODEC_ID_ADPCM_EA_R1: case AV_CODEC_ID_ADPCM_EA_R1:
header_size = 4 + 9 * ch; header_size = 4 + 9 * ch;
*coded_samples = bytestream2_get_le32(gb); *coded_samples = bytestream2_get_le32(gb);
break; break;
case CODEC_ID_ADPCM_EA_R2: case AV_CODEC_ID_ADPCM_EA_R2:
header_size = 4 + 5 * ch; header_size = 4 + 5 * ch;
*coded_samples = bytestream2_get_le32(gb); *coded_samples = bytestream2_get_le32(gb);
break; break;
case CODEC_ID_ADPCM_EA_R3: case AV_CODEC_ID_ADPCM_EA_R3:
header_size = 4 + 5 * ch; header_size = 4 + 5 * ch;
*coded_samples = bytestream2_get_be32(gb); *coded_samples = bytestream2_get_be32(gb);
break; break;
@ -496,35 +496,35 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
nb_samples = (buf_size - header_size) * 2 / ch; nb_samples = (buf_size - header_size) * 2 / ch;
nb_samples -= nb_samples % 28; nb_samples -= nb_samples % 28;
break; break;
case CODEC_ID_ADPCM_IMA_DK3: case AV_CODEC_ID_ADPCM_IMA_DK3:
if (avctx->block_align > 0) if (avctx->block_align > 0)
buf_size = FFMIN(buf_size, avctx->block_align); buf_size = FFMIN(buf_size, avctx->block_align);
nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch; nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
break; break;
case CODEC_ID_ADPCM_IMA_DK4: case AV_CODEC_ID_ADPCM_IMA_DK4:
if (avctx->block_align > 0) if (avctx->block_align > 0)
buf_size = FFMIN(buf_size, avctx->block_align); buf_size = FFMIN(buf_size, avctx->block_align);
nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch; nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
break; break;
case CODEC_ID_ADPCM_IMA_WAV: case AV_CODEC_ID_ADPCM_IMA_WAV:
if (avctx->block_align > 0) if (avctx->block_align > 0)
buf_size = FFMIN(buf_size, avctx->block_align); buf_size = FFMIN(buf_size, avctx->block_align);
nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8; nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8;
break; break;
case CODEC_ID_ADPCM_MS: case AV_CODEC_ID_ADPCM_MS:
if (avctx->block_align > 0) if (avctx->block_align > 0)
buf_size = FFMIN(buf_size, avctx->block_align); buf_size = FFMIN(buf_size, avctx->block_align);
nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch; nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
break; break;
case CODEC_ID_ADPCM_SBPRO_2: case AV_CODEC_ID_ADPCM_SBPRO_2:
case CODEC_ID_ADPCM_SBPRO_3: case AV_CODEC_ID_ADPCM_SBPRO_3:
case CODEC_ID_ADPCM_SBPRO_4: case AV_CODEC_ID_ADPCM_SBPRO_4:
{ {
int samples_per_byte; int samples_per_byte;
switch (avctx->codec->id) { switch (avctx->codec->id) {
case CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break; case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
case CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break; case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
case CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break; case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
} }
if (!s->status[0].step_index) { if (!s->status[0].step_index) {
nb_samples++; nb_samples++;
@ -533,7 +533,7 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
nb_samples += buf_size * samples_per_byte / ch; nb_samples += buf_size * samples_per_byte / ch;
break; break;
} }
case CODEC_ID_ADPCM_SWF: case AV_CODEC_ID_ADPCM_SWF:
{ {
int buf_bits = buf_size * 8 - 2; int buf_bits = buf_size * 8 - 2;
int nbits = (bytestream2_get_byte(gb) >> 6) + 2; int nbits = (bytestream2_get_byte(gb) >> 6) + 2;
@ -546,14 +546,14 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch); nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
break; break;
} }
case CODEC_ID_ADPCM_THP: case AV_CODEC_ID_ADPCM_THP:
has_coded_samples = 1; has_coded_samples = 1;
bytestream2_skip(gb, 4); // channel size bytestream2_skip(gb, 4); // channel size
*coded_samples = bytestream2_get_be32(gb); *coded_samples = bytestream2_get_be32(gb);
*coded_samples -= *coded_samples % 14; *coded_samples -= *coded_samples % 14;
nb_samples = (buf_size - 80) / (8 * ch) * 14; nb_samples = (buf_size - 80) / (8 * ch) * 14;
break; break;
case CODEC_ID_ADPCM_XA: case AV_CODEC_ID_ADPCM_XA:
nb_samples = (buf_size / 128) * 224 / ch; nb_samples = (buf_size / 128) * 224 / ch;
break; break;
} }
@ -605,7 +605,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
st = avctx->channels == 2 ? 1 : 0; st = avctx->channels == 2 ? 1 : 0;
switch(avctx->codec->id) { switch(avctx->codec->id) {
case CODEC_ID_ADPCM_IMA_QT: case AV_CODEC_ID_ADPCM_IMA_QT:
/* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples). /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
Channel data is interleaved per-chunk. */ Channel data is interleaved per-chunk. */
for (channel = 0; channel < avctx->channels; channel++) { for (channel = 0; channel < avctx->channels; channel++) {
@ -648,7 +648,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
} }
} }
break; break;
case CODEC_ID_ADPCM_IMA_WAV: case AV_CODEC_ID_ADPCM_IMA_WAV:
for(i=0; i<avctx->channels; i++){ for(i=0; i<avctx->channels; i++){
cs = &(c->status[i]); cs = &(c->status[i]);
cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16); cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
@ -676,7 +676,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
samples += 7 * avctx->channels; samples += 7 * avctx->channels;
} }
break; break;
case CODEC_ID_ADPCM_4XM: case AV_CODEC_ID_ADPCM_4XM:
for (i = 0; i < avctx->channels; i++) for (i = 0; i < avctx->channels; i++)
c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16); c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
@ -701,7 +701,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
} }
} }
break; break;
case CODEC_ID_ADPCM_MS: case AV_CODEC_ID_ADPCM_MS:
{ {
int block_predictor; int block_predictor;
@ -744,7 +744,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
} }
break; break;
} }
case CODEC_ID_ADPCM_IMA_DK4: case AV_CODEC_ID_ADPCM_IMA_DK4:
for (channel = 0; channel < avctx->channels; channel++) { for (channel = 0; channel < avctx->channels; channel++) {
cs = &c->status[channel]; cs = &c->status[channel];
cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16); cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
@ -761,7 +761,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
*samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3); *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
} }
break; break;
case CODEC_ID_ADPCM_IMA_DK3: case AV_CODEC_ID_ADPCM_IMA_DK3:
{ {
int last_byte = 0; int last_byte = 0;
int nibble; int nibble;
@ -822,7 +822,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
} }
break; break;
} }
case CODEC_ID_ADPCM_IMA_ISS: case AV_CODEC_ID_ADPCM_IMA_ISS:
for (channel = 0; channel < avctx->channels; channel++) { for (channel = 0; channel < avctx->channels; channel++) {
cs = &c->status[channel]; cs = &c->status[channel];
cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16); cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
@ -849,14 +849,14 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
*samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3); *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
} }
break; break;
case CODEC_ID_ADPCM_IMA_APC: case AV_CODEC_ID_ADPCM_IMA_APC:
while (bytestream2_get_bytes_left(&gb) > 0) { while (bytestream2_get_bytes_left(&gb) > 0) {
int v = bytestream2_get_byteu(&gb); int v = bytestream2_get_byteu(&gb);
*samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3); *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
*samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3); *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
} }
break; break;
case CODEC_ID_ADPCM_IMA_WS: case AV_CODEC_ID_ADPCM_IMA_WS:
if (c->vqa_version == 3) { if (c->vqa_version == 3) {
for (channel = 0; channel < avctx->channels; channel++) { for (channel = 0; channel < avctx->channels; channel++) {
int16_t *smp = samples + channel; int16_t *smp = samples + channel;
@ -881,7 +881,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
} }
bytestream2_seek(&gb, 0, SEEK_END); bytestream2_seek(&gb, 0, SEEK_END);
break; break;
case CODEC_ID_ADPCM_XA: case AV_CODEC_ID_ADPCM_XA:
while (bytestream2_get_bytes_left(&gb) >= 128) { while (bytestream2_get_bytes_left(&gb) >= 128) {
if ((ret = xa_decode(avctx, samples, buf + bytestream2_tell(&gb), &c->status[0], if ((ret = xa_decode(avctx, samples, buf + bytestream2_tell(&gb), &c->status[0],
&c->status[1], avctx->channels)) < 0) &c->status[1], avctx->channels)) < 0)
@ -890,7 +890,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
samples += 28 * 8; samples += 28 * 8;
} }
break; break;
case CODEC_ID_ADPCM_IMA_EA_EACS: case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
for (i=0; i<=st; i++) { for (i=0; i<=st; i++) {
c->status[i].step_index = bytestream2_get_le32u(&gb); c->status[i].step_index = bytestream2_get_le32u(&gb);
if (c->status[i].step_index > 88u) { if (c->status[i].step_index > 88u) {
@ -908,14 +908,14 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
*samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3); *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
} }
break; break;
case CODEC_ID_ADPCM_IMA_EA_SEAD: case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
for (n = nb_samples >> (1 - st); n > 0; n--) { for (n = nb_samples >> (1 - st); n > 0; n--) {
int byte = bytestream2_get_byteu(&gb); int byte = bytestream2_get_byteu(&gb);
*samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6); *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6);
*samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6); *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
} }
break; break;
case CODEC_ID_ADPCM_EA: case AV_CODEC_ID_ADPCM_EA:
{ {
int previous_left_sample, previous_right_sample; int previous_left_sample, previous_right_sample;
int current_left_sample, current_right_sample; int current_left_sample, current_right_sample;
@ -970,7 +970,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
break; break;
} }
case CODEC_ID_ADPCM_EA_MAXIS_XA: case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
{ {
int coeff[2][2], shift[2]; int coeff[2][2], shift[2];
@ -1000,14 +1000,14 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
bytestream2_seek(&gb, 0, SEEK_END); bytestream2_seek(&gb, 0, SEEK_END);
break; break;
} }
case CODEC_ID_ADPCM_EA_R1: case AV_CODEC_ID_ADPCM_EA_R1:
case CODEC_ID_ADPCM_EA_R2: case AV_CODEC_ID_ADPCM_EA_R2:
case CODEC_ID_ADPCM_EA_R3: { case AV_CODEC_ID_ADPCM_EA_R3: {
/* channel numbering /* channel numbering
2chan: 0=fl, 1=fr 2chan: 0=fl, 1=fr
4chan: 0=fl, 1=rl, 2=fr, 3=rr 4chan: 0=fl, 1=rl, 2=fr, 3=rr
6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */ 6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */
const int big_endian = avctx->codec->id == CODEC_ID_ADPCM_EA_R3; const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
int previous_sample, current_sample, next_sample; int previous_sample, current_sample, next_sample;
int coeff1, coeff2; int coeff1, coeff2;
int shift; int shift;
@ -1025,7 +1025,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
bytestream2_seek(&gb, offsets[channel], SEEK_SET); bytestream2_seek(&gb, offsets[channel], SEEK_SET);
samplesC = samples + channel; samplesC = samples + channel;
if (avctx->codec->id == CODEC_ID_ADPCM_EA_R1) { if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
current_sample = sign_extend(bytestream2_get_le16(&gb), 16); current_sample = sign_extend(bytestream2_get_le16(&gb), 16);
previous_sample = sign_extend(bytestream2_get_le16(&gb), 16); previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
} else { } else {
@ -1074,7 +1074,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
count = FFMAX(count, count1); count = FFMAX(count, count1);
} }
if (avctx->codec->id != CODEC_ID_ADPCM_EA_R1) { if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
c->status[channel].predictor = current_sample; c->status[channel].predictor = current_sample;
c->status[channel].prev_sample = previous_sample; c->status[channel].prev_sample = previous_sample;
} }
@ -1084,7 +1084,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
bytestream2_seek(&gb, 0, SEEK_END); bytestream2_seek(&gb, 0, SEEK_END);
break; break;
} }
case CODEC_ID_ADPCM_EA_XAS: case AV_CODEC_ID_ADPCM_EA_XAS:
for (channel=0; channel<avctx->channels; channel++) { for (channel=0; channel<avctx->channels; channel++) {
int coeff[2][4], shift[4]; int coeff[2][4], shift[4];
short *s2, *s = &samples[channel]; short *s2, *s = &samples[channel];
@ -1113,9 +1113,9 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
} }
} }
break; break;
case CODEC_ID_ADPCM_IMA_AMV: case AV_CODEC_ID_ADPCM_IMA_AMV:
case CODEC_ID_ADPCM_IMA_SMJPEG: case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV) { if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16); c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
c->status[0].step_index = bytestream2_get_le16u(&gb); c->status[0].step_index = bytestream2_get_le16u(&gb);
bytestream2_skipu(&gb, 4); bytestream2_skipu(&gb, 4);
@ -1133,7 +1133,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
for (n = nb_samples >> (1 - st); n > 0; n--) { for (n = nb_samples >> (1 - st); n > 0; n--) {
int hi, lo, v = bytestream2_get_byteu(&gb); int hi, lo, v = bytestream2_get_byteu(&gb);
if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV) { if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
hi = v & 0x0F; hi = v & 0x0F;
lo = v >> 4; lo = v >> 4;
} else { } else {
@ -1145,16 +1145,16 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
*samples++ = adpcm_ima_expand_nibble(&c->status[0], hi, 3); *samples++ = adpcm_ima_expand_nibble(&c->status[0], hi, 3);
} }
break; break;
case CODEC_ID_ADPCM_CT: case AV_CODEC_ID_ADPCM_CT:
for (n = nb_samples >> (1 - st); n > 0; n--) { for (n = nb_samples >> (1 - st); n > 0; n--) {
int v = bytestream2_get_byteu(&gb); int v = bytestream2_get_byteu(&gb);
*samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 ); *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );
*samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F); *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
} }
break; break;
case CODEC_ID_ADPCM_SBPRO_4: case AV_CODEC_ID_ADPCM_SBPRO_4:
case CODEC_ID_ADPCM_SBPRO_3: case AV_CODEC_ID_ADPCM_SBPRO_3:
case CODEC_ID_ADPCM_SBPRO_2: case AV_CODEC_ID_ADPCM_SBPRO_2:
if (!c->status[0].step_index) { if (!c->status[0].step_index) {
/* the first byte is a raw sample */ /* the first byte is a raw sample */
*samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80); *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
@ -1163,7 +1163,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
c->status[0].step_index = 1; c->status[0].step_index = 1;
nb_samples--; nb_samples--;
} }
if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) { if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
for (n = nb_samples >> (1 - st); n > 0; n--) { for (n = nb_samples >> (1 - st); n > 0; n--) {
int byte = bytestream2_get_byteu(&gb); int byte = bytestream2_get_byteu(&gb);
*samples++ = adpcm_sbpro_expand_nibble(&c->status[0], *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
@ -1171,7 +1171,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
*samples++ = adpcm_sbpro_expand_nibble(&c->status[st], *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
byte & 0x0F, 4, 0); byte & 0x0F, 4, 0);
} }
} else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) { } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
for (n = nb_samples / 3; n > 0; n--) { for (n = nb_samples / 3; n > 0; n--) {
int byte = bytestream2_get_byteu(&gb); int byte = bytestream2_get_byteu(&gb);
*samples++ = adpcm_sbpro_expand_nibble(&c->status[0], *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
@ -1195,18 +1195,18 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
} }
} }
break; break;
case CODEC_ID_ADPCM_SWF: case AV_CODEC_ID_ADPCM_SWF:
adpcm_swf_decode(avctx, buf, buf_size, samples); adpcm_swf_decode(avctx, buf, buf_size, samples);
bytestream2_seek(&gb, 0, SEEK_END); bytestream2_seek(&gb, 0, SEEK_END);
break; break;
case CODEC_ID_ADPCM_YAMAHA: case AV_CODEC_ID_ADPCM_YAMAHA:
for (n = nb_samples >> (1 - st); n > 0; n--) { for (n = nb_samples >> (1 - st); n > 0; n--) {
int v = bytestream2_get_byteu(&gb); int v = bytestream2_get_byteu(&gb);
*samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F); *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
*samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 ); *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 );
} }
break; break;
case CODEC_ID_ADPCM_THP: case AV_CODEC_ID_ADPCM_THP:
{ {
int table[2][16]; int table[2][16];
int prev[2][2]; int prev[2][2];
@ -1282,30 +1282,30 @@ AVCodec ff_ ## name_ ## _decoder = { \
} }
/* Note: Do not forget to add new entries to the Makefile as well. */ /* Note: Do not forget to add new entries to the Makefile as well. */
ADPCM_DECODER(CODEC_ID_ADPCM_4XM, adpcm_4xm, "ADPCM 4X Movie"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM, adpcm_4xm, "ADPCM 4X Movie");
ADPCM_DECODER(CODEC_ID_ADPCM_CT, adpcm_ct, "ADPCM Creative Technology"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT, adpcm_ct, "ADPCM Creative Technology");
ADPCM_DECODER(CODEC_ID_ADPCM_EA, adpcm_ea, "ADPCM Electronic Arts"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA, adpcm_ea, "ADPCM Electronic Arts");
ADPCM_DECODER(CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1, "ADPCM Electronic Arts R1"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1, "ADPCM Electronic Arts R1");
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2, "ADPCM Electronic Arts R2"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2, "ADPCM Electronic Arts R2");
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "ADPCM Electronic Arts R3"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "ADPCM Electronic Arts R3");
ADPCM_DECODER(CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "ADPCM Electronic Arts XAS"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "ADPCM IMA AMV"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "ADPCM IMA AMV");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_APC, adpcm_ima_apc, "ADPCM IMA CRYO APC"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APC, adpcm_ima_apc, "ADPCM IMA CRYO APC");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "ADPCM IMA Duck DK3"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "ADPCM IMA Duck DK4"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_ISS, adpcm_ima_iss, "ADPCM IMA Funcom ISS"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ISS, adpcm_ima_iss, "ADPCM IMA Funcom ISS");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws, "ADPCM IMA Westwood"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws, "ADPCM IMA Westwood");
ADPCM_DECODER(CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");
ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");
ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");
ADPCM_DECODER(CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
ADPCM_DECODER(CODEC_ID_ADPCM_THP, adpcm_thp, "ADPCM Nintendo Gamecube THP"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP, adpcm_thp, "ADPCM Nintendo Gamecube THP");
ADPCM_DECODER(CODEC_ID_ADPCM_XA, adpcm_xa, "ADPCM CDROM XA"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA, adpcm_xa, "ADPCM CDROM XA");
ADPCM_DECODER(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");

52
libavcodec/adpcmenc.c
View File

@ -94,7 +94,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id); avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
switch (avctx->codec->id) { switch (avctx->codec->id) {
case CODEC_ID_ADPCM_IMA_WAV: case AV_CODEC_ID_ADPCM_IMA_WAV:
/* each 16 bits sample gives one nibble /* each 16 bits sample gives one nibble
and we have 4 bytes per channel overhead */ and we have 4 bytes per channel overhead */
avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 /
@ -104,11 +104,11 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
avctx->block_align = BLKSIZE; avctx->block_align = BLKSIZE;
avctx->bits_per_coded_sample = 4; avctx->bits_per_coded_sample = 4;
break; break;
case CODEC_ID_ADPCM_IMA_QT: case AV_CODEC_ID_ADPCM_IMA_QT:
avctx->frame_size = 64; avctx->frame_size = 64;
avctx->block_align = 34 * avctx->channels; avctx->block_align = 34 * avctx->channels;
break; break;
case CODEC_ID_ADPCM_MS: case AV_CODEC_ID_ADPCM_MS:
/* each 16 bits sample gives one nibble /* each 16 bits sample gives one nibble
and we have 7 bytes per channel overhead */ and we have 7 bytes per channel overhead */
avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2;
@ -125,11 +125,11 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff2[i] * 4); bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff2[i] * 4);
} }
break; break;
case CODEC_ID_ADPCM_YAMAHA: case AV_CODEC_ID_ADPCM_YAMAHA:
avctx->frame_size = BLKSIZE * 2 / avctx->channels; avctx->frame_size = BLKSIZE * 2 / avctx->channels;
avctx->block_align = BLKSIZE; avctx->block_align = BLKSIZE;
break; break;
case CODEC_ID_ADPCM_SWF: case AV_CODEC_ID_ADPCM_SWF:
if (avctx->sample_rate != 11025 && if (avctx->sample_rate != 11025 &&
avctx->sample_rate != 22050 && avctx->sample_rate != 22050 &&
avctx->sample_rate != 44100) { avctx->sample_rate != 44100) {
@ -297,13 +297,13 @@ static void adpcm_compress_trellis(AVCodecContext *avctx,
nodes[0]->step = c->step_index; nodes[0]->step = c->step_index;
nodes[0]->sample1 = c->sample1; nodes[0]->sample1 = c->sample1;
nodes[0]->sample2 = c->sample2; nodes[0]->sample2 = c->sample2;
if (version == CODEC_ID_ADPCM_IMA_WAV || if (version == AV_CODEC_ID_ADPCM_IMA_WAV ||
version == CODEC_ID_ADPCM_IMA_QT || version == AV_CODEC_ID_ADPCM_IMA_QT ||
version == CODEC_ID_ADPCM_SWF) version == AV_CODEC_ID_ADPCM_SWF)
nodes[0]->sample1 = c->prev_sample; nodes[0]->sample1 = c->prev_sample;
if (version == CODEC_ID_ADPCM_MS) if (version == AV_CODEC_ID_ADPCM_MS)
nodes[0]->step = c->idelta; nodes[0]->step = c->idelta;
if (version == CODEC_ID_ADPCM_YAMAHA) { if (version == AV_CODEC_ID_ADPCM_YAMAHA) {
if (c->step == 0) { if (c->step == 0) {
nodes[0]->step = 127; nodes[0]->step = 127;
nodes[0]->sample1 = 0; nodes[0]->sample1 = 0;
@ -325,7 +325,7 @@ static void adpcm_compress_trellis(AVCodecContext *avctx,
const int range = (j < frontier / 2) ? 1 : 0; const int range = (j < frontier / 2) ? 1 : 0;
const int step = nodes[j]->step; const int step = nodes[j]->step;
int nidx; int nidx;
if (version == CODEC_ID_ADPCM_MS) { if (version == AV_CODEC_ID_ADPCM_MS) {
const int predictor = ((nodes[j]->sample1 * c->coeff1) + const int predictor = ((nodes[j]->sample1 * c->coeff1) +
(nodes[j]->sample2 * c->coeff2)) / 64; (nodes[j]->sample2 * c->coeff2)) / 64;
const int div = (sample - predictor) / step; const int div = (sample - predictor) / step;
@ -401,9 +401,9 @@ static void adpcm_compress_trellis(AVCodecContext *avctx,
STORE_NODE(ms, FFMAX(16, STORE_NODE(ms, FFMAX(16,
(ff_adpcm_AdaptationTable[nibble] * step) >> 8)); (ff_adpcm_AdaptationTable[nibble] * step) >> 8));
} }
} else if (version == CODEC_ID_ADPCM_IMA_WAV || } else if (version == AV_CODEC_ID_ADPCM_IMA_WAV ||
version == CODEC_ID_ADPCM_IMA_QT || version == AV_CODEC_ID_ADPCM_IMA_QT ||
version == CODEC_ID_ADPCM_SWF) { version == AV_CODEC_ID_ADPCM_SWF) {
#define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\ #define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\
const int predictor = nodes[j]->sample1;\ const int predictor = nodes[j]->sample1;\
const int div = (sample - predictor) * 4 / STEP_TABLE;\ const int div = (sample - predictor) * 4 / STEP_TABLE;\
@ -422,7 +422,7 @@ static void adpcm_compress_trellis(AVCodecContext *avctx,
} }
LOOP_NODES(ima, ff_adpcm_step_table[step], LOOP_NODES(ima, ff_adpcm_step_table[step],
av_clip(step + ff_adpcm_index_table[nibble], 0, 88)); av_clip(step + ff_adpcm_index_table[nibble], 0, 88));
} else { //CODEC_ID_ADPCM_YAMAHA } else { //AV_CODEC_ID_ADPCM_YAMAHA
LOOP_NODES(yamaha, step, LOOP_NODES(yamaha, step,
av_clip((step * ff_adpcm_yamaha_indexscale[nibble]) >> 8, av_clip((step * ff_adpcm_yamaha_indexscale[nibble]) >> 8,
127, 24567)); 127, 24567));
@ -490,7 +490,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
samples = (const int16_t *)frame->data[0]; samples = (const int16_t *)frame->data[0];
st = avctx->channels == 2; st = avctx->channels == 2;
if (avctx->codec_id == CODEC_ID_ADPCM_SWF) if (avctx->codec_id == AV_CODEC_ID_ADPCM_SWF)
pkt_size = (2 + avctx->channels * (22 + 4 * (frame->nb_samples - 1)) + 7) / 8; pkt_size = (2 + avctx->channels * (22 + 4 * (frame->nb_samples - 1)) + 7) / 8;
else else
pkt_size = avctx->block_align; pkt_size = avctx->block_align;
@ -499,7 +499,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
dst = avpkt->data; dst = avpkt->data;
switch(avctx->codec->id) { switch(avctx->codec->id) {
case CODEC_ID_ADPCM_IMA_WAV: case AV_CODEC_ID_ADPCM_IMA_WAV:
n = frame->nb_samples / 8; n = frame->nb_samples / 8;
c->status[0].prev_sample = samples[0]; c->status[0].prev_sample = samples[0];
/* c->status[0].step_index = 0; /* c->status[0].step_index = 0;
@ -564,7 +564,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
} }
} }
break; break;
case CODEC_ID_ADPCM_IMA_QT: case AV_CODEC_ID_ADPCM_IMA_QT:
{ {
int ch, i; int ch, i;
PutBitContext pb; PutBitContext pb;
@ -594,7 +594,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
flush_put_bits(&pb); flush_put_bits(&pb);
break; break;
} }
case CODEC_ID_ADPCM_SWF: case AV_CODEC_ID_ADPCM_SWF:
{ {
int i; int i;
PutBitContext pb; PutBitContext pb;
@ -638,7 +638,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
flush_put_bits(&pb); flush_put_bits(&pb);
break; break;
} }
case CODEC_ID_ADPCM_MS: case AV_CODEC_ID_ADPCM_MS:
for (i = 0; i < avctx->channels; i++) { for (i = 0; i < avctx->channels; i++) {
int predictor = 0; int predictor = 0;
*dst++ = predictor; *dst++ = predictor;
@ -682,7 +682,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
} }
} }
break; break;
case CODEC_ID_ADPCM_YAMAHA: case AV_CODEC_ID_ADPCM_YAMAHA:
n = frame->nb_samples / 2; n = frame->nb_samples / 2;
if (avctx->trellis > 0) { if (avctx->trellis > 0) {
FF_ALLOC_OR_GOTO(avctx, buf, 2 * n * 2, error); FF_ALLOC_OR_GOTO(avctx, buf, 2 * n * 2, error);
@ -734,8 +734,8 @@ AVCodec ff_ ## name_ ## _encoder = { \
.long_name = NULL_IF_CONFIG_SMALL(long_name_), \ .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
} }
ADPCM_ENCODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime"); ADPCM_ENCODER(AV_CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
ADPCM_ENCODER(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV"); ADPCM_ENCODER(AV_CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
ADPCM_ENCODER(CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft"); ADPCM_ENCODER(AV_CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
ADPCM_ENCODER(CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash"); ADPCM_ENCODER(AV_CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
ADPCM_ENCODER(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha"); ADPCM_ENCODER(AV_CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");

2
libavcodec/adx_parser.c
View File

@ -89,7 +89,7 @@ static int adx_parse(AVCodecParserContext *s1,
} }
AVCodecParser ff_adx_parser = { AVCodecParser ff_adx_parser = {
.codec_ids = { CODEC_ID_ADPCM_ADX }, .codec_ids = { AV_CODEC_ID_ADPCM_ADX },
.priv_data_size = sizeof(ADXParseContext), .priv_data_size = sizeof(ADXParseContext),
.parser_parse = adx_parse, .parser_parse = adx_parse,
.parser_close = ff_parse_close, .parser_close = ff_parse_close,

2
libavcodec/adxdec.c
View File

@ -176,7 +176,7 @@ static void adx_decode_flush(AVCodecContext *avctx)
AVCodec ff_adpcm_adx_decoder = { AVCodec ff_adpcm_adx_decoder = {
.name = "adpcm_adx", .name = "adpcm_adx",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ADPCM_ADX, .id = AV_CODEC_ID_ADPCM_ADX,
.priv_data_size = sizeof(ADXContext), .priv_data_size = sizeof(ADXContext),
.init = adx_decode_init, .init = adx_decode_init,
.decode = adx_decode_frame, .decode = adx_decode_frame,

2
libavcodec/adxenc.c
View File

@ -164,7 +164,7 @@ static int adx_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
AVCodec ff_adpcm_adx_encoder = { AVCodec ff_adpcm_adx_encoder = {
.name = "adpcm_adx", .name = "adpcm_adx",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ADPCM_ADX, .id = AV_CODEC_ID_ADPCM_ADX,
.priv_data_size = sizeof(ADXContext), .priv_data_size = sizeof(ADXContext),
.init = adx_encode_init, .init = adx_encode_init,
.encode2 = adx_encode_frame, .encode2 = adx_encode_frame,

2
libavcodec/alac.c
View File

@ -652,7 +652,7 @@ static av_cold int alac_decode_init(AVCodecContext * avctx)
AVCodec ff_alac_decoder = { AVCodec ff_alac_decoder = {
.name = "alac", .name = "alac",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ALAC, .id = AV_CODEC_ID_ALAC,
.priv_data_size = sizeof(ALACContext), .priv_data_size = sizeof(ALACContext),
.init = alac_decode_init, .init = alac_decode_init,
.close = alac_decode_close, .close = alac_decode_close,

2
libavcodec/alacenc.c
View File

@ -574,7 +574,7 @@ static int alac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
AVCodec ff_alac_encoder = { AVCodec ff_alac_encoder = {
.name = "alac", .name = "alac",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ALAC, .id = AV_CODEC_ID_ALAC,
.priv_data_size = sizeof(AlacEncodeContext), .priv_data_size = sizeof(AlacEncodeContext),
.init = alac_encode_init, .init = alac_encode_init,
.encode2 = alac_encode_frame, .encode2 = alac_encode_frame,

2
libavcodec/alsdec.c
View File

@ -1754,7 +1754,7 @@ static av_cold void flush(AVCodecContext *avctx)
AVCodec ff_als_decoder = { AVCodec ff_als_decoder = {
.name = "als", .name = "als",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_MP4ALS, .id = AV_CODEC_ID_MP4ALS,
.priv_data_size = sizeof(ALSDecContext), .priv_data_size = sizeof(ALSDecContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,

2
libavcodec/amrnbdec.c
View File

@ -1075,7 +1075,7 @@ static int amrnb_decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_amrnb_decoder = { AVCodec ff_amrnb_decoder = {
.name = "amrnb", .name = "amrnb",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AMR_NB, .id = AV_CODEC_ID_AMR_NB,
.priv_data_size = sizeof(AMRContext), .priv_data_size = sizeof(AMRContext),
.init = amrnb_decode_init, .init = amrnb_decode_init,
.decode = amrnb_decode_frame, .decode = amrnb_decode_frame,

2
libavcodec/amrwbdec.c
View File

@ -1257,7 +1257,7 @@ static int amrwb_decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_amrwb_decoder = { AVCodec ff_amrwb_decoder = {
.name = "amrwb", .name = "amrwb",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AMR_WB, .id = AV_CODEC_ID_AMR_WB,
.priv_data_size = sizeof(AMRWBContext), .priv_data_size = sizeof(AMRWBContext),
.init = amrwb_decode_init, .init = amrwb_decode_init,
.decode = amrwb_decode_frame, .decode = amrwb_decode_frame,

2
libavcodec/anm.c
View File

@ -187,7 +187,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_anm_decoder = { AVCodec ff_anm_decoder = {
.name = "anm", .name = "anm",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ANM, .id = AV_CODEC_ID_ANM,
.priv_data_size = sizeof(AnmContext), .priv_data_size = sizeof(AnmContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,

2
libavcodec/ansi.c
View File

@ -428,7 +428,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
AVCodec ff_ansi_decoder = { AVCodec ff_ansi_decoder = {
.name = "ansi", .name = "ansi",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ANSI, .id = AV_CODEC_ID_ANSI,
.priv_data_size = sizeof(AnsiContext), .priv_data_size = sizeof(AnsiContext),
.init = decode_init, .init = decode_init,
.close = decode_close, .close = decode_close,

2
libavcodec/apedec.c
View File

@ -987,7 +987,7 @@ static const AVClass ape_decoder_class = {
AVCodec ff_ape_decoder = { AVCodec ff_ape_decoder = {
.name = "ape", .name = "ape",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_APE, .id = AV_CODEC_ID_APE,
.priv_data_size = sizeof(APEContext), .priv_data_size = sizeof(APEContext),
.init = ape_decode_init, .init = ape_decode_init,
.close = ape_decode_close, .close = ape_decode_close,

6
libavcodec/arm/h264pred_init_arm.c
View File

@ -53,10 +53,10 @@ static void ff_h264_pred_init_neon(H264PredContext *h, int codec_id, const int b
if(chroma_format_idc == 1){ if(chroma_format_idc == 1){
h->pred8x8[VERT_PRED8x8 ] = ff_pred8x8_vert_neon; h->pred8x8[VERT_PRED8x8 ] = ff_pred8x8_vert_neon;
h->pred8x8[HOR_PRED8x8 ] = ff_pred8x8_hor_neon; h->pred8x8[HOR_PRED8x8 ] = ff_pred8x8_hor_neon;
if (codec_id != CODEC_ID_VP8) if (codec_id != AV_CODEC_ID_VP8)
h->pred8x8[PLANE_PRED8x8] = ff_pred8x8_plane_neon; h->pred8x8[PLANE_PRED8x8] = ff_pred8x8_plane_neon;
h->pred8x8[DC_128_PRED8x8 ] = ff_pred8x8_128_dc_neon; h->pred8x8[DC_128_PRED8x8 ] = ff_pred8x8_128_dc_neon;
if (codec_id != CODEC_ID_RV40 && codec_id != CODEC_ID_VP8) { if (codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP8) {
h->pred8x8[DC_PRED8x8 ] = ff_pred8x8_dc_neon; h->pred8x8[DC_PRED8x8 ] = ff_pred8x8_dc_neon;
h->pred8x8[LEFT_DC_PRED8x8] = ff_pred8x8_left_dc_neon; h->pred8x8[LEFT_DC_PRED8x8] = ff_pred8x8_left_dc_neon;
h->pred8x8[TOP_DC_PRED8x8 ] = ff_pred8x8_top_dc_neon; h->pred8x8[TOP_DC_PRED8x8 ] = ff_pred8x8_top_dc_neon;
@ -73,7 +73,7 @@ static void ff_h264_pred_init_neon(H264PredContext *h, int codec_id, const int b
h->pred16x16[LEFT_DC_PRED8x8] = ff_pred16x16_left_dc_neon; h->pred16x16[LEFT_DC_PRED8x8] = ff_pred16x16_left_dc_neon;
h->pred16x16[TOP_DC_PRED8x8 ] = ff_pred16x16_top_dc_neon; h->pred16x16[TOP_DC_PRED8x8 ] = ff_pred16x16_top_dc_neon;
h->pred16x16[DC_128_PRED8x8 ] = ff_pred16x16_128_dc_neon; h->pred16x16[DC_128_PRED8x8 ] = ff_pred16x16_128_dc_neon;
if (codec_id != CODEC_ID_SVQ3 && codec_id != CODEC_ID_RV40 && codec_id != CODEC_ID_VP8) if (codec_id != AV_CODEC_ID_SVQ3 && codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP8)
h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_plane_neon; h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_plane_neon;
#endif // HAVE_NEON #endif // HAVE_NEON
} }

4
libavcodec/arm/vp56dsp_init_arm.c
View File

@ -27,11 +27,11 @@
void ff_vp6_edge_filter_hor_neon(uint8_t *yuv, int stride, int t); void ff_vp6_edge_filter_hor_neon(uint8_t *yuv, int stride, int t);
void ff_vp6_edge_filter_ver_neon(uint8_t *yuv, int stride, int t); void ff_vp6_edge_filter_ver_neon(uint8_t *yuv, int stride, int t);
void ff_vp56dsp_init_arm(VP56DSPContext *s, enum CodecID codec) void ff_vp56dsp_init_arm(VP56DSPContext *s, enum AVCodecID codec)
{ {
int cpu_flags = av_get_cpu_flags(); int cpu_flags = av_get_cpu_flags();
if (codec != CODEC_ID_VP5 && have_neon(cpu_flags)) { if (codec != AV_CODEC_ID_VP5 && have_neon(cpu_flags)) {
s->edge_filter_hor = ff_vp6_edge_filter_hor_neon; s->edge_filter_hor = ff_vp6_edge_filter_hor_neon;
s->edge_filter_ver = ff_vp6_edge_filter_ver_neon; s->edge_filter_ver = ff_vp6_edge_filter_ver_neon;
} }

2
libavcodec/assdec.c
View File

@ -70,7 +70,7 @@ AVCodec ff_ass_decoder = {
.name = "ass", .name = "ass",
.long_name = NULL_IF_CONFIG_SMALL("SSA (SubStation Alpha) subtitle"), .long_name = NULL_IF_CONFIG_SMALL("SSA (SubStation Alpha) subtitle"),
.type = AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
.id = CODEC_ID_SSA, .id = AV_CODEC_ID_SSA,
.init = ass_decode_init, .init = ass_decode_init,
.decode = ass_decode_frame, .decode = ass_decode_frame,
.close = ass_decode_close, .close = ass_decode_close,

2
libavcodec/assenc.c
View File

@ -61,7 +61,7 @@ AVCodec ff_ass_encoder = {
.name = "ass", .name = "ass",
.long_name = NULL_IF_CONFIG_SMALL("SSA (SubStation Alpha) subtitle"), .long_name = NULL_IF_CONFIG_SMALL("SSA (SubStation Alpha) subtitle"),
.type = AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
.id = CODEC_ID_SSA, .id = AV_CODEC_ID_SSA,
.init = ass_encode_init, .init = ass_encode_init,
.encode = ass_encode_frame, .encode = ass_encode_frame,
}; };

22
libavcodec/asv1.c
View File

@ -309,7 +309,7 @@ static inline int decode_mb(ASV1Context *a, DCTELEM block[6][64]){
a->dsp.clear_blocks(block[0]); a->dsp.clear_blocks(block[0]);
if(a->avctx->codec_id == CODEC_ID_ASV1){ if(a->avctx->codec_id == AV_CODEC_ID_ASV1){
for(i=0; i<6; i++){ for(i=0; i<6; i++){
if( asv1_decode_block(a, block[i]) < 0) if( asv1_decode_block(a, block[i]) < 0)
return -1; return -1;
@ -333,7 +333,7 @@ static inline int encode_mb(ASV1Context *a, DCTELEM block[6][64]){
return -1; return -1;
} }
if(a->avctx->codec_id == CODEC_ID_ASV1){ if(a->avctx->codec_id == AV_CODEC_ID_ASV1){
for(i=0; i<6; i++) for(i=0; i<6; i++)
asv1_encode_block(a, block[i]); asv1_encode_block(a, block[i]);
}else{ }else{
@ -413,7 +413,7 @@ static int decode_frame(AVCodecContext *avctx,
if (!a->bitstream_buffer) if (!a->bitstream_buffer)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if(avctx->codec_id == CODEC_ID_ASV1) if(avctx->codec_id == AV_CODEC_ID_ASV1)
a->dsp.bswap_buf((uint32_t*)a->bitstream_buffer, (const uint32_t*)buf, buf_size/4); a->dsp.bswap_buf((uint32_t*)a->bitstream_buffer, (const uint32_t*)buf, buf_size/4);
else{ else{
int i; int i;
@ -509,7 +509,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
size= put_bits_count(&a->pb)/32; size= put_bits_count(&a->pb)/32;
if(avctx->codec_id == CODEC_ID_ASV1) if(avctx->codec_id == AV_CODEC_ID_ASV1)
a->dsp.bswap_buf((uint32_t*)pkt->data, (uint32_t*)pkt->data, size); a->dsp.bswap_buf((uint32_t*)pkt->data, (uint32_t*)pkt->data, size);
else{ else{
int i; int i;
@ -543,7 +543,7 @@ static av_cold int decode_init(AVCodecContext *avctx){
ASV1Context * const a = avctx->priv_data; ASV1Context * const a = avctx->priv_data;
AVFrame *p= &a->picture; AVFrame *p= &a->picture;
int i; int i;
const int scale= avctx->codec_id == CODEC_ID_ASV1 ? 1 : 2; const int scale= avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
common_init(avctx); common_init(avctx);
init_vlcs(a); init_vlcs(a);
@ -552,7 +552,7 @@ static av_cold int decode_init(AVCodecContext *avctx){
if(avctx->extradata_size < 1 || (a->inv_qscale= avctx->extradata[0]) == 0){ if(avctx->extradata_size < 1 || (a->inv_qscale= avctx->extradata[0]) == 0){
av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n"); av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
if(avctx->codec_id == CODEC_ID_ASV1) if(avctx->codec_id == AV_CODEC_ID_ASV1)
a->inv_qscale= 6; a->inv_qscale= 6;
else else
a->inv_qscale= 10; a->inv_qscale= 10;
@ -576,7 +576,7 @@ static av_cold int decode_init(AVCodecContext *avctx){
static av_cold int encode_init(AVCodecContext *avctx){ static av_cold int encode_init(AVCodecContext *avctx){
ASV1Context * const a = avctx->priv_data; ASV1Context * const a = avctx->priv_data;
int i; int i;
const int scale= avctx->codec_id == CODEC_ID_ASV1 ? 1 : 2; const int scale= avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
common_init(avctx); common_init(avctx);
@ -615,7 +615,7 @@ static av_cold int decode_end(AVCodecContext *avctx){
AVCodec ff_asv1_decoder = { AVCodec ff_asv1_decoder = {
.name = "asv1", .name = "asv1",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ASV1, .id = AV_CODEC_ID_ASV1,
.priv_data_size = sizeof(ASV1Context), .priv_data_size = sizeof(ASV1Context),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,
@ -629,7 +629,7 @@ AVCodec ff_asv1_decoder = {
AVCodec ff_asv2_decoder = { AVCodec ff_asv2_decoder = {
.name = "asv2", .name = "asv2",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ASV2, .id = AV_CODEC_ID_ASV2,
.priv_data_size = sizeof(ASV1Context), .priv_data_size = sizeof(ASV1Context),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,
@ -643,7 +643,7 @@ AVCodec ff_asv2_decoder = {
AVCodec ff_asv1_encoder = { AVCodec ff_asv1_encoder = {
.name = "asv1", .name = "asv1",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ASV1, .id = AV_CODEC_ID_ASV1,
.priv_data_size = sizeof(ASV1Context), .priv_data_size = sizeof(ASV1Context),
.init = encode_init, .init = encode_init,
.encode2 = encode_frame, .encode2 = encode_frame,
@ -656,7 +656,7 @@ AVCodec ff_asv1_encoder = {
AVCodec ff_asv2_encoder = { AVCodec ff_asv2_encoder = {
.name = "asv2", .name = "asv2",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ASV2, .id = AV_CODEC_ID_ASV2,
.priv_data_size = sizeof(ASV1Context), .priv_data_size = sizeof(ASV1Context),
.init = encode_init, .init = encode_init,
.encode2 = encode_frame, .encode2 = encode_frame,

2
libavcodec/atrac1.c
View File

@ -403,7 +403,7 @@ static av_cold int atrac1_decode_init(AVCodecContext *avctx)
AVCodec ff_atrac1_decoder = { AVCodec ff_atrac1_decoder = {
.name = "atrac1", .name = "atrac1",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ATRAC1, .id = AV_CODEC_ID_ATRAC1,
.priv_data_size = sizeof(AT1Ctx), .priv_data_size = sizeof(AT1Ctx),
.init = atrac1_decode_init, .init = atrac1_decode_init,
.close = atrac1_decode_end, .close = atrac1_decode_end,

2
libavcodec/atrac3.c
View File

@ -1068,7 +1068,7 @@ AVCodec ff_atrac3_decoder =
{ {
.name = "atrac3", .name = "atrac3",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ATRAC3, .id = AV_CODEC_ID_ATRAC3,
.priv_data_size = sizeof(ATRAC3Context), .priv_data_size = sizeof(ATRAC3Context),
.init = atrac3_decode_init, .init = atrac3_decode_init,
.close = atrac3_decode_close, .close = atrac3_decode_close,

2
libavcodec/aura.c
View File

@ -126,7 +126,7 @@ static av_cold int aura_decode_end(AVCodecContext *avctx)
AVCodec ff_aura2_decoder = { AVCodec ff_aura2_decoder = {
.name = "aura2", .name = "aura2",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_AURA2, .id = AV_CODEC_ID_AURA2,
.priv_data_size = sizeof(AuraDecodeContext), .priv_data_size = sizeof(AuraDecodeContext),
.init = aura_decode_init, .init = aura_decode_init,
.close = aura_decode_end, .close = aura_decode_end,

720
libavcodec/avcodec.h
View File

@ -77,6 +77,10 @@
* @{ * @{
*/ */
#if FF_API_CODEC_ID
#include "old_codec_ids.h"
#endif
/** /**
* Identify the syntax and semantics of the bitstream. * Identify the syntax and semantics of the bitstream.
* The principle is roughly: * The principle is roughly:
@ -90,371 +94,371 @@
* 2. Give it a value which when taken as ASCII is recognized uniquely by a human as this specific codec. * 2. Give it a value which when taken as ASCII is recognized uniquely by a human as this specific codec.
* This ensures that 2 forks can independently add CodecIDs without producing conflicts. * This ensures that 2 forks can independently add CodecIDs without producing conflicts.
*/ */
enum CodecID { enum AVCodecID {
CODEC_ID_NONE, AV_CODEC_ID_NONE,
/* video codecs */ /* video codecs */
CODEC_ID_MPEG1VIDEO, AV_CODEC_ID_MPEG1VIDEO,
CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
CODEC_ID_MPEG2VIDEO_XVMC, AV_CODEC_ID_MPEG2VIDEO_XVMC,
CODEC_ID_H261, AV_CODEC_ID_H261,
CODEC_ID_H263, AV_CODEC_ID_H263,
CODEC_ID_RV10, AV_CODEC_ID_RV10,
CODEC_ID_RV20, AV_CODEC_ID_RV20,
CODEC_ID_MJPEG, AV_CODEC_ID_MJPEG,
CODEC_ID_MJPEGB, AV_CODEC_ID_MJPEGB,
CODEC_ID_LJPEG, AV_CODEC_ID_LJPEG,
CODEC_ID_SP5X, AV_CODEC_ID_SP5X,
CODEC_ID_JPEGLS, AV_CODEC_ID_JPEGLS,
CODEC_ID_MPEG4, AV_CODEC_ID_MPEG4,
CODEC_ID_RAWVIDEO, AV_CODEC_ID_RAWVIDEO,
CODEC_ID_MSMPEG4V1, AV_CODEC_ID_MSMPEG4V1,
CODEC_ID_MSMPEG4V2, AV_CODEC_ID_MSMPEG4V2,
CODEC_ID_MSMPEG4V3, AV_CODEC_ID_MSMPEG4V3,
CODEC_ID_WMV1, AV_CODEC_ID_WMV1,
CODEC_ID_WMV2, AV_CODEC_ID_WMV2,
CODEC_ID_H263P, AV_CODEC_ID_H263P,
CODEC_ID_H263I, AV_CODEC_ID_H263I,
CODEC_ID_FLV1, AV_CODEC_ID_FLV1,
CODEC_ID_SVQ1, AV_CODEC_ID_SVQ1,
CODEC_ID_SVQ3, AV_CODEC_ID_SVQ3,
CODEC_ID_DVVIDEO, AV_CODEC_ID_DVVIDEO,
CODEC_ID_HUFFYUV, AV_CODEC_ID_HUFFYUV,
CODEC_ID_CYUV, AV_CODEC_ID_CYUV,
CODEC_ID_H264, AV_CODEC_ID_H264,
CODEC_ID_INDEO3, AV_CODEC_ID_INDEO3,
CODEC_ID_VP3, AV_CODEC_ID_VP3,
CODEC_ID_THEORA, AV_CODEC_ID_THEORA,
CODEC_ID_ASV1, AV_CODEC_ID_ASV1,
CODEC_ID_ASV2, AV_CODEC_ID_ASV2,
CODEC_ID_FFV1, AV_CODEC_ID_FFV1,
CODEC_ID_4XM, AV_CODEC_ID_4XM,
CODEC_ID_VCR1, AV_CODEC_ID_VCR1,
CODEC_ID_CLJR, AV_CODEC_ID_CLJR,
CODEC_ID_MDEC, AV_CODEC_ID_MDEC,
CODEC_ID_ROQ, AV_CODEC_ID_ROQ,
CODEC_ID_INTERPLAY_VIDEO, AV_CODEC_ID_INTERPLAY_VIDEO,
CODEC_ID_XAN_WC3, AV_CODEC_ID_XAN_WC3,
CODEC_ID_XAN_WC4, AV_CODEC_ID_XAN_WC4,
CODEC_ID_RPZA, AV_CODEC_ID_RPZA,
CODEC_ID_CINEPAK, AV_CODEC_ID_CINEPAK,
CODEC_ID_WS_VQA, AV_CODEC_ID_WS_VQA,
CODEC_ID_MSRLE, AV_CODEC_ID_MSRLE,
CODEC_ID_MSVIDEO1, AV_CODEC_ID_MSVIDEO1,
CODEC_ID_IDCIN, AV_CODEC_ID_IDCIN,
CODEC_ID_8BPS, AV_CODEC_ID_8BPS,
CODEC_ID_SMC, AV_CODEC_ID_SMC,
CODEC_ID_FLIC, AV_CODEC_ID_FLIC,
CODEC_ID_TRUEMOTION1, AV_CODEC_ID_TRUEMOTION1,
CODEC_ID_VMDVIDEO, AV_CODEC_ID_VMDVIDEO,
CODEC_ID_MSZH, AV_CODEC_ID_MSZH,
CODEC_ID_ZLIB, AV_CODEC_ID_ZLIB,
CODEC_ID_QTRLE, AV_CODEC_ID_QTRLE,
CODEC_ID_SNOW, AV_CODEC_ID_SNOW,
CODEC_ID_TSCC, AV_CODEC_ID_TSCC,
CODEC_ID_ULTI, AV_CODEC_ID_ULTI,
CODEC_ID_QDRAW, AV_CODEC_ID_QDRAW,
CODEC_ID_VIXL, AV_CODEC_ID_VIXL,
CODEC_ID_QPEG, AV_CODEC_ID_QPEG,
CODEC_ID_PNG, AV_CODEC_ID_PNG,
CODEC_ID_PPM, AV_CODEC_ID_PPM,
CODEC_ID_PBM, AV_CODEC_ID_PBM,
CODEC_ID_PGM, AV_CODEC_ID_PGM,
CODEC_ID_PGMYUV, AV_CODEC_ID_PGMYUV,
CODEC_ID_PAM, AV_CODEC_ID_PAM,
CODEC_ID_FFVHUFF, AV_CODEC_ID_FFVHUFF,
CODEC_ID_RV30, AV_CODEC_ID_RV30,
CODEC_ID_RV40, AV_CODEC_ID_RV40,
CODEC_ID_VC1, AV_CODEC_ID_VC1,
CODEC_ID_WMV3, AV_CODEC_ID_WMV3,
CODEC_ID_LOCO, AV_CODEC_ID_LOCO,
CODEC_ID_WNV1, AV_CODEC_ID_WNV1,
CODEC_ID_AASC, AV_CODEC_ID_AASC,
CODEC_ID_INDEO2, AV_CODEC_ID_INDEO2,
CODEC_ID_FRAPS, AV_CODEC_ID_FRAPS,
CODEC_ID_TRUEMOTION2, AV_CODEC_ID_TRUEMOTION2,
CODEC_ID_BMP, AV_CODEC_ID_BMP,
CODEC_ID_CSCD, AV_CODEC_ID_CSCD,
CODEC_ID_MMVIDEO, AV_CODEC_ID_MMVIDEO,
CODEC_ID_ZMBV, AV_CODEC_ID_ZMBV,
CODEC_ID_AVS, AV_CODEC_ID_AVS,
CODEC_ID_SMACKVIDEO, AV_CODEC_ID_SMACKVIDEO,
CODEC_ID_NUV, AV_CODEC_ID_NUV,
CODEC_ID_KMVC, AV_CODEC_ID_KMVC,
CODEC_ID_FLASHSV, AV_CODEC_ID_FLASHSV,
CODEC_ID_CAVS, AV_CODEC_ID_CAVS,
CODEC_ID_JPEG2000, AV_CODEC_ID_JPEG2000,
CODEC_ID_VMNC, AV_CODEC_ID_VMNC,
CODEC_ID_VP5, AV_CODEC_ID_VP5,
CODEC_ID_VP6, AV_CODEC_ID_VP6,
CODEC_ID_VP6F, AV_CODEC_ID_VP6F,
CODEC_ID_TARGA, AV_CODEC_ID_TARGA,
CODEC_ID_DSICINVIDEO, AV_CODEC_ID_DSICINVIDEO,
CODEC_ID_TIERTEXSEQVIDEO, AV_CODEC_ID_TIERTEXSEQVIDEO,
CODEC_ID_TIFF, AV_CODEC_ID_TIFF,
CODEC_ID_GIF, AV_CODEC_ID_GIF,
CODEC_ID_DXA, AV_CODEC_ID_DXA,
CODEC_ID_DNXHD, AV_CODEC_ID_DNXHD,
CODEC_ID_THP, AV_CODEC_ID_THP,
CODEC_ID_SGI, AV_CODEC_ID_SGI,
CODEC_ID_C93, AV_CODEC_ID_C93,
CODEC_ID_BETHSOFTVID, AV_CODEC_ID_BETHSOFTVID,
CODEC_ID_PTX, AV_CODEC_ID_PTX,
CODEC_ID_TXD, AV_CODEC_ID_TXD,
CODEC_ID_VP6A, AV_CODEC_ID_VP6A,
CODEC_ID_AMV, AV_CODEC_ID_AMV,
CODEC_ID_VB, AV_CODEC_ID_VB,
CODEC_ID_PCX, AV_CODEC_ID_PCX,
CODEC_ID_SUNRAST, AV_CODEC_ID_SUNRAST,
CODEC_ID_INDEO4, AV_CODEC_ID_INDEO4,
CODEC_ID_INDEO5, AV_CODEC_ID_INDEO5,
CODEC_ID_MIMIC, AV_CODEC_ID_MIMIC,
CODEC_ID_RL2, AV_CODEC_ID_RL2,
CODEC_ID_ESCAPE124, AV_CODEC_ID_ESCAPE124,
CODEC_ID_DIRAC, AV_CODEC_ID_DIRAC,
CODEC_ID_BFI, AV_CODEC_ID_BFI,
CODEC_ID_CMV, AV_CODEC_ID_CMV,
CODEC_ID_MOTIONPIXELS, AV_CODEC_ID_MOTIONPIXELS,
CODEC_ID_TGV, AV_CODEC_ID_TGV,
CODEC_ID_TGQ, AV_CODEC_ID_TGQ,
CODEC_ID_TQI, AV_CODEC_ID_TQI,
CODEC_ID_AURA, AV_CODEC_ID_AURA,
CODEC_ID_AURA2, AV_CODEC_ID_AURA2,
CODEC_ID_V210X, AV_CODEC_ID_V210X,
CODEC_ID_TMV, AV_CODEC_ID_TMV,
CODEC_ID_V210, AV_CODEC_ID_V210,
CODEC_ID_DPX, AV_CODEC_ID_DPX,
CODEC_ID_MAD, AV_CODEC_ID_MAD,
CODEC_ID_FRWU, AV_CODEC_ID_FRWU,
CODEC_ID_FLASHSV2, AV_CODEC_ID_FLASHSV2,
CODEC_ID_CDGRAPHICS, AV_CODEC_ID_CDGRAPHICS,
CODEC_ID_R210, AV_CODEC_ID_R210,
CODEC_ID_ANM, AV_CODEC_ID_ANM,
CODEC_ID_BINKVIDEO, AV_CODEC_ID_BINKVIDEO,
CODEC_ID_IFF_ILBM, AV_CODEC_ID_IFF_ILBM,
CODEC_ID_IFF_BYTERUN1, AV_CODEC_ID_IFF_BYTERUN1,
CODEC_ID_KGV1, AV_CODEC_ID_KGV1,
CODEC_ID_YOP, AV_CODEC_ID_YOP,
CODEC_ID_VP8, AV_CODEC_ID_VP8,
CODEC_ID_PICTOR, AV_CODEC_ID_PICTOR,
CODEC_ID_ANSI, AV_CODEC_ID_ANSI,
CODEC_ID_A64_MULTI, AV_CODEC_ID_A64_MULTI,
CODEC_ID_A64_MULTI5, AV_CODEC_ID_A64_MULTI5,
CODEC_ID_R10K, AV_CODEC_ID_R10K,
CODEC_ID_MXPEG, AV_CODEC_ID_MXPEG,
CODEC_ID_LAGARITH, AV_CODEC_ID_LAGARITH,
CODEC_ID_PRORES, AV_CODEC_ID_PRORES,
CODEC_ID_JV, AV_CODEC_ID_JV,
CODEC_ID_DFA, AV_CODEC_ID_DFA,
CODEC_ID_WMV3IMAGE, AV_CODEC_ID_WMV3IMAGE,
CODEC_ID_VC1IMAGE, AV_CODEC_ID_VC1IMAGE,
CODEC_ID_UTVIDEO, AV_CODEC_ID_UTVIDEO,
CODEC_ID_BMV_VIDEO, AV_CODEC_ID_BMV_VIDEO,
CODEC_ID_VBLE, AV_CODEC_ID_VBLE,
CODEC_ID_DXTORY, AV_CODEC_ID_DXTORY,
CODEC_ID_V410, AV_CODEC_ID_V410,
CODEC_ID_XWD, AV_CODEC_ID_XWD,
CODEC_ID_CDXL, AV_CODEC_ID_CDXL,
CODEC_ID_XBM, AV_CODEC_ID_XBM,
CODEC_ID_ZEROCODEC, AV_CODEC_ID_ZEROCODEC,
CODEC_ID_MSS1, AV_CODEC_ID_MSS1,
CODEC_ID_MSA1, AV_CODEC_ID_MSA1,
CODEC_ID_TSCC2, AV_CODEC_ID_TSCC2,
CODEC_ID_MTS2, AV_CODEC_ID_MTS2,
CODEC_ID_CLLC, AV_CODEC_ID_CLLC,
CODEC_ID_Y41P = MKBETAG('Y','4','1','P'), AV_CODEC_ID_Y41P = MKBETAG('Y','4','1','P'),
CODEC_ID_ESCAPE130 = MKBETAG('E','1','3','0'), AV_CODEC_ID_ESCAPE130 = MKBETAG('E','1','3','0'),
CODEC_ID_EXR = MKBETAG('0','E','X','R'), AV_CODEC_ID_EXR = MKBETAG('0','E','X','R'),
CODEC_ID_AVRP = MKBETAG('A','V','R','P'), AV_CODEC_ID_AVRP = MKBETAG('A','V','R','P'),
CODEC_ID_G2M = MKBETAG( 0 ,'G','2','M'), AV_CODEC_ID_G2M = MKBETAG( 0 ,'G','2','M'),
CODEC_ID_AVUI = MKBETAG('A','V','U','I'), AV_CODEC_ID_AVUI = MKBETAG('A','V','U','I'),
CODEC_ID_AYUV = MKBETAG('A','Y','U','V'), AV_CODEC_ID_AYUV = MKBETAG('A','Y','U','V'),
CODEC_ID_V308 = MKBETAG('V','3','0','8'), AV_CODEC_ID_V308 = MKBETAG('V','3','0','8'),
CODEC_ID_V408 = MKBETAG('V','4','0','8'), AV_CODEC_ID_V408 = MKBETAG('V','4','0','8'),
CODEC_ID_YUV4 = MKBETAG('Y','U','V','4'), AV_CODEC_ID_YUV4 = MKBETAG('Y','U','V','4'),
CODEC_ID_SANM = MKBETAG('S','A','N','M'), AV_CODEC_ID_SANM = MKBETAG('S','A','N','M'),
CODEC_ID_PAF_VIDEO = MKBETAG('P','A','F','V'), AV_CODEC_ID_PAF_VIDEO = MKBETAG('P','A','F','V'),
/* various PCM "codecs" */ /* various PCM "codecs" */
CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs
CODEC_ID_PCM_S16LE = 0x10000, AV_CODEC_ID_PCM_S16LE = 0x10000,
CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16BE,
CODEC_ID_PCM_U16LE, AV_CODEC_ID_PCM_U16LE,
CODEC_ID_PCM_U16BE, AV_CODEC_ID_PCM_U16BE,
CODEC_ID_PCM_S8, AV_CODEC_ID_PCM_S8,
CODEC_ID_PCM_U8, AV_CODEC_ID_PCM_U8,
CODEC_ID_PCM_MULAW, AV_CODEC_ID_PCM_MULAW,
CODEC_ID_PCM_ALAW, AV_CODEC_ID_PCM_ALAW,
CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32LE,
CODEC_ID_PCM_S32BE, AV_CODEC_ID_PCM_S32BE,
CODEC_ID_PCM_U32LE, AV_CODEC_ID_PCM_U32LE,
CODEC_ID_PCM_U32BE, AV_CODEC_ID_PCM_U32BE,
CODEC_ID_PCM_S24LE, AV_CODEC_ID_PCM_S24LE,
CODEC_ID_PCM_S24BE, AV_CODEC_ID_PCM_S24BE,
CODEC_ID_PCM_U24LE, AV_CODEC_ID_PCM_U24LE,
CODEC_ID_PCM_U24BE, AV_CODEC_ID_PCM_U24BE,
CODEC_ID_PCM_S24DAUD, AV_CODEC_ID_PCM_S24DAUD,
CODEC_ID_PCM_ZORK, AV_CODEC_ID_PCM_ZORK,
CODEC_ID_PCM_S16LE_PLANAR, AV_CODEC_ID_PCM_S16LE_PLANAR,
CODEC_ID_PCM_DVD, AV_CODEC_ID_PCM_DVD,
CODEC_ID_PCM_F32BE, AV_CODEC_ID_PCM_F32BE,
CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32LE,
CODEC_ID_PCM_F64BE, AV_CODEC_ID_PCM_F64BE,
CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64LE,
CODEC_ID_PCM_BLURAY, AV_CODEC_ID_PCM_BLURAY,
CODEC_ID_PCM_LXF, AV_CODEC_ID_PCM_LXF,
CODEC_ID_S302M, AV_CODEC_ID_S302M,
CODEC_ID_PCM_S8_PLANAR, AV_CODEC_ID_PCM_S8_PLANAR,
/* various ADPCM codecs */ /* various ADPCM codecs */
CODEC_ID_ADPCM_IMA_QT = 0x11000, AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
CODEC_ID_ADPCM_IMA_WAV, AV_CODEC_ID_ADPCM_IMA_WAV,
CODEC_ID_ADPCM_IMA_DK3, AV_CODEC_ID_ADPCM_IMA_DK3,
CODEC_ID_ADPCM_IMA_DK4, AV_CODEC_ID_ADPCM_IMA_DK4,
CODEC_ID_ADPCM_IMA_WS, AV_CODEC_ID_ADPCM_IMA_WS,
CODEC_ID_ADPCM_IMA_SMJPEG, AV_CODEC_ID_ADPCM_IMA_SMJPEG,
CODEC_ID_ADPCM_MS, AV_CODEC_ID_ADPCM_MS,
CODEC_ID_ADPCM_4XM, AV_CODEC_ID_ADPCM_4XM,
CODEC_ID_ADPCM_XA, AV_CODEC_ID_ADPCM_XA,
CODEC_ID_ADPCM_ADX, AV_CODEC_ID_ADPCM_ADX,
CODEC_ID_ADPCM_EA, AV_CODEC_ID_ADPCM_EA,
CODEC_ID_ADPCM_G726, AV_CODEC_ID_ADPCM_G726,
CODEC_ID_ADPCM_CT, AV_CODEC_ID_ADPCM_CT,
CODEC_ID_ADPCM_SWF, AV_CODEC_ID_ADPCM_SWF,
CODEC_ID_ADPCM_YAMAHA, AV_CODEC_ID_ADPCM_YAMAHA,
CODEC_ID_ADPCM_SBPRO_4, AV_CODEC_ID_ADPCM_SBPRO_4,
CODEC_ID_ADPCM_SBPRO_3, AV_CODEC_ID_ADPCM_SBPRO_3,
CODEC_ID_ADPCM_SBPRO_2, AV_CODEC_ID_ADPCM_SBPRO_2,
CODEC_ID_ADPCM_THP, AV_CODEC_ID_ADPCM_THP,
CODEC_ID_ADPCM_IMA_AMV, AV_CODEC_ID_ADPCM_IMA_AMV,
CODEC_ID_ADPCM_EA_R1, AV_CODEC_ID_ADPCM_EA_R1,
CODEC_ID_ADPCM_EA_R3, AV_CODEC_ID_ADPCM_EA_R3,
CODEC_ID_ADPCM_EA_R2, AV_CODEC_ID_ADPCM_EA_R2,
CODEC_ID_ADPCM_IMA_EA_SEAD, AV_CODEC_ID_ADPCM_IMA_EA_SEAD,
CODEC_ID_ADPCM_IMA_EA_EACS, AV_CODEC_ID_ADPCM_IMA_EA_EACS,
CODEC_ID_ADPCM_EA_XAS, AV_CODEC_ID_ADPCM_EA_XAS,
CODEC_ID_ADPCM_EA_MAXIS_XA, AV_CODEC_ID_ADPCM_EA_MAXIS_XA,
CODEC_ID_ADPCM_IMA_ISS, AV_CODEC_ID_ADPCM_IMA_ISS,
CODEC_ID_ADPCM_G722, AV_CODEC_ID_ADPCM_G722,
CODEC_ID_ADPCM_IMA_APC, AV_CODEC_ID_ADPCM_IMA_APC,
CODEC_ID_VIMA = MKBETAG('V','I','M','A'), AV_CODEC_ID_VIMA = MKBETAG('V','I','M','A'),
/* AMR */ /* AMR */
CODEC_ID_AMR_NB = 0x12000, AV_CODEC_ID_AMR_NB = 0x12000,
CODEC_ID_AMR_WB, AV_CODEC_ID_AMR_WB,
/* RealAudio codecs*/ /* RealAudio codecs*/
CODEC_ID_RA_144 = 0x13000, AV_CODEC_ID_RA_144 = 0x13000,
CODEC_ID_RA_288, AV_CODEC_ID_RA_288,
/* various DPCM codecs */ /* various DPCM codecs */
CODEC_ID_ROQ_DPCM = 0x14000, AV_CODEC_ID_ROQ_DPCM = 0x14000,
CODEC_ID_INTERPLAY_DPCM, AV_CODEC_ID_INTERPLAY_DPCM,
CODEC_ID_XAN_DPCM, AV_CODEC_ID_XAN_DPCM,
CODEC_ID_SOL_DPCM, AV_CODEC_ID_SOL_DPCM,
/* audio codecs */ /* audio codecs */
CODEC_ID_MP2 = 0x15000, AV_CODEC_ID_MP2 = 0x15000,
CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3 AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
CODEC_ID_AAC, AV_CODEC_ID_AAC,
CODEC_ID_AC3, AV_CODEC_ID_AC3,
CODEC_ID_DTS, AV_CODEC_ID_DTS,
CODEC_ID_VORBIS, AV_CODEC_ID_VORBIS,
CODEC_ID_DVAUDIO, AV_CODEC_ID_DVAUDIO,
CODEC_ID_WMAV1, AV_CODEC_ID_WMAV1,
CODEC_ID_WMAV2, AV_CODEC_ID_WMAV2,
CODEC_ID_MACE3, AV_CODEC_ID_MACE3,
CODEC_ID_MACE6, AV_CODEC_ID_MACE6,
CODEC_ID_VMDAUDIO, AV_CODEC_ID_VMDAUDIO,
CODEC_ID_FLAC, AV_CODEC_ID_FLAC,
CODEC_ID_MP3ADU, AV_CODEC_ID_MP3ADU,
CODEC_ID_MP3ON4, AV_CODEC_ID_MP3ON4,
CODEC_ID_SHORTEN, AV_CODEC_ID_SHORTEN,
CODEC_ID_ALAC, AV_CODEC_ID_ALAC,
CODEC_ID_WESTWOOD_SND1, AV_CODEC_ID_WESTWOOD_SND1,
CODEC_ID_GSM, ///< as in Berlin toast format AV_CODEC_ID_GSM, ///< as in Berlin toast format
CODEC_ID_QDM2, AV_CODEC_ID_QDM2,
CODEC_ID_COOK, AV_CODEC_ID_COOK,
CODEC_ID_TRUESPEECH, AV_CODEC_ID_TRUESPEECH,
CODEC_ID_TTA, AV_CODEC_ID_TTA,
CODEC_ID_SMACKAUDIO, AV_CODEC_ID_SMACKAUDIO,
CODEC_ID_QCELP, AV_CODEC_ID_QCELP,
CODEC_ID_WAVPACK, AV_CODEC_ID_WAVPACK,
CODEC_ID_DSICINAUDIO, AV_CODEC_ID_DSICINAUDIO,
CODEC_ID_IMC, AV_CODEC_ID_IMC,
CODEC_ID_MUSEPACK7, AV_CODEC_ID_MUSEPACK7,
CODEC_ID_MLP, AV_CODEC_ID_MLP,
CODEC_ID_GSM_MS, /* as found in WAV */ AV_CODEC_ID_GSM_MS, /* as found in WAV */
CODEC_ID_ATRAC3, AV_CODEC_ID_ATRAC3,
CODEC_ID_VOXWARE, AV_CODEC_ID_VOXWARE,
CODEC_ID_APE, AV_CODEC_ID_APE,
CODEC_ID_NELLYMOSER, AV_CODEC_ID_NELLYMOSER,
CODEC_ID_MUSEPACK8, AV_CODEC_ID_MUSEPACK8,
CODEC_ID_SPEEX, AV_CODEC_ID_SPEEX,
CODEC_ID_WMAVOICE, AV_CODEC_ID_WMAVOICE,
CODEC_ID_WMAPRO, AV_CODEC_ID_WMAPRO,
CODEC_ID_WMALOSSLESS, AV_CODEC_ID_WMALOSSLESS,
CODEC_ID_ATRAC3P, AV_CODEC_ID_ATRAC3P,
CODEC_ID_EAC3, AV_CODEC_ID_EAC3,
CODEC_ID_SIPR, AV_CODEC_ID_SIPR,
CODEC_ID_MP1, AV_CODEC_ID_MP1,
CODEC_ID_TWINVQ, AV_CODEC_ID_TWINVQ,
CODEC_ID_TRUEHD, AV_CODEC_ID_TRUEHD,
CODEC_ID_MP4ALS, AV_CODEC_ID_MP4ALS,
CODEC_ID_ATRAC1, AV_CODEC_ID_ATRAC1,
CODEC_ID_BINKAUDIO_RDFT, AV_CODEC_ID_BINKAUDIO_RDFT,
CODEC_ID_BINKAUDIO_DCT, AV_CODEC_ID_BINKAUDIO_DCT,
CODEC_ID_AAC_LATM, AV_CODEC_ID_AAC_LATM,
CODEC_ID_QDMC, AV_CODEC_ID_QDMC,
CODEC_ID_CELT, AV_CODEC_ID_CELT,
CODEC_ID_G723_1, AV_CODEC_ID_G723_1,
CODEC_ID_G729, AV_CODEC_ID_G729,
CODEC_ID_8SVX_EXP, AV_CODEC_ID_8SVX_EXP,
CODEC_ID_8SVX_FIB, AV_CODEC_ID_8SVX_FIB,
CODEC_ID_BMV_AUDIO, AV_CODEC_ID_BMV_AUDIO,
CODEC_ID_RALF, AV_CODEC_ID_RALF,
CODEC_ID_IAC, AV_CODEC_ID_IAC,
CODEC_ID_ILBC, AV_CODEC_ID_ILBC,
CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'), AV_CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'),
CODEC_ID_8SVX_RAW = MKBETAG('8','S','V','X'), AV_CODEC_ID_8SVX_RAW = MKBETAG('8','S','V','X'),
CODEC_ID_SONIC = MKBETAG('S','O','N','C'), AV_CODEC_ID_SONIC = MKBETAG('S','O','N','C'),
CODEC_ID_SONIC_LS = MKBETAG('S','O','N','L'), AV_CODEC_ID_SONIC_LS = MKBETAG('S','O','N','L'),
CODEC_ID_PAF_AUDIO = MKBETAG('P','A','F','A'), AV_CODEC_ID_PAF_AUDIO = MKBETAG('P','A','F','A'),
CODEC_ID_OPUS = MKBETAG('O','P','U','S'), AV_CODEC_ID_OPUS = MKBETAG('O','P','U','S'),
/* subtitle codecs */ /* subtitle codecs */
CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs. AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs.
CODEC_ID_DVD_SUBTITLE = 0x17000, AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
CODEC_ID_DVB_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE,
CODEC_ID_TEXT, ///< raw UTF-8 text AV_CODEC_ID_TEXT, ///< raw UTF-8 text
CODEC_ID_XSUB, AV_CODEC_ID_XSUB,
CODEC_ID_SSA, AV_CODEC_ID_SSA,
CODEC_ID_MOV_TEXT, AV_CODEC_ID_MOV_TEXT,
CODEC_ID_HDMV_PGS_SUBTITLE, AV_CODEC_ID_HDMV_PGS_SUBTITLE,
CODEC_ID_DVB_TELETEXT, AV_CODEC_ID_DVB_TELETEXT,
CODEC_ID_SRT, AV_CODEC_ID_SRT,
CODEC_ID_MICRODVD = MKBETAG('m','D','V','D'), AV_CODEC_ID_MICRODVD = MKBETAG('m','D','V','D'),
CODEC_ID_EIA_608 = MKBETAG('c','6','0','8'), AV_CODEC_ID_EIA_608 = MKBETAG('c','6','0','8'),
CODEC_ID_JACOSUB = MKBETAG('J','S','U','B'), AV_CODEC_ID_JACOSUB = MKBETAG('J','S','U','B'),
CODEC_ID_SAMI = MKBETAG('S','A','M','I'), AV_CODEC_ID_SAMI = MKBETAG('S','A','M','I'),
CODEC_ID_REALTEXT = MKBETAG('R','T','X','T'), AV_CODEC_ID_REALTEXT = MKBETAG('R','T','X','T'),
CODEC_ID_SUBVIEWER = MKBETAG('S','u','b','V'), AV_CODEC_ID_SUBVIEWER = MKBETAG('S','u','b','V'),
/* other specific kind of codecs (generally used for attachments) */ /* other specific kind of codecs (generally used for attachments) */
CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs. AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs.
CODEC_ID_TTF = 0x18000, AV_CODEC_ID_TTF = 0x18000,
CODEC_ID_BINTEXT = MKBETAG('B','T','X','T'), AV_CODEC_ID_BINTEXT = MKBETAG('B','T','X','T'),
CODEC_ID_XBIN = MKBETAG('X','B','I','N'), AV_CODEC_ID_XBIN = MKBETAG('X','B','I','N'),
CODEC_ID_IDF = MKBETAG( 0 ,'I','D','F'), AV_CODEC_ID_IDF = MKBETAG( 0 ,'I','D','F'),
CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like CODEC_ID_NONE) but lavf should attempt to identify it AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
* stream (only used by libavformat) */ * stream (only used by libavformat) */
CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
* stream (only used by libavformat) */ * stream (only used by libavformat) */
CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information. AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information.
}; };
#if FF_API_OLD_DECODE_AUDIO #if FF_API_OLD_DECODE_AUDIO
@ -1402,7 +1406,7 @@ typedef struct AVCodecContext {
enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */ enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */
struct AVCodec *codec; struct AVCodec *codec;
char codec_name[32]; char codec_name[32];
enum CodecID codec_id; /* see CODEC_ID_xxx */ enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */
/** /**
* fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
@ -3037,7 +3041,7 @@ typedef struct AVCodec {
*/ */
const char *long_name; const char *long_name;
enum AVMediaType type; enum AVMediaType type;
enum CodecID id; enum AVCodecID id;
/** /**
* Codec capabilities. * Codec capabilities.
* see CODEC_CAP_* * see CODEC_CAP_*
@ -3135,9 +3139,9 @@ typedef struct AVHWAccel {
/** /**
* Codec implemented by the hardware accelerator. * Codec implemented by the hardware accelerator.
* *
* See CODEC_ID_xxx * See AV_CODEC_ID_xxx
*/ */
enum CodecID id; enum AVCodecID id;
/** /**
* Supported pixel format. * Supported pixel format.
@ -3453,7 +3457,7 @@ void avcodec_get_frame_defaults(AVFrame *pic);
* *
* @code * @code
* avcodec_register_all(); * avcodec_register_all();
* codec = avcodec_find_decoder(CODEC_ID_H264); * codec = avcodec_find_decoder(AV_CODEC_ID_H264);
* if (!codec) * if (!codec)
* exit(1); * exit(1);
* *
@ -3487,7 +3491,7 @@ int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
* @code * @code
* avcodec_register_all(); * avcodec_register_all();
* av_dict_set(&opts, "b", "2.5M", 0); * av_dict_set(&opts, "b", "2.5M", 0);
* codec = avcodec_find_decoder(CODEC_ID_H264); * codec = avcodec_find_decoder(AV_CODEC_ID_H264);
* if (!codec) * if (!codec)
* exit(1); * exit(1);
* *
@ -3648,10 +3652,10 @@ int av_packet_split_side_data(AVPacket *pkt);
/** /**
* Find a registered decoder with a matching codec ID. * Find a registered decoder with a matching codec ID.
* *
* @param id CodecID of the requested decoder * @param id AVCodecID of the requested decoder
* @return A decoder if one was found, NULL otherwise. * @return A decoder if one was found, NULL otherwise.
*/ */
AVCodec *avcodec_find_decoder(enum CodecID id); AVCodec *avcodec_find_decoder(enum AVCodecID id);
/** /**
* Find a registered decoder with the specified name. * Find a registered decoder with the specified name.
@ -4071,10 +4075,10 @@ void av_parser_close(AVCodecParserContext *s);
/** /**
* Find a registered encoder with a matching codec ID. * Find a registered encoder with a matching codec ID.
* *
* @param id CodecID of the requested encoder * @param id AVCodecID of the requested encoder
* @return An encoder if one was found, NULL otherwise. * @return An encoder if one was found, NULL otherwise.
*/ */
AVCodec *avcodec_find_encoder(enum CodecID id); AVCodec *avcodec_find_encoder(enum AVCodecID id);
/** /**
* Find a registered encoder with the specified name. * Find a registered encoder with the specified name.
@ -4593,15 +4597,15 @@ void avcodec_default_free_buffers(AVCodecContext *s);
* @param[in] codec_id the codec * @param[in] codec_id the codec
* @return Number of bits per sample or zero if unknown for the given codec. * @return Number of bits per sample or zero if unknown for the given codec.
*/ */
int av_get_bits_per_sample(enum CodecID codec_id); int av_get_bits_per_sample(enum AVCodecID codec_id);
/** /**
* Return the PCM codec associated with a sample format. * Return the PCM codec associated with a sample format.
* @param be endianness, 0 for little, 1 for big, * @param be endianness, 0 for little, 1 for big,
* -1 (or anything else) for native * -1 (or anything else) for native
* @return CODEC_ID_PCM_* or CODEC_ID_NONE * @return AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE
*/ */
enum CodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be); enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
/** /**
* Return codec bits per sample. * Return codec bits per sample.
@ -4611,7 +4615,7 @@ enum CodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
* @param[in] codec_id the codec * @param[in] codec_id the codec
* @return Number of bits per sample or zero if unknown for the given codec. * @return Number of bits per sample or zero if unknown for the given codec.
*/ */
int av_get_exact_bits_per_sample(enum CodecID codec_id); int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
/** /**
* Return audio frame duration. * Return audio frame duration.
@ -4765,13 +4769,13 @@ int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op));
/** /**
* Get the type of the given codec. * Get the type of the given codec.
*/ */
enum AVMediaType avcodec_get_type(enum CodecID codec_id); enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
/** /**
* Get the name of a codec. * Get the name of a codec.
* @return a static string identifying the codec; never NULL * @return a static string identifying the codec; never NULL
*/ */
const char *avcodec_get_name(enum CodecID id); const char *avcodec_get_name(enum AVCodecID id);
/** /**
* @return a positive value if s is open (i.e. avcodec_open2() was called on it * @return a positive value if s is open (i.e. avcodec_open2() was called on it

2
libavcodec/avs.c
View File

@ -178,7 +178,7 @@ static av_cold int avs_decode_end(AVCodecContext *avctx)
AVCodec ff_avs_decoder = { AVCodec ff_avs_decoder = {
.name = "avs", .name = "avs",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_AVS, .id = AV_CODEC_ID_AVS,
.priv_data_size = sizeof(AvsContext), .priv_data_size = sizeof(AvsContext),
.init = avs_decode_init, .init = avs_decode_init,
.decode = avs_decode_frame, .decode = avs_decode_frame,

2
libavcodec/avuidec.c
View File

@ -146,7 +146,7 @@ static av_cold int avui_decode_close(AVCodecContext *avctx)
AVCodec ff_avui_decoder = { AVCodec ff_avui_decoder = {
.name = "avui", .name = "avui",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_AVUI, .id = AV_CODEC_ID_AVUI,
.init = avui_decode_init, .init = avui_decode_init,
.decode = avui_decode_frame, .decode = avui_decode_frame,
.close = avui_decode_close, .close = avui_decode_close,

2
libavcodec/avuienc.c
View File

@ -103,7 +103,7 @@ static av_cold int avui_encode_close(AVCodecContext *avctx)
AVCodec ff_avui_encoder = { AVCodec ff_avui_encoder = {
.name = "avui", .name = "avui",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_AVUI, .id = AV_CODEC_ID_AVUI,
.init = avui_encode_init, .init = avui_encode_init,
.encode2 = avui_encode_frame, .encode2 = avui_encode_frame,
.close = avui_encode_close, .close = avui_encode_close,

2
libavcodec/bethsoftvideo.c
View File

@ -155,7 +155,7 @@ static av_cold int bethsoftvid_decode_end(AVCodecContext *avctx)
AVCodec ff_bethsoftvid_decoder = { AVCodec ff_bethsoftvid_decoder = {
.name = "bethsoftvid", .name = "bethsoftvid",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BETHSOFTVID, .id = AV_CODEC_ID_BETHSOFTVID,
.priv_data_size = sizeof(BethsoftvidContext), .priv_data_size = sizeof(BethsoftvidContext),
.init = bethsoftvid_decode_init, .init = bethsoftvid_decode_init,
.close = bethsoftvid_decode_end, .close = bethsoftvid_decode_end,

2
libavcodec/bfi.c
View File

@ -185,7 +185,7 @@ static av_cold int bfi_decode_close(AVCodecContext *avctx)
AVCodec ff_bfi_decoder = { AVCodec ff_bfi_decoder = {
.name = "bfi", .name = "bfi",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BFI, .id = AV_CODEC_ID_BFI,
.priv_data_size = sizeof(BFIContext), .priv_data_size = sizeof(BFIContext),
.init = bfi_decode_init, .init = bfi_decode_init,
.close = bfi_decode_close, .close = bfi_decode_close,

2
libavcodec/bink.c
View File

@ -1335,7 +1335,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_bink_decoder = { AVCodec ff_bink_decoder = {
.name = "binkvideo", .name = "binkvideo",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BINKVIDEO, .id = AV_CODEC_ID_BINKVIDEO,
.priv_data_size = sizeof(BinkContext), .priv_data_size = sizeof(BinkContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,

12
libavcodec/binkaudio.c
View File

@ -98,7 +98,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
s->version_b = avctx->extradata_size >= 4 && avctx->extradata[3] == 'b'; s->version_b = avctx->extradata_size >= 4 && avctx->extradata[3] == 'b';
if (avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT) { if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT) {
// audio is already interleaved for the RDFT format variant // audio is already interleaved for the RDFT format variant
sample_rate *= avctx->channels; sample_rate *= avctx->channels;
s->channels = 1; s->channels = 1;
@ -141,7 +141,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
s->prev_ptr[i] = s->coeffs_ptr[i] + s->frame_len - s->overlap_len; s->prev_ptr[i] = s->coeffs_ptr[i] + s->frame_len - s->overlap_len;
} }
if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT) if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
ff_rdft_init(&s->trans.rdft, frame_len_bits, DFT_C2R); ff_rdft_init(&s->trans.rdft, frame_len_bits, DFT_C2R);
else if (CONFIG_BINKAUDIO_DCT_DECODER) else if (CONFIG_BINKAUDIO_DCT_DECODER)
ff_dct_init(&s->trans.dct, frame_len_bits, DCT_III); ff_dct_init(&s->trans.dct, frame_len_bits, DCT_III);
@ -293,7 +293,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
BinkAudioContext * s = avctx->priv_data; BinkAudioContext * s = avctx->priv_data;
av_freep(&s->bands); av_freep(&s->bands);
av_freep(&s->packet_buffer); av_freep(&s->packet_buffer);
if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT) if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
ff_rdft_end(&s->trans.rdft); ff_rdft_end(&s->trans.rdft);
else if (CONFIG_BINKAUDIO_DCT_DECODER) else if (CONFIG_BINKAUDIO_DCT_DECODER)
ff_dct_end(&s->trans.dct); ff_dct_end(&s->trans.dct);
@ -346,7 +346,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
} }
samples = (int16_t *)s->frame.data[0]; samples = (int16_t *)s->frame.data[0];
if (decode_block(s, samples, avctx->codec->id == CODEC_ID_BINKAUDIO_DCT)) { if (decode_block(s, samples, avctx->codec->id == AV_CODEC_ID_BINKAUDIO_DCT)) {
av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n"); av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -361,7 +361,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_binkaudio_rdft_decoder = { AVCodec ff_binkaudio_rdft_decoder = {
.name = "binkaudio_rdft", .name = "binkaudio_rdft",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_BINKAUDIO_RDFT, .id = AV_CODEC_ID_BINKAUDIO_RDFT,
.priv_data_size = sizeof(BinkAudioContext), .priv_data_size = sizeof(BinkAudioContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,
@ -373,7 +373,7 @@ AVCodec ff_binkaudio_rdft_decoder = {
AVCodec ff_binkaudio_dct_decoder = { AVCodec ff_binkaudio_dct_decoder = {
.name = "binkaudio_dct", .name = "binkaudio_dct",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_BINKAUDIO_DCT, .id = AV_CODEC_ID_BINKAUDIO_DCT,
.priv_data_size = sizeof(BinkAudioContext), .priv_data_size = sizeof(BinkAudioContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,

10
libavcodec/bintext.c
View File

@ -148,7 +148,7 @@ static int decode_frame(AVCodecContext *avctx,
s->frame.palette_has_changed = 1; s->frame.palette_has_changed = 1;
memcpy(s->frame.data[1], s->palette, 16 * 4); memcpy(s->frame.data[1], s->palette, 16 * 4);
if (avctx->codec_id == CODEC_ID_XBIN) { if (avctx->codec_id == AV_CODEC_ID_XBIN) {
while (buf + 2 < buf_end) { while (buf + 2 < buf_end) {
int i,c,a; int i,c,a;
int type = *buf >> 6; int type = *buf >> 6;
@ -179,7 +179,7 @@ static int decode_frame(AVCodecContext *avctx,
break; break;
} }
} }
} else if (avctx->codec_id == CODEC_ID_IDF) { } else if (avctx->codec_id == AV_CODEC_ID_IDF) {
while (buf + 2 < buf_end) { while (buf + 2 < buf_end) {
if (AV_RL16(buf) == 1) { if (AV_RL16(buf) == 1) {
int i; int i;
@ -219,7 +219,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_bintext_decoder = { AVCodec ff_bintext_decoder = {
.name = "bintext", .name = "bintext",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BINTEXT, .id = AV_CODEC_ID_BINTEXT,
.priv_data_size = sizeof(XbinContext), .priv_data_size = sizeof(XbinContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,
@ -232,7 +232,7 @@ AVCodec ff_bintext_decoder = {
AVCodec ff_xbin_decoder = { AVCodec ff_xbin_decoder = {
.name = "xbin", .name = "xbin",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_XBIN, .id = AV_CODEC_ID_XBIN,
.priv_data_size = sizeof(XbinContext), .priv_data_size = sizeof(XbinContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,
@ -245,7 +245,7 @@ AVCodec ff_xbin_decoder = {
AVCodec ff_idf_decoder = { AVCodec ff_idf_decoder = {
.name = "idf", .name = "idf",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_IDF, .id = AV_CODEC_ID_IDF,
.priv_data_size = sizeof(XbinContext), .priv_data_size = sizeof(XbinContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,

2
libavcodec/bmp.c
View File

@ -352,7 +352,7 @@ static av_cold int bmp_decode_end(AVCodecContext *avctx)
AVCodec ff_bmp_decoder = { AVCodec ff_bmp_decoder = {
.name = "bmp", .name = "bmp",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BMP, .id = AV_CODEC_ID_BMP,
.priv_data_size = sizeof(BMPContext), .priv_data_size = sizeof(BMPContext),
.init = bmp_decode_init, .init = bmp_decode_init,
.close = bmp_decode_end, .close = bmp_decode_end,

2
libavcodec/bmp_parser.c
View File

@ -84,7 +84,7 @@ flush:
} }
AVCodecParser ff_bmp_parser = { AVCodecParser ff_bmp_parser = {
.codec_ids = { CODEC_ID_BMP }, .codec_ids = { AV_CODEC_ID_BMP },
.priv_data_size = sizeof(BMPParseContext), .priv_data_size = sizeof(BMPParseContext),
.parser_parse = bmp_parse, .parser_parse = bmp_parse,
.parser_close = ff_parse_close, .parser_close = ff_parse_close,

2
libavcodec/bmpenc.c
View File

@ -168,7 +168,7 @@ static int bmp_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
AVCodec ff_bmp_encoder = { AVCodec ff_bmp_encoder = {
.name = "bmp", .name = "bmp",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BMP, .id = AV_CODEC_ID_BMP,
.priv_data_size = sizeof(BMPContext), .priv_data_size = sizeof(BMPContext),
.init = bmp_encode_init, .init = bmp_encode_init,
.encode2 = bmp_encode_frame, .encode2 = bmp_encode_frame,

4
libavcodec/bmv.c
View File

@ -364,7 +364,7 @@ static int bmv_aud_decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_bmv_video_decoder = { AVCodec ff_bmv_video_decoder = {
.name = "bmv_video", .name = "bmv_video",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BMV_VIDEO, .id = AV_CODEC_ID_BMV_VIDEO,
.priv_data_size = sizeof(BMVDecContext), .priv_data_size = sizeof(BMVDecContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,
@ -376,7 +376,7 @@ AVCodec ff_bmv_video_decoder = {
AVCodec ff_bmv_audio_decoder = { AVCodec ff_bmv_audio_decoder = {
.name = "bmv_audio", .name = "bmv_audio",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_BMV_AUDIO, .id = AV_CODEC_ID_BMV_AUDIO,
.priv_data_size = sizeof(BMVAudioDecContext), .priv_data_size = sizeof(BMVAudioDecContext),
.init = bmv_aud_decode_init, .init = bmv_aud_decode_init,
.decode = bmv_aud_decode_frame, .decode = bmv_aud_decode_frame,

2
libavcodec/c93.c
View File

@ -251,7 +251,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_c93_decoder = { AVCodec ff_c93_decoder = {
.name = "c93", .name = "c93",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_C93, .id = AV_CODEC_ID_C93,
.priv_data_size = sizeof(C93DecoderContext), .priv_data_size = sizeof(C93DecoderContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,

2
libavcodec/cavs_parser.c
View File

@ -98,7 +98,7 @@ static int cavsvideo_parse(AVCodecParserContext *s,
} }
AVCodecParser ff_cavsvideo_parser = { AVCodecParser ff_cavsvideo_parser = {
.codec_ids = { CODEC_ID_CAVS }, .codec_ids = { AV_CODEC_ID_CAVS },
.priv_data_size = sizeof(ParseContext), .priv_data_size = sizeof(ParseContext),
.parser_parse = cavsvideo_parse, .parser_parse = cavsvideo_parse,
.parser_close = ff_parse_close, .parser_close = ff_parse_close,

2
libavcodec/cavsdec.c
View File

@ -733,7 +733,7 @@ static int cavs_decode_frame(AVCodecContext * avctx,void *data, int *data_size,
AVCodec ff_cavs_decoder = { AVCodec ff_cavs_decoder = {
.name = "cavs", .name = "cavs",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CAVS, .id = AV_CODEC_ID_CAVS,
.priv_data_size = sizeof(AVSContext), .priv_data_size = sizeof(AVSContext),
.init = ff_cavs_init, .init = ff_cavs_init,
.close = ff_cavs_end, .close = ff_cavs_end,

2
libavcodec/cdgraphics.c
View File

@ -374,7 +374,7 @@ static av_cold int cdg_decode_end(AVCodecContext *avctx)
AVCodec ff_cdgraphics_decoder = { AVCodec ff_cdgraphics_decoder = {
.name = "cdgraphics", .name = "cdgraphics",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CDGRAPHICS, .id = AV_CODEC_ID_CDGRAPHICS,
.priv_data_size = sizeof(CDGraphicsContext), .priv_data_size = sizeof(CDGraphicsContext),
.init = cdg_decode_init, .init = cdg_decode_init,
.close = cdg_decode_end, .close = cdg_decode_end,

2
libavcodec/cdxl.c
View File

@ -302,7 +302,7 @@ static av_cold int cdxl_decode_end(AVCodecContext *avctx)
AVCodec ff_cdxl_decoder = { AVCodec ff_cdxl_decoder = {
.name = "cdxl", .name = "cdxl",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CDXL, .id = AV_CODEC_ID_CDXL,
.priv_data_size = sizeof(CDXLVideoContext), .priv_data_size = sizeof(CDXLVideoContext),
.init = cdxl_decode_init, .init = cdxl_decode_init,
.close = cdxl_decode_end, .close = cdxl_decode_end,

2
libavcodec/cinepak.c
View File

@ -475,7 +475,7 @@ static av_cold int cinepak_decode_end(AVCodecContext *avctx)
AVCodec ff_cinepak_decoder = { AVCodec ff_cinepak_decoder = {
.name = "cinepak", .name = "cinepak",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CINEPAK, .id = AV_CODEC_ID_CINEPAK,
.priv_data_size = sizeof(CinepakContext), .priv_data_size = sizeof(CinepakContext),
.init = cinepak_decode_init, .init = cinepak_decode_init,
.close = cinepak_decode_end, .close = cinepak_decode_end,

4
libavcodec/cljr.c
View File

@ -122,7 +122,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_cljr_decoder = { AVCodec ff_cljr_decoder = {
.name = "cljr", .name = "cljr",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CLJR, .id = AV_CODEC_ID_CLJR,
.priv_data_size = sizeof(CLJRContext), .priv_data_size = sizeof(CLJRContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,
@ -199,7 +199,7 @@ static const AVClass class = {
AVCodec ff_cljr_encoder = { AVCodec ff_cljr_encoder = {
.name = "cljr", .name = "cljr",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CLJR, .id = AV_CODEC_ID_CLJR,
.priv_data_size = sizeof(CLJRContext), .priv_data_size = sizeof(CLJRContext),
.init = common_init, .init = common_init,
.encode2 = encode_frame, .encode2 = encode_frame,

2
libavcodec/cllc.c
View File

@ -274,7 +274,7 @@ static av_cold int cllc_decode_init(AVCodecContext *avctx)
AVCodec ff_cllc_decoder = { AVCodec ff_cllc_decoder = {
.name = "cllc", .name = "cllc",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CLLC, .id = AV_CODEC_ID_CLLC,
.priv_data_size = sizeof(CLLCContext), .priv_data_size = sizeof(CLLCContext),
.init = cllc_decode_init, .init = cllc_decode_init,
.decode = cllc_decode_frame, .decode = cllc_decode_frame,

8
libavcodec/codec_names.sh
View File

@ -41,7 +41,7 @@ parse_config_h () {
define_codecid () { define_codecid () {
id="$1" id="$1"
n=${1#CODEC_ID_} n=${1#AV_CODEC_ID_}
add_line "case ${id}:" add_line "case ${id}:"
eval "c=\${CONFIG_${n}_DECODER}:\${CONFIG_${n}_ENCODER}" eval "c=\${CONFIG_${n}_DECODER}:\${CONFIG_${n}_ENCODER}"
case "$c" in case "$c" in
@ -62,8 +62,8 @@ parse_enum_codecid () {
while read line; do while read line; do
case "$line" in case "$line" in
"};") break;; "};") break;;
*CODEC_ID_FIRST*=*) ;; *AV_CODEC_ID_FIRST*=*) ;;
CODEC_ID_*) define_codecid ${line%%[=,]*};; AV_CODEC_ID_*) define_codecid ${line%%[=,]*};;
esac esac
done done
} }
@ -71,7 +71,7 @@ parse_enum_codecid () {
parse_avcodec_h () { parse_avcodec_h () {
while read line; do while read line; do
case "$line" in case "$line" in
"enum CodecID {") parse_enum_codecid; break;; "enum AVCodecID {") parse_enum_codecid; break;;
esac esac
done done
} }

2
libavcodec/cook.c
View File

@ -1313,7 +1313,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)
AVCodec ff_cook_decoder = { AVCodec ff_cook_decoder = {
.name = "cook", .name = "cook",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_COOK, .id = AV_CODEC_ID_COOK,
.priv_data_size = sizeof(COOKContext), .priv_data_size = sizeof(COOKContext),
.init = cook_decode_init, .init = cook_decode_init,
.close = cook_decode_close, .close = cook_decode_close,

2
libavcodec/cook_parser.c
View File

@ -53,7 +53,7 @@ static int cook_parse(AVCodecParserContext *s1, AVCodecContext *avctx,
} }
AVCodecParser ff_cook_parser = { AVCodecParser ff_cook_parser = {
.codec_ids = { CODEC_ID_COOK }, .codec_ids = { AV_CODEC_ID_COOK },
.priv_data_size = sizeof(CookParseContext), .priv_data_size = sizeof(CookParseContext),
.parser_parse = cook_parse, .parser_parse = cook_parse,
}; };

30
libavcodec/crystalhd.c
View File

@ -166,17 +166,17 @@ static const AVOption options[] = {
static inline BC_MEDIA_SUBTYPE id2subtype(CHDContext *priv, enum CodecID id) static inline BC_MEDIA_SUBTYPE id2subtype(CHDContext *priv, enum CodecID id)
{ {
switch (id) { switch (id) {
case CODEC_ID_MPEG4: case AV_CODEC_ID_MPEG4:
return BC_MSUBTYPE_DIVX; return BC_MSUBTYPE_DIVX;
case CODEC_ID_MSMPEG4V3: case AV_CODEC_ID_MSMPEG4V3:
return BC_MSUBTYPE_DIVX311; return BC_MSUBTYPE_DIVX311;
case CODEC_ID_MPEG2VIDEO: case AV_CODEC_ID_MPEG2VIDEO:
return BC_MSUBTYPE_MPEG2VIDEO; return BC_MSUBTYPE_MPEG2VIDEO;
case CODEC_ID_VC1: case AV_CODEC_ID_VC1:
return BC_MSUBTYPE_VC1; return BC_MSUBTYPE_VC1;
case CODEC_ID_WMV3: case AV_CODEC_ID_WMV3:
return BC_MSUBTYPE_WMV3; return BC_MSUBTYPE_WMV3;
case CODEC_ID_H264: case AV_CODEC_ID_H264:
return priv->is_nal ? BC_MSUBTYPE_AVC1 : BC_MSUBTYPE_H264; return priv->is_nal ? BC_MSUBTYPE_AVC1 : BC_MSUBTYPE_H264;
default: default:
return BC_MSUBTYPE_INVALID; return BC_MSUBTYPE_INVALID;
@ -515,7 +515,7 @@ static av_cold int init(AVCodecContext *avctx)
goto fail; goto fail;
} }
if (avctx->codec->id == CODEC_ID_H264) { if (avctx->codec->id == AV_CODEC_ID_H264) {
priv->parser = av_parser_init(avctx->codec->id); priv->parser = av_parser_init(avctx->codec->id);
if (!priv->parser) if (!priv->parser)
av_log(avctx, AV_LOG_WARNING, av_log(avctx, AV_LOG_WARNING,
@ -604,7 +604,7 @@ static inline CopyRet copy_frame(AVCodecContext *avctx,
* picture or if there is a corruption in the stream. (In either * picture or if there is a corruption in the stream. (In either
* case a 0 will be returned for the next picture number) * case a 0 will be returned for the next picture number)
*/ */
trust_interlaced = avctx->codec->id != CODEC_ID_H264 || trust_interlaced = avctx->codec->id != AV_CODEC_ID_H264 ||
!(output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) || !(output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) ||
priv->need_second_field || priv->need_second_field ||
(decoder_status.picNumFlags & ~0x40000000) == (decoder_status.picNumFlags & ~0x40000000) ==
@ -812,7 +812,7 @@ static inline CopyRet receive_frame(AVCodecContext *avctx,
priv->last_picture = output.PicInfo.picture_number - 1; priv->last_picture = output.PicInfo.picture_number - 1;
} }
if (avctx->codec->id == CODEC_ID_MPEG4 && if (avctx->codec->id == AV_CODEC_ID_MPEG4 &&
output.PicInfo.timeStamp == 0 && priv->bframe_bug) { output.PicInfo.timeStamp == 0 && priv->bframe_bug) {
av_log(avctx, AV_LOG_VERBOSE, av_log(avctx, AV_LOG_VERBOSE,
"CrystalHD: Not returning packed frame twice.\n"); "CrystalHD: Not returning packed frame twice.\n");
@ -1091,7 +1091,7 @@ static AVClass h264_class = {
AVCodec ff_h264_crystalhd_decoder = { AVCodec ff_h264_crystalhd_decoder = {
.name = "h264_crystalhd", .name = "h264_crystalhd",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H264, .id = AV_CODEC_ID_H264,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
.init = init, .init = init,
.close = uninit, .close = uninit,
@ -1115,7 +1115,7 @@ static AVClass mpeg2_class = {
AVCodec ff_mpeg2_crystalhd_decoder = { AVCodec ff_mpeg2_crystalhd_decoder = {
.name = "mpeg2_crystalhd", .name = "mpeg2_crystalhd",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MPEG2VIDEO, .id = AV_CODEC_ID_MPEG2VIDEO,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
.init = init, .init = init,
.close = uninit, .close = uninit,
@ -1139,7 +1139,7 @@ static AVClass mpeg4_class = {
AVCodec ff_mpeg4_crystalhd_decoder = { AVCodec ff_mpeg4_crystalhd_decoder = {
.name = "mpeg4_crystalhd", .name = "mpeg4_crystalhd",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MPEG4, .id = AV_CODEC_ID_MPEG4,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
.init = init, .init = init,
.close = uninit, .close = uninit,
@ -1163,7 +1163,7 @@ static AVClass msmpeg4_class = {
AVCodec ff_msmpeg4_crystalhd_decoder = { AVCodec ff_msmpeg4_crystalhd_decoder = {
.name = "msmpeg4_crystalhd", .name = "msmpeg4_crystalhd",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MSMPEG4V3, .id = AV_CODEC_ID_MSMPEG4V3,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
.init = init, .init = init,
.close = uninit, .close = uninit,
@ -1187,7 +1187,7 @@ static AVClass vc1_class = {
AVCodec ff_vc1_crystalhd_decoder = { AVCodec ff_vc1_crystalhd_decoder = {
.name = "vc1_crystalhd", .name = "vc1_crystalhd",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_VC1, .id = AV_CODEC_ID_VC1,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
.init = init, .init = init,
.close = uninit, .close = uninit,
@ -1211,7 +1211,7 @@ static AVClass wmv3_class = {
AVCodec ff_wmv3_crystalhd_decoder = { AVCodec ff_wmv3_crystalhd_decoder = {
.name = "wmv3_crystalhd", .name = "wmv3_crystalhd",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_WMV3, .id = AV_CODEC_ID_WMV3,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
.init = init, .init = init,
.close = uninit, .close = uninit,

2
libavcodec/cscd.c
View File

@ -161,7 +161,7 @@ static av_cold int decode_end(AVCodecContext *avctx) {
AVCodec ff_cscd_decoder = { AVCodec ff_cscd_decoder = {
.name = "camstudio", .name = "camstudio",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CSCD, .id = AV_CODEC_ID_CSCD,
.priv_data_size = sizeof(CamStudioContext), .priv_data_size = sizeof(CamStudioContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,

6
libavcodec/cyuv.c
View File

@ -83,7 +83,7 @@ static int cyuv_decode_frame(AVCodecContext *avctx,
unsigned char cur_byte; unsigned char cur_byte;
int pixel_groups; int pixel_groups;
if (avctx->codec_id == CODEC_ID_AURA) { if (avctx->codec_id == AV_CODEC_ID_AURA) {
y_table = u_table; y_table = u_table;
u_table = v_table; u_table = v_table;
} }
@ -182,7 +182,7 @@ static av_cold int cyuv_decode_end(AVCodecContext *avctx)
AVCodec ff_aura_decoder = { AVCodec ff_aura_decoder = {
.name = "aura", .name = "aura",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_AURA, .id = AV_CODEC_ID_AURA,
.priv_data_size = sizeof(CyuvDecodeContext), .priv_data_size = sizeof(CyuvDecodeContext),
.init = cyuv_decode_init, .init = cyuv_decode_init,
.close = cyuv_decode_end, .close = cyuv_decode_end,
@ -196,7 +196,7 @@ AVCodec ff_aura_decoder = {
AVCodec ff_cyuv_decoder = { AVCodec ff_cyuv_decoder = {
.name = "cyuv", .name = "cyuv",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CYUV, .id = AV_CODEC_ID_CYUV,
.priv_data_size = sizeof(CyuvDecodeContext), .priv_data_size = sizeof(CyuvDecodeContext),
.init = cyuv_decode_init, .init = cyuv_decode_init,
.close = cyuv_decode_end, .close = cyuv_decode_end,

2
libavcodec/dca_parser.c
View File

@ -201,7 +201,7 @@ static int dca_parse(AVCodecParserContext * s,
} }
AVCodecParser ff_dca_parser = { AVCodecParser ff_dca_parser = {
.codec_ids = { CODEC_ID_DTS }, .codec_ids = { AV_CODEC_ID_DTS },
.priv_data_size = sizeof(DCAParseContext), .priv_data_size = sizeof(DCAParseContext),
.parser_init = dca_parse_init, .parser_init = dca_parse_init,
.parser_parse = dca_parse, .parser_parse = dca_parse,

2
libavcodec/dcadec.c
View File

@ -2493,7 +2493,7 @@ static const AVProfile profiles[] = {
AVCodec ff_dca_decoder = { AVCodec ff_dca_decoder = {
.name = "dca", .name = "dca",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_DTS, .id = AV_CODEC_ID_DTS,
.priv_data_size = sizeof(DCAContext), .priv_data_size = sizeof(DCAContext),
.init = dca_decode_init, .init = dca_decode_init,
.decode = dca_decode_frame, .decode = dca_decode_frame,

2
libavcodec/dcaenc.c
View File

@ -592,7 +592,7 @@ static int encode_init(AVCodecContext *avctx)
AVCodec ff_dca_encoder = { AVCodec ff_dca_encoder = {
.name = "dca", .name = "dca",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_DTS, .id = AV_CODEC_ID_DTS,
.priv_data_size = sizeof(DCAContext), .priv_data_size = sizeof(DCAContext),
.init = encode_init, .init = encode_init,
.encode2 = encode_frame, .encode2 = encode_frame,

2
libavcodec/dfa.c
View File

@ -381,7 +381,7 @@ static av_cold int dfa_decode_end(AVCodecContext *avctx)
AVCodec ff_dfa_decoder = { AVCodec ff_dfa_decoder = {
.name = "dfa", .name = "dfa",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DFA, .id = AV_CODEC_ID_DFA,
.priv_data_size = sizeof(DfaContext), .priv_data_size = sizeof(DfaContext),
.init = dfa_decode_init, .init = dfa_decode_init,
.close = dfa_decode_end, .close = dfa_decode_end,

2
libavcodec/dirac_parser.c
View File

@ -248,7 +248,7 @@ static void dirac_parse_close(AVCodecParserContext *s)
} }
AVCodecParser ff_dirac_parser = { AVCodecParser ff_dirac_parser = {
.codec_ids = { CODEC_ID_DIRAC }, .codec_ids = { AV_CODEC_ID_DIRAC },
.priv_data_size = sizeof(DiracParseContext), .priv_data_size = sizeof(DiracParseContext),
.parser_parse = dirac_parse, .parser_parse = dirac_parse,
.parser_close = dirac_parse_close, .parser_close = dirac_parse_close,

2
libavcodec/diracdec.c
View File

@ -1916,7 +1916,7 @@ static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVCodec ff_dirac_decoder = { AVCodec ff_dirac_decoder = {
.name = "dirac", .name = "dirac",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DIRAC, .id = AV_CODEC_ID_DIRAC,
.priv_data_size = sizeof(DiracContext), .priv_data_size = sizeof(DiracContext),
.init = dirac_decode_init, .init = dirac_decode_init,
.close = dirac_decode_end, .close = dirac_decode_end,

2
libavcodec/dnxhd_parser.c
View File

@ -109,7 +109,7 @@ static int dnxhd_parse(AVCodecParserContext *s,
} }
AVCodecParser ff_dnxhd_parser = { AVCodecParser ff_dnxhd_parser = {
.codec_ids = { CODEC_ID_DNXHD }, .codec_ids = { AV_CODEC_ID_DNXHD },
.priv_data_size = sizeof(DNXHDParserContext), .priv_data_size = sizeof(DNXHDParserContext),
.parser_parse = dnxhd_parse, .parser_parse = dnxhd_parse,
.parser_close = ff_parse_close, .parser_close = ff_parse_close,

2
libavcodec/dnxhddec.c
View File

@ -427,7 +427,7 @@ static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
AVCodec ff_dnxhd_decoder = { AVCodec ff_dnxhd_decoder = {
.name = "dnxhd", .name = "dnxhd",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DNXHD, .id = AV_CODEC_ID_DNXHD,
.priv_data_size = sizeof(DNXHDContext), .priv_data_size = sizeof(DNXHDContext),
.init = dnxhd_decode_init, .init = dnxhd_decode_init,
.close = dnxhd_decode_close, .close = dnxhd_decode_close,

2
libavcodec/dnxhdenc.c
View File

@ -1008,7 +1008,7 @@ static const AVCodecDefault dnxhd_defaults[] = {
AVCodec ff_dnxhd_encoder = { AVCodec ff_dnxhd_encoder = {
.name = "dnxhd", .name = "dnxhd",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DNXHD, .id = AV_CODEC_ID_DNXHD,
.priv_data_size = sizeof(DNXHDEncContext), .priv_data_size = sizeof(DNXHDEncContext),
.init = dnxhd_encode_init, .init = dnxhd_encode_init,
.encode2 = dnxhd_encode_picture, .encode2 = dnxhd_encode_picture,

30
libavcodec/dpcm.c
View File

@ -128,7 +128,7 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx)
switch(avctx->codec->id) { switch(avctx->codec->id) {
case CODEC_ID_ROQ_DPCM: case AV_CODEC_ID_ROQ_DPCM:
/* initialize square table */ /* initialize square table */
for (i = 0; i < 128; i++) { for (i = 0; i < 128; i++) {
int16_t square = i * i; int16_t square = i * i;
@ -137,7 +137,7 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx)
} }
break; break;
case CODEC_ID_SOL_DPCM: case AV_CODEC_ID_SOL_DPCM:
switch(avctx->codec_tag){ switch(avctx->codec_tag){
case 1: case 1:
s->sol_table = sol_table_old; s->sol_table = sol_table_old;
@ -159,7 +159,7 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx)
break; break;
} }
if (avctx->codec->id == CODEC_ID_SOL_DPCM && avctx->codec_tag != 3) if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
avctx->sample_fmt = AV_SAMPLE_FMT_U8; avctx->sample_fmt = AV_SAMPLE_FMT_U8;
else else
avctx->sample_fmt = AV_SAMPLE_FMT_S16; avctx->sample_fmt = AV_SAMPLE_FMT_S16;
@ -189,16 +189,16 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
/* calculate output size */ /* calculate output size */
switch(avctx->codec->id) { switch(avctx->codec->id) {
case CODEC_ID_ROQ_DPCM: case AV_CODEC_ID_ROQ_DPCM:
out = buf_size - 8; out = buf_size - 8;
break; break;
case CODEC_ID_INTERPLAY_DPCM: case AV_CODEC_ID_INTERPLAY_DPCM:
out = buf_size - 6 - s->channels; out = buf_size - 6 - s->channels;
break; break;
case CODEC_ID_XAN_DPCM: case AV_CODEC_ID_XAN_DPCM:
out = buf_size - 2 * s->channels; out = buf_size - 2 * s->channels;
break; break;
case CODEC_ID_SOL_DPCM: case AV_CODEC_ID_SOL_DPCM:
if (avctx->codec_tag != 3) if (avctx->codec_tag != 3)
out = buf_size * 2; out = buf_size * 2;
else else
@ -224,7 +224,7 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
switch(avctx->codec->id) { switch(avctx->codec->id) {
case CODEC_ID_ROQ_DPCM: case AV_CODEC_ID_ROQ_DPCM:
bytestream2_skipu(&gb, 6); bytestream2_skipu(&gb, 6);
if (stereo) { if (stereo) {
@ -245,7 +245,7 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
} }
break; break;
case CODEC_ID_INTERPLAY_DPCM: case AV_CODEC_ID_INTERPLAY_DPCM:
bytestream2_skipu(&gb, 6); /* skip over the stream mask and stream length */ bytestream2_skipu(&gb, 6); /* skip over the stream mask and stream length */
for (ch = 0; ch < s->channels; ch++) { for (ch = 0; ch < s->channels; ch++) {
@ -264,7 +264,7 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
} }
break; break;
case CODEC_ID_XAN_DPCM: case AV_CODEC_ID_XAN_DPCM:
{ {
int shift[2] = { 4, 4 }; int shift[2] = { 4, 4 };
@ -297,7 +297,7 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
} }
break; break;
} }
case CODEC_ID_SOL_DPCM: case AV_CODEC_ID_SOL_DPCM:
if (avctx->codec_tag != 3) { if (avctx->codec_tag != 3) {
uint8_t *output_samples_u8 = s->frame.data[0], uint8_t *output_samples_u8 = s->frame.data[0],
*samples_end_u8 = output_samples_u8 + out; *samples_end_u8 = output_samples_u8 + out;
@ -344,7 +344,7 @@ AVCodec ff_ ## name_ ## _decoder = { \
.long_name = NULL_IF_CONFIG_SMALL(long_name_), \ .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
} }
DPCM_DECODER(CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay"); DPCM_DECODER(AV_CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
DPCM_DECODER(CODEC_ID_ROQ_DPCM, roq_dpcm, "DPCM id RoQ"); DPCM_DECODER(AV_CODEC_ID_ROQ_DPCM, roq_dpcm, "DPCM id RoQ");
DPCM_DECODER(CODEC_ID_SOL_DPCM, sol_dpcm, "DPCM Sol"); DPCM_DECODER(AV_CODEC_ID_SOL_DPCM, sol_dpcm, "DPCM Sol");
DPCM_DECODER(CODEC_ID_XAN_DPCM, xan_dpcm, "DPCM Xan"); DPCM_DECODER(AV_CODEC_ID_XAN_DPCM, xan_dpcm, "DPCM Xan");

2
libavcodec/dpx.c
View File

@ -243,7 +243,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_dpx_decoder = { AVCodec ff_dpx_decoder = {
.name = "dpx", .name = "dpx",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DPX, .id = AV_CODEC_ID_DPX,
.priv_data_size = sizeof(DPXContext), .priv_data_size = sizeof(DPXContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,

2
libavcodec/dpxenc.c
View File

@ -178,7 +178,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
AVCodec ff_dpx_encoder = { AVCodec ff_dpx_encoder = {
.name = "dpx", .name = "dpx",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DPX, .id = AV_CODEC_ID_DPX,
.priv_data_size = sizeof(DPXContext), .priv_data_size = sizeof(DPXContext),
.init = encode_init, .init = encode_init,
.encode2 = encode_frame, .encode2 = encode_frame,

4
libavcodec/dsicinav.c
View File

@ -381,7 +381,7 @@ static int cinaudio_decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_dsicinvideo_decoder = { AVCodec ff_dsicinvideo_decoder = {
.name = "dsicinvideo", .name = "dsicinvideo",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DSICINVIDEO, .id = AV_CODEC_ID_DSICINVIDEO,
.priv_data_size = sizeof(CinVideoContext), .priv_data_size = sizeof(CinVideoContext),
.init = cinvideo_decode_init, .init = cinvideo_decode_init,
.close = cinvideo_decode_end, .close = cinvideo_decode_end,
@ -393,7 +393,7 @@ AVCodec ff_dsicinvideo_decoder = {
AVCodec ff_dsicinaudio_decoder = { AVCodec ff_dsicinaudio_decoder = {
.name = "dsicinaudio", .name = "dsicinaudio",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_DSICINAUDIO, .id = AV_CODEC_ID_DSICINAUDIO,
.priv_data_size = sizeof(CinAudioContext), .priv_data_size = sizeof(CinAudioContext),
.init = cinaudio_decode_init, .init = cinaudio_decode_init,
.decode = cinaudio_decode_frame, .decode = cinaudio_decode_frame,

2
libavcodec/dv.c
View File

@ -987,7 +987,7 @@ static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
AVCodec ff_dvvideo_encoder = { AVCodec ff_dvvideo_encoder = {
.name = "dvvideo", .name = "dvvideo",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DVVIDEO, .id = AV_CODEC_ID_DVVIDEO,
.priv_data_size = sizeof(DVVideoContext), .priv_data_size = sizeof(DVVideoContext),
.init = dvvideo_init_encoder, .init = dvvideo_init_encoder,
.encode2 = dvvideo_encode_frame, .encode2 = dvvideo_encode_frame,

2
libavcodec/dvbsub.c
View File

@ -464,7 +464,7 @@ static int dvbsub_encode(AVCodecContext *avctx,
AVCodec ff_dvbsub_encoder = { AVCodec ff_dvbsub_encoder = {
.name = "dvbsub", .name = "dvbsub",
.type = AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
.id = CODEC_ID_DVB_SUBTITLE, .id = AV_CODEC_ID_DVB_SUBTITLE,
.priv_data_size = sizeof(DVBSubtitleContext), .priv_data_size = sizeof(DVBSubtitleContext),
.encode = dvbsub_encode, .encode = dvbsub_encode,
.long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"), .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),

2
libavcodec/dvbsub_parser.c
View File

@ -172,7 +172,7 @@ static av_cold void dvbsub_parse_close(AVCodecParserContext *s)
} }
AVCodecParser ff_dvbsub_parser = { AVCodecParser ff_dvbsub_parser = {
.codec_ids = { CODEC_ID_DVB_SUBTITLE }, .codec_ids = { AV_CODEC_ID_DVB_SUBTITLE },
.priv_data_size = sizeof(DVBSubParseContext), .priv_data_size = sizeof(DVBSubParseContext),
.parser_init = dvbsub_parse_init, .parser_init = dvbsub_parse_init,
.parser_parse = dvbsub_parse, .parser_parse = dvbsub_parse,

2
libavcodec/dvbsubdec.c
View File

@ -1533,7 +1533,7 @@ static int dvbsub_decode(AVCodecContext *avctx,
AVCodec ff_dvbsub_decoder = { AVCodec ff_dvbsub_decoder = {
.name = "dvbsub", .name = "dvbsub",
.type = AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
.id = CODEC_ID_DVB_SUBTITLE, .id = AV_CODEC_ID_DVB_SUBTITLE,
.priv_data_size = sizeof(DVBSubContext), .priv_data_size = sizeof(DVBSubContext),
.init = dvbsub_init_decoder, .init = dvbsub_init_decoder,
.close = dvbsub_close_decoder, .close = dvbsub_close_decoder,

2
libavcodec/dvdec.c
View File

@ -377,7 +377,7 @@ static int dvvideo_close(AVCodecContext *c)
AVCodec ff_dvvideo_decoder = { AVCodec ff_dvvideo_decoder = {
.name = "dvvideo", .name = "dvvideo",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DVVIDEO, .id = AV_CODEC_ID_DVVIDEO,
.priv_data_size = sizeof(DVVideoContext), .priv_data_size = sizeof(DVVideoContext),
.init = ff_dvvideo_init, .init = ff_dvvideo_init,
.close = dvvideo_close, .close = dvvideo_close,

2
libavcodec/dvdsub_parser.c
View File

@ -77,7 +77,7 @@ static av_cold void dvdsub_parse_close(AVCodecParserContext *s)
} }
AVCodecParser ff_dvdsub_parser = { AVCodecParser ff_dvdsub_parser = {
.codec_ids = { CODEC_ID_DVD_SUBTITLE }, .codec_ids = { AV_CODEC_ID_DVD_SUBTITLE },
.priv_data_size = sizeof(DVDSubParseContext), .priv_data_size = sizeof(DVDSubParseContext),
.parser_init = dvdsub_parse_init, .parser_init = dvdsub_parse_init,
.parser_parse = dvdsub_parse, .parser_parse = dvdsub_parse,

2
libavcodec/dvdsubdec.c
View File

@ -561,7 +561,7 @@ static int dvdsub_init(AVCodecContext *avctx)
AVCodec ff_dvdsub_decoder = { AVCodec ff_dvdsub_decoder = {
.name = "dvdsub", .name = "dvdsub",
.type = AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
.id = CODEC_ID_DVD_SUBTITLE, .id = AV_CODEC_ID_DVD_SUBTITLE,
.priv_data_size = sizeof(DVDSubContext), .priv_data_size = sizeof(DVDSubContext),
.init = dvdsub_init, .init = dvdsub_init,
.decode = dvdsub_decode, .decode = dvdsub_decode,

2
libavcodec/dvdsubenc.c
View File

@ -217,7 +217,7 @@ static int dvdsub_encode(AVCodecContext *avctx,
AVCodec ff_dvdsub_encoder = { AVCodec ff_dvdsub_encoder = {
.name = "dvdsub", .name = "dvdsub",
.type = AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
.id = CODEC_ID_DVD_SUBTITLE, .id = AV_CODEC_ID_DVD_SUBTITLE,
.encode = dvdsub_encode, .encode = dvdsub_encode,
.long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"), .long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"),
}; };

2
libavcodec/dxa.c
View File

@ -321,7 +321,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_dxa_decoder = { AVCodec ff_dxa_decoder = {
.name = "dxa", .name = "dxa",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DXA, .id = AV_CODEC_ID_DXA,
.priv_data_size = sizeof(DxaDecContext), .priv_data_size = sizeof(DxaDecContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,

2
libavcodec/dxtory.c
View File

@ -101,7 +101,7 @@ AVCodec ff_dxtory_decoder = {
.name = "dxtory", .name = "dxtory",
.long_name = NULL_IF_CONFIG_SMALL("Dxtory"), .long_name = NULL_IF_CONFIG_SMALL("Dxtory"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DXTORY, .id = AV_CODEC_ID_DXTORY,
.init = decode_init, .init = decode_init,
.close = decode_close, .close = decode_close,
.decode = decode_frame, .decode = decode_frame,

2
libavcodec/dxva2_h264.c
View File

@ -442,7 +442,7 @@ static int end_frame(AVCodecContext *avctx)
AVHWAccel ff_h264_dxva2_hwaccel = { AVHWAccel ff_h264_dxva2_hwaccel = {
.name = "h264_dxva2", .name = "h264_dxva2",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H264, .id = AV_CODEC_ID_H264,
.pix_fmt = PIX_FMT_DXVA2_VLD, .pix_fmt = PIX_FMT_DXVA2_VLD,
.start_frame = start_frame, .start_frame = start_frame,
.decode_slice = decode_slice, .decode_slice = decode_slice,

2
libavcodec/dxva2_mpeg2.c
View File

@ -263,7 +263,7 @@ static int end_frame(AVCodecContext *avctx)
AVHWAccel ff_mpeg2_dxva2_hwaccel = { AVHWAccel ff_mpeg2_dxva2_hwaccel = {
.name = "mpeg2_dxva2", .name = "mpeg2_dxva2",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MPEG2VIDEO, .id = AV_CODEC_ID_MPEG2VIDEO,
.pix_fmt = PIX_FMT_DXVA2_VLD, .pix_fmt = PIX_FMT_DXVA2_VLD,
.start_frame = start_frame, .start_frame = start_frame,
.decode_slice = decode_slice, .decode_slice = decode_slice,

8
libavcodec/dxva2_vc1.c
View File

@ -167,7 +167,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
DXVA_SliceInfo *slice = &ctx_pic->si; DXVA_SliceInfo *slice = &ctx_pic->si;
static const uint8_t start_code[] = { 0, 0, 1, 0x0d }; static const uint8_t start_code[] = { 0, 0, 1, 0x0d };
const unsigned start_code_size = avctx->codec_id == CODEC_ID_VC1 ? sizeof(start_code) : 0; const unsigned start_code_size = avctx->codec_id == AV_CODEC_ID_VC1 ? sizeof(start_code) : 0;
const unsigned slice_size = slice->dwSliceBitsInBuffer / 8; const unsigned slice_size = slice->dwSliceBitsInBuffer / 8;
const unsigned padding = 128 - ((start_code_size + slice_size) & 127); const unsigned padding = 128 - ((start_code_size + slice_size) & 127);
const unsigned data_size = start_code_size + slice_size + padding; const unsigned data_size = start_code_size + slice_size + padding;
@ -237,7 +237,7 @@ static int decode_slice(AVCodecContext *avctx,
if (ctx_pic->bitstream_size > 0) if (ctx_pic->bitstream_size > 0)
return -1; return -1;
if (avctx->codec_id == CODEC_ID_VC1 && if (avctx->codec_id == AV_CODEC_ID_VC1 &&
size >= 4 && IS_MARKER(AV_RB32(buffer))) { size >= 4 && IS_MARKER(AV_RB32(buffer))) {
buffer += 4; buffer += 4;
size -= 4; size -= 4;
@ -268,7 +268,7 @@ static int end_frame(AVCodecContext *avctx)
AVHWAccel ff_wmv3_dxva2_hwaccel = { AVHWAccel ff_wmv3_dxva2_hwaccel = {
.name = "wmv3_dxva2", .name = "wmv3_dxva2",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_WMV3, .id = AV_CODEC_ID_WMV3,
.pix_fmt = PIX_FMT_DXVA2_VLD, .pix_fmt = PIX_FMT_DXVA2_VLD,
.start_frame = start_frame, .start_frame = start_frame,
.decode_slice = decode_slice, .decode_slice = decode_slice,
@ -280,7 +280,7 @@ AVHWAccel ff_wmv3_dxva2_hwaccel = {
AVHWAccel ff_vc1_dxva2_hwaccel = { AVHWAccel ff_vc1_dxva2_hwaccel = {
.name = "vc1_dxva2", .name = "vc1_dxva2",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_VC1, .id = AV_CODEC_ID_VC1,
.pix_fmt = PIX_FMT_DXVA2_VLD, .pix_fmt = PIX_FMT_DXVA2_VLD,
.start_frame = start_frame, .start_frame = start_frame,
.decode_slice = decode_slice, .decode_slice = decode_slice,

2
libavcodec/eac3enc.c
View File

@ -253,7 +253,7 @@ void ff_eac3_output_frame_header(AC3EncodeContext *s)
AVCodec ff_eac3_encoder = { AVCodec ff_eac3_encoder = {
.name = "eac3", .name = "eac3",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_EAC3, .id = AV_CODEC_ID_EAC3,
.priv_data_size = sizeof(AC3EncodeContext), .priv_data_size = sizeof(AC3EncodeContext),
.init = ff_ac3_encode_init, .init = ff_ac3_encode_init,
.encode2 = ff_ac3_float_encode_frame, .encode2 = ff_ac3_float_encode_frame,

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