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

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