@@ -61,6 +61,7 @@ version <next>:

 - support for dvaudio in wav and avi

 - libaacplus and libvo-aacenc support removed

 - Cineform HD decoder

+- new DCA decoder with full support for DTS-HD extensions

 version 2.8:

@@ -2271,6 +2271,7 @@ comfortnoise_encoder_select="lpc"

 cook_decoder_select="audiodsp mdct sinewin"

 cscd_decoder_select="lzo"

 cscd_decoder_suggest="zlib"

+dca_decoder_select="mdct"

 dds_decoder_select="texturedsp"

 dirac_decoder_select="dirac_parse dwt golomb videodsp mpegvideoenc"

 dnxhd_decoder_select="blockdsp idctdsp"

@@ -222,6 +222,9 @@ OBJS-$(CONFIG_COMFORTNOISE_ENCODER)    += cngenc.o

 OBJS-$(CONFIG_CPIA_DECODER)            += cpia.o

 OBJS-$(CONFIG_CSCD_DECODER)            += cscd.o

 OBJS-$(CONFIG_CYUV_DECODER)            += cyuv.o

+OBJS-$(CONFIG_DCA_DECODER)             += dcadec.o dca.o dcadata.o        \

+                                          dca_core.o dca_exss.o dca_xll.o \

+                                          dcadsp.o dcadct.o synth_filter.o

 OBJS-$(CONFIG_DCA_ENCODER)             += dcaenc.o dca.o dcadata.o

 OBJS-$(CONFIG_DDS_DECODER)             += dds.o

 OBJS-$(CONFIG_DIRAC_DECODER)           += diracdec.o dirac.o diracdsp.o \

@@ -1,4 +1,4 @@

-#OBJS-$(CONFIG_DCA_DECODER)              += aarch64/synth_filter_init.o

+OBJS-$(CONFIG_DCA_DECODER)              += aarch64/synth_filter_init.o

 OBJS-$(CONFIG_FFT)                      += aarch64/fft_init_aarch64.o

 OBJS-$(CONFIG_FMTCONVERT)               += aarch64/fmtconvert_init.o

 OBJS-$(CONFIG_H264CHROMA)               += aarch64/h264chroma_init_aarch64.o

@@ -17,7 +17,7 @@ OBJS-$(CONFIG_VORBIS_DECODER)           += aarch64/vorbisdsp_init.o

 ARMV8-OBJS-$(CONFIG_VIDEODSP)           += aarch64/videodsp.o

-#NEON-OBJS-$(CONFIG_DCA_DECODER)         += aarch64/synth_filter_neon.o

+NEON-OBJS-$(CONFIG_DCA_DECODER)         += aarch64/synth_filter_neon.o

 NEON-OBJS-$(CONFIG_FFT)                 += aarch64/fft_neon.o

 NEON-OBJS-$(CONFIG_FMTCONVERT)          += aarch64/fmtconvert_neon.o

 NEON-OBJS-$(CONFIG_H264CHROMA)          += aarch64/h264cmc_neon.o

@@ -391,7 +391,7 @@ void avcodec_register_all(void)

     REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);

     REGISTER_DECODER(BMV_AUDIO,         bmv_audio);

     REGISTER_DECODER(COOK,              cook);

-    REGISTER_ENCODER(DCA,               dca);

+    REGISTER_ENCDEC (DCA,               dca);

     REGISTER_DECODER(DSD_LSBF,          dsd_lsbf);

     REGISTER_DECODER(DSD_MSBF,          dsd_msbf);

     REGISTER_DECODER(DSD_LSBF_PLANAR,   dsd_lsbf_planar);

@@ -36,7 +36,7 @@ OBJS-$(CONFIG_VP8DSP)                  += arm/vp8dsp_init_arm.o

 # decoders/encoders

 OBJS-$(CONFIG_AAC_DECODER)             += arm/aacpsdsp_init_arm.o       \

                                           arm/sbrdsp_init_arm.o

-#OBJS-$(CONFIG_DCA_DECODER)             += arm/synth_filter_init_arm.o

+OBJS-$(CONFIG_DCA_DECODER)             += arm/synth_filter_init_arm.o

 OBJS-$(CONFIG_HEVC_DECODER)            += arm/hevcdsp_init_arm.o

 OBJS-$(CONFIG_MLP_DECODER)             += arm/mlpdsp_init_arm.o

 OBJS-$(CONFIG_RV40_DECODER)            += arm/rv40dsp_init_arm.o

@@ -87,7 +87,7 @@ VFP-OBJS-$(CONFIG_FMTCONVERT)          += arm/fmtconvert_vfp.o

 VFP-OBJS-$(CONFIG_MDCT)                += arm/mdct_vfp.o

 # decoders/encoders

-#VFP-OBJS-$(CONFIG_DCA_DECODER)         += arm/synth_filter_vfp.o

+VFP-OBJS-$(CONFIG_DCA_DECODER)         += arm/synth_filter_vfp.o

 # NEON optimizations

@@ -126,7 +126,7 @@ NEON-OBJS-$(CONFIG_VP8DSP)             += arm/vp8dsp_init_neon.o        \

 NEON-OBJS-$(CONFIG_AAC_DECODER)        += arm/aacpsdsp_neon.o           \

                                           arm/sbrdsp_neon.o

 NEON-OBJS-$(CONFIG_LLAUDDSP)           += arm/lossless_audiodsp_neon.o

-#NEON-OBJS-$(CONFIG_DCA_DECODER)        += arm/synth_filter_neon.o

+NEON-OBJS-$(CONFIG_DCA_DECODER)        += arm/synth_filter_neon.o

 NEON-OBJS-$(CONFIG_HEVC_DECODER)       += arm/hevcdsp_init_neon.o       \

                                           arm/hevcdsp_deblock_neon.o    \

                                           arm/hevcdsp_idct_neon.o       \

new file mode 100644

@@ -0,0 +1,2603 @@

+/*

+ * Copyright (C) 2016 foo86

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include "dcadec.h"

+#include "dcadata.h"

+#include "dcahuff.h"

+#include "dcamath.h"

+#include "dca_syncwords.h"

+

+#if ARCH_ARM

+#include "arm/dca.h"

+#endif

+

+enum HeaderType {

+    HEADER_CORE,

+    HEADER_XCH,

+    HEADER_XXCH

+};

+

+enum AudioMode {

+    AMODE_MONO,             // Mode 0: A (mono)

+    AMODE_MONO_DUAL,        // Mode 1: A + B (dual mono)

+    AMODE_STEREO,           // Mode 2: L + R (stereo)

+    AMODE_STEREO_SUMDIFF,   // Mode 3: (L+R) + (L-R) (sum-diff)

+    AMODE_STEREO_TOTAL,     // Mode 4: LT + RT (left and right total)

+    AMODE_3F,               // Mode 5: C + L + R

+    AMODE_2F1R,             // Mode 6: L + R + S

+    AMODE_3F1R,             // Mode 7: C + L + R + S

+    AMODE_2F2R,             // Mode 8: L + R + SL + SR

+    AMODE_3F2R,             // Mode 9: C + L + R + SL + SR

+

+    AMODE_COUNT

+};

+

+enum ExtAudioType {

+    EXT_AUDIO_XCH   = 0,

+    EXT_AUDIO_X96   = 2,

+    EXT_AUDIO_XXCH  = 6

+};

+

+enum LFEFlag {

+    LFE_FLAG_NONE,

+    LFE_FLAG_128,

+    LFE_FLAG_64,

+    LFE_FLAG_INVALID

+};

+

+static const int8_t prm_ch_to_spkr_map[AMODE_COUNT][5] = {

+    { DCA_SPEAKER_C,            -1,             -1,             -1,             -1 },

+    { DCA_SPEAKER_L, DCA_SPEAKER_R,             -1,             -1,             -1 },

+    { DCA_SPEAKER_L, DCA_SPEAKER_R,             -1,             -1,             -1 },

+    { DCA_SPEAKER_L, DCA_SPEAKER_R,             -1,             -1,             -1 },

+    { DCA_SPEAKER_L, DCA_SPEAKER_R,             -1,             -1,             -1 },

+    { DCA_SPEAKER_C, DCA_SPEAKER_L, DCA_SPEAKER_R ,             -1,             -1 },

+    { DCA_SPEAKER_L, DCA_SPEAKER_R, DCA_SPEAKER_Cs,             -1,             -1 },

+    { DCA_SPEAKER_C, DCA_SPEAKER_L, DCA_SPEAKER_R , DCA_SPEAKER_Cs,             -1 },

+    { DCA_SPEAKER_L, DCA_SPEAKER_R, DCA_SPEAKER_Ls, DCA_SPEAKER_Rs,             -1 },

+    { DCA_SPEAKER_C, DCA_SPEAKER_L, DCA_SPEAKER_R,  DCA_SPEAKER_Ls, DCA_SPEAKER_Rs }

+};

+

+static const uint8_t audio_mode_ch_mask[AMODE_COUNT] = {

+    DCA_SPEAKER_LAYOUT_MONO,

+    DCA_SPEAKER_LAYOUT_STEREO,

+    DCA_SPEAKER_LAYOUT_STEREO,

+    DCA_SPEAKER_LAYOUT_STEREO,

+    DCA_SPEAKER_LAYOUT_STEREO,

+    DCA_SPEAKER_LAYOUT_3_0,

+    DCA_SPEAKER_LAYOUT_2_1,

+    DCA_SPEAKER_LAYOUT_3_1,

+    DCA_SPEAKER_LAYOUT_2_2,

+    DCA_SPEAKER_LAYOUT_5POINT0

+};

+

+static const uint8_t block_code_nbits[7] = {

+    7, 10, 12, 13, 15, 17, 19

+};

+

+static const uint8_t quant_index_sel_nbits[DCA_CODE_BOOKS] = {

+    1, 2, 2, 2, 2, 3, 3, 3, 3, 3

+};

+

+static const uint8_t quant_index_group_size[DCA_CODE_BOOKS] = {

+    1, 3, 3, 3, 3, 7, 7, 7, 7, 7

+};

+

+typedef struct DCAVLC {

+    int offset;         ///< Code values offset

+    int max_depth;      ///< Parameter for get_vlc2()

+    VLC vlc[7];         ///< Actual codes

+} DCAVLC;

+

+static DCAVLC   vlc_bit_allocation;

+static DCAVLC   vlc_transition_mode;

+static DCAVLC   vlc_scale_factor;

+static DCAVLC   vlc_quant_index[DCA_CODE_BOOKS];

+

+static av_cold void dca_init_vlcs(void)

+{

+    static VLC_TYPE dca_table[23622][2];

+    static int vlcs_initialized = 0;

+    int i, j, k;

+

+    if (vlcs_initialized)

+        return;

+

+#define DCA_INIT_VLC(vlc, a, b, c, d)                                      \

+    do {                                                                   \

+        vlc.table           = &dca_table[ff_dca_vlc_offs[k]];              \

+        vlc.table_allocated = ff_dca_vlc_offs[k + 1] - ff_dca_vlc_offs[k]; \

+        init_vlc(&vlc, a, b, c, 1, 1, d, 2, 2, INIT_VLC_USE_NEW_STATIC);   \

+    } while (0)

+

+    vlc_bit_allocation.offset    = 1;

+    vlc_bit_allocation.max_depth = 2;

+    for (i = 0, k = 0; i < 5; i++, k++)

+        DCA_INIT_VLC(vlc_bit_allocation.vlc[i], bitalloc_12_vlc_bits[i], 12,

+                     bitalloc_12_bits[i], bitalloc_12_codes[i]);

+

+    vlc_scale_factor.offset    = -64;

+    vlc_scale_factor.max_depth = 2;

+    for (i = 0; i < 5; i++, k++)

+        DCA_INIT_VLC(vlc_scale_factor.vlc[i], SCALES_VLC_BITS, 129,

+                     scales_bits[i], scales_codes[i]);

+

+    vlc_transition_mode.offset    = 0;

+    vlc_transition_mode.max_depth = 1;

+    for (i = 0; i < 4; i++, k++)

+        DCA_INIT_VLC(vlc_transition_mode.vlc[i], tmode_vlc_bits[i], 4,

+                     tmode_bits[i], tmode_codes[i]);

+

+    for (i = 0; i < DCA_CODE_BOOKS; i++) {

+        vlc_quant_index[i].offset    = bitalloc_offsets[i];

+        vlc_quant_index[i].max_depth = 1 + (i > 4);

+        for (j = 0; j < quant_index_group_size[i]; j++, k++)

+            DCA_INIT_VLC(vlc_quant_index[i].vlc[j], bitalloc_maxbits[i][j],

+                         bitalloc_sizes[i], bitalloc_bits[i][j], bitalloc_codes[i][j]);

+    }

+

+    vlcs_initialized = 1;

+}

+

+static int get_vlc(GetBitContext *s, DCAVLC *v, int i)

+{

+    return get_vlc2(s, v->vlc[i].table, v->vlc[i].bits, v->max_depth) + v->offset;

+}

+

+static void get_array(GetBitContext *s, int32_t *array, int size, int n)

+{

+    int i;

+

+    for (i = 0; i < size; i++)

+        array[i] = get_sbits(s, n);

+}

+

+// 5.3.1 - Bit stream header

+static int parse_frame_header(DCACoreDecoder *s)

+{

+    int normal_frame, pcmr_index;

+

+    // Frame type

+    normal_frame = get_bits1(&s->gb);

+

+    // Deficit sample count

+    if (get_bits(&s->gb, 5) != DCA_PCMBLOCK_SAMPLES - 1) {

+        av_log(s->avctx, AV_LOG_ERROR, "Deficit samples are not supported\n");

+        return normal_frame ? AVERROR_INVALIDDATA : AVERROR_PATCHWELCOME;

+    }

+

+    // CRC present flag

+    s->crc_present = get_bits1(&s->gb);

+

+    // Number of PCM sample blocks

+    s->npcmblocks = get_bits(&s->gb, 7) + 1;

+    if (s->npcmblocks & (DCA_SUBBAND_SAMPLES - 1)) {

+        av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of PCM sample blocks (%d)\n", s->npcmblocks);

+        return (s->npcmblocks < 6 || normal_frame) ? AVERROR_INVALIDDATA : AVERROR_PATCHWELCOME;

+    }

+

+    // Primary frame byte size

+    s->frame_size = get_bits(&s->gb, 14) + 1;

+    if (s->frame_size < 96) {

+        av_log(s->avctx, AV_LOG_ERROR, "Invalid core frame size (%d bytes)\n", s->frame_size);

+        return AVERROR_INVALIDDATA;

+    }

+

+    // Audio channel arrangement

+    s->audio_mode = get_bits(&s->gb, 6);

+    if (s->audio_mode >= AMODE_COUNT) {

+        av_log(s->avctx, AV_LOG_ERROR, "Unsupported audio channel arrangement (%d)\n", s->audio_mode);

+        return AVERROR_PATCHWELCOME;

+    }

+

+    // Core audio sampling frequency

+    s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];

+    if (!s->sample_rate) {

+        av_log(s->avctx, AV_LOG_ERROR, "Invalid core audio sampling frequency\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    // Transmission bit rate

+    s->bit_rate = ff_dca_bit_rates[get_bits(&s->gb, 5)];

+

+    // Reserved field

+    skip_bits1(&s->gb);

+

+    // Embedded dynamic range flag

+    s->drc_present = get_bits1(&s->gb);

+

+    // Embedded time stamp flag

+    s->ts_present = get_bits1(&s->gb);

+

+    // Auxiliary data flag

+    s->aux_present = get_bits1(&s->gb);

+

+    // HDCD mastering flag

+    skip_bits1(&s->gb);

+

+    // Extension audio descriptor flag

+    s->ext_audio_type = get_bits(&s->gb, 3);

+

+    // Extended coding flag

+    s->ext_audio_present = get_bits1(&s->gb);

+

+    // Audio sync word insertion flag

+    s->sync_ssf = get_bits1(&s->gb);

+

+    // Low frequency effects flag

+    s->lfe_present = get_bits(&s->gb, 2);

+    if (s->lfe_present == LFE_FLAG_INVALID) {

+        av_log(s->avctx, AV_LOG_ERROR, "Invalid low frequency effects flag\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    // Predictor history flag switch

+    s->predictor_history = get_bits1(&s->gb);

+

+    // Header CRC check bytes

+    if (s->crc_present)

+        skip_bits(&s->gb, 16);

+

+    // Multirate interpolator switch

+    s->filter_perfect = get_bits1(&s->gb);

+

+    // Encoder software revision

+    skip_bits(&s->gb, 4);

+

+    // Copy history

+    skip_bits(&s->gb, 2);

+

+    // Source PCM resolution

+    s->source_pcm_res = ff_dca_bits_per_sample[pcmr_index = get_bits(&s->gb, 3)];

+    if (!s->source_pcm_res) {

+        av_log(s->avctx, AV_LOG_ERROR, "Invalid source PCM resolution\n");

+        return AVERROR_INVALIDDATA;

+    }

+    s->es_format = pcmr_index & 1;

+

+    // Front sum/difference flag

+    s->sumdiff_front = get_bits1(&s->gb);

+

+    // Surround sum/difference flag

+    s->sumdiff_surround = get_bits1(&s->gb);

+

+    // Dialog normalization / unspecified

+    skip_bits(&s->gb, 4);

+

+    return 0;

+}

+

+// 5.3.2 - Primary audio coding header

+static int parse_coding_header(DCACoreDecoder *s, enum HeaderType header, int xch_base)

+{

+    int n, ch, nchannels, header_size = 0, header_pos = get_bits_count(&s->gb);

+    unsigned int mask, index;

+

+    if (get_bits_left(&s->gb) < 0)

+        return AVERROR_INVALIDDATA;

+

+    switch (header) {

+    case HEADER_CORE:

+        // Number of subframes

+        s->nsubframes = get_bits(&s->gb, 4) + 1;

+

+        // Number of primary audio channels

+        s->nchannels = get_bits(&s->gb, 3) + 1;

+        if (s->nchannels != ff_dca_channels[s->audio_mode]) {

+            av_log(s->avctx, AV_LOG_ERROR, "Invalid number of primary audio channels (%d) for audio channel arrangement (%d)\n", s->nchannels, s->audio_mode);

+            return AVERROR_INVALIDDATA;

+        }

+        av_assert1(s->nchannels <= DCA_CHANNELS - 2);

+

+        s->ch_mask = audio_mode_ch_mask[s->audio_mode];

+

+        // Add LFE channel if present

+        if (s->lfe_present)

+            s->ch_mask |= DCA_SPEAKER_MASK_LFE1;

+        break;

+

+    case HEADER_XCH:

+        s->nchannels = ff_dca_channels[s->audio_mode] + 1;

+        av_assert1(s->nchannels <= DCA_CHANNELS - 1);

+        s->ch_mask |= DCA_SPEAKER_MASK_Cs;

+        break;

+

+    case HEADER_XXCH:

+        // Channel set header length

+        header_size = get_bits(&s->gb, 7) + 1;

+

+        // Check CRC

+        if (s->xxch_crc_present

+            && (s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL))

+            && ff_dca_check_crc(&s->gb, header_pos, header_pos + header_size * 8)) {

+            av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH channel set header checksum\n");

+            return AVERROR_INVALIDDATA;

+        }

+

+        // Number of channels in a channel set

+        nchannels = get_bits(&s->gb, 3) + 1;

+        if (nchannels > DCA_XXCH_CHANNELS_MAX) {

+            avpriv_request_sample(s->avctx, "%d XXCH channels", nchannels);

+            return AVERROR_PATCHWELCOME;

+        }

+        s->nchannels = ff_dca_channels[s->audio_mode] + nchannels;

+        av_assert1(s->nchannels <= DCA_CHANNELS);

+

+        // Loudspeaker layout mask

+        mask = get_bits_long(&s->gb, s->xxch_mask_nbits - DCA_SPEAKER_Cs);

+        s->xxch_spkr_mask = mask << DCA_SPEAKER_Cs;

+

+        if (av_popcount(s->xxch_spkr_mask) != nchannels) {

+            av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH speaker layout mask (%#x)\n", s->xxch_spkr_mask);

+            return AVERROR_INVALIDDATA;

+        }

+

+        if (s->xxch_core_mask & s->xxch_spkr_mask) {

+            av_log(s->avctx, AV_LOG_ERROR, "XXCH speaker layout mask (%#x) overlaps with core (%#x)\n", s->xxch_spkr_mask, s->xxch_core_mask);

+            return AVERROR_INVALIDDATA;

+        }

+

+        // Combine core and XXCH masks together

+        s->ch_mask = s->xxch_core_mask | s->xxch_spkr_mask;

+

+        // Downmix coefficients present in stream

+        if (get_bits1(&s->gb)) {

+            int *coeff_ptr = s->xxch_dmix_coeff;

+

+            // Downmix already performed by encoder

+            s->xxch_dmix_embedded = get_bits1(&s->gb);

+

+            // Downmix scale factor

+            index = get_bits(&s->gb, 6) * 4 - FF_DCA_DMIXTABLE_OFFSET - 3;

+            if (index >= FF_DCA_INV_DMIXTABLE_SIZE) {

+                av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH downmix scale index (%d)\n", index);

+                return AVERROR_INVALIDDATA;

+            }

+            s->xxch_dmix_scale_inv = ff_dca_inv_dmixtable[index];

+

+            // Downmix channel mapping mask

+            for (ch = 0; ch < nchannels; ch++) {

+                mask = get_bits_long(&s->gb, s->xxch_mask_nbits);

+                if ((mask & s->xxch_core_mask) != mask) {

+                    av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH downmix channel mapping mask (%#x)\n", mask);

+                    return AVERROR_INVALIDDATA;

+                }

+                s->xxch_dmix_mask[ch] = mask;

+            }

+

+            // Downmix coefficients

+            for (ch = 0; ch < nchannels; ch++) {

+                for (n = 0; n < s->xxch_mask_nbits; n++) {

+                    if (s->xxch_dmix_mask[ch] & (1U << n)) {

+                        int code = get_bits(&s->gb, 7);

+                        int sign = (code >> 6) - 1;

+                        if (code &= 63) {

+                            index = code * 4 - 3;

+                            if (index >= FF_DCA_DMIXTABLE_SIZE) {

+                                av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH downmix coefficient index (%d)\n", index);

+                                return AVERROR_INVALIDDATA;

+                            }

+                            *coeff_ptr++ = (ff_dca_dmixtable[index] ^ sign) - sign;

+                        } else {

+                            *coeff_ptr++ = 0;

+                        }

+                    }

+                }

+            }

+        } else {

+            s->xxch_dmix_embedded = 0;

+        }

+

+        break;

+    }

+

+    // Subband activity count

+    for (ch = xch_base; ch < s->nchannels; ch++) {

+        s->nsubbands[ch] = get_bits(&s->gb, 5) + 2;

+        if (s->nsubbands[ch] > DCA_SUBBANDS) {

+            av_log(s->avctx, AV_LOG_ERROR, "Invalid subband activity count\n");

+            return AVERROR_INVALIDDATA;

+        }

+    }

+

+    // High frequency VQ start subband

+    for (ch = xch_base; ch < s->nchannels; ch++)

+        s->subband_vq_start[ch] = get_bits(&s->gb, 5) + 1;

+

+    // Joint intensity coding index

+    for (ch = xch_base; ch < s->nchannels; ch++) {

+        if ((n = get_bits(&s->gb, 3)) && header == HEADER_XXCH)

+            n += xch_base - 1;

+        if (n > s->nchannels) {

+            av_log(s->avctx, AV_LOG_ERROR, "Invalid joint intensity coding index\n");

+            return AVERROR_INVALIDDATA;

+        }

+        s->joint_intensity_index[ch] = n;

+    }

+

+    // Transient mode code book

+    for (ch = xch_base; ch < s->nchannels; ch++)

+        s->transition_mode_sel[ch] = get_bits(&s->gb, 2);

+

+    // Scale factor code book

+    for (ch = xch_base; ch < s->nchannels; ch++) {

+        s->scale_factor_sel[ch] = get_bits(&s->gb, 3);

+        if (s->scale_factor_sel[ch] == 7) {

+            av_log(s->avctx, AV_LOG_ERROR, "Invalid scale factor code book\n");

+            return AVERROR_INVALIDDATA;

+        }

+    }

+

+    // Bit allocation quantizer select

+    for (ch = xch_base; ch < s->nchannels; ch++) {

+        s->bit_allocation_sel[ch] = get_bits(&s->gb, 3);

+        if (s->bit_allocation_sel[ch] == 7) {

+            av_log(s->avctx, AV_LOG_ERROR, "Invalid bit allocation quantizer select\n");

+            return AVERROR_INVALIDDATA;

+        }

+    }

+

+    // Quantization index codebook select

+    for (n = 0; n < DCA_CODE_BOOKS; n++)

+        for (ch = xch_base; ch < s->nchannels; ch++)

+            s->quant_index_sel[ch][n] = get_bits(&s->gb, quant_index_sel_nbits[n]);

+

+    // Scale factor adjustment index

+    for (n = 0; n < DCA_CODE_BOOKS; n++)

+        for (ch = xch_base; ch < s->nchannels; ch++)

+            if (s->quant_index_sel[ch][n] < quant_index_group_size[n])

+                s->scale_factor_adj[ch][n] = ff_dca_scale_factor_adj[get_bits(&s->gb, 2)];

+

+    if (header == HEADER_XXCH) {

+        // Reserved

+        // Byte align

+        // CRC16 of channel set header

+        if (ff_dca_seek_bits(&s->gb, header_pos + header_size * 8)) {

+            av_log(s->avctx, AV_LOG_ERROR, "Read past end of XXCH channel set header\n");

+            return AVERROR_INVALIDDATA;

+        }

+    } else {

+        // Audio header CRC check word

+        if (s->crc_present)

+            skip_bits(&s->gb, 16);

+    }

+

+    return 0;

+}

+

+static inline int parse_scale(DCACoreDecoder *s, int *scale_index, int sel)

+{

+    const uint32_t *scale_table;

+    unsigned int scale_size;

+

+    // Select the root square table

+    if (sel > 5) {

+        scale_table = ff_dca_scale_factor_quant7;

+        scale_size = FF_ARRAY_ELEMS(ff_dca_scale_factor_quant7);

+    } else {

+        scale_table = ff_dca_scale_factor_quant6;

+        scale_size = FF_ARRAY_ELEMS(ff_dca_scale_factor_quant6);

+    }

+

+    // If Huffman code was used, the difference of scales was encoded

+    if (sel < 5)

+        *scale_index += get_vlc(&s->gb, &vlc_scale_factor, sel);

+    else

+        *scale_index = get_bits(&s->gb, sel + 1);

+

+    // Look up scale factor from the root square table

+    if ((unsigned int)*scale_index >= scale_size) {

+        av_log(s->avctx, AV_LOG_ERROR, "Invalid scale factor index\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    return scale_table[*scale_index];

+}

+

+static inline int parse_joint_scale(DCACoreDecoder *s, int sel)

+{

+    int scale_index;

+

+    // Absolute value was encoded even when Huffman code was used

+    if (sel < 5)

+        scale_index = get_vlc(&s->gb, &vlc_scale_factor, sel);

+    else

+        scale_index = get_bits(&s->gb, sel + 1);

+

+    // Bias by 64

+    scale_index += 64;

+

+    // Look up joint scale factor

+    if ((unsigned int)scale_index >= FF_ARRAY_ELEMS(ff_dca_joint_scale_factors)) {

+        av_log(s->avctx, AV_LOG_ERROR, "Invalid joint scale factor index\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    return ff_dca_joint_scale_factors[scale_index];

+}

+

+// 5.4.1 - Primary audio coding side information

+static int parse_subframe_header(DCACoreDecoder *s, int sf,

+                                 enum HeaderType header, int xch_base)

+{

+    int ch, band, ret;

+

+    if (get_bits_left(&s->gb) < 0)

+        return AVERROR_INVALIDDATA;

+

+    if (header == HEADER_CORE) {

+        // Subsubframe count

+        s->nsubsubframes[sf] = get_bits(&s->gb, 2) + 1;

+

+        // Partial subsubframe sample count

+        skip_bits(&s->gb, 3);

+    }

+

+    // Prediction mode

+    for (ch = xch_base; ch < s->nchannels; ch++)

+        for (band = 0; band < s->nsubbands[ch]; band++)

+            s->prediction_mode[ch][band] = get_bits1(&s->gb);

+

+    // Prediction coefficients VQ address

+    for (ch = xch_base; ch < s->nchannels; ch++)

+        for (band = 0; band < s->nsubbands[ch]; band++)

+            if (s->prediction_mode[ch][band])

+                s->prediction_vq_index[ch][band] = get_bits(&s->gb, 12);

+

+    // Bit allocation index

+    for (ch = xch_base; ch < s->nchannels; ch++) {

+        int sel = s->bit_allocation_sel[ch];

+

+        for (band = 0; band < s->subband_vq_start[ch]; band++) {

+            int abits;

+

+            if (sel < 5)

+                abits = get_vlc(&s->gb, &vlc_bit_allocation, sel);

+            else

+                abits = get_bits(&s->gb, sel - 1);

+

+            if (abits > DCA_ABITS_MAX) {

+                av_log(s->avctx, AV_LOG_ERROR, "Invalid bit allocation index\n");

+                return AVERROR_INVALIDDATA;

+            }

+

+            s->bit_allocation[ch][band] = abits;

+        }

+    }

+

+    // Transition mode

+    for (ch = xch_base; ch < s->nchannels; ch++) {

+        // Clear transition mode for all subbands

+        memset(s->transition_mode[sf][ch], 0, sizeof(s->transition_mode[0][0]));

+

+        // Transient possible only if more than one subsubframe

+        if (s->nsubsubframes[sf] > 1) {

+            int sel = s->transition_mode_sel[ch];

+            for (band = 0; band < s->subband_vq_start[ch]; band++)

+                if (s->bit_allocation[ch][band])

+                    s->transition_mode[sf][ch][band] = get_vlc(&s->gb, &vlc_transition_mode, sel);

+        }

+    }

+

+    // Scale factors

+    for (ch = xch_base; ch < s->nchannels; ch++) {

+        int sel = s->scale_factor_sel[ch];

+        int scale_index = 0;

+

+        // Extract scales for subbands up to VQ

+        for (band = 0; band < s->subband_vq_start[ch]; band++) {

+            if (s->bit_allocation[ch][band]) {

+                if ((ret = parse_scale(s, &scale_index, sel)) < 0)

+                    return ret;

+                s->scale_factors[ch][band][0] = ret;

+                if (s->transition_mode[sf][ch][band]) {

+                    if ((ret = parse_scale(s, &scale_index, sel)) < 0)

+                        return ret;

+                    s->scale_factors[ch][band][1] = ret;

+                }

+            } else {

+                s->scale_factors[ch][band][0] = 0;

+            }

+        }

+

+        // High frequency VQ subbands

+        for (band = s->subband_vq_start[ch]; band < s->nsubbands[ch]; band++) {

+            if ((ret = parse_scale(s, &scale_index, sel)) < 0)

+                return ret;

+            s->scale_factors[ch][band][0] = ret;

+        }

+    }

+

+    // Joint subband codebook select

+    for (ch = xch_base; ch < s->nchannels; ch++) {

+        if (s->joint_intensity_index[ch]) {

+            s->joint_scale_sel[ch] = get_bits(&s->gb, 3);

+            if (s->joint_scale_sel[ch] == 7) {

+                av_log(s->avctx, AV_LOG_ERROR, "Invalid joint scale factor code book\n");

+                return AVERROR_INVALIDDATA;

+            }

+        }

+    }

+

+    // Scale factors for joint subband coding

+    for (ch = xch_base; ch < s->nchannels; ch++) {

+        int src_ch = s->joint_intensity_index[ch] - 1;

+        if (src_ch >= 0) {

+            int sel = s->joint_scale_sel[ch];

+            for (band = s->nsubbands[ch]; band < s->nsubbands[src_ch]; band++) {

+                if ((ret = parse_joint_scale(s, sel)) < 0)

+                    return ret;

+                s->joint_scale_factors[ch][band] = ret;

+            }

+        }

+    }

+

+    // Dynamic range coefficient

+    if (s->drc_present && header == HEADER_CORE)

+        skip_bits(&s->gb, 8);

+

+    // Side information CRC check word

+    if (s->crc_present)

+        skip_bits(&s->gb, 16);

+

+    return 0;

+}

+

+#ifndef decode_blockcodes

+static inline int decode_blockcodes(int code1, int code2, int levels, int32_t *audio)

+{

+    int offset = (levels - 1) / 2;

+    int n, div;

+

+    for (n = 0; n < DCA_SUBBAND_SAMPLES / 2; n++) {

+        div = FASTDIV(code1, levels);

+        audio[n] = code1 - div * levels - offset;

+        code1 = div;

+    }

+    for (; n < DCA_SUBBAND_SAMPLES; n++) {

+        div = FASTDIV(code2, levels);

+        audio[n] = code2 - div * levels - offset;

+        code2 = div;

+    }

+

+    return code1 | code2;

+}

+#endif

+

+static inline int parse_block_codes(DCACoreDecoder *s, int32_t *audio, int abits)

+{

+    // Extract block code indices from the bit stream

+    int code1 = get_bits(&s->gb, block_code_nbits[abits - 1]);

+    int code2 = get_bits(&s->gb, block_code_nbits[abits - 1]);

+    int levels = ff_dca_quant_levels[abits];

+

+    // Look up samples from the block code book

+    if (decode_blockcodes(code1, code2, levels, audio)) {

+        av_log(s->avctx, AV_LOG_ERROR, "Failed to decode block code(s)\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    return 0;

+}

+

+static inline int parse_huffman_codes(DCACoreDecoder *s, int32_t *audio, int abits, int sel)

+{

+    int i;

+

+    // Extract Huffman codes from the bit stream

+    for (i = 0; i < DCA_SUBBAND_SAMPLES; i++)

+        audio[i] = get_vlc(&s->gb, &vlc_quant_index[abits - 1], sel);

+

+    return 1;

+}

+

+static inline int extract_audio(DCACoreDecoder *s, int32_t *audio, int abits, int ch)

+{

+    av_assert1(abits >= 0 && abits <= DCA_ABITS_MAX);

+

+    if (abits == 0) {

+        // No bits allocated

+        memset(audio, 0, DCA_SUBBAND_SAMPLES * sizeof(*audio));

+        return 0;

+    }

+

+    if (abits <= DCA_CODE_BOOKS) {

+        int sel = s->quant_index_sel[ch][abits - 1];

+        if (sel < quant_index_group_size[abits - 1]) {

+            // Huffman codes

+            return parse_huffman_codes(s, audio, abits, sel);

+        }

+        if (abits <= 7) {

+            // Block codes

+            return parse_block_codes(s, audio, abits);

+        }

+    }

+

+    // No further encoding

+    get_array(&s->gb, audio, DCA_SUBBAND_SAMPLES, abits - 3);

+    return 0;

+}

+

+static inline void dequantize(int32_t *output, const int32_t *input,

+                              int32_t step_size, int32_t scale, int residual)

+{

+    // Account for quantizer step size

+    int64_t step_scale = (int64_t)step_size * scale;

+    int n, shift = 0;

+

+    // Limit scale factor resolution to 22 bits

+    if (step_scale > (1 << 23)) {

+        shift = av_log2(step_scale >> 23) + 1;

+        step_scale >>= shift;

+    }

+

+    // Scale the samples

+    if (residual) {

+        for (n = 0; n < DCA_SUBBAND_SAMPLES; n++)

+            output[n] += clip23(norm__(input[n] * step_scale, 22 - shift));

+    } else {

+        for (n = 0; n < DCA_SUBBAND_SAMPLES; n++)

+            output[n]  = clip23(norm__(input[n] * step_scale, 22 - shift));

+    }

+}

+

+static inline void inverse_adpcm(int32_t **subband_samples,

+                                 const int16_t *vq_index,

+                                 const int8_t *prediction_mode,

+                                 int sb_start, int sb_end,

+                                 int ofs, int len)

+{

+    int i, j, k;

+

+    for (i = sb_start; i < sb_end; i++) {

+        if (prediction_mode[i]) {

+            const int16_t *coeff = ff_dca_adpcm_vb[vq_index[i]];

+            int32_t *ptr = subband_samples[i] + ofs;

+            for (j = 0; j < len; j++) {

+                int64_t err = 0;

+                for (k = 0; k < DCA_ADPCM_COEFFS; k++)

+                    err += (int64_t)ptr[j - k - 1] * coeff[k];

+                ptr[j] = clip23(ptr[j] + clip23(norm13(err)));

+            }

+        }

+    }

+}

+

+// 5.5 - Primary audio data arrays

+static int parse_subframe_audio(DCACoreDecoder *s, int sf, enum HeaderType header,

+                                int xch_base, int *sub_pos, int *lfe_pos)

+{

+    int32_t audio[16], scale;

+    int n, ssf, ofs, ch, band;

+

+    // Check number of subband samples in this subframe