is deprecated and will be dropped at the next major bump.
Originally committed as revision 22735 to svn://svn.ffmpeg.org/ffmpeg/trunk
const char **opt_names;
static int opt_name_count;
-AVCodecContext *avcodec_opts[CODEC_TYPE_NB];
+AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
AVFormatContext *avformat_opts;
struct SwsContext *sws_opts;
const AVOption *o= NULL;
int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
- for(type=0; type<CODEC_TYPE_NB && ret>= 0; type++){
+ for(type=0; type<AVMEDIA_TYPE_NB && ret>= 0; type++){
const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
if(o2)
ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
ret = av_set_string3(sws_opts, opt, arg, 1, &o);
if(!o){
if(opt[0] == 'a')
- ret = av_set_string3(avcodec_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1, &o);
+ ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
else if(opt[0] == 'v')
- ret = av_set_string3(avcodec_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1, &o);
+ ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
else if(opt[0] == 's')
- ret = av_set_string3(avcodec_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1, &o);
+ ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
}
if (o && ret < 0) {
fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
last_name= p2->name;
switch(p2->type) {
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
type_str = "V";
break;
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
type_str = "A";
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
type_str = "S";
break;
default:
extern const int this_year;
extern const char **opt_names;
-extern AVCodecContext *avcodec_opts[CODEC_TYPE_NB];
+extern AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
extern AVFormatContext *avformat_opts;
extern struct SwsContext *sws_opts;
powerpc_display_perf_report();
#endif /* CONFIG_POWERPC_PERF */
- for (i=0;i<CODEC_TYPE_NB;i++)
+ for (i=0;i<AVMEDIA_TYPE_NB;i++)
av_free(avcodec_opts[i]);
av_free(avformat_opts);
av_free(sws_opts);
memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
s->streams[i] = st;
- if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
+ if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && audio_stream_copy)
st->stream_copy = 1;
- else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
+ else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && video_stream_copy)
st->stream_copy = 1;
if(!st->codec->thread_count)
}else
ost->sync_opts= lrintf(sync_ipts);
- nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
+ nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
if (nb_frames <= 0)
return;
/* better than nothing: use input picture interlaced
settings */
big_picture.interlaced_frame = in_picture->interlaced_frame;
- if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
+ if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
if(top_field_first == -1)
big_picture.top_field_first = in_picture->top_field_first;
else
}
enc = ost->st->codec;
- if (enc->codec_type == CODEC_TYPE_VIDEO) {
+ if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
frame_number = ost->frame_number;
fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
if (enc->flags&CODEC_FLAG_PSNR)
for(i=0;i<nb_ostreams;i++) {
ost = ost_table[i];
enc = ost->st->codec;
- if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
+ if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
!ost->st->stream_copy ?
enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
}
- if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
+ if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
float t = (av_gettime()-timer_start) / 1000000.0;
frame_number = ost->frame_number;
subtitle_to_free = NULL;
if (ist->decoding_needed) {
switch(ist->st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:{
+ case AVMEDIA_TYPE_AUDIO:{
if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
av_free(samples);
ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
(ist->st->codec->sample_rate * ist->st->codec->channels);
break;}
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
/* XXX: allocate picture correctly */
avcodec_get_frame_defaults(&picture);
}
avpkt.size = 0;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
ret = avcodec_decode_subtitle2(ist->st->codec,
&subtitle, &got_subtitle, &avpkt);
if (ret < 0)
}
} else {
switch(ist->st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
ist->st->codec->sample_rate;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
if (ist->st->codec->time_base.num != 0) {
int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
ist->next_pts += ((int64_t)AV_TIME_BASE *
}
buffer_to_free = NULL;
- if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
pre_process_video_frame(ist, (AVPicture *)&picture,
&buffer_to_free);
}
// preprocess audio (volume)
- if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
if (audio_volume != 256) {
short *volp;
volp = samples;
if (ost->encoding_needed) {
assert(ist->decoding_needed);
switch(ost->st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
do_video_out(os, ost, ist, &picture, &frame_size);
if (vstats_filename && frame_size)
do_video_stats(os, ost, frame_size);
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
do_subtitle_out(os, ost, ist, &subtitle,
pkt->pts);
break;
ost->st->codec->coded_frame= &avframe;
avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
- if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
+ if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
audio_size += data_size;
- else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
+ else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
video_size += data_size;
ost->sync_opts++;
}
AVCodecContext *enc= ost->st->codec;
os = output_files[ost->file_index];
- if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
+ if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
continue;
- if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
+ if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
continue;
if (ost->encoding_needed) {
pkt.stream_index= ost->index;
switch(ost->st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
fifo_bytes = av_fifo_size(ost->fifo);
ret = 0;
/* encode any samples remaining in fifo */
audio_size += ret;
pkt.flags |= PKT_FLAG_KEY;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
if (ret < 0) {
fprintf(stderr, "Video encoding failed\n");
}else
codec->time_base = ist->st->time_base;
switch(codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
if(audio_volume != 256) {
fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
av_exit(1);
if(codec->codec_id == CODEC_ID_AC3)
codec->block_align= 0;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
codec->pix_fmt = icodec->pix_fmt;
codec->width = icodec->width;
codec->height = icodec->height;
codec->has_b_frames = icodec->has_b_frames;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
codec->width = icodec->width;
codec->height = icodec->height;
break;
}
} else {
switch(codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
ost->fifo= av_fifo_alloc(1024);
if(!ost->fifo)
goto fail;
ist->decoding_needed = 1;
ost->encoding_needed = 1;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
av_exit(1);
ost->encoding_needed = 1;
ist->decoding_needed = 1;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
ost->encoding_needed = 1;
ist->decoding_needed = 1;
break;
}
}
}
- if(codec->codec_type == CODEC_TYPE_VIDEO){
+ if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
int size= codec->width * codec->height;
bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
}
ret = AVERROR(EINVAL);
goto dump_format;
}
- //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
+ //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
// ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
}
}
static int opt_bitrate(const char *opt, const char *arg)
{
- int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
+ int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
opt_default(opt, arg);
static void opt_audio_codec(const char *arg)
{
- opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
+ opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
}
static void opt_audio_tag(const char *arg)
static void opt_video_codec(const char *arg)
{
- opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
+ opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
}
static void opt_subtitle_codec(const char *arg)
{
- opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
+ opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
}
static void opt_subtitle_tag(const char *arg)
set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
- ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
- ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
- ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
+ ic->video_codec_id = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
+ ic->audio_codec_id = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
+ ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
ic->flags |= AVFMT_FLAG_NONBLOCK;
if(pgmyuv_compatibility_hack)
AVCodecContext *enc = st->codec;
avcodec_thread_init(enc, thread_count);
switch(enc->codec_type) {
- case CODEC_TYPE_AUDIO:
- set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
+ case AVMEDIA_TYPE_AUDIO:
+ set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
//fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
channel_layout = enc->channel_layout;
audio_channels = enc->channels;
if(audio_disable)
st->discard= AVDISCARD_ALL;
break;
- case CODEC_TYPE_VIDEO:
- set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
+ case AVMEDIA_TYPE_VIDEO:
+ set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
frame_height = enc->height;
frame_width = enc->width;
if(ic->streams[i]->sample_aspect_ratio.num)
else if(video_discard)
st->discard= video_discard;
break;
- case CODEC_TYPE_DATA:
+ case AVMEDIA_TYPE_DATA:
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
if(subtitle_disable)
st->discard = AVDISCARD_ALL;
break;
- case CODEC_TYPE_ATTACHMENT:
- case CODEC_TYPE_UNKNOWN:
+ case AVMEDIA_TYPE_ATTACHMENT:
+ case AVMEDIA_TYPE_UNKNOWN:
nb_icodecs++;
break;
default:
for(i=0;i<ic->nb_streams;i++) {
AVCodecContext *enc = ic->streams[i]->codec;
switch(enc->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
has_audio = 1;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
has_video = 1;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
has_subtitle = 1;
break;
- case CODEC_TYPE_DATA:
- case CODEC_TYPE_ATTACHMENT:
- case CODEC_TYPE_UNKNOWN:
+ case AVMEDIA_TYPE_DATA:
+ case AVMEDIA_TYPE_ATTACHMENT:
+ case AVMEDIA_TYPE_UNKNOWN:
break;
default:
abort();
fprintf(stderr, "Could not alloc stream\n");
av_exit(1);
}
- avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
+ avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
video_bitstream_filters= NULL;
if( (video_global_header&1)
|| (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
+ avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
}
if(video_global_header&2){
video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
- avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
+ avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
}
if (video_stream_copy) {
st->stream_copy = 1;
- video_enc->codec_type = CODEC_TYPE_VIDEO;
+ video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
video_enc->sample_aspect_ratio =
st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
} else {
AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
if (video_codec_name) {
- codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
+ codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
codec = avcodec_find_encoder_by_name(video_codec_name);
output_codecs[nb_ocodecs] = codec;
} else {
- codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
+ codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
codec = avcodec_find_encoder(codec_id);
}
video_enc->codec_id = codec_id;
- set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
+ set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
if (codec && codec->supported_framerates && !force_fps)
fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
fprintf(stderr, "Could not alloc stream\n");
av_exit(1);
}
- avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
+ avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
audio_bitstream_filters= NULL;
avcodec_thread_init(st->codec, thread_count);
audio_enc = st->codec;
- audio_enc->codec_type = CODEC_TYPE_AUDIO;
+ audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
if(audio_codec_tag)
audio_enc->codec_tag= audio_codec_tag;
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
+ avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
}
if (audio_stream_copy) {
st->stream_copy = 1;
} else {
AVCodec *codec;
- set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
+ set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
if (audio_codec_name) {
- codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
+ codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
codec = avcodec_find_encoder_by_name(audio_codec_name);
output_codecs[nb_ocodecs] = codec;
} else {
- codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
+ codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
codec = avcodec_find_encoder(codec_id);
}
audio_enc->codec_id = codec_id;
fprintf(stderr, "Could not alloc stream\n");
av_exit(1);
}
- avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
+ avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
subtitle_bitstream_filters= NULL;
subtitle_enc = st->codec;
- subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
+ subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
if(subtitle_codec_tag)
subtitle_enc->codec_tag= subtitle_codec_tag;
if (subtitle_stream_copy) {
st->stream_copy = 1;
} else {
- set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
- subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
+ set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
+ subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
}
nb_ocodecs++;
for(j = 0; j < nb_input_files; j++) {
for(i = 0; i < input_files[j]->nb_streams; i++) {
AVCodecContext *c = input_files[j]->streams[i]->codec;
- if(c->codec_type != CODEC_TYPE_VIDEO)
+ if(c->codec_type != AVMEDIA_TYPE_VIDEO)
continue;
fr = c->time_base.den * 1000 / c->time_base.num;
if(fr == 25000) {
{ "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
{ "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
{ "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
- { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
+ { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
{ "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
"add timings for benchmarking" },
{ "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
/* video options */
{ "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
{ "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
- { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
+ { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
{ "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
{ "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
{ "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
/* audio options */
{ "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
- { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
+ { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
{ "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
{ "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
{ "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
url_set_interrupt_cb(decode_interrupt_cb);
#endif
- for(i=0; i<CODEC_TYPE_NB; i++){
+ for(i=0; i<AVMEDIA_TYPE_NB; i++){
avcodec_opts[i]= avcodec_alloc_context2(i);
}
avformat_opts = avformat_alloc_context();
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
static int audio_disable;
static int video_disable;
-static int wanted_stream[CODEC_TYPE_NB]={
- [CODEC_TYPE_AUDIO]=-1,
- [CODEC_TYPE_VIDEO]=-1,
- [CODEC_TYPE_SUBTITLE]=-1,
+static int wanted_stream[AVMEDIA_TYPE_NB]={
+ [AVMEDIA_TYPE_AUDIO]=-1,
+ [AVMEDIA_TYPE_VIDEO]=-1,
+ [AVMEDIA_TYPE_SUBTITLE]=-1,
};
static int seek_by_bytes=-1;
static int display_disable;
.inputs = (AVFilterPad[]) {{ .name = NULL }},
.outputs = (AVFilterPad[]) {{ .name = "default",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.request_frame = input_request_frame,
.config_props = input_config_props, },
{ .name = NULL }},
.query_formats = output_query_formats,
.inputs = (AVFilterPad[]) {{ .name = "default",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.end_frame = output_end_frame,
.min_perms = AV_PERM_READ, },
{ .name = NULL }},
avctx = ic->streams[stream_index]->codec;
/* prepare audio output */
- if (avctx->codec_type == CODEC_TYPE_AUDIO) {
+ if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
if (avctx->channels > 0) {
avctx->request_channels = FFMIN(2, avctx->channels);
} else {
return -1;
/* prepare audio output */
- if (avctx->codec_type == CODEC_TYPE_AUDIO) {
+ if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
wanted_spec.freq = avctx->sample_rate;
wanted_spec.format = AUDIO_S16SYS;
wanted_spec.channels = avctx->channels;
ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
switch(avctx->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
is->audio_stream = stream_index;
is->audio_st = ic->streams[stream_index];
is->audio_buf_size = 0;
packet_queue_init(&is->audioq);
SDL_PauseAudio(0);
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
is->video_stream = stream_index;
is->video_st = ic->streams[stream_index];
packet_queue_init(&is->videoq);
is->video_tid = SDL_CreateThread(video_thread, is);
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
is->subtitle_stream = stream_index;
is->subtitle_st = ic->streams[stream_index];
packet_queue_init(&is->subtitleq);
avctx = ic->streams[stream_index]->codec;
switch(avctx->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
packet_queue_abort(&is->audioq);
SDL_CloseAudio();
av_audio_convert_free(is->reformat_ctx);
is->reformat_ctx = NULL;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
packet_queue_abort(&is->videoq);
/* note: we also signal this mutex to make sure we deblock the
packet_queue_end(&is->videoq);
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
packet_queue_abort(&is->subtitleq);
/* note: we also signal this mutex to make sure we deblock the
ic->streams[stream_index]->discard = AVDISCARD_ALL;
avcodec_close(avctx);
switch(avctx->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
is->audio_st = NULL;
is->audio_stream = -1;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
is->video_st = NULL;
is->video_stream = -1;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
is->subtitle_st = NULL;
is->subtitle_stream = -1;
break;
VideoState *is = arg;
AVFormatContext *ic;
int err, i, ret;
- int st_index[CODEC_TYPE_NB];
- int st_count[CODEC_TYPE_NB]={0};
- int st_best_packet_count[CODEC_TYPE_NB];
+ int st_index[AVMEDIA_TYPE_NB];
+ int st_count[AVMEDIA_TYPE_NB]={0};
+ int st_best_packet_count[AVMEDIA_TYPE_NB];
AVPacket pkt1, *pkt = &pkt1;
AVFormatParameters params, *ap = ¶ms;
int eof=0;
AVStream *st= ic->streams[i];
AVCodecContext *avctx = st->codec;
ic->streams[i]->discard = AVDISCARD_ALL;
- if(avctx->codec_type >= (unsigned)CODEC_TYPE_NB)
+ if(avctx->codec_type >= (unsigned)AVMEDIA_TYPE_NB)
continue;
if(st_count[avctx->codec_type]++ != wanted_stream[avctx->codec_type] && wanted_stream[avctx->codec_type] >= 0)
continue;
st_best_packet_count[avctx->codec_type]= st->codec_info_nb_frames;
switch(avctx->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
if (!audio_disable)
- st_index[CODEC_TYPE_AUDIO] = i;
+ st_index[AVMEDIA_TYPE_AUDIO] = i;
break;
- case CODEC_TYPE_VIDEO:
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_VIDEO:
+ case AVMEDIA_TYPE_SUBTITLE:
if (!video_disable)
st_index[avctx->codec_type] = i;
break;
}
/* open the streams */
- if (st_index[CODEC_TYPE_AUDIO] >= 0) {
- stream_component_open(is, st_index[CODEC_TYPE_AUDIO]);
+ if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
+ stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
}
ret=-1;
- if (st_index[CODEC_TYPE_VIDEO] >= 0) {
- ret= stream_component_open(is, st_index[CODEC_TYPE_VIDEO]);
+ if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
+ ret= stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
}
is->refresh_tid = SDL_CreateThread(refresh_thread, is);
if(ret<0) {
is->show_audio = 2;
}
- if (st_index[CODEC_TYPE_SUBTITLE] >= 0) {
- stream_component_open(is, st_index[CODEC_TYPE_SUBTITLE]);
+ if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
+ stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
}
if (is->video_stream < 0 && is->audio_stream < 0) {
int start_index, stream_index;
AVStream *st;
- if (codec_type == CODEC_TYPE_VIDEO)
+ if (codec_type == AVMEDIA_TYPE_VIDEO)
start_index = is->video_stream;
- else if (codec_type == CODEC_TYPE_AUDIO)
+ else if (codec_type == AVMEDIA_TYPE_AUDIO)
start_index = is->audio_stream;
else
start_index = is->subtitle_stream;
- if (start_index < (codec_type == CODEC_TYPE_SUBTITLE ? -1 : 0))
+ if (start_index < (codec_type == AVMEDIA_TYPE_SUBTITLE ? -1 : 0))
return;
stream_index = start_index;
for(;;) {
if (++stream_index >= is->ic->nb_streams)
{
- if (codec_type == CODEC_TYPE_SUBTITLE)
+ if (codec_type == AVMEDIA_TYPE_SUBTITLE)
{
stream_index = -1;
goto the_end;
if (st->codec->codec_type == codec_type) {
/* check that parameters are OK */
switch(codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
if (st->codec->sample_rate != 0 &&
st->codec->channels != 0)
goto the_end;
break;
- case CODEC_TYPE_VIDEO:
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_VIDEO:
+ case AVMEDIA_TYPE_SUBTITLE:
goto the_end;
default:
break;
stream_close(cur_stream);
cur_stream = NULL;
}
- for (i = 0; i < CODEC_TYPE_NB; i++)
+ for (i = 0; i < AVMEDIA_TYPE_NB; i++)
av_free(avcodec_opts[i]);
av_free(avformat_opts);
av_free(sws_opts);
break;
case SDLK_a:
if (cur_stream)
- stream_cycle_channel(cur_stream, CODEC_TYPE_AUDIO);
+ stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
break;
case SDLK_v:
if (cur_stream)
- stream_cycle_channel(cur_stream, CODEC_TYPE_VIDEO);
+ stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
break;
case SDLK_t:
if (cur_stream)
- stream_cycle_channel(cur_stream, CODEC_TYPE_SUBTITLE);
+ stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
break;
case SDLK_w:
toggle_audio_display();
{ "fs", OPT_BOOL, {(void*)&is_full_screen}, "force full screen" },
{ "an", OPT_BOOL, {(void*)&audio_disable}, "disable audio" },
{ "vn", OPT_BOOL, {(void*)&video_disable}, "disable video" },
- { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_stream[CODEC_TYPE_AUDIO]}, "select desired audio stream", "stream_number" },
- { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_stream[CODEC_TYPE_VIDEO]}, "select desired video stream", "stream_number" },
- { "sst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_stream[CODEC_TYPE_SUBTITLE]}, "select desired subtitle stream", "stream_number" },
+ { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_stream[AVMEDIA_TYPE_AUDIO]}, "select desired audio stream", "stream_number" },
+ { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_stream[AVMEDIA_TYPE_VIDEO]}, "select desired video stream", "stream_number" },
+ { "sst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_stream[AVMEDIA_TYPE_SUBTITLE]}, "select desired subtitle stream", "stream_number" },
{ "ss", HAS_ARG | OPT_FUNC2, {(void*)&opt_seek}, "seek to a given position in seconds", "pos" },
{ "bytes", OPT_INT | HAS_ARG, {(void*)&seek_by_bytes}, "seek by bytes 0=off 1=on -1=auto", "val" },
{ "nodisp", OPT_BOOL, {(void*)&display_disable}, "disable graphical display" },
#endif
av_register_all();
- for(i=0; i<CODEC_TYPE_NB; i++){
+ for(i=0; i<AVMEDIA_TYPE_NB; i++){
avcodec_opts[i]= avcodec_alloc_context2(i);
}
avformat_opts = avformat_alloc_context();
return buf;
}
-static const char *codec_type_string(enum CodecType codec_type)
+static const char *media_type_string(enum AVMediaType media_type)
{
- switch (codec_type) {
- case CODEC_TYPE_VIDEO: return "video";
- case CODEC_TYPE_AUDIO: return "audio";
- case CODEC_TYPE_DATA: return "data";
- case CODEC_TYPE_SUBTITLE: return "subtitle";
- case CODEC_TYPE_ATTACHMENT: return "attachment";
+ switch (media_type) {
+ case AVMEDIA_TYPE_VIDEO: return "video";
+ case AVMEDIA_TYPE_AUDIO: return "audio";
+ case AVMEDIA_TYPE_DATA: return "data";
+ case AVMEDIA_TYPE_SUBTITLE: return "subtitle";
+ case AVMEDIA_TYPE_ATTACHMENT: return "attachment";
default: return "unknown";
}
}
printf("codec_name=unknown\n");
}
- printf("codec_type=%s\n", codec_type_string(dec_ctx->codec_type));
+ printf("codec_type=%s\n", media_type_string(dec_ctx->codec_type));
printf("codec_time_base=%d/%d\n", dec_ctx->time_base.num, dec_ctx->time_base.den);
/* print AVI/FourCC tag */
printf("\ncodec_tag=0x%04x\n", dec_ctx->codec_tag);
switch (dec_ctx->codec_type) {
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
printf("width=%d\n", dec_ctx->width);
printf("height=%d\n", dec_ctx->height);
printf("has_b_frames=%d\n", dec_ctx->has_b_frames);
av_pix_fmt_descriptors[dec_ctx->pix_fmt].name : "unknown");
break;
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
printf("sample_rate=%s\n", value_string(val_str, sizeof(val_str),
dec_ctx->sample_rate,
unit_hertz_str));
AVStream *st = stream->streams[i];
AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
switch(st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
audio_bit_rate += st->codec->bit_rate;
if (codec) {
if (*audio_codec_name)
audio_codec_name = codec->name;
}
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
video_bit_rate += st->codec->bit_rate;
if (codec) {
if (*video_codec_name)
video_codec_name = codec->name;
}
break;
- case CODEC_TYPE_DATA:
+ case AVMEDIA_TYPE_DATA:
video_bit_rate += st->codec->bit_rate;
break;
default:
parameters[0] = 0;
switch(st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
type = "audio";
snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
type = "video";
snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
c->pts_stream_index = 0;
for(i=0;i<c->stream->nb_streams;i++) {
if (c->pts_stream_index == 0 &&
- c->stream->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO) {
+ c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
c->pts_stream_index = i;
}
}
AVStream *st = c->fmt_in->streams[source_index];
pkt.stream_index = i;
if (pkt.flags & PKT_FLAG_KEY &&
- (st->codec->codec_type == CODEC_TYPE_VIDEO ||
+ (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
c->stream->nb_streams == 1))
c->got_key_frame = 1;
if (!c->stream->send_on_key || c->got_key_frame)
av1->bit_rate == av->bit_rate) {
switch(av->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
if (av1->channels == av->channels &&
av1->sample_rate == av->sample_rate)
goto found;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
if (av1->width == av->width &&
av1->height == av->height &&
av1->time_base.den == av->time_base.den &&
} else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
http_log("Codec bitrates do not match for stream %d\n", i);
matches = 0;
- } else if (ccf->codec_type == CODEC_TYPE_VIDEO) {
+ } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
if (CHECK_CODEC(time_base.den) ||
CHECK_CODEC(time_base.num) ||
CHECK_CODEC(width) ||
http_log("Codec width, height and framerate do not match for stream %d\n", i);
matches = 0;
}
- } else if (ccf->codec_type == CODEC_TYPE_AUDIO) {
+ } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
if (CHECK_CODEC(sample_rate) ||
CHECK_CODEC(channels) ||
CHECK_CODEC(frame_size)) {
for(i=0;i<stream->nb_streams;i++) {
AVStream *st = stream->streams[i];
switch(st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_AUDIO:
+ case AVMEDIA_TYPE_VIDEO:
bandwidth += st->codec->bit_rate;
break;
default:
/* compute default parameters */
switch(av->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
if (av->bit_rate == 0)
av->bit_rate = 64000;
if (av->sample_rate == 0)
if (av->channels == 0)
av->channels = 1;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
if (av->bit_rate == 0)
av->bit_rate = 64000;
if (av->time_base.num == 0){
{
AVCodec *p= avcodec_find_encoder_by_name(arg);
- if (p == NULL || p->type != CODEC_TYPE_AUDIO)
+ if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO)
return CODEC_ID_NONE;
return p->id;
{
AVCodec *p= avcodec_find_encoder_by_name(arg);
- if (p == NULL || p->type != CODEC_TYPE_VIDEO)
+ if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO)
return CODEC_ID_NONE;
return p->id;
} else {
if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
if (audio_id != CODEC_ID_NONE) {
- audio_enc.codec_type = CODEC_TYPE_AUDIO;
+ audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
audio_enc.codec_id = audio_id;
add_codec(stream, &audio_enc);
}
if (video_id != CODEC_ID_NONE) {
- video_enc.codec_type = CODEC_TYPE_VIDEO;
+ video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
video_enc.codec_id = video_id;
add_codec(stream, &video_enc);
}
AVCodec fourxm_decoder = {
"4xm",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_4XM,
sizeof(FourXContext),
decode_init,
AVCodec eightbps_decoder = {
"8bps",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_8BPS,
sizeof(EightBpsContext),
decode_init,
AVCodec eightsvx_fib_decoder = {
.name = "8svx_fib",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_8SVX_FIB,
.priv_data_size = sizeof (EightSvxContext),
.init = eightsvx_decode_init,
AVCodec eightsvx_exp_decoder = {
.name = "8svx_exp",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_8SVX_EXP,
.priv_data_size = sizeof (EightSvxContext),
.init = eightsvx_decode_init,
AVCodec aac_decoder = {
"aac",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
sizeof(AACContext),
aac_decode_init,
AVCodec aac_encoder = {
"aac",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
sizeof(AACEncContext),
aac_encode_init,
AVCodec aasc_decoder = {
"aasc",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_AASC,
sizeof(AascContext),
aasc_decode_init,
AVCodec ac3_decoder = {
.name = "ac3",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AC3,
.priv_data_size = sizeof (AC3DecodeContext),
.init = ac3_decode_init,
#if CONFIG_EAC3_DECODER
AVCodec eac3_decoder = {
.name = "eac3",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_EAC3,
.priv_data_size = sizeof (AC3DecodeContext),
.init = ac3_decode_init,
AVCodec ac3_encoder = {
"ac3",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_AC3,
sizeof(AC3EncodeContext),
AC3_encode_init,
#define ADPCM_ENCODER(id,name,long_name_) \
AVCodec name ## _encoder = { \
#name, \
- CODEC_TYPE_AUDIO, \
+ AVMEDIA_TYPE_AUDIO, \
id, \
sizeof(ADPCMContext), \
adpcm_encode_init, \
#define ADPCM_DECODER(id,name,long_name_) \
AVCodec name ## _decoder = { \
#name, \
- CODEC_TYPE_AUDIO, \
+ AVMEDIA_TYPE_AUDIO, \
id, \
sizeof(ADPCMContext), \
adpcm_decode_init, \
AVCodec adpcm_adx_decoder = {
"adpcm_adx",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_ADX,
sizeof(ADXContext),
adx_decode_init,
AVCodec adpcm_adx_encoder = {
"adpcm_adx",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_ADX,
sizeof(ADXContext),
adx_encode_init,
AVCodec alac_decoder = {
"alac",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_ALAC,
sizeof(ALACContext),
alac_decode_init,
AVCodec alac_encoder = {
"alac",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_ALAC,
sizeof(AlacEncodeContext),
alac_encode_init,
AVCodec als_decoder = {
"als",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP4ALS,
sizeof(ALSDecContext),
decode_init,
AVCodec amrnb_decoder = {
.name = "amrnb",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AMR_NB,
.priv_data_size = sizeof(AMRContext),
.init = amrnb_decode_init,
AVCodec anm_decoder = {
"anm",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_ANM,
sizeof(AnmContext),
decode_init,
AVCodec ape_decoder = {
"ape",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_APE,
sizeof(APEContext),
ape_decode_init,
AVCodec asv1_decoder = {
"asv1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV1,
sizeof(ASV1Context),
decode_init,
AVCodec asv2_decoder = {
"asv2",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV2,
sizeof(ASV1Context),
decode_init,
#if CONFIG_ASV1_ENCODER
AVCodec asv1_encoder = {
"asv1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV1,
sizeof(ASV1Context),
encode_init,
#if CONFIG_ASV2_ENCODER
AVCodec asv2_encoder = {
"asv2",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV2,
sizeof(ASV1Context),
encode_init,
AVCodec atrac1_decoder = {
.name = "atrac1",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ATRAC1,
.priv_data_size = sizeof(AT1Ctx),
.init = atrac1_decode_init,
AVCodec atrac3_decoder =
{
.name = "atrac3",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ATRAC3,
.priv_data_size = sizeof(ATRAC3Context),
.init = atrac3_decode_init,
AVCodec aura2_decoder = {
"aura2",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_AURA2,
sizeof(AuraDecodeContext),
aura_decode_init,
#include "libavutil/avutil.h"
#define LIBAVCODEC_VERSION_MAJOR 52
-#define LIBAVCODEC_VERSION_MINOR 63
+#define LIBAVCODEC_VERSION_MINOR 64
#define LIBAVCODEC_VERSION_MICRO 0
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
* stream (only used by libavformat) */
};
-enum CodecType {
- CODEC_TYPE_UNKNOWN = -1,
- CODEC_TYPE_VIDEO,
- CODEC_TYPE_AUDIO,
- CODEC_TYPE_DATA,
- CODEC_TYPE_SUBTITLE,
- CODEC_TYPE_ATTACHMENT,
- CODEC_TYPE_NB
+enum AVMediaType {
+ AVMEDIA_TYPE_UNKNOWN = -1,
+ AVMEDIA_TYPE_VIDEO,
+ AVMEDIA_TYPE_AUDIO,
+ AVMEDIA_TYPE_DATA,
+ AVMEDIA_TYPE_SUBTITLE,
+ AVMEDIA_TYPE_ATTACHMENT,
+ AVMEDIA_TYPE_NB
};
+#if LIBAVCODEC_VERSION_MAJOR < 53
+#define CodecType AVMediaType
+
+#define CODEC_TYPE_UNKNOWN AVMEDIA_TYPE_UNKNOWN
+#define CODEC_TYPE_VIDEO AVMEDIA_TYPE_VIDEO
+#define CODEC_TYPE_AUDIO AVMEDIA_TYPE_AUDIO
+#define CODEC_TYPE_DATA AVMEDIA_TYPE_DATA
+#define CODEC_TYPE_SUBTITLE AVMEDIA_TYPE_SUBTITLE
+#define CODEC_TYPE_ATTACHMENT AVMEDIA_TYPE_ATTACHMENT
+#define CODEC_TYPE_NB AVMEDIA_TYPE_NB
+#endif
+
/**
* all in native-endian format
*/
void *opaque;
char codec_name[32];
- enum CodecType codec_type; /* see CODEC_TYPE_xxx */
+ enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */
enum CodecID codec_id; /* see CODEC_ID_xxx */
/**
* This is the primary way to find a codec from the user perspective.
*/
const char *name;
- enum CodecType type;
+ enum AVMediaType type;
enum CodecID id;
int priv_data_size;
int (*init)(AVCodecContext *);
/**
* Type of codec implemented by the hardware accelerator.
*
- * See CODEC_TYPE_xxx
+ * See AVMEDIA_TYPE_xxx
*/
- enum CodecType type;
+ enum AVMediaType type;
/**
* Codec implemented by the hardware accelerator.
/** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API!
* we WILL change its arguments and name a few times! */
-void avcodec_get_context_defaults2(AVCodecContext *s, enum CodecType);
+void avcodec_get_context_defaults2(AVCodecContext *s, enum AVMediaType);
/**
* Allocates an AVCodecContext and sets its fields to default values. The
/** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API!
* we WILL change its arguments and name a few times! */
-AVCodecContext *avcodec_alloc_context2(enum CodecType);
+AVCodecContext *avcodec_alloc_context2(enum AVMediaType);
/**
* Sets the fields of the given AVFrame to default values.
AVCodec avs_decoder = {
"avs",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_AVS,
sizeof(AvsContext),
avs_decode_init,
AVCodec bethsoftvid_decoder = {
.name = "bethsoftvid",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BETHSOFTVID,
.priv_data_size = sizeof(BethsoftvidContext),
.init = bethsoftvid_decode_init,
AVCodec bfi_decoder = {
.name = "bfi",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BFI,
.priv_data_size = sizeof(BFIContext),
.init = bfi_decode_init,
AVCodec bink_decoder = {
"binkvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_BINKVIDEO,
sizeof(BinkContext),
decode_init,
AVCodec binkaudio_rdft_decoder = {
"binkaudio_rdft",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_BINKAUDIO_RDFT,
sizeof(BinkAudioContext),
decode_init,
AVCodec binkaudio_dct_decoder = {
"binkaudio_dct",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_BINKAUDIO_DCT,
sizeof(BinkAudioContext),
decode_init,
AVCodec bmp_decoder = {
"bmp",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_BMP,
sizeof(BMPContext),
bmp_decode_init,
AVCodec bmp_encoder = {
"bmp",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_BMP,
sizeof(BMPContext),
bmp_encode_init,
AVCodec c93_decoder = {
"c93",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_C93,
sizeof(C93DecoderContext),
decode_init,
AVCodec cavs_decoder = {
"cavs",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_CAVS,
sizeof(AVSContext),
ff_cavs_init,
AVCodec cdgraphics_decoder = {
"cdgraphics",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_CDGRAPHICS,
sizeof(CDGraphicsContext),
cdg_decode_init,
AVCodec cinepak_decoder = {
"cinepak",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_CINEPAK,
sizeof(CinepakContext),
cinepak_decode_init,
AVCodec cljr_decoder = {
"cljr",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_CLJR,
sizeof(CLJRContext),
decode_init,
#if CONFIG_CLJR_ENCODER
AVCodec cljr_encoder = {
"cljr",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_CLJR,
sizeof(CLJRContext),
encode_init,
AVCodec cook_decoder =
{
.name = "cook",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_COOK,
.priv_data_size = sizeof(COOKContext),
.init = cook_decode_init,
AVCodec cscd_decoder = {
"camstudio",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_CSCD,
sizeof(CamStudioContext),
decode_init,
#if CONFIG_AURA_DECODER
AVCodec aura_decoder = {
"aura",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_AURA,
sizeof(CyuvDecodeContext),
cyuv_decode_init,
#if CONFIG_CYUV_DECODER
AVCodec cyuv_decoder = {
"cyuv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_CYUV,
sizeof(CyuvDecodeContext),
cyuv_decode_init,
AVCodec dca_decoder = {
.name = "dca",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_DTS,
.priv_data_size = sizeof(DCAContext),
.init = dca_decode_init,
AVCodec dnxhd_decoder = {
"dnxhd",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DNXHD,
sizeof(DNXHDContext),
dnxhd_decode_init,
AVCodec dnxhd_encoder = {
"dnxhd",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DNXHD,
sizeof(DNXHDEncContext),
dnxhd_encode_init,
#define DPCM_DECODER(id, name, long_name_) \
AVCodec name ## _decoder = { \
#name, \
- CODEC_TYPE_AUDIO, \
+ AVMEDIA_TYPE_AUDIO, \
id, \
sizeof(DPCMContext), \
dpcm_decode_init, \
AVCodec dpx_decoder = {
"dpx",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DPX,
sizeof(DPXContext),
decode_init,
AVCodec dsicinvideo_decoder = {
"dsicinvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DSICINVIDEO,
sizeof(CinVideoContext),
cinvideo_decode_init,
AVCodec dsicinaudio_decoder = {
"dsicinaudio",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_DSICINAUDIO,
sizeof(CinAudioContext),
cinaudio_decode_init,
#if CONFIG_DVVIDEO_ENCODER
AVCodec dvvideo_encoder = {
"dvvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DVVIDEO,
sizeof(DVVideoContext),
dvvideo_init_encoder,
#if CONFIG_DVVIDEO_DECODER
AVCodec dvvideo_decoder = {
"dvvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DVVIDEO,
sizeof(DVVideoContext),
dvvideo_init,
AVCodec dvbsub_encoder = {
"dvbsub",
- CODEC_TYPE_SUBTITLE,
+ AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVB_SUBTITLE,
sizeof(DVBSubtitleContext),
NULL,
AVCodec dvbsub_decoder = {
"dvbsub",
- CODEC_TYPE_SUBTITLE,
+ AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVB_SUBTITLE,
sizeof(DVBSubContext),
dvbsub_init_decoder,
AVCodec dvdsub_decoder = {
"dvdsub",
- CODEC_TYPE_SUBTITLE,
+ AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVD_SUBTITLE,
0,
NULL,
AVCodec dvdsub_encoder = {
"dvdsub",
- CODEC_TYPE_SUBTITLE,
+ AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVD_SUBTITLE,
0,
NULL,
AVCodec dxa_decoder = {
"dxa",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DXA,
sizeof(DxaDecContext),
decode_init,
AVHWAccel h264_dxva2_hwaccel = {
.name = "h264_dxva2",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H264,
.pix_fmt = PIX_FMT_DXVA2_VLD,
.capabilities = 0,
#if CONFIG_WMV3_DXVA2_HWACCEL
AVHWAccel wmv3_dxva2_hwaccel = {
.name = "wmv3_dxva2",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_WMV3,
.pix_fmt = PIX_FMT_DXVA2_VLD,
.capabilities = 0,
AVHWAccel vc1_dxva2_hwaccel = {
.name = "vc1_dxva2",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_VC1,
.pix_fmt = PIX_FMT_DXVA2_VLD,
.capabilities = 0,
AVCodec eacmv_decoder = {
"eacmv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_CMV,
sizeof(CmvContext),
cmv_decode_init,
AVCodec eamad_decoder = {
"eamad",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MAD,
sizeof(MadContext),
decode_init,
AVCodec eatgq_decoder = {
"eatgq",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_TGQ,
sizeof(TgqContext),
tgq_decode_init,
AVCodec eatgv_decoder = {
"eatgv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_TGV,
sizeof(TgvContext),
tgv_decode_init,
AVCodec eatqi_decoder = {
"eatqi",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_TQI,
sizeof(TqiContext),
tqi_decode_init,
AVCodec escape124_decoder = {
"escape124",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_ESCAPE124,
sizeof(Escape124Context),
escape124_decode_init,
AVCodec ffv1_decoder = {
"ffv1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFV1,
sizeof(FFV1Context),
decode_init,
#if CONFIG_FFV1_ENCODER
AVCodec ffv1_encoder = {
"ffv1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFV1,
sizeof(FFV1Context),
encode_init,
AVCodec flac_decoder = {
"flac",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_FLAC,
sizeof(FLACContext),
flac_decode_init,
AVCodec flac_encoder = {
"flac",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_FLAC,
sizeof(FlacEncodeContext),
flac_encode_init,
AVCodec flashsv_decoder = {
"flashsv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLASHSV,
sizeof(FlashSVContext),
flashsv_decode_init,
AVCodec flashsv_encoder = {
"flashsv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLASHSV,
sizeof(FlashSVContext),
flashsv_encode_init,
AVCodec flic_decoder = {
"flic",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLIC,
sizeof(FlicDecodeContext),
flic_decode_init,
AVCodec flv_decoder = {
"flv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLV1,
sizeof(MpegEncContext),
ff_h263_decode_init,
AVCodec flv_encoder = {
"flv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLV1,
sizeof(MpegEncContext),
MPV_encode_init,
AVCodec fraps_decoder = {
"fraps",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_FRAPS,
sizeof(FrapsContext),
decode_init,
AVCodec frwu_decoder = {
"FRWU",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_FRWU,
0,
decode_init,
#if CONFIG_ADPCM_G726_ENCODER
AVCodec adpcm_g726_encoder = {
"g726",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_G726,
sizeof(G726Context),
g726_init,
AVCodec adpcm_g726_decoder = {
"g726",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_G726,
sizeof(G726Context),
g726_init,
AVCodec g729_decoder =
{
"g729",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_G729,
sizeof(G729Context),
decoder_init,
AVCodec gif_encoder = {
"gif",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_GIF,
sizeof(GIFContext),
gif_encode_init,
AVCodec gif_decoder = {
"gif",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_GIF,
sizeof(GifState),
gif_decode_init,
AVCodec h261_decoder = {
"h261",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_H261,
sizeof(H261Context),
h261_decode_init,
AVCodec h261_encoder = {
"h261",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_H261,
sizeof(H261Context),
MPV_encode_init,
AVCodec h263_decoder = {
"h263",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263,
sizeof(MpegEncContext),
ff_h263_decode_init,
AVCodec h264_decoder = {
"h264",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_H264,
sizeof(H264Context),
ff_h264_decode_init,
#if CONFIG_H264_VDPAU_DECODER
AVCodec h264_vdpau_decoder = {
"h264_vdpau",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_H264,
sizeof(H264Context),
ff_h264_decode_init,
#if CONFIG_HUFFYUV_DECODER
AVCodec huffyuv_decoder = {
"huffyuv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_HUFFYUV,
sizeof(HYuvContext),
decode_init,
#if CONFIG_FFVHUFF_DECODER
AVCodec ffvhuff_decoder = {
"ffvhuff",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFVHUFF,
sizeof(HYuvContext),
decode_init,
#if CONFIG_HUFFYUV_ENCODER
AVCodec huffyuv_encoder = {
"huffyuv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_HUFFYUV,
sizeof(HYuvContext),
encode_init,
#if CONFIG_FFVHUFF_ENCODER
AVCodec ffvhuff_encoder = {
"ffvhuff",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFVHUFF,
sizeof(HYuvContext),
encode_init,
AVCodec idcin_decoder = {
"idcinvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_IDCIN,
sizeof(IdcinContext),
idcin_decode_init,
AVCodec iff_ilbm_decoder = {
"iff_ilbm",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_IFF_ILBM,
sizeof(IffContext),
decode_init,
AVCodec iff_byterun1_decoder = {
"iff_byterun1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_IFF_BYTERUN1,
sizeof(IffContext),
decode_init,
AVCodec imc_decoder = {
.name = "imc",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_IMC,
.priv_data_size = sizeof(IMCContext),
.init = imc_decode_init,
AVCodec indeo2_decoder = {
"indeo2",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_INDEO2,
sizeof(Ir2Context),
ir2_decode_init,
AVCodec indeo3_decoder = {
"indeo3",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_INDEO3,
sizeof(Indeo3DecodeContext),
indeo3_decode_init,
AVCodec indeo5_decoder = {
.name = "indeo5",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_INDEO5,
.priv_data_size = sizeof(IVI5DecContext),
.init = decode_init,
AVCodec h263i_decoder = {
"h263i",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263I,
sizeof(MpegEncContext),
ff_h263_decode_init,
AVCodec interplay_video_decoder = {
"interplayvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_INTERPLAY_VIDEO,
sizeof(IpvideoContext),
ipvideo_decode_init,
AVCodec jpegls_decoder = {
"jpegls",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_JPEGLS,
sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init,
AVCodec jpegls_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
"jpegls",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_JPEGLS,
sizeof(JpeglsContext),
encode_init_ls,
AVCodec kgv1_decoder = {
"kgv1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_KGV1,
sizeof(KgvContext),
decode_init,
AVCodec kmvc_decoder = {
"kmvc",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_KMVC,
sizeof(KmvcContext),
decode_init,
#if CONFIG_MSZH_DECODER
AVCodec mszh_decoder = {
"mszh",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSZH,
sizeof(LclDecContext),
decode_init,
#if CONFIG_ZLIB_DECODER
AVCodec zlib_decoder = {
"zlib",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_ZLIB,
sizeof(LclDecContext),
decode_init,
AVCodec zlib_encoder = {
"zlib",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_ZLIB,
sizeof(LclEncContext),
encode_init,
AVCodec libdirac_decoder = {
"libdirac",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
sizeof(FfmpegDiracDecoderParams),
libdirac_decode_init,
AVCodec libdirac_encoder = {
"libdirac",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
sizeof(FfmpegDiracEncoderParams),
libdirac_encode_init,
AVCodec libfaac_encoder = {
"libfaac",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
sizeof(FaacAudioContext),
Faac_encode_init,
AVCodec libfaad_decoder = {
"libfaad",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
sizeof(FAACContext),
faac_decode_init,
AVCodec libgsm_encoder = {
"libgsm",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM,
0,
libgsm_init,
AVCodec libgsm_ms_encoder = {
"libgsm_ms",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM_MS,
0,
libgsm_init,
AVCodec libgsm_decoder = {
"libgsm",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM,
0,
libgsm_init,
AVCodec libgsm_ms_decoder = {
"libgsm_ms",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM_MS,
0,
libgsm_init,
AVCodec libmp3lame_encoder = {
"libmp3lame",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP3,
sizeof(Mp3AudioContext),
MP3lame_encode_init,
AVCodec libopencore_amrnb_decoder = {
"libopencore_amrnb",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_NB,
sizeof(AMRContext),
amr_nb_decode_init,
AVCodec libopencore_amrnb_encoder = {
"libopencore_amrnb",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_NB,
sizeof(AMRContext),
amr_nb_encode_init,
AVCodec libopencore_amrwb_decoder = {
"libopencore_amrwb",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_WB,
sizeof(AMRWBContext),
amr_wb_decode_init,
AVCodec libopenjpeg_decoder = {
"libopenjpeg",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_JPEG2000,
sizeof(LibOpenJPEGContext),
libopenjpeg_decode_init,
AVCodec libschroedinger_decoder = {
"libschroedinger",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
sizeof(FfmpegSchroDecoderParams),
libschroedinger_decode_init,
AVCodec libschroedinger_encoder = {
"libschroedinger",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
sizeof(FfmpegSchroEncoderParams),
libschroedinger_encode_init,
AVCodec libspeex_decoder = {
"libspeex",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_SPEEX,
sizeof(LibSpeexContext),
libspeex_decode_init,
/*! AVCodec struct exposed to libavcodec */
AVCodec libtheora_encoder = {
.name = "libtheora",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_THEORA,
.priv_data_size = sizeof(TheoraContext),
.init = encode_init,
AVCodec libvorbis_encoder = {
"libvorbis",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_VORBIS,
sizeof(OggVorbisContext),
oggvorbis_encode_init,
AVCodec libx264_encoder = {
.name = "libx264",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H264,
.priv_data_size = sizeof(X264Context),
.init = X264_init,
*/
AVCodec libxvid_encoder = {
"libxvid",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG4,
sizeof(struct xvid_context),
xvid_encode_init,
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
"ljpeg",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_LJPEG,
sizeof(MpegEncContext),
MPV_encode_init,
AVCodec loco_decoder = {
"loco",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_LOCO,
sizeof(LOCOContext),
decode_init,
AVCodec mace3_decoder = {
"mace3",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MACE3,
sizeof(MACEContext),
mace_decode_init,
AVCodec mace6_decoder = {
"mace6",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MACE6,
sizeof(MACEContext),
mace_decode_init,
AVCodec mdec_decoder = {
"mdec",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MDEC,
sizeof(MDECContext),
decode_init,
AVCodec mimic_decoder = {
"mimic",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MIMIC,
sizeof(MimicContext),
mimic_decode_init,
AVCodec mjpegb_decoder = {
"mjpegb",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEGB,
sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init,
AVCodec mjpeg_decoder = {
"mjpeg",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEG,
sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init,
AVCodec thp_decoder = {
"thp",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_THP,
sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init,
AVCodec mjpeg_encoder = {
"mjpeg",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEG,
sizeof(MpegEncContext),
MPV_encode_init,
AVCodec mlp_decoder = {
"mlp",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MLP,
sizeof(MLPDecodeContext),
mlp_decode_init,
#if CONFIG_TRUEHD_DECODER
AVCodec truehd_decoder = {
"truehd",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_TRUEHD,
sizeof(MLPDecodeContext),
mlp_decode_init,
AVCodec mmvideo_decoder = {
"mmvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MMVIDEO,
sizeof(MmContext),
mm_decode_init,
AVCodec motionpixels_decoder = {
"motionpixels",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MOTIONPIXELS,
sizeof(MotionPixelsContext),
mp_decode_init,
AVCodec mpc7_decoder = {
"mpc7",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MUSEPACK7,
sizeof(MPCContext),
mpc7_decode_init,
AVCodec mpc8_decoder = {
"mpc8",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MUSEPACK8,
sizeof(MPCContext),
mpc8_decode_init,
AVCodec mpeg1video_decoder = {
"mpeg1video",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG1VIDEO,
sizeof(Mpeg1Context),
mpeg_decode_init,
AVCodec mpeg2video_decoder = {
"mpeg2video",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG2VIDEO,
sizeof(Mpeg1Context),
mpeg_decode_init,
//legacy decoder
AVCodec mpegvideo_decoder = {
"mpegvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG2VIDEO,
sizeof(Mpeg1Context),
mpeg_decode_init,
AVCodec mpeg_xvmc_decoder = {
"mpegvideo_xvmc",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG2VIDEO_XVMC,
sizeof(Mpeg1Context),
mpeg_mc_decode_init,
#if CONFIG_MPEG_VDPAU_DECODER
AVCodec mpeg_vdpau_decoder = {
"mpegvideo_vdpau",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG2VIDEO,
sizeof(Mpeg1Context),
mpeg_decode_init,
#if CONFIG_MPEG1_VDPAU_DECODER
AVCodec mpeg1_vdpau_decoder = {
"mpeg1video_vdpau",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG1VIDEO,
sizeof(Mpeg1Context),
mpeg_decode_init,
AVCodec mpeg1video_encoder = {
"mpeg1video",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG1VIDEO,
sizeof(MpegEncContext),
encode_init,
AVCodec mpeg2video_encoder = {
"mpeg2video",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG2VIDEO,
sizeof(MpegEncContext),
encode_init,
AVCodec mpeg4_decoder = {
"mpeg4",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG4,
sizeof(MpegEncContext),
decode_init,
#if CONFIG_MPEG4_VDPAU_DECODER
AVCodec mpeg4_vdpau_decoder = {
"mpeg4_vdpau",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG4,
sizeof(MpegEncContext),
decode_init,
AVCodec mpeg4_encoder = {
"mpeg4",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG4,
sizeof(MpegEncContext),
encode_init,
AVCodec mp1_decoder =
{
"mp1",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP1,
sizeof(MPADecodeContext),
decode_init,
AVCodec mp2_decoder =
{
"mp2",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP2,
sizeof(MPADecodeContext),
decode_init,
AVCodec mp3_decoder =
{
"mp3",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP3,
sizeof(MPADecodeContext),
decode_init,
AVCodec mp3adu_decoder =
{
"mp3adu",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP3ADU,
sizeof(MPADecodeContext),
decode_init,
AVCodec mp3on4_decoder =
{
"mp3on4",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP3ON4,
sizeof(MP3On4DecodeContext),
decode_init_mp3on4,
AVCodec mp2_encoder = {
"mp2",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP2,
sizeof(MpegAudioContext),
MPA_encode_init,
AVCodec h263_encoder = {
"h263",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263,
sizeof(MpegEncContext),
MPV_encode_init,
AVCodec h263p_encoder = {
"h263p",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263P,
sizeof(MpegEncContext),
MPV_encode_init,
AVCodec msmpeg4v1_encoder = {
"msmpeg4v1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V1,
sizeof(MpegEncContext),
MPV_encode_init,
AVCodec msmpeg4v2_encoder = {
"msmpeg4v2",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V2,
sizeof(MpegEncContext),
MPV_encode_init,
AVCodec msmpeg4v3_encoder = {
"msmpeg4",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V3,
sizeof(MpegEncContext),
MPV_encode_init,
AVCodec wmv1_encoder = {
"wmv1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_WMV1,
sizeof(MpegEncContext),
MPV_encode_init,
AVCodec msmpeg4v1_decoder = {
"msmpeg4v1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V1,
sizeof(MpegEncContext),
ff_msmpeg4_decode_init,
AVCodec msmpeg4v2_decoder = {
"msmpeg4v2",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V2,
sizeof(MpegEncContext),
ff_msmpeg4_decode_init,
AVCodec msmpeg4v3_decoder = {
"msmpeg4",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V3,
sizeof(MpegEncContext),
ff_msmpeg4_decode_init,
AVCodec wmv1_decoder = {
"wmv1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_WMV1,
sizeof(MpegEncContext),
ff_msmpeg4_decode_init,
AVCodec msrle_decoder = {
"msrle",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSRLE,
sizeof(MsrleContext),
msrle_decode_init,
AVCodec msvideo1_decoder = {
"msvideo1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSVIDEO1,
sizeof(Msvideo1Context),
msvideo1_decode_init,
AVCodec nellymoser_decoder = {
"nellymoser",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_NELLYMOSER,
sizeof(NellyMoserDecodeContext),
decode_init,
AVCodec nellymoser_encoder = {
.name = "nellymoser",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_NELLYMOSER,
.priv_data_size = sizeof(NellyMoserEncodeContext),
.init = encode_init,
AVCodec nuv_decoder = {
"nuv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_NUV,
sizeof(NuvContext),
decode_init,
static const AVClass av_codec_context_class = { "AVCodecContext", context_to_name, options };
-void avcodec_get_context_defaults2(AVCodecContext *s, enum CodecType codec_type){
+void avcodec_get_context_defaults2(AVCodecContext *s, enum AVMediaType codec_type){
int flags=0;
memset(s, 0, sizeof(AVCodecContext));
s->av_class= &av_codec_context_class;
s->codec_type = codec_type;
- if(codec_type == CODEC_TYPE_AUDIO)
+ if(codec_type == AVMEDIA_TYPE_AUDIO)
flags= AV_OPT_FLAG_AUDIO_PARAM;
- else if(codec_type == CODEC_TYPE_VIDEO)
+ else if(codec_type == AVMEDIA_TYPE_VIDEO)
flags= AV_OPT_FLAG_VIDEO_PARAM;
- else if(codec_type == CODEC_TYPE_SUBTITLE)
+ else if(codec_type == AVMEDIA_TYPE_SUBTITLE)
flags= AV_OPT_FLAG_SUBTITLE_PARAM;
av_opt_set_defaults2(s, flags, flags);
s->reordered_opaque= AV_NOPTS_VALUE;
}
-AVCodecContext *avcodec_alloc_context2(enum CodecType codec_type){
+AVCodecContext *avcodec_alloc_context2(enum AVMediaType codec_type){
AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext));
if(avctx==NULL) return NULL;
}
void avcodec_get_context_defaults(AVCodecContext *s){
- avcodec_get_context_defaults2(s, CODEC_TYPE_UNKNOWN);
+ avcodec_get_context_defaults2(s, AVMEDIA_TYPE_UNKNOWN);
}
AVCodecContext *avcodec_alloc_context(void){
- return avcodec_alloc_context2(CODEC_TYPE_UNKNOWN);
+ return avcodec_alloc_context2(AVMEDIA_TYPE_UNKNOWN);
}
AVCodec pam_encoder = {
"pam",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PAM,
sizeof(PNMContext),
ff_pnm_init,
AVCodec pcm_bluray_decoder = {
"pcm_bluray",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_PCM_BLURAY,
0,
NULL,
#define PCM_ENCODER(id,sample_fmt_,name,long_name_) \
AVCodec name ## _encoder = { \
#name, \
- CODEC_TYPE_AUDIO, \
+ AVMEDIA_TYPE_AUDIO, \
id, \
0, \
pcm_encode_init, \
#define PCM_DECODER(id,sample_fmt_,name,long_name_) \
AVCodec name ## _decoder = { \
#name, \
- CODEC_TYPE_AUDIO, \
+ AVMEDIA_TYPE_AUDIO, \
id, \
sizeof(PCMDecode), \
pcm_decode_init, \
AVCodec pcx_decoder = {
"pcx",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PCX,
sizeof(PCXContext),
pcx_init,
AVCodec pcx_encoder = {
"pcx",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PCX,
sizeof(PCXContext),
pcx_encode_init,
AVCodec pgssub_decoder = {
"pgssub",
- CODEC_TYPE_SUBTITLE,
+ AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_HDMV_PGS_SUBTITLE,
sizeof(PGSSubContext),
init_decoder,
AVCodec png_decoder = {
"png",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PNG,
sizeof(PNGDecContext),
png_dec_init,
AVCodec png_encoder = {
"png",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PNG,
sizeof(PNGEncContext),
png_enc_init,
#if CONFIG_PGM_DECODER
AVCodec pgm_decoder = {
"pgm",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PGM,
sizeof(PNMContext),
ff_pnm_init,
#if CONFIG_PGMYUV_DECODER
AVCodec pgmyuv_decoder = {
"pgmyuv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PGMYUV,
sizeof(PNMContext),
ff_pnm_init,
#if CONFIG_PPM_DECODER
AVCodec ppm_decoder = {
"ppm",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PPM,
sizeof(PNMContext),
ff_pnm_init,
#if CONFIG_PBM_DECODER
AVCodec pbm_decoder = {
"pbm",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PBM,
sizeof(PNMContext),
ff_pnm_init,
#if CONFIG_PAM_DECODER
AVCodec pam_decoder = {
"pam",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PAM,
sizeof(PNMContext),
ff_pnm_init,
#if CONFIG_PGM_ENCODER
AVCodec pgm_encoder = {
"pgm",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PGM,
sizeof(PNMContext),
ff_pnm_init,
#if CONFIG_PGMYUV_ENCODER
AVCodec pgmyuv_encoder = {
"pgmyuv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PGMYUV,
sizeof(PNMContext),
ff_pnm_init,
#if CONFIG_PPM_ENCODER
AVCodec ppm_encoder = {
"ppm",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PPM,
sizeof(PNMContext),
ff_pnm_init,
#if CONFIG_PBM_ENCODER
AVCodec pbm_encoder = {
"pbm",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PBM,
sizeof(PNMContext),
ff_pnm_init,
AVCodec ptx_decoder = {
"ptx",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_PTX,
sizeof(PTXContext),
ptx_init,
AVCodec qcelp_decoder =
{
.name = "qcelp",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_QCELP,
.init = qcelp_decode_init,
.decode = qcelp_decode_frame,
AVCodec qdm2_decoder =
{
.name = "qdm2",
- .type = CODEC_TYPE_AUDIO,
+ .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_QDM2,
.priv_data_size = sizeof(QDM2Context),
.init = qdm2_decode_init,
AVCodec qdraw_decoder = {
"qdraw",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_QDRAW,
sizeof(QdrawContext),
decode_init,
AVCodec qpeg_decoder = {
"qpeg",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_QPEG,
sizeof(QpegContext),
decode_init,
AVCodec qtrle_decoder = {
"qtrle",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_QTRLE,
sizeof(QtrleContext),
qtrle_decode_init,
AVCodec qtrle_encoder = {
"qtrle",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_QTRLE,
sizeof(QtrleEncContext),
qtrle_encode_init,
AVCodec r210_decoder = {
"r210",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_R210,
0,
decode_init,
AVCodec ra_144_decoder =
{
"real_144",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_RA_144,
sizeof(RA144Context),
ra144_decode_init,
AVCodec ra_288_decoder =
{
"real_288",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_RA_288,
sizeof(RA288Context),
ra288_decode_init,
AVCodec rawvideo_decoder = {
"rawvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_RAWVIDEO,
sizeof(RawVideoContext),
raw_init_decoder,
AVCodec rawvideo_encoder = {
"rawvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_RAWVIDEO,
sizeof(AVFrame),
raw_init_encoder,
AVCodec rl2_decoder = {
"rl2",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_RL2,
sizeof(Rl2Context),
rl2_decode_init,
AVCodec roq_dpcm_encoder = {
"roq_dpcm",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_ROQ_DPCM,
sizeof(ROQDPCMContext),
roq_dpcm_encode_init,
AVCodec roq_decoder = {
"roqvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_ROQ,
sizeof(RoqContext),
roq_decode_init,
AVCodec roq_encoder =
{
"roqvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_ROQ,
sizeof(RoqContext),
roq_encode_init,
AVCodec rpza_decoder = {
"rpza",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_RPZA,
sizeof(RpzaContext),
rpza_decode_init,
AVCodec rv10_decoder = {
"rv10",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV10,
sizeof(MpegEncContext),
rv10_decode_init,
AVCodec rv20_decoder = {
"rv20",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV20,
sizeof(MpegEncContext),
rv10_decode_init,
AVCodec rv10_encoder = {
"rv10",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV10,
sizeof(MpegEncContext),
MPV_encode_init,
AVCodec rv20_encoder = {
"rv20",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV20,
sizeof(MpegEncContext),
MPV_encode_init,
AVCodec rv30_decoder = {
"rv30",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV30,
sizeof(RV34DecContext),
rv30_decode_init,
AVCodec rv40_decoder = {
"rv40",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV40,
sizeof(RV34DecContext),
rv40_decode_init,
AVCodec sgi_decoder = {
"sgi",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_SGI,
sizeof(SgiState),
sgi_init,
AVCodec sgi_encoder = {
"sgi",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_SGI,
sizeof(SgiContext),
encode_init,
AVCodec shorten_decoder = {
"shorten",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_SHORTEN,
sizeof(ShortenContext),
shorten_decode_init,
AVCodec sipr_decoder = {
"sipr",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_SIPR,
sizeof(SiprContext),
sipr_decoder_init,
AVCodec smacker_decoder = {
"smackvid",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_SMACKVIDEO,
sizeof(SmackVContext),
decode_init,
AVCodec smackaud_decoder = {
"smackaud",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_SMACKAUDIO,
0,
smka_decode_init,
AVCodec smc_decoder = {
"smc",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_SMC,
sizeof(SmcContext),
smc_decode_init,
AVCodec snow_decoder = {
"snow",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_SNOW,
sizeof(SnowContext),
decode_init,
AVCodec snow_encoder = {
"snow",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_SNOW,
sizeof(SnowContext),
encode_init,
AVCodec sonic_decoder = {
"sonic",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_SONIC,
sizeof(SonicContext),
sonic_decode_init,
#if CONFIG_SONIC_ENCODER
AVCodec sonic_encoder = {
"sonic",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_SONIC,
sizeof(SonicContext),
sonic_encode_init,
#if CONFIG_SONIC_LS_ENCODER
AVCodec sonic_ls_encoder = {
"sonicls",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_SONIC_LS,
sizeof(SonicContext),
sonic_encode_init,
AVCodec sp5x_decoder = {
"sp5x",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_SP5X,
sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init,
AVCodec amv_decoder = {
"amv",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_AMV,
sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init,
AVCodec sunrast_decoder = {
"sunrast",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_SUNRAST,
sizeof(SUNRASTContext),
sunrast_init,
AVCodec svq1_decoder = {
"svq1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_SVQ1,
sizeof(MpegEncContext),
svq1_decode_init,
AVCodec svq1_encoder = {
"svq1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_SVQ1,
sizeof(SVQ1Context),
svq1_encode_init,
AVCodec svq3_decoder = {
"svq3",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_SVQ3,
sizeof(H264Context),
svq3_decode_init,
AVCodec targa_decoder = {
"targa",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_TARGA,
sizeof(TargaContext),
targa_init,
AVCodec targa_encoder = {
.name = "targa",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_TARGA,
.priv_data_size = sizeof(TargaContext),
.init = targa_encode_init,
AVCodec tiertexseqvideo_decoder = {
"tiertexseqvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_TIERTEXSEQVIDEO,
sizeof(SeqVideoContext),
seqvideo_decode_init,
AVCodec tiff_decoder = {
"tiff",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_TIFF,
sizeof(TiffContext),
tiff_init,
AVCodec tiff_encoder = {
"tiff",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_TIFF,
sizeof(TiffEncoderContext),
NULL,
AVCodec tmv_decoder = {
.name = "tmv",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_TMV,
.priv_data_size = sizeof(TMVContext),
.close = tmv_decode_close,
AVCodec truemotion1_decoder = {
"truemotion1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_TRUEMOTION1,
sizeof(TrueMotion1Context),
truemotion1_decode_init,
AVCodec truemotion2_decoder = {
"truemotion2",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_TRUEMOTION2,
sizeof(TM2Context),
decode_init,
AVCodec truespeech_decoder = {
"truespeech",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_TRUESPEECH,
sizeof(TSContext),
truespeech_decode_init,
AVCodec tscc_decoder = {
"camtasia",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_TSCC,
sizeof(CamtasiaContext),
decode_init,
AVCodec tta_decoder = {
"tta",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_TTA,
sizeof(TTAContext),
tta_decode_init,
AVCodec twinvq_decoder =
{
"twinvq",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_TWINVQ,
sizeof(TwinContext),
twin_decode_init,
AVCodec txd_decoder = {
"txd",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_TXD,
sizeof(TXDContext),
txd_init,
AVCodec ulti_decoder = {
"ultimotion",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_ULTI,
sizeof(UltimotionDecodeContext),
ulti_decode_init,
}
avctx->codec = codec;
- if ((avctx->codec_type == CODEC_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
+ if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
avctx->codec_id == CODEC_ID_NONE) {
avctx->codec_type = codec->type;
avctx->codec_id = codec->id;
int bits_per_sample;
switch(ctx->codec_type) {
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
bit_rate = ctx->bit_rate;
break;
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
bit_rate = bits_per_sample ? ctx->sample_rate * ctx->channels * bits_per_sample : ctx->bit_rate;
break;
- case CODEC_TYPE_DATA:
+ case AVMEDIA_TYPE_DATA:
bit_rate = ctx->bit_rate;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
bit_rate = ctx->bit_rate;
break;
- case CODEC_TYPE_ATTACHMENT:
+ case AVMEDIA_TYPE_ATTACHMENT:
bit_rate = ctx->bit_rate;
break;
default:
}
switch(enc->codec_type) {
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
snprintf(buf, buf_size,
"Video: %s%s",
codec_name, enc->mb_decision ? " (hq)" : "");
", q=%d-%d", enc->qmin, enc->qmax);
}
break;
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
snprintf(buf, buf_size,
"Audio: %s",
codec_name);
", %s", avcodec_get_sample_fmt_name(enc->sample_fmt));
}
break;
- case CODEC_TYPE_DATA:
+ case AVMEDIA_TYPE_DATA:
snprintf(buf, buf_size, "Data: %s", codec_name);
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
snprintf(buf, buf_size, "Subtitle: %s", codec_name);
break;
- case CODEC_TYPE_ATTACHMENT:
+ case AVMEDIA_TYPE_ATTACHMENT:
snprintf(buf, buf_size, "Attachment: %s", codec_name);
break;
default:
AVCodec v210_decoder = {
"v210",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_V210,
0,
decode_init,
AVCodec v210_encoder = {
"v210",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_V210,
0,
encode_init,
AVCodec v210x_decoder = {
"v210x",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_V210X,
0,
decode_init,
AVHWAccel h264_vaapi_hwaccel = {
.name = "h264_vaapi",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H264,
.pix_fmt = PIX_FMT_VAAPI_VLD,
.capabilities = 0,
AVHWAccel mpeg2_vaapi_hwaccel = {
.name = "mpeg2_vaapi",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MPEG2VIDEO,
.pix_fmt = PIX_FMT_VAAPI_VLD,
.capabilities = 0,
#if CONFIG_MPEG4_VAAPI_HWACCEL
AVHWAccel mpeg4_vaapi_hwaccel = {
.name = "mpeg4_vaapi",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MPEG4,
.pix_fmt = PIX_FMT_VAAPI_VLD,
.capabilities = 0,
#if CONFIG_H263_VAAPI_HWACCEL
AVHWAccel h263_vaapi_hwaccel = {
.name = "h263_vaapi",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H263,
.pix_fmt = PIX_FMT_VAAPI_VLD,
.capabilities = 0,
#if CONFIG_WMV3_VAAPI_HWACCEL
AVHWAccel wmv3_vaapi_hwaccel = {
.name = "wmv3_vaapi",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_WMV3,
.pix_fmt = PIX_FMT_VAAPI_VLD,
.capabilities = 0,
AVHWAccel vc1_vaapi_hwaccel = {
.name = "vc1_vaapi",
- .type = CODEC_TYPE_VIDEO,
+ .type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_VC1,
.pix_fmt = PIX_FMT_VAAPI_VLD,
.capabilities = 0,
AVCodec vb_decoder = {
"vb",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VB,
sizeof(VBDecContext),
decode_init,
AVCodec vc1_decoder = {
"vc1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VC1,
sizeof(VC1Context),
vc1_decode_init,
#if CONFIG_WMV3_DECODER
AVCodec wmv3_decoder = {
"wmv3",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_WMV3,
sizeof(VC1Context),
vc1_decode_init,
#if CONFIG_WMV3_VDPAU_DECODER
AVCodec wmv3_vdpau_decoder = {
"wmv3_vdpau",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_WMV3,
sizeof(VC1Context),
vc1_decode_init,
#if CONFIG_VC1_VDPAU_DECODER
AVCodec vc1_vdpau_decoder = {
"vc1_vdpau",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VC1,
sizeof(VC1Context),
vc1_decode_init,
AVCodec vcr1_decoder = {
"vcr1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VCR1,
sizeof(VCR1Context),
decode_init,
#if CONFIG_VCR1_ENCODER
AVCodec vcr1_encoder = {
"vcr1",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VCR1,
sizeof(VCR1Context),
encode_init,
AVCodec vmdvideo_decoder = {
"vmdvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VMDVIDEO,
sizeof(VmdVideoContext),
vmdvideo_decode_init,
AVCodec vmdaudio_decoder = {
"vmdaudio",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_VMDAUDIO,
sizeof(VmdAudioContext),
vmdaudio_decode_init,
AVCodec vmnc_decoder = {
"vmnc",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VMNC,
sizeof(VmncContext),
decode_init,
AVCodec vorbis_decoder = {
"vorbis",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_VORBIS,
sizeof(vorbis_context),
vorbis_decode_init,
AVCodec vorbis_encoder = {
"vorbis",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_VORBIS,
sizeof(vorbis_enc_context),
vorbis_encode_init,
AVCodec theora_decoder = {
"theora",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_THEORA,
sizeof(Vp3DecodeContext),
theora_decode_init,
AVCodec vp3_decoder = {
"vp3",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP3,
sizeof(Vp3DecodeContext),
vp3_decode_init,
AVCodec vp5_decoder = {
"vp5",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP5,
sizeof(VP56Context),
vp5_decode_init,
AVCodec vp6_decoder = {
"vp6",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP6,
sizeof(VP56Context),
vp6_decode_init,
/* flash version, not flipped upside-down */
AVCodec vp6f_decoder = {
"vp6f",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP6F,
sizeof(VP56Context),
vp6_decode_init,
/* flash version, not flipped upside-down, with alpha channel */
AVCodec vp6a_decoder = {
"vp6a",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP6A,
sizeof(VP56Context),
vp6_decode_init,
AVCodec vqa_decoder = {
"vqavideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_WS_VQA,
sizeof(VqaContext),
vqa_decode_init,
AVCodec wavpack_decoder = {
"wavpack",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_WAVPACK,
sizeof(WavpackContext),
wavpack_decode_init,
AVCodec wmav1_decoder =
{
"wmav1",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_WMAV1,
sizeof(WMACodecContext),
wma_decode_init,
AVCodec wmav2_decoder =
{
"wmav2",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_WMAV2,
sizeof(WMACodecContext),
wma_decode_init,
AVCodec wmav1_encoder =
{
"wmav1",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_WMAV1,
sizeof(WMACodecContext),
encode_init,
AVCodec wmav2_encoder =
{
"wmav2",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_WMAV2,
sizeof(WMACodecContext),
encode_init,
*/
AVCodec wmapro_decoder = {
"wmapro",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_WMAPRO,
sizeof(WMAProDecodeCtx),
decode_init,
AVCodec wmavoice_decoder = {
"wmavoice",
- CODEC_TYPE_AUDIO,
+ AVMEDIA_TYPE_AUDIO,
CODEC_ID_WMAVOICE,
sizeof(WMAVoiceContext),
wmavoice_decode_init,