git.sesse.net Git - ffmpeg/blob - libavcodec/dcadec.c

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