mlp: convert to new channel layout API

Signed-off-by: James Almer <jamrial@gmail.com>

5 files changed, 153 insertions, 99 deletions

diff --git a/libavcodec/mlp.c b/libavcodec/mlp.c
index dcec145eb0..3f54b2e448 100644
--- a/libavcodec/mlp.c
+++ b/libavcodec/mlp.c
@@ -57,12 +57,21 @@ const ChannelInformation ff_mlp_ch_info[21] = {
     { 0x3F, 0x04, 0x02, 0x00 },
 };
 
+#if FF_API_OLD_CHANNEL_LAYOUT
 const uint64_t ff_mlp_channel_layouts[12] = {
     AV_CH_LAYOUT_MONO, AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_2_1,
     AV_CH_LAYOUT_QUAD, AV_CH_LAYOUT_2POINT1, AV_CH_LAYOUT_SURROUND,
     AV_CH_LAYOUT_4POINT0, AV_CH_LAYOUT_5POINT0_BACK, AV_CH_LAYOUT_3POINT1,
     AV_CH_LAYOUT_4POINT1, AV_CH_LAYOUT_5POINT1_BACK, 0,
 };
+#endif
+
+const AVChannelLayout ff_mlp_ch_layouts[12] = {
+    AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO, AV_CHANNEL_LAYOUT_2_1,
+    AV_CHANNEL_LAYOUT_QUAD, AV_CHANNEL_LAYOUT_2POINT1, AV_CHANNEL_LAYOUT_SURROUND,
+    AV_CHANNEL_LAYOUT_4POINT0, AV_CHANNEL_LAYOUT_5POINT0_BACK, AV_CHANNEL_LAYOUT_3POINT1,
+    AV_CHANNEL_LAYOUT_4POINT1, AV_CHANNEL_LAYOUT_5POINT1_BACK, { 0 },
+};
 
 #if CONFIG_SMALL
 #define CRC_TABLE_SIZE 257
diff --git a/libavcodec/mlp.h b/libavcodec/mlp.h
index e45eba55ae..8a3e4566a3 100644
--- a/libavcodec/mlp.h
+++ b/libavcodec/mlp.h
@@ -24,6 +24,8 @@
 
 #include <stdint.h>
 
+#include "libavutil/channel_layout.h"
+
 #define SYNC_MLP        0xbb
 #define SYNC_TRUEHD     0xba
 
@@ -135,7 +137,10 @@ typedef struct {
  */
 extern const ChannelInformation ff_mlp_ch_info[21];
 
+#if FF_API_OLD_CHANNEL_LAYOUT
 extern const uint64_t ff_mlp_channel_layouts[12];
+#endif
+extern const AVChannelLayout ff_mlp_ch_layouts[12];
 
 /** MLP uses checksums that seem to be based on the standard CRC algorithm, but
  *  are not (in implementation terms, the table lookup and XOR are reversed).
diff --git a/libavcodec/mlp_parser.c b/libavcodec/mlp_parser.c
index 9fea7db955..d391390dd5 100644
--- a/libavcodec/mlp_parser.c
+++ b/libavcodec/mlp_parser.c
@@ -175,22 +175,18 @@ static int mlp_parse(AVCodecParserContext *s,
         avctx->frame_size =
         s->duration = mh.access_unit_size;
 
-        if(!avctx->channels || !avctx->channel_layout) {
+        av_channel_layout_uninit(&avctx->ch_layout);
         if (mh.stream_type == 0xbb) {
             /* MLP stream */
-            avctx->channels       = mh.channels_mlp;
-            avctx->channel_layout = mh.channel_layout_mlp;
+            av_channel_layout_from_mask(&avctx->ch_layout, mh.channel_layout_mlp);
         } else { /* mh.stream_type == 0xba */
             /* TrueHD stream */
             if (!mh.channels_thd_stream2) {
-                avctx->channels       = mh.channels_thd_stream1;
-                avctx->channel_layout = mh.channel_layout_thd_stream1;
+                av_channel_layout_from_mask(&avctx->ch_layout, mh.channel_layout_thd_stream1);
             } else {
-                avctx->channels       = mh.channels_thd_stream2;
-                avctx->channel_layout = mh.channel_layout_thd_stream2;
+                av_channel_layout_from_mask(&avctx->ch_layout, mh.channel_layout_thd_stream2);
             }
         }
