diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 6a8e8d2..df4ce74 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -60,6 +60,7 @@
 OBJS-$(CONFIG_CSCD_DECODER)            += cscd.o
 OBJS-$(CONFIG_CYUV_DECODER)            += cyuv.o
 OBJS-$(CONFIG_DCA_DECODER)             += dca.o
+OBJS-$(CONFIG_DCADUMMY_DECODER)        += dcadummy.o
 OBJS-$(CONFIG_DNXHD_DECODER)           += dnxhddec.o dnxhddata.o
 OBJS-$(CONFIG_DNXHD_ENCODER)           += dnxhdenc.o dnxhddata.o mpegvideo_enc.o motion_est.o ratecontrol.o mpeg12data.o mpegvideo.o
 OBJS-$(CONFIG_DSICINAUDIO_DECODER)     += dsicinav.o
@@ -125,6 +126,7 @@
 OBJS-$(CONFIG_MJPEG_ENCODER)           += mjpegenc.o mjpeg.o mpegvideo_enc.o motion_est.o ratecontrol.o mpeg12data.o mpegvideo.o
 OBJS-$(CONFIG_MJPEGB_DECODER)          += mjpegbdec.o mjpegdec.o mjpeg.o
 OBJS-$(CONFIG_MLP_DECODER)             += mlpdec.o mlp_parser.o mlp.o
+OBJS-$(CONFIG_MLPDUMMY_DECODER)        += mlpdummy.o
 OBJS-$(CONFIG_MMVIDEO_DECODER)         += mmvideo.o
 OBJS-$(CONFIG_MOTIONPIXELS_DECODER)    += motionpixels.o
 OBJS-$(CONFIG_MP1_DECODER)             += mpegaudiodec.o mpegaudiodecheader.o mpegaudio.o mpegaudiodata.o
diff --git a/libavcodec/ac3decdummy.c b/libavcodec/ac3decdummy.c
new file mode 100644
index 0000000..468d5d8
--- /dev/null
+++ b/libavcodec/ac3decdummy.c
@@ -0,0 +1,49 @@
+/*
+ * AC-3 Audio Decoder Dummy
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <math.h>
+#include <string.h>
+
+#include "avcodec.h"
+#include "bitstream.h"
+#include "dsputil.h"
+
+static int ac3_decode_dummy_init(AVCodecContext *avctx)
+{
+      return 0;
+}
+
+static int ac3_decode_dummy_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t *buf, int buf_size)
+{
+      return 0;
+}
+
+static int ac3_decode_dummy_end(AVCodecContext *avctx)
+{
+      return 0;
+}
+
+AVCodec ac3dummy_decoder = {
+  .name = "ac3",
+  .type = CODEC_TYPE_AUDIO,
+  .id = CODEC_ID_AC3,
+  .priv_data_size = 0,
+  .init = ac3_decode_dummy_init,
+  .close = ac3_decode_dummy_end,
+  .decode = ac3_decode_dummy_frame,
+  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)-Dummy"),
+};
+
+AVCodec eac3dummy_decoder = {
+  .name = "eac3",
+  .type = CODEC_TYPE_AUDIO,
+  .id = CODEC_ID_EAC3,
+  .priv_data_size = 0,
+  .init = ac3_decode_dummy_init,
+  .close = ac3_decode_dummy_end,
+  .decode = ac3_decode_dummy_frame,
+  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)-Dummy"),
+};
diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
index 739b69e..7b3a62f 100644
--- a/libavcodec/allcodecs.c
+++ b/libavcodec/allcodecs.c
@@ -187,23 +187,26 @@
     /* audio codecs */
     REGISTER_DECODER (AAC, aac);
     REGISTER_ENCDEC  (AC3, ac3);
-#ifdef EM8622
-    REGISTER_DECODER  (AC3DUMMY, ac3);
-#endif
+    REGISTER_DECODER (AC3DUMMY, ac3dummy);
     REGISTER_ENCDEC  (ALAC, alac);
     REGISTER_DECODER (APE, ape);
     REGISTER_DECODER (ATRAC3, atrac3);
     REGISTER_DECODER (COOK, cook);
     REGISTER_DECODER (DCA, dca);
