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