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 av_cold void dca_init_vlcs(void)
 256 {
 257     static int vlcs_initialized = 0;
 258     int i, j;
 259
 260     if (vlcs_initialized)
 261         return;
 262
 263     dca_bitalloc_index.offset = 1;
 264     dca_bitalloc_index.wrap = 2;
 265     for (i = 0; i < 5; i++)
 266         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
 267                  bitalloc_12_bits[i], 1, 1,
 268                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_STATIC);
 269     dca_scalefactor.offset = -64;
 270     dca_scalefactor.wrap = 2;
 271     for (i = 0; i < 5; i++)
 272         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
 273                  scales_bits[i], 1, 1,
 274                  scales_codes[i], 2, 2, INIT_VLC_USE_STATIC);
 275     dca_tmode.offset = 0;
 276     dca_tmode.wrap = 1;
 277     for (i = 0; i < 4; i++)
 278         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
 279                  tmode_bits[i], 1, 1,
 280                  tmode_codes[i], 2, 2, INIT_VLC_USE_STATIC);
 281
 282     for(i = 0; i < 10; i++)
 283         for(j = 0; j < 7; j++){
 284             if(!bitalloc_codes[i][j]) break;
 285             dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
 286             dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
 287             init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
 288                      bitalloc_sizes[i],
 289                      bitalloc_bits[i][j], 1, 1,
 290                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_STATIC);
 291         }
 292     vlcs_initialized = 1;
 293 }
 294
 295 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
 296 {
 297     while(len--)
 298         *dst++ = get_bits(gb, bits);
 299 }
 300
 301 static int dca_parse_frame_header(DCAContext * s)
 302 {
 303     int i, j;
 304     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
 305     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
 306     static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
 307
 308     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
 309
 310     /* Sync code */
 311     get_bits(&s->gb, 32);
 312
 313     /* Frame header */
 314     s->frame_type        = get_bits(&s->gb, 1);
 315     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
 316     s->crc_present       = get_bits(&s->gb, 1);
 317     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
 318     s->frame_size        = get_bits(&s->gb, 14) + 1;
 319     if (s->frame_size < 95)
 320         return -1;
 321     s->amode             = get_bits(&s->gb, 6);
 322     s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
 323     if (!s->sample_rate)
 324         return -1;
 325     s->bit_rate_index    = get_bits(&s->gb, 5);
 326     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
 327     if (!s->bit_rate)
 328         return -1;
 329
 330     s->downmix           = get_bits(&s->gb, 1);
 331     s->dynrange          = get_bits(&s->gb, 1);
 332     s->timestamp         = get_bits(&s->gb, 1);
 333     s->aux_data          = get_bits(&s->gb, 1);
 334     s->hdcd              = get_bits(&s->gb, 1);
 335     s->ext_descr         = get_bits(&s->gb, 3);
 336     s->ext_coding        = get_bits(&s->gb, 1);
 337     s->aspf              = get_bits(&s->gb, 1);
 338     s->lfe               = get_bits(&s->gb, 2);
 339     s->predictor_history = get_bits(&s->gb, 1);
 340
 341     /* TODO: check CRC */
 342     if (s->crc_present)
 343         s->header_crc    = get_bits(&s->gb, 16);
 344
 345     s->multirate_inter   = get_bits(&s->gb, 1);
 346     s->version           = get_bits(&s->gb, 4);
 347     s->copy_history      = get_bits(&s->gb, 2);
 348     s->source_pcm_res    = get_bits(&s->gb, 3);
 349     s->front_sum         = get_bits(&s->gb, 1);
 350     s->surround_sum      = get_bits(&s->gb, 1);
 351     s->dialog_norm       = get_bits(&s->gb, 4);
 352
 353     /* FIXME: channels mixing levels */
 354     s->output = s->amode;
 355     if(s->lfe) s->output |= DCA_LFE;
 356
 357 #ifdef TRACE
 358     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
 359     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
 360     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
 361     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
 362            s->sample_blocks, s->sample_blocks * 32);
 363     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
 364     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
 365            s->amode, dca_channels[s->amode]);
 366     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
 367            s->sample_rate);
 368     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
 369            s->bit_rate);
 370     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
 371     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
 372     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
 373     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
 374     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
 375     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
 376     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
 377     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
 378     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
 379     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
 380            s->predictor_history);
 381     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
 382     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
 383            s->multirate_inter);
 384     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
 385     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
 386     av_log(s->avctx, AV_LOG_DEBUG,
 387            "source pcm resolution: %i (%i bits/sample)\n",
 388            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
 389     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
 390     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
 391     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
 392     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 393 #endif
 394
 395     /* Primary audio coding header */
 396     s->subframes         = get_bits(&s->gb, 4) + 1;
 397     s->total_channels    = get_bits(&s->gb, 3) + 1;
 398     s->prim_channels     = s->total_channels;
 399     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
 400         s->prim_channels = DCA_PRIM_CHANNELS_MAX;   /* We only support DTS core */
 401
 402
 403     for (i = 0; i < s->prim_channels; i++) {
 404         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
 405         if (s->subband_activity[i] > DCA_SUBBANDS)
 406             s->subband_activity[i] = DCA_SUBBANDS;
 407     }
 408     for (i = 0; i < s->prim_channels; i++) {
 409         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
 410         if (s->vq_start_subband[i] > DCA_SUBBANDS)
 411             s->vq_start_subband[i] = DCA_SUBBANDS;
 412     }
 413     get_array(&s->gb, s->joint_intensity,     s->prim_channels, 3);
 414     get_array(&s->gb, s->transient_huffman,   s->prim_channels, 2);
 415     get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
 416     get_array(&s->gb, s->bitalloc_huffman,    s->prim_channels, 3);
 417
 418     /* Get codebooks quantization indexes */
 419     memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
 420     for (j = 1; j < 11; j++)
 421         for (i = 0; i < s->prim_channels; i++)
 422             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
 423
 424     /* Get scale factor adjustment */
 425     for (j = 0; j < 11; j++)
 426         for (i = 0; i < s->prim_channels; i++)
 427             s->scalefactor_adj[i][j] = 1;
 428
 429     for (j = 1; j < 11; j++)
 430         for (i = 0; i < s->prim_channels; i++)
 431             if (s->quant_index_huffman[i][j] < thr[j])
 432                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
 433
 434     if (s->crc_present) {
 435         /* Audio header CRC check */
 436         get_bits(&s->gb, 16);
 437     }
 438
 439     s->current_subframe = 0;
 440     s->current_subsubframe = 0;
 441
 442 #ifdef TRACE
 443     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
 444     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
 445     for(i = 0; i < s->prim_channels; i++){
 446         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
 447         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
 448         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
 449         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
 450         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
 451         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
 452         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
 453         for (j = 0; j < 11; j++)
 454             av_log(s->avctx, AV_LOG_DEBUG, " %i",
 455                    s->quant_index_huffman[i][j]);
 456         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 457         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
 458         for (j = 0; j < 11; j++)
 459             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
 460         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 461     }
 462 #endif
 463
 464     return 0;
 465 }
 466
 467
 468 static inline int get_scale(GetBitContext *gb, int level, int value)
 469 {
 470    if (level < 5) {
 471        /* huffman encoded */
 472        value += get_bitalloc(gb, &dca_scalefactor, level);
 473    } else if(level < 8)
 474        value = get_bits(gb, level + 1);
 475    return value;
 476 }
 477
 478 static int dca_subframe_header(DCAContext * s)
 479 {
 480     /* Primary audio coding side information */
 481     int j, k;
 482
 483     s->subsubframes = get_bits(&s->gb, 2) + 1;
 484     s->partial_samples = get_bits(&s->gb, 3);
 485     for (j = 0; j < s->prim_channels; j++) {
 486         for (k = 0; k < s->subband_activity[j]; k++)
 487             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
 488     }
 489
 490     /* Get prediction codebook */
 491     for (j = 0; j < s->prim_channels; j++) {
 492         for (k = 0; k < s->subband_activity[j]; k++) {
 493             if (s->prediction_mode[j][k] > 0) {
 494                 /* (Prediction coefficient VQ address) */
 495                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
 496             }
 497         }
 498     }
 499
 500     /* Bit allocation index */
 501     for (j = 0; j < s->prim_channels; j++) {
 502         for (k = 0; k < s->vq_start_subband[j]; k++) {
 503             if (s->bitalloc_huffman[j] == 6)
 504                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
 505             else if (s->bitalloc_huffman[j] == 5)
 506                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
 507             else if (s->bitalloc_huffman[j] == 7) {
 508                 av_log(s->avctx, AV_LOG_ERROR,
 509                        "Invalid bit allocation index\n");
 510                 return -1;
 511             } else {
 512                 s->bitalloc[j][k] =
 513                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
 514             }
 515
 516             if (s->bitalloc[j][k] > 26) {
 517 //                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
 518 //                          j, k, s->bitalloc[j][k]);
 519                 return -1;
 520             }
 521         }
 522     }
 523
 524     /* Transition mode */
 525     for (j = 0; j < s->prim_channels; j++) {
 526         for (k = 0; k < s->subband_activity[j]; k++) {
 527             s->transition_mode[j][k] = 0;
 528             if (s->subsubframes > 1 &&
 529                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
 530                 s->transition_mode[j][k] =
 531                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
 532             }
 533         }
 534     }
 535
 536     for (j = 0; j < s->prim_channels; j++) {
 537         const uint32_t *scale_table;
 538         int scale_sum;
 539
 540         memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
 541
 542         if (s->scalefactor_huffman[j] == 6)
 543             scale_table = scale_factor_quant7;
 544         else
 545             scale_table = scale_factor_quant6;
 546
 547         /* When huffman coded, only the difference is encoded */
 548         scale_sum = 0;
 549
 550         for (k = 0; k < s->subband_activity[j]; k++) {
 551             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
 552                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
 553                 s->scale_factor[j][k][0] = scale_table[scale_sum];
 554             }
 555
 556             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
 557                 /* Get second scale factor */
 558                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
 559                 s->scale_factor[j][k][1] = scale_table[scale_sum];
 560             }
 561         }
 562     }
 563
 564     /* Joint subband scale factor codebook select */
 565     for (j = 0; j < s->prim_channels; j++) {
 566         /* Transmitted only if joint subband coding enabled */
 567         if (s->joint_intensity[j] > 0)
 568             s->joint_huff[j] = get_bits(&s->gb, 3);
 569     }
 570
 571     /* Scale factors for joint subband coding */
 572     for (j = 0; j < s->prim_channels; j++) {
 573         int source_channel;
 574
 575         /* Transmitted only if joint subband coding enabled */
 576         if (s->joint_intensity[j] > 0) {
 577             int scale = 0;
 578             source_channel = s->joint_intensity[j] - 1;
 579
 580             /* When huffman coded, only the difference is encoded
 581              * (is this valid as well for joint scales ???) */
 582
 583             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
 584                 scale = get_scale(&s->gb, s->joint_huff[j], 0);
 585                 scale += 64;    /* bias */
 586                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
 587             }
 588
 589             if (!s->debug_flag & 0x02) {
 590                 av_log(s->avctx, AV_LOG_DEBUG,
 591                        "Joint stereo coding not supported\n");
 592                 s->debug_flag |= 0x02;
 593             }
 594         }
 595     }
 596
 597     /* Stereo downmix coefficients */
 598     if (s->prim_channels > 2) {
 599         if(s->downmix) {
 600             for (j = 0; j < s->prim_channels; j++) {
 601                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
 602                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
 603             }
 604         } else {
 605             int am = s->amode & DCA_CHANNEL_MASK;
 606             for (j = 0; j < s->prim_channels; j++) {
 607                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
 608                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
 609             }
 610         }
 611     }
 612
 613     /* Dynamic range coefficient */
 614     if (s->dynrange)
 615         s->dynrange_coef = get_bits(&s->gb, 8);
 616
 617     /* Side information CRC check word */
 618     if (s->crc_present) {
 619         get_bits(&s->gb, 16);
 620     }
 621
 622     /*
 623      * Primary audio data arrays
 624      */
 625
 626     /* VQ encoded high frequency subbands */
 627     for (j = 0; j < s->prim_channels; j++)
 628         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 629             /* 1 vector -> 32 samples */
 630             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
 631
 632     /* Low frequency effect data */
 633     if (s->lfe) {
 634         /* LFE samples */
 635         int lfe_samples = 2 * s->lfe * s->subsubframes;
 636         float lfe_scale;
 637
 638         for (j = lfe_samples; j < lfe_samples * 2; j++) {
 639             /* Signed 8 bits int */
 640             s->lfe_data[j] = get_sbits(&s->gb, 8);
 641         }
 642
 643         /* Scale factor index */
 644         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
 645
 646         /* Quantization step size * scale factor */
 647         lfe_scale = 0.035 * s->lfe_scale_factor;
 648
 649         for (j = lfe_samples; j < lfe_samples * 2; j++)
 650             s->lfe_data[j] *= lfe_scale;
 651     }
 652
 653 #ifdef TRACE
 654     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
 655     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
 656            s->partial_samples);
 657     for (j = 0; j < s->prim_channels; j++) {
 658         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
 659         for (k = 0; k < s->subband_activity[j]; k++)
 660             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
 661         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 662     }
 663     for (j = 0; j < s->prim_channels; j++) {
 664         for (k = 0; k < s->subband_activity[j]; k++)
 665                 av_log(s->avctx, AV_LOG_DEBUG,
 666                        "prediction coefs: %f, %f, %f, %f\n",
 667                        (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
 668                        (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
 669                        (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
 670                        (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
 671     }
 672     for (j = 0; j < s->prim_channels; j++) {
 673         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
 674         for (k = 0; k < s->vq_start_subband[j]; k++)
 675             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
 676         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 677     }
 678     for (j = 0; j < s->prim_channels; j++) {
 679         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
 680         for (k = 0; k < s->subband_activity[j]; k++)
 681             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
 682         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 683     }
 684     for (j = 0; j < s->prim_channels; j++) {
 685         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
 686         for (k = 0; k < s->subband_activity[j]; k++) {
 687             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
 688                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
 689             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
 690                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
 691         }
 692         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 693     }
 694     for (j = 0; j < s->prim_channels; j++) {
 695         if (s->joint_intensity[j] > 0) {
 696             int source_channel = s->joint_intensity[j] - 1;
 697             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
 698             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
 699                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
 700             av_log(s->avctx, AV_LOG_DEBUG, "\n");
 701         }
 702     }
 703     if (s->prim_channels > 2 && s->downmix) {
 704         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
 705         for (j = 0; j < s->prim_channels; j++) {
 706             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
 707             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
 708         }
 709         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 710     }
 711     for (j = 0; j < s->prim_channels; j++)
 712         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 713             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
 714     if(s->lfe){
 715         int lfe_samples = 2 * s->lfe * s->subsubframes;
 716         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
 717         for (j = lfe_samples; j < lfe_samples * 2; j++)
 718             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
 719         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 720     }
 721 #endif
 722
 723     return 0;
 724 }
 725
 726 static void qmf_32_subbands(DCAContext * s, int chans,
 727                             float samples_in[32][8], float *samples_out,
 728                             float scale, float bias)
 729 {
 730     const float *prCoeff;
 731     int i, j;
 732     DECLARE_ALIGNED_16(float, raXin[32]);
 733
 734     int hist_index= s->hist_index[chans];
 735     float *subband_fir_hist2 = s->subband_fir_noidea[chans];
 736
 737     int subindex;
 738
 739     scale *= sqrt(1/8.0);
 740
 741     /* Select filter */
 742     if (!s->multirate_inter)    /* Non-perfect reconstruction */
 743         prCoeff = fir_32bands_nonperfect;
 744     else                        /* Perfect reconstruction */
 745         prCoeff = fir_32bands_perfect;
 746
 747     /* Reconstructed channel sample index */
 748     for (subindex = 0; subindex < 8; subindex++) {
 749         float *subband_fir_hist = s->subband_fir_hist[chans] + hist_index;
 750         /* Load in one sample from each subband and clear inactive subbands */
 751         for (i = 0; i < s->subband_activity[chans]; i++){
 752             if((i-1)&2) raXin[i] = -samples_in[i][subindex];
 753             else        raXin[i] =  samples_in[i][subindex];
 754         }
 755         for (; i < 32; i++)
 756             raXin[i] = 0.0;
 757
 758         ff_imdct_half(&s->imdct, subband_fir_hist, raXin);
 759
 760         /* Multiply by filter coefficients */
 761         for (i = 0; i < 16; i++){
 762             float a= subband_fir_hist2[i   ];
 763             float b= subband_fir_hist2[i+16];
 764             float c= 0;
 765             float d= 0;
 766             for (j = 0; j < 512-hist_index; j += 64){
 767                 a += prCoeff[i+j   ]*(-subband_fir_hist[15-i+j]);
 768                 b += prCoeff[i+j+16]*( subband_fir_hist[   i+j]);
 769                 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j]);
 770                 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j]);
 771             }
 772             for (     ; j < 512; j += 64){
 773                 a += prCoeff[i+j   ]*(-subband_fir_hist[15-i+j-512]);
 774                 b += prCoeff[i+j+16]*( subband_fir_hist[   i+j-512]);
 775                 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j-512]);
 776                 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j-512]);
 777             }
 778             samples_out[i   ] = a * scale + bias;
 779             samples_out[i+16] = b * scale + bias;
 780             subband_fir_hist2[i   ] = c;
 781             subband_fir_hist2[i+16] = d;
 782         }
 783         samples_out+= 32;
 784
 785         hist_index = (hist_index-32)&511;
 786     }
 787     s->hist_index[chans]= hist_index;
 788 }
 789
 790 static void lfe_interpolation_fir(int decimation_select,
 791                                   int num_deci_sample, float *samples_in,
 792                                   float *samples_out, float scale,
 793                                   float bias)
 794 {
 795     /* samples_in: An array holding decimated samples.
 796      *   Samples in current subframe starts from samples_in[0],
 797      *   while samples_in[-1], samples_in[-2], ..., stores samples
 798      *   from last subframe as history.
 799      *
 800      * samples_out: An array holding interpolated samples
 801      */
 802
 803     int decifactor, k, j;
 804     const float *prCoeff;
 805
 806     int interp_index = 0;       /* Index to the interpolated samples */
 807     int deciindex;
 808
 809     /* Select decimation filter */
 810     if (decimation_select == 1) {
 811         decifactor = 128;
 812         prCoeff = lfe_fir_128;
 813     } else {
 814         decifactor = 64;
 815         prCoeff = lfe_fir_64;
 816     }
 817     /* Interpolation */
 818     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
 819         /* One decimated sample generates decifactor interpolated ones */
 820         for (k = 0; k < decifactor; k++) {
 821             float rTmp = 0.0;
 822             //FIXME the coeffs are symetric, fix that
 823             for (j = 0; j < 512 / decifactor; j++)
 824                 rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor];
 825             samples_out[interp_index++] = (rTmp * scale) + bias;
 826         }
 827     }
 828 }
 829
 830 /* downmixing routines */
 831 #define MIX_REAR1(samples, si1, rs, coef) \
 832      samples[i]     += samples[si1] * coef[rs][0]; \
 833      samples[i+256] += samples[si1] * coef[rs][1];
 834
 835 #define MIX_REAR2(samples, si1, si2, rs, coef) \
 836      samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
 837      samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
 838
 839 #define MIX_FRONT3(samples, coef) \
 840     t = samples[i]; \
 841     samples[i]     = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
 842     samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
 843
 844 #define DOWNMIX_TO_STEREO(op1, op2) \
 845     for(i = 0; i < 256; i++){ \
 846         op1 \
 847         op2 \
 848     }
 849
 850 static void dca_downmix(float *samples, int srcfmt,
 851                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
 852 {
 853     int i;
 854     float t;
 855     float coef[DCA_PRIM_CHANNELS_MAX][2];
 856
 857     for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
 858         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
 859         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
 860     }
 861
 862     switch (srcfmt) {
 863     case DCA_MONO:
 864     case DCA_CHANNEL:
 865     case DCA_STEREO_TOTAL:
 866     case DCA_STEREO_SUMDIFF:
 867     case DCA_4F2R:
 868         av_log(NULL, 0, "Not implemented!\n");
 869         break;
 870     case DCA_STEREO:
 871         break;
 872     case DCA_3F:
 873         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
 874         break;
 875     case DCA_2F1R:
 876         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
 877         break;
 878     case DCA_3F1R:
 879         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
 880                           MIX_REAR1(samples, i + 768, 3, coef));
 881         break;
 882     case DCA_2F2R:
 883         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
 884         break;
 885     case DCA_3F2R:
 886         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
 887                           MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
 888         break;
 889     }
 890 }
 891
 892
 893 /* Very compact version of the block code decoder that does not use table
 894  * look-up but is slightly slower */
 895 static int decode_blockcode(int code, int levels, int *values)
 896 {
 897     int i;
 898     int offset = (levels - 1) >> 1;
 899
 900     for (i = 0; i < 4; i++) {
 901         values[i] = (code % levels) - offset;
 902         code /= levels;
 903     }
 904
 905     if (code == 0)
 906         return 0;
 907     else {
 908         av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
 909         return -1;
 910     }
 911 }
 912
 913 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
 914 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
 915
 916 static int dca_subsubframe(DCAContext * s)
 917 {
 918     int k, l;
 919     int subsubframe = s->current_subsubframe;
 920
 921     const float *quant_step_table;
 922
 923     /* FIXME */
 924     float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
 925
 926     /*
 927      * Audio data
 928      */
 929
 930     /* Select quantization step size table */
 931     if (s->bit_rate_index == 0x1f)
 932         quant_step_table = lossless_quant_d;
 933     else
 934         quant_step_table = lossy_quant_d;
 935
 936     for (k = 0; k < s->prim_channels; k++) {
 937         for (l = 0; l < s->vq_start_subband[k]; l++) {
 938             int m;
 939
 940             /* Select the mid-tread linear quantizer */
 941             int abits = s->bitalloc[k][l];
 942
 943             float quant_step_size = quant_step_table[abits];
 944             float rscale;
 945
 946             /*
 947              * Determine quantization index code book and its type
 948              */
 949
 950             /* Select quantization index code book */
 951             int sel = s->quant_index_huffman[k][abits];
 952
 953             /*
 954              * Extract bits from the bit stream
 955              */
 956             if(!abits){
 957                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
 958             }else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
 959                 if(abits <= 7){
 960                     /* Block code */
 961                     int block_code1, block_code2, size, levels;
 962                     int block[8];
 963
 964                     size = abits_sizes[abits-1];
 965                     levels = abits_levels[abits-1];
 966
 967                     block_code1 = get_bits(&s->gb, size);
 968                     /* FIXME Should test return value */
 969                     decode_blockcode(block_code1, levels, block);
 970                     block_code2 = get_bits(&s->gb, size);
 971                     decode_blockcode(block_code2, levels, &block[4]);
 972                     for (m = 0; m < 8; m++)
 973                         subband_samples[k][l][m] = block[m];
 974                 }else{
 975                     /* no coding */
 976                     for (m = 0; m < 8; m++)
 977                         subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3);
 978                 }
 979             }else{
 980                 /* Huffman coded */
 981                 for (m = 0; m < 8; m++)
 982                     subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
 983             }
 984
 985             /* Deal with transients */
 986             if (s->transition_mode[k][l] &&
 987                 subsubframe >= s->transition_mode[k][l])
 988                 rscale = quant_step_size * s->scale_factor[k][l][1];
 989             else
 990                 rscale = quant_step_size * s->scale_factor[k][l][0];
 991
 992             rscale *= s->scalefactor_adj[k][sel];
 993
 994             for (m = 0; m < 8; m++)
 995                 subband_samples[k][l][m] *= rscale;
 996
 997             /*
 998              * Inverse ADPCM if in prediction mode
 999              */
1000             if (s->prediction_mode[k][l]) {
1001                 int n;
1002                 for (m = 0; m < 8; m++) {
1003                     for (n = 1; n <= 4; n++)
1004                         if (m >= n)
1005                             subband_samples[k][l][m] +=
1006                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1007                                  subband_samples[k][l][m - n] / 8192);
1008                         else if (s->predictor_history)
1009                             subband_samples[k][l][m] +=
1010                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1011                                  s->subband_samples_hist[k][l][m - n +
1012                                                                4] / 8192);
1013                 }
1014             }
1015         }
1016
1017         /*
1018          * Decode VQ encoded high frequencies
1019          */
1020         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1021             /* 1 vector -> 32 samples but we only need the 8 samples
1022              * for this subsubframe. */
1023             int m;
1024
1025             if (!s->debug_flag & 0x01) {
1026                 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1027                 s->debug_flag |= 0x01;
1028             }
1029
1030             for (m = 0; m < 8; m++) {
1031                 subband_samples[k][l][m] =
1032                     high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1033                                                         m]
1034                     * (float) s->scale_factor[k][l][0] / 16.0;
1035             }
1036         }
1037     }
1038
1039     /* Check for DSYNC after subsubframe */
1040     if (s->aspf || subsubframe == s->subsubframes - 1) {
1041         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1042 #ifdef TRACE
1043             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1044 #endif
1045         } else {
1046             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1047         }
1048     }
1049
1050     /* Backup predictor history for adpcm */
1051     for (k = 0; k < s->prim_channels; k++)
1052         for (l = 0; l < s->vq_start_subband[k]; l++)
1053             memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1054                         4 * sizeof(subband_samples[0][0][0]));
1055
1056     /* 32 subbands QMF */
1057     for (k = 0; k < s->prim_channels; k++) {
1058 /*        static float pcm_to_double[8] =
1059             {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1060          qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1061                             M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1062                             s->add_bias );
1063     }
1064
1065     /* Down mixing */
1066
1067     if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1068         dca_downmix(s->samples, s->amode, s->downmix_coef);
1069     }
1070
1071     /* Generate LFE samples for this subsubframe FIXME!!! */
1072     if (s->output & DCA_LFE) {
1073         int lfe_samples = 2 * s->lfe * s->subsubframes;
1074
1075         lfe_interpolation_fir(s->lfe, 2 * s->lfe,
1076                               s->lfe_data + lfe_samples +
1077                               2 * s->lfe * subsubframe,
1078                               &s->samples[256 * dca_lfe_index[s->amode]],
1079                               (1.0/256.0)*s->scale_bias,  s->add_bias);
1080         /* Outputs 20bits pcm samples */
1081     }
1082
1083     return 0;
1084 }
1085
1086
1087 static int dca_subframe_footer(DCAContext * s)
1088 {
1089     int aux_data_count = 0, i;
1090     int lfe_samples;
1091
1092     /*
1093      * Unpack optional information
1094      */
1095
1096     if (s->timestamp)
1097         get_bits(&s->gb, 32);
1098
1099     if (s->aux_data)
1100         aux_data_count = get_bits(&s->gb, 6);
1101
1102     for (i = 0; i < aux_data_count; i++)
1103         get_bits(&s->gb, 8);
1104
1105     if (s->crc_present && (s->downmix || s->dynrange))
1106         get_bits(&s->gb, 16);
1107
1108     lfe_samples = 2 * s->lfe * s->subsubframes;
1109     for (i = 0; i < lfe_samples; i++) {
1110         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1111     }
1112
1113     return 0;
1114 }
1115
1116 /**
1117  * Decode a dca frame block
1118  *
1119  * @param s     pointer to the DCAContext
1120  */
1121
1122 static int dca_decode_block(DCAContext * s)
1123 {
1124
1125     /* Sanity check */
1126     if (s->current_subframe >= s->subframes) {
1127         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1128                s->current_subframe, s->subframes);
1129         return -1;
1130     }
1131
1132     if (!s->current_subsubframe) {
1133 #ifdef TRACE
1134         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1135 #endif
1136         /* Read subframe header */
1137         if (dca_subframe_header(s))
1138             return -1;
1139     }
1140
1141     /* Read subsubframe */
1142 #ifdef TRACE
1143     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1144 #endif
1145     if (dca_subsubframe(s))
1146         return -1;
1147
1148     /* Update state */
1149     s->current_subsubframe++;
1150     if (s->current_subsubframe >= s->subsubframes) {
1151         s->current_subsubframe = 0;
1152         s->current_subframe++;
1153     }
1154     if (s->current_subframe >= s->subframes) {
1155 #ifdef TRACE
1156         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1157 #endif
1158         /* Read subframe footer */
1159         if (dca_subframe_footer(s))
1160             return -1;
1161     }
1162
1163     return 0;
1164 }
1165
1166 /**
1167  * Convert bitstream to one representation based on sync marker
1168  */
1169 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1170                           int max_size)
1171 {
1172     uint32_t mrk;
1173     int i, tmp;
1174     const uint16_t *ssrc = (const uint16_t *) src;
1175     uint16_t *sdst = (uint16_t *) dst;
1176     PutBitContext pb;
1177
1178     if((unsigned)src_size > (unsigned)max_size) {
1179 //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1180 //        return -1;
1181         src_size = max_size;
1182     }
1183
1184     mrk = AV_RB32(src);
1185     switch (mrk) {
1186     case DCA_MARKER_RAW_BE:
1187         memcpy(dst, src, src_size);
1188         return src_size;
1189     case DCA_MARKER_RAW_LE:
1190         for (i = 0; i < (src_size + 1) >> 1; i++)
1191             *sdst++ = bswap_16(*ssrc++);
1192         return src_size;
1193     case DCA_MARKER_14B_BE:
1194     case DCA_MARKER_14B_LE:
1195         init_put_bits(&pb, dst, max_size);
1196         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1197             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1198             put_bits(&pb, 14, tmp);
1199         }
1200         flush_put_bits(&pb);
1201         return (put_bits_count(&pb) + 7) >> 3;
1202     default:
1203         return -1;
1204     }
1205 }
1206
1207 /**
1208  * Main frame decoding function
1209  * FIXME add arguments
1210  */
1211 static int dca_decode_frame(AVCodecContext * avctx,
1212                             void *data, int *data_size,
1213                             AVPacket *avpkt)
1214 {
1215     const uint8_t *buf = avpkt->data;
1216     int buf_size = avpkt->size;
1217
1218     int i;
1219     int16_t *samples = data;
1220     DCAContext *s = avctx->priv_data;
1221     int channels;
1222
1223
1224     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1225     if (s->dca_buffer_size == -1) {
1226         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1227         return -1;
1228     }
1229
1230     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1231     if (dca_parse_frame_header(s) < 0) {
1232         //seems like the frame is corrupt, try with the next one
1233         *data_size=0;
1234         return buf_size;
1235     }
1236     //set AVCodec values with parsed data
1237     avctx->sample_rate = s->sample_rate;
1238     avctx->bit_rate = s->bit_rate;
1239
1240     channels = s->prim_channels + !!s->lfe;
1241
1242     if (s->amode<16) {
1243         avctx->channel_layout = dca_core_channel_layout[s->amode];
1244
1245         if (s->lfe) {
1246             avctx->channel_layout |= CH_LOW_FREQUENCY;
1247             s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1248         } else
1249             s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1250
1251         if(avctx->request_channels == 2 && s->prim_channels > 2) {
1252             channels = 2;
1253             s->output = DCA_STEREO;
1254             avctx->channel_layout = CH_LAYOUT_STEREO;
1255         }
1256     } else {
1257         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1258         return -1;
1259     }
1260
1261
1262     /* There is nothing that prevents a dts frame to change channel configuration
1263        but FFmpeg doesn't support that so only set the channels if it is previously
1264        unset. Ideally during the first probe for channels the crc should be checked
1265        and only set avctx->channels when the crc is ok. Right now the decoder could
1266        set the channels based on a broken first frame.*/
1267     if (!avctx->channels)
1268         avctx->channels = channels;
1269
1270     if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1271         return -1;
1272     *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1273     for (i = 0; i < (s->sample_blocks / 8); i++) {
1274         dca_decode_block(s);
1275         s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1276         samples += 256 * channels;
1277     }
1278
1279     return buf_size;
1280 }
1281
1282
1283
1284 /**
1285  * DCA initialization
1286  *
1287  * @param avctx     pointer to the AVCodecContext
1288  */
1289
1290 static av_cold int dca_decode_init(AVCodecContext * avctx)
1291 {
1292     DCAContext *s = avctx->priv_data;
1293     int i;
1294
1295     s->avctx = avctx;
1296     dca_init_vlcs();
1297
1298     dsputil_init(&s->dsp, avctx);
1299     ff_mdct_init(&s->imdct, 6, 1);
1300
1301     for(i = 0; i < 6; i++)
1302         s->samples_chanptr[i] = s->samples + i * 256;
1303     avctx->sample_fmt = SAMPLE_FMT_S16;
1304
1305     if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
1306         s->add_bias = 385.0f;
1307         s->scale_bias = 1.0 / 32768.0;
1308     } else {
1309         s->add_bias = 0.0f;
1310         s->scale_bias = 1.0;
1311
1312         /* allow downmixing to stereo */
1313         if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1314                 avctx->request_channels == 2) {
1315             avctx->channels = avctx->request_channels;
1316         }
1317     }
1318
1319
1320     return 0;
1321 }
1322
1323 static av_cold int dca_decode_end(AVCodecContext * avctx)
1324 {
1325     DCAContext *s = avctx->priv_data;
1326     ff_mdct_end(&s->imdct);
1327     return 0;
1328 }
1329
1330 AVCodec dca_decoder = {
1331     .name = "dca",
1332     .type = CODEC_TYPE_AUDIO,
1333     .id = CODEC_ID_DTS,
1334     .priv_data_size = sizeof(DCAContext),
1335     .init = dca_decode_init,
1336     .decode = dca_decode_frame,
1337     .close = dca_decode_end,
1338     .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1339 };