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         int quant7;
 821         /* LFE samples */
 822         int lfe_samples = 2 * s->lfe * (4 + block_index);
 823         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
 824         float lfe_scale;
 825
 826         for (j = lfe_samples; j < lfe_end_sample; j++) {
 827             /* Signed 8 bits int */
 828             s->lfe_data[j] = get_sbits(&s->gb, 8);
 829         }
 830
 831         /* Scale factor index */
 832         quant7 = get_bits(&s->gb, 8);
 833         if (quant7 > 127) {
 834             av_log_ask_for_sample(s->avctx, "LFEScaleIndex larger than 127\n");
 835             return AVERROR_INVALIDDATA;
 836         }
 837         s->lfe_scale_factor = scale_factor_quant7[quant7];
 838
 839         /* Quantization step size * scale factor */
 840         lfe_scale = 0.035 * s->lfe_scale_factor;
 841
 842         for (j = lfe_samples; j < lfe_end_sample; j++)
 843             s->lfe_data[j] *= lfe_scale;
 844     }
 845
 846 #ifdef TRACE
 847     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
 848            s->subsubframes[s->current_subframe]);
 849     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
 850            s->partial_samples[s->current_subframe]);
 851
 852     for (j = base_channel; j < s->prim_channels; j++) {
 853         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
 854         for (k = 0; k < s->subband_activity[j]; k++)
 855             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
 856         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 857     }
 858     for (j = base_channel; j < s->prim_channels; j++) {
 859         for (k = 0; k < s->subband_activity[j]; k++)
 860             av_log(s->avctx, AV_LOG_DEBUG,
 861                    "prediction coefs: %f, %f, %f, %f\n",
 862                    (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
 863                    (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
 864                    (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
 865                    (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
 866     }
 867     for (j = base_channel; j < s->prim_channels; j++) {
 868         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
 869         for (k = 0; k < s->vq_start_subband[j]; k++)
 870             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[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, "Transition mode:");
 875         for (k = 0; k < s->subband_activity[j]; k++)
 876             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
 877         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 878     }
 879     for (j = base_channel; j < s->prim_channels; j++) {
 880         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
 881         for (k = 0; k < s->subband_activity[j]; k++) {
 882             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
 883                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
 884             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
 885                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
 886         }
 887         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 888     }
 889     for (j = base_channel; j < s->prim_channels; j++) {
 890         if (s->joint_intensity[j] > 0) {
 891             int source_channel = s->joint_intensity[j] - 1;
 892             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
 893             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
 894                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
 895             av_log(s->avctx, AV_LOG_DEBUG, "\n");
 896         }
 897     }
 898     if (!base_channel && s->prim_channels > 2 && s->downmix) {
 899         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
 900         for (j = 0; j < s->prim_channels; j++) {
 901             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
 902                    dca_downmix_coeffs[s->downmix_coef[j][0]]);
 903             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
 904                    dca_downmix_coeffs[s->downmix_coef[j][1]]);
 905         }
 906         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 907     }
 908     for (j = base_channel; j < s->prim_channels; j++)
 909         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
 910             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
 911     if (!base_channel && s->lfe) {
 912         int lfe_samples = 2 * s->lfe * (4 + block_index);
 913         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
 914
 915         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
 916         for (j = lfe_samples; j < lfe_end_sample; j++)
 917             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
 918         av_log(s->avctx, AV_LOG_DEBUG, "\n");
 919     }
 920 #endif
 921
 922     return 0;
 923 }
 924
 925 static void qmf_32_subbands(DCAContext *s, int chans,
 926                             float samples_in[32][8], float *samples_out,
 927                             float scale)
 928 {
 929     const float *prCoeff;
 930     int i;
 931
 932     int sb_act = s->subband_activity[chans];
 933     int subindex;
 934
 935     scale *= sqrt(1 / 8.0);
 936
 937     /* Select filter */
 938     if (!s->multirate_inter)    /* Non-perfect reconstruction */
 939         prCoeff = fir_32bands_nonperfect;
 940     else                        /* Perfect reconstruction */
 941         prCoeff = fir_32bands_perfect;
 942
 943     for (i = sb_act; i < 32; i++)
 944         s->raXin[i] = 0.0;
 945
 946     /* Reconstructed channel sample index */
 947     for (subindex = 0; subindex < 8; subindex++) {
 948         /* Load in one sample from each subband and clear inactive subbands */
 949         for (i = 0; i < sb_act; i++) {
 950             unsigned sign = (i - 1) & 2;
 951             uint32_t v    = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
 952             AV_WN32A(&s->raXin[i], v);
 953         }
 954
 955         s->synth.synth_filter_float(&s->imdct,
 956                                     s->subband_fir_hist[chans],
 957                                     &s->hist_index[chans],
 958                                     s->subband_fir_noidea[chans], prCoeff,
 959                                     samples_out, s->raXin, scale);
 960         samples_out += 32;
 961     }
 962 }
 963
 964 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
 965                                   int num_deci_sample, float *samples_in,
 966                                   float *samples_out, float scale)
 967 {
 968     /* samples_in: An array holding decimated samples.
 969      *   Samples in current subframe starts from samples_in[0],
 970      *   while samples_in[-1], samples_in[-2], ..., stores samples
 971      *   from last subframe as history.
 972      *
 973      * samples_out: An array holding interpolated samples
 974      */
 975
 976     int decifactor;
 977     const float *prCoeff;
 978     int deciindex;
 979
 980     /* Select decimation filter */
 981     if (decimation_select == 1) {
 982         decifactor = 64;
 983         prCoeff = lfe_fir_128;
 984     } else {
 985         decifactor = 32;
 986         prCoeff = lfe_fir_64;
 987     }
 988     /* Interpolation */
 989     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
 990         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
 991         samples_in++;
 992         samples_out += 2 * decifactor;
 993     }
 994 }
 995
 996 /* downmixing routines */
 997 #define MIX_REAR1(samples, si1, rs, coef)           \
 998     samples[i]     += samples[si1] * coef[rs][0];   \
 999     samples[i+256] += samples[si1] * coef[rs][1];
