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