libavcodec/dca.c

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