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