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