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 Libav.
   9  *
  10  * Libav 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  * Libav 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 Libav; 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 "put_bits.h"
  50 #include "synth_filter.h"
  51
  52 #if ARCH_ARM
  53 #   include "arm/dca.h"
  54 #endif
  55
  56 //#define TRACE
  57
  58 enum DCAMode {
  59     DCA_MONO = 0,
  60     DCA_CHANNEL,
  61     DCA_STEREO,
  62     DCA_STEREO_SUMDIFF,
  63     DCA_STEREO_TOTAL,
  64     DCA_3F,
  65     DCA_2F1R,
  66     DCA_3F1R,
  67     DCA_2F2R,
  68     DCA_3F2R,
  69     DCA_4F2R
  70 };
  71
  72 /* -1 are reserved or unknown */
  73 static const int dca_ext_audio_descr_mask[] = {
  74     DCA_EXT_XCH,
  75     -1,
  76     DCA_EXT_X96,
  77     DCA_EXT_XCH | DCA_EXT_X96,
  78     -1,
  79     -1,
  80     DCA_EXT_XXCH,
  81     -1,
  82 };
  83
  84 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
  85  * Some compromises have been made for special configurations. Most configurations
  86  * are never used so complete accuracy is not needed.
  87  *
  88  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
  89  * S  -> side, when both rear and back are configured move one of them to the side channel
  90  * OV -> center back
  91  * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
  92  */
  93 static const uint64_t dca_core_channel_layout[] = {
  94     AV_CH_FRONT_CENTER,                                                     ///< 1, A
  95     AV_CH_LAYOUT_STEREO,                                                    ///< 2, A + B (dual mono)
  96     AV_CH_LAYOUT_STEREO,                                                    ///< 2, L + R (stereo)
  97     AV_CH_LAYOUT_STEREO,                                                    ///< 2, (L + R) + (L - R) (sum-difference)
  98     AV_CH_LAYOUT_STEREO,                                                    ///< 2, LT + RT (left and right total)
  99     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER,                               ///< 3, C + L + R
 100     AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER,                                ///< 3, L + R + S
 101     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER,           ///< 4, C + L + R + S
 102     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,               ///< 4, L + R + SL + SR
 103
 104     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
 105     AV_CH_SIDE_RIGHT,                                                       ///< 5, C + L + R + SL + SR
 106
 107     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
 108     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER,               ///< 6, CL + CR + L + R + SL + SR
 109
 110     AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
 111     AV_CH_FRONT_CENTER  | AV_CH_BACK_CENTER,                                ///< 6, C + L + R + LR + RR + OV
 112
 113     AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
 114     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER   |
 115     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 6, CF + CR + LF + RF + LR + RR
 116
 117     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
 118     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
 119     AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,                                     ///< 7, CL + C + CR + L + R + SL + SR
 120
 121     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
 122     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
 123     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2
 124
 125     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
 126     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
 127     AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT,                 ///< 8, CL + C + CR + L + R + SL + S + SR
 128 };
 129
 130 static const int8_t dca_lfe_index[] = {
 131     1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
 132 };
 133
 134 static const int8_t dca_channel_reorder_lfe[][9] = {
 135     { 0, -1, -1, -1, -1, -1, -1, -1, -1 },
 136     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 137     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 138     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 139     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 140     { 2,  0,  1, -1, -1, -1, -1, -1, -1 },
 141     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },
 142     { 2,  0,  1,  4, -1, -1, -1, -1, -1 },
 143     { 0,  1,  3,  4, -1, -1, -1, -1, -1 },
 144     { 2,  0,  1,  4,  5, -1, -1, -1, -1 },
 145     { 3,  4,  0,  1,  5,  6, -1, -1, -1 },
 146     { 2,  0,  1,  4,  5,  6, -1, -1, -1 },
 147     { 0,  6,  4,  5,  2,  3, -1, -1, -1 },
 148     { 4,  2,  5,  0,  1,  6,  7, -1, -1 },
 149     { 5,  6,  0,  1,  7,  3,  8,  4, -1 },
 150     { 4,  2,  5,  0,  1,  6,  8,  7, -1 },
 151 };
 152
 153 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
 154     { 0,  2, -1, -1, -1, -1, -1, -1, -1 },
 155     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },
 156     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },
 157     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },
 158     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },
 159     { 2,  0,  1,  4, -1, -1, -1, -1, -1 },
 160     { 0,  1,  3,  4, -1, -1, -1, -1, -1 },
 161     { 2,  0,  1,  4,  5, -1, -1, -1, -1 },
 162     { 0,  1,  4,  5,  3, -1, -1, -1, -1 },
 163     { 2,  0,  1,  5,  6,  4, -1, -1, -1 },
 164     { 3,  4,  0,  1,  6,  7,  5, -1, -1 },
 165     { 2,  0,  1,  4,  5,  6,  7, -1, -1 },
 166     { 0,  6,  4,  5,  2,  3,  7, -1, -1 },
 167     { 4,  2,  5,  0,  1,  7,  8,  6, -1 },
 168     { 5,  6,  0,  1,  8,  3,  9,  4,  7 },
 169     { 4,  2,  5,  0,  1,  6,  9,  8,  7 },
 170 };
 171
 172 static const int8_t dca_channel_reorder_nolfe[][9] = {
 173     { 0, -1, -1, -1, -1, -1, -1, -1, -1 },
 174     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 175     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 176     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 177     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 178     { 2,  0,  1, -1, -1, -1, -1, -1, -1 },
 179     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },
 180     { 2,  0,  1,  3, -1, -1, -1, -1, -1 },
 181     { 0,  1,  2,  3, -1, -1, -1, -1, -1 },
 182     { 2,  0,  1,  3,  4, -1, -1, -1, -1 },
 183     { 2,  3,  0,  1,  4,  5, -1, -1, -1 },
 184     { 2,  0,  1,  3,  4,  5, -1, -1, -1 },
 185     { 0,  5,  3,  4,  1,  2, -1, -1, -1 },
 186     { 3,  2,  4,  0,  1,  5,  6, -1, -1 },
 187     { 4,  5,  0,  1,  6,  2,  7,  3, -1 },
 188     { 3,  2,  4,  0,  1,  5,  7,  6, -1 },
 189 };
 190
 191 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
 192     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },
 193     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },
 194     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },
 195     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },
 196     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },
 197     { 2,  0,  1,  3, -1, -1, -1, -1, -1 },
 198     { 0,  1,  2,  3, -1, -1, -1, -1, -1 },
 199     { 2,  0,  1,  3,  4, -1, -1, -1, -1 },
 200     { 0,  1,  3,  4,  2, -1, -1, -1, -1 },
 201     { 2,  0,  1,  4,  5,  3, -1, -1, -1 },
 202     { 2,  3,  0,  1,  5,  6,  4, -1, -1 },
 203     { 2,  0,  1,  3,  4,  5,  6, -1, -1 },
 204     { 0,  5,  3,  4,  1,  2,  6, -1, -1 },
 205     { 3,  2,  4,  0,  1,  6,  7,  5, -1 },
 206     { 4,  5,  0,  1,  7,  2,  8,  3,  6 },
 207     { 3,  2,  4,  0,  1,  5,  8,  7,  6 },
 208 };
 209
 210 #define DCA_DOLBY                  101           /* FIXME */
 211
 212 #define DCA_CHANNEL_BITS             6
 213 #define DCA_CHANNEL_MASK          0x3F
 214
 215 #define DCA_LFE                   0x80
 216
 217 #define HEADER_SIZE                 14
 218
 219 #define DCA_NSYNCAUX        0x9A1105A0
 220
 221 /** Bit allocation */
 222 typedef struct BitAlloc {
 223     int offset;                 ///< code values offset
 224     int maxbits[8];             ///< max bits in VLC
 225     int wrap;                   ///< wrap for get_vlc2()
 226     VLC vlc[8];                 ///< actual codes
 227 } BitAlloc;
 228
 229 static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
 230 static BitAlloc dca_tmode;             ///< transition mode VLCs
 231 static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
 232 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
 233
 234 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
 235                                          int idx)
 236 {
 237     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
 238            ba->offset;
 239 }
 240
 241 static const uint16_t dca_vlc_offs[] = {
 242         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
 243      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
 244      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
 245      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
 246     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
 247     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
 248 };
 249
 250 static av_cold void dca_init_vlcs(void)
 251 {
 252     static int vlcs_initialized = 0;
 253     int i, j, c = 14;
 254     static VLC_TYPE dca_table[23622][2];
 255
 256     if (vlcs_initialized)
 257         return;
 258
 259     dca_bitalloc_index.offset = 1;
 260     dca_bitalloc_index.wrap   = 2;
 261     for (i = 0; i < 5; i++) {
 262         dca_bitalloc_index.vlc[i].table           = &dca_table[dca_vlc_offs[i]];
 263         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
 264         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
 265                  bitalloc_12_bits[i], 1, 1,
 266                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 267     }
 268     dca_scalefactor.offset = -64;
 269     dca_scalefactor.wrap   = 2;
 270     for (i = 0; i < 5; i++) {
 271         dca_scalefactor.vlc[i].table           = &dca_table[dca_vlc_offs[i + 5]];
 272         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
 273         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
 274                  scales_bits[i], 1, 1,
 275                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 276     }
 277     dca_tmode.offset = 0;
 278     dca_tmode.wrap   = 1;
 279     for (i = 0; i < 4; i++) {
 280         dca_tmode.vlc[i].table           = &dca_table[dca_vlc_offs[i + 10]];
 281         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
 282         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
 283                  tmode_bits[i], 1, 1,
 284                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 285     }
 286
 287     for (i = 0; i < 10; i++)
 288         for (j = 0; j < 7; j++) {
 289             if (!bitalloc_codes[i][j])
 290                 break;
 291             dca_smpl_bitalloc[i + 1].offset                 = bitalloc_offsets[i];
 292             dca_smpl_bitalloc[i + 1].wrap                   = 1 + (j > 4);
 293             dca_smpl_bitalloc[i + 1].vlc[j].table           = &dca_table[dca_vlc_offs[c]];
 294             dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
 295
 296             init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
 297                      bitalloc_sizes[i],
 298                      bitalloc_bits[i][j], 1, 1,
 299                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
 300             c++;
 301         }
 302     vlcs_initialized = 1;
 303 }
 304
 305 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
 306 {
 307     while (len--)
 308         *dst++ = get_bits(gb, bits);
 309 }
 310
 311 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel)
 312 {
 313     int i, j;
 314     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
 315     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
 316     static const int thr[11]    = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
 317
 318     s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
 319     s->prim_channels  = s->total_channels;
 320
 321     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
 322         s->prim_channels = DCA_PRIM_CHANNELS_MAX;
 323
 324     for (i = base_channel; i < s->prim_channels; i++) {
 325         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
 326         if (s->subband_activity[i] > DCA_SUBBANDS)
 327             s->subband_activity[i] = DCA_SUBBANDS;
 328     }
 329     for (i = base_channel; i < s->prim_channels; i++) {
 330         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
 331         if (s->vq_start_subband[i] > DCA_SUBBANDS)
 332             s->vq_start_subband[i] = DCA_SUBBANDS;
 333     }
 334     get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);
 335     get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);
 336     get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
 337     get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);
 338
 339     /* Get codebooks quantization indexes */
 340     if (!base_channel)
 341         memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
 342     for (j = 1; j < 11; j++)
 343         for (i = base_channel; i < s->prim_channels; i++)
 344             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
 345
 346     /* Get scale factor adjustment */
 347     for (j = 0; j < 11; j++)
 348         for (i = base_channel; i < s->prim_channels; i++)
 349             s->scalefactor_adj[i][j] = 1;
 350
 351     for (j = 1; j < 11; j++)
 352         for (i = base_channel; i < s->prim_channels; i++)
 353             if (s->quant_index_huffman[i][j] < thr[j])
 354                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
 355
 356     if (s->crc_present) {
 357         /* Audio header CRC check */
 358         get_bits(&s->gb, 16);
 359     }
 360
 361     s->current_subframe    = 0;
 362     s->current_subsubframe = 0;
 363
 364 #ifdef TRACE
 365     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
 366     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
 367     for (i = base_channel; i < s->prim_channels; i++) {
 368         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
 369                s->subband_activity[i]);
 370         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
 371                s->vq_start_subband[i]);
 372         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
 373                s->joint_intensity[i]);
 374         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
 375                s->transient_huffman[i]);
 376         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
 377                s->scalefactor_huffman[i]);
 378         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
 379                s->bitalloc_huffman[i]);
 380         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
 381         for (j = 0; j < 11; j++)
 382             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
 383         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 384         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
 385         for (j = 0; j < 11; j++)
 386             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
 387         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 388     }
 389 #endif
 390
 391     return 0;
 392 }
 393
 394 static int dca_parse_frame_header(DCAContext *s)
 395 {
 396     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
 397
 398     /* Sync code */
 399     skip_bits_long(&s->gb, 32);
 400
 401     /* Frame header */
 402     s->frame_type        = get_bits(&s->gb, 1);
 403     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
 404     s->crc_present       = get_bits(&s->gb, 1);
 405     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
 406     s->frame_size        = get_bits(&s->gb, 14) + 1;
 407     if (s->frame_size < 95)
 408         return AVERROR_INVALIDDATA;
 409     s->amode             = get_bits(&s->gb, 6);
 410     s->sample_rate       = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
 411     if (!s->sample_rate)
 412         return AVERROR_INVALIDDATA;
 413     s->bit_rate_index    = get_bits(&s->gb, 5);
 414     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
 415     if (!s->bit_rate)
 416         return AVERROR_INVALIDDATA;
 417
 418     skip_bits1(&s->gb); // always 0 (reserved, cf. ETSI TS 102 114 V1.4.1)
 419     s->dynrange          = get_bits(&s->gb, 1);
 420     s->timestamp         = get_bits(&s->gb, 1);
 421     s->aux_data          = get_bits(&s->gb, 1);
 422     s->hdcd              = get_bits(&s->gb, 1);
 423     s->ext_descr         = get_bits(&s->gb, 3);
 424     s->ext_coding        = get_bits(&s->gb, 1);
 425     s->aspf              = get_bits(&s->gb, 1);
 426     s->lfe               = get_bits(&s->gb, 2);
 427     s->predictor_history = get_bits(&s->gb, 1);
 428
 429     if (s->lfe > 2) {
 430         av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
 431         return AVERROR_INVALIDDATA;
 432     }
 433
 434     /* TODO: check CRC */
 435     if (s->crc_present)
 436         s->header_crc    = get_bits(&s->gb, 16);
 437
 438     s->multirate_inter   = get_bits(&s->gb, 1);
 439     s->version           = get_bits(&s->gb, 4);
 440     s->copy_history      = get_bits(&s->gb, 2);
 441     s->source_pcm_res    = get_bits(&s->gb, 3);
 442     s->front_sum         = get_bits(&s->gb, 1);
 443     s->surround_sum      = get_bits(&s->gb, 1);
 444     s->dialog_norm       = get_bits(&s->gb, 4);
 445
 446     /* FIXME: channels mixing levels */
 447     s->output = s->amode;
 448     if (s->lfe)
 449         s->output |= DCA_LFE;
 450
 451 #ifdef TRACE
 452     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
 453     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
 454     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
 455     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
 456            s->sample_blocks, s->sample_blocks * 32);
 457     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
 458     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
 459            s->amode, dca_channels[s->amode]);
 460     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
 461            s->sample_rate);
 462     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
 463            s->bit_rate);
 464     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
 465     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
 466     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
 467     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
 468     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
 469     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
 470     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
 471     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
 472     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
 473            s->predictor_history);
 474     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
 475     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
 476            s->multirate_inter);
 477     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
 478     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
 479     av_log(s->avctx, AV_LOG_DEBUG,
 480            "source pcm resolution: %i (%i bits/sample)\n",
 481            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
 482     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
 483     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
 484     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
 485     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 486 #endif
 487
 488     /* Primary audio coding header */
 489     s->subframes = get_bits(&s->gb, 4) + 1;
 490
 491     return dca_parse_audio_coding_header(s, 0);
 492 }
 493
 494 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
 495 {
 496     if (level < 5) {
 497         /* huffman encoded */
 498         value += get_bitalloc(gb, &dca_scalefactor, level);
 499         value  = av_clip(value, 0, (1 << log2range) - 1);
 500     } else if (level < 8) {
 501         if (level + 1 > log2range) {
 502             skip_bits(gb, level + 1 - log2range);
 503             value = get_bits(gb, log2range);
 504         } else {
 505             value = get_bits(gb, level + 1);
 506         }
 507     }
 508     return value;
 509 }
 510
 511 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
 512 {
 513     /* Primary audio coding side information */
 514     int j, k;
 515
 516     if (get_bits_left(&s->gb) < 0)
 517         return AVERROR_INVALIDDATA;
 518
 519     if (!base_channel) {
 520         s->subsubframes[s->current_subframe]    = get_bits(&s->gb, 2) + 1;
 521         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
 522     }
 523
 524     for (j = base_channel; j < s->prim_channels; j++) {
 525         for (k = 0; k < s->subband_activity[j]; k++)
 526             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
 527     }
 528
 529     /* Get prediction codebook */
 530     for (j = base_channel; j < s->prim_channels; j++) {
 531         for (k = 0; k < s->subband_activity[j]; k++) {
 532             if (s->prediction_mode[j][k] > 0) {
 533                 /* (Prediction coefficient VQ address) */
 534                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
 535             }
 536         }
 537     }
 538
 539     /* Bit allocation index */
 540     for (j = base_channel; j < s->prim_channels; j++) {
 541         for (k = 0; k < s->vq_start_subband[j]; k++) {
 542             if (s->bitalloc_huffman[j] == 6)
 543                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
 544             else if (s->bitalloc_huffman[j] == 5)
 545                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
 546             else if (s->bitalloc_huffman[j] == 7) {
 547                 av_log(s->avctx, AV_LOG_ERROR,
 548                        "Invalid bit allocation index\n");
 549                 return AVERROR_INVALIDDATA;
 550             } else {
 551                 s->bitalloc[j][k] =
 552                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
 553             }
 554
 555             if (s->bitalloc[j][k] > 26) {
 556                 av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
 557                         j, k, s->bitalloc[j][k]);
 558                 return AVERROR_INVALIDDATA;
 559             }
 560         }
 561     }
 562
 563     /* Transition mode */
 564     for (j = base_channel; j < s->prim_channels; j++) {
 565         for (k = 0; k < s->subband_activity[j]; k++) {
 566             s->transition_mode[j][k] = 0;
 567             if (s->subsubframes[s->current_subframe] > 1 &&
 568                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
 569                 s->transition_mode[j][k] =
 570                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
 571             }
 572         }
 573     }
 574
 575     if (get_bits_left(&s->gb) < 0)
 576         return AVERROR_INVALIDDATA;
 577
 578     for (j = base_channel; j < s->prim_channels; j++) {
 579         const uint32_t *scale_table;
 580         int scale_sum, log_size;
 581
 582         memset(s->scale_factor[j], 0,
 583                s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
 584
 585         if (s->scalefactor_huffman[j] == 6) {
 586             scale_table = scale_factor_quant7;
 587             log_size    = 7;
 588         } else {
 589             scale_table = scale_factor_quant6;
 590             log_size    = 6;
 591         }
 592
 593         /* When huffman coded, only the difference is encoded */
 594         scale_sum = 0;
 595
 596         for (k = 0; k < s->subband_activity[j]; k++) {
 597             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
 598                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
 599                 s->scale_factor[j][k][0] = scale_table[scale_sum];
 600             }
 601
 602             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
 603                 /* Get second scale factor */
 604                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
 605                 s->scale_factor[j][k][1] = scale_table[scale_sum];
 606             }
 607         }
 608     }
 609
 610     /* Joint subband scale factor codebook select */
 611     for (j = base_channel; j < s->prim_channels; j++) {
 612         /* Transmitted only if joint subband coding enabled */
 613         if (s->joint_intensity[j] > 0)
 614             s->joint_huff[j] = get_bits(&s->gb, 3);
 615     }
 616
 617     if (get_bits_left(&s->gb) < 0)
 618         return AVERROR_INVALIDDATA;
 619
 620     /* Scale factors for joint subband coding */
 621     for (j = base_channel; j < s->prim_channels; j++) {
 622         int source_channel;
 623
 624         /* Transmitted only if joint subband coding enabled */
 625         if (s->joint_intensity[j] > 0) {
 626             int scale = 0;
 627             source_channel = s->joint_intensity[j] - 1;
 628
 629             /* When huffman coded, only the difference is encoded
 630              * (is this valid as well for joint scales ???) */
 631
 632             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
 633                 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
 634                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
 635             }
 636
 637             if (!(s->debug_flag & 0x02)) {
 638                 av_log(s->avctx, AV_LOG_DEBUG,
 639                        "Joint stereo coding not supported\n");
 640                 s->debug_flag |= 0x02;
 641             }
 642         }
 643     }
 644
 645     /* Dynamic range coefficient */
 646     if (!base_channel && s->dynrange)
 647         s->dynrange_coef = get_bits(&s->gb, 8);
 648
 649     /* Side information CRC check word */
 650     if (s->crc_present) {
 651         get_bits(&s->gb, 16);
 652     }
 653
 654     /*
 655      * Primary audio data arrays
 656      */
 657
 658     /* VQ encoded high frequency subbands */
 659     for (j = base_channel; j < s->prim_channels; j++)
 660         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 661             /* 1 vector -> 32 samples */
 662             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
 663
 664     /* Low frequency effect data */
 665     if (!base_channel && s->lfe) {
 666         /* LFE samples */
 667         int lfe_samples    = 2 * s->lfe * (4 + block_index);
 668         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
 669         float lfe_scale;
 670
 671         for (j = lfe_samples; j < lfe_end_sample; j++) {
 672             /* Signed 8 bits int */
 673             s->lfe_data[j] = get_sbits(&s->gb, 8);
 674         }
 675
 676         /* Scale factor index */
 677         skip_bits(&s->gb, 1);
 678         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 7)];
 679
 680         /* Quantization step size * scale factor */
 681         lfe_scale = 0.035 * s->lfe_scale_factor;
 682
 683         for (j = lfe_samples; j < lfe_end_sample; j++)
 684             s->lfe_data[j] *= lfe_scale;
 685     }
 686
 687 #ifdef TRACE
 688     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
 689            s->subsubframes[s->current_subframe]);
 690     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
 691            s->partial_samples[s->current_subframe]);
 692
 693     for (j = base_channel; j < s->prim_channels; j++) {
 694         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
 695         for (k = 0; k < s->subband_activity[j]; k++)
 696             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
 697         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 698     }
 699     for (j = base_channel; j < s->prim_channels; j++) {
 700         for (k = 0; k < s->subband_activity[j]; k++)
 701             av_log(s->avctx, AV_LOG_DEBUG,
 702                    "prediction coefs: %f, %f, %f, %f\n",
 703                    (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
 704                    (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
 705                    (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
 706                    (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
 707     }
 708     for (j = base_channel; j < s->prim_channels; j++) {
 709         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
 710         for (k = 0; k < s->vq_start_subband[j]; k++)
 711             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
 712         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 713     }
 714     for (j = base_channel; j < s->prim_channels; j++) {
 715         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
 716         for (k = 0; k < s->subband_activity[j]; k++)
 717             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
 718         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 719     }
 720     for (j = base_channel; j < s->prim_channels; j++) {
 721         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
 722         for (k = 0; k < s->subband_activity[j]; k++) {
 723             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
 724                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
 725             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
 726                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
 727         }
 728         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 729     }
 730     for (j = base_channel; j < s->prim_channels; j++) {
 731         if (s->joint_intensity[j] > 0) {
 732             int source_channel = s->joint_intensity[j] - 1;
 733             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
 734             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
 735                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
 736             av_log(s->avctx, AV_LOG_DEBUG, "\n");
 737         }
 738     }
 739     for (j = base_channel; j < s->prim_channels; j++)
 740         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 741             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
 742     if (!base_channel && s->lfe) {
 743         int lfe_samples    = 2 * s->lfe * (4 + block_index);
 744         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
 745
 746         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
 747         for (j = lfe_samples; j < lfe_end_sample; j++)
 748             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
 749         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 750     }
 751 #endif
 752
 753     return 0;
 754 }
 755
 756 static void qmf_32_subbands(DCAContext *s, int chans,
 757                             float samples_in[32][8], float *samples_out,
 758                             float scale)
 759 {
 760     const float *prCoeff;
 761
 762     int sb_act = s->subband_activity[chans];
 763
 764     scale *= sqrt(1 / 8.0);
 765
 766     /* Select filter */
 767     if (!s->multirate_inter)    /* Non-perfect reconstruction */
 768         prCoeff = fir_32bands_nonperfect;
 769     else                        /* Perfect reconstruction */
 770         prCoeff = fir_32bands_perfect;
 771
 772     s->dcadsp.qmf_32_subbands(samples_in, sb_act, &s->synth, &s->imdct,
 773                               s->subband_fir_hist[chans],
 774                               &s->hist_index[chans],
 775                               s->subband_fir_noidea[chans], prCoeff,
 776                               samples_out, s->raXin, scale);
 777 }
 778
 779 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
 780                                   int num_deci_sample, float *samples_in,
 781                                   float *samples_out)
 782 {
 783     /* samples_in: An array holding decimated samples.
 784      *   Samples in current subframe starts from samples_in[0],
 785      *   while samples_in[-1], samples_in[-2], ..., stores samples
 786      *   from last subframe as history.
 787      *
 788      * samples_out: An array holding interpolated samples
 789      */
 790
 791     int idx;
 792     const float *prCoeff;
 793     int deciindex;
 794
 795     /* Select decimation filter */
 796     if (decimation_select == 1) {
 797         idx     = 1;
 798         prCoeff = lfe_fir_128;
 799     } else {
 800         idx     = 0;
 801         prCoeff = lfe_fir_64;
 802     }
 803     /* Interpolation */
 804     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
 805         s->dcadsp.lfe_fir[idx](samples_out, samples_in, prCoeff);
 806         samples_in++;
 807         samples_out += 2 * 32 * (1 + idx);
 808     }
 809 }
 810
 811 /* downmixing routines */
 812 #define MIX_REAR1(samples, s1, rs, coef)            \
 813     samples[0][i] += samples[s1][i] * coef[rs][0];  \
 814     samples[1][i] += samples[s1][i] * coef[rs][1];
 815
 816 #define MIX_REAR2(samples, s1, s2, rs, coef)                                          \
 817     samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
 818     samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
 819
 820 #define MIX_FRONT3(samples, coef)                                      \
 821     t = samples[c][i];                                                 \
 822     u = samples[l][i];                                                 \
 823     v = samples[r][i];                                                 \
 824     samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0];  \
 825     samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
 826
 827 #define DOWNMIX_TO_STEREO(op1, op2)             \
 828     for (i = 0; i < 256; i++) {                 \
 829         op1                                     \
 830         op2                                     \
 831     }
 832
 833 static void dca_downmix(float **samples, int srcfmt, int lfe_present,
 834                         float coef[DCA_PRIM_CHANNELS_MAX + 1][2],
 835                         const int8_t *channel_mapping)
 836 {
 837     int c, l, r, sl, sr, s;
 838     int i;
 839     float t, u, v;
 840
 841     switch (srcfmt) {
 842     case DCA_MONO:
 843     case DCA_4F2R:
 844         av_log(NULL, 0, "Not implemented!\n");
 845         break;
 846     case DCA_CHANNEL:
 847     case DCA_STEREO:
 848     case DCA_STEREO_TOTAL:
 849     case DCA_STEREO_SUMDIFF:
 850         break;
 851     case DCA_3F:
 852         c = channel_mapping[0];
 853         l = channel_mapping[1];
 854         r = channel_mapping[2];
 855         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
 856         break;
 857     case DCA_2F1R:
 858         s = channel_mapping[2];
 859         DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
 860         break;
 861     case DCA_3F1R:
 862         c = channel_mapping[0];
 863         l = channel_mapping[1];
 864         r = channel_mapping[2];
 865         s = channel_mapping[3];
 866         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
 867                           MIX_REAR1(samples, s, 3, coef));
 868         break;
 869     case DCA_2F2R:
 870         sl = channel_mapping[2];
 871         sr = channel_mapping[3];
 872         DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
 873         break;
 874     case DCA_3F2R:
 875         c  = channel_mapping[0];
 876         l  = channel_mapping[1];
 877         r  = channel_mapping[2];
 878         sl = channel_mapping[3];
 879         sr = channel_mapping[4];
 880         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
 881                           MIX_REAR2(samples, sl, sr, 3, coef));
 882         break;
 883     }
 884     if (lfe_present) {
 885         int lf_buf = dca_lfe_index[srcfmt];
 886         int lf_idx =  dca_channels[srcfmt];
 887         for (i = 0; i < 256; i++) {
 888             samples[0][i] += samples[lf_buf][i] * coef[lf_idx][0];
 889             samples[1][i] += samples[lf_buf][i] * coef[lf_idx][1];
 890         }
 891     }
 892 }
 893
 894 #ifndef decode_blockcodes
 895 /* Very compact version of the block code decoder that does not use table
 896  * look-up but is slightly slower */
 897 static int decode_blockcode(int code, int levels, int32_t *values)
 898 {
 899     int i;
 900     int offset = (levels - 1) >> 1;
 901
 902     for (i = 0; i < 4; i++) {
 903         int div = FASTDIV(code, levels);
 904         values[i] = code - offset - div * levels;
 905         code      = div;
 906     }
 907
 908     return code;
 909 }
 910
 911 static int decode_blockcodes(int code1, int code2, int levels, int32_t *values)
 912 {
 913     return decode_blockcode(code1, levels, values) |
 914            decode_blockcode(code2, levels, values + 4);
 915 }
 916 #endif
 917
 918 static const uint8_t abits_sizes[7]  = { 7, 10, 12, 13, 15, 17, 19 };
 919 static const uint8_t abits_levels[7] = { 3,  5,  7,  9, 13, 17, 25 };
 920
 921 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
 922 {
 923     int k, l;
 924     int subsubframe = s->current_subsubframe;
 925
 926     const float *quant_step_table;
 927
 928     /* FIXME */
 929     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
 930     LOCAL_ALIGNED_16(int32_t, block, [8 * DCA_SUBBANDS]);
 931
 932     /*
 933      * Audio data
 934      */
 935
 936     /* Select quantization step size table */
 937     if (s->bit_rate_index == 0x1f)
 938         quant_step_table = lossless_quant_d;
 939     else
 940         quant_step_table = lossy_quant_d;
 941
 942     for (k = base_channel; k < s->prim_channels; k++) {
 943         float rscale[DCA_SUBBANDS];
 944
 945         if (get_bits_left(&s->gb) < 0)
 946             return AVERROR_INVALIDDATA;
 947
 948         for (l = 0; l < s->vq_start_subband[k]; l++) {
 949             int m;
 950
 951             /* Select the mid-tread linear quantizer */
 952             int abits = s->bitalloc[k][l];
 953
 954             float quant_step_size = quant_step_table[abits];
 955
 956             /*
 957              * Determine quantization index code book and its type
 958              */
 959
 960             /* Select quantization index code book */
 961             int sel = s->quant_index_huffman[k][abits];
 962
 963             /*
 964              * Extract bits from the bit stream
 965              */
 966             if (!abits) {
 967                 rscale[l] = 0;
 968                 memset(block + 8 * l, 0, 8 * sizeof(block[0]));
 969             } else {
 970                 /* Deal with transients */
 971                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
 972                 rscale[l] = quant_step_size * s->scale_factor[k][l][sfi] *
 973                             s->scalefactor_adj[k][sel];
 974
 975                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
 976                     if (abits <= 7) {
 977                         /* Block code */
 978                         int block_code1, block_code2, size, levels, err;
 979
 980                         size   = abits_sizes[abits - 1];
 981                         levels = abits_levels[abits - 1];
 982
 983                         block_code1 = get_bits(&s->gb, size);
 984                         block_code2 = get_bits(&s->gb, size);
 985                         err         = decode_blockcodes(block_code1, block_code2,
 986                                                         levels, block + 8 * l);
 987                         if (err) {
 988                             av_log(s->avctx, AV_LOG_ERROR,
 989                                    "ERROR: block code look-up failed\n");
 990                             return AVERROR_INVALIDDATA;
 991                         }
 992                     } else {
 993                         /* no coding */
 994                         for (m = 0; m < 8; m++)
 995                             block[8 * l + m] = get_sbits(&s->gb, abits - 3);
 996                     }
 997                 } else {
 998                     /* Huffman coded */
 999                     for (m = 0; m < 8; m++)
1000                         block[8 * l + m] = get_bitalloc(&s->gb,
1001                                                         &dca_smpl_bitalloc[abits], sel);
1002                 }
1003             }
1004         }
1005
1006         s->fmt_conv.int32_to_float_fmul_array8(&s->fmt_conv, subband_samples[k][0],
1007                                                block, rscale, 8 * s->vq_start_subband[k]);
1008
1009         for (l = 0; l < s->vq_start_subband[k]; l++) {
1010             int m;
1011             /*
1012              * Inverse ADPCM if in prediction mode
1013              */
1014             if (s->prediction_mode[k][l]) {
1015                 int n;
1016                 if (s->predictor_history)
1017                     subband_samples[k][l][0] += (adpcm_vb[s->prediction_vq[k][l]][0] *
1018                                                  s->subband_samples_hist[k][l][3] +
1019                                                  adpcm_vb[s->prediction_vq[k][l]][1] *
1020                                                  s->subband_samples_hist[k][l][2] +
1021                                                  adpcm_vb[s->prediction_vq[k][l]][2] *
1022                                                  s->subband_samples_hist[k][l][1] +
1023                                                  adpcm_vb[s->prediction_vq[k][l]][3] *
1024                                                  s->subband_samples_hist[k][l][0]) *
1025                                                 (1.0f / 8192);
1026                 for (m = 1; m < 8; m++) {
1027                     float sum = adpcm_vb[s->prediction_vq[k][l]][0] *
1028                                 subband_samples[k][l][m - 1];
1029                     for (n = 2; n <= 4; n++)
1030                         if (m >= n)
1031                             sum += adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1032                                    subband_samples[k][l][m - n];
1033                         else if (s->predictor_history)
1034                             sum += adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1035                                    s->subband_samples_hist[k][l][m - n + 4];
1036                     subband_samples[k][l][m] += sum * 1.0f / 8192;
1037                 }
1038             }
1039         }
1040
1041         /*
1042          * Decode VQ encoded high frequencies
1043          */
1044         if (s->subband_activity[k] > s->vq_start_subband[k]) {
1045             if (!s->debug_flag & 0x01) {
1046                 av_log(s->avctx, AV_LOG_DEBUG,
1047                        "Stream with high frequencies VQ coding\n");
1048                 s->debug_flag |= 0x01;
1049             }
1050             s->dcadsp.decode_hf(subband_samples[k], s->high_freq_vq[k],
1051                                 high_freq_vq, subsubframe * 8,
1052                                 s->scale_factor[k], s->vq_start_subband[k],
1053                                 s->subband_activity[k]);
1054         }
1055     }
1056
1057     /* Check for DSYNC after subsubframe */
1058     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1059         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1060 #ifdef TRACE
1061             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1062 #endif
1063         } else {
1064             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1065             return AVERROR_INVALIDDATA;
1066         }
1067     }
1068
1069     /* Backup predictor history for adpcm */
1070     for (k = base_channel; k < s->prim_channels; k++)
1071         for (l = 0; l < s->vq_start_subband[k]; l++)
1072             AV_COPY128(s->subband_samples_hist[k][l], &subband_samples[k][l][4]);
1073
1074     return 0;
1075 }
1076
1077 static int dca_filter_channels(DCAContext *s, int block_index)
1078 {
1079     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1080     int k;
1081
1082     /* 32 subbands QMF */
1083     for (k = 0; k < s->prim_channels; k++) {
1084         if (s->channel_order_tab[k] >= 0)
1085             qmf_32_subbands(s, k, subband_samples[k],
1086                             s->samples_chanptr[s->channel_order_tab[k]],
1087                             M_SQRT1_2 / 32768.0);
1088     }
1089
1090     /* Generate LFE samples for this subsubframe FIXME!!! */
1091     if (s->lfe) {
1092         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1093                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1094                               s->samples_chanptr[dca_lfe_index[s->amode]]);
1095         /* Outputs 20bits pcm samples */
1096     }
1097
1098     /* Downmixing to Stereo */
1099     if (s->prim_channels + !!s->lfe > 2 &&
1100         s->avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1101         dca_downmix(s->samples_chanptr, s->amode, !!s->lfe, s->downmix_coef,
1102                     s->channel_order_tab);
1103     }
1104
1105     return 0;
1106 }
1107
1108 static int dca_subframe_footer(DCAContext *s, int base_channel)
1109 {
1110     int in, out, aux_data_count, aux_data_end, reserved;
1111     uint32_t nsyncaux;
1112
1113     /*
1114      * Unpack optional information
1115      */
1116
1117     /* presumably optional information only appears in the core? */
1118     if (!base_channel) {
1119         if (s->timestamp)
1120             skip_bits_long(&s->gb, 32);
1121
1122         if (s->aux_data) {
1123             aux_data_count = get_bits(&s->gb, 6);
1124
1125             // align (32-bit)
1126             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1127
1128             aux_data_end = 8 * aux_data_count + get_bits_count(&s->gb);
1129
1130             if ((nsyncaux = get_bits_long(&s->gb, 32)) != DCA_NSYNCAUX) {
1131                 av_log(s->avctx, AV_LOG_ERROR, "nSYNCAUX mismatch %#"PRIx32"\n",
1132                        nsyncaux);
1133                 return AVERROR_INVALIDDATA;
1134             }
1135
1136             if (get_bits1(&s->gb)) { // bAUXTimeStampFlag
1137                 avpriv_request_sample(s->avctx,
1138                                       "Auxiliary Decode Time Stamp Flag");
1139                 // align (4-bit)
1140                 skip_bits(&s->gb, (-get_bits_count(&s->gb)) & 4);
1141                 // 44 bits: nMSByte (8), nMarker (4), nLSByte (28), nMarker (4)
1142                 skip_bits_long(&s->gb, 44);
1143             }
1144
1145             if ((s->core_downmix = get_bits1(&s->gb))) {
1146                 int am = get_bits(&s->gb, 3);
1147                 switch (am) {
1148                 case 0:
1149                     s->core_downmix_amode = DCA_MONO;
1150                     break;
1151                 case 1:
1152                     s->core_downmix_amode = DCA_STEREO;
1153                     break;
1154                 case 2:
1155                     s->core_downmix_amode = DCA_STEREO_TOTAL;
1156                     break;
1157                 case 3:
1158                     s->core_downmix_amode = DCA_3F;
1159                     break;
1160                 case 4:
1161                     s->core_downmix_amode = DCA_2F1R;
1162                     break;
1163                 case 5:
1164                     s->core_downmix_amode = DCA_2F2R;
1165                     break;
1166                 case 6:
1167                     s->core_downmix_amode = DCA_3F1R;
1168                     break;
1169                 default:
1170                     av_log(s->avctx, AV_LOG_ERROR,
1171                            "Invalid mode %d for embedded downmix coefficients\n",
1172                            am);
1173                     return AVERROR_INVALIDDATA;
1174                 }
1175                 for (out = 0; out < dca_channels[s->core_downmix_amode]; out++) {
1176                     for (in = 0; in < s->prim_channels + !!s->lfe; in++) {
1177                         uint16_t tmp = get_bits(&s->gb, 9);
1178                         if ((tmp & 0xFF) > 241) {
1179                             av_log(s->avctx, AV_LOG_ERROR,
1180                                    "Invalid downmix coefficient code %"PRIu16"\n",
1181                                    tmp);
1182                             return AVERROR_INVALIDDATA;
1183                         }
1184                         s->core_downmix_codes[in][out] = tmp;
1185                     }
1186                 }
1187             }
1188
1189             align_get_bits(&s->gb); // byte align
1190             skip_bits(&s->gb, 16);  // nAUXCRC16
1191
1192             // additional data (reserved, cf. ETSI TS 102 114 V1.4.1)
1193             if ((reserved = (aux_data_end - get_bits_count(&s->gb))) < 0) {
1194                 av_log(s->avctx, AV_LOG_ERROR,
1195                        "Overread auxiliary data by %d bits\n", -reserved);
1196                 return AVERROR_INVALIDDATA;
1197             } else if (reserved) {
1198                 avpriv_request_sample(s->avctx,
1199                                       "Core auxiliary data reserved content");
1200                 skip_bits_long(&s->gb, reserved);
1201             }
1202         }
1203
1204         if (s->crc_present && s->dynrange)
1205             get_bits(&s->gb, 16);
1206     }
1207
1208     return 0;
1209 }
1210
1211 /**
1212  * Decode a dca frame block
1213  *
1214  * @param s     pointer to the DCAContext
1215  */
1216
1217 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1218 {
1219     int ret;
1220
1221     /* Sanity check */
1222     if (s->current_subframe >= s->subframes) {
1223         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1224                s->current_subframe, s->subframes);
1225         return AVERROR_INVALIDDATA;
1226     }
1227
1228     if (!s->current_subsubframe) {
1229 #ifdef TRACE
1230         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1231 #endif
1232         /* Read subframe header */
1233         if ((ret = dca_subframe_header(s, base_channel, block_index)))
1234             return ret;
1235     }
1236
1237     /* Read subsubframe */
1238 #ifdef TRACE
1239     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1240 #endif
1241     if ((ret = dca_subsubframe(s, base_channel, block_index)))
1242         return ret;
1243
1244     /* Update state */
1245     s->current_subsubframe++;
1246     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1247         s->current_subsubframe = 0;
1248         s->current_subframe++;
1249     }
1250     if (s->current_subframe >= s->subframes) {
1251 #ifdef TRACE
1252         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1253 #endif
1254         /* Read subframe footer */
1255         if ((ret = dca_subframe_footer(s, base_channel)))
1256             return ret;
1257     }
1258
1259     return 0;
1260 }
1261
1262 static float dca_dmix_code(unsigned code)
1263 {
1264     int sign = (code >> 8) - 1;
1265     code &= 0xff;
1266     return ((dca_dmixtable[code] ^ sign) - sign) * (1.0 / (1U << 15));
1267 }
1268
1269 /**
1270  * Main frame decoding function
1271  * FIXME add arguments
1272  */
1273 static int dca_decode_frame(AVCodecContext *avctx, void *data,
1274                             int *got_frame_ptr, AVPacket *avpkt)
1275 {
1276     AVFrame *frame     = data;
1277     const uint8_t *buf = avpkt->data;
1278     int buf_size       = avpkt->size;
1279
1280     int lfe_samples;
1281     int num_core_channels = 0;
1282     int i, ret;
1283     float  **samples_flt;
1284     DCAContext *s = avctx->priv_data;
1285     int channels, full_channels;
1286     int core_ss_end;
1287
1288     s->xch_present = 0;
1289
1290     s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1291                                                   DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1292     if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
1293         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1294         return AVERROR_INVALIDDATA;
1295     }
1296
1297     if ((ret = dca_parse_frame_header(s)) < 0) {
1298         // seems like the frame is corrupt, try with the next one
1299         return ret;
1300     }
1301     // set AVCodec values with parsed data
1302     avctx->sample_rate = s->sample_rate;
1303     avctx->bit_rate    = s->bit_rate;
1304
1305     s->profile = FF_PROFILE_DTS;
1306
1307     for (i = 0; i < (s->sample_blocks / 8); i++) {
1308         if ((ret = dca_decode_block(s, 0, i))) {
1309             av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
1310             return ret;
1311         }
1312     }
1313
1314     /* record number of core channels incase less than max channels are requested */
1315     num_core_channels = s->prim_channels;
1316
1317     if (s->ext_coding)
1318         s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
1319     else
1320         s->core_ext_mask = 0;
1321
1322     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1323
1324     /* only scan for extensions if ext_descr was unknown or indicated a
1325      * supported XCh extension */
1326     if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
1327         /* if ext_descr was unknown, clear s->core_ext_mask so that the
1328          * extensions scan can fill it up */
1329         s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
1330
1331         /* extensions start at 32-bit boundaries into bitstream */
1332         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1333
1334         while (core_ss_end - get_bits_count(&s->gb) >= 32) {
1335             uint32_t bits = get_bits_long(&s->gb, 32);
1336
1337             switch (bits) {
1338             case 0x5a5a5a5a: {
1339                 int ext_amode, xch_fsize;
1340
1341                 s->xch_base_channel = s->prim_channels;
1342
1343                 /* validate sync word using XCHFSIZE field */
1344                 xch_fsize = show_bits(&s->gb, 10);
1345                 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1346                     (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1347                     continue;
1348
1349                 /* skip length-to-end-of-frame field for the moment */
1350                 skip_bits(&s->gb, 10);
1351
1352                 s->core_ext_mask |= DCA_EXT_XCH;
1353
1354                 /* extension amode(number of channels in extension) should be 1 */
1355                 /* AFAIK XCh is not used for more channels */
1356                 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1357                     av_log(avctx, AV_LOG_ERROR,
1358                            "XCh extension amode %d not supported!\n",
1359                            ext_amode);
1360                     continue;
1361                 }
1362
1363                 /* much like core primary audio coding header */
1364                 dca_parse_audio_coding_header(s, s->xch_base_channel);
1365
1366                 for (i = 0; i < (s->sample_blocks / 8); i++)
1367                     if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
1368                         av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
1369                         continue;
1370                     }
1371
1372                 s->xch_present = 1;
1373                 break;
1374             }
1375             case 0x47004a03:
1376                 /* XXCh: extended channels */
1377                 /* usually found either in core or HD part in DTS-HD HRA streams,
1378                  * but not in DTS-ES which contains XCh extensions instead */
1379                 s->core_ext_mask |= DCA_EXT_XXCH;
1380                 break;
1381
1382             case 0x1d95f262: {
1383                 int fsize96 = show_bits(&s->gb, 12) + 1;
1384                 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1385                     continue;
1386
1387                 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
1388                        get_bits_count(&s->gb));
1389                 skip_bits(&s->gb, 12);
1390                 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1391                 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1392
1393                 s->core_ext_mask |= DCA_EXT_X96;
1394                 break;
1395             }
1396             }
1397
1398             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1399         }
1400     } else {
1401         /* no supported extensions, skip the rest of the core substream */
1402         skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
1403     }
1404
1405     if (s->core_ext_mask & DCA_EXT_X96)
1406         s->profile = FF_PROFILE_DTS_96_24;
1407     else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
1408         s->profile = FF_PROFILE_DTS_ES;
1409
1410     /* check for ExSS (HD part) */
1411     if (s->dca_buffer_size - s->frame_size > 32 &&
1412         get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1413         ff_dca_exss_parse_header(s);
1414
1415     avctx->profile = s->profile;
1416
1417     full_channels = channels = s->prim_channels + !!s->lfe;
1418
1419     if (s->amode < 16) {
1420         avctx->channel_layout = dca_core_channel_layout[s->amode];
1421
1422         if (s->prim_channels + !!s->lfe > 2 &&
1423             avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1424             /*
1425              * Neither the core's auxiliary data nor our default tables contain
1426              * downmix coefficients for the additional channel coded in the XCh
1427              * extension, so when we're doing a Stereo downmix, don't decode it.
1428              */
1429             s->xch_disable = 1;
1430         }
1431
1432 #if FF_API_REQUEST_CHANNELS
1433 FF_DISABLE_DEPRECATION_WARNINGS
1434         if (s->xch_present && !s->xch_disable &&
1435             (!avctx->request_channels ||
1436              avctx->request_channels > num_core_channels + !!s->lfe)) {
1437 FF_ENABLE_DEPRECATION_WARNINGS
1438 #else
1439         if (s->xch_present && !s->xch_disable) {
1440 #endif
1441             avctx->channel_layout |= AV_CH_BACK_CENTER;
1442             if (s->lfe) {
1443                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1444                 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1445             } else {
1446                 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1447             }
1448         } else {
1449             channels       = num_core_channels + !!s->lfe;
1450             s->xch_present = 0; /* disable further xch processing */
1451             if (s->lfe) {
1452                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1453                 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1454             } else
1455                 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1456         }
1457
1458         if (channels > !!s->lfe &&
1459             s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1460             return AVERROR_INVALIDDATA;
1461
1462         if (num_core_channels + !!s->lfe > 2 &&
1463             avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1464             channels              = 2;
1465             s->output             = s->prim_channels == 2 ? s->amode : DCA_STEREO;
1466             avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1467
1468             /* Stereo downmix coefficients
1469              *
1470              * The decoder can only downmix to 2-channel, so we need to ensure
1471              * embedded downmix coefficients are actually targeting 2-channel.
1472              */
1473             if (s->core_downmix && (s->core_downmix_amode == DCA_STEREO ||
1474                                     s->core_downmix_amode == DCA_STEREO_TOTAL)) {
1475                 for (i = 0; i < num_core_channels + !!s->lfe; i++) {
1476                     /* Range checked earlier */
1477                     s->downmix_coef[i][0] = dca_dmix_code(s->core_downmix_codes[i][0]);
1478                     s->downmix_coef[i][1] = dca_dmix_code(s->core_downmix_codes[i][1]);
1479                 }
1480                 s->output = s->core_downmix_amode;
1481             } else {
1482                 int am = s->amode & DCA_CHANNEL_MASK;
1483                 if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
1484                     av_log(s->avctx, AV_LOG_ERROR,
1485                            "Invalid channel mode %d\n", am);
1486                     return AVERROR_INVALIDDATA;
1487                 }
1488                 if (num_core_channels + !!s->lfe >
1489                     FF_ARRAY_ELEMS(dca_default_coeffs[0])) {
1490                     avpriv_request_sample(s->avctx, "Downmixing %d channels",
1491                                           s->prim_channels + !!s->lfe);
1492                     return AVERROR_PATCHWELCOME;
1493                 }
1494                 for (i = 0; i < num_core_channels + !!s->lfe; i++) {
1495                     s->downmix_coef[i][0] = dca_default_coeffs[am][i][0];
1496                     s->downmix_coef[i][1] = dca_default_coeffs[am][i][1];
1497                 }
1498             }
1499             av_dlog(s->avctx, "Stereo downmix coeffs:\n");
1500             for (i = 0; i < num_core_channels + !!s->lfe; i++) {
1501                 av_dlog(s->avctx, "L, input channel %d = %f\n", i,
1502                         s->downmix_coef[i][0]);
1503                 av_dlog(s->avctx, "R, input channel %d = %f\n", i,
1504                         s->downmix_coef[i][1]);
1505             }
1506             av_dlog(s->avctx, "\n");
1507         }
1508     } else {
1509         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
1510         return AVERROR_INVALIDDATA;
1511     }
1512     avctx->channels = channels;
1513
1514     /* get output buffer */
1515     frame->nb_samples = 256 * (s->sample_blocks / 8);
1516     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1517         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1518         return ret;
1519     }
1520     samples_flt = (float **) frame->extended_data;
1521
1522     /* allocate buffer for extra channels if downmixing */
1523     if (avctx->channels < full_channels) {
1524         ret = av_samples_get_buffer_size(NULL, full_channels - channels,
1525                                          frame->nb_samples,
1526                                          avctx->sample_fmt, 0);
1527         if (ret < 0)
1528             return ret;
1529
1530         av_fast_malloc(&s->extra_channels_buffer,
1531                        &s->extra_channels_buffer_size, ret);
1532         if (!s->extra_channels_buffer)
1533             return AVERROR(ENOMEM);
1534
1535         ret = av_samples_fill_arrays((uint8_t **) s->extra_channels, NULL,
1536                                      s->extra_channels_buffer,
1537                                      full_channels - channels,
1538                                      frame->nb_samples, avctx->sample_fmt, 0);
1539         if (ret < 0)
1540             return ret;
1541     }
1542
1543     /* filter to get final output */
1544     for (i = 0; i < (s->sample_blocks / 8); i++) {
1545         int ch;
1546
1547         for (ch = 0; ch < channels; ch++)
1548             s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
1549         for (; ch < full_channels; ch++)
1550             s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
1551
1552         dca_filter_channels(s, i);
1553
1554         /* If this was marked as a DTS-ES stream we need to subtract back- */
1555         /* channel from SL & SR to remove matrixed back-channel signal */
1556         if ((s->source_pcm_res & 1) && s->xch_present) {
1557             float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];
1558             float *lt_chan   = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];
1559             float *rt_chan   = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];
1560             s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
1561             s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
1562         }
1563     }
1564
1565     /* update lfe history */
1566     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1567     for (i = 0; i < 2 * s->lfe * 4; i++)
1568         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1569
1570     /* AVMatrixEncoding
1571      *
1572      * DCA_STEREO_TOTAL (Lt/Rt) is equivalent to Dolby Surround */
1573     ret = ff_side_data_update_matrix_encoding(frame,
1574                                               (s->output & ~DCA_LFE) == DCA_STEREO_TOTAL ?
1575                                               AV_MATRIX_ENCODING_DOLBY : AV_MATRIX_ENCODING_NONE);
1576     if (ret < 0)
1577         return ret;
1578
1579     *got_frame_ptr = 1;
1580
1581     return buf_size;
1582 }
1583
1584 /**
1585  * DCA initialization
1586  *
1587  * @param avctx     pointer to the AVCodecContext
1588  */
1589
1590 static av_cold int dca_decode_init(AVCodecContext *avctx)
1591 {
1592     DCAContext *s = avctx->priv_data;
1593
1594     s->avctx = avctx;
1595     dca_init_vlcs();
1596
1597     avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
1598     ff_mdct_init(&s->imdct, 6, 1, 1.0);
1599     ff_synth_filter_init(&s->synth);
1600     ff_dcadsp_init(&s->dcadsp);
1601     ff_fmt_convert_init(&s->fmt_conv, avctx);
1602
1603     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1604
1605     /* allow downmixing to stereo */
1606 #if FF_API_REQUEST_CHANNELS
1607 FF_DISABLE_DEPRECATION_WARNINGS
1608     if (avctx->request_channels == 2)
1609         avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
1610 FF_ENABLE_DEPRECATION_WARNINGS
1611 #endif
1612     if (avctx->channels > 2 &&
1613         avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
1614         avctx->channels = 2;
1615
1616     return 0;
1617 }
1618
1619 static av_cold int dca_decode_end(AVCodecContext *avctx)
1620 {
1621     DCAContext *s = avctx->priv_data;
1622     ff_mdct_end(&s->imdct);
1623     av_freep(&s->extra_channels_buffer);
1624     return 0;
1625 }
1626
1627 static const AVProfile profiles[] = {
1628     { FF_PROFILE_DTS,        "DTS"        },
1629     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
1630     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
1631     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1632     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
1633     { FF_PROFILE_UNKNOWN },
1634 };
1635
1636 static const AVOption options[] = {
1637     { "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 },
1638     { NULL },
1639 };
1640
1641 static const AVClass dca_decoder_class = {
1642     .class_name = "DCA decoder",
1643     .item_name  = av_default_item_name,
1644     .option     = options,
1645     .version    = LIBAVUTIL_VERSION_INT,
1646 };
1647
1648 AVCodec ff_dca_decoder = {
1649     .name            = "dca",
1650     .long_name       = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1651     .type            = AVMEDIA_TYPE_AUDIO,
1652     .id              = AV_CODEC_ID_DTS,
1653     .priv_data_size  = sizeof(DCAContext),
1654     .init            = dca_decode_init,
1655     .decode          = dca_decode_frame,
1656     .close           = dca_decode_end,
1657     .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
1658     .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1659                                                        AV_SAMPLE_FMT_NONE },
1660     .profiles        = NULL_IF_CONFIG_SMALL(profiles),
1661     .priv_class      = &dca_decoder_class,
1662 };