-	REGISTER_DECODER (DTS_HD, dts_hd);
-	REGISTER_DECODER (DTS_MA, dts_ma);
+    REGISTER_DECODER (DCADUMMY, dcadummy);
+    REGISTER_DECODER (DTS_HD, dts_hd);
+    REGISTER_DECODER (DTS_HDDUMMY, dts_hddummy);
+    REGISTER_DECODER (DTS_MA, dts_ma);
+    REGISTER_DECODER (DTS_MADUMMY, dts_madummy);
     REGISTER_DECODER (DSICINAUDIO, dsicinaudio);
     REGISTER_DECODER (EAC3, eac3);
+    REGISTER_DECODER (EAC3DUMMY, eac3dummy);
     REGISTER_ENCDEC  (FLAC, flac);
     REGISTER_DECODER (IMC, imc);
     REGISTER_DECODER (MACE3, mace3);
     REGISTER_DECODER (MACE6, mace6);
     REGISTER_DECODER (MLP, mlp);
+    REGISTER_DECODER (MLPDUMMY, mlpdummy);
     REGISTER_DECODER (MP1, mp1);
     REGISTER_ENCDEC  (MP2, mp2);
     REGISTER_DECODER (MP3, mp3);
@@ -221,6 +224,7 @@
     REGISTER_ENCDEC  (SONIC, sonic);
     REGISTER_ENCODER (SONIC_LS, sonic_ls);
     REGISTER_DECODER (TRUEHD, truehd);
+    REGISTER_DECODER (TRUEHDDUMMY, truehddummy);
     REGISTER_DECODER (TRUESPEECH, truespeech);
     REGISTER_DECODER (TTA, tta);
     REGISTER_DECODER (VMDAUDIO, vmdaudio);
