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