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)
 644 {
 645     if (level < 5) {
 646         /* huffman encoded */
 647         value += get_bitalloc(gb, &dca_scalefactor, level);
 648     } else if (level < 8)
 649         value = get_bits(gb, level + 1);
 650     return value;
 651 }
 652
 653 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
 654 {
 655     /* Primary audio coding side information */
 656     int j, k;
 657
 658     if (get_bits_left(&s->gb) < 0)
 659         return AVERROR_INVALIDDATA;
 660
 661     if (!base_channel) {
 662         s->subsubframes[s->current_subframe]    = get_bits(&s->gb, 2) + 1;
 663         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
 664     }
 665
 666     for (j = base_channel; j < s->prim_channels; j++) {
 667         for (k = 0; k < s->subband_activity[j]; k++)
 668             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
 669     }
 670
 671     /* Get prediction codebook */
 672     for (j = base_channel; j < s->prim_channels; j++) {
 673         for (k = 0; k < s->subband_activity[j]; k++) {
 674             if (s->prediction_mode[j][k] > 0) {
 675                 /* (Prediction coefficient VQ address) */
 676                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
 677             }
 678         }
 679     }
 680
 681     /* Bit allocation index */
 682     for (j = base_channel; j < s->prim_channels; j++) {
 683         for (k = 0; k < s->vq_start_subband[j]; k++) {
 684             if (s->bitalloc_huffman[j] == 6)
 685                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
 686             else if (s->bitalloc_huffman[j] == 5)
 687                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
 688             else if (s->bitalloc_huffman[j] == 7) {
 689                 av_log(s->avctx, AV_LOG_ERROR,
 690                        "Invalid bit allocation index\n");
 691                 return AVERROR_INVALIDDATA;
 692             } else {
 693                 s->bitalloc[j][k] =
 694                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
 695             }
 696
 697             if (s->bitalloc[j][k] > 26) {
 698                 // av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index [%i][%i] too big (%i)\n",
 699                 //        j, k, s->bitalloc[j][k]);
 700                 return AVERROR_INVALIDDATA;
 701             }
 702         }
 703     }
 704
 705     /* Transition mode */
 706     for (j = base_channel; j < s->prim_channels; j++) {
 707         for (k = 0; k < s->subband_activity[j]; k++) {
 708             s->transition_mode[j][k] = 0;
 709             if (s->subsubframes[s->current_subframe] > 1 &&
 710                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
 711                 s->transition_mode[j][k] =
 712                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
 713             }
 714         }
 715     }
 716
 717     if (get_bits_left(&s->gb) < 0)
 718         return AVERROR_INVALIDDATA;
 719
 720     for (j = base_channel; j < s->prim_channels; j++) {
 721         const uint32_t *scale_table;
 722         int scale_sum;
 723
 724         memset(s->scale_factor[j], 0,
 725                s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
 726
 727         if (s->scalefactor_huffman[j] == 6)
 728             scale_table = scale_factor_quant7;
 729         else
 730             scale_table = scale_factor_quant6;
 731
 732         /* When huffman coded, only the difference is encoded */
 733         scale_sum = 0;
 734
 735         for (k = 0; k < s->subband_activity[j]; k++) {
 736             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
 737                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
 738                 s->scale_factor[j][k][0] = scale_table[scale_sum];
 739             }
 740
 741             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
 742                 /* Get second scale factor */
 743                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
 744                 s->scale_factor[j][k][1] = scale_table[scale_sum];
 745             }
 746         }
 747     }
 748
 749     /* Joint subband scale factor codebook select */
 750     for (j = base_channel; j < s->prim_channels; j++) {
 751         /* Transmitted only if joint subband coding enabled */
 752         if (s->joint_intensity[j] > 0)
 753             s->joint_huff[j] = get_bits(&s->gb, 3);
 754     }
 755
 756     if (get_bits_left(&s->gb) < 0)
 757         return AVERROR_INVALIDDATA;
 758
 759     /* Scale factors for joint subband coding */
 760     for (j = base_channel; j < s->prim_channels; j++) {
 761         int source_channel;
 762
 763         /* Transmitted only if joint subband coding enabled */
 764         if (s->joint_intensity[j] > 0) {
 765             int scale = 0;
 766             source_channel = s->joint_intensity[j] - 1;
 767
 768             /* When huffman coded, only the difference is encoded
 769              * (is this valid as well for joint scales ???) */
 770
 771             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
 772                 scale = get_scale(&s->gb, s->joint_huff[j], 0);
 773                 scale += 64;    /* bias */
 774                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
 775             }
 776
 777             if (!(s->debug_flag & 0x02)) {
 778                 av_log(s->avctx, AV_LOG_DEBUG,
 779                        "Joint stereo coding not supported\n");
 780                 s->debug_flag |= 0x02;
 781             }
 782         }
 783     }
 784
 785     /* Stereo downmix coefficients */
 786     if (!base_channel && s->prim_channels > 2) {
 787         if (s->downmix) {
 788             for (j = base_channel; j < s->prim_channels; j++) {
 789                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
 790                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
 791             }
 792         } else {
 793             int am = s->amode & DCA_CHANNEL_MASK;
 794             for (j = base_channel; j < s->prim_channels; j++) {
 795                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
 796                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
 797             }
 798         }
 799     }
 800
 801     /* Dynamic range coefficient */
 802     if (!base_channel && s->dynrange)
 803         s->dynrange_coef = get_bits(&s->gb, 8);
 804
 805     /* Side information CRC check word */
 806     if (s->crc_present) {
 807         get_bits(&s->gb, 16);
 808     }
 809
 810     /*
 811      * Primary audio data arrays
 812      */
 813
 814     /* VQ encoded high frequency subbands */
 815     for (j = base_channel; j < s->prim_channels; j++)
 816         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 817             /* 1 vector -> 32 samples */
 818             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
 819
 820     /* Low frequency effect data */
 821     if (!base_channel && s->lfe) {
 822         /* LFE samples */
 823         int lfe_samples = 2 * s->lfe * (4 + block_index);
 824         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
 825         float lfe_scale;
 826
 827         for (j = lfe_samples; j < lfe_end_sample; j++) {
 828             /* Signed 8 bits int */
 829             s->lfe_data[j] = get_sbits(&s->gb, 8);
 830         }
 831
 832         /* Scale factor index */
 833         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
 834
 835         /* Quantization step size * scale factor */
 836         lfe_scale = 0.035 * s->lfe_scale_factor;
 837
 838         for (j = lfe_samples; j < lfe_end_sample; j++)
 839             s->lfe_data[j] *= lfe_scale;
 840     }
 841
 842 #ifdef TRACE
 843     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
 844            s->subsubframes[s->current_subframe]);
 845     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
 846            s->partial_samples[s->current_subframe]);
 847
 848     for (j = base_channel; j < s->prim_channels; j++) {
 849         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
 850         for (k = 0; k < s->subband_activity[j]; k++)
 851             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
 852         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 853     }
 854     for (j = base_channel; j < s->prim_channels; j++) {
 855         for (k = 0; k < s->subband_activity[j]; k++)
 856             av_log(s->avctx, AV_LOG_DEBUG,
 857                    "prediction coefs: %f, %f, %f, %f\n",
 858                    (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
 859                    (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
 860                    (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
 861                    (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
 862     }
 863     for (j = base_channel; j < s->prim_channels; j++) {
 864         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
 865         for (k = 0; k < s->vq_start_subband[j]; k++)
 866             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
 867         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 868     }
 869     for (j = base_channel; j < s->prim_channels; j++) {
 870         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
 871         for (k = 0; k < s->subband_activity[j]; k++)
 872             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
 873         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 874     }
 875     for (j = base_channel; j < s->prim_channels; j++) {
 876         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
 877         for (k = 0; k < s->subband_activity[j]; k++) {
 878             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
 879                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
 880             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
 881                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
 882         }
 883         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 884     }
 885     for (j = base_channel; j < s->prim_channels; j++) {
 886         if (s->joint_intensity[j] > 0) {
 887             int source_channel = s->joint_intensity[j] - 1;
 888             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
 889             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
 890                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
 891             av_log(s->avctx, AV_LOG_DEBUG, "\n");
 892         }
 893     }
 894     if (!base_channel && s->prim_channels > 2 && s->downmix) {
 895         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
 896         for (j = 0; j < s->prim_channels; j++) {
 897             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
 898                    dca_downmix_coeffs[s->downmix_coef[j][0]]);
 899             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
 900                    dca_downmix_coeffs[s->downmix_coef[j][1]]);
 901         }
 902         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 903     }
 904     for (j = base_channel; j < s->prim_channels; j++)
 905         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 906             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
 907     if (!base_channel && s->lfe) {
 908         int lfe_samples = 2 * s->lfe * (4 + block_index);
 909         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
 910
 911         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
 912         for (j = lfe_samples; j < lfe_end_sample; j++)
 913             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
 914         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 915     }
 916 #endif
 917
 918     return 0;
 919 }
 920
 921 static void qmf_32_subbands(DCAContext *s, int chans,
 922                             float samples_in[32][8], float *samples_out,
 923                             float scale)
 924 {
 925     const float *prCoeff;
 926     int i;
 927
 928     int sb_act = s->subband_activity[chans];
 929     int subindex;
 930
 931     scale *= sqrt(1 / 8.0);
 932
 933     /* Select filter */
 934     if (!s->multirate_inter)    /* Non-perfect reconstruction */
 935         prCoeff = fir_32bands_nonperfect;
 936     else                        /* Perfect reconstruction */
 937         prCoeff = fir_32bands_perfect;
 938
 939     for (i = sb_act; i < 32; i++)
 940         s->raXin[i] = 0.0;
 941
 942     /* Reconstructed channel sample index */
 943     for (subindex = 0; subindex < 8; subindex++) {
 944         /* Load in one sample from each subband and clear inactive subbands */
 945         for (i = 0; i < sb_act; i++) {
 946             unsigned sign = (i - 1) & 2;
 947             uint32_t v    = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
 948             AV_WN32A(&s->raXin[i], v);
 949         }
 950
 951         s->synth.synth_filter_float(&s->imdct,
 952                                     s->subband_fir_hist[chans],
 953                                     &s->hist_index[chans],
 954                                     s->subband_fir_noidea[chans], prCoeff,
 955                                     samples_out, s->raXin, scale);
 956         samples_out += 32;
 957     }
 958 }
 959
 960 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
 961                                   int num_deci_sample, float *samples_in,
 962                                   float *samples_out, float scale)
 963 {
 964     /* samples_in: An array holding decimated samples.
 965      *   Samples in current subframe starts from samples_in[0],
 966      *   while samples_in[-1], samples_in[-2], ..., stores samples
 967      *   from last subframe as history.
 968      *
 969      * samples_out: An array holding interpolated samples
 970      */
 971
 972     int decifactor;
 973     const float *prCoeff;
 974     int deciindex;
 975
 976     /* Select decimation filter */
 977     if (decimation_select == 1) {
 978         decifactor = 64;
 979         prCoeff = lfe_fir_128;
 980     } else {
 981         decifactor = 32;
 982         prCoeff = lfe_fir_64;
 983     }
 984     /* Interpolation */
 985     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
 986         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
 987         samples_in++;
 988         samples_out += 2 * decifactor;
 989     }
 990 }
 991
 992 /* downmixing routines */
 993 #define MIX_REAR1(samples, si1, rs, coef)           \
 994     samples[i]     += samples[si1] * coef[rs][0];   \
 995     samples[i+256] += samples[si1] * coef[rs][1];
 996
 997 #define MIX_REAR2(samples, si1, si2, rs, coef)                                     \
 998     samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs + 1][0]; \
 999     samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs + 1][1];
