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

   1 /*
   2  * DCA compatible decoder
   3  * Copyright (C) 2004 Gildas Bazin
   4  * Copyright (C) 2004 Benjamin Zores
   5  * Copyright (C) 2006 Benjamin Larsson
   6  * Copyright (C) 2007 Konstantin Shishkov
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 #include <math.h>
  26 #include <stddef.h>
  27 #include <stdio.h>
  28
  29 #include "libavutil/common.h"
  30 #include "libavutil/intmath.h"
  31 #include "libavutil/intreadwrite.h"
  32 #include "libavcore/audioconvert.h"
  33 #include "avcodec.h"
  34 #include "dsputil.h"
  35 #include "fft.h"
  36 #include "get_bits.h"
  37 #include "put_bits.h"
  38 #include "dcadata.h"
  39 #include "dcahuff.h"
  40 #include "dca.h"
  41 #include "synth_filter.h"
  42 #include "dcadsp.h"
  43
  44 //#define TRACE
  45
  46 #define DCA_PRIM_CHANNELS_MAX (7)
  47 #define DCA_SUBBANDS (32)
  48 #define DCA_ABITS_MAX (32)      /* Should be 28 */
  49 #define DCA_SUBSUBFRAMES_MAX (4)
  50 #define DCA_SUBFRAMES_MAX (16)
  51 #define DCA_BLOCKS_MAX (16)
  52 #define DCA_LFE_MAX (3)
  53
  54 enum DCAMode {
  55     DCA_MONO = 0,
  56     DCA_CHANNEL,
  57     DCA_STEREO,
  58     DCA_STEREO_SUMDIFF,
  59     DCA_STEREO_TOTAL,
  60     DCA_3F,
  61     DCA_2F1R,
  62     DCA_3F1R,
  63     DCA_2F2R,
  64     DCA_3F2R,
  65     DCA_4F2R
  66 };
  67
  68 /* these are unconfirmed but should be mostly correct */
  69 enum DCAExSSSpeakerMask {
  70     DCA_EXSS_FRONT_CENTER          = 0x0001,
  71     DCA_EXSS_FRONT_LEFT_RIGHT      = 0x0002,
  72     DCA_EXSS_SIDE_REAR_LEFT_RIGHT  = 0x0004,
  73     DCA_EXSS_LFE                   = 0x0008,
  74     DCA_EXSS_REAR_CENTER           = 0x0010,
  75     DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
  76     DCA_EXSS_REAR_LEFT_RIGHT       = 0x0040,
  77     DCA_EXSS_FRONT_HIGH_CENTER     = 0x0080,
  78     DCA_EXSS_OVERHEAD              = 0x0100,
  79     DCA_EXSS_CENTER_LEFT_RIGHT     = 0x0200,
  80     DCA_EXSS_WIDE_LEFT_RIGHT       = 0x0400,
  81     DCA_EXSS_SIDE_LEFT_RIGHT       = 0x0800,
  82     DCA_EXSS_LFE2                  = 0x1000,
  83     DCA_EXSS_SIDE_HIGH_LEFT_RIGHT  = 0x2000,
  84     DCA_EXSS_REAR_HIGH_CENTER      = 0x4000,
  85     DCA_EXSS_REAR_HIGH_LEFT_RIGHT  = 0x8000,
  86 };
  87
  88 enum DCAExtensionMask {
  89     DCA_EXT_CORE       = 0x001, ///< core in core substream
  90     DCA_EXT_XXCH       = 0x002, ///< XXCh channels extension in core substream
  91     DCA_EXT_X96        = 0x004, ///< 96/24 extension in core substream
  92     DCA_EXT_XCH        = 0x008, ///< XCh channel extension in core substream
  93     DCA_EXT_EXSS_CORE  = 0x010, ///< core in ExSS (extension substream)
  94     DCA_EXT_EXSS_XBR   = 0x020, ///< extended bitrate extension in ExSS
  95     DCA_EXT_EXSS_XXCH  = 0x040, ///< XXCh channels extension in ExSS
  96     DCA_EXT_EXSS_X96   = 0x080, ///< 96/24 extension in ExSS
  97     DCA_EXT_EXSS_LBR   = 0x100, ///< low bitrate component in ExSS
  98     DCA_EXT_EXSS_XLL   = 0x200, ///< lossless extension in ExSS
  99 };
 100
 101 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
 102  * Some compromises have been made for special configurations. Most configurations
 103  * are never used so complete accuracy is not needed.
 104  *
 105  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
 106  * S  -> side, when both rear and back are configured move one of them to the side channel
 107  * OV -> center back
 108  * All 2 channel configurations -> CH_LAYOUT_STEREO
 109  */
 110
 111 static const int64_t dca_core_channel_layout[] = {
 112     AV_CH_FRONT_CENTER,                                                      ///< 1, A
 113     AV_CH_LAYOUT_STEREO,                                                     ///< 2, A + B (dual mono)
 114     AV_CH_LAYOUT_STEREO,                                                     ///< 2, L + R (stereo)
 115     AV_CH_LAYOUT_STEREO,                                                     ///< 2, (L+R) + (L-R) (sum-difference)
 116     AV_CH_LAYOUT_STEREO,                                                     ///< 2, LT +RT (left and right total)
 117     AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER,                                  ///< 3, C+L+R
 118     AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER,                                   ///< 3, L+R+S
 119     AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|CH_BACK_CENTER,                   ///< 4, C + L + R+ S
 120     AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT,                    ///< 4, L + R +SL+ SR
 121     AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
 122     AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER,                    ///< 6, CL + CR + L + R + SL + SR
 123     AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT|AV_CH_FRONT_CENTER|AV_CH_BACK_CENTER,                                      ///< 6, C + L + R+ LR + RR + OV
 124     AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_BACK_CENTER|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT,   ///< 6, CF+ CR+LF+ RF+LR + RR
 125     AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
 126     AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2
 127     AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_BACK_CENTER|AV_CH_SIDE_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR
 128 };
 129
 130 static const int8_t dca_lfe_index[] = {
 131     1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
 132 };
 133
 134 static const int8_t dca_channel_reorder_lfe[][9] = {
 135     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
 136     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 137     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 138     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 139     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 140     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
 141     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
 142     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
 143     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
 144     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
 145     { 3,  4,  0,  1,  5,  6, -1, -1, -1},
 146     { 2,  0,  1,  4,  5,  6, -1, -1, -1},
 147     { 0,  6,  4,  5,  2,  3, -1, -1, -1},
 148     { 4,  2,  5,  0,  1,  6,  7, -1, -1},
 149     { 5,  6,  0,  1,  7,  3,  8,  4, -1},
 150     { 4,  2,  5,  0,  1,  6,  8,  7, -1},
 151 };
 152
 153 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
 154     { 0,  2, -1, -1, -1, -1, -1, -1, -1},
 155     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
 156     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
 157     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
 158     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
 159     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
 160     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
 161     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
 162     { 0,  1,  4,  5,  3, -1, -1, -1, -1},
 163     { 2,  0,  1,  5,  6,  4, -1, -1, -1},
 164     { 3,  4,  0,  1,  6,  7,  5, -1, -1},
 165     { 2,  0,  1,  4,  5,  6,  7, -1, -1},
 166     { 0,  6,  4,  5,  2,  3,  7, -1, -1},
 167     { 4,  2,  5,  0,  1,  7,  8,  6, -1},
 168     { 5,  6,  0,  1,  8,  3,  9,  4,  7},
 169     { 4,  2,  5,  0,  1,  6,  9,  8,  7},
 170 };
 171
 172 static const int8_t dca_channel_reorder_nolfe[][9] = {
 173     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
 174     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 175     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 176     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 177     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 178     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
 179     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
 180     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
 181     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
 182     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
 183     { 2,  3,  0,  1,  4,  5, -1, -1, -1},
 184     { 2,  0,  1,  3,  4,  5, -1, -1, -1},
 185     { 0,  5,  3,  4,  1,  2, -1, -1, -1},
 186     { 3,  2,  4,  0,  1,  5,  6, -1, -1},
 187     { 4,  5,  0,  1,  6,  2,  7,  3, -1},
 188     { 3,  2,  4,  0,  1,  5,  7,  6, -1},
 189 };
 190
 191 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
 192     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 193     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
 194     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
 195     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
 196     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
 197     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
 198     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
 199     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
 200     { 0,  1,  3,  4,  2, -1, -1, -1, -1},
 201     { 2,  0,  1,  4,  5,  3, -1, -1, -1},
 202     { 2,  3,  0,  1,  5,  6,  4, -1, -1},
 203     { 2,  0,  1,  3,  4,  5,  6, -1, -1},
 204     { 0,  5,  3,  4,  1,  2,  6, -1, -1},
 205     { 3,  2,  4,  0,  1,  6,  7,  5, -1},
 206     { 4,  5,  0,  1,  7,  2,  8,  3,  6},
 207     { 3,  2,  4,  0,  1,  5,  8,  7,  6},
 208 };
 209
 210 #define DCA_DOLBY 101           /* FIXME */
 211
 212 #define DCA_CHANNEL_BITS 6
 213 #define DCA_CHANNEL_MASK 0x3F
 214
 215 #define DCA_LFE 0x80
 216
 217 #define HEADER_SIZE 14
 218
 219 #define DCA_MAX_FRAME_SIZE 16384
 220 #define DCA_MAX_EXSS_HEADER_SIZE 4096
 221
 222 #define DCA_BUFFER_PADDING_SIZE 1024
 223
 224 /** Bit allocation */
 225 typedef struct {
 226     int offset;                 ///< code values offset
 227     int maxbits[8];             ///< max bits in VLC
 228     int wrap;                   ///< wrap for get_vlc2()
 229     VLC vlc[8];                 ///< actual codes
 230 } BitAlloc;
 231
 232 static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
 233 static BitAlloc dca_tmode;             ///< transition mode VLCs
 234 static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
 235 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
 236
 237 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
 238 {
 239     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
 240 }
 241
 242 typedef struct {
 243     AVCodecContext *avctx;
 244     /* Frame header */
 245     int frame_type;             ///< type of the current frame
 246     int samples_deficit;        ///< deficit sample count
 247     int crc_present;            ///< crc is present in the bitstream
 248     int sample_blocks;          ///< number of PCM sample blocks
 249     int frame_size;             ///< primary frame byte size
 250     int amode;                  ///< audio channels arrangement
 251     int sample_rate;            ///< audio sampling rate
 252     int bit_rate;               ///< transmission bit rate
 253     int bit_rate_index;         ///< transmission bit rate index
 254
 255     int downmix;                ///< embedded downmix enabled
 256     int dynrange;               ///< embedded dynamic range flag
 257     int timestamp;              ///< embedded time stamp flag
 258     int aux_data;               ///< auxiliary data flag
 259     int hdcd;                   ///< source material is mastered in HDCD
 260     int ext_descr;              ///< extension audio descriptor flag
 261     int ext_coding;             ///< extended coding flag
 262     int aspf;                   ///< audio sync word insertion flag
 263     int lfe;                    ///< low frequency effects flag
 264     int predictor_history;      ///< predictor history flag
 265     int header_crc;             ///< header crc check bytes
 266     int multirate_inter;        ///< multirate interpolator switch
 267     int version;                ///< encoder software revision
 268     int copy_history;           ///< copy history
 269     int source_pcm_res;         ///< source pcm resolution
 270     int front_sum;              ///< front sum/difference flag
 271     int surround_sum;           ///< surround sum/difference flag
 272     int dialog_norm;            ///< dialog normalisation parameter
 273
 274     /* Primary audio coding header */
 275     int subframes;              ///< number of subframes
 276     int total_channels;         ///< number of channels including extensions
 277     int prim_channels;          ///< number of primary audio channels
 278     int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
 279     int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
 280     int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
 281     int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
 282     int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
 283     int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
 284     int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
 285     float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
 286
 287     /* Primary audio coding side information */
 288     int subsubframes[DCA_SUBFRAMES_MAX];           ///< number of subsubframes
 289     int partial_samples[DCA_SUBFRAMES_MAX];        ///< partial subsubframe samples count
 290     int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
 291     int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
 292     int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
 293     int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
 294     int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
 295     int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
 296     int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
 297     int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
 298     int dynrange_coef;                                           ///< dynamic range coefficient
 299
 300     int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
 301
 302     float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      ///< Low frequency effect data
 303     int lfe_scale_factor;
 304
 305     /* Subband samples history (for ADPCM) */
 306     float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
 307     DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
 308     DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
 309     int hist_index[DCA_PRIM_CHANNELS_MAX];
 310     DECLARE_ALIGNED(16, float, raXin)[32];
 311
 312     int output;                 ///< type of output
 313     float add_bias;             ///< output bias
 314     float scale_bias;           ///< output scale
 315
 316     DECLARE_ALIGNED(16, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
 317     DECLARE_ALIGNED(16, float, samples)[(DCA_PRIM_CHANNELS_MAX+1)*256];
 318     const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX+1];
 319
 320     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
 321     int dca_buffer_size;        ///< how much data is in the dca_buffer
 322
 323     const int8_t* channel_order_tab;                             ///< channel reordering table, lfe and non lfe
 324     GetBitContext gb;
 325     /* Current position in DCA frame */
 326     int current_subframe;
 327     int current_subsubframe;
 328
 329     /* XCh extension information */
 330     int xch_present;
 331     int xch_base_channel;       ///< index of first (only) channel containing XCH data
 332
 333     /* Other detected extensions in the core substream */
 334     int xxch_present;
 335     int x96_present;
 336
 337     /* ExSS header parser */
 338     int static_fields;          ///< static fields present
 339     int mix_metadata;           ///< mixing metadata present
 340     int num_mix_configs;        ///< number of mix out configurations
 341     int mix_config_num_ch[4];   ///< number of channels in each mix out configuration
 342
 343     int profile;
 344
 345     int debug_flag;             ///< used for suppressing repeated error messages output
 346     DSPContext dsp;
 347     FFTContext imdct;
 348     SynthFilterContext synth;
 349     DCADSPContext dcadsp;
 350 } DCAContext;
 351
 352 static const uint16_t dca_vlc_offs[] = {
 353         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
 354      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
 355      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
 356      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
 357     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
 358     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
 359 };
 360
 361 static av_cold void dca_init_vlcs(void)
 362 {
 363     static int vlcs_initialized = 0;
 364     int i, j, c = 14;
 365     static VLC_TYPE dca_table[23622][2];
 366
 367     if (vlcs_initialized)
 368         return;
 369
 370     dca_bitalloc_index.offset = 1;
 371     dca_bitalloc_index.wrap = 2;
 372     for (i = 0; i < 5; i++) {
 373         dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
 374         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
 375         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
 376                  bitalloc_12_bits[i], 1, 1,
 377                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 378     }
 379     dca_scalefactor.offset = -64;
 380     dca_scalefactor.wrap = 2;
 381     for (i = 0; i < 5; i++) {
 382         dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
 383         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
 384         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
 385                  scales_bits[i], 1, 1,
 386                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 387     }
 388     dca_tmode.offset = 0;
 389     dca_tmode.wrap = 1;
 390     for (i = 0; i < 4; i++) {
 391         dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
 392         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
 393         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
 394                  tmode_bits[i], 1, 1,
 395                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 396     }
 397
 398     for (i = 0; i < 10; i++)
 399         for (j = 0; j < 7; j++){
 400             if (!bitalloc_codes[i][j]) break;
 401             dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
 402             dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
 403             dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
 404             dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
 405             init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
 406                      bitalloc_sizes[i],
 407                      bitalloc_bits[i][j], 1, 1,
 408                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
 409             c++;
 410         }
 411     vlcs_initialized = 1;
 412 }
 413
 414 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
 415 {
 416     while(len--)
 417         *dst++ = get_bits(gb, bits);
 418 }
 419
 420 static int dca_parse_audio_coding_header(DCAContext * s, int base_channel)
 421 {
 422     int i, j;
 423     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
 424     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
 425     static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
 426
 427     s->total_channels    = get_bits(&s->gb, 3) + 1 + base_channel;
 428     s->prim_channels     = s->total_channels;
 429
 430     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
 431         s->prim_channels = DCA_PRIM_CHANNELS_MAX;
 432
 433
 434     for (i = base_channel; i < s->prim_channels; i++) {
 435         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
 436         if (s->subband_activity[i] > DCA_SUBBANDS)
 437             s->subband_activity[i] = DCA_SUBBANDS;
 438     }
 439     for (i = base_channel; i < s->prim_channels; i++) {
 440         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
 441         if (s->vq_start_subband[i] > DCA_SUBBANDS)
 442             s->vq_start_subband[i] = DCA_SUBBANDS;
 443     }
 444     get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);
 445     get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);
 446     get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
 447     get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);
 448
 449     /* Get codebooks quantization indexes */
 450     if (!base_channel)
 451         memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
 452     for (j = 1; j < 11; j++)
 453         for (i = base_channel; i < s->prim_channels; i++)
 454             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
 455
 456     /* Get scale factor adjustment */
 457     for (j = 0; j < 11; j++)
 458         for (i = base_channel; i < s->prim_channels; i++)
 459             s->scalefactor_adj[i][j] = 1;
 460
 461     for (j = 1; j < 11; j++)
 462         for (i = base_channel; i < s->prim_channels; i++)
 463             if (s->quant_index_huffman[i][j] < thr[j])
 464                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
 465
 466     if (s->crc_present) {
 467         /* Audio header CRC check */
 468         get_bits(&s->gb, 16);
 469     }
 470
 471     s->current_subframe = 0;
 472     s->current_subsubframe = 0;
 473
 474 #ifdef TRACE
 475     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
 476     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
 477     for (i = base_channel; i < s->prim_channels; i++){
 478         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
 479         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
 480         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
 481         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
 482         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
 483         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
 484         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
 485         for (j = 0; j < 11; j++)
 486             av_log(s->avctx, AV_LOG_DEBUG, " %i",
 487                    s->quant_index_huffman[i][j]);
 488         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 489         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
 490         for (j = 0; j < 11; j++)
 491             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
 492         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 493     }
 494 #endif
 495
 496   return 0;
 497 }
 498
 499 static int dca_parse_frame_header(DCAContext * s)
 500 {
 501     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
 502
 503     /* Sync code */
 504     get_bits(&s->gb, 32);
 505
 506     /* Frame header */
 507     s->frame_type        = get_bits(&s->gb, 1);
 508     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
 509     s->crc_present       = get_bits(&s->gb, 1);
 510     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
 511     s->frame_size        = get_bits(&s->gb, 14) + 1;
 512     if (s->frame_size < 95)
 513         return -1;
 514     s->amode             = get_bits(&s->gb, 6);
 515     s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
 516     if (!s->sample_rate)
 517         return -1;
 518     s->bit_rate_index    = get_bits(&s->gb, 5);
 519     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
 520     if (!s->bit_rate)
 521         return -1;
 522
 523     s->downmix           = get_bits(&s->gb, 1);
 524     s->dynrange          = get_bits(&s->gb, 1);
 525     s->timestamp         = get_bits(&s->gb, 1);
 526     s->aux_data          = get_bits(&s->gb, 1);
 527     s->hdcd              = get_bits(&s->gb, 1);
 528     s->ext_descr         = get_bits(&s->gb, 3);
 529     s->ext_coding        = get_bits(&s->gb, 1);
 530     s->aspf              = get_bits(&s->gb, 1);
 531     s->lfe               = get_bits(&s->gb, 2);
 532     s->predictor_history = get_bits(&s->gb, 1);
 533
 534     /* TODO: check CRC */
 535     if (s->crc_present)
 536         s->header_crc    = get_bits(&s->gb, 16);
 537
 538     s->multirate_inter   = get_bits(&s->gb, 1);
 539     s->version           = get_bits(&s->gb, 4);
 540     s->copy_history      = get_bits(&s->gb, 2);
 541     s->source_pcm_res    = get_bits(&s->gb, 3);
 542     s->front_sum         = get_bits(&s->gb, 1);
 543     s->surround_sum      = get_bits(&s->gb, 1);
 544     s->dialog_norm       = get_bits(&s->gb, 4);
 545
 546     /* FIXME: channels mixing levels */
 547     s->output = s->amode;
 548     if (s->lfe) s->output |= DCA_LFE;
 549
 550 #ifdef TRACE
 551     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
 552     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
 553     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
 554     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
 555            s->sample_blocks, s->sample_blocks * 32);
 556     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
 557     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
 558            s->amode, dca_channels[s->amode]);
 559     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
 560            s->sample_rate);
 561     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
 562            s->bit_rate);
 563     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
 564     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
 565     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
 566     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
 567     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
 568     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
 569     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
 570     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
 571     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
 572     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
 573            s->predictor_history);
 574     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
 575     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
 576            s->multirate_inter);
 577     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
 578     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
 579     av_log(s->avctx, AV_LOG_DEBUG,
 580            "source pcm resolution: %i (%i bits/sample)\n",
 581            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
 582     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
 583     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
 584     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
 585     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 586 #endif
 587
 588     /* Primary audio coding header */
 589     s->subframes         = get_bits(&s->gb, 4) + 1;
 590
 591     return dca_parse_audio_coding_header(s, 0);
 592 }
 593
 594
 595 static inline int get_scale(GetBitContext *gb, int level, int value)
 596 {
 597    if (level < 5) {
 598        /* huffman encoded */
 599        value += get_bitalloc(gb, &dca_scalefactor, level);
 600    } else if (level < 8)
 601        value = get_bits(gb, level + 1);
 602    return value;
 603 }
 604
 605 static int dca_subframe_header(DCAContext * s, int base_channel, int block_index)
 606 {
 607     /* Primary audio coding side information */
 608     int j, k;
 609
 610     if (get_bits_left(&s->gb) < 0)
 611         return -1;
 612
 613     if (!base_channel) {
 614         s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
 615         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
 616     }
 617
 618     for (j = base_channel; j < s->prim_channels; j++) {
 619         for (k = 0; k < s->subband_activity[j]; k++)
 620             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
 621     }
 622
 623     /* Get prediction codebook */
 624     for (j = base_channel; j < s->prim_channels; j++) {
 625         for (k = 0; k < s->subband_activity[j]; k++) {
 626             if (s->prediction_mode[j][k] > 0) {
 627                 /* (Prediction coefficient VQ address) */
 628                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
 629             }
 630         }
 631     }
 632
 633     /* Bit allocation index */
 634     for (j = base_channel; j < s->prim_channels; j++) {
 635         for (k = 0; k < s->vq_start_subband[j]; k++) {
 636             if (s->bitalloc_huffman[j] == 6)
 637                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
 638             else if (s->bitalloc_huffman[j] == 5)
 639                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
 640             else if (s->bitalloc_huffman[j] == 7) {
 641                 av_log(s->avctx, AV_LOG_ERROR,
 642                        "Invalid bit allocation index\n");
 643                 return -1;
 644             } else {
 645                 s->bitalloc[j][k] =
 646                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
 647             }
 648
 649             if (s->bitalloc[j][k] > 26) {
 650 //                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
 651 //                          j, k, s->bitalloc[j][k]);
 652                 return -1;
 653             }
 654         }
 655     }
 656
 657     /* Transition mode */
 658     for (j = base_channel; j < s->prim_channels; j++) {
 659         for (k = 0; k < s->subband_activity[j]; k++) {
 660             s->transition_mode[j][k] = 0;
 661             if (s->subsubframes[s->current_subframe] > 1 &&
 662                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
 663                 s->transition_mode[j][k] =
 664                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
 665             }
 666         }
 667     }
 668
 669     if (get_bits_left(&s->gb) < 0)
 670         return -1;
 671
 672     for (j = base_channel; j < s->prim_channels; j++) {
 673         const uint32_t *scale_table;
 674         int scale_sum;
 675
 676         memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
 677
 678         if (s->scalefactor_huffman[j] == 6)
 679             scale_table = scale_factor_quant7;
 680         else
 681             scale_table = scale_factor_quant6;
 682
 683         /* When huffman coded, only the difference is encoded */
 684         scale_sum = 0;
 685
 686         for (k = 0; k < s->subband_activity[j]; k++) {
 687             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
 688                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
 689                 s->scale_factor[j][k][0] = scale_table[scale_sum];
 690             }
 691
 692             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
 693                 /* Get second scale factor */
 694                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
 695                 s->scale_factor[j][k][1] = scale_table[scale_sum];
 696             }
 697         }
 698     }
 699
 700     /* Joint subband scale factor codebook select */
 701     for (j = base_channel; j < s->prim_channels; j++) {
 702         /* Transmitted only if joint subband coding enabled */
 703         if (s->joint_intensity[j] > 0)
 704             s->joint_huff[j] = get_bits(&s->gb, 3);
 705     }
 706
 707     if (get_bits_left(&s->gb) < 0)
 708         return -1;
 709
 710     /* Scale factors for joint subband coding */
 711     for (j = base_channel; j < s->prim_channels; j++) {
 712         int source_channel;
 713
 714         /* Transmitted only if joint subband coding enabled */
 715         if (s->joint_intensity[j] > 0) {
 716             int scale = 0;
 717             source_channel = s->joint_intensity[j] - 1;
 718
 719             /* When huffman coded, only the difference is encoded
 720              * (is this valid as well for joint scales ???) */
 721
 722             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
 723                 scale = get_scale(&s->gb, s->joint_huff[j], 0);
 724                 scale += 64;    /* bias */
 725                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
 726             }
 727
 728             if (!(s->debug_flag & 0x02)) {
 729                 av_log(s->avctx, AV_LOG_DEBUG,
 730                        "Joint stereo coding not supported\n");
 731                 s->debug_flag |= 0x02;
 732             }
 733         }
 734     }
 735
 736     /* Stereo downmix coefficients */
 737     if (!base_channel && s->prim_channels > 2) {
 738         if (s->downmix) {
 739             for (j = base_channel; j < s->prim_channels; j++) {
 740                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
 741                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
 742             }
 743         } else {
 744             int am = s->amode & DCA_CHANNEL_MASK;
 745             for (j = base_channel; j < s->prim_channels; j++) {
 746                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
 747                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
 748             }
 749         }
 750     }
 751
 752     /* Dynamic range coefficient */
 753     if (!base_channel && s->dynrange)
 754         s->dynrange_coef = get_bits(&s->gb, 8);
 755
 756     /* Side information CRC check word */
 757     if (s->crc_present) {
 758         get_bits(&s->gb, 16);
 759     }
 760
 761     /*
 762      * Primary audio data arrays
 763      */
 764
 765     /* VQ encoded high frequency subbands */
 766     for (j = base_channel; j < s->prim_channels; j++)
 767         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 768             /* 1 vector -> 32 samples */
 769             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
 770
 771     /* Low frequency effect data */
 772     if (!base_channel && s->lfe) {
 773         /* LFE samples */
 774         int lfe_samples = 2 * s->lfe * (4 + block_index);
 775         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
 776         float lfe_scale;
 777
 778         for (j = lfe_samples; j < lfe_end_sample; j++) {
 779             /* Signed 8 bits int */
 780             s->lfe_data[j] = get_sbits(&s->gb, 8);
 781         }
 782
 783         /* Scale factor index */
 784         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
 785
 786         /* Quantization step size * scale factor */
 787         lfe_scale = 0.035 * s->lfe_scale_factor;
 788
 789         for (j = lfe_samples; j < lfe_end_sample; j++)
 790             s->lfe_data[j] *= lfe_scale;
 791     }
 792
 793 #ifdef TRACE
 794     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes[s->current_subframe]);
 795     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
 796            s->partial_samples[s->current_subframe]);
 797     for (j = base_channel; j < s->prim_channels; j++) {
 798         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
 799         for (k = 0; k < s->subband_activity[j]; k++)
 800             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
 801         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 802     }
 803     for (j = base_channel; j < s->prim_channels; j++) {
 804         for (k = 0; k < s->subband_activity[j]; k++)
 805                 av_log(s->avctx, AV_LOG_DEBUG,
 806                        "prediction coefs: %f, %f, %f, %f\n",
 807                        (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
 808                        (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
 809                        (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
 810                        (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
 811     }
 812     for (j = base_channel; j < s->prim_channels; j++) {
 813         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
 814         for (k = 0; k < s->vq_start_subband[j]; k++)
 815             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
 816         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 817     }
 818     for (j = base_channel; j < s->prim_channels; j++) {
 819         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
 820         for (k = 0; k < s->subband_activity[j]; k++)
 821             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
 822         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 823     }
 824     for (j = base_channel; j < s->prim_channels; j++) {
 825         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
 826         for (k = 0; k < s->subband_activity[j]; k++) {
 827             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
 828                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
 829             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
 830                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
 831         }
 832         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 833     }
 834     for (j = base_channel; j < s->prim_channels; j++) {
 835         if (s->joint_intensity[j] > 0) {
 836             int source_channel = s->joint_intensity[j] - 1;
 837             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
 838             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
 839                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
 840             av_log(s->avctx, AV_LOG_DEBUG, "\n");
 841         }
 842     }
 843     if (!base_channel && s->prim_channels > 2 && s->downmix) {
 844         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
 845         for (j = 0; j < s->prim_channels; j++) {
 846             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
 847             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
 848         }
 849         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 850     }
 851     for (j = base_channel; j < s->prim_channels; j++)
 852         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 853             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
 854     if (!base_channel && s->lfe) {
 855         int lfe_samples = 2 * s->lfe * (4 + block_index);
 856         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
 857
 858         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
 859         for (j = lfe_samples; j < lfe_end_sample; j++)
 860             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
 861         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 862     }
 863 #endif
 864
 865     return 0;
 866 }
 867
 868 static void qmf_32_subbands(DCAContext * s, int chans,
 869                             float samples_in[32][8], float *samples_out,
 870                             float scale, float bias)
 871 {
 872     const float *prCoeff;
 873     int i;
 874
 875     int sb_act = s->subband_activity[chans];
 876     int subindex;
 877
 878     scale *= sqrt(1/8.0);
 879
 880     /* Select filter */
 881     if (!s->multirate_inter)    /* Non-perfect reconstruction */
 882         prCoeff = fir_32bands_nonperfect;
 883     else                        /* Perfect reconstruction */
 884         prCoeff = fir_32bands_perfect;
 885
 886     /* Reconstructed channel sample index */
 887     for (subindex = 0; subindex < 8; subindex++) {
 888         /* Load in one sample from each subband and clear inactive subbands */
 889         for (i = 0; i < sb_act; i++){
 890             uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
 891             AV_WN32A(&s->raXin[i], v);
 892         }
 893         for (; i < 32; i++)
 894             s->raXin[i] = 0.0;
 895
 896         s->synth.synth_filter_float(&s->imdct,
 897                               s->subband_fir_hist[chans], &s->hist_index[chans],
 898                               s->subband_fir_noidea[chans], prCoeff,
 899                               samples_out, s->raXin, scale, bias);
 900         samples_out+= 32;
 901
 902     }
 903 }
 904
 905 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
 906                                   int num_deci_sample, float *samples_in,
 907                                   float *samples_out, float scale,
 908                                   float bias)
 909 {
 910     /* samples_in: An array holding decimated samples.
 911      *   Samples in current subframe starts from samples_in[0],
 912      *   while samples_in[-1], samples_in[-2], ..., stores samples
 913      *   from last subframe as history.
 914      *
 915      * samples_out: An array holding interpolated samples
 916      */
 917
 918     int decifactor;
 919     const float *prCoeff;
 920     int deciindex;
 921
 922     /* Select decimation filter */
 923     if (decimation_select == 1) {
 924         decifactor = 64;
 925         prCoeff = lfe_fir_128;
 926     } else {
 927         decifactor = 32;
 928         prCoeff = lfe_fir_64;
 929     }
 930     /* Interpolation */
 931     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
 932         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
 933                           scale, bias);
 934         samples_in++;
 935         samples_out += 2 * decifactor;
 936     }
 937 }
 938
 939 /* downmixing routines */
 940 #define MIX_REAR1(samples, si1, rs, coef) \
 941      samples[i]     += (samples[si1] - add_bias) * coef[rs][0];  \
 942      samples[i+256] += (samples[si1] - add_bias) * coef[rs][1];
 943
 944 #define MIX_REAR2(samples, si1, si2, rs, coef) \
 945      samples[i]     += (samples[si1] - add_bias) * coef[rs][0] + (samples[si2] - add_bias) * coef[rs+1][0]; \
 946      samples[i+256] += (samples[si1] - add_bias) * coef[rs][1] + (samples[si2] - add_bias) * coef[rs+1][1];
 947
 948 #define MIX_FRONT3(samples, coef) \
 949     t = samples[i+c] - add_bias; \
 950     u = samples[i+l] - add_bias; \
 951     v = samples[i+r] - add_bias; \
 952     samples[i]     = t * coef[0][0] + u * coef[1][0] + v * coef[2][0] + add_bias; \
 953     samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1] + add_bias;
 954
 955 #define DOWNMIX_TO_STEREO(op1, op2) \
 956     for (i = 0; i < 256; i++){ \
 957         op1 \
 958         op2 \
 959     }
 960
 961 static void dca_downmix(float *samples, int srcfmt,
 962                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
 963                         const int8_t *channel_mapping, float add_bias)
 964 {
 965     int c,l,r,sl,sr,s;
 966     int i;
 967     float t, u, v;
 968     float coef[DCA_PRIM_CHANNELS_MAX][2];
 969
 970     for (i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
 971         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
 972         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
 973     }
 974
 975     switch (srcfmt) {
 976     case DCA_MONO:
 977     case DCA_CHANNEL:
 978     case DCA_STEREO_TOTAL:
 979     case DCA_STEREO_SUMDIFF:
 980     case DCA_4F2R:
 981         av_log(NULL, 0, "Not implemented!\n");
 982         break;
 983     case DCA_STEREO:
 984         break;
 985     case DCA_3F:
 986         c = channel_mapping[0] * 256;
 987         l = channel_mapping[1] * 256;
 988         r = channel_mapping[2] * 256;
 989         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
 990         break;
 991     case DCA_2F1R:
 992         s = channel_mapping[2] * 256;
 993         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef),);
 994         break;
 995     case DCA_3F1R:
 996         c = channel_mapping[0] * 256;
 997         l = channel_mapping[1] * 256;
 998         r = channel_mapping[2] * 256;
 999         s = channel_mapping[3] * 256;
