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 is_channels_set;        ///< check for if the channel number is already set
 277     int total_channels;         ///< number of channels including extensions
 278     int prim_channels;          ///< number of primary audio channels
 279     int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
 280     int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
 281     int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
 282     int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
 283     int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
 284     int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
 285     int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
 286     float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
 287
 288     /* Primary audio coding side information */
 289     int subsubframes[DCA_SUBFRAMES_MAX];           ///< number of subsubframes
 290     int partial_samples[DCA_SUBFRAMES_MAX];        ///< partial subsubframe samples count
 291     int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
 292     int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
 293     int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
 294     int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
 295     int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
 296     int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
 297     int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
 298     int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
 299     int dynrange_coef;                                           ///< dynamic range coefficient
 300
 301     int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
 302
 303     float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      ///< Low frequency effect data
 304     int lfe_scale_factor;
 305
 306     /* Subband samples history (for ADPCM) */
 307     float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
 308     DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
 309     DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
 310     int hist_index[DCA_PRIM_CHANNELS_MAX];
 311     DECLARE_ALIGNED(16, float, raXin)[32];
 312
 313     int output;                 ///< type of output
 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)
 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, 0);
 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 {
 909     /* samples_in: An array holding decimated samples.
 910      *   Samples in current subframe starts from samples_in[0],
 911      *   while samples_in[-1], samples_in[-2], ..., stores samples
 912      *   from last subframe as history.
 913      *
 914      * samples_out: An array holding interpolated samples
 915      */
 916
 917     int decifactor;
 918     const float *prCoeff;
 919     int deciindex;
 920
 921     /* Select decimation filter */
 922     if (decimation_select == 1) {
 923         decifactor = 64;
 924         prCoeff = lfe_fir_128;
 925     } else {
 926         decifactor = 32;
 927         prCoeff = lfe_fir_64;
 928     }
 929     /* Interpolation */
 930     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
 931         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
 932                           scale, 0);
 933         samples_in++;
 934         samples_out += 2 * decifactor;
 935     }
 936 }
 937
 938 /* downmixing routines */
 939 #define MIX_REAR1(samples, si1, rs, coef) \
 940      samples[i]     += samples[si1] * coef[rs][0];  \
 941      samples[i+256] += samples[si1] * coef[rs][1];
 942
 943 #define MIX_REAR2(samples, si1, si2, rs, coef) \
 944      samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
 945      samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
 946
 947 #define MIX_FRONT3(samples, coef) \
 948     t = samples[i+c]; \
 949     u = samples[i+l]; \
 950     v = samples[i+r]; \
 951     samples[i]     = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
 952     samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
 953
 954 #define DOWNMIX_TO_STEREO(op1, op2) \
 955     for (i = 0; i < 256; i++){ \
 956         op1 \
 957         op2 \
 958     }
 959
 960 static void dca_downmix(float *samples, int srcfmt,
 961                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
 962                         const int8_t *channel_mapping)
 963 {
 964     int c,l,r,sl,sr,s;
 965     int i;
 966     float t, u, v;
 967     float coef[DCA_PRIM_CHANNELS_MAX][2];
 968
 969     for (i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
 970         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
 971         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
 972     }
 973
 974     switch (srcfmt) {
 975     case DCA_MONO:
 976     case DCA_CHANNEL:
 977     case DCA_STEREO_TOTAL:
 978     case DCA_STEREO_SUMDIFF:
 979     case DCA_4F2R:
 980         av_log(NULL, 0, "Not implemented!\n");
 981         break;
 982     case DCA_STEREO:
 983         break;
 984     case DCA_3F:
 985         c = channel_mapping[0] * 256;
 986         l = channel_mapping[1] * 256;
 987         r = channel_mapping[2] * 256;
 988         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
 989         break;
 990     case DCA_2F1R:
 991         s = channel_mapping[2] * 256;
 992         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef),);
 993         break;
 994     case DCA_3F1R:
 995         c = channel_mapping[0] * 256;
 996         l = channel_mapping[1] * 256;
 997         r = channel_mapping[2] * 256;
 998         s = channel_mapping[3] * 256;
 999         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1000                           MIX_REAR1(samples, i + s, 3, coef));