-        }
 
         if (!mh.is_vbr) /* Stream is CBR */
             avctx->bit_rate = mh.peak_bitrate;
diff --git a/libavcodec/mlpdec.c b/libavcodec/mlpdec.c
index 29fac54542..d4b8226ec6 100644
--- a/libavcodec/mlpdec.c
+++ b/libavcodec/mlpdec.c
@@ -32,6 +32,7 @@
 #include "libavutil/channel_layout.h"
 #include "libavutil/mem_internal.h"
 #include "libavutil/thread.h"
+#include "libavutil/opt.h"
 #include "get_bits.h"
 #include "internal.h"
 #include "libavutil/crc.h"
@@ -132,8 +133,11 @@ typedef struct SubStream {
 } SubStream;
 
 typedef struct MLPDecodeContext {
+    const AVClass  *class;
     AVCodecContext *avctx;
 
+    AVChannelLayout downmix_layout;
+
     /// Current access unit being read has a major sync.
     int         is_major_sync_unit;
 
@@ -169,39 +173,41 @@ typedef struct MLPDecodeContext {
     MLPDSPContext dsp;
 } MLPDecodeContext;
 
-static const uint64_t thd_channel_order[] = {
-    AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT,                     // LR
-    AV_CH_FRONT_CENTER,                                      // C
-    AV_CH_LOW_FREQUENCY,                                     // LFE
-    AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT,                       // LRs
-    AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT,             // LRvh
-    AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
-    AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT,                       // LRrs
-    AV_CH_BACK_CENTER,                                       // Cs
-    AV_CH_TOP_CENTER,                                        // Ts
-    AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
-    AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT,                       // LRw
-    AV_CH_TOP_FRONT_CENTER,                                  // Cvh
-    AV_CH_LOW_FREQUENCY_2,                                   // LFE2
+static const enum AVChannel thd_channel_order[] = {
+    AV_CHAN_FRONT_LEFT, AV_CHAN_FRONT_RIGHT,                     // LR
+    AV_CHAN_FRONT_CENTER,                                        // C
+    AV_CHAN_LOW_FREQUENCY,                                       // LFE
+    AV_CHAN_SIDE_LEFT, AV_CHAN_SIDE_RIGHT,                       // LRs
+    AV_CHAN_TOP_FRONT_LEFT, AV_CHAN_TOP_FRONT_RIGHT,             // LRvh
+    AV_CHAN_FRONT_LEFT_OF_CENTER, AV_CHAN_FRONT_RIGHT_OF_CENTER, // LRc
+    AV_CHAN_BACK_LEFT, AV_CHAN_BACK_RIGHT,                       // LRrs
+    AV_CHAN_BACK_CENTER,                                         // Cs
+    AV_CHAN_TOP_CENTER,                                          // Ts
+    AV_CHAN_SURROUND_DIRECT_LEFT, AV_CHAN_SURROUND_DIRECT_RIGHT, // LRsd
+    AV_CHAN_WIDE_LEFT, AV_CHAN_WIDE_RIGHT,                       // LRw
+    AV_CHAN_TOP_FRONT_CENTER,                                    // Cvh
+    AV_CHAN_LOW_FREQUENCY_2,                                     // LFE2
 };
 
-static int mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
+static int mlp_channel_layout_subset(AVChannelLayout *layout, uint64_t mask)
 {
-    return channel_layout && ((channel_layout & mask) == channel_layout);
+    return av_channel_layout_check(layout) &&
+           av_channel_layout_subset(layout, mask) ==
+           av_channel_layout_subset(layout, UINT64_MAX);
 }
 
-static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
-                                                   int index)
+static enum AVChannel thd_channel_layout_extract_channel(uint64_t channel_layout,
+                                                         int index)
 {
     int i;
 
-    if (av_get_channel_layout_nb_channels(channel_layout) <= index)
-        return 0;
+    if (av_popcount64(channel_layout) <= index)
+        return AV_CHAN_NONE;
 
     for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
-        if (channel_layout & thd_channel_order[i] && !index--)
+        if (channel_layout & (1 << thd_channel_order[i]) && !index--)
             return thd_channel_order[i];
-    return 0;
+    return AV_CHAN_NONE;
 }
 
 static VLC huff_vlc[3];
@@ -290,6 +296,14 @@ static av_cold int mlp_decode_init(AVCodecContext *avctx)
         m->substream[substr].lossless_check_data = 0xffffffff;
     ff_mlpdsp_init(&m->dsp);
 
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
+    if (avctx->request_channel_layout) {
+        av_channel_layout_uninit(&m->downmix_layout);
+        av_channel_layout_from_mask(&m->downmix_layout, avctx->request_channel_layout);
+    }
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
     ff_thread_once(&init_static_once, init_static);
 
     return 0;
@@ -410,7 +424,7 @@ static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
         }
         if (mh.channels_thd_stream1 == 2 &&
             mh.channels_thd_stream2 == 2 &&
-            m->avctx->channels == 2)
+            m->avctx->ch_layout.nb_channels == 2)
             m->substream[0].mask = AV_CH_LAYOUT_STEREO;
         if ((substr = (mh.num_substreams > 1)))
             m->substream[0].mask = AV_CH_LAYOUT_STEREO;
