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