@@ -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:

@@ -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;

@@ -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();

@@ -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;