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 FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 #include <math.h>
  26 #include <stddef.h>
  27 #include <stdio.h>
  28
  29 #include "libavutil/channel_layout.h"
  30 #include "libavutil/common.h"
  31 #include "libavutil/float_dsp.h"
  32 #include "libavutil/intmath.h"
  33 #include "libavutil/intreadwrite.h"
  34 #include "libavutil/mathematics.h"
  35 #include "libavutil/samplefmt.h"
  36 #include "avcodec.h"
  37 #include "dsputil.h"
  38 #include "fft.h"
  39 #include "get_bits.h"
  40 #include "put_bits.h"
  41 #include "dcadata.h"
  42 #include "dcahuff.h"
  43 #include "dca.h"
  44 #include "dca_parser.h"
  45 #include "synth_filter.h"
  46 #include "dcadsp.h"
  47 #include "fmtconvert.h"
  48 #include "internal.h"
  49
  50 #if ARCH_ARM
  51 #   include "arm/dca.h"
  52 #endif
  53
  54 //#define TRACE
  55
  56 #define DCA_PRIM_CHANNELS_MAX  (7)
  57 #define DCA_SUBBANDS          (64)
  58 #define DCA_ABITS_MAX         (32)      /* Should be 28 */
  59 #define DCA_SUBSUBFRAMES_MAX   (4)
  60 #define DCA_SUBFRAMES_MAX     (16)
  61 #define DCA_BLOCKS_MAX        (16)
  62 #define DCA_LFE_MAX            (3)
  63 #define DCA_CHSETS_MAX         (4)
  64 #define DCA_CHSET_CHANS_MAX    (8)
  65
  66 enum DCAMode {
  67     DCA_MONO = 0,
  68     DCA_CHANNEL,
  69     DCA_STEREO,
  70     DCA_STEREO_SUMDIFF,
  71     DCA_STEREO_TOTAL,
  72     DCA_3F,
  73     DCA_2F1R,
  74     DCA_3F1R,
  75     DCA_2F2R,
  76     DCA_3F2R,
  77     DCA_4F2R
  78 };
  79
  80 /* these are unconfirmed but should be mostly correct */
  81 enum DCAExSSSpeakerMask {
  82     DCA_EXSS_FRONT_CENTER          = 0x0001,
  83     DCA_EXSS_FRONT_LEFT_RIGHT      = 0x0002,
  84     DCA_EXSS_SIDE_REAR_LEFT_RIGHT  = 0x0004,
  85     DCA_EXSS_LFE                   = 0x0008,
  86     DCA_EXSS_REAR_CENTER           = 0x0010,
  87     DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
  88     DCA_EXSS_REAR_LEFT_RIGHT       = 0x0040,
  89     DCA_EXSS_FRONT_HIGH_CENTER     = 0x0080,
  90     DCA_EXSS_OVERHEAD              = 0x0100,
  91     DCA_EXSS_CENTER_LEFT_RIGHT     = 0x0200,
  92     DCA_EXSS_WIDE_LEFT_RIGHT       = 0x0400,
  93     DCA_EXSS_SIDE_LEFT_RIGHT       = 0x0800,
  94     DCA_EXSS_LFE2                  = 0x1000,
  95     DCA_EXSS_SIDE_HIGH_LEFT_RIGHT  = 0x2000,
  96     DCA_EXSS_REAR_HIGH_CENTER      = 0x4000,
  97     DCA_EXSS_REAR_HIGH_LEFT_RIGHT  = 0x8000,
  98 };
  99
 100 enum DCAXxchSpeakerMask {
 101     DCA_XXCH_FRONT_CENTER          = 0x0000001,
 102     DCA_XXCH_FRONT_LEFT            = 0x0000002,
 103     DCA_XXCH_FRONT_RIGHT           = 0x0000004,
 104     DCA_XXCH_SIDE_REAR_LEFT        = 0x0000008,
 105     DCA_XXCH_SIDE_REAR_RIGHT       = 0x0000010,
 106     DCA_XXCH_LFE1                  = 0x0000020,
 107     DCA_XXCH_REAR_CENTER           = 0x0000040,
 108     DCA_XXCH_SURROUND_REAR_LEFT    = 0x0000080,
 109     DCA_XXCH_SURROUND_REAR_RIGHT   = 0x0000100,
 110     DCA_XXCH_SIDE_SURROUND_LEFT    = 0x0000200,
 111     DCA_XXCH_SIDE_SURROUND_RIGHT   = 0x0000400,
 112     DCA_XXCH_FRONT_CENTER_LEFT     = 0x0000800,
 113     DCA_XXCH_FRONT_CENTER_RIGHT    = 0x0001000,
 114     DCA_XXCH_FRONT_HIGH_LEFT       = 0x0002000,
 115     DCA_XXCH_FRONT_HIGH_CENTER     = 0x0004000,
 116     DCA_XXCH_FRONT_HIGH_RIGHT      = 0x0008000,
 117     DCA_XXCH_LFE2                  = 0x0010000,
 118     DCA_XXCH_SIDE_FRONT_LEFT       = 0x0020000,
 119     DCA_XXCH_SIDE_FRONT_RIGHT      = 0x0040000,
 120     DCA_XXCH_OVERHEAD              = 0x0080000,
 121     DCA_XXCH_SIDE_HIGH_LEFT        = 0x0100000,
 122     DCA_XXCH_SIDE_HIGH_RIGHT       = 0x0200000,
 123     DCA_XXCH_REAR_HIGH_CENTER      = 0x0400000,
 124     DCA_XXCH_REAR_HIGH_LEFT        = 0x0800000,
 125     DCA_XXCH_REAR_HIGH_RIGHT       = 0x1000000,
 126     DCA_XXCH_REAR_LOW_CENTER       = 0x2000000,
 127     DCA_XXCH_REAR_LOW_LEFT         = 0x4000000,
 128     DCA_XXCH_REAR_LOW_RIGHT        = 0x8000000,
 129 };
 130
 131 static const uint32_t map_xxch_to_native[28] = {
 132     AV_CH_FRONT_CENTER,
 133     AV_CH_FRONT_LEFT,
 134     AV_CH_FRONT_RIGHT,
 135     AV_CH_SIDE_LEFT,
 136     AV_CH_SIDE_RIGHT,
 137     AV_CH_LOW_FREQUENCY,
 138     AV_CH_BACK_CENTER,
 139     AV_CH_BACK_LEFT,
 140     AV_CH_BACK_RIGHT,
 141     AV_CH_SIDE_LEFT,           /* side surround left -- dup sur side L */
 142     AV_CH_SIDE_RIGHT,          /* side surround right -- dup sur side R */
 143     AV_CH_FRONT_LEFT_OF_CENTER,
 144     AV_CH_FRONT_RIGHT_OF_CENTER,
 145     AV_CH_TOP_FRONT_LEFT,
 146     AV_CH_TOP_FRONT_CENTER,
 147     AV_CH_TOP_FRONT_RIGHT,
 148     AV_CH_LOW_FREQUENCY,        /* lfe2 -- duplicate lfe1 position */
 149     AV_CH_FRONT_LEFT_OF_CENTER, /* side front left -- dup front cntr L */
 150     AV_CH_FRONT_RIGHT_OF_CENTER,/* side front right -- dup front cntr R */
 151     AV_CH_TOP_CENTER,           /* overhead */
 152     AV_CH_TOP_FRONT_LEFT,       /* side high left -- dup */
 153     AV_CH_TOP_FRONT_RIGHT,      /* side high right -- dup */
 154     AV_CH_TOP_BACK_CENTER,
 155     AV_CH_TOP_BACK_LEFT,
 156     AV_CH_TOP_BACK_RIGHT,
 157     AV_CH_BACK_CENTER,          /* rear low center -- dup */
 158     AV_CH_BACK_LEFT,            /* rear low left -- dup */
 159     AV_CH_BACK_RIGHT            /* read low right -- dup  */
 160 };
 161
 162 enum DCAExtensionMask {
 163     DCA_EXT_CORE       = 0x001, ///< core in core substream
 164     DCA_EXT_XXCH       = 0x002, ///< XXCh channels extension in core substream
 165     DCA_EXT_X96        = 0x004, ///< 96/24 extension in core substream
 166     DCA_EXT_XCH        = 0x008, ///< XCh channel extension in core substream
 167     DCA_EXT_EXSS_CORE  = 0x010, ///< core in ExSS (extension substream)
 168     DCA_EXT_EXSS_XBR   = 0x020, ///< extended bitrate extension in ExSS
 169     DCA_EXT_EXSS_XXCH  = 0x040, ///< XXCh channels extension in ExSS
 170     DCA_EXT_EXSS_X96   = 0x080, ///< 96/24 extension in ExSS
 171     DCA_EXT_EXSS_LBR   = 0x100, ///< low bitrate component in ExSS
 172     DCA_EXT_EXSS_XLL   = 0x200, ///< lossless extension in ExSS
 173 };
 174
 175 /* -1 are reserved or unknown */
 176 static const int dca_ext_audio_descr_mask[] = {
 177     DCA_EXT_XCH,
 178     -1,
 179     DCA_EXT_X96,
 180     DCA_EXT_XCH | DCA_EXT_X96,
 181     -1,
 182     -1,
 183     DCA_EXT_XXCH,
 184     -1,
 185 };
 186
 187 /* extensions that reside in core substream */
 188 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
 189
 190 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
 191  * Some compromises have been made for special configurations. Most configurations
 192  * are never used so complete accuracy is not needed.
 193  *
 194  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
 195  * S  -> side, when both rear and back are configured move one of them to the side channel
 196  * OV -> center back
 197  * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
 198  */
 199 static const uint64_t dca_core_channel_layout[] = {
 200     AV_CH_FRONT_CENTER,                                                     ///< 1, A
 201     AV_CH_LAYOUT_STEREO,                                                    ///< 2, A + B (dual mono)
 202     AV_CH_LAYOUT_STEREO,                                                    ///< 2, L + R (stereo)
 203     AV_CH_LAYOUT_STEREO,                                                    ///< 2, (L + R) + (L - R) (sum-difference)
 204     AV_CH_LAYOUT_STEREO,                                                    ///< 2, LT + RT (left and right total)
 205     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER,                               ///< 3, C + L + R
 206     AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER,                                ///< 3, L + R + S
 207     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER,           ///< 4, C + L + R + S
 208     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,               ///< 4, L + R + SL + SR
 209
 210     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
 211     AV_CH_SIDE_RIGHT,                                                       ///< 5, C + L + R + SL + SR
 212
 213     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
 214     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER,               ///< 6, CL + CR + L + R + SL + SR
 215
 216     AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
 217     AV_CH_FRONT_CENTER  | AV_CH_BACK_CENTER,                                ///< 6, C + L + R + LR + RR + OV
 218
 219     AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
 220     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER   |
 221     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 6, CF + CR + LF + RF + LR + RR
 222
 223     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
 224     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
 225     AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,                                     ///< 7, CL + C + CR + L + R + SL + SR
 226
 227     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
 228     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
 229     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2
 230
 231     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
 232     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
 233     AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT,                 ///< 8, CL + C + CR + L + R + SL + S + SR
 234 };
 235
 236 static const int8_t dca_lfe_index[] = {
 237     1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
 238 };
 239
 240 static const int8_t dca_channel_reorder_lfe[][9] = {
 241     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
 242     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 243     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 244     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 245     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 246     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
 247     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
 248     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
 249     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
 250     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
 251     { 3,  4,  0,  1,  5,  6, -1, -1, -1},
 252     { 2,  0,  1,  4,  5,  6, -1, -1, -1},
 253     { 0,  6,  4,  5,  2,  3, -1, -1, -1},
 254     { 4,  2,  5,  0,  1,  6,  7, -1, -1},
 255     { 5,  6,  0,  1,  7,  3,  8,  4, -1},
 256     { 4,  2,  5,  0,  1,  6,  8,  7, -1},
 257 };
 258
 259 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
 260     { 0,  2, -1, -1, -1, -1, -1, -1, -1},
 261     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
 262     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
 263     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
 264     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
 265     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
 266     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
 267     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
 268     { 0,  1,  4,  5,  3, -1, -1, -1, -1},
 269     { 2,  0,  1,  5,  6,  4, -1, -1, -1},
 270     { 3,  4,  0,  1,  6,  7,  5, -1, -1},
 271     { 2,  0,  1,  4,  5,  6,  7, -1, -1},
 272     { 0,  6,  4,  5,  2,  3,  7, -1, -1},
 273     { 4,  2,  5,  0,  1,  7,  8,  6, -1},
 274     { 5,  6,  0,  1,  8,  3,  9,  4,  7},
 275     { 4,  2,  5,  0,  1,  6,  9,  8,  7},
 276 };
 277
 278 static const int8_t dca_channel_reorder_nolfe[][9] = {
 279     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
 280     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 281     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 282     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 283     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 284     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
 285     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
 286     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
 287     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
 288     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
 289     { 2,  3,  0,  1,  4,  5, -1, -1, -1},
 290     { 2,  0,  1,  3,  4,  5, -1, -1, -1},
 291     { 0,  5,  3,  4,  1,  2, -1, -1, -1},
 292     { 3,  2,  4,  0,  1,  5,  6, -1, -1},
 293     { 4,  5,  0,  1,  6,  2,  7,  3, -1},
 294     { 3,  2,  4,  0,  1,  5,  7,  6, -1},
 295 };
 296
 297 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
 298     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
 299     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
 300     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
 301     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
 302     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
 303     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
 304     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
 305     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
 306     { 0,  1,  3,  4,  2, -1, -1, -1, -1},
 307     { 2,  0,  1,  4,  5,  3, -1, -1, -1},
 308     { 2,  3,  0,  1,  5,  6,  4, -1, -1},
 309     { 2,  0,  1,  3,  4,  5,  6, -1, -1},
 310     { 0,  5,  3,  4,  1,  2,  6, -1, -1},
 311     { 3,  2,  4,  0,  1,  6,  7,  5, -1},
 312     { 4,  5,  0,  1,  7,  2,  8,  3,  6},
 313     { 3,  2,  4,  0,  1,  5,  8,  7,  6},
 314 };
 315
 316 #define DCA_DOLBY                  101           /* FIXME */
 317
 318 #define DCA_CHANNEL_BITS             6
 319 #define DCA_CHANNEL_MASK          0x3F
 320
 321 #define DCA_LFE                   0x80
 322
 323 #define HEADER_SIZE                 14
 324
 325 #define DCA_MAX_FRAME_SIZE       16384
 326 #define DCA_MAX_EXSS_HEADER_SIZE  4096
 327
 328 #define DCA_BUFFER_PADDING_SIZE   1024
 329
 330 /** Bit allocation */
 331 typedef struct {
 332     int offset;                 ///< code values offset
 333     int maxbits[8];             ///< max bits in VLC
 334     int wrap;                   ///< wrap for get_vlc2()
 335     VLC vlc[8];                 ///< actual codes
 336 } BitAlloc;
 337
 338 static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
 339 static BitAlloc dca_tmode;             ///< transition mode VLCs
 340 static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
 341 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
 342
 343 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
 344                                          int idx)
 345 {
 346     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
 347            ba->offset;
 348 }
 349
 350 typedef struct {
 351     AVCodecContext *avctx;
 352     AVFrame frame;
 353     /* Frame header */
 354     int frame_type;             ///< type of the current frame
 355     int samples_deficit;        ///< deficit sample count
 356     int crc_present;            ///< crc is present in the bitstream
 357     int sample_blocks;          ///< number of PCM sample blocks
 358     int frame_size;             ///< primary frame byte size
 359     int amode;                  ///< audio channels arrangement
 360     int sample_rate;            ///< audio sampling rate
 361     int bit_rate;               ///< transmission bit rate
 362     int bit_rate_index;         ///< transmission bit rate index
 363
 364     int downmix;                ///< embedded downmix enabled
 365     int dynrange;               ///< embedded dynamic range flag
 366     int timestamp;              ///< embedded time stamp flag
 367     int aux_data;               ///< auxiliary data flag
 368     int hdcd;                   ///< source material is mastered in HDCD
 369     int ext_descr;              ///< extension audio descriptor flag
 370     int ext_coding;             ///< extended coding flag
 371     int aspf;                   ///< audio sync word insertion flag
 372     int lfe;                    ///< low frequency effects flag
 373     int predictor_history;      ///< predictor history flag
 374     int header_crc;             ///< header crc check bytes
 375     int multirate_inter;        ///< multirate interpolator switch
 376     int version;                ///< encoder software revision
 377     int copy_history;           ///< copy history
 378     int source_pcm_res;         ///< source pcm resolution
 379     int front_sum;              ///< front sum/difference flag
 380     int surround_sum;           ///< surround sum/difference flag
 381     int dialog_norm;            ///< dialog normalisation parameter
 382
 383     /* Primary audio coding header */
 384     int subframes;              ///< number of subframes
 385     int total_channels;         ///< number of channels including extensions
 386     int prim_channels;          ///< number of primary audio channels
 387     int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
 388     int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
 389     int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
 390     int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
 391     int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
 392     int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
 393     int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
 394     float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
 395
 396     /* Primary audio coding side information */
 397     int subsubframes[DCA_SUBFRAMES_MAX];                         ///< number of subsubframes
 398     int partial_samples[DCA_SUBFRAMES_MAX];                      ///< partial subsubframe samples count
 399     int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
 400     int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
 401     int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
 402     int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
 403     int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
 404     int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
 405     int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
 406     int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
 407     int dynrange_coef;                                           ///< dynamic range coefficient
 408
 409     int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
 410
 411     float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      ///< Low frequency effect data
 412     int lfe_scale_factor;
 413
 414     /* Subband samples history (for ADPCM) */
 415     DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
 416     DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
 417     DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
 418     int hist_index[DCA_PRIM_CHANNELS_MAX];
 419     DECLARE_ALIGNED(32, float, raXin)[32];
 420
 421     int output;                 ///< type of output
 422
 423     DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
 424     float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
 425     float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
 426     uint8_t *extra_channels_buffer;
 427     unsigned int extra_channels_buffer_size;
 428
 429     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
 430     int dca_buffer_size;        ///< how much data is in the dca_buffer
 431
 432     const int8_t *channel_order_tab;  ///< channel reordering table, lfe and non lfe
 433     GetBitContext gb;
 434     /* Current position in DCA frame */
 435     int current_subframe;
 436     int current_subsubframe;
 437
 438     int core_ext_mask;          ///< present extensions in the core substream
 439
 440     /* XCh extension information */
 441     int xch_present;            ///< XCh extension present and valid
 442     int xch_base_channel;       ///< index of first (only) channel containing XCH data
 443
 444     /* XXCH extension information */
 445     int xxch_chset;
 446     int xxch_nbits_spk_mask;
 447     uint32_t xxch_core_spkmask;
 448     uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */
 449     int xxch_chset_nch[4];
 450     float xxch_dmix_sf[DCA_CHSETS_MAX];
 451
 452     uint32_t xxch_dmix_embedded;  /* lower layer has mix pre-embedded, per chset */
 453     float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */
 454
 455     int8_t xxch_order_tab[32];
 456     int8_t lfe_index;
 457
 458     /* ExSS header parser */
 459     int static_fields;          ///< static fields present
 460     int mix_metadata;           ///< mixing metadata present
 461     int num_mix_configs;        ///< number of mix out configurations
 462     int mix_config_num_ch[4];   ///< number of channels in each mix out configuration
 463
 464     int profile;
 465
 466     int debug_flag;             ///< used for suppressing repeated error messages output
 467     AVFloatDSPContext fdsp;
 468     FFTContext imdct;
 469     SynthFilterContext synth;
 470     DCADSPContext dcadsp;
 471     FmtConvertContext fmt_conv;
 472 } DCAContext;
 473
 474 static const uint16_t dca_vlc_offs[] = {
 475         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
 476      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
 477      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
 478      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
 479     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
 480     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
 481 };
 482
 483 static av_cold void dca_init_vlcs(void)
 484 {
 485     static int vlcs_initialized = 0;
 486     int i, j, c = 14;
 487     static VLC_TYPE dca_table[23622][2];
 488
 489     if (vlcs_initialized)
 490         return;
 491
 492     dca_bitalloc_index.offset = 1;
 493     dca_bitalloc_index.wrap = 2;
 494     for (i = 0; i < 5; i++) {
 495         dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
 496         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
 497         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
 498                  bitalloc_12_bits[i], 1, 1,
 499                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 500     }
 501     dca_scalefactor.offset = -64;
 502     dca_scalefactor.wrap = 2;
 503     for (i = 0; i < 5; i++) {
 504         dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
 505         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
 506         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
 507                  scales_bits[i], 1, 1,
 508                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 509     }
 510     dca_tmode.offset = 0;
 511     dca_tmode.wrap = 1;
 512     for (i = 0; i < 4; i++) {
 513         dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
 514         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
 515         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
 516                  tmode_bits[i], 1, 1,
 517                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 518     }
 519
 520     for (i = 0; i < 10; i++)
 521         for (j = 0; j < 7; j++) {
 522             if (!bitalloc_codes[i][j])
 523                 break;
 524             dca_smpl_bitalloc[i + 1].offset                 = bitalloc_offsets[i];
 525             dca_smpl_bitalloc[i + 1].wrap                   = 1 + (j > 4);
 526             dca_smpl_bitalloc[i + 1].vlc[j].table           = &dca_table[dca_vlc_offs[c]];
 527             dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
 528
 529             init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
 530                      bitalloc_sizes[i],
 531                      bitalloc_bits[i][j], 1, 1,
 532                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
 533             c++;
 534         }
 535     vlcs_initialized = 1;
 536 }
 537
 538 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
 539 {
 540     while (len--)
 541         *dst++ = get_bits(gb, bits);
 542 }
 543
 544 static inline int dca_xxch2index(DCAContext *s, int xxch_ch)
 545 {
 546     int i, base, mask;
 547
 548     /* locate channel set containing the channel */
 549     for (i = -1, base = 0, mask = (s->xxch_core_spkmask & ~DCA_XXCH_LFE1);
 550          i <= s->xxch_chset && !(mask & xxch_ch); mask = s->xxch_spk_masks[++i])
 551         base += av_popcount(mask);
 552
 553     return base + av_popcount(mask & (xxch_ch - 1));
 554 }
 555
 556 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,
 557                                          int xxch)
 558 {
 559     int i, j;
 560     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
 561     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
 562     static const int thr[11]    = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
 563     int hdr_pos = 0, hdr_size = 0;
 564     float sign, mag, scale_factor;
 565     int this_chans, acc_mask;
 566     int embedded_downmix;
 567     int nchans, mask[8];
 568     int coeff, ichan;
 569
 570     /* xxch has arbitrary sized audio coding headers */
 571     if (xxch) {
 572         hdr_pos  = get_bits_count(&s->gb);
 573         hdr_size = get_bits(&s->gb, 7) + 1;
 574     }
 575
 576     nchans = get_bits(&s->gb, 3) + 1;
 577     s->total_channels = nchans + base_channel;
 578     s->prim_channels  = s->total_channels;
 579
 580     /* obtain speaker layout mask & downmix coefficients for XXCH */
 581     if (xxch) {
 582         acc_mask = s->xxch_core_spkmask;
 583
 584         this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6;
 585         s->xxch_spk_masks[s->xxch_chset] = this_chans;
 586         s->xxch_chset_nch[s->xxch_chset] = nchans;
 587
 588         for (i = 0; i <= s->xxch_chset; i++)
 589             acc_mask |= s->xxch_spk_masks[i];
 590
 591         /* check for downmixing information */
 592         if (get_bits1(&s->gb)) {
 593             embedded_downmix = get_bits1(&s->gb);
 594             scale_factor     =
 595                1.0f / dca_downmix_scale_factors[(get_bits(&s->gb, 6) - 1) << 2];
 596
 597             s->xxch_dmix_sf[s->xxch_chset] = scale_factor;
 598
 599             for (i = base_channel; i < s->prim_channels; i++) {
 600                 mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask);
 601             }
 602
 603             for (j = base_channel; j < s->prim_channels; j++) {
 604                 memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0]));
 605                 s->xxch_dmix_embedded |= (embedded_downmix << j);
 606                 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
 607                     if (mask[j] & (1 << i)) {
 608                         if ((1 << i) == DCA_XXCH_LFE1) {
 609                             av_log(s->avctx, AV_LOG_WARNING,
 610                                    "DCA-XXCH: dmix to LFE1 not supported.\n");
 611                             continue;
 612                         }
 613
 614                         coeff = get_bits(&s->gb, 7);
 615                         sign  = (coeff & 64) ? 1.0 : -1.0;
 616                         mag   = dca_downmix_scale_factors[((coeff & 63) - 1) << 2];
 617                         ichan = dca_xxch2index(s, 1 << i);
 618                         s->xxch_dmix_coeff[j][ichan] = sign * mag;
 619                     }
 620                 }
 621             }
 622         }
 623     }
 624
 625     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
 626         s->prim_channels = DCA_PRIM_CHANNELS_MAX;
 627
 628
 629     for (i = base_channel; i < s->prim_channels; i++) {
 630         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
 631         if (s->subband_activity[i] > DCA_SUBBANDS)
 632             s->subband_activity[i] = DCA_SUBBANDS;
 633     }
 634     for (i = base_channel; i < s->prim_channels; i++) {
 635         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
 636         if (s->vq_start_subband[i] > DCA_SUBBANDS)
 637             s->vq_start_subband[i] = DCA_SUBBANDS;
 638     }
 639     get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);
 640     get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);
 641     get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
 642     get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);
 643
 644     /* Get codebooks quantization indexes */
 645     if (!base_channel)
 646         memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
 647     for (j = 1; j < 11; j++)
 648         for (i = base_channel; i < s->prim_channels; i++)
 649             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
 650
 651     /* Get scale factor adjustment */
 652     for (j = 0; j < 11; j++)
 653         for (i = base_channel; i < s->prim_channels; i++)
 654             s->scalefactor_adj[i][j] = 1;
 655
 656     for (j = 1; j < 11; j++)
 657         for (i = base_channel; i < s->prim_channels; i++)
 658             if (s->quant_index_huffman[i][j] < thr[j])
 659                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
 660
 661     if (!xxch) {
 662         if (s->crc_present) {
 663             /* Audio header CRC check */
 664             get_bits(&s->gb, 16);
 665         }
 666     } else {
 667         /* Skip to the end of the header, also ignore CRC if present  */
 668         i = get_bits_count(&s->gb);
 669         if (hdr_pos + 8 * hdr_size > i)
 670             skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);
 671     }
 672
 673     s->current_subframe    = 0;
 674     s->current_subsubframe = 0;
 675
 676 #ifdef TRACE
 677     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
 678     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
 679     for (i = base_channel; i < s->prim_channels; i++) {
 680         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
 681                s->subband_activity[i]);
 682         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
 683                s->vq_start_subband[i]);
 684         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
 685                s->joint_intensity[i]);
 686         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
 687                s->transient_huffman[i]);
 688         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
 689                s->scalefactor_huffman[i]);
 690         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
 691                s->bitalloc_huffman[i]);
 692         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
 693         for (j = 0; j < 11; j++)
 694             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
 695         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 696         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
 697         for (j = 0; j < 11; j++)
 698             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
 699         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 700     }
 701 #endif
 702
 703     return 0;
 704 }
 705
 706 static int dca_parse_frame_header(DCAContext *s)
 707 {
 708     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
 709
 710     /* Sync code */
 711     skip_bits_long(&s->gb, 32);
 712
 713     /* Frame header */
 714     s->frame_type        = get_bits(&s->gb, 1);
 715     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
 716     s->crc_present       = get_bits(&s->gb, 1);
 717     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
 718     s->frame_size        = get_bits(&s->gb, 14) + 1;
 719     if (s->frame_size < 95)
 720         return AVERROR_INVALIDDATA;
 721     s->amode             = get_bits(&s->gb, 6);
 722     s->sample_rate       = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
 723     if (!s->sample_rate)
 724         return AVERROR_INVALIDDATA;
 725     s->bit_rate_index    = get_bits(&s->gb, 5);
 726     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
 727     if (!s->bit_rate)
 728         return AVERROR_INVALIDDATA;
 729
 730     s->downmix           = get_bits(&s->gb, 1); /* note: this is FixedBit == 0 */
 731     s->dynrange          = get_bits(&s->gb, 1);
 732     s->timestamp         = get_bits(&s->gb, 1);
 733     s->aux_data          = get_bits(&s->gb, 1);
 734     s->hdcd              = get_bits(&s->gb, 1);
 735     s->ext_descr         = get_bits(&s->gb, 3);
 736     s->ext_coding        = get_bits(&s->gb, 1);
 737     s->aspf              = get_bits(&s->gb, 1);
 738     s->lfe               = get_bits(&s->gb, 2);
 739     s->predictor_history = get_bits(&s->gb, 1);
 740
 741     if (s->lfe == 3) {
 742         s->lfe = 0;
 743         av_log_ask_for_sample(s->avctx, "LFE is 3\n");
 744         return AVERROR_PATCHWELCOME;
 745     }
 746
 747     /* TODO: check CRC */
 748     if (s->crc_present)
 749         s->header_crc    = get_bits(&s->gb, 16);
 750
 751     s->multirate_inter   = get_bits(&s->gb, 1);
 752     s->version           = get_bits(&s->gb, 4);
 753     s->copy_history      = get_bits(&s->gb, 2);
 754     s->source_pcm_res    = get_bits(&s->gb, 3);
 755     s->front_sum         = get_bits(&s->gb, 1);
 756     s->surround_sum      = get_bits(&s->gb, 1);
 757     s->dialog_norm       = get_bits(&s->gb, 4);
 758
 759     /* FIXME: channels mixing levels */
 760     s->output = s->amode;
 761     if (s->lfe)
 762         s->output |= DCA_LFE;
 763
 764 #ifdef TRACE
 765     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
 766     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
 767     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
 768     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
 769            s->sample_blocks, s->sample_blocks * 32);
 770     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
 771     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
 772            s->amode, dca_channels[s->amode]);
 773     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
 774            s->sample_rate);
 775     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
 776            s->bit_rate);
 777     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
 778     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
 779     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
 780     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
 781     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
 782     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
 783     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
 784     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
 785     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
 786     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
 787            s->predictor_history);
 788     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
 789     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
 790            s->multirate_inter);
 791     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
 792     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
 793     av_log(s->avctx, AV_LOG_DEBUG,
 794            "source pcm resolution: %i (%i bits/sample)\n",
 795            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
 796     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
 797     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
 798     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
 799     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 800 #endif
 801
 802     /* Primary audio coding header */
 803     s->subframes         = get_bits(&s->gb, 4) + 1;
 804
 805     return dca_parse_audio_coding_header(s, 0, 0);
 806 }
 807
 808
 809 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
 810 {
 811     if (level < 5) {
 812         /* huffman encoded */
 813         value += get_bitalloc(gb, &dca_scalefactor, level);
 814         value = av_clip(value, 0, (1 << log2range) - 1);
 815     } else if (level < 8) {
 816         if (level + 1 > log2range) {
 817             skip_bits(gb, level + 1 - log2range);
 818             value = get_bits(gb, log2range);
 819         } else {
 820             value = get_bits(gb, level + 1);
 821         }
 822     }
 823     return value;
 824 }
 825
 826 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
 827 {
 828     /* Primary audio coding side information */
 829     int j, k;
 830
 831     if (get_bits_left(&s->gb) < 0)
 832         return AVERROR_INVALIDDATA;
 833
 834     if (!base_channel) {
 835         s->subsubframes[s->current_subframe]    = get_bits(&s->gb, 2) + 1;
 836         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
 837     }
 838
 839     for (j = base_channel; j < s->prim_channels; j++) {
 840         for (k = 0; k < s->subband_activity[j]; k++)
 841             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
 842     }
 843
 844     /* Get prediction codebook */
 845     for (j = base_channel; j < s->prim_channels; j++) {
 846         for (k = 0; k < s->subband_activity[j]; k++) {
 847             if (s->prediction_mode[j][k] > 0) {
 848                 /* (Prediction coefficient VQ address) */
 849                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
 850             }
 851         }
 852     }
 853
 854     /* Bit allocation index */
 855     for (j = base_channel; j < s->prim_channels; j++) {
 856         for (k = 0; k < s->vq_start_subband[j]; k++) {
 857             if (s->bitalloc_huffman[j] == 6)
 858                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
 859             else if (s->bitalloc_huffman[j] == 5)
 860                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
 861             else if (s->bitalloc_huffman[j] == 7) {
 862                 av_log(s->avctx, AV_LOG_ERROR,
 863                        "Invalid bit allocation index\n");
 864                 return AVERROR_INVALIDDATA;
 865             } else {
 866                 s->bitalloc[j][k] =
 867                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
 868             }
 869
 870             if (s->bitalloc[j][k] > 26) {
 871                 av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
 872                         j, k, s->bitalloc[j][k]);
 873                 return AVERROR_INVALIDDATA;
 874             }
 875         }
 876     }
 877
 878     /* Transition mode */
 879     for (j = base_channel; j < s->prim_channels; j++) {
 880         for (k = 0; k < s->subband_activity[j]; k++) {
 881             s->transition_mode[j][k] = 0;
 882             if (s->subsubframes[s->current_subframe] > 1 &&
 883                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
 884                 s->transition_mode[j][k] =
 885                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
 886             }
 887         }
 888     }
 889
 890     if (get_bits_left(&s->gb) < 0)
 891         return AVERROR_INVALIDDATA;
 892
 893     for (j = base_channel; j < s->prim_channels; j++) {
 894         const uint32_t *scale_table;
 895         int scale_sum, log_size;
 896
 897         memset(s->scale_factor[j], 0,
 898                s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
 899
 900         if (s->scalefactor_huffman[j] == 6) {
 901             scale_table = scale_factor_quant7;
 902             log_size = 7;
 903         } else {
 904             scale_table = scale_factor_quant6;
 905             log_size = 6;
 906         }
 907
 908         /* When huffman coded, only the difference is encoded */
 909         scale_sum = 0;
 910
 911         for (k = 0; k < s->subband_activity[j]; k++) {
 912             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
 913                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
 914                 s->scale_factor[j][k][0] = scale_table[scale_sum];
 915             }
 916
 917             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
 918                 /* Get second scale factor */
 919                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
 920                 s->scale_factor[j][k][1] = scale_table[scale_sum];
 921             }
 922         }
 923     }
 924
 925     /* Joint subband scale factor codebook select */
 926     for (j = base_channel; j < s->prim_channels; j++) {
 927         /* Transmitted only if joint subband coding enabled */
 928         if (s->joint_intensity[j] > 0)
 929             s->joint_huff[j] = get_bits(&s->gb, 3);
 930     }
 931
 932     if (get_bits_left(&s->gb) < 0)
 933         return AVERROR_INVALIDDATA;
 934
 935     /* Scale factors for joint subband coding */
 936     for (j = base_channel; j < s->prim_channels; j++) {
 937         int source_channel;
 938
 939         /* Transmitted only if joint subband coding enabled */
 940         if (s->joint_intensity[j] > 0) {
 941             int scale = 0;
 942             source_channel = s->joint_intensity[j] - 1;
 943
 944             /* When huffman coded, only the difference is encoded
 945              * (is this valid as well for joint scales ???) */
 946
 947             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
 948                 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
 949                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
 950             }
 951
 952             if (!(s->debug_flag & 0x02)) {
 953                 av_log(s->avctx, AV_LOG_DEBUG,
 954                        "Joint stereo coding not supported\n");
 955                 s->debug_flag |= 0x02;
 956             }
 957         }
 958     }
 959
 960     /* Stereo downmix coefficients */
 961     if (!base_channel && s->prim_channels > 2) {
 962         if (s->downmix) {
 963             for (j = base_channel; j < s->prim_channels; j++) {
 964                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
 965                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
 966             }
 967         } else {
 968             int am = s->amode & DCA_CHANNEL_MASK;
 969             if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
 970                 av_log(s->avctx, AV_LOG_ERROR,
 971                        "Invalid channel mode %d\n", am);
 972                 return AVERROR_INVALIDDATA;
 973             }
 974             for (j = base_channel; j < FFMIN(s->prim_channels, FF_ARRAY_ELEMS(dca_default_coeffs[am])); j++) {
 975                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
 976                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
 977             }
 978         }
 979     }
 980
 981     /* Dynamic range coefficient */
 982     if (!base_channel && s->dynrange)
 983         s->dynrange_coef = get_bits(&s->gb, 8);
 984
 985     /* Side information CRC check word */
 986     if (s->crc_present) {
 987         get_bits(&s->gb, 16);
 988     }
 989
 990     /*
 991      * Primary audio data arrays
 992      */
 993
 994     /* VQ encoded high frequency subbands */
 995     for (j = base_channel; j < s->prim_channels; j++)
 996         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 997             /* 1 vector -> 32 samples */
 998             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
 999