1000
1001 #define MIX_REAR2(samples, si1, si2, rs, coef)                                     \
1002     samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs + 1][0]; \
1003     samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs + 1][1];
1004
1005 #define MIX_FRONT3(samples, coef)                                      \
1006     t = samples[i + c];                                                \
1007     u = samples[i + l];                                                \
1008     v = samples[i + r];                                                \
1009     samples[i]     = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1010     samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1011
1012 #define DOWNMIX_TO_STEREO(op1, op2)             \
1013     for (i = 0; i < 256; i++) {                 \
1014         op1                                     \
1015         op2                                     \
1016     }
1017
1018 static void dca_downmix(float *samples, int srcfmt,
1019                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
1020                         const int8_t *channel_mapping)
1021 {
1022     int c, l, r, sl, sr, s;
1023     int i;
1024     float t, u, v;
1025     float coef[DCA_PRIM_CHANNELS_MAX][2];
1026
1027     for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
1028         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
1029         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
1030     }
1031
1032     switch (srcfmt) {
1033     case DCA_MONO:
1034     case DCA_CHANNEL:
1035     case DCA_STEREO_TOTAL:
1036     case DCA_STEREO_SUMDIFF:
1037     case DCA_4F2R:
1038         av_log(NULL, 0, "Not implemented!\n");
1039         break;
1040     case DCA_STEREO:
1041         break;
1042     case DCA_3F:
1043         c = channel_mapping[0] * 256;
1044         l = channel_mapping[1] * 256;
1045         r = channel_mapping[2] * 256;
1046         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1047         break;
1048     case DCA_2F1R:
1049         s = channel_mapping[2] * 256;
1050         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef), );
1051         break;
1052     case DCA_3F1R:
1053         c = channel_mapping[0] * 256;
1054         l = channel_mapping[1] * 256;
1055         r = channel_mapping[2] * 256;
1056         s = channel_mapping[3] * 256;
1057         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1058                           MIX_REAR1(samples, i + s, 3, coef));
1059         break;
1060     case DCA_2F2R:
1061         sl = channel_mapping[2] * 256;
1062         sr = channel_mapping[3] * 256;
1063         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef), );
1064         break;
1065     case DCA_3F2R:
1066         c  = channel_mapping[0] * 256;
1067         l  = channel_mapping[1] * 256;
1068         r  = channel_mapping[2] * 256;
1069         sl = channel_mapping[3] * 256;
1070         sr = channel_mapping[4] * 256;
1071         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1072                           MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1073         break;
1074     }
1075 }
1076
1077
1078 #ifndef decode_blockcodes
1079 /* Very compact version of the block code decoder that does not use table
1080  * look-up but is slightly slower */
1081 static int decode_blockcode(int code, int levels, int *values)
1082 {
1083     int i;
1084     int offset = (levels - 1) >> 1;
1085
1086     for (i = 0; i < 4; i++) {
1087         int div = FASTDIV(code, levels);
1088         values[i] = code - offset - div * levels;
1089         code = div;
1090     }
1091
1092     return code;
1093 }
1094
1095 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1096 {
1097     return decode_blockcode(code1, levels, values) |
1098            decode_blockcode(code2, levels, values + 4);
1099 }
1100 #endif
1101
1102 static const uint8_t abits_sizes[7]  = { 7, 10, 12, 13, 15, 17, 19 };
1103 static const uint8_t abits_levels[7] = { 3,  5,  7,  9, 13, 17, 25 };
1104
1105 #ifndef int8x8_fmul_int32
1106 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1107 {
1108     float fscale = scale / 16.0;
1109     int i;
1110     for (i = 0; i < 8; i++)
1111         dst[i] = src[i] * fscale;
1112 }
1113 #endif
1114
1115 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1116 {
1117     int k, l;
1118     int subsubframe = s->current_subsubframe;
1119
1120     const float *quant_step_table;
1121
1122     /* FIXME */
1123     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1124     LOCAL_ALIGNED_16(int, block, [8]);
1125
1126     /*
1127      * Audio data
1128      */
1129
1130     /* Select quantization step size table */
1131     if (s->bit_rate_index == 0x1f)
1132         quant_step_table = lossless_quant_d;
1133     else
1134         quant_step_table = lossy_quant_d;
1135
1136     for (k = base_channel; k < s->prim_channels; k++) {
1137         if (get_bits_left(&s->gb) < 0)
1138             return AVERROR_INVALIDDATA;
1139
1140         for (l = 0; l < s->vq_start_subband[k]; l++) {
1141             int m;
1142
1143             /* Select the mid-tread linear quantizer */
1144             int abits = s->bitalloc[k][l];
1145
1146             float quant_step_size = quant_step_table[abits];
1147
1148             /*
1149              * Determine quantization index code book and its type
1150              */
1151
1152             /* Select quantization index code book */
1153             int sel = s->quant_index_huffman[k][abits];
1154
1155             /*
1156              * Extract bits from the bit stream
1157              */
1158             if (!abits) {
1159                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1160             } else {
1161                 /* Deal with transients */
1162                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1163                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
1164                                s->scalefactor_adj[k][sel];
1165
1166                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1167                     if (abits <= 7) {
1168                         /* Block code */
1169                         int block_code1, block_code2, size, levels, err;
1170
1171                         size   = abits_sizes[abits - 1];
1172                         levels = abits_levels[abits - 1];
1173
1174                         block_code1 = get_bits(&s->gb, size);
1175                         block_code2 = get_bits(&s->gb, size);
1176                         err = decode_blockcodes(block_code1, block_code2,
1177                                                 levels, block);
1178                         if (err) {
1179                             av_log(s->avctx, AV_LOG_ERROR,
1180                                    "ERROR: block code look-up failed\n");
1181                             return AVERROR_INVALIDDATA;
1182                         }
1183                     } else {
1184                         /* no coding */
1185                         for (m = 0; m < 8; m++)
1186                             block[m] = get_sbits(&s->gb, abits - 3);
1187                     }
1188                 } else {
1189                     /* Huffman coded */
1190                     for (m = 0; m < 8; m++)
1191                         block[m] = get_bitalloc(&s->gb,
1192                                                 &dca_smpl_bitalloc[abits], sel);
1193                 }
1194
1195                 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1196                                                        block, rscale, 8);
1197             }
1198
1199             /*
1200              * Inverse ADPCM if in prediction mode
1201              */
1202             if (s->prediction_mode[k][l]) {
1203                 int n;
1204                 for (m = 0; m < 8; m++) {
1205                     for (n = 1; n <= 4; n++)
1206                         if (m >= n)
1207                             subband_samples[k][l][m] +=
1208                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1209                                  subband_samples[k][l][m - n] / 8192);
1210                         else if (s->predictor_history)
1211                             subband_samples[k][l][m] +=
1212                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1213                                  s->subband_samples_hist[k][l][m - n + 4] / 8192);
1214                 }
1215             }
1216         }
1217
1218         /*
1219          * Decode VQ encoded high frequencies
1220          */
1221         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1222             /* 1 vector -> 32 samples but we only need the 8 samples
1223              * for this subsubframe. */
1224             int hfvq = s->high_freq_vq[k][l];
1225
1226             if (!s->debug_flag & 0x01) {
1227                 av_log(s->avctx, AV_LOG_DEBUG,
1228                        "Stream with high frequencies VQ coding\n");
1229                 s->debug_flag |= 0x01;
1230             }
1231
1232             int8x8_fmul_int32(subband_samples[k][l],
1233                               &high_freq_vq[hfvq][subsubframe * 8],
1234                               s->scale_factor[k][l][0]);
1235         }
1236     }
1237
1238     /* Check for DSYNC after subsubframe */
1239     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1240         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1241 #ifdef TRACE
1242             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1243 #endif
1244         } else {
1245             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1246         }
1247     }
1248
1249     /* Backup predictor history for adpcm */
1250     for (k = base_channel; k < s->prim_channels; k++)
1251         for (l = 0; l < s->vq_start_subband[k]; l++)
1252             memcpy(s->subband_samples_hist[k][l],
1253                    &subband_samples[k][l][4],
1254                    4 * sizeof(subband_samples[0][0][0]));
1255
1256     return 0;
1257 }
1258
1259 static int dca_filter_channels(DCAContext *s, int block_index)
1260 {
1261     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1262     int k;
1263
1264     /* 32 subbands QMF */
1265     for (k = 0; k < s->prim_channels; k++) {
1266 /*        static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1267                                             0, 8388608.0, 8388608.0 };*/
1268         qmf_32_subbands(s, k, subband_samples[k],
1269                         &s->samples[256 * s->channel_order_tab[k]],
1270                         M_SQRT1_2 * s->scale_bias /* pcm_to_double[s->source_pcm_res] */);
1271     }
1272
1273     /* Down mixing */
1274     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1275         dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
1276     }
1277
1278     /* Generate LFE samples for this subsubframe FIXME!!! */
1279     if (s->output & DCA_LFE) {
1280         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1281                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1282                               &s->samples[256 * dca_lfe_index[s->amode]],
1283                               (1.0 / 256.0) * s->scale_bias);
1284         /* Outputs 20bits pcm samples */
1285     }
1286
1287     return 0;
1288 }
1289
1290
1291 static int dca_subframe_footer(DCAContext *s, int base_channel)
1292 {
1293     int aux_data_count = 0, i;
1294
1295     /*
1296      * Unpack optional information
1297      */
1298
1299     /* presumably optional information only appears in the core? */
1300     if (!base_channel) {
1301         if (s->timestamp)
1302             skip_bits_long(&s->gb, 32);
1303
1304         if (s->aux_data)
1305             aux_data_count = get_bits(&s->gb, 6);
1306
1307         for (i = 0; i < aux_data_count; i++)
1308             get_bits(&s->gb, 8);
1309
1310         if (s->crc_present && (s->downmix || s->dynrange))
1311             get_bits(&s->gb, 16);
1312     }
1313
1314     return 0;
1315 }
1316
1317 /**
1318  * Decode a dca frame block
1319  *
1320  * @param s     pointer to the DCAContext
1321  */
1322
1323 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1324 {
1325     int ret;
1326
1327     /* Sanity check */
1328     if (s->current_subframe >= s->subframes) {
1329         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1330                s->current_subframe, s->subframes);
1331         return AVERROR_INVALIDDATA;
1332     }
1333
1334     if (!s->current_subsubframe) {
1335 #ifdef TRACE
1336         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1337 #endif
1338         /* Read subframe header */
1339         if ((ret = dca_subframe_header(s, base_channel, block_index)))
1340             return ret;
1341     }
1342
1343     /* Read subsubframe */
1344 #ifdef TRACE
1345     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1346 #endif
1347     if ((ret = dca_subsubframe(s, base_channel, block_index)))
1348         return ret;
1349
1350     /* Update state */
1351     s->current_subsubframe++;
1352     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1353         s->current_subsubframe = 0;
1354         s->current_subframe++;
1355     }
1356     if (s->current_subframe >= s->subframes) {
1357 #ifdef TRACE
1358         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1359 #endif
1360         /* Read subframe footer */
1361         if ((ret = dca_subframe_footer(s, base_channel)))
1362             return ret;
1363     }
1364
1365     return 0;
1366 }
1367
1368 /**
1369  * Convert bitstream to one representation based on sync marker
1370  */
1371 static int dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
1372                                  int max_size)
1373 {
1374     uint32_t mrk;
1375     int i, tmp;
1376     const uint16_t *ssrc = (const uint16_t *) src;
1377     uint16_t *sdst = (uint16_t *) dst;
1378     PutBitContext pb;
1379
1380     if ((unsigned) src_size > (unsigned) max_size) {
1381 //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger than DCA_MAX_FRAME_SIZE!\n");
1382 //        return -1;
1383         src_size = max_size;
1384     }
1385
1386     mrk = AV_RB32(src);
1387     switch (mrk) {
1388     case DCA_MARKER_RAW_BE:
1389         memcpy(dst, src, src_size);
1390         return src_size;
1391     case DCA_MARKER_RAW_LE:
1392         for (i = 0; i < (src_size + 1) >> 1; i++)
1393             *sdst++ = av_bswap16(*ssrc++);
1394         return src_size;
1395     case DCA_MARKER_14B_BE:
1396     case DCA_MARKER_14B_LE:
1397         init_put_bits(&pb, dst, max_size);
1398         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1399             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1400             put_bits(&pb, 14, tmp);
1401         }
1402         flush_put_bits(&pb);
1403         return (put_bits_count(&pb) + 7) >> 3;
1404     default:
1405         return AVERROR_INVALIDDATA;
1406     }
1407 }
1408
1409 /**
1410  * Return the number of channels in an ExSS speaker mask (HD)
1411  */
1412 static int dca_exss_mask2count(int mask)
1413 {
1414     /* count bits that mean speaker pairs twice */
1415     return av_popcount(mask) +
1416            av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT      |
1417                                DCA_EXSS_FRONT_LEFT_RIGHT       |
1418                                DCA_EXSS_FRONT_HIGH_LEFT_RIGHT  |
1419                                DCA_EXSS_WIDE_LEFT_RIGHT        |
1420                                DCA_EXSS_SIDE_LEFT_RIGHT        |
1421                                DCA_EXSS_SIDE_HIGH_LEFT_RIGHT   |
1422                                DCA_EXSS_SIDE_REAR_LEFT_RIGHT   |
1423                                DCA_EXSS_REAR_LEFT_RIGHT        |
1424                                DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1425 }
1426
1427 /**
1428  * Skip mixing coefficients of a single mix out configuration (HD)
1429  */
1430 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1431 {
1432     int i;
1433
1434     for (i = 0; i < channels; i++) {
1435         int mix_map_mask = get_bits(gb, out_ch);
1436         int num_coeffs = av_popcount(mix_map_mask);
1437         skip_bits_long(gb, num_coeffs * 6);
1438     }
1439 }
1440
1441 /**
1442  * Parse extension substream asset header (HD)
1443  */
1444 static int dca_exss_parse_asset_header(DCAContext *s)
1445 {
1446     int header_pos = get_bits_count(&s->gb);
1447     int header_size;
1448     int channels = 0;
1449     int embedded_stereo = 0;
1450     int embedded_6ch    = 0;
1451     int drc_code_present;
1452     int av_uninit(extensions_mask);
1453     int i, j;
1454
1455     if (get_bits_left(&s->gb) < 16)
1456         return -1;
1457
1458     /* We will parse just enough to get to the extensions bitmask with which
1459      * we can set the profile value. */
1460
1461     header_size = get_bits(&s->gb, 9) + 1;
1462     skip_bits(&s->gb, 3); // asset index
1463
1464     if (s->static_fields) {
1465         if (get_bits1(&s->gb))
1466             skip_bits(&s->gb, 4); // asset type descriptor
1467         if (get_bits1(&s->gb))
1468             skip_bits_long(&s->gb, 24); // language descriptor
1469
1470         if (get_bits1(&s->gb)) {
1471             /* How can one fit 1024 bytes of text here if the maximum value
1472              * for the asset header size field above was 512 bytes? */
1473             int text_length = get_bits(&s->gb, 10) + 1;
1474             if (get_bits_left(&s->gb) < text_length * 8)
1475                 return -1;
1476             skip_bits_long(&s->gb, text_length * 8); // info text
1477         }
1478
1479         skip_bits(&s->gb, 5); // bit resolution - 1
1480         skip_bits(&s->gb, 4); // max sample rate code
1481         channels = get_bits(&s->gb, 8) + 1;
1482
1483         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1484             int spkr_remap_sets;
1485             int spkr_mask_size = 16;
1486             int num_spkrs[7];
1487
1488             if (channels > 2)
1489                 embedded_stereo = get_bits1(&s->gb);
1490             if (channels > 6)
1491                 embedded_6ch = get_bits1(&s->gb);
1492
1493             if (get_bits1(&s->gb)) {
1494                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1495                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1496             }
1497
1498             spkr_remap_sets = get_bits(&s->gb, 3);
1499
1500             for (i = 0; i < spkr_remap_sets; i++) {
1501                 /* std layout mask for each remap set */
1502                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1503             }
1504
1505             for (i = 0; i < spkr_remap_sets; i++) {
1506                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1507                 if (get_bits_left(&s->gb) < 0)
1508                     return -1;
1509
1510                 for (j = 0; j < num_spkrs[i]; j++) {
1511                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1512                     int num_dec_ch = av_popcount(remap_dec_ch_mask);
1513                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1514                 }
1515             }
1516
1517         } else {
1518             skip_bits(&s->gb, 3); // representation type
1519         }
1520     }
1521
1522     drc_code_present = get_bits1(&s->gb);
1523     if (drc_code_present)
1524         get_bits(&s->gb, 8); // drc code
1525
1526     if (get_bits1(&s->gb))
1527         skip_bits(&s->gb, 5); // dialog normalization code
1528
1529     if (drc_code_present && embedded_stereo)
1530         get_bits(&s->gb, 8); // drc stereo code
1531
1532     if (s->mix_metadata && get_bits1(&s->gb)) {
1533         skip_bits(&s->gb, 1); // external mix
1534         skip_bits(&s->gb, 6); // post mix gain code
1535
1536         if (get_bits(&s->gb, 2) != 3) // mixer drc code
1537             skip_bits(&s->gb, 3); // drc limit
1538         else
1539             skip_bits(&s->gb, 8); // custom drc code
1540
1541         if (get_bits1(&s->gb)) // channel specific scaling
1542             for (i = 0; i < s->num_mix_configs; i++)
1543                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1544         else
1545             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1546
1547         for (i = 0; i < s->num_mix_configs; i++) {
1548             if (get_bits_left(&s->gb) < 0)
1549                 return -1;
1550             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1551             if (embedded_6ch)
1552                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1553             if (embedded_stereo)
1554                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1555         }
1556     }
1557
1558     switch (get_bits(&s->gb, 2)) {
1559     case 0: extensions_mask = get_bits(&s->gb, 12); break;
1560     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
1561     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
1562     case 3: extensions_mask = 0; /* aux coding */   break;
1563     }
1564
1565     /* not parsed further, we were only interested in the extensions mask */
1566
1567     if (get_bits_left(&s->gb) < 0)
1568         return -1;
1569
1570     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1571         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1572         return -1;
1573     }
1574     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1575
1576     if (extensions_mask & DCA_EXT_EXSS_XLL)
1577         s->profile = FF_PROFILE_DTS_HD_MA;
1578     else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1579                                 DCA_EXT_EXSS_XXCH))
1580         s->profile = FF_PROFILE_DTS_HD_HRA;
1581
1582     if (!(extensions_mask & DCA_EXT_CORE))
1583         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1584     if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1585         av_log(s->avctx, AV_LOG_WARNING,
1586                "DTS extensions detection mismatch (%d, %d)\n",
1587                extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1588
1589     return 0;
1590 }
1591
1592 /**
1593  * Parse extension substream header (HD)
1594  */
1595 static void dca_exss_parse_header(DCAContext *s)
1596 {
1597     int ss_index;
1598     int blownup;
1599     int num_audiop = 1;
1600     int num_assets = 1;
1601     int active_ss_mask[8];
1602     int i, j;
1603
1604     if (get_bits_left(&s->gb) < 52)
1605         return;
1606
1607     skip_bits(&s->gb, 8); // user data
1608     ss_index = get_bits(&s->gb, 2);
1609
1610     blownup = get_bits1(&s->gb);
1611     skip_bits(&s->gb,  8 + 4 * blownup); // header_size
1612     skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1613
1614     s->static_fields = get_bits1(&s->gb);
1615     if (s->static_fields) {
1616         skip_bits(&s->gb, 2); // reference clock code
1617         skip_bits(&s->gb, 3); // frame duration code
1618
1619         if (get_bits1(&s->gb))
1620             skip_bits_long(&s->gb, 36); // timestamp
1621
1622         /* a single stream can contain multiple audio assets that can be
1623          * combined to form multiple audio presentations */
1624
1625         num_audiop = get_bits(&s->gb, 3) + 1;
1626         if (num_audiop > 1) {
1627             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1628             /* ignore such streams for now */
1629             return;
1630         }
1631
1632         num_assets = get_bits(&s->gb, 3) + 1;
1633         if (num_assets > 1) {
1634             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1635             /* ignore such streams for now */
1636             return;
1637         }
1638
1639         for (i = 0; i < num_audiop; i++)
1640             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1641
1642         for (i = 0; i < num_audiop; i++)
1643             for (j = 0; j <= ss_index; j++)
1644                 if (active_ss_mask[i] & (1 << j))
1645                     skip_bits(&s->gb, 8); // active asset mask
1646
1647         s->mix_metadata = get_bits1(&s->gb);
1648         if (s->mix_metadata) {
1649             int mix_out_mask_size;
1650
1651             skip_bits(&s->gb, 2); // adjustment level
1652             mix_out_mask_size  = (get_bits(&s->gb, 2) + 1) << 2;
1653             s->num_mix_configs =  get_bits(&s->gb, 2) + 1;
1654
1655             for (i = 0; i < s->num_mix_configs; i++) {
1656                 int mix_out_mask        = get_bits(&s->gb, mix_out_mask_size);
1657                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1658             }
1659         }
1660     }
1661
1662     for (i = 0; i < num_assets; i++)
1663         skip_bits_long(&s->gb, 16 + 4 * blownup);  // asset size
1664
1665     for (i = 0; i < num_assets; i++) {
1666         if (dca_exss_parse_asset_header(s))
1667             return;
1668     }
1669
1670     /* not parsed further, we were only interested in the extensions mask
1671      * from the asset header */
1672 }
1673
1674 /**
1675  * Main frame decoding function
1676  * FIXME add arguments
1677  */
1678 static int dca_decode_frame(AVCodecContext *avctx, void *data,
1679                             int *got_frame_ptr, AVPacket *avpkt)
1680 {
1681     const uint8_t *buf = avpkt->data;
1682     int buf_size = avpkt->size;
1683
1684     int lfe_samples;
1685     int num_core_channels = 0;
1686     int i, ret;
1687     float   *samples_flt;
1688     int16_t *samples_s16;
1689     DCAContext *s = avctx->priv_data;
1690     int channels;
1691     int core_ss_end;
1692
1693
1694     s->xch_present = 0;
1695
1696     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1697                                                DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1698     if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
1699         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1700         return AVERROR_INVALIDDATA;
1701     }
1702
1703     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1704     if ((ret = dca_parse_frame_header(s)) < 0) {
1705         //seems like the frame is corrupt, try with the next one
1706         return ret;
1707     }
1708     //set AVCodec values with parsed data
1709     avctx->sample_rate = s->sample_rate;
1710     avctx->bit_rate    = s->bit_rate;
1711     avctx->frame_size  = s->sample_blocks * 32;
1712
1713     s->profile = FF_PROFILE_DTS;
1714
1715     for (i = 0; i < (s->sample_blocks / 8); i++) {
1716         if ((ret = dca_decode_block(s, 0, i))) {
1717             av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
1718             return ret;
1719         }
1720     }
1721
1722     /* record number of core channels incase less than max channels are requested */
1723     num_core_channels = s->prim_channels;
1724
1725     if (s->ext_coding)
1726         s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
1727     else
1728         s->core_ext_mask = 0;
1729
1730     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1731
1732     /* only scan for extensions if ext_descr was unknown or indicated a
1733      * supported XCh extension */
1734     if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
1735
1736         /* if ext_descr was unknown, clear s->core_ext_mask so that the
1737          * extensions scan can fill it up */
1738         s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
1739
1740         /* extensions start at 32-bit boundaries into bitstream */
1741         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1742
1743         while (core_ss_end - get_bits_count(&s->gb) >= 32) {
1744             uint32_t bits = get_bits_long(&s->gb, 32);
1745
1746             switch (bits) {
1747             case 0x5a5a5a5a: {
1748                 int ext_amode, xch_fsize;
1749
1750                 s->xch_base_channel = s->prim_channels;
1751
1752                 /* validate sync word using XCHFSIZE field */
1753                 xch_fsize = show_bits(&s->gb, 10);
1754                 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1755                     (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1756                     continue;
1757
1758                 /* skip length-to-end-of-frame field for the moment */
1759                 skip_bits(&s->gb, 10);
1760
1761                 s->core_ext_mask |= DCA_EXT_XCH;
1762
1763                 /* extension amode(number of channels in extension) should be 1 */
1764                 /* AFAIK XCh is not used for more channels */
1765                 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1766                     av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1767                            " supported!\n", ext_amode);
1768                     continue;
1769                 }
1770
1771                 /* much like core primary audio coding header */
1772                 dca_parse_audio_coding_header(s, s->xch_base_channel);
1773
1774                 for (i = 0; i < (s->sample_blocks / 8); i++)
1775                     if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
1776                         av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
1777                         continue;
1778                     }
1779
1780                 s->xch_present = 1;
1781                 break;
1782             }
1783             case 0x47004a03:
1784                 /* XXCh: extended channels */
1785                 /* usually found either in core or HD part in DTS-HD HRA streams,
1786                  * but not in DTS-ES which contains XCh extensions instead */
1787                 s->core_ext_mask |= DCA_EXT_XXCH;
1788                 break;
1789
1790             case 0x1d95f262: {
1791                 int fsize96 = show_bits(&s->gb, 12) + 1;
1792                 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1793                     continue;
1794
1795                 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
1796                        get_bits_count(&s->gb));
1797                 skip_bits(&s->gb, 12);
1798                 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1799                 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1800
1801                 s->core_ext_mask |= DCA_EXT_X96;
1802                 break;
1803             }
1804             }
1805
1806             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1807         }
1808     } else {
1809         /* no supported extensions, skip the rest of the core substream */
1810         skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
1811     }
1812
1813     if (s->core_ext_mask & DCA_EXT_X96)
1814         s->profile = FF_PROFILE_DTS_96_24;
1815     else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
1816         s->profile = FF_PROFILE_DTS_ES;
1817
1818     /* check for ExSS (HD part) */
1819     if (s->dca_buffer_size - s->frame_size > 32 &&
1820         get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1821         dca_exss_parse_header(s);
1822
1823     avctx->profile = s->profile;
1824
1825     channels = s->prim_channels + !!s->lfe;
1826
1827     if (s->amode < 16) {
1828         avctx->channel_layout = dca_core_channel_layout[s->amode];
1829
1830         if (s->xch_present && (!avctx->request_channels ||
1831                                avctx->request_channels > num_core_channels + !!s->lfe)) {
1832             avctx->channel_layout |= AV_CH_BACK_CENTER;
1833             if (s->lfe) {
1834                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1835                 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1836             } else {
1837                 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1838             }
1839         } else {
1840             channels = num_core_channels + !!s->lfe;
1841             s->xch_present = 0; /* disable further xch processing */
1842             if (s->lfe) {
1843                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1844                 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1845             } else
1846                 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1847         }
1848
1849         if (channels > !!s->lfe &&
1850             s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1851             return AVERROR_INVALIDDATA;
1852
1853         if (avctx->request_channels == 2 && s->prim_channels > 2) {
1854             channels = 2;
1855             s->output = DCA_STEREO;
1856             avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1857         }
1858         else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
1859             static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
1860             s->channel_order_tab = dca_channel_order_native;
1861         }
1862     } else {
1863         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
1864         return AVERROR_INVALIDDATA;
1865     }
1866
1867     if (avctx->channels != channels) {
1868         if (avctx->channels)
1869             av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
1870         avctx->channels = channels;
1871     }
1872
1873     /* get output buffer */
1874     s->frame.nb_samples = 256 * (s->sample_blocks / 8);
1875     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1876         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1877         return ret;
1878     }
1879     samples_flt = (float *)   s->frame.data[0];
1880     samples_s16 = (int16_t *) s->frame.data[0];
1881
1882     /* filter to get final output */
1883     for (i = 0; i < (s->sample_blocks / 8); i++) {
1884         dca_filter_channels(s, i);
1885
1886         /* If this was marked as a DTS-ES stream we need to subtract back- */
1887         /* channel from SL & SR to remove matrixed back-channel signal */
1888         if ((s->source_pcm_res & 1) && s->xch_present) {
1889             float *back_chan = s->samples + s->channel_order_tab[s->xch_base_channel]     * 256;
1890             float *lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1891             float *rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1892             s->dsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
1893             s->dsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
1894         }
1895
1896         if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1897             s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
1898                                          channels);
1899             samples_flt += 256 * channels;
1900         } else {
1901             s->fmt_conv.float_to_int16_interleave(samples_s16,
1902                                                   s->samples_chanptr, 256,
1903                                                   channels);
1904             samples_s16 += 256 * channels;
1905         }
1906     }
1907
1908     /* update lfe history */
1909     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1910     for (i = 0; i < 2 * s->lfe * 4; i++)
1911         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1912
1913     *got_frame_ptr    = 1;
1914     *(AVFrame *) data = s->frame;
1915
1916     return buf_size;
1917 }
1918
1919
1920
1921 /**
1922  * DCA initialization
1923  *
1924  * @param avctx     pointer to the AVCodecContext
1925  */
1926
1927 static av_cold int dca_decode_init(AVCodecContext *avctx)
1928 {
1929     DCAContext *s = avctx->priv_data;
1930     int i;
1931
1932     s->avctx = avctx;
1933     dca_init_vlcs();
1934
1935     ff_dsputil_init(&s->dsp, avctx);
1936     ff_mdct_init(&s->imdct, 6, 1, 1.0);
1937     ff_synth_filter_init(&s->synth);
1938     ff_dcadsp_init(&s->dcadsp);
1939     ff_fmt_convert_init(&s->fmt_conv, avctx);
1940
1941     for (i = 0; i < DCA_PRIM_CHANNELS_MAX + 1; i++)
1942         s->samples_chanptr[i] = s->samples + i * 256;
1943
1944     if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
1945         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1946         s->scale_bias     = 1.0 / 32768.0;
1947     } else {
1948         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1949         s->scale_bias     = 1.0;
1950     }
1951
1952     /* allow downmixing to stereo */
1953     if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1954         avctx->request_channels == 2) {
1955         avctx->channels = avctx->request_channels;
1956     }
1957
1958     avcodec_get_frame_defaults(&s->frame);
1959     avctx->coded_frame = &s->frame;
1960
1961     return 0;
1962 }
1963
1964 static av_cold int dca_decode_end(AVCodecContext *avctx)
1965 {
1966     DCAContext *s = avctx->priv_data;
1967     ff_mdct_end(&s->imdct);
1968     return 0;
1969 }
1970
1971 static const AVProfile profiles[] = {
1972     { FF_PROFILE_DTS,        "DTS"        },
1973     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
1974     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
1975     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1976     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
1977     { FF_PROFILE_UNKNOWN },
1978 };
1979
1980 AVCodec ff_dca_decoder = {
1981     .name            = "dca",
1982     .type            = AVMEDIA_TYPE_AUDIO,
1983     .id              = CODEC_ID_DTS,
1984     .priv_data_size  = sizeof(DCAContext),
1985     .init            = dca_decode_init,
1986     .decode          = dca_decode_frame,
1987     .close           = dca_decode_end,
1988     .long_name       = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1989     .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
1990     .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
1991                                                        AV_SAMPLE_FMT_S16,
1992                                                        AV_SAMPLE_FMT_NONE },
1993     .profiles        = NULL_IF_CONFIG_SMALL(profiles),
1994 };