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