Merge commit '36ef5369ee9b336febc2c270f8718cec4476cb85'

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

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

Merged-by: Michael Niedermayer <michaelni@gmx.at>

1 files changed, 119 insertions, 119 deletions

diff --git a/libavcodec/utils.c b/libavcodec/utils.c
index 529d3ab6d0..d9ad10f021 100644
--- a/libavcodec/utils.c
+++ b/libavcodec/utils.c
@@ -234,25 +234,25 @@ void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
         h_align=8;
         break;
     case PIX_FMT_YUV410P:
-        if(s->codec_id == CODEC_ID_SVQ1){
+        if(s->codec_id == AV_CODEC_ID_SVQ1){
             w_align=64;
             h_align=64;
         }
     case PIX_FMT_RGB555:
-        if(s->codec_id == CODEC_ID_RPZA){
+        if(s->codec_id == AV_CODEC_ID_RPZA){
             w_align=4;
             h_align=4;
         }
     case PIX_FMT_PAL8:
     case PIX_FMT_BGR8:
     case PIX_FMT_RGB8:
-        if(s->codec_id == CODEC_ID_SMC){
+        if(s->codec_id == AV_CODEC_ID_SMC){
             w_align=4;
             h_align=4;
         }
         break;
     case PIX_FMT_BGR24:
-        if((s->codec_id == CODEC_ID_MSZH) || (s->codec_id == CODEC_ID_ZLIB)){
+        if((s->codec_id == AV_CODEC_ID_MSZH) || (s->codec_id == AV_CODEC_ID_ZLIB)){
             w_align=4;
             h_align=4;
         }
@@ -263,13 +263,13 @@ void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
         break;
     }
 
-    if(s->codec_id == CODEC_ID_IFF_ILBM || s->codec_id == CODEC_ID_IFF_BYTERUN1){
+    if(s->codec_id == AV_CODEC_ID_IFF_ILBM || s->codec_id == AV_CODEC_ID_IFF_BYTERUN1){
         w_align= FFMAX(w_align, 8);
     }
 
     *width = FFALIGN(*width , w_align);
     *height= FFALIGN(*height, h_align);
-    if(s->codec_id == CODEC_ID_H264 || s->lowres)
+    if(s->codec_id == AV_CODEC_ID_H264 || s->lowres)
         *height+=2; // some of the optimized chroma MC reads one line too much
                     // which is also done in mpeg decoders with lowres > 0
 
@@ -822,7 +822,7 @@ int attribute_align_arg avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVD
         }
 
     //We only call avcodec_set_dimensions() for non h264 codecs so as not to overwrite previously setup dimensions
-    if(!( avctx->coded_width && avctx->coded_height && avctx->width && avctx->height && avctx->codec_id == CODEC_ID_H264)){
+    if(!( avctx->coded_width && avctx->coded_height && avctx->width && avctx->height && avctx->codec_id == AV_CODEC_ID_H264)){
     if(avctx->coded_width && avctx->coded_height)
         avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
     else if(avctx->width && avctx->height)
@@ -849,7 +849,7 @@ int attribute_align_arg avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVD
 
     avctx->codec = codec;
     if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
-        avctx->codec_id == CODEC_ID_NONE) {
+        avctx->codec_id == AV_CODEC_ID_NONE) {
         avctx->codec_type = codec->type;
         avctx->codec_id   = codec->id;
     }
@@ -910,7 +910,7 @@ int attribute_align_arg avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVD
                 if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
                     break;
             if (avctx->codec->pix_fmts[i] == PIX_FMT_NONE
-                && !((avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG)
+                && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
                      && avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {
                 av_log(avctx, AV_LOG_ERROR, "Specified pix_fmt is not supported\n");
                 ret = AVERROR(EINVAL);
@@ -1771,17 +1771,17 @@ av_cold int avcodec_close(AVCodecContext *avctx)
     return 0;
 }
 
-static enum CodecID remap_deprecated_codec_id(enum CodecID id)
+static enum AVCodecID remap_deprecated_codec_id(enum AVCodecID id)
 {
     switch(id){
         //This is for future deprecatec codec ids, its empty since
         //last major bump but will fill up again over time, please don't remove it
-//         case CODEC_ID_UTVIDEO_DEPRECATED: return CODEC_ID_UTVIDEO;
+//         case AV_CODEC_ID_UTVIDEO_DEPRECATED: return AV_CODEC_ID_UTVIDEO;
         default                         : return id;
     }
 }
 
-AVCodec *avcodec_find_encoder(enum CodecID id)
+AVCodec *avcodec_find_encoder(enum AVCodecID id)
 {
     AVCodec *p, *experimental=NULL;
     p = first_avcodec;
@@ -1812,7 +1812,7 @@ AVCodec *avcodec_find_encoder_by_name(const char *name)
     return NULL;
 }
 
-AVCodec *avcodec_find_decoder(enum CodecID id)
+AVCodec *avcodec_find_decoder(enum AVCodecID id)
 {
     AVCodec *p, *experimental=NULL;
     p = first_avcodec;
@@ -1843,7 +1843,7 @@ AVCodec *avcodec_find_decoder_by_name(const char *name)
     return NULL;
 }
 
-const char *avcodec_get_name(enum CodecID id)
+const char *avcodec_get_name(enum AVCodecID id)
 {
     AVCodec *codec;
 
@@ -1994,11 +1994,11 @@ const char *av_get_profile_name(const AVCodec *codec, int profile)
 
 unsigned avcodec_version( void )
 {
-//    av_assert0(CODEC_ID_V410==164);
-    av_assert0(CODEC_ID_PCM_S8_PLANAR==65563);
-    av_assert0(CODEC_ID_ADPCM_G722==69660);
-//     av_assert0(CODEC_ID_BMV_AUDIO==86071);
-    av_assert0(CODEC_ID_SRT==94216);
+//    av_assert0(AV_CODEC_ID_V410==164);
+    av_assert0(AV_CODEC_ID_PCM_S8_PLANAR==65563);
+    av_assert0(AV_CODEC_ID_ADPCM_G722==69660);
+//     av_assert0(AV_CODEC_ID_BMV_AUDIO==86071);
+    av_assert0(AV_CODEC_ID_SRT==94216);
     av_assert0(LIBAVCODEC_VERSION_MICRO >= 100);
 
   return LIBAVCODEC_VERSION_INT;
@@ -2080,82 +2080,82 @@ void avcodec_default_free_buffers(AVCodecContext *avctx)
     }
 }
 
-int av_get_exact_bits_per_sample(enum CodecID codec_id)
+int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
 {
     switch(codec_id){
-    case CODEC_ID_ADPCM_CT:
-    case CODEC_ID_ADPCM_IMA_APC:
-    case CODEC_ID_ADPCM_IMA_EA_SEAD:
-    case CODEC_ID_ADPCM_IMA_WS:
-    case CODEC_ID_ADPCM_G722:
-    case CODEC_ID_ADPCM_YAMAHA:
+    case AV_CODEC_ID_ADPCM_CT:
+    case AV_CODEC_ID_ADPCM_IMA_APC:
+    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
+    case AV_CODEC_ID_ADPCM_IMA_WS:
+    case AV_CODEC_ID_ADPCM_G722:
+    case AV_CODEC_ID_ADPCM_YAMAHA:
         return 4;
-    case CODEC_ID_PCM_ALAW:
-    case CODEC_ID_PCM_MULAW:
-    case CODEC_ID_PCM_S8:
-    case CODEC_ID_PCM_U8:
-    case CODEC_ID_PCM_ZORK:
+    case AV_CODEC_ID_PCM_ALAW:
+    case AV_CODEC_ID_PCM_MULAW:
+    case AV_CODEC_ID_PCM_S8:
+    case AV_CODEC_ID_PCM_U8:
+    case AV_CODEC_ID_PCM_ZORK:
         return 8;
-    case CODEC_ID_PCM_S16BE:
-    case CODEC_ID_PCM_S16LE:
-    case CODEC_ID_PCM_S16LE_PLANAR:
-    case CODEC_ID_PCM_U16BE:
-    case CODEC_ID_PCM_U16LE:
+    case AV_CODEC_ID_PCM_S16BE:
+    case AV_CODEC_ID_PCM_S16LE:
+    case AV_CODEC_ID_PCM_S16LE_PLANAR:
+    case AV_CODEC_ID_PCM_U16BE:
+    case AV_CODEC_ID_PCM_U16LE:
         return 16;
-    case CODEC_ID_PCM_S24DAUD:
-    case CODEC_ID_PCM_S24BE:
-    case CODEC_ID_PCM_S24LE:
-    case CODEC_ID_PCM_U24BE:
-    case CODEC_ID_PCM_U24LE:
+    case AV_CODEC_ID_PCM_S24DAUD:
+    case AV_CODEC_ID_PCM_S24BE:
+    case AV_CODEC_ID_PCM_S24LE:
+    case AV_CODEC_ID_PCM_U24BE:
+    case AV_CODEC_ID_PCM_U24LE:
         return 24;
-    case CODEC_ID_PCM_S32BE:
-    case CODEC_ID_PCM_S32LE:
-    case CODEC_ID_PCM_U32BE:
-    case CODEC_ID_PCM_U32LE:
-    case CODEC_ID_PCM_F32BE:
-    case CODEC_ID_PCM_F32LE:
+    case AV_CODEC_ID_PCM_S32BE:
+    case AV_CODEC_ID_PCM_S32LE:
+    case AV_CODEC_ID_PCM_U32BE:
+    case AV_CODEC_ID_PCM_U32LE:
+    case AV_CODEC_ID_PCM_F32BE:
+    case AV_CODEC_ID_PCM_F32LE:
         return 32;
-    case CODEC_ID_PCM_F64BE:
-    case CODEC_ID_PCM_F64LE:
+    case AV_CODEC_ID_PCM_F64BE:
+    case AV_CODEC_ID_PCM_F64LE:
         return 64;
     default:
         return 0;
     }
 }
 
-enum CodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
+enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
 {
-    static const enum CodecID map[AV_SAMPLE_FMT_NB][2] = {
-        [AV_SAMPLE_FMT_U8  ] = { CODEC_ID_PCM_U8,    CODEC_ID_PCM_U8    },
-        [AV_SAMPLE_FMT_S16 ] = { CODEC_ID_PCM_S16LE, CODEC_ID_PCM_S16BE },
-        [AV_SAMPLE_FMT_S32 ] = { CODEC_ID_PCM_S32LE, CODEC_ID_PCM_S32BE },
-        [AV_SAMPLE_FMT_FLT ] = { CODEC_ID_PCM_F32LE, CODEC_ID_PCM_F32BE },
-        [AV_SAMPLE_FMT_DBL ] = { CODEC_ID_PCM_F64LE, CODEC_ID_PCM_F64BE },
-        [AV_SAMPLE_FMT_U8P ] = { CODEC_ID_PCM_U8,    CODEC_ID_PCM_U8    },
-        [AV_SAMPLE_FMT_S16P] = { CODEC_ID_PCM_S16LE, CODEC_ID_PCM_S16BE },
-        [AV_SAMPLE_FMT_S32P] = { CODEC_ID_PCM_S32LE, CODEC_ID_PCM_S32BE },
-        [AV_SAMPLE_FMT_FLTP] = { CODEC_ID_PCM_F32LE, CODEC_ID_PCM_F32BE },
-        [AV_SAMPLE_FMT_DBLP] = { CODEC_ID_PCM_F64LE, CODEC_ID_PCM_F64BE },
+    static const enum AVCodecID map[AV_SAMPLE_FMT_NB][2] = {
+        [AV_SAMPLE_FMT_U8  ] = { AV_CODEC_ID_PCM_U8,    AV_CODEC_ID_PCM_U8    },
+        [AV_SAMPLE_FMT_S16 ] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
+        [AV_SAMPLE_FMT_S32 ] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
+        [AV_SAMPLE_FMT_FLT ] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
+        [AV_SAMPLE_FMT_DBL ] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
+        [AV_SAMPLE_FMT_U8P ] = { AV_CODEC_ID_PCM_U8,    AV_CODEC_ID_PCM_U8    },
+        [AV_SAMPLE_FMT_S16P] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
+        [AV_SAMPLE_FMT_S32P] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
+        [AV_SAMPLE_FMT_FLTP] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
+        [AV_SAMPLE_FMT_DBLP] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
     };
     if (fmt < 0 || fmt >= AV_SAMPLE_FMT_NB)
-        return CODEC_ID_NONE;
+        return AV_CODEC_ID_NONE;
     if (be < 0 || be > 1)
         be = AV_NE(1, 0);
     return map[fmt][be];
 }
 
-int av_get_bits_per_sample(enum CodecID codec_id)
+int av_get_bits_per_sample(enum AVCodecID codec_id)
 {
     switch (codec_id) {
-    case CODEC_ID_ADPCM_SBPRO_2:
+    case AV_CODEC_ID_ADPCM_SBPRO_2:
         return 2;
-    case CODEC_ID_ADPCM_SBPRO_3:
+    case AV_CODEC_ID_ADPCM_SBPRO_3:
         return 3;
-    case CODEC_ID_ADPCM_SBPRO_4:
-    case CODEC_ID_ADPCM_IMA_WAV:
-    case CODEC_ID_ADPCM_IMA_QT:
-    case CODEC_ID_ADPCM_SWF:
-    case CODEC_ID_ADPCM_MS:
+    case AV_CODEC_ID_ADPCM_SBPRO_4:
+    case AV_CODEC_ID_ADPCM_IMA_WAV:
+    case AV_CODEC_ID_ADPCM_IMA_QT:
+    case AV_CODEC_ID_ADPCM_SWF:
+    case AV_CODEC_ID_ADPCM_MS:
         return 4;
     default:
         return av_get_exact_bits_per_sample(codec_id);
@@ -2180,47 +2180,47 @@ int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
 
     /* codecs with a fixed packet duration */
     switch (id) {
-    case CODEC_ID_ADPCM_ADX:    return   32;
-    case CODEC_ID_ADPCM_IMA_QT: return   64;
-    case CODEC_ID_ADPCM_EA_XAS: return  128;
-    case CODEC_ID_AMR_NB:
-    case CODEC_ID_GSM:
-    case CODEC_ID_QCELP:
-    case CODEC_ID_RA_144:
-    case CODEC_ID_RA_288:       return  160;
-    case CODEC_ID_IMC:          return  256;
-    case CODEC_ID_AMR_WB:
-    case CODEC_ID_GSM_MS:       return  320;
-    case CODEC_ID_MP1:          return  384;
-    case CODEC_ID_ATRAC1:       return  512;
-    case CODEC_ID_ATRAC3:       return 1024;
-    case CODEC_ID_MP2:
-    case CODEC_ID_MUSEPACK7:    return 1152;
-    case CODEC_ID_AC3:          return 1536;
+    case AV_CODEC_ID_ADPCM_ADX:    return   32;
+    case AV_CODEC_ID_ADPCM_IMA_QT: return   64;
+    case AV_CODEC_ID_ADPCM_EA_XAS: return  128;
+    case AV_CODEC_ID_AMR_NB:
+    case AV_CODEC_ID_GSM:
+    case AV_CODEC_ID_QCELP:
+    case AV_CODEC_ID_RA_144:
+    case AV_CODEC_ID_RA_288:       return  160;
+    case AV_CODEC_ID_IMC:          return  256;
+    case AV_CODEC_ID_AMR_WB:
+    case AV_CODEC_ID_GSM_MS:       return  320;
+    case AV_CODEC_ID_MP1:          return  384;
+    case AV_CODEC_ID_ATRAC1:       return  512;
+    case AV_CODEC_ID_ATRAC3:       return 1024;
+    case AV_CODEC_ID_MP2:
+    case AV_CODEC_ID_MUSEPACK7:    return 1152;
+    case AV_CODEC_ID_AC3:          return 1536;
     }
 
     if (sr > 0) {
         /* calc from sample rate */
-        if (id == CODEC_ID_TTA)
+        if (id == AV_CODEC_ID_TTA)
             return 256 * sr / 245;
 
         if (ch > 0) {
             /* calc from sample rate and channels */
-            if (id == CODEC_ID_BINKAUDIO_DCT)
+            if (id == AV_CODEC_ID_BINKAUDIO_DCT)
                 return (480 << (sr / 22050)) / ch;
         }
     }
 
     if (ba > 0) {
         /* calc from block_align */
-        if (id == CODEC_ID_SIPR) {
+        if (id == AV_CODEC_ID_SIPR) {
             switch (ba) {
             case 20: return 160;
             case 19: return 144;
             case 29: return 288;
             case 37: return 480;
             }
-        } else if (id == CODEC_ID_ILBC) {
+        } else if (id == AV_CODEC_ID_ILBC) {
             switch (ba) {
             case 38: return 160;
             case 50: return 240;
@@ -2230,46 +2230,46 @@ int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
 
     if (frame_bytes > 0) {
         /* calc from frame_bytes only */
-        if (id == CODEC_ID_TRUESPEECH)
+        if (id == AV_CODEC_ID_TRUESPEECH)
             return 240 * (frame_bytes / 32);
-        if (id == CODEC_ID_NELLYMOSER)
+        if (id == AV_CODEC_ID_NELLYMOSER)
             return 256 * (frame_bytes / 64);
 
         if (bps > 0) {
             /* calc from frame_bytes and bits_per_coded_sample */
-            if (id == CODEC_ID_ADPCM_G726)
+            if (id == AV_CODEC_ID_ADPCM_G726)
                 return frame_bytes * 8 / bps;
         }
 
         if (ch > 0) {
             /* calc from frame_bytes and channels */
             switch (id) {
-            case CODEC_ID_ADPCM_4XM:
-            case CODEC_ID_ADPCM_IMA_ISS:
+            case AV_CODEC_ID_ADPCM_4XM:
+            case AV_CODEC_ID_ADPCM_IMA_ISS:
                 return (frame_bytes - 4 * ch) * 2 / ch;
-            case CODEC_ID_ADPCM_IMA_SMJPEG:
+            case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
                 return (frame_bytes - 4) * 2 / ch;
-            case CODEC_ID_ADPCM_IMA_AMV:
+            case AV_CODEC_ID_ADPCM_IMA_AMV:
                 return (frame_bytes - 8) * 2 / ch;
-            case CODEC_ID_ADPCM_XA:
+            case AV_CODEC_ID_ADPCM_XA:
                 return (frame_bytes / 128) * 224 / ch;
-            case CODEC_ID_INTERPLAY_DPCM:
+            case AV_CODEC_ID_INTERPLAY_DPCM:
                 return (frame_bytes - 6 - ch) / ch;
-            case CODEC_ID_ROQ_DPCM:
+            case AV_CODEC_ID_ROQ_DPCM:
                 return (frame_bytes - 8) / ch;
-            case CODEC_ID_XAN_DPCM:
+            case AV_CODEC_ID_XAN_DPCM:
                 return (frame_bytes - 2 * ch) / ch;
-            case CODEC_ID_MACE3:
+            case AV_CODEC_ID_MACE3:
                 return 3 * frame_bytes / ch;
-            case CODEC_ID_MACE6:
+            case AV_CODEC_ID_MACE6:
                 return 6 * frame_bytes / ch;
-            case CODEC_ID_PCM_LXF:
+            case AV_CODEC_ID_PCM_LXF:
                 return 2 * (frame_bytes / (5 * ch));
             }
 
             if (tag) {
                 /* calc from frame_bytes, channels, and codec_tag */
-                if (id == CODEC_ID_SOL_DPCM) {
+                if (id == AV_CODEC_ID_SOL_DPCM) {
                     if (tag == 3)
                         return frame_bytes / ch;
                     else
@@ -2281,13 +2281,13 @@ int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
                 /* calc from frame_bytes, channels, and block_align */
                 int blocks = frame_bytes / ba;
                 switch (avctx->codec_id) {
-                case CODEC_ID_ADPCM_IMA_WAV:
+                case AV_CODEC_ID_ADPCM_IMA_WAV:
                     return blocks * (1 + (ba - 4 * ch) / (4 * ch) * 8);
-                case CODEC_ID_ADPCM_IMA_DK3:
+                case AV_CODEC_ID_ADPCM_IMA_DK3:
                     return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
-                case CODEC_ID_ADPCM_IMA_DK4:
+                case AV_CODEC_ID_ADPCM_IMA_DK4:
                     return blocks * (1 + (ba - 4 * ch) * 2 / ch);
-                case CODEC_ID_ADPCM_MS:
+                case AV_CODEC_ID_ADPCM_MS:
                     return blocks * (2 + (ba - 7 * ch) * 2 / ch);
                 }
             }
@@ -2295,15 +2295,15 @@ int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
             if (bps > 0) {
                 /* calc from frame_bytes, channels, and bits_per_coded_sample */
                 switch (avctx->codec_id) {
-                case CODEC_ID_PCM_DVD:
+                case AV_CODEC_ID_PCM_DVD:
                     if(bps<4)
                         return 0;
                     return 2 * (frame_bytes / ((bps * 2 / 8) * ch));
-                case CODEC_ID_PCM_BLURAY:
+                case AV_CODEC_ID_PCM_BLURAY:
                     if(bps<4)
                         return 0;
                     return frame_bytes / ((FFALIGN(ch, 2) * bps) / 8);
-                case CODEC_ID_S302M:
+                case AV_CODEC_ID_S302M:
                     return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
                 }
             }
@@ -2380,7 +2380,7 @@ AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel)
     return hwaccel ? hwaccel->next : first_hwaccel;
 }
 
-AVHWAccel *ff_find_hwaccel(enum CodecID codec_id, enum PixelFormat pix_fmt)
+AVHWAccel *ff_find_hwaccel(enum AVCodecID codec_id, enum PixelFormat pix_fmt)
 {
     AVHWAccel *hwaccel=NULL;
 
@@ -2473,7 +2473,7 @@ int ff_thread_can_start_frame(AVCodecContext *avctx)
 
 #endif
 
-enum AVMediaType avcodec_get_type(enum CodecID codec_id)
+enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
 {
     AVCodec *c= avcodec_find_decoder(codec_id);
     if(!c)
@@ -2481,13 +2481,13 @@ enum AVMediaType avcodec_get_type(enum CodecID codec_id)
     if(c)
         return c->type;
 
-    if (codec_id <= CODEC_ID_NONE)
+    if (codec_id <= AV_CODEC_ID_NONE)
         return AVMEDIA_TYPE_UNKNOWN;
-    else if (codec_id < CODEC_ID_FIRST_AUDIO)
+    else if (codec_id < AV_CODEC_ID_FIRST_AUDIO)
         return AVMEDIA_TYPE_VIDEO;
-    else if (codec_id < CODEC_ID_FIRST_SUBTITLE)
+    else if (codec_id < AV_CODEC_ID_FIRST_SUBTITLE)
         return AVMEDIA_TYPE_AUDIO;
-    else if (codec_id < CODEC_ID_FIRST_UNKNOWN)
+    else if (codec_id < AV_CODEC_ID_FIRST_UNKNOWN)
         return AVMEDIA_TYPE_SUBTITLE;
 
     return AVMEDIA_TYPE_UNKNOWN;