Update ffmpeg

9 files changed, 176 insertions, 176 deletions

diff --git a/decoder/LAVAudio/Bitstream.cpp b/decoder/LAVAudio/Bitstream.cpp
index 246168fa..7134f6b5 100644
--- a/decoder/LAVAudio/Bitstream.cpp
+++ b/decoder/LAVAudio/Bitstream.cpp
@@ -27,17 +27,17 @@
 #define LAV_BITSTREAM_DTS_HD_RATE 768000
 
 static struct {
-  CodecID codec;
+  AVCodecID codec;
   LAVBitstreamCodec config;
 } lavf_bitstream_config[] = {
-  { CODEC_ID_AC3,    Bitstream_AC3 },
-  { CODEC_ID_EAC3,   Bitstream_EAC3 },
-  { CODEC_ID_TRUEHD, Bitstream_TRUEHD },
-  { CODEC_ID_DTS,    Bitstream_DTS } // DTS-HD is still DTS, and handled special below
+  { AV_CODEC_ID_AC3,    Bitstream_AC3 },
+  { AV_CODEC_ID_EAC3,   Bitstream_EAC3 },
+  { AV_CODEC_ID_TRUEHD, Bitstream_TRUEHD },
+  { AV_CODEC_ID_DTS,    Bitstream_DTS } // DTS-HD is still DTS, and handled special below
 };
 
 // Check wether a codec is bitstreaming eligible and enabled