1000         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1001                           MIX_REAR1(samples, i + s, 3, coef));
1002         break;
1003     case DCA_2F2R:
1004         sl = channel_mapping[2] * 256;
1005         sr = channel_mapping[3] * 256;
1006         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef),);
1007         break;
1008     case DCA_3F2R:
1009         c =  channel_mapping[0] * 256;
1010         l =  channel_mapping[1] * 256;
1011         r =  channel_mapping[2] * 256;
1012         sl = channel_mapping[3] * 256;
1013         sr = channel_mapping[4] * 256;
1014         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1015                           MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1016         break;
1017     }
1018 }
1019
1020
1021 /* Very compact version of the block code decoder that does not use table
1022  * look-up but is slightly slower */
1023 static int decode_blockcode(int code, int levels, int *values)
1024 {
1025     int i;
1026     int offset = (levels - 1) >> 1;
1027
1028     for (i = 0; i < 4; i++) {
1029         int div = FASTDIV(code, levels);
1030         values[i] = code - offset - div*levels;
1031         code = div;
1032     }
1033
1034     if (code == 0)
1035         return 0;
1036     else {
1037         av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
1038         return -1;
1039     }
1040 }
1041
1042 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1043 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1044
1045 static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
1046 {
1047     int k, l;
1048     int subsubframe = s->current_subsubframe;
1049
1050     const float *quant_step_table;
1051
1052     /* FIXME */
1053     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1054     LOCAL_ALIGNED_16(int, block, [8]);
1055
1056     /*
1057      * Audio data
1058      */
1059
1060     /* Select quantization step size table */
1061     if (s->bit_rate_index == 0x1f)
1062         quant_step_table = lossless_quant_d;
1063     else
1064         quant_step_table = lossy_quant_d;
1065
1066     for (k = base_channel; k < s->prim_channels; k++) {
1067         if (get_bits_left(&s->gb) < 0)
1068             return -1;
1069
1070         for (l = 0; l < s->vq_start_subband[k]; l++) {
1071             int m;
1072
1073             /* Select the mid-tread linear quantizer */
1074             int abits = s->bitalloc[k][l];
1075
1076             float quant_step_size = quant_step_table[abits];
1077
1078             /*
1079              * Determine quantization index code book and its type
1080              */
1081
1082             /* Select quantization index code book */
1083             int sel = s->quant_index_huffman[k][abits];
1084
1085             /*
1086              * Extract bits from the bit stream
1087              */
1088             if (!abits){
1089                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1090             } else {
1091                 /* Deal with transients */
1092                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1093                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
1094
1095                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
1096                     if (abits <= 7){
1097                         /* Block code */
1098                         int block_code1, block_code2, size, levels;
1099
1100                         size = abits_sizes[abits-1];
1101                         levels = abits_levels[abits-1];
1102
1103                         block_code1 = get_bits(&s->gb, size);
1104                         /* FIXME Should test return value */
1105                         decode_blockcode(block_code1, levels, block);
1106                         block_code2 = get_bits(&s->gb, size);
1107                         decode_blockcode(block_code2, levels, &block[4]);
1108                     }else{
1109                         /* no coding */
1110                         for (m = 0; m < 8; m++)
1111                             block[m] = get_sbits(&s->gb, abits - 3);
1112                     }
1113                 }else{
1114                     /* Huffman coded */
1115                     for (m = 0; m < 8; m++)
1116                         block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1117                 }
1118
1119                 s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
1120                                                   block, rscale, 8);
1121             }
1122
1123             /*
1124              * Inverse ADPCM if in prediction mode
1125              */
1126             if (s->prediction_mode[k][l]) {
1127                 int n;
1128                 for (m = 0; m < 8; m++) {
1129                     for (n = 1; n <= 4; n++)
1130                         if (m >= n)
1131                             subband_samples[k][l][m] +=
1132                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1133                                  subband_samples[k][l][m - n] / 8192);
1134                         else if (s->predictor_history)
1135                             subband_samples[k][l][m] +=
1136                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1137                                  s->subband_samples_hist[k][l][m - n +
1138                                                                4] / 8192);
1139                 }
1140             }
1141         }
1142
1143         /*
1144          * Decode VQ encoded high frequencies
1145          */
1146         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1147             /* 1 vector -> 32 samples but we only need the 8 samples
1148              * for this subsubframe. */
1149             int m;
1150
1151             if (!s->debug_flag & 0x01) {
1152                 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1153                 s->debug_flag |= 0x01;
1154             }
1155
1156             for (m = 0; m < 8; m++) {
1157                 subband_samples[k][l][m] =
1158                     high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1159                                                         m]
1160                     * (float) s->scale_factor[k][l][0] / 16.0;
1161             }
1162         }
1163     }
1164
1165     /* Check for DSYNC after subsubframe */
1166     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1167         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1168 #ifdef TRACE
1169             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1170 #endif
1171         } else {
1172             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1173         }
1174     }
1175
1176     /* Backup predictor history for adpcm */
1177     for (k = base_channel; k < s->prim_channels; k++)
1178         for (l = 0; l < s->vq_start_subband[k]; l++)
1179             memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1180                         4 * sizeof(subband_samples[0][0][0]));
1181
1182     return 0;
1183 }
1184
1185 static int dca_filter_channels(DCAContext * s, int block_index)
1186 {
1187     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1188     int k;
1189
1190     /* 32 subbands QMF */
1191     for (k = 0; k < s->prim_channels; k++) {
1192 /*        static float pcm_to_double[8] =
1193             {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1194          qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1195                             M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1196                             s->add_bias );
1197     }
1198
1199     /* Down mixing */
1200     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1201         dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab, s->add_bias);
1202     }
1203
1204     /* Generate LFE samples for this subsubframe FIXME!!! */
1205     if (s->output & DCA_LFE) {
1206         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1207                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1208                               &s->samples[256 * dca_lfe_index[s->amode]],
1209                               (1.0/256.0)*s->scale_bias,  s->add_bias);
1210         /* Outputs 20bits pcm samples */
1211     }
1212
1213     return 0;
1214 }
1215
1216
1217 static int dca_subframe_footer(DCAContext * s, int base_channel)
1218 {
1219     int aux_data_count = 0, i;
1220
1221     /*
1222      * Unpack optional information
1223      */
1224
1225     /* presumably optional information only appears in the core? */
1226     if (!base_channel) {
1227         if (s->timestamp)
1228             get_bits(&s->gb, 32);
1229
1230         if (s->aux_data)
1231             aux_data_count = get_bits(&s->gb, 6);
1232
1233         for (i = 0; i < aux_data_count; i++)
1234             get_bits(&s->gb, 8);
1235
1236         if (s->crc_present && (s->downmix || s->dynrange))
1237             get_bits(&s->gb, 16);
1238     }
1239
1240     return 0;
1241 }
1242
1243 /**
1244  * Decode a dca frame block
1245  *
1246  * @param s     pointer to the DCAContext
1247  */
1248
1249 static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1250 {
1251
1252     /* Sanity check */
1253     if (s->current_subframe >= s->subframes) {
1254         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1255                s->current_subframe, s->subframes);
1256         return -1;
1257     }
1258
1259     if (!s->current_subsubframe) {
1260 #ifdef TRACE
1261         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1262 #endif
1263         /* Read subframe header */
1264         if (dca_subframe_header(s, base_channel, block_index))
1265             return -1;
1266     }
1267
1268     /* Read subsubframe */
1269 #ifdef TRACE
1270     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1271 #endif
1272     if (dca_subsubframe(s, base_channel, block_index))
1273         return -1;
1274
1275     /* Update state */
1276     s->current_subsubframe++;
1277     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1278         s->current_subsubframe = 0;
1279         s->current_subframe++;
1280     }
1281     if (s->current_subframe >= s->subframes) {
1282 #ifdef TRACE
1283         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1284 #endif
1285         /* Read subframe footer */
1286         if (dca_subframe_footer(s, base_channel))
1287             return -1;
1288     }
1289
1290     return 0;
1291 }
1292
1293 /**
1294  * Convert bitstream to one representation based on sync marker
1295  */
1296 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1297                           int max_size)
1298 {
1299     uint32_t mrk;
1300     int i, tmp;
1301     const uint16_t *ssrc = (const uint16_t *) src;
1302     uint16_t *sdst = (uint16_t *) dst;
1303     PutBitContext pb;
1304
1305     if ((unsigned)src_size > (unsigned)max_size) {
1306 //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1307 //        return -1;
1308         src_size = max_size;
1309     }
1310
1311     mrk = AV_RB32(src);
1312     switch (mrk) {
1313     case DCA_MARKER_RAW_BE:
1314         memcpy(dst, src, src_size);
1315         return src_size;
1316     case DCA_MARKER_RAW_LE:
1317         for (i = 0; i < (src_size + 1) >> 1; i++)
1318             *sdst++ = av_bswap16(*ssrc++);
1319         return src_size;
1320     case DCA_MARKER_14B_BE:
1321     case DCA_MARKER_14B_LE:
1322         init_put_bits(&pb, dst, max_size);
1323         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1324             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1325             put_bits(&pb, 14, tmp);
1326         }
1327         flush_put_bits(&pb);
1328         return (put_bits_count(&pb) + 7) >> 3;
1329     default:
1330         return -1;
1331     }
1332 }
1333
1334 /**
1335  * Return the number of channels in an ExSS speaker mask (HD)
1336  */
1337 static int dca_exss_mask2count(int mask)
1338 {
1339     /* count bits that mean speaker pairs twice */
1340     return av_popcount(mask)
1341         + av_popcount(mask & (
1342             DCA_EXSS_CENTER_LEFT_RIGHT
1343           | DCA_EXSS_FRONT_LEFT_RIGHT
1344           | DCA_EXSS_FRONT_HIGH_LEFT_RIGHT
1345           | DCA_EXSS_WIDE_LEFT_RIGHT
1346           | DCA_EXSS_SIDE_LEFT_RIGHT
1347           | DCA_EXSS_SIDE_HIGH_LEFT_RIGHT
1348           | DCA_EXSS_SIDE_REAR_LEFT_RIGHT
1349           | DCA_EXSS_REAR_LEFT_RIGHT
1350           | DCA_EXSS_REAR_HIGH_LEFT_RIGHT
1351           ));
1352 }
1353
1354 /**
1355  * Skip mixing coefficients of a single mix out configuration (HD)
1356  */
1357 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1358 {
1359     for (int i = 0; i < channels; i++) {
1360         int mix_map_mask = get_bits(gb, out_ch);
1361         int num_coeffs = av_popcount(mix_map_mask);
1362         skip_bits_long(gb, num_coeffs * 6);
1363     }
1364 }
1365
1366 /**
1367  * Parse extension substream asset header (HD)
1368  */
1369 static int dca_exss_parse_asset_header(DCAContext *s)
1370 {
1371     int header_pos = get_bits_count(&s->gb);
1372     int header_size;
1373     int channels;
1374     int embedded_stereo = 0;
1375     int embedded_6ch = 0;
1376     int drc_code_present;
1377     int extensions_mask;
1378     int i, j;
1379
1380     if (get_bits_left(&s->gb) < 16)
1381         return -1;
1382
1383     /* We will parse just enough to get to the extensions bitmask with which
1384      * we can set the profile value. */
1385
1386     header_size = get_bits(&s->gb, 9) + 1;
1387     skip_bits(&s->gb, 3); // asset index
1388
1389     if (s->static_fields) {
1390         if (get_bits1(&s->gb))
1391             skip_bits(&s->gb, 4); // asset type descriptor
1392         if (get_bits1(&s->gb))
1393             skip_bits_long(&s->gb, 24); // language descriptor
1394
1395         if (get_bits1(&s->gb)) {
1396             /* How can one fit 1024 bytes of text here if the maximum value
1397              * for the asset header size field above was 512 bytes? */
1398             int text_length = get_bits(&s->gb, 10) + 1;
1399             if (get_bits_left(&s->gb) < text_length * 8)
1400                 return -1;
1401             skip_bits_long(&s->gb, text_length * 8); // info text
1402         }
1403
1404         skip_bits(&s->gb, 5); // bit resolution - 1
1405         skip_bits(&s->gb, 4); // max sample rate code
1406         channels = get_bits(&s->gb, 8) + 1;
1407
1408         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1409             int spkr_remap_sets;
1410             int spkr_mask_size = 16;
1411             int num_spkrs[7];
1412
1413             if (channels > 2)
1414                 embedded_stereo = get_bits1(&s->gb);
1415             if (channels > 6)
1416                 embedded_6ch = get_bits1(&s->gb);
1417
1418             if (get_bits1(&s->gb)) {
1419                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1420                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1421             }
1422
1423             spkr_remap_sets = get_bits(&s->gb, 3);
1424
1425             for (i = 0; i < spkr_remap_sets; i++) {
1426                 /* std layout mask for each remap set */
1427                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1428             }
1429
1430             for (i = 0; i < spkr_remap_sets; i++) {
1431                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1432                 if (get_bits_left(&s->gb) < 0)
1433                     return -1;
1434
1435                 for (j = 0; j < num_spkrs[i]; j++) {
1436                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1437                     int num_dec_ch = av_popcount(remap_dec_ch_mask);
1438                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1439                 }
1440             }
1441
1442         } else {
1443             skip_bits(&s->gb, 3); // representation type
1444         }
1445     }
1446
1447     drc_code_present = get_bits1(&s->gb);
1448     if (drc_code_present)
1449         get_bits(&s->gb, 8); // drc code
1450
1451     if (get_bits1(&s->gb))
1452         skip_bits(&s->gb, 5); // dialog normalization code
1453
1454     if (drc_code_present && embedded_stereo)
1455         get_bits(&s->gb, 8); // drc stereo code
1456
1457     if (s->mix_metadata && get_bits1(&s->gb)) {
1458         skip_bits(&s->gb, 1); // external mix
1459         skip_bits(&s->gb, 6); // post mix gain code
1460
1461         if (get_bits(&s->gb, 2) != 3) // mixer drc code
1462             skip_bits(&s->gb, 3); // drc limit
1463         else
1464             skip_bits(&s->gb, 8); // custom drc code
1465
1466         if (get_bits1(&s->gb)) // channel specific scaling
1467             for (i = 0; i < s->num_mix_configs; i++)
1468                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1469         else
1470             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1471
1472         for (i = 0; i < s->num_mix_configs; i++) {
1473             if (get_bits_left(&s->gb) < 0)
1474                 return -1;
1475             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1476             if (embedded_6ch)
1477                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1478             if (embedded_stereo)
1479                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1480         }
1481     }
1482
1483     switch (get_bits(&s->gb, 2)) {
1484     case 0: extensions_mask = get_bits(&s->gb, 12); break;
1485     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
1486     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
1487     case 3: extensions_mask = 0; /* aux coding */   break;
1488     }
1489
1490     /* not parsed further, we were only interested in the extensions mask */
1491
1492     if (get_bits_left(&s->gb) < 0)
1493         return -1;
1494
1495     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1496         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1497         return -1;
1498     }
1499     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1500
1501     if (extensions_mask & DCA_EXT_EXSS_XLL)
1502         s->profile = FF_PROFILE_DTS_HD_MA;
1503     else if (extensions_mask & DCA_EXT_EXSS_XBR)
1504         s->profile = FF_PROFILE_DTS_HD_HRA;
1505     else if (extensions_mask & DCA_EXT_EXSS_X96)
1506         s->profile = FF_PROFILE_DTS_96_24;
1507     else if (extensions_mask & DCA_EXT_EXSS_XXCH)
1508         s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1509
1510     if (!(extensions_mask & DCA_EXT_CORE))
1511         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1512     if (!!(extensions_mask & DCA_EXT_XCH) != s->xch_present)
1513         av_log(s->avctx, AV_LOG_WARNING, "DTS XCh detection mismatch.\n");
1514     if (!!(extensions_mask & DCA_EXT_XXCH) != s->xxch_present)
1515         av_log(s->avctx, AV_LOG_WARNING, "DTS XXCh detection mismatch.\n");
1516     if (!!(extensions_mask & DCA_EXT_X96) != s->x96_present)
1517         av_log(s->avctx, AV_LOG_WARNING, "DTS X96 detection mismatch.\n");
1518
1519     return 0;
1520 }
1521
1522 /**
1523  * Parse extension substream header (HD)
1524  */
1525 static void dca_exss_parse_header(DCAContext *s)
1526 {
1527     int ss_index;
1528     int blownup;
1529     int header_size;
1530     int hd_size;
1531     int num_audiop = 1;
1532     int num_assets = 1;
1533     int active_ss_mask[8];
1534     int i, j;
1535
1536     if (get_bits_left(&s->gb) < 52)
1537         return;
1538
1539     skip_bits(&s->gb, 8); // user data
1540     ss_index = get_bits(&s->gb, 2);
1541
1542     blownup = get_bits1(&s->gb);
1543     header_size = get_bits(&s->gb, 8 + 4 * blownup) + 1;
1544     hd_size = get_bits_long(&s->gb, 16 + 4 * blownup) + 1;
1545
1546     s->static_fields = get_bits1(&s->gb);
1547     if (s->static_fields) {
1548         skip_bits(&s->gb, 2); // reference clock code
1549         skip_bits(&s->gb, 3); // frame duration code
1550
1551         if (get_bits1(&s->gb))
1552             skip_bits_long(&s->gb, 36); // timestamp
1553
1554         /* a single stream can contain multiple audio assets that can be
1555          * combined to form multiple audio presentations */
1556
1557         num_audiop = get_bits(&s->gb, 3) + 1;
1558         if (num_audiop > 1) {
1559             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1560             /* ignore such streams for now */
1561             return;
1562         }
1563
1564         num_assets = get_bits(&s->gb, 3) + 1;
1565         if (num_assets > 1) {
1566             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1567             /* ignore such streams for now */
1568             return;
1569         }
1570
1571         for (i = 0; i < num_audiop; i++)
1572             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1573
1574         for (i = 0; i < num_audiop; i++)
1575             for (j = 0; j <= ss_index; j++)
1576                 if (active_ss_mask[i] & (1 << j))
1577                     skip_bits(&s->gb, 8); // active asset mask
1578
1579         s->mix_metadata = get_bits1(&s->gb);
1580         if (s->mix_metadata) {
1581             int mix_out_mask_size;
1582
1583             skip_bits(&s->gb, 2); // adjustment level
1584             mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1585             s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1586
1587             for (i = 0; i < s->num_mix_configs; i++) {
1588                 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1589                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1590             }
1591         }
1592     }
1593
1594     for (i = 0; i < num_assets; i++)
1595         skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1596
1597     for (i = 0; i < num_assets; i++) {
1598         if (dca_exss_parse_asset_header(s))
1599             return;
1600     }
1601
1602     /* not parsed further, we were only interested in the extensions mask
1603      * from the asset header */
1604 }
1605
1606 /**
1607  * Main frame decoding function
1608  * FIXME add arguments
1609  */
1610 static int dca_decode_frame(AVCodecContext * avctx,
1611                             void *data, int *data_size,
1612                             AVPacket *avpkt)
1613 {
1614     const uint8_t *buf = avpkt->data;
1615     int buf_size = avpkt->size;
1616
1617     int lfe_samples;
1618     int num_core_channels = 0;
1619     int i;
1620     int16_t *samples = data;
1621     DCAContext *s = avctx->priv_data;
1622     int channels;
1623     int core_ss_end;
1624
1625
1626     s->xch_present = 0;
1627     s->x96_present = 0;
1628     s->xxch_present = 0;
1629
1630     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1631                                                DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1632     if (s->dca_buffer_size == -1) {
1633         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1634         return -1;
1635     }
1636
1637     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1638     if (dca_parse_frame_header(s) < 0) {
1639         //seems like the frame is corrupt, try with the next one
1640         *data_size=0;
1641         return buf_size;
1642     }
1643     //set AVCodec values with parsed data
1644     avctx->sample_rate = s->sample_rate;
1645     avctx->bit_rate = s->bit_rate;
1646
1647     s->profile = FF_PROFILE_DTS;
1648
1649     for (i = 0; i < (s->sample_blocks / 8); i++) {
1650         dca_decode_block(s, 0, i);
1651     }
1652
1653     /* record number of core channels incase less than max channels are requested */
1654     num_core_channels = s->prim_channels;
1655
1656     /* extensions start at 32-bit boundaries into bitstream */
1657     skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1658
1659     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1660
1661     while(core_ss_end - get_bits_count(&s->gb) >= 32) {
1662         uint32_t bits = get_bits_long(&s->gb, 32);
1663
1664         switch(bits) {
1665         case 0x5a5a5a5a: {
1666             int ext_amode, xch_fsize;
1667
1668             s->xch_base_channel = s->prim_channels;
1669
1670             /* validate sync word using XCHFSIZE field */
1671             xch_fsize = show_bits(&s->gb, 10);
1672             if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1673                (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1674                 continue;
1675
1676             /* skip length-to-end-of-frame field for the moment */
1677             skip_bits(&s->gb, 10);
1678
1679             s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1680
1681             /* extension amode should == 1, number of channels in extension */
1682             /* AFAIK XCh is not used for more channels */
1683             if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1684                 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1685                        " supported!\n",ext_amode);
1686                 continue;
1687             }
1688
1689             /* much like core primary audio coding header */
1690             dca_parse_audio_coding_header(s, s->xch_base_channel);
1691
1692             for (i = 0; i < (s->sample_blocks / 8); i++) {
1693                 dca_decode_block(s, s->xch_base_channel, i);
1694             }
1695
1696             s->xch_present = 1;
1697             break;
1698         }
1699         case 0x47004a03:
1700             /* XXCh: extended channels */
1701             /* usually found either in core or HD part in DTS-HD HRA streams,
1702              * but not in DTS-ES which contains XCh extensions instead */
1703             s->xxch_present = 1;
1704             s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1705             break;
1706
1707         case 0x1d95f262: {
1708             int fsize96 = show_bits(&s->gb, 12) + 1;
1709             if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1710                 continue;
1711
1712             av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n", get_bits_count(&s->gb));
1713             skip_bits(&s->gb, 12);
1714             av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1715             av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1716
1717             s->x96_present = 1;
1718             s->profile = FFMAX(s->profile, FF_PROFILE_DTS_96_24);
1719             break;
1720         }
1721         }
1722
1723         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1724     }
1725
1726     /* check for ExSS (HD part) */
1727     if (s->dca_buffer_size - s->frame_size > 32
1728         && get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1729         dca_exss_parse_header(s);
1730
1731     avctx->profile = s->profile;
1732
1733     channels = s->prim_channels + !!s->lfe;
1734
1735     if (s->amode<16) {
1736         avctx->channel_layout = dca_core_channel_layout[s->amode];
1737
1738         if (s->xch_present && (!avctx->request_channels ||
1739                                avctx->request_channels > num_core_channels + !!s->lfe)) {
1740             avctx->channel_layout |= AV_CH_BACK_CENTER;
1741             if (s->lfe) {
1742                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1743                 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1744             } else {
1745                 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1746             }
1747         } else {
1748             channels = num_core_channels + !!s->lfe;
1749             s->xch_present = 0; /* disable further xch processing */
1750             if (s->lfe) {
1751                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1752                 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1753             } else
1754                 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1755         }
1756
1757         if (channels > !!s->lfe &&
1758             s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1759             return -1;
1760
1761         if (avctx->request_channels == 2 && s->prim_channels > 2) {
1762             channels = 2;
1763             s->output = DCA_STEREO;
1764             avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1765         }
1766     } else {
1767         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1768         return -1;
1769     }
1770
1771
1772     /* There is nothing that prevents a dts frame to change channel configuration
1773        but FFmpeg doesn't support that so only set the channels if it is previously
1774        unset. Ideally during the first probe for channels the crc should be checked
1775        and only set avctx->channels when the crc is ok. Right now the decoder could
1776        set the channels based on a broken first frame.*/
1777     avctx->channels = channels;
1778
1779     if (*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1780         return -1;
1781     *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1782
1783     /* filter to get final output */
1784     for (i = 0; i < (s->sample_blocks / 8); i++) {
1785         dca_filter_channels(s, i);
1786
1787         /* If this was marked as a DTS-ES stream we need to subtract back- */
1788         /* channel from SL & SR to remove matrixed back-channel signal */
1789         if((s->source_pcm_res & 1) && s->xch_present) {
1790             float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1791             float* lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1792             float* rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1793             int j;
1794             for(j = 0; j < 256; ++j) {
1795                 lt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1796                 rt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1797             }
1798         }
1799
1800         s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1801         samples += 256 * channels;
1802     }
1803
1804     /* update lfe history */
1805     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1806     for (i = 0; i < 2 * s->lfe * 4; i++) {
1807         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1808     }
1809
1810     return buf_size;
1811 }
1812
1813
1814
1815 /**
1816  * DCA initialization
1817  *
1818  * @param avctx     pointer to the AVCodecContext
1819  */
1820
1821 static av_cold int dca_decode_init(AVCodecContext * avctx)
1822 {
1823     DCAContext *s = avctx->priv_data;
1824     int i;
1825
1826     s->avctx = avctx;
1827     dca_init_vlcs();
1828
1829     dsputil_init(&s->dsp, avctx);
1830     ff_mdct_init(&s->imdct, 6, 1, 1.0);
1831     ff_synth_filter_init(&s->synth);
1832     ff_dcadsp_init(&s->dcadsp);
1833
1834     for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
1835         s->samples_chanptr[i] = s->samples + i * 256;
1836     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1837
1838     if (s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1839         s->add_bias = 385.0f;
1840         s->scale_bias = 1.0 / 32768.0;
1841     } else {
1842         s->add_bias = 0.0f;
1843         s->scale_bias = 1.0;
1844
1845         /* allow downmixing to stereo */
1846         if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1847                 avctx->request_channels == 2) {
1848             avctx->channels = avctx->request_channels;
1849         }
1850     }
1851
1852
1853     return 0;
1854 }
1855
1856 static av_cold int dca_decode_end(AVCodecContext * avctx)
1857 {
1858     DCAContext *s = avctx->priv_data;
1859     ff_mdct_end(&s->imdct);
1860     return 0;
1861 }
1862
1863 AVCodec dca_decoder = {
1864     .name = "dca",
1865     .type = AVMEDIA_TYPE_AUDIO,
1866     .id = CODEC_ID_DTS,
1867     .priv_data_size = sizeof(DCAContext),
1868     .init = dca_decode_init,
1869     .decode = dca_decode_frame,
1870     .close = dca_decode_end,
1871     .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1872     .capabilities = CODEC_CAP_CHANNEL_CONF,
1873 };