diff --git a/cmdutils.c b/cmdutils.c
index 1ffe2e8f940893cc2673a921a007551a9a95dd16..7964befd4ce2e25e6950adf610d2dd90f1f66b07 100644
--- a/cmdutils.c
+++ b/cmdutils.c
@@ -48,7 +48,7 @@
 
 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;
 
@@ -191,7 +191,7 @@ int opt_default(const char *opt, const char *arg){
     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);
@@ -202,11 +202,11 @@ int opt_default(const char *opt, const char *arg){
         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);
@@ -535,13 +535,13 @@ void show_codecs(void)
         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:
diff --git a/cmdutils.h b/cmdutils.h
index 9190a81fd95460cf913f4675e6a3d2dcc2f3df03..549ade8767a97634f8ae2e4321f45ae28ca25d10 100644
--- a/cmdutils.h
+++ b/cmdutils.h
@@ -40,7 +40,7 @@ extern const int program_birth_year;
 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;
 
diff --git a/ffmpeg.c b/ffmpeg.c
index 30a80505cdbdf96535fa59dd3485e1c90a255ea5..c053a239555b86fdab675304cf03c3845d2df851 100644
--- a/ffmpeg.c
+++ b/ffmpeg.c
@@ -452,7 +452,7 @@ static int av_exit(int ret)
     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);
@@ -527,9 +527,9 @@ static int read_ffserver_streams(AVFormatContext *s, const char *filename)
         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)
@@ -967,7 +967,7 @@ static void do_video_out(AVFormatContext *s,
     }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;
 
@@ -1088,7 +1088,7 @@ static void do_video_out(AVFormatContext *s,
             /* 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
@@ -1163,7 +1163,7 @@ static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
     }
 
     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)
@@ -1223,12 +1223,12 @@ static void print_report(AVFormatContext **output_files,
     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;
@@ -1360,7 +1360,7 @@ static int output_packet(AVInputStream *ist, int ist_index,
         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);
@@ -1386,7 +1386,7 @@ static int output_packet(AVInputStream *ist, int ist_index,
                 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);
@@ -1408,7 +1408,7 @@ static int output_packet(AVInputStream *ist, int ist_index,
                     }
                     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)
@@ -1424,11 +1424,11 @@ static int output_packet(AVInputStream *ist, int ist_index,
             }
         } 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 *
@@ -1442,13 +1442,13 @@ static int output_packet(AVInputStream *ist, int ist_index,
         }
 
         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;
@@ -1485,15 +1485,15 @@ static int output_packet(AVInputStream *ist, int ist_index,
                     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;
@@ -1517,9 +1517,9 @@ static int output_packet(AVInputStream *ist, int ist_index,
                         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++;
                         }
@@ -1583,9 +1583,9 @@ static int output_packet(AVInputStream *ist, int ist_index,
                 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) {
@@ -1596,7 +1596,7 @@ static int output_packet(AVInputStream *ist, int ist_index,
                         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 */
@@ -1629,7 +1629,7 @@ static int output_packet(AVInputStream *ist, int ist_index,
                             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");
@@ -1946,7 +1946,7 @@ static int av_encode(AVFormatContext **output_files,
             }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);
@@ -1961,13 +1961,13 @@ static int av_encode(AVFormatContext **output_files,
                 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;
@@ -1976,7 +1976,7 @@ static int av_encode(AVFormatContext **output_files,
             }
         } else {
             switch(codec->codec_type) {
-            case CODEC_TYPE_AUDIO:
+            case AVMEDIA_TYPE_AUDIO:
                 ost->fifo= av_fifo_alloc(1024);
                 if(!ost->fifo)
                     goto fail;
@@ -1986,7 +1986,7 @@ static int av_encode(AVFormatContext **output_files,
                 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);
@@ -2050,7 +2050,7 @@ static int av_encode(AVFormatContext **output_files,
                 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;
@@ -2098,7 +2098,7 @@ static int av_encode(AVFormatContext **output_files,
                 }
             }
         }
-        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);
         }
@@ -2155,7 +2155,7 @@ static int av_encode(AVFormatContext **output_files,
                 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;
         }
     }
@@ -2528,7 +2528,7 @@ static int opt_frame_rate(const char *opt, const char *arg)
 
 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);
 
@@ -2781,7 +2781,7 @@ static void opt_codec(int *pstream_copy, char **pcodec_name,
 
 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)
@@ -2804,12 +2804,12 @@ static void opt_video_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)
@@ -2965,9 +2965,9 @@ static void opt_input_file(const char *filename)
 
     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)
@@ -3035,8 +3035,8 @@ static void opt_input_file(const char *filename)
         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;
@@ -3046,8 +3046,8 @@ static void opt_input_file(const char *filename)
             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)
@@ -3084,15 +3084,15 @@ static void opt_input_file(const char *filename)
             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:
@@ -3129,18 +3129,18 @@ static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
         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();
@@ -3163,7 +3163,7 @@ static void new_video_stream(AVFormatContext *oc)
         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;
 
@@ -3177,16 +3177,16 @@ static void new_video_stream(AVFormatContext *oc)
     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 {
@@ -3196,17 +3196,17 @@ static void new_video_stream(AVFormatContext *oc)
         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)];
@@ -3300,7 +3300,7 @@ static void new_audio_stream(AVFormatContext *oc)
         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;
@@ -3308,14 +3308,14 @@ static void new_audio_stream(AVFormatContext *oc)
     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;
@@ -3323,14 +3323,14 @@ static void new_audio_stream(AVFormatContext *oc)
     } 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;
@@ -3370,13 +3370,13 @@ static void new_subtitle_stream(AVFormatContext *oc)
         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;
@@ -3384,8 +3384,8 @@ static void new_subtitle_stream(AVFormatContext *oc)
     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++;
@@ -3739,7 +3739,7 @@ static void opt_target(const char *arg)
                 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) {
@@ -3965,7 +3965,7 @@ static const OptionDef options[] = {
     { "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" },
@@ -3993,7 +3993,7 @@ static const OptionDef options[] = {
     /* 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" },
@@ -4035,7 +4035,7 @@ static const OptionDef options[] = {
 
     /* 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" },
@@ -4090,7 +4090,7 @@ int main(int argc, char **argv)
         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();
diff --git a/ffplay.c b/ffplay.c
index 03da89658212b4b316064ed15426994e49b606d2..f3a076b98ff4bbd4b1294b2aa4cee674559a15c5 100644
--- a/ffplay.c
+++ b/ffplay.c
@@ -234,10 +234,10 @@ static int frame_height = 0;
 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;
@@ -1643,7 +1643,7 @@ static AVFilter input_filter =
 
     .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 }},
@@ -1689,7 +1689,7 @@ static AVFilter output_filter =
     .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 }},
@@ -2122,7 +2122,7 @@ static int stream_component_open(VideoState *is, int stream_index)
     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 {
@@ -2152,7 +2152,7 @@ static int stream_component_open(VideoState *is, int stream_index)
         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;
@@ -2170,7 +2170,7 @@ static int stream_component_open(VideoState *is, int stream_index)
 
     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;
@@ -2187,7 +2187,7 @@ static int stream_component_open(VideoState *is, int stream_index)
         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];
 
@@ -2196,7 +2196,7 @@ static int stream_component_open(VideoState *is, int 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);
@@ -2219,7 +2219,7 @@ static void stream_component_close(VideoState *is, int stream_index)
     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();
@@ -2229,7 +2229,7 @@ static void stream_component_close(VideoState *is, int stream_index)
             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
@@ -2242,7 +2242,7 @@ static void stream_component_close(VideoState *is, int stream_index)
 
         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
@@ -2264,15 +2264,15 @@ static void stream_component_close(VideoState *is, int stream_index)
     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;
@@ -2296,9 +2296,9 @@ static int decode_thread(void *arg)
     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 = &params;
     int eof=0;
@@ -2366,7 +2366,7 @@ static int decode_thread(void *arg)
         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;
@@ -2376,12 +2376,12 @@ static int decode_thread(void *arg)
         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;
@@ -2394,13 +2394,13 @@ static int decode_thread(void *arg)
     }
 
     /* 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) {
@@ -2408,8 +2408,8 @@ static int decode_thread(void *arg)
             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) {
@@ -2612,19 +2612,19 @@ static void stream_cycle_channel(VideoState *is, int codec_type)
     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;
@@ -2637,13 +2637,13 @@ static void stream_cycle_channel(VideoState *is, int codec_type)
         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;
@@ -2690,7 +2690,7 @@ static void do_exit(void)
         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);
@@ -2743,15 +2743,15 @@ static void event_loop(void)
                 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();
@@ -2943,9 +2943,9 @@ static const OptionDef options[] = {
     { "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" },
@@ -3032,7 +3032,7 @@ int main(int argc, char **argv)
 #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();
diff --git a/ffprobe.c b/ffprobe.c
index 35bbe9fd5b135b78a869018abb3a6b20e82b0031..f0669a475d15eb316d271e108e684576b9ab08f5 100644
--- a/ffprobe.c
+++ b/ffprobe.c
@@ -101,14 +101,14 @@ static char *time_value_string(char *buf, int buf_size, int64_t val, const AVRat
     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";
     }
 }
@@ -134,7 +134,7 @@ static void show_stream(AVFormatContext *fmt_ctx, int stream_idx)
             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 */
@@ -150,7 +150,7 @@ static void show_stream(AVFormatContext *fmt_ctx, int stream_idx)
         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);
@@ -162,7 +162,7 @@ static void show_stream(AVFormatContext *fmt_ctx, int stream_idx)
                    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));
diff --git a/ffserver.c b/ffserver.c
index 37b9a8ee1dcaeb33877a8736a909512aa416aac5..076635fa04e7f0b2498ebc3c87ff7122b9e918cb 100644
--- a/ffserver.c
+++ b/ffserver.c
@@ -1805,7 +1805,7 @@ static void compute_status(HTTPContext *c)
                         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)
@@ -1813,7 +1813,7 @@ static void compute_status(HTTPContext *c)
                                 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)
@@ -1821,7 +1821,7 @@ static void compute_status(HTTPContext *c)
                                 video_codec_name = codec->name;
                             }
                             break;
-                        case CODEC_TYPE_DATA:
+                        case AVMEDIA_TYPE_DATA:
                             video_bit_rate += st->codec->bit_rate;
                             break;
                         default:
@@ -1894,11 +1894,11 @@ static void compute_status(HTTPContext *c)
                 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);
@@ -2047,7 +2047,7 @@ static int open_input_stream(HTTPContext *c, const char *info)
     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;
         }
     }
@@ -2210,7 +2210,7 @@ static int http_prepare_data(HTTPContext *c)
                             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)
@@ -3346,12 +3346,12 @@ static int add_av_stream(FFStream *feed, AVStream *st)
             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 &&
@@ -3549,7 +3549,7 @@ static void build_feed_streams(void)
                             } 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) ||
@@ -3557,7 +3557,7 @@ static void build_feed_streams(void)
                                     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)) {
@@ -3651,8 +3651,8 @@ static void compute_bandwidth(void)
         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:
@@ -3670,7 +3670,7 @@ static void add_codec(FFStream *stream, AVCodecContext *av)
 
     /* 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)
@@ -3678,7 +3678,7 @@ static void add_codec(FFStream *stream, AVCodecContext *av)
         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){
@@ -3742,7 +3742,7 @@ static enum CodecID opt_audio_codec(const char *arg)
 {
     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;
@@ -3752,7 +3752,7 @@ static enum CodecID opt_video_codec(const char *arg)
 {
     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;
@@ -4445,12 +4445,12 @@ static int parse_ffconfig(const char *filename)
             } 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);
                     }
diff --git a/libavcodec/4xm.c b/libavcodec/4xm.c
index 92ff9f6d7aed81609c6226ba3b3ca267b2ca6f87..ec25b9b7a94fdf46d503c600c79d9ff363881850 100644
--- a/libavcodec/4xm.c
+++ b/libavcodec/4xm.c
@@ -842,7 +842,7 @@ static av_cold int decode_end(AVCodecContext *avctx){
 
 AVCodec fourxm_decoder = {
     "4xm",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_4XM,
     sizeof(FourXContext),
     decode_init,
diff --git a/libavcodec/8bps.c b/libavcodec/8bps.c
index fb5ef7173266b6d141717518962691c62f1fff18..be5735f608bbc4ff58844b9a34d06013a3f629b1 100644
--- a/libavcodec/8bps.c
+++ b/libavcodec/8bps.c
@@ -221,7 +221,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec eightbps_decoder = {
         "8bps",
-        CODEC_TYPE_VIDEO,
+        AVMEDIA_TYPE_VIDEO,
         CODEC_ID_8BPS,
         sizeof(EightBpsContext),
         decode_init,
diff --git a/libavcodec/8svx.c b/libavcodec/8svx.c
index c139e5d40b3aa1e403230b6811c1bb0cbe7d4819..2afd57dce60ec6d539f922961affb254913c0ae4 100644
--- a/libavcodec/8svx.c
+++ b/libavcodec/8svx.c
@@ -94,7 +94,7 @@ static av_cold int eightsvx_decode_init(AVCodecContext *avctx)
 
 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,
@@ -104,7 +104,7 @@ AVCodec eightsvx_fib_decoder = {
 
 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,
diff --git a/libavcodec/aac.c b/libavcodec/aac.c
index 26555e9dea1c893aa4c77a509a7821a69e89bd48..c4636015a7ead4d7dbc9d3452857899af7073a57 100644
--- a/libavcodec/aac.c
+++ b/libavcodec/aac.c
@@ -2091,7 +2091,7 @@ static av_cold int aac_decode_close(AVCodecContext *avccontext)
 
 AVCodec aac_decoder = {
     "aac",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_AAC,
     sizeof(AACContext),
     aac_decode_init,
diff --git a/libavcodec/aacenc.c b/libavcodec/aacenc.c
index d32ae5e286b971131f9142e62ecc9ecafb1b77bb..eb32d1464cae05c3e962774196cefe0bd3b18841 100644
--- a/libavcodec/aacenc.c
+++ b/libavcodec/aacenc.c
@@ -629,7 +629,7 @@ static av_cold int aac_encode_end(AVCodecContext *avctx)
 
 AVCodec aac_encoder = {
     "aac",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_AAC,
     sizeof(AACEncContext),
     aac_encode_init,
diff --git a/libavcodec/aasc.c b/libavcodec/aasc.c
index 46f64f7e9e2f638827006354ad2064eaf585d31f..c5e8fd089403e862e29b77fd369987ac3c664ab0 100644
--- a/libavcodec/aasc.c
+++ b/libavcodec/aasc.c
@@ -111,7 +111,7 @@ static av_cold int aasc_decode_end(AVCodecContext *avctx)
 
 AVCodec aasc_decoder = {
     "aasc",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_AASC,
     sizeof(AascContext),
     aasc_decode_init,
diff --git a/libavcodec/ac3dec.c b/libavcodec/ac3dec.c
index 1656a4c540ba6737c79dc645ff13e498a95612dc..9b1aeeceaad282057f507b27a6f985c37f403d82 100644
--- a/libavcodec/ac3dec.c
+++ b/libavcodec/ac3dec.c
@@ -1439,7 +1439,7 @@ static av_cold int ac3_decode_end(AVCodecContext *avctx)
 
 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,
@@ -1451,7 +1451,7 @@ AVCodec ac3_decoder = {
 #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,
diff --git a/libavcodec/ac3enc.c b/libavcodec/ac3enc.c
index 6f8fe009af6d4934909737ffc9f7c96445cf07ce..9ff309e7bd72ef90da82a9250385fe2e6c812917 100644
--- a/libavcodec/ac3enc.c
+++ b/libavcodec/ac3enc.c
@@ -1393,7 +1393,7 @@ void test_ac3(void)
 
 AVCodec ac3_encoder = {
     "ac3",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_AC3,
     sizeof(AC3EncodeContext),
     AC3_encode_init,
diff --git a/libavcodec/adpcm.c b/libavcodec/adpcm.c
index 6abe18495cc5ff99c9b1788ec82676c9a2925ea4..e1234fc1c753691bc2e0b4922ae6c806a174e081 100644
--- a/libavcodec/adpcm.c
+++ b/libavcodec/adpcm.c
@@ -1638,7 +1638,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
 #define ADPCM_ENCODER(id,name,long_name_)       \
 AVCodec name ## _encoder = {                    \
     #name,                                      \
-    CODEC_TYPE_AUDIO,                           \
+    AVMEDIA_TYPE_AUDIO,                         \
     id,                                         \
     sizeof(ADPCMContext),                       \
     adpcm_encode_init,                          \
@@ -1656,7 +1656,7 @@ AVCodec name ## _encoder = {                    \
 #define ADPCM_DECODER(id,name,long_name_)       \
 AVCodec name ## _decoder = {                    \
     #name,                                      \
-    CODEC_TYPE_AUDIO,                           \
+    AVMEDIA_TYPE_AUDIO,                         \
     id,                                         \
     sizeof(ADPCMContext),                       \
     adpcm_decode_init,                          \
diff --git a/libavcodec/adxdec.c b/libavcodec/adxdec.c
index 94ee793cfa82d01a10229eba18691039923023bf..9828b1beff1dd0f4a529d745cda0b814d3c60d19 100644
--- a/libavcodec/adxdec.c
+++ b/libavcodec/adxdec.c
@@ -168,7 +168,7 @@ static int adx_decode_frame(AVCodecContext *avctx,
 
 AVCodec adpcm_adx_decoder = {
     "adpcm_adx",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_ADPCM_ADX,
     sizeof(ADXContext),
     adx_decode_init,
diff --git a/libavcodec/adxenc.c b/libavcodec/adxenc.c
index 04e9b789b5422a9f1c593da72a52501f5529d8d5..833dde8bd3b8a564d2779fdf852190dca4bd1d7e 100644
--- a/libavcodec/adxenc.c
+++ b/libavcodec/adxenc.c
@@ -185,7 +185,7 @@ static int adx_encode_frame(AVCodecContext *avctx,
 
 AVCodec adpcm_adx_encoder = {
     "adpcm_adx",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_ADPCM_ADX,
     sizeof(ADXContext),
     adx_encode_init,
diff --git a/libavcodec/alac.c b/libavcodec/alac.c
index 959bc6208a51a26278be078e1ef3cda2b0380d13..b896e32bb9904d35323ef3d65fa51064f10f2f3c 100644
--- a/libavcodec/alac.c
+++ b/libavcodec/alac.c
@@ -701,7 +701,7 @@ static av_cold int alac_decode_close(AVCodecContext *avctx)
 
 AVCodec alac_decoder = {
     "alac",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_ALAC,
     sizeof(ALACContext),
     alac_decode_init,
diff --git a/libavcodec/alacenc.c b/libavcodec/alacenc.c
index 70b3b0f2b102fdb952603e1b5d046d376685ee73..90c27884db2e882289dfbd45705cf09a8ee37736 100644
--- a/libavcodec/alacenc.c
+++ b/libavcodec/alacenc.c
@@ -521,7 +521,7 @@ static av_cold int alac_encode_close(AVCodecContext *avctx)
 
 AVCodec alac_encoder = {
     "alac",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_ALAC,
     sizeof(AlacEncodeContext),
     alac_encode_init,
diff --git a/libavcodec/alsdec.c b/libavcodec/alsdec.c
index c39fced3a1e25de0b2491587e4c90209b4508197..5050d0bcc94ad5d0a6622cbbe7a1a91eefbb3598 100644
--- a/libavcodec/alsdec.c
+++ b/libavcodec/alsdec.c
@@ -1622,7 +1622,7 @@ static av_cold void flush(AVCodecContext *avctx)
 
 AVCodec als_decoder = {
     "als",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MP4ALS,
     sizeof(ALSDecContext),
     decode_init,
diff --git a/libavcodec/amrnbdec.c b/libavcodec/amrnbdec.c
index e5a82b493a24725aa2ec14f67f3e77cc35078326..653a03e927541040b7cca5973fc145b3b69bebbb 100644
--- a/libavcodec/amrnbdec.c
+++ b/libavcodec/amrnbdec.c
@@ -1071,7 +1071,7 @@ static int amrnb_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 
 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,
diff --git a/libavcodec/anm.c b/libavcodec/anm.c
index 963f0771942bd06f38368730538ad17394608f87..bccffabad4c43b6a4e0a41e1f26a18b855ac6702 100644
--- a/libavcodec/anm.c
+++ b/libavcodec/anm.c
@@ -185,7 +185,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec anm_decoder = {
     "anm",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ANM,
     sizeof(AnmContext),
     decode_init,
diff --git a/libavcodec/apedec.c b/libavcodec/apedec.c
index f7b6e07d6dde11ccd6e23720989b9a55eaef573c..9930e2139cc0e9d0e2f6004cc0eb2f9023da245e 100644
--- a/libavcodec/apedec.c
+++ b/libavcodec/apedec.c
@@ -879,7 +879,7 @@ static int ape_decode_frame(AVCodecContext * avctx,
 
 AVCodec ape_decoder = {
     "ape",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_APE,
     sizeof(APEContext),
     ape_decode_init,
diff --git a/libavcodec/asv1.c b/libavcodec/asv1.c
index 078fc656f6d5461fd22a98bfd5dfa752b077e03c..978e6b68d9677272237fe2950341d8469c611fe0 100644
--- a/libavcodec/asv1.c
+++ b/libavcodec/asv1.c
@@ -615,7 +615,7 @@ static av_cold int decode_end(AVCodecContext *avctx){
 
 AVCodec asv1_decoder = {
     "asv1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ASV1,
     sizeof(ASV1Context),
     decode_init,
@@ -628,7 +628,7 @@ AVCodec asv1_decoder = {
 
 AVCodec asv2_decoder = {
     "asv2",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ASV2,
     sizeof(ASV1Context),
     decode_init,
@@ -642,7 +642,7 @@ AVCodec asv2_decoder = {
 #if CONFIG_ASV1_ENCODER
 AVCodec asv1_encoder = {
     "asv1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ASV1,
     sizeof(ASV1Context),
     encode_init,
@@ -656,7 +656,7 @@ AVCodec asv1_encoder = {
 #if CONFIG_ASV2_ENCODER
 AVCodec asv2_encoder = {
     "asv2",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ASV2,
     sizeof(ASV1Context),
     encode_init,
diff --git a/libavcodec/atrac1.c b/libavcodec/atrac1.c
index 4954dd8bb53da4842b6ed3109351b87ea0d72670..202ed8f5ea994c37c423ac8813659fc730b4efb2 100644
--- a/libavcodec/atrac1.c
+++ b/libavcodec/atrac1.c
@@ -372,7 +372,7 @@ static av_cold int atrac1_decode_end(AVCodecContext * avctx) {
 
 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,
diff --git a/libavcodec/atrac3.c b/libavcodec/atrac3.c
index dd69e4d87b5c6f57550746f4c29fa75bdddc91be..aa5a7536a9c0332613a45e1a2fa986f22561499a 100644
--- a/libavcodec/atrac3.c
+++ b/libavcodec/atrac3.c
@@ -1016,7 +1016,7 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)
 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,
diff --git a/libavcodec/aura.c b/libavcodec/aura.c
index f7830102230ea0c0118f87df5881796bf5a48238..dd22328a0160d6da5ff8037a6bf9ae0289707f02 100644
--- a/libavcodec/aura.c
+++ b/libavcodec/aura.c
@@ -124,7 +124,7 @@ static av_cold int aura_decode_end(AVCodecContext *avctx)
 
 AVCodec aura2_decoder = {
     "aura2",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_AURA2,
     sizeof(AuraDecodeContext),
     aura_decode_init,
diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h
index 5a461c623c5613b5e9a2f85e159ddf75f1c09f4f..2fb4fd49df42ccbfc12b478e8b642f58c7090cba 100644
--- a/libavcodec/avcodec.h
+++ b/libavcodec/avcodec.h
@@ -30,7 +30,7 @@
 #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, \
@@ -355,16 +355,28 @@ enum CodecID {
                                 * 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
  */
@@ -1277,7 +1289,7 @@ typedef struct AVCodecContext {
     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 */
 
     /**
@@ -2657,7 +2669,7 @@ typedef struct AVCodec {
      * 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 *);
@@ -2701,9 +2713,9 @@ typedef struct AVHWAccel {
     /**
      * 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.
@@ -3241,7 +3253,7 @@ void avcodec_get_context_defaults(AVCodecContext *s);
 
 /** 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
@@ -3254,7 +3266,7 @@ AVCodecContext *avcodec_alloc_context(void);
 
 /** 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.
diff --git a/libavcodec/avs.c b/libavcodec/avs.c
index a53a068c152144ed5ecb220b5b48e4120c77724f..f65a25a8e314040e2739b6e67f0671dc4163db74 100644
--- a/libavcodec/avs.c
+++ b/libavcodec/avs.c
@@ -152,7 +152,7 @@ static av_cold int avs_decode_init(AVCodecContext * avctx)
 
 AVCodec avs_decoder = {
     "avs",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_AVS,
     sizeof(AvsContext),
     avs_decode_init,
diff --git a/libavcodec/bethsoftvideo.c b/libavcodec/bethsoftvideo.c
index 6b4a5acabd70c13f33f38448662e58fd9a80ada6..4ed48c2a1aa8651d12b32dd6d94afc1b3ba23bb7 100644
--- a/libavcodec/bethsoftvideo.c
+++ b/libavcodec/bethsoftvideo.c
@@ -132,7 +132,7 @@ static av_cold int bethsoftvid_decode_end(AVCodecContext *avctx)
 
 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,
diff --git a/libavcodec/bfi.c b/libavcodec/bfi.c
index 31b914927e54d096fee4b47ac2b7f953dc95e9f3..2581b377a49aa6e3a3ab23b065095087d92c1569 100644
--- a/libavcodec/bfi.c
+++ b/libavcodec/bfi.c
@@ -173,7 +173,7 @@ static av_cold int bfi_decode_close(AVCodecContext * avctx)
 
 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,
diff --git a/libavcodec/bink.c b/libavcodec/bink.c
index f7b17b144f6b510987f1ed8de6c2e7ea110bfe21..a988a34933ed2cd1700a98266f3883adac999e4f 100644
--- a/libavcodec/bink.c
+++ b/libavcodec/bink.c
@@ -1001,7 +1001,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec bink_decoder = {
     "binkvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_BINKVIDEO,
     sizeof(BinkContext),
     decode_init,
diff --git a/libavcodec/binkaudio.c b/libavcodec/binkaudio.c
index 5fbc2de6d6fb121021b54d61d55db4e4afed1f9c..ff2906077a40f191050a972a911f58596cfdcc39 100644
--- a/libavcodec/binkaudio.c
+++ b/libavcodec/binkaudio.c
@@ -288,7 +288,7 @@ static int decode_frame(AVCodecContext *avctx,
 
 AVCodec binkaudio_rdft_decoder = {
     "binkaudio_rdft",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_BINKAUDIO_RDFT,
     sizeof(BinkAudioContext),
     decode_init,
@@ -300,7 +300,7 @@ AVCodec binkaudio_rdft_decoder = {
 
 AVCodec binkaudio_dct_decoder = {
     "binkaudio_dct",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_BINKAUDIO_DCT,
     sizeof(BinkAudioContext),
     decode_init,
diff --git a/libavcodec/bmp.c b/libavcodec/bmp.c
index 43e7f2f91bd41869a617cf1c315777d98bc8d760..da7bb787d0674883f124d4df1756be9047e93b38 100644
--- a/libavcodec/bmp.c
+++ b/libavcodec/bmp.c
@@ -337,7 +337,7 @@ static av_cold int bmp_decode_end(AVCodecContext *avctx)
 
 AVCodec bmp_decoder = {
     "bmp",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_BMP,
     sizeof(BMPContext),
     bmp_decode_init,
diff --git a/libavcodec/bmpenc.c b/libavcodec/bmpenc.c
index edb4dadf1fac2292b009e3082770e240345e82cb..ee85f3cfaefb36c0670439781e64a5f0754c738c 100644
--- a/libavcodec/bmpenc.c
+++ b/libavcodec/bmpenc.c
@@ -133,7 +133,7 @@ static int bmp_encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_s
 
 AVCodec bmp_encoder = {
     "bmp",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_BMP,
     sizeof(BMPContext),
     bmp_encode_init,
diff --git a/libavcodec/c93.c b/libavcodec/c93.c
index 0e362cad981c2011cb9964f484fbd173dc235a35..d713ff8e26366381bee0e32e6bcf32094778908f 100644
--- a/libavcodec/c93.c
+++ b/libavcodec/c93.c
@@ -244,7 +244,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
 
 AVCodec c93_decoder = {
     "c93",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_C93,
     sizeof(C93DecoderContext),
     decode_init,
diff --git a/libavcodec/cavsdec.c b/libavcodec/cavsdec.c
index 5929c8e2fb8e111be51f044a44ce5ce85cf19bc1..b4ae451ed6797c64686866d114be56199fb5cf7a 100644
--- a/libavcodec/cavsdec.c
+++ b/libavcodec/cavsdec.c
@@ -711,7 +711,7 @@ static int cavs_decode_frame(AVCodecContext * avctx,void *data, int *data_size,
 
 AVCodec cavs_decoder = {
     "cavs",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_CAVS,
     sizeof(AVSContext),
     ff_cavs_init,
diff --git a/libavcodec/cdgraphics.c b/libavcodec/cdgraphics.c
index 8f04e012979deea21d119504961570d1e312b184..5ad6e51c1c0f41e50fad4c7e978499219f9a42fd 100644
--- a/libavcodec/cdgraphics.c
+++ b/libavcodec/cdgraphics.c
@@ -369,7 +369,7 @@ static av_cold int cdg_decode_end(AVCodecContext *avctx)
 
 AVCodec cdgraphics_decoder = {
     "cdgraphics",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_CDGRAPHICS,
     sizeof(CDGraphicsContext),
     cdg_decode_init,
diff --git a/libavcodec/cinepak.c b/libavcodec/cinepak.c
index 45ca1a93e32d7dd150d6e245d4abd7d4edd03328..90c2a6410dbf1158c61542d1cbd35789d392a2d1 100644
--- a/libavcodec/cinepak.c
+++ b/libavcodec/cinepak.c
@@ -457,7 +457,7 @@ static av_cold int cinepak_decode_end(AVCodecContext *avctx)
 
 AVCodec cinepak_decoder = {
     "cinepak",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_CINEPAK,
     sizeof(CinepakContext),
     cinepak_decode_init,
diff --git a/libavcodec/cljr.c b/libavcodec/cljr.c
index 2164bf20f4ff78221b183d577c5f6b45fe122e45..b7c34436755a65aa0bd6fa5bdc381bc6a0568fdd 100644
--- a/libavcodec/cljr.c
+++ b/libavcodec/cljr.c
@@ -137,7 +137,7 @@ static av_cold int encode_init(AVCodecContext *avctx){
 
 AVCodec cljr_decoder = {
     "cljr",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_CLJR,
     sizeof(CLJRContext),
     decode_init,
@@ -151,7 +151,7 @@ AVCodec cljr_decoder = {
 #if CONFIG_CLJR_ENCODER
 AVCodec cljr_encoder = {
     "cljr",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_CLJR,
     sizeof(CLJRContext),
     encode_init,
diff --git a/libavcodec/cook.c b/libavcodec/cook.c
index 4948acfb898801e41e2b6043660365b32db34057..f7efe9e60c233f89d9ae703528dedc82e3c3df00 100644
--- a/libavcodec/cook.c
+++ b/libavcodec/cook.c
@@ -1288,7 +1288,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)
 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,
diff --git a/libavcodec/cscd.c b/libavcodec/cscd.c
index 45edca382c125386684713723b64b663494a87c2..e4f4b8f8254549de9fecbbcc296e83d2fb5b7c0d 100644
--- a/libavcodec/cscd.c
+++ b/libavcodec/cscd.c
@@ -249,7 +249,7 @@ static av_cold int decode_end(AVCodecContext *avctx) {
 
 AVCodec cscd_decoder = {
     "camstudio",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_CSCD,
     sizeof(CamStudioContext),
     decode_init,
diff --git a/libavcodec/cyuv.c b/libavcodec/cyuv.c
index c9471654784f81b7fb26e32ccacc8c8fa0f48889..cfc7000897066df861c79cc70923c7052923e87f 100644
--- a/libavcodec/cyuv.c
+++ b/libavcodec/cyuv.c
@@ -180,7 +180,7 @@ static av_cold int cyuv_decode_end(AVCodecContext *avctx)
 #if CONFIG_AURA_DECODER
 AVCodec aura_decoder = {
     "aura",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_AURA,
     sizeof(CyuvDecodeContext),
     cyuv_decode_init,
@@ -196,7 +196,7 @@ AVCodec aura_decoder = {
 #if CONFIG_CYUV_DECODER
 AVCodec cyuv_decoder = {
     "cyuv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_CYUV,
     sizeof(CyuvDecodeContext),
     cyuv_decode_init,
diff --git a/libavcodec/dca.c b/libavcodec/dca.c
index dfa8945e3d9c94bb5de6410ac6e348f7003325c4..18074cf4043b128e0b8294cf02def8de6a64dc93 100644
--- a/libavcodec/dca.c
+++ b/libavcodec/dca.c
@@ -1330,7 +1330,7 @@ static av_cold int dca_decode_end(AVCodecContext * avctx)
 
 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,
diff --git a/libavcodec/dnxhddec.c b/libavcodec/dnxhddec.c
index f78cb0d7db86c30586a70d0d3fbb5eab82279593..8b7c343d09cf25197c8333d3eefa573ffca91079 100644
--- a/libavcodec/dnxhddec.c
+++ b/libavcodec/dnxhddec.c
@@ -346,7 +346,7 @@ static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
 
 AVCodec dnxhd_decoder = {
     "dnxhd",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_DNXHD,
     sizeof(DNXHDContext),
     dnxhd_decode_init,
diff --git a/libavcodec/dnxhdenc.c b/libavcodec/dnxhdenc.c
index 5c986452e34565b1bee8542914bc4e285ac381e8..6b089299e93a59e4bdbe5c7a03b55cefc641a1f8 100644
--- a/libavcodec/dnxhdenc.c
+++ b/libavcodec/dnxhdenc.c
@@ -850,7 +850,7 @@ static int dnxhd_encode_end(AVCodecContext *avctx)
 
 AVCodec dnxhd_encoder = {
     "dnxhd",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_DNXHD,
     sizeof(DNXHDEncContext),
     dnxhd_encode_init,
diff --git a/libavcodec/dpcm.c b/libavcodec/dpcm.c
index 69c7002ad73c31be144393087a337168cc755f77..7c5351686ed912a26016e934e8e12398e6c2e557 100644
--- a/libavcodec/dpcm.c
+++ b/libavcodec/dpcm.c
@@ -301,7 +301,7 @@ static int dpcm_decode_frame(AVCodecContext *avctx,
 #define DPCM_DECODER(id, name, long_name_)      \
 AVCodec name ## _decoder = {                    \
     #name,                                      \
-    CODEC_TYPE_AUDIO,                           \
+    AVMEDIA_TYPE_AUDIO,                         \
     id,                                         \
     sizeof(DPCMContext),                        \
     dpcm_decode_init,                           \
diff --git a/libavcodec/dpx.c b/libavcodec/dpx.c
index ec0f435610e3eebf4f9a4b280db2a1ec79b27f5a..94a91816c5fb998ffa810a689540c8814405afa8 100644
--- a/libavcodec/dpx.c
+++ b/libavcodec/dpx.c
@@ -216,7 +216,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec dpx_decoder = {
     "dpx",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_DPX,
     sizeof(DPXContext),
     decode_init,
diff --git a/libavcodec/dsicinav.c b/libavcodec/dsicinav.c
index 6e5ff1244607007c74f72dbea94c8fae421f0fa5..03ea3c9e543c919a0c466c315f2430945f942441 100644
--- a/libavcodec/dsicinav.c
+++ b/libavcodec/dsicinav.c
@@ -345,7 +345,7 @@ static int cinaudio_decode_frame(AVCodecContext *avctx,
 
 AVCodec dsicinvideo_decoder = {
     "dsicinvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_DSICINVIDEO,
     sizeof(CinVideoContext),
     cinvideo_decode_init,
@@ -358,7 +358,7 @@ AVCodec dsicinvideo_decoder = {
 
 AVCodec dsicinaudio_decoder = {
     "dsicinaudio",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_DSICINAUDIO,
     sizeof(CinAudioContext),
     cinaudio_decode_init,
diff --git a/libavcodec/dv.c b/libavcodec/dv.c
index e3b1064a9574df0082eac3582fdfa22ff0f76ccb..182fe29d38956ea4ba896ea609d7e4e9bc08afe2 100644
--- a/libavcodec/dv.c
+++ b/libavcodec/dv.c
@@ -1282,7 +1282,7 @@ static int dvvideo_close(AVCodecContext *c)
 #if CONFIG_DVVIDEO_ENCODER
 AVCodec dvvideo_encoder = {
     "dvvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_DVVIDEO,
     sizeof(DVVideoContext),
     dvvideo_init_encoder,
@@ -1295,7 +1295,7 @@ AVCodec dvvideo_encoder = {
 #if CONFIG_DVVIDEO_DECODER
 AVCodec dvvideo_decoder = {
     "dvvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_DVVIDEO,
     sizeof(DVVideoContext),
     dvvideo_init,
diff --git a/libavcodec/dvbsub.c b/libavcodec/dvbsub.c
index 3788d559339cf6609e0217bf07c11bebcf2d0c20..0f098266d8a45eec3ce1a0bd867073110a002dbd 100644
--- a/libavcodec/dvbsub.c
+++ b/libavcodec/dvbsub.c
@@ -404,7 +404,7 @@ static int dvbsub_encode(AVCodecContext *avctx,
 
 AVCodec dvbsub_encoder = {
     "dvbsub",
-    CODEC_TYPE_SUBTITLE,
+    AVMEDIA_TYPE_SUBTITLE,
     CODEC_ID_DVB_SUBTITLE,
     sizeof(DVBSubtitleContext),
     NULL,
diff --git a/libavcodec/dvbsubdec.c b/libavcodec/dvbsubdec.c
index b810ef9e490bf79ce9b3c7bd94e4b0032d09d230..54c74b5b41a19369445b48b6d52ec5930ce16f8c 100644
--- a/libavcodec/dvbsubdec.c
+++ b/libavcodec/dvbsubdec.c
@@ -1413,7 +1413,7 @@ static int dvbsub_decode(AVCodecContext *avctx,
 
 AVCodec dvbsub_decoder = {
     "dvbsub",
-    CODEC_TYPE_SUBTITLE,
+    AVMEDIA_TYPE_SUBTITLE,
     CODEC_ID_DVB_SUBTITLE,
     sizeof(DVBSubContext),
     dvbsub_init_decoder,
diff --git a/libavcodec/dvdsubdec.c b/libavcodec/dvdsubdec.c
index 142241217c5b5baab242e65286c72ae91b86c6ad..75b52566d3e5383c27b20a4714d055069a5fef36 100644
--- a/libavcodec/dvdsubdec.c
+++ b/libavcodec/dvdsubdec.c
@@ -488,7 +488,7 @@ static int dvdsub_decode(AVCodecContext *avctx,
 
 AVCodec dvdsub_decoder = {
     "dvdsub",
-    CODEC_TYPE_SUBTITLE,
+    AVMEDIA_TYPE_SUBTITLE,
     CODEC_ID_DVD_SUBTITLE,
     0,
     NULL,
diff --git a/libavcodec/dvdsubenc.c b/libavcodec/dvdsubenc.c
index 4dc58e7bde60310aa04342bf51c2835c0858752d..4ee0f37c9dec72464815aa9e3f8eacb97512f8bc 100644
--- a/libavcodec/dvdsubenc.c
+++ b/libavcodec/dvdsubenc.c
@@ -217,7 +217,7 @@ static int dvdsub_encode(AVCodecContext *avctx,
 
 AVCodec dvdsub_encoder = {
     "dvdsub",
-    CODEC_TYPE_SUBTITLE,
+    AVMEDIA_TYPE_SUBTITLE,
     CODEC_ID_DVD_SUBTITLE,
     0,
     NULL,
diff --git a/libavcodec/dxa.c b/libavcodec/dxa.c
index c06ab85cc79b293bee55e7740c7928a36ff7d5bb..97420c13e85a606b5172e2159c8facc4bcaf2fd0 100644
--- a/libavcodec/dxa.c
+++ b/libavcodec/dxa.c
@@ -319,7 +319,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec dxa_decoder = {
     "dxa",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_DXA,
     sizeof(DxaDecContext),
     decode_init,
diff --git a/libavcodec/dxva2_h264.c b/libavcodec/dxva2_h264.c
index 9262bb89575793a69bc113f195cf657828b1c016..22c76df601a2773659cbd7a056f186b0e55720d3 100644
--- a/libavcodec/dxva2_h264.c
+++ b/libavcodec/dxva2_h264.c
@@ -425,7 +425,7 @@ static int end_frame(AVCodecContext *avctx)
 
 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,
diff --git a/libavcodec/dxva2_vc1.c b/libavcodec/dxva2_vc1.c
index 95a55849be33d9b3890457477156fbbcc2c6dc55..a11121347a125c8f5b379dfca725fabf649bb731 100644
--- a/libavcodec/dxva2_vc1.c
+++ b/libavcodec/dxva2_vc1.c
@@ -266,7 +266,7 @@ static int end_frame(AVCodecContext *avctx)
 #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,
@@ -279,7 +279,7 @@ AVHWAccel wmv3_dxva2_hwaccel = {
 
 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,
diff --git a/libavcodec/eacmv.c b/libavcodec/eacmv.c
index 30eaf3cfd253ecad02e1c07bc66a29db6e0f7baa..a39705de87e04bca9c768687ed739b91f75f4276 100644
--- a/libavcodec/eacmv.c
+++ b/libavcodec/eacmv.c
@@ -205,7 +205,7 @@ static av_cold int cmv_decode_end(AVCodecContext *avctx){
 
 AVCodec eacmv_decoder = {
     "eacmv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_CMV,
     sizeof(CmvContext),
     cmv_decode_init,
diff --git a/libavcodec/eamad.c b/libavcodec/eamad.c
index 2e9fa8b4521d1759e289459506c5dbd17697e24c..91f5ec0c6f6f207a35896c23dcea80d7d4deb9fc 100644
--- a/libavcodec/eamad.c
+++ b/libavcodec/eamad.c
@@ -307,7 +307,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec eamad_decoder = {
     "eamad",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MAD,
     sizeof(MadContext),
     decode_init,
diff --git a/libavcodec/eatgq.c b/libavcodec/eatgq.c
index e5c39912c7466153984bb210a6b20c4be19a5727..1a28e09d2d94f9dc7c9d9d57760e9929ff50b50a 100644
--- a/libavcodec/eatgq.c
+++ b/libavcodec/eatgq.c
@@ -245,7 +245,7 @@ static av_cold int tgq_decode_end(AVCodecContext *avctx){
 
 AVCodec eatgq_decoder = {
     "eatgq",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_TGQ,
     sizeof(TgqContext),
     tgq_decode_init,
diff --git a/libavcodec/eatgv.c b/libavcodec/eatgv.c
index 5eb31b7fc845ad6a0842a6d11b9527fbf9e3767d..ce0be4bae7475bcd9bb25d88b00ea9e065d80dce 100644
--- a/libavcodec/eatgv.c
+++ b/libavcodec/eatgv.c
@@ -335,7 +335,7 @@ static av_cold int tgv_decode_end(AVCodecContext *avctx)
 
 AVCodec eatgv_decoder = {
     "eatgv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_TGV,
     sizeof(TgvContext),
     tgv_decode_init,
diff --git a/libavcodec/eatqi.c b/libavcodec/eatqi.c
index e917be9fe840f51ba08943911d0945ebc3cf2979..bedfaadc153f4ae720f731015bffe06f0d400e2f 100644
--- a/libavcodec/eatqi.c
+++ b/libavcodec/eatqi.c
@@ -156,7 +156,7 @@ static av_cold int tqi_decode_end(AVCodecContext *avctx)
 
 AVCodec eatqi_decoder = {
     "eatqi",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_TQI,
     sizeof(TqiContext),
     tqi_decode_init,
diff --git a/libavcodec/escape124.c b/libavcodec/escape124.c
index 80b1484b751d5d7217a5f4cf4c7a28d69f13f0d6..b51206a0b52ad0eb58f296c06ceb3a6fd711e687 100644
--- a/libavcodec/escape124.c
+++ b/libavcodec/escape124.c
@@ -374,7 +374,7 @@ static int escape124_decode_frame(AVCodecContext *avctx,
 
 AVCodec escape124_decoder = {
     "escape124",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ESCAPE124,
     sizeof(Escape124Context),
     escape124_decode_init,
diff --git a/libavcodec/ffv1.c b/libavcodec/ffv1.c
index e3b71f7bb19d291968a4e7cf1731d54b642416b6..5566b0a7cd343a84b30d8dc448fe069322b5b551 100644
--- a/libavcodec/ffv1.c
+++ b/libavcodec/ffv1.c
@@ -1125,7 +1125,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
 
 AVCodec ffv1_decoder = {
     "ffv1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_FFV1,
     sizeof(FFV1Context),
     decode_init,
@@ -1140,7 +1140,7 @@ AVCodec ffv1_decoder = {
 #if CONFIG_FFV1_ENCODER
 AVCodec ffv1_encoder = {
     "ffv1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_FFV1,
     sizeof(FFV1Context),
     encode_init,
diff --git a/libavcodec/flacdec.c b/libavcodec/flacdec.c
index 0ebc23d6cfe5679d5fbe8b2455b94b6ffa025432..89b09e87209524fac3d9ba22001df12bb1309640 100644
--- a/libavcodec/flacdec.c
+++ b/libavcodec/flacdec.c
@@ -799,7 +799,7 @@ static void flac_flush(AVCodecContext *avctx)
 
 AVCodec flac_decoder = {
     "flac",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_FLAC,
     sizeof(FLACContext),
     flac_decode_init,
diff --git a/libavcodec/flacenc.c b/libavcodec/flacenc.c
index c1f862a68458397c795eb4bd35739052100d81c4..33d8133a37b2522f02211c243e4d9dc7a8ae659d 100644
--- a/libavcodec/flacenc.c
+++ b/libavcodec/flacenc.c
@@ -1253,7 +1253,7 @@ static av_cold int flac_encode_close(AVCodecContext *avctx)
 
 AVCodec flac_encoder = {
     "flac",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_FLAC,
     sizeof(FlacEncodeContext),
     flac_encode_init,
diff --git a/libavcodec/flashsv.c b/libavcodec/flashsv.c
index b2bdffe7c92397c0b980504df3f9edaced632de4..9d581c70992c2b8899a07509728b4dab435b8971 100644
--- a/libavcodec/flashsv.c
+++ b/libavcodec/flashsv.c
@@ -252,7 +252,7 @@ static av_cold int flashsv_decode_end(AVCodecContext *avctx)
 
 AVCodec flashsv_decoder = {
     "flashsv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_FLASHSV,
     sizeof(FlashSVContext),
     flashsv_decode_init,
diff --git a/libavcodec/flashsvenc.c b/libavcodec/flashsvenc.c
index 4d2b47979f220307c90c5be954bee30c52c38e48..852b344396dd3b1de338dffc89bd5565571bec50 100644
--- a/libavcodec/flashsvenc.c
+++ b/libavcodec/flashsvenc.c
@@ -282,7 +282,7 @@ static av_cold int flashsv_encode_end(AVCodecContext *avctx)
 
 AVCodec flashsv_encoder = {
     "flashsv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_FLASHSV,
     sizeof(FlashSVContext),
     flashsv_encode_init,
diff --git a/libavcodec/flicvideo.c b/libavcodec/flicvideo.c
index 2ee7837f604ea8aaff55d181c42c1bf56104a4b3..e2bb0e90ecc77eb53d733fc7b63e3df22e90dfd0 100644
--- a/libavcodec/flicvideo.c
+++ b/libavcodec/flicvideo.c
@@ -739,7 +739,7 @@ static av_cold int flic_decode_end(AVCodecContext *avctx)
 
 AVCodec flic_decoder = {
     "flic",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_FLIC,
     sizeof(FlicDecodeContext),
     flic_decode_init,
diff --git a/libavcodec/flvdec.c b/libavcodec/flvdec.c
index 50f7b251913345b5f9cfc480df79f0a1d13cfb91..cf9661ce1cefa7bc57a207ae5030ddc952c23eee 100644
--- a/libavcodec/flvdec.c
+++ b/libavcodec/flvdec.c
@@ -119,7 +119,7 @@ int ff_flv_decode_picture_header(MpegEncContext *s)
 
 AVCodec flv_decoder = {
     "flv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_FLV1,
     sizeof(MpegEncContext),
     ff_h263_decode_init,
diff --git a/libavcodec/flvenc.c b/libavcodec/flvenc.c
index 80dd46b60dd8c3df04cf53474513ee502c86be9c..bf320f2ffe084c19bb41fdd170d9449e3debb3ae 100644
--- a/libavcodec/flvenc.c
+++ b/libavcodec/flvenc.c
@@ -86,7 +86,7 @@ void ff_flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level, int run, in
 
 AVCodec flv_encoder = {
     "flv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_FLV1,
     sizeof(MpegEncContext),
     MPV_encode_init,
diff --git a/libavcodec/fraps.c b/libavcodec/fraps.c
index da1bf0dd723c61ba7589e47c2804a86d53f56f21..4e85f6106ab20a1c28765207b3eb40093e2240b9 100644
--- a/libavcodec/fraps.c
+++ b/libavcodec/fraps.c
@@ -366,7 +366,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec fraps_decoder = {
     "fraps",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_FRAPS,
     sizeof(FrapsContext),
     decode_init,
diff --git a/libavcodec/frwu.c b/libavcodec/frwu.c
index 28ed612df00262e6468c61b935ac29c7ad11825e..b685248b5fb368b15e4b2dd56988bdfd77c2e585 100644
--- a/libavcodec/frwu.c
+++ b/libavcodec/frwu.c
@@ -111,7 +111,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
 
 AVCodec frwu_decoder = {
     "FRWU",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_FRWU,
     0,
     decode_init,
diff --git a/libavcodec/g726.c b/libavcodec/g726.c
index a4b2099832922fcf94f2d4dbc96f01dd6194aea0..5e0051171b9b8745fcc0406ebf32b9d8ea76ede0 100644
--- a/libavcodec/g726.c
+++ b/libavcodec/g726.c
@@ -387,7 +387,7 @@ static int g726_decode_frame(AVCodecContext *avctx,
 #if CONFIG_ADPCM_G726_ENCODER
 AVCodec adpcm_g726_encoder = {
     "g726",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_ADPCM_G726,
     sizeof(G726Context),
     g726_init,
@@ -401,7 +401,7 @@ AVCodec adpcm_g726_encoder = {
 
 AVCodec adpcm_g726_decoder = {
     "g726",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_ADPCM_G726,
     sizeof(G726Context),
     g726_init,
diff --git a/libavcodec/g729dec.c b/libavcodec/g729dec.c
index be243606cf85f1589a8e68aa01a12352969c6545..3a6fb0fb7a2b6f1ade9d4da9bb022adc780ff443 100644
--- a/libavcodec/g729dec.c
+++ b/libavcodec/g729dec.c
@@ -315,7 +315,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 AVCodec g729_decoder =
 {
     "g729",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_G729,
     sizeof(G729Context),
     decoder_init,
diff --git a/libavcodec/gif.c b/libavcodec/gif.c
index 8c7f72ba80e4dc1059d9ea89b2ad5d570a392f48..c04f8bbc1ddd7e7f06fa76f5461219eb454a8148 100644
--- a/libavcodec/gif.c
+++ b/libavcodec/gif.c
@@ -168,7 +168,7 @@ static int gif_encode_close(AVCodecContext *avctx)
 
 AVCodec gif_encoder = {
     "gif",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_GIF,
     sizeof(GIFContext),
     gif_encode_init,
diff --git a/libavcodec/gifdec.c b/libavcodec/gifdec.c
index 70da4e2a57c3af8757a36ab9478351cb236178ba..1daf1b7b1a440b104e8b4482c5f234058059baf1 100644
--- a/libavcodec/gifdec.c
+++ b/libavcodec/gifdec.c
@@ -328,7 +328,7 @@ static av_cold int gif_decode_close(AVCodecContext *avctx)
 
 AVCodec gif_decoder = {
     "gif",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_GIF,
     sizeof(GifState),
     gif_decode_init,
diff --git a/libavcodec/h261dec.c b/libavcodec/h261dec.c
index ab266a0f6cdc5513a44ca5dcd7925534e51876fd..328e959637413e8bd4e6df4b40cbfe45e2bf18c4 100644
--- a/libavcodec/h261dec.c
+++ b/libavcodec/h261dec.c
@@ -643,7 +643,7 @@ static av_cold int h261_decode_end(AVCodecContext *avctx)
 
 AVCodec h261_decoder = {
     "h261",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_H261,
     sizeof(H261Context),
     h261_decode_init,
diff --git a/libavcodec/h261enc.c b/libavcodec/h261enc.c
index 68d60f872d135ccce6b820f579b2030c67cf807c..9538567999f94dca574da917c99d9d5eefe2c6a8 100644
--- a/libavcodec/h261enc.c
+++ b/libavcodec/h261enc.c
@@ -323,7 +323,7 @@ static void h261_encode_block(H261Context * h, DCTELEM * block, int n){
 
 AVCodec h261_encoder = {
     "h261",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_H261,
     sizeof(H261Context),
     MPV_encode_init,
diff --git a/libavcodec/h263dec.c b/libavcodec/h263dec.c
index e690583010e8a275b453da167f3419c75fc4e064..f85f15abe34b46423eb7973c11d8d449b04e0406 100644
--- a/libavcodec/h263dec.c
+++ b/libavcodec/h263dec.c
@@ -727,7 +727,7 @@ av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time);
 
 AVCodec h263_decoder = {
     "h263",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_H263,
     sizeof(MpegEncContext),
     ff_h263_decode_init,
diff --git a/libavcodec/h264.c b/libavcodec/h264.c
index 16ece73693ee1d9a9b7160365127c73a88e5489f..62c74a3325e85d95d94259c08492ac044f153785 100644
--- a/libavcodec/h264.c
+++ b/libavcodec/h264.c
@@ -3148,7 +3148,7 @@ av_cold int ff_h264_decode_end(AVCodecContext *avctx)
 
 AVCodec h264_decoder = {
     "h264",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_H264,
     sizeof(H264Context),
     ff_h264_decode_init,
@@ -3164,7 +3164,7 @@ AVCodec h264_decoder = {
 #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,
diff --git a/libavcodec/huffyuv.c b/libavcodec/huffyuv.c
index 3b56bb3869918d6fdc8bc4f69ff2c134fd6049cd..1a55abbe4c6d44fe752a280b18f7cf437a509ca9 100644
--- a/libavcodec/huffyuv.c
+++ b/libavcodec/huffyuv.c
@@ -1414,7 +1414,7 @@ static av_cold int encode_end(AVCodecContext *avctx)
 #if CONFIG_HUFFYUV_DECODER
 AVCodec huffyuv_decoder = {
     "huffyuv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_HUFFYUV,
     sizeof(HYuvContext),
     decode_init,
@@ -1430,7 +1430,7 @@ AVCodec huffyuv_decoder = {
 #if CONFIG_FFVHUFF_DECODER
 AVCodec ffvhuff_decoder = {
     "ffvhuff",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_FFVHUFF,
     sizeof(HYuvContext),
     decode_init,
@@ -1446,7 +1446,7 @@ AVCodec ffvhuff_decoder = {
 #if CONFIG_HUFFYUV_ENCODER
 AVCodec huffyuv_encoder = {
     "huffyuv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_HUFFYUV,
     sizeof(HYuvContext),
     encode_init,
@@ -1460,7 +1460,7 @@ AVCodec huffyuv_encoder = {
 #if CONFIG_FFVHUFF_ENCODER
 AVCodec ffvhuff_encoder = {
     "ffvhuff",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_FFVHUFF,
     sizeof(HYuvContext),
     encode_init,
diff --git a/libavcodec/idcinvideo.c b/libavcodec/idcinvideo.c
index 7ce9c42a399ace25cd062819004e859e5ea76ebb..7cb887c8eb059512ab0b8364706725df14cc2bac 100644
--- a/libavcodec/idcinvideo.c
+++ b/libavcodec/idcinvideo.c
@@ -255,7 +255,7 @@ static av_cold int idcin_decode_end(AVCodecContext *avctx)
 
 AVCodec idcin_decoder = {
     "idcinvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_IDCIN,
     sizeof(IdcinContext),
     idcin_decode_init,
diff --git a/libavcodec/iff.c b/libavcodec/iff.c
index 19671d767f8d95245b18eb7927553b4ed30a4c3d..a5d8c93e787c135aff4939480d6c432b75e630d5 100644
--- a/libavcodec/iff.c
+++ b/libavcodec/iff.c
@@ -218,7 +218,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec iff_ilbm_decoder = {
     "iff_ilbm",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_IFF_ILBM,
     sizeof(IffContext),
     decode_init,
@@ -231,7 +231,7 @@ AVCodec iff_ilbm_decoder = {
 
 AVCodec iff_byterun1_decoder = {
     "iff_byterun1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_IFF_BYTERUN1,
     sizeof(IffContext),
     decode_init,
diff --git a/libavcodec/imc.c b/libavcodec/imc.c
index c8bf3367ac93882257453c49a7685ce3f7abcde4..4dd73b6a4c1a96ef981bb1a5d9d6e1b9f5a1925c 100644
--- a/libavcodec/imc.c
+++ b/libavcodec/imc.c
@@ -823,7 +823,7 @@ static av_cold int imc_decode_close(AVCodecContext * avctx)
 
 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,
diff --git a/libavcodec/indeo2.c b/libavcodec/indeo2.c
index 6755014110bf72663adf50a1b81149f2aa99d77c..f210a4bf095293530ed543f9781e6774bcfd7386 100644
--- a/libavcodec/indeo2.c
+++ b/libavcodec/indeo2.c
@@ -226,7 +226,7 @@ static av_cold int ir2_decode_end(AVCodecContext *avctx){
 
 AVCodec indeo2_decoder = {
     "indeo2",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_INDEO2,
     sizeof(Ir2Context),
     ir2_decode_init,
diff --git a/libavcodec/indeo3.c b/libavcodec/indeo3.c
index 05f79258b34531a8a6468a8145acf5eb2c6e2244..e5df32c6720a52e0cf55af912368c7b7717e8182 100644
--- a/libavcodec/indeo3.c
+++ b/libavcodec/indeo3.c
@@ -1138,7 +1138,7 @@ static av_cold int indeo3_decode_end(AVCodecContext *avctx)
 
 AVCodec indeo3_decoder = {
     "indeo3",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_INDEO3,
     sizeof(Indeo3DecodeContext),
     indeo3_decode_init,
diff --git a/libavcodec/indeo5.c b/libavcodec/indeo5.c
index 9dea301d8ad6b1fed504aad86440d84cb637bbfe..eb8961cbfacde5fe0e2a9183560df5037c53f133 100644
--- a/libavcodec/indeo5.c
+++ b/libavcodec/indeo5.c
@@ -817,7 +817,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
 
 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,
diff --git a/libavcodec/intelh263dec.c b/libavcodec/intelh263dec.c
index e522ed4adaeb6fef33e2cf1d699c22886e8dcf82..5e451294da53ebd290784ca382f525e94c44573e 100644
--- a/libavcodec/intelh263dec.c
+++ b/libavcodec/intelh263dec.c
@@ -117,7 +117,7 @@ int ff_intel_h263_decode_picture_header(MpegEncContext *s)
 
 AVCodec h263i_decoder = {
     "h263i",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_H263I,
     sizeof(MpegEncContext),
     ff_h263_decode_init,
diff --git a/libavcodec/interplayvideo.c b/libavcodec/interplayvideo.c
index 8992a1de30f56ec7776a3e88477d6b8fb04b29bf..e1d6baf8c7632863adc567f43d5fb60c708e8598 100644
--- a/libavcodec/interplayvideo.c
+++ b/libavcodec/interplayvideo.c
@@ -1095,7 +1095,7 @@ static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
 
 AVCodec interplay_video_decoder = {
     "interplayvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_INTERPLAY_VIDEO,
     sizeof(IpvideoContext),
     ipvideo_decode_init,
diff --git a/libavcodec/jpeglsdec.c b/libavcodec/jpeglsdec.c
index bc80d13d68e43a260ee20c9323684189a5dac17c..0df3c4bcd888eabe3bed8bd088e486814caa7add 100644
--- a/libavcodec/jpeglsdec.c
+++ b/libavcodec/jpeglsdec.c
@@ -365,7 +365,7 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor
 
 AVCodec jpegls_decoder = {
     "jpegls",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_JPEGLS,
     sizeof(MJpegDecodeContext),
     ff_mjpeg_decode_init,
diff --git a/libavcodec/jpeglsenc.c b/libavcodec/jpeglsenc.c
index ea12ddaae483b07e141b8cca22b0894662baeeee..91e0f2d496339ccfbeb71673409c973bf1ec44de 100644
--- a/libavcodec/jpeglsenc.c
+++ b/libavcodec/jpeglsenc.c
@@ -384,7 +384,7 @@ static av_cold int encode_init_ls(AVCodecContext *ctx) {
 
 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,
diff --git a/libavcodec/kgv1dec.c b/libavcodec/kgv1dec.c
index d786578a950926acd4dbb9cd41daadf71e57e943..f07d2367ec497d22aa48bd87122096cb8f45e438 100644
--- a/libavcodec/kgv1dec.c
+++ b/libavcodec/kgv1dec.c
@@ -165,7 +165,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec kgv1_decoder = {
     "kgv1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_KGV1,
     sizeof(KgvContext),
     decode_init,
diff --git a/libavcodec/kmvc.c b/libavcodec/kmvc.c
index f4b54a138f452baf9e01cd67b427a73023391362..48c7ca44a2ab11b949675eb5bb35b050e3090d87 100644
--- a/libavcodec/kmvc.c
+++ b/libavcodec/kmvc.c
@@ -403,7 +403,7 @@ static av_cold int decode_end(AVCodecContext * avctx)
 
 AVCodec kmvc_decoder = {
     "kmvc",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_KMVC,
     sizeof(KmvcContext),
     decode_init,
diff --git a/libavcodec/lcldec.c b/libavcodec/lcldec.c
index d4fe65ccebb4d5bfc9abc4c5150e6cdf1e400e58..b6dc266b46384a64d4788d78c45f3436e5c66bd1 100644
--- a/libavcodec/lcldec.c
+++ b/libavcodec/lcldec.c
@@ -611,7 +611,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 #if CONFIG_MSZH_DECODER
 AVCodec mszh_decoder = {
     "mszh",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MSZH,
     sizeof(LclDecContext),
     decode_init,
@@ -626,7 +626,7 @@ AVCodec mszh_decoder = {
 #if CONFIG_ZLIB_DECODER
 AVCodec zlib_decoder = {
     "zlib",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ZLIB,
     sizeof(LclDecContext),
     decode_init,
diff --git a/libavcodec/lclenc.c b/libavcodec/lclenc.c
index 4c43916fd195220484bee573cf8e83fb5d4059da..abaa86891ae53847db936ffbb805c6f2f7533edd 100644
--- a/libavcodec/lclenc.c
+++ b/libavcodec/lclenc.c
@@ -180,7 +180,7 @@ static av_cold int encode_end(AVCodecContext *avctx)
 
 AVCodec zlib_encoder = {
     "zlib",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ZLIB,
     sizeof(LclEncContext),
     encode_init,
diff --git a/libavcodec/libdiracdec.c b/libavcodec/libdiracdec.c
index b403094198e2f4e0e93204a75fc62b8ee6043a8f..273a9501f3a082faae8db4c0fa253311c507b5aa 100644
--- a/libavcodec/libdiracdec.c
+++ b/libavcodec/libdiracdec.c
@@ -195,7 +195,7 @@ static void libdirac_flush(AVCodecContext *avccontext)
 
 AVCodec libdirac_decoder = {
     "libdirac",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_DIRAC,
     sizeof(FfmpegDiracDecoderParams),
     libdirac_decode_init,
diff --git a/libavcodec/libdiracenc.c b/libavcodec/libdiracenc.c
index 6770eb7c3fefa3f86695cd6bc1b7868ff7127354..65b088c2b3e0c9609c9429eb02b834ec40a287cc 100644
--- a/libavcodec/libdiracenc.c
+++ b/libavcodec/libdiracenc.c
@@ -393,7 +393,7 @@ static av_cold int libdirac_encode_close(AVCodecContext *avccontext)
 
 AVCodec libdirac_encoder = {
     "libdirac",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_DIRAC,
     sizeof(FfmpegDiracEncoderParams),
     libdirac_encode_init,
diff --git a/libavcodec/libfaac.c b/libavcodec/libfaac.c
index 18b056b04f521ea2581669be455c225da73eee17..e8514e11b849d4f62728c4cbbc59ba76c28d2493 100644
--- a/libavcodec/libfaac.c
+++ b/libavcodec/libfaac.c
@@ -147,7 +147,7 @@ static av_cold int Faac_encode_close(AVCodecContext *avctx)
 
 AVCodec libfaac_encoder = {
     "libfaac",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_AAC,
     sizeof(FaacAudioContext),
     Faac_encode_init,
diff --git a/libavcodec/libfaad.c b/libavcodec/libfaad.c
index e417467d01fa366741aaa18805edf161d01a665a..eff5089db2bd5a81db64c2318b8f10d86d3f4cab 100644
--- a/libavcodec/libfaad.c
+++ b/libavcodec/libfaad.c
@@ -322,7 +322,7 @@ static av_cold int faac_decode_init(AVCodecContext *avctx)
 
 AVCodec libfaad_decoder = {
     "libfaad",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_AAC,
     sizeof(FAACContext),
     faac_decode_init,
diff --git a/libavcodec/libgsm.c b/libavcodec/libgsm.c
index 9dfad1392c3a95f86aa391e572a3b23e7b0ea6ae..d8122488dbdc18756ab73788976ffbcaa00e04a8 100644
--- a/libavcodec/libgsm.c
+++ b/libavcodec/libgsm.c
@@ -114,7 +114,7 @@ static int libgsm_encode_frame(AVCodecContext *avctx,
 
 AVCodec libgsm_encoder = {
     "libgsm",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_GSM,
     0,
     libgsm_init,
@@ -126,7 +126,7 @@ AVCodec libgsm_encoder = {
 
 AVCodec libgsm_ms_encoder = {
     "libgsm_ms",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_GSM_MS,
     0,
     libgsm_init,
@@ -158,7 +158,7 @@ static int libgsm_decode_frame(AVCodecContext *avctx,
 
 AVCodec libgsm_decoder = {
     "libgsm",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_GSM,
     0,
     libgsm_init,
@@ -170,7 +170,7 @@ AVCodec libgsm_decoder = {
 
 AVCodec libgsm_ms_decoder = {
     "libgsm_ms",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_GSM_MS,
     0,
     libgsm_init,
diff --git a/libavcodec/libmp3lame.c b/libavcodec/libmp3lame.c
index 62f6c02179fd6669b7e621c9fdb75bf91b1427e5..31190cc5d055de281b48d7815d21dbc013e37beb 100644
--- a/libavcodec/libmp3lame.c
+++ b/libavcodec/libmp3lame.c
@@ -216,7 +216,7 @@ static av_cold int MP3lame_encode_close(AVCodecContext *avctx)
 
 AVCodec libmp3lame_encoder = {
     "libmp3lame",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MP3,
     sizeof(Mp3AudioContext),
     MP3lame_encode_init,
diff --git a/libavcodec/libopencore-amr.c b/libavcodec/libopencore-amr.c
index 8aee7c581702b918b5e1363adf05c6c3610ac8bb..266164514f177b96bbb0e307d098d53e6352c7cc 100644
--- a/libavcodec/libopencore-amr.c
+++ b/libavcodec/libopencore-amr.c
@@ -141,7 +141,7 @@ static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
 
 AVCodec libopencore_amrnb_decoder = {
     "libopencore_amrnb",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_AMR_NB,
     sizeof(AMRContext),
     amr_nb_decode_init,
@@ -215,7 +215,7 @@ static int amr_nb_encode_frame(AVCodecContext *avctx,
 
 AVCodec libopencore_amrnb_encoder = {
     "libopencore_amrnb",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_AMR_NB,
     sizeof(AMRContext),
     amr_nb_encode_init,
@@ -312,7 +312,7 @@ static int amr_wb_decode_close(AVCodecContext *avctx)
 
 AVCodec libopencore_amrwb_decoder = {
     "libopencore_amrwb",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_AMR_WB,
     sizeof(AMRWBContext),
     amr_wb_decode_init,
diff --git a/libavcodec/libopenjpeg.c b/libavcodec/libopenjpeg.c
index 387ea8b5d91b06bd19d842f9ac175fbdae4a3e86..86282f7163f8adcddad8a3fab193fa6e6dd9a4dd 100644
--- a/libavcodec/libopenjpeg.c
+++ b/libavcodec/libopenjpeg.c
@@ -185,7 +185,7 @@ static av_cold int libopenjpeg_decode_close(AVCodecContext *avctx)
 
 AVCodec libopenjpeg_decoder = {
     "libopenjpeg",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_JPEG2000,
     sizeof(LibOpenJPEGContext),
     libopenjpeg_decode_init,
diff --git a/libavcodec/libschroedingerdec.c b/libavcodec/libschroedingerdec.c
index 53ded57ba49a070dd372476ae7e88661389f9541..1e623c0ec25f01871d37753d08661a9a813e9350 100644
--- a/libavcodec/libschroedingerdec.c
+++ b/libavcodec/libschroedingerdec.c
@@ -347,7 +347,7 @@ static void libschroedinger_flush(AVCodecContext *avccontext)
 
 AVCodec libschroedinger_decoder = {
     "libschroedinger",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_DIRAC,
     sizeof(FfmpegSchroDecoderParams),
     libschroedinger_decode_init,
diff --git a/libavcodec/libschroedingerenc.c b/libavcodec/libschroedingerenc.c
index 44d4dcd428fe0797008ec30b42b546c8e49da093..d4430bf3ac60d57519faad3efeee5ec3e40e6cb6 100644
--- a/libavcodec/libschroedingerenc.c
+++ b/libavcodec/libschroedingerenc.c
@@ -407,7 +407,7 @@ static int libschroedinger_encode_close(AVCodecContext *avccontext)
 
 AVCodec libschroedinger_encoder = {
     "libschroedinger",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_DIRAC,
     sizeof(FfmpegSchroEncoderParams),
     libschroedinger_encode_init,
diff --git a/libavcodec/libspeexdec.c b/libavcodec/libspeexdec.c
index 153e395eb0c62453f28cd307f45bd21b504fe966..c5cfbd51087b1d1f8b6d0be76a4f06ba91b8cf30 100644
--- a/libavcodec/libspeexdec.c
+++ b/libavcodec/libspeexdec.c
@@ -140,7 +140,7 @@ static av_cold int libspeex_decode_close(AVCodecContext *avctx)
 
 AVCodec libspeex_decoder = {
     "libspeex",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_SPEEX,
     sizeof(LibSpeexContext),
     libspeex_decode_init,
diff --git a/libavcodec/libtheoraenc.c b/libavcodec/libtheoraenc.c
index ac015ff20000fa5b91164b23c7808bf98296e42c..0ae03bfb1c42ed52a64e8002382b7071ef5a942b 100644
--- a/libavcodec/libtheoraenc.c
+++ b/libavcodec/libtheoraenc.c
@@ -361,7 +361,7 @@ static av_cold int encode_close(AVCodecContext* avc_context)
 /*! 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,
diff --git a/libavcodec/libvorbis.c b/libavcodec/libvorbis.c
index 530db5c14ca85c5c391256e01c7d2c18a185c620..afa6c046931732e37b38662c0824fdbb9f9f9e9d 100644
--- a/libavcodec/libvorbis.c
+++ b/libavcodec/libvorbis.c
@@ -217,7 +217,7 @@ static av_cold int oggvorbis_encode_close(AVCodecContext *avccontext) {
 
 AVCodec libvorbis_encoder = {
     "libvorbis",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_VORBIS,
     sizeof(OggVorbisContext),
     oggvorbis_encode_init,
diff --git a/libavcodec/libx264.c b/libavcodec/libx264.c
index a5f0a533d7a2c5ce868d5933a4a97d9e71935a27..1ad270f84f9043ca90e3b8fd6fa3b92352b0a25b 100644
--- a/libavcodec/libx264.c
+++ b/libavcodec/libx264.c
@@ -317,7 +317,7 @@ static av_cold int X264_init(AVCodecContext *avctx)
 
 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,
diff --git a/libavcodec/libxvidff.c b/libavcodec/libxvidff.c
index 855aba1ec511fe80ea6b98fe5f13970a6ec12e0a..3624770087536698d7f9392dd45566dcde3abb42 100644
--- a/libavcodec/libxvidff.c
+++ b/libavcodec/libxvidff.c
@@ -769,7 +769,7 @@ int xvid_ff_2pass(void *ref, int cmd, void *p1, void *p2) {
  */
 AVCodec libxvid_encoder = {
     "libxvid",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MPEG4,
     sizeof(struct xvid_context),
     xvid_encode_init,
diff --git a/libavcodec/ljpegenc.c b/libavcodec/ljpegenc.c
index 566723dbc00bf1456d7785301d2d665c6932617a..d529352b073488fc30c28128029ef03a9adf3a6c 100644
--- a/libavcodec/ljpegenc.c
+++ b/libavcodec/ljpegenc.c
@@ -188,7 +188,7 @@ static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, in
 
 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,
diff --git a/libavcodec/loco.c b/libavcodec/loco.c
index 57fba82cf00d9563e710253b31325f4a57168366..988cd0ec639c993f764a9c901a1c0c5c377191c5 100644
--- a/libavcodec/loco.c
+++ b/libavcodec/loco.c
@@ -287,7 +287,7 @@ static av_cold int decode_end(AVCodecContext *avctx){
 
 AVCodec loco_decoder = {
     "loco",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_LOCO,
     sizeof(LOCOContext),
     decode_init,
diff --git a/libavcodec/mace.c b/libavcodec/mace.c
index ae7b4dc83323e6992024666c33b44a45efde1bdd..95473345df17d2230847bd8ad8708a5d59855a0e 100644
--- a/libavcodec/mace.c
+++ b/libavcodec/mace.c
@@ -281,7 +281,7 @@ static int mace_decode_frame(AVCodecContext *avctx,
 
 AVCodec mace3_decoder = {
     "mace3",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MACE3,
     sizeof(MACEContext),
     mace_decode_init,
@@ -293,7 +293,7 @@ AVCodec mace3_decoder = {
 
 AVCodec mace6_decoder = {
     "mace6",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MACE6,
     sizeof(MACEContext),
     mace_decode_init,
diff --git a/libavcodec/mdec.c b/libavcodec/mdec.c
index 8e737715c1262598169a9221638bcce245acfd7b..33408a6f006ec15a2b3c20b17614adf8427e28d9 100644
--- a/libavcodec/mdec.c
+++ b/libavcodec/mdec.c
@@ -250,7 +250,7 @@ static av_cold int decode_end(AVCodecContext *avctx){
 
 AVCodec mdec_decoder = {
     "mdec",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MDEC,
     sizeof(MDECContext),
     decode_init,
diff --git a/libavcodec/mimic.c b/libavcodec/mimic.c
index 8cac02fe71e98d6e72cdda3b895f3dc7df858d66..e5f7123e947a39f7abe2a460c658c0f37fb55ef5 100644
--- a/libavcodec/mimic.c
+++ b/libavcodec/mimic.c
@@ -380,7 +380,7 @@ static av_cold int mimic_decode_end(AVCodecContext *avctx)
 
 AVCodec mimic_decoder = {
     "mimic",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MIMIC,
     sizeof(MimicContext),
     mimic_decode_init,
diff --git a/libavcodec/mjpegbdec.c b/libavcodec/mjpegbdec.c
index 185e7bb55ca05593404fefe4cc73c751b33261cb..3bea47e3c9d75c08b7b2155ddb22158211f9f567 100644
--- a/libavcodec/mjpegbdec.c
+++ b/libavcodec/mjpegbdec.c
@@ -147,7 +147,7 @@ read_header:
 
 AVCodec mjpegb_decoder = {
     "mjpegb",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MJPEGB,
     sizeof(MJpegDecodeContext),
     ff_mjpeg_decode_init,
diff --git a/libavcodec/mjpegdec.c b/libavcodec/mjpegdec.c
index 14bd24e128c5ce00950c8ac45341042166c73acc..9b930e5bfd7087c4e8ee664d268f1c9eba5026dd 100644
--- a/libavcodec/mjpegdec.c
+++ b/libavcodec/mjpegdec.c
@@ -1533,7 +1533,7 @@ av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
 
 AVCodec mjpeg_decoder = {
     "mjpeg",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MJPEG,
     sizeof(MJpegDecodeContext),
     ff_mjpeg_decode_init,
@@ -1547,7 +1547,7 @@ AVCodec mjpeg_decoder = {
 
 AVCodec thp_decoder = {
     "thp",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_THP,
     sizeof(MJpegDecodeContext),
     ff_mjpeg_decode_init,
diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index 129a257d704e450985725edea6c5f3facaa6c741..635fa1206f01912052aa81d7b8f27470b4dd64db 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -445,7 +445,7 @@ void ff_mjpeg_encode_mb(MpegEncContext *s, DCTELEM block[6][64])
 
 AVCodec mjpeg_encoder = {
     "mjpeg",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MJPEG,
     sizeof(MpegEncContext),
     MPV_encode_init,
diff --git a/libavcodec/mlpdec.c b/libavcodec/mlpdec.c
index aa3b9cd2cdc6100253bd89b1465a3f71f52fa1e2..88e6cdf5bd0a5ab85fde049382202fccd033f123 100644
--- a/libavcodec/mlpdec.c
+++ b/libavcodec/mlpdec.c
@@ -1136,7 +1136,7 @@ error:
 
 AVCodec mlp_decoder = {
     "mlp",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MLP,
     sizeof(MLPDecodeContext),
     mlp_decode_init,
@@ -1149,7 +1149,7 @@ AVCodec mlp_decoder = {
 #if CONFIG_TRUEHD_DECODER
 AVCodec truehd_decoder = {
     "truehd",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_TRUEHD,
     sizeof(MLPDecodeContext),
     mlp_decode_init,
diff --git a/libavcodec/mmvideo.c b/libavcodec/mmvideo.c
index fe1156159bdc942e7e3b9a96ea6bd3c39e540b1f..6d9aaacbe6b4b3c5c1053ae684c64492c235ac19 100644
--- a/libavcodec/mmvideo.c
+++ b/libavcodec/mmvideo.c
@@ -200,7 +200,7 @@ static av_cold int mm_decode_end(AVCodecContext *avctx)
 
 AVCodec mmvideo_decoder = {
     "mmvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MMVIDEO,
     sizeof(MmContext),
     mm_decode_init,
diff --git a/libavcodec/motionpixels.c b/libavcodec/motionpixels.c
index ac9c6ecf81dee8fe66ffaccf0525dfeff379c78b..9bc5e2035da81b2de51f8dcf3b8616b83b7455d7 100644
--- a/libavcodec/motionpixels.c
+++ b/libavcodec/motionpixels.c
@@ -304,7 +304,7 @@ static av_cold int mp_decode_end(AVCodecContext *avctx)
 
 AVCodec motionpixels_decoder = {
     "motionpixels",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MOTIONPIXELS,
     sizeof(MotionPixelsContext),
     mp_decode_init,
diff --git a/libavcodec/mpc7.c b/libavcodec/mpc7.c
index f6eb12cdb4f8098cb05ccc20baf2855344d716d1..5eadbc6162e6a6a8d81ccd253d2a0d7a70b69916 100644
--- a/libavcodec/mpc7.c
+++ b/libavcodec/mpc7.c
@@ -290,7 +290,7 @@ static void mpc7_decode_flush(AVCodecContext *avctx)
 
 AVCodec mpc7_decoder = {
     "mpc7",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MUSEPACK7,
     sizeof(MPCContext),
     mpc7_decode_init,
diff --git a/libavcodec/mpc8.c b/libavcodec/mpc8.c
index 379528e9bd40b9866982d9f6b8c3b714387fd145..780f0b7066a1fcaf5c4c44e05cec0a453509f81f 100644
--- a/libavcodec/mpc8.c
+++ b/libavcodec/mpc8.c
@@ -401,7 +401,7 @@ static int mpc8_decode_frame(AVCodecContext * avctx,
 
 AVCodec mpc8_decoder = {
     "mpc8",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MUSEPACK8,
     sizeof(MPCContext),
     mpc8_decode_init,
diff --git a/libavcodec/mpeg12.c b/libavcodec/mpeg12.c
index 1cd9acc771084286338433ee30ccd1291657811d..bcc7fcfe78c2e07f832b2ba2f25fdbc89c8954ef 100644
--- a/libavcodec/mpeg12.c
+++ b/libavcodec/mpeg12.c
@@ -2502,7 +2502,7 @@ static int mpeg_decode_end(AVCodecContext *avctx)
 
 AVCodec mpeg1video_decoder = {
     "mpeg1video",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MPEG1VIDEO,
     sizeof(Mpeg1Context),
     mpeg_decode_init,
@@ -2516,7 +2516,7 @@ AVCodec mpeg1video_decoder = {
 
 AVCodec mpeg2video_decoder = {
     "mpeg2video",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MPEG2VIDEO,
     sizeof(Mpeg1Context),
     mpeg_decode_init,
@@ -2531,7 +2531,7 @@ AVCodec mpeg2video_decoder = {
 //legacy decoder
 AVCodec mpegvideo_decoder = {
     "mpegvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MPEG2VIDEO,
     sizeof(Mpeg1Context),
     mpeg_decode_init,
@@ -2562,7 +2562,7 @@ static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx){
 
 AVCodec mpeg_xvmc_decoder = {
     "mpegvideo_xvmc",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MPEG2VIDEO_XVMC,
     sizeof(Mpeg1Context),
     mpeg_mc_decode_init,
@@ -2579,7 +2579,7 @@ AVCodec mpeg_xvmc_decoder = {
 #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,
@@ -2595,7 +2595,7 @@ AVCodec mpeg_vdpau_decoder = {
 #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,
diff --git a/libavcodec/mpeg12enc.c b/libavcodec/mpeg12enc.c
index 350fa4016bcb48b743295a587cae0649584332d1..9cb4ef29d0821601e98f370476d19cca4a9d3cd6 100644
--- a/libavcodec/mpeg12enc.c
+++ b/libavcodec/mpeg12enc.c
@@ -932,7 +932,7 @@ static void mpeg1_encode_block(MpegEncContext *s,
 
 AVCodec mpeg1video_encoder = {
     "mpeg1video",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MPEG1VIDEO,
     sizeof(MpegEncContext),
     encode_init,
@@ -946,7 +946,7 @@ AVCodec mpeg1video_encoder = {
 
 AVCodec mpeg2video_encoder = {
     "mpeg2video",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MPEG2VIDEO,
     sizeof(MpegEncContext),
     encode_init,
diff --git a/libavcodec/mpeg4videodec.c b/libavcodec/mpeg4videodec.c
index baf7809d008354bd778ec999521caac9aa4a1c30..fa69c9ef87e3aadeb17a67f640db6df9622db569 100644
--- a/libavcodec/mpeg4videodec.c
+++ b/libavcodec/mpeg4videodec.c
@@ -2236,7 +2236,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
 
 AVCodec mpeg4_decoder = {
     "mpeg4",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MPEG4,
     sizeof(MpegEncContext),
     decode_init,
@@ -2253,7 +2253,7 @@ AVCodec mpeg4_decoder = {
 #if CONFIG_MPEG4_VDPAU_DECODER
 AVCodec mpeg4_vdpau_decoder = {
     "mpeg4_vdpau",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MPEG4,
     sizeof(MpegEncContext),
     decode_init,
diff --git a/libavcodec/mpeg4videoenc.c b/libavcodec/mpeg4videoenc.c
index 28d026b33265d0325de2596d1adfdfa1e2f9b3f8..79190f0a6f07d945c11e472fce5ca620092c9a12 100644
--- a/libavcodec/mpeg4videoenc.c
+++ b/libavcodec/mpeg4videoenc.c
@@ -1340,7 +1340,7 @@ void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
 
 AVCodec mpeg4_encoder = {
     "mpeg4",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MPEG4,
     sizeof(MpegEncContext),
     encode_init,
diff --git a/libavcodec/mpegaudiodec.c b/libavcodec/mpegaudiodec.c
index f301ce9d886cc3cc6d89d37cc9e1e87f4265dd08..af518aab9ba58ab276fb95c0e695a20004eadd0d 100644
--- a/libavcodec/mpegaudiodec.c
+++ b/libavcodec/mpegaudiodec.c
@@ -2485,7 +2485,7 @@ static int decode_frame_mp3on4(AVCodecContext * avctx,
 AVCodec mp1_decoder =
 {
     "mp1",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MP1,
     sizeof(MPADecodeContext),
     decode_init,
@@ -2501,7 +2501,7 @@ AVCodec mp1_decoder =
 AVCodec mp2_decoder =
 {
     "mp2",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MP2,
     sizeof(MPADecodeContext),
     decode_init,
@@ -2517,7 +2517,7 @@ AVCodec mp2_decoder =
 AVCodec mp3_decoder =
 {
     "mp3",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MP3,
     sizeof(MPADecodeContext),
     decode_init,
@@ -2533,7 +2533,7 @@ AVCodec mp3_decoder =
 AVCodec mp3adu_decoder =
 {
     "mp3adu",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MP3ADU,
     sizeof(MPADecodeContext),
     decode_init,
@@ -2549,7 +2549,7 @@ AVCodec mp3adu_decoder =
 AVCodec mp3on4_decoder =
 {
     "mp3on4",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MP3ON4,
     sizeof(MP3On4DecodeContext),
     decode_init_mp3on4,
diff --git a/libavcodec/mpegaudioenc.c b/libavcodec/mpegaudioenc.c
index a1e2023ba1e96466afa549cfe294867b11010006..222db5357bd4c186e8ddce8c7ee22284d3c97540 100644
--- a/libavcodec/mpegaudioenc.c
+++ b/libavcodec/mpegaudioenc.c
@@ -790,7 +790,7 @@ static av_cold int MPA_encode_close(AVCodecContext *avctx)
 
 AVCodec mp2_encoder = {
     "mp2",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_MP2,
     sizeof(MpegAudioContext),
     MPA_encode_init,
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 8b28062e9e51ff8269b57e0c15562cea07c65155..ec1cbc5db8f7b66df70595b170923bcc4ca24ef8 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -3771,7 +3771,7 @@ int dct_quantize_c(MpegEncContext *s,
 
 AVCodec h263_encoder = {
     "h263",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_H263,
     sizeof(MpegEncContext),
     MPV_encode_init,
@@ -3783,7 +3783,7 @@ AVCodec h263_encoder = {
 
 AVCodec h263p_encoder = {
     "h263p",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_H263P,
     sizeof(MpegEncContext),
     MPV_encode_init,
@@ -3795,7 +3795,7 @@ AVCodec h263p_encoder = {
 
 AVCodec msmpeg4v1_encoder = {
     "msmpeg4v1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MSMPEG4V1,
     sizeof(MpegEncContext),
     MPV_encode_init,
@@ -3807,7 +3807,7 @@ AVCodec msmpeg4v1_encoder = {
 
 AVCodec msmpeg4v2_encoder = {
     "msmpeg4v2",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MSMPEG4V2,
     sizeof(MpegEncContext),
     MPV_encode_init,
@@ -3819,7 +3819,7 @@ AVCodec msmpeg4v2_encoder = {
 
 AVCodec msmpeg4v3_encoder = {
     "msmpeg4",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MSMPEG4V3,
     sizeof(MpegEncContext),
     MPV_encode_init,
@@ -3831,7 +3831,7 @@ AVCodec msmpeg4v3_encoder = {
 
 AVCodec wmv1_encoder = {
     "wmv1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_WMV1,
     sizeof(MpegEncContext),
     MPV_encode_init,
diff --git a/libavcodec/msmpeg4.c b/libavcodec/msmpeg4.c
index 60d104bdef015417bc537c17b366e87f0136ffa4..94127cf7b65bb90f854683c10ecd49f477adee86 100644
--- a/libavcodec/msmpeg4.c
+++ b/libavcodec/msmpeg4.c
@@ -1921,7 +1921,7 @@ int ff_msmpeg4_decode_motion(MpegEncContext * s,
 
 AVCodec msmpeg4v1_decoder = {
     "msmpeg4v1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MSMPEG4V1,
     sizeof(MpegEncContext),
     ff_msmpeg4_decode_init,
@@ -1935,7 +1935,7 @@ AVCodec msmpeg4v1_decoder = {
 
 AVCodec msmpeg4v2_decoder = {
     "msmpeg4v2",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MSMPEG4V2,
     sizeof(MpegEncContext),
     ff_msmpeg4_decode_init,
@@ -1949,7 +1949,7 @@ AVCodec msmpeg4v2_decoder = {
 
 AVCodec msmpeg4v3_decoder = {
     "msmpeg4",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MSMPEG4V3,
     sizeof(MpegEncContext),
     ff_msmpeg4_decode_init,
@@ -1963,7 +1963,7 @@ AVCodec msmpeg4v3_decoder = {
 
 AVCodec wmv1_decoder = {
     "wmv1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_WMV1,
     sizeof(MpegEncContext),
     ff_msmpeg4_decode_init,
diff --git a/libavcodec/msrle.c b/libavcodec/msrle.c
index 3ab73a395740e653aac685308af68927f1fc9699..0fa2c67a87d4f42c5862bf6825307f36000ecd7a 100644
--- a/libavcodec/msrle.c
+++ b/libavcodec/msrle.c
@@ -145,7 +145,7 @@ static av_cold int msrle_decode_end(AVCodecContext *avctx)
 
 AVCodec msrle_decoder = {
     "msrle",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MSRLE,
     sizeof(MsrleContext),
     msrle_decode_init,
diff --git a/libavcodec/msvideo1.c b/libavcodec/msvideo1.c
index a9d94f8f571021214c9d8d7c84b1a68a00b01970..b2e98a015b6248c81052b63262bbb89b595a229c 100644
--- a/libavcodec/msvideo1.c
+++ b/libavcodec/msvideo1.c
@@ -333,7 +333,7 @@ static av_cold int msvideo1_decode_end(AVCodecContext *avctx)
 
 AVCodec msvideo1_decoder = {
     "msvideo1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_MSVIDEO1,
     sizeof(Msvideo1Context),
     msvideo1_decode_init,
diff --git a/libavcodec/nellymoserdec.c b/libavcodec/nellymoserdec.c
index a2c67f65e024d9489756accbaf2ca7018237116a..95e8ed58785881e7941238d436afb236fefe7c79 100644
--- a/libavcodec/nellymoserdec.c
+++ b/libavcodec/nellymoserdec.c
@@ -200,7 +200,7 @@ static av_cold int decode_end(AVCodecContext * avctx) {
 
 AVCodec nellymoser_decoder = {
     "nellymoser",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_NELLYMOSER,
     sizeof(NellyMoserDecodeContext),
     decode_init,
diff --git a/libavcodec/nellymoserenc.c b/libavcodec/nellymoserenc.c
index 95ab22fa3ee66bfead5e75aec27d59b2f810572f..3ea2763b7851daf4c6bbd4a98bf9852873abf0d2 100644
--- a/libavcodec/nellymoserenc.c
+++ b/libavcodec/nellymoserenc.c
@@ -384,7 +384,7 @@ static int encode_frame(AVCodecContext *avctx, uint8_t *frame, int buf_size, voi
 
 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,
diff --git a/libavcodec/nuv.c b/libavcodec/nuv.c
index dfc26e4ebcd054eaa9fa920823ea956e16888773..791f45091378630566ec42f922c6481ac692025c 100644
--- a/libavcodec/nuv.c
+++ b/libavcodec/nuv.c
@@ -274,7 +274,7 @@ static av_cold int decode_end(AVCodecContext *avctx) {
 
 AVCodec nuv_decoder = {
     "nuv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_NUV,
     sizeof(NuvContext),
     decode_init,
diff --git a/libavcodec/options.c b/libavcodec/options.c
index eae0205640a669f64e6bae8b8c3814e6dcd48fa8..89b25483c219378610bdee7b59876244b2c507d8 100644
--- a/libavcodec/options.c
+++ b/libavcodec/options.c
@@ -423,18 +423,18 @@ static const AVOption options[]={
 
 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);
 
@@ -453,7 +453,7 @@ void avcodec_get_context_defaults2(AVCodecContext *s, enum CodecType codec_type)
     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;
@@ -464,10 +464,10 @@ AVCodecContext *avcodec_alloc_context2(enum CodecType codec_type){
 }
 
 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);
 }
 
diff --git a/libavcodec/pamenc.c b/libavcodec/pamenc.c
index 1239521a7aeb5885067a008a4d988389c156f745..ae0ea3a102bff1e8a884b85dc21639e376f6a73f 100644
--- a/libavcodec/pamenc.c
+++ b/libavcodec/pamenc.c
@@ -110,7 +110,7 @@ static int pam_encode_frame(AVCodecContext *avctx, unsigned char *outbuf,
 
 AVCodec pam_encoder = {
     "pam",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PAM,
     sizeof(PNMContext),
     ff_pnm_init,
diff --git a/libavcodec/pcm-mpeg.c b/libavcodec/pcm-mpeg.c
index ec5f19bef4af5753d3fd959527629ed48e11b719..20c1db92f1050334cec465202e8ea532167cfbdd 100644
--- a/libavcodec/pcm-mpeg.c
+++ b/libavcodec/pcm-mpeg.c
@@ -297,7 +297,7 @@ static int pcm_bluray_decode_frame(AVCodecContext *avctx,
 
 AVCodec pcm_bluray_decoder = {
     "pcm_bluray",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_PCM_BLURAY,
     0,
     NULL,
diff --git a/libavcodec/pcm.c b/libavcodec/pcm.c
index 572ee947e57dea17fc1d233d32bf7b1c6f6f94d8..1298121facdef19f03c9eeac5507bc6af2103dad 100644
--- a/libavcodec/pcm.c
+++ b/libavcodec/pcm.c
@@ -516,7 +516,7 @@ static int pcm_decode_frame(AVCodecContext *avctx,
 #define PCM_ENCODER(id,sample_fmt_,name,long_name_) \
 AVCodec name ## _encoder = {                    \
     #name,                                      \
-    CODEC_TYPE_AUDIO,                           \
+    AVMEDIA_TYPE_AUDIO,                         \
     id,                                         \
     0,                                          \
     pcm_encode_init,                            \
@@ -534,7 +534,7 @@ AVCodec name ## _encoder = {                    \
 #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,                            \
diff --git a/libavcodec/pcx.c b/libavcodec/pcx.c
index bbca8bce7ad97cadb4be82acfaa900275964d65f..2174184bced855155772a505aa4c73a9e4a20f37 100644
--- a/libavcodec/pcx.c
+++ b/libavcodec/pcx.c
@@ -244,7 +244,7 @@ static av_cold int pcx_end(AVCodecContext *avctx) {
 
 AVCodec pcx_decoder = {
     "pcx",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PCX,
     sizeof(PCXContext),
     pcx_init,
diff --git a/libavcodec/pcxenc.c b/libavcodec/pcxenc.c
index 17fa3c2f472cbd6d2164d7aea7afe17bcc36bdc2..43ebc8720aa3637036afba6cecd3f5582a2a8d44 100644
--- a/libavcodec/pcxenc.c
+++ b/libavcodec/pcxenc.c
@@ -191,7 +191,7 @@ static int pcx_encode_frame(AVCodecContext *avctx,
 
 AVCodec pcx_encoder = {
     "pcx",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PCX,
     sizeof(PCXContext),
     pcx_encode_init,
diff --git a/libavcodec/pgssubdec.c b/libavcodec/pgssubdec.c
index 5041d3a3d955dabe17c0bf2da8f68690ef9ed26a..85db88ebac1f44a437ff8785b9ed54c3ce4684af 100644
--- a/libavcodec/pgssubdec.c
+++ b/libavcodec/pgssubdec.c
@@ -454,7 +454,7 @@ static int decode(AVCodecContext *avctx, void *data, int *data_size,
 
 AVCodec pgssub_decoder = {
     "pgssub",
-    CODEC_TYPE_SUBTITLE,
+    AVMEDIA_TYPE_SUBTITLE,
     CODEC_ID_HDMV_PGS_SUBTITLE,
     sizeof(PGSSubContext),
     init_decoder,
diff --git a/libavcodec/pngdec.c b/libavcodec/pngdec.c
index 6cce626fd361f5df94cca9f0694231548637a7b3..382ba524cc0b34de4c1a91fa98fdf2374bd0ef1f 100644
--- a/libavcodec/pngdec.c
+++ b/libavcodec/pngdec.c
@@ -656,7 +656,7 @@ static av_cold int png_dec_end(AVCodecContext *avctx)
 
 AVCodec png_decoder = {
     "png",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PNG,
     sizeof(PNGDecContext),
     png_dec_init,
diff --git a/libavcodec/pngenc.c b/libavcodec/pngenc.c
index 4638095e11a5178bfd28a94c9f4b38840dc55ebe..615bcc44cc926bcba7c3a8ccaa5aab19ba2af725 100644
--- a/libavcodec/pngenc.c
+++ b/libavcodec/pngenc.c
@@ -438,7 +438,7 @@ static av_cold int png_enc_init(AVCodecContext *avctx){
 
 AVCodec png_encoder = {
     "png",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PNG,
     sizeof(PNGEncContext),
     png_enc_init,
diff --git a/libavcodec/pnmdec.c b/libavcodec/pnmdec.c
index 5630e7689cb24946491c8f5e1abdc9f6f745f78c..66033c1f4e9e63f0168903cedea7da3ca57e55c8 100644
--- a/libavcodec/pnmdec.c
+++ b/libavcodec/pnmdec.c
@@ -190,7 +190,7 @@ static int pnm_decode_frame(AVCodecContext *avctx, void *data,
 #if CONFIG_PGM_DECODER
 AVCodec pgm_decoder = {
     "pgm",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PGM,
     sizeof(PNMContext),
     ff_pnm_init,
@@ -206,7 +206,7 @@ AVCodec pgm_decoder = {
 #if CONFIG_PGMYUV_DECODER
 AVCodec pgmyuv_decoder = {
     "pgmyuv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PGMYUV,
     sizeof(PNMContext),
     ff_pnm_init,
@@ -222,7 +222,7 @@ AVCodec pgmyuv_decoder = {
 #if CONFIG_PPM_DECODER
 AVCodec ppm_decoder = {
     "ppm",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PPM,
     sizeof(PNMContext),
     ff_pnm_init,
@@ -238,7 +238,7 @@ AVCodec ppm_decoder = {
 #if CONFIG_PBM_DECODER
 AVCodec pbm_decoder = {
     "pbm",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PBM,
     sizeof(PNMContext),
     ff_pnm_init,
@@ -254,7 +254,7 @@ AVCodec pbm_decoder = {
 #if CONFIG_PAM_DECODER
 AVCodec pam_decoder = {
     "pam",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PAM,
     sizeof(PNMContext),
     ff_pnm_init,
diff --git a/libavcodec/pnmenc.c b/libavcodec/pnmenc.c
index b14a15193781517020f794841e50803ffa52fb88..1fbf6658835433eee8cad0be143c1c9b8e8f2f5b 100644
--- a/libavcodec/pnmenc.c
+++ b/libavcodec/pnmenc.c
@@ -115,7 +115,7 @@ static int pnm_encode_frame(AVCodecContext *avctx, unsigned char *outbuf,
 #if CONFIG_PGM_ENCODER
 AVCodec pgm_encoder = {
     "pgm",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PGM,
     sizeof(PNMContext),
     ff_pnm_init,
@@ -128,7 +128,7 @@ AVCodec pgm_encoder = {
 #if CONFIG_PGMYUV_ENCODER
 AVCodec pgmyuv_encoder = {
     "pgmyuv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PGMYUV,
     sizeof(PNMContext),
     ff_pnm_init,
@@ -141,7 +141,7 @@ AVCodec pgmyuv_encoder = {
 #if CONFIG_PPM_ENCODER
 AVCodec ppm_encoder = {
     "ppm",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PPM,
     sizeof(PNMContext),
     ff_pnm_init,
@@ -154,7 +154,7 @@ AVCodec ppm_encoder = {
 #if CONFIG_PBM_ENCODER
 AVCodec pbm_encoder = {
     "pbm",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PBM,
     sizeof(PNMContext),
     ff_pnm_init,
diff --git a/libavcodec/ptx.c b/libavcodec/ptx.c
index f5aa601cde5c2da1f7c7d045759026f0598b88cf..d8798f2e9c8d32c0b9dd4350aa4b34e54c8d505f 100644
--- a/libavcodec/ptx.c
+++ b/libavcodec/ptx.c
@@ -107,7 +107,7 @@ static av_cold int ptx_end(AVCodecContext *avctx) {
 
 AVCodec ptx_decoder = {
     "ptx",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_PTX,
     sizeof(PTXContext),
     ptx_init,
diff --git a/libavcodec/qcelpdec.c b/libavcodec/qcelpdec.c
index 285de1baa546c6e25fd320c7dc3f7d2c36da70c9..15481e0a91751d48a694dcf888932aa1bc5b618f 100644
--- a/libavcodec/qcelpdec.c
+++ b/libavcodec/qcelpdec.c
@@ -813,7 +813,7 @@ erasure:
 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,
diff --git a/libavcodec/qdm2.c b/libavcodec/qdm2.c
index 031bf2f3a488820c28564eedb5234efecc6c699d..33d4824e7b9fa91062ab5caa354ed4d28e67c0cb 100644
--- a/libavcodec/qdm2.c
+++ b/libavcodec/qdm2.c
@@ -1974,7 +1974,7 @@ static int qdm2_decode_frame(AVCodecContext *avctx,
 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,
diff --git a/libavcodec/qdrw.c b/libavcodec/qdrw.c
index f0c0350c23afedf6468f5ed20b44d9ccf27e42ca..594ef8c768fb44d565029dc7e0fa6d30c164bfe2 100644
--- a/libavcodec/qdrw.c
+++ b/libavcodec/qdrw.c
@@ -152,7 +152,7 @@ static av_cold int decode_end(AVCodecContext *avctx){
 
 AVCodec qdraw_decoder = {
     "qdraw",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_QDRAW,
     sizeof(QdrawContext),
     decode_init,
diff --git a/libavcodec/qpeg.c b/libavcodec/qpeg.c
index 6b5d8732d955abbc4323dc9b2898bedf674231bd..e72afd1dd951d7513f0536a4298e1b3812ee4ffe 100644
--- a/libavcodec/qpeg.c
+++ b/libavcodec/qpeg.c
@@ -313,7 +313,7 @@ static av_cold int decode_end(AVCodecContext *avctx){
 
 AVCodec qpeg_decoder = {
     "qpeg",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_QPEG,
     sizeof(QpegContext),
     decode_init,
diff --git a/libavcodec/qtrle.c b/libavcodec/qtrle.c
index dcb76ecfe50ccc075840c70c285bc25d01588e04..dc300f00ac5c28f726e1a655603816b2bd55140a 100644
--- a/libavcodec/qtrle.c
+++ b/libavcodec/qtrle.c
@@ -539,7 +539,7 @@ static av_cold int qtrle_decode_end(AVCodecContext *avctx)
 
 AVCodec qtrle_decoder = {
     "qtrle",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_QTRLE,
     sizeof(QtrleContext),
     qtrle_decode_init,
diff --git a/libavcodec/qtrleenc.c b/libavcodec/qtrleenc.c
index 259a377ef05a4d9046666b7205228e878960da77..7f95c7f5a4aa47ee3b30a4a1fe47eea814d56aa2 100644
--- a/libavcodec/qtrleenc.c
+++ b/libavcodec/qtrleenc.c
@@ -322,7 +322,7 @@ static av_cold int qtrle_encode_end(AVCodecContext *avctx)
 
 AVCodec qtrle_encoder = {
     "qtrle",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_QTRLE,
     sizeof(QtrleEncContext),
     qtrle_encode_init,
diff --git a/libavcodec/r210dec.c b/libavcodec/r210dec.c
index 0b100e5f7df2110d8a44f5d9107d427d1313b251..416f76498c2408965bed563c934b1a2a8b7e6615 100644
--- a/libavcodec/r210dec.c
+++ b/libavcodec/r210dec.c
@@ -92,7 +92,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
 
 AVCodec r210_decoder = {
     "r210",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_R210,
     0,
     decode_init,
diff --git a/libavcodec/ra144.c b/libavcodec/ra144.c
index deda412b2a5a3a83e22bff459a8ada7a2bdfd87e..efa62c49137885cf4996cb5ccd50d7cc19d66483 100644
--- a/libavcodec/ra144.c
+++ b/libavcodec/ra144.c
@@ -353,7 +353,7 @@ static int ra144_decode_frame(AVCodecContext * avctx, void *vdata,
 AVCodec ra_144_decoder =
 {
     "real_144",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_RA_144,
     sizeof(RA144Context),
     ra144_decode_init,
diff --git a/libavcodec/ra288.c b/libavcodec/ra288.c
index abc7df51bd65f7c620c910b74141ab3adc8a0ff9..c74b5f78dfd4e29c5e753653eda33602f5dd4e4c 100644
--- a/libavcodec/ra288.c
+++ b/libavcodec/ra288.c
@@ -206,7 +206,7 @@ static int ra288_decode_frame(AVCodecContext * avctx, void *data,
 AVCodec ra_288_decoder =
 {
     "real_288",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_RA_288,
     sizeof(RA288Context),
     ra288_decode_init,
diff --git a/libavcodec/rawdec.c b/libavcodec/rawdec.c
index b4c7b3c6d83b12290d563917d2476fd92cafe902..b2a3c99e87410bd5d807913ef4e9e8953f0c0656 100644
--- a/libavcodec/rawdec.c
+++ b/libavcodec/rawdec.c
@@ -185,7 +185,7 @@ static av_cold int raw_close_decoder(AVCodecContext *avctx)
 
 AVCodec rawvideo_decoder = {
     "rawvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_RAWVIDEO,
     sizeof(RawVideoContext),
     raw_init_decoder,
diff --git a/libavcodec/rawenc.c b/libavcodec/rawenc.c
index b7924a97ac7a3eeeeb7df32108554bd5c70b1014..8a9bb311b662793d4fb192e6af60f08c0e424b48 100644
--- a/libavcodec/rawenc.c
+++ b/libavcodec/rawenc.c
@@ -57,7 +57,7 @@ static int raw_encode(AVCodecContext *avctx,
 
 AVCodec rawvideo_encoder = {
     "rawvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_RAWVIDEO,
     sizeof(AVFrame),
     raw_init_encoder,
diff --git a/libavcodec/rl2.c b/libavcodec/rl2.c
index 721e5706acf3072b37d99c7312abbbbf451d66ce..0e582754b67f9d58485317c16019c018dfa60a3d 100644
--- a/libavcodec/rl2.c
+++ b/libavcodec/rl2.c
@@ -230,7 +230,7 @@ static av_cold int rl2_decode_end(AVCodecContext *avctx)
 
 AVCodec rl2_decoder = {
     "rl2",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_RL2,
     sizeof(Rl2Context),
     rl2_decode_init,
diff --git a/libavcodec/roqaudioenc.c b/libavcodec/roqaudioenc.c
index b44d5d382a0f1e8925a604fde14a04da53d35f7b..11fd6f06cb19eb2fe6683ceaafc9ea1f811da36d 100644
--- a/libavcodec/roqaudioenc.c
+++ b/libavcodec/roqaudioenc.c
@@ -155,7 +155,7 @@ static av_cold int roq_dpcm_encode_close(AVCodecContext *avctx)
 
 AVCodec roq_dpcm_encoder = {
     "roq_dpcm",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_ROQ_DPCM,
     sizeof(ROQDPCMContext),
     roq_dpcm_encode_init,
diff --git a/libavcodec/roqvideodec.c b/libavcodec/roqvideodec.c
index 8e3bdb0dc30ce86d8c061453f3766e3ba381737e..a762adbc8892de99081dd263a8670928191699ab 100644
--- a/libavcodec/roqvideodec.c
+++ b/libavcodec/roqvideodec.c
@@ -212,7 +212,7 @@ static av_cold int roq_decode_end(AVCodecContext *avctx)
 
 AVCodec roq_decoder = {
     "roqvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ROQ,
     sizeof(RoqContext),
     roq_decode_init,
diff --git a/libavcodec/roqvideoenc.c b/libavcodec/roqvideoenc.c
index 8dc77bd414cdd8a71db6ff69f4689f71ded820e8..0326dee3687bb851509a143ff9af7af404f360c0 100644
--- a/libavcodec/roqvideoenc.c
+++ b/libavcodec/roqvideoenc.c
@@ -1057,7 +1057,7 @@ static int roq_encode_end(AVCodecContext *avctx)
 AVCodec roq_encoder =
 {
     "roqvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ROQ,
     sizeof(RoqContext),
     roq_encode_init,
diff --git a/libavcodec/rpza.c b/libavcodec/rpza.c
index e24508df49f26c295bf7b70a076ffd289c30cc4d..1ddb5aad627b60d86a1cab2216e0c68460cded72 100644
--- a/libavcodec/rpza.c
+++ b/libavcodec/rpza.c
@@ -277,7 +277,7 @@ static av_cold int rpza_decode_end(AVCodecContext *avctx)
 
 AVCodec rpza_decoder = {
     "rpza",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_RPZA,
     sizeof(RpzaContext),
     rpza_decode_init,
diff --git a/libavcodec/rv10.c b/libavcodec/rv10.c
index 47399164756599c26ae9169ef967a57999efcd6c..7fb1af91d6dda11ff143076807610527b8b0c951 100644
--- a/libavcodec/rv10.c
+++ b/libavcodec/rv10.c
@@ -708,7 +708,7 @@ static int rv10_decode_frame(AVCodecContext *avctx,
 
 AVCodec rv10_decoder = {
     "rv10",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_RV10,
     sizeof(MpegEncContext),
     rv10_decode_init,
@@ -722,7 +722,7 @@ AVCodec rv10_decoder = {
 
 AVCodec rv20_decoder = {
     "rv20",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_RV20,
     sizeof(MpegEncContext),
     rv10_decode_init,
diff --git a/libavcodec/rv10enc.c b/libavcodec/rv10enc.c
index db0e6edec482c92c5941980e883e3dec7e9898f1..333a108c489a610d641bf8521cdae9b50f65eb9e 100644
--- a/libavcodec/rv10enc.c
+++ b/libavcodec/rv10enc.c
@@ -58,7 +58,7 @@ void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
 
 AVCodec rv10_encoder = {
     "rv10",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_RV10,
     sizeof(MpegEncContext),
     MPV_encode_init,
diff --git a/libavcodec/rv20enc.c b/libavcodec/rv20enc.c
index e25a1bc4522e9875a3c2b6d90d1040e918a9ccf6..ac43891c39c37c4f453322acf9e2c257d782c3a9 100644
--- a/libavcodec/rv20enc.c
+++ b/libavcodec/rv20enc.c
@@ -59,7 +59,7 @@ void rv20_encode_picture_header(MpegEncContext *s, int picture_number){
 
 AVCodec rv20_encoder = {
     "rv20",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_RV20,
     sizeof(MpegEncContext),
     MPV_encode_init,
diff --git a/libavcodec/rv30.c b/libavcodec/rv30.c
index 4cb2c3d9009485674c026bf394653855cea0a398..8bab0bba09fde707dc73bf0753b4903e5936abba 100644
--- a/libavcodec/rv30.c
+++ b/libavcodec/rv30.c
@@ -268,7 +268,7 @@ static av_cold int rv30_decode_init(AVCodecContext *avctx)
 
 AVCodec rv30_decoder = {
     "rv30",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_RV30,
     sizeof(RV34DecContext),
     rv30_decode_init,
diff --git a/libavcodec/rv40.c b/libavcodec/rv40.c
index baf2d6a34d674f562789e43200fce2671858d139..2eb030d8336b1b0892517afcd47a821f68997a5e 100644
--- a/libavcodec/rv40.c
+++ b/libavcodec/rv40.c
@@ -668,7 +668,7 @@ static av_cold int rv40_decode_init(AVCodecContext *avctx)
 
 AVCodec rv40_decoder = {
     "rv40",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_RV40,
     sizeof(RV34DecContext),
     rv40_decode_init,
diff --git a/libavcodec/sgidec.c b/libavcodec/sgidec.c
index 2670140b286e733f0a4edc4d4d159942abc1a8a6..bbfd94bdf0e87f8c793c1f9a731c7c5098484fef 100644
--- a/libavcodec/sgidec.c
+++ b/libavcodec/sgidec.c
@@ -260,7 +260,7 @@ static av_cold int sgi_end(AVCodecContext *avctx)
 
 AVCodec sgi_decoder = {
     "sgi",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_SGI,
     sizeof(SgiState),
     sgi_init,
diff --git a/libavcodec/sgienc.c b/libavcodec/sgienc.c
index 7c2bcae52824e1fe07d03ca5e09840fd053edb8b..f9f3709788c79f93aa4025876483f3395973829e 100644
--- a/libavcodec/sgienc.c
+++ b/libavcodec/sgienc.c
@@ -161,7 +161,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf,
 
 AVCodec sgi_encoder = {
     "sgi",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_SGI,
     sizeof(SgiContext),
     encode_init,
diff --git a/libavcodec/shorten.c b/libavcodec/shorten.c
index 328aaccd29828b1c5a470c0687abc992092ebb73..0dd07dd83cf900e32c09acaf32f54798cefe3d8d 100644
--- a/libavcodec/shorten.c
+++ b/libavcodec/shorten.c
@@ -527,7 +527,7 @@ static void shorten_flush(AVCodecContext *avctx){
 
 AVCodec shorten_decoder = {
     "shorten",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_SHORTEN,
     sizeof(ShortenContext),
     shorten_decode_init,
diff --git a/libavcodec/sipr.c b/libavcodec/sipr.c
index d2ce9c789720b62314a6cdfc32f360ba4e0af9bf..fc19ecd710aa9c40805b466a1bafb55ee48b755a 100644
--- a/libavcodec/sipr.c
+++ b/libavcodec/sipr.c
@@ -579,7 +579,7 @@ static int sipr_decode_frame(AVCodecContext *avctx, void *datap,
 
 AVCodec sipr_decoder = {
     "sipr",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_SIPR,
     sizeof(SiprContext),
     sipr_decoder_init,
diff --git a/libavcodec/smacker.c b/libavcodec/smacker.c
index 19f0b289e5586e1437b78296a4030f761db3effc..a7134f227d04df6a82d0bc66ecf2476af646f06e 100644
--- a/libavcodec/smacker.c
+++ b/libavcodec/smacker.c
@@ -691,7 +691,7 @@ static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 
 AVCodec smacker_decoder = {
     "smackvid",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_SMACKVIDEO,
     sizeof(SmackVContext),
     decode_init,
@@ -704,7 +704,7 @@ AVCodec smacker_decoder = {
 
 AVCodec smackaud_decoder = {
     "smackaud",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_SMACKAUDIO,
     0,
     smka_decode_init,
diff --git a/libavcodec/smc.c b/libavcodec/smc.c
index f63dc1e6ac91304321c6bcbddca69e5b59908838..7891220c35ebe94110b4f605393b8def8412224c 100644
--- a/libavcodec/smc.c
+++ b/libavcodec/smc.c
@@ -473,7 +473,7 @@ static av_cold int smc_decode_end(AVCodecContext *avctx)
 
 AVCodec smc_decoder = {
     "smc",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_SMC,
     sizeof(SmcContext),
     smc_decode_init,
diff --git a/libavcodec/snow.c b/libavcodec/snow.c
index ad28d6484d8cdd3a1169d848eaeb96a1fe1bd800..5ef9e5e811a90b6431b304e71e1c81e190435007 100644
--- a/libavcodec/snow.c
+++ b/libavcodec/snow.c
@@ -2237,7 +2237,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec snow_decoder = {
     "snow",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_SNOW,
     sizeof(SnowContext),
     decode_init,
@@ -3988,7 +3988,7 @@ static av_cold int encode_end(AVCodecContext *avctx)
 
 AVCodec snow_encoder = {
     "snow",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_SNOW,
     sizeof(SnowContext),
     encode_init,
diff --git a/libavcodec/sonic.c b/libavcodec/sonic.c
index 178ae01528859141492de159649c7e6c65ec25ba..570dd245d0ebbc235824896af20fb9fa0009a8ca 100644
--- a/libavcodec/sonic.c
+++ b/libavcodec/sonic.c
@@ -937,7 +937,7 @@ static int sonic_decode_frame(AVCodecContext *avctx,
 
 AVCodec sonic_decoder = {
     "sonic",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_SONIC,
     sizeof(SonicContext),
     sonic_decode_init,
@@ -951,7 +951,7 @@ AVCodec sonic_decoder = {
 #if CONFIG_SONIC_ENCODER
 AVCodec sonic_encoder = {
     "sonic",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_SONIC,
     sizeof(SonicContext),
     sonic_encode_init,
@@ -965,7 +965,7 @@ AVCodec sonic_encoder = {
 #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,
diff --git a/libavcodec/sp5xdec.c b/libavcodec/sp5xdec.c
index 13cce225a2e3a357063c1150fc6aa4605c8de58a..d0b4b8cc56c0475f434cb3add4fe88e31f49988d 100644
--- a/libavcodec/sp5xdec.c
+++ b/libavcodec/sp5xdec.c
@@ -195,7 +195,7 @@ static int sp5x_decode_frame(AVCodecContext *avctx,
 
 AVCodec sp5x_decoder = {
     "sp5x",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_SP5X,
     sizeof(MJpegDecodeContext),
     ff_mjpeg_decode_init,
@@ -209,7 +209,7 @@ AVCodec sp5x_decoder = {
 
 AVCodec amv_decoder = {
     "amv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_AMV,
     sizeof(MJpegDecodeContext),
     ff_mjpeg_decode_init,
diff --git a/libavcodec/sunrast.c b/libavcodec/sunrast.c
index e5e0f73cb88e5d941c8811c9b10432937aab97a9..456ab85a88aab7017b13800bf726c791e8108e3f 100644
--- a/libavcodec/sunrast.c
+++ b/libavcodec/sunrast.c
@@ -185,7 +185,7 @@ static av_cold int sunrast_end(AVCodecContext *avctx) {
 
 AVCodec sunrast_decoder = {
     "sunrast",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_SUNRAST,
     sizeof(SUNRASTContext),
     sunrast_init,
diff --git a/libavcodec/svq1dec.c b/libavcodec/svq1dec.c
index 7bc18f604e86e0217c68d4eec25f54473a06102d..3834afb14a9fcd18710216d96561c70453994047 100644
--- a/libavcodec/svq1dec.c
+++ b/libavcodec/svq1dec.c
@@ -828,7 +828,7 @@ static av_cold int svq1_decode_end(AVCodecContext *avctx)
 
 AVCodec svq1_decoder = {
     "svq1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_SVQ1,
     sizeof(MpegEncContext),
     svq1_decode_init,
diff --git a/libavcodec/svq1enc.c b/libavcodec/svq1enc.c
index 3432bb9c5f856627b60fc36a566248d1f5bd2209..03c77ffcd6aef052e361c12e0785b57cae68eda2 100644
--- a/libavcodec/svq1enc.c
+++ b/libavcodec/svq1enc.c
@@ -574,7 +574,7 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx)
 
 AVCodec svq1_encoder = {
     "svq1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_SVQ1,
     sizeof(SVQ1Context),
     svq1_encode_init,
diff --git a/libavcodec/svq3.c b/libavcodec/svq3.c
index 8ece9a9b52e0103c8bd31196e840ad7b44a45fac..50de623cba8e50aaf7df657fad8f220058d0527a 100644
--- a/libavcodec/svq3.c
+++ b/libavcodec/svq3.c
@@ -1071,7 +1071,7 @@ static int svq3_decode_frame(AVCodecContext *avctx,
 
 AVCodec svq3_decoder = {
     "svq3",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_SVQ3,
     sizeof(H264Context),
     svq3_decode_init,
diff --git a/libavcodec/targa.c b/libavcodec/targa.c
index b6fe5dfed593ec3b37e2bd587434db2856fb971d..50fe107ea9fd0ceea022fd166b1ad4bd6c25243a 100644
--- a/libavcodec/targa.c
+++ b/libavcodec/targa.c
@@ -243,7 +243,7 @@ static av_cold int targa_end(AVCodecContext *avctx){
 
 AVCodec targa_decoder = {
     "targa",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_TARGA,
     sizeof(TargaContext),
     targa_init,
diff --git a/libavcodec/targaenc.c b/libavcodec/targaenc.c
index fa886755c1a6b43e8e89f7c99a87d2f93809f7b4..e5d0042ecb04229348bda91d1aafb4069601ed45 100644
--- a/libavcodec/targaenc.c
+++ b/libavcodec/targaenc.c
@@ -153,7 +153,7 @@ static av_cold int targa_encode_init(AVCodecContext *avctx)
 
 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,
diff --git a/libavcodec/tiertexseqv.c b/libavcodec/tiertexseqv.c
index 66055937feab50d5875d3477dace3b70ad2b9d6d..3e29c46fe246985a6e3221bc845ad4eb968d81ea 100644
--- a/libavcodec/tiertexseqv.c
+++ b/libavcodec/tiertexseqv.c
@@ -221,7 +221,7 @@ static av_cold int seqvideo_decode_end(AVCodecContext *avctx)
 
 AVCodec tiertexseqvideo_decoder = {
     "tiertexseqvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_TIERTEXSEQVIDEO,
     sizeof(SeqVideoContext),
     seqvideo_decode_init,
diff --git a/libavcodec/tiff.c b/libavcodec/tiff.c
index f8f3cbde95d8d1709e86974e0a6271d9b5acdc2b..e02767caadb1602166abe892ebffc0befe9caeba 100644
--- a/libavcodec/tiff.c
+++ b/libavcodec/tiff.c
@@ -592,7 +592,7 @@ static av_cold int tiff_end(AVCodecContext *avctx)
 
 AVCodec tiff_decoder = {
     "tiff",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_TIFF,
     sizeof(TiffContext),
     tiff_init,
diff --git a/libavcodec/tiffenc.c b/libavcodec/tiffenc.c
index 1d6b5b01f713519eea7d0b753696a665c14296b7..0cc8655b6d7b8e5f2e7ebf058f23503d9da277bb 100644
--- a/libavcodec/tiffenc.c
+++ b/libavcodec/tiffenc.c
@@ -444,7 +444,7 @@ fail:
 
 AVCodec tiff_encoder = {
     "tiff",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_TIFF,
     sizeof(TiffEncoderContext),
     NULL,
diff --git a/libavcodec/tmv.c b/libavcodec/tmv.c
index 29aaae1fe71b339a063209dd8e6e572ca0f4a88b..827d8a618371a5fc85bf106dd22eb45d4fbbff80 100644
--- a/libavcodec/tmv.c
+++ b/libavcodec/tmv.c
@@ -100,7 +100,7 @@ static av_cold int tmv_decode_close(AVCodecContext *avctx)
 
 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,
diff --git a/libavcodec/truemotion1.c b/libavcodec/truemotion1.c
index ae08bfe0b2337dd9e898ea43e9f98d6e0eb24bf4..2e8b72080af0318b755def61ba3dae970e4d8795 100644
--- a/libavcodec/truemotion1.c
+++ b/libavcodec/truemotion1.c
@@ -892,7 +892,7 @@ static av_cold int truemotion1_decode_end(AVCodecContext *avctx)
 
 AVCodec truemotion1_decoder = {
     "truemotion1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_TRUEMOTION1,
     sizeof(TrueMotion1Context),
     truemotion1_decode_init,
diff --git a/libavcodec/truemotion2.c b/libavcodec/truemotion2.c
index 44b89e70d16e3abc97413ab858700ed43ae8e7e1..4a5a2edf4035e51c862d381b73c4fddedf0b5cbb 100644
--- a/libavcodec/truemotion2.c
+++ b/libavcodec/truemotion2.c
@@ -872,7 +872,7 @@ static av_cold int decode_end(AVCodecContext *avctx){
 
 AVCodec truemotion2_decoder = {
     "truemotion2",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_TRUEMOTION2,
     sizeof(TM2Context),
     decode_init,
diff --git a/libavcodec/truespeech.c b/libavcodec/truespeech.c
index 598d414832a3e8f8d9e7198f22ec8d838f355a3f..da5f2636d732843cf80b8b5110a88a5c7d96ccf8 100644
--- a/libavcodec/truespeech.c
+++ b/libavcodec/truespeech.c
@@ -378,7 +378,7 @@ static int truespeech_decode_frame(AVCodecContext *avctx,
 
 AVCodec truespeech_decoder = {
     "truespeech",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_TRUESPEECH,
     sizeof(TSContext),
     truespeech_decode_init,
diff --git a/libavcodec/tscc.c b/libavcodec/tscc.c
index bf82c6302b451320de2a5b5e90b12aba2ec1ca43..d200c8aabd3ef719f759b3809e6a9317a993a989 100644
--- a/libavcodec/tscc.c
+++ b/libavcodec/tscc.c
@@ -199,7 +199,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec tscc_decoder = {
         "camtasia",
-        CODEC_TYPE_VIDEO,
+        AVMEDIA_TYPE_VIDEO,
         CODEC_ID_TSCC,
         sizeof(CamtasiaContext),
         decode_init,
diff --git a/libavcodec/tta.c b/libavcodec/tta.c
index 77f9978c090bf0296e9f1d6ffe76d9bfd3ea7041..68c9840465ec3589d056a11eb36480207bb2ca4e 100644
--- a/libavcodec/tta.c
+++ b/libavcodec/tta.c
@@ -449,7 +449,7 @@ static av_cold int tta_decode_close(AVCodecContext *avctx) {
 
 AVCodec tta_decoder = {
     "tta",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_TTA,
     sizeof(TTAContext),
     tta_decode_init,
diff --git a/libavcodec/twinvq.c b/libavcodec/twinvq.c
index e460ea9623cad716780b59aa4b975e0aec64ca6f..1aa66661d6a180909d5ab7c83cce6a230e860696 100644
--- a/libavcodec/twinvq.c
+++ b/libavcodec/twinvq.c
@@ -1119,7 +1119,7 @@ static av_cold int twin_decode_close(AVCodecContext *avctx)
 AVCodec twinvq_decoder =
 {
     "twinvq",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_TWINVQ,
     sizeof(TwinContext),
     twin_decode_init,
diff --git a/libavcodec/txd.c b/libavcodec/txd.c
index 5065d08f19eabb1334c8b79b715dbf6b8d466e67..ac8229f9e430aea9ab7326f632281137e7d61209 100644
--- a/libavcodec/txd.c
+++ b/libavcodec/txd.c
@@ -156,7 +156,7 @@ static av_cold int txd_end(AVCodecContext *avctx) {
 
 AVCodec txd_decoder = {
     "txd",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_TXD,
     sizeof(TXDContext),
     txd_init,
diff --git a/libavcodec/ulti.c b/libavcodec/ulti.c
index 12dc6ac14f071564b8d272168a85d2f4ab7a9697..f53690f4d0e06e9a9b2ee65ae492e488f5d2c7b8 100644
--- a/libavcodec/ulti.c
+++ b/libavcodec/ulti.c
@@ -406,7 +406,7 @@ static int ulti_decode_frame(AVCodecContext *avctx,
 
 AVCodec ulti_decoder = {
     "ultimotion",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ULTI,
     sizeof(UltimotionDecodeContext),
     ulti_decode_init,
diff --git a/libavcodec/utils.c b/libavcodec/utils.c
index e48cf6e4c8b07434bd6314212abfd99e200c3002..0abf07ce62bb21c32ea9f78ca9a8cbd09a02cac3 100644
--- a/libavcodec/utils.c
+++ b/libavcodec/utils.c
@@ -497,7 +497,7 @@ int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
     }
 
     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;
@@ -775,20 +775,20 @@ static int get_bit_rate(AVCodecContext *ctx)
     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:
@@ -836,7 +836,7 @@ void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
     }
 
     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)" : "");
@@ -871,7 +871,7 @@ void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
                      ", q=%d-%d", enc->qmin, enc->qmax);
         }
         break;
-    case CODEC_TYPE_AUDIO:
+    case AVMEDIA_TYPE_AUDIO:
         snprintf(buf, buf_size,
                  "Audio: %s",
                  codec_name);
@@ -886,13 +886,13 @@ void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
                      ", %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:
diff --git a/libavcodec/v210dec.c b/libavcodec/v210dec.c
index ceeccb634609f5117c57b40170196adf0e629b38..a1a0827bedc30902197cdd00271419c1f57ae6e7 100644
--- a/libavcodec/v210dec.c
+++ b/libavcodec/v210dec.c
@@ -122,7 +122,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
 
 AVCodec v210_decoder = {
     "v210",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_V210,
     0,
     decode_init,
diff --git a/libavcodec/v210enc.c b/libavcodec/v210enc.c
index 8f20f73d45ebcd17f196b061d0eb50b3c63a61bc..11e0e0eb7ab26266a06ee04ebb7cdef70e4322e2 100644
--- a/libavcodec/v210enc.c
+++ b/libavcodec/v210enc.c
@@ -119,7 +119,7 @@ static av_cold int encode_close(AVCodecContext *avctx)
 
 AVCodec v210_encoder = {
     "v210",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_V210,
     0,
     encode_init,
diff --git a/libavcodec/v210x.c b/libavcodec/v210x.c
index 089aa2c127b816115201c2aa7dd61dea2a4ce663..d869d64725cbe8c3c6d25cc5703ee6eb78bdf01d 100644
--- a/libavcodec/v210x.c
+++ b/libavcodec/v210x.c
@@ -134,7 +134,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
 
 AVCodec v210x_decoder = {
     "v210x",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_V210X,
     0,
     decode_init,
diff --git a/libavcodec/vaapi_h264.c b/libavcodec/vaapi_h264.c
index f49a54d1e21cb886f2b1991a74744b9ff91d9947..52f836330db4123f801a69558d67ee134f0669d5 100644
--- a/libavcodec/vaapi_h264.c
+++ b/libavcodec/vaapi_h264.c
@@ -336,7 +336,7 @@ static int decode_slice(AVCodecContext *avctx,
 
 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,
diff --git a/libavcodec/vaapi_mpeg2.c b/libavcodec/vaapi_mpeg2.c
index 21bc77863f6c07271b74492cf7cdff247b53c7b2..2e870dcfa0e179a2c1e26acca9f0a2556c99632e 100644
--- a/libavcodec/vaapi_mpeg2.c
+++ b/libavcodec/vaapi_mpeg2.c
@@ -140,7 +140,7 @@ static int vaapi_mpeg2_decode_slice(AVCodecContext *avctx, const uint8_t *buffer
 
 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,
diff --git a/libavcodec/vaapi_mpeg4.c b/libavcodec/vaapi_mpeg4.c
index 4e606f0f1d8830682b3c614c43d5ed73800698d2..466ce2fd915d68b392c80c66253ce4686ece66a9 100644
--- a/libavcodec/vaapi_mpeg4.c
+++ b/libavcodec/vaapi_mpeg4.c
@@ -151,7 +151,7 @@ static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer
 #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,
@@ -165,7 +165,7 @@ AVHWAccel mpeg4_vaapi_hwaccel = {
 #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,
diff --git a/libavcodec/vaapi_vc1.c b/libavcodec/vaapi_vc1.c
index 50a4ba266bf75d0f8a7efc03c2fa025a739ef1d8..992e1da4b1b80db5fcddb7543817ffb34e183a85 100644
--- a/libavcodec/vaapi_vc1.c
+++ b/libavcodec/vaapi_vc1.c
@@ -328,7 +328,7 @@ static int vaapi_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer,
 #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,
@@ -341,7 +341,7 @@ AVHWAccel wmv3_vaapi_hwaccel = {
 
 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,
diff --git a/libavcodec/vb.c b/libavcodec/vb.c
index 4dfac435ac33b575f7404d2f75f732432cc1eb1c..2d4d4e286d0355981b6e6c81354b6517e34e2dea 100644
--- a/libavcodec/vb.c
+++ b/libavcodec/vb.c
@@ -289,7 +289,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec vb_decoder = {
     "vb",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VB,
     sizeof(VBDecContext),
     decode_init,
diff --git a/libavcodec/vc1dec.c b/libavcodec/vc1dec.c
index ebd14cb1cb96e02f60ecf5b566901f4df2d19340..333afbd6b65276f4837ff41884d6eb3c93b8f8b2 100644
--- a/libavcodec/vc1dec.c
+++ b/libavcodec/vc1dec.c
@@ -3319,7 +3319,7 @@ static av_cold int vc1_decode_end(AVCodecContext *avctx)
 
 AVCodec vc1_decoder = {
     "vc1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VC1,
     sizeof(VC1Context),
     vc1_decode_init,
@@ -3335,7 +3335,7 @@ AVCodec vc1_decoder = {
 #if CONFIG_WMV3_DECODER
 AVCodec wmv3_decoder = {
     "wmv3",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_WMV3,
     sizeof(VC1Context),
     vc1_decode_init,
@@ -3352,7 +3352,7 @@ AVCodec wmv3_decoder = {
 #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,
@@ -3369,7 +3369,7 @@ AVCodec wmv3_vdpau_decoder = {
 #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,
diff --git a/libavcodec/vcr1.c b/libavcodec/vcr1.c
index ea2d5553a6c07ed88483c807e638cce9a570199b..7800859760003403d5cf27f03b9482c6008f1fbe 100644
--- a/libavcodec/vcr1.c
+++ b/libavcodec/vcr1.c
@@ -178,7 +178,7 @@ static av_cold int encode_init(AVCodecContext *avctx){
 
 AVCodec vcr1_decoder = {
     "vcr1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VCR1,
     sizeof(VCR1Context),
     decode_init,
@@ -192,7 +192,7 @@ AVCodec vcr1_decoder = {
 #if CONFIG_VCR1_ENCODER
 AVCodec vcr1_encoder = {
     "vcr1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VCR1,
     sizeof(VCR1Context),
     encode_init,
diff --git a/libavcodec/vmdav.c b/libavcodec/vmdav.c
index 79318b027766600098cf8b73c4c7e3262ce9d8d2..9e2d1a13c835e9e534b9d0ee6c1953cb2fd9e5b1 100644
--- a/libavcodec/vmdav.c
+++ b/libavcodec/vmdav.c
@@ -567,7 +567,7 @@ static int vmdaudio_decode_frame(AVCodecContext *avctx,
 
 AVCodec vmdvideo_decoder = {
     "vmdvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VMDVIDEO,
     sizeof(VmdVideoContext),
     vmdvideo_decode_init,
@@ -580,7 +580,7 @@ AVCodec vmdvideo_decoder = {
 
 AVCodec vmdaudio_decoder = {
     "vmdaudio",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_VMDAUDIO,
     sizeof(VmdAudioContext),
     vmdaudio_decode_init,
diff --git a/libavcodec/vmnc.c b/libavcodec/vmnc.c
index b4c07f76e46868fabea53cc3287cb33454668fb2..1b30f0af104258af3dd42389209f311ea101843f 100644
--- a/libavcodec/vmnc.c
+++ b/libavcodec/vmnc.c
@@ -510,7 +510,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec vmnc_decoder = {
     "vmnc",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VMNC,
     sizeof(VmncContext),
     decode_init,
diff --git a/libavcodec/vorbis_dec.c b/libavcodec/vorbis_dec.c
index ae45c1f74678448d3d1f5f38cd0d2f05d4e05b74..0676e87efe7b7c52c2f21c6c77d19d141ea1350a 100644
--- a/libavcodec/vorbis_dec.c
+++ b/libavcodec/vorbis_dec.c
@@ -1645,7 +1645,7 @@ static av_cold int vorbis_decode_close(AVCodecContext *avccontext)
 
 AVCodec vorbis_decoder = {
     "vorbis",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_VORBIS,
     sizeof(vorbis_context),
     vorbis_decode_init,
diff --git a/libavcodec/vorbis_enc.c b/libavcodec/vorbis_enc.c
index f33f431655c3dfbe9588aed6c16029bc8d603d20..862d16c878aa8f057f24eccc0d7939e60ba04b7f 100644
--- a/libavcodec/vorbis_enc.c
+++ b/libavcodec/vorbis_enc.c
@@ -1093,7 +1093,7 @@ static av_cold int vorbis_encode_close(AVCodecContext *avccontext)
 
 AVCodec vorbis_encoder = {
     "vorbis",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_VORBIS,
     sizeof(vorbis_enc_context),
     vorbis_encode_init,
diff --git a/libavcodec/vp3.c b/libavcodec/vp3.c
index cab3f2bd5e2bedea8981397f37a97e559a447f38..2dccbcdea4ed0e64350010a3919b9226e056b7be 100644
--- a/libavcodec/vp3.c
+++ b/libavcodec/vp3.c
@@ -2191,7 +2191,7 @@ static av_cold int theora_decode_init(AVCodecContext *avctx)
 
 AVCodec theora_decoder = {
     "theora",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_THEORA,
     sizeof(Vp3DecodeContext),
     theora_decode_init,
@@ -2206,7 +2206,7 @@ AVCodec theora_decoder = {
 
 AVCodec vp3_decoder = {
     "vp3",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VP3,
     sizeof(Vp3DecodeContext),
     vp3_decode_init,
diff --git a/libavcodec/vp5.c b/libavcodec/vp5.c
index 1f8434c731db408356f4189dda3e34f47dca1d03..41e649720200cc24631f08333df4d739ebaf0a74 100644
--- a/libavcodec/vp5.c
+++ b/libavcodec/vp5.c
@@ -286,7 +286,7 @@ static av_cold int vp5_decode_init(AVCodecContext *avctx)
 
 AVCodec vp5_decoder = {
     "vp5",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VP5,
     sizeof(VP56Context),
     vp5_decode_init,
diff --git a/libavcodec/vp6.c b/libavcodec/vp6.c
index b3dd80ffbf35f2d30e9abb7a42667e855493a3e6..53e2ca25ed2deb4309c559a565da992c4e561ceb 100644
--- a/libavcodec/vp6.c
+++ b/libavcodec/vp6.c
@@ -621,7 +621,7 @@ static av_cold int vp6_decode_free(AVCodecContext *avctx)
 
 AVCodec vp6_decoder = {
     "vp6",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VP6,
     sizeof(VP56Context),
     vp6_decode_init,
@@ -635,7 +635,7 @@ AVCodec vp6_decoder = {
 /* flash version, not flipped upside-down */
 AVCodec vp6f_decoder = {
     "vp6f",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VP6F,
     sizeof(VP56Context),
     vp6_decode_init,
@@ -649,7 +649,7 @@ AVCodec vp6f_decoder = {
 /* 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,
diff --git a/libavcodec/vqavideo.c b/libavcodec/vqavideo.c
index aba886489e5b912c76783413b270133923724197..a40e4e0102a800dafc751cb2fe86ae92ee8a05c1 100644
--- a/libavcodec/vqavideo.c
+++ b/libavcodec/vqavideo.c
@@ -610,7 +610,7 @@ static av_cold int vqa_decode_end(AVCodecContext *avctx)
 
 AVCodec vqa_decoder = {
     "vqavideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_WS_VQA,
     sizeof(VqaContext),
     vqa_decode_init,
diff --git a/libavcodec/wavpack.c b/libavcodec/wavpack.c
index 2c1df38b3ed3af8bb929eec24816c52bc2e9202d..d4608939371b61ff96f4cb832c6ff876f6073655 100644
--- a/libavcodec/wavpack.c
+++ b/libavcodec/wavpack.c
@@ -1020,7 +1020,7 @@ static int wavpack_decode_frame(AVCodecContext *avctx,
 
 AVCodec wavpack_decoder = {
     "wavpack",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_WAVPACK,
     sizeof(WavpackContext),
     wavpack_decode_init,
diff --git a/libavcodec/wmadec.c b/libavcodec/wmadec.c
index 74583abe58700d01068e0cd2be37b0562f33e89d..e7705470f2d84e9f824502608203c3db52c3bad0 100644
--- a/libavcodec/wmadec.c
+++ b/libavcodec/wmadec.c
@@ -942,7 +942,7 @@ static av_cold void flush(AVCodecContext *avctx)
 AVCodec wmav1_decoder =
 {
     "wmav1",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_WMAV1,
     sizeof(WMACodecContext),
     wma_decode_init,
@@ -956,7 +956,7 @@ AVCodec wmav1_decoder =
 AVCodec wmav2_decoder =
 {
     "wmav2",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_WMAV2,
     sizeof(WMACodecContext),
     wma_decode_init,
diff --git a/libavcodec/wmaenc.c b/libavcodec/wmaenc.c
index b1d4cb160d06f6455ebaa864a508a4324e389a2c..7aaeb70baa157a5e08c1d158ea414d07854a3cec 100644
--- a/libavcodec/wmaenc.c
+++ b/libavcodec/wmaenc.c
@@ -386,7 +386,7 @@ static int encode_superframe(AVCodecContext *avctx,
 AVCodec wmav1_encoder =
 {
     "wmav1",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_WMAV1,
     sizeof(WMACodecContext),
     encode_init,
@@ -399,7 +399,7 @@ AVCodec wmav1_encoder =
 AVCodec wmav2_encoder =
 {
     "wmav2",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_WMAV2,
     sizeof(WMACodecContext),
     encode_init,
diff --git a/libavcodec/wmaprodec.c b/libavcodec/wmaprodec.c
index a323a19fbac76914ec4ccd5475c3e18b3eeff481..82f1b3623b28c3e57f93f8cf1c2c1cbcfa2dfa46 100644
--- a/libavcodec/wmaprodec.c
+++ b/libavcodec/wmaprodec.c
@@ -1565,7 +1565,7 @@ static void flush(AVCodecContext *avctx)
  */
 AVCodec wmapro_decoder = {
     "wmapro",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_WMAPRO,
     sizeof(WMAProDecodeCtx),
     decode_init,
diff --git a/libavcodec/wmavoice.c b/libavcodec/wmavoice.c
index 9b9609f1a2b628102c7cb7077020ff779d2379ac..259755343d950923bb7a60c45df1df07c10f2ff2 100644
--- a/libavcodec/wmavoice.c
+++ b/libavcodec/wmavoice.c
@@ -1555,7 +1555,7 @@ static av_cold void wmavoice_flush(AVCodecContext *ctx)
 
 AVCodec wmavoice_decoder = {
     "wmavoice",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_WMAVOICE,
     sizeof(WMAVoiceContext),
     wmavoice_decode_init,
diff --git a/libavcodec/wmv2dec.c b/libavcodec/wmv2dec.c
index a2eb4292a2a8346066b928a01e27eff55dd47bdd..a9bb80cae44b8f45d56aebe62f120d012669f31e 100644
--- a/libavcodec/wmv2dec.c
+++ b/libavcodec/wmv2dec.c
@@ -486,7 +486,7 @@ static av_cold int wmv2_decode_end(AVCodecContext *avctx)
 
 AVCodec wmv2_decoder = {
     "wmv2",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_WMV2,
     sizeof(Wmv2Context),
     wmv2_decode_init,
diff --git a/libavcodec/wmv2enc.c b/libavcodec/wmv2enc.c
index 84eedf3e4385df171f9f55ca1b282b2b523ad9f1..7416f852336167dad0c5595475c825b5bf0c7144 100644
--- a/libavcodec/wmv2enc.c
+++ b/libavcodec/wmv2enc.c
@@ -213,7 +213,7 @@ void ff_wmv2_encode_mb(MpegEncContext * s,
 
 AVCodec wmv2_encoder = {
     "wmv2",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_WMV2,
     sizeof(Wmv2Context),
     wmv2_encode_init,
diff --git a/libavcodec/wnv1.c b/libavcodec/wnv1.c
index f537aee3af718136ad1c7b4b15b50a098d173311..7d325578afb68a083f8bdc26728836185bdb32cd 100644
--- a/libavcodec/wnv1.c
+++ b/libavcodec/wnv1.c
@@ -156,7 +156,7 @@ static av_cold int decode_end(AVCodecContext *avctx){
 
 AVCodec wnv1_decoder = {
     "wnv1",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_WNV1,
     sizeof(WNV1Context),
     decode_init,
diff --git a/libavcodec/ws-snd1.c b/libavcodec/ws-snd1.c
index 85e04f55d4fba4d58ad1d684459f2fc040573a15..0e75654c1eba2b85f0330c26730763e830ca861d 100644
--- a/libavcodec/ws-snd1.c
+++ b/libavcodec/ws-snd1.c
@@ -147,7 +147,7 @@ static int ws_snd_decode_frame(AVCodecContext *avctx,
 
 AVCodec ws_snd1_decoder = {
     "ws_snd1",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_WESTWOOD_SND1,
     0,
     ws_snd_decode_init,
diff --git a/libavcodec/xan.c b/libavcodec/xan.c
index 2638172d3fe5d26a3242bb9dbc5f3230fc30959a..d75d4692a2bd6dc786c421e770fa4a648a2325bd 100644
--- a/libavcodec/xan.c
+++ b/libavcodec/xan.c
@@ -417,7 +417,7 @@ static av_cold int xan_decode_end(AVCodecContext *avctx)
 
 AVCodec xan_wc3_decoder = {
     "xan_wc3",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_XAN_WC3,
     sizeof(XanContext),
     xan_decode_init,
@@ -431,7 +431,7 @@ AVCodec xan_wc3_decoder = {
 /*
 AVCodec xan_wc4_decoder = {
     "xan_wc4",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_XAN_WC4,
     sizeof(XanContext),
     xan_decode_init,
diff --git a/libavcodec/xl.c b/libavcodec/xl.c
index 2a5110cb98ead540921c080cf414cfffae4317fb..bf88938bf50c8cdea31f9d66ad71f3b52adca167 100644
--- a/libavcodec/xl.c
+++ b/libavcodec/xl.c
@@ -140,7 +140,7 @@ static av_cold int decode_end(AVCodecContext *avctx){
 
 AVCodec xl_decoder = {
     "xl",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VIXL,
     sizeof(VideoXLContext),
     decode_init,
diff --git a/libavcodec/xsubdec.c b/libavcodec/xsubdec.c
index 368caf4a6db590861a896ceb2e3d67ca611f921b..0055ebb20be68ce99b844715abab299f41a0b139 100644
--- a/libavcodec/xsubdec.c
+++ b/libavcodec/xsubdec.c
@@ -132,7 +132,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 
 AVCodec xsub_decoder = {
     "xsub",
-    CODEC_TYPE_SUBTITLE,
+    AVMEDIA_TYPE_SUBTITLE,
     CODEC_ID_XSUB,
     0,
     decode_init,
diff --git a/libavcodec/xsubenc.c b/libavcodec/xsubenc.c
index dbf2a2f3ab2cca61652931b4ce2a09cf1d05326f..903cbd2098dcebef4812ea761b3c50216a85d8b4 100644
--- a/libavcodec/xsubenc.c
+++ b/libavcodec/xsubenc.c
@@ -212,7 +212,7 @@ static av_cold int xsub_encoder_init(AVCodecContext *avctx)
 
 AVCodec xsub_encoder = {
     "xsub",
-    CODEC_TYPE_SUBTITLE,
+    AVMEDIA_TYPE_SUBTITLE,
     CODEC_ID_XSUB,
     0,
     xsub_encoder_init,
diff --git a/libavcodec/yop.c b/libavcodec/yop.c
index 235e5c9658cac43ea65f516aca739b5cdb4e9139..0c771fe05ea71b3cbc037b1cd927a468ca0e632d 100644
--- a/libavcodec/yop.c
+++ b/libavcodec/yop.c
@@ -249,7 +249,7 @@ static int yop_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 
 AVCodec yop_decoder = {
     "yop",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_YOP,
     sizeof(YopDecContext),
     yop_decode_init,
diff --git a/libavcodec/zmbv.c b/libavcodec/zmbv.c
index 35a31c092463ed65327746e9ad29f7dbe01228a0..e8e5135731b53c865f9ee35cab3d88a7dd5a4a9f 100644
--- a/libavcodec/zmbv.c
+++ b/libavcodec/zmbv.c
@@ -654,7 +654,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 AVCodec zmbv_decoder = {
     "zmbv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ZMBV,
     sizeof(ZmbvContext),
     decode_init,
diff --git a/libavcodec/zmbvenc.c b/libavcodec/zmbvenc.c
index a04c0597ee5e7d99ad2d2a15c4a1ebfe1fb431f2..162b8485cb3161ab63cd582745393d7e9bb4bf61 100644
--- a/libavcodec/zmbvenc.c
+++ b/libavcodec/zmbvenc.c
@@ -325,7 +325,7 @@ static av_cold int encode_end(AVCodecContext *avctx)
 
 AVCodec zmbv_encoder = {
     "zmbv",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_ZMBV,
     sizeof(ZmbvEncContext),
     encode_init,
diff --git a/libavdevice/alsa-audio-dec.c b/libavdevice/alsa-audio-dec.c
index 833bca3b06ac6ba1c7567baa32ebff03908f5088..1fb0bf5c68d7260e2699826cd1c1ddf7d8a2b24d 100644
--- a/libavdevice/alsa-audio-dec.c
+++ b/libavdevice/alsa-audio-dec.c
@@ -111,7 +111,7 @@ static av_cold int audio_read_header(AVFormatContext *s1,
     }
 
     /* take real parameters */
-    st->codec->codec_type  = CODEC_TYPE_AUDIO;
+    st->codec->codec_type  = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id    = codec_id;
     st->codec->sample_rate = sample_rate;
     st->codec->channels    = ap->channels;
diff --git a/libavdevice/bktr.c b/libavdevice/bktr.c
index c63d79ea28294cc3612b0a12c257bcc8db67f339..afb94b6c5d174416dc6bfbd478979dab6f94c05f 100644
--- a/libavdevice/bktr.c
+++ b/libavdevice/bktr.c
@@ -269,7 +269,7 @@ static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
     s->frame_rate_base = frame_rate_base;
     s->per_frame = ((uint64_t)1000000 * s->frame_rate_base) / s->frame_rate;
 
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->pix_fmt = PIX_FMT_YUV420P;
     st->codec->codec_id = CODEC_ID_RAWVIDEO;
     st->codec->width = width;
diff --git a/libavdevice/jack_audio.c b/libavdevice/jack_audio.c
index fa1fba13ca78072636b5f7c22a913e44bd59caef..b41bbdf902ab96b41e8a47a67ebff302e4c4fe09 100644
--- a/libavdevice/jack_audio.c
+++ b/libavdevice/jack_audio.c
@@ -237,7 +237,7 @@ static int audio_read_header(AVFormatContext *context, AVFormatParameters *param
         return AVERROR(ENOMEM);
     }
 
-    stream->codec->codec_type   = CODEC_TYPE_AUDIO;
+    stream->codec->codec_type   = AVMEDIA_TYPE_AUDIO;
 #if HAVE_BIGENDIAN
     stream->codec->codec_id     = CODEC_ID_PCM_F32BE;
 #else
diff --git a/libavdevice/libdc1394.c b/libavdevice/libdc1394.c
index 0d8e36ad63341420dba12a965677749e15cd22a7..8ffbc58974d6363cc79532653be024cbc6c64465 100644
--- a/libavdevice/libdc1394.c
+++ b/libavdevice/libdc1394.c
@@ -117,7 +117,7 @@ static inline int dc1394_read_common(AVFormatContext *c, AVFormatParameters *ap,
     if (!vst)
         goto out;
     av_set_pts_info(vst, 64, 1, 1000);
-    vst->codec->codec_type = CODEC_TYPE_VIDEO;
+    vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     vst->codec->codec_id = CODEC_ID_RAWVIDEO;
     vst->codec->time_base.den = fps->frame_rate;
     vst->codec->time_base.num = 1000;
diff --git a/libavdevice/oss_audio.c b/libavdevice/oss_audio.c
index 8e4dbf2fc44f7c6da117b0e2f1ed44ea199a60f2..d382c0376eea4c5c32afdf9595b9198841428d9b 100644
--- a/libavdevice/oss_audio.c
+++ b/libavdevice/oss_audio.c
@@ -232,7 +232,7 @@ static int audio_read_header(AVFormatContext *s1, AVFormatParameters *ap)
     }
 
     /* take real parameters */
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = s->codec_id;
     st->codec->sample_rate = s->sample_rate;
     st->codec->channels = s->channels;
diff --git a/libavdevice/v4l.c b/libavdevice/v4l.c
index 3382cdb0ae0da179aa640ee79b19bdee93285045..d0ef7d5e047d1332fa365f3a6da4194084244b30 100644
--- a/libavdevice/v4l.c
+++ b/libavdevice/v4l.c
@@ -242,7 +242,7 @@ static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
 
     s->fd = video_fd;
 
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_RAWVIDEO;
     st->codec->width = s->video_win.width;
     st->codec->height = s->video_win.height;
diff --git a/libavdevice/v4l2.c b/libavdevice/v4l2.c
index 36c8d66c6b3b5043d38f0420403e0b3f12929740..9cc68062563b818017bad230a5b4e0537636bb9b 100644
--- a/libavdevice/v4l2.c
+++ b/libavdevice/v4l2.c
@@ -646,7 +646,7 @@ static int v4l2_read_header(AVFormatContext *s1, AVFormatParameters *ap)
     }
     s->top_field_first = first_field(s->fd);
 
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = codec_id;
     st->codec->width = width;
     st->codec->height = height;
diff --git a/libavdevice/vfwcap.c b/libavdevice/vfwcap.c
index 9f242f80f9071c9b3bda73fe6cd6aa5ff9116ce8..9f54494c83eee3dca4efc3fccf9d42c921028b94 100644
--- a/libavdevice/vfwcap.c
+++ b/libavdevice/vfwcap.c
@@ -353,7 +353,7 @@ static int vfw_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
     codec = st->codec;
     codec->time_base = ap->time_base;
-    codec->codec_type = CODEC_TYPE_VIDEO;
+    codec->codec_type = AVMEDIA_TYPE_VIDEO;
     codec->width = width;
     codec->height = height;
     codec->pix_fmt = vfw_pixfmt(biCompression, biBitCount);
diff --git a/libavdevice/x11grab.c b/libavdevice/x11grab.c
index 045b82306e0659347136901b8a7f2a37607ed280..865206dfcf8171041a3aa44c32eede979c1823df 100644
--- a/libavdevice/x11grab.c
+++ b/libavdevice/x11grab.c
@@ -226,7 +226,7 @@ x11grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
     x11grab->image = image;
     x11grab->use_shm = use_shm;
 
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_RAWVIDEO;
     st->codec->width = ap->width;
     st->codec->height = ap->height;
diff --git a/libavfilter/avfilter.h b/libavfilter/avfilter.h
index 7867cd09fd5c7245151cdc9e8640aba26150ec41..fabc1beb82d5ec6f4fdbc9138166eda4462ca196 100644
--- a/libavfilter/avfilter.h
+++ b/libavfilter/avfilter.h
@@ -280,7 +280,7 @@ struct AVFilterPad
      * AVFilterPad type. Only video supported now, hopefully someone will
      * add audio in the future.
      */
-    enum CodecType type;
+    enum AVMediaType type;
 
     /**
      * Minimum required permissions on incoming buffers. Any buffer with
diff --git a/libavfilter/vf_aspect.c b/libavfilter/vf_aspect.c
index 801f927ba37d925bd68eab35d6e600613b7966e2..79e26998e9b48fbced7221bc7f8566b50db46838 100644
--- a/libavfilter/vf_aspect.c
+++ b/libavfilter/vf_aspect.c
@@ -86,7 +86,7 @@ AVFilter avfilter_vf_aspect = {
     .priv_size = sizeof(AspectContext),
 
     .inputs    = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO,
+                                    .type             = AVMEDIA_TYPE_VIDEO,
                                     .config_props     = frameaspect_config_props,
                                     .get_video_buffer = avfilter_null_get_video_buffer,
                                     .start_frame      = start_frame,
@@ -94,7 +94,7 @@ AVFilter avfilter_vf_aspect = {
                                   { .name = NULL}},
 
     .outputs   = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO, },
+                                    .type             = AVMEDIA_TYPE_VIDEO, },
                                   { .name = NULL}},
 };
 #endif /* CONFIG_ASPECT_FILTER */
@@ -109,14 +109,14 @@ AVFilter avfilter_vf_pixelaspect = {
     .priv_size = sizeof(AspectContext),
 
     .inputs    = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO,
+                                    .type             = AVMEDIA_TYPE_VIDEO,
                                     .get_video_buffer = avfilter_null_get_video_buffer,
                                     .start_frame      = start_frame,
                                     .end_frame        = avfilter_null_end_frame },
                                   { .name = NULL}},
 
     .outputs   = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO, },
+                                    .type             = AVMEDIA_TYPE_VIDEO, },
                                   { .name = NULL}},
 };
 #endif /* CONFIG_PIXELASPECT_FILTER */
diff --git a/libavfilter/vf_crop.c b/libavfilter/vf_crop.c
index 69dfdea2e7fa54b70c3717b2ba5fa14d228e7c12..85e99c28b9f07cc7158c17c347c0aeab8f76400c 100644
--- a/libavfilter/vf_crop.c
+++ b/libavfilter/vf_crop.c
@@ -214,14 +214,14 @@ AVFilter avfilter_vf_crop = {
     .init          = init,
 
     .inputs    = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO,
+                                    .type             = AVMEDIA_TYPE_VIDEO,
                                     .start_frame      = start_frame,
                                     .draw_slice       = draw_slice,
                                     .get_video_buffer = avfilter_null_get_video_buffer,
                                     .config_props     = config_input, },
                                   { .name = NULL}},
     .outputs   = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO,
+                                    .type             = AVMEDIA_TYPE_VIDEO,
                                     .config_props     = config_output, },
                                   { .name = NULL}},
 };
diff --git a/libavfilter/vf_format.c b/libavfilter/vf_format.c
index 2c84b0ab1a8b94e1d9f8d44dad089309fe5331c3..36d5f4009a01dc99700227736f53a827e39f3f23 100644
--- a/libavfilter/vf_format.c
+++ b/libavfilter/vf_format.c
@@ -103,14 +103,14 @@ AVFilter avfilter_vf_format = {
     .priv_size = sizeof(FormatContext),
 
     .inputs    = (AVFilterPad[]) {{ .name            = "default",
-                                    .type            = CODEC_TYPE_VIDEO,
+                                    .type            = AVMEDIA_TYPE_VIDEO,
                                     .get_video_buffer= avfilter_null_get_video_buffer,
                                     .start_frame     = avfilter_null_start_frame,
                                     .draw_slice      = avfilter_null_draw_slice,
                                     .end_frame       = avfilter_null_end_frame, },
                                   { .name = NULL}},
     .outputs   = (AVFilterPad[]) {{ .name            = "default",
-                                    .type            = CODEC_TYPE_VIDEO },
+                                    .type            = AVMEDIA_TYPE_VIDEO },
                                   { .name = NULL}},
 };
 #endif /* CONFIG_FORMAT_FILTER */
@@ -133,14 +133,14 @@ AVFilter avfilter_vf_noformat = {
     .priv_size = sizeof(FormatContext),
 
     .inputs    = (AVFilterPad[]) {{ .name            = "default",
-                                    .type            = CODEC_TYPE_VIDEO,
+                                    .type            = AVMEDIA_TYPE_VIDEO,
                                     .get_video_buffer= avfilter_null_get_video_buffer,
                                     .start_frame     = avfilter_null_start_frame,
                                     .draw_slice      = avfilter_null_draw_slice,
                                     .end_frame       = avfilter_null_end_frame, },
                                   { .name = NULL}},
     .outputs   = (AVFilterPad[]) {{ .name            = "default",
-                                    .type            = CODEC_TYPE_VIDEO },
+                                    .type            = AVMEDIA_TYPE_VIDEO },
                                   { .name = NULL}},
 };
 #endif /* CONFIG_NOFORMAT_FILTER */
diff --git a/libavfilter/vf_null.c b/libavfilter/vf_null.c
index 75eba6783f979a16cf23f538f03ce53c5cc45fe8..e3987ff693fb9d505119a7c7d7a4a544a2140498 100644
--- a/libavfilter/vf_null.c
+++ b/libavfilter/vf_null.c
@@ -30,13 +30,13 @@ AVFilter avfilter_vf_null = {
     .priv_size = 0,
 
     .inputs    = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO,
+                                    .type             = AVMEDIA_TYPE_VIDEO,
                                     .get_video_buffer = avfilter_null_get_video_buffer,
                                     .start_frame      = avfilter_null_start_frame,
                                     .end_frame        = avfilter_null_end_frame },
                                   { .name = NULL}},
 
     .outputs   = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO, },
+                                    .type             = AVMEDIA_TYPE_VIDEO, },
                                   { .name = NULL}},
 };
diff --git a/libavfilter/vf_scale.c b/libavfilter/vf_scale.c
index 8b70d0319f9e2bcf4bf0797a8fa402e7ad7c3a05..4898dc554dd6c91d1f6f081f1a80df5820125c1e 100644
--- a/libavfilter/vf_scale.c
+++ b/libavfilter/vf_scale.c
@@ -197,13 +197,13 @@ AVFilter avfilter_vf_scale = {
     .priv_size = sizeof(ScaleContext),
 
     .inputs    = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO,
+                                    .type             = AVMEDIA_TYPE_VIDEO,
                                     .start_frame      = start_frame,
                                     .draw_slice       = draw_slice,
                                     .min_perms        = AV_PERM_READ, },
                                   { .name = NULL}},
     .outputs   = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO,
+                                    .type             = AVMEDIA_TYPE_VIDEO,
                                     .config_props     = config_props, },
                                   { .name = NULL}},
 };
diff --git a/libavfilter/vf_slicify.c b/libavfilter/vf_slicify.c
index ec96db499d1c48ec56c29838e7ea20ca5cbe2b58..e405e70e2a4d7fdb1297ab21c01b582e8ce80844 100644
--- a/libavfilter/vf_slicify.c
+++ b/libavfilter/vf_slicify.c
@@ -104,7 +104,7 @@ AVFilter avfilter_vf_slicify = {
     .priv_size = sizeof(SliceContext),
 
     .inputs    = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO,
+                                    .type             = AVMEDIA_TYPE_VIDEO,
                                     .get_video_buffer = avfilter_null_get_video_buffer,
                                     .start_frame      = start_frame,
                                     .draw_slice       = draw_slice,
@@ -112,6 +112,6 @@ AVFilter avfilter_vf_slicify = {
                                     .end_frame        = avfilter_null_end_frame, },
                                   { .name = NULL}},
     .outputs   = (AVFilterPad[]) {{ .name            = "default",
-                                    .type            = CODEC_TYPE_VIDEO, },
+                                    .type            = AVMEDIA_TYPE_VIDEO, },
                                   { .name = NULL}},
 };
diff --git a/libavfilter/vf_vflip.c b/libavfilter/vf_vflip.c
index 7f5299297f12584c80480c8a219c72d83ce19239..3ab56b993996a0b39908f9821e128bda363c8492 100644
--- a/libavfilter/vf_vflip.c
+++ b/libavfilter/vf_vflip.c
@@ -91,7 +91,7 @@ AVFilter avfilter_vf_vflip = {
     .priv_size = sizeof(FlipContext),
 
     .inputs    = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO,
+                                    .type             = AVMEDIA_TYPE_VIDEO,
                                     .get_video_buffer = get_video_buffer,
                                     .start_frame      = start_frame,
                                     .draw_slice       = draw_slice,
@@ -99,6 +99,6 @@ AVFilter avfilter_vf_vflip = {
                                     .config_props     = config_input, },
                                   { .name = NULL}},
     .outputs   = (AVFilterPad[]) {{ .name             = "default",
-                                    .type             = CODEC_TYPE_VIDEO, },
+                                    .type             = AVMEDIA_TYPE_VIDEO, },
                                   { .name = NULL}},
 };
diff --git a/libavfilter/vsink_nullsink.c b/libavfilter/vsink_nullsink.c
index d87f20400bec117b7080446529b9e04cdc568af1..d11912f7dd424b38a368f49918f94f8525735ba1 100644
--- a/libavfilter/vsink_nullsink.c
+++ b/libavfilter/vsink_nullsink.c
@@ -35,7 +35,7 @@ AVFilter avfilter_vsink_nullsink = {
     .inputs    = (AVFilterPad[]) {
         {
             .name            = "default",
-            .type            = CODEC_TYPE_VIDEO,
+            .type            = AVMEDIA_TYPE_VIDEO,
             .start_frame     = start_frame,
             .end_frame       = end_frame,
         },
diff --git a/libavfilter/vsrc_nullsrc.c b/libavfilter/vsrc_nullsrc.c
index ff14ea68b2815632dbf6a573abedbf6d5e3bbc6c..892ee1205ef418760872950dd5a1291f1ad7afaa 100644
--- a/libavfilter/vsrc_nullsrc.c
+++ b/libavfilter/vsrc_nullsrc.c
@@ -74,7 +74,7 @@ AVFilter avfilter_vsrc_nullsrc = {
     .outputs   = (AVFilterPad[]) {
         {
             .name            = "default",
-            .type            = CODEC_TYPE_VIDEO,
+            .type            = AVMEDIA_TYPE_VIDEO,
             .config_props    = config_props,
             .request_frame   = request_frame,
         },
diff --git a/libavformat/4xm.c b/libavformat/4xm.c
index 631f8216a55157d8ce19fa3bed46221355e0e98a..661d6718b614330a8aaaeef476f2e09ced58ab81 100644
--- a/libavformat/4xm.c
+++ b/libavformat/4xm.c
@@ -149,7 +149,7 @@ static int fourxm_read_header(AVFormatContext *s,
 
             fourxm->video_stream_index = st->index;
 
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             st->codec->codec_id = CODEC_ID_4XM;
             st->codec->extradata_size = 4;
             st->codec->extradata = av_malloc(4);
@@ -198,7 +198,7 @@ static int fourxm_read_header(AVFormatContext *s,
 
             fourxm->tracks[current_track].stream_index = st->index;
 
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             st->codec->codec_tag = 0;
             st->codec->channels              = fourxm->tracks[current_track].channels;
             st->codec->sample_rate           = fourxm->tracks[current_track].sample_rate;
diff --git a/libavformat/aea.c b/libavformat/aea.c
index 7c44d786635115dc74e873b78a7a698bb8ab779c..ec95a0f92c8bb946d5c58cdb5c17385d3eb9b5ea 100644
--- a/libavformat/aea.c
+++ b/libavformat/aea.c
@@ -71,7 +71,7 @@ static int aea_read_header(AVFormatContext *s,
     url_fskip(s->pb, 1783);
 
 
-    st->codec->codec_type     = CODEC_TYPE_AUDIO;
+    st->codec->codec_type     = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id       = CODEC_ID_ATRAC1;
     st->codec->sample_rate    = 44100;
     st->codec->bit_rate       = 292000;
diff --git a/libavformat/aiffdec.c b/libavformat/aiffdec.c
index a56bb0911d78b8d257da5248cac23cf98a59c8dd..f72af00f4cf46d34271dca31d922726b37dae56e 100644
--- a/libavformat/aiffdec.c
+++ b/libavformat/aiffdec.c
@@ -92,7 +92,7 @@ static unsigned int get_aiff_header(ByteIOContext *pb, AVCodecContext *codec,
 
     if (size & 1)
         size++;
-    codec->codec_type = CODEC_TYPE_AUDIO;
+    codec->codec_type = AVMEDIA_TYPE_AUDIO;
     codec->channels = get_be16(pb);
     num_frames = get_be32(pb);
     codec->bits_per_coded_sample = get_be16(pb);
diff --git a/libavformat/amr.c b/libavformat/amr.c
index cbc4ec50d4209dd8e7641669769cbe1d5c17511c..d16b4c03cd0a7e28dac523715189e9a480658f64 100644
--- a/libavformat/amr.c
+++ b/libavformat/amr.c
@@ -108,7 +108,7 @@ static int amr_read_header(AVFormatContext *s,
         st->codec->sample_rate = 8000;
     }
     st->codec->channels = 1;
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     av_set_pts_info(st, 64, 1, st->codec->sample_rate);
 
     return 0;
diff --git a/libavformat/anm.c b/libavformat/anm.c
index 2099dc96e8a159406b991b1e52613a7d4f12685d..0d28ff4e8f6bb73e4bcccd7f47fe327611469d22 100644
--- a/libavformat/anm.c
+++ b/libavformat/anm.c
@@ -100,7 +100,7 @@ static int read_header(AVFormatContext *s,
     st = av_new_stream(s, 0);
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id   = CODEC_ID_ANM;
     st->codec->codec_tag  = 0; /* no fourcc */
     st->codec->width      = get_le16(pb);
diff --git a/libavformat/apc.c b/libavformat/apc.c
index 14701d92296150575d8197ed785ce2a51e9d6121..9b4a8adc1d441a080f0fca65937dbab2789ca947 100644
--- a/libavformat/apc.c
+++ b/libavformat/apc.c
@@ -43,7 +43,7 @@ static int apc_read_header(AVFormatContext *s, AVFormatParameters *ap)
     if (!st)
         return AVERROR(ENOMEM);
 
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;
 
     get_le32(pb); /* number of samples */
diff --git a/libavformat/ape.c b/libavformat/ape.c
index b5f93cf13467ce13355f37f5db1a6580f2b3bae4..102e191a3fc9725ad45685b0c38680cfebe8d8d9 100644
--- a/libavformat/ape.c
+++ b/libavformat/ape.c
@@ -301,7 +301,7 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap)
 
     total_blocks = (ape->totalframes == 0) ? 0 : ((ape->totalframes - 1) * ape->blocksperframe) + ape->finalframeblocks;
 
-    st->codec->codec_type      = CODEC_TYPE_AUDIO;
+    st->codec->codec_type      = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id        = CODEC_ID_APE;
     st->codec->codec_tag       = MKTAG('A', 'P', 'E', ' ');
     st->codec->channels        = ape->channels;
diff --git a/libavformat/asfdec.c b/libavformat/asfdec.c
index 882614be3df85c1e9b39c404ebcc25c92b09803d..ab96cc433993038354de3c4b89b974d0d8500ae3 100644
--- a/libavformat/asfdec.c
+++ b/libavformat/asfdec.c
@@ -236,7 +236,7 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
             asf->hdr.max_bitrate        = get_le32(pb);
             s->packet_size = asf->hdr.max_pktsize;
         } else if (!guidcmp(&g, &ff_asf_stream_header)) {
-            enum CodecType type;
+            enum AVMediaType type;
             int type_specific_size, sizeX;
             uint64_t total_size;
             unsigned int tag1;
@@ -265,14 +265,14 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
             test_for_ext_stream_audio = 0;
             if (!guidcmp(&g, &ff_asf_audio_stream)) {
-                type = CODEC_TYPE_AUDIO;
+                type = AVMEDIA_TYPE_AUDIO;
             } else if (!guidcmp(&g, &ff_asf_video_stream)) {
-                type = CODEC_TYPE_VIDEO;
+                type = AVMEDIA_TYPE_VIDEO;
             } else if (!guidcmp(&g, &ff_asf_command_stream)) {
-                type = CODEC_TYPE_DATA;
+                type = AVMEDIA_TYPE_DATA;
             } else if (!guidcmp(&g, &ff_asf_ext_stream_embed_stream_header)) {
                 test_for_ext_stream_audio = 1;
-                type = CODEC_TYPE_UNKNOWN;
+                type = AVMEDIA_TYPE_UNKNOWN;
             } else {
                 return -1;
             }
@@ -289,7 +289,7 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
             if (test_for_ext_stream_audio) {
                 get_guid(pb, &g);
                 if (!guidcmp(&g, &ff_asf_ext_stream_audio_stream)) {
-                    type = CODEC_TYPE_AUDIO;
+                    type = AVMEDIA_TYPE_AUDIO;
                     is_dvr_ms_audio=1;
                     get_guid(pb, &g);
                     get_le32(pb);
@@ -301,7 +301,7 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
             }
 
             st->codec->codec_type = type;
-            if (type == CODEC_TYPE_AUDIO) {
+            if (type == AVMEDIA_TYPE_AUDIO) {
                 ff_get_wav_header(pb, st->codec, type_specific_size);
                 if (is_dvr_ms_audio) {
                     // codec_id and codec_tag are unreliable in dvr_ms
@@ -351,7 +351,7 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
                     st->codec->frame_size = 1;
                     break;
                 }
-            } else if (type == CODEC_TYPE_VIDEO) {
+            } else if (type == AVMEDIA_TYPE_VIDEO) {
                 get_le32(pb);
                 get_le32(pb);
                 get_byte(pb);
@@ -889,8 +889,8 @@ static int ff_asf_parse_packet(AVFormatContext *s, ByteIOContext *pb, AVPacket *
             asf_st->packet_pos= asf->packet_pos;
 //printf("new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
 //asf->stream_index, asf->packet_key_frame, asf_st->pkt.flags & PKT_FLAG_KEY,
-//s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO, asf->packet_obj_size);
-            if (s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO)
+//s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO, asf->packet_obj_size);
+            if (s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
                 asf->packet_key_frame = 1;
             if (asf->packet_key_frame)
                 asf_st->pkt.flags |= PKT_FLAG_KEY;
diff --git a/libavformat/asfenc.c b/libavformat/asfenc.c
index 03b7256397efbbf682de877a248b9883e5d264e4..f3a368ae3bda808f9c4b0a9c6fa222b0c7fe03af 100644
--- a/libavformat/asfenc.c
+++ b/libavformat/asfenc.c
@@ -375,13 +375,13 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
 
 
         switch(enc->codec_type) {
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             wav_extra_size = 0;
             extra_size = 18 + wav_extra_size;
             extra_size2 = 8;
             break;
         default:
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             wav_extra_size = enc->extradata_size;
             extra_size = 0x33 + wav_extra_size;
             extra_size2 = 0;
@@ -389,7 +389,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
         }
 
         hpos = put_header(pb, &ff_asf_stream_header);
-        if (enc->codec_type == CODEC_TYPE_AUDIO) {
+        if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
             put_guid(pb, &ff_asf_audio_stream);
             put_guid(pb, &ff_asf_audio_conceal_spread);
         } else {
@@ -403,7 +403,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
         put_le16(pb, n + 1); /* stream number */
         put_le32(pb, 0); /* ??? */
 
-        if (enc->codec_type == CODEC_TYPE_AUDIO) {
+        if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
             /* WAVEFORMATEX header */
             int wavsize = ff_put_wav_header(pb, enc);
             if ((enc->codec_id != CODEC_ID_MP3) && (enc->codec_id != CODEC_ID_MP2) && (enc->codec_id != CODEC_ID_ADPCM_IMA_WAV) && (enc->extradata_size==0)) {
@@ -457,9 +457,9 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
         enc = s->streams[n]->codec;
         p = avcodec_find_encoder(enc->codec_id);
 
-        if(enc->codec_type == CODEC_TYPE_AUDIO)
+        if(enc->codec_type == AVMEDIA_TYPE_AUDIO)
             put_le16(pb, 2);
-        else if(enc->codec_type == CODEC_TYPE_VIDEO)
+        else if(enc->codec_type == AVMEDIA_TYPE_VIDEO)
             put_le16(pb, 1);
         else
             put_le16(pb, -1);
@@ -483,7 +483,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
 
 
         /* id */
-        if (enc->codec_type == CODEC_TYPE_AUDIO) {
+        if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
             put_le16(pb, 2);
             put_le16(pb, enc->codec_tag);
         } else {
@@ -722,7 +722,7 @@ static void put_frame(
             // multi payloads
             frag_len1 = asf->packet_size_left - PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS - PACKET_HEADER_MIN_SIZE - 1;
 
-            if(frag_len1 < payload_len && avst->codec->codec_type == CODEC_TYPE_AUDIO){
+            if(frag_len1 < payload_len && avst->codec->codec_type == AVMEDIA_TYPE_AUDIO){
                 flush_packet(s);
                 continue;
             }
@@ -770,7 +770,7 @@ static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
     codec = s->streams[pkt->stream_index]->codec;
     stream = &asf->streams[pkt->stream_index];
 
-    if(codec->codec_type == CODEC_TYPE_AUDIO)
+    if(codec->codec_type == AVMEDIA_TYPE_AUDIO)
         flags &= ~PKT_FLAG_KEY;
 
     pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts;
diff --git a/libavformat/assdec.c b/libavformat/assdec.c
index 32fb09d22d001cb02101cc3963844667e06d5040..173dc0c632d0939d2ac3bce26f862ce936b73313 100644
--- a/libavformat/assdec.c
+++ b/libavformat/assdec.c
@@ -99,7 +99,7 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
     if (!st)
         return -1;
     av_set_pts_info(st, 64, 1, 100);
-    st->codec->codec_type = CODEC_TYPE_SUBTITLE;
+    st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
     st->codec->codec_id= CODEC_ID_SSA;
 
     header_remaining= INT_MAX;
diff --git a/libavformat/au.c b/libavformat/au.c
index 0ea0ea8c981ac28ca1c778ae3d6adc4a06352c47..f8f718d4ff13b8200094bc542c95db7d4d0b3b33 100644
--- a/libavformat/au.c
+++ b/libavformat/au.c
@@ -148,7 +148,7 @@ static int au_read_header(AVFormatContext *s,
     st = av_new_stream(s, 0);
     if (!st)
         return -1;
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_tag = id;
     st->codec->codec_id = codec;
     st->codec->channels = channels;
diff --git a/libavformat/audiointerleave.c b/libavformat/audiointerleave.c
index a3a6531348c44a0b2639f5d085b5b39245c55914..3c235c069e7df59ecad081a4575edca4777829c3 100644
--- a/libavformat/audiointerleave.c
+++ b/libavformat/audiointerleave.c
@@ -32,7 +32,7 @@ void ff_audio_interleave_close(AVFormatContext *s)
         AVStream *st = s->streams[i];
         AudioInterleaveContext *aic = st->priv_data;
 
-        if (st->codec->codec_type == CODEC_TYPE_AUDIO)
+        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
             av_fifo_free(aic->fifo);
     }
 }
@@ -50,7 +50,7 @@ int ff_audio_interleave_init(AVFormatContext *s,
         AVStream *st = s->streams[i];
         AudioInterleaveContext *aic = st->priv_data;
 
-        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
             aic->sample_size = (st->codec->channels *
                                 av_get_bits_per_sample(st->codec->codec_id)) / 8;
             if (!aic->sample_size) {
@@ -103,7 +103,7 @@ int ff_audio_rechunk_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt
     if (pkt) {
         AVStream *st = s->streams[pkt->stream_index];
         AudioInterleaveContext *aic = st->priv_data;
-        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
             unsigned new_size = av_fifo_size(aic->fifo) + pkt->size;
             if (new_size > aic->fifo_size) {
                 if (av_fifo_realloc2(aic->fifo, new_size) < 0)
@@ -122,7 +122,7 @@ int ff_audio_rechunk_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt
 
     for (i = 0; i < s->nb_streams; i++) {
         AVStream *st = s->streams[i];
-        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
             AVPacket new_pkt;
             while (ff_interleave_new_audio_packet(s, &new_pkt, i, flush))
                 ff_interleave_add_packet(s, &new_pkt, compare_ts);
diff --git a/libavformat/avformat.h b/libavformat/avformat.h
index 92fd85c703534ea20cbd776c0aacd1d43dc68ff9..65e32bb043b143f74256a6888fe401e4bfa9c1b7 100644
--- a/libavformat/avformat.h
+++ b/libavformat/avformat.h
@@ -804,7 +804,7 @@ AVOutputFormat *av_guess_format(const char *short_name,
  */
 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
                             const char *filename, const char *mime_type,
-                            enum CodecType type);
+                            enum AVMediaType type);
 
 /**
  * Sends a nice hexadecimal dump of a buffer to the specified file stream.
diff --git a/libavformat/avidec.c b/libavformat/avidec.c
index cba34f8d3d84ad009277eb79e75c89cc8b45010e..a74400f86050f40246b4401c01931d7ba7b4ce02 100644
--- a/libavformat/avidec.c
+++ b/libavformat/avidec.c
@@ -442,19 +442,19 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
             switch(tag1) {
             case MKTAG('v', 'i', 'd', 's'):
-                codec_type = CODEC_TYPE_VIDEO;
+                codec_type = AVMEDIA_TYPE_VIDEO;
 
                 ast->sample_size = 0;
                 break;
             case MKTAG('a', 'u', 'd', 's'):
-                codec_type = CODEC_TYPE_AUDIO;
+                codec_type = AVMEDIA_TYPE_AUDIO;
                 break;
             case MKTAG('t', 'x', 't', 's'):
                 //FIXME
-                codec_type = CODEC_TYPE_DATA; //CODEC_TYPE_SUB ?  FIXME
+                codec_type = AVMEDIA_TYPE_DATA; //AVMEDIA_TYPE_SUB ?  FIXME
                 break;
             case MKTAG('d', 'a', 't', 's'):
-                codec_type = CODEC_TYPE_DATA;
+                codec_type = AVMEDIA_TYPE_DATA;
                 break;
             default:
                 av_log(s, AV_LOG_ERROR, "unknown stream type %X\n", tag1);
@@ -475,11 +475,11 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
                     size = FFMIN(size, list_end - cur_pos);
                 st = s->streams[stream_index];
                 switch(codec_type) {
-                case CODEC_TYPE_VIDEO:
+                case AVMEDIA_TYPE_VIDEO:
                     if(amv_file_format){
                         st->codec->width=avih_width;
                         st->codec->height=avih_height;
-                        st->codec->codec_type = CODEC_TYPE_VIDEO;
+                        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
                         st->codec->codec_id = CODEC_ID_AMV;
                         url_fskip(pb, size);
                         break;
@@ -497,7 +497,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
                     get_le32(pb); /* ClrImportant */
 
                     if (tag1 == MKTAG('D', 'X', 'S', 'B') || tag1 == MKTAG('D','X','S','A')) {
-                        st->codec->codec_type = CODEC_TYPE_SUBTITLE;
+                        st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
                         st->codec->codec_tag = tag1;
                         st->codec->codec_id = CODEC_ID_XSUB;
                         break;
@@ -534,7 +534,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
 #ifdef DEBUG
                     print_tag("video", tag1, 0);
 #endif
-                    st->codec->codec_type = CODEC_TYPE_VIDEO;
+                    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
                     st->codec->codec_tag = tag1;
                     st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag1);
                     st->need_parsing = AVSTREAM_PARSE_HEADERS; // This is needed to get the pict type which is necessary for generating correct pts.
@@ -554,7 +554,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
 //                    url_fskip(pb, size - 5 * 4);
                     break;
-                case CODEC_TYPE_AUDIO:
+                case AVMEDIA_TYPE_AUDIO:
                     ff_get_wav_header(pb, st->codec, size);
                     if(ast->sample_size && st->codec->block_align && ast->sample_size != st->codec->block_align){
                         av_log(s, AV_LOG_WARNING, "sample size (%d) != block align (%d)\n", ast->sample_size, st->codec->block_align);
@@ -580,7 +580,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
                         st->codec->codec_id  = CODEC_ID_ADPCM_IMA_AMV;
                     break;
                 default:
-                    st->codec->codec_type = CODEC_TYPE_DATA;
+                    st->codec->codec_type = AVMEDIA_TYPE_DATA;
                     st->codec->codec_id= CODEC_ID_NONE;
                     st->codec->codec_tag= 0;
                     url_fskip(pb, size);
@@ -787,7 +787,7 @@ resync:
 //av_log(s, AV_LOG_DEBUG, "dts:%"PRId64" offset:%"PRId64" %d/%d smpl_siz:%d base:%d st:%d size:%d\n", pkt->dts, ast->frame_offset, ast->scale, ast->rate, ast->sample_size, AV_TIME_BASE, avi->stream_index, size);
             pkt->stream_index = avi->stream_index;
 
-            if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+            if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
                 AVIndexEntry *e;
                 int index;
                 assert(st->index_entries);
@@ -871,8 +871,8 @@ resync:
                 //workaround for broken small-file-bug402.avi
                 if(   d[2] == 'w' && d[3] == 'b'
                    && n==0
-                   && st ->codec->codec_type == CODEC_TYPE_VIDEO
-                   && st1->codec->codec_type == CODEC_TYPE_AUDIO
+                   && st ->codec->codec_type == AVMEDIA_TYPE_VIDEO
+                   && st1->codec->codec_type == AVMEDIA_TYPE_AUDIO
                    && ast->prefix == 'd'*256+'c'
                    && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)
                   ){
diff --git a/libavformat/avienc.c b/libavformat/avienc.c
index 50419960a32fe90e7e5be7a0361ef28366ddc5f0..51daf500fe3ca2c9e2504cf882b1b2bff83edc3e 100644
--- a/libavformat/avienc.c
+++ b/libavformat/avienc.c
@@ -83,14 +83,14 @@ static int64_t avi_start_new_riff(AVFormatContext *s, ByteIOContext *pb,
     return loff;
 }
 
-static char* avi_stream2fourcc(char* tag, int index, enum CodecType type)
+static char* avi_stream2fourcc(char* tag, int index, enum AVMediaType type)
 {
     tag[0] = '0';
     tag[1] = '0' + index;
-    if (type == CODEC_TYPE_VIDEO) {
+    if (type == AVMEDIA_TYPE_VIDEO) {
         tag[2] = 'd';
         tag[3] = 'c';
-    } else if (type == CODEC_TYPE_SUBTITLE) {
+    } else if (type == AVMEDIA_TYPE_SUBTITLE) {
         // note: this is not an official code
         tag[2] = 's';
         tag[3] = 'b';
@@ -136,7 +136,7 @@ static int avi_write_counters(AVFormatContext* s, int riff_id)
         } else {
             put_le32(pb, avist->audio_strm_length / au_ssize);
         }
-        if(stream->codec_type == CODEC_TYPE_VIDEO)
+        if(stream->codec_type == AVMEDIA_TYPE_VIDEO)
             nb_frames = FFMAX(nb_frames, avist->packet_count);
     }
     if(riff_id == 1) {
@@ -177,7 +177,7 @@ static int avi_write_header(AVFormatContext *s)
     for(n=0;n<s->nb_streams;n++) {
         stream = s->streams[n]->codec;
         bitrate += stream->bit_rate;
-        if (stream->codec_type == CODEC_TYPE_VIDEO)
+        if (stream->codec_type == AVMEDIA_TYPE_VIDEO)
             video_enc = stream;
     }
 
@@ -222,16 +222,16 @@ static int avi_write_header(AVFormatContext *s)
         /* stream generic header */
         strh = ff_start_tag(pb, "strh");
         switch(stream->codec_type) {
-        case CODEC_TYPE_SUBTITLE:
+        case AVMEDIA_TYPE_SUBTITLE:
             // XSUB subtitles behave like video tracks, other subtitles
             // are not (yet) supported.
             if (stream->codec_id != CODEC_ID_XSUB) break;
-        case CODEC_TYPE_VIDEO: put_tag(pb, "vids"); break;
-        case CODEC_TYPE_AUDIO: put_tag(pb, "auds"); break;
-//        case CODEC_TYPE_TEXT : put_tag(pb, "txts"); break;
-        case CODEC_TYPE_DATA : put_tag(pb, "dats"); break;
+        case AVMEDIA_TYPE_VIDEO: put_tag(pb, "vids"); break;
+        case AVMEDIA_TYPE_AUDIO: put_tag(pb, "auds"); break;
+//        case AVMEDIA_TYPE_TEXT : put_tag(pb, "txts"); break;
+        case AVMEDIA_TYPE_DATA : put_tag(pb, "dats"); break;
         }
-        if(stream->codec_type == CODEC_TYPE_VIDEO ||
+        if(stream->codec_type == AVMEDIA_TYPE_VIDEO ||
            stream->codec_id == CODEC_ID_XSUB)
             put_le32(pb, stream->codec_tag);
         else
@@ -255,9 +255,9 @@ static int avi_write_header(AVFormatContext *s)
             put_le32(pb, 0); /* length, XXX: filled later */
 
         /* suggested buffer size */ //FIXME set at the end to largest chunk
-        if(stream->codec_type == CODEC_TYPE_VIDEO)
+        if(stream->codec_type == AVMEDIA_TYPE_VIDEO)
             put_le32(pb, 1024 * 1024);
-        else if(stream->codec_type == CODEC_TYPE_AUDIO)
+        else if(stream->codec_type == AVMEDIA_TYPE_AUDIO)
             put_le32(pb, 12 * 1024);
         else
             put_le32(pb, 0);
@@ -268,17 +268,17 @@ static int avi_write_header(AVFormatContext *s)
         put_le16(pb, stream->height);
         ff_end_tag(pb, strh);
 
-      if(stream->codec_type != CODEC_TYPE_DATA){
+      if(stream->codec_type != AVMEDIA_TYPE_DATA){
         strf = ff_start_tag(pb, "strf");
         switch(stream->codec_type) {
-        case CODEC_TYPE_SUBTITLE:
+        case AVMEDIA_TYPE_SUBTITLE:
             // XSUB subtitles behave like video tracks, other subtitles
             // are not (yet) supported.
             if (stream->codec_id != CODEC_ID_XSUB) break;
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             ff_put_bmp_header(pb, stream, ff_codec_bmp_tags, 0);
             break;
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             if (ff_put_wav_header(pb, stream) < 0) {
                 return -1;
             }
@@ -322,7 +322,7 @@ static int avi_write_header(AVFormatContext *s)
             ff_end_tag(pb, avist->indexes.indx_start);
         }
 
-        if(   stream->codec_type == CODEC_TYPE_VIDEO
+        if(   stream->codec_type == AVMEDIA_TYPE_VIDEO
            && s->streams[i]->sample_aspect_ratio.num>0
            && s->streams[i]->sample_aspect_ratio.den>0){
             int vprp= ff_start_tag(pb, "vprp");
@@ -542,7 +542,7 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
     avi_stream2fourcc(&tag[0], stream_index, enc->codec_type);
     if(pkt->flags&PKT_FLAG_KEY)
         flags = 0x10;
-    if (enc->codec_type == CODEC_TYPE_AUDIO) {
+    if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
        avist->audio_strm_length += size;
     }
 
@@ -603,7 +603,7 @@ static int avi_write_trailer(AVFormatContext *s)
                 AVCodecContext *stream = s->streams[n]->codec;
                 AVIStream *avist= s->streams[n]->priv_data;
 
-                if (stream->codec_type == CODEC_TYPE_VIDEO) {
+                if (stream->codec_type == AVMEDIA_TYPE_VIDEO) {
                     if (nb_frames < avist->packet_count)
                         nb_frames = avist->packet_count;
                 } else {
diff --git a/libavformat/avisynth.c b/libavformat/avisynth.c
index 7ca52d98928b4ad8dd57f0dcb28ed2acedfc6668..e2a8a3cf5a61a95b505b2ef2fcf0b7d3cab2d0d2 100644
--- a/libavformat/avisynth.c
+++ b/libavformat/avisynth.c
@@ -85,7 +85,7 @@ static int avisynth_read_header(AVFormatContext *s, AVFormatParameters *ap)
                     continue;
 
                   st = av_new_stream(s, id);
-                  st->codec->codec_type = CODEC_TYPE_AUDIO;
+                  st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
 
                   st->codec->block_align = wvfmt.nBlockAlign;
                   st->codec->channels = wvfmt.nChannels;
@@ -111,7 +111,7 @@ static int avisynth_read_header(AVFormatContext *s, AVFormatParameters *ap)
                     continue;
 
                   st = av_new_stream(s, id);
-                  st->codec->codec_type = CODEC_TYPE_VIDEO;
+                  st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
                   st->r_frame_rate.num = stream->info.dwRate;
                   st->r_frame_rate.den = stream->info.dwScale;
 
diff --git a/libavformat/avs.c b/libavformat/avs.c
index 1fcb19fddeacb4aac19af8e75b86c77f8135f34d..9cdd336c05adfe4d19d13ec5c718ab05ad05c18d 100644
--- a/libavformat/avs.c
+++ b/libavformat/avs.c
@@ -178,7 +178,7 @@ static int avs_read_packet(AVFormatContext * s, AVPacket * pkt)
                     avs->st_video = av_new_stream(s, AVS_VIDEO);
                     if (avs->st_video == NULL)
                         return AVERROR(ENOMEM);
-                    avs->st_video->codec->codec_type = CODEC_TYPE_VIDEO;
+                    avs->st_video->codec->codec_type = AVMEDIA_TYPE_VIDEO;
                     avs->st_video->codec->codec_id = CODEC_ID_AVS;
                     avs->st_video->codec->width = avs->width;
                     avs->st_video->codec->height = avs->height;
@@ -195,7 +195,7 @@ static int avs_read_packet(AVFormatContext * s, AVPacket * pkt)
                     avs->st_audio = av_new_stream(s, AVS_AUDIO);
                     if (avs->st_audio == NULL)
                         return AVERROR(ENOMEM);
-                    avs->st_audio->codec->codec_type = CODEC_TYPE_AUDIO;
+                    avs->st_audio->codec->codec_type = AVMEDIA_TYPE_AUDIO;
                 }
                 avs->remaining_audio_size = size - 4;
                 size = avs_read_audio_packet(s, pkt);
diff --git a/libavformat/bethsoftvid.c b/libavformat/bethsoftvid.c
index e599255f16910201b1d161bbceb5e70bcff4ac38..43275c985906d56b7b387f22faef6b1274d7f83f 100644
--- a/libavformat/bethsoftvid.c
+++ b/libavformat/bethsoftvid.c
@@ -74,7 +74,7 @@ static int vid_read_header(AVFormatContext *s,
     if (!stream)
         return AVERROR(ENOMEM);
     av_set_pts_info(stream, 32, 1, 60);     // 16 ms increments, i.e. 60 fps
-    stream->codec->codec_type = CODEC_TYPE_VIDEO;
+    stream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     stream->codec->codec_id = CODEC_ID_BETHSOFTVID;
     stream->codec->width = get_le16(pb);
     stream->codec->height = get_le16(pb);
@@ -86,7 +86,7 @@ static int vid_read_header(AVFormatContext *s,
     stream = av_new_stream(s, 0);
     if (!stream)
         return AVERROR(ENOMEM);
-    stream->codec->codec_type = CODEC_TYPE_AUDIO;
+    stream->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     stream->codec->codec_id = CODEC_ID_PCM_U8;
     stream->codec->channels = 1;
     stream->codec->sample_rate = 11025;
diff --git a/libavformat/bfi.c b/libavformat/bfi.c
index cecbfbabd0f989cbb8834a2adba91f8b419dd96b..f9e427ccd1ee9fc70a7030627f0693f653be6d58 100644
--- a/libavformat/bfi.c
+++ b/libavformat/bfi.c
@@ -87,12 +87,12 @@ static int bfi_read_header(AVFormatContext * s, AVFormatParameters * ap)
 
     /* Set up the video codec... */
     av_set_pts_info(vstream, 32, 1, fps);
-    vstream->codec->codec_type = CODEC_TYPE_VIDEO;
+    vstream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     vstream->codec->codec_id   = CODEC_ID_BFI;
     vstream->codec->pix_fmt    = PIX_FMT_PAL8;
 
     /* Set up the audio codec now... */
-    astream->codec->codec_type      = CODEC_TYPE_AUDIO;
+    astream->codec->codec_type      = AVMEDIA_TYPE_AUDIO;
     astream->codec->codec_id        = CODEC_ID_PCM_U8;
     astream->codec->channels        = 1;
     astream->codec->bits_per_coded_sample = 8;
diff --git a/libavformat/bink.c b/libavformat/bink.c
index ac04e762e853f5cd87a771742b2ec71811cac1dd..3bb73610adfbddfc56f4a195ad3da6abeddb4b2f 100644
--- a/libavformat/bink.c
+++ b/libavformat/bink.c
@@ -111,7 +111,7 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
     }
     av_set_pts_info(vst, 64, fps_den, fps_num);
 
-    vst->codec->codec_type = CODEC_TYPE_VIDEO;
+    vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     vst->codec->codec_id   = CODEC_ID_BINKVIDEO;
     vst->codec->extradata  = av_mallocz(4 + FF_INPUT_BUFFER_PADDING_SIZE);
     vst->codec->extradata_size = 4;
@@ -133,7 +133,7 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
             ast = av_new_stream(s, 1);
             if (!ast)
                 return AVERROR(ENOMEM);
-            ast->codec->codec_type  = CODEC_TYPE_AUDIO;
+            ast->codec->codec_type  = AVMEDIA_TYPE_AUDIO;
             ast->codec->codec_tag   = 0;
             ast->codec->sample_rate = get_le16(pb);
             av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
diff --git a/libavformat/c93.c b/libavformat/c93.c
index e829e395cc818593af6f5bc120b6c2356b771cfc..cd3d36a1600c6cba555b2dd9b04d2eeffda3e4a1 100644
--- a/libavformat/c93.c
+++ b/libavformat/c93.c
@@ -83,7 +83,7 @@ static int read_header(AVFormatContext *s,
     if (!video)
         return AVERROR(ENOMEM);
 
-    video->codec->codec_type = CODEC_TYPE_VIDEO;
+    video->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     video->codec->codec_id = CODEC_ID_C93;
     video->codec->width = 320;
     video->codec->height = 192;
@@ -120,7 +120,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
                 c93->audio = av_new_stream(s, 1);
                 if (!c93->audio)
                     return AVERROR(ENOMEM);
-                c93->audio->codec->codec_type = CODEC_TYPE_AUDIO;
+                c93->audio->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             }
             url_fskip(pb, 26); /* VOC header */
             ret = voc_get_packet(s, pkt, c93->audio, datasize - 26);
diff --git a/libavformat/cafdec.c b/libavformat/cafdec.c
index df297164ba30b8b1a7cd58a179f0549d400470e4..720a49a8997dc50bb5a74cce442f791cdbdec3ad 100644
--- a/libavformat/cafdec.c
+++ b/libavformat/cafdec.c
@@ -64,7 +64,7 @@ static int read_desc_chunk(AVFormatContext *s)
         return AVERROR_NOMEM;
 
     /* parse format description */
-    st->codec->codec_type  = CODEC_TYPE_AUDIO;
+    st->codec->codec_type  = AVMEDIA_TYPE_AUDIO;
     st->codec->sample_rate = av_int2dbl(get_be64(pb));
     st->codec->codec_tag   = get_be32(pb);
     flags = get_be32(pb);
diff --git a/libavformat/cdg.c b/libavformat/cdg.c
index f40028d2f967686cb17c0348cf9c420427dda000..2f4fb2771d9d52baaddad7771a97e634373cb197 100644
--- a/libavformat/cdg.c
+++ b/libavformat/cdg.c
@@ -32,7 +32,7 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
     if (!vst)
         return AVERROR(ENOMEM);
 
-    vst->codec->codec_type = CODEC_TYPE_VIDEO;
+    vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     vst->codec->codec_id   = CODEC_ID_CDGRAPHICS;
 
     /// 75 sectors/sec * 4 packets/sector = 300 packets/sec
diff --git a/libavformat/daud.c b/libavformat/daud.c
index cdd831ba4b0d081544cc1b5eb0754c3153d0607f..9b0e00834725e184d2faeb9cbe1076bcbc588753 100644
--- a/libavformat/daud.c
+++ b/libavformat/daud.c
@@ -24,7 +24,7 @@ static int daud_header(AVFormatContext *s, AVFormatParameters *ap) {
     AVStream *st = av_new_stream(s, 0);
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_PCM_S24DAUD;
     st->codec->codec_tag = MKTAG('d', 'a', 'u', 'd');
     st->codec->channels = 6;
diff --git a/libavformat/dsicin.c b/libavformat/dsicin.c
index 113f8ffca2e401ae174acab24761d05a7118ee14..72ce17c57e44760c89a8e6e788cd0e037fbaae56 100644
--- a/libavformat/dsicin.c
+++ b/libavformat/dsicin.c
@@ -113,7 +113,7 @@ static int cin_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
     av_set_pts_info(st, 32, 1, 12);
     cin->video_stream_index = st->index;
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_DSICINVIDEO;
     st->codec->codec_tag = 0;  /* no fourcc */
     st->codec->width = hdr->video_frame_width;
@@ -126,7 +126,7 @@ static int cin_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
     av_set_pts_info(st, 32, 1, 22050);
     cin->audio_stream_index = st->index;
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_DSICINAUDIO;
     st->codec->codec_tag = 0;  /* no tag */
     st->codec->channels = 1;
diff --git a/libavformat/dv.c b/libavformat/dv.c
index af8bb921cb8981409864e04afe1177e594950a69..f30f2ae1b9b709da6ebc59b40f837f49f920c310 100644
--- a/libavformat/dv.c
+++ b/libavformat/dv.c
@@ -214,7 +214,7 @@ static int dv_extract_audio_info(DVDemuxContext* c, uint8_t* frame)
            if (!c->ast[i])
                break;
            av_set_pts_info(c->ast[i], 64, 1, 30000);
-           c->ast[i]->codec->codec_type = CODEC_TYPE_AUDIO;
+           c->ast[i]->codec->codec_type = AVMEDIA_TYPE_AUDIO;
            c->ast[i]->codec->codec_id   = CODEC_ID_PCM_S16LE;
 
            av_init_packet(&c->audio_pkt[i]);
@@ -290,7 +290,7 @@ DVDemuxContext* dv_init_demux(AVFormatContext *s)
     c->frames = 0;
     c->abytes = 0;
 
-    c->vst->codec->codec_type = CODEC_TYPE_VIDEO;
+    c->vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     c->vst->codec->codec_id   = CODEC_ID_DVVIDEO;
     c->vst->codec->bit_rate   = 25000000;
     c->vst->start_time        = 0;
diff --git a/libavformat/dvenc.c b/libavformat/dvenc.c
index 351062b76ae496aa7a102fcda4dddb85a7225ce8..617980903e3c655b597864d49f315a0b793b2302 100644
--- a/libavformat/dvenc.c
+++ b/libavformat/dvenc.c
@@ -239,7 +239,7 @@ int dv_assemble_frame(DVMuxContext *c, AVStream* st,
     reqasize = 4 * dv_audio_frame_size(c->sys, c->frames);
 
     switch (st->codec->codec_type) {
-    case CODEC_TYPE_VIDEO:
+    case AVMEDIA_TYPE_VIDEO:
         /* FIXME: we have to have more sensible approach than this one */
         if (c->has_video)
             av_log(st->codec, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient audio data or severe sync problem.\n", c->frames);
@@ -247,7 +247,7 @@ int dv_assemble_frame(DVMuxContext *c, AVStream* st,
         memcpy(*frame, data, c->sys->frame_size);
         c->has_video = 1;
         break;
-    case CODEC_TYPE_AUDIO:
+    case AVMEDIA_TYPE_AUDIO:
         for (i = 0; i < c->n_ast && st != c->ast[i]; i++);
 
           /* FIXME: we have to have more sensible approach than this one */
@@ -299,11 +299,11 @@ DVMuxContext* dv_init_mux(AVFormatContext* s)
     /* We have to sort out where audio and where video stream is */
     for (i=0; i<s->nb_streams; i++) {
         switch (s->streams[i]->codec->codec_type) {
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             if (vst) return NULL;
             vst = s->streams[i];
             break;
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             if (c->n_ast > 1) return NULL;
             c->ast[c->n_ast++] = s->streams[i];
             break;
diff --git a/libavformat/dxa.c b/libavformat/dxa.c
index a68d4c4efbc64cb07d5008cff058aa7b660a4ad3..c00c917d0b9c776276e78e1aebbc0cfbd690e359 100644
--- a/libavformat/dxa.c
+++ b/libavformat/dxa.c
@@ -119,7 +119,7 @@ static int dxa_read_header(AVFormatContext *s, AVFormatParameters *ap)
     }
 
     /* now we are ready: build format streams */
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id   = CODEC_ID_DXA;
     st->codec->width      = w;
     st->codec->height     = h;
diff --git a/libavformat/eacdata.c b/libavformat/eacdata.c
index 5fa22863b8d04aee8b5529b768140eba1d073692..ac5dbe3947d1541a136bde309d68ca59d4837788 100644
--- a/libavformat/eacdata.c
+++ b/libavformat/eacdata.c
@@ -67,7 +67,7 @@ static int cdata_read_header(AVFormatContext *s, AVFormatParameters *ap)
     st = av_new_stream(s, 0);
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_tag = 0; /* no fourcc */
     st->codec->codec_id = CODEC_ID_ADPCM_EA_XAS;
     st->codec->channels = cdata->channels;
diff --git a/libavformat/electronicarts.c b/libavformat/electronicarts.c
index df9aded9d3f7210553b50c0e5f1c1bdc0297e053..fd05870f0d5e9dd69189adb206103db5ad88ed76 100644
--- a/libavformat/electronicarts.c
+++ b/libavformat/electronicarts.c
@@ -414,7 +414,7 @@ static int ea_read_header(AVFormatContext *s,
         if (!st)
             return AVERROR(ENOMEM);
         ea->video_stream_index = st->index;
-        st->codec->codec_type = CODEC_TYPE_VIDEO;
+        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         st->codec->codec_id = ea->video_codec;
         st->codec->codec_tag = 0;  /* no fourcc */
         st->codec->time_base = ea->time_base;
@@ -428,7 +428,7 @@ static int ea_read_header(AVFormatContext *s,
         if (!st)
             return AVERROR(ENOMEM);
         av_set_pts_info(st, 33, 1, ea->sample_rate);
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_id = ea->audio_codec;
         st->codec->codec_tag = 0;  /* no tag */
         st->codec->channels = ea->num_channels;
diff --git a/libavformat/ffmdec.c b/libavformat/ffmdec.c
index b39836adb4aa076a01f05e73fca5d017b9202082..3f0911fa1e0b5c46e5a85b4e77b960f2e9608896 100644
--- a/libavformat/ffmdec.c
+++ b/libavformat/ffmdec.c
@@ -301,7 +301,7 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
         codec->debug = get_be32(pb);
         /* specific info */
         switch(codec->codec_type) {
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             codec->time_base.num = get_be32(pb);
             codec->time_base.den = get_be32(pb);
             codec->width = get_be16(pb);
@@ -350,7 +350,7 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
             codec->refs = get_be32(pb);
             codec->directpred = get_be32(pb);
             break;
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             codec->sample_rate = get_be32(pb);
             codec->channels = get_le16(pb);
             codec->frame_size = get_le16(pb);
diff --git a/libavformat/ffmenc.c b/libavformat/ffmenc.c
index 52d55d6936f60ed5d8cc3c79adad647ab0373e11..b9e62aa197f64cf729663fe383bd90c4b14a65c0 100644
--- a/libavformat/ffmenc.c
+++ b/libavformat/ffmenc.c
@@ -119,7 +119,7 @@ static int ffm_write_header(AVFormatContext *s)
         put_be32(pb, codec->debug);
         /* specific info */
         switch(codec->codec_type) {
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             put_be32(pb, codec->time_base.num);
             put_be32(pb, codec->time_base.den);
             put_be16(pb, codec->width);
@@ -168,7 +168,7 @@ static int ffm_write_header(AVFormatContext *s)
             put_be32(pb, codec->refs);
             put_be32(pb, codec->directpred);
             break;
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             put_be32(pb, codec->sample_rate);
             put_le16(pb, codec->channels);
             put_le16(pb, codec->frame_size);
diff --git a/libavformat/filmstripdec.c b/libavformat/filmstripdec.c
index 80c4157d8e0e5553111b970fe09d3202d9115ebf..2fa658b4f0aa7418ca18f01b40efb551fe889103 100644
--- a/libavformat/filmstripdec.c
+++ b/libavformat/filmstripdec.c
@@ -60,7 +60,7 @@ static int read_header(AVFormatContext *s,
     }
 
     url_fskip(pb, 2);
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id   = CODEC_ID_RAWVIDEO;
     st->codec->pix_fmt    = PIX_FMT_RGBA;
     st->codec->codec_tag  = 0; /* no fourcc */
diff --git a/libavformat/flacdec.c b/libavformat/flacdec.c
index a1bb51b074d6b39c67449f7f13bb7d79cbe6dfaf..02ae8ae628cee0a5d9680af5124d49413f36a457 100644
--- a/libavformat/flacdec.c
+++ b/libavformat/flacdec.c
@@ -36,7 +36,7 @@ static int flac_read_header(AVFormatContext *s,
     AVStream *st = av_new_stream(s, 0);
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_FLAC;
     st->need_parsing = AVSTREAM_PARSE_FULL;
     /* the parameters will be extracted from the compressed bitstream */
diff --git a/libavformat/flic.c b/libavformat/flic.c
index b382a25f96de6ca14a5ab1118c6e58350334742a..55f07587bef30b0dddb8974246fc23b1544ed3d8 100644
--- a/libavformat/flic.c
+++ b/libavformat/flic.c
@@ -103,7 +103,7 @@ static int flic_read_header(AVFormatContext *s,
     if (!st)
         return AVERROR(ENOMEM);
     flic->video_stream_index = st->index;
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_FLIC;
     st->codec->codec_tag = 0;  /* no fourcc */
     st->codec->width = AV_RL16(&header[0x08]);
diff --git a/libavformat/flvdec.c b/libavformat/flvdec.c
index f84ad31c31b29e3c0c74959e43ad613917598907..fc51594f6f229ffbd348259483349fefa54894a5 100644
--- a/libavformat/flvdec.c
+++ b/libavformat/flvdec.c
@@ -221,8 +221,8 @@ static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {
     //find the streams now so that amf_parse_object doesn't need to do the lookup every time it is called.
     for(i = 0; i < s->nb_streams; i++) {
         stream = s->streams[i];
-        if     (stream->codec->codec_type == CODEC_TYPE_AUDIO) astream = stream;
-        else if(stream->codec->codec_type == CODEC_TYPE_VIDEO) vstream = stream;
+        if     (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO) astream = stream;
+        else if(stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) vstream = stream;
     }
 
     //parse the second object (we want a mixed array)
@@ -236,7 +236,7 @@ static AVStream *create_stream(AVFormatContext *s, int is_audio){
     AVStream *st = av_new_stream(s, is_audio);
     if (!st)
         return NULL;
-    st->codec->codec_type = is_audio ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
+    st->codec->codec_type = is_audio ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
     av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
     return st;
 }
diff --git a/libavformat/flvenc.c b/libavformat/flvenc.c
index cf6b1c566fe9d748a8333d6984aaac5d549de841..9b687375308b557f434d9f2c2c36d3fa1d5b9383 100644
--- a/libavformat/flvenc.c
+++ b/libavformat/flvenc.c
@@ -166,7 +166,7 @@ static int flv_write_header(AVFormatContext *s)
 
     for(i=0; i<s->nb_streams; i++){
         AVCodecContext *enc = s->streams[i]->codec;
-        if (enc->codec_type == CODEC_TYPE_VIDEO) {
+        if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
             if (s->streams[i]->r_frame_rate.den && s->streams[i]->r_frame_rate.num) {
                 framerate = av_q2d(s->streams[i]->r_frame_rate);
             } else {
@@ -275,7 +275,7 @@ static int flv_write_header(AVFormatContext *s)
         AVCodecContext *enc = s->streams[i]->codec;
         if (enc->codec_id == CODEC_ID_AAC || enc->codec_id == CODEC_ID_H264) {
             int64_t pos;
-            put_byte(pb, enc->codec_type == CODEC_TYPE_VIDEO ?
+            put_byte(pb, enc->codec_type == AVMEDIA_TYPE_VIDEO ?
                      FLV_TAG_TYPE_VIDEO : FLV_TAG_TYPE_AUDIO);
             put_be24(pb, 0); // size patched later
             put_be24(pb, 0); // ts
@@ -342,7 +342,7 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
     else
         flags_size= 1;
 
-    if (enc->codec_type == CODEC_TYPE_VIDEO) {
+    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
         put_byte(pb, FLV_TAG_TYPE_VIDEO);
 
         flags = enc->codec_tag;
@@ -353,7 +353,7 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
 
         flags |= pkt->flags & PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER;
     } else {
-        assert(enc->codec_type == CODEC_TYPE_AUDIO);
+        assert(enc->codec_type == AVMEDIA_TYPE_AUDIO);
         flags = get_audio_flags(enc);
 
         assert(size);
diff --git a/libavformat/gif.c b/libavformat/gif.c
index 2b802a9dca019e47ee5caaa559f8cbde4ab0c153..4741915bac63666bd2b567a46f1c2b5133759d4a 100644
--- a/libavformat/gif.c
+++ b/libavformat/gif.c
@@ -266,7 +266,7 @@ static int gif_write_header(AVFormatContext *s)
     video_enc = NULL;
     for(i=0;i<s->nb_streams;i++) {
         enc = s->streams[i]->codec;
-        if (enc->codec_type != CODEC_TYPE_AUDIO)
+        if (enc->codec_type != AVMEDIA_TYPE_AUDIO)
             video_enc = enc;
     }
 
@@ -329,7 +329,7 @@ static int gif_write_video(AVFormatContext *s,
 static int gif_write_packet(AVFormatContext *s, AVPacket *pkt)
 {
     AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
-    if (codec->codec_type == CODEC_TYPE_AUDIO)
+    if (codec->codec_type == AVMEDIA_TYPE_AUDIO)
         return 0; /* just ignore audio */
     else
         return gif_write_video(s, codec, pkt->data, pkt->size);
diff --git a/libavformat/gxf.c b/libavformat/gxf.c
index 774f61aedc246eb578ce030bcb2f3c5c896f6032..ea8a2fff7fee2bd6a3e719f0be712e79867b149e 100644
--- a/libavformat/gxf.c
+++ b/libavformat/gxf.c
@@ -87,34 +87,34 @@ static int get_sindex(AVFormatContext *s, int id, int format) {
     switch (format) {
         case 3:
         case 4:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             st->codec->codec_id = CODEC_ID_MJPEG;
             break;
         case 13:
         case 15:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             st->codec->codec_id = CODEC_ID_DVVIDEO;
             break;
         case 14:
         case 16:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             st->codec->codec_id = CODEC_ID_DVVIDEO;
             break;
         case 11:
         case 12:
         case 20:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
             st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
             break;
         case 22:
         case 23:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             st->codec->codec_id = CODEC_ID_MPEG1VIDEO;
             st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
             break;
         case 9:
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             st->codec->codec_id = CODEC_ID_PCM_S24LE;
             st->codec->channels = 1;
             st->codec->sample_rate = 48000;
@@ -123,7 +123,7 @@ static int get_sindex(AVFormatContext *s, int id, int format) {
             st->codec->bits_per_coded_sample = 24;
             break;
         case 10:
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             st->codec->codec_id = CODEC_ID_PCM_S16LE;
             st->codec->channels = 1;
             st->codec->sample_rate = 48000;
@@ -132,7 +132,7 @@ static int get_sindex(AVFormatContext *s, int id, int format) {
             st->codec->bits_per_coded_sample = 16;
             break;
         case 17:
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             st->codec->codec_id = CODEC_ID_AC3;
             st->codec->channels = 2;
             st->codec->sample_rate = 48000;
@@ -141,11 +141,11 @@ static int get_sindex(AVFormatContext *s, int id, int format) {
         case 7:
         case 8:
         case 24:
-            st->codec->codec_type = CODEC_TYPE_DATA;
+            st->codec->codec_type = AVMEDIA_TYPE_DATA;
             st->codec->codec_id = CODEC_ID_NONE;
             break;
         default:
-            st->codec->codec_type = CODEC_TYPE_UNKNOWN;
+            st->codec->codec_type = AVMEDIA_TYPE_UNKNOWN;
             st->codec->codec_id = CODEC_ID_NONE;
             break;
     }
diff --git a/libavformat/gxfenc.c b/libavformat/gxfenc.c
index 603f595b32219e62e26053af8cd8dd4ac91f433c..a6f4b7260efb7d58e46d39524bf8ffa8ab145ba7 100644
--- a/libavformat/gxfenc.c
+++ b/libavformat/gxfenc.c
@@ -644,7 +644,7 @@ static int gxf_write_header(AVFormatContext *s)
         st->priv_data = sc;
 
         sc->media_type = ff_codec_get_tag(gxf_media_types, st->codec->codec_id);
-        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
             if (st->codec->codec_id != CODEC_ID_PCM_S16LE) {
                 av_log(s, AV_LOG_ERROR, "only 16 BIT PCM LE allowed for now\n");
                 return -1;
@@ -667,7 +667,7 @@ static int gxf_write_header(AVFormatContext *s)
             gxf->audio_tracks++;
             gxf->flags |= 0x04000000; /* audio is 16 bit pcm */
             media_info = 'A';
-        } else if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
             if (i != 0) {
                 av_log(s, AV_LOG_ERROR, "video stream must be the first track\n");
                 return -1;
@@ -811,7 +811,7 @@ static int gxf_write_media_preamble(AVFormatContext *s, AVPacket *pkt, int size)
     /* If the video is frame-encoded, the frame numbers shall be represented by
      * even field numbers.
      * see SMPTE360M-2004  6.4.2.1.3 Media field number */
-    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+    if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
         field_nb = gxf->nb_fields;
     } else {
         field_nb = av_rescale_rnd(pkt->dts, gxf->time_base.den,
@@ -821,7 +821,7 @@ static int gxf_write_media_preamble(AVFormatContext *s, AVPacket *pkt, int size)
     put_byte(pb, sc->media_type);
     put_byte(pb, st->index);
     put_be32(pb, field_nb);
-    if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+    if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
         put_be16(pb, 0);
         put_be16(pb, size / 2);
     } else if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO) {
@@ -859,13 +859,13 @@ static int gxf_write_packet(AVFormatContext *s, AVPacket *pkt)
     gxf_write_packet_header(pb, PKT_MEDIA);
     if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO && pkt->size % 4) /* MPEG-2 frames must be padded */
         padding = 4 - pkt->size % 4;
-    else if (st->codec->codec_type == CODEC_TYPE_AUDIO)
+    else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
         padding = GXF_AUDIO_PACKET_SIZE - pkt->size;
     gxf_write_media_preamble(s, pkt, pkt->size + padding);
     put_buffer(pb, pkt->data, pkt->size);
     gxf_write_padding(pb, padding);
 
-    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+    if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
         if (!(gxf->flt_entries_nb % 500)) {
             gxf->flt_entries = av_realloc(gxf->flt_entries,
                                           (gxf->flt_entries_nb+500)*sizeof(*gxf->flt_entries));
@@ -901,7 +901,7 @@ static int gxf_compare_field_nb(AVFormatContext *s, AVPacket *next, AVPacket *cu
     for (i = 0; i < 2; i++) {
         AVStream *st = s->streams[pkt[i]->stream_index];
         sc[i] = st->priv_data;
-        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
             field_nb[i] = av_rescale_rnd(pkt[i]->dts, gxf->time_base.den,
                                          (int64_t)48000*gxf->time_base.num, AV_ROUND_UP);
             field_nb[i] &= ~1; // compare against even field number because audio must be before video
@@ -915,7 +915,7 @@ static int gxf_compare_field_nb(AVFormatContext *s, AVPacket *next, AVPacket *cu
 
 static int gxf_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
 {
-    if (pkt && s->streams[pkt->stream_index]->codec->codec_type == CODEC_TYPE_VIDEO)
+    if (pkt && s->streams[pkt->stream_index]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
         pkt->duration = 2; // enforce 2 fields
     return ff_audio_rechunk_interleave(s, out, pkt, flush,
                                av_interleave_packet_per_dts, gxf_compare_field_nb);
diff --git a/libavformat/idcin.c b/libavformat/idcin.c
index 9fd146f9badbbaa3acf100bec720d813687f51cd..9014a6e502668262ac4ee178d72b85fce1014d7b 100644
--- a/libavformat/idcin.c
+++ b/libavformat/idcin.c
@@ -160,7 +160,7 @@ static int idcin_read_header(AVFormatContext *s,
         return AVERROR(ENOMEM);
     av_set_pts_info(st, 33, 1, IDCIN_FPS);
     idcin->video_stream_index = st->index;
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_IDCIN;
     st->codec->codec_tag = 0;  /* no fourcc */
     st->codec->width = width;
@@ -183,7 +183,7 @@ static int idcin_read_header(AVFormatContext *s,
             return AVERROR(ENOMEM);
         av_set_pts_info(st, 33, 1, IDCIN_FPS);
         idcin->audio_stream_index = st->index;
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_tag = 1;
         st->codec->channels = channels;
         st->codec->sample_rate = sample_rate;
diff --git a/libavformat/idroq.c b/libavformat/idroq.c
index c570eecf0d5729d002b024f98cc456501b93a05b..4df7fd4a679af330bcfb494b2e131c5647d94691 100644
--- a/libavformat/idroq.c
+++ b/libavformat/idroq.c
@@ -89,7 +89,7 @@ static int roq_read_header(AVFormatContext *s,
         return AVERROR(ENOMEM);
     av_set_pts_info(st, 63, 1, framerate);
     roq->video_stream_index = st->index;
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_ROQ;
     st->codec->codec_tag = 0;  /* no fourcc */
 
@@ -171,7 +171,7 @@ static int roq_read_packet(AVFormatContext *s,
                     return AVERROR(ENOMEM);
                 av_set_pts_info(st, 32, 1, RoQ_AUDIO_SAMPLE_RATE);
                 roq->audio_stream_index = st->index;
-                st->codec->codec_type = CODEC_TYPE_AUDIO;
+                st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
                 st->codec->codec_id = CODEC_ID_ROQ_DPCM;
                 st->codec->codec_tag = 0;  /* no tag */
                 st->codec->channels = roq->audio_channels = chunk_type == RoQ_SOUND_STEREO ? 2 : 1;
diff --git a/libavformat/iff.c b/libavformat/iff.c
index 62ee16d7a06c5308875ee32012b23fcb4268f859..6dcd686b806247e5fc90266789b9d17560b5acd7 100644
--- a/libavformat/iff.c
+++ b/libavformat/iff.c
@@ -119,7 +119,7 @@ static int iff_read_header(AVFormatContext *s,
 
         switch(chunk_id) {
         case ID_VHDR:
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             url_fskip(pb, 12);
             st->codec->sample_rate = get_be16(pb);
             url_fskip(pb, 1);
@@ -146,7 +146,7 @@ static int iff_read_header(AVFormatContext *s,
             break;
 
         case ID_BMHD:
-            st->codec->codec_type            = CODEC_TYPE_VIDEO;
+            st->codec->codec_type            = AVMEDIA_TYPE_VIDEO;
             st->codec->width                 = get_be16(pb);
             st->codec->height                = get_be16(pb);
             url_fskip(pb, 4); // x, y offset
@@ -175,7 +175,7 @@ static int iff_read_header(AVFormatContext *s,
     }
 
     switch(st->codec->codec_type) {
-    case CODEC_TYPE_AUDIO:
+    case AVMEDIA_TYPE_AUDIO:
     av_set_pts_info(st, 32, 1, st->codec->sample_rate);
 
     switch(compression) {
@@ -198,7 +198,7 @@ static int iff_read_header(AVFormatContext *s,
     st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample;
     break;
 
-    case CODEC_TYPE_VIDEO:
+    case AVMEDIA_TYPE_VIDEO:
         switch (compression) {
         case BITMAP_RAW:
             if (st->codec->codec_tag == ID_ILBM) {
@@ -256,7 +256,7 @@ static int iff_read_packet(AVFormatContext *s,
         st->codec->extradata_size = 0;
 
         ret = get_buffer(pb, pkt->data, iff->body_size);
-    } else if (s->streams[0]->codec->codec_type == CODEC_TYPE_VIDEO) {
+    } else if (s->streams[0]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
         ret = av_get_packet(pb, pkt, iff->body_size);
     } else {
         ret = av_get_packet(pb, pkt, PACKET_SIZE);
@@ -265,13 +265,13 @@ static int iff_read_packet(AVFormatContext *s,
     if(iff->sent_bytes == 0)
         pkt->flags |= PKT_FLAG_KEY;
 
-    if(s->streams[0]->codec->codec_type == CODEC_TYPE_AUDIO) {
+    if(s->streams[0]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
         iff->sent_bytes += PACKET_SIZE;
     } else {
         iff->sent_bytes = iff->body_size;
     }
     pkt->stream_index = 0;
-    if(s->streams[0]->codec->codec_type == CODEC_TYPE_AUDIO) {
+    if(s->streams[0]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
         pkt->pts = iff->audio_frame_count;
         iff->audio_frame_count += ret / s->streams[0]->codec->channels;
     }
diff --git a/libavformat/img2.c b/libavformat/img2.c
index 783167317c52af0b55da60b2a3774f8446c90361..a531967d81b3e0bb475be0dc1b62c93b8ee7a3cc 100644
--- a/libavformat/img2.c
+++ b/libavformat/img2.c
@@ -233,16 +233,16 @@ static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap)
     }
 
     if(s1->video_codec_id){
-        st->codec->codec_type = CODEC_TYPE_VIDEO;
+        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         st->codec->codec_id = s1->video_codec_id;
     }else if(s1->audio_codec_id){
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_id = s1->audio_codec_id;
     }else{
-        st->codec->codec_type = CODEC_TYPE_VIDEO;
+        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         st->codec->codec_id = av_str2id(img_tags, s->path);
     }
-    if(st->codec->codec_type == CODEC_TYPE_VIDEO && ap->pix_fmt != PIX_FMT_NONE)
+    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ap->pix_fmt != PIX_FMT_NONE)
         st->codec->pix_fmt = ap->pix_fmt;
 
     return 0;
diff --git a/libavformat/ipmovie.c b/libavformat/ipmovie.c
index bf62ee64cea3e7d0fcaddebe7a3403d823aa1932..7e94acef0b4ff2306da8f54820e28605c277bb0d 100644
--- a/libavformat/ipmovie.c
+++ b/libavformat/ipmovie.c
@@ -566,7 +566,7 @@ static int ipmovie_read_header(AVFormatContext *s,
         return AVERROR(ENOMEM);
     av_set_pts_info(st, 63, 1, 1000000);
     ipmovie->video_stream_index = st->index;
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_INTERPLAY_VIDEO;
     st->codec->codec_tag = 0;  /* no fourcc */
     st->codec->width = ipmovie->video_width;
@@ -582,7 +582,7 @@ static int ipmovie_read_header(AVFormatContext *s,
             return AVERROR(ENOMEM);
         av_set_pts_info(st, 32, 1, ipmovie->audio_sample_rate);
         ipmovie->audio_stream_index = st->index;
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_id = ipmovie->audio_type;
         st->codec->codec_tag = 0;  /* no tag */
         st->codec->channels = ipmovie->audio_channels;
diff --git a/libavformat/iss.c b/libavformat/iss.c
index 891729a2b57c507384ced5ccd9b333cbb80696fa..b417eb364c520a1aad0d2205b0a96efd197f12b1 100644
--- a/libavformat/iss.c
+++ b/libavformat/iss.c
@@ -92,7 +92,7 @@ static av_cold int iss_read_header(AVFormatContext *s, AVFormatParameters *ap)
     st = av_new_stream(s, 0);
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_ADPCM_IMA_ISS;
     st->codec->channels = stereo ? 2 : 1;
     st->codec->sample_rate = 44100;
diff --git a/libavformat/iv8.c b/libavformat/iv8.c
index 299de45ba82257d2bf2825d73c05b1d82cc93455..00ddcd4f7a0b586d4a8d1843f874cb3add0c5a3f 100644
--- a/libavformat/iv8.c
+++ b/libavformat/iv8.c
@@ -44,7 +44,7 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
     if (!st)
         return AVERROR(ENOMEM);
 
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_MPEG4;
     st->need_parsing = AVSTREAM_PARSE_FULL;
     av_set_pts_info(st, 64, 1, 90000);
diff --git a/libavformat/libnut.c b/libavformat/libnut.c
index f23e70dc0832519ba434691d26da611e05212a14..365a5452349e9ab729b015b1677eb3d3e0a6f08b 100644
--- a/libavformat/libnut.c
+++ b/libavformat/libnut.c
@@ -77,14 +77,14 @@ static int nut_write_header(AVFormatContext * avf) {
         int fourcc = 0;
         int num, denom, ssize;
 
-        s[i].type = codec->codec_type == CODEC_TYPE_VIDEO ? NUT_VIDEO_CLASS : NUT_AUDIO_CLASS;
+        s[i].type = codec->codec_type == AVMEDIA_TYPE_VIDEO ? NUT_VIDEO_CLASS : NUT_AUDIO_CLASS;
 
         if (codec->codec_tag) fourcc = codec->codec_tag;
         else fourcc = ff_codec_get_tag(nut_tags, codec->codec_id);
 
         if (!fourcc) {
-            if (codec->codec_type == CODEC_TYPE_VIDEO) fourcc = ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id);
-            if (codec->codec_type == CODEC_TYPE_AUDIO) fourcc = ff_codec_get_tag(ff_codec_wav_tags, codec->codec_id);
+            if (codec->codec_type == AVMEDIA_TYPE_VIDEO) fourcc = ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id);
+            if (codec->codec_type == AVMEDIA_TYPE_AUDIO) fourcc = ff_codec_get_tag(ff_codec_wav_tags, codec->codec_id);
         }
 
         s[i].fourcc_len = 4;
@@ -102,7 +102,7 @@ static int nut_write_header(AVFormatContext * avf) {
         s[i].codec_specific_len = codec->extradata_size;
         s[i].codec_specific = codec->extradata;
 
-        if (codec->codec_type == CODEC_TYPE_VIDEO) {
+        if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
             s[i].width = codec->width;
             s[i].height = codec->height;
             s[i].sample_width = 0;
@@ -234,14 +234,14 @@ static int nut_read_header(AVFormatContext * avf, AVFormatParameters * ap) {
 
         switch(s[i].type) {
         case NUT_AUDIO_CLASS:
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             if (st->codec->codec_id == CODEC_ID_NONE) st->codec->codec_id = ff_codec_get_id(ff_codec_wav_tags, st->codec->codec_tag);
 
             st->codec->channels = s[i].channel_count;
             st->codec->sample_rate = s[i].samplerate_num / s[i].samplerate_denom;
             break;
         case NUT_VIDEO_CLASS:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             if (st->codec->codec_id == CODEC_ID_NONE) st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, st->codec->codec_tag);
 
             st->codec->width = s[i].width;
diff --git a/libavformat/lmlm4.c b/libavformat/lmlm4.c
index dc0a90125ac9a058175d97852fffe067407a319c..be606e827ee195fccd768617de25262dd7374863 100644
--- a/libavformat/lmlm4.c
+++ b/libavformat/lmlm4.c
@@ -62,14 +62,14 @@ static int lmlm4_read_header(AVFormatContext *s, AVFormatParameters *ap) {
 
     if (!(st = av_new_stream(s, 0)))
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id   = CODEC_ID_MPEG4;
     st->need_parsing      = AVSTREAM_PARSE_HEADERS;
     av_set_pts_info(st, 64, 1001, 30000);
 
     if (!(st = av_new_stream(s, 1)))
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id   = CODEC_ID_MP2;
     st->need_parsing      = AVSTREAM_PARSE_HEADERS;
 
diff --git a/libavformat/matroskadec.c b/libavformat/matroskadec.c
index 1e646fc5591047234e3fb00ad7b351d565581bd3..01c2c7cabe51302b7efe92191b1420d8e1413bf4 100644
--- a/libavformat/matroskadec.c
+++ b/libavformat/matroskadec.c
@@ -1378,7 +1378,7 @@ static int matroska_read_header(AVFormatContext *s, AVFormatParameters *ap)
         }
 
         if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             st->codec->codec_tag  = track->video.fourcc;
             st->codec->width  = track->video.pixel_width;
             st->codec->height = track->video.pixel_height;
@@ -1390,11 +1390,11 @@ static int matroska_read_header(AVFormatContext *s, AVFormatParameters *ap)
             if (st->codec->codec_id != CODEC_ID_H264)
             st->need_parsing = AVSTREAM_PARSE_HEADERS;
         } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             st->codec->sample_rate = track->audio.out_samplerate;
             st->codec->channels = track->audio.channels;
         } else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
-            st->codec->codec_type = CODEC_TYPE_SUBTITLE;
+            st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
         }
     }
 
@@ -1409,7 +1409,7 @@ static int matroska_read_header(AVFormatContext *s, AVFormatParameters *ap)
                 break;
             av_metadata_set(&st->metadata, "filename",attachements[j].filename);
             st->codec->codec_id = CODEC_ID_NONE;
-            st->codec->codec_type = CODEC_TYPE_ATTACHMENT;
+            st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
             st->codec->extradata  = av_malloc(attachements[j].bin.size);
             if(st->codec->extradata == NULL)
                 break;
diff --git a/libavformat/matroskaenc.c b/libavformat/matroskaenc.c
index 0a17c73d46eceb9cef7f8719b846f87b8abc465b..32fc4bc82ff5e11929950e711614fead6a8901c0 100644
--- a/libavformat/matroskaenc.c
+++ b/libavformat/matroskaenc.c
@@ -475,7 +475,7 @@ static int mkv_write_codecprivate(AVFormatContext *s, ByteIOContext *pb, AVCodec
             ret = ff_isom_write_avcc(dyn_cp, codec->extradata, codec->extradata_size);
         else if (codec->extradata_size)
             put_buffer(dyn_cp, codec->extradata, codec->extradata_size);
-    } else if (codec->codec_type == CODEC_TYPE_VIDEO) {
+    } else if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
         if (qt_id) {
             if (!codec->codec_tag)
                 codec->codec_tag = ff_codec_get_tag(codec_movvideo_tags, codec->codec_id);
@@ -492,7 +492,7 @@ static int mkv_write_codecprivate(AVFormatContext *s, ByteIOContext *pb, AVCodec
             ff_put_bmp_header(dyn_cp, codec, ff_codec_bmp_tags, 0);
         }
 
-    } else if (codec->codec_type == CODEC_TYPE_AUDIO) {
+    } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
         unsigned int tag;
         tag = ff_codec_get_tag(ff_codec_wav_tags, codec->codec_id);
         if (!tag) {
@@ -565,7 +565,7 @@ static int mkv_write_tracks(AVFormatContext *s)
         }
 
         switch (codec->codec_type) {
-            case CODEC_TYPE_VIDEO:
+            case AVMEDIA_TYPE_VIDEO:
                 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_VIDEO);
 
                 if (!native_id &&
@@ -596,7 +596,7 @@ static int mkv_write_tracks(AVFormatContext *s)
                 end_ebml_master(pb, subinfo);
                 break;
 
-            case CODEC_TYPE_AUDIO:
+            case AVMEDIA_TYPE_AUDIO:
                 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_AUDIO);
 
                 if (!native_id)
@@ -613,7 +613,7 @@ static int mkv_write_tracks(AVFormatContext *s)
                 end_ebml_master(pb, subinfo);
                 break;
 
-            case CODEC_TYPE_SUBTITLE:
+            case AVMEDIA_TYPE_SUBTITLE:
                 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_SUBTITLE);
                 break;
             default:
@@ -893,7 +893,7 @@ static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
         av_md5_update(mkv->md5_ctx, pkt->data, FFMIN(200, pkt->size));
     }
 
-    if (codec->codec_type != CODEC_TYPE_SUBTITLE) {
+    if (codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
         mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7);
     } else if (codec->codec_id == CODEC_ID_SSA) {
         duration = mkv_write_ass_blocks(s, pb, pkt);
@@ -905,7 +905,7 @@ static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
         end_ebml_master(pb, blockgroup);
     }
 
-    if (codec->codec_type == CODEC_TYPE_VIDEO && keyframe) {
+    if (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe) {
         ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, ts, mkv->cluster_pos);
         if (ret < 0) return ret;
     }
diff --git a/libavformat/mm.c b/libavformat/mm.c
index 8ed315428a76cda96d0ddd0093610097a7f0d9a4..d6c9c303c9dc9218d60fbfef1bd6a62b4ca83c83 100644
--- a/libavformat/mm.c
+++ b/libavformat/mm.c
@@ -108,7 +108,7 @@ static int read_header(AVFormatContext *s,
     st = av_new_stream(s, 0);
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_MMVIDEO;
     st->codec->codec_tag = 0;  /* no fourcc */
     st->codec->width = width;
@@ -120,7 +120,7 @@ static int read_header(AVFormatContext *s,
         st = av_new_stream(s, 0);
         if (!st)
             return AVERROR(ENOMEM);
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_tag = 0; /* no fourcc */
         st->codec->codec_id = CODEC_ID_PCM_U8;
         st->codec->channels = 1;
diff --git a/libavformat/mmf.c b/libavformat/mmf.c
index 75afa0e31c701de65ccf429bafbc81a7f4446fe5..540407f65911f7813044cb5c7ccaa20db2e725a7 100644
--- a/libavformat/mmf.c
+++ b/libavformat/mmf.c
@@ -244,7 +244,7 @@ static int mmf_read_header(AVFormatContext *s,
     if (!st)
         return AVERROR(ENOMEM);
 
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_ADPCM_YAMAHA;
     st->codec->sample_rate = rate;
     st->codec->channels = 1;
diff --git a/libavformat/mov.c b/libavformat/mov.c
index f8b2d8d0cbf941314f92f518efc25a44d21f1b04..59baa0d6c3008db88fb2957d94a05fe301875f02 100644
--- a/libavformat/mov.c
+++ b/libavformat/mov.c
@@ -411,13 +411,13 @@ static int mov_read_hdlr(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
     dprintf(c->fc, "stype= %.4s\n", (char*)&type);
 
     if     (type == MKTAG('v','i','d','e'))
-        st->codec->codec_type = CODEC_TYPE_VIDEO;
+        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     else if(type == MKTAG('s','o','u','n'))
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     else if(type == MKTAG('m','1','a',' '))
         st->codec->codec_id = CODEC_ID_MP2;
     else if(type == MKTAG('s','u','b','p'))
-        st->codec->codec_type = CODEC_TYPE_SUBTITLE;
+        st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
 
     get_be32(pb); /* component  manufacture */
     get_be32(pb); /* component flags */
@@ -933,19 +933,19 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
         if (id<=0 && ((format&0xFFFF) == 'm'+('s'<<8) || (format&0xFFFF) == 'T'+('S'<<8)))
             id = ff_codec_get_id(ff_codec_wav_tags, bswap_32(format)&0xFFFF);
 
-        if (st->codec->codec_type != CODEC_TYPE_VIDEO && id > 0) {
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
-        } else if (st->codec->codec_type != CODEC_TYPE_AUDIO && /* do not overwrite codec type */
+        if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
+        } else if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO && /* do not overwrite codec type */
                    format && format != MKTAG('m','p','4','s')) { /* skip old asf mpeg4 tag */
             id = ff_codec_get_id(codec_movvideo_tags, format);
             if (id <= 0)
                 id = ff_codec_get_id(ff_codec_bmp_tags, format);
             if (id > 0)
-                st->codec->codec_type = CODEC_TYPE_VIDEO;
-            else if(st->codec->codec_type == CODEC_TYPE_DATA){
+                st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+            else if(st->codec->codec_type == AVMEDIA_TYPE_DATA){
                 id = ff_codec_get_id(ff_codec_movsubtitle_tags, format);
                 if(id > 0)
-                    st->codec->codec_type = CODEC_TYPE_SUBTITLE;
+                    st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
             }
         }
 
@@ -953,7 +953,7 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
                 (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
                 (format >> 24) & 0xff, st->codec->codec_type);
 
-        if(st->codec->codec_type==CODEC_TYPE_VIDEO) {
+        if(st->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
             unsigned int color_depth, len;
             int color_greyscale;
 
@@ -1057,7 +1057,7 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
                 }
                 st->codec->palctrl->palette_changed = 1;
             }
-        } else if(st->codec->codec_type==CODEC_TYPE_AUDIO) {
+        } else if(st->codec->codec_type==AVMEDIA_TYPE_AUDIO) {
             int bits_per_sample, flags;
             uint16_t version = get_be16(pb);
 
@@ -1137,7 +1137,7 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
                 st->codec->bits_per_coded_sample = bits_per_sample;
                 sc->sample_size = (bits_per_sample >> 3) * st->codec->channels;
             }
-        } else if(st->codec->codec_type==CODEC_TYPE_SUBTITLE){
+        } else if(st->codec->codec_type==AVMEDIA_TYPE_SUBTITLE){
             // ttxt stsd contains display flags, justification, background
             // color, fonts, and default styles, so fake an atom to read it
             MOVAtom fake_atom = { .size = size - (url_ftell(pb) - start_pos) };
@@ -1159,7 +1159,7 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
             url_fskip(pb, a.size);
     }
 
-    if(st->codec->codec_type==CODEC_TYPE_AUDIO && st->codec->sample_rate==0 && sc->time_scale>1)
+    if(st->codec->codec_type==AVMEDIA_TYPE_AUDIO && st->codec->sample_rate==0 && sc->time_scale>1)
         st->codec->sample_rate= sc->time_scale;
 
     /* special codec parameters handling */
@@ -1196,7 +1196,7 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
         break;
     case CODEC_ID_MP2:
     case CODEC_ID_MP3:
-        st->codec->codec_type = CODEC_TYPE_AUDIO; /* force type after stsd for m1a hdlr */
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO; /* force type after stsd for m1a hdlr */
         st->need_parsing = AVSTREAM_PARSE_FULL;
         break;
     case CODEC_ID_GSM:
@@ -1490,7 +1490,7 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
     }
 
     /* only use old uncompressed audio chunk demuxing when stts specifies it */
-    if (!(st->codec->codec_type == CODEC_TYPE_AUDIO &&
+    if (!(st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
           sc->stts_count == 1 && sc->stts_data[0].duration == 1)) {
         unsigned int current_sample = 0;
         unsigned int stts_sample = 0;
@@ -1698,7 +1698,7 @@ static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
     if (!sc) return AVERROR(ENOMEM);
 
     st->priv_data = sc;
-    st->codec->codec_type = CODEC_TYPE_DATA;
+    st->codec->codec_type = AVMEDIA_TYPE_DATA;
     sc->ffindex = st->index;
 
     if ((ret = mov_read_default(c, pb, atom)) < 0)
@@ -1721,7 +1721,7 @@ static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
 
     av_set_pts_info(st, 64, 1, sc->time_scale);
 
-    if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
+    if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
         !st->codec->frame_size && sc->stts_count == 1) {
         st->codec->frame_size = av_rescale(sc->stts_data[0].duration,
                                            st->codec->sample_rate, sc->time_scale);
@@ -1741,7 +1741,7 @@ static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
     } else
         sc->pb = c->fc->pb;
 
-    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+    if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
         if (st->codec->width != sc->width || st->codec->height != sc->height) {
             AVRational r = av_d2q(((double)st->codec->height * sc->width) /
                                   ((double)st->codec->width * sc->height), INT_MAX);
@@ -2004,7 +2004,7 @@ static int mov_read_trun(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
             sc->ctts_data[sc->ctts_count].duration = get_be32(pb);
             sc->ctts_count++;
         }
-        if ((keyframe = st->codec->codec_type == CODEC_TYPE_AUDIO ||
+        if ((keyframe = st->codec->codec_type == AVMEDIA_TYPE_AUDIO ||
              (flags & 0x004 && !i && !sample_flags) || sample_flags & 0x2000000))
             distance = 0;
         av_add_index_entry(st, offset, dts, sample_size, distance,
diff --git a/libavformat/movenc.c b/libavformat/movenc.c
index 671a9dde2dab87882eb836cab299f62c7d5ee191..f5c344f7abf0b2ecbc78f915d299dded7f560e2c 100644
--- a/libavformat/movenc.c
+++ b/libavformat/movenc.c
@@ -333,7 +333,7 @@ static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack *track) // Basic
 
     // the following fields is made of 6 bits to identify the streamtype (4 for video, 5 for audio)
     // plus 1 bit to indicate upstream and 1 bit set to 1 (reserved)
-    if(track->enc->codec_type == CODEC_TYPE_AUDIO)
+    if(track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
         put_byte(pb, 0x15); // flags (= Audiostream)
     else
         put_byte(pb, 0x11); // flags (= Visualstream)
@@ -620,8 +620,8 @@ static int mp4_get_codec_tag(AVFormatContext *s, MOVTrack *track)
     else if (track->enc->codec_id == CODEC_ID_AC3)       tag = MKTAG('a','c','-','3');
     else if (track->enc->codec_id == CODEC_ID_DIRAC)     tag = MKTAG('d','r','a','c');
     else if (track->enc->codec_id == CODEC_ID_MOV_TEXT)  tag = MKTAG('t','x','3','g');
-    else if (track->enc->codec_type == CODEC_TYPE_VIDEO) tag = MKTAG('m','p','4','v');
-    else if (track->enc->codec_type == CODEC_TYPE_AUDIO) tag = MKTAG('m','p','4','a');
+    else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) tag = MKTAG('m','p','4','v');
+    else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) tag = MKTAG('m','p','4','a');
 
     return tag;
 }
@@ -642,7 +642,7 @@ static int ipod_get_codec_tag(AVFormatContext *s, MOVTrack *track)
     int tag = track->enc->codec_tag;
 
     // keep original tag for subs, ipod supports both formats
-    if (!(track->enc->codec_type == CODEC_TYPE_SUBTITLE &&
+    if (!(track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE &&
         (tag == MKTAG('t','x','3','g') ||
          tag == MKTAG('t','e','x','t'))))
         tag = ff_codec_get_tag(codec_ipod_tags, track->enc->codec_id);
@@ -714,7 +714,7 @@ static int mov_get_codec_tag(AVFormatContext *s, MOVTrack *track)
             tag = mov_get_dv_codec_tag(s, track);
         else if (track->enc->codec_id == CODEC_ID_RAWVIDEO)
             tag = mov_get_rawvideo_codec_tag(s, track);
-        else if (track->enc->codec_type == CODEC_TYPE_VIDEO) {
+        else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
             tag = ff_codec_get_tag(codec_movvideo_tags, track->enc->codec_id);
             if (!tag) { // if no mac fcc found, try with Microsoft tags
                 tag = ff_codec_get_tag(ff_codec_bmp_tags, track->enc->codec_id);
@@ -722,7 +722,7 @@ static int mov_get_codec_tag(AVFormatContext *s, MOVTrack *track)
                     av_log(s, AV_LOG_INFO, "Warning, using MS style video codec tag, "
                            "the file may be unplayable!\n");
             }
-        } else if (track->enc->codec_type == CODEC_TYPE_AUDIO) {
+        } else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) {
             tag = ff_codec_get_tag(codec_movaudio_tags, track->enc->codec_id);
             if (!tag) { // if no mac fcc found, try with Microsoft tags
                 int ms_tag = ff_codec_get_tag(ff_codec_wav_tags, track->enc->codec_id);
@@ -732,7 +732,7 @@ static int mov_get_codec_tag(AVFormatContext *s, MOVTrack *track)
                            "the file may be unplayable!\n");
                 }
             }
-        } else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE)
+        } else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE)
             tag = ff_codec_get_tag(ff_codec_movsubtitle_tags, track->enc->codec_id);
     }
 
@@ -868,11 +868,11 @@ static int mov_write_stsd_tag(ByteIOContext *pb, MOVTrack *track)
     put_tag(pb, "stsd");
     put_be32(pb, 0); /* version & flags */
     put_be32(pb, 1); /* entry count */
-    if (track->enc->codec_type == CODEC_TYPE_VIDEO)
+    if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO)
         mov_write_video_tag(pb, track);
-    else if (track->enc->codec_type == CODEC_TYPE_AUDIO)
+    else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
         mov_write_audio_tag(pb, track);
-    else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE)
+    else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE)
         mov_write_subtitle_tag(pb, track);
     return updateSize(pb, pos);
 }
@@ -918,7 +918,7 @@ static int mov_write_stts_tag(ByteIOContext *pb, MOVTrack *track)
     uint32_t atom_size;
     int i;
 
-    if (track->enc->codec_type == CODEC_TYPE_AUDIO && !track->audio_vbr) {
+    if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO && !track->audio_vbr) {
         stts_entries = av_malloc(sizeof(*stts_entries)); /* one entry */
         stts_entries[0].count = track->sampleCount;
         stts_entries[0].duration = 1;
@@ -973,12 +973,12 @@ static int mov_write_stbl_tag(ByteIOContext *pb, MOVTrack *track)
     put_tag(pb, "stbl");
     mov_write_stsd_tag(pb, track);
     mov_write_stts_tag(pb, track);
-    if (track->enc->codec_type == CODEC_TYPE_VIDEO &&
+    if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO &&
         track->hasKeyframes && track->hasKeyframes < track->entry)
         mov_write_stss_tag(pb, track, MOV_SYNC_SAMPLE);
     if (track->mode == MODE_MOV && track->flags & MOV_TRACK_STPS)
         mov_write_stss_tag(pb, track, MOV_PARTIAL_SYNC_SAMPLE);
-    if (track->enc->codec_type == CODEC_TYPE_VIDEO &&
+    if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO &&
         track->flags & MOV_TRACK_CTTS)
         mov_write_ctts_tag(pb, track);
     mov_write_stsc_tag(pb, track);
@@ -1050,13 +1050,13 @@ static int mov_write_hdlr_tag(ByteIOContext *pb, MOVTrack *track)
         descr = "DataHandler";
     } else {
         hdlr = (track->mode == MODE_MOV) ? "mhlr" : "\0\0\0\0";
-        if (track->enc->codec_type == CODEC_TYPE_VIDEO) {
+        if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
             hdlr_type = "vide";
             descr = "VideoHandler";
-        } else if (track->enc->codec_type == CODEC_TYPE_AUDIO) {
+        } else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) {
             hdlr_type = "soun";
             descr = "SoundHandler";
-        } else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE) {
+        } else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE) {
             if (track->tag == MKTAG('t','x','3','g')) hdlr_type = "sbtl";
             else                                      hdlr_type = "text";
             descr = "SubtitleHandler";
@@ -1084,11 +1084,11 @@ static int mov_write_minf_tag(ByteIOContext *pb, MOVTrack *track)
     int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     put_tag(pb, "minf");
-    if(track->enc->codec_type == CODEC_TYPE_VIDEO)
+    if(track->enc->codec_type == AVMEDIA_TYPE_VIDEO)
         mov_write_vmhd_tag(pb);
-    else if (track->enc->codec_type == CODEC_TYPE_AUDIO)
+    else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
         mov_write_smhd_tag(pb);
-    else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE) {
+    else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE) {
         if (track->tag == MKTAG('t','e','x','t')) mov_write_gmhd_tag(pb);
         else                                      mov_write_nmhd_tag(pb);
     }
@@ -1165,7 +1165,7 @@ static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
     put_be32(pb, 0); /* reserved */
     put_be32(pb, 0x0); /* reserved (Layer & Alternate group) */
     /* Volume, only for audio */
-    if(track->enc->codec_type == CODEC_TYPE_AUDIO)
+    if(track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
         put_be16(pb, 0x0100);
     else
         put_be16(pb, 0);
@@ -1183,8 +1183,8 @@ static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
     put_be32(pb, 0x40000000); /* reserved */
 
     /* Track width and height, for visual only */
-    if(track->enc->codec_type == CODEC_TYPE_VIDEO ||
-       track->enc->codec_type == CODEC_TYPE_SUBTITLE) {
+    if(track->enc->codec_type == AVMEDIA_TYPE_VIDEO ||
+       track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE) {
         double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
         if(!sample_aspect_ratio || track->height != track->enc->height)
             sample_aspect_ratio = 1;
@@ -1671,7 +1671,7 @@ static int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)
 
     for (i = 0; i < s->nb_streams; i++) {
         AVStream *st = s->streams[i];
-        if (st->codec->codec_type == CODEC_TYPE_VIDEO)
+        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
             has_video = 1;
         if (st->codec->codec_id == CODEC_ID_H264)
             has_h264 = 1;
@@ -1829,7 +1829,7 @@ static int mov_write_header(AVFormatContext *s)
                    "codec not currently supported in container\n", i);
             goto error;
         }
-        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
+        if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
             if (track->tag == MKTAG('m','x','3','p') || track->tag == MKTAG('m','x','3','n') ||
                 track->tag == MKTAG('m','x','4','p') || track->tag == MKTAG('m','x','4','n') ||
                 track->tag == MKTAG('m','x','5','p') || track->tag == MKTAG('m','x','5','n')) {
@@ -1845,7 +1845,7 @@ static int mov_write_header(AVFormatContext *s)
                        "WARNING codec timebase is very high. If duration is too long,\n"
                        "file may not be playable by quicktime. Specify a shorter timebase\n"
                        "or choose different container.\n");
-        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO){
+        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO){
             track->timescale = st->codec->sample_rate;
             if(!st->codec->frame_size && !av_get_bits_per_sample(st->codec->codec_id)) {
                 av_log(s, AV_LOG_ERROR, "track %d: codec frame size is not set\n", i);
@@ -1868,7 +1868,7 @@ static int mov_write_header(AVFormatContext *s)
                     goto error;
                 }
             }
-        }else if(st->codec->codec_type == CODEC_TYPE_SUBTITLE){
+        }else if(st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE){
             track->timescale = st->codec->time_base.den;
         }
         if (!track->height)
diff --git a/libavformat/mp3.c b/libavformat/mp3.c
index a111b19272b8e9840b18761d8348d8e3de87a44d..3ee3cb2a8a3d4a4f83705eda9a4af52fdca78cd4 100644
--- a/libavformat/mp3.c
+++ b/libavformat/mp3.c
@@ -140,7 +140,7 @@ static int mp3_read_header(AVFormatContext *s,
     if (!st)
         return AVERROR(ENOMEM);
 
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_MP3;
     st->need_parsing = AVSTREAM_PARSE_FULL;
     st->start_time = 0;
diff --git a/libavformat/mpc.c b/libavformat/mpc.c
index a16478300219fc6b90cc879cc74e9cfdd80951e2..4dda65dbca4cc5a626d5ddd8c5f7ad10cecc630c 100644
--- a/libavformat/mpc.c
+++ b/libavformat/mpc.c
@@ -104,7 +104,7 @@ static int mpc_read_header(AVFormatContext *s, AVFormatParameters *ap)
     st = av_new_stream(s, 0);
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_MUSEPACK7;
     st->codec->channels = 2;
     st->codec->bits_per_coded_sample = 16;
diff --git a/libavformat/mpc8.c b/libavformat/mpc8.c
index 85cbb41f83ad3aa431f4ac4a93418a6d4def4a2d..92e996c29c23736c854e7e9c127f89f150457b57 100644
--- a/libavformat/mpc8.c
+++ b/libavformat/mpc8.c
@@ -224,7 +224,7 @@ static int mpc8_read_header(AVFormatContext *s, AVFormatParameters *ap)
     st = av_new_stream(s, 0);
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_MUSEPACK8;
     st->codec->bits_per_coded_sample = 16;
 
diff --git a/libavformat/mpeg.c b/libavformat/mpeg.c
index 2b1cc34349bebc846b69dfd5f004fcefadf1f537..4224a04b371d4ce536c3d48978b617e9dada3eca 100644
--- a/libavformat/mpeg.c
+++ b/libavformat/mpeg.c
@@ -417,7 +417,7 @@ static int mpegps_read_packet(AVFormatContext *s,
     AVStream *st;
     int len, startcode, i, es_type;
     enum CodecID codec_id = CODEC_ID_NONE;
-    enum CodecType type;
+    enum AVMediaType type;
     int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
     uint8_t av_uninit(dvdaudio_substream_type);
 
@@ -443,26 +443,26 @@ static int mpegps_read_packet(AVFormatContext *s,
     if(es_type > 0 && es_type != STREAM_TYPE_PRIVATE_DATA){
         if(es_type == STREAM_TYPE_VIDEO_MPEG1){
             codec_id = CODEC_ID_MPEG2VIDEO;
-            type = CODEC_TYPE_VIDEO;
+            type = AVMEDIA_TYPE_VIDEO;
         } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
             codec_id = CODEC_ID_MPEG2VIDEO;
-            type = CODEC_TYPE_VIDEO;
+            type = AVMEDIA_TYPE_VIDEO;
         } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
                   es_type == STREAM_TYPE_AUDIO_MPEG2){
             codec_id = CODEC_ID_MP3;
-            type = CODEC_TYPE_AUDIO;
+            type = AVMEDIA_TYPE_AUDIO;
         } else if(es_type == STREAM_TYPE_AUDIO_AAC){
             codec_id = CODEC_ID_AAC;
-            type = CODEC_TYPE_AUDIO;
+            type = AVMEDIA_TYPE_AUDIO;
         } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
             codec_id = CODEC_ID_MPEG4;
-            type = CODEC_TYPE_VIDEO;
+            type = AVMEDIA_TYPE_VIDEO;
         } else if(es_type == STREAM_TYPE_VIDEO_H264){
             codec_id = CODEC_ID_H264;
-            type = CODEC_TYPE_VIDEO;
+            type = AVMEDIA_TYPE_VIDEO;
         } else if(es_type == STREAM_TYPE_AUDIO_AC3){
             codec_id = CODEC_ID_AC3;
-            type = CODEC_TYPE_AUDIO;
+            type = AVMEDIA_TYPE_AUDIO;
         } else {
             goto skip;
         }
@@ -475,38 +475,38 @@ static int mpegps_read_packet(AVFormatContext *s,
             codec_id = CODEC_ID_CAVS;
         else
             codec_id = CODEC_ID_PROBE;
-        type = CODEC_TYPE_VIDEO;
+        type = AVMEDIA_TYPE_VIDEO;
     } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
-        type = CODEC_TYPE_AUDIO;
+        type = AVMEDIA_TYPE_AUDIO;
         codec_id = m->sofdec > 0 ? CODEC_ID_ADPCM_ADX : CODEC_ID_MP2;
     } else if (startcode >= 0x80 && startcode <= 0x87) {
-        type = CODEC_TYPE_AUDIO;
+        type = AVMEDIA_TYPE_AUDIO;
         codec_id = CODEC_ID_AC3;
     } else if (  ( startcode >= 0x88 && startcode <= 0x8f)
                ||( startcode >= 0x98 && startcode <= 0x9f)) {
         /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
-        type = CODEC_TYPE_AUDIO;
+        type = AVMEDIA_TYPE_AUDIO;
         codec_id = CODEC_ID_DTS;
     } else if (startcode >= 0xa0 && startcode <= 0xaf) {
-        type = CODEC_TYPE_AUDIO;
+        type = AVMEDIA_TYPE_AUDIO;
         /* 16 bit form will be handled as CODEC_ID_PCM_S16BE */
         codec_id = CODEC_ID_PCM_DVD;
     } else if (startcode >= 0xb0 && startcode <= 0xbf) {
-        type = CODEC_TYPE_AUDIO;
+        type = AVMEDIA_TYPE_AUDIO;
         codec_id = CODEC_ID_TRUEHD;
     } else if (startcode >= 0xc0 && startcode <= 0xcf) {
         /* Used for both AC-3 and E-AC-3 in EVOB files */
-        type = CODEC_TYPE_AUDIO;
+        type = AVMEDIA_TYPE_AUDIO;
         codec_id = CODEC_ID_AC3;
     } else if (startcode >= 0x20 && startcode <= 0x3f) {
-        type = CODEC_TYPE_SUBTITLE;
+        type = AVMEDIA_TYPE_SUBTITLE;
         codec_id = CODEC_ID_DVD_SUBTITLE;
     } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
-        type = CODEC_TYPE_VIDEO;
+        type = AVMEDIA_TYPE_VIDEO;
         codec_id = CODEC_ID_VC1;
     } else if (startcode == 0x1bd) {
         // check dvd audio substream type
-        type = CODEC_TYPE_AUDIO;
+        type = AVMEDIA_TYPE_AUDIO;
         switch(dvdaudio_substream_type & 0xe0) {
         case 0xa0:  codec_id = CODEC_ID_PCM_DVD;
                     break;
diff --git a/libavformat/mpegenc.c b/libavformat/mpegenc.c
index a471b38bb9e00d18a3dcbad1c31abbc4263a7a24..32a3858f565a796250d504e47a456ff592ff619b 100644
--- a/libavformat/mpegenc.c
+++ b/libavformat/mpegenc.c
@@ -335,7 +335,7 @@ static int mpeg_mux_init(AVFormatContext *ctx)
         av_set_pts_info(st, 64, 1, 90000);
 
         switch(st->codec->codec_type) {
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             if        (st->codec->codec_id == CODEC_ID_AC3) {
                 stream->id = ac3_id++;
             } else if (st->codec->codec_id == CODEC_ID_DTS) {
@@ -363,7 +363,7 @@ static int mpeg_mux_init(AVFormatContext *ctx)
             stream->max_buffer_size = 4 * 1024;
             s->audio_bound++;
             break;
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             stream->id = mpv_id++;
             if (st->codec->rc_buffer_size)
                 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
@@ -379,7 +379,7 @@ static int mpeg_mux_init(AVFormatContext *ctx)
 #endif
             s->video_bound++;
             break;
-        case CODEC_TYPE_SUBTITLE:
+        case AVMEDIA_TYPE_SUBTITLE:
             stream->id = mps_id++;
             stream->max_buffer_size = 16 * 1024;
             break;
@@ -1046,7 +1046,7 @@ retry:
         /* for subtitle, a single PES packet must be generated,
            so we flush after every single subtitle packet */
         if(s->packet_size > avail_data && !flush
-           && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
+           && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
             return 0;
         if(avail_data==0)
             continue;
@@ -1156,7 +1156,7 @@ static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
     int64_t pts, dts;
     PacketDesc *pkt_desc;
     const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
-    const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
+    const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
 
     pts= pkt->pts;
     dts= pkt->dts;
diff --git a/libavformat/mpegts.c b/libavformat/mpegts.c
index 0a49ed9d68cdef45e2c89b66259c4983daa3a583..ac1e911e357dc1339bfa48a15bfb55d12a7c0be3 100644
--- a/libavformat/mpegts.c
+++ b/libavformat/mpegts.c
@@ -486,54 +486,54 @@ static int parse_section_header(SectionHeader *h,
 
 typedef struct {
     uint32_t stream_type;
-    enum CodecType codec_type;
+    enum AVMediaType codec_type;
     enum CodecID codec_id;
 } StreamType;
 
 static const StreamType ISO_types[] = {
-    { 0x01, CODEC_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
-    { 0x02, CODEC_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
-    { 0x03, CODEC_TYPE_AUDIO,        CODEC_ID_MP3 },
-    { 0x04, CODEC_TYPE_AUDIO,        CODEC_ID_MP3 },
-    { 0x0f, CODEC_TYPE_AUDIO,        CODEC_ID_AAC },
-    { 0x10, CODEC_TYPE_VIDEO,      CODEC_ID_MPEG4 },
-    { 0x11, CODEC_TYPE_AUDIO,        CODEC_ID_AAC }, /* LATM syntax */
-    { 0x1b, CODEC_TYPE_VIDEO,       CODEC_ID_H264 },
-    { 0xd1, CODEC_TYPE_VIDEO,      CODEC_ID_DIRAC },
-    { 0xea, CODEC_TYPE_VIDEO,        CODEC_ID_VC1 },
+    { 0x01, AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
+    { 0x02, AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
+    { 0x03, AVMEDIA_TYPE_AUDIO,        CODEC_ID_MP3 },
+    { 0x04, AVMEDIA_TYPE_AUDIO,        CODEC_ID_MP3 },
+    { 0x0f, AVMEDIA_TYPE_AUDIO,        CODEC_ID_AAC },
+    { 0x10, AVMEDIA_TYPE_VIDEO,      CODEC_ID_MPEG4 },
+    { 0x11, AVMEDIA_TYPE_AUDIO,        CODEC_ID_AAC }, /* LATM syntax */
+    { 0x1b, AVMEDIA_TYPE_VIDEO,       CODEC_ID_H264 },
+    { 0xd1, AVMEDIA_TYPE_VIDEO,      CODEC_ID_DIRAC },
+    { 0xea, AVMEDIA_TYPE_VIDEO,        CODEC_ID_VC1 },
     { 0 },
 };
 
 static const StreamType HDMV_types[] = {
-    { 0x80, CODEC_TYPE_AUDIO, CODEC_ID_PCM_BLURAY },
-    { 0x81, CODEC_TYPE_AUDIO, CODEC_ID_AC3 },
-    { 0x82, CODEC_TYPE_AUDIO, CODEC_ID_DTS },
-    { 0x83, CODEC_TYPE_AUDIO, CODEC_ID_TRUEHD },
-    { 0x84, CODEC_TYPE_AUDIO, CODEC_ID_EAC3 },
-    { 0x90, CODEC_TYPE_SUBTITLE, CODEC_ID_HDMV_PGS_SUBTITLE },
+    { 0x80, AVMEDIA_TYPE_AUDIO, CODEC_ID_PCM_BLURAY },
+    { 0x81, AVMEDIA_TYPE_AUDIO, CODEC_ID_AC3 },
+    { 0x82, AVMEDIA_TYPE_AUDIO, CODEC_ID_DTS },
+    { 0x83, AVMEDIA_TYPE_AUDIO, CODEC_ID_TRUEHD },
+    { 0x84, AVMEDIA_TYPE_AUDIO, CODEC_ID_EAC3 },
+    { 0x90, AVMEDIA_TYPE_SUBTITLE, CODEC_ID_HDMV_PGS_SUBTITLE },
     { 0 },
 };
 
 /* ATSC ? */
 static const StreamType MISC_types[] = {
-    { 0x81, CODEC_TYPE_AUDIO,   CODEC_ID_AC3 },
-    { 0x8a, CODEC_TYPE_AUDIO,   CODEC_ID_DTS },
+    { 0x81, AVMEDIA_TYPE_AUDIO,   CODEC_ID_AC3 },
+    { 0x8a, AVMEDIA_TYPE_AUDIO,   CODEC_ID_DTS },
     { 0 },
 };
 
 static const StreamType REGD_types[] = {
-    { MKTAG('d','r','a','c'), CODEC_TYPE_VIDEO, CODEC_ID_DIRAC },
-    { MKTAG('A','C','-','3'), CODEC_TYPE_AUDIO,   CODEC_ID_AC3 },
+    { MKTAG('d','r','a','c'), AVMEDIA_TYPE_VIDEO, CODEC_ID_DIRAC },
+    { MKTAG('A','C','-','3'), AVMEDIA_TYPE_AUDIO,   CODEC_ID_AC3 },
     { 0 },
 };
 
 /* descriptor present */
 static const StreamType DESC_types[] = {
-    { 0x6a, CODEC_TYPE_AUDIO,             CODEC_ID_AC3 }, /* AC-3 descriptor */
-    { 0x7a, CODEC_TYPE_AUDIO,            CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
-    { 0x7b, CODEC_TYPE_AUDIO,             CODEC_ID_DTS },
-    { 0x56, CODEC_TYPE_SUBTITLE, CODEC_ID_DVB_TELETEXT },
-    { 0x59, CODEC_TYPE_SUBTITLE, CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
+    { 0x6a, AVMEDIA_TYPE_AUDIO,             CODEC_ID_AC3 }, /* AC-3 descriptor */
+    { 0x7a, AVMEDIA_TYPE_AUDIO,            CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
+    { 0x7b, AVMEDIA_TYPE_AUDIO,             CODEC_ID_DTS },
+    { 0x56, AVMEDIA_TYPE_SUBTITLE, CODEC_ID_DVB_TELETEXT },
+    { 0x59, AVMEDIA_TYPE_SUBTITLE, CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
     { 0 },
 };
 
@@ -554,7 +554,7 @@ static int mpegts_set_stream_info(AVStream *st, PESContext *pes,
 {
     av_set_pts_info(st, 33, 1, 90000);
     st->priv_data = pes;
-    st->codec->codec_type = CODEC_TYPE_DATA;
+    st->codec->codec_type = AVMEDIA_TYPE_DATA;
     st->codec->codec_id   = CODEC_ID_NONE;
     st->need_parsing = AVSTREAM_PARSE_FULL;
     pes->st = st;
@@ -588,7 +588,7 @@ static int mpegts_set_stream_info(AVStream *st, PESContext *pes,
 
             av_set_pts_info(sub_st, 33, 1, 90000);
             sub_st->priv_data = sub_pes;
-            sub_st->codec->codec_type = CODEC_TYPE_AUDIO;
+            sub_st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             sub_st->codec->codec_id   = CODEC_ID_AC3;
             sub_st->need_parsing = AVSTREAM_PARSE_FULL;
             sub_pes->sub_st = pes->sub_st = sub_st;
@@ -1394,7 +1394,7 @@ static int mpegts_read_header(AVFormatContext *s,
         if (!st)
             goto fail;
         av_set_pts_info(st, 60, 1, 27000000);
-        st->codec->codec_type = CODEC_TYPE_DATA;
+        st->codec->codec_type = AVMEDIA_TYPE_DATA;
         st->codec->codec_id = CODEC_ID_MPEG2TS;
 
         /* we iterate until we find two PCRs to estimate the bitrate */
diff --git a/libavformat/mpegtsenc.c b/libavformat/mpegtsenc.c
index 487a0c2fdfeb5be933d8fdb921a71a7e6c17dbbf..adb94af956dc069cb9441dd1d79e3ced6dace89a 100644
--- a/libavformat/mpegtsenc.c
+++ b/libavformat/mpegtsenc.c
@@ -255,7 +255,7 @@ static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
 
         /* write optional descriptors here */
         switch(st->codec->codec_type) {
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             if (lang && strlen(lang->value) == 3) {
                 *q++ = 0x0a; /* ISO 639 language descriptor */
                 *q++ = 4;
@@ -265,7 +265,7 @@ static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
                 *q++ = 0; /* undefined type */
             }
             break;
-        case CODEC_TYPE_SUBTITLE:
+        case AVMEDIA_TYPE_SUBTITLE:
             {
                 const char *language;
                 language = lang && strlen(lang->value)==3 ? lang->value : "eng";
@@ -279,7 +279,7 @@ static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
                 put16(&q, 1); /* ancillary page id */
             }
             break;
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             if (stream_type == STREAM_TYPE_VIDEO_DIRAC) {
                 *q++ = 0x05; /*MPEG-2 registration descriptor*/
                 *q++ = 4;
@@ -424,7 +424,7 @@ static int mpegts_write_header(AVFormatContext *s)
         ts_st->first_pts_check = 1;
         ts_st->cc = 15;
         /* update PCR pid by using the first video stream */
-        if (st->codec->codec_type == CODEC_TYPE_VIDEO &&
+        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
             service->pcr_pid == 0x1fff) {
             service->pcr_pid = ts_st->pid;
             pcr_st = st;
@@ -462,7 +462,7 @@ static int mpegts_write_header(AVFormatContext *s)
         /* Arbitrary values, PAT/PMT could be written on key frames */
         ts->sdt_packet_period = 200;
         ts->pat_packet_period = 40;
-        if (pcr_st->codec->codec_type == CODEC_TYPE_AUDIO) {
+        if (pcr_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
             if (!pcr_st->codec->frame_size) {
                 av_log(s, AV_LOG_WARNING, "frame size not set\n");
                 service->pcr_packet_period =
@@ -661,18 +661,18 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
             *q++ = 0x00;
             *q++ = 0x01;
             private_code = 0;
-            if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+            if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
                 if (st->codec->codec_id == CODEC_ID_DIRAC) {
                     *q++ = 0xfd;
                 } else
                     *q++ = 0xe0;
-            } else if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
+            } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
                        (st->codec->codec_id == CODEC_ID_MP2 ||
                         st->codec->codec_id == CODEC_ID_MP3)) {
                 *q++ = 0xc0;
             } else {
                 *q++ = 0xbd;
-                if (st->codec->codec_type == CODEC_TYPE_SUBTITLE) {
+                if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
                     private_code = 0x20;
                 }
             }
@@ -686,7 +686,7 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
                 header_len += 5;
                 flags |= 0x40;
             }
-            if (st->codec->codec_type == CODEC_TYPE_VIDEO &&
+            if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
                 st->codec->codec_id == CODEC_ID_DIRAC) {
                 /* set PES_extension_flag */
                 pes_extension = 1;
@@ -708,7 +708,7 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
             *q++ = len;
             val = 0x80;
             /* data alignment indicator is required for subtitle data */
-            if (st->codec->codec_type == CODEC_TYPE_SUBTITLE)
+            if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
                 val |= 0x04;
             *q++ = val;
             *q++ = flags;
@@ -848,7 +848,7 @@ static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
         }
     }
 
-    if (st->codec->codec_type != CODEC_TYPE_AUDIO) {
+    if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
         // for video and subtitle, write a single pes packet
         mpegts_write_pes(s, st, buf, size, pts, dts);
         av_free(data);
diff --git a/libavformat/msnwc_tcp.c b/libavformat/msnwc_tcp.c
index 34ab9d94bbe6f2f1410a4ae8ddeac54a4880ffa4..49b8297a4f8f96a3607f50497cac9c3ff701909b 100644
--- a/libavformat/msnwc_tcp.c
+++ b/libavformat/msnwc_tcp.c
@@ -80,7 +80,7 @@ static int msnwc_tcp_read_header(AVFormatContext *ctx, AVFormatParameters *ap)
         return AVERROR_NOMEM;
 
     codec = st->codec;
-    codec->codec_type = CODEC_TYPE_VIDEO;
+    codec->codec_type = AVMEDIA_TYPE_VIDEO;
     codec->codec_id = CODEC_ID_MIMIC;
     codec->codec_tag = MKTAG('M', 'L', '2', '0');
 
diff --git a/libavformat/mtv.c b/libavformat/mtv.c
index e7e3a1c4bc087c1324998929b53cf0bbac022035..fd26c14869ca39de8dae265b75ffa5b3e2e5a41d 100644
--- a/libavformat/mtv.c
+++ b/libavformat/mtv.c
@@ -123,7 +123,7 @@ static int mtv_read_header(AVFormatContext *s, AVFormatParameters *ap)
         return AVERROR(ENOMEM);
 
     av_set_pts_info(st, 64, 1, mtv->video_fps);
-    st->codec->codec_type      = CODEC_TYPE_VIDEO;
+    st->codec->codec_type      = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id        = CODEC_ID_RAWVIDEO;
     st->codec->codec_tag       = MKTAG('R', 'G', 'B', mtv->img_bpp);
     st->codec->width           = mtv->img_width;
@@ -140,7 +140,7 @@ static int mtv_read_header(AVFormatContext *s, AVFormatParameters *ap)
         return AVERROR(ENOMEM);
 
     av_set_pts_info(st, 64, 1, AUDIO_SAMPLING_RATE);
-    st->codec->codec_type      = CODEC_TYPE_AUDIO;
+    st->codec->codec_type      = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id        = CODEC_ID_MP3;
     st->codec->bit_rate        = mtv->audio_br;
     st->need_parsing           = AVSTREAM_PARSE_FULL;
diff --git a/libavformat/mvi.c b/libavformat/mvi.c
index 89c47da4732b71094dd5d1f6efb57110996a9400..506976df432e5718114e1e7095528c9594d16879 100644
--- a/libavformat/mvi.c
+++ b/libavformat/mvi.c
@@ -77,14 +77,14 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap)
     }
 
     av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
-    ast->codec->codec_type      = CODEC_TYPE_AUDIO;
+    ast->codec->codec_type      = AVMEDIA_TYPE_AUDIO;
     ast->codec->codec_id        = CODEC_ID_PCM_U8;
     ast->codec->channels        = 1;
     ast->codec->bits_per_coded_sample = 8;
     ast->codec->bit_rate        = ast->codec->sample_rate * 8;
 
     av_set_pts_info(vst, 64, msecs_per_frame, 1000000);
-    vst->codec->codec_type = CODEC_TYPE_VIDEO;
+    vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     vst->codec->codec_id   = CODEC_ID_MOTIONPIXELS;
 
     mvi->get_int = (vst->codec->width * vst->codec->height < (1 << 16)) ? get_le16 : get_le24;
diff --git a/libavformat/mxf.c b/libavformat/mxf.c
index 05cb173ac39f7acb41b2aef54fe47711af353a23..452ee6ddfed29f6f58b66328b078b36722aa62a2 100644
--- a/libavformat/mxf.c
+++ b/libavformat/mxf.c
@@ -25,9 +25,9 @@
  * SMPTE RP224 http://www.smpte-ra.org/mdd/index.html
  */
 const MXFCodecUL ff_mxf_data_definition_uls[] = {
-    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x01,0x03,0x02,0x02,0x01,0x00,0x00,0x00 }, 13, CODEC_TYPE_VIDEO },
-    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x01,0x03,0x02,0x02,0x02,0x00,0x00,0x00 }, 13, CODEC_TYPE_AUDIO },
-    { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,  CODEC_TYPE_DATA },
+    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x01,0x03,0x02,0x02,0x01,0x00,0x00,0x00 }, 13, AVMEDIA_TYPE_VIDEO },
+    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x01,0x03,0x02,0x02,0x02,0x00,0x00,0x00 }, 13, AVMEDIA_TYPE_AUDIO },
+    { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,  AVMEDIA_TYPE_DATA },
 };
 
 const MXFCodecUL ff_mxf_codec_uls[] = {
diff --git a/libavformat/mxfdec.c b/libavformat/mxfdec.c
index 2f6d2eaa2f548129f72f8fc536c446def0d0a958..168fd8d69ff3b0c9e4a06c97b4e314f84a49c409 100644
--- a/libavformat/mxfdec.c
+++ b/libavformat/mxfdec.c
@@ -795,7 +795,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf)
             st->codec->extradata = descriptor->extradata;
             st->codec->extradata_size = descriptor->extradata_size;
         }
-        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
             container_ul = mxf_get_codec_ul(mxf_essence_container_uls, essence_container_ul);
             if (st->codec->codec_id == CODEC_ID_NONE)
                 st->codec->codec_id = container_ul->id;
@@ -803,7 +803,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf)
             st->codec->height = descriptor->height;
             st->codec->bits_per_coded_sample = descriptor->bits_per_sample; /* Uncompressed */
             st->need_parsing = AVSTREAM_PARSE_HEADERS;
-        } else if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+        } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
             container_ul = mxf_get_codec_ul(mxf_essence_container_uls, essence_container_ul);
             if (st->codec->codec_id == CODEC_ID_NONE)
                 st->codec->codec_id = container_ul->id;
@@ -825,7 +825,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf)
                 st->need_parsing = AVSTREAM_PARSE_FULL;
             }
         }
-        if (st->codec->codec_type != CODEC_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
+        if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
             av_log(mxf->fc, AV_LOG_WARNING, "only frame wrapped mappings are correctly supported\n");
             st->need_parsing = AVSTREAM_PARSE_FULL;
         }
diff --git a/libavformat/mxfenc.c b/libavformat/mxfenc.c
index 766327ded34eb13c3934acf4e57bfebcc09e3de0..ab381189c95ce8287c6911bcecd2e9ab16c47aa7 100644
--- a/libavformat/mxfenc.c
+++ b/libavformat/mxfenc.c
@@ -1415,7 +1415,7 @@ static int mxf_write_header(AVFormatContext *s)
             return AVERROR(ENOMEM);
         st->priv_data = sc;
 
-        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
             if (i != 0) {
                 av_log(s, AV_LOG_ERROR, "video stream must be first track\n");
                 return -1;
@@ -1455,7 +1455,7 @@ static int mxf_write_header(AVFormatContext *s)
                 mxf->edit_unit_byte_count += 16 + 4 + 4 + samples_per_frame[0]*8*4;
                 mxf->edit_unit_byte_count += klv_fill_size(mxf->edit_unit_byte_count);
             }
-        } else if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+        } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
             if (st->codec->sample_rate != 48000) {
                 av_log(s, AV_LOG_ERROR, "only 48khz is implemented\n");
                 return -1;
@@ -1717,7 +1717,7 @@ static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
     mxf_write_klv_fill(s);
     put_buffer(pb, sc->track_essence_element_key, 16); // write key
     if (s->oformat == &mxf_d10_muxer) {
-        if (st->codec->codec_type == CODEC_TYPE_VIDEO)
+        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
             mxf_write_d10_video_packet(s, st, pkt);
         else
             mxf_write_d10_audio_packet(s, st, pkt);
diff --git a/libavformat/ncdec.c b/libavformat/ncdec.c
index 8e51f840d2b83b6a5a031f785a6d824b71862971..6d99a049e61d0676df91a9ff361608b73589b92d 100644
--- a/libavformat/ncdec.c
+++ b/libavformat/ncdec.c
@@ -50,7 +50,7 @@ static int nc_read_header(AVFormatContext *s, AVFormatParameters *ap)
     if (!st)
         return AVERROR(ENOMEM);
 
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id   = CODEC_ID_MPEG4;
     st->need_parsing      = AVSTREAM_PARSE_FULL;
 
diff --git a/libavformat/nsvdec.c b/libavformat/nsvdec.c
index 6149d83f3af2708f1c289095db0d19644d8ef99d..1c58cd6c3b6691a3fa54cf7befcea3e2026f8cd8 100644
--- a/libavformat/nsvdec.c
+++ b/libavformat/nsvdec.c
@@ -456,7 +456,7 @@ static int nsv_parse_NSVs_header(AVFormatContext *s, AVFormatParameters *ap)
             if (!nst)
                 goto fail;
             st->priv_data = nst;
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             st->codec->codec_tag = vtag;
             st->codec->codec_id = ff_codec_get_id(nsv_codec_video_tags, vtag);
             st->codec->width = vwidth;
@@ -487,7 +487,7 @@ static int nsv_parse_NSVs_header(AVFormatContext *s, AVFormatParameters *ap)
             if (!nst)
                 goto fail;
             st->priv_data = nst;
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             st->codec->codec_tag = atag;
             st->codec->codec_id = ff_codec_get_id(nsv_codec_audio_tags, atag);
 
diff --git a/libavformat/nutdec.c b/libavformat/nutdec.c
index 3dbca9eeb37dc98451c67dc06c9166f624ed351c..7b934c50c66cd08988b0bf1bd67dc051d67caec1 100644
--- a/libavformat/nutdec.c
+++ b/libavformat/nutdec.c
@@ -315,19 +315,19 @@ static int decode_stream_header(NUTContext *nut){
     switch(class)
     {
         case 0:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tmp);
             break;
         case 1:
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             st->codec->codec_id = ff_codec_get_id(ff_codec_wav_tags, tmp);
             break;
         case 2:
-            st->codec->codec_type = CODEC_TYPE_SUBTITLE;
+            st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
             st->codec->codec_id = ff_codec_get_id(ff_nut_subtitle_tags, tmp);
             break;
         case 3:
-            st->codec->codec_type = CODEC_TYPE_DATA;
+            st->codec->codec_type = AVMEDIA_TYPE_DATA;
             break;
         default:
             av_log(s, AV_LOG_ERROR, "unknown stream class (%d)\n", class);
@@ -349,7 +349,7 @@ static int decode_stream_header(NUTContext *nut){
         get_buffer(bc, st->codec->extradata, st->codec->extradata_size);
     }
 
-    if (st->codec->codec_type == CODEC_TYPE_VIDEO){
+    if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
         GET_V(st->codec->width , tmp > 0)
         GET_V(st->codec->height, tmp > 0)
         st->sample_aspect_ratio.num= ff_get_v(bc);
@@ -359,7 +359,7 @@ static int decode_stream_header(NUTContext *nut){
             return -1;
         }
         ff_get_v(bc); /* csp type */
-    }else if (st->codec->codec_type == CODEC_TYPE_AUDIO){
+    }else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO){
         GET_V(st->codec->sample_rate , tmp > 0)
         ff_get_v(bc); // samplerate_den
         GET_V(st->codec->channels, tmp > 0)
diff --git a/libavformat/nutenc.c b/libavformat/nutenc.c
index 84ea29024eb1b02b99cd84ae56cdb22578983481..28eac127ecb2d27c2db16bac0bf1d8dbb4bdb46c 100644
--- a/libavformat/nutenc.c
+++ b/libavformat/nutenc.c
@@ -152,7 +152,7 @@ static void build_frame_code(AVFormatContext *s){
         int start2= start + (end-start)*stream_id / s->nb_streams;
         int end2  = start + (end-start)*(stream_id+1) / s->nb_streams;
         AVCodecContext *codec = s->streams[stream_id]->codec;
-        int is_audio= codec->codec_type == CODEC_TYPE_AUDIO;
+        int is_audio= codec->codec_type == AVMEDIA_TYPE_AUDIO;
         int intra_only= /*codec->intra_only || */is_audio;
         int pred_count;
 
@@ -394,9 +394,9 @@ static int write_streamheader(NUTContext *nut, ByteIOContext *bc, AVStream *st,
     AVCodecContext *codec = st->codec;
     put_v(bc, i);
     switch(codec->codec_type){
-    case CODEC_TYPE_VIDEO: put_v(bc, 0); break;
-    case CODEC_TYPE_AUDIO: put_v(bc, 1); break;
-    case CODEC_TYPE_SUBTITLE: put_v(bc, 2); break;
+    case AVMEDIA_TYPE_VIDEO: put_v(bc, 0); break;
+    case AVMEDIA_TYPE_AUDIO: put_v(bc, 1); break;
+    case AVMEDIA_TYPE_SUBTITLE: put_v(bc, 2); break;
     default              : put_v(bc, 3); break;
     }
     put_v(bc, 4);
@@ -415,12 +415,12 @@ static int write_streamheader(NUTContext *nut, ByteIOContext *bc, AVStream *st,
     put_buffer(bc, codec->extradata, codec->extradata_size);
 
     switch(codec->codec_type){
-    case CODEC_TYPE_AUDIO:
+    case AVMEDIA_TYPE_AUDIO:
         put_v(bc, codec->sample_rate);
         put_v(bc, 1);
         put_v(bc, codec->channels);
         break;
-    case CODEC_TYPE_VIDEO:
+    case AVMEDIA_TYPE_VIDEO:
         put_v(bc, codec->width);
         put_v(bc, codec->height);
 
diff --git a/libavformat/nuv.c b/libavformat/nuv.c
index 4abe54fd6e48933a701a63eea018ec4791054609..940bb03df2a68f1af52d6c764a0c0ccd6991c356 100644
--- a/libavformat/nuv.c
+++ b/libavformat/nuv.c
@@ -155,7 +155,7 @@ static int nuv_header(AVFormatContext *s, AVFormatParameters *ap) {
         vst = av_new_stream(s, ctx->v_id);
         if (!vst)
             return AVERROR(ENOMEM);
-        vst->codec->codec_type = CODEC_TYPE_VIDEO;
+        vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         vst->codec->codec_id = CODEC_ID_NUV;
         vst->codec->width = width;
         vst->codec->height = height;
@@ -171,7 +171,7 @@ static int nuv_header(AVFormatContext *s, AVFormatParameters *ap) {
         ast = av_new_stream(s, ctx->a_id);
         if (!ast)
             return AVERROR(ENOMEM);
-        ast->codec->codec_type = CODEC_TYPE_AUDIO;
+        ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         ast->codec->codec_id = CODEC_ID_PCM_S16LE;
         ast->codec->channels = 2;
         ast->codec->sample_rate = 44100;
diff --git a/libavformat/oggdec.c b/libavformat/oggdec.c
index 435044fcb3b124b123dcaef423cad9aaf5c2cb30..ed90832c149f031ac9298370b5f4f133877c0637 100644
--- a/libavformat/oggdec.c
+++ b/libavformat/oggdec.c
@@ -612,7 +612,7 @@ static int ogg_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp
 
     // Try seeking to a keyframe first. If this fails (very possible),
     // av_seek_frame will fall back to ignoring keyframes
-    if (s->streams[stream_index]->codec->codec_type == CODEC_TYPE_VIDEO
+    if (s->streams[stream_index]->codec->codec_type == AVMEDIA_TYPE_VIDEO
         && !(flags & AVSEEK_FLAG_ANY))
         os->keyframe_seek = 1;
 
diff --git a/libavformat/oggenc.c b/libavformat/oggenc.c
index 35080f3a4e98b1e6f29d42dc6a333b54c9736345..6944b3c0699d2e7d8ab2b57346e6ec5884749398 100644
--- a/libavformat/oggenc.c
+++ b/libavformat/oggenc.c
@@ -178,9 +178,9 @@ static int ogg_write_header(AVFormatContext *s)
     int i, j;
     for (i = 0; i < s->nb_streams; i++) {
         AVStream *st = s->streams[i];
-        if (st->codec->codec_type == CODEC_TYPE_AUDIO)
+        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
             av_set_pts_info(st, 64, 1, st->codec->sample_rate);
-        else if (st->codec->codec_type == CODEC_TYPE_VIDEO)
+        else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
             av_set_pts_info(st, 64, st->codec->time_base.num, st->codec->time_base.den);
         if (st->codec->codec_id != CODEC_ID_VORBIS &&
             st->codec->codec_id != CODEC_ID_THEORA &&
diff --git a/libavformat/oggparsedirac.c b/libavformat/oggparsedirac.c
index 59a6deec4964a42c3d6037e67416b8498d18e7a0..132087790026f518d230d3c03b7ee7fc56671f99 100644
--- a/libavformat/oggparsedirac.c
+++ b/libavformat/oggparsedirac.c
@@ -39,7 +39,7 @@ static int dirac_header(AVFormatContext *s, int idx)
     if (ff_dirac_parse_sequence_header(st->codec, &gb, &source) < 0)
         return -1;
 
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_DIRAC;
     // dirac in ogg always stores timestamps as though the video were interlaced
     st->time_base = (AVRational){st->codec->time_base.num, 2*st->codec->time_base.den};
@@ -77,7 +77,7 @@ static int old_dirac_header(AVFormatContext *s, int idx)
     if (buf[0] != 'K')
         return 0;
 
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_DIRAC;
     st->time_base.den = AV_RB32(buf+8);
     st->time_base.num = AV_RB32(buf+12);
diff --git a/libavformat/oggparseflac.c b/libavformat/oggparseflac.c
index 9a9ca7ead779f877c4b1481c73fa16f9c93904ae..e5034af3a033c0ed51aa26e5c160250b6b4431df 100644
--- a/libavformat/oggparseflac.c
+++ b/libavformat/oggparseflac.c
@@ -57,7 +57,7 @@ flac_header (AVFormatContext * s, int idx)
 
         ff_flac_parse_streaminfo(st->codec, &si, streaminfo_start);
 
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_id = CODEC_ID_FLAC;
 
         st->codec->extradata =
@@ -78,7 +78,7 @@ static int
 old_flac_header (AVFormatContext * s, int idx)
 {
     AVStream *st = s->streams[idx];
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_FLAC;
 
     return 0;
diff --git a/libavformat/oggparseogm.c b/libavformat/oggparseogm.c
index 01464839c441828a94de193d5c1c83983fbaef80..25722f3b0e1f935217c758d364ab7048f94d9260 100644
--- a/libavformat/oggparseogm.c
+++ b/libavformat/oggparseogm.c
@@ -49,19 +49,19 @@ ogm_header(AVFormatContext *s, int idx)
 
         if(*p == 'v'){
             int tag;
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             p += 8;
             tag = bytestream_get_le32(&p);
             st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag);
             st->codec->codec_tag = tag;
         } else if (*p == 't') {
-            st->codec->codec_type = CODEC_TYPE_SUBTITLE;
+            st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
             st->codec->codec_id = CODEC_ID_TEXT;
             p += 12;
         } else {
             uint8_t acid[5];
             int cid;
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             p += 8;
             bytestream_get_buffer(&p, acid, 4);
             acid[4] = 0;
@@ -78,7 +78,7 @@ ogm_header(AVFormatContext *s, int idx)
 
         p += 8;                     /* buffersize + bits_per_sample */
 
-        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
+        if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
             st->codec->width = bytestream_get_le32(&p);
             st->codec->height = bytestream_get_le32(&p);
             st->codec->time_base.den = spu * 10000000;
@@ -117,14 +117,14 @@ ogm_dshow_header(AVFormatContext *s, int idx)
     t = AV_RL32(p + 96);
 
     if(t == 0x05589f80){
-        st->codec->codec_type = CODEC_TYPE_VIDEO;
+        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, AV_RL32(p + 68));
         st->codec->time_base.den = 10000000;
         st->codec->time_base.num = AV_RL64(p + 164);
         st->codec->width = AV_RL32(p + 176);
         st->codec->height = AV_RL32(p + 180);
     } else if(t == 0x05589f81){
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_id = ff_codec_get_id(ff_codec_wav_tags, AV_RL16(p + 124));
         st->codec->channels = AV_RL16(p + 126);
         st->codec->sample_rate = AV_RL32(p + 128);
diff --git a/libavformat/oggparseskeleton.c b/libavformat/oggparseskeleton.c
index 82d249246e4a5ab59c4c4ca91463c18648c8f07f..ad0dded0d7cb1a1f474ae32d38cd8890ec60c9ca 100644
--- a/libavformat/oggparseskeleton.c
+++ b/libavformat/oggparseskeleton.c
@@ -33,7 +33,7 @@ static int skeleton_header(AVFormatContext *s, int idx)
     int target_idx, start_time;
 
     strcpy(st->codec->codec_name, "skeleton");
-    st->codec->codec_type = CODEC_TYPE_DATA;
+    st->codec->codec_type = AVMEDIA_TYPE_DATA;
 
     if (os->psize < 8)
         return -1;
diff --git a/libavformat/oggparsespeex.c b/libavformat/oggparsespeex.c
index 9ad5397af4e9a8d6abd18fa459611c2ca6158004..936b37e952e50478c331f6d1ccf67981b4cb957a 100644
--- a/libavformat/oggparsespeex.c
+++ b/libavformat/oggparsespeex.c
@@ -52,7 +52,7 @@ static int speex_header(AVFormatContext *s, int idx) {
 
     if (spxp->seq == 0) {
         int frames_per_packet;
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_id = CODEC_ID_SPEEX;
 
         st->codec->sample_rate = AV_RL32(p + 36);
diff --git a/libavformat/oggparsetheora.c b/libavformat/oggparsetheora.c
index ecd2bbe0119cd77e2b16d6258fc4168d0abc2a02..8c1b1c5b40fce42811909d7a34483d2978238d3a 100644
--- a/libavformat/oggparsetheora.c
+++ b/libavformat/oggparsetheora.c
@@ -104,7 +104,7 @@ theora_header (AVFormatContext * s, int idx)
         thp->gpshift = get_bits(&gb, 5);
         thp->gpmask = (1 << thp->gpshift) - 1;
 
-        st->codec->codec_type = CODEC_TYPE_VIDEO;
+        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         st->codec->codec_id = CODEC_ID_THEORA;
         st->need_parsing = AVSTREAM_PARSE_HEADERS;
 
diff --git a/libavformat/oggparsevorbis.c b/libavformat/oggparsevorbis.c
index 3bd692427ca614ec58cac45957384f54fbe55a97..886ef522b5cbe42b5995b6cef926b4c4d966ac3c 100644
--- a/libavformat/oggparsevorbis.c
+++ b/libavformat/oggparsevorbis.c
@@ -237,7 +237,7 @@ vorbis_header (AVFormatContext * s, int idx)
         if (bytestream_get_byte(&p) != 1) /* framing_flag */
             return -1;
 
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_id = CODEC_ID_VORBIS;
 
         st->time_base.num = 1;
diff --git a/libavformat/oma.c b/libavformat/oma.c
index 7052ad374e08cea2a1b133c241a20df2b68a1cb1..dc47b1b54cfbb12a69a492b11ac2d7bb7e59c11d 100644
--- a/libavformat/oma.c
+++ b/libavformat/oma.c
@@ -112,7 +112,7 @@ static int oma_read_header(AVFormatContext *s,
         return AVERROR(ENOMEM);
 
     st->start_time = 0;
-    st->codec->codec_type  = CODEC_TYPE_AUDIO;
+    st->codec->codec_type  = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_tag   = buf[32];
     st->codec->codec_id    = ff_codec_get_id(codec_oma_tags, st->codec->codec_tag);
 
diff --git a/libavformat/output-example.c b/libavformat/output-example.c
index fb1d3a78192fb00e0344f88ff6766b1429f72466..fc070b736c74642baa9d7e31ebcc8dcd9585e2f2 100644
--- a/libavformat/output-example.c
+++ b/libavformat/output-example.c
@@ -65,7 +65,7 @@ static AVStream *add_audio_stream(AVFormatContext *oc, enum CodecID codec_id)
 
     c = st->codec;
     c->codec_id = codec_id;
-    c->codec_type = CODEC_TYPE_AUDIO;
+    c->codec_type = AVMEDIA_TYPE_AUDIO;
 
     /* put sample parameters */
     c->bit_rate = 64000;
@@ -199,7 +199,7 @@ static AVStream *add_video_stream(AVFormatContext *oc, enum CodecID codec_id)
 
     c = st->codec;
     c->codec_id = codec_id;
-    c->codec_type = CODEC_TYPE_VIDEO;
+    c->codec_type = AVMEDIA_TYPE_VIDEO;
 
     /* put sample parameters */
     c->bit_rate = 400000;
diff --git a/libavformat/psxstr.c b/libavformat/psxstr.c
index f5fea95cd64da7dfa45f32eaf6571028eabde029..b1ed66364cc6b766f47951a6d5a631423d429892 100644
--- a/libavformat/psxstr.c
+++ b/libavformat/psxstr.c
@@ -169,7 +169,7 @@ static int str_read_packet(AVFormatContext *s,
 
                     str->channels[channel].video_stream_index = st->index;
 
-                    st->codec->codec_type = CODEC_TYPE_VIDEO;
+                    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
                     st->codec->codec_id   = CODEC_ID_MDEC;
                     st->codec->codec_tag  = 0;  /* no fourcc */
                     st->codec->width      = AV_RL16(&sector[0x28]);
@@ -216,7 +216,7 @@ static int str_read_packet(AVFormatContext *s,
 
                 str->channels[channel].audio_stream_index = st->index;
 
-                st->codec->codec_type  = CODEC_TYPE_AUDIO;
+                st->codec->codec_type  = AVMEDIA_TYPE_AUDIO;
                 st->codec->codec_id    = CODEC_ID_ADPCM_XA;
                 st->codec->codec_tag   = 0;  /* no fourcc */
                 st->codec->channels    = (fmt&1)?2:1;
diff --git a/libavformat/pva.c b/libavformat/pva.c
index 4255f8a71c52e9651ee267c4ea360f19ea47fd87..abbc6f1c60cfa92b8cf6e72b1c52ee0bdfecb6e8 100644
--- a/libavformat/pva.c
+++ b/libavformat/pva.c
@@ -45,7 +45,7 @@ static int pva_read_header(AVFormatContext *s, AVFormatParameters *ap) {
 
     if (!(st = av_new_stream(s, 0)))
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id   = CODEC_ID_MPEG2VIDEO;
     st->need_parsing      = AVSTREAM_PARSE_FULL;
     av_set_pts_info(st, 32, 1, 90000);
@@ -53,7 +53,7 @@ static int pva_read_header(AVFormatContext *s, AVFormatParameters *ap) {
 
     if (!(st = av_new_stream(s, 1)))
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id   = CODEC_ID_MP2;
     st->need_parsing      = AVSTREAM_PARSE_FULL;
     av_set_pts_info(st, 33, 1, 90000);
diff --git a/libavformat/qcp.c b/libavformat/qcp.c
index 2aadb2d79b53b47164734decb602e5d44f9ff6f0..78b7ef734fa3cb865b7a95c5ee0e91730586847c 100644
--- a/libavformat/qcp.c
+++ b/libavformat/qcp.c
@@ -95,7 +95,7 @@ static int qcp_read_header(AVFormatContext *s, AVFormatParameters *ap)
     s->file_size = get_le32(pb) + 8;
     url_fskip(pb, 8 + 4 + 1 + 1);    // "QLCMfmt " + chunk-size + major-version + minor-version
 
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->channels   = 1;
     get_buffer(pb, buf, 16);
     if (is_qcelp_13k_guid(buf)) {
diff --git a/libavformat/r3d.c b/libavformat/r3d.c
index 4f03d7f248543bf5384adbf37c298e0e1a211065..398ef620484cd620038c119dd119a12b47a17216 100644
--- a/libavformat/r3d.c
+++ b/libavformat/r3d.c
@@ -56,7 +56,7 @@ static int r3d_read_red1(AVFormatContext *s)
 
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_JPEG2000;
 
     tmp  = get_byte(s->pb); // major version
@@ -89,7 +89,7 @@ static int r3d_read_red1(AVFormatContext *s)
         AVStream *ast = av_new_stream(s, 1);
         if (!ast)
             return AVERROR(ENOMEM);
-        ast->codec->codec_type = CODEC_TYPE_AUDIO;
+        ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         ast->codec->codec_id = CODEC_ID_PCM_S32BE;
         ast->codec->channels = tmp;
         av_set_pts_info(ast, 32, 1, st->time_base.den);
diff --git a/libavformat/raw.c b/libavformat/raw.c
index b2e3ae8aa8a1efbb37e14ab2969316e3a02adb5e..7837de842acd48fe6b320a6066549098add418bf 100644
--- a/libavformat/raw.c
+++ b/libavformat/raw.c
@@ -74,14 +74,14 @@ static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
         id = s->iformat->value;
         if (id == CODEC_ID_RAWVIDEO) {
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         } else {
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         }
         st->codec->codec_id = id;
 
         switch(st->codec->codec_type) {
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             st->codec->sample_rate = ap->sample_rate;
             if(ap->channels) st->codec->channels = ap->channels;
             else             st->codec->channels = 1;
@@ -90,7 +90,7 @@ static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
             st->codec->block_align = st->codec->bits_per_coded_sample*st->codec->channels/8;
             av_set_pts_info(st, 64, 1, st->codec->sample_rate);
             break;
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             if(ap->time_base.num)
                 av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
             else
@@ -253,7 +253,7 @@ static int audio_read_header(AVFormatContext *s,
     AVStream *st = av_new_stream(s, 0);
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = s->iformat->value;
     st->need_parsing = AVSTREAM_PARSE_FULL;
     /* the parameters will be extracted from the compressed bitstream */
@@ -271,7 +271,7 @@ static int video_read_header(AVFormatContext *s,
     if (!st)
         return AVERROR(ENOMEM);
 
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = s->iformat->value;
     st->need_parsing = AVSTREAM_PARSE_FULL;
 
@@ -700,7 +700,7 @@ static int adts_aac_read_header(AVFormatContext *s,
     if (!st)
         return AVERROR(ENOMEM);
 
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = s->iformat->value;
     st->need_parsing = AVSTREAM_PARSE_FULL;
 
diff --git a/libavformat/rdt.c b/libavformat/rdt.c
index 0a390614c20e1f94abac9a1e874e2a1f9e68c017..268d5dedac5bd587c4b9d644276e91e7c6182f11 100644
--- a/libavformat/rdt.c
+++ b/libavformat/rdt.c
@@ -546,10 +546,10 @@ static RTPDynamicProtocolHandler ff_rdt_ ## n ## _handler = { \
     .parse_packet     = rdt_parse_packet \
 };
 
-RDT_HANDLER(live_video, "x-pn-multirate-realvideo-live", CODEC_TYPE_VIDEO);
-RDT_HANDLER(live_audio, "x-pn-multirate-realaudio-live", CODEC_TYPE_AUDIO);
-RDT_HANDLER(video,      "x-pn-realvideo",                CODEC_TYPE_VIDEO);
-RDT_HANDLER(audio,      "x-pn-realaudio",                CODEC_TYPE_AUDIO);
+RDT_HANDLER(live_video, "x-pn-multirate-realvideo-live", AVMEDIA_TYPE_VIDEO);
+RDT_HANDLER(live_audio, "x-pn-multirate-realaudio-live", AVMEDIA_TYPE_AUDIO);
+RDT_HANDLER(video,      "x-pn-realvideo",                AVMEDIA_TYPE_VIDEO);
+RDT_HANDLER(audio,      "x-pn-realaudio",                AVMEDIA_TYPE_AUDIO);
 
 void av_register_rdt_dynamic_payload_handlers(void)
 {
diff --git a/libavformat/riff.c b/libavformat/riff.c
index 8db684ae8ea8977e0d1d0a672cc6c64f31fbf200..12a7ce711b539ac3db4eba4629a79d0dd8b80323 100644
--- a/libavformat/riff.c
+++ b/libavformat/riff.c
@@ -461,7 +461,7 @@ void ff_get_wav_header(ByteIOContext *pb, AVCodecContext *codec, int size)
     int id;
 
     id = get_le16(pb);
-    codec->codec_type = CODEC_TYPE_AUDIO;
+    codec->codec_type = AVMEDIA_TYPE_AUDIO;
     codec->codec_tag = id;
     codec->channels = get_le16(pb);
     codec->sample_rate = get_le32(pb);
@@ -527,8 +527,8 @@ void ff_parse_specific_params(AVCodecContext *stream, int *au_rate, int *au_ssiz
     if(stream->frame_size && stream->sample_rate){
         *au_scale=stream->frame_size;
         *au_rate= stream->sample_rate;
-    }else if(stream->codec_type == CODEC_TYPE_VIDEO ||
-             stream->codec_type == CODEC_TYPE_SUBTITLE){
+    }else if(stream->codec_type == AVMEDIA_TYPE_VIDEO ||
+             stream->codec_type == AVMEDIA_TYPE_SUBTITLE){
         *au_scale= stream->time_base.num;
         *au_rate = stream->time_base.den;
     }else{
diff --git a/libavformat/rl2.c b/libavformat/rl2.c
index 1b193b002aedecadc4ca332fd73f1d579c09091b..7057e7e33d66e0a7bd56bbeb7ec02f6dbd845fa3 100644
--- a/libavformat/rl2.c
+++ b/libavformat/rl2.c
@@ -116,7 +116,7 @@ static av_cold int rl2_read_header(AVFormatContext *s,
     if(!st)
          return AVERROR(ENOMEM);
 
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_RL2;
     st->codec->codec_tag = 0;  /* no fourcc */
     st->codec->width = 320;
@@ -145,7 +145,7 @@ static av_cold int rl2_read_header(AVFormatContext *s,
         st = av_new_stream(s, 0);
         if (!st)
             return AVERROR(ENOMEM);
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_id = CODEC_ID_PCM_U8;
         st->codec->codec_tag = 1;
         st->codec->channels = channels;
diff --git a/libavformat/rmdec.c b/libavformat/rmdec.c
index 350970ab03f05a4fc5af692eea45a75d5b9e12a6..7f0db866d92f1a7698d30fba51be6d94235738ab 100644
--- a/libavformat/rmdec.c
+++ b/libavformat/rmdec.c
@@ -161,7 +161,7 @@ static int rm_read_audio_stream_info(AVFormatContext *s, ByteIOContext *pb,
             url_fskip(pb, header_size + startpos - url_ftell(pb));
         st->codec->sample_rate = 8000;
         st->codec->channels = 1;
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_id = CODEC_ID_RA_144;
     } else {
         int flavor, sub_packet_h, coded_framesize, sub_packet_size;
@@ -195,7 +195,7 @@ static int rm_read_audio_stream_info(AVFormatContext *s, ByteIOContext *pb,
             get_str8(pb, buf, sizeof(buf)); /* desc */
             get_str8(pb, buf, sizeof(buf)); /* desc */
         }
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_tag  = AV_RL32(buf);
         st->codec->codec_id   = ff_codec_get_id(rm_codec_tags, st->codec->codec_tag);
         switch (st->codec->codec_id) {
@@ -316,7 +316,7 @@ ff_rm_read_mdpr_codecdata (AVFormatContext *s, ByteIOContext *pb,
         st->codec->height = get_be16(pb);
         st->codec->time_base.num= 1;
         fps= get_be16(pb);
-        st->codec->codec_type = CODEC_TYPE_VIDEO;
+        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         get_be32(pb);
         fps2= get_be16(pb);
         get_be16(pb);
@@ -479,7 +479,7 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
             st->duration = duration;
             get_str8(pb, buf, sizeof(buf)); /* desc */
             get_str8(pb, buf, sizeof(buf)); /* mimetype */
-            st->codec->codec_type = CODEC_TYPE_DATA;
+            st->codec->codec_type = AVMEDIA_TYPE_DATA;
             st->priv_data = ff_rm_alloc_rmstream();
             if (ff_rm_read_mdpr_codecdata(s, s->pb, st, st->priv_data,
                                           get_be32(pb)) < 0)
@@ -725,11 +725,11 @@ ff_rm_parse_packet (AVFormatContext *s, ByteIOContext *pb,
 {
     RMDemuxContext *rm = s->priv_data;
 
-    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+    if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
         rm->current_stream= st->id;
         if(rm_assemble_video_frame(s, pb, rm, ast, pkt, len, seq))
             return -1; //got partial frame
-    } else if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+    } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
         if ((st->codec->codec_id == CODEC_ID_RA_288) ||
             (st->codec->codec_id == CODEC_ID_COOK) ||
             (st->codec->codec_id == CODEC_ID_ATRAC3) ||
@@ -790,7 +790,7 @@ ff_rm_parse_packet (AVFormatContext *s, ByteIOContext *pb,
     pkt->stream_index = st->index;
 
 #if 0
-    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+    if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
         if(st->codec->codec_id == CODEC_ID_RV20){
             int seq= 128*(pkt->data[2]&0x7F) + (pkt->data[3]>>1);
             av_log(s, AV_LOG_DEBUG, "%d %"PRId64" %d\n", *timestamp, *timestamp*512LL/25, seq);
@@ -806,7 +806,7 @@ ff_rm_parse_packet (AVFormatContext *s, ByteIOContext *pb,
     if (flags & 2)
         pkt->flags |= PKT_FLAG_KEY;
 
-    return st->codec->codec_type == CODEC_TYPE_AUDIO ? rm->audio_pkt_cnt : 0;
+    return st->codec->codec_type == AVMEDIA_TYPE_AUDIO ? rm->audio_pkt_cnt : 0;
 }
 
 int
@@ -932,7 +932,7 @@ static int64_t rm_read_dts(AVFormatContext *s, int stream_index,
             return AV_NOPTS_VALUE;
 
         st = s->streams[stream_index2];
-        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
             h= get_byte(s->pb); len--;
             if(!(h & 0x40)){
                 seq = get_byte(s->pb); len--;
diff --git a/libavformat/rmenc.c b/libavformat/rmenc.c
index 21748d5d5253f5c15618e66fc95028eef28816f2..9dbe3d08dccf8d9736569175db979d1457a04956 100644
--- a/libavformat/rmenc.c
+++ b/libavformat/rmenc.c
@@ -141,7 +141,7 @@ static void rv10_write_header(AVFormatContext *ctx,
 
         stream = &rm->streams[i];
 
-        if (stream->enc->codec_type == CODEC_TYPE_AUDIO) {
+        if (stream->enc->codec_type == AVMEDIA_TYPE_AUDIO) {
             desc = "The Audio Stream";
             mimetype = "audio/x-pn-realaudio";
             codec_data_size = 73;
@@ -177,7 +177,7 @@ static void rv10_write_header(AVFormatContext *ctx,
         put_str8(s, mimetype);
         put_be32(s, codec_data_size);
 
-        if (stream->enc->codec_type == CODEC_TYPE_AUDIO) {
+        if (stream->enc->codec_type == AVMEDIA_TYPE_AUDIO) {
             int coded_frame_size, fscode, sample_rate;
             sample_rate = stream->enc->sample_rate;
             coded_frame_size = (stream->enc->bit_rate *
@@ -309,7 +309,7 @@ static int rm_write_header(AVFormatContext *s)
         stream->enc = codec;
 
         switch(codec->codec_type) {
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             rm->audio_stream = stream;
             stream->frame_rate = (float)codec->sample_rate / (float)codec->frame_size;
             /* XXX: dummy values */
@@ -317,7 +317,7 @@ static int rm_write_header(AVFormatContext *s)
             stream->nb_packets = 0;
             stream->total_frames = stream->nb_packets;
             break;
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             rm->video_stream = stream;
             stream->frame_rate = (float)codec->time_base.den / (float)codec->time_base.num;
             /* XXX: dummy values */
@@ -408,7 +408,7 @@ static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int
 static int rm_write_packet(AVFormatContext *s, AVPacket *pkt)
 {
     if (s->streams[pkt->stream_index]->codec->codec_type ==
-        CODEC_TYPE_AUDIO)
+        AVMEDIA_TYPE_AUDIO)
         return rm_write_audio(s, pkt->data, pkt->size, pkt->flags);
     else
         return rm_write_video(s, pkt->data, pkt->size, pkt->flags);
diff --git a/libavformat/rpl.c b/libavformat/rpl.c
index ad713ffada80989731f67e058b8b2a55c73091d5..41c1687745e6c4feb58c82848be5bc504cbdbd56 100644
--- a/libavformat/rpl.c
+++ b/libavformat/rpl.c
@@ -141,7 +141,7 @@ static int rpl_read_header(AVFormatContext *s, AVFormatParameters *ap)
     vst = av_new_stream(s, 0);
     if (!vst)
         return AVERROR(ENOMEM);
-    vst->codec->codec_type      = CODEC_TYPE_VIDEO;
+    vst->codec->codec_type      = AVMEDIA_TYPE_VIDEO;
     vst->codec->codec_tag       = read_line_and_int(pb, &error);  // video format
     vst->codec->width           = read_line_and_int(pb, &error);  // video width
     vst->codec->height          = read_line_and_int(pb, &error);  // video height
@@ -183,7 +183,7 @@ static int rpl_read_header(AVFormatContext *s, AVFormatParameters *ap)
         ast = av_new_stream(s, 0);
         if (!ast)
             return AVERROR(ENOMEM);
-        ast->codec->codec_type      = CODEC_TYPE_AUDIO;
+        ast->codec->codec_type      = AVMEDIA_TYPE_AUDIO;
         ast->codec->codec_tag       = audio_format;
         ast->codec->sample_rate     = read_line_and_int(pb, &error);  // audio bitrate
         ast->codec->channels        = read_line_and_int(pb, &error);  // number of audio channels
@@ -295,7 +295,7 @@ static int rpl_read_packet(AVFormatContext *s, AVPacket *pkt)
         if (url_fseek(pb, index_entry->pos, SEEK_SET) < 0)
             return AVERROR(EIO);
 
-    if (stream->codec->codec_type == CODEC_TYPE_VIDEO &&
+    if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
         stream->codec->codec_tag == 124) {
         // We have to split Escape 124 frames because there are
         // multiple frames per chunk in Escape 124 samples.
@@ -327,7 +327,7 @@ static int rpl_read_packet(AVFormatContext *s, AVPacket *pkt)
             return AVERROR(EIO);
         }
 
-        if (stream->codec->codec_type == CODEC_TYPE_VIDEO) {
+        if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
             // frames_per_chunk should always be one here; the header
             // parsing will warn if it isn't.
             pkt->duration = rpl->frames_per_chunk;
diff --git a/libavformat/rtp.c b/libavformat/rtp.c
index 9c17a62aff2145f8857878838ed55393e74e8baf..a8dcfd79de85158edce7d853e251d84244040fa5 100644
--- a/libavformat/rtp.c
+++ b/libavformat/rtp.c
@@ -35,39 +35,39 @@ static const struct
 {
     int pt;
     const char enc_name[6];
-    enum CodecType codec_type;
+    enum AVMediaType codec_type;
     enum CodecID codec_id;
     int clock_rate;
     int audio_channels;
 } AVRtpPayloadTypes[]=
 {
-  {0, "PCMU",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_MULAW, 8000, 1},
-  {3, "GSM",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
-  {4, "G723",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
-  {5, "DVI4",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
-  {6, "DVI4",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 16000, 1},
-  {7, "LPC",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
-  {8, "PCMA",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_ALAW, 8000, 1},
-  {9, "G722",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
-  {10, "L16",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 2},
-  {11, "L16",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 1},
-  {12, "QCELP",      CODEC_TYPE_AUDIO,   CODEC_ID_QCELP, 8000, 1},
-  {13, "CN",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
-  {14, "MPA",        CODEC_TYPE_AUDIO,   CODEC_ID_MP2, -1, -1},
-  {14, "MPA",        CODEC_TYPE_AUDIO,   CODEC_ID_MP3, -1, -1},
-  {15, "G728",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
-  {16, "DVI4",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 11025, 1},
-  {17, "DVI4",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 22050, 1},
-  {18, "G729",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
-  {25, "CelB",       CODEC_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
-  {26, "JPEG",       CODEC_TYPE_VIDEO,   CODEC_ID_MJPEG, 90000, -1},
-  {28, "nv",         CODEC_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
-  {31, "H261",       CODEC_TYPE_VIDEO,   CODEC_ID_H261, 90000, -1},
-  {32, "MPV",        CODEC_TYPE_VIDEO,   CODEC_ID_MPEG1VIDEO, 90000, -1},
-  {32, "MPV",        CODEC_TYPE_VIDEO,   CODEC_ID_MPEG2VIDEO, 90000, -1},
-  {33, "MP2T",       CODEC_TYPE_DATA,    CODEC_ID_MPEG2TS, 90000, -1},
-  {34, "H263",       CODEC_TYPE_VIDEO,   CODEC_ID_H263, 90000, -1},
-  {-1, "",           CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
+  {0, "PCMU",        AVMEDIA_TYPE_AUDIO,   CODEC_ID_PCM_MULAW, 8000, 1},
+  {3, "GSM",         AVMEDIA_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
+  {4, "G723",        AVMEDIA_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
+  {5, "DVI4",        AVMEDIA_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
+  {6, "DVI4",        AVMEDIA_TYPE_AUDIO,   CODEC_ID_NONE, 16000, 1},
+  {7, "LPC",         AVMEDIA_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
+  {8, "PCMA",        AVMEDIA_TYPE_AUDIO,   CODEC_ID_PCM_ALAW, 8000, 1},
+  {9, "G722",        AVMEDIA_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
+  {10, "L16",        AVMEDIA_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 2},
+  {11, "L16",        AVMEDIA_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 1},
+  {12, "QCELP",      AVMEDIA_TYPE_AUDIO,   CODEC_ID_QCELP, 8000, 1},
+  {13, "CN",         AVMEDIA_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
+  {14, "MPA",        AVMEDIA_TYPE_AUDIO,   CODEC_ID_MP2, -1, -1},
+  {14, "MPA",        AVMEDIA_TYPE_AUDIO,   CODEC_ID_MP3, -1, -1},
+  {15, "G728",       AVMEDIA_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
+  {16, "DVI4",       AVMEDIA_TYPE_AUDIO,   CODEC_ID_NONE, 11025, 1},
+  {17, "DVI4",       AVMEDIA_TYPE_AUDIO,   CODEC_ID_NONE, 22050, 1},
+  {18, "G729",       AVMEDIA_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
+  {25, "CelB",       AVMEDIA_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
+  {26, "JPEG",       AVMEDIA_TYPE_VIDEO,   CODEC_ID_MJPEG, 90000, -1},
+  {28, "nv",         AVMEDIA_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
+  {31, "H261",       AVMEDIA_TYPE_VIDEO,   CODEC_ID_H261, 90000, -1},
+  {32, "MPV",        AVMEDIA_TYPE_VIDEO,   CODEC_ID_MPEG1VIDEO, 90000, -1},
+  {32, "MPV",        AVMEDIA_TYPE_VIDEO,   CODEC_ID_MPEG2VIDEO, 90000, -1},
+  {33, "MP2T",       AVMEDIA_TYPE_DATA,    CODEC_ID_MPEG2TS, 90000, -1},
+  {34, "H263",       AVMEDIA_TYPE_VIDEO,   CODEC_ID_H263, 90000, -1},
+  {-1, "",           AVMEDIA_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
 };
 
 int ff_rtp_get_codec_info(AVCodecContext *codec, int payload_type)
@@ -118,7 +118,7 @@ const char *ff_rtp_enc_name(int payload_type)
     return "";
 }
 
-enum CodecID ff_rtp_codec_id(const char *buf, enum CodecType codec_type)
+enum CodecID ff_rtp_codec_id(const char *buf, enum AVMediaType codec_type)
 {
     int i;
 
diff --git a/libavformat/rtp.h b/libavformat/rtp.h
index 80081ac9eb8d6ec24c54c1adc9f3acd770403d6f..7834f9deb85c7a13cb6d04599afec7a6763d2339 100644
--- a/libavformat/rtp.h
+++ b/libavformat/rtp.h
@@ -66,7 +66,7 @@ const char *ff_rtp_enc_name(int payload_type);
  * @return In case of unknown encoding name, CODEC_ID_NONE is returned;
  * otherwise, the codec id is returned
  */
-enum CodecID ff_rtp_codec_id(const char *buf, enum CodecType codec_type);
+enum CodecID ff_rtp_codec_id(const char *buf, enum AVMediaType codec_type);
 
 #define RTP_PT_PRIVATE 96
 #define RTP_VERSION 2
diff --git a/libavformat/rtpdec.c b/libavformat/rtpdec.c
index 6ffe1dadac2a9632507f6a26c0e8bac200409055..e329ad291d5d3a3ad963552534486387404f8f5a 100644
--- a/libavformat/rtpdec.c
+++ b/libavformat/rtpdec.c
@@ -51,8 +51,8 @@
 /* statistics functions */
 RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
 
-static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
-static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
+static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG4};
+static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", AVMEDIA_TYPE_AUDIO, CODEC_ID_AAC};
 
 void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
 {
@@ -350,7 +350,7 @@ RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *r
             st->need_parsing = AVSTREAM_PARSE_FULL;
             break;
         default:
-            if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+            if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
                 av_set_pts_info(st, 32, 1, st->codec->sample_rate);
             }
             break;
diff --git a/libavformat/rtpdec.h b/libavformat/rtpdec.h
index 6907a0c6875b742d548604c03c85325994ffd61b..366102af998ad44f0aba2fb9b903d5aa4440438b 100644
--- a/libavformat/rtpdec.h
+++ b/libavformat/rtpdec.h
@@ -132,7 +132,7 @@ typedef int (*DynamicPayloadPacketHandlerProc) (AVFormatContext *ctx,
 struct RTPDynamicProtocolHandler_s {
     // fields from AVRtpDynamicPayloadType_s
     const char enc_name[50];    /* XXX: still why 50 ? ;-) */
-    enum CodecType codec_type;
+    enum AVMediaType codec_type;
     enum CodecID codec_id;
 
     // may be null
diff --git a/libavformat/rtpdec_amr.c b/libavformat/rtpdec_amr.c
index cbf9f28d02cc83772de3bf8481bb079321b21687..38399c6660d03f065cda1d1c04bc086cc9fcb32c 100644
--- a/libavformat/rtpdec_amr.c
+++ b/libavformat/rtpdec_amr.c
@@ -170,7 +170,7 @@ static int amr_parse_sdp_line(AVFormatContext *s, int st_index,
 
 RTPDynamicProtocolHandler ff_amr_nb_dynamic_handler = {
     .enc_name         = "AMR",
-    .codec_type       = CODEC_TYPE_AUDIO,
+    .codec_type       = AVMEDIA_TYPE_AUDIO,
     .codec_id         = CODEC_ID_AMR_NB,
     .parse_sdp_a_line = amr_parse_sdp_line,
     .parse_packet     = amr_handle_packet,
@@ -178,7 +178,7 @@ RTPDynamicProtocolHandler ff_amr_nb_dynamic_handler = {
 
 RTPDynamicProtocolHandler ff_amr_wb_dynamic_handler = {
     .enc_name         = "AMR-WB",
-    .codec_type       = CODEC_TYPE_AUDIO,
+    .codec_type       = AVMEDIA_TYPE_AUDIO,
     .codec_id         = CODEC_ID_AMR_WB,
     .parse_sdp_a_line = amr_parse_sdp_line,
     .parse_packet     = amr_handle_packet,
diff --git a/libavformat/rtpdec_asf.c b/libavformat/rtpdec_asf.c
index 44c1c83ea4de1e6ada32e22bad20b6e3c55f9dbf..8fea87201436799e5f3886e8bcbbb74b87acb3b1 100644
--- a/libavformat/rtpdec_asf.c
+++ b/libavformat/rtpdec_asf.c
@@ -277,5 +277,5 @@ RTPDynamicProtocolHandler ff_ms_rtp_ ## n ## _handler = { \
     .parse_packet     = asfrtp_parse_packet,   \
 };
 
-RTP_ASF_HANDLER(asf_pfv, "x-asf-pf",  CODEC_TYPE_VIDEO);
-RTP_ASF_HANDLER(asf_pfa, "x-asf-pf",  CODEC_TYPE_AUDIO);
+RTP_ASF_HANDLER(asf_pfv, "x-asf-pf",  AVMEDIA_TYPE_VIDEO);
+RTP_ASF_HANDLER(asf_pfa, "x-asf-pf",  AVMEDIA_TYPE_AUDIO);
diff --git a/libavformat/rtpdec_h263.c b/libavformat/rtpdec_h263.c
index 7d498f3af0a5f07c4b50c1f9c5bc006d33f43bcc..3d5925e9a4696b5baee397e53e1fa67ecf60c9c4 100644
--- a/libavformat/rtpdec_h263.c
+++ b/libavformat/rtpdec_h263.c
@@ -94,14 +94,14 @@ static int h263_handle_packet(AVFormatContext *ctx,
 
 RTPDynamicProtocolHandler ff_h263_1998_dynamic_handler = {
     .enc_name         = "H263-1998",
-    .codec_type       = CODEC_TYPE_VIDEO,
+    .codec_type       = AVMEDIA_TYPE_VIDEO,
     .codec_id         = CODEC_ID_H263,
     .parse_packet     = h263_handle_packet,
 };
 
 RTPDynamicProtocolHandler ff_h263_2000_dynamic_handler = {
     .enc_name         = "H263-2000",
-    .codec_type       = CODEC_TYPE_VIDEO,
+    .codec_type       = AVMEDIA_TYPE_VIDEO,
     .codec_id         = CODEC_ID_H263,
     .parse_packet     = h263_handle_packet,
 };
diff --git a/libavformat/rtpdec_h264.c b/libavformat/rtpdec_h264.c
index 970e6fdcc7d8362fcb4d7b06d2972cf121a684ce..dd32e18b447fba69bcc405a874763d07bc6f5eab 100644
--- a/libavformat/rtpdec_h264.c
+++ b/libavformat/rtpdec_h264.c
@@ -411,7 +411,7 @@ This is the structure for expanding on the dynamic rtp protocols (makes everythi
 */
 RTPDynamicProtocolHandler ff_h264_dynamic_handler = {
     .enc_name         = "H264",
-    .codec_type       = CODEC_TYPE_VIDEO,
+    .codec_type       = AVMEDIA_TYPE_VIDEO,
     .codec_id         = CODEC_ID_H264,
     .parse_sdp_a_line = parse_h264_sdp_line,
     .open             = h264_new_context,
diff --git a/libavformat/rtpdec_theora.c b/libavformat/rtpdec_theora.c
index b87a6f79944cc2505334ec1d29574efbe9b8c3e2..56a59e4e16cede6284f6be7aecb8bfd8ca52e11b 100644
--- a/libavformat/rtpdec_theora.c
+++ b/libavformat/rtpdec_theora.c
@@ -378,7 +378,7 @@ static int theora_parse_sdp_line(AVFormatContext *s, int st_index,
 
 RTPDynamicProtocolHandler ff_theora_dynamic_handler = {
     .enc_name         = "theora",
-    .codec_type       = CODEC_TYPE_VIDEO,
+    .codec_type       = AVMEDIA_TYPE_VIDEO,
     .codec_id         = CODEC_ID_THEORA,
     .parse_sdp_a_line = theora_parse_sdp_line,
     .open             = theora_new_context,
diff --git a/libavformat/rtpdec_vorbis.c b/libavformat/rtpdec_vorbis.c
index 3d1b2cc1efbe42dfcd45d5e84aa8721102922ee1..35b672f40918eb4ac85f25d82456491799235d9c 100644
--- a/libavformat/rtpdec_vorbis.c
+++ b/libavformat/rtpdec_vorbis.c
@@ -209,7 +209,7 @@ vorbis_handle_packet(AVFormatContext * ctx,
 
 RTPDynamicProtocolHandler ff_vorbis_dynamic_handler = {
     .enc_name         = "vorbis",
-    .codec_type       = CODEC_TYPE_AUDIO,
+    .codec_type       = AVMEDIA_TYPE_AUDIO,
     .codec_id         = CODEC_ID_VORBIS,
     .parse_sdp_a_line = NULL,
     .open             = vorbis_new_context,
diff --git a/libavformat/rtpenc.c b/libavformat/rtpenc.c
index c5441b8312555d2f2f8f5bd35c8ccd39cf583247..5df101eb04c5bd437e2c5545195cd86227e29d88 100644
--- a/libavformat/rtpenc.c
+++ b/libavformat/rtpenc.c
@@ -78,7 +78,7 @@ static int rtp_write_header(AVFormatContext *s1)
 
     s->payload_type = ff_rtp_get_payload_type(st->codec);
     if (s->payload_type < 0)
-        s->payload_type = RTP_PT_PRIVATE + (st->codec->codec_type == CODEC_TYPE_AUDIO);
+        s->payload_type = RTP_PT_PRIVATE + (st->codec->codec_type == AVMEDIA_TYPE_AUDIO);
 
     s->base_timestamp = ff_random_get_seed();
     s->timestamp = s->base_timestamp;
@@ -102,14 +102,14 @@ static int rtp_write_header(AVFormatContext *s1)
 
     s->max_frames_per_packet = 0;
     if (s1->max_delay) {
-        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
             if (st->codec->frame_size == 0) {
                 av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n");
             } else {
                 s->max_frames_per_packet = av_rescale_rnd(s1->max_delay, st->codec->sample_rate, AV_TIME_BASE * st->codec->frame_size, AV_ROUND_DOWN);
             }
         }
-        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
             /* FIXME: We should round down here... */
             s->max_frames_per_packet = av_rescale_q(s1->max_delay, (AVRational){1, 1000000}, st->codec->time_base);
         }
@@ -151,7 +151,7 @@ static int rtp_write_header(AVFormatContext *s1)
     case CODEC_ID_AAC:
         s->num_frames = 0;
     default:
-        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
             av_set_pts_info(st, 32, 1, st->codec->sample_rate);
         }
         s->buf_ptr = s->buf;
diff --git a/libavformat/rtsp.c b/libavformat/rtsp.c
index a675e9a333dcc5fbf3f68acb880c969181947871..352426e333c5283a739959b8c5f15213ab189927 100644
--- a/libavformat/rtsp.c
+++ b/libavformat/rtsp.c
@@ -141,7 +141,7 @@ static int sdp_parse_rtpmap(AVFormatContext *s,
     get_word_sep(buf, sizeof(buf), "/", &p);
     i = atoi(buf);
     switch (codec->codec_type) {
-    case CODEC_TYPE_AUDIO:
+    case AVMEDIA_TYPE_AUDIO:
         av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name);
         codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;
         codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;
@@ -161,7 +161,7 @@ static int sdp_parse_rtpmap(AVFormatContext *s,
         av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n",
                codec->channels);
         break;
-    case CODEC_TYPE_VIDEO:
+    case AVMEDIA_TYPE_VIDEO:
         av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
         break;
     default:
@@ -343,7 +343,7 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
     RTSPState *rt = s->priv_data;
     char buf1[64], st_type[64];
     const char *p;
-    enum CodecType codec_type;
+    enum AVMediaType codec_type;
     int payload_type, i;
     AVStream *st;
     RTSPStream *rtsp_st;
@@ -396,11 +396,11 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
         s1->skip_media = 0;
         get_word(st_type, sizeof(st_type), &p);
         if (!strcmp(st_type, "audio")) {
-            codec_type = CODEC_TYPE_AUDIO;
+            codec_type = AVMEDIA_TYPE_AUDIO;
         } else if (!strcmp(st_type, "video")) {
-            codec_type = CODEC_TYPE_VIDEO;
+            codec_type = AVMEDIA_TYPE_VIDEO;
         } else if (!strcmp(st_type, "application")) {
-            codec_type = CODEC_TYPE_DATA;
+            codec_type = AVMEDIA_TYPE_DATA;
         } else {
             s1->skip_media = 1;
             return;
@@ -1181,7 +1181,7 @@ static int make_setup_request(AVFormatContext *s, const char *host, int port,
              * will return an error. Therefore, we skip those streams. */
             if (rt->server_type == RTSP_SERVER_WMS &&
                 s->streams[rtsp_st->stream_index]->codec->codec_type ==
-                    CODEC_TYPE_DATA)
+                    AVMEDIA_TYPE_DATA)
                 continue;
             snprintf(transport, sizeof(transport) - 1,
                      "%s/TCP;", trans_pref);
diff --git a/libavformat/sdp.c b/libavformat/sdp.c
index d48a5df950ccac3bd856b2f0a860e77024d36c3b..a8cab6a68fcdc29998f5a0651faab8df9cd1ef9a 100644
--- a/libavformat/sdp.c
+++ b/libavformat/sdp.c
@@ -301,13 +301,13 @@ static void sdp_write_media(char *buff, int size, AVCodecContext *c, const char
 
     payload_type = ff_rtp_get_payload_type(c);
     if (payload_type < 0) {
-        payload_type = RTP_PT_PRIVATE + (c->codec_type == CODEC_TYPE_AUDIO);
+        payload_type = RTP_PT_PRIVATE + (c->codec_type == AVMEDIA_TYPE_AUDIO);
     }
 
     switch (c->codec_type) {
-        case CODEC_TYPE_VIDEO   : type = "video"      ; break;
-        case CODEC_TYPE_AUDIO   : type = "audio"      ; break;
-        case CODEC_TYPE_SUBTITLE: type = "text"       ; break;
+        case AVMEDIA_TYPE_VIDEO   : type = "video"      ; break;
+        case AVMEDIA_TYPE_AUDIO   : type = "audio"      ; break;
+        case AVMEDIA_TYPE_SUBTITLE: type = "text"       ; break;
         default                 : type = "application"; break;
     }
 
diff --git a/libavformat/segafilm.c b/libavformat/segafilm.c
index ae1263cf98317a3b250d6c5951768c827fa1a179..aec8c4bd79cbdcaf25f8e5411cd909f13718573d 100644
--- a/libavformat/segafilm.c
+++ b/libavformat/segafilm.c
@@ -133,7 +133,7 @@ static int film_read_header(AVFormatContext *s,
         if (!st)
             return AVERROR(ENOMEM);
         film->video_stream_index = st->index;
-        st->codec->codec_type = CODEC_TYPE_VIDEO;
+        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         st->codec->codec_id = film->video_type;
         st->codec->codec_tag = 0;  /* no fourcc */
         st->codec->width = AV_RB32(&scratch[16]);
@@ -145,7 +145,7 @@ static int film_read_header(AVFormatContext *s,
         if (!st)
             return AVERROR(ENOMEM);
         film->audio_stream_index = st->index;
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_id = film->audio_type;
         st->codec->codec_tag = 1;
         st->codec->channels = film->audio_channels;
diff --git a/libavformat/sierravmd.c b/libavformat/sierravmd.c
index 9d069fdff6632ba0c65973e65af9645957dfa9af..a052e7bffa90d5a0bc84684a8194f8412b2cf252 100644
--- a/libavformat/sierravmd.c
+++ b/libavformat/sierravmd.c
@@ -109,7 +109,7 @@ static int vmd_read_header(AVFormatContext *s,
         return AVERROR(ENOMEM);
     av_set_pts_info(vst, 33, 1, 10);
     vmd->video_stream_index = vst->index;
-    vst->codec->codec_type = CODEC_TYPE_VIDEO;
+    vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     vst->codec->codec_id = vmd->is_indeo3 ? CODEC_ID_INDEO3 : CODEC_ID_VMDVIDEO;
     vst->codec->codec_tag = 0;  /* no fourcc */
     vst->codec->width = AV_RL16(&vmd->vmd_header[12]);
@@ -129,7 +129,7 @@ static int vmd_read_header(AVFormatContext *s,
         if (!st)
             return AVERROR(ENOMEM);
         vmd->audio_stream_index = st->index;
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codec->codec_id = CODEC_ID_VMDAUDIO;
         st->codec->codec_tag = 0;  /* no fourcc */
         st->codec->channels = (vmd->vmd_header[811] & 0x80) ? 2 : 1;
diff --git a/libavformat/siff.c b/libavformat/siff.c
index 1194f71bf6a288c58f9097c723d82c446777507e..fcf736fd27f2db947a6c0fe7204ef12b63d3c4a6 100644
--- a/libavformat/siff.c
+++ b/libavformat/siff.c
@@ -74,7 +74,7 @@ static int create_audio_stream(AVFormatContext *s, SIFFContext *c)
     ast = av_new_stream(s, 0);
     if (!ast)
         return -1;
-    ast->codec->codec_type      = CODEC_TYPE_AUDIO;
+    ast->codec->codec_type      = AVMEDIA_TYPE_AUDIO;
     ast->codec->codec_id        = CODEC_ID_PCM_U8;
     ast->codec->channels        = 1;
     ast->codec->bits_per_coded_sample = c->bits;
@@ -118,7 +118,7 @@ static int siff_parse_vbv1(AVFormatContext *s, SIFFContext *c, ByteIOContext *pb
     st = av_new_stream(s, 0);
     if (!st)
         return -1;
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id   = CODEC_ID_VB;
     st->codec->codec_tag  = MKTAG('V', 'B', 'V', '1');
     st->codec->width      = width;
diff --git a/libavformat/smacker.c b/libavformat/smacker.c
index 59fed35d3f21b93b79226f4fdf7af43bc204a70b..0dcc2865560504f68a4ea00125b5bb4f25db1ac8 100644
--- a/libavformat/smacker.c
+++ b/libavformat/smacker.c
@@ -158,7 +158,7 @@ static int smacker_read_header(AVFormatContext *s, AVFormatParameters *ap)
     st->codec->width = smk->width;
     st->codec->height = smk->height;
     st->codec->pix_fmt = PIX_FMT_PAL8;
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_SMACKVIDEO;
     st->codec->codec_tag = smk->magic;
     /* Smacker uses 100000 as internal timebase */
@@ -176,7 +176,7 @@ static int smacker_read_header(AVFormatContext *s, AVFormatParameters *ap)
         if(smk->rates[i] & 0xFFFFFF){
             ast[i] = av_new_stream(s, 0);
             smk->indexes[i] = ast[i]->index;
-            ast[i]->codec->codec_type = CODEC_TYPE_AUDIO;
+            ast[i]->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             if (smk->rates[i] & SMK_AUD_BINKAUD) {
                 ast[i]->codec->codec_id = CODEC_ID_BINKAUDIO_RDFT;
             } else if (smk->rates[i] & SMK_AUD_USEDCT) {
diff --git a/libavformat/sol.c b/libavformat/sol.c
index aa566647bb15a2e86d8d065ccea8d001d4392701..3ae2d04bb35ccdcc115bb423fa08659dde48a777 100644
--- a/libavformat/sol.c
+++ b/libavformat/sol.c
@@ -114,7 +114,7 @@ static int sol_read_header(AVFormatContext *s,
     st = av_new_stream(s, 0);
     if (!st)
         return -1;
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_tag = id;
     st->codec->codec_id = codec;
     st->codec->channels = channels;
diff --git a/libavformat/soxdec.c b/libavformat/soxdec.c
index 0151efebc10168d6c8d63ca4ca0dd7882bc255f2..41cf884b25a1f6d886e1ca909f030a453aca87df 100644
--- a/libavformat/soxdec.c
+++ b/libavformat/soxdec.c
@@ -53,7 +53,7 @@ static int sox_read_header(AVFormatContext *s,
     if (!st)
         return AVERROR(ENOMEM);
 
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
 
     if (get_le32(pb) == SOX_TAG) {
         st->codec->codec_id = CODEC_ID_PCM_S32LE;
diff --git a/libavformat/swfdec.c b/libavformat/swfdec.c
index 3a60fab702f2e2b605a4056809e78cdfdf3bd5e8..64f775f783fc337161318b9ace4afb551db05218 100644
--- a/libavformat/swfdec.c
+++ b/libavformat/swfdec.c
@@ -97,7 +97,7 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
 
             for (i=0; i<s->nb_streams; i++) {
                 st = s->streams[i];
-                if (st->codec->codec_type == CODEC_TYPE_VIDEO && st->id == ch_id)
+                if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id)
                     goto skip;
             }
 
@@ -109,7 +109,7 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
             vst = av_new_stream(s, ch_id);
             if (!vst)
                 return -1;
-            vst->codec->codec_type = CODEC_TYPE_VIDEO;
+            vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             vst->codec->codec_id = ff_codec_get_id(swf_codec_tags, get_byte(pb));
             av_set_pts_info(vst, 16, 256, swf->frame_rate);
             vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
@@ -120,7 +120,7 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
 
             for (i=0; i<s->nb_streams; i++) {
                 st = s->streams[i];
-                if (st->codec->codec_type == CODEC_TYPE_AUDIO && st->id == -1)
+                if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1)
                     goto skip;
             }
 
@@ -131,7 +131,7 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
             if (!ast)
                 return -1;
             ast->codec->channels = 1 + (v&1);
-            ast->codec->codec_type = CODEC_TYPE_AUDIO;
+            ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             ast->codec->codec_id = ff_codec_get_id(swf_audio_codec_tags, (v>>4) & 15);
             ast->need_parsing = AVSTREAM_PARSE_FULL;
             sample_rate_code= (v>>2) & 3;
@@ -145,7 +145,7 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
             len -= 2;
             for(i=0; i<s->nb_streams; i++) {
                 st = s->streams[i];
-                if (st->codec->codec_type == CODEC_TYPE_VIDEO && st->id == ch_id) {
+                if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {
                     frame = get_le16(pb);
                     av_get_packet(pb, pkt, len-2);
                     pkt->pos = pos;
@@ -157,7 +157,7 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
         } else if (tag == TAG_STREAMBLOCK) {
             for (i = 0; i < s->nb_streams; i++) {
                 st = s->streams[i];
-                if (st->codec->codec_type == CODEC_TYPE_AUDIO && st->id == -1) {
+                if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {
             if (st->codec->codec_id == CODEC_ID_MP3) {
                 url_fskip(pb, 4);
                 av_get_packet(pb, pkt, len-4);
@@ -179,7 +179,7 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
                 vst = av_new_stream(s, -2); /* -2 to avoid clash with video stream and audio stream */
                 if (!vst)
                     return -1;
-                vst->codec->codec_type = CODEC_TYPE_VIDEO;
+                vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
                 vst->codec->codec_id = CODEC_ID_MJPEG;
                 av_set_pts_info(vst, 64, 256, swf->frame_rate);
                 vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
diff --git a/libavformat/swfenc.c b/libavformat/swfenc.c
index 60b7171cc9af2d09cf7bcd8988ad7bb3c6162ede..1a1a9ab8086612adc10bf688d8cf1bd7cd2d78d2 100644
--- a/libavformat/swfenc.c
+++ b/libavformat/swfenc.c
@@ -185,7 +185,7 @@ static int swf_write_header(AVFormatContext *s)
 
     for(i=0;i<s->nb_streams;i++) {
         AVCodecContext *enc = s->streams[i]->codec;
-        if (enc->codec_type == CODEC_TYPE_AUDIO) {
+        if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
             if (enc->codec_id == CODEC_ID_MP3) {
                 if (!enc->frame_size) {
                     av_log(s, AV_LOG_ERROR, "audio frame size not set\n");
@@ -464,7 +464,7 @@ static int swf_write_audio(AVFormatContext *s,
 static int swf_write_packet(AVFormatContext *s, AVPacket *pkt)
 {
     AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
-    if (codec->codec_type == CODEC_TYPE_AUDIO)
+    if (codec->codec_type == AVMEDIA_TYPE_AUDIO)
         return swf_write_audio(s, codec, pkt->data, pkt->size);
     else
         return swf_write_video(s, codec, pkt->data, pkt->size);
@@ -480,7 +480,7 @@ static int swf_write_trailer(AVFormatContext *s)
     video_enc = NULL;
     for(i=0;i<s->nb_streams;i++) {
         enc = s->streams[i]->codec;
-        if (enc->codec_type == CODEC_TYPE_VIDEO)
+        if (enc->codec_type == AVMEDIA_TYPE_VIDEO)
             video_enc = enc;
         else
             av_fifo_free(swf->audio_fifo);
diff --git a/libavformat/thp.c b/libavformat/thp.c
index a5c9476d1ad78012c6cf5cc6257f08ce76d2f89e..82966dde7e42e0d19319ab636470251747ee6d95 100644
--- a/libavformat/thp.c
+++ b/libavformat/thp.c
@@ -100,7 +100,7 @@ static int thp_read_header(AVFormatContext *s,
             /* The denominator and numerator are switched because 1/fps
                is required.  */
             av_set_pts_info(st, 64, thp->fps.den, thp->fps.num);
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             st->codec->codec_id = CODEC_ID_THP;
             st->codec->codec_tag = 0;  /* no fourcc */
             st->codec->width = get_be32(pb);
@@ -120,7 +120,7 @@ static int thp_read_header(AVFormatContext *s,
             if (!st)
                 return AVERROR(ENOMEM);
 
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
             st->codec->codec_id = CODEC_ID_ADPCM_THP;
             st->codec->codec_tag = 0;  /* no fourcc */
             st->codec->channels    = get_be32(pb); /* numChannels.  */
diff --git a/libavformat/tiertexseq.c b/libavformat/tiertexseq.c
index 43ee6b1e21801f2cdbefe9f7b13ab82014e447a7..b8516f9f8ad79516498ed0f196a6479c24fba863 100644
--- a/libavformat/tiertexseq.c
+++ b/libavformat/tiertexseq.c
@@ -212,7 +212,7 @@ static int seq_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
     av_set_pts_info(st, 32, 1, SEQ_FRAME_RATE);
     seq->video_stream_index = st->index;
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_TIERTEXSEQVIDEO;
     st->codec->codec_tag = 0;  /* no fourcc */
     st->codec->width = SEQ_FRAME_W;
@@ -225,7 +225,7 @@ static int seq_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
     av_set_pts_info(st, 32, 1, SEQ_SAMPLE_RATE);
     seq->audio_stream_index = st->index;
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_PCM_S16BE;
     st->codec->codec_tag = 0;  /* no tag */
     st->codec->channels = 1;
diff --git a/libavformat/tmv.c b/libavformat/tmv.c
index 27afbbfa6d336e2ab94ca1dc412e04d67f994005..cec6f99148e2fbaa66a1ac72348e8d6b29594fa5 100644
--- a/libavformat/tmv.c
+++ b/libavformat/tmv.c
@@ -109,7 +109,7 @@ static int tmv_read_header(AVFormatContext *s, AVFormatParameters *ap)
         return -1;
     }
 
-    ast->codec->codec_type            = CODEC_TYPE_AUDIO;
+    ast->codec->codec_type            = AVMEDIA_TYPE_AUDIO;
     ast->codec->codec_id              = CODEC_ID_PCM_U8;
     ast->codec->channels              = features & TMV_STEREO ? 2 : 1;
     ast->codec->bits_per_coded_sample = 8;
@@ -121,7 +121,7 @@ static int tmv_read_header(AVFormatContext *s, AVFormatParameters *ap)
     fps.den = tmv->audio_chunk_size;
     av_reduce(&fps.num, &fps.den, fps.num, fps.den, 0xFFFFFFFFLL);
 
-    vst->codec->codec_type = CODEC_TYPE_VIDEO;
+    vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     vst->codec->codec_id   = CODEC_ID_TMV;
     vst->codec->pix_fmt    = PIX_FMT_PAL8;
     vst->codec->width      = char_cols * 8;
diff --git a/libavformat/tta.c b/libavformat/tta.c
index e5b9e5f4edfa52aa7e61cf8190f1ac42d84e2ba0..66d3bad90416e606b4a50d4776c4fbec5fac98b9 100644
--- a/libavformat/tta.c
+++ b/libavformat/tta.c
@@ -101,7 +101,7 @@ static int tta_read_header(AVFormatContext *s, AVFormatParameters *ap)
     }
     url_fskip(s->pb, 4); // seektable crc
 
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_TTA;
     st->codec->channels = channels;
     st->codec->sample_rate = samplerate;
diff --git a/libavformat/txd.c b/libavformat/txd.c
index 6a06711bc47896114f39a59dbe9965bed3a2c014..38bdb1ba94a85fd49b8fd0e02e9bd4d138e77d90 100644
--- a/libavformat/txd.c
+++ b/libavformat/txd.c
@@ -43,7 +43,7 @@ static int txd_read_header(AVFormatContext *s, AVFormatParameters *ap) {
     st = av_new_stream(s, 0);
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_TXD;
     st->codec->time_base.den = 5;
     st->codec->time_base.num = 1;
diff --git a/libavformat/utils.c b/libavformat/utils.c
index b29e65d93c716b899a54caf2f477e57f8913aab3..8b57b39d5964615a6128b0fc3750d51e2e52fb48 100644
--- a/libavformat/utils.c
+++ b/libavformat/utils.c
@@ -254,8 +254,8 @@ AVOutputFormat *guess_stream_format(const char *short_name, const char *filename
 #endif
 
 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
-                            const char *filename, const char *mime_type, enum CodecType type){
-    if(type == CODEC_TYPE_VIDEO){
+                            const char *filename, const char *mime_type, enum AVMediaType type){
+    if(type == AVMEDIA_TYPE_VIDEO){
         enum CodecID codec_id= CODEC_ID_NONE;
 
 #if CONFIG_IMAGE2_MUXER
@@ -266,7 +266,7 @@ enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
         if(codec_id == CODEC_ID_NONE)
             codec_id= fmt->video_codec;
         return codec_id;
-    }else if(type == CODEC_TYPE_AUDIO)
+    }else if(type == AVMEDIA_TYPE_AUDIO)
         return fmt->audio_codec;
     else
         return CODEC_ID_NONE;
@@ -351,25 +351,25 @@ static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeDa
                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
         if (!strcmp(fmt->name, "mp3")) {
             st->codec->codec_id = CODEC_ID_MP3;
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         } else if (!strcmp(fmt->name, "ac3")) {
             st->codec->codec_id = CODEC_ID_AC3;
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         } else if (!strcmp(fmt->name, "eac3")) {
             st->codec->codec_id = CODEC_ID_EAC3;
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         } else if (!strcmp(fmt->name, "mpegvideo")) {
             st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         } else if (!strcmp(fmt->name, "m4v")) {
             st->codec->codec_id = CODEC_ID_MPEG4;
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         } else if (!strcmp(fmt->name, "h264")) {
             st->codec->codec_id = CODEC_ID_H264;
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
         } else if (!strcmp(fmt->name, "dts")) {
             st->codec->codec_id = CODEC_ID_DTS;
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         }
     }
     return !!fmt;
@@ -646,13 +646,13 @@ int av_read_packet(AVFormatContext *s, AVPacket *pkt)
         st= s->streams[pkt->stream_index];
 
         switch(st->codec->codec_type){
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
             break;
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
             break;
-        case CODEC_TYPE_SUBTITLE:
+        case AVMEDIA_TYPE_SUBTITLE:
             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
             break;
         }
@@ -729,7 +729,7 @@ static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
     *pnum = 0;
     *pden = 0;
     switch(st->codec->codec_type) {
-    case CODEC_TYPE_VIDEO:
+    case AVMEDIA_TYPE_VIDEO:
         if(st->time_base.num*1000LL > st->time_base.den){
             *pnum = st->time_base.num;
             *pden = st->time_base.den;
@@ -741,7 +741,7 @@ static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
             }
         }
         break;
-    case CODEC_TYPE_AUDIO:
+    case AVMEDIA_TYPE_AUDIO:
         frame_size = get_audio_frame_size(st->codec, pkt->size);
         if (frame_size < 0)
             break;
@@ -754,9 +754,9 @@ static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
 }
 
 static int is_intra_only(AVCodecContext *enc){
-    if(enc->codec_type == CODEC_TYPE_AUDIO){
+    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
         return 1;
-    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
+    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
         switch(enc->codec_id){
         case CODEC_ID_MJPEG:
         case CODEC_ID_MJPEGB:
@@ -1223,10 +1223,10 @@ int av_find_default_stream_index(AVFormatContext *s)
         return -1;
     for(i = 0; i < s->nb_streams; i++) {
         st = s->streams[i];
-        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
             return i;
         }
-        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
+        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
             first_audio_index = i;
     }
     return first_audio_index >= 0 ? first_audio_index : 0;
@@ -1953,7 +1953,7 @@ static int has_codec_parameters(AVCodecContext *enc)
 {
     int val;
     switch(enc->codec_type) {
-    case CODEC_TYPE_AUDIO:
+    case AVMEDIA_TYPE_AUDIO:
         val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
         if(!enc->frame_size &&
            (enc->codec_id == CODEC_ID_VORBIS ||
@@ -1964,7 +1964,7 @@ static int has_codec_parameters(AVCodecContext *enc)
             enc->codec_id == CODEC_ID_SPEEX))
             return 0;
         break;
-    case CODEC_TYPE_VIDEO:
+    case AVMEDIA_TYPE_VIDEO:
         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
         break;
     default:
@@ -1992,12 +1992,12 @@ static int try_decode_frame(AVStream *st, AVPacket *avpkt)
 
     if(!has_codec_parameters(st->codec)){
         switch(st->codec->codec_type) {
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             avcodec_get_frame_defaults(&picture);
             ret = avcodec_decode_video2(st->codec, &picture,
                                         &got_picture, avpkt);
             break;
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
             samples = av_malloc(data_size);
             if (!samples)
@@ -2129,7 +2129,7 @@ int av_find_stream_info(AVFormatContext *ic)
             st->codec->frame_size = 0;
             st->codec->channels = 0;
         }
-        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
+        if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
 /*            if(!st->time_base.num)
                 st->time_base= */
             if(!st->codec->time_base.num)
@@ -2171,7 +2171,7 @@ int av_find_stream_info(AVFormatContext *ic)
                 break;
             /* variable fps and no guess at the real fps */
             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
-               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
+               && duration_count[i]<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
                 break;
             if(st->parser && st->parser->parser->split && !st->codec->extradata)
                 break;
@@ -2243,7 +2243,7 @@ int av_find_stream_info(AVFormatContext *ic)
             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
                 double dur= duration * av_q2d(st->time_base);
 
-//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
+//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
                 if(duration_count[index] < 2)
                     memset(duration_error[index], 0, sizeof(*duration_error));
@@ -2293,7 +2293,7 @@ int av_find_stream_info(AVFormatContext *ic)
             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
                       codec_info_duration[i]    *(int64_t)st->time_base.num, 60000);
-        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
 
@@ -2312,7 +2312,7 @@ int av_find_stream_info(AVFormatContext *ic)
 
                 for(j=1; j<MAX_STD_TIMEBASES; j++){
                     double error= duration_error[i][j] * get_std_framerate(j);
-//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
+//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
                     if(error < best_error){
                         best_error= error;
@@ -2334,7 +2334,7 @@ int av_find_stream_info(AVFormatContext *ic)
                     st->r_frame_rate.den = st->time_base.num;
                 }
             }
-        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
+        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
             if(!st->codec->bits_per_coded_sample)
                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
         }
@@ -2348,7 +2348,7 @@ int av_find_stream_info(AVFormatContext *ic)
     /* correct DTS for B-frame streams with no timestamps */
     for(i=0;i<ic->nb_streams;i++) {
         st = ic->streams[i];
-        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
             if(b-frames){
                 ppktl = &ic->packet_buffer;
                 while(ppkt1){
@@ -2581,7 +2581,7 @@ int av_write_header(AVFormatContext *s)
         st = s->streams[i];
 
         switch (st->codec->codec_type) {
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             if(st->codec->sample_rate<=0){
                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
                 return -1;
@@ -2590,7 +2590,7 @@ int av_write_header(AVFormatContext *s)
                 st->codec->block_align = st->codec->channels *
                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
             break;
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
                 av_log(s, AV_LOG_ERROR, "time base not set\n");
                 return -1;
@@ -2658,10 +2658,10 @@ int av_write_header(AVFormatContext *s)
         st = s->streams[i];
 
         switch (st->codec->codec_type) {
-        case CODEC_TYPE_AUDIO:
+        case AVMEDIA_TYPE_AUDIO:
             den = (int64_t)st->time_base.num * st->codec->sample_rate;
             break;
-        case CODEC_TYPE_VIDEO:
+        case AVMEDIA_TYPE_VIDEO:
             den = (int64_t)st->time_base.num * st->codec->time_base.den;
             break;
         default:
@@ -2732,7 +2732,7 @@ static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
 
     /* update pts */
     switch (st->codec->codec_type) {
-    case CODEC_TYPE_AUDIO:
+    case AVMEDIA_TYPE_AUDIO:
         frame_size = get_audio_frame_size(st->codec, pkt->size);
 
         /* HACK/FIXME, we skip the initial 0 size packets as they are most
@@ -2742,7 +2742,7 @@ static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
         }
         break;
-    case CODEC_TYPE_VIDEO:
+    case AVMEDIA_TYPE_VIDEO:
         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
         break;
     default:
@@ -2859,7 +2859,7 @@ int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
     AVStream *st= s->streams[ pkt->stream_index];
 
     //FIXME/XXX/HACK drop zero sized packets
-    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
+    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
         return 0;
 
 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
@@ -2999,7 +2999,7 @@ static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_out
                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
                  display_aspect_ratio.num, display_aspect_ratio.den);
     }
-    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
+    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
             print_fps(av_q2d(st->avg_frame_rate), "fps");
         if(st->r_frame_rate.den && st->r_frame_rate.num)
diff --git a/libavformat/vc1test.c b/libavformat/vc1test.c
index 11a4a6f4a72afe6639c3b48ec2241e984549d876..d47fe6af3287d4c688e9002926521875161fa5f7 100644
--- a/libavformat/vc1test.c
+++ b/libavformat/vc1test.c
@@ -58,7 +58,7 @@ static int vc1t_read_header(AVFormatContext *s,
     if (!st)
         return -1;
 
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_WMV3;
 
     st->codec->extradata = av_malloc(VC1_EXTRADATA_SIZE);
diff --git a/libavformat/vocdec.c b/libavformat/vocdec.c
index 246dbd91b4d8ee9e419e66e497990ee654190ee0..13d48f7397f41371b0fab1ba0b740e1ceae2f7e9 100644
--- a/libavformat/vocdec.c
+++ b/libavformat/vocdec.c
@@ -54,7 +54,7 @@ static int voc_read_header(AVFormatContext *s, AVFormatParameters *ap)
     st = av_new_stream(s, 0);
     if (!st)
         return AVERROR(ENOMEM);
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
 
     voc->remaining_size = 0;
     return 0;
diff --git a/libavformat/vocenc.c b/libavformat/vocenc.c
index 744b2337a050374fee6c6c263db3c9a6248c304c..f127c7e8263ea71b4641bf31495f903ed944c240 100644
--- a/libavformat/vocenc.c
+++ b/libavformat/vocenc.c
@@ -33,7 +33,7 @@ static int voc_write_header(AVFormatContext *s)
     const int version = 0x0114;
 
     if (s->nb_streams != 1
-        || s->streams[0]->codec->codec_type != CODEC_TYPE_AUDIO)
+        || s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
         return AVERROR_PATCHWELCOME;
 
     put_buffer(pb, ff_voc_magic, sizeof(ff_voc_magic) - 1);
diff --git a/libavformat/vqf.c b/libavformat/vqf.c
index 40fea471579011bf5b2dddb2e39ee17919269a2b..27890f84825ca67cf50a1de3f9a8b5958511aa10 100644
--- a/libavformat/vqf.c
+++ b/libavformat/vqf.c
@@ -76,7 +76,7 @@ static int vqf_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
     header_size = get_be32(s->pb);
 
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id   = CODEC_ID_TWINVQ;
     st->start_time = 0;
 
diff --git a/libavformat/wc3movie.c b/libavformat/wc3movie.c
index 502ff525649e577152f7feea172d7572918e2745..4138873573bd9dae7d74371986a3154d052fc4ea 100644
--- a/libavformat/wc3movie.c
+++ b/libavformat/wc3movie.c
@@ -243,7 +243,7 @@ static int wc3_read_header(AVFormatContext *s,
         return AVERROR(ENOMEM);
     av_set_pts_info(st, 33, 1, WC3_FRAME_FPS);
     wc3->video_stream_index = st->index;
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_XAN_WC3;
     st->codec->codec_tag = 0;  /* no fourcc */
     st->codec->width = wc3->width;
@@ -257,7 +257,7 @@ static int wc3_read_header(AVFormatContext *s,
         return AVERROR(ENOMEM);
     av_set_pts_info(st, 33, 1, WC3_FRAME_FPS);
     wc3->audio_stream_index = st->index;
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_PCM_S16LE;
     st->codec->codec_tag = 1;
     st->codec->channels = WC3_AUDIO_CHANNELS;
diff --git a/libavformat/westwood.c b/libavformat/westwood.c
index 7b016fdeda2b21d8404dabcd47e22781e9efcb8a..369d67a85e8cf0f53890a63692adcb9de18d4eb4 100644
--- a/libavformat/westwood.c
+++ b/libavformat/westwood.c
@@ -148,7 +148,7 @@ static int wsaud_read_header(AVFormatContext *s,
     if (!st)
         return AVERROR(ENOMEM);
     av_set_pts_info(st, 33, 1, wsaud->audio_samplerate);
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = wsaud->audio_type;
     st->codec->codec_tag = 0;  /* no tag */
     st->codec->channels = wsaud->audio_channels;
@@ -226,7 +226,7 @@ static int wsvqa_read_header(AVFormatContext *s,
         return AVERROR(ENOMEM);
     av_set_pts_info(st, 33, 1, VQA_FRAMERATE);
     wsvqa->video_stream_index = st->index;
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_WS_VQA;
     st->codec->codec_tag = 0;  /* no fourcc */
 
@@ -251,7 +251,7 @@ static int wsvqa_read_header(AVFormatContext *s,
         if (!st)
             return AVERROR(ENOMEM);
         av_set_pts_info(st, 33, 1, VQA_FRAMERATE);
-        st->codec->codec_type = CODEC_TYPE_AUDIO;
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
         if (AV_RL16(&header[0]) == 1)
             st->codec->codec_id = CODEC_ID_WESTWOOD_SND1;
         else
diff --git a/libavformat/wv.c b/libavformat/wv.c
index 6290a9941258b5e49da92867fac1916ca43fcd6f..03b864bdaf4ab086a4ffda92a01d1026046e429d 100644
--- a/libavformat/wv.c
+++ b/libavformat/wv.c
@@ -162,7 +162,7 @@ static int wv_read_header(AVFormatContext *s,
     st = av_new_stream(s, 0);
     if (!st)
         return -1;
-    st->codec->codec_type = CODEC_TYPE_AUDIO;
+    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id = CODEC_ID_WAVPACK;
     st->codec->channels = wc->chan;
     st->codec->sample_rate = wc->rate;
diff --git a/libavformat/xa.c b/libavformat/xa.c
index d9179df6b794da80d9b0b733dc5ff12dfcabf441..6576c527809d7afa18db79a2688aeb9665c224b5 100644
--- a/libavformat/xa.c
+++ b/libavformat/xa.c
@@ -74,7 +74,7 @@ static int xa_read_header(AVFormatContext *s,
     if (!st)
         return AVERROR(ENOMEM);
 
-    st->codec->codec_type   = CODEC_TYPE_AUDIO;
+    st->codec->codec_type   = AVMEDIA_TYPE_AUDIO;
     st->codec->codec_id     = CODEC_ID_ADPCM_EA_MAXIS_XA;
     url_fskip(pb, 4);       /* Skip the XA ID */
     xa->out_size            =  get_le32(pb);
diff --git a/libavformat/yop.c b/libavformat/yop.c
index 36c9369916008fc7dad9c7b20a72313aa27285e7..9c0e5822b55ec320bd246f6c349f5616ebe258ba 100644
--- a/libavformat/yop.c
+++ b/libavformat/yop.c
@@ -71,14 +71,14 @@ static int yop_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
     // Audio
     audio_dec               = audio_stream->codec;
-    audio_dec->codec_type   = CODEC_TYPE_AUDIO;
+    audio_dec->codec_type   = AVMEDIA_TYPE_AUDIO;
     audio_dec->codec_id     = CODEC_ID_ADPCM_IMA_WS;
     audio_dec->channels     = 1;
     audio_dec->sample_rate  = 22050;
 
     // Video
     video_dec               = video_stream->codec;
-    video_dec->codec_type   = CODEC_TYPE_VIDEO;
+    video_dec->codec_type   = AVMEDIA_TYPE_VIDEO;
     video_dec->codec_id     = CODEC_ID_YOP;
 
     url_fskip(pb, 6);
diff --git a/libavformat/yuv4mpeg.c b/libavformat/yuv4mpeg.c
index 8e7acebe7165e9f823f2c686c53c216ab31b3120..99a1ce2f385339ea27c5f12036764dcbfe8ea0d0 100644
--- a/libavformat/yuv4mpeg.c
+++ b/libavformat/yuv4mpeg.c
@@ -335,7 +335,7 @@ static int yuv4_read_header(AVFormatContext *s, AVFormatParameters *ap)
     av_reduce(&raten, &rated, raten, rated, (1UL<<31)-1);
     av_set_pts_info(st, 64, rated, raten);
     st->codec->pix_fmt = pix_fmt;
-    st->codec->codec_type = CODEC_TYPE_VIDEO;
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->codec_id = CODEC_ID_RAWVIDEO;
     st->sample_aspect_ratio= (AVRational){aspectn, aspectd};
     st->codec->chroma_sample_location = chroma_sample_location;