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

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