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] - add_bias) * coef[rs][0];  \
 883      samples[i+256] += (samples[si1] - add_bias) * coef[rs][1];
 884
 885 #define MIX_REAR2(samples, si1, si2, rs, coef) \
 886      samples[i]     += (samples[si1] - add_bias) * coef[rs][0] + (samples[si2] - add_bias) * coef[rs+1][0]; \
 887      samples[i+256] += (samples[si1] - add_bias) * coef[rs][1] + (samples[si2] - add_bias) * coef[rs+1][1];
 888
 889 #define MIX_FRONT3(samples, coef) \
 890     t = samples[i+c] - add_bias; \
 891     u = samples[i+l] - add_bias; \
 892     v = samples[i+r] - add_bias; \
 893     samples[i]     = t * coef[0][0] + u * coef[1][0] + v * coef[2][0] + add_bias; \
 894     samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1] + add_bias;
 895
 896 #define DOWNMIX_TO_STEREO(op1, op2) \
 897     for (i = 0; i < 256; i++){ \
 898         op1 \
 899         op2 \
 900     }
 901
 902 static void dca_downmix(float *samples, int srcfmt,
 903                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
 904                         const int8_t *channel_mapping, float add_bias)
 905 {
 906     int c,l,r,sl,sr,s;
 907     int i;
 908     float t, u, v;
 909     float coef[DCA_PRIM_CHANNELS_MAX][2];
 910
 911     for (i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
 912         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
 913         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
 914     }
 915
 916     switch (srcfmt) {
 917     case DCA_MONO:
 918     case DCA_CHANNEL:
 919     case DCA_STEREO_TOTAL:
 920     case DCA_STEREO_SUMDIFF:
 921     case DCA_4F2R:
 922         av_log(NULL, 0, "Not implemented!\n");
 923         break;
 924     case DCA_STEREO:
 925         break;
 926     case DCA_3F:
 927         c = channel_mapping[0] * 256;
 928         l = channel_mapping[1] * 256;
 929         r = channel_mapping[2] * 256;
 930         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
 931         break;
 932     case DCA_2F1R:
 933         s = channel_mapping[2] * 256;
 934         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef),);
 935         break;
 936     case DCA_3F1R:
 937         c = channel_mapping[0] * 256;
 938         l = channel_mapping[1] * 256;
 939         r = channel_mapping[2] * 256;
 940         s = channel_mapping[3] * 256;
 941         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
 942                           MIX_REAR1(samples, i + s, 3, coef));
 943         break;
 944     case DCA_2F2R:
 945         sl = channel_mapping[2] * 256;
 946         sr = channel_mapping[3] * 256;
 947         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef),);
 948         break;
 949     case DCA_3F2R:
 950         c =  channel_mapping[0] * 256;
 951         l =  channel_mapping[1] * 256;
 952         r =  channel_mapping[2] * 256;
 953         sl = channel_mapping[3] * 256;
 954         sr = channel_mapping[4] * 256;
 955         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
 956                           MIX_REAR2(samples, i + sl, i + sr, 3, coef));
 957         break;
 958     }
 959 }
 960
 961
 962 /* Very compact version of the block code decoder that does not use table
 963  * look-up but is slightly slower */
 964 static int decode_blockcode(int code, int levels, int *values)
 965 {
 966     int i;
 967     int offset = (levels - 1) >> 1;
 968
 969     for (i = 0; i < 4; i++) {
 970         int div = FASTDIV(code, levels);
 971         values[i] = code - offset - div*levels;
 972         code = div;
 973     }
 974
 975     if (code == 0)
 976         return 0;
 977     else {
 978         av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
 979         return -1;
 980     }
 981 }
 982
 983 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
 984 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
 985
 986 static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
 987 {
 988     int k, l;
 989     int subsubframe = s->current_subsubframe;
 990
 991     const float *quant_step_table;
 992
 993     /* FIXME */
 994     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
 995     LOCAL_ALIGNED_16(int, block, [8]);
 996
 997     /*
 998      * Audio data
 999      */
1000
1001     /* Select quantization step size table */
1002     if (s->bit_rate_index == 0x1f)
1003         quant_step_table = lossless_quant_d;
1004     else
1005         quant_step_table = lossy_quant_d;
1006
1007     for (k = base_channel; k < s->prim_channels; k++) {
1008         for (l = 0; l < s->vq_start_subband[k]; l++) {
1009             int m;
1010
1011             /* Select the mid-tread linear quantizer */
1012             int abits = s->bitalloc[k][l];
1013
1014             float quant_step_size = quant_step_table[abits];
1015
1016             /*
1017              * Determine quantization index code book and its type
1018              */
1019
1020             /* Select quantization index code book */
1021             int sel = s->quant_index_huffman[k][abits];
1022
1023             /*
1024              * Extract bits from the bit stream
1025              */
1026             if (!abits){
1027                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1028             } else {
1029                 /* Deal with transients */
1030                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1031                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
1032
1033                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
1034                     if (abits <= 7){
1035                         /* Block code */
1036                         int block_code1, block_code2, size, levels;
1037
1038                         size = abits_sizes[abits-1];
1039                         levels = abits_levels[abits-1];
1040
1041                         block_code1 = get_bits(&s->gb, size);
1042                         /* FIXME Should test return value */
1043                         decode_blockcode(block_code1, levels, block);
1044                         block_code2 = get_bits(&s->gb, size);
1045                         decode_blockcode(block_code2, levels, &block[4]);
1046                     }else{
1047                         /* no coding */
1048                         for (m = 0; m < 8; m++)
1049                             block[m] = get_sbits(&s->gb, abits - 3);
1050                     }
1051                 }else{
1052                     /* Huffman coded */
1053                     for (m = 0; m < 8; m++)
1054                         block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1055                 }
1056
1057                 s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
1058                                                   block, rscale, 8);
1059             }
1060
1061             /*
1062              * Inverse ADPCM if in prediction mode
1063              */
1064             if (s->prediction_mode[k][l]) {
1065                 int n;
1066                 for (m = 0; m < 8; m++) {
1067                     for (n = 1; n <= 4; n++)
1068                         if (m >= n)
1069                             subband_samples[k][l][m] +=
1070                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1071                                  subband_samples[k][l][m - n] / 8192);
1072                         else if (s->predictor_history)
1073                             subband_samples[k][l][m] +=
1074                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1075                                  s->subband_samples_hist[k][l][m - n +
1076                                                                4] / 8192);
1077                 }
1078             }
1079         }
1080
1081         /*
1082          * Decode VQ encoded high frequencies
1083          */
1084         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1085             /* 1 vector -> 32 samples but we only need the 8 samples
1086              * for this subsubframe. */
1087             int m;
1088
1089             if (!s->debug_flag & 0x01) {
1090                 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1091                 s->debug_flag |= 0x01;
1092             }
1093
1094             for (m = 0; m < 8; m++) {
1095                 subband_samples[k][l][m] =
1096                     high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1097                                                         m]
1098                     * (float) s->scale_factor[k][l][0] / 16.0;
1099             }
1100         }
1101     }
1102
1103     /* Check for DSYNC after subsubframe */
1104     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1105         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1106 #ifdef TRACE
1107             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1108 #endif
1109         } else {
1110             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1111         }
1112     }
1113
1114     /* Backup predictor history for adpcm */
1115     for (k = base_channel; k < s->prim_channels; k++)
1116         for (l = 0; l < s->vq_start_subband[k]; l++)
1117             memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1118                         4 * sizeof(subband_samples[0][0][0]));
1119
1120     return 0;
1121 }
1122
1123 static int dca_filter_channels(DCAContext * s, int block_index)
1124 {
1125     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1126     int k;
1127
1128     /* 32 subbands QMF */
1129     for (k = 0; k < s->prim_channels; k++) {
1130 /*        static float pcm_to_double[8] =
1131             {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1132          qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1133                             M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1134                             s->add_bias );
1135     }
1136
1137     /* Down mixing */
1138     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1139         dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab, s->add_bias);
1140     }
1141
1142     /* Generate LFE samples for this subsubframe FIXME!!! */
1143     if (s->output & DCA_LFE) {
1144         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1145                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1146                               &s->samples[256 * dca_lfe_index[s->amode]],
1147                               (1.0/256.0)*s->scale_bias,  s->add_bias);
1148         /* Outputs 20bits pcm samples */
1149     }
1150
1151     return 0;
1152 }
1153
1154
1155 static int dca_subframe_footer(DCAContext * s, int base_channel)
1156 {
1157     int aux_data_count = 0, i;
1158
1159     /*
1160      * Unpack optional information
1161      */
1162
1163     /* presumably optional information only appears in the core? */
1164     if (!base_channel) {
1165         if (s->timestamp)
1166             get_bits(&s->gb, 32);
1167
1168         if (s->aux_data)
1169             aux_data_count = get_bits(&s->gb, 6);
1170
1171         for (i = 0; i < aux_data_count; i++)
1172             get_bits(&s->gb, 8);
1173
1174         if (s->crc_present && (s->downmix || s->dynrange))
1175             get_bits(&s->gb, 16);
1176     }
1177
1178     return 0;
1179 }
1180
1181 /**
1182  * Decode a dca frame block
1183  *
1184  * @param s     pointer to the DCAContext
1185  */
1186
1187 static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1188 {
1189
1190     /* Sanity check */
1191     if (s->current_subframe >= s->subframes) {
1192         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1193                s->current_subframe, s->subframes);
1194         return -1;
1195     }
1196
1197     if (!s->current_subsubframe) {
1198 #ifdef TRACE
1199         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1200 #endif
1201         /* Read subframe header */
1202         if (dca_subframe_header(s, base_channel, block_index))
1203             return -1;
1204     }
1205
1206     /* Read subsubframe */
1207 #ifdef TRACE
1208     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1209 #endif
1210     if (dca_subsubframe(s, base_channel, block_index))
1211         return -1;
1212
1213     /* Update state */
1214     s->current_subsubframe++;
1215     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1216         s->current_subsubframe = 0;
1217         s->current_subframe++;
1218     }
1219     if (s->current_subframe >= s->subframes) {
1220 #ifdef TRACE
1221         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1222 #endif
1223         /* Read subframe footer */
1224         if (dca_subframe_footer(s, base_channel))
1225             return -1;
1226     }
1227
1228     return 0;
1229 }
1230
1231 /**
1232  * Convert bitstream to one representation based on sync marker
1233  */
1234 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1235                           int max_size)
1236 {
1237     uint32_t mrk;
1238     int i, tmp;
1239     const uint16_t *ssrc = (const uint16_t *) src;
1240     uint16_t *sdst = (uint16_t *) dst;
1241     PutBitContext pb;
1242
1243     if ((unsigned)src_size > (unsigned)max_size) {
1244 //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1245 //        return -1;
1246         src_size = max_size;
1247     }
1248
1249     mrk = AV_RB32(src);
1250     switch (mrk) {
1251     case DCA_MARKER_RAW_BE:
1252         memcpy(dst, src, src_size);
1253         return src_size;
1254     case DCA_MARKER_RAW_LE:
1255         for (i = 0; i < (src_size + 1) >> 1; i++)
1256             *sdst++ = av_bswap16(*ssrc++);
1257         return src_size;
1258     case DCA_MARKER_14B_BE:
1259     case DCA_MARKER_14B_LE:
1260         init_put_bits(&pb, dst, max_size);
1261         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1262             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1263             put_bits(&pb, 14, tmp);
1264         }
1265         flush_put_bits(&pb);
1266         return (put_bits_count(&pb) + 7) >> 3;
1267     default:
1268         return -1;
1269     }
1270 }
1271
1272 /**
1273  * Main frame decoding function
1274  * FIXME add arguments
1275  */
1276 static int dca_decode_frame(AVCodecContext * avctx,
1277                             void *data, int *data_size,
1278                             AVPacket *avpkt)
1279 {
1280     const uint8_t *buf = avpkt->data;
1281     int buf_size = avpkt->size;
1282
1283     int lfe_samples;
1284     int num_core_channels = 0;
1285     int i;
1286     int16_t *samples = data;
1287     DCAContext *s = avctx->priv_data;
1288     int channels;
1289
1290
1291     s->xch_present = 0;
1292     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1293     if (s->dca_buffer_size == -1) {
1294         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1295         return -1;
1296     }
1297
1298     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1299     if (dca_parse_frame_header(s) < 0) {
1300         //seems like the frame is corrupt, try with the next one
1301         *data_size=0;
1302         return buf_size;
1303     }
1304     //set AVCodec values with parsed data
1305     avctx->sample_rate = s->sample_rate;
1306     avctx->bit_rate = s->bit_rate;
1307
1308     for (i = 0; i < (s->sample_blocks / 8); i++) {
1309         dca_decode_block(s, 0, i);
1310     }
1311
1312     /* record number of core channels incase less than max channels are requested */
1313     num_core_channels = s->prim_channels;
1314
1315     /* extensions start at 32-bit boundaries into bitstream */
1316     skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1317
1318     while(get_bits_left(&s->gb) >= 32) {
1319         uint32_t bits = get_bits_long(&s->gb, 32);
1320
1321         switch(bits) {
1322         case 0x5a5a5a5a: {
1323             int ext_amode, xch_fsize;
1324
1325             s->xch_base_channel = s->prim_channels;
1326
1327             /* validate sync word using XCHFSIZE field */
1328             xch_fsize = show_bits(&s->gb, 10);
1329             if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1330                (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1331                 continue;
1332
1333             /* skip length-to-end-of-frame field for the moment */
1334             skip_bits(&s->gb, 10);
1335
1336             /* extension amode should == 1, number of channels in extension */
1337             /* AFAIK XCh is not used for more channels */
1338             if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1339                 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1340                        " supported!\n",ext_amode);
1341                 continue;
1342             }
1343
1344             /* much like core primary audio coding header */
1345             dca_parse_audio_coding_header(s, s->xch_base_channel);
1346
1347             for (i = 0; i < (s->sample_blocks / 8); i++) {
1348                 dca_decode_block(s, s->xch_base_channel, i);
1349             }
1350
1351             s->xch_present = 1;
1352             break;
1353         }
1354         case 0x1d95f262:
1355             av_log(avctx, AV_LOG_DEBUG, "Possible X96 extension found at %d bits\n", get_bits_count(&s->gb));
1356             av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", get_bits(&s->gb, 12)+1);
1357             av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1358             break;
1359         }
1360
1361         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1362     }
1363
1364     channels = s->prim_channels + !!s->lfe;
1365
1366     if (s->amode<16) {
1367         avctx->channel_layout = dca_core_channel_layout[s->amode];
1368
1369         if (s->xch_present && (!avctx->request_channels ||
1370                                avctx->request_channels > num_core_channels + !!s->lfe)) {
1371             avctx->channel_layout |= CH_BACK_CENTER;
1372             if (s->lfe) {
1373                 avctx->channel_layout |= CH_LOW_FREQUENCY;
1374                 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1375             } else {
1376                 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1377             }
1378         } else {
1379             channels = num_core_channels + !!s->lfe;
1380             s->xch_present = 0; /* disable further xch processing */
1381             if (s->lfe) {
1382                 avctx->channel_layout |= CH_LOW_FREQUENCY;
1383                 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1384             } else
1385                 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1386         }
1387
1388         if (channels > !!s->lfe &&
1389             s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1390             return -1;
1391
1392         if (avctx->request_channels == 2 && s->prim_channels > 2) {
1393             channels = 2;
1394             s->output = DCA_STEREO;
1395             avctx->channel_layout = CH_LAYOUT_STEREO;
1396         }
1397     } else {
1398         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1399         return -1;
1400     }
1401
1402
1403     /* There is nothing that prevents a dts frame to change channel configuration
1404        but FFmpeg doesn't support that so only set the channels if it is previously
1405        unset. Ideally during the first probe for channels the crc should be checked
1406        and only set avctx->channels when the crc is ok. Right now the decoder could
1407        set the channels based on a broken first frame.*/
1408     avctx->channels = channels;
1409
1410     if (*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1411         return -1;
1412     *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1413
1414     /* filter to get final output */
1415     for (i = 0; i < (s->sample_blocks / 8); i++) {
1416         dca_filter_channels(s, i);
1417
1418         /* If this was marked as a DTS-ES stream we need to subtract back- */
1419         /* channel from SL & SR to remove matrixed back-channel signal */
1420         if((s->source_pcm_res & 1) && s->xch_present) {
1421             float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1422             float* lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1423             float* rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1424             int j;
1425             for(j = 0; j < 256; ++j) {
1426                 lt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1427                 rt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1428             }
1429         }
1430
1431         s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1432         samples += 256 * channels;
1433     }
1434
1435     /* update lfe history */
1436     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1437     for (i = 0; i < 2 * s->lfe * 4; i++) {
1438         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1439     }
1440
1441     return buf_size;
1442 }
1443
1444
1445
1446 /**
1447  * DCA initialization
1448  *
1449  * @param avctx     pointer to the AVCodecContext
1450  */
1451
1452 static av_cold int dca_decode_init(AVCodecContext * avctx)
1453 {
1454     DCAContext *s = avctx->priv_data;
1455     int i;
1456
1457     s->avctx = avctx;
1458     dca_init_vlcs();
1459
1460     dsputil_init(&s->dsp, avctx);
1461     ff_mdct_init(&s->imdct, 6, 1, 1.0);
1462     ff_synth_filter_init(&s->synth);
1463     ff_dcadsp_init(&s->dcadsp);
1464
1465     for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
1466         s->samples_chanptr[i] = s->samples + i * 256;
1467     avctx->sample_fmt = SAMPLE_FMT_S16;
1468
1469     if (s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1470         s->add_bias = 385.0f;
1471         s->scale_bias = 1.0 / 32768.0;
1472     } else {
1473         s->add_bias = 0.0f;
1474         s->scale_bias = 1.0;
1475
1476         /* allow downmixing to stereo */
1477         if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1478                 avctx->request_channels == 2) {
1479             avctx->channels = avctx->request_channels;
1480         }
1481     }
1482
1483
1484     return 0;
1485 }
1486
1487 static av_cold int dca_decode_end(AVCodecContext * avctx)
1488 {
1489     DCAContext *s = avctx->priv_data;
1490     ff_mdct_end(&s->imdct);
1491     return 0;
1492 }
1493
1494 AVCodec dca_decoder = {
1495     .name = "dca",
1496     .type = AVMEDIA_TYPE_AUDIO,
1497     .id = CODEC_ID_DTS,
1498     .priv_data_size = sizeof(DCAContext),
1499     .init = dca_decode_init,
1500     .decode = dca_decode_frame,
1501     .close = dca_decode_end,
1502     .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1503 };