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