git.sesse.net Git - ffmpeg/blob - libavcodec/dca.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/common.h"
  30 #include "libavutil/intmath.h"
  31 #include "libavutil/intreadwrite.h"
  32 #include "libavcore/audioconvert.h"
  33 #include "avcodec.h"
  34 #include "dsputil.h"
  35 #include "fft.h"
  36 #include "get_bits.h"
  37 #include "put_bits.h"
  38 #include "dcadata.h"
  39 #include "dcahuff.h"
  40 #include "dca.h"
  41 #include "synth_filter.h"
  42 #include "dcadsp.h"
  43
  44 //#define TRACE
  45
  46 #define DCA_PRIM_CHANNELS_MAX (7)
  47 #define DCA_SUBBANDS (32)
  48 #define DCA_ABITS_MAX (32)      /* Should be 28 */
  49 #define DCA_SUBSUBFRAMES_MAX (4)
  50 #define DCA_SUBFRAMES_MAX (16)
  51 #define DCA_BLOCKS_MAX (16)
  52 #define DCA_LFE_MAX (3)
  53
  54 enum DCAMode {
  55     DCA_MONO = 0,
  56     DCA_CHANNEL,
  57     DCA_STEREO,
  58     DCA_STEREO_SUMDIFF,
  59     DCA_STEREO_TOTAL,
  60     DCA_3F,
  61     DCA_2F1R,
  62     DCA_3F1R,
  63     DCA_2F2R,
  64     DCA_3F2R,
  65     DCA_4F2R
  66 };
  67
  68 /* these are unconfirmed but should be mostly correct */
  69 enum DCAExSSSpeakerMask {
  70     DCA_EXSS_FRONT_CENTER          = 0x0001,
  71     DCA_EXSS_FRONT_LEFT_RIGHT      = 0x0002,
  72     DCA_EXSS_SIDE_REAR_LEFT_RIGHT  = 0x0004,
  73     DCA_EXSS_LFE                   = 0x0008,
  74     DCA_EXSS_REAR_CENTER           = 0x0010,
  75     DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
  76     DCA_EXSS_REAR_LEFT_RIGHT       = 0x0040,
  77     DCA_EXSS_FRONT_HIGH_CENTER     = 0x0080,
  78     DCA_EXSS_OVERHEAD              = 0x0100,
  79     DCA_EXSS_CENTER_LEFT_RIGHT     = 0x0200,
  80     DCA_EXSS_WIDE_LEFT_RIGHT       = 0x0400,
  81     DCA_EXSS_SIDE_LEFT_RIGHT       = 0x0800,
  82     DCA_EXSS_LFE2                  = 0x1000,
  83     DCA_EXSS_SIDE_HIGH_LEFT_RIGHT  = 0x2000,
  84     DCA_EXSS_REAR_HIGH_CENTER      = 0x4000,
  85     DCA_EXSS_REAR_HIGH_LEFT_RIGHT  = 0x8000,
  86 };
  87
  88 enum DCAExtensionMask {
  89     DCA_EXT_CORE       = 0x001, ///< core in core substream
  90     DCA_EXT_XXCH       = 0x002, ///< XXCh channels extension in core substream
  91     DCA_EXT_X96        = 0x004, ///< 96/24 extension in core substream
  92     DCA_EXT_XCH        = 0x008, ///< XCh channel extension in core substream
  93     DCA_EXT_EXSS_CORE  = 0x010, ///< core in ExSS (extension substream)
  94     DCA_EXT_EXSS_XBR   = 0x020, ///< extended bitrate extension in ExSS
  95     DCA_EXT_EXSS_XXCH  = 0x040, ///< XXCh channels extension in ExSS
  96     DCA_EXT_EXSS_X96   = 0x080, ///< 96/24 extension in ExSS
  97     DCA_EXT_EXSS_LBR   = 0x100, ///< low bitrate component in ExSS
  98     DCA_EXT_EXSS_XLL   = 0x200, ///< lossless extension in ExSS
  99 };
 100
 101 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
 102  * Some compromises have been made for special configurations. Most configurations
 103  * are never used so complete accuracy is not needed.
 104  *
 105  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
 106  * S  -> side, when both rear and back are configured move one of them to the side channel
 107  * OV -> center back
 108  * All 2 channel configurations -> CH_LAYOUT_STEREO
 109  */
 110
 111 static const int64_t dca_core_channel_layout[] = {
 112     AV_CH_FRONT_CENTER,                                                      ///< 1, A
 113     AV_CH_LAYOUT_STEREO,                                                     ///< 2, A + B (dual mono)
 114     AV_CH_LAYOUT_STEREO,                                                     ///< 2, L + R (stereo)
 115     AV_CH_LAYOUT_STEREO,                                                     ///< 2, (L+R) + (L-R) (sum-difference)
 116     AV_CH_LAYOUT_STEREO,                                                     ///< 2, LT +RT (left and right total)
 117     AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER,                                  ///< 3, C+L+R
 118     AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER,                                   ///< 3, L+R+S
 119     AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|CH_BACK_CENTER,                   ///< 4, C + L + R+ S
 120     AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT,                    ///< 4, L + R +SL+ SR
 121     AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
 122     AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER,                    ///< 6, CL + CR + L + R + SL + SR
 123     AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT|AV_CH_FRONT_CENTER|AV_CH_BACK_CENTER,                                      ///< 6, C + L + R+ LR + RR + OV
 124     AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_BACK_CENTER|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT,   ///< 6, CF+ CR+LF+ RF+LR + RR
 125     AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
 126     AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2
 127     AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|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_MAX_FRAME_SIZE 16384
 220 #define DCA_MAX_EXSS_HEADER_SIZE 4096
 221
 222 #define DCA_BUFFER_PADDING_SIZE 1024
 223
 224 /** Bit allocation */
 225 typedef struct {
 226     int offset;                 ///< code values offset
 227     int maxbits[8];             ///< max bits in VLC
 228     int wrap;                   ///< wrap for get_vlc2()
 229     VLC vlc[8];                 ///< actual codes
 230 } BitAlloc;
 231
 232 static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
 233 static BitAlloc dca_tmode;             ///< transition mode VLCs
 234 static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
 235 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
 236
 237 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
 238 {
 239     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
 240 }
 241
 242 typedef struct {
 243     AVCodecContext *avctx;
 244     /* Frame header */
 245     int frame_type;             ///< type of the current frame
 246     int samples_deficit;        ///< deficit sample count
 247     int crc_present;            ///< crc is present in the bitstream
 248     int sample_blocks;          ///< number of PCM sample blocks
 249     int frame_size;             ///< primary frame byte size
 250     int amode;                  ///< audio channels arrangement
 251     int sample_rate;            ///< audio sampling rate
 252     int bit_rate;               ///< transmission bit rate
 253     int bit_rate_index;         ///< transmission bit rate index
 254
 255     int downmix;                ///< embedded downmix enabled
 256     int dynrange;               ///< embedded dynamic range flag
 257     int timestamp;              ///< embedded time stamp flag
 258     int aux_data;               ///< auxiliary data flag
 259     int hdcd;                   ///< source material is mastered in HDCD
 260     int ext_descr;              ///< extension audio descriptor flag
 261     int ext_coding;             ///< extended coding flag
 262     int aspf;                   ///< audio sync word insertion flag
 263     int lfe;                    ///< low frequency effects flag
 264     int predictor_history;      ///< predictor history flag
 265     int header_crc;             ///< header crc check bytes
 266     int multirate_inter;        ///< multirate interpolator switch
 267     int version;                ///< encoder software revision
 268     int copy_history;           ///< copy history
 269     int source_pcm_res;         ///< source pcm resolution
 270     int front_sum;              ///< front sum/difference flag
 271     int surround_sum;           ///< surround sum/difference flag
 272     int dialog_norm;            ///< dialog normalisation parameter
 273
 274     /* Primary audio coding header */
 275     int subframes;              ///< number of subframes
 276     int is_channels_set;        ///< check for if the channel number is already set
 277     int total_channels;         ///< number of channels including extensions
 278     int prim_channels;          ///< number of primary audio channels
 279     int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
 280     int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
 281     int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
 282     int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
 283     int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
 284     int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
 285     int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
 286     float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
 287
 288     /* Primary audio coding side information */
 289     int subsubframes[DCA_SUBFRAMES_MAX];           ///< number of subsubframes
 290     int partial_samples[DCA_SUBFRAMES_MAX];        ///< partial subsubframe samples count
 291     int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
 292     int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
 293     int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
 294     int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
 295     int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
 296     int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
 297     int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
 298     int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
 299     int dynrange_coef;                                           ///< dynamic range coefficient
 300
 301     int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
 302
 303     float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      ///< Low frequency effect data
 304     int lfe_scale_factor;
 305
 306     /* Subband samples history (for ADPCM) */
 307     float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
 308     DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
 309     DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
 310     int hist_index[DCA_PRIM_CHANNELS_MAX];
 311     DECLARE_ALIGNED(16, float, raXin)[32];
 312
 313     int output;                 ///< type of output
 314     float add_bias;             ///< output bias
 315     float scale_bias;           ///< output scale
 316
 317     DECLARE_ALIGNED(16, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
 318     DECLARE_ALIGNED(16, float, samples)[(DCA_PRIM_CHANNELS_MAX+1)*256];
 319     const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX+1];
 320
 321     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
 322     int dca_buffer_size;        ///< how much data is in the dca_buffer
 323
 324     const int8_t* channel_order_tab;                             ///< channel reordering table, lfe and non lfe
 325     GetBitContext gb;
 326     /* Current position in DCA frame */
 327     int current_subframe;
 328     int current_subsubframe;
 329
 330     /* XCh extension information */
 331     int xch_present;
 332     int xch_base_channel;       ///< index of first (only) channel containing XCH data
 333
 334     /* Other detected extensions in the core substream */
 335     int xxch_present;
 336     int x96_present;
 337
 338     /* ExSS header parser */
 339     int static_fields;          ///< static fields present
 340     int mix_metadata;           ///< mixing metadata present
 341     int num_mix_configs;        ///< number of mix out configurations
 342     int mix_config_num_ch[4];   ///< number of channels in each mix out configuration
 343
 344     int profile;
 345
 346     int debug_flag;             ///< used for suppressing repeated error messages output
 347     DSPContext dsp;
 348     FFTContext imdct;
 349     SynthFilterContext synth;
 350     DCADSPContext dcadsp;
 351 } DCAContext;
 352
 353 static const uint16_t dca_vlc_offs[] = {
 354         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
 355      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
 356      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
 357      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
 358     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
 359     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
 360 };
 361
 362 static av_cold void dca_init_vlcs(void)
 363 {
 364     static int vlcs_initialized = 0;
 365     int i, j, c = 14;
 366     static VLC_TYPE dca_table[23622][2];
 367
 368     if (vlcs_initialized)
 369         return;
 370
 371     dca_bitalloc_index.offset = 1;
 372     dca_bitalloc_index.wrap = 2;
 373     for (i = 0; i < 5; i++) {
 374         dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
 375         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
 376         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
 377                  bitalloc_12_bits[i], 1, 1,
 378                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 379     }
 380     dca_scalefactor.offset = -64;
 381     dca_scalefactor.wrap = 2;
 382     for (i = 0; i < 5; i++) {
 383         dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
 384         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
 385         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
 386                  scales_bits[i], 1, 1,
 387                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 388     }
 389     dca_tmode.offset = 0;
 390     dca_tmode.wrap = 1;
 391     for (i = 0; i < 4; i++) {
 392         dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
 393         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
 394         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
 395                  tmode_bits[i], 1, 1,
 396                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
 397     }
 398
 399     for (i = 0; i < 10; i++)
 400         for (j = 0; j < 7; j++){
 401             if (!bitalloc_codes[i][j]) break;
 402             dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
 403             dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
 404             dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
 405             dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
 406             init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
 407                      bitalloc_sizes[i],
 408                      bitalloc_bits[i][j], 1, 1,
 409                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
 410             c++;
 411         }
 412     vlcs_initialized = 1;
 413 }
 414
 415 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
 416 {
 417     while(len--)
 418         *dst++ = get_bits(gb, bits);
 419 }
 420
 421 static int dca_parse_audio_coding_header(DCAContext * s, int base_channel)
 422 {
 423     int i, j;
 424     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
 425     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
 426     static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
 427
 428     s->total_channels    = get_bits(&s->gb, 3) + 1 + base_channel;
 429     s->prim_channels     = s->total_channels;
 430
 431     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
 432         s->prim_channels = DCA_PRIM_CHANNELS_MAX;
 433
 434
 435     for (i = base_channel; i < s->prim_channels; i++) {
 436         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
 437         if (s->subband_activity[i] > DCA_SUBBANDS)
 438             s->subband_activity[i] = DCA_SUBBANDS;
 439     }
 440     for (i = base_channel; i < s->prim_channels; i++) {
 441         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
 442         if (s->vq_start_subband[i] > DCA_SUBBANDS)
 443             s->vq_start_subband[i] = DCA_SUBBANDS;
 444     }
 445     get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);
 446     get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);
 447     get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
 448     get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);
 449
 450     /* Get codebooks quantization indexes */
 451     if (!base_channel)
 452         memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
 453     for (j = 1; j < 11; j++)
 454         for (i = base_channel; i < s->prim_channels; i++)
 455             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
 456
 457     /* Get scale factor adjustment */
 458     for (j = 0; j < 11; j++)
 459         for (i = base_channel; i < s->prim_channels; i++)
 460             s->scalefactor_adj[i][j] = 1;
 461
 462     for (j = 1; j < 11; j++)
 463         for (i = base_channel; i < s->prim_channels; i++)
 464             if (s->quant_index_huffman[i][j] < thr[j])
 465                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
 466
 467     if (s->crc_present) {
 468         /* Audio header CRC check */
 469         get_bits(&s->gb, 16);
 470     }
 471
 472     s->current_subframe = 0;
 473     s->current_subsubframe = 0;
 474
 475 #ifdef TRACE
 476     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
 477     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
 478     for (i = base_channel; i < s->prim_channels; i++){
 479         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
 480         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
 481         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
 482         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
 483         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
 484         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
 485         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
 486         for (j = 0; j < 11; j++)
 487             av_log(s->avctx, AV_LOG_DEBUG, " %i",
 488                    s->quant_index_huffman[i][j]);
 489         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 490         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
 491         for (j = 0; j < 11; j++)
 492             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
 493         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 494     }
 495 #endif
 496
 497   return 0;
 498 }
 499
 500 static int dca_parse_frame_header(DCAContext * s)
 501 {
 502     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
 503
 504     /* Sync code */
 505     get_bits(&s->gb, 32);
 506
 507     /* Frame header */
 508     s->frame_type        = get_bits(&s->gb, 1);
 509     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
 510     s->crc_present       = get_bits(&s->gb, 1);
 511     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
 512     s->frame_size        = get_bits(&s->gb, 14) + 1;
 513     if (s->frame_size < 95)
 514         return -1;
 515     s->amode             = get_bits(&s->gb, 6);
 516     s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
 517     if (!s->sample_rate)
 518         return -1;
 519     s->bit_rate_index    = get_bits(&s->gb, 5);
 520     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
 521     if (!s->bit_rate)
 522         return -1;
 523
 524     s->downmix           = get_bits(&s->gb, 1);
 525     s->dynrange          = get_bits(&s->gb, 1);
 526     s->timestamp         = get_bits(&s->gb, 1);
 527     s->aux_data          = get_bits(&s->gb, 1);
 528     s->hdcd              = get_bits(&s->gb, 1);
 529     s->ext_descr         = get_bits(&s->gb, 3);
 530     s->ext_coding        = get_bits(&s->gb, 1);
 531     s->aspf              = get_bits(&s->gb, 1);
 532     s->lfe               = get_bits(&s->gb, 2);
 533     s->predictor_history = get_bits(&s->gb, 1);
 534
 535     /* TODO: check CRC */
 536     if (s->crc_present)
 537         s->header_crc    = get_bits(&s->gb, 16);
 538
 539     s->multirate_inter   = get_bits(&s->gb, 1);
 540     s->version           = get_bits(&s->gb, 4);
 541     s->copy_history      = get_bits(&s->gb, 2);
 542     s->source_pcm_res    = get_bits(&s->gb, 3);
 543     s->front_sum         = get_bits(&s->gb, 1);
 544     s->surround_sum      = get_bits(&s->gb, 1);
 545     s->dialog_norm       = get_bits(&s->gb, 4);
 546
 547     /* FIXME: channels mixing levels */
 548     s->output = s->amode;
 549     if (s->lfe) s->output |= DCA_LFE;
 550
 551 #ifdef TRACE
 552     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
 553     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
 554     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
 555     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
 556            s->sample_blocks, s->sample_blocks * 32);
 557     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
 558     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
 559            s->amode, dca_channels[s->amode]);
 560     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
 561            s->sample_rate);
 562     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
 563            s->bit_rate);
 564     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
 565     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
 566     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
 567     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
 568     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
 569     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
 570     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
 571     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
 572     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
 573     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
 574            s->predictor_history);
 575     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
 576     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
 577            s->multirate_inter);
 578     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
 579     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
 580     av_log(s->avctx, AV_LOG_DEBUG,
 581            "source pcm resolution: %i (%i bits/sample)\n",
 582            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
 583     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
 584     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
 585     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
 586     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 587 #endif
 588
 589     /* Primary audio coding header */
 590     s->subframes         = get_bits(&s->gb, 4) + 1;
 591
 592     return dca_parse_audio_coding_header(s, 0);
 593 }
 594
 595
 596 static inline int get_scale(GetBitContext *gb, int level, int value)
 597 {
 598    if (level < 5) {
 599        /* huffman encoded */
 600        value += get_bitalloc(gb, &dca_scalefactor, level);
 601    } else if (level < 8)
 602        value = get_bits(gb, level + 1);
 603    return value;
 604 }
 605
 606 static int dca_subframe_header(DCAContext * s, int base_channel, int block_index)
 607 {
 608     /* Primary audio coding side information */
 609     int j, k;
 610
 611     if (get_bits_left(&s->gb) < 0)
 612         return -1;
 613
 614     if (!base_channel) {
 615         s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
 616         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
 617     }
 618
 619     for (j = base_channel; j < s->prim_channels; j++) {
 620         for (k = 0; k < s->subband_activity[j]; k++)
 621             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
 622     }
 623
 624     /* Get prediction codebook */
 625     for (j = base_channel; j < s->prim_channels; j++) {
 626         for (k = 0; k < s->subband_activity[j]; k++) {
 627             if (s->prediction_mode[j][k] > 0) {
 628                 /* (Prediction coefficient VQ address) */
 629                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
 630             }
 631         }
 632     }
 633
 634     /* Bit allocation index */
 635     for (j = base_channel; j < s->prim_channels; j++) {
 636         for (k = 0; k < s->vq_start_subband[j]; k++) {
 637             if (s->bitalloc_huffman[j] == 6)
 638                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
 639             else if (s->bitalloc_huffman[j] == 5)
 640                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
 641             else if (s->bitalloc_huffman[j] == 7) {
 642                 av_log(s->avctx, AV_LOG_ERROR,
 643                        "Invalid bit allocation index\n");
 644                 return -1;
 645             } else {
 646                 s->bitalloc[j][k] =
 647                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
 648             }
 649
 650             if (s->bitalloc[j][k] > 26) {
 651 //                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
 652 //                          j, k, s->bitalloc[j][k]);
 653                 return -1;
 654             }
 655         }
 656     }
 657
 658     /* Transition mode */
 659     for (j = base_channel; j < s->prim_channels; j++) {
 660         for (k = 0; k < s->subband_activity[j]; k++) {
 661             s->transition_mode[j][k] = 0;
 662             if (s->subsubframes[s->current_subframe] > 1 &&
 663                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
 664                 s->transition_mode[j][k] =
 665                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
 666             }
 667         }
 668     }
 669
 670     if (get_bits_left(&s->gb) < 0)
 671         return -1;
 672
 673     for (j = base_channel; j < s->prim_channels; j++) {
 674         const uint32_t *scale_table;
 675         int scale_sum;
 676
 677         memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
 678
 679         if (s->scalefactor_huffman[j] == 6)
 680             scale_table = scale_factor_quant7;
 681         else
 682             scale_table = scale_factor_quant6;
 683
 684         /* When huffman coded, only the difference is encoded */
 685         scale_sum = 0;
 686
 687         for (k = 0; k < s->subband_activity[j]; k++) {
 688             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
 689                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
 690                 s->scale_factor[j][k][0] = scale_table[scale_sum];
 691             }
 692
 693             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
 694                 /* Get second scale factor */
 695                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
 696                 s->scale_factor[j][k][1] = scale_table[scale_sum];
 697             }
 698         }
 699     }
 700
 701     /* Joint subband scale factor codebook select */
 702     for (j = base_channel; j < s->prim_channels; j++) {
 703         /* Transmitted only if joint subband coding enabled */
 704         if (s->joint_intensity[j] > 0)
 705             s->joint_huff[j] = get_bits(&s->gb, 3);
 706     }
 707
 708     if (get_bits_left(&s->gb) < 0)
 709         return -1;
 710
 711     /* Scale factors for joint subband coding */
 712     for (j = base_channel; j < s->prim_channels; j++) {
 713         int source_channel;
 714
 715         /* Transmitted only if joint subband coding enabled */
 716         if (s->joint_intensity[j] > 0) {
 717             int scale = 0;
 718             source_channel = s->joint_intensity[j] - 1;
 719
 720             /* When huffman coded, only the difference is encoded
 721              * (is this valid as well for joint scales ???) */
 722
 723             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
 724                 scale = get_scale(&s->gb, s->joint_huff[j], 0);
 725                 scale += 64;    /* bias */
 726                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
 727             }
 728
 729             if (!(s->debug_flag & 0x02)) {
 730                 av_log(s->avctx, AV_LOG_DEBUG,
 731                        "Joint stereo coding not supported\n");
 732                 s->debug_flag |= 0x02;
 733             }
 734         }
 735     }
 736
 737     /* Stereo downmix coefficients */
 738     if (!base_channel && s->prim_channels > 2) {
 739         if (s->downmix) {
 740             for (j = base_channel; j < s->prim_channels; j++) {
 741                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
 742                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
 743             }
 744         } else {
 745             int am = s->amode & DCA_CHANNEL_MASK;
 746             for (j = base_channel; j < s->prim_channels; j++) {
 747                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
 748                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
 749             }
 750         }
 751     }
 752
 753     /* Dynamic range coefficient */
 754     if (!base_channel && s->dynrange)
 755         s->dynrange_coef = get_bits(&s->gb, 8);
 756
 757     /* Side information CRC check word */
 758     if (s->crc_present) {
 759         get_bits(&s->gb, 16);
 760     }
 761
 762     /*
 763      * Primary audio data arrays
 764      */
 765
 766     /* VQ encoded high frequency subbands */
 767     for (j = base_channel; j < s->prim_channels; j++)
 768         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 769             /* 1 vector -> 32 samples */
 770             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
 771
 772     /* Low frequency effect data */
 773     if (!base_channel && s->lfe) {
 774         /* LFE samples */
 775         int lfe_samples = 2 * s->lfe * (4 + block_index);
 776         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
 777         float lfe_scale;
 778
 779         for (j = lfe_samples; j < lfe_end_sample; j++) {
 780             /* Signed 8 bits int */
 781             s->lfe_data[j] = get_sbits(&s->gb, 8);
 782         }
 783
 784         /* Scale factor index */
 785         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
 786
 787         /* Quantization step size * scale factor */
 788         lfe_scale = 0.035 * s->lfe_scale_factor;
 789
 790         for (j = lfe_samples; j < lfe_end_sample; j++)
 791             s->lfe_data[j] *= lfe_scale;
 792     }
 793
 794 #ifdef TRACE
 795     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes[s->current_subframe]);
 796     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
 797            s->partial_samples[s->current_subframe]);
 798     for (j = base_channel; j < s->prim_channels; j++) {
 799         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
 800         for (k = 0; k < s->subband_activity[j]; k++)
 801             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
 802         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 803     }
 804     for (j = base_channel; j < s->prim_channels; j++) {
 805         for (k = 0; k < s->subband_activity[j]; k++)
 806                 av_log(s->avctx, AV_LOG_DEBUG,
 807                        "prediction coefs: %f, %f, %f, %f\n",
 808                        (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
 809                        (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
 810                        (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
 811                        (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
 812     }
 813     for (j = base_channel; j < s->prim_channels; j++) {
 814         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
 815         for (k = 0; k < s->vq_start_subband[j]; k++)
 816             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
 817         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 818     }
 819     for (j = base_channel; j < s->prim_channels; j++) {
 820         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
 821         for (k = 0; k < s->subband_activity[j]; k++)
 822             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
 823         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 824     }
 825     for (j = base_channel; j < s->prim_channels; j++) {
 826         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
 827         for (k = 0; k < s->subband_activity[j]; k++) {
 828             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
 829                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
 830             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
 831                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
 832         }
 833         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 834     }
 835     for (j = base_channel; j < s->prim_channels; j++) {
 836         if (s->joint_intensity[j] > 0) {
 837             int source_channel = s->joint_intensity[j] - 1;
 838             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
 839             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
 840                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
 841             av_log(s->avctx, AV_LOG_DEBUG, "\n");
 842         }
 843     }
 844     if (!base_channel && s->prim_channels > 2 && s->downmix) {
 845         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
 846         for (j = 0; j < s->prim_channels; j++) {
 847             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
 848             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
 849         }
 850         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 851     }
 852     for (j = base_channel; j < s->prim_channels; j++)
 853         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 854             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
 855     if (!base_channel && s->lfe) {
 856         int lfe_samples = 2 * s->lfe * (4 + block_index);
 857         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
 858
 859         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
 860         for (j = lfe_samples; j < lfe_end_sample; j++)
 861             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
 862         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 863     }
 864 #endif
 865
 866     return 0;
 867 }
 868
 869 static void qmf_32_subbands(DCAContext * s, int chans,
 870                             float samples_in[32][8], float *samples_out,
 871                             float scale, float bias)
 872 {
 873     const float *prCoeff;
 874     int i;
 875
 876     int sb_act = s->subband_activity[chans];
 877     int subindex;
 878
 879     scale *= sqrt(1/8.0);
 880
 881     /* Select filter */
 882     if (!s->multirate_inter)    /* Non-perfect reconstruction */
 883         prCoeff = fir_32bands_nonperfect;
 884     else                        /* Perfect reconstruction */
 885         prCoeff = fir_32bands_perfect;
 886
 887     /* Reconstructed channel sample index */
 888     for (subindex = 0; subindex < 8; subindex++) {
 889         /* Load in one sample from each subband and clear inactive subbands */
 890         for (i = 0; i < sb_act; i++){
 891             uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
 892             AV_WN32A(&s->raXin[i], v);
 893         }
 894         for (; i < 32; i++)
 895             s->raXin[i] = 0.0;
 896
 897         s->synth.synth_filter_float(&s->imdct,
 898                               s->subband_fir_hist[chans], &s->hist_index[chans],
 899                               s->subband_fir_noidea[chans], prCoeff,
 900                               samples_out, s->raXin, scale, bias);
 901         samples_out+= 32;
 902
 903     }
 904 }
 905
 906 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
 907                                   int num_deci_sample, float *samples_in,
 908                                   float *samples_out, float scale,
 909                                   float bias)
 910 {
 911     /* samples_in: An array holding decimated samples.
 912      *   Samples in current subframe starts from samples_in[0],
 913      *   while samples_in[-1], samples_in[-2], ..., stores samples
 914      *   from last subframe as history.
 915      *
 916      * samples_out: An array holding interpolated samples
 917      */
 918
 919     int decifactor;
 920     const float *prCoeff;
 921     int deciindex;
 922
 923     /* Select decimation filter */
 924     if (decimation_select == 1) {
 925         decifactor = 64;
 926         prCoeff = lfe_fir_128;
 927     } else {
 928         decifactor = 32;
 929         prCoeff = lfe_fir_64;
 930     }
 931     /* Interpolation */
 932     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
 933         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
 934                           scale, bias);
 935         samples_in++;
 936         samples_out += 2 * decifactor;
 937     }
 938 }
 939
 940 /* downmixing routines */
 941 #define MIX_REAR1(samples, si1, rs, coef) \
 942      samples[i]     += (samples[si1] - add_bias) * coef[rs][0];  \
 943      samples[i+256] += (samples[si1] - add_bias) * coef[rs][1];
 944
 945 #define MIX_REAR2(samples, si1, si2, rs, coef) \
 946      samples[i]     += (samples[si1] - add_bias) * coef[rs][0] + (samples[si2] - add_bias) * coef[rs+1][0]; \
 947      samples[i+256] += (samples[si1] - add_bias) * coef[rs][1] + (samples[si2] - add_bias) * coef[rs+1][1];
 948
 949 #define MIX_FRONT3(samples, coef) \
 950     t = samples[i+c] - add_bias; \
 951     u = samples[i+l] - add_bias; \
 952     v = samples[i+r] - add_bias; \
 953     samples[i]     = t * coef[0][0] + u * coef[1][0] + v * coef[2][0] + add_bias; \
 954     samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1] + add_bias;
 955
 956 #define DOWNMIX_TO_STEREO(op1, op2) \
 957     for (i = 0; i < 256; i++){ \
 958         op1 \
 959         op2 \
 960     }
 961
 962 static void dca_downmix(float *samples, int srcfmt,
 963                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
 964                         const int8_t *channel_mapping, float add_bias)
 965 {
 966     int c,l,r,sl,sr,s;
 967     int i;
 968     float t, u, v;
 969     float coef[DCA_PRIM_CHANNELS_MAX][2];
 970
 971     for (i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
 972         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
 973         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
 974     }
 975
 976     switch (srcfmt) {
 977     case DCA_MONO:
 978     case DCA_CHANNEL:
 979     case DCA_STEREO_TOTAL:
 980     case DCA_STEREO_SUMDIFF:
 981     case DCA_4F2R:
 982         av_log(NULL, 0, "Not implemented!\n");
 983         break;
 984     case DCA_STEREO:
 985         break;
 986     case DCA_3F:
 987         c = channel_mapping[0] * 256;
 988         l = channel_mapping[1] * 256;
 989         r = channel_mapping[2] * 256;
 990         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
 991         break;
 992     case DCA_2F1R:
 993         s = channel_mapping[2] * 256;
 994         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef),);
 995         break;
 996     case DCA_3F1R:
 997         c = channel_mapping[0] * 256;
 998         l = channel_mapping[1] * 256;
 999         r = channel_mapping[2] * 256;
