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

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