git.sesse.net Git - ffmpeg/blob - libavcodec/dca.c

   1 /*
   2  * DCA compatible decoder
   3  * Copyright (C) 2004 Gildas Bazin
   4  * Copyright (C) 2004 Benjamin Zores
   5  * Copyright (C) 2006 Benjamin Larsson
   6  * Copyright (C) 2007 Konstantin Shishkov
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file libavcodec/dca.c
  27  */
  28
  29 #include <math.h>
  30 #include <stddef.h>
  31 #include <stdio.h>
  32
  33 #include "avcodec.h"
  34 #include "dsputil.h"
  35 #include "fft.h"
  36 #include "get_bits.h"
  37 #include "put_bits.h"
  38 #include "dcadata.h"
  39 #include "dcahuff.h"
  40 #include "dca.h"
  41 #include "synth_filter.h"
  42
  43 //#define TRACE
  44
  45 #define DCA_PRIM_CHANNELS_MAX (5)
  46 #define DCA_SUBBANDS (32)
  47 #define DCA_ABITS_MAX (32)      /* Should be 28 */
  48 #define DCA_SUBSUBFAMES_MAX (4)
  49 #define DCA_LFE_MAX (3)
  50
  51 enum DCAMode {
  52     DCA_MONO = 0,
  53     DCA_CHANNEL,
  54     DCA_STEREO,
  55     DCA_STEREO_SUMDIFF,
  56     DCA_STEREO_TOTAL,
  57     DCA_3F,
  58     DCA_2F1R,
  59     DCA_3F1R,
  60     DCA_2F2R,
  61     DCA_3F2R,
  62     DCA_4F2R
  63 };
  64
  65 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
  66  * Some compromises have been made for special configurations. Most configurations
  67  * are never used so complete accuracy is not needed.
  68  *
  69  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
  70  * S  -> side, when both rear and back are configured move one of them to the side channel
  71  * OV -> center back
  72  * All 2 channel configurations -> CH_LAYOUT_STEREO
  73  */
  74
  75 static const int64_t dca_core_channel_layout[] = {
  76     CH_FRONT_CENTER,                                               ///< 1, A
  77     CH_LAYOUT_STEREO,                                              ///< 2, A + B (dual mono)
  78     CH_LAYOUT_STEREO,                                              ///< 2, L + R (stereo)
  79     CH_LAYOUT_STEREO,                                              ///< 2, (L+R) + (L-R) (sum-difference)
  80     CH_LAYOUT_STEREO,                                              ///< 2, LT +RT (left and right total)
  81     CH_LAYOUT_STEREO|CH_FRONT_CENTER,                              ///< 3, C+L+R
  82     CH_LAYOUT_STEREO|CH_BACK_CENTER,                               ///< 3, L+R+S
  83     CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER,               ///< 4, C + L + R+ S
  84     CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT,                   ///< 4, L + R +SL+ SR
  85     CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT,   ///< 5, C + L + R+ SL+SR
  86     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
  87     CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER,                                   ///< 6, C + L + R+ LR + RR + OV
  88     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
  89     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
  90     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
  91     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
  92 };
  93
  94 static const int8_t dca_lfe_index[] = {
  95     1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
  96 };
  97
  98 static const int8_t dca_channel_reorder_lfe[][8] = {
  99     { 0, -1, -1, -1, -1, -1, -1, -1},
 100     { 0,  1, -1, -1, -1, -1, -1, -1},
 101     { 0,  1, -1, -1, -1, -1, -1, -1},
 102     { 0,  1, -1, -1, -1, -1, -1, -1},
 103     { 0,  1, -1, -1, -1, -1, -1, -1},
 104     { 2,  0,  1, -1, -1, -1, -1, -1},
 105     { 0,  1,  3, -1, -1, -1, -1, -1},
 106     { 2,  0,  1,  4, -1, -1, -1, -1},
 107     { 0,  1,  3,  4, -1, -1, -1, -1},
 108     { 2,  0,  1,  4,  5, -1, -1, -1},
 109     { 3,  4,  0,  1,  5,  6, -1, -1},
 110     { 2,  0,  1,  4,  5,  6, -1, -1},
 111     { 0,  6,  4,  5,  2,  3, -1, -1},
 112     { 4,  2,  5,  0,  1,  6,  7, -1},
 113     { 5,  6,  0,  1,  7,  3,  8,  4},
 114     { 4,  2,  5,  0,  1,  6,  8,  7},
 115 };
 116
 117 static const int8_t dca_channel_reorder_nolfe[][8] = {
 118     { 0, -1, -1, -1, -1, -1, -1, -1},
 119     { 0,  1, -1, -1, -1, -1, -1, -1},
 120     { 0,  1, -1, -1, -1, -1, -1, -1},
 121     { 0,  1, -1, -1, -1, -1, -1, -1},
 122     { 0,  1, -1, -1, -1, -1, -1, -1},
 123     { 2,  0,  1, -1, -1, -1, -1, -1},
 124     { 0,  1,  2, -1, -1, -1, -1, -1},
 125     { 2,  0,  1,  3, -1, -1, -1, -1},
 126     { 0,  1,  2,  3, -1, -1, -1, -1},
 127     { 2,  0,  1,  3,  4, -1, -1, -1},
 128     { 2,  3,  0,  1,  4,  5, -1, -1},
 129     { 2,  0,  1,  3,  4,  5, -1, -1},
 130     { 0,  5,  3,  4,  1,  2, -1, -1},
 131     { 3,  2,  4,  0,  1,  5,  6, -1},
 132     { 4,  5,  0,  1,  6,  2,  7,  3},
 133     { 3,  2,  4,  0,  1,  5,  7,  6},
 134 };
 135
 136
 137 #define DCA_DOLBY 101           /* FIXME */
 138
 139 #define DCA_CHANNEL_BITS 6
 140 #define DCA_CHANNEL_MASK 0x3F
 141
 142 #define DCA_LFE 0x80
 143
 144 #define HEADER_SIZE 14
 145
 146 #define DCA_MAX_FRAME_SIZE 16384
 147
 148 /** Bit allocation */
 149 typedef struct {
 150     int offset;                 ///< code values offset
 151     int maxbits[8];             ///< max bits in VLC
 152     int wrap;                   ///< wrap for get_vlc2()
 153     VLC vlc[8];                 ///< actual codes
 154 } BitAlloc;
 155
 156 static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
 157 static BitAlloc dca_tmode;             ///< transition mode VLCs
 158 static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
 159 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
 160
 161 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
 162 {
 163     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
 164 }
 165
 166 typedef struct {
 167     AVCodecContext *avctx;
 168     /* Frame header */
 169     int frame_type;             ///< type of the current frame
 170     int samples_deficit;        ///< deficit sample count
 171     int crc_present;            ///< crc is present in the bitstream
 172     int sample_blocks;          ///< number of PCM sample blocks
 173     int frame_size;             ///< primary frame byte size
 174     int amode;                  ///< audio channels arrangement
 175     int sample_rate;            ///< audio sampling rate
 176     int bit_rate;               ///< transmission bit rate
 177     int bit_rate_index;         ///< transmission bit rate index
 178
 179     int downmix;                ///< embedded downmix enabled
 180     int dynrange;               ///< embedded dynamic range flag
 181     int timestamp;              ///< embedded time stamp flag
 182     int aux_data;               ///< auxiliary data flag
 183     int hdcd;                   ///< source material is mastered in HDCD
 184     int ext_descr;              ///< extension audio descriptor flag
 185     int ext_coding;             ///< extended coding flag
 186     int aspf;                   ///< audio sync word insertion flag
 187     int lfe;                    ///< low frequency effects flag
 188     int predictor_history;      ///< predictor history flag
 189     int header_crc;             ///< header crc check bytes
 190     int multirate_inter;        ///< multirate interpolator switch
 191     int version;                ///< encoder software revision
 192     int copy_history;           ///< copy history
 193     int source_pcm_res;         ///< source pcm resolution
 194     int front_sum;              ///< front sum/difference flag
 195     int surround_sum;           ///< surround sum/difference flag
 196     int dialog_norm;            ///< dialog normalisation parameter
 197
 198     /* Primary audio coding header */
 199     int subframes;              ///< number of subframes
 200     int total_channels;         ///< number of channels including extensions
 201     int prim_channels;          ///< number of primary audio channels
 202     int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
 203     int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
 204     int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
 205     int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
 206     int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
 207     int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
 208     int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
 209     float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
 210
 211     /* Primary audio coding side information */
 212     int subsubframes;           ///< number of subsubframes
 213     int partial_samples;        ///< partial subsubframe samples count
 214     int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
 215     int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
 216     int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
 217     int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
 218     int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
 219     int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
 220     int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
 221     int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
 222     int dynrange_coef;                                           ///< dynamic range coefficient
 223
 224     int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
 225
 226     float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *
 227                    2 /*history */ ];    ///< Low frequency effect data
 228     int lfe_scale_factor;
 229
 230     /* Subband samples history (for ADPCM) */
 231     float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
 232     DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
 233     float subband_fir_noidea[DCA_PRIM_CHANNELS_MAX][32];
 234     int hist_index[DCA_PRIM_CHANNELS_MAX];
 235     DECLARE_ALIGNED(16, float, raXin)[32];
 236
 237     int output;                 ///< type of output
 238     float add_bias;             ///< output bias
 239     float scale_bias;           ///< output scale
 240
 241     DECLARE_ALIGNED(16, float, samples)[1536];  /* 6 * 256 = 1536, might only need 5 */
 242     const float *samples_chanptr[6];
 243
 244     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
 245     int dca_buffer_size;        ///< how much data is in the dca_buffer
 246
 247     const int8_t* channel_order_tab;                             ///< channel reordering table, lfe and non lfe
 248     GetBitContext gb;
 249     /* Current position in DCA frame */
 250     int current_subframe;
 251     int current_subsubframe;
 252
 253     int debug_flag;             ///< used for suppressing repeated error messages output
 254     DSPContext dsp;
 255     FFTContext imdct;
 256 } DCAContext;
 257
 258 static const uint16_t dca_vlc_offs[] = {
 259         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
 260      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
 261      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
 262      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
 263     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
 264     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
 265 };
 266
 267 static av_cold void dca_init_vlcs(void)
 268 {
 269     static int vlcs_initialized = 0;
 270     int i, j, c = 14;
 271     static VLC_TYPE dca_table[23622][2];
 272
 273     if (vlcs_initialized)
 274         return;
 275
 276     dca_bitalloc_index.offset = 1;
 277     dca_bitalloc_index.wrap = 2;
 278     for (i = 0; i < 5; i++) {
 279         dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
 280         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
 281         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
 282                  bitalloc_12_bits[i], 1, 1,
 283                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 284     }
 285     dca_scalefactor.offset = -64;
 286     dca_scalefactor.wrap = 2;
 287     for (i = 0; i < 5; i++) {
 288         dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
 289         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
 290         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
 291                  scales_bits[i], 1, 1,
 292                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 293     }
 294     dca_tmode.offset = 0;
 295     dca_tmode.wrap = 1;
 296     for (i = 0; i < 4; i++) {
 297         dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
 298         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
 299         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
 300                  tmode_bits[i], 1, 1,
 301                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 302     }
 303
 304     for(i = 0; i < 10; i++)
 305         for(j = 0; j < 7; j++){
 306             if(!bitalloc_codes[i][j]) break;
 307             dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
 308             dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
 309             dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
 310             dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
 311             init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
 312                      bitalloc_sizes[i],
 313                      bitalloc_bits[i][j], 1, 1,
 314                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
 315             c++;
 316         }
 317     vlcs_initialized = 1;
 318 }
 319
 320 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
 321 {
 322     while(len--)
 323         *dst++ = get_bits(gb, bits);
 324 }
 325
 326 static int dca_parse_frame_header(DCAContext * s)
 327 {
 328     int i, j;
 329     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
 330     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
 331     static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
 332
 333     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
 334
 335     /* Sync code */
 336     get_bits(&s->gb, 32);
 337
 338     /* Frame header */
 339     s->frame_type        = get_bits(&s->gb, 1);
 340     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
 341     s->crc_present       = get_bits(&s->gb, 1);
 342     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
 343     s->frame_size        = get_bits(&s->gb, 14) + 1;
 344     if (s->frame_size < 95)
 345         return -1;
 346     s->amode             = get_bits(&s->gb, 6);
 347     s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
 348     if (!s->sample_rate)
 349         return -1;
 350     s->bit_rate_index    = get_bits(&s->gb, 5);
 351     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
 352     if (!s->bit_rate)
 353         return -1;
 354
 355     s->downmix           = get_bits(&s->gb, 1);
 356     s->dynrange          = get_bits(&s->gb, 1);
 357     s->timestamp         = get_bits(&s->gb, 1);
 358     s->aux_data          = get_bits(&s->gb, 1);
 359     s->hdcd              = get_bits(&s->gb, 1);
 360     s->ext_descr         = get_bits(&s->gb, 3);
 361     s->ext_coding        = get_bits(&s->gb, 1);
 362     s->aspf              = get_bits(&s->gb, 1);
 363     s->lfe               = get_bits(&s->gb, 2);
 364     s->predictor_history = get_bits(&s->gb, 1);
 365
 366     /* TODO: check CRC */
 367     if (s->crc_present)
 368         s->header_crc    = get_bits(&s->gb, 16);
 369
 370     s->multirate_inter   = get_bits(&s->gb, 1);
 371     s->version           = get_bits(&s->gb, 4);
 372     s->copy_history      = get_bits(&s->gb, 2);
 373     s->source_pcm_res    = get_bits(&s->gb, 3);
 374     s->front_sum         = get_bits(&s->gb, 1);
 375     s->surround_sum      = get_bits(&s->gb, 1);
 376     s->dialog_norm       = get_bits(&s->gb, 4);
 377
 378     /* FIXME: channels mixing levels */
 379     s->output = s->amode;
 380     if(s->lfe) s->output |= DCA_LFE;
 381
 382 #ifdef TRACE
 383     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
 384     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
 385     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
 386     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
 387            s->sample_blocks, s->sample_blocks * 32);
 388     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
 389     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
 390            s->amode, dca_channels[s->amode]);
 391     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
 392            s->sample_rate);
 393     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
 394            s->bit_rate);
 395     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
 396     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
 397     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
 398     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
 399     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
 400     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
 401     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
 402     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
 403     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
 404     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
 405            s->predictor_history);
 406     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
 407     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
 408            s->multirate_inter);
 409     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
 410     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
 411     av_log(s->avctx, AV_LOG_DEBUG,
 412            "source pcm resolution: %i (%i bits/sample)\n",
 413            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
 414     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
 415     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
 416     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
 417     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 418 #endif
 419
 420     /* Primary audio coding header */
 421     s->subframes         = get_bits(&s->gb, 4) + 1;
 422     s->total_channels    = get_bits(&s->gb, 3) + 1;
 423     s->prim_channels     = s->total_channels;
 424     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
 425         s->prim_channels = DCA_PRIM_CHANNELS_MAX;   /* We only support DTS core */
 426
 427
 428     for (i = 0; i < s->prim_channels; i++) {
 429         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
 430         if (s->subband_activity[i] > DCA_SUBBANDS)
 431             s->subband_activity[i] = DCA_SUBBANDS;
 432     }
 433     for (i = 0; i < s->prim_channels; i++) {
 434         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
 435         if (s->vq_start_subband[i] > DCA_SUBBANDS)
 436             s->vq_start_subband[i] = DCA_SUBBANDS;
 437     }
 438     get_array(&s->gb, s->joint_intensity,     s->prim_channels, 3);
 439     get_array(&s->gb, s->transient_huffman,   s->prim_channels, 2);
 440     get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
 441     get_array(&s->gb, s->bitalloc_huffman,    s->prim_channels, 3);
 442
 443     /* Get codebooks quantization indexes */
 444     memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
 445     for (j = 1; j < 11; j++)
 446         for (i = 0; i < s->prim_channels; i++)
 447             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
 448
 449     /* Get scale factor adjustment */
 450     for (j = 0; j < 11; j++)
 451         for (i = 0; i < s->prim_channels; i++)
 452             s->scalefactor_adj[i][j] = 1;
 453
 454     for (j = 1; j < 11; j++)
 455         for (i = 0; i < s->prim_channels; i++)
 456             if (s->quant_index_huffman[i][j] < thr[j])
 457                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
 458
 459     if (s->crc_present) {
 460         /* Audio header CRC check */
 461         get_bits(&s->gb, 16);
 462     }
 463
 464     s->current_subframe = 0;
 465     s->current_subsubframe = 0;
 466
 467 #ifdef TRACE
 468     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
 469     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
 470     for(i = 0; i < s->prim_channels; i++){
 471         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
 472         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
 473         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
 474         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
 475         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
 476         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
 477         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
 478         for (j = 0; j < 11; j++)
 479             av_log(s->avctx, AV_LOG_DEBUG, " %i",
 480                    s->quant_index_huffman[i][j]);
 481         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 482         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
 483         for (j = 0; j < 11; j++)
 484             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
 485         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 486     }
 487 #endif
 488
 489     return 0;
 490 }
 491
 492
 493 static inline int get_scale(GetBitContext *gb, int level, int value)
 494 {
 495    if (level < 5) {
 496        /* huffman encoded */
 497        value += get_bitalloc(gb, &dca_scalefactor, level);
 498    } else if(level < 8)
 499        value = get_bits(gb, level + 1);
 500    return value;
 501 }
 502
 503 static int dca_subframe_header(DCAContext * s)
 504 {
 505     /* Primary audio coding side information */
 506     int j, k;
 507
 508     s->subsubframes = get_bits(&s->gb, 2) + 1;
 509     s->partial_samples = get_bits(&s->gb, 3);
 510     for (j = 0; j < s->prim_channels; j++) {
 511         for (k = 0; k < s->subband_activity[j]; k++)
 512             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
 513     }
 514
 515     /* Get prediction codebook */
 516     for (j = 0; j < s->prim_channels; j++) {
 517         for (k = 0; k < s->subband_activity[j]; k++) {
 518             if (s->prediction_mode[j][k] > 0) {
 519                 /* (Prediction coefficient VQ address) */
 520                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
 521             }
 522         }
 523     }
 524
 525     /* Bit allocation index */
 526     for (j = 0; j < s->prim_channels; j++) {
 527         for (k = 0; k < s->vq_start_subband[j]; k++) {
 528             if (s->bitalloc_huffman[j] == 6)
 529                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
 530             else if (s->bitalloc_huffman[j] == 5)
 531                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
 532             else if (s->bitalloc_huffman[j] == 7) {
 533                 av_log(s->avctx, AV_LOG_ERROR,
 534                        "Invalid bit allocation index\n");
 535                 return -1;
 536             } else {
 537                 s->bitalloc[j][k] =
 538                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
 539             }
 540
 541             if (s->bitalloc[j][k] > 26) {
 542 //                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
 543 //                          j, k, s->bitalloc[j][k]);
 544                 return -1;
 545             }
 546         }
 547     }
 548
 549     /* Transition mode */
 550     for (j = 0; j < s->prim_channels; j++) {
 551         for (k = 0; k < s->subband_activity[j]; k++) {
 552             s->transition_mode[j][k] = 0;
 553             if (s->subsubframes > 1 &&
 554                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
 555                 s->transition_mode[j][k] =
 556                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
 557             }
 558         }
 559     }
 560
 561     for (j = 0; j < s->prim_channels; j++) {
 562         const uint32_t *scale_table;
 563         int scale_sum;
 564
 565         memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
 566
 567         if (s->scalefactor_huffman[j] == 6)
 568             scale_table = scale_factor_quant7;
 569         else
 570             scale_table = scale_factor_quant6;
 571
 572         /* When huffman coded, only the difference is encoded */
 573         scale_sum = 0;
 574
 575         for (k = 0; k < s->subband_activity[j]; k++) {
 576             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
 577                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
 578                 s->scale_factor[j][k][0] = scale_table[scale_sum];
 579             }
 580
 581             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
 582                 /* Get second scale factor */
 583                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
 584                 s->scale_factor[j][k][1] = scale_table[scale_sum];
 585             }
 586         }
 587     }
 588
 589     /* Joint subband scale factor codebook select */
 590     for (j = 0; j < s->prim_channels; j++) {
 591         /* Transmitted only if joint subband coding enabled */
 592         if (s->joint_intensity[j] > 0)
 593             s->joint_huff[j] = get_bits(&s->gb, 3);
 594     }
 595
 596     /* Scale factors for joint subband coding */
 597     for (j = 0; j < s->prim_channels; j++) {
 598         int source_channel;
 599
 600         /* Transmitted only if joint subband coding enabled */
 601         if (s->joint_intensity[j] > 0) {
 602             int scale = 0;
 603             source_channel = s->joint_intensity[j] - 1;
 604
 605             /* When huffman coded, only the difference is encoded
 606              * (is this valid as well for joint scales ???) */
 607
 608             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
 609                 scale = get_scale(&s->gb, s->joint_huff[j], 0);
 610                 scale += 64;    /* bias */
 611                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
 612             }
 613
 614             if (!(s->debug_flag & 0x02)) {
 615                 av_log(s->avctx, AV_LOG_DEBUG,
 616                        "Joint stereo coding not supported\n");
 617                 s->debug_flag |= 0x02;
 618             }
 619         }
 620     }
 621
 622     /* Stereo downmix coefficients */
 623     if (s->prim_channels > 2) {
 624         if(s->downmix) {
 625             for (j = 0; j < s->prim_channels; j++) {
 626                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
 627                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
 628             }
 629         } else {
 630             int am = s->amode & DCA_CHANNEL_MASK;
 631             for (j = 0; j < s->prim_channels; j++) {
 632                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
 633                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
 634             }
 635         }
 636     }
 637
 638     /* Dynamic range coefficient */
 639     if (s->dynrange)
 640         s->dynrange_coef = get_bits(&s->gb, 8);
 641
 642     /* Side information CRC check word */
 643     if (s->crc_present) {
 644         get_bits(&s->gb, 16);
 645     }
 646
 647     /*
 648      * Primary audio data arrays
 649      */
 650
 651     /* VQ encoded high frequency subbands */
 652     for (j = 0; j < s->prim_channels; j++)
 653         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 654             /* 1 vector -> 32 samples */
 655             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
 656
 657     /* Low frequency effect data */
 658     if (s->lfe) {
 659         /* LFE samples */
 660         int lfe_samples = 2 * s->lfe * s->subsubframes;
 661         float lfe_scale;
 662
 663         for (j = lfe_samples; j < lfe_samples * 2; j++) {
 664             /* Signed 8 bits int */
 665             s->lfe_data[j] = get_sbits(&s->gb, 8);
 666         }
 667
 668         /* Scale factor index */
 669         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
 670
 671         /* Quantization step size * scale factor */
 672         lfe_scale = 0.035 * s->lfe_scale_factor;
 673
 674         for (j = lfe_samples; j < lfe_samples * 2; j++)
 675             s->lfe_data[j] *= lfe_scale;
 676     }
 677
 678 #ifdef TRACE
 679     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
 680     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
 681            s->partial_samples);
 682     for (j = 0; j < s->prim_channels; j++) {
 683         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
 684         for (k = 0; k < s->subband_activity[j]; k++)
 685             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
 686         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 687     }
 688     for (j = 0; j < s->prim_channels; j++) {
 689         for (k = 0; k < s->subband_activity[j]; k++)
 690                 av_log(s->avctx, AV_LOG_DEBUG,
 691                        "prediction coefs: %f, %f, %f, %f\n",
 692                        (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
 693                        (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
 694                        (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
 695                        (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
 696     }
 697     for (j = 0; j < s->prim_channels; j++) {
 698         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
 699         for (k = 0; k < s->vq_start_subband[j]; k++)
 700             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
 701         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 702     }
 703     for (j = 0; j < s->prim_channels; j++) {
 704         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
 705         for (k = 0; k < s->subband_activity[j]; k++)
 706             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
 707         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 708     }
 709     for (j = 0; j < s->prim_channels; j++) {
 710         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
 711         for (k = 0; k < s->subband_activity[j]; k++) {
 712             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
 713                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
 714             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
 715                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
 716         }
 717         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 718     }
 719     for (j = 0; j < s->prim_channels; j++) {
 720         if (s->joint_intensity[j] > 0) {
 721             int source_channel = s->joint_intensity[j] - 1;
 722             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
 723             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
 724                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
 725             av_log(s->avctx, AV_LOG_DEBUG, "\n");
 726         }
 727     }
 728     if (s->prim_channels > 2 && s->downmix) {
 729         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
 730         for (j = 0; j < s->prim_channels; j++) {
 731             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
 732             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
 733         }
 734         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 735     }
 736     for (j = 0; j < s->prim_channels; j++)
 737         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 738             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
 739     if(s->lfe){
 740         int lfe_samples = 2 * s->lfe * s->subsubframes;
 741         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
 742         for (j = lfe_samples; j < lfe_samples * 2; j++)
 743             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
 744         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 745     }
 746 #endif
 747
 748     return 0;
 749 }
 750
 751 static void qmf_32_subbands(DCAContext * s, int chans,
 752                             float samples_in[32][8], float *samples_out,
 753                             float scale, float bias)
 754 {
 755     const float *prCoeff;
 756     int i;
 757
 758     int subindex;
 759
 760     scale *= sqrt(1/8.0);
 761
 762     /* Select filter */
 763     if (!s->multirate_inter)    /* Non-perfect reconstruction */
 764         prCoeff = fir_32bands_nonperfect;
 765     else                        /* Perfect reconstruction */
 766         prCoeff = fir_32bands_perfect;
 767
 768     /* Reconstructed channel sample index */
 769     for (subindex = 0; subindex < 8; subindex++) {
 770         /* Load in one sample from each subband and clear inactive subbands */
 771         for (i = 0; i < s->subband_activity[chans]; i++){
 772             if((i-1)&2) s->raXin[i] = -samples_in[i][subindex];
 773             else        s->raXin[i] =  samples_in[i][subindex];
 774         }
 775         for (; i < 32; i++)
 776             s->raXin[i] = 0.0;
 777
 778         ff_synth_filter_float(&s->imdct,
 779                               s->subband_fir_hist[chans], &s->hist_index[chans],
 780                               s->subband_fir_noidea[chans], prCoeff,
 781                               samples_out, s->raXin, scale, bias);
 782         samples_out+= 32;
 783
 784     }
 785 }
 786
 787 static void lfe_interpolation_fir(int decimation_select,
 788                                   int num_deci_sample, float *samples_in,
 789                                   float *samples_out, float scale,
 790                                   float bias)
 791 {
 792     /* samples_in: An array holding decimated samples.
 793      *   Samples in current subframe starts from samples_in[0],
 794      *   while samples_in[-1], samples_in[-2], ..., stores samples
 795      *   from last subframe as history.
 796      *
 797      * samples_out: An array holding interpolated samples
 798      */
 799
 800     int decifactor, k, j;
 801     const float *prCoeff;
 802
 803     int interp_index = 0;       /* Index to the interpolated samples */
 804     int deciindex;
 805
 806     /* Select decimation filter */
 807     if (decimation_select == 1) {
 808         decifactor = 128;
 809         prCoeff = lfe_fir_128;
 810     } else {
 811         decifactor = 64;
 812         prCoeff = lfe_fir_64;
 813     }
 814     /* Interpolation */
 815     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
 816         /* One decimated sample generates decifactor interpolated ones */
 817         for (k = 0; k < decifactor; k++) {
 818             float rTmp = 0.0;
 819             //FIXME the coeffs are symetric, fix that
 820             for (j = 0; j < 512 / decifactor; j++)
 821                 rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor];
 822             samples_out[interp_index++] = (rTmp * scale) + bias;
 823         }
 824     }
 825 }
 826
 827 /* downmixing routines */
 828 #define MIX_REAR1(samples, si1, rs, coef) \
 829      samples[i]     += samples[si1] * coef[rs][0]; \
 830      samples[i+256] += samples[si1] * coef[rs][1];
 831
 832 #define MIX_REAR2(samples, si1, si2, rs, coef) \
 833      samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
 834      samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
 835
 836 #define MIX_FRONT3(samples, coef) \
 837     t = samples[i]; \
 838     samples[i]     = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
 839     samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
 840
 841 #define DOWNMIX_TO_STEREO(op1, op2) \
 842     for(i = 0; i < 256; i++){ \
 843         op1 \
 844         op2 \
 845     }
 846
 847 static void dca_downmix(float *samples, int srcfmt,
 848                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
 849 {
 850     int i;
 851     float t;
 852     float coef[DCA_PRIM_CHANNELS_MAX][2];
 853
 854     for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
 855         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
 856         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
 857     }
 858
 859     switch (srcfmt) {
 860     case DCA_MONO:
 861     case DCA_CHANNEL:
 862     case DCA_STEREO_TOTAL:
 863     case DCA_STEREO_SUMDIFF:
 864     case DCA_4F2R:
 865         av_log(NULL, 0, "Not implemented!\n");
 866         break;
 867     case DCA_STEREO:
 868         break;
 869     case DCA_3F:
 870         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
 871         break;
 872     case DCA_2F1R:
 873         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
 874         break;
 875     case DCA_3F1R:
 876         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
 877                           MIX_REAR1(samples, i + 768, 3, coef));
 878         break;
 879     case DCA_2F2R:
 880         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
 881         break;
 882     case DCA_3F2R:
 883         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
 884                           MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
 885         break;
 886     }
 887 }
 888
 889
 890 /* Very compact version of the block code decoder that does not use table
 891  * look-up but is slightly slower */
 892 static int decode_blockcode(int code, int levels, int *values)
 893 {
 894     int i;
 895     int offset = (levels - 1) >> 1;
 896
 897     for (i = 0; i < 4; i++) {
 898         values[i] = (code % levels) - offset;
 899         code /= levels;
 900     }
 901
 902     if (code == 0)
 903         return 0;
 904     else {
 905         av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
 906         return -1;
 907     }
 908 }
 909
 910 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
 911 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
 912
 913 static int dca_subsubframe(DCAContext * s)
 914 {
 915     int k, l;
 916     int subsubframe = s->current_subsubframe;
 917
 918     const float *quant_step_table;
 919
 920     /* FIXME */
 921     float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
 922
 923     /*
 924      * Audio data
 925      */
 926
 927     /* Select quantization step size table */
 928     if (s->bit_rate_index == 0x1f)
 929         quant_step_table = lossless_quant_d;
 930     else
 931         quant_step_table = lossy_quant_d;
 932
 933     for (k = 0; k < s->prim_channels; k++) {
 934         for (l = 0; l < s->vq_start_subband[k]; l++) {
 935             int m;
 936
 937             /* Select the mid-tread linear quantizer */
 938             int abits = s->bitalloc[k][l];
 939
 940             float quant_step_size = quant_step_table[abits];
 941             float rscale;
 942
 943             /*
 944              * Determine quantization index code book and its type
 945              */
 946
 947             /* Select quantization index code book */
 948             int sel = s->quant_index_huffman[k][abits];
 949
 950             /*
 951              * Extract bits from the bit stream
 952              */
 953             if(!abits){
 954                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
 955             }else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
 956                 if(abits <= 7){
 957                     /* Block code */
 958                     int block_code1, block_code2, size, levels;
 959                     int block[8];
 960
 961                     size = abits_sizes[abits-1];
 962                     levels = abits_levels[abits-1];
 963
 964                     block_code1 = get_bits(&s->gb, size);
 965                     /* FIXME Should test return value */
 966                     decode_blockcode(block_code1, levels, block);
 967                     block_code2 = get_bits(&s->gb, size);
 968                     decode_blockcode(block_code2, levels, &block[4]);
 969                     for (m = 0; m < 8; m++)
 970                         subband_samples[k][l][m] = block[m];
 971                 }else{
 972                     /* no coding */
 973                     for (m = 0; m < 8; m++)
 974                         subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3);
 975                 }
 976             }else{
 977                 /* Huffman coded */
 978                 for (m = 0; m < 8; m++)
 979                     subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
 980             }
 981
 982             /* Deal with transients */
 983             if (s->transition_mode[k][l] &&
 984                 subsubframe >= s->transition_mode[k][l])
 985                 rscale = quant_step_size * s->scale_factor[k][l][1];
 986             else
 987                 rscale = quant_step_size * s->scale_factor[k][l][0];
 988
 989             rscale *= s->scalefactor_adj[k][sel];
 990
 991             for (m = 0; m < 8; m++)
 992                 subband_samples[k][l][m] *= rscale;
 993
 994             /*
 995              * Inverse ADPCM if in prediction mode
 996              */
 997             if (s->prediction_mode[k][l]) {
 998                 int n;
 999                 for (m = 0; m < 8; m++) {
1000                     for (n = 1; n <= 4; n++)
1001                         if (m >= n)
1002                             subband_samples[k][l][m] +=
1003                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1004                                  subband_samples[k][l][m - n] / 8192);
1005                         else if (s->predictor_history)
1006                             subband_samples[k][l][m] +=
1007                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1008                                  s->subband_samples_hist[k][l][m - n +
1009                                                                4] / 8192);
1010                 }
1011             }
1012         }
1013
1014         /*
1015          * Decode VQ encoded high frequencies
1016          */
1017         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1018             /* 1 vector -> 32 samples but we only need the 8 samples
1019              * for this subsubframe. */
1020             int m;
1021
1022             if (!s->debug_flag & 0x01) {
1023                 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1024                 s->debug_flag |= 0x01;
1025             }
1026
1027             for (m = 0; m < 8; m++) {
1028                 subband_samples[k][l][m] =
1029                     high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1030                                                         m]
1031                     * (float) s->scale_factor[k][l][0] / 16.0;
1032             }
1033         }
1034     }
1035
1036     /* Check for DSYNC after subsubframe */
1037     if (s->aspf || subsubframe == s->subsubframes - 1) {
1038         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1039 #ifdef TRACE
1040             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1041 #endif
1042         } else {
1043             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1044         }
1045     }
1046
1047     /* Backup predictor history for adpcm */
1048     for (k = 0; k < s->prim_channels; k++)
1049         for (l = 0; l < s->vq_start_subband[k]; l++)
1050             memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1051                         4 * sizeof(subband_samples[0][0][0]));
1052
1053     /* 32 subbands QMF */
1054     for (k = 0; k < s->prim_channels; k++) {
1055 /*        static float pcm_to_double[8] =
1056             {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1057          qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1058                             M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1059                             s->add_bias );
1060     }
1061
1062     /* Down mixing */
1063
1064     if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1065         dca_downmix(s->samples, s->amode, s->downmix_coef);
1066     }
1067
1068     /* Generate LFE samples for this subsubframe FIXME!!! */
1069     if (s->output & DCA_LFE) {
1070         int lfe_samples = 2 * s->lfe * s->subsubframes;
1071
1072         lfe_interpolation_fir(s->lfe, 2 * s->lfe,
1073                               s->lfe_data + lfe_samples +
1074                               2 * s->lfe * subsubframe,
1075                               &s->samples[256 * dca_lfe_index[s->amode]],
1076                               (1.0/256.0)*s->scale_bias,  s->add_bias);
1077         /* Outputs 20bits pcm samples */
1078     }
1079
1080     return 0;
1081 }
1082
1083
1084 static int dca_subframe_footer(DCAContext * s)
1085 {
1086     int aux_data_count = 0, i;
1087     int lfe_samples;
1088
1089     /*
1090      * Unpack optional information
1091      */
1092
1093     if (s->timestamp)
1094         get_bits(&s->gb, 32);
1095
1096     if (s->aux_data)
1097         aux_data_count = get_bits(&s->gb, 6);
1098
1099     for (i = 0; i < aux_data_count; i++)
1100         get_bits(&s->gb, 8);
1101
1102     if (s->crc_present && (s->downmix || s->dynrange))
1103         get_bits(&s->gb, 16);
1104
1105     lfe_samples = 2 * s->lfe * s->subsubframes;
1106     for (i = 0; i < lfe_samples; i++) {
1107         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1108     }
1109
1110     return 0;
1111 }
1112
1113 /**
1114  * Decode a dca frame block
1115  *
1116  * @param s     pointer to the DCAContext
1117  */
1118
1119 static int dca_decode_block(DCAContext * s)
1120 {
1121
1122     /* Sanity check */
1123     if (s->current_subframe >= s->subframes) {
1124         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1125                s->current_subframe, s->subframes);
1126         return -1;
1127     }
1128
1129     if (!s->current_subsubframe) {
1130 #ifdef TRACE
1131         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1132 #endif
1133         /* Read subframe header */
1134         if (dca_subframe_header(s))
1135             return -1;
1136     }
1137
1138     /* Read subsubframe */
1139 #ifdef TRACE
1140     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1141 #endif
1142     if (dca_subsubframe(s))
1143         return -1;
1144
1145     /* Update state */
1146     s->current_subsubframe++;
1147     if (s->current_subsubframe >= s->subsubframes) {
1148         s->current_subsubframe = 0;
1149         s->current_subframe++;
1150     }
1151     if (s->current_subframe >= s->subframes) {
1152 #ifdef TRACE
1153         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1154 #endif
1155         /* Read subframe footer */
1156         if (dca_subframe_footer(s))
1157             return -1;
1158     }
1159
1160     return 0;
1161 }
1162
1163 /**
1164  * Convert bitstream to one representation based on sync marker
1165  */
1166 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1167                           int max_size)
1168 {
1169     uint32_t mrk;
1170     int i, tmp;
1171     const uint16_t *ssrc = (const uint16_t *) src;
1172     uint16_t *sdst = (uint16_t *) dst;
1173     PutBitContext pb;
1174
1175     if((unsigned)src_size > (unsigned)max_size) {
1176 //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1177 //        return -1;
1178         src_size = max_size;
1179     }
1180
1181     mrk = AV_RB32(src);
1182     switch (mrk) {
1183     case DCA_MARKER_RAW_BE:
1184         memcpy(dst, src, src_size);
1185         return src_size;
1186     case DCA_MARKER_RAW_LE:
1187         for (i = 0; i < (src_size + 1) >> 1; i++)
1188             *sdst++ = bswap_16(*ssrc++);
1189         return src_size;
1190     case DCA_MARKER_14B_BE:
1191     case DCA_MARKER_14B_LE:
1192         init_put_bits(&pb, dst, max_size);
1193         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1194             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1195             put_bits(&pb, 14, tmp);
1196         }
1197         flush_put_bits(&pb);
1198         return (put_bits_count(&pb) + 7) >> 3;
1199     default:
1200         return -1;
1201     }
1202 }
1203
1204 /**
1205  * Main frame decoding function
1206  * FIXME add arguments
1207  */
1208 static int dca_decode_frame(AVCodecContext * avctx,
1209                             void *data, int *data_size,
1210                             AVPacket *avpkt)
1211 {
1212     const uint8_t *buf = avpkt->data;
1213     int buf_size = avpkt->size;
1214
1215     int i;
1216     int16_t *samples = data;
1217     DCAContext *s = avctx->priv_data;
1218     int channels;
1219
1220
1221     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1222     if (s->dca_buffer_size == -1) {
1223         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1224         return -1;
1225     }
1226
1227     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1228     if (dca_parse_frame_header(s) < 0) {
1229         //seems like the frame is corrupt, try with the next one
1230         *data_size=0;
1231         return buf_size;
1232     }
1233     //set AVCodec values with parsed data
1234     avctx->sample_rate = s->sample_rate;
1235     avctx->bit_rate = s->bit_rate;
1236
1237     channels = s->prim_channels + !!s->lfe;
1238
1239     if (s->amode<16) {
1240         avctx->channel_layout = dca_core_channel_layout[s->amode];
1241
1242         if (s->lfe) {
1243             avctx->channel_layout |= CH_LOW_FREQUENCY;
1244             s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1245         } else
1246             s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1247
1248         if (s->prim_channels > 0 &&
1249             s->channel_order_tab[s->prim_channels - 1] < 0)
1250             return -1;
1251
1252         if(avctx->request_channels == 2 && s->prim_channels > 2) {
1253             channels = 2;
1254             s->output = DCA_STEREO;
1255             avctx->channel_layout = CH_LAYOUT_STEREO;
1256         }
1257     } else {
1258         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1259         return -1;
1260     }
1261
1262
1263     /* There is nothing that prevents a dts frame to change channel configuration
1264        but FFmpeg doesn't support that so only set the channels if it is previously
1265        unset. Ideally during the first probe for channels the crc should be checked
1266        and only set avctx->channels when the crc is ok. Right now the decoder could
1267        set the channels based on a broken first frame.*/
1268     if (!avctx->channels)
1269         avctx->channels = channels;
1270
1271     if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1272         return -1;
1273     *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1274     for (i = 0; i < (s->sample_blocks / 8); i++) {
1275         dca_decode_block(s);
1276         s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1277         samples += 256 * channels;
1278     }
1279
1280     return buf_size;
1281 }
1282
1283
1284
1285 /**
1286  * DCA initialization
1287  *
1288  * @param avctx     pointer to the AVCodecContext
1289  */
1290
1291 static av_cold int dca_decode_init(AVCodecContext * avctx)
1292 {
1293     DCAContext *s = avctx->priv_data;
1294     int i;
1295
1296     s->avctx = avctx;
1297     dca_init_vlcs();
1298
1299     dsputil_init(&s->dsp, avctx);
1300     ff_mdct_init(&s->imdct, 6, 1, 1.0);
1301
1302     for(i = 0; i < 6; i++)
1303         s->samples_chanptr[i] = s->samples + i * 256;
1304     avctx->sample_fmt = SAMPLE_FMT_S16;
1305
1306     if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1307         s->add_bias = 385.0f;
1308         s->scale_bias = 1.0 / 32768.0;
1309     } else {
1310         s->add_bias = 0.0f;
1311         s->scale_bias = 1.0;
1312
1313         /* allow downmixing to stereo */
1314         if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1315                 avctx->request_channels == 2) {
1316             avctx->channels = avctx->request_channels;
1317         }
1318     }
1319
1320
1321     return 0;
1322 }
1323
1324 static av_cold int dca_decode_end(AVCodecContext * avctx)
1325 {
1326     DCAContext *s = avctx->priv_data;
1327     ff_mdct_end(&s->imdct);
1328     return 0;
1329 }
1330
1331 AVCodec dca_decoder = {
1332     .name = "dca",
1333     .type = CODEC_TYPE_AUDIO,
1334     .id = CODEC_ID_DTS,
1335     .priv_data_size = sizeof(DCAContext),
1336     .init = dca_decode_init,
1337     .decode = dca_decode_frame,
1338     .close = dca_decode_end,
1339     .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1340 };