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