1000     /* Low frequency effect data */
1001     if (!base_channel && s->lfe) {
1002         int quant7;
1003         /* LFE samples */
1004         int lfe_samples = 2 * s->lfe * (4 + block_index);
1005         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
1006         float lfe_scale;
1007
1008         for (j = lfe_samples; j < lfe_end_sample; j++) {
1009             /* Signed 8 bits int */
1010             s->lfe_data[j] = get_sbits(&s->gb, 8);
1011         }
1012
1013         /* Scale factor index */
1014         quant7 = get_bits(&s->gb, 8);
1015         if (quant7 > 127) {
1016             av_log_ask_for_sample(s->avctx, "LFEScaleIndex larger than 127\n");
1017             return AVERROR_INVALIDDATA;
1018         }
1019         s->lfe_scale_factor = scale_factor_quant7[quant7];
1020
1021         /* Quantization step size * scale factor */
1022         lfe_scale = 0.035 * s->lfe_scale_factor;
1023
1024         for (j = lfe_samples; j < lfe_end_sample; j++)
1025             s->lfe_data[j] *= lfe_scale;
1026     }
1027
1028 #ifdef TRACE
1029     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
1030            s->subsubframes[s->current_subframe]);
1031     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
1032            s->partial_samples[s->current_subframe]);
1033
1034     for (j = base_channel; j < s->prim_channels; j++) {
1035         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
1036         for (k = 0; k < s->subband_activity[j]; k++)
1037             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
1038         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1039     }
1040     for (j = base_channel; j < s->prim_channels; j++) {
1041         for (k = 0; k < s->subband_activity[j]; k++)
1042             av_log(s->avctx, AV_LOG_DEBUG,
1043                    "prediction coefs: %f, %f, %f, %f\n",
1044                    (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
1045                    (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
1046                    (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
1047                    (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
1048     }
1049     for (j = base_channel; j < s->prim_channels; j++) {
1050         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
1051         for (k = 0; k < s->vq_start_subband[j]; k++)
1052             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
1053         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1054     }
1055     for (j = base_channel; j < s->prim_channels; j++) {
1056         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
1057         for (k = 0; k < s->subband_activity[j]; k++)
1058             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
1059         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1060     }
1061     for (j = base_channel; j < s->prim_channels; j++) {
1062         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
1063         for (k = 0; k < s->subband_activity[j]; k++) {
1064             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
1065                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
1066             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
1067                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
1068         }
1069         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1070     }
1071     for (j = base_channel; j < s->prim_channels; j++) {
1072         if (s->joint_intensity[j] > 0) {
1073             int source_channel = s->joint_intensity[j] - 1;
1074             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
1075             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
1076                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
1077             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1078         }
1079     }
1080     if (!base_channel && s->prim_channels > 2 && s->downmix) {
1081         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
1082         for (j = 0; j < s->prim_channels; j++) {
1083             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
1084                    dca_downmix_coeffs[s->downmix_coef[j][0]]);
1085             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
1086                    dca_downmix_coeffs[s->downmix_coef[j][1]]);
1087         }
1088         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1089     }
1090     for (j = base_channel; j < s->prim_channels; j++)
1091         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
1092             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
1093     if (!base_channel && s->lfe) {
1094         int lfe_samples = 2 * s->lfe * (4 + block_index);
1095         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
1096
1097         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
1098         for (j = lfe_samples; j < lfe_end_sample; j++)
1099             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
1100         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1101     }
1102 #endif
1103
1104     return 0;
1105 }
1106
1107 static void qmf_32_subbands(DCAContext *s, int chans,
1108                             float samples_in[32][8], float *samples_out,
1109                             float scale)
1110 {
1111     const float *prCoeff;
1112     int i;
1113
1114     int sb_act = s->subband_activity[chans];
1115     int subindex;
1116
1117     scale *= sqrt(1 / 8.0);
1118
1119     /* Select filter */
1120     if (!s->multirate_inter)    /* Non-perfect reconstruction */
1121         prCoeff = fir_32bands_nonperfect;
1122     else                        /* Perfect reconstruction */
1123         prCoeff = fir_32bands_perfect;
1124
1125     for (i = sb_act; i < 32; i++)
1126         s->raXin[i] = 0.0;
1127
1128     /* Reconstructed channel sample index */
1129     for (subindex = 0; subindex < 8; subindex++) {
1130         /* Load in one sample from each subband and clear inactive subbands */
1131         for (i = 0; i < sb_act; i++) {
1132             unsigned sign = (i - 1) & 2;
1133             uint32_t v    = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
1134             AV_WN32A(&s->raXin[i], v);
1135         }
1136
1137         s->synth.synth_filter_float(&s->imdct,
1138                                     s->subband_fir_hist[chans],
1139                                     &s->hist_index[chans],
1140                                     s->subband_fir_noidea[chans], prCoeff,
1141                                     samples_out, s->raXin, scale);
1142         samples_out += 32;
1143     }
1144 }
1145
1146 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
1147                                   int num_deci_sample, float *samples_in,
1148                                   float *samples_out, float scale)
1149 {
1150     /* samples_in: An array holding decimated samples.
1151      *   Samples in current subframe starts from samples_in[0],
1152      *   while samples_in[-1], samples_in[-2], ..., stores samples
1153      *   from last subframe as history.
1154      *
1155      * samples_out: An array holding interpolated samples
1156      */
1157
1158     int decifactor;
1159     const float *prCoeff;
1160     int deciindex;
1161
1162     /* Select decimation filter */
1163     if (decimation_select == 1) {
1164         decifactor = 64;
1165         prCoeff = lfe_fir_128;
1166     } else {
1167         decifactor = 32;
1168         prCoeff = lfe_fir_64;
1169     }
1170     /* Interpolation */
1171     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
1172         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
1173         samples_in++;
1174         samples_out += 2 * decifactor;
1175     }
1176 }
1177
1178 /* downmixing routines */
1179 #define MIX_REAR1(samples, s1, rs, coef)            \
1180     samples[0][i] += samples[s1][i] * coef[rs][0];  \
1181     samples[1][i] += samples[s1][i] * coef[rs][1];
1182
1183 #define MIX_REAR2(samples, s1, s2, rs, coef)                                          \
1184     samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
1185     samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
1186
1187 #define MIX_FRONT3(samples, coef)                                      \
1188     t = samples[c][i];                                                 \
1189     u = samples[l][i];                                                 \
1190     v = samples[r][i];                                                 \
1191     samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0];  \
1192     samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1193
1194 #define DOWNMIX_TO_STEREO(op1, op2)             \
1195     for (i = 0; i < 256; i++) {                 \
1196         op1                                     \
1197         op2                                     \
1198     }
1199
1200 static void dca_downmix(float **samples, int srcfmt,
1201                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
1202                         const int8_t *channel_mapping)
1203 {
1204     int c, l, r, sl, sr, s;
1205     int i;
1206     float t, u, v;
1207     float coef[DCA_PRIM_CHANNELS_MAX][2];
1208
1209     for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
1210         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
1211         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
1212     }
1213
1214     switch (srcfmt) {
1215     case DCA_MONO:
1216     case DCA_CHANNEL:
1217     case DCA_STEREO_TOTAL:
1218     case DCA_STEREO_SUMDIFF:
1219     case DCA_4F2R:
1220         av_log(NULL, AV_LOG_ERROR, "Not implemented!\n");
1221         break;
1222     case DCA_STEREO:
1223         break;
1224     case DCA_3F:
1225         c = channel_mapping[0];
1226         l = channel_mapping[1];
1227         r = channel_mapping[2];
1228         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1229         break;
1230     case DCA_2F1R:
1231         s = channel_mapping[2];
1232         DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
1233         break;
1234     case DCA_3F1R:
1235         c = channel_mapping[0];
1236         l = channel_mapping[1];
1237         r = channel_mapping[2];
1238         s = channel_mapping[3];
1239         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1240                           MIX_REAR1(samples, s, 3, coef));
1241         break;
1242     case DCA_2F2R:
1243         sl = channel_mapping[2];
1244         sr = channel_mapping[3];
1245         DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
1246         break;
1247     case DCA_3F2R:
1248         c  = channel_mapping[0];
1249         l  = channel_mapping[1];
1250         r  = channel_mapping[2];
1251         sl = channel_mapping[3];
1252         sr = channel_mapping[4];
1253         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1254                           MIX_REAR2(samples, sl, sr, 3, coef));
1255         break;
1256     }
1257 }
1258
1259
1260 #ifndef decode_blockcodes
1261 /* Very compact version of the block code decoder that does not use table
1262  * look-up but is slightly slower */
1263 static int decode_blockcode(int code, int levels, int *values)
1264 {
1265     int i;
1266     int offset = (levels - 1) >> 1;
1267
1268     for (i = 0; i < 4; i++) {
1269         int div = FASTDIV(code, levels);
1270         values[i] = code - offset - div * levels;
1271         code = div;
1272     }
1273
1274     return code;
1275 }
1276
1277 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1278 {
1279     return decode_blockcode(code1, levels, values) |
1280            decode_blockcode(code2, levels, values + 4);
1281 }
1282 #endif
1283
1284 static const uint8_t abits_sizes[7]  = { 7, 10, 12, 13, 15, 17, 19 };
1285 static const uint8_t abits_levels[7] = { 3,  5,  7,  9, 13, 17, 25 };
1286
1287 #ifndef int8x8_fmul_int32
1288 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1289 {
1290     float fscale = scale / 16.0;
1291     int i;
1292     for (i = 0; i < 8; i++)
1293         dst[i] = src[i] * fscale;
1294 }
1295 #endif
1296
1297 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1298 {
1299     int k, l;
1300     int subsubframe = s->current_subsubframe;
1301
1302     const float *quant_step_table;
1303
1304     /* FIXME */
1305     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1306     LOCAL_ALIGNED_16(int, block, [8]);
1307
1308     /*
1309      * Audio data
1310      */
1311
1312     /* Select quantization step size table */
1313     if (s->bit_rate_index == 0x1f)
1314         quant_step_table = lossless_quant_d;
1315     else
1316         quant_step_table = lossy_quant_d;
1317
1318     for (k = base_channel; k < s->prim_channels; k++) {
1319         if (get_bits_left(&s->gb) < 0)
1320             return AVERROR_INVALIDDATA;
1321
1322         for (l = 0; l < s->vq_start_subband[k]; l++) {
1323             int m;
1324
1325             /* Select the mid-tread linear quantizer */
1326             int abits = s->bitalloc[k][l];
1327
1328             float quant_step_size = quant_step_table[abits];
1329
1330             /*
1331              * Determine quantization index code book and its type
1332              */
1333
1334             /* Select quantization index code book */
1335             int sel = s->quant_index_huffman[k][abits];
1336
1337             /*
1338              * Extract bits from the bit stream
1339              */
1340             if (!abits) {
1341                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1342             } else {
1343                 /* Deal with transients */
1344                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1345                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
1346                                s->scalefactor_adj[k][sel];
1347
1348                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1349                     if (abits <= 7) {
1350                         /* Block code */
1351                         int block_code1, block_code2, size, levels, err;
1352
1353                         size   = abits_sizes[abits - 1];
1354                         levels = abits_levels[abits - 1];
1355
1356                         block_code1 = get_bits(&s->gb, size);
1357                         block_code2 = get_bits(&s->gb, size);
1358                         err = decode_blockcodes(block_code1, block_code2,
1359                                                 levels, block);
1360                         if (err) {
1361                             av_log(s->avctx, AV_LOG_ERROR,
1362                                    "ERROR: block code look-up failed\n");
1363                             return AVERROR_INVALIDDATA;
1364                         }
1365                     } else {
1366                         /* no coding */
1367                         for (m = 0; m < 8; m++)
1368                             block[m] = get_sbits(&s->gb, abits - 3);
1369                     }
1370                 } else {
1371                     /* Huffman coded */
1372                     for (m = 0; m < 8; m++)
1373                         block[m] = get_bitalloc(&s->gb,
1374                                                 &dca_smpl_bitalloc[abits], sel);
1375                 }
1376
1377                 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1378                                                        block, rscale, 8);
1379             }
1380
1381             /*
1382              * Inverse ADPCM if in prediction mode
1383              */
1384             if (s->prediction_mode[k][l]) {
1385                 int n;
1386                 for (m = 0; m < 8; m++) {
1387                     for (n = 1; n <= 4; n++)
1388                         if (m >= n)
1389                             subband_samples[k][l][m] +=
1390                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1391                                  subband_samples[k][l][m - n] / 8192);
1392                         else if (s->predictor_history)
1393                             subband_samples[k][l][m] +=
1394                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1395                                  s->subband_samples_hist[k][l][m - n + 4] / 8192);
1396                 }
1397             }
1398         }
1399
1400         /*
1401          * Decode VQ encoded high frequencies
1402          */
1403         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1404             /* 1 vector -> 32 samples but we only need the 8 samples
1405              * for this subsubframe. */
1406             int hfvq = s->high_freq_vq[k][l];
1407
1408             if (!s->debug_flag & 0x01) {
1409                 av_log(s->avctx, AV_LOG_DEBUG,
1410                        "Stream with high frequencies VQ coding\n");
1411                 s->debug_flag |= 0x01;
1412             }
1413
1414             int8x8_fmul_int32(subband_samples[k][l],
1415                               &high_freq_vq[hfvq][subsubframe * 8],
1416                               s->scale_factor[k][l][0]);
1417         }
1418     }
1419
1420     /* Check for DSYNC after subsubframe */
1421     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1422         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1423 #ifdef TRACE
1424             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1425 #endif
1426         } else {
1427             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1428         }
1429     }
1430
1431     /* Backup predictor history for adpcm */
1432     for (k = base_channel; k < s->prim_channels; k++)
1433         for (l = 0; l < s->vq_start_subband[k]; l++)
1434             memcpy(s->subband_samples_hist[k][l],
1435                    &subband_samples[k][l][4],
1436                    4 * sizeof(subband_samples[0][0][0]));
1437
1438     return 0;
1439 }
1440
1441 static int dca_filter_channels(DCAContext *s, int block_index)
1442 {
1443     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1444     int k;
1445
1446     /* 32 subbands QMF */
1447     for (k = 0; k < s->prim_channels; k++) {
1448 /*        static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1449                                             0, 8388608.0, 8388608.0 };*/
1450         if (s->channel_order_tab[k] >= 0)
1451             qmf_32_subbands(s, k, subband_samples[k],
1452                             s->samples_chanptr[s->channel_order_tab[k]],
1453                             M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */);
1454     }
1455
1456     /* Down mixing */
1457     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1458         dca_downmix(s->samples_chanptr, s->amode, s->downmix_coef, s->channel_order_tab);
1459     }
1460
1461     /* Generate LFE samples for this subsubframe FIXME!!! */
1462     if (s->output & DCA_LFE) {
1463         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1464                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1465                               s->samples_chanptr[s->lfe_index],
1466                               1.0 / (256.0 * 32768.0));
1467         /* Outputs 20bits pcm samples */
1468     }
1469
1470     return 0;
1471 }
1472
1473
1474 static int dca_subframe_footer(DCAContext *s, int base_channel)
1475 {
1476     int aux_data_count = 0, i;
1477
1478     /*
1479      * Unpack optional information
1480      */
1481
1482     /* presumably optional information only appears in the core? */
1483     if (!base_channel) {
1484         if (s->timestamp)
1485             skip_bits_long(&s->gb, 32);
1486
1487         if (s->aux_data)
1488             aux_data_count = get_bits(&s->gb, 6);
1489
1490         for (i = 0; i < aux_data_count; i++)
1491             get_bits(&s->gb, 8);
1492
1493         if (s->crc_present && (s->downmix || s->dynrange))
1494             get_bits(&s->gb, 16);
1495     }
1496
1497     return 0;
1498 }
1499
1500 /**
1501  * Decode a dca frame block
1502  *
1503  * @param s     pointer to the DCAContext
1504  */
1505
1506 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1507 {
1508     int ret;
1509
1510     /* Sanity check */
1511     if (s->current_subframe >= s->subframes) {
1512         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1513                s->current_subframe, s->subframes);
1514         return AVERROR_INVALIDDATA;
1515     }
1516
1517     if (!s->current_subsubframe) {
1518 #ifdef TRACE
1519         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1520 #endif
1521         /* Read subframe header */
1522         if ((ret = dca_subframe_header(s, base_channel, block_index)))
1523             return ret;
1524     }
1525
1526     /* Read subsubframe */
1527 #ifdef TRACE
1528     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1529 #endif
1530     if ((ret = dca_subsubframe(s, base_channel, block_index)))
1531         return ret;
1532
1533     /* Update state */
1534     s->current_subsubframe++;
1535     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1536         s->current_subsubframe = 0;
1537         s->current_subframe++;
1538     }
1539     if (s->current_subframe >= s->subframes) {
1540 #ifdef TRACE
1541         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1542 #endif
1543         /* Read subframe footer */
1544         if ((ret = dca_subframe_footer(s, base_channel)))
1545             return ret;
1546     }
1547
1548     return 0;
1549 }
1550
1551 /**
1552  * Return the number of channels in an ExSS speaker mask (HD)
1553  */
1554 static int dca_exss_mask2count(int mask)
1555 {
1556     /* count bits that mean speaker pairs twice */
1557     return av_popcount(mask) +
1558            av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT      |
1559                                DCA_EXSS_FRONT_LEFT_RIGHT       |
1560                                DCA_EXSS_FRONT_HIGH_LEFT_RIGHT  |
1561                                DCA_EXSS_WIDE_LEFT_RIGHT        |
1562                                DCA_EXSS_SIDE_LEFT_RIGHT        |
1563                                DCA_EXSS_SIDE_HIGH_LEFT_RIGHT   |
1564                                DCA_EXSS_SIDE_REAR_LEFT_RIGHT   |
1565                                DCA_EXSS_REAR_LEFT_RIGHT        |
1566                                DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1567 }
1568
1569 /**
1570  * Skip mixing coefficients of a single mix out configuration (HD)
1571  */
1572 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1573 {
1574     int i;
1575
1576     for (i = 0; i < channels; i++) {
1577         int mix_map_mask = get_bits(gb, out_ch);
1578         int num_coeffs = av_popcount(mix_map_mask);
1579         skip_bits_long(gb, num_coeffs * 6);
1580     }
1581 }
1582
1583 /**
1584  * Parse extension substream asset header (HD)
1585  */
1586 static int dca_exss_parse_asset_header(DCAContext *s)
1587 {
1588     int header_pos = get_bits_count(&s->gb);
1589     int header_size;
1590     int channels = 0;
1591     int embedded_stereo = 0;
1592     int embedded_6ch    = 0;
1593     int drc_code_present;
1594     int av_uninit(extensions_mask);
1595     int i, j;
1596
1597     if (get_bits_left(&s->gb) < 16)
1598         return -1;
1599
1600     /* We will parse just enough to get to the extensions bitmask with which
1601      * we can set the profile value. */
1602
1603     header_size = get_bits(&s->gb, 9) + 1;
1604     skip_bits(&s->gb, 3); // asset index
1605
1606     if (s->static_fields) {
1607         if (get_bits1(&s->gb))
1608             skip_bits(&s->gb, 4); // asset type descriptor
1609         if (get_bits1(&s->gb))
1610             skip_bits_long(&s->gb, 24); // language descriptor
1611
1612         if (get_bits1(&s->gb)) {
1613             /* How can one fit 1024 bytes of text here if the maximum value
1614              * for the asset header size field above was 512 bytes? */
1615             int text_length = get_bits(&s->gb, 10) + 1;
1616             if (get_bits_left(&s->gb) < text_length * 8)
1617                 return -1;
1618             skip_bits_long(&s->gb, text_length * 8); // info text
1619         }
1620
1621         skip_bits(&s->gb, 5); // bit resolution - 1
1622         skip_bits(&s->gb, 4); // max sample rate code
1623         channels = get_bits(&s->gb, 8) + 1;
1624
1625         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1626             int spkr_remap_sets;
1627             int spkr_mask_size = 16;
1628             int num_spkrs[7];
1629
1630             if (channels > 2)
1631                 embedded_stereo = get_bits1(&s->gb);
1632             if (channels > 6)
1633                 embedded_6ch = get_bits1(&s->gb);
1634
1635             if (get_bits1(&s->gb)) {
1636                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1637                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1638             }
1639
1640             spkr_remap_sets = get_bits(&s->gb, 3);
1641
1642             for (i = 0; i < spkr_remap_sets; i++) {
1643                 /* std layout mask for each remap set */
1644                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1645             }
1646
1647             for (i = 0; i < spkr_remap_sets; i++) {
1648                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1649                 if (get_bits_left(&s->gb) < 0)
1650                     return -1;
1651
1652                 for (j = 0; j < num_spkrs[i]; j++) {
1653                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1654                     int num_dec_ch = av_popcount(remap_dec_ch_mask);
1655                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1656                 }
1657             }
1658
1659         } else {
1660             skip_bits(&s->gb, 3); // representation type
1661         }
1662     }
1663
1664     drc_code_present = get_bits1(&s->gb);
1665     if (drc_code_present)
1666         get_bits(&s->gb, 8); // drc code
1667
1668     if (get_bits1(&s->gb))
1669         skip_bits(&s->gb, 5); // dialog normalization code
1670
1671     if (drc_code_present && embedded_stereo)
1672         get_bits(&s->gb, 8); // drc stereo code
1673
1674     if (s->mix_metadata && get_bits1(&s->gb)) {
1675         skip_bits(&s->gb, 1); // external mix
1676         skip_bits(&s->gb, 6); // post mix gain code
1677
1678         if (get_bits(&s->gb, 2) != 3) // mixer drc code
1679             skip_bits(&s->gb, 3); // drc limit
1680         else
1681             skip_bits(&s->gb, 8); // custom drc code
1682
1683         if (get_bits1(&s->gb)) // channel specific scaling
1684             for (i = 0; i < s->num_mix_configs; i++)
1685                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1686         else
1687             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1688
1689         for (i = 0; i < s->num_mix_configs; i++) {
1690             if (get_bits_left(&s->gb) < 0)
1691                 return -1;
1692             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1693             if (embedded_6ch)
1694                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1695             if (embedded_stereo)
1696                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1697         }
1698     }
1699
1700     switch (get_bits(&s->gb, 2)) {
1701     case 0: extensions_mask = get_bits(&s->gb, 12); break;
1702     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
1703     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
1704     case 3: extensions_mask = 0; /* aux coding */   break;
1705     }
1706
1707     /* not parsed further, we were only interested in the extensions mask */
1708
1709     if (get_bits_left(&s->gb) < 0)
1710         return -1;
1711
1712     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1713         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1714         return -1;
1715     }
1716     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1717
1718     if (extensions_mask & DCA_EXT_EXSS_XLL)
1719         s->profile = FF_PROFILE_DTS_HD_MA;
1720     else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1721                                 DCA_EXT_EXSS_XXCH))
1722         s->profile = FF_PROFILE_DTS_HD_HRA;
1723
1724     if (!(extensions_mask & DCA_EXT_CORE))
1725         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1726     if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1727         av_log(s->avctx, AV_LOG_WARNING,
1728                "DTS extensions detection mismatch (%d, %d)\n",
1729                extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1730
1731     return 0;
1732 }
1733
1734 static int dca_xbr_parse_frame(DCAContext *s)
1735 {
1736     int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];
1737     int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];
1738     int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS];
1739     int anctemp[DCA_CHSET_CHANS_MAX];
1740     int chset_fsize[DCA_CHSETS_MAX];
1741     int n_xbr_ch[DCA_CHSETS_MAX];
1742     int hdr_size, num_chsets, xbr_tmode, hdr_pos;
1743     int i, j, k, l, chset, chan_base;
1744
1745     av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n");
1746
1747     /* get bit position of sync header */
1748     hdr_pos = get_bits_count(&s->gb) - 32;
1749
1750     hdr_size = get_bits(&s->gb, 6) + 1;
1751     num_chsets = get_bits(&s->gb, 2) + 1;
1752
1753     for(i = 0; i < num_chsets; i++)
1754         chset_fsize[i] = get_bits(&s->gb, 14) + 1;
1755
1756     xbr_tmode = get_bits1(&s->gb);
1757
1758     for(i = 0; i < num_chsets; i++) {
1759         n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;
1760         k = get_bits(&s->gb, 2) + 5;
1761         for(j = 0; j < n_xbr_ch[i]; j++)
1762             active_bands[i][j] = get_bits(&s->gb, k) + 1;
1763     }
1764
1765     /* skip to the end of the header */
1766     i = get_bits_count(&s->gb);
1767     if(hdr_pos + hdr_size * 8 > i)
1768         skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1769
1770     /* loop over the channel data sets */
1771     /* only decode as many channels as we've decoded base data for */
1772     for(chset = 0, chan_base = 0;
1773         chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels;
1774         chan_base += n_xbr_ch[chset++]) {
1775         int start_posn = get_bits_count(&s->gb);
1776         int subsubframe = 0;
1777         int subframe = 0;
1778
1779         /* loop over subframes */
1780         for (k = 0; k < (s->sample_blocks / 8); k++) {
1781             /* parse header if we're on first subsubframe of a block */
1782             if(subsubframe == 0) {
1783                 /* Parse subframe header */
1784                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1785                     anctemp[i] = get_bits(&s->gb, 2) + 2;
1786                 }
1787
1788                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1789                     get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]);
1790                 }
1791
1792                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1793                     anctemp[i] = get_bits(&s->gb, 3);
1794                     if(anctemp[i] < 1) {
1795                         av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n");
1796                         return AVERROR_INVALIDDATA;
1797                     }
1798                 }
1799
1800                 /* generate scale factors */
1801                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1802                     const uint32_t *scale_table;
1803                     int nbits;
1804
1805                     if (s->scalefactor_huffman[chan_base+i] == 6) {
1806                         scale_table = scale_factor_quant7;
1807                     } else {
1808                         scale_table = scale_factor_quant6;
1809                     }
1810
1811                     nbits = anctemp[i];
1812
1813                     for(j = 0; j < active_bands[chset][i]; j++) {
1814                         if(abits_high[i][j] > 0) {
1815                             scale_table_high[i][j][0] =
1816                                 scale_table[get_bits(&s->gb, nbits)];
1817
1818                             if(xbr_tmode && s->transition_mode[i][j]) {
1819                                 scale_table_high[i][j][1] =
1820                                     scale_table[get_bits(&s->gb, nbits)];
1821                             }
1822                         }
1823                     }
1824                 }
1825             }
1826
1827             /* decode audio array for this block */
1828             for(i = 0; i < n_xbr_ch[chset]; i++) {
1829                 for(j = 0; j < active_bands[chset][i]; j++) {
1830                     const int xbr_abits = abits_high[i][j];
1831                     const float quant_step_size = lossless_quant_d[xbr_abits];
1832                     const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j];
1833                     const float rscale = quant_step_size * scale_table_high[i][j][sfi];
1834                     float *subband_samples = s->subband_samples[k][chan_base+i][j];
1835                     int block[8];
1836
1837                     if(xbr_abits <= 0)
1838                         continue;
1839
1840                     if(xbr_abits > 7) {
1841                         get_array(&s->gb, block, 8, xbr_abits - 3);
1842                     } else {
1843                         int block_code1, block_code2, size, levels, err;
1844
1845                         size   = abits_sizes[xbr_abits - 1];
1846                         levels = abits_levels[xbr_abits - 1];
1847
1848                         block_code1 = get_bits(&s->gb, size);
1849                         block_code2 = get_bits(&s->gb, size);
1850                         err = decode_blockcodes(block_code1, block_code2,
1851                                                 levels, block);
1852                         if (err) {
1853                             av_log(s->avctx, AV_LOG_ERROR,
1854                                    "ERROR: DTS-XBR: block code look-up failed\n");
1855                             return AVERROR_INVALIDDATA;
1856                         }
1857                     }
1858
1859                     /* scale & sum into subband */
1860                     for(l = 0; l < 8; l++)
1861                         subband_samples[l] += (float)block[l] * rscale;
1862                 }
1863             }
1864
1865             /* check DSYNC marker */
1866             if(s->aspf || subsubframe == s->subsubframes[subframe] - 1) {
1867                 if(get_bits(&s->gb, 16) != 0xffff) {
1868                     av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n");
1869                     return AVERROR_INVALIDDATA;
1870                 }
1871             }
1872
1873             /* advance sub-sub-frame index */
1874             if(++subsubframe >= s->subsubframes[subframe]) {
1875                 subsubframe = 0;
1876                 subframe++;
1877             }
1878         }
1879
1880         /* skip to next channel set */
1881         i = get_bits_count(&s->gb);
1882         if(start_posn + chset_fsize[chset] * 8 != i) {
1883             j = start_posn + chset_fsize[chset] * 8 - i;
1884             if(j < 0 || j >= 8)
1885                 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set,"
1886                        " skipping further than expected (%d bits)\n", j);
1887             skip_bits_long(&s->gb, j);
1888         }
1889     }
1890
1891     return 0;
1892 }
1893
1894 /* parse initial header for XXCH and dump details */
1895 static int dca_xxch_decode_frame(DCAContext *s)
1896 {
1897     int hdr_size, spkmsk_bits, num_chsets, core_spk, hdr_pos;
1898     int i, chset, base_channel, chstart, fsize[8];
1899
1900     /* assume header word has already been parsed */
1901     hdr_pos     = get_bits_count(&s->gb) - 32;
1902     hdr_size    = get_bits(&s->gb, 6) + 1;
1903   /*chhdr_crc   =*/ skip_bits1(&s->gb);
1904     spkmsk_bits = get_bits(&s->gb, 5) + 1;
1905     num_chsets  = get_bits(&s->gb, 2) + 1;
1906
1907     for (i = 0; i < num_chsets; i++)
1908         fsize[i] = get_bits(&s->gb, 14) + 1;
1909
1910     core_spk               = get_bits(&s->gb, spkmsk_bits);
1911     s->xxch_core_spkmask   = core_spk;
1912     s->xxch_nbits_spk_mask = spkmsk_bits;
1913     s->xxch_dmix_embedded  = 0;
1914
1915     /* skip to the end of the header */
1916     i = get_bits_count(&s->gb);
1917     if (hdr_pos + hdr_size * 8 > i)
1918         skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1919
1920     for (chset = 0; chset < num_chsets; chset++) {
1921         chstart       = get_bits_count(&s->gb);
1922         base_channel  = s->prim_channels;
1923         s->xxch_chset = chset;
1924
1925         /* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs.
1926            5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */
1927         dca_parse_audio_coding_header(s, base_channel, 1);
1928
1929         /* decode channel data */
1930         for (i = 0; i < (s->sample_blocks / 8); i++) {
1931             if (dca_decode_block(s, base_channel, i)) {
1932                 av_log(s->avctx, AV_LOG_ERROR,
1933                        "Error decoding DTS-XXCH extension\n");
1934                 continue;
1935             }
1936         }
1937
1938         /* skip to end of this section */
1939         i = get_bits_count(&s->gb);
1940         if (chstart + fsize[chset] * 8 > i)
1941             skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i);
1942     }
1943     s->xxch_chset = num_chsets;
1944
1945     return 0;
1946 }
1947
1948 /**
1949  * Parse extension substream header (HD)
1950  */
1951 static void dca_exss_parse_header(DCAContext *s)
1952 {
1953     int asset_size[8];
1954     int ss_index;
1955     int blownup;
1956     int num_audiop = 1;
1957     int num_assets = 1;
1958     int active_ss_mask[8];
1959     int i, j;
1960     int start_posn;
1961     int hdrsize;
1962     uint32_t mkr;
1963
1964     if (get_bits_left(&s->gb) < 52)
1965         return;
1966
1967     start_posn = get_bits_count(&s->gb) - 32;
1968
1969     skip_bits(&s->gb, 8); // user data
1970     ss_index = get_bits(&s->gb, 2);
1971
1972     blownup = get_bits1(&s->gb);
1973     hdrsize = get_bits(&s->gb,  8 + 4 * blownup) + 1; // header_size
1974     skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1975
1976     s->static_fields = get_bits1(&s->gb);
1977     if (s->static_fields) {
1978         skip_bits(&s->gb, 2); // reference clock code
1979         skip_bits(&s->gb, 3); // frame duration code
1980
1981         if (get_bits1(&s->gb))
1982             skip_bits_long(&s->gb, 36); // timestamp
1983
1984         /* a single stream can contain multiple audio assets that can be
1985          * combined to form multiple audio presentations */
1986
1987         num_audiop = get_bits(&s->gb, 3) + 1;
1988         if (num_audiop > 1) {
1989             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1990             /* ignore such streams for now */
1991             return;
1992         }
1993
1994         num_assets = get_bits(&s->gb, 3) + 1;
1995         if (num_assets > 1) {
1996             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1997             /* ignore such streams for now */
1998             return;
1999         }
2000
2001         for (i = 0; i < num_audiop; i++)
2002             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
2003
2004         for (i = 0; i < num_audiop; i++)
2005             for (j = 0; j <= ss_index; j++)
2006                 if (active_ss_mask[i] & (1 << j))
2007                     skip_bits(&s->gb, 8); // active asset mask
2008
2009         s->mix_metadata = get_bits1(&s->gb);
2010         if (s->mix_metadata) {
2011             int mix_out_mask_size;
2012
2013             skip_bits(&s->gb, 2); // adjustment level
2014             mix_out_mask_size  = (get_bits(&s->gb, 2) + 1) << 2;
2015             s->num_mix_configs =  get_bits(&s->gb, 2) + 1;
2016
2017             for (i = 0; i < s->num_mix_configs; i++) {
2018                 int mix_out_mask        = get_bits(&s->gb, mix_out_mask_size);
2019                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
2020             }
2021         }
2022     }
2023
2024     for (i = 0; i < num_assets; i++)
2025         asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup);
2026
2027     for (i = 0; i < num_assets; i++) {
2028         if (dca_exss_parse_asset_header(s))
2029             return;
2030     }
2031
2032     /* not parsed further, we were only interested in the extensions mask
2033      * from the asset header */
2034
2035     if (num_assets > 0) {
2036         j = get_bits_count(&s->gb);
2037         if (start_posn + hdrsize * 8 > j)
2038             skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j);
2039
2040         for (i = 0; i < num_assets; i++) {
2041             start_posn = get_bits_count(&s->gb);
2042             mkr        = get_bits_long(&s->gb, 32);
2043
2044             /* parse extensions that we know about */
2045             if (mkr == 0x655e315e) {
2046                 dca_xbr_parse_frame(s);
2047             } else if (mkr == 0x47004a03) {
2048                 dca_xxch_decode_frame(s);
2049                 s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
2050             } else {
2051                 av_log(s->avctx, AV_LOG_DEBUG,
2052                        "DTS-ExSS: unknown marker = 0x%08x\n", mkr);
2053             }
2054
2055             /* skip to end of block */
2056             j = get_bits_count(&s->gb);
2057             if (start_posn + asset_size[i] * 8 > j)
2058                 skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j);
2059         }
2060     }
2061 }
2062
2063 /**
2064  * Main frame decoding function
2065  * FIXME add arguments
2066  */
2067 static int dca_decode_frame(AVCodecContext *avctx, void *data,
2068                             int *got_frame_ptr, AVPacket *avpkt)
2069 {
2070     const uint8_t *buf = avpkt->data;
2071     int buf_size = avpkt->size;
2072     int channel_mask;
2073     int channel_layout;
2074     int lfe_samples;
2075     int num_core_channels = 0;
2076     int i, ret;
2077     float **samples_flt;
2078     float *src_chan;
2079     float *dst_chan;
2080     DCAContext *s = avctx->priv_data;
2081     int core_ss_end;
2082     int channels, full_channels;
2083     float scale;
2084     int achan;
2085     int chset;
2086     int mask;
2087     int lavc;
2088     int posn;
2089     int j, k;
2090     int endch;
2091
2092     s->xch_present = 0;
2093
2094     s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
2095                                                   DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
2096     if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
2097         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
2098         return AVERROR_INVALIDDATA;
2099     }
2100
2101     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
2102     if ((ret = dca_parse_frame_header(s)) < 0) {
2103         //seems like the frame is corrupt, try with the next one
2104         return ret;
2105     }
2106     //set AVCodec values with parsed data
2107     avctx->sample_rate = s->sample_rate;
2108     avctx->bit_rate    = s->bit_rate;
2109
2110     s->profile = FF_PROFILE_DTS;
2111
2112     for (i = 0; i < (s->sample_blocks / 8); i++) {
2113         if ((ret = dca_decode_block(s, 0, i))) {
2114             av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
2115             return ret;
2116         }
2117     }
2118
2119     /* record number of core channels incase less than max channels are requested */
2120     num_core_channels = s->prim_channels;
2121
2122     if (s->ext_coding)
2123         s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
2124     else
2125         s->core_ext_mask = 0;
2126
2127     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
2128
2129     /* only scan for extensions if ext_descr was unknown or indicated a
2130      * supported XCh extension */
2131     if (s->core_ext_mask < 0 || s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH)) {
2132
2133         /* if ext_descr was unknown, clear s->core_ext_mask so that the
2134          * extensions scan can fill it up */
2135         s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
2136
2137         /* extensions start at 32-bit boundaries into bitstream */
2138         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2139
2140         while (core_ss_end - get_bits_count(&s->gb) >= 32) {
2141             uint32_t bits = get_bits_long(&s->gb, 32);
2142
2143             switch (bits) {
2144             case 0x5a5a5a5a: {
2145                 int ext_amode, xch_fsize;
2146
2147                 s->xch_base_channel = s->prim_channels;
2148
2149                 /* validate sync word using XCHFSIZE field */
2150                 xch_fsize = show_bits(&s->gb, 10);
2151                 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
2152                     (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
2153                     continue;
2154
2155                 /* skip length-to-end-of-frame field for the moment */
2156                 skip_bits(&s->gb, 10);
2157
2158                 s->core_ext_mask |= DCA_EXT_XCH;
2159
2160                 /* extension amode(number of channels in extension) should be 1 */
2161                 /* AFAIK XCh is not used for more channels */
2162                 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
2163                     av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
2164                            " supported!\n", ext_amode);
2165                     continue;
2166                 }
2167
2168                 if (s->xch_base_channel < 2) {
2169                     av_log_ask_for_sample(avctx, "XCh with fewer than 2 base channels is not supported\n");
2170                     continue;
2171                 }
2172
2173                 /* much like core primary audio coding header */
2174                 dca_parse_audio_coding_header(s, s->xch_base_channel, 0);
2175
2176                 for (i = 0; i < (s->sample_blocks / 8); i++)
2177                     if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
2178                         av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
2179                         continue;
2180                     }
2181
2182                 s->xch_present = 1;
2183                 break;
2184             }
2185             case 0x47004a03:
2186                 /* XXCh: extended channels */
2187                 /* usually found either in core or HD part in DTS-HD HRA streams,
2188                  * but not in DTS-ES which contains XCh extensions instead */
2189                 s->core_ext_mask |= DCA_EXT_XXCH;
2190                 dca_xxch_decode_frame(s);
2191                 break;
2192
2193             case 0x1d95f262: {
2194                 int fsize96 = show_bits(&s->gb, 12) + 1;
2195                 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
2196                     continue;
2197
2198                 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
2199                        get_bits_count(&s->gb));
2200                 skip_bits(&s->gb, 12);
2201                 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
2202                 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
2203
2204                 s->core_ext_mask |= DCA_EXT_X96;
2205                 break;
2206             }
2207             }
2208
2209             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2210         }
2211     } else {
2212         /* no supported extensions, skip the rest of the core substream */
2213         skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
2214     }
2215
2216     if (s->core_ext_mask & DCA_EXT_X96)
2217         s->profile = FF_PROFILE_DTS_96_24;
2218     else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
2219         s->profile = FF_PROFILE_DTS_ES;
2220
2221     /* check for ExSS (HD part) */
2222     if (s->dca_buffer_size - s->frame_size > 32 &&
2223         get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
2224         dca_exss_parse_header(s);
2225
2226     avctx->profile = s->profile;
2227
2228     full_channels = channels = s->prim_channels + !!s->lfe;
2229
2230     /* If we have XXCH then the channel layout is managed differently */
2231     /* note that XLL will also have another way to do things */
2232     if (!(s->core_ext_mask & DCA_EXT_XXCH)
2233         || (s->core_ext_mask & DCA_EXT_XXCH && avctx->request_channels > 0
2234             && avctx->request_channels
2235             < num_core_channels + !!s->lfe + s->xxch_chset_nch[0]))
2236     { /* xxx should also do MA extensions */
2237         if (s->amode < 16) {
2238             avctx->channel_layout = dca_core_channel_layout[s->amode];
2239
2240             if (s->xch_present && (!avctx->request_channels ||
2241                                    avctx->request_channels
2242                                    > num_core_channels + !!s->lfe)) {
2243                 avctx->channel_layout |= AV_CH_BACK_CENTER;
2244                 if (s->lfe) {
2245                     avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2246                     s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
2247                 } else {
2248                     s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
2249                 }
2250                 if (s->channel_order_tab[s->xch_base_channel] < 0)
2251                     return AVERROR_INVALIDDATA;
2252             } else {
2253                 channels = num_core_channels + !!s->lfe;
2254                 s->xch_present = 0; /* disable further xch processing */
2255                 if (s->lfe) {
2256                     avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2257                     s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
2258                 } else
2259                     s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
2260             }
2261
2262             if (channels > !!s->lfe &&
2263                 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
2264                 return AVERROR_INVALIDDATA;
2265
2266             if (av_get_channel_layout_nb_channels(avctx->channel_layout) != channels) {
2267                 av_log(avctx, AV_LOG_ERROR, "Number of channels %d mismatches layout %d\n", channels, av_get_channel_layout_nb_channels(avctx->channel_layout));
2268                 return AVERROR_INVALIDDATA;
2269             }
2270
2271             if (avctx->request_channels == 2 && s->prim_channels > 2) {
2272                 channels = 2;
2273                 s->output = DCA_STEREO;
2274                 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
2275             }
2276             else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
2277                 static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
2278                 s->channel_order_tab = dca_channel_order_native;
2279             }
2280             s->lfe_index = dca_lfe_index[s->amode];
2281         } else {
2282             av_log(avctx, AV_LOG_ERROR,
2283                    "Non standard configuration %d !\n", s->amode);
2284             return AVERROR_INVALIDDATA;
2285         }
2286
2287         s->xxch_dmix_embedded = 0;
2288     } else {
2289         /* we only get here if an XXCH channel set can be added to the mix */
2290         channel_mask = s->xxch_core_spkmask;
2291
2292         if (avctx->request_channels > 0
2293             && avctx->request_channels < s->prim_channels) {
2294             channels = num_core_channels + !!s->lfe;
2295             for (i = 0; i < s->xxch_chset && channels + s->xxch_chset_nch[i]
2296                                               <= avctx->request_channels; i++) {
2297                 channels += s->xxch_chset_nch[i];
2298                 channel_mask |= s->xxch_spk_masks[i];
2299             }
2300         } else {
2301             channels = s->prim_channels + !!s->lfe;
2302             for (i = 0; i < s->xxch_chset; i++) {
2303                 channel_mask |= s->xxch_spk_masks[i];
2304             }
2305         }
2306
2307         /* Given the DTS spec'ed channel mask, generate an avcodec version */
2308         channel_layout = 0;
2309         for (i = 0; i < s->xxch_nbits_spk_mask; ++i) {
2310             if (channel_mask & (1 << i)) {
2311                 channel_layout |= map_xxch_to_native[i];
2312             }
2313         }
2314
2315         /* make sure that we have managed to get equivelant dts/avcodec channel
2316          * masks in some sense -- unfortunately some channels could overlap */
2317         if (av_popcount(channel_mask) != av_popcount(channel_layout)) {
2318             av_log(avctx, AV_LOG_DEBUG,
2319                    "DTS-XXCH: Inconsistant avcodec/dts channel layouts\n");
2320             return AVERROR_INVALIDDATA;
2321         }
2322
2323         avctx->channel_layout = channel_layout;
2324
2325         if (!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)) {
2326             /* Estimate DTS --> avcodec ordering table */
2327             for (chset = -1, j = 0; chset < s->xxch_chset; ++chset) {
2328                 mask = chset >= 0 ? s->xxch_spk_masks[chset]
2329                                   : s->xxch_core_spkmask;
2330                 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
2331                     if (mask & ~(DCA_XXCH_LFE1 | DCA_XXCH_LFE2) & (1 << i)) {
2332                         lavc = map_xxch_to_native[i];
2333                         posn = av_popcount(channel_layout & (lavc - 1));
2334                         s->xxch_order_tab[j++] = posn;
2335                     }
2336                 }
2337             }
2338
2339             s->lfe_index = av_popcount(channel_layout & (AV_CH_LOW_FREQUENCY-1));
2340         } else { /* native ordering */
2341             for (i = 0; i < channels; i++)
2342                 s->xxch_order_tab[i] = i;
2343
2344             s->lfe_index = channels - 1;
2345         }
2346
2347         s->channel_order_tab = s->xxch_order_tab;
2348     }
2349
2350     if (avctx->channels != channels) {
2351         if (avctx->channels)
2352             av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
2353         avctx->channels = channels;
2354     }
2355
2356     /* get output buffer */
2357     s->frame.nb_samples = 256 * (s->sample_blocks / 8);
2358     if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
2359         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2360         return ret;
2361     }
2362     samples_flt = (float  **) s->frame.extended_data;
2363
2364     /* allocate buffer for extra channels if downmixing */
2365     if (avctx->channels < full_channels) {
2366         ret = av_samples_get_buffer_size(NULL, full_channels - channels,
2367                                          s->frame.nb_samples,
2368                                          avctx->sample_fmt, 0);
2369         if (ret < 0)
2370             return ret;
2371
2372         av_fast_malloc(&s->extra_channels_buffer,
2373                        &s->extra_channels_buffer_size, ret);
2374         if (!s->extra_channels_buffer)
2375             return AVERROR(ENOMEM);
2376
2377         ret = av_samples_fill_arrays((uint8_t **)s->extra_channels, NULL,
2378                                      s->extra_channels_buffer,
2379                                      full_channels - channels,
2380                                      s->frame.nb_samples, avctx->sample_fmt, 0);
2381         if (ret < 0)
2382             return ret;
2383     }
2384
2385     /* filter to get final output */
2386     for (i = 0; i < (s->sample_blocks / 8); i++) {
2387         int ch;
2388
2389         for (ch = 0; ch < channels; ch++)
2390             s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
2391         for (; ch < full_channels; ch++)
2392             s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
2393
2394         dca_filter_channels(s, i);
2395
2396         /* If this was marked as a DTS-ES stream we need to subtract back- */
2397         /* channel from SL & SR to remove matrixed back-channel signal */
2398         if ((s->source_pcm_res & 1) && s->xch_present) {
2399             float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];
2400             float *lt_chan   = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];
2401             float *rt_chan   = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];
2402             s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
2403             s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
2404         }
2405
2406         /* If stream contains XXCH, we might need to undo an embedded downmix */
2407         if (s->xxch_dmix_embedded) {
2408             /* Loop over channel sets in turn */
2409             ch = num_core_channels;
2410             for (chset = 0; chset < s->xxch_chset; chset++) {
2411                 endch = ch + s->xxch_chset_nch[chset];
2412                 mask = s->xxch_dmix_embedded;
2413
2414                 /* undo downmix */
2415                 for (j = ch; j < endch; j++) {
2416                     if (mask & (1 << j)) { /* this channel has been mixed-out */
2417                         src_chan = s->samples_chanptr[s->channel_order_tab[j]];
2418                         for (k = 0; k < endch; k++) {
2419                             achan = s->channel_order_tab[k];
2420                             scale = s->xxch_dmix_coeff[j][k];
2421                             if (scale != 0.0) {
2422                                 dst_chan = s->samples_chanptr[achan];
2423                                 s->fdsp.vector_fmac_scalar(dst_chan, src_chan,
2424                                                            -scale, 256);
2425                             }
2426                         }
2427                     }
2428                 }
2429
2430                 /* if a downmix has been embedded then undo the pre-scaling */
2431                 if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) {
2432                     scale = s->xxch_dmix_sf[chset];
2433
2434                     for (j = 0; j < ch; j++) {
2435                         src_chan = s->samples_chanptr[s->channel_order_tab[j]];
2436                         for (k = 0; k < 256; k++)
2437                             src_chan[k] *= scale;
2438                     }
2439
2440                     /* LFE channel is always part of core, scale if it exists */
2441                     if (s->lfe) {
2442                         src_chan = s->samples_chanptr[s->lfe_index];
2443                         for (k = 0; k < 256; k++)
2444                             src_chan[k] *= scale;
2445                     }
2446                 }
2447
2448                 ch = endch;
2449             }
2450
2451         }
2452     }
2453
2454     /* update lfe history */
2455     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
2456     for (i = 0; i < 2 * s->lfe * 4; i++)
2457         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
2458
2459     *got_frame_ptr    = 1;
2460     *(AVFrame *) data = s->frame;
2461
2462     return buf_size;
2463 }
2464
2465
2466
2467 /**
2468  * DCA initialization
2469  *
2470  * @param avctx     pointer to the AVCodecContext
2471  */
2472
2473 static av_cold int dca_decode_init(AVCodecContext *avctx)
2474 {
2475     DCAContext *s = avctx->priv_data;
2476
2477     s->avctx = avctx;
2478     dca_init_vlcs();
2479
2480     avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
2481     ff_mdct_init(&s->imdct, 6, 1, 1.0);
2482     ff_synth_filter_init(&s->synth);
2483     ff_dcadsp_init(&s->dcadsp);
2484     ff_fmt_convert_init(&s->fmt_conv, avctx);
2485
2486     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
2487
2488     /* allow downmixing to stereo */
2489     if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
2490         avctx->request_channels == 2) {
2491         avctx->channels = avctx->request_channels;
2492     }
2493
2494     avcodec_get_frame_defaults(&s->frame);
2495     avctx->coded_frame = &s->frame;
2496
2497     return 0;
2498 }
2499
2500 static av_cold int dca_decode_end(AVCodecContext *avctx)
2501 {
2502     DCAContext *s = avctx->priv_data;
2503     ff_mdct_end(&s->imdct);
2504     av_freep(&s->extra_channels_buffer);
2505     return 0;
2506 }
2507
2508 static const AVProfile profiles[] = {
2509     { FF_PROFILE_DTS,        "DTS"        },
2510     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
2511     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
2512     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
2513     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
2514     { FF_PROFILE_UNKNOWN },
2515 };
2516
2517 AVCodec ff_dca_decoder = {
2518     .name            = "dca",
2519     .type            = AVMEDIA_TYPE_AUDIO,
2520     .id              = AV_CODEC_ID_DTS,
2521     .priv_data_size  = sizeof(DCAContext),
2522     .init            = dca_decode_init,
2523     .decode          = dca_decode_frame,
2524     .close           = dca_decode_end,
2525     .long_name       = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
2526     .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
2527     .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2528                                                        AV_SAMPLE_FMT_NONE },
2529     .profiles        = NULL_IF_CONFIG_SMALL(profiles),
2530 };