Replace all CODEC_ID_* with AV_CODEC_ID_*

1 files changed, 96 insertions, 96 deletions

diff --git a/libavcodec/utils.c b/libavcodec/utils.c
index 514a1f5569..43a8f67934 100644
--- a/libavcodec/utils.c
+++ b/libavcodec/utils.c
@@ -197,25 +197,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;
         }
@@ -228,7 +228,7 @@ void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
 
     *width = FFALIGN(*width , w_align);
     *height= FFALIGN(*height, h_align);
-    if (s->codec_id == CODEC_ID_H264)
+    if (s->codec_id == AV_CODEC_ID_H264)
         *height+=2; // some of the optimized chroma MC reads one line too much
 
     for (i = 0; i < 4; i++)
@@ -717,7 +717,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;
     }
@@ -1410,7 +1410,7 @@ av_cold int avcodec_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec *avcodec_find_encoder(enum CodecID id)
+AVCodec *avcodec_find_encoder(enum AVCodecID id)
 {
     AVCodec *p, *experimental=NULL;
     p = first_avcodec;
@@ -1440,7 +1440,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;
     p = first_avcodec;
@@ -1523,7 +1523,7 @@ void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
     if (p) {
         codec_name = p->name;
         profile = av_get_profile_name(p, enc->profile);
-    } else if (enc->codec_id == CODEC_ID_MPEG2TS) {
+    } else if (enc->codec_id == AV_CODEC_ID_MPEG2TS) {
         /* fake mpeg2 transport stream codec (currently not
            registered) */
         codec_name = "mpeg2ts";
@@ -1713,61 +1713,61 @@ 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;
     }
 }
 
-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);
@@ -1792,47 +1792,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;
@@ -1842,46 +1842,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
@@ -1893,13 +1893,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);
                 }
             }
@@ -1907,11 +1907,11 @@ 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:
                     return 2 * (frame_bytes / ((bps * 2 / 8) * ch));
-                case CODEC_ID_PCM_BLURAY:
+                case AV_CODEC_ID_PCM_BLURAY:
                     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;
                 }
             }
@@ -1988,7 +1988,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;
 
@@ -2073,15 +2073,15 @@ void ff_thread_await_progress(AVFrame *f, int progress, int field)
 
 #endif
 
-enum AVMediaType avcodec_get_type(enum CodecID codec_id)
+enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
 {
-    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;