1001         break;
1002     case DCA_2F2R:
1003         sl = channel_mapping[2] * 256;
1004         sr = channel_mapping[3] * 256;
1005         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef),);
1006         break;
1007     case DCA_3F2R:
1008         c =  channel_mapping[0] * 256;
1009         l =  channel_mapping[1] * 256;
1010         r =  channel_mapping[2] * 256;
1011         sl = channel_mapping[3] * 256;
1012         sr = channel_mapping[4] * 256;
1013         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1014                           MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1015         break;
1016     }
1017 }
1018
1019
1020 /* Very compact version of the block code decoder that does not use table
1021  * look-up but is slightly slower */
1022 static int decode_blockcode(int code, int levels, int *values)
1023 {
1024     int i;
1025     int offset = (levels - 1) >> 1;
1026
1027     for (i = 0; i < 4; i++) {
1028         int div = FASTDIV(code, levels);
1029         values[i] = code - offset - div*levels;
1030         code = div;
1031     }
1032
1033     if (code == 0)
1034         return 0;
1035     else {
1036         av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
1037         return -1;
1038     }
1039 }
1040
1041 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1042 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1043
1044 static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
1045 {
1046     int k, l;
1047     int subsubframe = s->current_subsubframe;
1048
1049     const float *quant_step_table;
1050
1051     /* FIXME */
1052     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1053     LOCAL_ALIGNED_16(int, block, [8]);
1054
1055     /*
1056      * Audio data
1057      */
1058
1059     /* Select quantization step size table */
1060     if (s->bit_rate_index == 0x1f)
1061         quant_step_table = lossless_quant_d;
1062     else
1063         quant_step_table = lossy_quant_d;
1064
1065     for (k = base_channel; k < s->prim_channels; k++) {
1066         if (get_bits_left(&s->gb) < 0)
1067             return -1;
1068
1069         for (l = 0; l < s->vq_start_subband[k]; l++) {
1070             int m;
1071
1072             /* Select the mid-tread linear quantizer */
1073             int abits = s->bitalloc[k][l];
1074
1075             float quant_step_size = quant_step_table[abits];
1076
1077             /*
1078              * Determine quantization index code book and its type
1079              */
1080
1081             /* Select quantization index code book */
1082             int sel = s->quant_index_huffman[k][abits];
1083
1084             /*
1085              * Extract bits from the bit stream
1086              */
1087             if (!abits){
1088                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1089             } else {
1090                 /* Deal with transients */
1091                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1092                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
1093
1094                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
1095                     if (abits <= 7){
1096                         /* Block code */
1097                         int block_code1, block_code2, size, levels;
1098
1099                         size = abits_sizes[abits-1];
1100                         levels = abits_levels[abits-1];
1101
1102                         block_code1 = get_bits(&s->gb, size);
1103                         /* FIXME Should test return value */
1104                         decode_blockcode(block_code1, levels, block);
1105                         block_code2 = get_bits(&s->gb, size);
1106                         decode_blockcode(block_code2, levels, &block[4]);
1107                     }else{
1108                         /* no coding */
1109                         for (m = 0; m < 8; m++)
1110                             block[m] = get_sbits(&s->gb, abits - 3);
1111                     }
1112                 }else{
1113                     /* Huffman coded */
1114                     for (m = 0; m < 8; m++)
1115                         block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1116                 }
1117
1118                 s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
1119                                                   block, rscale, 8);
1120             }
1121
1122             /*
1123              * Inverse ADPCM if in prediction mode
1124              */
1125             if (s->prediction_mode[k][l]) {
1126                 int n;
1127                 for (m = 0; m < 8; m++) {
1128                     for (n = 1; n <= 4; n++)
1129                         if (m >= n)
1130                             subband_samples[k][l][m] +=
1131                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1132                                  subband_samples[k][l][m - n] / 8192);
1133                         else if (s->predictor_history)
1134                             subband_samples[k][l][m] +=
1135                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1136                                  s->subband_samples_hist[k][l][m - n +
1137                                                                4] / 8192);
1138                 }
1139             }
1140         }
1141
1142         /*
1143          * Decode VQ encoded high frequencies
1144          */
1145         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1146             /* 1 vector -> 32 samples but we only need the 8 samples
1147              * for this subsubframe. */
1148             int m;
1149
1150             if (!s->debug_flag & 0x01) {
1151                 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1152                 s->debug_flag |= 0x01;
1153             }
1154
1155             for (m = 0; m < 8; m++) {
1156                 subband_samples[k][l][m] =
1157                     high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1158                                                         m]
1159                     * (float) s->scale_factor[k][l][0] / 16.0;
1160             }
1161         }
1162     }
1163
1164     /* Check for DSYNC after subsubframe */
1165     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1166         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1167 #ifdef TRACE
1168             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1169 #endif
1170         } else {
1171             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1172         }
1173     }
1174
1175     /* Backup predictor history for adpcm */
1176     for (k = base_channel; k < s->prim_channels; k++)
1177         for (l = 0; l < s->vq_start_subband[k]; l++)
1178             memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1179                         4 * sizeof(subband_samples[0][0][0]));
1180
1181     return 0;
1182 }
1183
1184 static int dca_filter_channels(DCAContext * s, int block_index)
1185 {
1186     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1187     int k;
1188
1189     /* 32 subbands QMF */
1190     for (k = 0; k < s->prim_channels; k++) {
1191 /*        static float pcm_to_double[8] =
1192             {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1193          qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1194                          M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ );
1195     }
1196
1197     /* Down mixing */
1198     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1199         dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
1200     }
1201
1202     /* Generate LFE samples for this subsubframe FIXME!!! */
1203     if (s->output & DCA_LFE) {
1204         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1205                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1206                               &s->samples[256 * dca_lfe_index[s->amode]],
1207                               (1.0/256.0)*s->scale_bias);
1208         /* Outputs 20bits pcm samples */
1209     }
1210
1211     return 0;
1212 }
1213
1214
1215 static int dca_subframe_footer(DCAContext * s, int base_channel)
1216 {
1217     int aux_data_count = 0, i;
1218
1219     /*
1220      * Unpack optional information
1221      */
1222
1223     /* presumably optional information only appears in the core? */
1224     if (!base_channel) {
1225         if (s->timestamp)
1226             get_bits(&s->gb, 32);
1227
1228         if (s->aux_data)
1229             aux_data_count = get_bits(&s->gb, 6);
1230
1231         for (i = 0; i < aux_data_count; i++)
1232             get_bits(&s->gb, 8);
1233
1234         if (s->crc_present && (s->downmix || s->dynrange))
1235             get_bits(&s->gb, 16);
1236     }
1237
1238     return 0;
1239 }
1240
1241 /**
1242  * Decode a dca frame block
1243  *
1244  * @param s     pointer to the DCAContext
1245  */
1246
1247 static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1248 {
1249
1250     /* Sanity check */
1251     if (s->current_subframe >= s->subframes) {
1252         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1253                s->current_subframe, s->subframes);
1254         return -1;
1255     }
1256
1257     if (!s->current_subsubframe) {
1258 #ifdef TRACE
1259         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1260 #endif
1261         /* Read subframe header */
1262         if (dca_subframe_header(s, base_channel, block_index))
1263             return -1;
1264     }
1265
1266     /* Read subsubframe */
1267 #ifdef TRACE
1268     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1269 #endif
1270     if (dca_subsubframe(s, base_channel, block_index))
1271         return -1;
1272
1273     /* Update state */
1274     s->current_subsubframe++;
1275     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1276         s->current_subsubframe = 0;
1277         s->current_subframe++;
1278     }
1279     if (s->current_subframe >= s->subframes) {
1280 #ifdef TRACE
1281         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1282 #endif
1283         /* Read subframe footer */
1284         if (dca_subframe_footer(s, base_channel))
1285             return -1;
1286     }
1287
1288     return 0;
1289 }
1290
1291 /**
1292  * Convert bitstream to one representation based on sync marker
1293  */
1294 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1295                           int max_size)
1296 {
1297     uint32_t mrk;
1298     int i, tmp;
1299     const uint16_t *ssrc = (const uint16_t *) src;
1300     uint16_t *sdst = (uint16_t *) dst;
1301     PutBitContext pb;
1302
1303     if ((unsigned)src_size > (unsigned)max_size) {
1304 //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1305 //        return -1;
1306         src_size = max_size;
1307     }
1308
1309     mrk = AV_RB32(src);
1310     switch (mrk) {
1311     case DCA_MARKER_RAW_BE:
1312         memcpy(dst, src, src_size);
1313         return src_size;
1314     case DCA_MARKER_RAW_LE:
1315         for (i = 0; i < (src_size + 1) >> 1; i++)
1316             *sdst++ = av_bswap16(*ssrc++);
1317         return src_size;
1318     case DCA_MARKER_14B_BE:
1319     case DCA_MARKER_14B_LE:
1320         init_put_bits(&pb, dst, max_size);
1321         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1322             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1323             put_bits(&pb, 14, tmp);
1324         }
1325         flush_put_bits(&pb);
1326         return (put_bits_count(&pb) + 7) >> 3;
1327     default:
1328         return -1;
1329     }
1330 }
1331
1332 /**
1333  * Return the number of channels in an ExSS speaker mask (HD)
1334  */
1335 static int dca_exss_mask2count(int mask)
1336 {
1337     /* count bits that mean speaker pairs twice */
1338     return av_popcount(mask)
1339         + av_popcount(mask & (
1340             DCA_EXSS_CENTER_LEFT_RIGHT
1341           | DCA_EXSS_FRONT_LEFT_RIGHT
1342           | DCA_EXSS_FRONT_HIGH_LEFT_RIGHT
1343           | DCA_EXSS_WIDE_LEFT_RIGHT
1344           | DCA_EXSS_SIDE_LEFT_RIGHT
1345           | DCA_EXSS_SIDE_HIGH_LEFT_RIGHT
1346           | DCA_EXSS_SIDE_REAR_LEFT_RIGHT
1347           | DCA_EXSS_REAR_LEFT_RIGHT
1348           | DCA_EXSS_REAR_HIGH_LEFT_RIGHT
1349           ));
1350 }
1351
1352 /**
1353  * Skip mixing coefficients of a single mix out configuration (HD)
1354  */
1355 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1356 {
1357     for (int i = 0; i < channels; i++) {
1358         int mix_map_mask = get_bits(gb, out_ch);
1359         int num_coeffs = av_popcount(mix_map_mask);
1360         skip_bits_long(gb, num_coeffs * 6);
1361     }
1362 }
1363
1364 /**
1365  * Parse extension substream asset header (HD)
1366  */
1367 static int dca_exss_parse_asset_header(DCAContext *s)
1368 {
1369     int header_pos = get_bits_count(&s->gb);
1370     int header_size;
1371     int channels;
1372     int embedded_stereo = 0;
1373     int embedded_6ch = 0;
1374     int drc_code_present;
1375     int extensions_mask;
1376     int i, j;
1377
1378     if (get_bits_left(&s->gb) < 16)
1379         return -1;
1380
1381     /* We will parse just enough to get to the extensions bitmask with which
1382      * we can set the profile value. */
1383
1384     header_size = get_bits(&s->gb, 9) + 1;
1385     skip_bits(&s->gb, 3); // asset index
1386
1387     if (s->static_fields) {
1388         if (get_bits1(&s->gb))
1389             skip_bits(&s->gb, 4); // asset type descriptor
1390         if (get_bits1(&s->gb))
1391             skip_bits_long(&s->gb, 24); // language descriptor
1392
1393         if (get_bits1(&s->gb)) {
1394             /* How can one fit 1024 bytes of text here if the maximum value
1395              * for the asset header size field above was 512 bytes? */
1396             int text_length = get_bits(&s->gb, 10) + 1;
1397             if (get_bits_left(&s->gb) < text_length * 8)
1398                 return -1;
1399             skip_bits_long(&s->gb, text_length * 8); // info text
1400         }
1401
1402         skip_bits(&s->gb, 5); // bit resolution - 1
1403         skip_bits(&s->gb, 4); // max sample rate code
1404         channels = get_bits(&s->gb, 8) + 1;
1405
1406         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1407             int spkr_remap_sets;
1408             int spkr_mask_size = 16;
1409             int num_spkrs[7];
1410
1411             if (channels > 2)
1412                 embedded_stereo = get_bits1(&s->gb);
1413             if (channels > 6)
1414                 embedded_6ch = get_bits1(&s->gb);
1415
1416             if (get_bits1(&s->gb)) {
1417                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1418                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1419             }
1420
1421             spkr_remap_sets = get_bits(&s->gb, 3);
1422
1423             for (i = 0; i < spkr_remap_sets; i++) {
1424                 /* std layout mask for each remap set */
1425                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1426             }
1427
1428             for (i = 0; i < spkr_remap_sets; i++) {
1429                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1430                 if (get_bits_left(&s->gb) < 0)
1431                     return -1;
1432
1433                 for (j = 0; j < num_spkrs[i]; j++) {
1434                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1435                     int num_dec_ch = av_popcount(remap_dec_ch_mask);
1436                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1437                 }
1438             }
1439
1440         } else {
1441             skip_bits(&s->gb, 3); // representation type
1442         }
1443     }
1444
1445     drc_code_present = get_bits1(&s->gb);
1446     if (drc_code_present)
1447         get_bits(&s->gb, 8); // drc code
1448
1449     if (get_bits1(&s->gb))
1450         skip_bits(&s->gb, 5); // dialog normalization code
1451
1452     if (drc_code_present && embedded_stereo)
1453         get_bits(&s->gb, 8); // drc stereo code
1454
1455     if (s->mix_metadata && get_bits1(&s->gb)) {
1456         skip_bits(&s->gb, 1); // external mix
1457         skip_bits(&s->gb, 6); // post mix gain code
1458
1459         if (get_bits(&s->gb, 2) != 3) // mixer drc code
1460             skip_bits(&s->gb, 3); // drc limit
1461         else
1462             skip_bits(&s->gb, 8); // custom drc code
1463
1464         if (get_bits1(&s->gb)) // channel specific scaling
1465             for (i = 0; i < s->num_mix_configs; i++)
1466                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1467         else
1468             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1469
1470         for (i = 0; i < s->num_mix_configs; i++) {
1471             if (get_bits_left(&s->gb) < 0)
1472                 return -1;
1473             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1474             if (embedded_6ch)
1475                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1476             if (embedded_stereo)
1477                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1478         }
1479     }
1480
1481     switch (get_bits(&s->gb, 2)) {
1482     case 0: extensions_mask = get_bits(&s->gb, 12); break;
1483     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
1484     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
1485     case 3: extensions_mask = 0; /* aux coding */   break;
1486     }
1487
1488     /* not parsed further, we were only interested in the extensions mask */
1489
1490     if (get_bits_left(&s->gb) < 0)
1491         return -1;
1492
1493     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1494         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1495         return -1;
1496     }
1497     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1498
1499     if (extensions_mask & DCA_EXT_EXSS_XLL)
1500         s->profile = FF_PROFILE_DTS_HD_MA;
1501     else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1502                                 DCA_EXT_EXSS_XXCH))
1503         s->profile = FF_PROFILE_DTS_HD_HRA;
1504
1505     if (!(extensions_mask & DCA_EXT_CORE))
1506         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1507     if (!!(extensions_mask & DCA_EXT_XCH) != s->xch_present)
1508         av_log(s->avctx, AV_LOG_WARNING, "DTS XCh detection mismatch.\n");
1509     if (!!(extensions_mask & DCA_EXT_XXCH) != s->xxch_present)
1510         av_log(s->avctx, AV_LOG_WARNING, "DTS XXCh detection mismatch.\n");
1511     if (!!(extensions_mask & DCA_EXT_X96) != s->x96_present)
1512         av_log(s->avctx, AV_LOG_WARNING, "DTS X96 detection mismatch.\n");
1513
1514     return 0;
1515 }
1516
1517 /**
1518  * Parse extension substream header (HD)
1519  */
1520 static void dca_exss_parse_header(DCAContext *s)
1521 {
1522     int ss_index;
1523     int blownup;
1524     int header_size;
1525     int hd_size;
1526     int num_audiop = 1;
1527     int num_assets = 1;
1528     int active_ss_mask[8];
1529     int i, j;
1530
1531     if (get_bits_left(&s->gb) < 52)
1532         return;
1533
1534     skip_bits(&s->gb, 8); // user data
1535     ss_index = get_bits(&s->gb, 2);
1536
1537     blownup = get_bits1(&s->gb);
1538     header_size = get_bits(&s->gb, 8 + 4 * blownup) + 1;
1539     hd_size = get_bits_long(&s->gb, 16 + 4 * blownup) + 1;
1540
1541     s->static_fields = get_bits1(&s->gb);
1542     if (s->static_fields) {
1543         skip_bits(&s->gb, 2); // reference clock code
1544         skip_bits(&s->gb, 3); // frame duration code
1545
1546         if (get_bits1(&s->gb))
1547             skip_bits_long(&s->gb, 36); // timestamp
1548
1549         /* a single stream can contain multiple audio assets that can be
1550          * combined to form multiple audio presentations */
1551
1552         num_audiop = get_bits(&s->gb, 3) + 1;
1553         if (num_audiop > 1) {
1554             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1555             /* ignore such streams for now */
1556             return;
1557         }
1558
1559         num_assets = get_bits(&s->gb, 3) + 1;
1560         if (num_assets > 1) {
1561             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1562             /* ignore such streams for now */
1563             return;
1564         }
1565
1566         for (i = 0; i < num_audiop; i++)
1567             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1568
1569         for (i = 0; i < num_audiop; i++)
1570             for (j = 0; j <= ss_index; j++)
1571                 if (active_ss_mask[i] & (1 << j))
1572                     skip_bits(&s->gb, 8); // active asset mask
1573
1574         s->mix_metadata = get_bits1(&s->gb);
1575         if (s->mix_metadata) {
1576             int mix_out_mask_size;
1577
1578             skip_bits(&s->gb, 2); // adjustment level
1579             mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1580             s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1581
1582             for (i = 0; i < s->num_mix_configs; i++) {
1583                 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1584                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1585             }
1586         }
1587     }
1588
1589     for (i = 0; i < num_assets; i++)
1590         skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1591
1592     for (i = 0; i < num_assets; i++) {
1593         if (dca_exss_parse_asset_header(s))
1594             return;
1595     }
1596
1597     /* not parsed further, we were only interested in the extensions mask
1598      * from the asset header */
1599 }
1600
1601 /**
1602  * Main frame decoding function
1603  * FIXME add arguments
1604  */
1605 static int dca_decode_frame(AVCodecContext * avctx,
1606                             void *data, int *data_size,
1607                             AVPacket *avpkt)
1608 {
1609     const uint8_t *buf = avpkt->data;
1610     int buf_size = avpkt->size;
1611
1612     int lfe_samples;
1613     int num_core_channels = 0;
1614     int i;
1615     int16_t *samples = data;
1616     DCAContext *s = avctx->priv_data;
1617     int channels;
1618     int core_ss_end;
1619
1620
1621     s->xch_present = 0;
1622     s->x96_present = 0;
1623     s->xxch_present = 0;
1624
1625     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1626                                                DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1627     if (s->dca_buffer_size == -1) {
1628         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1629         return -1;
1630     }
1631
1632     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1633     if (dca_parse_frame_header(s) < 0) {
1634         //seems like the frame is corrupt, try with the next one
1635         *data_size=0;
1636         return buf_size;
1637     }
1638     //set AVCodec values with parsed data
1639     avctx->sample_rate = s->sample_rate;
1640     avctx->bit_rate = s->bit_rate;
1641
1642     s->profile = FF_PROFILE_DTS;
1643
1644     for (i = 0; i < (s->sample_blocks / 8); i++) {
1645         dca_decode_block(s, 0, i);
1646     }
1647
1648     /* record number of core channels incase less than max channels are requested */
1649     num_core_channels = s->prim_channels;
1650
1651     /* extensions start at 32-bit boundaries into bitstream */
1652     skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1653
1654     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1655
1656     while(core_ss_end - get_bits_count(&s->gb) >= 32) {
1657         uint32_t bits = get_bits_long(&s->gb, 32);
1658
1659         switch(bits) {
1660         case 0x5a5a5a5a: {
1661             int ext_amode, xch_fsize;
1662
1663             s->xch_base_channel = s->prim_channels;
1664
1665             /* validate sync word using XCHFSIZE field */
1666             xch_fsize = show_bits(&s->gb, 10);
1667             if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1668                (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1669                 continue;
1670
1671             /* skip length-to-end-of-frame field for the moment */
1672             skip_bits(&s->gb, 10);
1673
1674             s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1675
1676             /* extension amode should == 1, number of channels in extension */
1677             /* AFAIK XCh is not used for more channels */
1678             if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1679                 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1680                        " supported!\n",ext_amode);
1681                 continue;
1682             }
1683
1684             /* much like core primary audio coding header */
1685             dca_parse_audio_coding_header(s, s->xch_base_channel);
1686
1687             for (i = 0; i < (s->sample_blocks / 8); i++) {
1688                 dca_decode_block(s, s->xch_base_channel, i);
1689             }
1690
1691             s->xch_present = 1;
1692             break;
1693         }
1694         case 0x47004a03:
1695             /* XXCh: extended channels */
1696             /* usually found either in core or HD part in DTS-HD HRA streams,
1697              * but not in DTS-ES which contains XCh extensions instead */
1698             s->xxch_present = 1;
1699             s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1700             break;
1701
1702         case 0x1d95f262: {
1703             int fsize96 = show_bits(&s->gb, 12) + 1;
1704             if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1705                 continue;
1706
1707             av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n", get_bits_count(&s->gb));
1708             skip_bits(&s->gb, 12);
1709             av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1710             av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1711
1712             s->x96_present = 1;
1713             s->profile = FFMAX(s->profile, FF_PROFILE_DTS_96_24);
1714             break;
1715         }
1716         }
1717
1718         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1719     }
1720
1721     /* check for ExSS (HD part) */
1722     if (s->dca_buffer_size - s->frame_size > 32
1723         && get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1724         dca_exss_parse_header(s);
1725
1726     avctx->profile = s->profile;
1727
1728     channels = s->prim_channels + !!s->lfe;
1729
1730     if (s->amode<16) {
1731         avctx->channel_layout = dca_core_channel_layout[s->amode];
1732
1733         if (s->xch_present && (!avctx->request_channels ||
1734                                avctx->request_channels > num_core_channels + !!s->lfe)) {
1735             avctx->channel_layout |= AV_CH_BACK_CENTER;
1736             if (s->lfe) {
1737                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1738                 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1739             } else {
1740                 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1741             }
1742         } else {
1743             channels = num_core_channels + !!s->lfe;
1744             s->xch_present = 0; /* disable further xch processing */
1745             if (s->lfe) {
1746                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1747                 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1748             } else
1749                 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1750         }
1751
1752         if (channels > !!s->lfe &&
1753             s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1754             return -1;
1755
1756         if (avctx->request_channels == 2 && s->prim_channels > 2) {
1757             channels = 2;
1758             s->output = DCA_STEREO;
1759             avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1760         }
1761     } else {
1762         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1763         return -1;
1764     }
1765
1766
1767     /* There is nothing that prevents a dts frame to change channel configuration
1768        but FFmpeg doesn't support that so only set the channels if it is previously
1769        unset. Ideally during the first probe for channels the crc should be checked
1770        and only set avctx->channels when the crc is ok. Right now the decoder could
1771        set the channels based on a broken first frame.*/
1772     if (s->is_channels_set == 0) {
1773         s->is_channels_set = 1;
1774         avctx->channels = channels;
1775     }
1776     if (avctx->channels != channels) {
1777         av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
1778                "channels changing in stream. Skipping frame.\n");
1779         return -1;
1780     }
1781
1782     if (*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1783         return -1;
1784     *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1785
1786     /* filter to get final output */
1787     for (i = 0; i < (s->sample_blocks / 8); i++) {
1788         dca_filter_channels(s, i);
1789
1790         /* If this was marked as a DTS-ES stream we need to subtract back- */
1791         /* channel from SL & SR to remove matrixed back-channel signal */
1792         if((s->source_pcm_res & 1) && s->xch_present) {
1793             float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1794             float* lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1795             float* rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1796             int j;
1797             for(j = 0; j < 256; ++j) {
1798                 lt_chan[j] -= back_chan[j] * M_SQRT1_2;
1799                 rt_chan[j] -= back_chan[j] * M_SQRT1_2;
1800             }
1801         }
1802
1803         s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1804         samples += 256 * channels;
1805     }
1806
1807     /* update lfe history */
1808     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1809     for (i = 0; i < 2 * s->lfe * 4; i++) {
1810         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1811     }
1812
1813     return buf_size;
1814 }
1815
1816
1817
1818 /**
1819  * DCA initialization
1820  *
1821  * @param avctx     pointer to the AVCodecContext
1822  */
1823
1824 static av_cold int dca_decode_init(AVCodecContext * avctx)
1825 {
1826     DCAContext *s = avctx->priv_data;
1827     int i;
1828
1829     s->avctx = avctx;
1830     dca_init_vlcs();
1831
1832     dsputil_init(&s->dsp, avctx);
1833     ff_mdct_init(&s->imdct, 6, 1, 1.0);
1834     ff_synth_filter_init(&s->synth);
1835     ff_dcadsp_init(&s->dcadsp);
1836
1837     for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
1838         s->samples_chanptr[i] = s->samples + i * 256;
1839     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1840
1841     s->scale_bias = 1.0;
1842
1843     /* allow downmixing to stereo */
1844     if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1845         avctx->request_channels == 2) {
1846         avctx->channels = avctx->request_channels;
1847     }
1848
1849     return 0;
1850 }
1851
1852 static av_cold int dca_decode_end(AVCodecContext * avctx)
1853 {
1854     DCAContext *s = avctx->priv_data;
1855     ff_mdct_end(&s->imdct);
1856     return 0;
1857 }
1858
1859 static const AVProfile profiles[] = {
1860     { FF_PROFILE_DTS,        "DTS"        },
1861     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
1862     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
1863     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1864     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
1865     { FF_PROFILE_UNKNOWN },
1866 };
1867
1868 AVCodec ff_dca_decoder = {
1869     .name = "dca",
1870     .type = AVMEDIA_TYPE_AUDIO,
1871     .id = CODEC_ID_DTS,
1872     .priv_data_size = sizeof(DCAContext),
1873     .init = dca_decode_init,
1874     .decode = dca_decode_frame,
1875     .close = dca_decode_end,
1876     .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1877     .capabilities = CODEC_CAP_CHANNEL_CONF,
1878     .profiles = NULL_IF_CONFIG_SMALL(profiles),
1879 };