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