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 uint64_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_blockcodes
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     return code;
1055 }
1056
1057 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1058 {
1059     return decode_blockcode(code1, levels, values) |
1060            decode_blockcode(code2, levels, values + 4);
1061 }
1062 #endif
1063
1064 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1065 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1066
1067 #ifndef int8x8_fmul_int32
1068 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1069 {
1070     float fscale = scale / 16.0;
1071     int i;
1072     for (i = 0; i < 8; i++)
1073         dst[i] = src[i] * fscale;
1074 }
1075 #endif
1076
1077 static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
1078 {
1079     int k, l;
1080     int subsubframe = s->current_subsubframe;
1081
1082     const float *quant_step_table;
1083
1084     /* FIXME */
1085     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1086     LOCAL_ALIGNED_16(int, block, [8]);
1087
1088     /*
1089      * Audio data
1090      */
1091
1092     /* Select quantization step size table */
1093     if (s->bit_rate_index == 0x1f)
1094         quant_step_table = lossless_quant_d;
1095     else
1096         quant_step_table = lossy_quant_d;
1097
1098     for (k = base_channel; k < s->prim_channels; k++) {
1099         if (get_bits_left(&s->gb) < 0)
1100             return AVERROR_INVALIDDATA;
1101
1102         for (l = 0; l < s->vq_start_subband[k]; l++) {
1103             int m;
1104
1105             /* Select the mid-tread linear quantizer */
1106             int abits = s->bitalloc[k][l];
1107
1108             float quant_step_size = quant_step_table[abits];
1109
1110             /*
1111              * Determine quantization index code book and its type
1112              */
1113
1114             /* Select quantization index code book */
1115             int sel = s->quant_index_huffman[k][abits];
1116
1117             /*
1118              * Extract bits from the bit stream
1119              */
1120             if (!abits){
1121                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1122             } else {
1123                 /* Deal with transients */
1124                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1125                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
1126
1127                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
1128                     if (abits <= 7){
1129                         /* Block code */
1130                         int block_code1, block_code2, size, levels, err;
1131
1132                         size = abits_sizes[abits-1];
1133                         levels = abits_levels[abits-1];
1134
1135                         block_code1 = get_bits(&s->gb, size);
1136                         block_code2 = get_bits(&s->gb, size);
1137                         err = decode_blockcodes(block_code1, block_code2,
1138                                                 levels, block);
1139                         if (err) {
1140                             av_log(s->avctx, AV_LOG_ERROR,
1141                                    "ERROR: block code look-up failed\n");
1142                             return AVERROR_INVALIDDATA;
1143                         }
1144                     }else{
1145                         /* no coding */
1146                         for (m = 0; m < 8; m++)
1147                             block[m] = get_sbits(&s->gb, abits - 3);
1148                     }
1149                 }else{
1150                     /* Huffman coded */
1151                     for (m = 0; m < 8; m++)
1152                         block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1153                 }
1154
1155                 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1156                                                   block, rscale, 8);
1157             }
1158
1159             /*
1160              * Inverse ADPCM if in prediction mode
1161              */
1162             if (s->prediction_mode[k][l]) {
1163                 int n;
1164                 for (m = 0; m < 8; m++) {
1165                     for (n = 1; n <= 4; n++)
1166                         if (m >= n)
1167                             subband_samples[k][l][m] +=
1168                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1169                                  subband_samples[k][l][m - n] / 8192);
1170                         else if (s->predictor_history)
1171                             subband_samples[k][l][m] +=
1172                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1173                                  s->subband_samples_hist[k][l][m - n +
1174                                                                4] / 8192);
1175                 }
1176             }
1177         }
1178
1179         /*
1180          * Decode VQ encoded high frequencies
1181          */
1182         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1183             /* 1 vector -> 32 samples but we only need the 8 samples
1184              * for this subsubframe. */
1185             int hfvq = s->high_freq_vq[k][l];
1186
1187             if (!s->debug_flag & 0x01) {
1188                 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1189                 s->debug_flag |= 0x01;
1190             }
1191
1192             int8x8_fmul_int32(subband_samples[k][l],
1193                               &high_freq_vq[hfvq][subsubframe * 8],
1194                               s->scale_factor[k][l][0]);
1195         }
1196     }
1197
1198     /* Check for DSYNC after subsubframe */
1199     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1200         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1201 #ifdef TRACE
1202             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1203 #endif
1204         } else {
1205             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1206         }
1207     }
1208
1209     /* Backup predictor history for adpcm */
1210     for (k = base_channel; k < s->prim_channels; k++)
1211         for (l = 0; l < s->vq_start_subband[k]; l++)
1212             memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1213                         4 * sizeof(subband_samples[0][0][0]));
1214
1215     return 0;
1216 }
1217
1218 static int dca_filter_channels(DCAContext * s, int block_index)
1219 {
1220     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1221     int k;
1222
1223     /* 32 subbands QMF */
1224     for (k = 0; k < s->prim_channels; k++) {
1225 /*        static float pcm_to_double[8] =
1226             {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1227          qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1228                          M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ );
1229     }
1230
1231     /* Down mixing */
1232     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1233         dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
1234     }
1235
1236     /* Generate LFE samples for this subsubframe FIXME!!! */
1237     if (s->output & DCA_LFE) {
1238         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1239                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1240                               &s->samples[256 * dca_lfe_index[s->amode]],
1241                               (1.0/256.0)*s->scale_bias);
1242         /* Outputs 20bits pcm samples */
1243     }
1244
1245     return 0;
1246 }
1247
1248
1249 static int dca_subframe_footer(DCAContext * s, int base_channel)
1250 {
1251     int aux_data_count = 0, i;
1252
1253     /*
1254      * Unpack optional information
1255      */
1256
1257     /* presumably optional information only appears in the core? */
1258     if (!base_channel) {
1259         if (s->timestamp)
1260             get_bits(&s->gb, 32);
1261
1262         if (s->aux_data)
1263             aux_data_count = get_bits(&s->gb, 6);
1264
1265         for (i = 0; i < aux_data_count; i++)
1266             get_bits(&s->gb, 8);
1267
1268         if (s->crc_present && (s->downmix || s->dynrange))
1269             get_bits(&s->gb, 16);
1270     }
1271
1272     return 0;
1273 }
1274
1275 /**
1276  * Decode a dca frame block
1277  *
1278  * @param s     pointer to the DCAContext
1279  */
1280
1281 static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1282 {
1283     int ret;
1284
1285     /* Sanity check */
1286     if (s->current_subframe >= s->subframes) {
1287         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1288                s->current_subframe, s->subframes);
1289         return AVERROR_INVALIDDATA;
1290     }
1291
1292     if (!s->current_subsubframe) {
1293 #ifdef TRACE
1294         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1295 #endif
1296         /* Read subframe header */
1297         if ((ret = dca_subframe_header(s, base_channel, block_index)))
1298             return ret;
1299     }
1300
1301     /* Read subsubframe */
1302 #ifdef TRACE
1303     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1304 #endif
1305     if ((ret = dca_subsubframe(s, base_channel, block_index)))
1306         return ret;
1307
1308     /* Update state */
1309     s->current_subsubframe++;
1310     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1311         s->current_subsubframe = 0;
1312         s->current_subframe++;
1313     }
1314     if (s->current_subframe >= s->subframes) {
1315 #ifdef TRACE
1316         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1317 #endif
1318         /* Read subframe footer */
1319         if ((ret = dca_subframe_footer(s, base_channel)))
1320             return ret;
1321     }
1322
1323     return 0;
1324 }
1325
1326 /**
1327  * Convert bitstream to one representation based on sync marker
1328  */
1329 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1330                           int max_size)
1331 {
1332     uint32_t mrk;
1333     int i, tmp;
1334     const uint16_t *ssrc = (const uint16_t *) src;
1335     uint16_t *sdst = (uint16_t *) dst;
1336     PutBitContext pb;
1337
1338     if ((unsigned)src_size > (unsigned)max_size) {
1339 //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger than DCA_MAX_FRAME_SIZE!\n");
1340 //        return -1;
1341         src_size = max_size;
1342     }
1343
1344     mrk = AV_RB32(src);
1345     switch (mrk) {
1346     case DCA_MARKER_RAW_BE:
1347         memcpy(dst, src, src_size);
1348         return src_size;
1349     case DCA_MARKER_RAW_LE:
1350         for (i = 0; i < (src_size + 1) >> 1; i++)
1351             *sdst++ = av_bswap16(*ssrc++);
1352         return src_size;
1353     case DCA_MARKER_14B_BE:
1354     case DCA_MARKER_14B_LE:
1355         init_put_bits(&pb, dst, max_size);
1356         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1357             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1358             put_bits(&pb, 14, tmp);
1359         }
1360         flush_put_bits(&pb);
1361         return (put_bits_count(&pb) + 7) >> 3;
1362     default:
1363         return AVERROR_INVALIDDATA;
1364     }
1365 }
1366
1367 /**
1368  * Return the number of channels in an ExSS speaker mask (HD)
1369  */
1370 static int dca_exss_mask2count(int mask)
1371 {
1372     /* count bits that mean speaker pairs twice */
1373     return av_popcount(mask)
1374         + av_popcount(mask & (
1375             DCA_EXSS_CENTER_LEFT_RIGHT
1376           | DCA_EXSS_FRONT_LEFT_RIGHT
1377           | DCA_EXSS_FRONT_HIGH_LEFT_RIGHT
1378           | DCA_EXSS_WIDE_LEFT_RIGHT
1379           | DCA_EXSS_SIDE_LEFT_RIGHT
1380           | DCA_EXSS_SIDE_HIGH_LEFT_RIGHT
1381           | DCA_EXSS_SIDE_REAR_LEFT_RIGHT
1382           | DCA_EXSS_REAR_LEFT_RIGHT
1383           | DCA_EXSS_REAR_HIGH_LEFT_RIGHT
1384           ));
1385 }
1386
1387 /**
1388  * Skip mixing coefficients of a single mix out configuration (HD)
1389  */
1390 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1391 {
1392     int i;
1393
1394     for (i = 0; i < channels; i++) {
1395         int mix_map_mask = get_bits(gb, out_ch);
1396         int num_coeffs = av_popcount(mix_map_mask);
1397         skip_bits_long(gb, num_coeffs * 6);
1398     }
1399 }
1400
1401 /**
1402  * Parse extension substream asset header (HD)
1403  */
1404 static int dca_exss_parse_asset_header(DCAContext *s)
1405 {
1406     int header_pos = get_bits_count(&s->gb);
1407     int header_size;
1408     int channels;
1409     int embedded_stereo = 0;
1410     int embedded_6ch = 0;
1411     int drc_code_present;
1412     int extensions_mask;
1413     int i, j;
1414
1415     if (get_bits_left(&s->gb) < 16)
1416         return -1;
1417
1418     /* We will parse just enough to get to the extensions bitmask with which
1419      * we can set the profile value. */
1420
1421     header_size = get_bits(&s->gb, 9) + 1;
1422     skip_bits(&s->gb, 3); // asset index
1423
1424     if (s->static_fields) {
1425         if (get_bits1(&s->gb))
1426             skip_bits(&s->gb, 4); // asset type descriptor
1427         if (get_bits1(&s->gb))
1428             skip_bits_long(&s->gb, 24); // language descriptor
1429
1430         if (get_bits1(&s->gb)) {
1431             /* How can one fit 1024 bytes of text here if the maximum value
1432              * for the asset header size field above was 512 bytes? */
1433             int text_length = get_bits(&s->gb, 10) + 1;
1434             if (get_bits_left(&s->gb) < text_length * 8)
1435                 return -1;
1436             skip_bits_long(&s->gb, text_length * 8); // info text
1437         }
1438
1439         skip_bits(&s->gb, 5); // bit resolution - 1
1440         skip_bits(&s->gb, 4); // max sample rate code
1441         channels = get_bits(&s->gb, 8) + 1;
1442
1443         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1444             int spkr_remap_sets;
1445             int spkr_mask_size = 16;
1446             int num_spkrs[7];
1447
1448             if (channels > 2)
1449                 embedded_stereo = get_bits1(&s->gb);
1450             if (channels > 6)
1451                 embedded_6ch = get_bits1(&s->gb);
1452
1453             if (get_bits1(&s->gb)) {
1454                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1455                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1456             }
1457
1458             spkr_remap_sets = get_bits(&s->gb, 3);
1459
1460             for (i = 0; i < spkr_remap_sets; i++) {
1461                 /* std layout mask for each remap set */
1462                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1463             }
1464
1465             for (i = 0; i < spkr_remap_sets; i++) {
1466                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1467                 if (get_bits_left(&s->gb) < 0)
1468                     return -1;
1469
1470                 for (j = 0; j < num_spkrs[i]; j++) {
1471                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1472                     int num_dec_ch = av_popcount(remap_dec_ch_mask);
1473                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1474                 }
1475             }
1476
1477         } else {
1478             skip_bits(&s->gb, 3); // representation type
1479         }
1480     }
1481
1482     drc_code_present = get_bits1(&s->gb);
1483     if (drc_code_present)
1484         get_bits(&s->gb, 8); // drc code
1485
1486     if (get_bits1(&s->gb))
1487         skip_bits(&s->gb, 5); // dialog normalization code
1488
1489     if (drc_code_present && embedded_stereo)
1490         get_bits(&s->gb, 8); // drc stereo code
1491
1492     if (s->mix_metadata && get_bits1(&s->gb)) {
1493         skip_bits(&s->gb, 1); // external mix
1494         skip_bits(&s->gb, 6); // post mix gain code
1495
1496         if (get_bits(&s->gb, 2) != 3) // mixer drc code
1497             skip_bits(&s->gb, 3); // drc limit
1498         else
1499             skip_bits(&s->gb, 8); // custom drc code
1500
1501         if (get_bits1(&s->gb)) // channel specific scaling
1502             for (i = 0; i < s->num_mix_configs; i++)
1503                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1504         else
1505             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1506
1507         for (i = 0; i < s->num_mix_configs; i++) {
1508             if (get_bits_left(&s->gb) < 0)
1509                 return -1;
1510             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1511             if (embedded_6ch)
1512                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1513             if (embedded_stereo)
1514                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1515         }
1516     }
1517
1518     switch (get_bits(&s->gb, 2)) {
1519     case 0: extensions_mask = get_bits(&s->gb, 12); break;
1520     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
1521     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
1522     case 3: extensions_mask = 0; /* aux coding */   break;
1523     }
1524
1525     /* not parsed further, we were only interested in the extensions mask */
1526
1527     if (get_bits_left(&s->gb) < 0)
1528         return -1;
1529
1530     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1531         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1532         return -1;
1533     }
1534     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1535
1536     if (extensions_mask & DCA_EXT_EXSS_XLL)
1537         s->profile = FF_PROFILE_DTS_HD_MA;
1538     else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1539                                 DCA_EXT_EXSS_XXCH))
1540         s->profile = FF_PROFILE_DTS_HD_HRA;
1541
1542     if (!(extensions_mask & DCA_EXT_CORE))
1543         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1544     if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1545         av_log(s->avctx, AV_LOG_WARNING, "DTS extensions detection mismatch (%d, %d)\n",
1546                extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1547
1548     return 0;
1549 }
1550
1551 /**
1552  * Parse extension substream header (HD)
1553  */
1554 static void dca_exss_parse_header(DCAContext *s)
1555 {
1556     int ss_index;
1557     int blownup;
1558     int num_audiop = 1;
1559     int num_assets = 1;
1560     int active_ss_mask[8];
1561     int i, j;
1562
1563     if (get_bits_left(&s->gb) < 52)
1564         return;
1565
1566     skip_bits(&s->gb, 8); // user data
1567     ss_index = get_bits(&s->gb, 2);
1568
1569     blownup = get_bits1(&s->gb);
1570     skip_bits(&s->gb, 8 + 4 * blownup); // header_size
1571     skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1572
1573     s->static_fields = get_bits1(&s->gb);
1574     if (s->static_fields) {
1575         skip_bits(&s->gb, 2); // reference clock code
1576         skip_bits(&s->gb, 3); // frame duration code
1577
1578         if (get_bits1(&s->gb))
1579             skip_bits_long(&s->gb, 36); // timestamp
1580
1581         /* a single stream can contain multiple audio assets that can be
1582          * combined to form multiple audio presentations */
1583
1584         num_audiop = get_bits(&s->gb, 3) + 1;
1585         if (num_audiop > 1) {
1586             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1587             /* ignore such streams for now */
1588             return;
1589         }
1590
1591         num_assets = get_bits(&s->gb, 3) + 1;
1592         if (num_assets > 1) {
1593             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1594             /* ignore such streams for now */
1595             return;
1596         }
1597
1598         for (i = 0; i < num_audiop; i++)
1599             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1600
1601         for (i = 0; i < num_audiop; i++)
1602             for (j = 0; j <= ss_index; j++)
1603                 if (active_ss_mask[i] & (1 << j))
1604                     skip_bits(&s->gb, 8); // active asset mask
1605
1606         s->mix_metadata = get_bits1(&s->gb);
1607         if (s->mix_metadata) {
1608             int mix_out_mask_size;
1609
1610             skip_bits(&s->gb, 2); // adjustment level
1611             mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1612             s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1613
1614             for (i = 0; i < s->num_mix_configs; i++) {
1615                 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1616                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1617             }
1618         }
1619     }
1620
1621     for (i = 0; i < num_assets; i++)
1622         skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1623
1624     for (i = 0; i < num_assets; i++) {
1625         if (dca_exss_parse_asset_header(s))
1626             return;
1627     }
1628
1629     /* not parsed further, we were only interested in the extensions mask
1630      * from the asset header */
1631 }
1632
1633 /**
1634  * Main frame decoding function
1635  * FIXME add arguments
1636  */
1637 static int dca_decode_frame(AVCodecContext * avctx,
1638                             void *data, int *data_size,
1639                             AVPacket *avpkt)
1640 {
1641     const uint8_t *buf = avpkt->data;
1642     int buf_size = avpkt->size;
1643
1644     int lfe_samples;
1645     int num_core_channels = 0;
1646     int i, ret;
1647     float   *samples_flt = data;
1648     int16_t *samples_s16 = data;
1649     int out_size;
1650     DCAContext *s = avctx->priv_data;
1651     int channels;
1652     int core_ss_end;
1653
1654
1655     s->xch_present = 0;
1656
1657     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1658                                                DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1659     if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
1660         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1661         return AVERROR_INVALIDDATA;
1662     }
1663
1664     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1665     if ((ret = dca_parse_frame_header(s)) < 0) {
1666         //seems like the frame is corrupt, try with the next one
1667         return ret;
1668     }
1669     //set AVCodec values with parsed data
1670     avctx->sample_rate = s->sample_rate;
1671     avctx->bit_rate = s->bit_rate;
1672     avctx->frame_size = s->sample_blocks * 32;
1673
1674     s->profile = FF_PROFILE_DTS;
1675
1676     for (i = 0; i < (s->sample_blocks / 8); i++) {
1677         if ((ret = dca_decode_block(s, 0, i))) {
1678             av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
1679             return ret;
1680         }
1681     }
1682
1683     /* record number of core channels incase less than max channels are requested */
1684     num_core_channels = s->prim_channels;
1685
1686     if (s->ext_coding)
1687         s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
1688     else
1689         s->core_ext_mask = 0;
1690
1691     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1692
1693     /* only scan for extensions if ext_descr was unknown or indicated a
1694      * supported XCh extension */
1695     if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
1696
1697         /* if ext_descr was unknown, clear s->core_ext_mask so that the
1698          * extensions scan can fill it up */
1699         s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
1700
1701         /* extensions start at 32-bit boundaries into bitstream */
1702         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1703
1704     while(core_ss_end - get_bits_count(&s->gb) >= 32) {
1705         uint32_t bits = get_bits_long(&s->gb, 32);
1706
1707         switch(bits) {
1708         case 0x5a5a5a5a: {
1709             int ext_amode, xch_fsize;
1710
1711             s->xch_base_channel = s->prim_channels;
1712
1713             /* validate sync word using XCHFSIZE field */
1714             xch_fsize = show_bits(&s->gb, 10);
1715             if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1716                (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1717                 continue;
1718
1719             /* skip length-to-end-of-frame field for the moment */
1720             skip_bits(&s->gb, 10);
1721
1722             s->core_ext_mask |= DCA_EXT_XCH;
1723
1724             /* extension amode should == 1, number of channels in extension */
1725             /* AFAIK XCh is not used for more channels */
1726             if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1727                 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1728                        " supported!\n",ext_amode);
1729                 continue;
1730             }
1731
1732             /* much like core primary audio coding header */
1733             dca_parse_audio_coding_header(s, s->xch_base_channel);
1734
1735             for (i = 0; i < (s->sample_blocks / 8); i++) {
1736                 if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
1737                     av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
1738                     continue;
1739                 }
1740             }
1741
1742             s->xch_present = 1;
1743             break;
1744         }
1745         case 0x47004a03:
1746             /* XXCh: extended channels */
1747             /* usually found either in core or HD part in DTS-HD HRA streams,
1748              * but not in DTS-ES which contains XCh extensions instead */
1749             s->core_ext_mask |= DCA_EXT_XXCH;
1750             break;
1751
1752         case 0x1d95f262: {
1753             int fsize96 = show_bits(&s->gb, 12) + 1;
1754             if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1755                 continue;
1756
1757             av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n", get_bits_count(&s->gb));
1758             skip_bits(&s->gb, 12);
1759             av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1760             av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1761
1762             s->core_ext_mask |= DCA_EXT_X96;
1763             break;
1764         }
1765         }
1766
1767         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1768     }
1769
1770     } else {
1771         /* no supported extensions, skip the rest of the core substream */
1772         skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
1773     }
1774
1775     if (s->core_ext_mask & DCA_EXT_X96)
1776         s->profile = FF_PROFILE_DTS_96_24;
1777     else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
1778         s->profile = FF_PROFILE_DTS_ES;
1779
1780     /* check for ExSS (HD part) */
1781     if (s->dca_buffer_size - s->frame_size > 32
1782         && get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1783         dca_exss_parse_header(s);
1784
1785     avctx->profile = s->profile;
1786
1787     channels = s->prim_channels + !!s->lfe;
1788
1789     if (s->amode<16) {
1790         avctx->channel_layout = dca_core_channel_layout[s->amode];
1791
1792         if (s->xch_present && (!avctx->request_channels ||
1793                                avctx->request_channels > num_core_channels + !!s->lfe)) {
1794             avctx->channel_layout |= AV_CH_BACK_CENTER;
1795             if (s->lfe) {
1796                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1797                 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1798             } else {
1799                 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1800             }
1801         } else {
1802             channels = num_core_channels + !!s->lfe;
1803             s->xch_present = 0; /* disable further xch processing */
1804             if (s->lfe) {
1805                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1806                 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1807             } else
1808                 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1809         }
1810
1811         if (channels > !!s->lfe &&
1812             s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1813             return AVERROR_INVALIDDATA;
1814
1815         if (avctx->request_channels == 2 && s->prim_channels > 2) {
1816             channels = 2;
1817             s->output = DCA_STEREO;
1818             avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1819         }
1820         else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
1821             static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
1822             s->channel_order_tab = dca_channel_order_native;
1823         }
1824     } else {
1825         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1826         return AVERROR_INVALIDDATA;
1827     }
1828
1829     if (avctx->channels != channels) {
1830         if (avctx->channels)
1831             av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
1832         avctx->channels = channels;
1833     }
1834
1835     out_size = 256 / 8 * s->sample_blocks * channels *
1836                av_get_bytes_per_sample(avctx->sample_fmt);
1837     if (*data_size < out_size)
1838         return AVERROR(EINVAL);
1839     *data_size = out_size;
1840
1841     /* filter to get final output */
1842     for (i = 0; i < (s->sample_blocks / 8); i++) {
1843         dca_filter_channels(s, i);
1844
1845         /* If this was marked as a DTS-ES stream we need to subtract back- */
1846         /* channel from SL & SR to remove matrixed back-channel signal */
1847         if((s->source_pcm_res & 1) && s->xch_present) {
1848             float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1849             float* lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1850             float* rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1851             s->dsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
1852             s->dsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
1853         }
1854
1855         if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1856             s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
1857                                          channels);
1858             samples_flt += 256 * channels;
1859         } else {
1860             s->fmt_conv.float_to_int16_interleave(samples_s16,
1861                                                   s->samples_chanptr, 256,
1862                                                   channels);
1863             samples_s16 += 256 * channels;
1864         }
1865     }
1866
1867     /* update lfe history */
1868     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1869     for (i = 0; i < 2 * s->lfe * 4; i++) {
1870         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1871     }
1872
1873     return buf_size;
1874 }
1875
1876
1877
1878 /**
1879  * DCA initialization
1880  *
1881  * @param avctx     pointer to the AVCodecContext
1882  */
1883
1884 static av_cold int dca_decode_init(AVCodecContext * avctx)
1885 {
1886     DCAContext *s = avctx->priv_data;
1887     int i;
1888
1889     s->avctx = avctx;
1890     dca_init_vlcs();
1891
1892     dsputil_init(&s->dsp, avctx);
1893     ff_mdct_init(&s->imdct, 6, 1, 1.0);
1894     ff_synth_filter_init(&s->synth);
1895     ff_dcadsp_init(&s->dcadsp);
1896     ff_fmt_convert_init(&s->fmt_conv, avctx);
1897
1898     for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
1899         s->samples_chanptr[i] = s->samples + i * 256;
1900
1901     if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
1902         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1903         s->scale_bias = 1.0 / 32768.0;
1904     } else {
1905         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1906         s->scale_bias = 1.0;
1907     }
1908
1909     /* allow downmixing to stereo */
1910     if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1911         avctx->request_channels == 2) {
1912         avctx->channels = avctx->request_channels;
1913     }
1914
1915     return 0;
1916 }
1917
1918 static av_cold int dca_decode_end(AVCodecContext * avctx)
1919 {
1920     DCAContext *s = avctx->priv_data;
1921     ff_mdct_end(&s->imdct);
1922     return 0;
1923 }
1924
1925 static const AVProfile profiles[] = {
1926     { FF_PROFILE_DTS,        "DTS"        },
1927     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
1928     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
1929     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1930     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
1931     { FF_PROFILE_UNKNOWN },
1932 };
1933
1934 AVCodec ff_dca_decoder = {
1935     .name = "dca",
1936     .type = AVMEDIA_TYPE_AUDIO,
1937     .id = CODEC_ID_DTS,
1938     .priv_data_size = sizeof(DCAContext),
1939     .init = dca_decode_init,
1940     .decode = dca_decode_frame,
1941     .close = dca_decode_end,
1942     .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1943     .capabilities = CODEC_CAP_CHANNEL_CONF,
1944     .sample_fmts = (const enum AVSampleFormat[]) {
1945         AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
1946     },
1947     .profiles = NULL_IF_CONFIG_SMALL(profiles),
1948 };