Added dummy decoders for AC3, TrueHD, DTS, DTS-HD and DTS-MA
This avoids having to include actual decode logic for
all of these different audio formats in FFMPEG while
still being able to identify the streams for proper passthrough.
Change-Id: I12a5b2393a087e79f078c2d8310b5ca35fd8c859
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 */