1000
1001 #define MIX_FRONT3(samples, coef)                                      \
1002     t = samples[i + c];                                                \
1003     u = samples[i + l];                                                \
1004     v = samples[i + r];                                                \
1005     samples[i]     = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1006     samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1007
1008 #define DOWNMIX_TO_STEREO(op1, op2)             \
1009     for (i = 0; i < 256; i++) {                 \
1010         op1                                     \
1011         op2                                     \
1012     }
1013
1014 static void dca_downmix(float *samples, int srcfmt,
1015                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
1016                         const int8_t *channel_mapping)
1017 {
1018     int c, l, r, sl, sr, s;
1019     int i;
1020     float t, u, v;
1021     float coef[DCA_PRIM_CHANNELS_MAX][2];
1022
1023     for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
1024         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
1025         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
1026     }
1027
1028     switch (srcfmt) {
1029     case DCA_MONO:
1030     case DCA_CHANNEL:
1031     case DCA_STEREO_TOTAL:
1032     case DCA_STEREO_SUMDIFF:
1033     case DCA_4F2R:
1034         av_log(NULL, 0, "Not implemented!\n");
1035         break;
1036     case DCA_STEREO:
1037         break;
1038     case DCA_3F:
1039         c = channel_mapping[0] * 256;
1040         l = channel_mapping[1] * 256;
1041         r = channel_mapping[2] * 256;
1042         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1043         break;
1044     case DCA_2F1R:
1045         s = channel_mapping[2] * 256;
1046         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef), );
1047         break;
1048     case DCA_3F1R:
1049         c = channel_mapping[0] * 256;
1050         l = channel_mapping[1] * 256;
1051         r = channel_mapping[2] * 256;
1052         s = channel_mapping[3] * 256;
1053         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1054                           MIX_REAR1(samples, i + s, 3, coef));
1055         break;
1056     case DCA_2F2R:
1057         sl = channel_mapping[2] * 256;
1058         sr = channel_mapping[3] * 256;
1059         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef), );
1060         break;
1061     case DCA_3F2R:
1062         c  = channel_mapping[0] * 256;
1063         l  = channel_mapping[1] * 256;
1064         r  = channel_mapping[2] * 256;
1065         sl = channel_mapping[3] * 256;
1066         sr = channel_mapping[4] * 256;
1067         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1068                           MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1069         break;
1070     }
1071 }
1072
1073
1074 #ifndef decode_blockcodes
1075 /* Very compact version of the block code decoder that does not use table
1076  * look-up but is slightly slower */
1077 static int decode_blockcode(int code, int levels, int *values)
1078 {
1079     int i;
1080     int offset = (levels - 1) >> 1;
1081
1082     for (i = 0; i < 4; i++) {
1083         int div = FASTDIV(code, levels);
1084         values[i] = code - offset - div * levels;
1085         code = div;
1086     }
1087
1088     return code;
1089 }
1090
1091 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1092 {
1093     return decode_blockcode(code1, levels, values) |
1094            decode_blockcode(code2, levels, values + 4);
1095 }
1096 #endif
1097
1098 static const uint8_t abits_sizes[7]  = { 7, 10, 12, 13, 15, 17, 19 };
1099 static const uint8_t abits_levels[7] = { 3,  5,  7,  9, 13, 17, 25 };
1100
1101 #ifndef int8x8_fmul_int32
1102 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1103 {
1104     float fscale = scale / 16.0;
1105     int i;
1106     for (i = 0; i < 8; i++)
1107         dst[i] = src[i] * fscale;
1108 }
1109 #endif
1110
1111 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1112 {
1113     int k, l;
1114     int subsubframe = s->current_subsubframe;
1115
1116     const float *quant_step_table;
1117
1118     /* FIXME */
1119     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1120     LOCAL_ALIGNED_16(int, block, [8]);
1121
1122     /*
1123      * Audio data
1124      */
1125
1126     /* Select quantization step size table */
1127     if (s->bit_rate_index == 0x1f)
1128         quant_step_table = lossless_quant_d;
1129     else
1130         quant_step_table = lossy_quant_d;
1131
1132     for (k = base_channel; k < s->prim_channels; k++) {
1133         if (get_bits_left(&s->gb) < 0)
1134             return AVERROR_INVALIDDATA;
1135
1136         for (l = 0; l < s->vq_start_subband[k]; l++) {
1137             int m;
1138
1139             /* Select the mid-tread linear quantizer */
1140             int abits = s->bitalloc[k][l];
1141
1142             float quant_step_size = quant_step_table[abits];
1143
1144             /*
1145              * Determine quantization index code book and its type
1146              */
1147
1148             /* Select quantization index code book */
1149             int sel = s->quant_index_huffman[k][abits];
1150
1151             /*
1152              * Extract bits from the bit stream
1153              */
1154             if (!abits) {
1155                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1156             } else {
1157                 /* Deal with transients */
1158                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1159                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
1160                                s->scalefactor_adj[k][sel];
1161
1162                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1163                     if (abits <= 7) {
1164                         /* Block code */
1165                         int block_code1, block_code2, size, levels, err;
1166
1167                         size   = abits_sizes[abits - 1];
1168                         levels = abits_levels[abits - 1];
1169
1170                         block_code1 = get_bits(&s->gb, size);
1171                         block_code2 = get_bits(&s->gb, size);
1172                         err = decode_blockcodes(block_code1, block_code2,
1173                                                 levels, block);
1174                         if (err) {
1175                             av_log(s->avctx, AV_LOG_ERROR,
1176                                    "ERROR: block code look-up failed\n");
1177                             return AVERROR_INVALIDDATA;
1178                         }
1179                     } else {
1180                         /* no coding */
1181                         for (m = 0; m < 8; m++)
1182                             block[m] = get_sbits(&s->gb, abits - 3);
1183                     }
1184                 } else {
1185                     /* Huffman coded */
1186                     for (m = 0; m < 8; m++)
1187                         block[m] = get_bitalloc(&s->gb,
1188                                                 &dca_smpl_bitalloc[abits], sel);
1189                 }
1190
1191                 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1192                                                        block, rscale, 8);
1193             }
1194
1195             /*
1196              * Inverse ADPCM if in prediction mode
1197              */
1198             if (s->prediction_mode[k][l]) {
1199                 int n;
1200                 for (m = 0; m < 8; m++) {
1201                     for (n = 1; n <= 4; n++)
1202                         if (m >= n)
1203                             subband_samples[k][l][m] +=
1204                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1205                                  subband_samples[k][l][m - n] / 8192);
1206                         else if (s->predictor_history)
1207                             subband_samples[k][l][m] +=
1208                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1209                                  s->subband_samples_hist[k][l][m - n + 4] / 8192);
1210                 }
1211             }
1212         }
1213
1214         /*
1215          * Decode VQ encoded high frequencies
1216          */
1217         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1218             /* 1 vector -> 32 samples but we only need the 8 samples
1219              * for this subsubframe. */
1220             int hfvq = s->high_freq_vq[k][l];
1221
1222             if (!s->debug_flag & 0x01) {
1223                 av_log(s->avctx, AV_LOG_DEBUG,
1224                        "Stream with high frequencies VQ coding\n");
1225                 s->debug_flag |= 0x01;
1226             }
1227
1228             int8x8_fmul_int32(subband_samples[k][l],
1229                               &high_freq_vq[hfvq][subsubframe * 8],
1230                               s->scale_factor[k][l][0]);
1231         }
1232     }
1233
1234     /* Check for DSYNC after subsubframe */
1235     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1236         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1237 #ifdef TRACE
1238             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1239 #endif
1240         } else {
1241             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1242         }
1243     }
1244
1245     /* Backup predictor history for adpcm */
1246     for (k = base_channel; k < s->prim_channels; k++)
1247         for (l = 0; l < s->vq_start_subband[k]; l++)
1248             memcpy(s->subband_samples_hist[k][l],
1249                    &subband_samples[k][l][4],
1250                    4 * sizeof(subband_samples[0][0][0]));
1251
1252     return 0;
1253 }
1254
1255 static int dca_filter_channels(DCAContext *s, int block_index)
1256 {
1257     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1258     int k;
1259
1260     /* 32 subbands QMF */
1261     for (k = 0; k < s->prim_channels; k++) {
1262 /*        static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1263                                             0, 8388608.0, 8388608.0 };*/
1264         qmf_32_subbands(s, k, subband_samples[k],
1265                         &s->samples[256 * s->channel_order_tab[k]],
1266                         M_SQRT1_2 * s->scale_bias /* pcm_to_double[s->source_pcm_res] */);
1267     }
1268
1269     /* Down mixing */
1270     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1271         dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
1272     }
1273
1274     /* Generate LFE samples for this subsubframe FIXME!!! */
1275     if (s->output & DCA_LFE) {
1276         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1277                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1278                               &s->samples[256 * dca_lfe_index[s->amode]],
1279                               (1.0 / 256.0) * s->scale_bias);
1280         /* Outputs 20bits pcm samples */
1281     }
1282
1283     return 0;
1284 }
1285
1286
1287 static int dca_subframe_footer(DCAContext *s, int base_channel)
1288 {
1289     int aux_data_count = 0, i;
1290
1291     /*
1292      * Unpack optional information
1293      */
1294
1295     /* presumably optional information only appears in the core? */
1296     if (!base_channel) {
1297         if (s->timestamp)
1298             skip_bits_long(&s->gb, 32);
1299
1300         if (s->aux_data)
1301             aux_data_count = get_bits(&s->gb, 6);
1302
1303         for (i = 0; i < aux_data_count; i++)
1304             get_bits(&s->gb, 8);
1305
1306         if (s->crc_present && (s->downmix || s->dynrange))
1307             get_bits(&s->gb, 16);
1308     }
1309
1310     return 0;
1311 }
1312
1313 /**
1314  * Decode a dca frame block
1315  *
1316  * @param s     pointer to the DCAContext
1317  */
1318
1319 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1320 {
1321     int ret;
1322
1323     /* Sanity check */
1324     if (s->current_subframe >= s->subframes) {
1325         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1326                s->current_subframe, s->subframes);
1327         return AVERROR_INVALIDDATA;
1328     }
1329
1330     if (!s->current_subsubframe) {
1331 #ifdef TRACE
1332         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1333 #endif
1334         /* Read subframe header */
1335         if ((ret = dca_subframe_header(s, base_channel, block_index)))
1336             return ret;
1337     }
1338
1339     /* Read subsubframe */
1340 #ifdef TRACE
1341     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1342 #endif
1343     if ((ret = dca_subsubframe(s, base_channel, block_index)))
1344         return ret;
1345
1346     /* Update state */
1347     s->current_subsubframe++;
1348     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1349         s->current_subsubframe = 0;
1350         s->current_subframe++;
1351     }
1352     if (s->current_subframe >= s->subframes) {
1353 #ifdef TRACE
1354         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1355 #endif
1356         /* Read subframe footer */
1357         if ((ret = dca_subframe_footer(s, base_channel)))
1358             return ret;
1359     }
1360
1361     return 0;
1362 }
1363
1364 /**
1365  * Return the number of channels in an ExSS speaker mask (HD)
1366  */
1367 static int dca_exss_mask2count(int mask)
1368 {
1369     /* count bits that mean speaker pairs twice */
1370     return av_popcount(mask) +
1371            av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT      |
1372                                DCA_EXSS_FRONT_LEFT_RIGHT       |
1373                                DCA_EXSS_FRONT_HIGH_LEFT_RIGHT  |
1374                                DCA_EXSS_WIDE_LEFT_RIGHT        |
1375                                DCA_EXSS_SIDE_LEFT_RIGHT        |
1376                                DCA_EXSS_SIDE_HIGH_LEFT_RIGHT   |
1377                                DCA_EXSS_SIDE_REAR_LEFT_RIGHT   |
1378                                DCA_EXSS_REAR_LEFT_RIGHT        |
1379                                DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1380 }
1381
1382 /**
1383  * Skip mixing coefficients of a single mix out configuration (HD)
1384  */
1385 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1386 {
1387     int i;
1388
1389     for (i = 0; i < channels; i++) {
1390         int mix_map_mask = get_bits(gb, out_ch);
1391         int num_coeffs = av_popcount(mix_map_mask);
1392         skip_bits_long(gb, num_coeffs * 6);
1393     }
1394 }
1395
1396 /**
1397  * Parse extension substream asset header (HD)
1398  */
1399 static int dca_exss_parse_asset_header(DCAContext *s)
1400 {
1401     int header_pos = get_bits_count(&s->gb);
1402     int header_size;
1403     int channels;
1404     int embedded_stereo = 0;
1405     int embedded_6ch    = 0;
1406     int drc_code_present;
1407     int extensions_mask;
1408     int i, j;
1409
1410     if (get_bits_left(&s->gb) < 16)
1411         return -1;
1412
1413     /* We will parse just enough to get to the extensions bitmask with which
1414      * we can set the profile value. */
1415
1416     header_size = get_bits(&s->gb, 9) + 1;
1417     skip_bits(&s->gb, 3); // asset index
1418
1419     if (s->static_fields) {
1420         if (get_bits1(&s->gb))
1421             skip_bits(&s->gb, 4); // asset type descriptor
1422         if (get_bits1(&s->gb))
1423             skip_bits_long(&s->gb, 24); // language descriptor
1424
1425         if (get_bits1(&s->gb)) {
1426             /* How can one fit 1024 bytes of text here if the maximum value
1427              * for the asset header size field above was 512 bytes? */
1428             int text_length = get_bits(&s->gb, 10) + 1;
1429             if (get_bits_left(&s->gb) < text_length * 8)
1430                 return -1;
1431             skip_bits_long(&s->gb, text_length * 8); // info text
1432         }
1433
1434         skip_bits(&s->gb, 5); // bit resolution - 1
1435         skip_bits(&s->gb, 4); // max sample rate code
1436         channels = get_bits(&s->gb, 8) + 1;
1437
1438         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1439             int spkr_remap_sets;
1440             int spkr_mask_size = 16;
1441             int num_spkrs[7];
1442
1443             if (channels > 2)
1444                 embedded_stereo = get_bits1(&s->gb);
1445             if (channels > 6)
1446                 embedded_6ch = get_bits1(&s->gb);
1447
1448             if (get_bits1(&s->gb)) {
1449                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1450                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1451             }
1452
1453             spkr_remap_sets = get_bits(&s->gb, 3);
1454
1455             for (i = 0; i < spkr_remap_sets; i++) {
1456                 /* std layout mask for each remap set */
1457                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1458             }
1459
1460             for (i = 0; i < spkr_remap_sets; i++) {
1461                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1462                 if (get_bits_left(&s->gb) < 0)
1463                     return -1;
1464
1465                 for (j = 0; j < num_spkrs[i]; j++) {
1466                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1467                     int num_dec_ch = av_popcount(remap_dec_ch_mask);
1468                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1469                 }
1470             }
1471
1472         } else {
1473             skip_bits(&s->gb, 3); // representation type
1474         }
1475     }
1476
1477     drc_code_present = get_bits1(&s->gb);
1478     if (drc_code_present)
1479         get_bits(&s->gb, 8); // drc code
1480
1481     if (get_bits1(&s->gb))
1482         skip_bits(&s->gb, 5); // dialog normalization code
1483
1484     if (drc_code_present && embedded_stereo)
1485         get_bits(&s->gb, 8); // drc stereo code
1486
1487     if (s->mix_metadata && get_bits1(&s->gb)) {
1488         skip_bits(&s->gb, 1); // external mix
1489         skip_bits(&s->gb, 6); // post mix gain code
1490
1491         if (get_bits(&s->gb, 2) != 3) // mixer drc code
1492             skip_bits(&s->gb, 3); // drc limit
1493         else
1494             skip_bits(&s->gb, 8); // custom drc code
1495
1496         if (get_bits1(&s->gb)) // channel specific scaling
1497             for (i = 0; i < s->num_mix_configs; i++)
1498                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1499         else
1500             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1501
1502         for (i = 0; i < s->num_mix_configs; i++) {
1503             if (get_bits_left(&s->gb) < 0)
1504                 return -1;
1505             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1506             if (embedded_6ch)
1507                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1508             if (embedded_stereo)
1509                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1510         }
1511     }
1512
1513     switch (get_bits(&s->gb, 2)) {
1514     case 0: extensions_mask = get_bits(&s->gb, 12); break;
1515     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
1516     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
1517     case 3: extensions_mask = 0; /* aux coding */   break;
1518     }
1519
1520     /* not parsed further, we were only interested in the extensions mask */
1521
1522     if (get_bits_left(&s->gb) < 0)
1523         return -1;
1524
1525     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1526         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1527         return -1;
1528     }
1529     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1530
1531     if (extensions_mask & DCA_EXT_EXSS_XLL)
1532         s->profile = FF_PROFILE_DTS_HD_MA;
1533     else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1534                                 DCA_EXT_EXSS_XXCH))
1535         s->profile = FF_PROFILE_DTS_HD_HRA;
1536
1537     if (!(extensions_mask & DCA_EXT_CORE))
1538         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1539     if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1540         av_log(s->avctx, AV_LOG_WARNING,
1541                "DTS extensions detection mismatch (%d, %d)\n",
1542                extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1543
1544     return 0;
1545 }
1546
1547 /**
1548  * Parse extension substream header (HD)
1549  */
1550 static void dca_exss_parse_header(DCAContext *s)
1551 {
1552     int ss_index;
1553     int blownup;
1554     int num_audiop = 1;
1555     int num_assets = 1;
1556     int active_ss_mask[8];
1557     int i, j;
1558
1559     if (get_bits_left(&s->gb) < 52)
1560         return;
1561
1562     skip_bits(&s->gb, 8); // user data
1563     ss_index = get_bits(&s->gb, 2);
1564
1565     blownup = get_bits1(&s->gb);
1566     skip_bits(&s->gb,  8 + 4 * blownup); // header_size
1567     skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1568
1569     s->static_fields = get_bits1(&s->gb);
1570     if (s->static_fields) {
1571         skip_bits(&s->gb, 2); // reference clock code
1572         skip_bits(&s->gb, 3); // frame duration code
1573
1574         if (get_bits1(&s->gb))
1575             skip_bits_long(&s->gb, 36); // timestamp
1576
1577         /* a single stream can contain multiple audio assets that can be
1578          * combined to form multiple audio presentations */
1579
1580         num_audiop = get_bits(&s->gb, 3) + 1;
1581         if (num_audiop > 1) {
1582             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1583             /* ignore such streams for now */
1584             return;
1585         }
1586
1587         num_assets = get_bits(&s->gb, 3) + 1;
1588         if (num_assets > 1) {
1589             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1590             /* ignore such streams for now */
1591             return;
1592         }
1593
1594         for (i = 0; i < num_audiop; i++)
1595             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1596
1597         for (i = 0; i < num_audiop; i++)
1598             for (j = 0; j <= ss_index; j++)
1599                 if (active_ss_mask[i] & (1 << j))
1600                     skip_bits(&s->gb, 8); // active asset mask
1601
1602         s->mix_metadata = get_bits1(&s->gb);
1603         if (s->mix_metadata) {
1604             int mix_out_mask_size;
1605
1606             skip_bits(&s->gb, 2); // adjustment level
1607             mix_out_mask_size  = (get_bits(&s->gb, 2) + 1) << 2;
1608             s->num_mix_configs =  get_bits(&s->gb, 2) + 1;
1609
1610             for (i = 0; i < s->num_mix_configs; i++) {
1611                 int mix_out_mask        = get_bits(&s->gb, mix_out_mask_size);
1612                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1613             }
1614         }
1615     }
1616
1617     for (i = 0; i < num_assets; i++)
1618         skip_bits_long(&s->gb, 16 + 4 * blownup);  // asset size
1619
1620     for (i = 0; i < num_assets; i++) {
1621         if (dca_exss_parse_asset_header(s))
1622             return;
1623     }
1624
1625     /* not parsed further, we were only interested in the extensions mask
1626      * from the asset header */
1627 }
1628
1629 /**
1630  * Main frame decoding function
1631  * FIXME add arguments
1632  */
1633 static int dca_decode_frame(AVCodecContext *avctx, void *data,
1634                             int *got_frame_ptr, AVPacket *avpkt)
1635 {
1636     const uint8_t *buf = avpkt->data;
1637     int buf_size = avpkt->size;
1638
1639     int lfe_samples;
1640     int num_core_channels = 0;
1641     int i, ret;
1642     float   *samples_flt;
1643     int16_t *samples_s16;
1644     DCAContext *s = avctx->priv_data;
1645     int channels;
1646     int core_ss_end;
1647
1648
1649     s->xch_present = 0;
1650
1651     s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1652                                                   DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1653     if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
1654         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1655         return AVERROR_INVALIDDATA;
1656     }
1657
1658     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1659     if ((ret = dca_parse_frame_header(s)) < 0) {
1660         //seems like the frame is corrupt, try with the next one
1661         return ret;
1662     }
1663     //set AVCodec values with parsed data
1664     avctx->sample_rate = s->sample_rate;
1665     avctx->bit_rate    = s->bit_rate;
1666
1667     s->profile = FF_PROFILE_DTS;
1668
1669     for (i = 0; i < (s->sample_blocks / 8); i++) {
1670         if ((ret = dca_decode_block(s, 0, i))) {
1671             av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
1672             return ret;
1673         }
1674     }
1675
1676     /* record number of core channels incase less than max channels are requested */
1677     num_core_channels = s->prim_channels;
1678
1679     if (s->ext_coding)
1680         s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
1681     else
1682         s->core_ext_mask = 0;
1683
1684     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1685
1686     /* only scan for extensions if ext_descr was unknown or indicated a
1687      * supported XCh extension */
1688     if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
1689
1690         /* if ext_descr was unknown, clear s->core_ext_mask so that the
1691          * extensions scan can fill it up */
1692         s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
1693
1694         /* extensions start at 32-bit boundaries into bitstream */
1695         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1696
1697         while (core_ss_end - get_bits_count(&s->gb) >= 32) {
1698             uint32_t bits = get_bits_long(&s->gb, 32);
1699
1700             switch (bits) {
1701             case 0x5a5a5a5a: {
1702                 int ext_amode, xch_fsize;
1703
1704                 s->xch_base_channel = s->prim_channels;
1705
1706                 /* validate sync word using XCHFSIZE field */
1707                 xch_fsize = show_bits(&s->gb, 10);
1708                 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1709                     (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1710                     continue;
1711
1712                 /* skip length-to-end-of-frame field for the moment */
1713                 skip_bits(&s->gb, 10);
1714
1715                 s->core_ext_mask |= DCA_EXT_XCH;
1716
1717                 /* extension amode(number of channels in extension) should be 1 */
1718                 /* AFAIK XCh is not used for more channels */
1719                 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1720                     av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1721                            " supported!\n", ext_amode);
1722                     continue;
1723                 }
1724
1725                 /* much like core primary audio coding header */
1726                 dca_parse_audio_coding_header(s, s->xch_base_channel);
1727
1728                 for (i = 0; i < (s->sample_blocks / 8); i++)
1729                     if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
1730                         av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
1731                         continue;
1732                     }
1733
1734                 s->xch_present = 1;
1735                 break;
1736             }
1737             case 0x47004a03:
1738                 /* XXCh: extended channels */
1739                 /* usually found either in core or HD part in DTS-HD HRA streams,
1740                  * but not in DTS-ES which contains XCh extensions instead */
1741                 s->core_ext_mask |= DCA_EXT_XXCH;
1742                 break;
1743
1744             case 0x1d95f262: {
1745                 int fsize96 = show_bits(&s->gb, 12) + 1;
1746                 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1747                     continue;
1748
1749                 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
1750                        get_bits_count(&s->gb));
1751                 skip_bits(&s->gb, 12);
1752                 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1753                 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1754
1755                 s->core_ext_mask |= DCA_EXT_X96;
1756                 break;
1757             }
1758             }
1759
1760             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1761         }
1762     } else {
1763         /* no supported extensions, skip the rest of the core substream */
1764         skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
1765     }
1766
1767     if (s->core_ext_mask & DCA_EXT_X96)
1768         s->profile = FF_PROFILE_DTS_96_24;
1769     else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
1770         s->profile = FF_PROFILE_DTS_ES;
1771
1772     /* check for ExSS (HD part) */
1773     if (s->dca_buffer_size - s->frame_size > 32 &&
1774         get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1775         dca_exss_parse_header(s);
1776
1777     avctx->profile = s->profile;
1778
1779     channels = s->prim_channels + !!s->lfe;
1780
1781     if (s->amode < 16) {
1782         avctx->channel_layout = dca_core_channel_layout[s->amode];
1783
1784         if (s->xch_present && (!avctx->request_channels ||
1785                                avctx->request_channels > num_core_channels + !!s->lfe)) {
1786             avctx->channel_layout |= AV_CH_BACK_CENTER;
1787             if (s->lfe) {
1788                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1789                 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1790             } else {
1791                 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1792             }
1793         } else {
1794             channels = num_core_channels + !!s->lfe;
1795             s->xch_present = 0; /* disable further xch processing */
1796             if (s->lfe) {
1797                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1798                 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1799             } else
1800                 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1801         }
1802
1803         if (channels > !!s->lfe &&
1804             s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1805             return AVERROR_INVALIDDATA;
1806
1807         if (avctx->request_channels == 2 && s->prim_channels > 2) {
1808             channels = 2;
1809             s->output = DCA_STEREO;
1810             avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1811         }
1812     } else {
1813         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
1814         return AVERROR_INVALIDDATA;
1815     }
1816
1817
1818     /* There is nothing that prevents a dts frame to change channel configuration
1819        but Libav doesn't support that so only set the channels if it is previously
1820        unset. Ideally during the first probe for channels the crc should be checked
1821        and only set avctx->channels when the crc is ok. Right now the decoder could
1822        set the channels based on a broken first frame.*/
1823     if (s->is_channels_set == 0) {
1824         s->is_channels_set = 1;
1825         avctx->channels = channels;
1826     }
1827     if (avctx->channels != channels) {
1828         av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
1829                "channels changing in stream. Skipping frame.\n");
1830         return AVERROR_PATCHWELCOME;
1831     }
1832
1833     /* get output buffer */
1834     s->frame.nb_samples = 256 * (s->sample_blocks / 8);
1835     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1836         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1837         return ret;
1838     }
1839     samples_flt = (float *)   s->frame.data[0];
1840     samples_s16 = (int16_t *) s->frame.data[0];
1841
1842     /* filter to get final output */
1843     for (i = 0; i < (s->sample_blocks / 8); i++) {
1844         dca_filter_channels(s, i);
1845
1846         /* If this was marked as a DTS-ES stream we need to subtract back- */
1847         /* channel from SL & SR to remove matrixed back-channel signal */
1848         if ((s->source_pcm_res & 1) && s->xch_present) {
1849             float *back_chan = s->samples + s->channel_order_tab[s->xch_base_channel]     * 256;
1850             float *lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1851             float *rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1852             s->dsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
1853             s->dsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
1854         }
1855
1856         if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1857             s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
1858                                          channels);
1859             samples_flt += 256 * channels;
1860         } else {
1861             s->fmt_conv.float_to_int16_interleave(samples_s16,
1862                                                   s->samples_chanptr, 256,
1863                                                   channels);
1864             samples_s16 += 256 * channels;
1865         }
1866     }
1867
1868     /* update lfe history */
1869     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1870     for (i = 0; i < 2 * s->lfe * 4; i++)
1871         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1872
1873     *got_frame_ptr    = 1;
1874     *(AVFrame *) data = s->frame;
1875
1876     return buf_size;
1877 }
1878
1879
1880
1881 /**
1882  * DCA initialization
1883  *
1884  * @param avctx     pointer to the AVCodecContext
1885  */
1886
1887 static av_cold int dca_decode_init(AVCodecContext *avctx)
1888 {
1889     DCAContext *s = avctx->priv_data;
1890     int i;
1891
1892     s->avctx = avctx;
1893     dca_init_vlcs();
1894
1895     ff_dsputil_init(&s->dsp, avctx);
1896     ff_mdct_init(&s->imdct, 6, 1, 1.0);
1897     ff_synth_filter_init(&s->synth);
1898     ff_dcadsp_init(&s->dcadsp);
1899     ff_fmt_convert_init(&s->fmt_conv, avctx);
1900
1901     for (i = 0; i < DCA_PRIM_CHANNELS_MAX + 1; i++)
1902         s->samples_chanptr[i] = s->samples + i * 256;
1903
1904     if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
1905         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1906         s->scale_bias     = 1.0 / 32768.0;
1907     } else {
1908         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1909         s->scale_bias     = 1.0;
1910     }
1911
1912     /* allow downmixing to stereo */
1913     if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1914         avctx->request_channels == 2) {
1915         avctx->channels = avctx->request_channels;
1916     }
1917
1918     avcodec_get_frame_defaults(&s->frame);
1919     avctx->coded_frame = &s->frame;
1920
1921     return 0;
1922 }
1923
1924 static av_cold int dca_decode_end(AVCodecContext *avctx)
1925 {
1926     DCAContext *s = avctx->priv_data;
1927     ff_mdct_end(&s->imdct);
1928     return 0;
1929 }
1930
1931 static const AVProfile profiles[] = {
1932     { FF_PROFILE_DTS,        "DTS"        },
1933     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
1934     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
1935     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1936     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
1937     { FF_PROFILE_UNKNOWN },
1938 };
1939
1940 AVCodec ff_dca_decoder = {
1941     .name            = "dca",
1942     .type            = AVMEDIA_TYPE_AUDIO,
1943     .id              = CODEC_ID_DTS,
1944     .priv_data_size  = sizeof(DCAContext),
1945     .init            = dca_decode_init,
1946     .decode          = dca_decode_frame,
1947     .close           = dca_decode_end,
1948     .long_name       = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1949     .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
1950     .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
1951                                                        AV_SAMPLE_FMT_S16,
1952                                                        AV_SAMPLE_FMT_NONE },
1953     .profiles        = NULL_IF_CONFIG_SMALL(profiles),
1954 };