diff --git a/mythtv/libs/libmyth/audio/audiooutputbase.cpp b/mythtv/libs/libmyth/audio/audiooutputbase.cpp
index f12a1b2f9a7..ab694fe4fdb 100644
--- a/mythtv/libs/libmyth/audio/audiooutputbase.cpp
+++ b/mythtv/libs/libmyth/audio/audiooutputbase.cpp
@@ -47,7 +47,7 @@ const char *AudioOutputBase::quality_string(int q)
 AudioOutputBase::AudioOutputBase(const AudioSettings &settings) :
     MThread("AudioOutputBase"),
     // protected
-    channels(-1),               codec(CODEC_ID_NONE),
+    channels(-1),               codec(AV_CODEC_ID_NONE),
     bytes_per_frame(0),         output_bytes_per_frame(0),
     format(FORMAT_NONE),        output_format(FORMAT_NONE),
     samplerate(-1),             effdsp(0),
@@ -251,10 +251,10 @@ bool AudioOutputBase::CanPassthrough(int samplerate, int channels,
 
     switch(codec)
     {
-        case CODEC_ID_AC3:
+        case AV_CODEC_ID_AC3:
             arg = FEATURE_AC3;
             break;
-        case CODEC_ID_DTS:
+        case AV_CODEC_ID_DTS:
             switch(profile)
             {
                 case FF_PROFILE_DTS:
@@ -270,10 +270,10 @@ bool AudioOutputBase::CanPassthrough(int samplerate, int channels,
                     break;
             }
             break;
-        case CODEC_ID_EAC3:
+        case AV_CODEC_ID_EAC3:
             arg = FEATURE_EAC3;
             break;
-        case CODEC_ID_TRUEHD:
+        case AV_CODEC_ID_TRUEHD:
             arg = FEATURE_TRUEHD;
             break;
     }
@@ -429,7 +429,7 @@ bool AudioOutputBase::CanUpmix(void)
 bool AudioOutputBase::SetupPassthrough(int codec, int codec_profile,
                                        int &samplerate_tmp, int &channels_tmp)
 {
-    if (codec == CODEC_ID_DTS &&
+    if (codec == AV_CODEC_ID_DTS &&
         !output_settingsdigital->canFeature(FEATURE_DTSHD))
     {
         // We do not support DTS-HD bitstream so force extraction of the
@@ -448,7 +448,7 @@ bool AudioOutputBase::SetupPassthrough(int codec, int codec_profile,
     }
 
     m_spdifenc = new SPDIFEncoder("spdif", codec);
-    if (m_spdifenc->Succeeded() && codec == CODEC_ID_DTS)
+    if (m_spdifenc->Succeeded() && codec == AV_CODEC_ID_DTS)
     {
         switch(codec_profile)
         {
@@ -553,7 +553,7 @@ void AudioOutputBase::Reconfigure(const AudioSettings &orig_settings)
         /* Might we reencode a bitstream that's been decoded for timestretch?
            If the device doesn't support the number of channels - see below */
         if (output_settingsdigital->canFeature(FEATURE_AC3) &&
-            (settings.codec == CODEC_ID_AC3 || settings.codec == CODEC_ID_DTS))
+            (settings.codec == AV_CODEC_ID_AC3 || settings.codec == AV_CODEC_ID_DTS))
         {
             lreenc = true;
         }
@@ -734,7 +734,7 @@ void AudioOutputBase::Reconfigure(const AudioSettings &orig_settings)
                 .arg(samplerate).arg(configured_channels));
 
         encoder = new AudioOutputDigitalEncoder();
-        if (!encoder->Init(CODEC_ID_AC3, 448000, samplerate,
+        if (!encoder->Init(AV_CODEC_ID_AC3, 448000, samplerate,
                            configured_channels))
         {
             Error("AC-3 encoder initialization failed");
diff --git a/mythtv/libs/libmyth/audio/audiooutputdigitalencoder.cpp b/mythtv/libs/libmyth/audio/audiooutputdigitalencoder.cpp
index 005507d4463..527a39005e8 100644
--- a/mythtv/libs/libmyth/audio/audiooutputdigitalencoder.cpp
+++ b/mythtv/libs/libmyth/audio/audiooutputdigitalencoder.cpp
@@ -154,7 +154,7 @@ bool AudioOutputDigitalEncoder::Init(
         delete m_spdifenc;
     }
 
-    m_spdifenc = new SPDIFEncoder("spdif", CODEC_ID_AC3);
+    m_spdifenc = new SPDIFEncoder("spdif", AV_CODEC_ID_AC3);
     if (!m_spdifenc->Succeeded())
     {
         Dispose();
@@ -235,7 +235,7 @@ size_t AudioOutputDigitalEncoder::Encode(void *buf, int len, AudioFormat format)
 
         if (!m_spdifenc)
         {
-            m_spdifenc = new SPDIFEncoder("spdif", CODEC_ID_AC3);
+            m_spdifenc = new SPDIFEncoder("spdif", AV_CODEC_ID_AC3);
         }
         m_spdifenc->WriteFrame((uint8_t *)m_encodebuffer, outsize);
         // Check if output buffer is big enough
diff --git a/mythtv/libs/libmyth/audio/audiooutputsettings.cpp b/mythtv/libs/libmyth/audio/audiooutputsettings.cpp
index 6c488a8fd7b..baf54cc68e5 100644
--- a/mythtv/libs/libmyth/audio/audiooutputsettings.cpp
+++ b/mythtv/libs/libmyth/audio/audiooutputsettings.cpp
@@ -449,14 +449,14 @@ QString AudioOutputSettings::GetPassthroughParams(int codec, int codec_profile,
 
     switch (codec)
     {
-        case CODEC_ID_AC3:
+        case AV_CODEC_ID_AC3:
             log = "AC3";
             break;
-        case CODEC_ID_EAC3:
+        case AV_CODEC_ID_EAC3:
             samplerate = samplerate * 4;
             log = "Dolby Digital Plus (E-AC3)";
             break;
-        case CODEC_ID_DTS:
+        case AV_CODEC_ID_DTS:
             switch(codec_profile)
             {
                 case FF_PROFILE_DTS_ES:
@@ -487,7 +487,7 @@ QString AudioOutputSettings::GetPassthroughParams(int codec, int codec_profile,
                     break;
             }
             break;
-        case CODEC_ID_TRUEHD:
+        case AV_CODEC_ID_TRUEHD:
             channels = 8;
             log = "TrueHD";
             switch(samplerate)
diff --git a/mythtv/libs/libmyth/audio/audiooutpututil.cpp b/mythtv/libs/libmyth/audio/audiooutpututil.cpp
index 0c42848bbf1..4cf536e5048 100644
--- a/mythtv/libs/libmyth/audio/audiooutpututil.cpp
+++ b/mythtv/libs/libmyth/audio/audiooutpututil.cpp
@@ -1,11 +1,18 @@
 #include <math.h>
-
-#include "mythconfig.h"
-#include "audiooutpututil.h"
 #include <sys/types.h>
 #include <inttypes.h>
 #include "bswap.h"
 
+#include "mythconfig.h"
+#include "mythlogging.h"
+#include "audiooutpututil.h"
+
+extern "C" {
+#include "libavcodec/avcodec.h"
+#include "libswresample/swresample.h"
+#include "pink.h"
+}
+
 #define LOC QString("AOUtil: ")
 
 #if ARCH_X86
@@ -675,4 +682,84 @@ char *AudioOutputUtil::GeneratePinkFrames(char *frames, int channels,
     }    
     return frames;
 }
-  
+
+/**
+ * DecodeAudio
+ * Decode an audio packet, and compact it if data is planar
+ * Return negative error code if an error occurred during decoding
+ * or the number of bytes consumed from the input AVPacket
+ * data_size contains the size of decoded data copied into buffer
+ */
+int AudioOutputUtil::DecodeAudio(AVCodecContext *ctx,
+                                 uint8_t *buffer, int &data_size,
+                                 AVPacket *pkt)
+{
+    AVFrame frame;
+    int got_frame = 0;
+    int ret, ret2;
+
+    data_size = 0;
+    avcodec_get_frame_defaults(&frame);
+    ret = avcodec_decode_audio4(ctx, &frame, &got_frame, pkt);
+    if (ret < 0 || !got_frame)
+    {
+        LOG(VB_AUDIO, LOG_ERR, LOC +
+            QString("audio decode error: %1 (%2)")
+            .arg(av_err2str(ret)).arg(got_frame));
+        return ret;
+    }
+
+    AVSampleFormat format = (AVSampleFormat)frame.format;
+    if (!av_sample_fmt_is_planar(format))
+    {
+            // data is already compacted... simply copy it
+        data_size = av_samples_get_buffer_size(NULL, ctx->channels,
+                                               frame.nb_samples,
+                                               format, 1);
+        memcpy(buffer, frame.extended_data[0], data_size);
+        return ret;
+    }
+
+        // Need to find a valid channels layout, as not all codecs provide one
+    int64_t channel_layout =
+        frame.channel_layout && frame.channels == av_get_channel_layout_nb_channels(frame.channel_layout) ?
+        frame.channel_layout : av_get_default_channel_layout(frame.channels);
+    SwrContext *swr = swr_alloc_set_opts(NULL,
+                                         channel_layout,
+                                         av_get_packed_sample_fmt(format),
+                                         frame.sample_rate,
+                                         channel_layout,
+                                         format,
+                                         frame.sample_rate,
+                                         0, NULL);
+    if (!swr)
+    {
+        LOG(VB_AUDIO, LOG_ERR, LOC + "error allocating resampler context");
+        return AVERROR(ENOMEM);
+    }
+        /* initialize the resampling context */
+    ret2 = swr_init(swr);
+    if (ret2 < 0)
+    {
+        LOG(VB_AUDIO, LOG_ERR, LOC +
+            QString("error initializing resampler context (%1)")
+            .arg(av_err2str(ret2)));
+        swr_free(&swr);
+        return ret2;
+    }
+
+    uint8_t *out[] = {buffer};
+    ret2 = swr_convert(swr, out, frame.nb_samples,
+                       (const uint8_t **)frame.extended_data, frame.nb_samples);
+    swr_free(&swr);
+    if (ret2 < 0)
+    {
+        LOG(VB_AUDIO, LOG_ERR, LOC +
+            QString("error converting audio from planar format (%1)")
+            .arg(av_err2str(ret2)));
+        return ret2;
+    }
+    data_size = ret2 * frame.channels * av_get_bytes_per_sample(format);
+
+    return ret;
+}
diff --git a/mythtv/libs/libmyth/audio/audiooutpututil.h b/mythtv/libs/libmyth/audio/audiooutpututil.h
index a084b99cf56..c7054e51a27 100644
--- a/mythtv/libs/libmyth/audio/audiooutpututil.h
+++ b/mythtv/libs/libmyth/audio/audiooutpututil.h
@@ -2,9 +2,6 @@
 #define AUDIOOUTPUTUTIL_H_
 
 #include "audiooutputsettings.h"
-extern "C" {
-#include "pink.h"
-}
 
 class MPUBLIC AudioOutputUtil
 {
@@ -19,6 +16,9 @@ class MPUBLIC AudioOutputUtil
                             void *buffer, int bytes);
     static char *GeneratePinkFrames(char *frames, int channels,
                                     int channel, int count, int bits = 16);
+    static int DecodeAudio(AVCodecContext *ctx,
+                           uint8_t *buffer, int &data_size,
+                           AVPacket *pkt);
 };
 
 #endif
diff --git a/mythtv/libs/libmyth/libmyth.pro b/mythtv/libs/libmyth/libmyth.pro
index 761a6963089..9d29882d563 100644
--- a/mythtv/libs/libmyth/libmyth.pro
+++ b/mythtv/libs/libmyth/libmyth.pro
@@ -87,12 +87,14 @@ LIBS += -L../libmythservicecontracts -lmythservicecontracts-$${LIBVERSION}
 LIBS += -L../../external/FFmpeg/libavcodec -lmythavcodec
 LIBS += -L../../external/FFmpeg/libavutil  -lmythavutil
 LIBS += -L../../external/FFmpeg/libavformat  -lmythavformat
+LIBS += -L../../external/FFmpeg/libswresample -lmythswresample
 
 POST_TARGETDEPS += ../libmythsamplerate/libmythsamplerate-$${MYTH_LIB_EXT}
 POST_TARGETDEPS += ../libmythsoundtouch/libmythsoundtouch-$${MYTH_LIB_EXT}
 POST_TARGETDEPS += ../libmythfreesurround/libmythfreesurround-$${MYTH_LIB_EXT}
 POST_TARGETDEPS += ../../external/FFmpeg/libavcodec/$$avLibName(avcodec)
 POST_TARGETDEPS += ../../external/FFmpeg/libavutil/$$avLibName(avutil)
+POST_TARGETDEPS += ../../external/FFmpeg/libswresample/$$avLibName(swresample)
 
 # Install headers so that plugins can compile independently
 inc.path = $${PREFIX}/include/mythtv/
@@ -100,7 +102,7 @@ inc.files  = dialogbox.h mythcontext.h
 inc.files += mythwidgets.h remotefile.h oldsettings.h volumecontrol.h
 inc.files += settings.h uitypes.h mythdialogs.h
 inc.files += audio/audiooutput.h audio/audiosettings.h
-inc.files += audio/audiooutputsettings.h
+inc.files += audio/audiooutputsettings.h audio/audiooutpututil.h
 inc.files += audio/volumebase.h audio/eldutils.h
 inc.files += inetcomms.h mythwizard.h schemawizard.h
 inc.files += mythmediamonitor.h
diff --git a/mythtv/libs/libmythtv/AirPlay/mythraopconnection.cpp b/mythtv/libs/libmythtv/AirPlay/mythraopconnection.cpp
index ecae5272d22..f468e8a331a 100644
--- a/mythtv/libs/libmythtv/AirPlay/mythraopconnection.cpp
+++ b/mythtv/libs/libmythtv/AirPlay/mythraopconnection.cpp
@@ -9,6 +9,7 @@
 #include "serverpool.h"
 
 #include "audiooutput.h"
+#include "audiooutpututil.h"
 
 #include "mythraopdevice.h"
 #include "mythraopconnection.h"
@@ -615,33 +616,28 @@ uint32_t MythRAOPConnection::decodeAudioPacket(uint8_t type,
     tmp_pkt.size = len;
 
     uint32_t frames_added = 0;
+    uint8_t *samples = (uint8_t *)av_mallocz(AVCODEC_MAX_AUDIO_FRAME_SIZE);
     while (tmp_pkt.size > 0)
     {
-        uint8_t *samples = (uint8_t *)av_mallocz(AVCODEC_MAX_AUDIO_FRAME_SIZE);
-        AVFrame frame;
-        int got_frame = 0;
-
-        int ret = avcodec_decode_audio4(ctx, &frame, &got_frame, &tmp_pkt);
-
+        int data_size;
+        int ret = AudioOutputUtil::DecodeAudio(ctx, samples,
+                                               data_size, &tmp_pkt);
         if (ret < 0)
         {
             av_free(samples);
             return -1;
         }
 
-        if (got_frame)
+        if (data_size)
         {
-            // ALAC codec isn't planar
-            int data_size = av_samples_get_buffer_size(NULL, ctx->channels,
-                                                       frame.nb_samples,
-                                                       ctx->sample_fmt, 1);
-            memcpy(samples, frame.extended_data[0], data_size);
+            int num_samples = data_size /
+	      (ctx->channels * av_get_bytes_per_sample(ctx->sample_fmt));
 
-            frames_added += frame.nb_samples;
+            frames_added += num_samples;
             AudioData block;
             block.data    = samples;
             block.length  = data_size;
-            block.frames  = frame.nb_samples;
+            block.frames  = num_samples;
             dest->append(block);
         }
         tmp_pkt.data += ret;
diff --git a/mythtv/libs/libmythtv/avformatdecoder.cpp b/mythtv/libs/libmythtv/avformatdecoder.cpp
index 70060c0e646..7c6af7b461b 100644
--- a/mythtv/libs/libmythtv/avformatdecoder.cpp
+++ b/mythtv/libs/libmythtv/avformatdecoder.cpp
@@ -64,7 +64,6 @@ extern "C" {
 #include "libavutil/avutil.h"
 #include "libavutil/log.h"
 #include "libavcodec/avcodec.h"
-#include "libavcodec/ac3_parser.h"
 #include "libavcodec/mpegvideo.h"
 #include "libavformat/avformat.h"
 #include "libavformat/avio.h"
@@ -1363,8 +1362,8 @@ void AvFormatDecoder::InitVideoCodec(AVStream *stream, AVCodecContext *enc,
     {
         enc->flags2 |= CODEC_FLAG2_FAST;
 
-        if ((CODEC_ID_MPEG2VIDEO == codec->id) ||
-            (CODEC_ID_MPEG1VIDEO == codec->id))
+        if ((AV_CODEC_ID_MPEG2VIDEO == codec->id) ||
+            (AV_CODEC_ID_MPEG1VIDEO == codec->id))
         {
             if (FlagIsSet(kDecodeFewBlocks))
             {
@@ -1376,7 +1375,7 @@ void AvFormatDecoder::InitVideoCodec(AVStream *stream, AVCodecContext *enc,
             if (FlagIsSet(kDecodeLowRes))
                 enc->lowres = 2; // 1 = 1/2 size, 2 = 1/4 size
         }
-        else if (CODEC_ID_H264 == codec->id)
+        else if (AV_CODEC_ID_H264 == codec->id)
         {
             if (FlagIsSet(kDecodeNoLoopFilter))
             {
@@ -1417,21 +1416,21 @@ void AvFormatDecoder::InitVideoCodec(AVStream *stream, AVCodecContext *enc,
 
             switch (enc->codec_id)
             {
-                case CODEC_ID_H263:
-                case CODEC_ID_MPEG4:
-                case CODEC_ID_MSMPEG4V1:
-                case CODEC_ID_MSMPEG4V2:
-                case CODEC_ID_MSMPEG4V3:
-                case CODEC_ID_H263P:
-                case CODEC_ID_H263I:
+                case AV_CODEC_ID_H263:
+                case AV_CODEC_ID_MPEG4:
+                case AV_CODEC_ID_MSMPEG4V1:
+                case AV_CODEC_ID_MSMPEG4V2:
+                case AV_CODEC_ID_MSMPEG4V3:
+                case AV_CODEC_ID_H263P:
+                case AV_CODEC_ID_H263I:
                     video_format = VIDEO_DIVX;
                     break;
-                case CODEC_ID_WMV1:
-                case CODEC_ID_WMV2:
+                case AV_CODEC_ID_WMV1:
+                case AV_CODEC_ID_WMV2:
                     video_format = VIDEO_WMV;
                     break;
 #if 0
-                case CODEC_ID_XVID:
+                case AV_CODEC_ID_XVID:
                     video_format = VIDEO_XVID;
                     break;
 #endif
@@ -1873,8 +1872,8 @@ int AvFormatDecoder::ScanStreams(bool novideo)
                     // Needed for broken transmitters which mark
                     // MPEG2 streams as MPEG1 streams, and should
                     // be harmless for unbroken ones.
-                    if (enc->codec_id == CODEC_ID_MPEG1VIDEO)
-                        enc->codec_id = CODEC_ID_MPEG2VIDEO;
+                    if (enc->codec_id == AV_CODEC_ID_MPEG1VIDEO)
+                        enc->codec_id = AV_CODEC_ID_MPEG2VIDEO;
                     // HACK -- end
 #endif // USING_VDPAU
 #ifdef USING_VDPAU
@@ -2007,9 +2006,9 @@ int AvFormatDecoder::ScanStreams(bool novideo)
             }
             case AVMEDIA_TYPE_SUBTITLE:
             {
-                if (enc->codec_id == CODEC_ID_DVB_TELETEXT)
+                if (enc->codec_id == AV_CODEC_ID_DVB_TELETEXT)
                     ScanTeletextCaptions(i);
-                if (enc->codec_id == CODEC_ID_TEXT)
+                if (enc->codec_id == AV_CODEC_ID_TEXT)
                     ScanRawTextCaptions(i);
                 bitrate += enc->bit_rate;
 
@@ -2027,7 +2026,7 @@ int AvFormatDecoder::ScanStreams(bool novideo)
             }
             case AVMEDIA_TYPE_ATTACHMENT:
             {
-                if (enc->codec_id == CODEC_ID_TTF)
+                if (enc->codec_id == AV_CODEC_ID_TTF)
                    tracks[kTrackTypeAttachment].push_back(
                        StreamInfo(i, 0, 0, ic->streams[i]->id, 0));
                 bitrate += enc->bit_rate;
@@ -2053,14 +2052,14 @@ int AvFormatDecoder::ScanStreams(bool novideo)
 
         // skip DVB teletext and text subs, there is no libavcodec decoder
         if (enc->codec_type == AVMEDIA_TYPE_SUBTITLE &&
-           (enc->codec_id   == CODEC_ID_DVB_TELETEXT ||
-            enc->codec_id   == CODEC_ID_TEXT))
+           (enc->codec_id   == AV_CODEC_ID_DVB_TELETEXT ||
+            enc->codec_id   == AV_CODEC_ID_TEXT))
             continue;
 
         LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("Looking for decoder for %1")
                 .arg(ff_codec_id_string(enc->codec_id)));
 
-        if (enc->codec_id == CODEC_ID_PROBE)
+        if (enc->codec_id == AV_CODEC_ID_PROBE)
         {
             LOG(VB_GENERAL, LOG_ERR, LOC +
                 QString("Probing of stream #%1 unsuccesful, ignoring.").arg(i));
@@ -2232,7 +2231,7 @@ int AvFormatDecoder::ScanStreams(bool novideo)
     // waiting on audio.
     if (m_audio->HasAudioIn() && tracks[kTrackTypeAudio].empty())
     {
-        m_audio->SetAudioParams(FORMAT_NONE, -1, -1, CODEC_ID_NONE, -1, false);
+        m_audio->SetAudioParams(FORMAT_NONE, -1, -1, AV_CODEC_ID_NONE, -1, false);
         m_audio->ReinitAudio();
         if (ringBuffer && ringBuffer->IsDVD())
             audioIn = AudioInfo();
@@ -2931,7 +2930,7 @@ void AvFormatDecoder::MpegPreProcessPkt(AVStream *stream, AVPacket *pkt)
             uint  width  = seq->width()  >> context->lowres;
             uint  height = seq->height() >> context->lowres;
             current_aspect = seq->aspect(context->codec_id ==
-                                         CODEC_ID_MPEG1VIDEO);
+                                         AV_CODEC_ID_MPEG1VIDEO);
             if (aspect_override > 0.0f)
                 current_aspect = aspect_override;
             float seqFPS = seq->fps();
@@ -3088,7 +3087,7 @@ bool AvFormatDecoder::H264PreProcessPkt(AVStream *stream, AVPacket *pkt)
                     (enc->codec) && (enc->thread_count>1))
                 {
                     QMutexLocker locker(avcodeclock);
-                    AVCodec *codec = enc->codec;
+                    const AVCodec *codec = enc->codec;
                     avcodec_close(enc);
                     int open_val = avcodec_open2(enc, codec, NULL);
                     if (open_val < 0)
@@ -3621,7 +3620,7 @@ bool AvFormatDecoder::ProcessSubtitlePacket(AVStream *curstream, AVPacket *pkt)
                 .arg(subtitle.end_display_time));
 
         bool forcedon = m_parent->GetSubReader(pkt->stream_index)->AddAVSubtitle(
-               subtitle, curstream->codec->codec_id == CODEC_ID_XSUB,
+               subtitle, curstream->codec->codec_id == AV_CODEC_ID_XSUB,
                m_parent->GetAllowForcedSubtitles());
         m_parent->EnableForcedSubtitles(forcedon || isForcedTrack);
     }
@@ -3659,13 +3658,13 @@ bool AvFormatDecoder::ProcessDataPacket(AVStream *curstream, AVPacket *pkt,
 
     switch (codec_id)
     {
-        case CODEC_ID_MPEG2VBI:
+        case AV_CODEC_ID_MPEG2VBI:
             ProcessVBIDataPacket(curstream, pkt);
             break;
-        case CODEC_ID_DVB_VBI:
+        case AV_CODEC_ID_DVB_VBI:
             ProcessDVBDataPacket(curstream, pkt);
             break;
-        case CODEC_ID_DSMCC_B:
+        case AV_CODEC_ID_DSMCC_B:
         {
             ProcessDSMCCPacket(curstream, pkt);
             GenerateDummyVideoFrames();
@@ -3718,7 +3717,7 @@ QString AvFormatDecoder::GetTrackDesc(uint type, uint trackNo) const
 
                 if (s)
                 {
-                    if (s->codec->codec_id == CODEC_ID_MP3)
+                    if (s->codec->codec_id == AV_CODEC_ID_MP3)
                         msg += QString(" MP%1").arg(s->codec->sub_id);
                     else if (s->codec->codec)
                         msg += QString(" %1").arg(s->codec->codec->name).toUpper();
@@ -3897,10 +3896,10 @@ int AvFormatDecoder::filter_max_ch(const AVFormatContext *ic,
     {
         const int stream_index = tracks[*it].av_stream_index;
         const AVCodecContext *ctx = ic->streams[stream_index]->codec;
-        if ((codecId == CODEC_ID_NONE || codecId == ctx->codec_id) &&
+        if ((codecId == AV_CODEC_ID_NONE || codecId == ctx->codec_id) &&
             (max_seen < ctx->channels))
         {
-            if (codecId == CODEC_ID_DTS && profile > 0)
+            if (codecId == AV_CODEC_ID_DTS && profile > 0)
             {
                 // we cannot decode dts-hd, so only select it if passthrough
                 if (!DoPassThrough(ctx, true) || ctx->profile != profile)
@@ -4060,22 +4059,22 @@ int AvFormatDecoder::AutoSelectAudioTrack(void)
         vector<int> flang = filter_lang(atracks, canonical_key, ftype);
 
         if (m_audio->CanDTSHD())
-            selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_DTS,
+            selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_DTS,
                                      FF_PROFILE_DTS_HD_MA);
         if (selTrack < 0)
-            selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_TRUEHD);
+            selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_TRUEHD);
 
         if (selTrack < 0 && m_audio->CanDTSHD())
-            selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_DTS,
+            selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_DTS,
                                      FF_PROFILE_DTS_HD_HRA);
         if (selTrack < 0)
-            selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_EAC3);
+            selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_EAC3);
 
         if (selTrack < 0)
-            selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_DTS);
+            selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_DTS);
 
         if (selTrack < 0)
-            selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_AC3);
+            selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_AC3);
 
         if (selTrack < 0)
             selTrack = filter_max_ch(ic, atracks, flang);
@@ -4090,25 +4089,25 @@ int AvFormatDecoder::AutoSelectAudioTrack(void)
                 vector<int> flang = filter_lang(atracks, *it, ftype);
 
                 if (m_audio->CanDTSHD())
-                    selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_DTS,
+                    selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_DTS,
                                              FF_PROFILE_DTS_HD_MA);
                 if (selTrack < 0)
                     selTrack = filter_max_ch(ic, atracks, flang,
-                                             CODEC_ID_TRUEHD);
+                                             AV_CODEC_ID_TRUEHD);
 
                 if (selTrack < 0 && m_audio->CanDTSHD())
-                    selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_DTS,
+                    selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_DTS,
                                              FF_PROFILE_DTS_HD_HRA);
 
                 if (selTrack < 0)
                     selTrack = filter_max_ch(ic, atracks, flang,
-                                             CODEC_ID_EAC3);
+                                             AV_CODEC_ID_EAC3);
 
                 if (selTrack < 0)
-                    selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_DTS);
+                    selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_DTS);
 
                 if (selTrack < 0)
-                    selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_AC3);
+                    selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_AC3);
 
                 if (selTrack < 0)
                     selTrack = filter_max_ch(ic, atracks, flang);
@@ -4122,23 +4121,23 @@ int AvFormatDecoder::AutoSelectAudioTrack(void)
             vector<int> flang = filter_lang(atracks, -1, ftype);
 
             if (m_audio->CanDTSHD())
-                selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_DTS,
+                selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_DTS,
                                          FF_PROFILE_DTS_HD_MA);
             if (selTrack < 0)
-                selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_TRUEHD);
+                selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_TRUEHD);
 
             if (selTrack < 0 && m_audio->CanDTSHD())
-                selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_DTS,
+                selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_DTS,
                                          FF_PROFILE_DTS_HD_HRA);
 
             if (selTrack < 0)
-                selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_EAC3);
+                selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_EAC3);
 
             if (selTrack < 0)
-                selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_DTS);
+                selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_DTS);
 
             if (selTrack < 0)
-                selTrack = filter_max_ch(ic, atracks, flang, CODEC_ID_AC3);
+                selTrack = filter_max_ch(ic, atracks, flang, AV_CODEC_ID_AC3);
 
             if (selTrack < 0)
                 selTrack = filter_max_ch(ic, atracks, flang);
@@ -4257,11 +4256,11 @@ bool AvFormatDecoder::ProcessAudioPacket(AVStream *curstream, AVPacket *pkt,
             else // No passthru, the decoder will downmix
             {
                 ctx->request_channels = m_audio->GetMaxChannels();
-                if (ctx->codec_id == CODEC_ID_AC3)
+                if (ctx->codec_id == AV_CODEC_ID_AC3)
                     ctx->channels = m_audio->GetMaxChannels();
             }
 
-            ret = DecodeAudio(ctx, audioSamples, data_size, &tmp_pkt);
+            ret = AudioOutputUtil::DecodeAudio(ctx, audioSamples, data_size, &tmp_pkt);
             decoded_size = data_size;
             already_decoded = true;
             reselectAudioTrack |= ctx->channels;
@@ -4312,7 +4311,7 @@ bool AvFormatDecoder::ProcessAudioPacket(AVStream *curstream, AVPacket *pkt,
             {
                 if (m_audio->NeedDecodingBeforePassthrough())
                 {
-                    ret = DecodeAudio(ctx, audioSamples, data_size, &tmp_pkt);
+                    ret = AudioOutputUtil::DecodeAudio(ctx, audioSamples, data_size, &tmp_pkt);
                     decoded_size = data_size;
                 }
                 else
@@ -4330,13 +4329,13 @@ bool AvFormatDecoder::ProcessAudioPacket(AVStream *curstream, AVPacket *pkt,
                 if (DecoderWillDownmix(ctx))
                 {
                     ctx->request_channels = m_audio->GetMaxChannels();
-                    if (ctx->codec_id == CODEC_ID_AC3)
+                    if (ctx->codec_id == AV_CODEC_ID_AC3)
                         ctx->channels = m_audio->GetMaxChannels();
                 }
                 else
                     ctx->request_channels = 0;
 
-                ret = DecodeAudio(ctx, audioSamples, data_size, &tmp_pkt);
+                ret = AudioOutputUtil::DecodeAudio(ctx, audioSamples, data_size, &tmp_pkt);
                 decoded_size = data_size;
             }
 
@@ -4402,39 +4401,6 @@ bool AvFormatDecoder::ProcessAudioPacket(AVStream *curstream, AVPacket *pkt,
     return true;
 }
 
-int AvFormatDecoder::DecodeAudio(AVCodecContext *ctx,
-                                 uint8_t *buffer, int &data_size,
-                                 AVPacket *pkt)
-{
-    AVFrame frame;
-    int got_frame = 0;
-
-    int ret = avcodec_decode_audio4(ctx, &frame, &got_frame, pkt);
-    if (ret < 0 || !got_frame)
-    {
-        data_size = 0;
-        return ret;
-    }
-
-    int plane_size;
-    int planar = av_sample_fmt_is_planar(ctx->sample_fmt);
-    data_size = av_samples_get_buffer_size(&plane_size, ctx->channels,
-                                           frame.nb_samples,
-                                           ctx->sample_fmt, 1);
-    memcpy(buffer, frame.extended_data[0], plane_size);
-
-    if (planar && ctx->channels > 1)
-    {
-        uint8_t *out = buffer + plane_size;
-        for (int i = 1; i < ctx->channels; i++)
-        {
-            memcpy(out, frame.extended_data[i], plane_size);
-            out += plane_size;
-        }
-    }
-    return ret;
-}
-
 // documented in decoderbase.h
 bool AvFormatDecoder::GetFrame(DecodeType decodetype)
 {
@@ -4628,7 +4594,7 @@ bool AvFormatDecoder::GetFrame(DecodeType decodetype)
         }
 
         if (codec_type == AVMEDIA_TYPE_SUBTITLE &&
-            curstream->codec->codec_id == CODEC_ID_TEXT)
+            curstream->codec->codec_id == AV_CODEC_ID_TEXT)
         {
             ProcessRawTextPacket(pkt);
             av_free_packet(pkt);
@@ -4636,7 +4602,7 @@ bool AvFormatDecoder::GetFrame(DecodeType decodetype)
         }
 
         if (codec_type == AVMEDIA_TYPE_SUBTITLE &&
-            curstream->codec->codec_id == CODEC_ID_DVB_TELETEXT)
+            curstream->codec->codec_id == AV_CODEC_ID_DVB_TELETEXT)
         {
             ProcessDVBDataPacket(curstream, pkt);
             av_free_packet(pkt);
@@ -4841,9 +4807,9 @@ inline bool AvFormatDecoder::DecoderWillDownmix(const AVCodecContext *ctx)
     // use ffmpeg only for dolby codecs if we have to
     switch (ctx->codec_id)
     {
-        case CODEC_ID_AC3:
-        case CODEC_ID_TRUEHD:
-        case CODEC_ID_EAC3:
+        case AV_CODEC_ID_AC3:
+        case AV_CODEC_ID_TRUEHD:
+        case AV_CODEC_ID_EAC3:
             return true;
         default:
             return false;
@@ -4856,7 +4822,7 @@ bool AvFormatDecoder::DoPassThrough(const AVCodecContext *ctx, bool withProfile)
 
     // if withProfile == false, we will accept any DTS stream regardless
     // of its profile. We do so, so we can bitstream DTS-HD as DTS core
-    if (!withProfile && ctx->codec_id == CODEC_ID_DTS && !m_audio->CanDTSHD())
+    if (!withProfile && ctx->codec_id == AV_CODEC_ID_DTS && !m_audio->CanDTSHD())
         passthru = m_audio->CanPassthrough(ctx->sample_rate, ctx->channels,
                                            ctx->codec_id, FF_PROFILE_DTS);
     else
@@ -4895,8 +4861,14 @@ bool AvFormatDecoder::SetupAudioStream(void)
         ctx = curstream->codec;
         orig_channels = selectedTrack[kTrackTypeAudio].orig_num_channels;
         AudioFormat fmt;
+        AVSampleFormat format_pack = av_get_packed_sample_fmt(ctx->sample_fmt);
+
+        if (format_pack != ctx->sample_fmt)
+        {
+            LOG(VB_AUDIO, LOG_INFO, LOC + QString("Audio data is planar"));
+        }
 
-        switch (ctx->sample_fmt)
+        switch (format_pack)
         {
             case AV_SAMPLE_FMT_U8:     fmt = FORMAT_U8;    break;
             case AV_SAMPLE_FMT_S16:    fmt = FORMAT_S16;   break;
@@ -4938,7 +4910,7 @@ bool AvFormatDecoder::SetupAudioStream(void)
 
         info = AudioInfo(ctx->codec_id, fmt, ctx->sample_rate,
                          ctx->channels, using_passthru, orig_channels,
-                         ctx->codec_id == CODEC_ID_DTS ? ctx->profile : 0);
+                         ctx->codec_id == AV_CODEC_ID_DTS ? ctx->profile : 0);
     }
 
     if (!ctx)
@@ -4973,25 +4945,25 @@ bool AvFormatDecoder::SetupAudioStream(void)
 
         switch (ctx->codec_id)
         {
-            case CODEC_ID_MP2:
+            case AV_CODEC_ID_MP2:
                 audio_format = AUDIO_MPEG2;
                 break;
-            case CODEC_ID_MP3:
+            case AV_CODEC_ID_MP3:
                 audio_format = AUDIO_MP3;
                 break;
-            case CODEC_ID_AC3:
+            case AV_CODEC_ID_AC3:
                 audio_format = AUDIO_AC3;
                 break;
-            case CODEC_ID_DTS:
+            case AV_CODEC_ID_DTS:
                 audio_format = AUDIO_DTS;
                 break;
-            case CODEC_ID_VORBIS:
+            case AV_CODEC_ID_VORBIS:
                 audio_format = AUDIO_OGG;
                 break;
-            case CODEC_ID_WMAV1:
+            case AV_CODEC_ID_WMAV1:
                 audio_format = AUDIO_WMA;
                 break;
-            case CODEC_ID_WMAV2:
+            case AV_CODEC_ID_WMAV2:
                 audio_format = AUDIO_WMA2;
                 break;
             default:
diff --git a/mythtv/libs/libmythtv/avformatdecoder.h b/mythtv/libs/libmythtv/avformatdecoder.h
index 3d0ec2a82aa..8cd7d1207cd 100644
--- a/mythtv/libs/libmythtv/avformatdecoder.h
+++ b/mythtv/libs/libmythtv/avformatdecoder.h
@@ -13,6 +13,7 @@
 #include "decoderbase.h"
 #include "privatedecoder.h"
 #include "audiooutputsettings.h"
+#include "audiooutpututil.h"
 #include "spdifencoder.h"
 #include "vbilut.h"
 #include "H264Parser.h"
@@ -46,7 +47,7 @@ class AudioInfo
 {
   public:
     AudioInfo() :
-        codec_id(CODEC_ID_NONE), format(FORMAT_NONE), sample_size(-2),
+        codec_id(AV_CODEC_ID_NONE), format(FORMAT_NONE), sample_size(-2),
         sample_rate(-1), channels(-1), codec_profile(0),
         do_passthru(false), original_channels(-1)
     {;}
@@ -197,7 +198,7 @@ class AvFormatDecoder : public DecoderBase
     int  filter_max_ch(const AVFormatContext *ic,
                        const sinfo_vec_t     &tracks,
                        const vector<int>     &fs,
-                       enum CodecID           codecId = CODEC_ID_NONE,
+                       enum CodecID           codecId = AV_CODEC_ID_NONE,
                        int                    profile = -1);
 
     friend int get_avf_buffer(struct AVCodecContext *c, AVFrame *pic);
diff --git a/mythtv/libs/libmythtv/avformatwriter.cpp b/mythtv/libs/libmythtv/avformatwriter.cpp
index 80044f7062d..e921c8adb37 100644
--- a/mythtv/libs/libmythtv/avformatwriter.cpp
+++ b/mythtv/libs/libmythtv/avformatwriter.cpp
@@ -124,7 +124,7 @@ bool AVFormatWriter::Init(void)
         m_fmt.video_codec = m_avVideoCodec->id;
     }
     else
-        m_fmt.video_codec = CODEC_ID_NONE;
+        m_fmt.video_codec = AV_CODEC_ID_NONE;
 
     m_avAudioCodec = avcodec_find_encoder_by_name(
         m_audioCodec.toAscii().constData());
@@ -153,9 +153,9 @@ bool AVFormatWriter::Init(void)
     snprintf(m_ctx->filename, sizeof(m_ctx->filename), "%s",
              m_filename.toAscii().constData());
 
-    if (m_fmt.video_codec != CODEC_ID_NONE)
+    if (m_fmt.video_codec != AV_CODEC_ID_NONE)
         m_videoStream = AddVideoStream();
-    if (m_fmt.audio_codec != CODEC_ID_NONE)
+    if (m_fmt.audio_codec != AV_CODEC_ID_NONE)
         m_audioStream = AddAudioStream();
 
     m_pkt = new AVPacket;
@@ -489,14 +489,14 @@ AVStream* AVFormatWriter::AddVideoStream(void)
     c->thread_count               = m_encodingThreadCount;
     c->thread_type                = FF_THREAD_SLICE;
 
-    if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
+    if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
         c->max_b_frames          = 2;
     }
-    else if (c->codec_id == CODEC_ID_MPEG1VIDEO)
+    else if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO)
     {
         c->mb_decision           = 2;
     }
-    else if (c->codec_id == CODEC_ID_H264)
+    else if (c->codec_id == AV_CODEC_ID_H264)
     {
 
         if ((c->width > 480) ||
diff --git a/mythtv/libs/libmythtv/mythcodecid.cpp b/mythtv/libs/libmythtv/mythcodecid.cpp
index 05297ee0eec..11f9aaba11f 100644
--- a/mythtv/libs/libmythtv/mythcodecid.cpp
+++ b/mythtv/libs/libmythtv/mythcodecid.cpp
@@ -96,47 +96,47 @@ QString toString(MythCodecID codecid)
 int myth2av_codecid(MythCodecID codec_id, bool &vdpau)
 {
     vdpau = false;
-    CodecID ret = CODEC_ID_NONE;
+    CodecID ret = AV_CODEC_ID_NONE;
     switch (codec_id)
     {
         case kCodec_NONE:
         case kCodec_NUV_MPEG4:
         case kCodec_NUV_RTjpeg:
-            ret = CODEC_ID_NONE;
+            ret = AV_CODEC_ID_NONE;
             break;
 
         case kCodec_MPEG1:
-            ret = CODEC_ID_MPEG1VIDEO;
+            ret = AV_CODEC_ID_MPEG1VIDEO;
             break;
         case kCodec_MPEG2:
-            ret = CODEC_ID_MPEG2VIDEO;
+            ret = AV_CODEC_ID_MPEG2VIDEO;
             break;
         case kCodec_H263:
-            ret = CODEC_ID_H263;
+            ret = AV_CODEC_ID_H263;
             break;
         case kCodec_MPEG4:
-            ret = CODEC_ID_MPEG4;
+            ret = AV_CODEC_ID_MPEG4;
             break;
         case kCodec_H264:
-            ret = CODEC_ID_H264;
+            ret = AV_CODEC_ID_H264;
             break;
         case kCodec_VP8:
-            ret = CODEC_ID_VP8;
+            ret = AV_CODEC_ID_VP8;
             break;
 
         case kCodec_VC1:
-            ret = CODEC_ID_VC1;
+            ret = AV_CODEC_ID_VC1;
             break;
         case kCodec_WMV3:
-            ret = CODEC_ID_WMV3;
+            ret = AV_CODEC_ID_WMV3;
             break;
 
         case kCodec_MPEG1_VDPAU:
-            ret = CODEC_ID_MPEG1VIDEO;
+            ret = AV_CODEC_ID_MPEG1VIDEO;
             vdpau = true;
             break;
         case kCodec_MPEG2_VDPAU:
-            ret = CODEC_ID_MPEG2VIDEO;
+            ret = AV_CODEC_ID_MPEG2VIDEO;
             vdpau = true;
             break;
         case kCodec_H263_VDPAU:
@@ -144,73 +144,73 @@ int myth2av_codecid(MythCodecID codec_id, bool &vdpau)
                 "Error: VDPAU H.263 not supported by ffmpeg");
             break;
         case kCodec_MPEG4_VDPAU:
-            ret = CODEC_ID_MPEG4;
+            ret = AV_CODEC_ID_MPEG4;
             break;
 
         case kCodec_H264_VDPAU:
-            ret = CODEC_ID_H264;
+            ret = AV_CODEC_ID_H264;
             vdpau = true;
             break;
         case kCodec_VC1_VDPAU:
-            ret = CODEC_ID_VC1;
+            ret = AV_CODEC_ID_VC1;
             vdpau = true;
             break;
         case kCodec_WMV3_VDPAU:
-            ret = CODEC_ID_WMV3;
+            ret = AV_CODEC_ID_WMV3;
             vdpau = true;
             break;
         case kCodec_VP8_VDPAU:
-            ret = CODEC_ID_VP8;
+            ret = AV_CODEC_ID_VP8;
             break;
 
         case kCodec_MPEG1_VAAPI:
-            ret = CODEC_ID_MPEG1VIDEO;
+            ret = AV_CODEC_ID_MPEG1VIDEO;
             break;
         case kCodec_MPEG2_VAAPI:
-            ret = CODEC_ID_MPEG2VIDEO;
+            ret = AV_CODEC_ID_MPEG2VIDEO;
             break;
         case kCodec_H263_VAAPI:
-            ret = CODEC_ID_H263;
+            ret = AV_CODEC_ID_H263;
             break;
         case kCodec_MPEG4_VAAPI:
-            ret = CODEC_ID_MPEG4;
+            ret = AV_CODEC_ID_MPEG4;
             break;
         case kCodec_H264_VAAPI:
-            ret = CODEC_ID_H264;
+            ret = AV_CODEC_ID_H264;
             break;
         case kCodec_VC1_VAAPI:
-            ret = CODEC_ID_VC1;
+            ret = AV_CODEC_ID_VC1;
             break;
         case kCodec_WMV3_VAAPI:
-            ret = CODEC_ID_WMV3;
+            ret = AV_CODEC_ID_WMV3;
             break;
         case kCodec_VP8_VAAPI:
-            ret = CODEC_ID_VP8;
+            ret = AV_CODEC_ID_VP8;
             break;
 
         case kCodec_MPEG1_DXVA2:
-            ret = CODEC_ID_MPEG1VIDEO;
+            ret = AV_CODEC_ID_MPEG1VIDEO;
             break;
         case kCodec_MPEG2_DXVA2:
-            ret = CODEC_ID_MPEG2VIDEO;
+            ret = AV_CODEC_ID_MPEG2VIDEO;
             break;
         case kCodec_H263_DXVA2:
-            ret = CODEC_ID_H263;
+            ret = AV_CODEC_ID_H263;
             break;
         case kCodec_MPEG4_DXVA2:
-            ret = CODEC_ID_MPEG4;
+            ret = AV_CODEC_ID_MPEG4;
             break;
         case kCodec_H264_DXVA2:
-            ret = CODEC_ID_H264;
+            ret = AV_CODEC_ID_H264;
             break;
         case kCodec_VC1_DXVA2:
-            ret = CODEC_ID_VC1;
+            ret = AV_CODEC_ID_VC1;
             break;
         case kCodec_WMV3_DXVA2:
-            ret = CODEC_ID_WMV3;
+            ret = AV_CODEC_ID_WMV3;
             break;
         case kCodec_VP8_DXVA2:
-            ret = CODEC_ID_VP8;
+            ret = AV_CODEC_ID_VP8;
             break;
 
         default:
@@ -226,21 +226,21 @@ int mpeg_version(int codec_id)
 {
     switch (codec_id)
     {
-        case CODEC_ID_MPEG1VIDEO:
+        case AV_CODEC_ID_MPEG1VIDEO:
             return 1;
-        case CODEC_ID_MPEG2VIDEO:
+        case AV_CODEC_ID_MPEG2VIDEO:
             return 2;
-        case CODEC_ID_H263:
+        case AV_CODEC_ID_H263:
             return 3;
-        case CODEC_ID_MPEG4:
+        case AV_CODEC_ID_MPEG4:
             return 4;
-        case CODEC_ID_H264:
+        case AV_CODEC_ID_H264:
             return 5;
-        case CODEC_ID_VC1:
+        case AV_CODEC_ID_VC1:
             return 6;
-        case CODEC_ID_WMV3:
+        case AV_CODEC_ID_WMV3:
             return 7;
-        case CODEC_ID_VP8:
+        case AV_CODEC_ID_VP8:
             return 8;
         default:
             break;
diff --git a/mythtv/libs/libmythtv/nuppeldecoder.cpp b/mythtv/libs/libmythtv/nuppeldecoder.cpp
index d606c62128a..efe21f7773c 100644
--- a/mythtv/libs/libmythtv/nuppeldecoder.cpp
+++ b/mythtv/libs/libmythtv/nuppeldecoder.cpp
@@ -526,7 +526,7 @@ int NuppelDecoder::OpenFile(RingBuffer *rbuffer, bool novideo,
 
         m_audio->SetAudioParams(format, extradata.audio_channels,
                                 extradata.audio_channels,
-                                CODEC_ID_NONE, extradata.audio_sample_rate,
+                                AV_CODEC_ID_NONE, extradata.audio_sample_rate,
                                 false /* AC3/DTS pass through */);
         m_audio->ReinitAudio();
         foundit = 1;
@@ -665,18 +665,18 @@ bool NuppelDecoder::InitAVCodecVideo(int codec)
     {
         switch(extradata.video_fourcc)
         {
-            case FOURCC_DIVX: codec = CODEC_ID_MPEG4;      break;
-            case FOURCC_WMV1: codec = CODEC_ID_WMV1;       break;
-            case FOURCC_DIV3: codec = CODEC_ID_MSMPEG4V3;  break;
-            case FOURCC_MP42: codec = CODEC_ID_MSMPEG4V2;  break;
-            case FOURCC_MPG4: codec = CODEC_ID_MSMPEG4V1;  break;
-            case FOURCC_MJPG: codec = CODEC_ID_MJPEG;      break;
-            case FOURCC_H263: codec = CODEC_ID_H263;       break;
-            case FOURCC_H264: codec = CODEC_ID_H264;       break;
-            case FOURCC_I263: codec = CODEC_ID_H263I;      break;
-            case FOURCC_MPEG: codec = CODEC_ID_MPEG1VIDEO; break;
-            case FOURCC_MPG2: codec = CODEC_ID_MPEG2VIDEO; break;
-            case FOURCC_HFYU: codec = CODEC_ID_HUFFYUV;    break;
+            case FOURCC_DIVX: codec = AV_CODEC_ID_MPEG4;      break;
+            case FOURCC_WMV1: codec = AV_CODEC_ID_WMV1;       break;
+            case FOURCC_DIV3: codec = AV_CODEC_ID_MSMPEG4V3;  break;
+            case FOURCC_MP42: codec = AV_CODEC_ID_MSMPEG4V2;  break;
+            case FOURCC_MPG4: codec = AV_CODEC_ID_MSMPEG4V1;  break;
+            case FOURCC_MJPG: codec = AV_CODEC_ID_MJPEG;      break;
+            case FOURCC_H263: codec = AV_CODEC_ID_H263;       break;
+            case FOURCC_H264: codec = AV_CODEC_ID_H264;       break;
+            case FOURCC_I263: codec = AV_CODEC_ID_H263I;      break;
+            case FOURCC_MPEG: codec = AV_CODEC_ID_MPEG1VIDEO; break;
+            case FOURCC_MPG2: codec = AV_CODEC_ID_MPEG2VIDEO; break;
+            case FOURCC_HFYU: codec = AV_CODEC_ID_HUFFYUV;    break;
             default: codec = -1;
         }
     }
@@ -693,7 +693,7 @@ bool NuppelDecoder::InitAVCodecVideo(int codec)
         return false;
     }
 
-    if (mpa_vidcodec->capabilities & CODEC_CAP_DR1 && codec != CODEC_ID_MJPEG)
+    if (mpa_vidcodec->capabilities & CODEC_CAP_DR1 && codec != AV_CODEC_ID_MJPEG)
         directrendering = true;
 
     if (mpa_vidctx)
@@ -759,8 +759,8 @@ bool NuppelDecoder::InitAVCodecAudio(int codec)
     {
         switch(extradata.audio_fourcc)
         {
-            case FOURCC_LAME: codec = CODEC_ID_MP3;        break;
-            case FOURCC_AC3 : codec = CODEC_ID_AC3;        break;
+            case FOURCC_LAME: codec = AV_CODEC_ID_MP3;        break;
+            case FOURCC_AC3 : codec = AV_CODEC_ID_AC3;        break;
             default: codec = -1;
         }
     }
@@ -1245,9 +1245,9 @@ bool NuppelDecoder::GetFrame(DecodeType decodetype)
                 if (!mpa_audcodec)
                 {
                     if (frameheader.comptype == '3')
-                        InitAVCodecAudio(CODEC_ID_MP3);
+                        InitAVCodecAudio(AV_CODEC_ID_MP3);
                     else if (frameheader.comptype == 'A')
-                        InitAVCodecAudio(CODEC_ID_AC3);
+                        InitAVCodecAudio(AV_CODEC_ID_AC3);
                     else
                     {
                         LOG(VB_GENERAL, LOG_ERR, LOC + QString("GetFrame: "
diff --git a/mythtv/libs/libmythtv/privatedecoder_crystalhd.cpp b/mythtv/libs/libmythtv/privatedecoder_crystalhd.cpp
index f5cab385918..3a01d90c9fe 100644
--- a/mythtv/libs/libmythtv/privatedecoder_crystalhd.cpp
+++ b/mythtv/libs/libmythtv/privatedecoder_crystalhd.cpp
@@ -196,19 +196,19 @@ bool PrivateDecoderCrystalHD::Init(const QString &decoder,
 
     switch (avctx->codec_id)
     {
-        case CODEC_ID_MPEG4:
+        case AV_CODEC_ID_MPEG4:
             if (codecs & BC_DEC_FLAGS_M4P2)
                 sub_type = BC_MSUBTYPE_DIVX;
             break;
-        case CODEC_ID_MPEG1VIDEO:
+        case AV_CODEC_ID_MPEG1VIDEO:
             if (codecs & BC_DEC_FLAGS_MPEG2)
                 sub_type = BC_MSUBTYPE_MPEG1VIDEO;
             break;
-        case CODEC_ID_MPEG2VIDEO:
+        case AV_CODEC_ID_MPEG2VIDEO:
             if (codecs & BC_DEC_FLAGS_MPEG2)
                 sub_type = BC_MSUBTYPE_MPEG2VIDEO;
             break;
-        case CODEC_ID_VC1:
+        case AV_CODEC_ID_VC1:
             if (codecs & BC_DEC_FLAGS_VC1)
             {
                 if (avctx->codec_tag == MKTAG('W','V','C','1'))
@@ -217,11 +217,11 @@ bool PrivateDecoderCrystalHD::Init(const QString &decoder,
                     sub_type = BC_MSUBTYPE_VC1;
             }
             break;
-        case CODEC_ID_WMV3:
+        case AV_CODEC_ID_WMV3:
             if (codecs & BC_DEC_FLAGS_VC1)
                 sub_type = BC_MSUBTYPE_WMV3;
             break;
-        case CODEC_ID_H264:
+        case AV_CODEC_ID_H264:
             if (codecs & BC_DEC_FLAGS_H264)
             {
                 if (avctx->extradata[0] == 0x01)
@@ -248,7 +248,7 @@ bool PrivateDecoderCrystalHD::Init(const QString &decoder,
     }
 
     int nalsize = 4;
-    if (avctx->codec_id == CODEC_ID_H264)
+    if (avctx->codec_id == AV_CODEC_ID_H264)
     {
         LOG(VB_PLAYBACK, LOG_INFO, LOC +
             QString("H.264 Profile: %1 RefFrames: %2 Codec tag: %3")
diff --git a/mythtv/libs/libmythtv/privatedecoder_vda.cpp b/mythtv/libs/libmythtv/privatedecoder_vda.cpp
index cf68b129e6f..dac20678b2a 100644
--- a/mythtv/libs/libmythtv/privatedecoder_vda.cpp
+++ b/mythtv/libs/libmythtv/privatedecoder_vda.cpp
@@ -319,7 +319,7 @@ bool PrivateDecoderVDA::Init(const QString &decoder,
                              PlayerFlags flags,
                              AVCodecContext *avctx)
 {
-    if ((decoder != "vda") || (avctx->codec_id != CODEC_ID_H264) ||
+    if ((decoder != "vda") || (avctx->codec_id != AV_CODEC_ID_H264) ||
         !(flags & kDecodeAllowEXT) || !avctx)
         return false;
 
diff --git a/mythtv/libs/libmythtv/recorders/NuppelVideoRecorder.cpp b/mythtv/libs/libmythtv/recorders/NuppelVideoRecorder.cpp
index 6fb0a7407e0..2730c9a0320 100644
--- a/mythtv/libs/libmythtv/recorders/NuppelVideoRecorder.cpp
+++ b/mythtv/libs/libmythtv/recorders/NuppelVideoRecorder.cpp
@@ -2128,18 +2128,18 @@ void NuppelVideoRecorder::WriteHeader(void)
         int vidfcc = 0;
         switch(mpa_vidcodec->id)
         {
-            case CODEC_ID_MPEG4:      vidfcc = FOURCC_DIVX; break;
-            case CODEC_ID_WMV1:       vidfcc = FOURCC_WMV1; break;
-            case CODEC_ID_MSMPEG4V3:  vidfcc = FOURCC_DIV3; break;
-            case CODEC_ID_MSMPEG4V2:  vidfcc = FOURCC_MP42; break;
-            case CODEC_ID_MSMPEG4V1:  vidfcc = FOURCC_MPG4; break;
-            case CODEC_ID_MJPEG:      vidfcc = FOURCC_MJPG; break;
-            case CODEC_ID_H263:       vidfcc = FOURCC_H263; break;
-            case CODEC_ID_H263P:      vidfcc = FOURCC_H263; break;
-            case CODEC_ID_H263I:      vidfcc = FOURCC_I263; break;
-            case CODEC_ID_MPEG1VIDEO: vidfcc = FOURCC_MPEG; break;
-            case CODEC_ID_MPEG2VIDEO: vidfcc = FOURCC_MPG2; break;
-            case CODEC_ID_HUFFYUV:    vidfcc = FOURCC_HFYU; break;
+            case AV_CODEC_ID_MPEG4:      vidfcc = FOURCC_DIVX; break;
+            case AV_CODEC_ID_WMV1:       vidfcc = FOURCC_WMV1; break;
+            case AV_CODEC_ID_MSMPEG4V3:  vidfcc = FOURCC_DIV3; break;
+            case AV_CODEC_ID_MSMPEG4V2:  vidfcc = FOURCC_MP42; break;
+            case AV_CODEC_ID_MSMPEG4V1:  vidfcc = FOURCC_MPG4; break;
+            case AV_CODEC_ID_MJPEG:      vidfcc = FOURCC_MJPG; break;
+            case AV_CODEC_ID_H263:       vidfcc = FOURCC_H263; break;
+            case AV_CODEC_ID_H263P:      vidfcc = FOURCC_H263; break;
+            case AV_CODEC_ID_H263I:      vidfcc = FOURCC_I263; break;
+            case AV_CODEC_ID_MPEG1VIDEO: vidfcc = FOURCC_MPEG; break;
+            case AV_CODEC_ID_MPEG2VIDEO: vidfcc = FOURCC_MPG2; break;
+            case AV_CODEC_ID_HUFFYUV:    vidfcc = FOURCC_HFYU; break;
             default: break;
         }
         moredata.video_fourcc = vidfcc;
@@ -3016,7 +3016,7 @@ void NuppelVideoRecorder::WriteVideo(VideoFrame *frame, bool skipsync,
     // compr ends here
     if (useavcodec)
     {
-        if (mpa_vidcodec->id == CODEC_ID_RAWVIDEO)
+        if (mpa_vidcodec->id == AV_CODEC_ID_RAWVIDEO)
         {
             frameheader.comptype = '0';
             frameheader.packetlength = len;
diff --git a/mythtv/programs/mythtranscode/mpeg2fix.cpp b/mythtv/programs/mythtranscode/mpeg2fix.cpp
index 23184f19895..66635b1a6ce 100644
--- a/mythtv/programs/mythtranscode/mpeg2fix.cpp
+++ b/mythtv/programs/mythtranscode/mpeg2fix.cpp
@@ -585,12 +585,12 @@ void MPEG2fixup::InitReplex()
         strncpy(rx.extframe[i].language, lang, 4);
         switch(GetStreamType(it.key()))
         {
-            case CODEC_ID_MP2:
-            case CODEC_ID_MP3:
+            case AV_CODEC_ID_MP2:
+            case AV_CODEC_ID_MP3:
                 rx.exttype[i] = 2;
                 rx.exttypcnt[i] = mp2_count++;
                 break;
-            case CODEC_ID_AC3:
+            case AV_CODEC_ID_AC3:
                 rx.exttype[i] = 1;
                 rx.exttypcnt[i] = ac3_count++;
                 break;
@@ -642,9 +642,9 @@ int MPEG2fixup::AddFrame(MPEG2frame *f)
         iu.frame_off = f->framePos - f->pkt.data;
         iu.dts = f->pkt.dts * 300;
     }
-    else if (GetStreamType(id) == CODEC_ID_MP2 ||
-             GetStreamType(id) == CODEC_ID_MP3 ||
-             GetStreamType(id) == CODEC_ID_AC3)
+    else if (GetStreamType(id) == AV_CODEC_ID_MP2 ||
+             GetStreamType(id) == AV_CODEC_ID_MP3 ||
+             GetStreamType(id) == AV_CODEC_ID_AC3)
     {
         rb = &rx.extrbuf[aud_map[id]];
         rbi = &rx.index_extrbuf[aud_map[id]];
@@ -783,9 +783,9 @@ bool MPEG2fixup::InitAV(QString inputfile, const char *type, int64_t offset)
                         QString("Skipping invalid audio stream: %1").arg(i));
                     break;
                 }
-                if (inputFC->streams[i]->codec->codec_id == CODEC_ID_AC3 ||
-                    inputFC->streams[i]->codec->codec_id == CODEC_ID_MP3 ||
-                    inputFC->streams[i]->codec->codec_id == CODEC_ID_MP2)
+                if (inputFC->streams[i]->codec->codec_id == AV_CODEC_ID_AC3 ||
+                    inputFC->streams[i]->codec->codec_id == AV_CODEC_ID_MP3 ||
+                    inputFC->streams[i]->codec->codec_id == AV_CODEC_ID_MP2)
                 {
                     aud_map[i] = ext_count++;
                     aFrame[i] = new FrameList();
@@ -1110,7 +1110,7 @@ bool MPEG2fixup::BuildFrame(AVPacket *pkt, QString fname)
     picture->interlaced_frame = !(info->display_picture->flags &
                                   PIC_FLAG_PROGRESSIVE_FRAME);
 
-    out_codec = avcodec_find_encoder(CODEC_ID_MPEG2VIDEO);
+    out_codec = avcodec_find_encoder(AV_CODEC_ID_MPEG2VIDEO);
 
     if (!out_codec)
     {
diff --git a/mythtv/programs/mythtranscode/mpeg2fix.h b/mythtv/programs/mythtranscode/mpeg2fix.h
index fe74ac0f699..5263a74ec58 100644
--- a/mythtv/programs/mythtranscode/mpeg2fix.h
+++ b/mythtv/programs/mythtranscode/mpeg2fix.h
@@ -211,8 +211,8 @@ class MPEG2fixup
     }
     int GetStreamType(int id) const
     {
-        return (inputFC->streams[id]->codec->codec_id == CODEC_ID_AC3) ?
-               CODEC_ID_AC3 : CODEC_ID_MP2;
+        return (inputFC->streams[id]->codec->codec_id == AV_CODEC_ID_AC3) ?
+               AV_CODEC_ID_AC3 : AV_CODEC_ID_MP2;
     }
     AVCodecContext *getCodecContext(int id)
     {
diff --git a/mythtv/programs/mythtranscode/transcode.cpp b/mythtv/programs/mythtranscode/transcode.cpp
index 71cee6dbb9e..55220429491 100755
--- a/mythtv/programs/mythtranscode/transcode.cpp
+++ b/mythtv/programs/mythtranscode/transcode.cpp
@@ -842,22 +842,22 @@ int Transcode::TranscodeFile(const QString &inputname,
 
         switch(aplayer->GetCodec())
         {
-            case CODEC_ID_AC3:
+            case AV_CODEC_ID_AC3:
                 audio_codec_name = "ac3";
                 break;
-            case CODEC_ID_EAC3:
+            case AV_CODEC_ID_EAC3:
                 audio_codec_name = "eac3";
                 break;
-            case CODEC_ID_DTS:
+            case AV_CODEC_ID_DTS:
                 audio_codec_name = "dts";
                 break;
-            case CODEC_ID_TRUEHD:
+            case AV_CODEC_ID_TRUEHD:
                 audio_codec_name = "truehd";
                 break;
-            case CODEC_ID_MP3:
+            case AV_CODEC_ID_MP3:
                 audio_codec_name = "mp3";
                 break;
-            case CODEC_ID_MP2:
+            case AV_CODEC_ID_MP2:
                 audio_codec_name = "mp2";
                 break;
             default: