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