@@ -419,14 +433,17 @@ static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
                 m->substream[2].mask = mh.channel_layout_thd_stream2;
             else
                 m->substream[2].mask = mh.channel_layout_thd_stream1;
-        if (m->avctx->channels > 2)
+        if (m->avctx->ch_layout.nb_channels > 2)
             m->substream[mh.num_substreams > 1].mask = mh.channel_layout_thd_stream1;
 
-        if (m->avctx->channels<=2 && m->substream[substr].mask == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
+        if (m->avctx->ch_layout.nb_channels <= 2 &&
+            m->substream[substr].mask == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
             av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
             m->max_decoded_substream = 0;
-            if (m->avctx->channels==2)
-                m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
+            if (m->avctx->ch_layout.nb_channels == 2) {
+                av_channel_layout_uninit(&m->avctx->ch_layout);
+                m->avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
+            }
         }
     }
 
@@ -548,7 +565,7 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
     s->max_matrix_channel = max_matrix_channel;
     s->noise_type         = noise_type;
 
-    if (mlp_channel_layout_subset(m->avctx->request_channel_layout, s->mask) &&
+    if (mlp_channel_layout_subset(&m->downmix_layout, s->mask) &&
         m->max_decoded_substream > substr) {
         av_log(m->avctx, AV_LOG_DEBUG,
                "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
@@ -580,10 +597,11 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
     for (ch = 0; ch <= s->max_matrix_channel; ch++) {
         int ch_assign = get_bits(gbp, 6);
         if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
-            uint64_t channel = thd_channel_layout_extract_channel(s->mask,
-                                                                  ch_assign);
-            ch_assign = av_get_channel_layout_channel_index(s->mask,
-                                                            channel);
+            AVChannelLayout l;
+            enum AVChannel channel = thd_channel_layout_extract_channel(s->mask, ch_assign);
+
+            av_channel_layout_from_mask(&l, s->mask);
+            ch_assign = av_channel_layout_index_from_channel(&l, channel);
         }
         if (ch_assign < 0 || ch_assign > s->max_matrix_channel) {
             avpriv_request_sample(m->avctx,
@@ -623,21 +641,21 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
     }
 
     if (substr == m->max_decoded_substream) {
-        m->avctx->channels       = s->max_matrix_channel + 1;
-        m->avctx->channel_layout = s->mask;
+        av_channel_layout_uninit(&m->avctx->ch_layout);
+        av_channel_layout_from_mask(&m->avctx->ch_layout, s->mask);
         m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
                                                                s->output_shift,
                                                                s->max_matrix_channel,
                                                                m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
 
         if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
-            if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
-                m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
+            if (s->mask == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
+                s->mask == AV_CH_LAYOUT_5POINT0_BACK) {
                 int i = s->ch_assign[4];
                 s->ch_assign[4] = s->ch_assign[3];
                 s->ch_assign[3] = s->ch_assign[2];
                 s->ch_assign[2] = i;
-            } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
+            } else if (s->mask == AV_CH_LAYOUT_5POINT1_BACK) {
                 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
                 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
             }
@@ -1078,7 +1096,7 @@ static int output_data(MLPDecodeContext *m, unsigned int substr,
     int ret;
     int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
 
-    if (m->avctx->channels != s->max_matrix_channel + 1) {
+    if (m->avctx->ch_layout.nb_channels != s->max_matrix_channel + 1) {
         av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
         return AVERROR_INVALIDDATA;
     }
@@ -1255,7 +1273,7 @@ static int read_access_unit(AVCodecContext *avctx, void* data,
 
         if (substr != m->max_decoded_substream &&
             m->substream[m->max_decoded_substream].min_channel == 0 &&
-            m->substream[m->max_decoded_substream].max_channel == avctx->channels - 1)
+            m->substream[m->max_decoded_substream].max_channel == avctx->ch_layout.nb_channels - 1)
             goto skip_substr;
 
         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
@@ -1372,6 +1390,28 @@ static void mlp_decode_flush(AVCodecContext *avctx)
     }
 }
 
+#define OFFSET(x) offsetof(MLPDecodeContext, x)
+#define FLAGS (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
+static const AVOption options[] = {
+    { "downmix", "Request a specific channel layout from the decoder", OFFSET(downmix_layout),
+        AV_OPT_TYPE_CHLAYOUT, {.str = NULL}, .flags = FLAGS },
+    { NULL },
+};
+
+static const AVClass mlp_decoder_class = {
+    .class_name = "MLP decoder",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+static const AVClass truehd_decoder_class = {
+    .class_name = "TrueHD decoder",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
 #if CONFIG_MLP_DECODER
 const AVCodec ff_mlp_decoder = {
     .name           = "mlp",
@@ -1379,6 +1419,7 @@ const AVCodec ff_mlp_decoder = {
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = AV_CODEC_ID_MLP,
     .priv_data_size = sizeof(MLPDecodeContext),
+    .priv_class     = &mlp_decoder_class,
     .init           = mlp_decode_init,
     .decode         = read_access_unit,
     .flush          = mlp_decode_flush,
@@ -1393,6 +1434,7 @@ const AVCodec ff_truehd_decoder = {
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = AV_CODEC_ID_TRUEHD,
     .priv_data_size = sizeof(MLPDecodeContext),
+    .priv_class     = &truehd_decoder_class,
     .init           = mlp_decode_init,
     .decode         = read_access_unit,
     .flush          = mlp_decode_flush,
diff --git a/libavcodec/mlpenc.c b/libavcodec/mlpenc.c
index d8783b6f56..80ebb72758 100644
--- a/libavcodec/mlpenc.c
+++ b/libavcodec/mlpenc.c
@@ -381,8 +381,8 @@ static void copy_restart_frame_params(MLPEncodeContext *ctx)
 
         copy_matrix_params(&dp->matrix_params, &ctx->cur_decoding_params->matrix_params);
 
-        for (unsigned int channel = 0; channel < ctx->avctx->channels; channel++) {
-            ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->channels) + channel;
+        for (unsigned int channel = 0; channel < ctx->avctx->ch_layout.nb_channels; channel++) {
+            ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->ch_layout.nb_channels) + channel;
 
             dp->quant_step_size[channel] = ctx->cur_decoding_params->quant_step_size[channel];
             dp->matrix_params.shift[channel] = ctx->cur_decoding_params->matrix_params.shift[channel];
@@ -528,13 +528,13 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
     ctx->coded_peak_bitrate = mlp_peak_bitrate(9600000, avctx->sample_rate);
 
     /* TODO support more channels. */
-    if (avctx->channels > 2) {
+    if (avctx->ch_layout.nb_channels > 2) {
         av_log(avctx, AV_LOG_WARNING,
                "Only mono and stereo are supported at the moment.\n");
     }
 
     ctx->substream_info |= SUBSTREAM_INFO_ALWAYS_SET;
-    if (avctx->channels <= 2) {
+    if (avctx->ch_layout.nb_channels <= 2) {
         ctx->substream_info |= SUBSTREAM_INFO_MAX_2_CHAN;
     }
 
@@ -559,7 +559,7 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
 
     ctx->dts = -avctx->frame_size;
 
-    ctx->num_channels = avctx->channels + 2; /* +2 noise channels */
+    ctx->num_channels = avctx->ch_layout.nb_channels + 2; /* +2 noise channels */
     ctx->one_sample_buffer_size = avctx->frame_size
                                 * ctx->num_channels;
     /* TODO Let user pass major header interval as parameter. */
@@ -588,59 +588,48 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
     ctx->num_substreams = 1; // TODO: change this after adding multi-channel support for TrueHD
 
     if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
-        /* MLP */
-        switch(avctx->channel_layout) {
-        case AV_CH_LAYOUT_MONO:
-            ctx->channel_arrangement = 0; break;
-        case AV_CH_LAYOUT_STEREO:
-            ctx->channel_arrangement = 1; break;
-        case AV_CH_LAYOUT_2_1:
-            ctx->channel_arrangement = 2; break;
-        case AV_CH_LAYOUT_QUAD:
-            ctx->channel_arrangement = 3; break;
-        case AV_CH_LAYOUT_2POINT1:
-            ctx->channel_arrangement = 4; break;
-        case AV_CH_LAYOUT_SURROUND:
-            ctx->channel_arrangement = 7; break;
-        case AV_CH_LAYOUT_4POINT0:
-            ctx->channel_arrangement = 8; break;
-        case AV_CH_LAYOUT_5POINT0_BACK:
-            ctx->channel_arrangement = 9; break;
-        case AV_CH_LAYOUT_3POINT1:
-            ctx->channel_arrangement = 10; break;
-        case AV_CH_LAYOUT_4POINT1:
-            ctx->channel_arrangement = 11; break;
-        case AV_CH_LAYOUT_5POINT1_BACK:
-            ctx->channel_arrangement = 12; break;
-        default:
+        static const AVChannelLayout layout_arrangement[] = {
+            AV_CHANNEL_LAYOUT_MONO,         AV_CHANNEL_LAYOUT_STEREO,
+            AV_CHANNEL_LAYOUT_2_1,          AV_CHANNEL_LAYOUT_QUAD,
+            AV_CHANNEL_LAYOUT_2POINT1,      { 0 }, { 0 },
+            AV_CHANNEL_LAYOUT_SURROUND,     AV_CHANNEL_LAYOUT_4POINT0,
+            AV_CHANNEL_LAYOUT_5POINT0_BACK, AV_CHANNEL_LAYOUT_3POINT1,
+            AV_CHANNEL_LAYOUT_4POINT1,      AV_CHANNEL_LAYOUT_5POINT1_BACK,
+        };
+        int i;
+
+        for (i = 0; i < FF_ARRAY_ELEMS(layout_arrangement); i++)
+            if (!av_channel_layout_compare(&avctx->ch_layout, &layout_arrangement[i]))
+                break;
+        if (i == FF_ARRAY_ELEMS(layout_arrangement)) {
             av_log(avctx, AV_LOG_ERROR, "Unsupported channel arrangement\n");
             return AVERROR(EINVAL);
         }
+        ctx->channel_arrangement = i;
         ctx->flags = FLAGS_DVDA;
         ctx->channel_occupancy = ff_mlp_ch_info[ctx->channel_arrangement].channel_occupancy;
         ctx->summary_info      = ff_mlp_ch_info[ctx->channel_arrangement].summary_info     ;
     } else {
         /* TrueHD */
-        switch(avctx->channel_layout) {
-        case AV_CH_LAYOUT_STEREO:
+        if (!av_channel_layout_compare(&avctx->ch_layout,
+                                       &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO)) {
             ctx->ch_modifier_thd0    = 0;
             ctx->ch_modifier_thd1    = 0;
             ctx->ch_modifier_thd2    = 0;
             ctx->channel_arrangement = 1;
-            break;
-        case AV_CH_LAYOUT_5POINT0_BACK:
+        } else if (!av_channel_layout_compare(&avctx->ch_layout,
+                                              &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT0_BACK)) {
             ctx->ch_modifier_thd0    = 1;
             ctx->ch_modifier_thd1    = 1;
             ctx->ch_modifier_thd2    = 1;
             ctx->channel_arrangement = 11;
-            break;
-        case AV_CH_LAYOUT_5POINT1_BACK:
+        } else if (!av_channel_layout_compare(&avctx->ch_layout,
+                                              &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1_BACK)) {
             ctx->ch_modifier_thd0    = 2;
             ctx->ch_modifier_thd1    = 1;
             ctx->ch_modifier_thd2    = 2;
             ctx->channel_arrangement = 15;
-            break;
-        default:
+        } else {
             av_log(avctx, AV_LOG_ERROR, "Unsupported channel arrangement\n");
             return AVERROR(EINVAL);
         }
@@ -665,7 +654,7 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
         sum += ctx->seq_size[index];
     }
     ctx->sequence_size = sum;
-    size = ctx->restart_intervals * ctx->sequence_size * ctx->avctx->channels;
+    size = ctx->restart_intervals * ctx->sequence_size * ctx->avctx->ch_layout.nb_channels;
     ctx->channel_params = av_calloc(size, sizeof(*ctx->channel_params));
     if (!ctx->channel_params)
         return AVERROR(ENOMEM);
@@ -679,7 +668,7 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
     rh->noisegen_seed      = 0;
 
     rh->min_channel        = 0;
-    rh->max_channel        = avctx->channels - 1;
+    rh->max_channel        = avctx->ch_layout.nb_channels - 1;
     /* FIXME: this works for 1 and 2 channels, but check for more */
     rh->max_matrix_channel = rh->max_channel;
 
@@ -1228,7 +1217,7 @@ static void input_to_sample_buffer(MLPEncodeContext *ctx)
         int32_t *input_buffer = ctx->inout_buffer + cur_index * ctx->one_sample_buffer_size;
 
         for (unsigned int i = 0; i < ctx->avctx->frame_size; i++) {
-            for (unsigned int channel = 0; channel < ctx->avctx->channels; channel++)
+            for (unsigned int channel = 0; channel < ctx->avctx->ch_layout.nb_channels; channel++)
                 *sample_buffer++ = *input_buffer++;
             sample_buffer += 2; /* noise_channels */
             input_buffer += 2; /* noise_channels */
@@ -1947,7 +1936,7 @@ static void set_best_codebook(MLPEncodeContext *ctx)
 
         /* Update context. */
         for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
-            ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->channels) + channel;
+            ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->ch_layout.nb_channels) + channel;
 
             best_codebook = *best_path++;
             cur_bo = &ctx->best_offset[index][channel][best_codebook];
@@ -1968,17 +1957,18 @@ static void set_major_params(MLPEncodeContext *ctx)
     RestartHeader *rh = ctx->cur_restart_header;
     uint8_t max_huff_lsbs = 0;
     uint8_t max_output_bits = 0;
-    DecodingParams *seq_dp = ctx->decoding_params + ctx->seq_offset[0] * ctx->avctx->channels;
-    ChannelParams *seq_cp = ctx->channel_params + ctx->seq_offset[0] * ctx->avctx->channels;
+    int channels = ctx->avctx->ch_layout.nb_channels;
+    DecodingParams *seq_dp = ctx->decoding_params + ctx->seq_offset[0] * channels;
+    ChannelParams *seq_cp = ctx->channel_params + ctx->seq_offset[0] * channels;
 
     for (unsigned int index = 0; index < ctx->seq_size[ctx->restart_intervals-1]; index++) {
         memcpy(&ctx->major_decoding_params[index], seq_dp + index, sizeof(DecodingParams));
-        for (unsigned int channel = 0; channel < ctx->avctx->channels; channel++) {
-            uint8_t huff_lsbs = (seq_cp + index*(ctx->avctx->channels) + channel)->huff_lsbs;
+        for (unsigned int channel = 0; channel < channels; channel++) {
+            uint8_t huff_lsbs = (seq_cp + index*(channels) + channel)->huff_lsbs;
             if (max_huff_lsbs < huff_lsbs)
                 max_huff_lsbs = huff_lsbs;
             memcpy(&ctx->major_channel_params[index][channel],
-                   (seq_cp + index*(ctx->avctx->channels) + channel),
+                   (seq_cp + index*(channels) + channel),
                    sizeof(ChannelParams));
         }
     }
@@ -2017,7 +2007,7 @@ static void analyze_sample_buffer(MLPEncodeContext *ctx)
 
     ctx->cur_restart_header = &ctx->restart_header;
     ctx->cur_decoding_params = seq_dp + 1;
-    ctx->cur_channel_params = seq_cp + ctx->avctx->channels;
+    ctx->cur_channel_params = seq_cp + ctx->avctx->ch_layout.nb_channels;
 
     determine_quant_step_size(ctx);
     generate_2_noise_channels(ctx);
@@ -2044,7 +2034,7 @@ static void analyze_sample_buffer(MLPEncodeContext *ctx)
 
     for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
         ctx->cur_decoding_params = seq_dp + index;
-        ctx->cur_channel_params = seq_cp + index*(ctx->avctx->channels);
+        ctx->cur_channel_params = seq_cp + index*(ctx->avctx->ch_layout.nb_channels);
         ctx->cur_best_offset = ctx->best_offset[index];
         determine_bits(ctx);
         ctx->sample_buffer += ctx->cur_decoding_params->blocksize * ctx->num_channels;
@@ -2078,13 +2068,14 @@ static int mlp_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 {
     MLPEncodeContext *ctx = avctx->priv_data;
     int bytes_written = 0;
+    int channels = avctx->ch_layout.nb_channels;
     int restart_frame, ret;
     uint8_t *data;
 
     if (!frame && !ctx->last_frames--)
         return 0;
 
-    if ((ret = ff_alloc_packet(avctx, avpkt, 87500 * avctx->channels)) < 0)
+    if ((ret = ff_alloc_packet(avctx, avpkt, 87500 * channels)) < 0)
         return ret;
 
     if (frame) {
@@ -2149,7 +2140,7 @@ input_and_return:
             ctx->number_of_frames = ctx->next_major_number_of_frames;
             ctx->number_of_subblocks = ctx->next_major_number_of_frames + 1;
 
-            ctx->seq_channel_params = ctx->channel_params + ctx->seq_offset[seq_index] * ctx->avctx->channels;
+            ctx->seq_channel_params = ctx->channel_params + ctx->seq_offset[seq_index] * channels;
 
             ctx->seq_decoding_params = ctx->decoding_params + ctx->seq_offset[seq_index];
 
@@ -2157,7 +2148,7 @@ input_and_return:
             ctx->number_of_samples = number_of_samples;
 
             for (unsigned int index = 0; index < ctx->seq_size[seq_index]; index++) {
-                clear_channel_params(ctx->seq_channel_params + index * ctx->avctx->channels, ctx->avctx->channels);
+                clear_channel_params(ctx->seq_channel_params + index * channels, channels);
                 default_decoding_params(ctx, ctx->seq_decoding_params + index);
             }
 
@@ -2225,7 +2216,10 @@ const AVCodec ff_mlp_encoder = {
     .capabilities           = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_EXPERIMENTAL,
     .sample_fmts            = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE},
     .supported_samplerates  = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
+#if FF_API_OLD_CHANNEL_LAYOUT
     .channel_layouts        = ff_mlp_channel_layouts,
+#endif
+    .ch_layouts             = ff_mlp_ch_layouts,
     .caps_internal          = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif
@@ -2242,7 +2236,15 @@ const AVCodec ff_truehd_encoder = {
     .capabilities           = AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_EXPERIMENTAL,
     .sample_fmts            = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE},
     .supported_samplerates  = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
+#if FF_API_OLD_CHANNEL_LAYOUT
     .channel_layouts        = (const uint64_t[]) {AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_5POINT0_BACK, AV_CH_LAYOUT_5POINT1_BACK, 0},
+#endif
+    .ch_layouts             = (const AVChannelLayout[]) {
+                                  AV_CHANNEL_LAYOUT_STEREO,
+                                  AV_CHANNEL_LAYOUT_5POINT0_BACK,
+                                  AV_CHANNEL_LAYOUT_5POINT1_BACK,
+                                  { 0 }
+                              },
     .caps_internal          = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif