Merge commit 'b339019de4e5f4d3c661bbdba98ae248ab77e2f0'

* commit 'b339019de4e5f4d3c661bbdba98ae248ab77e2f0':
  dca: Split code for handling the EXSS extension off into a separate file

Conflicts:
	libavcodec/Makefile
	libavcodec/dcadec.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>

6 files changed, 580 insertions, 513 deletions

diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 7d3b423462..2aa5120b81 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -189,7 +189,7 @@ 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 dcadsp.o      \
-                                          synth_filter.o
+                                          dca_exss.o synth_filter.o
 OBJS-$(CONFIG_DCA_ENCODER)             += dcaenc.o dca.o
 OBJS-$(CONFIG_DIRAC_DECODER)           += diracdec.o dirac.o diracdsp.o \
                                           dirac_arith.o mpeg12data.o dirac_dwt.o
diff --git a/libavcodec/dca.h b/libavcodec/dca.h
index 70dade5cd0..b752bc3fdb 100644
--- a/libavcodec/dca.h
+++ b/libavcodec/dca.h
@@ -26,8 +26,15 @@
 #define AVCODEC_DCA_H
 
 #include <stdint.h>
+
+#include "libavutil/float_dsp.h"
 #include "libavutil/internal.h"
 
+#include "avcodec.h"
+#include "dcadsp.h"
+#include "fmtconvert.h"
+#include "get_bits.h"
+
 /** DCA syncwords, also used for bitstream type detection */
 #define DCA_MARKER_RAW_BE 0x7FFE8001
 #define DCA_MARKER_RAW_LE 0xFE7F0180
@@ -37,6 +44,164 @@
 /** DCA-HD specific block starts with this marker. */
 #define DCA_HD_MARKER     0x64582025
 
+#define DCA_PRIM_CHANNELS_MAX  (7)
+#define DCA_ABITS_MAX         (32)      /* Should be 28 */
+#define DCA_SUBSUBFRAMES_MAX   (4)
+#define DCA_SUBFRAMES_MAX     (16)
+#define DCA_BLOCKS_MAX        (16)
+#define DCA_LFE_MAX            (3)
+#define DCA_CHSETS_MAX         (4)
+#define DCA_CHSET_CHANS_MAX    (8)
+
+#define DCA_MAX_FRAME_SIZE       16384
+#define DCA_MAX_EXSS_HEADER_SIZE  4096
+
+#define DCA_BUFFER_PADDING_SIZE   1024
+
+enum DCAExtensionMask {
+    DCA_EXT_CORE       = 0x001, ///< core in core substream
+    DCA_EXT_XXCH       = 0x002, ///< XXCh channels extension in core substream
+    DCA_EXT_X96        = 0x004, ///< 96/24 extension in core substream
+    DCA_EXT_XCH        = 0x008, ///< XCh channel extension in core substream
+    DCA_EXT_EXSS_CORE  = 0x010, ///< core in ExSS (extension substream)
+    DCA_EXT_EXSS_XBR   = 0x020, ///< extended bitrate extension in ExSS
+    DCA_EXT_EXSS_XXCH  = 0x040, ///< XXCh channels extension in ExSS
+    DCA_EXT_EXSS_X96   = 0x080, ///< 96/24 extension in ExSS
+    DCA_EXT_EXSS_LBR   = 0x100, ///< low bitrate component in ExSS
+    DCA_EXT_EXSS_XLL   = 0x200, ///< lossless extension in ExSS
+};
+
+typedef struct DCAContext {
+    const AVClass *class;       ///< class for AVOptions
+    AVCodecContext *avctx;
+    /* Frame header */
+    int frame_type;             ///< type of the current frame
+    int samples_deficit;        ///< deficit sample count
+    int crc_present;            ///< crc is present in the bitstream
+    int sample_blocks;          ///< number of PCM sample blocks
+    int frame_size;             ///< primary frame byte size
+    int amode;                  ///< audio channels arrangement
+    int sample_rate;            ///< audio sampling rate
+    int bit_rate;               ///< transmission bit rate
+    int bit_rate_index;         ///< transmission bit rate index
+
+    int dynrange;               ///< embedded dynamic range flag
+    int timestamp;              ///< embedded time stamp flag
+    int aux_data;               ///< auxiliary data flag
+    int hdcd;                   ///< source material is mastered in HDCD
+    int ext_descr;              ///< extension audio descriptor flag
+    int ext_coding;             ///< extended coding flag
+    int aspf;                   ///< audio sync word insertion flag
+    int lfe;                    ///< low frequency effects flag
+    int predictor_history;      ///< predictor history flag
+    int header_crc;             ///< header crc check bytes
+    int multirate_inter;        ///< multirate interpolator switch
+    int version;                ///< encoder software revision
+    int copy_history;           ///< copy history
+    int source_pcm_res;         ///< source pcm resolution
+    int front_sum;              ///< front sum/difference flag
+    int surround_sum;           ///< surround sum/difference flag
+    int dialog_norm;            ///< dialog normalisation parameter
+
+    /* Primary audio coding header */
+    int subframes;              ///< number of subframes
+    int total_channels;         ///< number of channels including extensions
+    int prim_channels;          ///< number of primary audio channels
+    int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
+    int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
+    int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
+    int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
+    int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
+    int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
+    int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
+    float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
+
+    /* Primary audio coding side information */
+    int subsubframes[DCA_SUBFRAMES_MAX];                         ///< number of subsubframes
+    int partial_samples[DCA_SUBFRAMES_MAX];                      ///< partial subsubframe samples count
+    int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
+    int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
+    int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
+    int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
+    int32_t scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];///< scale factors (2 if transient)
+    int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
+    int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
+    float downmix_coef[DCA_PRIM_CHANNELS_MAX + 1][2];            ///< stereo downmix coefficients
+    int dynrange_coef;                                           ///< dynamic range coefficient
+
+    /* Core substream's embedded downmix coefficients (cf. ETSI TS 102 114 V1.4.1)
+     * Input:  primary audio channels (incl. LFE if present)
+     * Output: downmix audio channels (up to 4, no LFE) */
+    uint8_t  core_downmix;                                       ///< embedded downmix coefficients available
+    uint8_t  core_downmix_amode;                                 ///< audio channel arrangement of embedded downmix
+    uint16_t core_downmix_codes[DCA_PRIM_CHANNELS_MAX + 1][4];   ///< embedded downmix coefficients (9-bit codes)
+
+    int32_t  high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];  ///< VQ encoded high frequency subbands
+
+    float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      ///< Low frequency effect data
+    int lfe_scale_factor;
+
+    /* Subband samples history (for ADPCM) */
+    DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
+    DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
+    DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
+    int hist_index[DCA_PRIM_CHANNELS_MAX];
+    DECLARE_ALIGNED(32, float, raXin)[32];
+
+    int output;                 ///< type of output
+
+    DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
+    float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
+    float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
+    uint8_t *extra_channels_buffer;
+    unsigned int extra_channels_buffer_size;
+
+    uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
+    int dca_buffer_size;        ///< how much data is in the dca_buffer
+
+    const int8_t *channel_order_tab;  ///< channel reordering table, lfe and non lfe
+    GetBitContext gb;
+    /* Current position in DCA frame */
+    int current_subframe;
+    int current_subsubframe;
+
+    int core_ext_mask;          ///< present extensions in the core substream
+
+    /* XCh extension information */
+    int xch_present;            ///< XCh extension present and valid
+    int xch_base_channel;       ///< index of first (only) channel containing XCH data
+    int xch_disable;            ///< whether the XCh extension should be decoded or not
+
+    /* XXCH extension information */
+    int xxch_chset;
+    int xxch_nbits_spk_mask;
+    uint32_t xxch_core_spkmask;
+    uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */
+    int xxch_chset_nch[4];
+    float xxch_dmix_sf[DCA_CHSETS_MAX];
+
+    uint32_t xxch_dmix_embedded;  /* lower layer has mix pre-embedded, per chset */
+    float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */
+
+    int8_t xxch_order_tab[32];
+    int8_t lfe_index;
+
+    /* ExSS header parser */
+    int static_fields;          ///< static fields present
+    int mix_metadata;           ///< mixing metadata present
+    int num_mix_configs;        ///< number of mix out configurations
+    int mix_config_num_ch[4];   ///< number of channels in each mix out configuration
+
+    int profile;
+
+    int debug_flag;             ///< used for suppressing repeated error messages output
+    AVFloatDSPContext *fdsp;
+    FFTContext imdct;
+    SynthFilterContext synth;
+    DCADSPContext dcadsp;
+    FmtConvertContext fmt_conv;
+} DCAContext;
+
 extern av_export const uint32_t avpriv_dca_sample_rates[16];
 
 /**
@@ -45,4 +210,7 @@ extern av_export const uint32_t avpriv_dca_sample_rates[16];
 int avpriv_dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
                              int max_size);
 
+int ff_dca_xbr_parse_frame(DCAContext *s);
+int ff_dca_xxch_decode_frame(DCAContext *s);
+
 #endif /* AVCODEC_DCA_H */
diff --git a/libavcodec/dca_exss.c b/libavcodec/dca_exss.c
new file mode 100644
index 0000000000..c90e9950af
--- /dev/null
+++ b/libavcodec/dca_exss.c
@@ -0,0 +1,355 @@
+/*
+ * DCA ExSS extension
+ *
+ * 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 "libavutil/common.h"
+#include "libavutil/log.h"
+
+#include "dca.h"
+#include "dca_exss.h"
+#include "get_bits.h"
+
+/* extensions that reside in core substream */
+#define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
+
+/* these are unconfirmed but should be mostly correct */
+enum DCAExSSSpeakerMask {
+    DCA_EXSS_FRONT_CENTER          = 0x0001,
+    DCA_EXSS_FRONT_LEFT_RIGHT      = 0x0002,
+    DCA_EXSS_SIDE_REAR_LEFT_RIGHT  = 0x0004,
+    DCA_EXSS_LFE                   = 0x0008,
+    DCA_EXSS_REAR_CENTER           = 0x0010,
+    DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
+    DCA_EXSS_REAR_LEFT_RIGHT       = 0x0040,
+    DCA_EXSS_FRONT_HIGH_CENTER     = 0x0080,
+    DCA_EXSS_OVERHEAD              = 0x0100,
+    DCA_EXSS_CENTER_LEFT_RIGHT     = 0x0200,
+    DCA_EXSS_WIDE_LEFT_RIGHT       = 0x0400,
+    DCA_EXSS_SIDE_LEFT_RIGHT       = 0x0800,
+    DCA_EXSS_LFE2                  = 0x1000,
+    DCA_EXSS_SIDE_HIGH_LEFT_RIGHT  = 0x2000,
+    DCA_EXSS_REAR_HIGH_CENTER      = 0x4000,
+    DCA_EXSS_REAR_HIGH_LEFT_RIGHT  = 0x8000,
+};
+
+/**
+ * Return the number of channels in an ExSS speaker mask (HD)
+ */
+static int dca_exss_mask2count(int mask)
+{
+    /* count bits that mean speaker pairs twice */
+    return av_popcount(mask) +
+           av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT      |
+                               DCA_EXSS_FRONT_LEFT_RIGHT       |
+                               DCA_EXSS_FRONT_HIGH_LEFT_RIGHT  |
+                               DCA_EXSS_WIDE_LEFT_RIGHT        |
+                               DCA_EXSS_SIDE_LEFT_RIGHT        |
+                               DCA_EXSS_SIDE_HIGH_LEFT_RIGHT   |
+                               DCA_EXSS_SIDE_REAR_LEFT_RIGHT   |
+                               DCA_EXSS_REAR_LEFT_RIGHT        |
+                               DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
+}
+
+/**
+ * Skip mixing coefficients of a single mix out configuration (HD)
+ */
+static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
+{
+    int i;
+
+    for (i = 0; i < channels; i++) {
+        int mix_map_mask = get_bits(gb, out_ch);
+        int num_coeffs = av_popcount(mix_map_mask);
+        skip_bits_long(gb, num_coeffs * 6);
+    }
+}
+
+/**
+ * Parse extension substream asset header (HD)
+ */
+static int dca_exss_parse_asset_header(DCAContext *s)
+{
+    int header_pos = get_bits_count(&s->gb);
+    int header_size;
+    int channels = 0;
+    int embedded_stereo = 0;
+    int embedded_6ch    = 0;
+    int drc_code_present;
+    int extensions_mask = 0;
+    int i, j;
+
+    if (get_bits_left(&s->gb) < 16)
+        return -1;
+
+    /* We will parse just enough to get to the extensions bitmask with which
+     * we can set the profile value. */
+
+    header_size = get_bits(&s->gb, 9) + 1;
+    skip_bits(&s->gb, 3); // asset index
+
+    if (s->static_fields) {
+        if (get_bits1(&s->gb))
+            skip_bits(&s->gb, 4); // asset type descriptor
+        if (get_bits1(&s->gb))
+            skip_bits_long(&s->gb, 24); // language descriptor
+
+        if (get_bits1(&s->gb)) {
+            /* How can one fit 1024 bytes of text here if the maximum value
+             * for the asset header size field above was 512 bytes? */
+            int text_length = get_bits(&s->gb, 10) + 1;
+            if (get_bits_left(&s->gb) < text_length * 8)
+                return -1;
+            skip_bits_long(&s->gb, text_length * 8); // info text
+        }
+
+        skip_bits(&s->gb, 5); // bit resolution - 1
+        skip_bits(&s->gb, 4); // max sample rate code
+        channels = get_bits(&s->gb, 8) + 1;
+
+        if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
+            int spkr_remap_sets;
+            int spkr_mask_size = 16;
+            int num_spkrs[7];
+
+            if (channels > 2)
+                embedded_stereo = get_bits1(&s->gb);
+            if (channels > 6)
+                embedded_6ch = get_bits1(&s->gb);
+
+            if (get_bits1(&s->gb)) {
+                spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
+                skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
+            }
+
+            spkr_remap_sets = get_bits(&s->gb, 3);
+
+            for (i = 0; i < spkr_remap_sets; i++) {
+                /* std layout mask for each remap set */
+                num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
+            }
+
+            for (i = 0; i < spkr_remap_sets; i++) {
+                int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
+                if (get_bits_left(&s->gb) < 0)
+                    return -1;
+
+                for (j = 0; j < num_spkrs[i]; j++) {
+                    int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
+                    int num_dec_ch = av_popcount(remap_dec_ch_mask);
+                    skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
+                }
+            }
+        } else {
+            skip_bits(&s->gb, 3); // representation type
+        }
+    }
+
+    drc_code_present = get_bits1(&s->gb);
+    if (drc_code_present)
+        get_bits(&s->gb, 8); // drc code
+
+    if (get_bits1(&s->gb))
+        skip_bits(&s->gb, 5); // dialog normalization code
+
+    if (drc_code_present && embedded_stereo)
+        get_bits(&s->gb, 8); // drc stereo code
+
+    if (s->mix_metadata && get_bits1(&s->gb)) {
+        skip_bits(&s->gb, 1); // external mix
+        skip_bits(&s->gb, 6); // post mix gain code
+
+        if (get_bits(&s->gb, 2) != 3) // mixer drc code
+            skip_bits(&s->gb, 3); // drc limit
+        else
+            skip_bits(&s->gb, 8); // custom drc code
+
+        if (get_bits1(&s->gb)) // channel specific scaling
+            for (i = 0; i < s->num_mix_configs; i++)
+                skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
+        else
+            skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
+
+        for (i = 0; i < s->num_mix_configs; i++) {
+            if (get_bits_left(&s->gb) < 0)
+                return -1;
+            dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
+            if (embedded_6ch)
+                dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
+            if (embedded_stereo)
+                dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
+        }
+    }
+
+    switch (get_bits(&s->gb, 2)) {
+    case 0:
+        extensions_mask = get_bits(&s->gb, 12);
+        break;
+    case 1:
+        extensions_mask = DCA_EXT_EXSS_XLL;
+        break;
+    case 2:
+        extensions_mask = DCA_EXT_EXSS_LBR;
+        break;
+    case 3:
+        extensions_mask = 0; /* aux coding */
+        break;
+    }
+
+    /* not parsed further, we were only interested in the extensions mask */
+
+    if (get_bits_left(&s->gb) < 0)
+        return -1;
+
+    if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
+        av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
+        return -1;
+    }
+    skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
+
+    if (extensions_mask & DCA_EXT_EXSS_XLL)
+        s->profile = FF_PROFILE_DTS_HD_MA;
+    else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
+                                DCA_EXT_EXSS_XXCH))
+        s->profile = FF_PROFILE_DTS_HD_HRA;
+
+    if (!(extensions_mask & DCA_EXT_CORE))
+        av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
+    if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
+        av_log(s->avctx, AV_LOG_WARNING,
+               "DTS extensions detection mismatch (%d, %d)\n",
+               extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
+
+    return 0;
+}
+
+/**
+ * Parse extension substream header (HD)
+ */
+void ff_dca_exss_parse_header(DCAContext *s)
+{
+    int asset_size[8];
+    int ss_index;
+    int blownup;
+    int num_audiop = 1;
+    int num_assets = 1;
+    int active_ss_mask[8];
+    int i, j;
+    int start_posn;
+    int hdrsize;
+    uint32_t mkr;
+
+    if (get_bits_left(&s->gb) < 52)
+        return;
+
+    start_posn = get_bits_count(&s->gb) - 32;
+
+    skip_bits(&s->gb, 8); // user data
+    ss_index = get_bits(&s->gb, 2);
+
+    blownup = get_bits1(&s->gb);
+    hdrsize = get_bits(&s->gb,  8 + 4 * blownup) + 1; // header_size
+    skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
+
+    s->static_fields = get_bits1(&s->gb);
+    if (s->static_fields) {
+        skip_bits(&s->gb, 2); // reference clock code
+        skip_bits(&s->gb, 3); // frame duration code
+
+        if (get_bits1(&s->gb))
+            skip_bits_long(&s->gb, 36); // timestamp
+
+        /* a single stream can contain multiple audio assets that can be
+         * combined to form multiple audio presentations */
+
+        num_audiop = get_bits(&s->gb, 3) + 1;
+        if (num_audiop > 1) {
+            avpriv_request_sample(s->avctx,
+                                  "Multiple DTS-HD audio presentations");
+            /* ignore such streams for now */
+            return;
+        }
+
+        num_assets = get_bits(&s->gb, 3) + 1;
+        if (num_assets > 1) {
+            avpriv_request_sample(s->avctx, "Multiple DTS-HD audio assets");
+            /* ignore such streams for now */
+            return;
+        }
+
+        for (i = 0; i < num_audiop; i++)
+            active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
+
+        for (i = 0; i < num_audiop; i++)
+            for (j = 0; j <= ss_index; j++)
+                if (active_ss_mask[i] & (1 << j))
+                    skip_bits(&s->gb, 8); // active asset mask
+
+        s->mix_metadata = get_bits1(&s->gb);
+        if (s->mix_metadata) {
+            int mix_out_mask_size;
+
+            skip_bits(&s->gb, 2); // adjustment level
+            mix_out_mask_size  = (get_bits(&s->gb, 2) + 1) << 2;
+            s->num_mix_configs =  get_bits(&s->gb, 2) + 1;
+
+            for (i = 0; i < s->num_mix_configs; i++) {
+                int mix_out_mask        = get_bits(&s->gb, mix_out_mask_size);
+                s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
+            }
+        }
+    }
+
+    av_assert0(num_assets > 0); // silence a warning
+
+    for (i = 0; i < num_assets; i++)
+        asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup);
+
+    for (i = 0; i < num_assets; i++) {
+        if (dca_exss_parse_asset_header(s))
+            return;
+    }
+
+    /* not parsed further, we were only interested in the extensions mask
+     * from the asset header */
+
+        j = get_bits_count(&s->gb);
+        if (start_posn + hdrsize * 8 > j)
+            skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j);
+
+        for (i = 0; i < num_assets; i++) {
+            start_posn = get_bits_count(&s->gb);
+            mkr        = get_bits_long(&s->gb, 32);
+
+            /* parse extensions that we know about */
+            if (mkr == 0x655e315e) {
+                ff_dca_xbr_parse_frame(s);
+            } else if (mkr == 0x47004a03) {
+                ff_dca_xxch_decode_frame(s);
+                s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
+            } else {
+                av_log(s->avctx, AV_LOG_DEBUG,
+                       "DTS-ExSS: unknown marker = 0x%08x\n", mkr);
+            }
+
+            /* skip to end of block */
+            j = get_bits_count(&s->gb);
+            if (start_posn + asset_size[i] * 8 > j)
+                skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j);
+        }
+}
diff --git a/libavcodec/dca_exss.h b/libavcodec/dca_exss.h
new file mode 100644
index 0000000000..6689bbb3fb
--- /dev/null
+++ b/libavcodec/dca_exss.h
@@ -0,0 +1,28 @@
+/*
+ * DCA ExSS extension
+ *
+ * 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
+ */
+
+#ifndef AVCODEC_DCA_EXSS_H
+#define AVCODEC_DCA_EXSS_H
+
+#include "dca.h"
+
+void ff_dca_exss_parse_header(DCAContext *s);
+
+#endif /* AVCODEC_DCA_EXSS_H */
diff --git a/libavcodec/dcadec.c b/libavcodec/dcadec.c
index 4e38511aa0..c6190a58a0 100644
--- a/libavcodec/dcadec.c
+++ b/libavcodec/dcadec.c
@@ -40,6 +40,7 @@
 #include "dcadata.h"
 #include "dcadsp.h"
 #include "dcahuff.h"
+#include "dca_exss.h"
 #include "fft.h"
 #include "fmtconvert.h"
 #include "get_bits.h"
@@ -53,15 +54,6 @@
 
 //#define TRACE
 
-#define DCA_PRIM_CHANNELS_MAX  (7)
-#define DCA_ABITS_MAX         (32)      /* Should be 28 */
-#define DCA_SUBSUBFRAMES_MAX   (4)
-#define DCA_SUBFRAMES_MAX     (16)
-#define DCA_BLOCKS_MAX        (16)
-#define DCA_LFE_MAX            (3)
-#define DCA_CHSETS_MAX         (4)
-#define DCA_CHSET_CHANS_MAX    (8)
-
 enum DCAMode {
     DCA_MONO = 0,
     DCA_CHANNEL,
@@ -76,25 +68,6 @@ enum DCAMode {
     DCA_4F2R
 };
 
-/* these are unconfirmed but should be mostly correct */
-enum DCAExSSSpeakerMask {
-    DCA_EXSS_FRONT_CENTER          = 0x0001,
-    DCA_EXSS_FRONT_LEFT_RIGHT      = 0x0002,
-    DCA_EXSS_SIDE_REAR_LEFT_RIGHT  = 0x0004,
-    DCA_EXSS_LFE                   = 0x0008,
-    DCA_EXSS_REAR_CENTER           = 0x0010,
-    DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
-    DCA_EXSS_REAR_LEFT_RIGHT       = 0x0040,
-    DCA_EXSS_FRONT_HIGH_CENTER     = 0x0080,
-    DCA_EXSS_OVERHEAD              = 0x0100,
-    DCA_EXSS_CENTER_LEFT_RIGHT     = 0x0200,
-    DCA_EXSS_WIDE_LEFT_RIGHT       = 0x0400,
-    DCA_EXSS_SIDE_LEFT_RIGHT       = 0x0800,
-    DCA_EXSS_LFE2                  = 0x1000,
-    DCA_EXSS_SIDE_HIGH_LEFT_RIGHT  = 0x2000,
-    DCA_EXSS_REAR_HIGH_CENTER      = 0x4000,
-    DCA_EXSS_REAR_HIGH_LEFT_RIGHT  = 0x8000,
-};
 
 enum DCAXxchSpeakerMask {
     DCA_XXCH_FRONT_CENTER          = 0x0000001,
@@ -158,19 +131,6 @@ static const uint32_t map_xxch_to_native[28] = {
     AV_CH_BACK_RIGHT            /* read low right -- dup  */
 };
 
-enum DCAExtensionMask {
-    DCA_EXT_CORE       = 0x001, ///< core in core substream
-    DCA_EXT_XXCH       = 0x002, ///< XXCh channels extension in core substream
-    DCA_EXT_X96        = 0x004, ///< 96/24 extension in core substream
-    DCA_EXT_XCH        = 0x008, ///< XCh channel extension in core substream
-    DCA_EXT_EXSS_CORE  = 0x010, ///< core in ExSS (extension substream)
-    DCA_EXT_EXSS_XBR   = 0x020, ///< extended bitrate extension in ExSS
-    DCA_EXT_EXSS_XXCH  = 0x040, ///< XXCh channels extension in ExSS
-    DCA_EXT_EXSS_X96   = 0x080, ///< 96/24 extension in ExSS
-    DCA_EXT_EXSS_LBR   = 0x100, ///< low bitrate component in ExSS
-    DCA_EXT_EXSS_XLL   = 0x200, ///< lossless extension in ExSS
-};
-
 /* -1 are reserved or unknown */
 static const int dca_ext_audio_descr_mask[] = {
     DCA_EXT_XCH,
@@ -183,9 +143,6 @@ static const int dca_ext_audio_descr_mask[] = {
     -1,
 };
 
-/* extensions that reside in core substream */
-#define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
-
 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
  * Some compromises have been made for special configurations. Most configurations
  * are never used so complete accuracy is not needed.
@@ -321,11 +278,6 @@ static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
 
 #define HEADER_SIZE                 14
 
-#define DCA_MAX_FRAME_SIZE       16384
-#define DCA_MAX_EXSS_HEADER_SIZE  4096
-
-#define DCA_BUFFER_PADDING_SIZE   1024
-
 #define DCA_NSYNCAUX        0x9A1105A0
 
 /** Bit allocation */
@@ -348,137 +300,6 @@ static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
            ba->offset;
 }
 
-typedef struct DCAContext {
-    const AVClass *class;       ///< class for AVOptions
-    AVCodecContext *avctx;
-    /* Frame header */
-    int frame_type;             ///< type of the current frame
-    int samples_deficit;        ///< deficit sample count
-    int crc_present;            ///< crc is present in the bitstream
-    int sample_blocks;          ///< number of PCM sample blocks
-    int frame_size;             ///< primary frame byte size
-    int amode;                  ///< audio channels arrangement
-    int sample_rate;            ///< audio sampling rate
-    int bit_rate;               ///< transmission bit rate
-    int bit_rate_index;         ///< transmission bit rate index
-
-    int dynrange;               ///< embedded dynamic range flag
-    int timestamp;              ///< embedded time stamp flag
-    int aux_data;               ///< auxiliary data flag
-    int hdcd;                   ///< source material is mastered in HDCD
-    int ext_descr;              ///< extension audio descriptor flag
-    int ext_coding;             ///< extended coding flag
-    int aspf;                   ///< audio sync word insertion flag
-    int lfe;                    ///< low frequency effects flag
-    int predictor_history;      ///< predictor history flag
-    int header_crc;             ///< header crc check bytes
-    int multirate_inter;        ///< multirate interpolator switch
-    int version;                ///< encoder software revision
-    int copy_history;           ///< copy history
-    int source_pcm_res;         ///< source pcm resolution
-    int front_sum;              ///< front sum/difference flag
-    int surround_sum;           ///< surround sum/difference flag
-    int dialog_norm;            ///< dialog normalisation parameter
-
-    /* Primary audio coding header */
-    int subframes;              ///< number of subframes
-    int total_channels;         ///< number of channels including extensions
-    int prim_channels;          ///< number of primary audio channels
-    int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
-    int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
-    int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
-    int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
-    int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
-    int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
-    int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
-    float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
-
-    /* Primary audio coding side information */
-    int subsubframes[DCA_SUBFRAMES_MAX];                         ///< number of subsubframes
-    int partial_samples[DCA_SUBFRAMES_MAX];                      ///< partial subsubframe samples count
-    int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
-    int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
-    int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
-    int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
-    int32_t scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];///< scale factors (2 if transient)
-    int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
-    int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
-    float downmix_coef[DCA_PRIM_CHANNELS_MAX + 1][2];            ///< stereo downmix coefficients
-    int dynrange_coef;                                           ///< dynamic range coefficient
-
-    /* Core substream's embedded downmix coefficients (cf. ETSI TS 102 114 V1.4.1)
-     * Input:  primary audio channels (incl. LFE if present)
-     * Output: downmix audio channels (up to 4, no LFE) */
-    uint8_t  core_downmix;                                       ///< embedded downmix coefficients available
-    uint8_t  core_downmix_amode;                                 ///< audio channel arrangement of embedded downmix
-    uint16_t core_downmix_codes[DCA_PRIM_CHANNELS_MAX + 1][4];   ///< embedded downmix coefficients (9-bit codes)
-
-    int32_t  high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];  ///< VQ encoded high frequency subbands
-
-    float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      ///< Low frequency effect data
-    int lfe_scale_factor;
-
-    /* Subband samples history (for ADPCM) */
-    DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
-    DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
-    DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
-    int hist_index[DCA_PRIM_CHANNELS_MAX];
-    DECLARE_ALIGNED(32, float, raXin)[32];
-
-    int output;                 ///< type of output
-
-    DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
-    float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
-    float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
-    uint8_t *extra_channels_buffer;
-    unsigned int extra_channels_buffer_size;
-
-    uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
-    int dca_buffer_size;        ///< how much data is in the dca_buffer
-
-    const int8_t *channel_order_tab;  ///< channel reordering table, lfe and non lfe
-    GetBitContext gb;
-    /* Current position in DCA frame */
-    int current_subframe;
-    int current_subsubframe;
-
-    int core_ext_mask;          ///< present extensions in the core substream
-
-    /* XCh extension information */
-    int xch_present;            ///< XCh extension present and valid
-    int xch_base_channel;       ///< index of first (only) channel containing XCH data
-    int xch_disable;            ///< whether the XCh extension should be decoded or not
-
-    /* XXCH extension information */
-    int xxch_chset;
-    int xxch_nbits_spk_mask;
-    uint32_t xxch_core_spkmask;
-    uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */
-    int xxch_chset_nch[4];
-    float xxch_dmix_sf[DCA_CHSETS_MAX];
-
-    uint32_t xxch_dmix_embedded;  /* lower layer has mix pre-embedded, per chset */
-    float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */
-
-    int8_t xxch_order_tab[32];
-    int8_t lfe_index;
-
-    /* ExSS header parser */
-    int static_fields;          ///< static fields present
-    int mix_metadata;           ///< mixing metadata present
-    int num_mix_configs;        ///< number of mix out configurations
-    int mix_config_num_ch[4];   ///< number of channels in each mix out configuration
-
-    int profile;
-
-    int debug_flag;             ///< used for suppressing repeated error messages output
-    AVFloatDSPContext *fdsp;
-    FFTContext imdct;
-    SynthFilterContext synth;
-    DCADSPContext dcadsp;
-    FmtConvertContext fmt_conv;
-} DCAContext;
-
 static float dca_dmix_code(unsigned code);
 
 static const uint16_t dca_vlc_offs[] = {
@@ -1594,197 +1415,7 @@ static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
     return 0;
 }
 
-/**
- * Return the number of channels in an ExSS speaker mask (HD)
- */
-static int dca_exss_mask2count(int mask)
-{
-    /* count bits that mean speaker pairs twice */
-    return av_popcount(mask) +
-           av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT      |
-                               DCA_EXSS_FRONT_LEFT_RIGHT       |
-                               DCA_EXSS_FRONT_HIGH_LEFT_RIGHT  |
-                               DCA_EXSS_WIDE_LEFT_RIGHT        |
-                               DCA_EXSS_SIDE_LEFT_RIGHT        |
-                               DCA_EXSS_SIDE_HIGH_LEFT_RIGHT   |
-                               DCA_EXSS_SIDE_REAR_LEFT_RIGHT   |
-                               DCA_EXSS_REAR_LEFT_RIGHT        |
-                               DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
-}
-
-/**
- * Skip mixing coefficients of a single mix out configuration (HD)
- */
-static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
-{
-    int i;
-
-    for (i = 0; i < channels; i++) {
-        int mix_map_mask = get_bits(gb, out_ch);
-        int num_coeffs = av_popcount(mix_map_mask);
-        skip_bits_long(gb, num_coeffs * 6);
-    }
-}
-
-/**
- * Parse extension substream asset header (HD)
- */
-static int dca_exss_parse_asset_header(DCAContext *s)
-{
-    int header_pos = get_bits_count(&s->gb);
-    int header_size;
-    int channels = 0;
-    int embedded_stereo = 0;
-    int embedded_6ch    = 0;
-    int drc_code_present;
-    int extensions_mask = 0;
-    int i, j;
-
-    if (get_bits_left(&s->gb) < 16)
-        return -1;
-
-    /* We will parse just enough to get to the extensions bitmask with which
-     * we can set the profile value. */
-
-    header_size = get_bits(&s->gb, 9) + 1;
-    skip_bits(&s->gb, 3); // asset index
-
-    if (s->static_fields) {
-        if (get_bits1(&s->gb))
-            skip_bits(&s->gb, 4); // asset type descriptor
-        if (get_bits1(&s->gb))
-            skip_bits_long(&s->gb, 24); // language descriptor
-
-        if (get_bits1(&s->gb)) {
-            /* How can one fit 1024 bytes of text here if the maximum value
-             * for the asset header size field above was 512 bytes? */
-            int text_length = get_bits(&s->gb, 10) + 1;
-            if (get_bits_left(&s->gb) < text_length * 8)
-                return -1;
-            skip_bits_long(&s->gb, text_length * 8); // info text
-        }
-
-        skip_bits(&s->gb, 5); // bit resolution - 1
-        skip_bits(&s->gb, 4); // max sample rate code
-        channels = get_bits(&s->gb, 8) + 1;
-
-        if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
-            int spkr_remap_sets;
-            int spkr_mask_size = 16;
-            int num_spkrs[7];
-
-            if (channels > 2)
-                embedded_stereo = get_bits1(&s->gb);
-            if (channels > 6)
-                embedded_6ch = get_bits1(&s->gb);
-
-            if (get_bits1(&s->gb)) {
-                spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
-                skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
-            }
-
-            spkr_remap_sets = get_bits(&s->gb, 3);
-
-            for (i = 0; i < spkr_remap_sets; i++) {
-                /* std layout mask for each remap set */
-                num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
-            }
-
-            for (i = 0; i < spkr_remap_sets; i++) {
-                int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
-                if (get_bits_left(&s->gb) < 0)
-                    return -1;
-
-                for (j = 0; j < num_spkrs[i]; j++) {
-                    int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
-                    int num_dec_ch = av_popcount(remap_dec_ch_mask);
-                    skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
-                }
-            }
-        } else {
-            skip_bits(&s->gb, 3); // representation type
-        }
-    }
-
-    drc_code_present = get_bits1(&s->gb);
-    if (drc_code_present)
-        get_bits(&s->gb, 8); // drc code
-
-    if (get_bits1(&s->gb))
-        skip_bits(&s->gb, 5); // dialog normalization code
-
-    if (drc_code_present && embedded_stereo)
-        get_bits(&s->gb, 8); // drc stereo code
-
-    if (s->mix_metadata && get_bits1(&s->gb)) {
-        skip_bits(&s->gb, 1); // external mix
-        skip_bits(&s->gb, 6); // post mix gain code
-
-        if (get_bits(&s->gb, 2) != 3) // mixer drc code
-            skip_bits(&s->gb, 3); // drc limit
-        else
-            skip_bits(&s->gb, 8); // custom drc code
-
-        if (get_bits1(&s->gb)) // channel specific scaling
-            for (i = 0; i < s->num_mix_configs; i++)
-                skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
-        else
-            skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
-
-        for (i = 0; i < s->num_mix_configs; i++) {
-            if (get_bits_left(&s->gb) < 0)
-                return -1;
-            dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
-            if (embedded_6ch)
-                dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
-            if (embedded_stereo)
-                dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
-        }
-    }
-
-    switch (get_bits(&s->gb, 2)) {
-    case 0:
-        extensions_mask = get_bits(&s->gb, 12);
-        break;
-    case 1:
-        extensions_mask = DCA_EXT_EXSS_XLL;
-        break;
-    case 2:
-        extensions_mask = DCA_EXT_EXSS_LBR;
-        break;
-    case 3:
-        extensions_mask = 0; /* aux coding */
-        break;
-    }
-
-    /* not parsed further, we were only interested in the extensions mask */
-
-    if (get_bits_left(&s->gb) < 0)
-        return -1;
-
-    if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
-        av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
-        return -1;
-    }
-    skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
-
-    if (extensions_mask & DCA_EXT_EXSS_XLL)
-        s->profile = FF_PROFILE_DTS_HD_MA;
-    else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
-                                DCA_EXT_EXSS_XXCH))
-        s->profile = FF_PROFILE_DTS_HD_HRA;
-
-    if (!(extensions_mask & DCA_EXT_CORE))
-        av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
-    if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
-        av_log(s->avctx, AV_LOG_WARNING,
-               "DTS extensions detection mismatch (%d, %d)\n",
-               extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
-
-    return 0;
-}
-
-static int dca_xbr_parse_frame(DCAContext *s)
+int ff_dca_xbr_parse_frame(DCAContext *s)
 {
     int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];
     int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];
@@ -1944,8 +1575,9 @@ static int dca_xbr_parse_frame(DCAContext *s)
     return 0;
 }
 
+
 /* parse initial header for XXCH and dump details */
-static int dca_xxch_decode_frame(DCAContext *s)
+int ff_dca_xxch_decode_frame(DCAContext *s)
 {
     int hdr_size, spkmsk_bits, num_chsets, core_spk, hdr_pos;
     int i, chset, base_channel, chstart, fsize[8];
@@ -1998,122 +1630,6 @@ static int dca_xxch_decode_frame(DCAContext *s)
     return 0;
 }
 
-/**
- * Parse extension substream header (HD)
- */
-static void dca_exss_parse_header(DCAContext *s)
-{
-    int asset_size[8];
-    int ss_index;
-    int blownup;
-    int num_audiop = 1;
-    int num_assets = 1;
-    int active_ss_mask[8];
-    int i, j;
-    int start_posn;
-    int hdrsize;
-    uint32_t mkr;
-
-    if (get_bits_left(&s->gb) < 52)
-        return;
-
-    start_posn = get_bits_count(&s->gb) - 32;
-
-    skip_bits(&s->gb, 8); // user data
-    ss_index = get_bits(&s->gb, 2);
-
-    blownup = get_bits1(&s->gb);
-    hdrsize = get_bits(&s->gb,  8 + 4 * blownup) + 1; // header_size
-    skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
-
-    s->static_fields = get_bits1(&s->gb);
-    if (s->static_fields) {
-        skip_bits(&s->gb, 2); // reference clock code
-        skip_bits(&s->gb, 3); // frame duration code
-
-        if (get_bits1(&s->gb))
-            skip_bits_long(&s->gb, 36); // timestamp
-
-        /* a single stream can contain multiple audio assets that can be
-         * combined to form multiple audio presentations */
-
-        num_audiop = get_bits(&s->gb, 3) + 1;
-        if (num_audiop > 1) {
-            avpriv_request_sample(s->avctx,
-                                  "Multiple DTS-HD audio presentations");
-            /* ignore such streams for now */
-            return;
-        }
-
-        num_assets = get_bits(&s->gb, 3) + 1;
-        if (num_assets > 1) {
-            avpriv_request_sample(s->avctx, "Multiple DTS-HD audio assets");
-            /* ignore such streams for now */
-            return;
-        }
-
-        for (i = 0; i < num_audiop; i++)
-            active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
-
-        for (i = 0; i < num_audiop; i++)
-            for (j = 0; j <= ss_index; j++)
-                if (active_ss_mask[i] & (1 << j))
-                    skip_bits(&s->gb, 8); // active asset mask
-
-        s->mix_metadata = get_bits1(&s->gb);
-        if (s->mix_metadata) {
-            int mix_out_mask_size;
-
-            skip_bits(&s->gb, 2); // adjustment level
-            mix_out_mask_size  = (get_bits(&s->gb, 2) + 1) << 2;
-            s->num_mix_configs =  get_bits(&s->gb, 2) + 1;
-
-            for (i = 0; i < s->num_mix_configs; i++) {
-                int mix_out_mask        = get_bits(&s->gb, mix_out_mask_size);
-                s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
-            }
-        }
-    }
-
-    av_assert0(num_assets > 0); // silence a warning
-
-    for (i = 0; i < num_assets; i++)
-        asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup);
-
-    for (i = 0; i < num_assets; i++) {
-        if (dca_exss_parse_asset_header(s))
-            return;
-    }
-
-    /* not parsed further, we were only interested in the extensions mask
-     * from the asset header */
-
-        j = get_bits_count(&s->gb);
-        if (start_posn + hdrsize * 8 > j)
-            skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j);
-
-        for (i = 0; i < num_assets; i++) {
-            start_posn = get_bits_count(&s->gb);
-            mkr        = get_bits_long(&s->gb, 32);
-
-            /* parse extensions that we know about */
-            if (mkr == 0x655e315e) {
-                dca_xbr_parse_frame(s);
-            } else if (mkr == 0x47004a03) {
-                dca_xxch_decode_frame(s);
-                s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
-            } else {
-                av_log(s->avctx, AV_LOG_DEBUG,
-                       "DTS-ExSS: unknown marker = 0x%08x\n", mkr);
-            }
-
-            /* skip to end of block */
-            j = get_bits_count(&s->gb);
-            if (start_posn + asset_size[i] * 8 > j)
-                skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j);
-        }
-}
-
 static float dca_dmix_code(unsigned code)
 {
     int sign = (code >> 8) - 1;
@@ -2291,7 +1807,7 @@ static int dca_decode_frame(AVCodecContext *avctx, void *data,
                 /* usually found either in core or HD part in DTS-HD HRA streams,
                  * but not in DTS-ES which contains XCh extensions instead */
                 s->core_ext_mask |= DCA_EXT_XXCH;
-                dca_xxch_decode_frame(s);
+                ff_dca_xxch_decode_frame(s);
                 break;
 
             case 0x1d95f262: {
@@ -2325,7 +1841,7 @@ static int dca_decode_frame(AVCodecContext *avctx, void *data,
     /* check for ExSS (HD part) */
     if (s->dca_buffer_size - s->frame_size > 32 &&
         get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
-        dca_exss_parse_header(s);
+        ff_dca_exss_parse_header(s);
 
     avctx->profile = s->profile;
 
diff --git a/libavcodec/dcaenc.c b/libavcodec/dcaenc.c
index 905cdc9ade..2325b0b0ec 100644
--- a/libavcodec/dcaenc.c
+++ b/libavcodec/dcaenc.c
@@ -43,7 +43,7 @@
 #define SUBBAND_SAMPLES (SUBFRAMES * SUBSUBFRAMES * 8)
 #define AUBANDS 25
 
-typedef struct DCAContext {
+typedef struct DCAEncContext {
     PutBitContext pb;
     int frame_size;
     int frame_bits;
@@ -73,7 +73,7 @@ typedef struct DCAContext {
     int32_t worst_quantization_noise;
     int32_t worst_noise_ever;
     int consumed_bits;
-} DCAContext;
+} DCAEncContext;
 
 static int32_t cos_table[2048];
 static int32_t band_interpolation[2][512];
@@ -105,7 +105,7 @@ static double gammafilter(int i, double f)
 
 static int encode_init(AVCodecContext *avctx)
 {
-    DCAContext *c = avctx->priv_data;
+    DCAEncContext *c = avctx->priv_data;
     uint64_t layout = avctx->channel_layout;
     int i, min_frame_bits;
 
@@ -235,7 +235,7 @@ static inline int32_t mul32(int32_t a, int32_t b)
     return r >> 32;
 }
 
-static void subband_transform(DCAContext *c, const int32_t *input)
+static void subband_transform(DCAEncContext *c, const int32_t *input)
 {
     int ch, subs, i, k, j;
 
@@ -285,7 +285,7 @@ static void subband_transform(DCAContext *c, const int32_t *input)
     }
 }
 
-static void lfe_downsample(DCAContext *c, const int32_t *input)
+static void lfe_downsample(DCAEncContext *c, const int32_t *input)
 {
     /* FIXME: make 128x LFE downsampling possible */
     int i, j, lfes;
@@ -442,11 +442,11 @@ static void adjust_jnd(int samplerate_index,
         out_cb[j] = add_cb(out_cb[j], -out_cb_unnorm[j] - ca_cb - cs_cb);
 }
 
-typedef void (*walk_band_t)(DCAContext *c, int band1, int band2, int f,
+typedef void (*walk_band_t)(DCAEncContext *c, int band1, int band2, int f,
                             int32_t spectrum1, int32_t spectrum2, int channel,
                             int32_t * arg);
 
-static void walk_band_low(DCAContext *c, int band, int channel,
+static void walk_band_low(DCAEncContext *c, int band, int channel,
                           walk_band_t walk, int32_t *arg)
 {
     int f;
@@ -461,7 +461,7 @@ static void walk_band_low(DCAContext *c, int band, int channel,
     }
 }
 
-static void walk_band_high(DCAContext *c, int band, int channel,
+static void walk_band_high(DCAEncContext *c, int band, int channel,
                            walk_band_t walk, int32_t *arg)
 {
     int f;
@@ -476,7 +476,7 @@ static void walk_band_high(DCAContext *c, int band, int channel,
     }
 }
 
-static void update_band_masking(DCAContext *c, int band1, int band2,
+static void update_band_masking(DCAEncContext *c, int band1, int band2,
                                 int f, int32_t spectrum1, int32_t spectrum2,
                                 int channel, int32_t * arg)
 {
@@ -486,7 +486,7 @@ static void update_band_masking(DCAContext *c, int band1, int band2,
         c->band_masking_cb[band1] = value;
 }
 
-static void calc_masking(DCAContext *c, const int32_t *input)
+static void calc_masking(DCAEncContext *c, const int32_t *input)
 {
     int i, k, band, ch, ssf;
     int32_t data[512];
@@ -519,7 +519,7 @@ static void calc_masking(DCAContext *c, const int32_t *input)
     }
 }
 
-static void find_peaks(DCAContext *c)
+static void find_peaks(DCAEncContext *c)
 {
     int band, ch;
 
@@ -552,7 +552,7 @@ static const int snr_fudge = 128;
 #define USED_NABITS 2
 #define USED_26ABITS 4
 
-static int init_quantization_noise(DCAContext *c, int noise)
+static int init_quantization_noise(DCAEncContext *c, int noise)
 {
     int ch, band, ret = 0;
 
@@ -589,7 +589,7 @@ static int init_quantization_noise(DCAContext *c, int noise)
     return ret;
 }
 
-static void assign_bits(DCAContext *c)
+static void assign_bits(DCAEncContext *c)
 {
     /* Find the bounds where the binary search should work */
     int low, high, down;
@@ -627,7 +627,7 @@ out:
         c->worst_noise_ever = high;
 }
 
-static void shift_history(DCAContext *c, const int32_t *input)
+static void shift_history(DCAEncContext *c, const int32_t *input)
 {
     int k, ch;
 
@@ -677,7 +677,7 @@ static int calc_one_scale(int32_t peak_cb, int abits, softfloat *quant)
     return our_nscale;
 }
 
-static void calc_scales(DCAContext *c)
+static void calc_scales(DCAEncContext *c)
 {
     int band, ch;
 
@@ -691,7 +691,7 @@ static void calc_scales(DCAContext *c)
         c->lfe_scale_factor = calc_one_scale(c->lfe_peak_cb, 11, &c->lfe_quant);
 }
 
-static void quantize_all(DCAContext *c)
+static void quantize_all(DCAEncContext *c)
 {
     int sample, band, ch;
 
@@ -701,7 +701,7 @@ static void quantize_all(DCAContext *c)
                 c->quantized[sample][band][ch] = quantize_value(c->subband[sample][band][ch], c->quant[band][ch]);
 }
 
-static void put_frame_header(DCAContext *c)
+static void put_frame_header(DCAEncContext *c)
 {
     /* SYNC */
     put_bits(&c->pb, 16, 0x7ffe);
@@ -784,7 +784,7 @@ static void put_frame_header(DCAContext *c)
     put_bits(&c->pb, 4, 0);
 }
 
-static void put_primary_audio_header(DCAContext *c)
+static void put_primary_audio_header(DCAEncContext *c)
 {
     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
     static const int thr[11]    = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
@@ -830,7 +830,7 @@ static void put_primary_audio_header(DCAContext *c)
     /* Audio header CRC check word: not transmitted */
 }
 
-static void put_subframe_samples(DCAContext *c, int ss, int band, int ch)
+static void put_subframe_samples(DCAEncContext *c, int ss, int band, int ch)
 {
     if (c->abits[band][ch] <= 7) {
         int sum, i, j;
@@ -853,7 +853,7 @@ static void put_subframe_samples(DCAContext *c, int ss, int band, int ch)
     }
 }
 
-static void put_subframe(DCAContext *c, int subframe)
+static void put_subframe(DCAEncContext *c, int subframe)
 {
     int i, band, ss, ch;
 
@@ -913,7 +913,7 @@ static void put_subframe(DCAContext *c, int subframe)
 static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
                         const AVFrame *frame, int *got_packet_ptr)
 {
-    DCAContext *c = avctx->priv_data;
+    DCAEncContext *c = avctx->priv_data;
     const int32_t *samples;
     int ret, i;
 
@@ -958,7 +958,7 @@ AVCodec ff_dca_encoder = {
     .long_name             = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
     .id                    = AV_CODEC_ID_DTS,
-    .priv_data_size        = sizeof(DCAContext),
+    .priv_data_size        = sizeof(DCAEncContext),
     .init                  = encode_init,
     .encode2               = encode_frame,
     .capabilities          = CODEC_CAP_EXPERIMENTAL,