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