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