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