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

   1 /*
   2  * DCA compatible decoder
   3  * Copyright (C) 2004 Gildas Bazin
   4  * Copyright (C) 2004 Benjamin Zores
   5  * Copyright (C) 2006 Benjamin Larsson
   6  * Copyright (C) 2007 Konstantin Shishkov
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 #include <math.h>
  26 #include <stddef.h>
  27 #include <stdio.h>
  28
  29 #include "libavutil/channel_layout.h"
  30 #include "libavutil/common.h"
  31 #include "libavutil/float_dsp.h"
  32 #include "libavutil/internal.h"
  33 #include "libavutil/intreadwrite.h"
  34 #include "libavutil/mathematics.h"
  35 #include "libavutil/opt.h"
  36 #include "libavutil/samplefmt.h"
  37
  38 #include "avcodec.h"
  39 #include "dca.h"
  40 #include "dcadata.h"
  41 #include "dcadsp.h"
  42 #include "dcahuff.h"
  43 #include "dca_exss.h"
  44 #include "fft.h"
  45 #include "fmtconvert.h"
  46 #include "get_bits.h"
  47 #include "internal.h"
  48 #include "mathops.h"
  49 #include "synth_filter.h"
  50
  51 #if ARCH_ARM
  52 #   include "arm/dca.h"
  53 #endif
  54
  55 enum DCAMode {
  56     DCA_MONO = 0,
  57     DCA_CHANNEL,
  58     DCA_STEREO,
  59     DCA_STEREO_SUMDIFF,
  60     DCA_STEREO_TOTAL,
  61     DCA_3F,
  62     DCA_2F1R,
  63     DCA_3F1R,
  64     DCA_2F2R,
  65     DCA_3F2R,
  66     DCA_4F2R
  67 };
  68
  69
  70 enum DCAXxchSpeakerMask {
  71     DCA_XXCH_FRONT_CENTER          = 0x0000001,
  72     DCA_XXCH_FRONT_LEFT            = 0x0000002,
  73     DCA_XXCH_FRONT_RIGHT           = 0x0000004,
  74     DCA_XXCH_SIDE_REAR_LEFT        = 0x0000008,
  75     DCA_XXCH_SIDE_REAR_RIGHT       = 0x0000010,
  76     DCA_XXCH_LFE1                  = 0x0000020,
  77     DCA_XXCH_REAR_CENTER           = 0x0000040,
  78     DCA_XXCH_SURROUND_REAR_LEFT    = 0x0000080,
  79     DCA_XXCH_SURROUND_REAR_RIGHT   = 0x0000100,
  80     DCA_XXCH_SIDE_SURROUND_LEFT    = 0x0000200,
  81     DCA_XXCH_SIDE_SURROUND_RIGHT   = 0x0000400,
  82     DCA_XXCH_FRONT_CENTER_LEFT     = 0x0000800,
  83     DCA_XXCH_FRONT_CENTER_RIGHT    = 0x0001000,
  84     DCA_XXCH_FRONT_HIGH_LEFT       = 0x0002000,
  85     DCA_XXCH_FRONT_HIGH_CENTER     = 0x0004000,
  86     DCA_XXCH_FRONT_HIGH_RIGHT      = 0x0008000,
  87     DCA_XXCH_LFE2                  = 0x0010000,
  88     DCA_XXCH_SIDE_FRONT_LEFT       = 0x0020000,
  89     DCA_XXCH_SIDE_FRONT_RIGHT      = 0x0040000,
  90     DCA_XXCH_OVERHEAD              = 0x0080000,
  91     DCA_XXCH_SIDE_HIGH_LEFT        = 0x0100000,
  92     DCA_XXCH_SIDE_HIGH_RIGHT       = 0x0200000,
  93     DCA_XXCH_REAR_HIGH_CENTER      = 0x0400000,
  94     DCA_XXCH_REAR_HIGH_LEFT        = 0x0800000,
  95     DCA_XXCH_REAR_HIGH_RIGHT       = 0x1000000,
  96     DCA_XXCH_REAR_LOW_CENTER       = 0x2000000,
  97     DCA_XXCH_REAR_LOW_LEFT         = 0x4000000,
  98     DCA_XXCH_REAR_LOW_RIGHT        = 0x8000000,
  99 };
 100
 101 static const uint32_t map_xxch_to_native[28] = {
 102     AV_CH_FRONT_CENTER,
 103     AV_CH_FRONT_LEFT,
 104     AV_CH_FRONT_RIGHT,
 105     AV_CH_SIDE_LEFT,
 106     AV_CH_SIDE_RIGHT,
 107     AV_CH_LOW_FREQUENCY,
 108     AV_CH_BACK_CENTER,
 109     AV_CH_BACK_LEFT,
 110     AV_CH_BACK_RIGHT,
 111     AV_CH_SIDE_LEFT,           /* side surround left -- dup sur side L */
 112     AV_CH_SIDE_RIGHT,          /* side surround right -- dup sur side R */
 113     AV_CH_FRONT_LEFT_OF_CENTER,
 114     AV_CH_FRONT_RIGHT_OF_CENTER,
 115     AV_CH_TOP_FRONT_LEFT,
 116     AV_CH_TOP_FRONT_CENTER,
 117     AV_CH_TOP_FRONT_RIGHT,
 118     AV_CH_LOW_FREQUENCY,        /* lfe2 -- duplicate lfe1 position */
 119     AV_CH_FRONT_LEFT_OF_CENTER, /* side front left -- dup front cntr L */
 120     AV_CH_FRONT_RIGHT_OF_CENTER,/* side front right -- dup front cntr R */
 121     AV_CH_TOP_CENTER,           /* overhead */
 122     AV_CH_TOP_FRONT_LEFT,       /* side high left -- dup */
 123     AV_CH_TOP_FRONT_RIGHT,      /* side high right -- dup */
 124     AV_CH_TOP_BACK_CENTER,
 125     AV_CH_TOP_BACK_LEFT,
 126     AV_CH_TOP_BACK_RIGHT,
 127     AV_CH_BACK_CENTER,          /* rear low center -- dup */
 128     AV_CH_BACK_LEFT,            /* rear low left -- dup */
 129     AV_CH_BACK_RIGHT            /* read low right -- dup  */
 130 };
 131
 132 /* -1 are reserved or unknown */
 133 static const int dca_ext_audio_descr_mask[] = {
 134     DCA_EXT_XCH,
 135     -1,
 136     DCA_EXT_X96,
 137     DCA_EXT_XCH | DCA_EXT_X96,
 138     -1,
 139     -1,
 140     DCA_EXT_XXCH,
 141     -1,
 142 };
 143
 144 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
 145  * Some compromises have been made for special configurations. Most configurations
 146  * are never used so complete accuracy is not needed.
 147  *
 148  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
 149  * S  -> side, when both rear and back are configured move one of them to the side channel
 150  * OV -> center back
 151  * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
 152  */
 153 static const uint64_t dca_core_channel_layout[] = {
 154     AV_CH_FRONT_CENTER,                                                     ///< 1, A
 155     AV_CH_LAYOUT_STEREO,                                                    ///< 2, A + B (dual mono)
 156     AV_CH_LAYOUT_STEREO,                                                    ///< 2, L + R (stereo)
 157     AV_CH_LAYOUT_STEREO,                                                    ///< 2, (L + R) + (L - R) (sum-difference)
 158     AV_CH_LAYOUT_STEREO,                                                    ///< 2, LT + RT (left and right total)
 159     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER,                               ///< 3, C + L + R
 160     AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER,                                ///< 3, L + R + S
 161     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER,           ///< 4, C + L + R + S
 162     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,               ///< 4, L + R + SL + SR
 163
 164     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
 165     AV_CH_SIDE_RIGHT,                                                       ///< 5, C + L + R + SL + SR
 166
 167     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
 168     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER,               ///< 6, CL + CR + L + R + SL + SR
 169
 170     AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
 171     AV_CH_FRONT_CENTER  | AV_CH_BACK_CENTER,                                ///< 6, C + L + R + LR + RR + OV
 172
 173     AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
 174     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER   |
 175     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 6, CF + CR + LF + RF + LR + RR
 176
 177     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
 178     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
 179     AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,                                     ///< 7, CL + C + CR + L + R + SL + SR
 180
 181     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
 182     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
 183     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2
 184
 185     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
 186     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
 187     AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT,                 ///< 8, CL + C + CR + L + R + SL + S + SR
 188 };
 189
 190 static const int8_t dca_lfe_index[] = {
 191     1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
 192 };
 193
 194 static const int8_t dca_channel_reorder_lfe[][9] = {
 195     { 0, -1, -1, -1, -1, -1, -1, -1, -1 },
 196     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 197     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 198     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 199     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 200     { 2,  0,  1, -1, -1, -1, -1, -1, -1 },
 201     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },
 202     { 2,  0,  1,  4, -1, -1, -1, -1, -1 },
 203     { 0,  1,  3,  4, -1, -1, -1, -1, -1 },
 204     { 2,  0,  1,  4,  5, -1, -1, -1, -1 },
 205     { 3,  4,  0,  1,  5,  6, -1, -1, -1 },
 206     { 2,  0,  1,  4,  5,  6, -1, -1, -1 },
 207     { 0,  6,  4,  5,  2,  3, -1, -1, -1 },
 208     { 4,  2,  5,  0,  1,  6,  7, -1, -1 },
 209     { 5,  6,  0,  1,  7,  3,  8,  4, -1 },
 210     { 4,  2,  5,  0,  1,  6,  8,  7, -1 },
 211 };
 212
 213 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
 214     { 0,  2, -1, -1, -1, -1, -1, -1, -1 },
 215     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },
 216     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },
 217     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },
 218     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },
 219     { 2,  0,  1,  4, -1, -1, -1, -1, -1 },
 220     { 0,  1,  3,  4, -1, -1, -1, -1, -1 },
 221     { 2,  0,  1,  4,  5, -1, -1, -1, -1 },
 222     { 0,  1,  4,  5,  3, -1, -1, -1, -1 },
 223     { 2,  0,  1,  5,  6,  4, -1, -1, -1 },
 224     { 3,  4,  0,  1,  6,  7,  5, -1, -1 },
 225     { 2,  0,  1,  4,  5,  6,  7, -1, -1 },
 226     { 0,  6,  4,  5,  2,  3,  7, -1, -1 },
 227     { 4,  2,  5,  0,  1,  7,  8,  6, -1 },
 228     { 5,  6,  0,  1,  8,  3,  9,  4,  7 },
 229     { 4,  2,  5,  0,  1,  6,  9,  8,  7 },
 230 };
 231
 232 static const int8_t dca_channel_reorder_nolfe[][9] = {
 233     { 0, -1, -1, -1, -1, -1, -1, -1, -1 },
 234     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 235     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 236     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 237     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 238     { 2,  0,  1, -1, -1, -1, -1, -1, -1 },
 239     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },
 240     { 2,  0,  1,  3, -1, -1, -1, -1, -1 },
 241     { 0,  1,  2,  3, -1, -1, -1, -1, -1 },
 242     { 2,  0,  1,  3,  4, -1, -1, -1, -1 },
 243     { 2,  3,  0,  1,  4,  5, -1, -1, -1 },
 244     { 2,  0,  1,  3,  4,  5, -1, -1, -1 },
 245     { 0,  5,  3,  4,  1,  2, -1, -1, -1 },
 246     { 3,  2,  4,  0,  1,  5,  6, -1, -1 },
 247     { 4,  5,  0,  1,  6,  2,  7,  3, -1 },
 248     { 3,  2,  4,  0,  1,  5,  7,  6, -1 },
 249 };
 250
 251 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
 252     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 253     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },
 254     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },
 255     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },
 256     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },
 257     { 2,  0,  1,  3, -1, -1, -1, -1, -1 },
 258     { 0,  1,  2,  3, -1, -1, -1, -1, -1 },
 259     { 2,  0,  1,  3,  4, -1, -1, -1, -1 },
 260     { 0,  1,  3,  4,  2, -1, -1, -1, -1 },
 261     { 2,  0,  1,  4,  5,  3, -1, -1, -1 },
 262     { 2,  3,  0,  1,  5,  6,  4, -1, -1 },
 263     { 2,  0,  1,  3,  4,  5,  6, -1, -1 },
 264     { 0,  5,  3,  4,  1,  2,  6, -1, -1 },
 265     { 3,  2,  4,  0,  1,  6,  7,  5, -1 },
 266     { 4,  5,  0,  1,  7,  2,  8,  3,  6 },
 267     { 3,  2,  4,  0,  1,  5,  8,  7,  6 },
 268 };
 269
 270 #define DCA_DOLBY                  101           /* FIXME */
 271
 272 #define DCA_CHANNEL_BITS             6
 273 #define DCA_CHANNEL_MASK          0x3F
 274
 275 #define DCA_LFE                   0x80
 276
 277 #define HEADER_SIZE                 14
 278
 279 #define DCA_NSYNCAUX        0x9A1105A0
 280
 281 /** Bit allocation */
 282 typedef struct BitAlloc {
 283     int offset;                 ///< code values offset
 284     int maxbits[8];             ///< max bits in VLC
 285     int wrap;                   ///< wrap for get_vlc2()
 286     VLC vlc[8];                 ///< actual codes
 287 } BitAlloc;
 288
 289 static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
 290 static BitAlloc dca_tmode;             ///< transition mode VLCs
 291 static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
 292 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
 293
 294 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
 295                                          int idx)
 296 {
 297     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
 298            ba->offset;
 299 }
 300
 301 static float dca_dmix_code(unsigned code);
 302
 303 static const uint16_t dca_vlc_offs[] = {
 304         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
 305      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
 306      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
 307      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
 308     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
 309     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
 310 };
 311
 312 static av_cold void dca_init_vlcs(void)
 313 {
 314     static int vlcs_initialized = 0;
 315     int i, j, c = 14;
 316     static VLC_TYPE dca_table[23622][2];
 317
 318     if (vlcs_initialized)
 319         return;
 320
 321     dca_bitalloc_index.offset = 1;
 322     dca_bitalloc_index.wrap   = 2;
 323     for (i = 0; i < 5; i++) {
 324         dca_bitalloc_index.vlc[i].table           = &dca_table[dca_vlc_offs[i]];
 325         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
 326         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
 327                  bitalloc_12_bits[i], 1, 1,
 328                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 329     }
 330     dca_scalefactor.offset = -64;
 331     dca_scalefactor.wrap   = 2;
 332     for (i = 0; i < 5; i++) {
 333         dca_scalefactor.vlc[i].table           = &dca_table[dca_vlc_offs[i + 5]];
 334         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
 335         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
 336                  scales_bits[i], 1, 1,
 337                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 338     }
 339     dca_tmode.offset = 0;
 340     dca_tmode.wrap   = 1;
 341     for (i = 0; i < 4; i++) {
 342         dca_tmode.vlc[i].table           = &dca_table[dca_vlc_offs[i + 10]];
 343         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
 344         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
 345                  tmode_bits[i], 1, 1,
 346                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 347     }
 348
 349     for (i = 0; i < 10; i++)
 350         for (j = 0; j < 7; j++) {
 351             if (!bitalloc_codes[i][j])
 352                 break;
 353             dca_smpl_bitalloc[i + 1].offset                 = bitalloc_offsets[i];
 354             dca_smpl_bitalloc[i + 1].wrap                   = 1 + (j > 4);
 355             dca_smpl_bitalloc[i + 1].vlc[j].table           = &dca_table[dca_vlc_offs[c]];
 356             dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
 357
 358             init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
 359                      bitalloc_sizes[i],
 360                      bitalloc_bits[i][j], 1, 1,
 361                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
 362             c++;
 363         }
 364     vlcs_initialized = 1;
 365 }
 366
 367 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
 368 {
 369     while (len--)
 370         *dst++ = get_bits(gb, bits);
 371 }
 372
 373 static inline int dca_xxch2index(DCAContext *s, int xxch_ch)
 374 {
 375     int i, base, mask;
 376
 377     /* locate channel set containing the channel */
 378     for (i = -1, base = 0, mask = (s->xxch_core_spkmask & ~DCA_XXCH_LFE1);
 379          i <= s->xxch_chset && !(mask & xxch_ch); mask = s->xxch_spk_masks[++i])
 380         base += av_popcount(mask);
 381
 382     return base + av_popcount(mask & (xxch_ch - 1));
 383 }
 384
 385 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,
 386                                          int xxch)
 387 {
 388     int i, j;
 389     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
 390     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
 391     static const int thr[11]    = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
 392     int hdr_pos = 0, hdr_size = 0;
 393     float scale_factor;
 394     int this_chans, acc_mask;
 395     int embedded_downmix;
 396     int nchans, mask[8];
 397     int coeff, ichan;
 398
 399     /* xxch has arbitrary sized audio coding headers */
 400     if (xxch) {
 401         hdr_pos  = get_bits_count(&s->gb);
 402         hdr_size = get_bits(&s->gb, 7) + 1;
 403     }
 404
 405     nchans = get_bits(&s->gb, 3) + 1;
 406     s->total_channels = nchans + base_channel;
 407     s->prim_channels  = s->total_channels;
 408
 409     /* obtain speaker layout mask & downmix coefficients for XXCH */
 410     if (xxch) {
 411         acc_mask = s->xxch_core_spkmask;
 412
 413         this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6;
 414         s->xxch_spk_masks[s->xxch_chset] = this_chans;
 415         s->xxch_chset_nch[s->xxch_chset] = nchans;
 416
 417         for (i = 0; i <= s->xxch_chset; i++)
 418             acc_mask |= s->xxch_spk_masks[i];
 419
 420         /* check for downmixing information */
 421         if (get_bits1(&s->gb)) {
 422             embedded_downmix = get_bits1(&s->gb);
 423             coeff            = get_bits(&s->gb, 6);
 424
 425             if (coeff<1 || coeff>61) {
 426                 av_log(s->avctx, AV_LOG_ERROR, "6bit coeff %d is out of range\n", coeff);
 427                 return AVERROR_INVALIDDATA;
 428             }
 429
 430             scale_factor     = -1.0f / dca_dmix_code((coeff<<2)-3);
 431
 432             s->xxch_dmix_sf[s->xxch_chset] = scale_factor;
 433
 434             for (i = base_channel; i < s->prim_channels; i++) {
 435                 mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask);
 436             }
 437
 438             for (j = base_channel; j < s->prim_channels; j++) {
 439                 memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0]));
 440                 s->xxch_dmix_embedded |= (embedded_downmix << j);
 441                 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
 442                     if (mask[j] & (1 << i)) {
 443                         if ((1 << i) == DCA_XXCH_LFE1) {
 444                             av_log(s->avctx, AV_LOG_WARNING,
 445                                    "DCA-XXCH: dmix to LFE1 not supported.\n");
 446                             continue;
 447                         }
 448
 449                         coeff = get_bits(&s->gb, 7);
 450                         ichan = dca_xxch2index(s, 1 << i);
 451                         if ((coeff&63)<1 || (coeff&63)>61) {
 452                             av_log(s->avctx, AV_LOG_ERROR, "7bit coeff %d is out of range\n", coeff);
 453                             return AVERROR_INVALIDDATA;
 454                         }
 455                         s->xxch_dmix_coeff[j][ichan] = dca_dmix_code((coeff<<2)-3);
 456                     }
 457                 }
 458             }
 459         }
 460     }
 461
 462     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
 463         s->prim_channels = DCA_PRIM_CHANNELS_MAX;
 464
 465     for (i = base_channel; i < s->prim_channels; i++) {
 466         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
 467         if (s->subband_activity[i] > DCA_SUBBANDS)
 468             s->subband_activity[i] = DCA_SUBBANDS;
 469     }
 470     for (i = base_channel; i < s->prim_channels; i++) {
 471         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
 472         if (s->vq_start_subband[i] > DCA_SUBBANDS)
 473             s->vq_start_subband[i] = DCA_SUBBANDS;
 474     }
 475     get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);
 476     get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);
 477     get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
 478     get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);
 479
 480     /* Get codebooks quantization indexes */
 481     if (!base_channel)
 482         memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
 483     for (j = 1; j < 11; j++)
 484         for (i = base_channel; i < s->prim_channels; i++)
 485             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
 486
 487     /* Get scale factor adjustment */
 488     for (j = 0; j < 11; j++)
 489         for (i = base_channel; i < s->prim_channels; i++)
 490             s->scalefactor_adj[i][j] = 1;
 491
 492     for (j = 1; j < 11; j++)
 493         for (i = base_channel; i < s->prim_channels; i++)
 494             if (s->quant_index_huffman[i][j] < thr[j])
 495                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
 496
 497     if (!xxch) {
 498         if (s->crc_present) {
 499             /* Audio header CRC check */
 500             get_bits(&s->gb, 16);
 501         }
 502     } else {
 503         /* Skip to the end of the header, also ignore CRC if present  */
 504         i = get_bits_count(&s->gb);
 505         if (hdr_pos + 8 * hdr_size > i)
 506             skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);
 507     }
 508
 509     s->current_subframe    = 0;
 510     s->current_subsubframe = 0;
 511
 512     return 0;
 513 }
 514
 515 static int dca_parse_frame_header(DCAContext *s)
 516 {
 517     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
 518
 519     /* Sync code */
 520     skip_bits_long(&s->gb, 32);
 521
 522     /* Frame header */
 523     s->frame_type        = get_bits(&s->gb, 1);
 524     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
 525     s->crc_present       = get_bits(&s->gb, 1);
 526     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
 527     s->frame_size        = get_bits(&s->gb, 14) + 1;
 528     if (s->frame_size < 95)
 529         return AVERROR_INVALIDDATA;
 530     s->amode             = get_bits(&s->gb, 6);
 531     s->sample_rate       = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
 532     if (!s->sample_rate)
 533         return AVERROR_INVALIDDATA;
 534     s->bit_rate_index    = get_bits(&s->gb, 5);
 535     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
 536     if (!s->bit_rate)
 537         return AVERROR_INVALIDDATA;
 538
 539     skip_bits1(&s->gb); // always 0 (reserved, cf. ETSI TS 102 114 V1.4.1)
 540     s->dynrange          = get_bits(&s->gb, 1);
 541     s->timestamp         = get_bits(&s->gb, 1);
 542     s->aux_data          = get_bits(&s->gb, 1);
 543     s->hdcd              = get_bits(&s->gb, 1);
 544     s->ext_descr         = get_bits(&s->gb, 3);
 545     s->ext_coding        = get_bits(&s->gb, 1);
 546     s->aspf              = get_bits(&s->gb, 1);
 547     s->lfe               = get_bits(&s->gb, 2);
 548     s->predictor_history = get_bits(&s->gb, 1);
 549
 550     if (s->lfe > 2) {
 551         s->lfe = 0;
 552         av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
 553         return AVERROR_INVALIDDATA;
 554     }
 555
 556     /* TODO: check CRC */
 557     if (s->crc_present)
 558         s->header_crc    = get_bits(&s->gb, 16);
 559
 560     s->multirate_inter   = get_bits(&s->gb, 1);
 561     s->version           = get_bits(&s->gb, 4);
 562     s->copy_history      = get_bits(&s->gb, 2);
 563     s->source_pcm_res    = get_bits(&s->gb, 3);
 564     s->front_sum         = get_bits(&s->gb, 1);
 565     s->surround_sum      = get_bits(&s->gb, 1);
 566     s->dialog_norm       = get_bits(&s->gb, 4);
 567
 568     /* FIXME: channels mixing levels */
 569     s->output = s->amode;
 570     if (s->lfe)
 571         s->output |= DCA_LFE;
 572
 573     /* Primary audio coding header */
 574     s->subframes = get_bits(&s->gb, 4) + 1;
 575
 576     return dca_parse_audio_coding_header(s, 0, 0);
 577 }
 578
 579 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
 580 {
 581     if (level < 5) {
 582         /* huffman encoded */
 583         value += get_bitalloc(gb, &dca_scalefactor, level);
 584         value  = av_clip(value, 0, (1 << log2range) - 1);
 585     } else if (level < 8) {
 586         if (level + 1 > log2range) {
 587             skip_bits(gb, level + 1 - log2range);
 588             value = get_bits(gb, log2range);
 589         } else {
 590             value = get_bits(gb, level + 1);
 591         }
 592     }
 593     return value;
 594 }
 595
 596 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
 597 {
 598     /* Primary audio coding side information */
 599     int j, k;
 600
 601     if (get_bits_left(&s->gb) < 0)
 602         return AVERROR_INVALIDDATA;
 603
 604     if (!base_channel) {
 605         s->subsubframes[s->current_subframe]    = get_bits(&s->gb, 2) + 1;
 606         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
 607     }
 608
 609     for (j = base_channel; j < s->prim_channels; j++) {
 610         for (k = 0; k < s->subband_activity[j]; k++)
 611             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
 612     }
 613
 614     /* Get prediction codebook */
 615     for (j = base_channel; j < s->prim_channels; j++) {
 616         for (k = 0; k < s->subband_activity[j]; k++) {
 617             if (s->prediction_mode[j][k] > 0) {
 618                 /* (Prediction coefficient VQ address) */
 619                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
 620             }
 621         }
 622     }
 623
 624     /* Bit allocation index */
 625     for (j = base_channel; j < s->prim_channels; j++) {
 626         for (k = 0; k < s->vq_start_subband[j]; k++) {
 627             if (s->bitalloc_huffman[j] == 6)
 628                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
 629             else if (s->bitalloc_huffman[j] == 5)
 630                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
 631             else if (s->bitalloc_huffman[j] == 7) {
 632                 av_log(s->avctx, AV_LOG_ERROR,
 633                        "Invalid bit allocation index\n");
 634                 return AVERROR_INVALIDDATA;
 635             } else {
 636                 s->bitalloc[j][k] =
 637                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
 638             }
 639
 640             if (s->bitalloc[j][k] > 26) {
 641                 av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
 642                         j, k, s->bitalloc[j][k]);
 643                 return AVERROR_INVALIDDATA;
 644             }
 645         }
 646     }
 647
 648     /* Transition mode */
 649     for (j = base_channel; j < s->prim_channels; j++) {
 650         for (k = 0; k < s->subband_activity[j]; k++) {
 651             s->transition_mode[j][k] = 0;
 652             if (s->subsubframes[s->current_subframe] > 1 &&
 653                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
 654                 s->transition_mode[j][k] =
 655                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
 656             }
 657         }
 658     }
 659
 660     if (get_bits_left(&s->gb) < 0)
 661         return AVERROR_INVALIDDATA;
 662
 663     for (j = base_channel; j < s->prim_channels; j++) {
 664         const uint32_t *scale_table;
 665         int scale_sum, log_size;
 666
 667         memset(s->scale_factor[j], 0,
 668                s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
 669
 670         if (s->scalefactor_huffman[j] == 6) {
 671             scale_table = scale_factor_quant7;
 672             log_size    = 7;
 673         } else {
 674             scale_table = scale_factor_quant6;
 675             log_size    = 6;
 676         }
 677
 678         /* When huffman coded, only the difference is encoded */
 679         scale_sum = 0;
 680
 681         for (k = 0; k < s->subband_activity[j]; k++) {
 682             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
 683                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
 684                 s->scale_factor[j][k][0] = scale_table[scale_sum];
 685             }
 686
 687             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
 688                 /* Get second scale factor */
 689                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
 690                 s->scale_factor[j][k][1] = scale_table[scale_sum];
 691             }
 692         }
 693     }
 694
 695     /* Joint subband scale factor codebook select */
 696     for (j = base_channel; j < s->prim_channels; j++) {
 697         /* Transmitted only if joint subband coding enabled */
 698         if (s->joint_intensity[j] > 0)
 699             s->joint_huff[j] = get_bits(&s->gb, 3);
 700     }
 701
 702     if (get_bits_left(&s->gb) < 0)
 703         return AVERROR_INVALIDDATA;
 704
 705     /* Scale factors for joint subband coding */
 706     for (j = base_channel; j < s->prim_channels; j++) {
 707         int source_channel;
 708
 709         /* Transmitted only if joint subband coding enabled */
 710         if (s->joint_intensity[j] > 0) {
 711             int scale = 0;
 712             source_channel = s->joint_intensity[j] - 1;
 713
 714             /* When huffman coded, only the difference is encoded
 715              * (is this valid as well for joint scales ???) */
 716
 717             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
 718                 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
 719                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
 720             }
 721
 722             if (!(s->debug_flag & 0x02)) {
 723                 av_log(s->avctx, AV_LOG_DEBUG,
 724                        "Joint stereo coding not supported\n");
 725                 s->debug_flag |= 0x02;
 726             }
 727         }
 728     }
 729
 730     /* Dynamic range coefficient */
 731     if (!base_channel && s->dynrange)
 732         s->dynrange_coef = get_bits(&s->gb, 8);
 733
 734     /* Side information CRC check word */
 735     if (s->crc_present) {
 736         get_bits(&s->gb, 16);
 737     }
 738
 739     /*
 740      * Primary audio data arrays
 741      */
 742
 743     /* VQ encoded high frequency subbands */
 744     for (j = base_channel; j < s->prim_channels; j++)
 745         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 746             /* 1 vector -> 32 samples */
 747             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
 748
 749     /* Low frequency effect data */
 750     if (!base_channel && s->lfe) {
 751         int quant7;
 752         /* LFE samples */
 753         int lfe_samples    = 2 * s->lfe * (4 + block_index);
 754         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
 755         float lfe_scale;
 756
 757         for (j = lfe_samples; j < lfe_end_sample; j++) {
 758             /* Signed 8 bits int */
 759             s->lfe_data[j] = get_sbits(&s->gb, 8);
 760         }
 761
 762         /* Scale factor index */
 763         quant7 = get_bits(&s->gb, 8);
 764         if (quant7 > 127) {
 765             avpriv_request_sample(s->avctx, "LFEScaleIndex larger than 127");
 766             return AVERROR_INVALIDDATA;
 767         }
 768         s->lfe_scale_factor = scale_factor_quant7[quant7];
 769
 770         /* Quantization step size * scale factor */
 771         lfe_scale = 0.035 * s->lfe_scale_factor;
 772
 773         for (j = lfe_samples; j < lfe_end_sample; j++)
 774             s->lfe_data[j] *= lfe_scale;
 775     }
 776
 777     return 0;
 778 }
 779
 780 static void qmf_32_subbands(DCAContext *s, int chans,
 781                             float samples_in[32][8], float *samples_out,
 782                             float scale)
 783 {
 784     const float *prCoeff;
 785
 786     int sb_act = s->subband_activity[chans];
 787
 788     scale *= sqrt(1 / 8.0);
 789
 790     /* Select filter */
 791     if (!s->multirate_inter)    /* Non-perfect reconstruction */
 792         prCoeff = fir_32bands_nonperfect;
 793     else                        /* Perfect reconstruction */
 794         prCoeff = fir_32bands_perfect;
 795
 796     s->dcadsp.qmf_32_subbands(samples_in, sb_act, &s->synth, &s->imdct,
 797                               s->subband_fir_hist[chans],
 798                               &s->hist_index[chans],
 799                               s->subband_fir_noidea[chans], prCoeff,
 800                               samples_out, s->raXin, scale);
 801 }
 802
 803 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
 804                                   int num_deci_sample, float *samples_in,
 805                                   float *samples_out)
 806 {
 807     /* samples_in: An array holding decimated samples.
 808      *   Samples in current subframe starts from samples_in[0],
 809      *   while samples_in[-1], samples_in[-2], ..., stores samples
 810      *   from last subframe as history.
 811      *
 812      * samples_out: An array holding interpolated samples
 813      */
 814
 815     int idx;
 816     const float *prCoeff;
 817     int deciindex;
 818
 819     /* Select decimation filter */
 820     if (decimation_select == 1) {
 821         idx     = 1;
 822         prCoeff = lfe_fir_128;
 823     } else {
 824         idx     = 0;
 825         prCoeff = lfe_fir_64;
 826     }
 827     /* Interpolation */
 828     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
 829         s->dcadsp.lfe_fir[idx](samples_out, samples_in, prCoeff);
 830         samples_in++;
 831         samples_out += 2 * 32 * (1 + idx);
 832     }
 833 }
 834
 835 /* downmixing routines */
 836 #define MIX_REAR1(samples, s1, rs, coef)            \
 837     samples[0][i] += samples[s1][i] * coef[rs][0];  \
 838     samples[1][i] += samples[s1][i] * coef[rs][1];
 839
 840 #define MIX_REAR2(samples, s1, s2, rs, coef)                                          \
 841     samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
 842     samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
 843
 844 #define MIX_FRONT3(samples, coef)                                      \
 845     t = samples[c][i];                                                 \
 846     u = samples[l][i];                                                 \
 847     v = samples[r][i];                                                 \
 848     samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0];  \
 849     samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
 850
 851 #define DOWNMIX_TO_STEREO(op1, op2)             \
 852     for (i = 0; i < 256; i++) {                 \
 853         op1                                     \
 854         op2                                     \
 855     }
 856
 857 static void dca_downmix(float **samples, int srcfmt, int lfe_present,
 858                         float coef[DCA_PRIM_CHANNELS_MAX + 1][2],
 859                         const int8_t *channel_mapping)
 860 {
 861     int c, l, r, sl, sr, s;
 862     int i;
 863     float t, u, v;
 864
 865     switch (srcfmt) {
 866     case DCA_MONO:
 867     case DCA_4F2R:
 868         av_log(NULL, AV_LOG_ERROR, "Not implemented!\n");
 869         break;
 870     case DCA_CHANNEL:
 871     case DCA_STEREO:
 872     case DCA_STEREO_TOTAL:
 873     case DCA_STEREO_SUMDIFF:
 874         break;
 875     case DCA_3F:
 876         c = channel_mapping[0];
 877         l = channel_mapping[1];
 878         r = channel_mapping[2];
 879         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
 880         break;
 881     case DCA_2F1R:
 882         s = channel_mapping[2];
 883         DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
 884         break;
 885     case DCA_3F1R:
 886         c = channel_mapping[0];
 887         l = channel_mapping[1];
 888         r = channel_mapping[2];
 889         s = channel_mapping[3];
 890         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
 891                           MIX_REAR1(samples, s, 3, coef));
 892         break;
 893     case DCA_2F2R:
 894         sl = channel_mapping[2];
 895         sr = channel_mapping[3];
 896         DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
 897         break;
 898     case DCA_3F2R:
 899         c  = channel_mapping[0];
 900         l  = channel_mapping[1];
 901         r  = channel_mapping[2];
 902         sl = channel_mapping[3];
 903         sr = channel_mapping[4];
 904         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
 905                           MIX_REAR2(samples, sl, sr, 3, coef));
 906         break;
 907     }
 908     if (lfe_present) {
 909         int lf_buf = dca_lfe_index[srcfmt];
 910         int lf_idx =  dca_channels[srcfmt];
 911         for (i = 0; i < 256; i++) {
 912             samples[0][i] += samples[lf_buf][i] * coef[lf_idx][0];
 913             samples[1][i] += samples[lf_buf][i] * coef[lf_idx][1];
 914         }
 915     }
 916 }
 917
 918 #ifndef decode_blockcodes
 919 /* Very compact version of the block code decoder that does not use table
 920  * look-up but is slightly slower */
 921 static int decode_blockcode(int code, int levels, int32_t *values)
 922 {
 923     int i;
 924     int offset = (levels - 1) >> 1;
 925
 926     for (i = 0; i < 4; i++) {
 927         int div = FASTDIV(code, levels);
 928         values[i] = code - offset - div * levels;
 929         code      = div;
 930     }
 931
 932     return code;
 933 }
 934
 935 static int decode_blockcodes(int code1, int code2, int levels, int32_t *values)
 936 {
 937     return decode_blockcode(code1, levels, values) |
 938            decode_blockcode(code2, levels, values + 4);
 939 }
 940 #endif
 941
 942 static const uint8_t abits_sizes[7]  = { 7, 10, 12, 13, 15, 17, 19 };
 943 static const uint8_t abits_levels[7] = { 3,  5,  7,  9, 13, 17, 25 };
 944
 945 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
 946 {
 947     int k, l;
 948     int subsubframe = s->current_subsubframe;
 949
 950     const float *quant_step_table;
 951
 952     /* FIXME */
 953     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
 954     LOCAL_ALIGNED_16(int32_t, block, [8 * DCA_SUBBANDS]);
 955
 956     /*
 957      * Audio data
 958      */
 959
 960     /* Select quantization step size table */
 961     if (s->bit_rate_index == 0x1f)
 962         quant_step_table = lossless_quant_d;
 963     else
 964         quant_step_table = lossy_quant_d;
 965
 966     for (k = base_channel; k < s->prim_channels; k++) {
 967         float rscale[DCA_SUBBANDS];
 968
 969         if (get_bits_left(&s->gb) < 0)
 970             return AVERROR_INVALIDDATA;
 971
 972         for (l = 0; l < s->vq_start_subband[k]; l++) {
 973             int m;
 974
 975             /* Select the mid-tread linear quantizer */
 976             int abits = s->bitalloc[k][l];
 977
 978             float quant_step_size = quant_step_table[abits];
 979
 980             /*
 981              * Determine quantization index code book and its type
 982              */
 983
 984             /* Select quantization index code book */
 985             int sel = s->quant_index_huffman[k][abits];
 986
 987             /*
 988              * Extract bits from the bit stream
 989              */
 990             if (!abits) {
 991                 rscale[l] = 0;
 992                 memset(block + 8 * l, 0, 8 * sizeof(block[0]));
 993             } else {
 994                 /* Deal with transients */
 995                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
 996                 rscale[l] = quant_step_size * s->scale_factor[k][l][sfi] *
 997                             s->scalefactor_adj[k][sel];
 998
 999                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1000                     if (abits <= 7) {
1001                         /* Block code */
1002                         int block_code1, block_code2, size, levels, err;
1003
1004                         size   = abits_sizes[abits - 1];
1005                         levels = abits_levels[abits - 1];
1006
1007                         block_code1 = get_bits(&s->gb, size);
1008                         block_code2 = get_bits(&s->gb, size);
1009                         err         = decode_blockcodes(block_code1, block_code2,
1010                                                         levels, block + 8 * l);
1011                         if (err) {
1012                             av_log(s->avctx, AV_LOG_ERROR,
1013                                    "ERROR: block code look-up failed\n");
1014                             return AVERROR_INVALIDDATA;
1015                         }
1016                     } else {
1017                         /* no coding */
1018                         for (m = 0; m < 8; m++)
1019                             block[8 * l + m] = get_sbits(&s->gb, abits - 3);
1020                     }
1021                 } else {
1022                     /* Huffman coded */
1023                     for (m = 0; m < 8; m++)
1024                         block[8 * l + m] = get_bitalloc(&s->gb,
1025                                                         &dca_smpl_bitalloc[abits], sel);
1026                 }
1027             }
1028         }
1029
1030         s->fmt_conv.int32_to_float_fmul_array8(&s->fmt_conv, subband_samples[k][0],
1031                                                block, rscale, 8 * s->vq_start_subband[k]);
1032
1033         for (l = 0; l < s->vq_start_subband[k]; l++) {
1034             int m;
1035             /*
1036              * Inverse ADPCM if in prediction mode
1037              */
1038             if (s->prediction_mode[k][l]) {
1039                 int n;
1040                 if (s->predictor_history)
1041                     subband_samples[k][l][0] += (adpcm_vb[s->prediction_vq[k][l]][0] *
1042                                                  s->subband_samples_hist[k][l][3] +
1043                                                  adpcm_vb[s->prediction_vq[k][l]][1] *
1044                                                  s->subband_samples_hist[k][l][2] +
1045                                                  adpcm_vb[s->prediction_vq[k][l]][2] *
1046                                                  s->subband_samples_hist[k][l][1] +
1047                                                  adpcm_vb[s->prediction_vq[k][l]][3] *
1048                                                  s->subband_samples_hist[k][l][0]) *
1049                                                 (1.0f / 8192);
1050                 for (m = 1; m < 8; m++) {
1051                     float sum = adpcm_vb[s->prediction_vq[k][l]][0] *
1052                                 subband_samples[k][l][m - 1];
1053                     for (n = 2; n <= 4; n++)
1054                         if (m >= n)
1055                             sum += adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1056                                    subband_samples[k][l][m - n];
1057                         else if (s->predictor_history)
1058                             sum += adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1059                                    s->subband_samples_hist[k][l][m - n + 4];
1060                     subband_samples[k][l][m] += sum * (1.0f / 8192);
1061                 }
1062             }
1063         }
1064
1065         /*
1066          * Decode VQ encoded high frequencies
1067          */
1068         if (s->subband_activity[k] > s->vq_start_subband[k]) {
1069             if (!(s->debug_flag & 0x01)) {
1070                 av_log(s->avctx, AV_LOG_DEBUG,
1071                        "Stream with high frequencies VQ coding\n");
1072                 s->debug_flag |= 0x01;
1073             }
1074             s->dcadsp.decode_hf(subband_samples[k], s->high_freq_vq[k],
1075                                 high_freq_vq, subsubframe * 8,
1076                                 s->scale_factor[k], s->vq_start_subband[k],
1077                                 s->subband_activity[k]);
1078         }
1079     }
1080
1081     /* Check for DSYNC after subsubframe */
1082     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1083         if (get_bits(&s->gb, 16) != 0xFFFF) {
1084             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1085             return AVERROR_INVALIDDATA;
1086         }
1087     }
1088
1089     /* Backup predictor history for adpcm */
1090     for (k = base_channel; k < s->prim_channels; k++)
1091         for (l = 0; l < s->vq_start_subband[k]; l++)
1092             AV_COPY128(s->subband_samples_hist[k][l], &subband_samples[k][l][4]);
1093
1094     return 0;
1095 }
1096
1097 static int dca_filter_channels(DCAContext *s, int block_index)
1098 {
1099     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1100     int k;
1101
1102     /* 32 subbands QMF */
1103     for (k = 0; k < s->prim_channels; k++) {
1104         if (s->channel_order_tab[k] >= 0)
1105             qmf_32_subbands(s, k, subband_samples[k],
1106                             s->samples_chanptr[s->channel_order_tab[k]],
1107                             M_SQRT1_2 / 32768.0);
1108     }
1109
1110     /* Generate LFE samples for this subsubframe FIXME!!! */
1111     if (s->lfe) {
1112         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1113                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1114                               s->samples_chanptr[s->lfe_index]);
1115         /* Outputs 20bits pcm samples */
1116     }
1117
1118     /* Downmixing to Stereo */
1119     if (s->prim_channels + !!s->lfe > 2 &&
1120         s->avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1121         dca_downmix(s->samples_chanptr, s->amode, !!s->lfe, s->downmix_coef,
1122                     s->channel_order_tab);
1123     }
1124
1125     return 0;
1126 }
1127
1128 static int dca_subframe_footer(DCAContext *s, int base_channel)
1129 {
1130     int in, out, aux_data_count, aux_data_end, reserved;
1131     uint32_t nsyncaux;
1132
1133     /*
1134      * Unpack optional information
1135      */
1136
1137     /* presumably optional information only appears in the core? */
1138     if (!base_channel) {
1139         if (s->timestamp)
1140             skip_bits_long(&s->gb, 32);
1141
1142         if (s->aux_data) {
1143             aux_data_count = get_bits(&s->gb, 6);
1144
1145             // align (32-bit)
1146             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1147
1148             aux_data_end = 8 * aux_data_count + get_bits_count(&s->gb);
1149
1150             if ((nsyncaux = get_bits_long(&s->gb, 32)) != DCA_NSYNCAUX) {
1151                 av_log(s->avctx, AV_LOG_ERROR, "nSYNCAUX mismatch %#"PRIx32"\n",
1152                        nsyncaux);
1153                 return AVERROR_INVALIDDATA;
1154             }
1155
1156             if (get_bits1(&s->gb)) { // bAUXTimeStampFlag
1157                 avpriv_request_sample(s->avctx,
1158                                       "Auxiliary Decode Time Stamp Flag");
1159                 // align (4-bit)
1160                 skip_bits(&s->gb, (-get_bits_count(&s->gb)) & 4);
1161                 // 44 bits: nMSByte (8), nMarker (4), nLSByte (28), nMarker (4)
1162                 skip_bits_long(&s->gb, 44);
1163             }
1164
1165             if ((s->core_downmix = get_bits1(&s->gb))) {
1166                 int am = get_bits(&s->gb, 3);
1167                 switch (am) {
1168                 case 0:
1169                     s->core_downmix_amode = DCA_MONO;
1170                     break;
1171                 case 1:
1172                     s->core_downmix_amode = DCA_STEREO;
1173                     break;
1174                 case 2:
1175                     s->core_downmix_amode = DCA_STEREO_TOTAL;
1176                     break;
1177                 case 3:
1178                     s->core_downmix_amode = DCA_3F;
1179                     break;
1180                 case 4:
1181                     s->core_downmix_amode = DCA_2F1R;
1182                     break;
1183                 case 5:
1184                     s->core_downmix_amode = DCA_2F2R;
1185                     break;
1186                 case 6:
1187                     s->core_downmix_amode = DCA_3F1R;
1188                     break;
1189                 default:
1190                     av_log(s->avctx, AV_LOG_ERROR,
1191                            "Invalid mode %d for embedded downmix coefficients\n",
1192                            am);
1193                     return AVERROR_INVALIDDATA;
1194                 }
1195                 for (out = 0; out < dca_channels[s->core_downmix_amode]; out++) {
1196                     for (in = 0; in < s->prim_channels + !!s->lfe; in++) {
1197                         uint16_t tmp = get_bits(&s->gb, 9);
1198                         if ((tmp & 0xFF) > 241) {
1199                             av_log(s->avctx, AV_LOG_ERROR,
1200                                    "Invalid downmix coefficient code %"PRIu16"\n",
1201                                    tmp);
1202                             return AVERROR_INVALIDDATA;
1203                         }
1204                         s->core_downmix_codes[in][out] = tmp;
1205                     }
1206                 }
1207             }
1208
1209             align_get_bits(&s->gb); // byte align
1210             skip_bits(&s->gb, 16);  // nAUXCRC16
1211
1212             // additional data (reserved, cf. ETSI TS 102 114 V1.4.1)
1213             if ((reserved = (aux_data_end - get_bits_count(&s->gb))) < 0) {
1214                 av_log(s->avctx, AV_LOG_ERROR,
1215                        "Overread auxiliary data by %d bits\n", -reserved);
1216                 return AVERROR_INVALIDDATA;
1217             } else if (reserved) {
1218                 avpriv_request_sample(s->avctx,
1219                                       "Core auxiliary data reserved content");
1220                 skip_bits_long(&s->gb, reserved);
1221             }
1222         }
1223
1224         if (s->crc_present && s->dynrange)
1225             get_bits(&s->gb, 16);
1226     }
1227
1228     return 0;
1229 }
1230
1231 /**
1232  * Decode a dca frame block
1233  *
1234  * @param s     pointer to the DCAContext
1235  */
1236
1237 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1238 {
1239     int ret;
1240
1241     /* Sanity check */
1242     if (s->current_subframe >= s->subframes) {
1243         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1244                s->current_subframe, s->subframes);
1245         return AVERROR_INVALIDDATA;
1246     }
1247
1248     if (!s->current_subsubframe) {
1249         /* Read subframe header */
1250         if ((ret = dca_subframe_header(s, base_channel, block_index)))
1251             return ret;
1252     }
1253
1254     /* Read subsubframe */
1255     if ((ret = dca_subsubframe(s, base_channel, block_index)))
1256         return ret;
1257
1258     /* Update state */
1259     s->current_subsubframe++;
1260     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1261         s->current_subsubframe = 0;
1262         s->current_subframe++;
1263     }
1264     if (s->current_subframe >= s->subframes) {
1265         /* Read subframe footer */
1266         if ((ret = dca_subframe_footer(s, base_channel)))
1267             return ret;
1268     }
1269
1270     return 0;
1271 }
1272
1273 int ff_dca_xbr_parse_frame(DCAContext *s)
1274 {
1275     int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];
1276     int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];
1277     int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS];
1278     int anctemp[DCA_CHSET_CHANS_MAX];
1279     int chset_fsize[DCA_CHSETS_MAX];
1280     int n_xbr_ch[DCA_CHSETS_MAX];
1281     int hdr_size, num_chsets, xbr_tmode, hdr_pos;
1282     int i, j, k, l, chset, chan_base;
1283
1284     av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n");
1285
1286     /* get bit position of sync header */
1287     hdr_pos = get_bits_count(&s->gb) - 32;
1288
1289     hdr_size = get_bits(&s->gb, 6) + 1;
1290     num_chsets = get_bits(&s->gb, 2) + 1;
1291
1292     for(i = 0; i < num_chsets; i++)
1293         chset_fsize[i] = get_bits(&s->gb, 14) + 1;
1294
1295     xbr_tmode = get_bits1(&s->gb);
1296
1297     for(i = 0; i < num_chsets; i++) {
1298         n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;
1299         k = get_bits(&s->gb, 2) + 5;
1300         for(j = 0; j < n_xbr_ch[i]; j++)
1301             active_bands[i][j] = get_bits(&s->gb, k) + 1;
1302     }
1303
1304     /* skip to the end of the header */
1305     i = get_bits_count(&s->gb);
1306     if(hdr_pos + hdr_size * 8 > i)
1307         skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1308
1309     /* loop over the channel data sets */
1310     /* only decode as many channels as we've decoded base data for */
1311     for(chset = 0, chan_base = 0;
1312         chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels;
1313         chan_base += n_xbr_ch[chset++]) {
1314         int start_posn = get_bits_count(&s->gb);
1315         int subsubframe = 0;
1316         int subframe = 0;
1317
1318         /* loop over subframes */
1319         for (k = 0; k < (s->sample_blocks / 8); k++) {
1320             /* parse header if we're on first subsubframe of a block */
1321             if(subsubframe == 0) {
1322                 /* Parse subframe header */
1323                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1324                     anctemp[i] = get_bits(&s->gb, 2) + 2;
1325                 }
1326
1327                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1328                     get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]);
1329                 }
1330
1331                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1332                     anctemp[i] = get_bits(&s->gb, 3);
1333                     if(anctemp[i] < 1) {
1334                         av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n");
1335                         return AVERROR_INVALIDDATA;
1336                     }
1337                 }
1338
1339                 /* generate scale factors */
1340                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1341                     const uint32_t *scale_table;
1342                     int nbits;
1343
1344                     if (s->scalefactor_huffman[chan_base+i] == 6) {
1345                         scale_table = scale_factor_quant7;
1346                     } else {
1347                         scale_table = scale_factor_quant6;
1348                     }
1349
1350                     nbits = anctemp[i];
1351
1352                     for(j = 0; j < active_bands[chset][i]; j++) {
1353                         if(abits_high[i][j] > 0) {
1354                             scale_table_high[i][j][0] =
1355                                 scale_table[get_bits(&s->gb, nbits)];
1356
1357                             if(xbr_tmode && s->transition_mode[i][j]) {
1358                                 scale_table_high[i][j][1] =
1359                                     scale_table[get_bits(&s->gb, nbits)];
1360                             }
1361                         }
1362                     }
1363                 }
1364             }
1365
1366             /* decode audio array for this block */
1367             for(i = 0; i < n_xbr_ch[chset]; i++) {
1368                 for(j = 0; j < active_bands[chset][i]; j++) {
1369                     const int xbr_abits = abits_high[i][j];
1370                     const float quant_step_size = lossless_quant_d[xbr_abits];
1371                     const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j];
1372                     const float rscale = quant_step_size * scale_table_high[i][j][sfi];
1373                     float *subband_samples = s->subband_samples[k][chan_base+i][j];
1374                     int block[8];
1375
1376                     if(xbr_abits <= 0)
1377                         continue;
1378
1379                     if(xbr_abits > 7) {
1380                         get_array(&s->gb, block, 8, xbr_abits - 3);
1381                     } else {
1382                         int block_code1, block_code2, size, levels, err;
1383
1384                         size   = abits_sizes[xbr_abits - 1];
1385                         levels = abits_levels[xbr_abits - 1];
1386
1387                         block_code1 = get_bits(&s->gb, size);
1388                         block_code2 = get_bits(&s->gb, size);
1389                         err = decode_blockcodes(block_code1, block_code2,
1390                                                 levels, block);
1391                         if (err) {
1392                             av_log(s->avctx, AV_LOG_ERROR,
1393                                    "ERROR: DTS-XBR: block code look-up failed\n");
1394                             return AVERROR_INVALIDDATA;
1395                         }
1396                     }
1397
1398                     /* scale & sum into subband */
1399                     for(l = 0; l < 8; l++)
1400                         subband_samples[l] += (float)block[l] * rscale;
1401                 }
1402             }
1403
1404             /* check DSYNC marker */
1405             if(s->aspf || subsubframe == s->subsubframes[subframe] - 1) {
1406                 if(get_bits(&s->gb, 16) != 0xffff) {
1407                     av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n");
1408                     return AVERROR_INVALIDDATA;
1409                 }
1410             }
1411
1412             /* advance sub-sub-frame index */
1413             if(++subsubframe >= s->subsubframes[subframe]) {
1414                 subsubframe = 0;
1415                 subframe++;
1416             }
1417         }
1418
1419         /* skip to next channel set */
1420         i = get_bits_count(&s->gb);
1421         if(start_posn + chset_fsize[chset] * 8 != i) {
1422             j = start_posn + chset_fsize[chset] * 8 - i;
1423             if(j < 0 || j >= 8)
1424                 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set,"
1425                        " skipping further than expected (%d bits)\n", j);
1426             skip_bits_long(&s->gb, j);
1427         }
1428     }
1429
1430     return 0;
1431 }
1432
1433
1434 /* parse initial header for XXCH and dump details */
1435 int ff_dca_xxch_decode_frame(DCAContext *s)
1436 {
1437     int hdr_size, spkmsk_bits, num_chsets, core_spk, hdr_pos;
1438     int i, chset, base_channel, chstart, fsize[8];
1439
1440     /* assume header word has already been parsed */
1441     hdr_pos     = get_bits_count(&s->gb) - 32;
1442     hdr_size    = get_bits(&s->gb, 6) + 1;
1443   /*chhdr_crc   =*/ skip_bits1(&s->gb);
1444     spkmsk_bits = get_bits(&s->gb, 5) + 1;
1445     num_chsets  = get_bits(&s->gb, 2) + 1;
1446
1447     for (i = 0; i < num_chsets; i++)
1448         fsize[i] = get_bits(&s->gb, 14) + 1;
1449
1450     core_spk               = get_bits(&s->gb, spkmsk_bits);
1451     s->xxch_core_spkmask   = core_spk;
1452     s->xxch_nbits_spk_mask = spkmsk_bits;
1453     s->xxch_dmix_embedded  = 0;
1454
1455     /* skip to the end of the header */
1456     i = get_bits_count(&s->gb);
1457     if (hdr_pos + hdr_size * 8 > i)
1458         skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1459
1460     for (chset = 0; chset < num_chsets; chset++) {
1461         chstart       = get_bits_count(&s->gb);
1462         base_channel  = s->prim_channels;
1463         s->xxch_chset = chset;
1464
1465         /* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs.
1466            5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */
1467         dca_parse_audio_coding_header(s, base_channel, 1);
1468
1469         /* decode channel data */
1470         for (i = 0; i < (s->sample_blocks / 8); i++) {
1471             if (dca_decode_block(s, base_channel, i)) {
1472                 av_log(s->avctx, AV_LOG_ERROR,
1473                        "Error decoding DTS-XXCH extension\n");
1474                 continue;
1475             }
1476         }
1477
1478         /* skip to end of this section */
1479         i = get_bits_count(&s->gb);
1480         if (chstart + fsize[chset] * 8 > i)
1481             skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i);
1482     }
1483     s->xxch_chset = num_chsets;
1484
1485     return 0;
1486 }
1487
1488 static float dca_dmix_code(unsigned code)
1489 {
1490     int sign = (code >> 8) - 1;
1491     code &= 0xff;
1492     return ((dca_dmixtable[code] ^ sign) - sign) * (1.0 / (1 << 15));
1493 }
1494
1495 /**
1496  * Main frame decoding function
1497  * FIXME add arguments
1498  */
1499 static int dca_decode_frame(AVCodecContext *avctx, void *data,
1500                             int *got_frame_ptr, AVPacket *avpkt)
1501 {
1502     AVFrame *frame     = data;
1503     const uint8_t *buf = avpkt->data;
1504     int buf_size       = avpkt->size;
1505     int channel_mask;
1506     int channel_layout;
1507     int lfe_samples;
1508     int num_core_channels = 0;
1509     int i, ret;
1510     float **samples_flt;
1511     float *src_chan;
1512     float *dst_chan;
1513     DCAContext *s = avctx->priv_data;
1514     int core_ss_end;
1515     int channels, full_channels;
1516     float scale;
1517     int achan;
1518     int chset;
1519     int mask;
1520     int lavc;
1521     int posn;
1522     int j, k;
1523     int endch;
1524
1525     s->xch_present = 0;
1526
1527     s->dca_buffer_size = avpriv_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1528                                                   DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1529     if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
1530         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1531         return AVERROR_INVALIDDATA;
1532     }
1533
1534     if ((ret = dca_parse_frame_header(s)) < 0) {
1535         // seems like the frame is corrupt, try with the next one
1536         return ret;
1537     }
1538     // set AVCodec values with parsed data
1539     avctx->sample_rate = s->sample_rate;
1540     avctx->bit_rate    = s->bit_rate;
1541
1542     s->profile = FF_PROFILE_DTS;
1543
1544     for (i = 0; i < (s->sample_blocks / 8); i++) {
1545         if ((ret = dca_decode_block(s, 0, i))) {
1546             av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
1547             return ret;
1548         }
1549     }
1550
1551     /* record number of core channels incase less than max channels are requested */
1552     num_core_channels = s->prim_channels;
1553
1554     if (s->prim_channels + !!s->lfe > 2 &&
1555         avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1556             /* Stereo downmix coefficients
1557              *
1558              * The decoder can only downmix to 2-channel, so we need to ensure
1559              * embedded downmix coefficients are actually targeting 2-channel.
1560              */
1561             if (s->core_downmix && (s->core_downmix_amode == DCA_STEREO ||
1562                                     s->core_downmix_amode == DCA_STEREO_TOTAL)) {
1563                 for (i = 0; i < num_core_channels + !!s->lfe; i++) {
1564                     /* Range checked earlier */
1565                     s->downmix_coef[i][0] = dca_dmix_code(s->core_downmix_codes[i][0]);
1566                     s->downmix_coef[i][1] = dca_dmix_code(s->core_downmix_codes[i][1]);
1567                 }
1568                 s->output = s->core_downmix_amode;
1569             } else {
1570                 int am = s->amode & DCA_CHANNEL_MASK;
1571                 if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
1572                     av_log(s->avctx, AV_LOG_ERROR,
1573                            "Invalid channel mode %d\n", am);
1574                     return AVERROR_INVALIDDATA;
1575                 }
1576                 if (num_core_channels + !!s->lfe >
1577                     FF_ARRAY_ELEMS(dca_default_coeffs[0])) {
1578                     avpriv_request_sample(s->avctx, "Downmixing %d channels",
1579                                           s->prim_channels + !!s->lfe);
1580                     return AVERROR_PATCHWELCOME;
1581                 }
1582                 for (i = 0; i < num_core_channels + !!s->lfe; i++) {
1583                     s->downmix_coef[i][0] = dca_default_coeffs[am][i][0];
1584                     s->downmix_coef[i][1] = dca_default_coeffs[am][i][1];
1585                 }
1586             }
1587             av_dlog(s->avctx, "Stereo downmix coeffs:\n");
1588             for (i = 0; i < num_core_channels + !!s->lfe; i++) {
1589                 av_dlog(s->avctx, "L, input channel %d = %f\n", i,
1590                         s->downmix_coef[i][0]);
1591                 av_dlog(s->avctx, "R, input channel %d = %f\n", i,
1592                         s->downmix_coef[i][1]);
1593             }
1594             av_dlog(s->avctx, "\n");
1595     }
1596
1597     if (s->ext_coding)
1598         s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
1599     else
1600         s->core_ext_mask = 0;
1601
1602     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1603
1604     /* only scan for extensions if ext_descr was unknown or indicated a
1605      * supported XCh extension */
1606     if (s->core_ext_mask < 0 || s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH)) {
1607         /* if ext_descr was unknown, clear s->core_ext_mask so that the
1608          * extensions scan can fill it up */
1609         s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
1610
1611         /* extensions start at 32-bit boundaries into bitstream */
1612         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1613
1614         while (core_ss_end - get_bits_count(&s->gb) >= 32) {
1615             uint32_t bits = get_bits_long(&s->gb, 32);
1616
1617             switch (bits) {
1618             case 0x5a5a5a5a: {
1619                 int ext_amode, xch_fsize;
1620
1621                 s->xch_base_channel = s->prim_channels;
1622
1623                 /* validate sync word using XCHFSIZE field */
1624                 xch_fsize = show_bits(&s->gb, 10);
1625                 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1626                     (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1627                     continue;
1628
1629                 /* skip length-to-end-of-frame field for the moment */
1630                 skip_bits(&s->gb, 10);
1631
1632                 s->core_ext_mask |= DCA_EXT_XCH;
1633
1634                 /* extension amode(number of channels in extension) should be 1 */
1635                 /* AFAIK XCh is not used for more channels */
1636                 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1637                     av_log(avctx, AV_LOG_ERROR,
1638                            "XCh extension amode %d not supported!\n",
1639                            ext_amode);
1640                     continue;
1641                 }
1642
1643                 if (s->xch_base_channel < 2) {
1644                     avpriv_request_sample(avctx, "XCh with fewer than 2 base channels");
1645                     continue;
1646                 }
1647
1648                 /* much like core primary audio coding header */
1649                 dca_parse_audio_coding_header(s, s->xch_base_channel, 0);
1650
1651                 for (i = 0; i < (s->sample_blocks / 8); i++)
1652                     if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
1653                         av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
1654                         continue;
1655                     }
1656
1657                 s->xch_present = 1;
1658                 break;
1659             }
1660             case 0x47004a03:
1661                 /* XXCh: extended channels */
1662                 /* usually found either in core or HD part in DTS-HD HRA streams,
1663                  * but not in DTS-ES which contains XCh extensions instead */
1664                 s->core_ext_mask |= DCA_EXT_XXCH;
1665                 ff_dca_xxch_decode_frame(s);
1666                 break;
1667
1668             case 0x1d95f262: {
1669                 int fsize96 = show_bits(&s->gb, 12) + 1;
1670                 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1671                     continue;
1672
1673                 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
1674                        get_bits_count(&s->gb));
1675                 skip_bits(&s->gb, 12);
1676                 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1677                 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1678
1679                 s->core_ext_mask |= DCA_EXT_X96;
1680                 break;
1681             }
1682             }
1683
1684             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1685         }
1686     } else {
1687         /* no supported extensions, skip the rest of the core substream */
1688         skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
1689     }
1690
1691     if (s->core_ext_mask & DCA_EXT_X96)
1692         s->profile = FF_PROFILE_DTS_96_24;
1693     else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
1694         s->profile = FF_PROFILE_DTS_ES;
1695
1696     /* check for ExSS (HD part) */
1697     if (s->dca_buffer_size - s->frame_size > 32 &&
1698         get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1699         ff_dca_exss_parse_header(s);
1700
1701     avctx->profile = s->profile;
1702
1703     full_channels = channels = s->prim_channels + !!s->lfe;
1704
1705     /* If we have XXCH then the channel layout is managed differently */
1706     /* note that XLL will also have another way to do things */
1707     if (!(s->core_ext_mask & DCA_EXT_XXCH)
1708         || (s->core_ext_mask & DCA_EXT_XXCH && avctx->request_channels > 0
1709             && avctx->request_channels
1710             < num_core_channels + !!s->lfe + s->xxch_chset_nch[0]))
1711     { /* xxx should also do MA extensions */
1712         if (s->amode < 16) {
1713             avctx->channel_layout = dca_core_channel_layout[s->amode];
1714
1715             if (s->prim_channels + !!s->lfe > 2 &&
1716                 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1717                 /*
1718                  * Neither the core's auxiliary data nor our default tables contain
1719                  * downmix coefficients for the additional channel coded in the XCh
1720                  * extension, so when we're doing a Stereo downmix, don't decode it.
1721                  */
1722                 s->xch_disable = 1;
1723             }
1724
1725 #if FF_API_REQUEST_CHANNELS
1726 FF_DISABLE_DEPRECATION_WARNINGS
1727             if (s->xch_present && !s->xch_disable &&
1728                 (!avctx->request_channels ||
1729                  avctx->request_channels > num_core_channels + !!s->lfe)) {
1730 FF_ENABLE_DEPRECATION_WARNINGS
1731 #else
1732             if (s->xch_present && !s->xch_disable) {
1733 #endif
1734                 if (avctx->channel_layout & AV_CH_BACK_CENTER) {
1735                     avpriv_request_sample(avctx, "XCh with Back center channel");
1736                     return AVERROR_INVALIDDATA;
1737                 }
1738                 avctx->channel_layout |= AV_CH_BACK_CENTER;
1739                 if (s->lfe) {
1740                     avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1741                     s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1742                 } else {
1743                     s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1744                 }
1745                 if (s->channel_order_tab[s->xch_base_channel] < 0)
1746                     return AVERROR_INVALIDDATA;
1747             } else {
1748                 channels       = num_core_channels + !!s->lfe;
1749                 s->xch_present = 0; /* disable further xch processing */
1750                 if (s->lfe) {
1751                     avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1752                     s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1753                 } else
1754                     s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1755             }
1756
1757             if (channels > !!s->lfe &&
1758                 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1759                 return AVERROR_INVALIDDATA;
1760
1761             if (av_get_channel_layout_nb_channels(avctx->channel_layout) != channels) {
1762                 av_log(avctx, AV_LOG_ERROR, "Number of channels %d mismatches layout %d\n", channels, av_get_channel_layout_nb_channels(avctx->channel_layout));
1763                 return AVERROR_INVALIDDATA;
1764             }
1765
1766             if (num_core_channels + !!s->lfe > 2 &&
1767                 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1768                 channels              = 2;
1769                 s->output             = s->prim_channels == 2 ? s->amode : DCA_STEREO;
1770                 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1771             }
1772             else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
1773                 static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
1774                 s->channel_order_tab = dca_channel_order_native;
1775             }
1776             s->lfe_index = dca_lfe_index[s->amode];
1777         } else {
1778             av_log(avctx, AV_LOG_ERROR,
1779                    "Non standard configuration %d !\n", s->amode);
1780             return AVERROR_INVALIDDATA;
1781         }
1782
1783         s->xxch_dmix_embedded = 0;
1784     } else {
1785         /* we only get here if an XXCH channel set can be added to the mix */
1786         channel_mask = s->xxch_core_spkmask;
1787
1788         if (avctx->request_channels > 0
1789             && avctx->request_channels < s->prim_channels) {
1790             channels = num_core_channels + !!s->lfe;
1791             for (i = 0; i < s->xxch_chset && channels + s->xxch_chset_nch[i]
1792                                               <= avctx->request_channels; i++) {
1793                 channels += s->xxch_chset_nch[i];
1794                 channel_mask |= s->xxch_spk_masks[i];
1795             }
1796         } else {
1797             channels = s->prim_channels + !!s->lfe;
1798             for (i = 0; i < s->xxch_chset; i++) {
1799                 channel_mask |= s->xxch_spk_masks[i];
1800             }
1801         }
1802
1803         /* Given the DTS spec'ed channel mask, generate an avcodec version */
1804         channel_layout = 0;
1805         for (i = 0; i < s->xxch_nbits_spk_mask; ++i) {
1806             if (channel_mask & (1 << i)) {
1807                 channel_layout |= map_xxch_to_native[i];
1808             }
1809         }
1810
1811         /* make sure that we have managed to get equivalent dts/avcodec channel
1812          * masks in some sense -- unfortunately some channels could overlap */
1813         if (av_popcount(channel_mask) != av_popcount(channel_layout)) {
1814             av_log(avctx, AV_LOG_DEBUG,
1815                    "DTS-XXCH: Inconsistent avcodec/dts channel layouts\n");
1816             return AVERROR_INVALIDDATA;
1817         }
1818
1819         avctx->channel_layout = channel_layout;
1820
1821         if (!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)) {
1822             /* Estimate DTS --> avcodec ordering table */
1823             for (chset = -1, j = 0; chset < s->xxch_chset; ++chset) {
1824                 mask = chset >= 0 ? s->xxch_spk_masks[chset]
1825                                   : s->xxch_core_spkmask;
1826                 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
1827                     if (mask & ~(DCA_XXCH_LFE1 | DCA_XXCH_LFE2) & (1 << i)) {
1828                         lavc = map_xxch_to_native[i];
1829                         posn = av_popcount(channel_layout & (lavc - 1));
1830                         s->xxch_order_tab[j++] = posn;
1831                     }
1832                 }
1833
1834             }
1835
1836             s->lfe_index = av_popcount(channel_layout & (AV_CH_LOW_FREQUENCY-1));
1837         } else { /* native ordering */
1838             for (i = 0; i < channels; i++)
1839                 s->xxch_order_tab[i] = i;
1840
1841             s->lfe_index = channels - 1;
1842         }
1843
1844         s->channel_order_tab = s->xxch_order_tab;
1845     }
1846
1847     if (avctx->channels != channels) {
1848         if (avctx->channels)
1849             av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
1850         avctx->channels = channels;
1851     }
1852
1853     /* get output buffer */
1854     frame->nb_samples = 256 * (s->sample_blocks / 8);
1855     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1856         return ret;
1857     samples_flt = (float **) frame->extended_data;
1858
1859     /* allocate buffer for extra channels if downmixing */
1860     if (avctx->channels < full_channels) {
1861         ret = av_samples_get_buffer_size(NULL, full_channels - channels,
1862                                          frame->nb_samples,
1863                                          avctx->sample_fmt, 0);
1864         if (ret < 0)
1865             return ret;
1866
1867         av_fast_malloc(&s->extra_channels_buffer,
1868                        &s->extra_channels_buffer_size, ret);
1869         if (!s->extra_channels_buffer)
1870             return AVERROR(ENOMEM);
1871
1872         ret = av_samples_fill_arrays((uint8_t **) s->extra_channels, NULL,
1873                                      s->extra_channels_buffer,
1874                                      full_channels - channels,
1875                                      frame->nb_samples, avctx->sample_fmt, 0);
1876         if (ret < 0)
1877             return ret;
1878     }
1879
1880     /* filter to get final output */
1881     for (i = 0; i < (s->sample_blocks / 8); i++) {
1882         int ch;
1883
1884         for (ch = 0; ch < channels; ch++)
1885             s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
1886         for (; ch < full_channels; ch++)
1887             s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
1888
1889         dca_filter_channels(s, i);
1890
1891         /* If this was marked as a DTS-ES stream we need to subtract back- */
1892         /* channel from SL & SR to remove matrixed back-channel signal */
1893         if ((s->source_pcm_res & 1) && s->xch_present) {
1894             float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];
1895             float *lt_chan   = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];
1896             float *rt_chan   = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];
1897             s->fdsp->vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
1898             s->fdsp->vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
1899         }
1900
1901         /* If stream contains XXCH, we might need to undo an embedded downmix */
1902         if (s->xxch_dmix_embedded) {
1903             /* Loop over channel sets in turn */
1904             ch = num_core_channels;
1905             for (chset = 0; chset < s->xxch_chset; chset++) {
1906                 endch = ch + s->xxch_chset_nch[chset];
1907                 mask = s->xxch_dmix_embedded;
1908
1909                 /* undo downmix */
1910                 for (j = ch; j < endch; j++) {
1911                     if (mask & (1 << j)) { /* this channel has been mixed-out */
1912                         src_chan = s->samples_chanptr[s->channel_order_tab[j]];
1913                         for (k = 0; k < endch; k++) {
1914                             achan = s->channel_order_tab[k];
1915                             scale = s->xxch_dmix_coeff[j][k];
1916                             if (scale != 0.0) {
1917                                 dst_chan = s->samples_chanptr[achan];
1918                                 s->fdsp->vector_fmac_scalar(dst_chan, src_chan,
1919                                                            -scale, 256);
1920                             }
1921                         }
1922                     }
1923                 }
1924
1925                 /* if a downmix has been embedded then undo the pre-scaling */
1926                 if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) {
1927                     scale = s->xxch_dmix_sf[chset];
1928
1929                     for (j = 0; j < ch; j++) {
1930                         src_chan = s->samples_chanptr[s->channel_order_tab[j]];
1931                         for (k = 0; k < 256; k++)
1932                             src_chan[k] *= scale;
1933                     }
1934
1935                     /* LFE channel is always part of core, scale if it exists */
1936                     if (s->lfe) {
1937                         src_chan = s->samples_chanptr[s->lfe_index];
1938                         for (k = 0; k < 256; k++)
1939                             src_chan[k] *= scale;
1940                     }
1941                 }
1942
1943                 ch = endch;
1944             }
1945
1946         }
1947     }
1948
1949     /* update lfe history */
1950     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1951     for (i = 0; i < 2 * s->lfe * 4; i++)
1952         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1953
1954     /* AVMatrixEncoding
1955      *
1956      * DCA_STEREO_TOTAL (Lt/Rt) is equivalent to Dolby Surround */
1957     ret = ff_side_data_update_matrix_encoding(frame,
1958                                               (s->output & ~DCA_LFE) == DCA_STEREO_TOTAL ?
1959                                               AV_MATRIX_ENCODING_DOLBY : AV_MATRIX_ENCODING_NONE);
1960     if (ret < 0)
1961         return ret;
1962
1963     *got_frame_ptr = 1;
1964
1965     return buf_size;
1966 }
1967
1968 /**
1969  * DCA initialization
1970  *
1971  * @param avctx     pointer to the AVCodecContext
1972  */
1973
1974 static av_cold int dca_decode_init(AVCodecContext *avctx)
1975 {
1976     DCAContext *s = avctx->priv_data;
1977
1978     s->avctx = avctx;
1979     dca_init_vlcs();
1980
1981     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & CODEC_FLAG_BITEXACT);
1982     if (!s->fdsp)
1983         return AVERROR(ENOMEM);
1984
1985     ff_mdct_init(&s->imdct, 6, 1, 1.0);
1986     ff_synth_filter_init(&s->synth);
1987     ff_dcadsp_init(&s->dcadsp);
1988     ff_fmt_convert_init(&s->fmt_conv, avctx);
1989
1990     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1991
1992     /* allow downmixing to stereo */
1993 #if FF_API_REQUEST_CHANNELS
1994 FF_DISABLE_DEPRECATION_WARNINGS
1995     if (avctx->request_channels == 2)
1996         avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
1997 FF_ENABLE_DEPRECATION_WARNINGS
1998 #endif
1999     if (avctx->channels > 2 &&
2000         avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
2001         avctx->channels = 2;
2002
2003     return 0;
2004 }
2005
2006 static av_cold int dca_decode_end(AVCodecContext *avctx)
2007 {
2008     DCAContext *s = avctx->priv_data;
2009     ff_mdct_end(&s->imdct);
2010     av_freep(&s->extra_channels_buffer);
2011     av_freep(&s->fdsp);
2012     return 0;
2013 }
2014
2015 static const AVProfile profiles[] = {
2016     { FF_PROFILE_DTS,        "DTS"        },
2017     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
2018     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
2019     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
2020     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
2021     { FF_PROFILE_UNKNOWN },
2022 };
2023
2024 static const AVOption options[] = {
2025     { "disable_xch", "disable decoding of the XCh extension", offsetof(DCAContext, xch_disable), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
2026     { NULL },
2027 };
2028
2029 static const AVClass dca_decoder_class = {
2030     .class_name = "DCA decoder",
2031     .item_name  = av_default_item_name,
2032     .option     = options,
2033     .version    = LIBAVUTIL_VERSION_INT,
2034     .category   = AV_CLASS_CATEGORY_DECODER,
2035 };
2036
2037 AVCodec ff_dca_decoder = {
2038     .name            = "dca",
2039     .long_name       = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
2040     .type            = AVMEDIA_TYPE_AUDIO,
2041     .id              = AV_CODEC_ID_DTS,
2042     .priv_data_size  = sizeof(DCAContext),
2043     .init            = dca_decode_init,
2044     .decode          = dca_decode_frame,
2045     .close           = dca_decode_end,
2046     .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
2047     .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2048                                                        AV_SAMPLE_FMT_NONE },
2049     .profiles        = NULL_IF_CONFIG_SMALL(profiles),
2050     .priv_class      = &dca_decoder_class,
2051 };