git.sesse.net Git - ffmpeg/blob - libavcodec/dcadec.c

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