1000         s = channel_mapping[3] * 256;
1001         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1002                           MIX_REAR1(samples, i + s, 3, coef));
1003         break;
1004     case DCA_2F2R:
1005         sl = channel_mapping[2] * 256;
1006         sr = channel_mapping[3] * 256;
1007         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef),);
1008         break;
1009     case DCA_3F2R:
1010         c =  channel_mapping[0] * 256;
1011         l =  channel_mapping[1] * 256;
1012         r =  channel_mapping[2] * 256;
1013         sl = channel_mapping[3] * 256;
1014         sr = channel_mapping[4] * 256;
1015         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1016                           MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1017         break;
1018     }
1019 }
1020
1021
1022 /* Very compact version of the block code decoder that does not use table
1023  * look-up but is slightly slower */
1024 static int decode_blockcode(int code, int levels, int *values)
1025 {
1026     int i;
1027     int offset = (levels - 1) >> 1;
1028
1029     for (i = 0; i < 4; i++) {
1030         int div = FASTDIV(code, levels);
1031         values[i] = code - offset - div*levels;
1032         code = div;
1033     }
1034
1035     if (code == 0)
1036         return 0;
1037     else {
1038         av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
1039         return -1;
1040     }
1041 }
1042
1043 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1044 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1045
1046 static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
1047 {
1048     int k, l;
1049     int subsubframe = s->current_subsubframe;
1050
1051     const float *quant_step_table;
1052
1053     /* FIXME */
1054     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1055     LOCAL_ALIGNED_16(int, block, [8]);
1056
1057     /*
1058      * Audio data
1059      */
1060
1061     /* Select quantization step size table */
1062     if (s->bit_rate_index == 0x1f)
1063         quant_step_table = lossless_quant_d;
1064     else
1065         quant_step_table = lossy_quant_d;
1066
1067     for (k = base_channel; k < s->prim_channels; k++) {
1068         if (get_bits_left(&s->gb) < 0)
1069             return -1;
1070
1071         for (l = 0; l < s->vq_start_subband[k]; l++) {
1072             int m;
1073
1074             /* Select the mid-tread linear quantizer */
1075             int abits = s->bitalloc[k][l];
1076
1077             float quant_step_size = quant_step_table[abits];
1078
1079             /*
1080              * Determine quantization index code book and its type
1081              */
1082
1083             /* Select quantization index code book */
1084             int sel = s->quant_index_huffman[k][abits];
1085
1086             /*
1087              * Extract bits from the bit stream
1088              */
1089             if (!abits){
1090                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1091             } else {
1092                 /* Deal with transients */
1093                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1094                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
1095
1096                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
1097                     if (abits <= 7){
1098                         /* Block code */
1099                         int block_code1, block_code2, size, levels;
1100
1101                         size = abits_sizes[abits-1];
1102                         levels = abits_levels[abits-1];
1103
1104                         block_code1 = get_bits(&s->gb, size);
1105                         /* FIXME Should test return value */
1106                         decode_blockcode(block_code1, levels, block);
1107                         block_code2 = get_bits(&s->gb, size);
1108                         decode_blockcode(block_code2, levels, &block[4]);
1109                     }else{
1110                         /* no coding */
1111                         for (m = 0; m < 8; m++)
1112                             block[m] = get_sbits(&s->gb, abits - 3);
1113                     }
1114                 }else{
1115                     /* Huffman coded */
1116                     for (m = 0; m < 8; m++)
1117                         block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1118                 }
1119
1120                 s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
1121                                                   block, rscale, 8);
1122             }
1123
1124             /*
1125              * Inverse ADPCM if in prediction mode
1126              */
1127             if (s->prediction_mode[k][l]) {
1128                 int n;
1129                 for (m = 0; m < 8; m++) {
1130                     for (n = 1; n <= 4; n++)
1131                         if (m >= n)
1132                             subband_samples[k][l][m] +=
1133                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1134                                  subband_samples[k][l][m - n] / 8192);
1135                         else if (s->predictor_history)
1136                             subband_samples[k][l][m] +=
1137                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1138                                  s->subband_samples_hist[k][l][m - n +
1139                                                                4] / 8192);
1140                 }
1141             }
1142         }
1143
1144         /*
1145          * Decode VQ encoded high frequencies
1146          */
1147         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1148             /* 1 vector -> 32 samples but we only need the 8 samples
1149              * for this subsubframe. */
1150             int m;
1151
1152             if (!s->debug_flag & 0x01) {
1153                 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1154                 s->debug_flag |= 0x01;
1155             }
1156
1157             for (m = 0; m < 8; m++) {
1158                 subband_samples[k][l][m] =
1159                     high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1160                                                         m]
1161                     * (float) s->scale_factor[k][l][0] / 16.0;
1162             }
1163         }
1164     }
1165
1166     /* Check for DSYNC after subsubframe */
1167     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1168         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1169 #ifdef TRACE
1170             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1171 #endif
1172         } else {
1173             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1174         }
1175     }
1176
1177     /* Backup predictor history for adpcm */
1178     for (k = base_channel; k < s->prim_channels; k++)
1179         for (l = 0; l < s->vq_start_subband[k]; l++)
1180             memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1181                         4 * sizeof(subband_samples[0][0][0]));
1182
1183     return 0;
1184 }
1185
1186 static int dca_filter_channels(DCAContext * s, int block_index)
1187 {
1188     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1189     int k;
1190
1191     /* 32 subbands QMF */
1192     for (k = 0; k < s->prim_channels; k++) {
1193 /*        static float pcm_to_double[8] =
1194             {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1195          qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1196                             M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1197                             s->add_bias );
1198     }
1199
1200     /* Down mixing */
1201     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1202         dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab, s->add_bias);
1203     }
1204
1205     /* Generate LFE samples for this subsubframe FIXME!!! */
1206     if (s->output & DCA_LFE) {
1207         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1208                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1209                               &s->samples[256 * dca_lfe_index[s->amode]],
1210                               (1.0/256.0)*s->scale_bias,  s->add_bias);
1211         /* Outputs 20bits pcm samples */
1212     }
1213
1214     return 0;
1215 }
1216
1217
1218 static int dca_subframe_footer(DCAContext * s, int base_channel)
1219 {
1220     int aux_data_count = 0, i;
1221
1222     /*
1223      * Unpack optional information
1224      */
1225
1226     /* presumably optional information only appears in the core? */
1227     if (!base_channel) {
1228         if (s->timestamp)
1229             get_bits(&s->gb, 32);
1230
1231         if (s->aux_data)
1232             aux_data_count = get_bits(&s->gb, 6);
1233
1234         for (i = 0; i < aux_data_count; i++)
1235             get_bits(&s->gb, 8);
1236
1237         if (s->crc_present && (s->downmix || s->dynrange))
1238             get_bits(&s->gb, 16);
1239     }
1240
1241     return 0;
1242 }
1243
1244 /**
1245  * Decode a dca frame block
1246  *
1247  * @param s     pointer to the DCAContext
1248  */
1249
1250 static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1251 {
1252
1253     /* Sanity check */
1254     if (s->current_subframe >= s->subframes) {
1255         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1256                s->current_subframe, s->subframes);
1257         return -1;
1258     }
1259
1260     if (!s->current_subsubframe) {
1261 #ifdef TRACE
1262         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1263 #endif
1264         /* Read subframe header */
1265         if (dca_subframe_header(s, base_channel, block_index))
1266             return -1;
1267     }
1268
1269     /* Read subsubframe */
1270 #ifdef TRACE
1271     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1272 #endif
1273     if (dca_subsubframe(s, base_channel, block_index))
1274         return -1;
1275
1276     /* Update state */
1277     s->current_subsubframe++;
1278     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1279         s->current_subsubframe = 0;
1280         s->current_subframe++;
1281     }
1282     if (s->current_subframe >= s->subframes) {
1283 #ifdef TRACE
1284         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1285 #endif
1286         /* Read subframe footer */
1287         if (dca_subframe_footer(s, base_channel))
1288             return -1;
1289     }
1290
1291     return 0;
1292 }
1293
1294 /**
1295  * Convert bitstream to one representation based on sync marker
1296  */
1297 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1298                           int max_size)
1299 {
1300     uint32_t mrk;
1301     int i, tmp;
1302     const uint16_t *ssrc = (const uint16_t *) src;
1303     uint16_t *sdst = (uint16_t *) dst;
1304     PutBitContext pb;
1305
1306     if ((unsigned)src_size > (unsigned)max_size) {
1307 //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1308 //        return -1;
1309         src_size = max_size;
1310     }
1311
1312     mrk = AV_RB32(src);
1313     switch (mrk) {
1314     case DCA_MARKER_RAW_BE:
1315         memcpy(dst, src, src_size);
1316         return src_size;
1317     case DCA_MARKER_RAW_LE:
1318         for (i = 0; i < (src_size + 1) >> 1; i++)
1319             *sdst++ = av_bswap16(*ssrc++);
1320         return src_size;
1321     case DCA_MARKER_14B_BE:
1322     case DCA_MARKER_14B_LE:
1323         init_put_bits(&pb, dst, max_size);
1324         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1325             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1326             put_bits(&pb, 14, tmp);
1327         }
1328         flush_put_bits(&pb);
1329         return (put_bits_count(&pb) + 7) >> 3;
1330     default:
1331         return -1;
1332     }
1333 }
1334
1335 /**
1336  * Return the number of channels in an ExSS speaker mask (HD)
1337  */
1338 static int dca_exss_mask2count(int mask)
1339 {
1340     /* count bits that mean speaker pairs twice */
1341     return av_popcount(mask)
1342         + av_popcount(mask & (
1343             DCA_EXSS_CENTER_LEFT_RIGHT
1344           | DCA_EXSS_FRONT_LEFT_RIGHT
1345           | DCA_EXSS_FRONT_HIGH_LEFT_RIGHT
1346           | DCA_EXSS_WIDE_LEFT_RIGHT
1347           | DCA_EXSS_SIDE_LEFT_RIGHT
1348           | DCA_EXSS_SIDE_HIGH_LEFT_RIGHT
1349           | DCA_EXSS_SIDE_REAR_LEFT_RIGHT
1350           | DCA_EXSS_REAR_LEFT_RIGHT
1351           | DCA_EXSS_REAR_HIGH_LEFT_RIGHT
1352           ));
1353 }
1354
1355 /**
1356  * Skip mixing coefficients of a single mix out configuration (HD)
1357  */
1358 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1359 {
1360     for (int i = 0; i < channels; i++) {
1361         int mix_map_mask = get_bits(gb, out_ch);
1362         int num_coeffs = av_popcount(mix_map_mask);
1363         skip_bits_long(gb, num_coeffs * 6);
1364     }
1365 }
1366
1367 /**
1368  * Parse extension substream asset header (HD)
1369  */
1370 static int dca_exss_parse_asset_header(DCAContext *s)
1371 {
1372     int header_pos = get_bits_count(&s->gb);
1373     int header_size;
1374     int channels;
1375     int embedded_stereo = 0;
1376     int embedded_6ch = 0;
1377     int drc_code_present;
1378     int extensions_mask;
1379     int i, j;
1380
1381     if (get_bits_left(&s->gb) < 16)
1382         return -1;
1383
1384     /* We will parse just enough to get to the extensions bitmask with which
1385      * we can set the profile value. */
1386
1387     header_size = get_bits(&s->gb, 9) + 1;
1388     skip_bits(&s->gb, 3); // asset index
1389
1390     if (s->static_fields) {
1391         if (get_bits1(&s->gb))
1392             skip_bits(&s->gb, 4); // asset type descriptor
1393         if (get_bits1(&s->gb))
1394             skip_bits_long(&s->gb, 24); // language descriptor
1395
1396         if (get_bits1(&s->gb)) {
1397             /* How can one fit 1024 bytes of text here if the maximum value
1398              * for the asset header size field above was 512 bytes? */
1399             int text_length = get_bits(&s->gb, 10) + 1;
1400             if (get_bits_left(&s->gb) < text_length * 8)
1401                 return -1;
1402             skip_bits_long(&s->gb, text_length * 8); // info text
1403         }
1404
1405         skip_bits(&s->gb, 5); // bit resolution - 1
1406         skip_bits(&s->gb, 4); // max sample rate code
1407         channels = get_bits(&s->gb, 8) + 1;
1408
1409         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1410             int spkr_remap_sets;
1411             int spkr_mask_size = 16;
1412             int num_spkrs[7];
1413
1414             if (channels > 2)
1415                 embedded_stereo = get_bits1(&s->gb);
1416             if (channels > 6)
1417                 embedded_6ch = get_bits1(&s->gb);
1418
1419             if (get_bits1(&s->gb)) {
1420                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1421                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1422             }
1423
1424             spkr_remap_sets = get_bits(&s->gb, 3);
1425
1426             for (i = 0; i < spkr_remap_sets; i++) {
1427                 /* std layout mask for each remap set */
1428                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1429             }
1430
1431             for (i = 0; i < spkr_remap_sets; i++) {
1432                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1433                 if (get_bits_left(&s->gb) < 0)
1434                     return -1;
1435
1436                 for (j = 0; j < num_spkrs[i]; j++) {
1437                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1438                     int num_dec_ch = av_popcount(remap_dec_ch_mask);
1439                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1440                 }
1441             }
1442
1443         } else {
1444             skip_bits(&s->gb, 3); // representation type
1445         }
1446     }
1447
1448     drc_code_present = get_bits1(&s->gb);
1449     if (drc_code_present)
1450         get_bits(&s->gb, 8); // drc code
1451
1452     if (get_bits1(&s->gb))
1453         skip_bits(&s->gb, 5); // dialog normalization code
1454
1455     if (drc_code_present && embedded_stereo)
1456         get_bits(&s->gb, 8); // drc stereo code
1457
1458     if (s->mix_metadata && get_bits1(&s->gb)) {
1459         skip_bits(&s->gb, 1); // external mix
1460         skip_bits(&s->gb, 6); // post mix gain code
1461
1462         if (get_bits(&s->gb, 2) != 3) // mixer drc code
1463             skip_bits(&s->gb, 3); // drc limit
1464         else
1465             skip_bits(&s->gb, 8); // custom drc code
1466
1467         if (get_bits1(&s->gb)) // channel specific scaling
1468             for (i = 0; i < s->num_mix_configs; i++)
1469                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1470         else
1471             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1472
1473         for (i = 0; i < s->num_mix_configs; i++) {
1474             if (get_bits_left(&s->gb) < 0)
1475                 return -1;
1476             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1477             if (embedded_6ch)
1478                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1479             if (embedded_stereo)
1480                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1481         }
1482     }
1483
1484     switch (get_bits(&s->gb, 2)) {
1485     case 0: extensions_mask = get_bits(&s->gb, 12); break;
1486     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
1487     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
1488     case 3: extensions_mask = 0; /* aux coding */   break;
1489     }
1490
1491     /* not parsed further, we were only interested in the extensions mask */
1492
1493     if (get_bits_left(&s->gb) < 0)
1494         return -1;
1495
1496     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1497         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1498         return -1;
1499     }
1500     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1501
1502     if (extensions_mask & DCA_EXT_EXSS_XLL)
1503         s->profile = FF_PROFILE_DTS_HD_MA;
1504     else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1505                                 DCA_EXT_EXSS_XXCH))
1506         s->profile = FF_PROFILE_DTS_HD_HRA;
1507
1508     if (!(extensions_mask & DCA_EXT_CORE))
1509         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1510     if (!!(extensions_mask & DCA_EXT_XCH) != s->xch_present)
1511         av_log(s->avctx, AV_LOG_WARNING, "DTS XCh detection mismatch.\n");
1512     if (!!(extensions_mask & DCA_EXT_XXCH) != s->xxch_present)
1513         av_log(s->avctx, AV_LOG_WARNING, "DTS XXCh detection mismatch.\n");
1514     if (!!(extensions_mask & DCA_EXT_X96) != s->x96_present)
1515         av_log(s->avctx, AV_LOG_WARNING, "DTS X96 detection mismatch.\n");
1516
1517     return 0;
1518 }
1519
1520 /**
1521  * Parse extension substream header (HD)
1522  */
1523 static void dca_exss_parse_header(DCAContext *s)
1524 {
1525     int ss_index;
1526     int blownup;
1527     int header_size;
1528     int hd_size;
1529     int num_audiop = 1;
1530     int num_assets = 1;
1531     int active_ss_mask[8];
1532     int i, j;
1533
1534     if (get_bits_left(&s->gb) < 52)
1535         return;
1536
1537     skip_bits(&s->gb, 8); // user data
1538     ss_index = get_bits(&s->gb, 2);
1539
1540     blownup = get_bits1(&s->gb);
1541     header_size = get_bits(&s->gb, 8 + 4 * blownup) + 1;
1542     hd_size = get_bits_long(&s->gb, 16 + 4 * blownup) + 1;
1543
1544     s->static_fields = get_bits1(&s->gb);
1545     if (s->static_fields) {
1546         skip_bits(&s->gb, 2); // reference clock code
1547         skip_bits(&s->gb, 3); // frame duration code
1548
1549         if (get_bits1(&s->gb))
1550             skip_bits_long(&s->gb, 36); // timestamp
1551
1552         /* a single stream can contain multiple audio assets that can be
1553          * combined to form multiple audio presentations */
1554
1555         num_audiop = get_bits(&s->gb, 3) + 1;
1556         if (num_audiop > 1) {
1557             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1558             /* ignore such streams for now */
1559             return;
1560         }
1561
1562         num_assets = get_bits(&s->gb, 3) + 1;
1563         if (num_assets > 1) {
1564             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1565             /* ignore such streams for now */
1566             return;
1567         }
1568
1569         for (i = 0; i < num_audiop; i++)
1570             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1571
1572         for (i = 0; i < num_audiop; i++)
1573             for (j = 0; j <= ss_index; j++)
1574                 if (active_ss_mask[i] & (1 << j))
1575                     skip_bits(&s->gb, 8); // active asset mask
1576
1577         s->mix_metadata = get_bits1(&s->gb);
1578         if (s->mix_metadata) {
1579             int mix_out_mask_size;
1580
1581             skip_bits(&s->gb, 2); // adjustment level
1582             mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1583             s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1584
1585             for (i = 0; i < s->num_mix_configs; i++) {
1586                 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1587                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1588             }
1589         }
1590     }
1591
1592     for (i = 0; i < num_assets; i++)
1593         skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1594
1595     for (i = 0; i < num_assets; i++) {
1596         if (dca_exss_parse_asset_header(s))
1597             return;
1598     }
1599
1600     /* not parsed further, we were only interested in the extensions mask
1601      * from the asset header */
1602 }
1603
1604 /**
1605  * Main frame decoding function
1606  * FIXME add arguments
1607  */
1608 static int dca_decode_frame(AVCodecContext * avctx,
1609                             void *data, int *data_size,
1610                             AVPacket *avpkt)
1611 {
1612     const uint8_t *buf = avpkt->data;
1613     int buf_size = avpkt->size;
1614
1615     int lfe_samples;
1616     int num_core_channels = 0;
1617     int i;
1618     int16_t *samples = data;
1619     DCAContext *s = avctx->priv_data;
1620     int channels;
1621     int core_ss_end;
1622
1623
1624     s->xch_present = 0;
1625     s->x96_present = 0;
1626     s->xxch_present = 0;
1627
1628     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1629                                                DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1630     if (s->dca_buffer_size == -1) {
1631         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1632         return -1;
1633     }
1634
1635     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1636     if (dca_parse_frame_header(s) < 0) {
1637         //seems like the frame is corrupt, try with the next one
1638         *data_size=0;
1639         return buf_size;
1640     }
1641     //set AVCodec values with parsed data
1642     avctx->sample_rate = s->sample_rate;
1643     avctx->bit_rate = s->bit_rate;
1644
1645     s->profile = FF_PROFILE_DTS;
1646
1647     for (i = 0; i < (s->sample_blocks / 8); i++) {
1648         dca_decode_block(s, 0, i);
1649     }
1650
1651     /* record number of core channels incase less than max channels are requested */
1652     num_core_channels = s->prim_channels;
1653
1654     /* extensions start at 32-bit boundaries into bitstream */
1655     skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1656
1657     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1658
1659     while(core_ss_end - get_bits_count(&s->gb) >= 32) {
1660         uint32_t bits = get_bits_long(&s->gb, 32);
1661
1662         switch(bits) {
1663         case 0x5a5a5a5a: {
1664             int ext_amode, xch_fsize;
1665
1666             s->xch_base_channel = s->prim_channels;
1667
1668             /* validate sync word using XCHFSIZE field */
1669             xch_fsize = show_bits(&s->gb, 10);
1670             if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1671                (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1672                 continue;
1673
1674             /* skip length-to-end-of-frame field for the moment */
1675             skip_bits(&s->gb, 10);
1676
1677             s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1678
1679             /* extension amode should == 1, number of channels in extension */
1680             /* AFAIK XCh is not used for more channels */
1681             if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1682                 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1683                        " supported!\n",ext_amode);
1684                 continue;
1685             }
1686
1687             /* much like core primary audio coding header */
1688             dca_parse_audio_coding_header(s, s->xch_base_channel);
1689
1690             for (i = 0; i < (s->sample_blocks / 8); i++) {
1691                 dca_decode_block(s, s->xch_base_channel, i);
1692             }
1693
1694             s->xch_present = 1;
1695             break;
1696         }
1697         case 0x47004a03:
1698             /* XXCh: extended channels */
1699             /* usually found either in core or HD part in DTS-HD HRA streams,
1700              * but not in DTS-ES which contains XCh extensions instead */
1701             s->xxch_present = 1;
1702             s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1703             break;
1704
1705         case 0x1d95f262: {
1706             int fsize96 = show_bits(&s->gb, 12) + 1;
1707             if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1708                 continue;
1709
1710             av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n", get_bits_count(&s->gb));
1711             skip_bits(&s->gb, 12);
1712             av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1713             av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1714
1715             s->x96_present = 1;
1716             s->profile = FFMAX(s->profile, FF_PROFILE_DTS_96_24);
1717             break;
1718         }
1719         }
1720
1721         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1722     }
1723
1724     /* check for ExSS (HD part) */
1725     if (s->dca_buffer_size - s->frame_size > 32
1726         && get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1727         dca_exss_parse_header(s);
1728
1729     avctx->profile = s->profile;
1730
1731     channels = s->prim_channels + !!s->lfe;
1732
1733     if (s->amode<16) {
1734         avctx->channel_layout = dca_core_channel_layout[s->amode];
1735
1736         if (s->xch_present && (!avctx->request_channels ||
1737                                avctx->request_channels > num_core_channels + !!s->lfe)) {
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         } else {
1746             channels = num_core_channels + !!s->lfe;
1747             s->xch_present = 0; /* disable further xch processing */
1748             if (s->lfe) {
1749                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1750                 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1751             } else
1752                 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1753         }
1754
1755         if (channels > !!s->lfe &&
1756             s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1757             return -1;
1758
1759         if (avctx->request_channels == 2 && s->prim_channels > 2) {
1760             channels = 2;
1761             s->output = DCA_STEREO;
1762             avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1763         }
1764     } else {
1765         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1766         return -1;
1767     }
1768
1769
1770     /* There is nothing that prevents a dts frame to change channel configuration
1771        but FFmpeg doesn't support that so only set the channels if it is previously
1772        unset. Ideally during the first probe for channels the crc should be checked
1773        and only set avctx->channels when the crc is ok. Right now the decoder could
1774        set the channels based on a broken first frame.*/
1775     if (s->is_channels_set == 0) {
1776         s->is_channels_set = 1;
1777         avctx->channels = channels;
1778     }
1779     if (avctx->channels != channels) {
1780         av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
1781                "channels changing in stream. Skipping frame.\n");
1782         return -1;
1783     }
1784
1785     if (*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1786         return -1;
1787     *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1788
1789     /* filter to get final output */
1790     for (i = 0; i < (s->sample_blocks / 8); i++) {
1791         dca_filter_channels(s, i);
1792
1793         /* If this was marked as a DTS-ES stream we need to subtract back- */
1794         /* channel from SL & SR to remove matrixed back-channel signal */
1795         if((s->source_pcm_res & 1) && s->xch_present) {
1796             float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1797             float* lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1798             float* rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1799             int j;
1800             for(j = 0; j < 256; ++j) {
1801                 lt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1802                 rt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1803             }
1804         }
1805
1806         s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1807         samples += 256 * channels;
1808     }
1809
1810     /* update lfe history */
1811     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1812     for (i = 0; i < 2 * s->lfe * 4; i++) {
1813         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1814     }
1815
1816     return buf_size;
1817 }
1818
1819
1820
1821 /**
1822  * DCA initialization
1823  *
1824  * @param avctx     pointer to the AVCodecContext
1825  */
1826
1827 static av_cold int dca_decode_init(AVCodecContext * avctx)
1828 {
1829     DCAContext *s = avctx->priv_data;
1830     int i;
1831
1832     s->avctx = avctx;
1833     dca_init_vlcs();
1834
1835     dsputil_init(&s->dsp, avctx);
1836     ff_mdct_init(&s->imdct, 6, 1, 1.0);
1837     ff_synth_filter_init(&s->synth);
1838     ff_dcadsp_init(&s->dcadsp);
1839
1840     for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
1841         s->samples_chanptr[i] = s->samples + i * 256;
1842     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1843
1844     if (s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1845         s->add_bias = 385.0f;
1846         s->scale_bias = 1.0 / 32768.0;
1847     } else {
1848         s->add_bias = 0.0f;
1849         s->scale_bias = 1.0;
1850
1851         /* allow downmixing to stereo */
1852         if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1853                 avctx->request_channels == 2) {
1854             avctx->channels = avctx->request_channels;
1855         }
1856     }
1857
1858
1859     return 0;
1860 }
1861
1862 static av_cold int dca_decode_end(AVCodecContext * avctx)
1863 {
1864     DCAContext *s = avctx->priv_data;
1865     ff_mdct_end(&s->imdct);
1866     return 0;
1867 }
1868
1869 static const AVProfile profiles[] = {
1870     { FF_PROFILE_DTS,        "DTS"        },
1871     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
1872     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
1873     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1874     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
1875     { FF_PROFILE_UNKNOWN },
1876 };
1877
1878 AVCodec dca_decoder = {
1879     .name = "dca",
1880     .type = AVMEDIA_TYPE_AUDIO,
1881     .id = CODEC_ID_DTS,
1882     .priv_data_size = sizeof(DCAContext),
1883     .init = dca_decode_init,
1884     .decode = dca_decode_frame,
1885     .close = dca_decode_end,
1886     .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1887     .capabilities = CODEC_CAP_CHANNEL_CONF,
1888     .profiles = NULL_IF_CONFIG_SMALL(profiles),
1889 };