diff --git a/libavcodec/dcadummy.c b/libavcodec/dcadummy.c
new file mode 100644
index 0000000..03e3bdd
--- /dev/null
+++ b/libavcodec/dcadummy.c
@@ -0,0 +1,686 @@
+/*
+ * DCA dummy decoder
+ * We retain some of the main logic for data extraction but
+ * have removed all of the actual decoding code. The only reason
+ * we still have this other logic is we need to do some minor stream
+ * introspection to differntiate DTS-MA vs. DTS.
+ */
+
+#include <math.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#include "avcodec.h"
+#include "dsputil.h"
+#include "bitstream.h"
+
+#include "dcadata.h"
+#include "dcahuff.h"
+#include "dca.h"
+
+#define DCA_PRIM_CHANNELS_MAX (5)
+#define DCA_SUBBANDS (32)
+#define DCA_ABITS_MAX (32)      /* Should be 28 */
+#define DCA_SUBSUBFAMES_MAX (4)
+#define DCA_LFE_MAX (3)
+
+enum DCAMode {
+    DCA_MONO = 0,
+    DCA_CHANNEL,
+    DCA_STEREO,
+    DCA_STEREO_SUMDIFF,
+    DCA_STEREO_TOTAL,
+    DCA_3F,
+    DCA_2F1R,
+    DCA_3F1R,
+    DCA_2F2R,
+    DCA_3F2R,
+    DCA_4F2R
+};
+
+/* 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.
+ *
+ * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
+ * S  -> side, when both rear and back are configured move one of them to the side channel
+ * OV -> center back
+ * All 2 channel configurations -> CH_LAYOUT_STEREO
+ */
+
+static const int64_t dca_core_channel_layout[] = {
+    CH_FRONT_CENTER,                                               ///< 1, A
+    CH_LAYOUT_STEREO,                                              ///< 2, A + B (dual mono)
+    CH_LAYOUT_STEREO,                                              ///< 2, L + R (stereo)
+    CH_LAYOUT_STEREO,                                              ///< 2, (L+R) + (L-R) (sum-difference)
+    CH_LAYOUT_STEREO,                                              ///< 2, LT +RT (left and right total)
+    CH_LAYOUT_STEREO|CH_FRONT_CENTER,                              ///< 3, C+L+R
+    CH_LAYOUT_STEREO|CH_BACK_CENTER,                               ///< 3, L+R+S
+    CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER,               ///< 4, C + L + R+ S
+    CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT,                   ///< 4, L + R +SL+ SR
+    CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT,   ///< 5, C + L + R+ SL+SR
+    CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER,                 ///< 6, CL + CR + L + R + SL + SR
+    CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER,                                   ///< 6, C + L + R+ LR + RR + OV
+    CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_FRONT_LEFT_OF_CENTER|CH_BACK_CENTER|CH_BACK_LEFT|CH_BACK_RIGHT,   ///< 6, CF+ CR+LF+ RF+LR + RR
+    CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
+    CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2
+    CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_BACK_CENTER|CH_SIDE_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR
+};
+
+static const int8_t dca_lfe_index[] = {
+    1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
+};
+
+static const int8_t dca_channel_reorder_lfe[][8] = {
+    { 0, -1, -1, -1, -1, -1, -1, -1},
+    { 0,  1, -1, -1, -1, -1, -1, -1},
+    { 0,  1, -1, -1, -1, -1, -1, -1},
+    { 0,  1, -1, -1, -1, -1, -1, -1},
+    { 0,  1, -1, -1, -1, -1, -1, -1},
+    { 2,  0,  1, -1, -1, -1, -1, -1},
+    { 0,  1,  3, -1, -1, -1, -1, -1},
+    { 2,  0,  1,  4, -1, -1, -1, -1},
+    { 0,  1,  3,  4, -1, -1, -1, -1},
+    { 2,  0,  1,  4,  5, -1, -1, -1},
+    { 3,  4,  0,  1,  5,  6, -1, -1},
+    { 2,  0,  1,  4,  5,  6, -1, -1},
+    { 0,  6,  4,  5,  2,  3, -1, -1},
+    { 4,  2,  5,  0,  1,  6,  7, -1},
+    { 5,  6,  0,  1,  7,  3,  8,  4},
+    { 4,  2,  5,  0,  1,  6,  8,  7},
+};
+
+static const int8_t dca_channel_reorder_nolfe[][8] = {
+    { 0, -1, -1, -1, -1, -1, -1, -1},
+    { 0,  1, -1, -1, -1, -1, -1, -1},
+    { 0,  1, -1, -1, -1, -1, -1, -1},
+    { 0,  1, -1, -1, -1, -1, -1, -1},
+    { 0,  1, -1, -1, -1, -1, -1, -1},
+    { 2,  0,  1, -1, -1, -1, -1, -1},
+    { 0,  1,  2, -1, -1, -1, -1, -1},
+    { 2,  0,  1,  3, -1, -1, -1, -1},
+    { 0,  1,  2,  3, -1, -1, -1, -1},
+    { 2,  0,  1,  3,  4, -1, -1, -1},
+    { 2,  3,  0,  1,  4,  5, -1, -1},
+    { 2,  0,  1,  3,  4,  5, -1, -1},
+    { 0,  5,  3,  4,  1,  2, -1, -1},
+    { 3,  2,  4,  0,  1,  5,  6, -1},
+    { 4,  5,  0,  1,  6,  2,  7,  3},
+    { 3,  2,  4,  0,  1,  5,  7,  6},
+};
+
+
+#define DCA_DOLBY 101           /* FIXME */
+
+#define DCA_CHANNEL_BITS 6
+#define DCA_CHANNEL_MASK 0x3F
+
+#define DCA_LFE 0x80
+
+#define HEADER_SIZE 14
+
+#define DCA_MAX_FRAME_SIZE 16384
+
+/** Bit allocation */
+typedef struct {
+    int offset;                 ///< code values offset
+    int maxbits[8];             ///< max bits in VLC
+    int wrap;                   ///< wrap for get_vlc2()
+    VLC vlc[8];                 ///< actual codes
+} BitAlloc;
+
+static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
+static BitAlloc dca_tmode;             ///< transition mode VLCs
+static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
+static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
+
+static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
+{
+    return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
+}
+
+typedef struct {
+    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 downmix;                ///< embedded downmix enabled
+    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;           ///< number of subsubframes
+    int partial_samples;        ///< 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)
+    int 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
+    int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
+    int dynrange_coef;                                           ///< dynamic range coefficient
+
+    int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
+
+    float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *
+                   2 /*history */ ];    ///< Low frequency effect data
+    int lfe_scale_factor;
+
+    /* Subband samples history (for ADPCM) */
+    float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
+    DECLARE_ALIGNED_16(float, subband_fir_hist[DCA_PRIM_CHANNELS_MAX][512]);
+    float subband_fir_noidea[DCA_PRIM_CHANNELS_MAX][32];
+    int hist_index[DCA_PRIM_CHANNELS_MAX];
+
+    int output;                 ///< type of output
+    float add_bias;             ///< output bias
+    float scale_bias;           ///< output scale
+
+    DECLARE_ALIGNED_16(float, samples[1536]);  /* 6 * 256 = 1536, might only need 5 */
+    const float *samples_chanptr[6];
+
+    uint8_t dca_buffer[DCA_MAX_FRAME_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 debug_flag;             ///< used for suppressing repeated error messages output
+    DSPContext dsp;
+    MDCTContext imdct;
+} DCAContext;
+
+static av_cold void dca_init_vlcs(void)
+{
+    static int vlcs_initialized = 0;
+    int i, j;
+
+    if (vlcs_initialized)
+        return;
+
+    dca_bitalloc_index.offset = 1;
+    dca_bitalloc_index.wrap = 2;
+    for (i = 0; i < 5; i++)
+        init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
+                 bitalloc_12_bits[i], 1, 1,
+                 bitalloc_12_codes[i], 2, 2, 1);
+    dca_scalefactor.offset = -64;
+    dca_scalefactor.wrap = 2;
+    for (i = 0; i < 5; i++)
+        init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
+                 scales_bits[i], 1, 1,
+                 scales_codes[i], 2, 2, 1);
+    dca_tmode.offset = 0;
+    dca_tmode.wrap = 1;
+    for (i = 0; i < 4; i++)
+        init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
+                 tmode_bits[i], 1, 1,
+                 tmode_codes[i], 2, 2, 1);
+
+    for(i = 0; i < 10; i++)
+        for(j = 0; j < 7; j++){
+            if(!bitalloc_codes[i][j]) break;
+            dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
+            dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
+            init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
+                     bitalloc_sizes[i],
+                     bitalloc_bits[i][j], 1, 1,
+                     bitalloc_codes[i][j], 2, 2, 1);
+        }
+    vlcs_initialized = 1;
+}
+
+static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
+{
+    while(len--)
+        *dst++ = get_bits(gb, bits);
+}
+
+static int dca_parse_frame_header(DCAContext * s)
+{
+    int i, j;
+    static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
+    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 };
+    uint32_t syncword = 0;
+
+    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
+
+    /* Sync code */
+    syncword = get_bits(&s->gb, 32);
+
+    /* Frame header */
+    s->frame_type        = get_bits(&s->gb, 1);
+    s->samples_deficit   = get_bits(&s->gb, 5) + 1;
+    s->crc_present       = get_bits(&s->gb, 1);
+    s->sample_blocks     = get_bits(&s->gb, 7) + 1;
+    s->frame_size        = get_bits(&s->gb, 14) + 1;
+    if (s->frame_size < 95)
+        return -1;
+    s->amode             = get_bits(&s->gb, 6);
+    s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
+    if (!s->sample_rate)
+        return -1;
+    s->bit_rate_index    = get_bits(&s->gb, 5);
+    s->bit_rate          = dca_bit_rates[s->bit_rate_index];
+    if (!s->bit_rate)
+        return -1;
+
+    s->downmix           = get_bits(&s->gb, 1);
+    s->dynrange          = get_bits(&s->gb, 1);
+    s->timestamp         = get_bits(&s->gb, 1);
+    s->aux_data          = get_bits(&s->gb, 1);
+    s->hdcd              = get_bits(&s->gb, 1);
+    s->ext_descr         = get_bits(&s->gb, 3);
+    s->ext_coding        = get_bits(&s->gb, 1);
+    s->aspf              = get_bits(&s->gb, 1);
+    s->lfe               = get_bits(&s->gb, 2);
+    s->predictor_history = get_bits(&s->gb, 1);
+
+    /* TODO: check CRC */
+    if (s->crc_present)
+        s->header_crc    = get_bits(&s->gb, 16);
+
+    s->multirate_inter   = get_bits(&s->gb, 1);
+    s->version           = get_bits(&s->gb, 4);
+    s->copy_history      = get_bits(&s->gb, 2);
+    s->source_pcm_res    = get_bits(&s->gb, 3);
+    s->front_sum         = get_bits(&s->gb, 1);
+    s->surround_sum      = get_bits(&s->gb, 1);
+    s->dialog_norm       = get_bits(&s->gb, 4);
+
+    /* FIXME: channels mixing levels */
+    s->output = s->amode;
+    if(s->lfe) s->output |= DCA_LFE;
+
+#ifdef TRACE
+    av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
+    av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
+    av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
+    av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
+           s->sample_blocks, s->sample_blocks * 32);
+    av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
+    av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
+           s->amode, dca_channels[s->amode]);
+    av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
+           s->sample_rate);
+    av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
+           s->bit_rate);
+    av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
+    av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
+    av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
+    av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
+    av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
+    av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
+    av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
+    av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
+    av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
+    av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
+           s->predictor_history);
+    av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
+    av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
+           s->multirate_inter);
+    av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
+    av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
+    av_log(s->avctx, AV_LOG_DEBUG,
+           "source pcm resolution: %i (%i bits/sample)\n",
+           s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
+    av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
+    av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
+    av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
+    av_log(s->avctx, AV_LOG_DEBUG, "\n");
+#endif
+
+    /* Primary audio coding header */
+    s->subframes         = get_bits(&s->gb, 4) + 1;
+    s->total_channels    = get_bits(&s->gb, 3) + 1;
+    s->prim_channels     = s->total_channels;
+    if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
+        s->prim_channels = DCA_PRIM_CHANNELS_MAX;   /* We only support DTS core */
+
+
+    for (i = 0; i < s->prim_channels; i++) {
+        s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
+        if (s->subband_activity[i] > DCA_SUBBANDS)
+            s->subband_activity[i] = DCA_SUBBANDS;
+    }
+    for (i = 0; i < s->prim_channels; i++) {
+        s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
+        if (s->vq_start_subband[i] > DCA_SUBBANDS)
+            s->vq_start_subband[i] = DCA_SUBBANDS;
+    }
+    get_array(&s->gb, s->joint_intensity,     s->prim_channels, 3);
+    get_array(&s->gb, s->transient_huffman,   s->prim_channels, 2);
+    get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
+    get_array(&s->gb, s->bitalloc_huffman,    s->prim_channels, 3);
+
+    /* Get codebooks quantization indexes */
+    memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
+    for (j = 1; j < 11; j++)
+        for (i = 0; i < s->prim_channels; i++)
+            s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
+
+    /* Get scale factor adjustment */
+    for (j = 0; j < 11; j++)
+        for (i = 0; i < s->prim_channels; i++)
+            s->scalefactor_adj[i][j] = 1;
+
+    for (j = 1; j < 11; j++)
+        for (i = 0; i < s->prim_channels; i++)
+            if (s->quant_index_huffman[i][j] < thr[j])
+                s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
+
+    if (s->crc_present) {
+        /* Audio header CRC check */
+        get_bits(&s->gb, 16);
+    }
+
+    s->current_subframe = 0;
+    s->current_subsubframe = 0;
+
+#ifdef TRACE
+    av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
+    av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
+    for(i = 0; i < s->prim_channels; i++){
+        av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
+        av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
+        av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
+        av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
+        av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
+        av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
+        av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
+        for (j = 0; j < 11; j++)
+            av_log(s->avctx, AV_LOG_DEBUG, " %i",
+                   s->quant_index_huffman[i][j]);
+        av_log(s->avctx, AV_LOG_DEBUG, "\n");
+        av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
+        for (j = 0; j < 11; j++)
+            av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
+        av_log(s->avctx, AV_LOG_DEBUG, "\n");
+    }
+#endif
+
+    return 0;
+}
+
+
+static inline int get_scale(GetBitContext *gb, int level, int value)
+{
+   if (level < 5) {
+       /* huffman encoded */
+       value += get_bitalloc(gb, &dca_scalefactor, level);
+   } else if(level < 8)
+       value = get_bits(gb, level + 1);
+   return value;
+}
+
+static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
+static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
+
+/**
+ * Convert bitstream to one representation based on sync marker
+ */
+static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
+                          int max_size)
+{
+    uint32_t mrk;
+    int i, tmp;
+    const uint16_t *ssrc = (const uint16_t *) src;
+    uint16_t *sdst = (uint16_t *) dst;
+    PutBitContext pb;
+
+    if((unsigned)src_size > (unsigned)max_size) {
+//        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
+//        return -1;
+        src_size = max_size;
+    }
+
+    mrk = AV_RB32(src);
+    switch (mrk) {
+    case DCA_MARKER_RAW_BE:
+        memcpy(dst, src, src_size);
+        return src_size;
+    case DCA_MARKER_RAW_LE:
+        for (i = 0; i < (src_size + 1) >> 1; i++)
+            *sdst++ = bswap_16(*ssrc++);
+        return src_size;
+    case DCA_MARKER_14B_BE:
+    case DCA_MARKER_14B_LE:
+        init_put_bits(&pb, dst, max_size);
+        for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
+            tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
+            put_bits(&pb, 14, tmp);
+        }
+        flush_put_bits(&pb);
+        return (put_bits_count(&pb) + 7) >> 3;
+    default:
+        return -1;
+    }
+}
+
+/**
+ * Main frame decoding function
+ * FIXME add arguments
+ */
+static int dca_decode_dummy_frame(AVCodecContext * avctx,
+                            void *data, int *data_size,
+                            const uint8_t * buf, int buf_size)
+{
+
+    int i;
+    int16_t *samples = data;
+    DCAContext *s = avctx->priv_data;
+    int channels;
+    uint32_t mrk=0;
+
+
+    s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
+    if (s->dca_buffer_size == -1) {
+        av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
+        return -1;
+    }
+
+    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
+    if (dca_parse_frame_header(s) < 0) {
+        //seems like the frame is corrupt, try with the next one
+        *data_size=0;
+        return buf_size;
+    }
+    //set AVCodec values with parsed data
+    avctx->sample_rate = s->sample_rate;
+    avctx->bit_rate = s->bit_rate;
+    // JFT, so we only look at 1 frame when looking for DTS-HD/DTS-MA
+    avctx->frame_size = s->sample_blocks*32;
+
+    channels = s->prim_channels + !!s->lfe;
+
+    if (s->amode<16) {
+        avctx->channel_layout = dca_core_channel_layout[s->amode];
+
+        if (s->lfe) {
+            avctx->channel_layout |= CH_LOW_FREQUENCY;
+            s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
+        } else
+            s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
+
+        if(avctx->request_channels == 2 && s->prim_channels > 2) {
+            channels = 2;
+            s->output = DCA_STEREO;
+            avctx->channel_layout = CH_LAYOUT_STEREO;
+        }
+    } else {
+        av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
+        return -1;
+    }
+
+
+    /* There is nothing that prevents a dts frame to change channel configuration
+       but FFmpeg doesn't support that so only set the channels if it is previously
+       unset. Ideally during the first probe for channels the crc should be checked
+       and only set avctx->channels when the crc is ok. Right now the decoder could
+       set the channels based on a broken first frame.*/
+    if (!avctx->channels)
+        avctx->channels = channels;
+
+    /* REMOVED DECODING CALLS
+    if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
+        return -1;
+    *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
+    for (i = 0; i < (s->sample_blocks / 8); i++) {
+        dca_decode_block(s);
+        s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
+        samples += 256 * channels;
+    }
+    */
+    // See if there is a HD extension
+
+    /* extensions start at 32-bit boundaries into bitstream */
+    skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
+    /*align_get_bits(&s->gb);
+    while(get_bits_count(&s->gb)<(s->dca_buffer_size * 8))
+    {
+        mrk=get_bits_long(&s->gb, 8);
+        if(mrk!=0)
+        {
+            mrk=(mrk<<24)|get_bits_long(&s->gb, 24);
+            break;
+        }
+    }
+    av_log(avctx, AV_LOG_ERROR, "Marker %X\n",mrk);
+    if(mrk==DCA_HD_MARKER)
+    {
+        avctx->codec_id=CODEC_ID_DTS_MA;
+    }*/
+    while(get_bits_count(&s->gb)<(s->dca_buffer_size * 8-31))
+    {
+        uint32_t bits = get_bits_long(&s->gb, 32);
+        switch(bits) {
+        case DCA_HD_MARKER:
+            avctx->codec_id=CODEC_ID_DTS_MA;
+            break;
+        }
+
+        skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
+    }
+
+    return 0;
+}
+
+
+
+/**
+ * DCA initialization
+ *
+ * @param avctx     pointer to the AVCodecContext
+ */
+
+static av_cold int dca_decode_dummy_init(AVCodecContext * avctx)
+{
+    DCAContext *s = avctx->priv_data;
+    int i;
+
+    s->avctx = avctx;
+    dca_init_vlcs();
+
+    dsputil_init(&s->dsp, avctx);
+    ff_mdct_init(&s->imdct, 6, 1);
+
+    for(i = 0; i < 6; i++)
+        s->samples_chanptr[i] = s->samples + i * 256;
+    avctx->sample_fmt = SAMPLE_FMT_S16;
+
+    if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
+        s->add_bias = 385.0f;
+        s->scale_bias = 1.0 / 32768.0;
+    } else {
+        s->add_bias = 0.0f;
+        s->scale_bias = 1.0;
+
+        /* allow downmixing to stereo */
+        if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
+                avctx->request_channels == 2) {
+            avctx->channels = avctx->request_channels;
+        }
+    }
+    return 0;
+}
+
+static av_cold int dca_decode_dummy_end(AVCodecContext * avctx)
+{
+   DCAContext *s = avctx->priv_data;
+   ff_mdct_end(&s->imdct);
+   return 0;
+}
+
+AVCodec dcadummy_decoder = {
+    .name = "dca",
+    .type = CODEC_TYPE_AUDIO,
+    .id = CODEC_ID_DTS,
+    .priv_data_size = sizeof(DCAContext),
+    .init = dca_decode_dummy_init,
+    .decode = dca_decode_dummy_frame,
+    .close = dca_decode_dummy_end,
+    .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)-Dummy"),
+};
+
+AVCodec dts_hddummy_decoder = {
+    .name = "dts_hd",
+    .type = CODEC_TYPE_AUDIO,
+    .id = CODEC_ID_DTS_HD,
+    .priv_data_size = sizeof(DCAContext),
+    .init = dca_decode_dummy_init,
+    .decode = dca_decode_dummy_frame,
+    .close = dca_decode_dummy_end,
+    .long_name = NULL_IF_CONFIG_SMALL("DTS-HD-Dummy"),
+};
+
+AVCodec dts_madummy_decoder = {
+    .name = "dts_ma",
+    .type = CODEC_TYPE_AUDIO,
+    .id = CODEC_ID_DTS_MA,
+    .priv_data_size = sizeof(DCAContext),
+    .init = dca_decode_dummy_init,
+    .decode = dca_decode_dummy_frame,
+    .close = dca_decode_dummy_end,
+    .long_name = NULL_IF_CONFIG_SMALL("DTS-MA-Dummy"),
+};
diff --git a/libavcodec/mlpdummy.c b/libavcodec/mlpdummy.c
new file mode 100644
index 0000000..313b0c7
--- /dev/null
+++ b/libavcodec/mlpdummy.c
@@ -0,0 +1,51 @@
+/*
+ * MLP dummy decoder
+ */
+
+#include <stdint.h>
+
+#include "avcodec.h"
+#include "bitstream.h"
+
+static av_cold int mlp_decode_dummy_init(AVCodecContext *avctx)
+{
+    return 0;
+}
+
+/** Read an access unit from the stream.
+ *  Returns < 0 on error, 0 if not enough data is present in the input stream
+ *  otherwise returns the number of bytes consumed. */
+
+static int read_access_unit_dummy(AVCodecContext *avctx, void* data, int *data_size,
+                            const uint8_t *buf, int buf_size)
+{
+    return 0;
+}
+
+#if CONFIG_MLPDUMMY_DECODER
+AVCodec mlpdummy_decoder = {
+    "mlp",
+    CODEC_TYPE_AUDIO,
+    CODEC_ID_MLP,
+    0,
+    mlp_decode_dummy_init,
+    NULL,
+    NULL,
+    read_access_unit_dummy,
+    .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)-Dummy"),
+};
+#endif /* CONFIG_MLP_DECODER */
+
+#if CONFIG_TRUEHDDUMMY_DECODER
+AVCodec truehddummy_decoder = {
+    "truehd",
+    CODEC_TYPE_AUDIO,
+    CODEC_ID_TRUEHD,
+    0,
+    mlp_decode_dummy_init,
+    NULL,
+    NULL,
+    read_access_unit_dummy,
+    .long_name = NULL_IF_CONFIG_SMALL("TrueHD-Dummy"),
+};
+#endif /* CONFIG_TRUEHD_DECODER */