-BOOL CLAVAudio::IsBitstreaming(CodecID codec)
+BOOL CLAVAudio::IsBitstreaming(AVCodecID codec)
 {
   for(int i = 0; i < countof(lavf_bitstream_config); ++i) {
     if (lavf_bitstream_config[i].codec == codec) {
@@ -81,7 +81,7 @@ int CLAVAudio::BSWriteBuffer(void *opaque, uint8_t *buf, int buf_size)
   return buf_size;
 }
 
-HRESULT CLAVAudio::CreateBitstreamContext(CodecID codec, WAVEFORMATEX *wfe)
+HRESULT CLAVAudio::CreateBitstreamContext(AVCodecID codec, WAVEFORMATEX *wfe)
 {
   int ret = 0;
 
@@ -90,7 +90,7 @@ HRESULT CLAVAudio::CreateBitstreamContext(CodecID codec, WAVEFORMATEX *wfe)
   m_bsParser.Reset();
 
   // Increase DTS buffer even further, as we do not have any sample caching
-  if (codec == CODEC_ID_DTS)
+  if (codec == AV_CODEC_ID_DTS)
     m_faJitter.SetNumSamples(400);
   else
     m_faJitter.SetNumSamples(100);
@@ -210,7 +210,7 @@ HRESULT CLAVAudio::FreeBitstreamContext()
   return S_OK;
 }
 
-CMediaType CLAVAudio::CreateBitstreamMediaType(CodecID codec, DWORD dwSampleRate)
+CMediaType CLAVAudio::CreateBitstreamMediaType(AVCodecID codec, DWORD dwSampleRate)
 {
    CMediaType mt;
 
@@ -229,21 +229,21 @@ CMediaType CLAVAudio::CreateBitstreamMediaType(CodecID codec, DWORD dwSampleRate
    GUID subtype = GUID_NULL;
 
    switch(codec) {
-   case CODEC_ID_AC3:
+   case AV_CODEC_ID_AC3:
      wfe->wFormatTag     = WAVE_FORMAT_DOLBY_AC3_SPDIF;
      wfe->nSamplesPerSec = min(dwSampleRate, 48000);
      break;
-   case CODEC_ID_EAC3:
+   case AV_CODEC_ID_EAC3:
      wfe->nSamplesPerSec = 192000;
      wfe->nChannels      = 2;
      subtype = KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_DIGITAL_PLUS;
      break;
-   case CODEC_ID_TRUEHD:
+   case AV_CODEC_ID_TRUEHD:
      wfe->nSamplesPerSec = 192000;
      wfe->nChannels      = 8;
      subtype = KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_MLP;
      break;
-   case CODEC_ID_DTS:
+   case AV_CODEC_ID_DTS:
      if (m_settings.bBitstream[Bitstream_DTSHD] && m_bDTSHD) {
        wfe->nSamplesPerSec = 192000;
        wfe->nChannels      = 8;
@@ -333,7 +333,7 @@ HRESULT CLAVAudio::Bitstream(const BYTE *buffer, int buffsize, int &consumed, HR
 
     if (pOut_size > 0) {
       m_bsParser.Parse(m_nCodecId, pOut, pOut_size, m_pParser->priv_data);
-      if (m_nCodecId == CODEC_ID_DTS && !m_bDTSHD && m_bsParser.m_bDTSHD && m_settings.bBitstream[Bitstream_DTSHD]) {
+      if (m_nCodecId == AV_CODEC_ID_DTS && !m_bDTSHD && m_bsParser.m_bDTSHD && m_settings.bBitstream[Bitstream_DTSHD]) {
         ActivateDTSHDMuxing();
       }
 
@@ -366,7 +366,7 @@ HRESULT CLAVAudio::Bitstream(const BYTE *buffer, int buffsize, int &consumed, HR
   return S_OK;
 }
 
-HRESULT CLAVAudio::DeliverBitstream(CodecID codec, const BYTE *buffer, DWORD dwSize, DWORD dwFrameSize, REFERENCE_TIME rtStartInput, REFERENCE_TIME rtStopInput)
+HRESULT CLAVAudio::DeliverBitstream(AVCodecID codec, const BYTE *buffer, DWORD dwSize, DWORD dwFrameSize, REFERENCE_TIME rtStartInput, REFERENCE_TIME rtStopInput)
 {
   HRESULT hr = S_OK;
 
@@ -393,7 +393,7 @@ HRESULT CLAVAudio::DeliverBitstream(CodecID codec, const BYTE *buffer, DWORD dwS
   REFERENCE_TIME rtStart = m_rtStart, rtStop = AV_NOPTS_VALUE, rtDur = AV_NOPTS_VALUE;
   // TrueHD timings
   // Since the SPDIF muxer takes 24 frames and puts them into one IEC61937 frame, we use the cached timestamp from before.
-  if (codec == CODEC_ID_TRUEHD) {
+  if (codec == AV_CODEC_ID_TRUEHD) {
     // long-term cache is valid
     if (m_rtBitstreamCache != AV_NOPTS_VALUE)
       rtStart = m_rtBitstreamCache;
@@ -406,7 +406,7 @@ HRESULT CLAVAudio::DeliverBitstream(CodecID codec, const BYTE *buffer, DWORD dwS
   } else {
     double dDuration = 0;
     // E-AC3 trusts the incoming timestamps until a better solution can be found
-    if (codec == CODEC_ID_EAC3) {
+    if (codec == AV_CODEC_ID_EAC3) {
       if (rtStartInput != AV_NOPTS_VALUE && rtStopInput != AV_NOPTS_VALUE) {
         rtStart = rtStartInput;
         rtDur = rtStopInput - rtStartInput;
diff --git a/decoder/LAVAudio/BitstreamParser.cpp b/decoder/LAVAudio/BitstreamParser.cpp
index ed8fc82c..1401a311 100644
--- a/decoder/LAVAudio/BitstreamParser.cpp
+++ b/decoder/LAVAudio/BitstreamParser.cpp
@@ -48,12 +48,12 @@ void CBitstreamParser::Reset()
 }
 
 
-HRESULT CBitstreamParser::Parse(CodecID codec, BYTE *pBuffer, DWORD dwSize, void *pParserContext)
+HRESULT CBitstreamParser::Parse(AVCodecID codec, BYTE *pBuffer, DWORD dwSize, void *pParserContext)
 {
   switch (codec) {
-  case CODEC_ID_DTS:
+  case AV_CODEC_ID_DTS:
     return ParseDTS(pBuffer, dwSize);
-  case CODEC_ID_AC3:
+  case AV_CODEC_ID_AC3:
     return ParseAC3(pBuffer, dwSize, pParserContext);
   }
   return S_OK;
diff --git a/decoder/LAVAudio/BitstreamParser.h b/decoder/LAVAudio/BitstreamParser.h
index 61e57e05..0a1b8cc3 100644
--- a/decoder/LAVAudio/BitstreamParser.h
+++ b/decoder/LAVAudio/BitstreamParser.h
@@ -28,7 +28,7 @@ public:
   CBitstreamParser();
   ~CBitstreamParser();
 
-  HRESULT Parse(CodecID codec, BYTE *pBuffer, DWORD dwSize, void *pParserContext);
+  HRESULT Parse(AVCodecID codec, BYTE *pBuffer, DWORD dwSize, void *pParserContext);
   void Reset();
 
 private:
diff --git a/decoder/LAVAudio/DTSDecoder.cpp b/decoder/LAVAudio/DTSDecoder.cpp
index 97f77004..f3100ada 100644
--- a/decoder/LAVAudio/DTSDecoder.cpp
+++ b/decoder/LAVAudio/DTSDecoder.cpp
@@ -335,7 +335,7 @@ HRESULT CLAVAudio::DecodeDTS(const BYTE * const buffer, int buffsize, int &consu
 
     if (pOut && pOut_size > 0) {
       // Parse DTS headers
-      m_bsParser.Parse(CODEC_ID_DTS, pOut, pOut_size, NULL);
+      m_bsParser.Parse(AV_CODEC_ID_DTS, pOut, pOut_size, NULL);
       unsigned decode_channels = dts_determine_decode_channels(m_bsParser.m_DTSHeader);
 
       // Init Decoder with new Parameters, if required
diff --git a/decoder/LAVAudio/LAVAudio.cpp b/decoder/LAVAudio/LAVAudio.cpp
index b6f91627..a677e6d8 100644
--- a/decoder/LAVAudio/LAVAudio.cpp
+++ b/decoder/LAVAudio/LAVAudio.cpp
@@ -50,7 +50,7 @@ extern HINSTANCE g_hInst;
 // Constructor
 CLAVAudio::CLAVAudio(LPUNKNOWN pUnk, HRESULT* phr)
   : CTransformFilter(NAME("lavc audio decoder"), 0, __uuidof(CLAVAudio))
-  , m_nCodecId(CODEC_ID_NONE)
+  , m_nCodecId(AV_CODEC_ID_NONE)
   , m_pAVCodec(NULL)
   , m_pAVCtx(NULL)
   , m_pFrame(NULL)
@@ -399,7 +399,7 @@ void CLAVAudio::ffmpeg_shutdown()
 
   FreeDTSDecoder();
 
-  m_nCodecId = CODEC_ID_NONE;
+  m_nCodecId = AV_CODEC_ID_NONE;
 }
 
 // IUnknown
@@ -1073,13 +1073,13 @@ HRESULT CLAVAudio::DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERT
     : NOERROR;
 }
 
-HRESULT CLAVAudio::ffmpeg_init(CodecID codec, const void *format, const GUID format_type, DWORD formatlen)
+HRESULT CLAVAudio::ffmpeg_init(AVCodecID codec, const void *format, const GUID format_type, DWORD formatlen)
 {
   CAutoLock lock(&m_csReceive);
   ffmpeg_shutdown();
   DbgLog((LOG_TRACE, 10, "::ffmpeg_init(): Initializing decoder for codec %d", codec));
 
-  if (codec == CODEC_ID_DTS || codec == CODEC_ID_TRUEHD) {
+  if (codec == AV_CODEC_ID_DTS || codec == AV_CODEC_ID_TRUEHD) {
     m_faJitter.SetNumSamples(200);
     m_JitterLimit = MAX_JITTER_DESYNC * 10;
   } else {
@@ -1088,32 +1088,32 @@ HRESULT CLAVAudio::ffmpeg_init(CodecID codec, const void *format, const GUID for
   }
 
   // Fake codecs that are dependant in input bits per sample, mostly to handle QT PCM tracks
-  if (codec == CODEC_ID_PCM_QTRAW || codec == CODEC_ID_PCM_SxxBE || codec == CODEC_ID_PCM_SxxLE || codec == CODEC_ID_PCM_UxxBE || codec == CODEC_ID_PCM_UxxLE) {
+  if (codec == AV_CODEC_ID_PCM_QTRAW || codec == AV_CODEC_ID_PCM_SxxBE || codec == AV_CODEC_ID_PCM_SxxLE || codec == AV_CODEC_ID_PCM_UxxBE || codec == AV_CODEC_ID_PCM_UxxLE) {
     if (format_type == FORMAT_WaveFormatEx) {
       WAVEFORMATEX *wfein = (WAVEFORMATEX *)format;
       ASSERT(wfein->wBitsPerSample == 8 || wfein->wBitsPerSample == 16);
       switch(codec) {
-      case CODEC_ID_PCM_QTRAW:
-        codec = wfein->wBitsPerSample == 8 ? CODEC_ID_PCM_U8 : CODEC_ID_PCM_S16BE;
+      case AV_CODEC_ID_PCM_QTRAW:
+        codec = wfein->wBitsPerSample == 8 ? AV_CODEC_ID_PCM_U8 : AV_CODEC_ID_PCM_S16BE;
         break;
-      case CODEC_ID_PCM_SxxBE:
-        codec = wfein->wBitsPerSample == 8 ? CODEC_ID_PCM_S8 : CODEC_ID_PCM_S16BE;
+      case AV_CODEC_ID_PCM_SxxBE:
+        codec = wfein->wBitsPerSample == 8 ? AV_CODEC_ID_PCM_S8 : AV_CODEC_ID_PCM_S16BE;
         break;
-      case CODEC_ID_PCM_SxxLE:
-        codec = wfein->wBitsPerSample == 8 ? CODEC_ID_PCM_S8 : CODEC_ID_PCM_S16LE;
+      case AV_CODEC_ID_PCM_SxxLE:
+        codec = wfein->wBitsPerSample == 8 ? AV_CODEC_ID_PCM_S8 : AV_CODEC_ID_PCM_S16LE;
         break;
-      case CODEC_ID_PCM_UxxBE:
-        codec = wfein->wBitsPerSample == 8 ? CODEC_ID_PCM_U8 : CODEC_ID_PCM_U16BE;
+      case AV_CODEC_ID_PCM_UxxBE:
+        codec = wfein->wBitsPerSample == 8 ? AV_CODEC_ID_PCM_U8 : AV_CODEC_ID_PCM_U16BE;
         break;
-      case CODEC_ID_PCM_UxxLE:
-        codec = wfein->wBitsPerSample == 8 ? CODEC_ID_PCM_U8 : CODEC_ID_PCM_U16LE;
+      case AV_CODEC_ID_PCM_UxxLE:
+        codec = wfein->wBitsPerSample == 8 ? AV_CODEC_ID_PCM_U8 : AV_CODEC_ID_PCM_U16LE;
         break;
       }
     }
   }
 
   // Special check for enabled PCM
-  if (codec >= 0x10000 && codec < 0x12000 && codec != CODEC_ID_PCM_BLURAY && codec != CODEC_ID_PCM_DVD && !m_settings.bFormats[Codec_PCM])
+  if (codec >= 0x10000 && codec < 0x12000 && codec != AV_CODEC_ID_PCM_BLURAY && codec != AV_CODEC_ID_PCM_DVD && !m_settings.bFormats[Codec_PCM])
     return VFW_E_UNSUPPORTED_AUDIO;
 
   for(int i = 0; i < Codec_NB; ++i) {
@@ -1130,11 +1130,11 @@ HRESULT CLAVAudio::ffmpeg_init(CodecID codec, const void *format, const GUID for
     }
   }
 
-  if (codec == CODEC_ID_PCM_DVD) {
+  if (codec == AV_CODEC_ID_PCM_DVD) {
     if (format_type == FORMAT_WaveFormatEx) {
       WAVEFORMATEX *wfein = (WAVEFORMATEX *)format;
       if (wfein->wBitsPerSample == 16) {
-        codec = CODEC_ID_PCM_S16BE;
+        codec = AV_CODEC_ID_PCM_S16BE;
       }
     }
   }
@@ -1160,7 +1160,7 @@ HRESULT CLAVAudio::ffmpeg_init(CodecID codec, const void *format, const GUID for
     }
   }
 
-  if (codec == CODEC_ID_DTS) {
+  if (codec == AV_CODEC_ID_DTS) {
     InitDTSDecoder();
   }
 
@@ -1179,27 +1179,27 @@ HRESULT CLAVAudio::ffmpeg_init(CodecID codec, const void *format, const GUID for
   m_pAVCtx = avcodec_alloc_context3(m_pAVCodec);
   CheckPointer(m_pAVCtx, E_POINTER);
 
-  if (codec != CODEC_ID_AAC && codec != CODEC_ID_FLAC && codec != CODEC_ID_COOK)
+  if (codec != AV_CODEC_ID_AAC && codec != AV_CODEC_ID_FLAC && codec != AV_CODEC_ID_COOK)
     m_pParser = av_parser_init(codec);
 
   if (m_pAVCodec->capabilities & CODEC_CAP_TRUNCATED)
     m_pAVCtx->flags                |= CODEC_FLAG_TRUNCATED;
 
-  if ( codec == CODEC_ID_AAC
-    || codec == CODEC_ID_AC3
-    || codec == CODEC_ID_ATRAC3
-    || codec == CODEC_ID_DTS
-    || codec == CODEC_ID_OPUS
-    || codec == CODEC_ID_NELLYMOSER
-    || codec == CODEC_ID_VORBIS) {
+  if ( codec == AV_CODEC_ID_AAC
+    || codec == AV_CODEC_ID_AC3
+    || codec == AV_CODEC_ID_ATRAC3
+    || codec == AV_CODEC_ID_DTS
+    || codec == AV_CODEC_ID_OPUS
+    || codec == AV_CODEC_ID_NELLYMOSER
+    || codec == AV_CODEC_ID_VORBIS) {
     m_pAVCtx->request_sample_fmt = AV_SAMPLE_FMT_FLT;
-  } else if (codec == CODEC_ID_ALAC) {
+  } else if (codec == AV_CODEC_ID_ALAC) {
     m_pAVCtx->request_sample_fmt = AV_SAMPLE_FMT_S32P;
   }
 
   // We can only trust LAV Splitters LATM AAC header...
   BOOL bTrustExtraData = TRUE;
-  if (codec == CODEC_ID_AAC_LATM) {
+  if (codec == AV_CODEC_ID_AAC_LATM) {
     if (!(FilterInGraphSafe(m_pInput, CLSID_LAVSplitter) || FilterInGraphSafe(m_pInput, CLSID_LAVSplitterSource))) {
       bTrustExtraData = FALSE;
     }
@@ -1222,7 +1222,7 @@ HRESULT CLAVAudio::ffmpeg_init(CodecID codec, const void *format, const GUID for
   memset(&m_raData, 0, sizeof(m_raData));
 
   if (bTrustExtraData && extralen) {
-    if (codec == CODEC_ID_COOK || codec == CODEC_ID_ATRAC3 || codec == CODEC_ID_SIPR) {
+    if (codec == AV_CODEC_ID_COOK || codec == AV_CODEC_ID_ATRAC3 || codec == AV_CODEC_ID_SIPR) {
       uint8_t *extra = (uint8_t *)av_mallocz(extralen + FF_INPUT_BUFFER_PADDING_SIZE);
       getExtraData((BYTE *)format, &format_type, formatlen, extra, NULL);
 
@@ -1232,13 +1232,13 @@ HRESULT CLAVAudio::ffmpeg_init(CodecID codec, const void *format, const GUID for
         if (FAILED(hr))
           return hr;
 
-        if (codec == CODEC_ID_SIPR) {
+        if (codec == AV_CODEC_ID_SIPR) {
           if (m_raData.flavor > 3) {
             DbgLog((LOG_TRACE, 10, L"->  Invalid SIPR flavor (%d)", m_raData.flavor));
             return VFW_E_UNSUPPORTED_AUDIO;
           }
           m_pAVCtx->block_align = ff_sipr_subpk_size[m_raData.flavor];
-        } else if (codec == CODEC_ID_COOK || codec == CODEC_ID_ATRAC3) {
+        } else if (codec == AV_CODEC_ID_COOK || codec == AV_CODEC_ID_ATRAC3) {
           m_pAVCtx->block_align = m_raData.sub_packet_size;
         }
 
@@ -1273,7 +1273,7 @@ HRESULT CLAVAudio::ffmpeg_init(CodecID codec, const void *format, const GUID for
   ret = av_opt_set_double(m_pAVCtx, "drc_scale", drc_scale, AV_OPT_SEARCH_CHILDREN);
 
   // This could probably be a bit smarter..
-  if (codec == CODEC_ID_PCM_BLURAY || codec == CODEC_ID_PCM_DVD) {
+  if (codec == AV_CODEC_ID_PCM_BLURAY || codec == AV_CODEC_ID_PCM_DVD) {
     m_pAVCtx->bits_per_raw_sample = m_pAVCtx->bits_per_coded_sample;
   }
 
@@ -1282,7 +1282,7 @@ HRESULT CLAVAudio::ffmpeg_init(CodecID codec, const void *format, const GUID for
     return VFW_E_UNSUPPORTED_AUDIO;
   }
 
-  m_bFindDTSInPCM = (codec == CODEC_ID_PCM_S16LE && m_settings.bFormats[Codec_DTS]);
+  m_bFindDTSInPCM = (codec == AV_CODEC_ID_PCM_S16LE && m_settings.bFormats[Codec_DTS]);
   m_bFallback16Int = FALSE;
   m_dwOverrideMixer = 0;
   m_bMixingSettingsChanged = TRUE;
@@ -1294,7 +1294,7 @@ HRESULT CLAVAudio::SetMediaType(PIN_DIRECTION dir, const CMediaType *pmt)
 {
   DbgLog((LOG_TRACE, 5, L"SetMediaType -- %S", dir == PINDIR_INPUT ? "in" : "out"));
   if (dir == PINDIR_INPUT) {
-    CodecID codec = CODEC_ID_NONE;
+    AVCodecID codec = AV_CODEC_ID_NONE;
     const void *format = pmt->Format();
     GUID format_type = pmt->formattype;
     DWORD formatlen = pmt->cbFormat;
@@ -1302,7 +1302,7 @@ HRESULT CLAVAudio::SetMediaType(PIN_DIRECTION dir, const CMediaType *pmt)
     // Override the format type
     if (pmt->subtype == MEDIASUBTYPE_FFMPEG_AUDIO && pmt->formattype == FORMAT_WaveFormatExFFMPEG) {
       WAVEFORMATEXFFMPEG *wfexff = (WAVEFORMATEXFFMPEG *)pmt->Format();
-      codec = (CodecID)wfexff->nCodecId;
+      codec = (AVCodecID)wfexff->nCodecId;
       format = &wfexff->wfex;
       format_type = FORMAT_WaveFormatEx;
       formatlen -= sizeof(WAVEFORMATEXFFMPEG) - sizeof(WAVEFORMATEX);
@@ -1310,29 +1310,29 @@ HRESULT CLAVAudio::SetMediaType(PIN_DIRECTION dir, const CMediaType *pmt)
       codec = FindCodecId(pmt);
     }
 
-    if (codec == CODEC_ID_NONE) {
+    if (codec == AV_CODEC_ID_NONE) {
       if (m_settings.AllowRawSPDIF) {
         if (pmt->formattype == FORMAT_WaveFormatEx && pmt->subtype == MEDIASUBTYPE_PCM) {
           WAVEFORMATEX *wfex = (WAVEFORMATEX *)pmt->Format();
           switch (wfex->wBitsPerSample) {
           case 8:
-            codec = CODEC_ID_PCM_U8;
+            codec = AV_CODEC_ID_PCM_U8;
             break;
           case 16:
-            codec = CODEC_ID_PCM_S16LE;
+            codec = AV_CODEC_ID_PCM_S16LE;
             break;
           case 24:
-            codec = CODEC_ID_PCM_S24LE;
+            codec = AV_CODEC_ID_PCM_S24LE;
             break;
           case 32:
-            codec = CODEC_ID_PCM_S32LE;
+            codec = AV_CODEC_ID_PCM_S32LE;
             break;
           }
         } else if (pmt->subtype == MEDIASUBTYPE_DOLBY_AC3_SPDIF) {
-          codec = CODEC_ID_AC3;
+          codec = AV_CODEC_ID_AC3;
         }
       }
-      if (codec == CODEC_ID_NONE)
+      if (codec == AV_CODEC_ID_NONE)
         return VFW_E_TYPE_NOT_ACCEPTED;
     }
 
@@ -1570,7 +1570,7 @@ HRESULT CLAVAudio::ProcessBuffer(BOOL bEOF)
       if (count >= 4) {
         DbgLog((LOG_TRACE, 10, L"::ProcessBuffer(): Detected %d DTS sync words in %d bytes of data, switching to DTS-in-WAV decoding", count, buffer_size));
         CMediaType mt = m_pInput->CurrentMediaType();
-        ffmpeg_init(CODEC_ID_DTS, mt.Format(), *mt.FormatType(), mt.FormatLength());
+        ffmpeg_init(AV_CODEC_ID_DTS, mt.Format(), *mt.FormatType(), mt.FormatLength());
         m_bFindDTSInPCM = FALSE;
       }
 
diff --git a/decoder/LAVAudio/LAVAudio.h b/decoder/LAVAudio/LAVAudio.h
index 610cfa6f..e2a4da4f 100644
--- a/decoder/LAVAudio/LAVAudio.h
+++ b/decoder/LAVAudio/LAVAudio.h
@@ -44,11 +44,11 @@
 
 //////////////////// End Configuration //////////////////////
 
-#define CODEC_ID_PCM_SxxBE (CodecID)0x19001
-#define CODEC_ID_PCM_SxxLE (CodecID)0x19002
-#define CODEC_ID_PCM_UxxBE (CodecID)0x19003
-#define CODEC_ID_PCM_UxxLE (CodecID)0x19004
-#define CODEC_ID_PCM_QTRAW (CodecID)0x19005
+#define AV_CODEC_ID_PCM_SxxBE (AVCodecID)0x19001
+#define AV_CODEC_ID_PCM_SxxLE (AVCodecID)0x19002
+#define AV_CODEC_ID_PCM_UxxBE (AVCodecID)0x19003
+#define AV_CODEC_ID_PCM_UxxLE (AVCodecID)0x19004
+#define AV_CODEC_ID_PCM_QTRAW (AVCodecID)0x19005
 
 #define LAVC_AUDIO_REGISTRY_KEY L"Software\\LAV\\Audio"
 #define LAVC_AUDIO_REGISTRY_KEY_FORMATS L"Software\\LAV\\Audio\\Formats"
@@ -182,7 +182,7 @@ private:
   HRESULT LoadSettings();
   HRESULT SaveSettings();
 
-  HRESULT ffmpeg_init(CodecID codec, const void *format, GUID format_type, DWORD formatlen);
+  HRESULT ffmpeg_init(AVCodecID codec, const void *format, GUID format_type, DWORD formatlen);
   void ffmpeg_shutdown();
 
   CMediaType CreateMediaType(LAVAudioSampleFormat outputFormat, DWORD nSamplesPerSec, WORD nChannels, DWORD dwChannelMask, WORD wBitsPerSample = 0) const;
@@ -202,19 +202,19 @@ private:
 
   void UpdateVolumeStats(const BufferDetails &buffer);
 
-  BOOL IsBitstreaming(CodecID codec);
+  BOOL IsBitstreaming(AVCodecID codec);
   HRESULT InitBitstreaming();
   HRESULT ShutdownBitstreaming();
   static int BSWriteBuffer(void *opaque, uint8_t *buf, int buf_size);
 
-  HRESULT CreateBitstreamContext(CodecID codec, WAVEFORMATEX *wfe);
+  HRESULT CreateBitstreamContext(AVCodecID codec, WAVEFORMATEX *wfe);
   HRESULT UpdateBitstreamContext();
   HRESULT FreeBitstreamContext();
 
   HRESULT Bitstream(const BYTE *p, int buffsize, int &consumed, HRESULT *hrDeliver);
-  HRESULT DeliverBitstream(CodecID codec, const BYTE *buffer, DWORD dwSize, DWORD dwFrameSize, REFERENCE_TIME rtStartInput, REFERENCE_TIME rtStopInput);
+  HRESULT DeliverBitstream(AVCodecID codec, const BYTE *buffer, DWORD dwSize, DWORD dwFrameSize, REFERENCE_TIME rtStartInput, REFERENCE_TIME rtStopInput);
 
-  CMediaType CreateBitstreamMediaType(CodecID codec, DWORD dwSampleRate);
+  CMediaType CreateBitstreamMediaType(AVCodecID codec, DWORD dwSampleRate);
   void ActivateDTSHDMuxing();
 
   HRESULT InitDTSDecoder();
@@ -235,7 +235,7 @@ private:
   HRESULT PerformMixing(BufferDetails *buffer);
 
 private:
-  CodecID              m_nCodecId;       // FFMPEG Codec Id
+  AVCodecID            m_nCodecId;       // FFMPEG Codec Id
   AVCodec              *m_pAVCodec;      // AVCodec reference
   AVCodecContext       *m_pAVCtx;        // AVCodecContext reference
   AVCodecParserContext *m_pParser;       // AVCodecParserContext reference
diff --git a/decoder/LAVAudio/Media.cpp b/decoder/LAVAudio/Media.cpp
index b985f9c5..dc7a0adc 100644
--- a/decoder/LAVAudio/Media.cpp
+++ b/decoder/LAVAudio/Media.cpp
@@ -29,98 +29,98 @@ extern "C" {
 };
 
 typedef struct {
-  const CLSID*        clsMinorType;
-  const enum CodecID  nFFCodec;
+  const CLSID*         clsMinorType;
+  const enum AVCodecID nFFCodec;
 } FFMPEG_SUBTYPE_MAP;
 
 // Map Media Subtype <> FFMPEG Codec Id
 static const FFMPEG_SUBTYPE_MAP lavc_audio_codecs[] = {
   // AAC
-  { &MEDIASUBTYPE_AAC,          CODEC_ID_AAC      },
-  { &MEDIASUBTYPE_LATM_AAC,     CODEC_ID_AAC_LATM },
-  { &MEDIASUBTYPE_MPEG_LOAS,    CODEC_ID_AAC_LATM },
-  { &MEDIASUBTYPE_MP4A,         CODEC_ID_AAC      },
-  { &MEDIASUBTYPE_mp4a,         CODEC_ID_AAC      },
-  { &MEDIASUBTYPE_AAC_ADTS,     CODEC_ID_AAC      },
-  { &MEDIASUBTYPE_MPEG_ADTS_AAC,CODEC_ID_AAC      },
-  { &MEDIASUBTYPE_MPEG_RAW_AAC, CODEC_ID_AAC      },
-  { &MEDIASUBTYPE_MPEG_HEAAC,   CODEC_ID_AAC      },
-  { &MEDIASUBTYPE_ALS,          CODEC_ID_MP4ALS   },
+  { &MEDIASUBTYPE_AAC,          AV_CODEC_ID_AAC      },
+  { &MEDIASUBTYPE_LATM_AAC,     AV_CODEC_ID_AAC_LATM },
+  { &MEDIASUBTYPE_MPEG_LOAS,    AV_CODEC_ID_AAC_LATM },
+  { &MEDIASUBTYPE_MP4A,         AV_CODEC_ID_AAC      },
+  { &MEDIASUBTYPE_mp4a,         AV_CODEC_ID_AAC      },
+  { &MEDIASUBTYPE_AAC_ADTS,     AV_CODEC_ID_AAC      },
+  { &MEDIASUBTYPE_MPEG_ADTS_AAC,AV_CODEC_ID_AAC      },
+  { &MEDIASUBTYPE_MPEG_RAW_AAC, AV_CODEC_ID_AAC      },
+  { &MEDIASUBTYPE_MPEG_HEAAC,   AV_CODEC_ID_AAC      },
+  { &MEDIASUBTYPE_ALS,          AV_CODEC_ID_MP4ALS   },
 
   // Dolby
-  { &MEDIASUBTYPE_DOLBY_AC3,    CODEC_ID_AC3      },
-  { &MEDIASUBTYPE_DOLBY_DDPLUS, CODEC_ID_EAC3     },
-  { &MEDIASUBTYPE_DOLBY_DDPLUS_ARCSOFT, CODEC_ID_EAC3 },
-  { &MEDIASUBTYPE_DOLBY_TRUEHD, CODEC_ID_TRUEHD   },
-  { &MEDIASUBTYPE_WAVE_DOLBY_AC3, CODEC_ID_AC3    },
+  { &MEDIASUBTYPE_DOLBY_AC3,    AV_CODEC_ID_AC3      },
+  { &MEDIASUBTYPE_DOLBY_DDPLUS, AV_CODEC_ID_EAC3     },
+  { &MEDIASUBTYPE_DOLBY_DDPLUS_ARCSOFT, AV_CODEC_ID_EAC3 },
+  { &MEDIASUBTYPE_DOLBY_TRUEHD, AV_CODEC_ID_TRUEHD   },
+  { &MEDIASUBTYPE_WAVE_DOLBY_AC3, AV_CODEC_ID_AC3    },
 
   // DTS
-  { &MEDIASUBTYPE_DTS,          CODEC_ID_DTS      },
-  { &MEDIASUBTYPE_DTS_HD,       CODEC_ID_DTS      },
-  { &MEDIASUBTYPE_WAVE_DTS,     CODEC_ID_DTS      },
+  { &MEDIASUBTYPE_DTS,          AV_CODEC_ID_DTS      },
+  { &MEDIASUBTYPE_DTS_HD,       AV_CODEC_ID_DTS      },
+  { &MEDIASUBTYPE_WAVE_DTS,     AV_CODEC_ID_DTS      },
 
   // MPEG Audio
-  { &MEDIASUBTYPE_MPEG1Packet,  CODEC_ID_MP1      },
-  { &MEDIASUBTYPE_MPEG1Payload, CODEC_ID_MP1      },
-  { &MEDIASUBTYPE_MPEG1AudioPayload, CODEC_ID_MP1 },
-  { &MEDIASUBTYPE_MPEG2_AUDIO,  CODEC_ID_MP2      },
-  { &MEDIASUBTYPE_MP3,          CODEC_ID_MP3      },
+  { &MEDIASUBTYPE_MPEG1Packet,  AV_CODEC_ID_MP1      },
+  { &MEDIASUBTYPE_MPEG1Payload, AV_CODEC_ID_MP1      },
+  { &MEDIASUBTYPE_MPEG1AudioPayload, AV_CODEC_ID_MP1 },
+  { &MEDIASUBTYPE_MPEG2_AUDIO,  AV_CODEC_ID_MP2      },
+  { &MEDIASUBTYPE_MP3,          AV_CODEC_ID_MP3      },
 
   // FLAC
-  { &MEDIASUBTYPE_FLAC,         CODEC_ID_FLAC     },
-  { &MEDIASUBTYPE_FLAC_FRAMED,  CODEC_ID_FLAC     },
+  { &MEDIASUBTYPE_FLAC,         AV_CODEC_ID_FLAC     },
+  { &MEDIASUBTYPE_FLAC_FRAMED,  AV_CODEC_ID_FLAC     },
 
   // Ogg Vorbis
-  { &MEDIASUBTYPE_Vorbis2,      CODEC_ID_VORBIS   },
+  { &MEDIASUBTYPE_Vorbis2,      AV_CODEC_ID_VORBIS   },
 
   // Other Lossless formats
-  { &MEDIASUBTYPE_TTA1,         CODEC_ID_TTA      },
-  { &MEDIASUBTYPE_WAVPACK4,     CODEC_ID_WAVPACK  },
-  { &MEDIASUBTYPE_MLP,          CODEC_ID_MLP      },
-  { &MEDIASUBTYPE_ALAC,         CODEC_ID_ALAC     },
+  { &MEDIASUBTYPE_TTA1,         AV_CODEC_ID_TTA      },
+  { &MEDIASUBTYPE_WAVPACK4,     AV_CODEC_ID_WAVPACK  },
+  { &MEDIASUBTYPE_MLP,          AV_CODEC_ID_MLP      },
+  { &MEDIASUBTYPE_ALAC,         AV_CODEC_ID_ALAC     },
 
   // BluRay LPCM
-  { &MEDIASUBTYPE_DVD_LPCM_AUDIO, CODEC_ID_PCM_DVD },
-  { &MEDIASUBTYPE_BD_LPCM_AUDIO,   CODEC_ID_PCM_BLURAY },
-  { &MEDIASUBTYPE_HDMV_LPCM_AUDIO, CODEC_ID_PCM_BLURAY }, // MPC-HC MPEG Splitter type with header stripped off
+  { &MEDIASUBTYPE_DVD_LPCM_AUDIO, AV_CODEC_ID_PCM_DVD },
+  { &MEDIASUBTYPE_BD_LPCM_AUDIO,   AV_CODEC_ID_PCM_BLURAY },
+  { &MEDIASUBTYPE_HDMV_LPCM_AUDIO, AV_CODEC_ID_PCM_BLURAY }, // MPC-HC MPEG Splitter type with header stripped off
 
   // QT PCM
-  { &MEDIASUBTYPE_PCM_NONE,     CODEC_ID_PCM_QTRAW},
-  { &MEDIASUBTYPE_PCM_RAW,      CODEC_ID_PCM_QTRAW},
-  { &MEDIASUBTYPE_PCM_TWOS,     CODEC_ID_PCM_SxxBE},
-  { &MEDIASUBTYPE_PCM_SOWT,     CODEC_ID_PCM_SxxLE},
-  { &MEDIASUBTYPE_PCM_IN24,     CODEC_ID_PCM_S24BE},
-  { &MEDIASUBTYPE_PCM_IN32,     CODEC_ID_PCM_S32BE},
-  { &MEDIASUBTYPE_PCM_FL32,     CODEC_ID_PCM_F32BE},
-  { &MEDIASUBTYPE_PCM_FL64,     CODEC_ID_PCM_F64BE},
-  { &MEDIASUBTYPE_PCM_IN24_le,  CODEC_ID_PCM_S24LE},
-  { &MEDIASUBTYPE_PCM_IN32_le,  CODEC_ID_PCM_S32LE},
-  { &MEDIASUBTYPE_PCM_FL32_le,  CODEC_ID_PCM_F32LE},
-  { &MEDIASUBTYPE_PCM_FL64_le,  CODEC_ID_PCM_F64LE},
+  { &MEDIASUBTYPE_PCM_NONE,     AV_CODEC_ID_PCM_QTRAW},
+  { &MEDIASUBTYPE_PCM_RAW,      AV_CODEC_ID_PCM_QTRAW},
+  { &MEDIASUBTYPE_PCM_TWOS,     AV_CODEC_ID_PCM_SxxBE},
+  { &MEDIASUBTYPE_PCM_SOWT,     AV_CODEC_ID_PCM_SxxLE},
+  { &MEDIASUBTYPE_PCM_IN24,     AV_CODEC_ID_PCM_S24BE},
+  { &MEDIASUBTYPE_PCM_IN32,     AV_CODEC_ID_PCM_S32BE},
+  { &MEDIASUBTYPE_PCM_FL32,     AV_CODEC_ID_PCM_F32BE},
+  { &MEDIASUBTYPE_PCM_FL64,     AV_CODEC_ID_PCM_F64BE},
+  { &MEDIASUBTYPE_PCM_IN24_le,  AV_CODEC_ID_PCM_S24LE},
+  { &MEDIASUBTYPE_PCM_IN32_le,  AV_CODEC_ID_PCM_S32LE},
+  { &MEDIASUBTYPE_PCM_FL32_le,  AV_CODEC_ID_PCM_F32LE},
+  { &MEDIASUBTYPE_PCM_FL64_le,  AV_CODEC_ID_PCM_F64LE},
 
   // WMV
-  { &MEDIASUBTYPE_WMAUDIO1,     CODEC_ID_WMAV1    },
-  { &MEDIASUBTYPE_WMAUDIO2,     CODEC_ID_WMAV2    },
-  { &MEDIASUBTYPE_WMAUDIO3,     CODEC_ID_WMAPRO   },
-  { &MEDIASUBTYPE_WMALOSSLESS,  CODEC_ID_WMALOSSLESS },
+  { &MEDIASUBTYPE_WMAUDIO1,     AV_CODEC_ID_WMAV1    },
+  { &MEDIASUBTYPE_WMAUDIO2,     AV_CODEC_ID_WMAV2    },
+  { &MEDIASUBTYPE_WMAUDIO3,     AV_CODEC_ID_WMAPRO   },
+  { &MEDIASUBTYPE_WMALOSSLESS,  AV_CODEC_ID_WMALOSSLESS },
 
   // RealMedia Audio
-  { &MEDIASUBTYPE_COOK,         CODEC_ID_COOK     },
-  { &MEDIASUBTYPE_ATRC,         CODEC_ID_ATRAC3   },
-  { &MEDIASUBTYPE_RAAC,         CODEC_ID_AAC      },
-  { &MEDIASUBTYPE_RACP,         CODEC_ID_AAC      },
-  { &MEDIASUBTYPE_SIPR,         CODEC_ID_SIPR     },
-  { &MEDIASUBTYPE_DNET,         CODEC_ID_AC3      },
-  { &MEDIASUBTYPE_28_8,         CODEC_ID_RA_288   },
-  { &MEDIASUBTYPE_14_4,         CODEC_ID_RA_144   },
-  { &MEDIASUBTYPE_RALF,         CODEC_ID_RALF     },
+  { &MEDIASUBTYPE_COOK,         AV_CODEC_ID_COOK     },
+  { &MEDIASUBTYPE_ATRC,         AV_CODEC_ID_ATRAC3   },
+  { &MEDIASUBTYPE_RAAC,         AV_CODEC_ID_AAC      },
+  { &MEDIASUBTYPE_RACP,         AV_CODEC_ID_AAC      },
+  { &MEDIASUBTYPE_SIPR,         AV_CODEC_ID_SIPR     },
+  { &MEDIASUBTYPE_DNET,         AV_CODEC_ID_AC3      },
+  { &MEDIASUBTYPE_28_8,         AV_CODEC_ID_RA_288   },
+  { &MEDIASUBTYPE_14_4,         AV_CODEC_ID_RA_144   },
+  { &MEDIASUBTYPE_RALF,         AV_CODEC_ID_RALF     },
 
   // Misc
-  { &MEDIASUBTYPE_SPEEX,        CODEC_ID_SPEEX    },
-  { &MEDIASUBTYPE_OPUS,         CODEC_ID_OPUS     },
+  { &MEDIASUBTYPE_SPEEX,        AV_CODEC_ID_SPEEX    },
+  { &MEDIASUBTYPE_OPUS,         AV_CODEC_ID_OPUS     },
 
   // Special LAVFSplitter interface
-  { &MEDIASUBTYPE_FFMPEG_AUDIO, CODEC_ID_NONE     },
+  { &MEDIASUBTYPE_FFMPEG_AUDIO, AV_CODEC_ID_NONE     },
 };
 
 // Define Input Media Types
@@ -236,28 +236,28 @@ const AMOVIESETUP_MEDIATYPE CLAVAudio::sudPinTypesOut[] = {
 const int CLAVAudio::sudPinTypesOutCount = countof(CLAVAudio::sudPinTypesOut);
 
 // Crawl the lavc_audio_codecs array for the proper codec
-CodecID FindCodecId(const CMediaType *mt)
+AVCodecID FindCodecId(const CMediaType *mt)
 {
   for (int i=0; i<countof(lavc_audio_codecs); ++i) {
     if (mt->subtype == *lavc_audio_codecs[i].clsMinorType) {
       return lavc_audio_codecs[i].nFFCodec;
     }
   }
-  return CODEC_ID_NONE;
+  return AV_CODEC_ID_NONE;
 }
 
 static const struct s_ffmpeg_codec_overrides {
-  CodecID codec;
+  AVCodecID codec;
   const char *override;
 } ffmpeg_codec_overrides[] = {
-  { CODEC_ID_MP1, "mp1float" },
-  { CODEC_ID_MP2, "mp2float" },
-  { CODEC_ID_MP3, "mp3float" },
-  { CODEC_ID_AMR_NB, "libopencore_amrnb" },
-  { CODEC_ID_AMR_WB, "libopencore_amrwb" },
+  { AV_CODEC_ID_MP1, "mp1float" },
+  { AV_CODEC_ID_MP2, "mp2float" },
+  { AV_CODEC_ID_MP3, "mp3float" },
+  { AV_CODEC_ID_AMR_NB, "libopencore_amrnb" },
+  { AV_CODEC_ID_AMR_WB, "libopencore_amrwb" },
 };
 
-const char *find_codec_override(CodecID codec)
+const char *find_codec_override(AVCodecID codec)
 {
   for (int i=0; i<countof(ffmpeg_codec_overrides); ++i) {
     if (ffmpeg_codec_overrides[i].codec == codec)
@@ -600,30 +600,30 @@ const char *get_channel_desc(DWORD dwFlag)
 }
 
 // Strings will be filled in eventually.
-// CODEC_ID_NONE means there is some special handling going on.
+// AV_CODEC_ID_NONE means there is some special handling going on.
 // Order is Important, has to be the same as the CC Enum
 // Also, the order is used for storage in the Registry
 static codec_config_t m_codec_config[] = {
-  { 2, { CODEC_ID_AAC, CODEC_ID_AAC_LATM }},       // CC_AAC
-  { 1, { CODEC_ID_AC3 }},                          // CC_AC3
-  { 1, { CODEC_ID_EAC3 }},                         // CC_EAC3
-  { 1, { CODEC_ID_DTS }},                          // CC_DTS
-  { 2, { CODEC_ID_MP2, CODEC_ID_MP1 }},            // CC_MP2
-  { 1, { CODEC_ID_MP3 }},                          // CC_MP3
-  { 2, { CODEC_ID_TRUEHD, CODEC_ID_MLP }},         // CC_TRUEHD
-  { 1, { CODEC_ID_FLAC }},                         // CC_FLAC
-  { 1, { CODEC_ID_VORBIS }},                       // CC_VORBIS
-  { 2, { CODEC_ID_PCM_BLURAY, CODEC_ID_PCM_DVD }, "lpcm", "Linear PCM (BluRay & DVD)"}, // CC_LPCM
-  { 1, { CODEC_ID_NONE }, "pcm", "Raw PCM Types (including QT PCM)" }, // CC_LPCM
-  { 1, { CODEC_ID_WAVPACK }},                      // CC_WAVPACK
-  { 1, { CODEC_ID_TTA }},                          // CC_TTA
-  { 2, { CODEC_ID_WMAV2, CODEC_ID_WMAV1 }, "wma", "Windows Media Audio 1/2"}, // CC_WMA2
-  { 1, { CODEC_ID_WMAPRO }},                       // CC_WMAPRO
-  { 1, { CODEC_ID_COOK }},                         // CC_COOK
-  { 5, { CODEC_ID_SIPR, CODEC_ID_ATRAC3, CODEC_ID_RA_144, CODEC_ID_RA_288, CODEC_ID_RALF }, "realaudio", "Real Audio (ATRAC, SIPR, RALF, 14.4 28.8)" }, // CC_REAL
-  { 1, { CODEC_ID_WMALOSSLESS }},                  // CC_WMALL
-  { 1, { CODEC_ID_ALAC }},                         // CC_ALAC
-  { 1, { CODEC_ID_OPUS }, "opus", "Opus Audio Codec"}, // CC_OPUS
+  { 2, { AV_CODEC_ID_AAC, AV_CODEC_ID_AAC_LATM }},       // CC_AAC
+  { 1, { AV_CODEC_ID_AC3 }},                          // CC_AC3
+  { 1, { AV_CODEC_ID_EAC3 }},                         // CC_EAC3
+  { 1, { AV_CODEC_ID_DTS }},                          // CC_DTS
+  { 2, { AV_CODEC_ID_MP2, AV_CODEC_ID_MP1 }},            // CC_MP2
+  { 1, { AV_CODEC_ID_MP3 }},                          // CC_MP3
+  { 2, { AV_CODEC_ID_TRUEHD, AV_CODEC_ID_MLP }},         // CC_TRUEHD
+  { 1, { AV_CODEC_ID_FLAC }},                         // CC_FLAC
+  { 1, { AV_CODEC_ID_VORBIS }},                       // CC_VORBIS
+  { 2, { AV_CODEC_ID_PCM_BLURAY, AV_CODEC_ID_PCM_DVD }, "lpcm", "Linear PCM (BluRay & DVD)"}, // CC_LPCM
+  { 1, { AV_CODEC_ID_NONE }, "pcm", "Raw PCM Types (including QT PCM)" }, // CC_LPCM
+  { 1, { AV_CODEC_ID_WAVPACK }},                      // CC_WAVPACK
+  { 1, { AV_CODEC_ID_TTA }},                          // CC_TTA
+  { 2, { AV_CODEC_ID_WMAV2, AV_CODEC_ID_WMAV1 }, "wma", "Windows Media Audio 1/2"}, // CC_WMA2
+  { 1, { AV_CODEC_ID_WMAPRO }},                       // CC_WMAPRO
+  { 1, { AV_CODEC_ID_COOK }},                         // CC_COOK
+  { 5, { AV_CODEC_ID_SIPR, AV_CODEC_ID_ATRAC3, AV_CODEC_ID_RA_144, AV_CODEC_ID_RA_288, AV_CODEC_ID_RALF }, "realaudio", "Real Audio (ATRAC, SIPR, RALF, 14.4 28.8)" }, // CC_REAL
+  { 1, { AV_CODEC_ID_WMALOSSLESS }},                  // CC_WMALL
+  { 1, { AV_CODEC_ID_ALAC }},                         // CC_ALAC
+  { 1, { AV_CODEC_ID_OPUS }, "opus", "Opus Audio Codec"}, // CC_OPUS
 };
 
 const codec_config_t *get_codec_config(LAVAudioCodec codec)
diff --git a/decoder/LAVAudio/Media.h b/decoder/LAVAudio/Media.h
index 0fcdc28f..dda522c2 100644
--- a/decoder/LAVAudio/Media.h
+++ b/decoder/LAVAudio/Media.h
@@ -38,16 +38,16 @@ struct scmap_t {
 
 struct codec_config_t {
   int nCodecs;
-  CodecID codecs[MAX_NUM_CC_CODECS];
+  AVCodecID codecs[MAX_NUM_CC_CODECS];
   const char *name;
   const char *description;
 };
 
 const codec_config_t *get_codec_config(LAVAudioCodec codec);
 
-CodecID FindCodecId(const CMediaType *mt);
+AVCodecID FindCodecId(const CMediaType *mt);
 
-const char *find_codec_override(CodecID codec);
+const char *find_codec_override(AVCodecID codec);
 
 DWORD get_channel_mask(int num_channels);
 
diff --git a/decoder/LAVAudio/PostProcessor.cpp b/decoder/LAVAudio/PostProcessor.cpp
index 0b7ae363..a7be332e 100644
--- a/decoder/LAVAudio/PostProcessor.cpp
+++ b/decoder/LAVAudio/PostProcessor.cpp
@@ -389,12 +389,12 @@ HRESULT CLAVAudio::Create71Conformity(DWORD dwLayout)
   return S_OK;
 }
 
-static DWORD sanitize_mask(DWORD mask, CodecID codec)
+static DWORD sanitize_mask(DWORD mask, AVCodecID codec)
 {
   DWORD newmask = mask;
   // Alot of codecs set 6.1/6.0 wrong..
   // Only these codecs we can trust to properly set BL/BR + BC layouts
-  if (codec != CODEC_ID_DTS) {
+  if (codec != AV_CODEC_ID_DTS) {
     // 6.1
     if (mask == (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER))
       newmask = AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER;
@@ -403,7 +403,7 @@ static DWORD sanitize_mask(DWORD mask, CodecID codec)
       newmask = AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER;
   }
   // The reverse, TrueHD sets SL/SR when it actually should be BL/BR
-  if (codec == CODEC_ID_TRUEHD) {
+  if (codec == AV_CODEC_ID_TRUEHD) {
     // 6.1
     if(mask == (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER))
       newmask = AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER;