1/* 2 * DCA compatible decoder 3 * Copyright (C) 2004 Gildas Bazin 4 * Copyright (C) 2004 Benjamin Zores 5 * Copyright (C) 2006 Benjamin Larsson 6 * Copyright (C) 2007 Konstantin Shishkov 7 * 8 * This file is part of FFmpeg. 9 * 10 * FFmpeg is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU Lesser General Public 12 * License as published by the Free Software Foundation; either 13 * version 2.1 of the License, or (at your option) any later version. 14 * 15 * FFmpeg is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * Lesser General Public License for more details. 19 * 20 * You should have received a copy of the GNU Lesser General Public 21 * License along with FFmpeg; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 23 */ 24 25#include <math.h> 26#include <stddef.h> 27#include <stdio.h> 28 29#include "libavutil/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 "dcadata.h" 41#include "dcahuff.h" 42#include "dca.h" 43#include "mathops.h" 44#include "synth_filter.h" 45#include "dcadsp.h" 46#include "fmtconvert.h" 47#include "internal.h" 48 49#if ARCH_ARM 50# include "arm/dca.h" 51#endif 52 53//#define TRACE 54 55#define DCA_PRIM_CHANNELS_MAX (7) 56#define DCA_ABITS_MAX (32) /* Should be 28 */ 57#define DCA_SUBSUBFRAMES_MAX (4) 58#define DCA_SUBFRAMES_MAX (16) 59#define DCA_BLOCKS_MAX (16) 60#define DCA_LFE_MAX (3) 61#define DCA_CHSETS_MAX (4) 62#define DCA_CHSET_CHANS_MAX (8) 63 64enum DCAMode { 65 DCA_MONO = 0, 66 DCA_CHANNEL, 67 DCA_STEREO, 68 DCA_STEREO_SUMDIFF, 69 DCA_STEREO_TOTAL, 70 DCA_3F, 71 DCA_2F1R, 72 DCA_3F1R, 73 DCA_2F2R, 74 DCA_3F2R, 75 DCA_4F2R 76}; 77 78/* these are unconfirmed but should be mostly correct */ 79enum DCAExSSSpeakerMask { 80 DCA_EXSS_FRONT_CENTER = 0x0001, 81 DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002, 82 DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004, 83 DCA_EXSS_LFE = 0x0008, 84 DCA_EXSS_REAR_CENTER = 0x0010, 85 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020, 86 DCA_EXSS_REAR_LEFT_RIGHT = 0x0040, 87 DCA_EXSS_FRONT_HIGH_CENTER = 0x0080, 88 DCA_EXSS_OVERHEAD = 0x0100, 89 DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200, 90 DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400, 91 DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800, 92 DCA_EXSS_LFE2 = 0x1000, 93 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000, 94 DCA_EXSS_REAR_HIGH_CENTER = 0x4000, 95 DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000, 96}; 97 98enum DCAXxchSpeakerMask { 99 DCA_XXCH_FRONT_CENTER = 0x0000001, 100 DCA_XXCH_FRONT_LEFT = 0x0000002, 101 DCA_XXCH_FRONT_RIGHT = 0x0000004, 102 DCA_XXCH_SIDE_REAR_LEFT = 0x0000008, 103 DCA_XXCH_SIDE_REAR_RIGHT = 0x0000010, 104 DCA_XXCH_LFE1 = 0x0000020, 105 DCA_XXCH_REAR_CENTER = 0x0000040, 106 DCA_XXCH_SURROUND_REAR_LEFT = 0x0000080, 107 DCA_XXCH_SURROUND_REAR_RIGHT = 0x0000100, 108 DCA_XXCH_SIDE_SURROUND_LEFT = 0x0000200, 109 DCA_XXCH_SIDE_SURROUND_RIGHT = 0x0000400, 110 DCA_XXCH_FRONT_CENTER_LEFT = 0x0000800, 111 DCA_XXCH_FRONT_CENTER_RIGHT = 0x0001000, 112 DCA_XXCH_FRONT_HIGH_LEFT = 0x0002000, 113 DCA_XXCH_FRONT_HIGH_CENTER = 0x0004000, 114 DCA_XXCH_FRONT_HIGH_RIGHT = 0x0008000, 115 DCA_XXCH_LFE2 = 0x0010000, 116 DCA_XXCH_SIDE_FRONT_LEFT = 0x0020000, 117 DCA_XXCH_SIDE_FRONT_RIGHT = 0x0040000, 118 DCA_XXCH_OVERHEAD = 0x0080000, 119 DCA_XXCH_SIDE_HIGH_LEFT = 0x0100000, 120 DCA_XXCH_SIDE_HIGH_RIGHT = 0x0200000, 121 DCA_XXCH_REAR_HIGH_CENTER = 0x0400000, 122 DCA_XXCH_REAR_HIGH_LEFT = 0x0800000, 123 DCA_XXCH_REAR_HIGH_RIGHT = 0x1000000, 124 DCA_XXCH_REAR_LOW_CENTER = 0x2000000, 125 DCA_XXCH_REAR_LOW_LEFT = 0x4000000, 126 DCA_XXCH_REAR_LOW_RIGHT = 0x8000000, 127}; 128 129static const uint32_t map_xxch_to_native[28] = { 130 AV_CH_FRONT_CENTER, 131 AV_CH_FRONT_LEFT, 132 AV_CH_FRONT_RIGHT, 133 AV_CH_SIDE_LEFT, 134 AV_CH_SIDE_RIGHT, 135 AV_CH_LOW_FREQUENCY, 136 AV_CH_BACK_CENTER, 137 AV_CH_BACK_LEFT, 138 AV_CH_BACK_RIGHT, 139 AV_CH_SIDE_LEFT, /* side surround left -- dup sur side L */ 140 AV_CH_SIDE_RIGHT, /* side surround right -- dup sur side R */ 141 AV_CH_FRONT_LEFT_OF_CENTER, 142 AV_CH_FRONT_RIGHT_OF_CENTER, 143 AV_CH_TOP_FRONT_LEFT, 144 AV_CH_TOP_FRONT_CENTER, 145 AV_CH_TOP_FRONT_RIGHT, 146 AV_CH_LOW_FREQUENCY, /* lfe2 -- duplicate lfe1 position */ 147 AV_CH_FRONT_LEFT_OF_CENTER, /* side front left -- dup front cntr L */ 148 AV_CH_FRONT_RIGHT_OF_CENTER,/* side front right -- dup front cntr R */ 149 AV_CH_TOP_CENTER, /* overhead */ 150 AV_CH_TOP_FRONT_LEFT, /* side high left -- dup */ 151 AV_CH_TOP_FRONT_RIGHT, /* side high right -- dup */ 152 AV_CH_TOP_BACK_CENTER, 153 AV_CH_TOP_BACK_LEFT, 154 AV_CH_TOP_BACK_RIGHT, 155 AV_CH_BACK_CENTER, /* rear low center -- dup */ 156 AV_CH_BACK_LEFT, /* rear low left -- dup */ 157 AV_CH_BACK_RIGHT /* read low right -- dup */ 158}; 159 160enum DCAExtensionMask { 161 DCA_EXT_CORE = 0x001, ///< core in core substream 162 DCA_EXT_XXCH = 0x002, ///< XXCh channels extension in core substream 163 DCA_EXT_X96 = 0x004, ///< 96/24 extension in core substream 164 DCA_EXT_XCH = 0x008, ///< XCh channel extension in core substream 165 DCA_EXT_EXSS_CORE = 0x010, ///< core in ExSS (extension substream) 166 DCA_EXT_EXSS_XBR = 0x020, ///< extended bitrate extension in ExSS 167 DCA_EXT_EXSS_XXCH = 0x040, ///< XXCh channels extension in ExSS 168 DCA_EXT_EXSS_X96 = 0x080, ///< 96/24 extension in ExSS 169 DCA_EXT_EXSS_LBR = 0x100, ///< low bitrate component in ExSS 170 DCA_EXT_EXSS_XLL = 0x200, ///< lossless extension in ExSS 171}; 172 173/* -1 are reserved or unknown */ 174static const int dca_ext_audio_descr_mask[] = { 175 DCA_EXT_XCH, 176 -1, 177 DCA_EXT_X96, 178 DCA_EXT_XCH | DCA_EXT_X96, 179 -1, 180 -1, 181 DCA_EXT_XXCH, 182 -1, 183}; 184 185/* extensions that reside in core substream */ 186#define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96) 187 188/* Tables for mapping dts channel configurations to libavcodec multichannel api. 189 * Some compromises have been made for special configurations. Most configurations 190 * are never used so complete accuracy is not needed. 191 * 192 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead. 193 * S -> side, when both rear and back are configured move one of them to the side channel 194 * OV -> center back 195 * All 2 channel configurations -> AV_CH_LAYOUT_STEREO 196 */ 197static const uint64_t dca_core_channel_layout[] = { 198 AV_CH_FRONT_CENTER, ///< 1, A 199 AV_CH_LAYOUT_STEREO, ///< 2, A + B (dual mono) 200 AV_CH_LAYOUT_STEREO, ///< 2, L + R (stereo) 201 AV_CH_LAYOUT_STEREO, ///< 2, (L + R) + (L - R) (sum-difference) 202 AV_CH_LAYOUT_STEREO, ///< 2, LT + RT (left and right total) 203 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER, ///< 3, C + L + R 204 AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER, ///< 3, L + R + S 205 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 4, C + L + R + S 206 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 4, L + R + SL + SR 207 208 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT | 209 AV_CH_SIDE_RIGHT, ///< 5, C + L + R + SL + SR 210 211 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT | 212 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR 213 214 AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT | 215 AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 6, C + L + R + LR + RR + OV 216 217 AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER | 218 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER | 219 AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 6, CF + CR + LF + RF + LR + RR 220 221 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER | 222 AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO | 223 AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR 224 225 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER | 226 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT | 227 AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2 228 229 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER | 230 AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO | 231 AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT, ///< 8, CL + C + CR + L + R + SL + S + SR 232}; 233 234static const int8_t dca_lfe_index[] = { 235 1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3 236}; 237 238static const int8_t dca_channel_reorder_lfe[][9] = { 239 { 0, -1, -1, -1, -1, -1, -1, -1, -1}, 240 { 0, 1, -1, -1, -1, -1, -1, -1, -1}, 241 { 0, 1, -1, -1, -1, -1, -1, -1, -1}, 242 { 0, 1, -1, -1, -1, -1, -1, -1, -1}, 243 { 0, 1, -1, -1, -1, -1, -1, -1, -1}, 244 { 2, 0, 1, -1, -1, -1, -1, -1, -1}, 245 { 0, 1, 3, -1, -1, -1, -1, -1, -1}, 246 { 2, 0, 1, 4, -1, -1, -1, -1, -1}, 247 { 0, 1, 3, 4, -1, -1, -1, -1, -1}, 248 { 2, 0, 1, 4, 5, -1, -1, -1, -1}, 249 { 3, 4, 0, 1, 5, 6, -1, -1, -1}, 250 { 2, 0, 1, 4, 5, 6, -1, -1, -1}, 251 { 0, 6, 4, 5, 2, 3, -1, -1, -1}, 252 { 4, 2, 5, 0, 1, 6, 7, -1, -1}, 253 { 5, 6, 0, 1, 7, 3, 8, 4, -1}, 254 { 4, 2, 5, 0, 1, 6, 8, 7, -1}, 255}; 256 257static const int8_t dca_channel_reorder_lfe_xch[][9] = { 258 { 0, 2, -1, -1, -1, -1, -1, -1, -1}, 259 { 0, 1, 3, -1, -1, -1, -1, -1, -1}, 260 { 0, 1, 3, -1, -1, -1, -1, -1, -1}, 261 { 0, 1, 3, -1, -1, -1, -1, -1, -1}, 262 { 0, 1, 3, -1, -1, -1, -1, -1, -1}, 263 { 2, 0, 1, 4, -1, -1, -1, -1, -1}, 264 { 0, 1, 3, 4, -1, -1, -1, -1, -1}, 265 { 2, 0, 1, 4, 5, -1, -1, -1, -1}, 266 { 0, 1, 4, 5, 3, -1, -1, -1, -1}, 267 { 2, 0, 1, 5, 6, 4, -1, -1, -1}, 268 { 3, 4, 0, 1, 6, 7, 5, -1, -1}, 269 { 2, 0, 1, 4, 5, 6, 7, -1, -1}, 270 { 0, 6, 4, 5, 2, 3, 7, -1, -1}, 271 { 4, 2, 5, 0, 1, 7, 8, 6, -1}, 272 { 5, 6, 0, 1, 8, 3, 9, 4, 7}, 273 { 4, 2, 5, 0, 1, 6, 9, 8, 7}, 274}; 275 276static const int8_t dca_channel_reorder_nolfe[][9] = { 277 { 0, -1, -1, -1, -1, -1, -1, -1, -1}, 278 { 0, 1, -1, -1, -1, -1, -1, -1, -1}, 279 { 0, 1, -1, -1, -1, -1, -1, -1, -1}, 280 { 0, 1, -1, -1, -1, -1, -1, -1, -1}, 281 { 0, 1, -1, -1, -1, -1, -1, -1, -1}, 282 { 2, 0, 1, -1, -1, -1, -1, -1, -1}, 283 { 0, 1, 2, -1, -1, -1, -1, -1, -1}, 284 { 2, 0, 1, 3, -1, -1, -1, -1, -1}, 285 { 0, 1, 2, 3, -1, -1, -1, -1, -1}, 286 { 2, 0, 1, 3, 4, -1, -1, -1, -1}, 287 { 2, 3, 0, 1, 4, 5, -1, -1, -1}, 288 { 2, 0, 1, 3, 4, 5, -1, -1, -1}, 289 { 0, 5, 3, 4, 1, 2, -1, -1, -1}, 290 { 3, 2, 4, 0, 1, 5, 6, -1, -1}, 291 { 4, 5, 0, 1, 6, 2, 7, 3, -1}, 292 { 3, 2, 4, 0, 1, 5, 7, 6, -1}, 293}; 294 295static const int8_t dca_channel_reorder_nolfe_xch[][9] = { 296 { 0, 1, -1, -1, -1, -1, -1, -1, -1}, 297 { 0, 1, 2, -1, -1, -1, -1, -1, -1}, 298 { 0, 1, 2, -1, -1, -1, -1, -1, -1}, 299 { 0, 1, 2, -1, -1, -1, -1, -1, -1}, 300 { 0, 1, 2, -1, -1, -1, -1, -1, -1}, 301 { 2, 0, 1, 3, -1, -1, -1, -1, -1}, 302 { 0, 1, 2, 3, -1, -1, -1, -1, -1}, 303 { 2, 0, 1, 3, 4, -1, -1, -1, -1}, 304 { 0, 1, 3, 4, 2, -1, -1, -1, -1}, 305 { 2, 0, 1, 4, 5, 3, -1, -1, -1}, 306 { 2, 3, 0, 1, 5, 6, 4, -1, -1}, 307 { 2, 0, 1, 3, 4, 5, 6, -1, -1}, 308 { 0, 5, 3, 4, 1, 2, 6, -1, -1}, 309 { 3, 2, 4, 0, 1, 6, 7, 5, -1}, 310 { 4, 5, 0, 1, 7, 2, 8, 3, 6}, 311 { 3, 2, 4, 0, 1, 5, 8, 7, 6}, 312}; 313 314#define DCA_DOLBY 101 /* FIXME */ 315 316#define DCA_CHANNEL_BITS 6 317#define DCA_CHANNEL_MASK 0x3F 318 319#define DCA_LFE 0x80 320 321#define HEADER_SIZE 14 322 323#define DCA_MAX_FRAME_SIZE 16384 324#define DCA_MAX_EXSS_HEADER_SIZE 4096 325 326#define DCA_BUFFER_PADDING_SIZE 1024 327 328#define DCA_NSYNCAUX 0x9A1105A0 329 330/** Bit allocation */ 331typedef struct { 332 int offset; ///< code values offset 333 int maxbits[8]; ///< max bits in VLC 334 int wrap; ///< wrap for get_vlc2() 335 VLC vlc[8]; ///< actual codes 336} BitAlloc; 337 338static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select 339static BitAlloc dca_tmode; ///< transition mode VLCs 340static BitAlloc dca_scalefactor; ///< scalefactor VLCs 341static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs 342 343static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, 344 int idx) 345{ 346 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + 347 ba->offset; 348} 349 350typedef struct { 351 const AVClass *class; ///< class for AVOptions 352 AVCodecContext *avctx; 353 /* Frame header */ 354 int frame_type; ///< type of the current frame 355 int samples_deficit; ///< deficit sample count 356 int crc_present; ///< crc is present in the bitstream 357 int sample_blocks; ///< number of PCM sample blocks 358 int frame_size; ///< primary frame byte size 359 int amode; ///< audio channels arrangement 360 int sample_rate; ///< audio sampling rate 361 int bit_rate; ///< transmission bit rate 362 int bit_rate_index; ///< transmission bit rate index 363 364 int dynrange; ///< embedded dynamic range flag 365 int timestamp; ///< embedded time stamp flag 366 int aux_data; ///< auxiliary data flag 367 int hdcd; ///< source material is mastered in HDCD 368 int ext_descr; ///< extension audio descriptor flag 369 int ext_coding; ///< extended coding flag 370 int aspf; ///< audio sync word insertion flag 371 int lfe; ///< low frequency effects flag 372 int predictor_history; ///< predictor history flag 373 int header_crc; ///< header crc check bytes 374 int multirate_inter; ///< multirate interpolator switch 375 int version; ///< encoder software revision 376 int copy_history; ///< copy history 377 int source_pcm_res; ///< source pcm resolution 378 int front_sum; ///< front sum/difference flag 379 int surround_sum; ///< surround sum/difference flag 380 int dialog_norm; ///< dialog normalisation parameter 381 382 /* Primary audio coding header */ 383 int subframes; ///< number of subframes 384 int total_channels; ///< number of channels including extensions 385 int prim_channels; ///< number of primary audio channels 386 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count 387 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband 388 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index 389 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book 390 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book 391 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select 392 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select 393 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment 394 395 /* Primary audio coding side information */ 396 int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes 397 int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count 398 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not) 399 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs 400 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index 401 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients) 402 int32_t scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];///< scale factors (2 if transient) 403 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook 404 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors 405 float downmix_coef[DCA_PRIM_CHANNELS_MAX + 1][2]; ///< stereo downmix coefficients 406 int dynrange_coef; ///< dynamic range coefficient 407 408 /* Core substream's embedded downmix coefficients (cf. ETSI TS 102 114 V1.4.1) 409 * Input: primary audio channels (incl. LFE if present) 410 * Output: downmix audio channels (up to 4, no LFE) */ 411 uint8_t core_downmix; ///< embedded downmix coefficients available 412 uint8_t core_downmix_amode; ///< audio channel arrangement of embedded downmix 413 uint16_t core_downmix_codes[DCA_PRIM_CHANNELS_MAX + 1][4]; ///< embedded downmix coefficients (9-bit codes) 414 415 int32_t high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands 416 417 float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data 418 int lfe_scale_factor; 419 420 /* Subband samples history (for ADPCM) */ 421 DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4]; 422 DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512]; 423 DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32]; 424 int hist_index[DCA_PRIM_CHANNELS_MAX]; 425 DECLARE_ALIGNED(32, float, raXin)[32]; 426 427 int output; ///< type of output 428 429 DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8]; 430 float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1]; 431 float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1]; 432 uint8_t *extra_channels_buffer; 433 unsigned int extra_channels_buffer_size; 434 435 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE]; 436 int dca_buffer_size; ///< how much data is in the dca_buffer 437 438 const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe 439 GetBitContext gb; 440 /* Current position in DCA frame */ 441 int current_subframe; 442 int current_subsubframe; 443 444 int core_ext_mask; ///< present extensions in the core substream 445 446 /* XCh extension information */ 447 int xch_present; ///< XCh extension present and valid 448 int xch_base_channel; ///< index of first (only) channel containing XCH data 449 int xch_disable; ///< whether the XCh extension should be decoded or not 450 451 /* XXCH extension information */ 452 int xxch_chset; 453 int xxch_nbits_spk_mask; 454 uint32_t xxch_core_spkmask; 455 uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */ 456 int xxch_chset_nch[4]; 457 float xxch_dmix_sf[DCA_CHSETS_MAX]; 458 459 uint32_t xxch_dmix_embedded; /* lower layer has mix pre-embedded, per chset */ 460 float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */ 461 462 int8_t xxch_order_tab[32]; 463 int8_t lfe_index; 464 465 /* ExSS header parser */ 466 int static_fields; ///< static fields present 467 int mix_metadata; ///< mixing metadata present 468 int num_mix_configs; ///< number of mix out configurations 469 int mix_config_num_ch[4]; ///< number of channels in each mix out configuration 470 471 int profile; 472 473 int debug_flag; ///< used for suppressing repeated error messages output 474 AVFloatDSPContext fdsp; 475 FFTContext imdct; 476 SynthFilterContext synth; 477 DCADSPContext dcadsp; 478 FmtConvertContext fmt_conv; 479} DCAContext; 480 481static float dca_dmix_code(unsigned code); 482 483static const uint16_t dca_vlc_offs[] = { 484 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364, 485 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508, 486 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564, 487 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240, 488 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264, 489 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622, 490}; 491 492static av_cold void dca_init_vlcs(void) 493{ 494 static int vlcs_initialized = 0; 495 int i, j, c = 14; 496 static VLC_TYPE dca_table[23622][2]; 497 498 if (vlcs_initialized) 499 return; 500 501 dca_bitalloc_index.offset = 1; 502 dca_bitalloc_index.wrap = 2; 503 for (i = 0; i < 5; i++) { 504 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]]; 505 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i]; 506 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12, 507 bitalloc_12_bits[i], 1, 1, 508 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); 509 } 510 dca_scalefactor.offset = -64; 511 dca_scalefactor.wrap = 2; 512 for (i = 0; i < 5; i++) { 513 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]]; 514 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5]; 515 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129, 516 scales_bits[i], 1, 1, 517 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); 518 } 519 dca_tmode.offset = 0; 520 dca_tmode.wrap = 1; 521 for (i = 0; i < 4; i++) { 522 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]]; 523 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10]; 524 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4, 525 tmode_bits[i], 1, 1, 526 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); 527 } 528 529 for (i = 0; i < 10; i++) 530 for (j = 0; j < 7; j++) { 531 if (!bitalloc_codes[i][j]) 532 break; 533 dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i]; 534 dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4); 535 dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[dca_vlc_offs[c]]; 536 dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c]; 537 538 init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j], 539 bitalloc_sizes[i], 540 bitalloc_bits[i][j], 1, 1, 541 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC); 542 c++; 543 } 544 vlcs_initialized = 1; 545} 546 547static inline void get_array(GetBitContext *gb, int *dst, int len, int bits) 548{ 549 while (len--) 550 *dst++ = get_bits(gb, bits); 551} 552 553static inline int dca_xxch2index(DCAContext *s, int xxch_ch) 554{ 555 int i, base, mask; 556 557 /* locate channel set containing the channel */ 558 for (i = -1, base = 0, mask = (s->xxch_core_spkmask & ~DCA_XXCH_LFE1); 559 i <= s->xxch_chset && !(mask & xxch_ch); mask = s->xxch_spk_masks[++i]) 560 base += av_popcount(mask); 561 562 return base + av_popcount(mask & (xxch_ch - 1)); 563} 564 565static int dca_parse_audio_coding_header(DCAContext *s, int base_channel, 566 int xxch) 567{ 568 int i, j; 569 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 }; 570 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 }; 571 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 }; 572 int hdr_pos = 0, hdr_size = 0; 573 float scale_factor; 574 int this_chans, acc_mask; 575 int embedded_downmix; 576 int nchans, mask[8]; 577 int coeff, ichan; 578 579 /* xxch has arbitrary sized audio coding headers */ 580 if (xxch) { 581 hdr_pos = get_bits_count(&s->gb); 582 hdr_size = get_bits(&s->gb, 7) + 1; 583 } 584 585 nchans = get_bits(&s->gb, 3) + 1; 586 s->total_channels = nchans + base_channel; 587 s->prim_channels = s->total_channels; 588 589 /* obtain speaker layout mask & downmix coefficients for XXCH */ 590 if (xxch) { 591 acc_mask = s->xxch_core_spkmask; 592 593 this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6; 594 s->xxch_spk_masks[s->xxch_chset] = this_chans; 595 s->xxch_chset_nch[s->xxch_chset] = nchans; 596 597 for (i = 0; i <= s->xxch_chset; i++) 598 acc_mask |= s->xxch_spk_masks[i]; 599 600 /* check for downmixing information */ 601 if (get_bits1(&s->gb)) { 602 embedded_downmix = get_bits1(&s->gb); 603 coeff = get_bits(&s->gb, 6); 604 605 if (coeff<1 || coeff>61) { 606 av_log(s->avctx, AV_LOG_ERROR, "6bit coeff %d is out of range\n", coeff); 607 return AVERROR_INVALIDDATA; 608 } 609 610 scale_factor = -1.0f / dca_dmix_code((coeff<<2)-3); 611 612 s->xxch_dmix_sf[s->xxch_chset] = scale_factor; 613 614 for (i = base_channel; i < s->prim_channels; i++) { 615 mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask); 616 } 617 618 for (j = base_channel; j < s->prim_channels; j++) { 619 memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0])); 620 s->xxch_dmix_embedded |= (embedded_downmix << j); 621 for (i = 0; i < s->xxch_nbits_spk_mask; i++) { 622 if (mask[j] & (1 << i)) { 623 if ((1 << i) == DCA_XXCH_LFE1) { 624 av_log(s->avctx, AV_LOG_WARNING, 625 "DCA-XXCH: dmix to LFE1 not supported.\n"); 626 continue; 627 } 628 629 coeff = get_bits(&s->gb, 7); 630 ichan = dca_xxch2index(s, 1 << i); 631 if ((coeff&63)<1 || (coeff&63)>61) { 632 av_log(s->avctx, AV_LOG_ERROR, "7bit coeff %d is out of range\n", coeff); 633 return AVERROR_INVALIDDATA; 634 } 635 s->xxch_dmix_coeff[j][ichan] = dca_dmix_code((coeff<<2)-3); 636 } 637 } 638 } 639 } 640 } 641 642 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX) 643 s->prim_channels = DCA_PRIM_CHANNELS_MAX; 644 645 646 for (i = base_channel; i < s->prim_channels; i++) { 647 s->subband_activity[i] = get_bits(&s->gb, 5) + 2; 648 if (s->subband_activity[i] > DCA_SUBBANDS) 649 s->subband_activity[i] = DCA_SUBBANDS; 650 } 651 for (i = base_channel; i < s->prim_channels; i++) { 652 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1; 653 if (s->vq_start_subband[i] > DCA_SUBBANDS) 654 s->vq_start_subband[i] = DCA_SUBBANDS; 655 } 656 get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3); 657 get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2); 658 get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3); 659 get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3); 660 661 /* Get codebooks quantization indexes */ 662 if (!base_channel) 663 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman)); 664 for (j = 1; j < 11; j++) 665 for (i = base_channel; i < s->prim_channels; i++) 666 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]); 667 668 /* Get scale factor adjustment */ 669 for (j = 0; j < 11; j++) 670 for (i = base_channel; i < s->prim_channels; i++) 671 s->scalefactor_adj[i][j] = 1; 672 673 for (j = 1; j < 11; j++) 674 for (i = base_channel; i < s->prim_channels; i++) 675 if (s->quant_index_huffman[i][j] < thr[j]) 676 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)]; 677 678 if (!xxch) { 679 if (s->crc_present) { 680 /* Audio header CRC check */ 681 get_bits(&s->gb, 16); 682 } 683 } else { 684 /* Skip to the end of the header, also ignore CRC if present */ 685 i = get_bits_count(&s->gb); 686 if (hdr_pos + 8 * hdr_size > i) 687 skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i); 688 } 689 690 s->current_subframe = 0; 691 s->current_subsubframe = 0; 692 693#ifdef TRACE 694 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes); 695 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels); 696 for (i = base_channel; i < s->prim_channels; i++) { 697 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", 698 s->subband_activity[i]); 699 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", 700 s->vq_start_subband[i]); 701 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", 702 s->joint_intensity[i]); 703 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", 704 s->transient_huffman[i]); 705 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", 706 s->scalefactor_huffman[i]); 707 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", 708 s->bitalloc_huffman[i]); 709 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:"); 710 for (j = 0; j < 11; j++) 711 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]); 712 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 713 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:"); 714 for (j = 0; j < 11; j++) 715 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]); 716 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 717 } 718#endif 719 720 return 0; 721} 722 723static int dca_parse_frame_header(DCAContext *s) 724{ 725 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8); 726 727 /* Sync code */ 728 skip_bits_long(&s->gb, 32); 729 730 /* Frame header */ 731 s->frame_type = get_bits(&s->gb, 1); 732 s->samples_deficit = get_bits(&s->gb, 5) + 1; 733 s->crc_present = get_bits(&s->gb, 1); 734 s->sample_blocks = get_bits(&s->gb, 7) + 1; 735 s->frame_size = get_bits(&s->gb, 14) + 1; 736 if (s->frame_size < 95) 737 return AVERROR_INVALIDDATA; 738 s->amode = get_bits(&s->gb, 6); 739 s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)]; 740 if (!s->sample_rate) 741 return AVERROR_INVALIDDATA; 742 s->bit_rate_index = get_bits(&s->gb, 5); 743 s->bit_rate = dca_bit_rates[s->bit_rate_index]; 744 if (!s->bit_rate) 745 return AVERROR_INVALIDDATA; 746 747 skip_bits1(&s->gb); // always 0 (reserved, cf. ETSI TS 102 114 V1.4.1) 748 s->dynrange = get_bits(&s->gb, 1); 749 s->timestamp = get_bits(&s->gb, 1); 750 s->aux_data = get_bits(&s->gb, 1); 751 s->hdcd = get_bits(&s->gb, 1); 752 s->ext_descr = get_bits(&s->gb, 3); 753 s->ext_coding = get_bits(&s->gb, 1); 754 s->aspf = get_bits(&s->gb, 1); 755 s->lfe = get_bits(&s->gb, 2); 756 s->predictor_history = get_bits(&s->gb, 1); 757 758 if (s->lfe > 2) { 759 s->lfe = 0; 760 av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe); 761 return AVERROR_INVALIDDATA; 762 } 763 764 /* TODO: check CRC */ 765 if (s->crc_present) 766 s->header_crc = get_bits(&s->gb, 16); 767 768 s->multirate_inter = get_bits(&s->gb, 1); 769 s->version = get_bits(&s->gb, 4); 770 s->copy_history = get_bits(&s->gb, 2); 771 s->source_pcm_res = get_bits(&s->gb, 3); 772 s->front_sum = get_bits(&s->gb, 1); 773 s->surround_sum = get_bits(&s->gb, 1); 774 s->dialog_norm = get_bits(&s->gb, 4); 775 776 /* FIXME: channels mixing levels */ 777 s->output = s->amode; 778 if (s->lfe) 779 s->output |= DCA_LFE; 780 781#ifdef TRACE 782 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type); 783 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit); 784 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present); 785 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n", 786 s->sample_blocks, s->sample_blocks * 32); 787 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size); 788 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n", 789 s->amode, dca_channels[s->amode]); 790 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n", 791 s->sample_rate); 792 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n", 793 s->bit_rate); 794 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange); 795 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp); 796 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data); 797 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd); 798 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr); 799 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding); 800 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf); 801 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe); 802 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n", 803 s->predictor_history); 804 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc); 805 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n", 806 s->multirate_inter); 807 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version); 808 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history); 809 av_log(s->avctx, AV_LOG_DEBUG, 810 "source pcm resolution: %i (%i bits/sample)\n", 811 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]); 812 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum); 813 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum); 814 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm); 815 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 816#endif 817 818 /* Primary audio coding header */ 819 s->subframes = get_bits(&s->gb, 4) + 1; 820 821 return dca_parse_audio_coding_header(s, 0, 0); 822} 823 824 825static inline int get_scale(GetBitContext *gb, int level, int value, int log2range) 826{ 827 if (level < 5) { 828 /* huffman encoded */ 829 value += get_bitalloc(gb, &dca_scalefactor, level); 830 value = av_clip(value, 0, (1 << log2range) - 1); 831 } else if (level < 8) { 832 if (level + 1 > log2range) { 833 skip_bits(gb, level + 1 - log2range); 834 value = get_bits(gb, log2range); 835 } else { 836 value = get_bits(gb, level + 1); 837 } 838 } 839 return value; 840} 841 842static int dca_subframe_header(DCAContext *s, int base_channel, int block_index) 843{ 844 /* Primary audio coding side information */ 845 int j, k; 846 847 if (get_bits_left(&s->gb) < 0) 848 return AVERROR_INVALIDDATA; 849 850 if (!base_channel) { 851 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1; 852 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3); 853 } 854 855 for (j = base_channel; j < s->prim_channels; j++) { 856 for (k = 0; k < s->subband_activity[j]; k++) 857 s->prediction_mode[j][k] = get_bits(&s->gb, 1); 858 } 859 860 /* Get prediction codebook */ 861 for (j = base_channel; j < s->prim_channels; j++) { 862 for (k = 0; k < s->subband_activity[j]; k++) { 863 if (s->prediction_mode[j][k] > 0) { 864 /* (Prediction coefficient VQ address) */ 865 s->prediction_vq[j][k] = get_bits(&s->gb, 12); 866 } 867 } 868 } 869 870 /* Bit allocation index */ 871 for (j = base_channel; j < s->prim_channels; j++) { 872 for (k = 0; k < s->vq_start_subband[j]; k++) { 873 if (s->bitalloc_huffman[j] == 6) 874 s->bitalloc[j][k] = get_bits(&s->gb, 5); 875 else if (s->bitalloc_huffman[j] == 5) 876 s->bitalloc[j][k] = get_bits(&s->gb, 4); 877 else if (s->bitalloc_huffman[j] == 7) { 878 av_log(s->avctx, AV_LOG_ERROR, 879 "Invalid bit allocation index\n"); 880 return AVERROR_INVALIDDATA; 881 } else { 882 s->bitalloc[j][k] = 883 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]); 884 } 885 886 if (s->bitalloc[j][k] > 26) { 887 av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n", 888 j, k, s->bitalloc[j][k]); 889 return AVERROR_INVALIDDATA; 890 } 891 } 892 } 893 894 /* Transition mode */ 895 for (j = base_channel; j < s->prim_channels; j++) { 896 for (k = 0; k < s->subband_activity[j]; k++) { 897 s->transition_mode[j][k] = 0; 898 if (s->subsubframes[s->current_subframe] > 1 && 899 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) { 900 s->transition_mode[j][k] = 901 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]); 902 } 903 } 904 } 905 906 if (get_bits_left(&s->gb) < 0) 907 return AVERROR_INVALIDDATA; 908 909 for (j = base_channel; j < s->prim_channels; j++) { 910 const uint32_t *scale_table; 911 int scale_sum, log_size; 912 913 memset(s->scale_factor[j], 0, 914 s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2); 915 916 if (s->scalefactor_huffman[j] == 6) { 917 scale_table = scale_factor_quant7; 918 log_size = 7; 919 } else { 920 scale_table = scale_factor_quant6; 921 log_size = 6; 922 } 923 924 /* When huffman coded, only the difference is encoded */ 925 scale_sum = 0; 926 927 for (k = 0; k < s->subband_activity[j]; k++) { 928 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) { 929 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size); 930 s->scale_factor[j][k][0] = scale_table[scale_sum]; 931 } 932 933 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) { 934 /* Get second scale factor */ 935 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size); 936 s->scale_factor[j][k][1] = scale_table[scale_sum]; 937 } 938 } 939 } 940 941 /* Joint subband scale factor codebook select */ 942 for (j = base_channel; j < s->prim_channels; j++) { 943 /* Transmitted only if joint subband coding enabled */ 944 if (s->joint_intensity[j] > 0) 945 s->joint_huff[j] = get_bits(&s->gb, 3); 946 } 947 948 if (get_bits_left(&s->gb) < 0) 949 return AVERROR_INVALIDDATA; 950 951 /* Scale factors for joint subband coding */ 952 for (j = base_channel; j < s->prim_channels; j++) { 953 int source_channel; 954 955 /* Transmitted only if joint subband coding enabled */ 956 if (s->joint_intensity[j] > 0) { 957 int scale = 0; 958 source_channel = s->joint_intensity[j] - 1; 959 960 /* When huffman coded, only the difference is encoded 961 * (is this valid as well for joint scales ???) */ 962 963 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) { 964 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7); 965 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */ 966 } 967 968 if (!(s->debug_flag & 0x02)) { 969 av_log(s->avctx, AV_LOG_DEBUG, 970 "Joint stereo coding not supported\n"); 971 s->debug_flag |= 0x02; 972 } 973 } 974 } 975 976 /* Dynamic range coefficient */ 977 if (!base_channel && s->dynrange) 978 s->dynrange_coef = get_bits(&s->gb, 8); 979 980 /* Side information CRC check word */ 981 if (s->crc_present) { 982 get_bits(&s->gb, 16); 983 } 984 985 /* 986 * Primary audio data arrays 987 */ 988 989 /* VQ encoded high frequency subbands */ 990 for (j = base_channel; j < s->prim_channels; j++) 991 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++) 992 /* 1 vector -> 32 samples */ 993 s->high_freq_vq[j][k] = get_bits(&s->gb, 10); 994 995 /* Low frequency effect data */ 996 if (!base_channel && s->lfe) { 997 int quant7; 998 /* LFE samples */ 999 int lfe_samples = 2 * s->lfe * (4 + block_index); 1000 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]); 1001 float lfe_scale; 1002 1003 for (j = lfe_samples; j < lfe_end_sample; j++) { 1004 /* Signed 8 bits int */ 1005 s->lfe_data[j] = get_sbits(&s->gb, 8); 1006 } 1007 1008 /* Scale factor index */ 1009 quant7 = get_bits(&s->gb, 8); 1010 if (quant7 > 127) { 1011 avpriv_request_sample(s->avctx, "LFEScaleIndex larger than 127"); 1012 return AVERROR_INVALIDDATA; 1013 } 1014 s->lfe_scale_factor = scale_factor_quant7[quant7]; 1015 1016 /* Quantization step size * scale factor */ 1017 lfe_scale = 0.035 * s->lfe_scale_factor; 1018 1019 for (j = lfe_samples; j < lfe_end_sample; j++) 1020 s->lfe_data[j] *= lfe_scale; 1021 } 1022 1023#ifdef TRACE 1024 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", 1025 s->subsubframes[s->current_subframe]); 1026 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n", 1027 s->partial_samples[s->current_subframe]); 1028 1029 for (j = base_channel; j < s->prim_channels; j++) { 1030 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:"); 1031 for (k = 0; k < s->subband_activity[j]; k++) 1032 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]); 1033 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 1034 } 1035 for (j = base_channel; j < s->prim_channels; j++) { 1036 for (k = 0; k < s->subband_activity[j]; k++) 1037 av_log(s->avctx, AV_LOG_DEBUG, 1038 "prediction coefs: %f, %f, %f, %f\n", 1039 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192, 1040 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192, 1041 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192, 1042 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192); 1043 } 1044 for (j = base_channel; j < s->prim_channels; j++) { 1045 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: "); 1046 for (k = 0; k < s->vq_start_subband[j]; k++) 1047 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]); 1048 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 1049 } 1050 for (j = base_channel; j < s->prim_channels; j++) { 1051 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:"); 1052 for (k = 0; k < s->subband_activity[j]; k++) 1053 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]); 1054 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 1055 } 1056 for (j = base_channel; j < s->prim_channels; j++) { 1057 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:"); 1058 for (k = 0; k < s->subband_activity[j]; k++) { 1059 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) 1060 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]); 1061 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) 1062 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]); 1063 } 1064 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 1065 } 1066 for (j = base_channel; j < s->prim_channels; j++) { 1067 if (s->joint_intensity[j] > 0) { 1068 int source_channel = s->joint_intensity[j] - 1; 1069 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n"); 1070 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) 1071 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]); 1072 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 1073 } 1074 } 1075 for (j = base_channel; j < s->prim_channels; j++) 1076 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++) 1077 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]); 1078 if (!base_channel && s->lfe) { 1079 int lfe_samples = 2 * s->lfe * (4 + block_index); 1080 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]); 1081 1082 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n"); 1083 for (j = lfe_samples; j < lfe_end_sample; j++) 1084 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]); 1085 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 1086 } 1087#endif 1088 1089 return 0; 1090} 1091 1092static void qmf_32_subbands(DCAContext *s, int chans, 1093 float samples_in[32][8], float *samples_out, 1094 float scale) 1095{ 1096 const float *prCoeff; 1097 1098 int sb_act = s->subband_activity[chans]; 1099 1100 scale *= sqrt(1 / 8.0); 1101 1102 /* Select filter */ 1103 if (!s->multirate_inter) /* Non-perfect reconstruction */ 1104 prCoeff = fir_32bands_nonperfect; 1105 else /* Perfect reconstruction */ 1106 prCoeff = fir_32bands_perfect; 1107 1108 s->dcadsp.qmf_32_subbands(samples_in, sb_act, &s->synth, &s->imdct, 1109 s->subband_fir_hist[chans], 1110 &s->hist_index[chans], 1111 s->subband_fir_noidea[chans], prCoeff, 1112 samples_out, s->raXin, scale); 1113} 1114 1115static void lfe_interpolation_fir(DCAContext *s, int decimation_select, 1116 int num_deci_sample, float *samples_in, 1117 float *samples_out) 1118{ 1119 /* samples_in: An array holding decimated samples. 1120 * Samples in current subframe starts from samples_in[0], 1121 * while samples_in[-1], samples_in[-2], ..., stores samples 1122 * from last subframe as history. 1123 * 1124 * samples_out: An array holding interpolated samples 1125 */ 1126 1127 int idx; 1128 const float *prCoeff; 1129 int deciindex; 1130 1131 /* Select decimation filter */ 1132 if (decimation_select == 1) { 1133 idx = 1; 1134 prCoeff = lfe_fir_128; 1135 } else { 1136 idx = 0; 1137 prCoeff = lfe_fir_64; 1138 } 1139 /* Interpolation */ 1140 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) { 1141 s->dcadsp.lfe_fir[idx](samples_out, samples_in, prCoeff); 1142 samples_in++; 1143 samples_out += 2 * 32 * (1 + idx); 1144 } 1145} 1146 1147/* downmixing routines */ 1148#define MIX_REAR1(samples, s1, rs, coef) \ 1149 samples[0][i] += samples[s1][i] * coef[rs][0]; \ 1150 samples[1][i] += samples[s1][i] * coef[rs][1]; 1151 1152#define MIX_REAR2(samples, s1, s2, rs, coef) \ 1153 samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \ 1154 samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1]; 1155 1156#define MIX_FRONT3(samples, coef) \ 1157 t = samples[c][i]; \ 1158 u = samples[l][i]; \ 1159 v = samples[r][i]; \ 1160 samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \ 1161 samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1]; 1162 1163#define DOWNMIX_TO_STEREO(op1, op2) \ 1164 for (i = 0; i < 256; i++) { \ 1165 op1 \ 1166 op2 \ 1167 } 1168 1169static void dca_downmix(float **samples, int srcfmt, int lfe_present, 1170 float coef[DCA_PRIM_CHANNELS_MAX + 1][2], 1171 const int8_t *channel_mapping) 1172{ 1173 int c, l, r, sl, sr, s; 1174 int i; 1175 float t, u, v; 1176 1177 switch (srcfmt) { 1178 case DCA_MONO: 1179 case DCA_4F2R: 1180 av_log(NULL, AV_LOG_ERROR, "Not implemented!\n"); 1181 break; 1182 case DCA_CHANNEL: 1183 case DCA_STEREO: 1184 case DCA_STEREO_TOTAL: 1185 case DCA_STEREO_SUMDIFF: 1186 break; 1187 case DCA_3F: 1188 c = channel_mapping[0]; 1189 l = channel_mapping[1]; 1190 r = channel_mapping[2]; 1191 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), ); 1192 break; 1193 case DCA_2F1R: 1194 s = channel_mapping[2]; 1195 DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), ); 1196 break; 1197 case DCA_3F1R: 1198 c = channel_mapping[0]; 1199 l = channel_mapping[1]; 1200 r = channel_mapping[2]; 1201 s = channel_mapping[3]; 1202 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), 1203 MIX_REAR1(samples, s, 3, coef)); 1204 break; 1205 case DCA_2F2R: 1206 sl = channel_mapping[2]; 1207 sr = channel_mapping[3]; 1208 DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), ); 1209 break; 1210 case DCA_3F2R: 1211 c = channel_mapping[0]; 1212 l = channel_mapping[1]; 1213 r = channel_mapping[2]; 1214 sl = channel_mapping[3]; 1215 sr = channel_mapping[4]; 1216 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), 1217 MIX_REAR2(samples, sl, sr, 3, coef)); 1218 break; 1219 } 1220 if (lfe_present) { 1221 int lf_buf = dca_lfe_index[srcfmt]; 1222 int lf_idx = dca_channels [srcfmt]; 1223 for (i = 0; i < 256; i++) { 1224 samples[0][i] += samples[lf_buf][i] * coef[lf_idx][0]; 1225 samples[1][i] += samples[lf_buf][i] * coef[lf_idx][1]; 1226 } 1227 } 1228} 1229 1230 1231#ifndef decode_blockcodes 1232/* Very compact version of the block code decoder that does not use table 1233 * look-up but is slightly slower */ 1234static int decode_blockcode(int code, int levels, int32_t *values) 1235{ 1236 int i; 1237 int offset = (levels - 1) >> 1; 1238 1239 for (i = 0; i < 4; i++) { 1240 int div = FASTDIV(code, levels); 1241 values[i] = code - offset - div * levels; 1242 code = div; 1243 } 1244 1245 return code; 1246} 1247 1248static int decode_blockcodes(int code1, int code2, int levels, int32_t *values) 1249{ 1250 return decode_blockcode(code1, levels, values) | 1251 decode_blockcode(code2, levels, values + 4); 1252} 1253#endif 1254 1255static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 }; 1256static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 }; 1257 1258static int dca_subsubframe(DCAContext *s, int base_channel, int block_index) 1259{ 1260 int k, l; 1261 int subsubframe = s->current_subsubframe; 1262 1263 const float *quant_step_table; 1264 1265 /* FIXME */ 1266 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index]; 1267 LOCAL_ALIGNED_16(int32_t, block, [8 * DCA_SUBBANDS]); 1268 1269 /* 1270 * Audio data 1271 */ 1272 1273 /* Select quantization step size table */ 1274 if (s->bit_rate_index == 0x1f) 1275 quant_step_table = lossless_quant_d; 1276 else 1277 quant_step_table = lossy_quant_d; 1278 1279 for (k = base_channel; k < s->prim_channels; k++) { 1280 float rscale[DCA_SUBBANDS]; 1281 1282 if (get_bits_left(&s->gb) < 0) 1283 return AVERROR_INVALIDDATA; 1284 1285 for (l = 0; l < s->vq_start_subband[k]; l++) { 1286 int m; 1287 1288 /* Select the mid-tread linear quantizer */ 1289 int abits = s->bitalloc[k][l]; 1290 1291 float quant_step_size = quant_step_table[abits]; 1292 1293 /* 1294 * Determine quantization index code book and its type 1295 */ 1296 1297 /* Select quantization index code book */ 1298 int sel = s->quant_index_huffman[k][abits]; 1299 1300 /* 1301 * Extract bits from the bit stream 1302 */ 1303 if (!abits) { 1304 rscale[l] = 0; 1305 memset(block + 8 * l, 0, 8 * sizeof(block[0])); 1306 } else { 1307 /* Deal with transients */ 1308 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l]; 1309 rscale[l] = quant_step_size * s->scale_factor[k][l][sfi] * 1310 s->scalefactor_adj[k][sel]; 1311 1312 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) { 1313 if (abits <= 7) { 1314 /* Block code */ 1315 int block_code1, block_code2, size, levels, err; 1316 1317 size = abits_sizes[abits - 1]; 1318 levels = abits_levels[abits - 1]; 1319 1320 block_code1 = get_bits(&s->gb, size); 1321 block_code2 = get_bits(&s->gb, size); 1322 err = decode_blockcodes(block_code1, block_code2, 1323 levels, block + 8 * l); 1324 if (err) { 1325 av_log(s->avctx, AV_LOG_ERROR, 1326 "ERROR: block code look-up failed\n"); 1327 return AVERROR_INVALIDDATA; 1328 } 1329 } else { 1330 /* no coding */ 1331 for (m = 0; m < 8; m++) 1332 block[8 * l + m] = get_sbits(&s->gb, abits - 3); 1333 } 1334 } else { 1335 /* Huffman coded */ 1336 for (m = 0; m < 8; m++) 1337 block[8 * l + m] = get_bitalloc(&s->gb, 1338 &dca_smpl_bitalloc[abits], sel); 1339 } 1340 1341 } 1342 } 1343 1344 s->fmt_conv.int32_to_float_fmul_array8(&s->fmt_conv, subband_samples[k][0], 1345 block, rscale, 8 * s->vq_start_subband[k]); 1346 1347 for (l = 0; l < s->vq_start_subband[k]; l++) { 1348 int m; 1349 /* 1350 * Inverse ADPCM if in prediction mode 1351 */ 1352 if (s->prediction_mode[k][l]) { 1353 int n; 1354 if (s->predictor_history) 1355 subband_samples[k][l][0] += (adpcm_vb[s->prediction_vq[k][l]][0] * 1356 s->subband_samples_hist[k][l][3] + 1357 adpcm_vb[s->prediction_vq[k][l]][1] * 1358 s->subband_samples_hist[k][l][2] + 1359 adpcm_vb[s->prediction_vq[k][l]][2] * 1360 s->subband_samples_hist[k][l][1] + 1361 adpcm_vb[s->prediction_vq[k][l]][3] * 1362 s->subband_samples_hist[k][l][0]) * 1363 (1.0f / 8192); 1364 for (m = 1; m < 8; m++) { 1365 float sum = adpcm_vb[s->prediction_vq[k][l]][0] * 1366 subband_samples[k][l][m - 1]; 1367 for (n = 2; n <= 4; n++) 1368 if (m >= n) 1369 sum += adpcm_vb[s->prediction_vq[k][l]][n - 1] * 1370 subband_samples[k][l][m - n]; 1371 else if (s->predictor_history) 1372 sum += adpcm_vb[s->prediction_vq[k][l]][n - 1] * 1373 s->subband_samples_hist[k][l][m - n + 4]; 1374 subband_samples[k][l][m] += sum * (1.0f / 8192); 1375 } 1376 } 1377 } 1378 1379 /* 1380 * Decode VQ encoded high frequencies 1381 */ 1382 if (s->subband_activity[k] > s->vq_start_subband[k]) { 1383 if (!(s->debug_flag & 0x01)) { 1384 av_log(s->avctx, AV_LOG_DEBUG, 1385 "Stream with high frequencies VQ coding\n"); 1386 s->debug_flag |= 0x01; 1387 } 1388 s->dcadsp.decode_hf(subband_samples[k], s->high_freq_vq[k], 1389 high_freq_vq, subsubframe * 8, 1390 s->scale_factor[k], s->vq_start_subband[k], 1391 s->subband_activity[k]); 1392 } 1393 } 1394 1395 /* Check for DSYNC after subsubframe */ 1396 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) { 1397 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */ 1398#ifdef TRACE 1399 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n"); 1400#endif 1401 } else { 1402 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n"); 1403 return AVERROR_INVALIDDATA; 1404 } 1405 } 1406 1407 /* Backup predictor history for adpcm */ 1408 for (k = base_channel; k < s->prim_channels; k++) 1409 for (l = 0; l < s->vq_start_subband[k]; l++) 1410 AV_COPY128(s->subband_samples_hist[k][l], &subband_samples[k][l][4]); 1411 1412 return 0; 1413} 1414 1415static int dca_filter_channels(DCAContext *s, int block_index) 1416{ 1417 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index]; 1418 int k; 1419 1420 /* 32 subbands QMF */ 1421 for (k = 0; k < s->prim_channels; k++) { 1422/* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0, 1423 0, 8388608.0, 8388608.0 };*/ 1424 if (s->channel_order_tab[k] >= 0) 1425 qmf_32_subbands(s, k, subband_samples[k], 1426 s->samples_chanptr[s->channel_order_tab[k]], 1427 M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */); 1428 } 1429 1430 /* Generate LFE samples for this subsubframe FIXME!!! */ 1431 if (s->lfe) { 1432 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe, 1433 s->lfe_data + 2 * s->lfe * (block_index + 4), 1434 s->samples_chanptr[s->lfe_index]); 1435 /* Outputs 20bits pcm samples */ 1436 } 1437 1438 /* Downmixing to Stereo */ 1439 if (s->prim_channels + !!s->lfe > 2 && 1440 s->avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) { 1441 dca_downmix(s->samples_chanptr, s->amode, !!s->lfe, s->downmix_coef, 1442 s->channel_order_tab); 1443 } 1444 1445 return 0; 1446} 1447 1448 1449static int dca_subframe_footer(DCAContext *s, int base_channel) 1450{ 1451 int in, out, aux_data_count, aux_data_end, reserved; 1452 uint32_t nsyncaux; 1453 1454 /* 1455 * Unpack optional information 1456 */ 1457 1458 /* presumably optional information only appears in the core? */ 1459 if (!base_channel) { 1460 if (s->timestamp) 1461 skip_bits_long(&s->gb, 32); 1462 1463 if (s->aux_data) { 1464 aux_data_count = get_bits(&s->gb, 6); 1465 1466 // align (32-bit) 1467 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31); 1468 1469 aux_data_end = 8 * aux_data_count + get_bits_count(&s->gb); 1470 1471 if ((nsyncaux = get_bits_long(&s->gb, 32)) != DCA_NSYNCAUX) { 1472 av_log(s->avctx, AV_LOG_ERROR, "nSYNCAUX mismatch %#"PRIx32"\n", 1473 nsyncaux); 1474 return AVERROR_INVALIDDATA; 1475 } 1476 1477 if (get_bits1(&s->gb)) { // bAUXTimeStampFlag 1478 avpriv_request_sample(s->avctx, 1479 "Auxiliary Decode Time Stamp Flag"); 1480 // align (4-bit) 1481 skip_bits(&s->gb, (-get_bits_count(&s->gb)) & 4); 1482 // 44 bits: nMSByte (8), nMarker (4), nLSByte (28), nMarker (4) 1483 skip_bits_long(&s->gb, 44); 1484 } 1485 1486 if ((s->core_downmix = get_bits1(&s->gb))) { 1487 int am = get_bits(&s->gb, 3); 1488 switch (am) { 1489 case 0: 1490 s->core_downmix_amode = DCA_MONO; 1491 break; 1492 case 1: 1493 s->core_downmix_amode = DCA_STEREO; 1494 break; 1495 case 2: 1496 s->core_downmix_amode = DCA_STEREO_TOTAL; 1497 break; 1498 case 3: 1499 s->core_downmix_amode = DCA_3F; 1500 break; 1501 case 4: 1502 s->core_downmix_amode = DCA_2F1R; 1503 break; 1504 case 5: 1505 s->core_downmix_amode = DCA_2F2R; 1506 break; 1507 case 6: 1508 s->core_downmix_amode = DCA_3F1R; 1509 break; 1510 default: 1511 av_log(s->avctx, AV_LOG_ERROR, 1512 "Invalid mode %d for embedded downmix coefficients\n", 1513 am); 1514 return AVERROR_INVALIDDATA; 1515 } 1516 for (out = 0; out < dca_channels[s->core_downmix_amode]; out++) { 1517 for (in = 0; in < s->prim_channels + !!s->lfe; in++) { 1518 uint16_t tmp = get_bits(&s->gb, 9); 1519 if ((tmp & 0xFF) > 241) { 1520 av_log(s->avctx, AV_LOG_ERROR, 1521 "Invalid downmix coefficient code %"PRIu16"\n", 1522 tmp); 1523 return AVERROR_INVALIDDATA; 1524 } 1525 s->core_downmix_codes[in][out] = tmp; 1526 } 1527 } 1528 } 1529 1530 align_get_bits(&s->gb); // byte align 1531 skip_bits(&s->gb, 16); // nAUXCRC16 1532 1533 // additional data (reserved, cf. ETSI TS 102 114 V1.4.1) 1534 if ((reserved = (aux_data_end - get_bits_count(&s->gb))) < 0) { 1535 av_log(s->avctx, AV_LOG_ERROR, 1536 "Overread auxiliary data by %d bits\n", -reserved); 1537 return AVERROR_INVALIDDATA; 1538 } else if (reserved) { 1539 avpriv_request_sample(s->avctx, 1540 "Core auxiliary data reserved content"); 1541 skip_bits_long(&s->gb, reserved); 1542 } 1543 } 1544 1545 if (s->crc_present && s->dynrange) 1546 get_bits(&s->gb, 16); 1547 } 1548 1549 return 0; 1550} 1551 1552/** 1553 * Decode a dca frame block 1554 * 1555 * @param s pointer to the DCAContext 1556 */ 1557 1558static int dca_decode_block(DCAContext *s, int base_channel, int block_index) 1559{ 1560 int ret; 1561 1562 /* Sanity check */ 1563 if (s->current_subframe >= s->subframes) { 1564 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i", 1565 s->current_subframe, s->subframes); 1566 return AVERROR_INVALIDDATA; 1567 } 1568 1569 if (!s->current_subsubframe) { 1570#ifdef TRACE 1571 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n"); 1572#endif 1573 /* Read subframe header */ 1574 if ((ret = dca_subframe_header(s, base_channel, block_index))) 1575 return ret; 1576 } 1577 1578 /* Read subsubframe */ 1579#ifdef TRACE 1580 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n"); 1581#endif 1582 if ((ret = dca_subsubframe(s, base_channel, block_index))) 1583 return ret; 1584 1585 /* Update state */ 1586 s->current_subsubframe++; 1587 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) { 1588 s->current_subsubframe = 0; 1589 s->current_subframe++; 1590 } 1591 if (s->current_subframe >= s->subframes) { 1592#ifdef TRACE 1593 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n"); 1594#endif 1595 /* Read subframe footer */ 1596 if ((ret = dca_subframe_footer(s, base_channel))) 1597 return ret; 1598 } 1599 1600 return 0; 1601} 1602 1603/** 1604 * Return the number of channels in an ExSS speaker mask (HD) 1605 */ 1606static int dca_exss_mask2count(int mask) 1607{ 1608 /* count bits that mean speaker pairs twice */ 1609 return av_popcount(mask) + 1610 av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT | 1611 DCA_EXSS_FRONT_LEFT_RIGHT | 1612 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT | 1613 DCA_EXSS_WIDE_LEFT_RIGHT | 1614 DCA_EXSS_SIDE_LEFT_RIGHT | 1615 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT | 1616 DCA_EXSS_SIDE_REAR_LEFT_RIGHT | 1617 DCA_EXSS_REAR_LEFT_RIGHT | 1618 DCA_EXSS_REAR_HIGH_LEFT_RIGHT)); 1619} 1620 1621/** 1622 * Skip mixing coefficients of a single mix out configuration (HD) 1623 */ 1624static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch) 1625{ 1626 int i; 1627 1628 for (i = 0; i < channels; i++) { 1629 int mix_map_mask = get_bits(gb, out_ch); 1630 int num_coeffs = av_popcount(mix_map_mask); 1631 skip_bits_long(gb, num_coeffs * 6); 1632 } 1633} 1634 1635/** 1636 * Parse extension substream asset header (HD) 1637 */ 1638static int dca_exss_parse_asset_header(DCAContext *s) 1639{ 1640 int header_pos = get_bits_count(&s->gb); 1641 int header_size; 1642 int channels = 0; 1643 int embedded_stereo = 0; 1644 int embedded_6ch = 0; 1645 int drc_code_present; 1646 int av_uninit(extensions_mask); 1647 int i, j; 1648 1649 if (get_bits_left(&s->gb) < 16) 1650 return -1; 1651 1652 /* We will parse just enough to get to the extensions bitmask with which 1653 * we can set the profile value. */ 1654 1655 header_size = get_bits(&s->gb, 9) + 1; 1656 skip_bits(&s->gb, 3); // asset index 1657 1658 if (s->static_fields) { 1659 if (get_bits1(&s->gb)) 1660 skip_bits(&s->gb, 4); // asset type descriptor 1661 if (get_bits1(&s->gb)) 1662 skip_bits_long(&s->gb, 24); // language descriptor 1663 1664 if (get_bits1(&s->gb)) { 1665 /* How can one fit 1024 bytes of text here if the maximum value 1666 * for the asset header size field above was 512 bytes? */ 1667 int text_length = get_bits(&s->gb, 10) + 1; 1668 if (get_bits_left(&s->gb) < text_length * 8) 1669 return -1; 1670 skip_bits_long(&s->gb, text_length * 8); // info text 1671 } 1672 1673 skip_bits(&s->gb, 5); // bit resolution - 1 1674 skip_bits(&s->gb, 4); // max sample rate code 1675 channels = get_bits(&s->gb, 8) + 1; 1676 1677 if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers 1678 int spkr_remap_sets; 1679 int spkr_mask_size = 16; 1680 int num_spkrs[7]; 1681 1682 if (channels > 2) 1683 embedded_stereo = get_bits1(&s->gb); 1684 if (channels > 6) 1685 embedded_6ch = get_bits1(&s->gb); 1686 1687 if (get_bits1(&s->gb)) { 1688 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2; 1689 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask 1690 } 1691 1692 spkr_remap_sets = get_bits(&s->gb, 3); 1693 1694 for (i = 0; i < spkr_remap_sets; i++) { 1695 /* std layout mask for each remap set */ 1696 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size)); 1697 } 1698 1699 for (i = 0; i < spkr_remap_sets; i++) { 1700 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1; 1701 if (get_bits_left(&s->gb) < 0) 1702 return -1; 1703 1704 for (j = 0; j < num_spkrs[i]; j++) { 1705 int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps); 1706 int num_dec_ch = av_popcount(remap_dec_ch_mask); 1707 skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes 1708 } 1709 } 1710 1711 } else { 1712 skip_bits(&s->gb, 3); // representation type 1713 } 1714 } 1715 1716 drc_code_present = get_bits1(&s->gb); 1717 if (drc_code_present) 1718 get_bits(&s->gb, 8); // drc code 1719 1720 if (get_bits1(&s->gb)) 1721 skip_bits(&s->gb, 5); // dialog normalization code 1722 1723 if (drc_code_present && embedded_stereo) 1724 get_bits(&s->gb, 8); // drc stereo code 1725 1726 if (s->mix_metadata && get_bits1(&s->gb)) { 1727 skip_bits(&s->gb, 1); // external mix 1728 skip_bits(&s->gb, 6); // post mix gain code 1729 1730 if (get_bits(&s->gb, 2) != 3) // mixer drc code 1731 skip_bits(&s->gb, 3); // drc limit 1732 else 1733 skip_bits(&s->gb, 8); // custom drc code 1734 1735 if (get_bits1(&s->gb)) // channel specific scaling 1736 for (i = 0; i < s->num_mix_configs; i++) 1737 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes 1738 else 1739 skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes 1740 1741 for (i = 0; i < s->num_mix_configs; i++) { 1742 if (get_bits_left(&s->gb) < 0) 1743 return -1; 1744 dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]); 1745 if (embedded_6ch) 1746 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]); 1747 if (embedded_stereo) 1748 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]); 1749 } 1750 } 1751 1752 switch (get_bits(&s->gb, 2)) { 1753 case 0: extensions_mask = get_bits(&s->gb, 12); break; 1754 case 1: extensions_mask = DCA_EXT_EXSS_XLL; break; 1755 case 2: extensions_mask = DCA_EXT_EXSS_LBR; break; 1756 case 3: extensions_mask = 0; /* aux coding */ break; 1757 } 1758 1759 /* not parsed further, we were only interested in the extensions mask */ 1760 1761 if (get_bits_left(&s->gb) < 0) 1762 return -1; 1763 1764 if (get_bits_count(&s->gb) - header_pos > header_size * 8) { 1765 av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n"); 1766 return -1; 1767 } 1768 skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb)); 1769 1770 if (extensions_mask & DCA_EXT_EXSS_XLL) 1771 s->profile = FF_PROFILE_DTS_HD_MA; 1772 else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 | 1773 DCA_EXT_EXSS_XXCH)) 1774 s->profile = FF_PROFILE_DTS_HD_HRA; 1775 1776 if (!(extensions_mask & DCA_EXT_CORE)) 1777 av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n"); 1778 if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask) 1779 av_log(s->avctx, AV_LOG_WARNING, 1780 "DTS extensions detection mismatch (%d, %d)\n", 1781 extensions_mask & DCA_CORE_EXTS, s->core_ext_mask); 1782 1783 return 0; 1784} 1785 1786static int dca_xbr_parse_frame(DCAContext *s) 1787{ 1788 int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2]; 1789 int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX]; 1790 int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS]; 1791 int anctemp[DCA_CHSET_CHANS_MAX]; 1792 int chset_fsize[DCA_CHSETS_MAX]; 1793 int n_xbr_ch[DCA_CHSETS_MAX]; 1794 int hdr_size, num_chsets, xbr_tmode, hdr_pos; 1795 int i, j, k, l, chset, chan_base; 1796 1797 av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n"); 1798 1799 /* get bit position of sync header */ 1800 hdr_pos = get_bits_count(&s->gb) - 32; 1801 1802 hdr_size = get_bits(&s->gb, 6) + 1; 1803 num_chsets = get_bits(&s->gb, 2) + 1; 1804 1805 for(i = 0; i < num_chsets; i++) 1806 chset_fsize[i] = get_bits(&s->gb, 14) + 1; 1807 1808 xbr_tmode = get_bits1(&s->gb); 1809 1810 for(i = 0; i < num_chsets; i++) { 1811 n_xbr_ch[i] = get_bits(&s->gb, 3) + 1; 1812 k = get_bits(&s->gb, 2) + 5; 1813 for(j = 0; j < n_xbr_ch[i]; j++) 1814 active_bands[i][j] = get_bits(&s->gb, k) + 1; 1815 } 1816 1817 /* skip to the end of the header */ 1818 i = get_bits_count(&s->gb); 1819 if(hdr_pos + hdr_size * 8 > i) 1820 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i); 1821 1822 /* loop over the channel data sets */ 1823 /* only decode as many channels as we've decoded base data for */ 1824 for(chset = 0, chan_base = 0; 1825 chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels; 1826 chan_base += n_xbr_ch[chset++]) { 1827 int start_posn = get_bits_count(&s->gb); 1828 int subsubframe = 0; 1829 int subframe = 0; 1830 1831 /* loop over subframes */ 1832 for (k = 0; k < (s->sample_blocks / 8); k++) { 1833 /* parse header if we're on first subsubframe of a block */ 1834 if(subsubframe == 0) { 1835 /* Parse subframe header */ 1836 for(i = 0; i < n_xbr_ch[chset]; i++) { 1837 anctemp[i] = get_bits(&s->gb, 2) + 2; 1838 } 1839 1840 for(i = 0; i < n_xbr_ch[chset]; i++) { 1841 get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]); 1842 } 1843 1844 for(i = 0; i < n_xbr_ch[chset]; i++) { 1845 anctemp[i] = get_bits(&s->gb, 3); 1846 if(anctemp[i] < 1) { 1847 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n"); 1848 return AVERROR_INVALIDDATA; 1849 } 1850 } 1851 1852 /* generate scale factors */ 1853 for(i = 0; i < n_xbr_ch[chset]; i++) { 1854 const uint32_t *scale_table; 1855 int nbits; 1856 1857 if (s->scalefactor_huffman[chan_base+i] == 6) { 1858 scale_table = scale_factor_quant7; 1859 } else { 1860 scale_table = scale_factor_quant6; 1861 } 1862 1863 nbits = anctemp[i]; 1864 1865 for(j = 0; j < active_bands[chset][i]; j++) { 1866 if(abits_high[i][j] > 0) { 1867 scale_table_high[i][j][0] = 1868 scale_table[get_bits(&s->gb, nbits)]; 1869 1870 if(xbr_tmode && s->transition_mode[i][j]) { 1871 scale_table_high[i][j][1] = 1872 scale_table[get_bits(&s->gb, nbits)]; 1873 } 1874 } 1875 } 1876 } 1877 } 1878 1879 /* decode audio array for this block */ 1880 for(i = 0; i < n_xbr_ch[chset]; i++) { 1881 for(j = 0; j < active_bands[chset][i]; j++) { 1882 const int xbr_abits = abits_high[i][j]; 1883 const float quant_step_size = lossless_quant_d[xbr_abits]; 1884 const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j]; 1885 const float rscale = quant_step_size * scale_table_high[i][j][sfi]; 1886 float *subband_samples = s->subband_samples[k][chan_base+i][j]; 1887 int block[8]; 1888 1889 if(xbr_abits <= 0) 1890 continue; 1891 1892 if(xbr_abits > 7) { 1893 get_array(&s->gb, block, 8, xbr_abits - 3); 1894 } else { 1895 int block_code1, block_code2, size, levels, err; 1896 1897 size = abits_sizes[xbr_abits - 1]; 1898 levels = abits_levels[xbr_abits - 1]; 1899 1900 block_code1 = get_bits(&s->gb, size); 1901 block_code2 = get_bits(&s->gb, size); 1902 err = decode_blockcodes(block_code1, block_code2, 1903 levels, block); 1904 if (err) { 1905 av_log(s->avctx, AV_LOG_ERROR, 1906 "ERROR: DTS-XBR: block code look-up failed\n"); 1907 return AVERROR_INVALIDDATA; 1908 } 1909 } 1910 1911 /* scale & sum into subband */ 1912 for(l = 0; l < 8; l++) 1913 subband_samples[l] += (float)block[l] * rscale; 1914 } 1915 } 1916 1917 /* check DSYNC marker */ 1918 if(s->aspf || subsubframe == s->subsubframes[subframe] - 1) { 1919 if(get_bits(&s->gb, 16) != 0xffff) { 1920 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n"); 1921 return AVERROR_INVALIDDATA; 1922 } 1923 } 1924 1925 /* advance sub-sub-frame index */ 1926 if(++subsubframe >= s->subsubframes[subframe]) { 1927 subsubframe = 0; 1928 subframe++; 1929 } 1930 } 1931 1932 /* skip to next channel set */ 1933 i = get_bits_count(&s->gb); 1934 if(start_posn + chset_fsize[chset] * 8 != i) { 1935 j = start_posn + chset_fsize[chset] * 8 - i; 1936 if(j < 0 || j >= 8) 1937 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set," 1938 " skipping further than expected (%d bits)\n", j); 1939 skip_bits_long(&s->gb, j); 1940 } 1941 } 1942 1943 return 0; 1944} 1945 1946/* parse initial header for XXCH and dump details */ 1947static int dca_xxch_decode_frame(DCAContext *s) 1948{ 1949 int hdr_size, spkmsk_bits, num_chsets, core_spk, hdr_pos; 1950 int i, chset, base_channel, chstart, fsize[8]; 1951 1952 /* assume header word has already been parsed */ 1953 hdr_pos = get_bits_count(&s->gb) - 32; 1954 hdr_size = get_bits(&s->gb, 6) + 1; 1955 /*chhdr_crc =*/ skip_bits1(&s->gb); 1956 spkmsk_bits = get_bits(&s->gb, 5) + 1; 1957 num_chsets = get_bits(&s->gb, 2) + 1; 1958 1959 for (i = 0; i < num_chsets; i++) 1960 fsize[i] = get_bits(&s->gb, 14) + 1; 1961 1962 core_spk = get_bits(&s->gb, spkmsk_bits); 1963 s->xxch_core_spkmask = core_spk; 1964 s->xxch_nbits_spk_mask = spkmsk_bits; 1965 s->xxch_dmix_embedded = 0; 1966 1967 /* skip to the end of the header */ 1968 i = get_bits_count(&s->gb); 1969 if (hdr_pos + hdr_size * 8 > i) 1970 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i); 1971 1972 for (chset = 0; chset < num_chsets; chset++) { 1973 chstart = get_bits_count(&s->gb); 1974 base_channel = s->prim_channels; 1975 s->xxch_chset = chset; 1976 1977 /* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs. 1978 5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */ 1979 dca_parse_audio_coding_header(s, base_channel, 1); 1980 1981 /* decode channel data */ 1982 for (i = 0; i < (s->sample_blocks / 8); i++) { 1983 if (dca_decode_block(s, base_channel, i)) { 1984 av_log(s->avctx, AV_LOG_ERROR, 1985 "Error decoding DTS-XXCH extension\n"); 1986 continue; 1987 } 1988 } 1989 1990 /* skip to end of this section */ 1991 i = get_bits_count(&s->gb); 1992 if (chstart + fsize[chset] * 8 > i) 1993 skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i); 1994 } 1995 s->xxch_chset = num_chsets; 1996 1997 return 0; 1998} 1999 2000/** 2001 * Parse extension substream header (HD) 2002 */ 2003static void dca_exss_parse_header(DCAContext *s) 2004{ 2005 int asset_size[8]; 2006 int ss_index; 2007 int blownup; 2008 int num_audiop = 1; 2009 int num_assets = 1; 2010 int active_ss_mask[8]; 2011 int i, j; 2012 int start_posn; 2013 int hdrsize; 2014 uint32_t mkr; 2015 2016 if (get_bits_left(&s->gb) < 52) 2017 return; 2018 2019 start_posn = get_bits_count(&s->gb) - 32; 2020 2021 skip_bits(&s->gb, 8); // user data 2022 ss_index = get_bits(&s->gb, 2); 2023 2024 blownup = get_bits1(&s->gb); 2025 hdrsize = get_bits(&s->gb, 8 + 4 * blownup) + 1; // header_size 2026 skip_bits(&s->gb, 16 + 4 * blownup); // hd_size 2027 2028 s->static_fields = get_bits1(&s->gb); 2029 if (s->static_fields) { 2030 skip_bits(&s->gb, 2); // reference clock code 2031 skip_bits(&s->gb, 3); // frame duration code 2032 2033 if (get_bits1(&s->gb)) 2034 skip_bits_long(&s->gb, 36); // timestamp 2035 2036 /* a single stream can contain multiple audio assets that can be 2037 * combined to form multiple audio presentations */ 2038 2039 num_audiop = get_bits(&s->gb, 3) + 1; 2040 if (num_audiop > 1) { 2041 avpriv_request_sample(s->avctx, 2042 "Multiple DTS-HD audio presentations"); 2043 /* ignore such streams for now */ 2044 return; 2045 } 2046 2047 num_assets = get_bits(&s->gb, 3) + 1; 2048 if (num_assets > 1) { 2049 avpriv_request_sample(s->avctx, "Multiple DTS-HD audio assets"); 2050 /* ignore such streams for now */ 2051 return; 2052 } 2053 2054 for (i = 0; i < num_audiop; i++) 2055 active_ss_mask[i] = get_bits(&s->gb, ss_index + 1); 2056 2057 for (i = 0; i < num_audiop; i++) 2058 for (j = 0; j <= ss_index; j++) 2059 if (active_ss_mask[i] & (1 << j)) 2060 skip_bits(&s->gb, 8); // active asset mask 2061 2062 s->mix_metadata = get_bits1(&s->gb); 2063 if (s->mix_metadata) { 2064 int mix_out_mask_size; 2065 2066 skip_bits(&s->gb, 2); // adjustment level 2067 mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2; 2068 s->num_mix_configs = get_bits(&s->gb, 2) + 1; 2069 2070 for (i = 0; i < s->num_mix_configs; i++) { 2071 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size); 2072 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask); 2073 } 2074 } 2075 } 2076 2077 av_assert0(num_assets > 0); // silence a warning 2078 2079 for (i = 0; i < num_assets; i++) 2080 asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup); 2081 2082 for (i = 0; i < num_assets; i++) { 2083 if (dca_exss_parse_asset_header(s)) 2084 return; 2085 } 2086 2087 /* not parsed further, we were only interested in the extensions mask 2088 * from the asset header */ 2089 2090 j = get_bits_count(&s->gb); 2091 if (start_posn + hdrsize * 8 > j) 2092 skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j); 2093 2094 for (i = 0; i < num_assets; i++) { 2095 start_posn = get_bits_count(&s->gb); 2096 mkr = get_bits_long(&s->gb, 32); 2097 2098 /* parse extensions that we know about */ 2099 if (mkr == 0x655e315e) { 2100 dca_xbr_parse_frame(s); 2101 } else if (mkr == 0x47004a03) { 2102 dca_xxch_decode_frame(s); 2103 s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */ 2104 } else { 2105 av_log(s->avctx, AV_LOG_DEBUG, 2106 "DTS-ExSS: unknown marker = 0x%08x\n", mkr); 2107 } 2108 2109 /* skip to end of block */ 2110 j = get_bits_count(&s->gb); 2111 if (start_posn + asset_size[i] * 8 > j) 2112 skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j); 2113 } 2114} 2115 2116static float dca_dmix_code(unsigned code) 2117{ 2118 int sign = (code >> 8) - 1; 2119 code &= 0xff; 2120 return ((dca_dmixtable[code] ^ sign) - sign) * (1.0 / (1 << 15)); 2121} 2122 2123/** 2124 * Main frame decoding function 2125 * FIXME add arguments 2126 */ 2127static int dca_decode_frame(AVCodecContext *avctx, void *data, 2128 int *got_frame_ptr, AVPacket *avpkt) 2129{ 2130 AVFrame *frame = data; 2131 const uint8_t *buf = avpkt->data; 2132 int buf_size = avpkt->size; 2133 int channel_mask; 2134 int channel_layout; 2135 int lfe_samples; 2136 int num_core_channels = 0; 2137 int i, ret; 2138 float **samples_flt; 2139 float *src_chan; 2140 float *dst_chan; 2141 DCAContext *s = avctx->priv_data; 2142 int core_ss_end; 2143 int channels, full_channels; 2144 float scale; 2145 int achan; 2146 int chset; 2147 int mask; 2148 int lavc; 2149 int posn; 2150 int j, k; 2151 int endch; 2152 2153 s->xch_present = 0; 2154 2155 s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer, 2156 DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE); 2157 if (s->dca_buffer_size == AVERROR_INVALIDDATA) { 2158 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n"); 2159 return AVERROR_INVALIDDATA; 2160 } 2161 2162 if ((ret = dca_parse_frame_header(s)) < 0) { 2163 //seems like the frame is corrupt, try with the next one 2164 return ret; 2165 } 2166 //set AVCodec values with parsed data 2167 avctx->sample_rate = s->sample_rate; 2168 avctx->bit_rate = s->bit_rate; 2169 2170 s->profile = FF_PROFILE_DTS; 2171 2172 for (i = 0; i < (s->sample_blocks / 8); i++) { 2173 if ((ret = dca_decode_block(s, 0, i))) { 2174 av_log(avctx, AV_LOG_ERROR, "error decoding block\n"); 2175 return ret; 2176 } 2177 } 2178 2179 /* record number of core channels incase less than max channels are requested */ 2180 num_core_channels = s->prim_channels; 2181 2182 if (s->prim_channels + !!s->lfe > 2 && 2183 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) { 2184 /* Stereo downmix coefficients 2185 * 2186 * The decoder can only downmix to 2-channel, so we need to ensure 2187 * embedded downmix coefficients are actually targeting 2-channel. 2188 */ 2189 if (s->core_downmix && (s->core_downmix_amode == DCA_STEREO || 2190 s->core_downmix_amode == DCA_STEREO_TOTAL)) { 2191 for (i = 0; i < num_core_channels + !!s->lfe; i++) { 2192 /* Range checked earlier */ 2193 s->downmix_coef[i][0] = dca_dmix_code(s->core_downmix_codes[i][0]); 2194 s->downmix_coef[i][1] = dca_dmix_code(s->core_downmix_codes[i][1]); 2195 } 2196 s->output = s->core_downmix_amode; 2197 } else { 2198 int am = s->amode & DCA_CHANNEL_MASK; 2199 if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) { 2200 av_log(s->avctx, AV_LOG_ERROR, 2201 "Invalid channel mode %d\n", am); 2202 return AVERROR_INVALIDDATA; 2203 } 2204 if (num_core_channels + !!s->lfe > 2205 FF_ARRAY_ELEMS(dca_default_coeffs[0])) { 2206 avpriv_request_sample(s->avctx, "Downmixing %d channels", 2207 s->prim_channels + !!s->lfe); 2208 return AVERROR_PATCHWELCOME; 2209 } 2210 for (i = 0; i < num_core_channels + !!s->lfe; i++) { 2211 s->downmix_coef[i][0] = dca_default_coeffs[am][i][0]; 2212 s->downmix_coef[i][1] = dca_default_coeffs[am][i][1]; 2213 } 2214 } 2215 av_dlog(s->avctx, "Stereo downmix coeffs:\n"); 2216 for (i = 0; i < num_core_channels + !!s->lfe; i++) { 2217 av_dlog(s->avctx, "L, input channel %d = %f\n", i, 2218 s->downmix_coef[i][0]); 2219 av_dlog(s->avctx, "R, input channel %d = %f\n", i, 2220 s->downmix_coef[i][1]); 2221 } 2222 av_dlog(s->avctx, "\n"); 2223 } 2224 2225 if (s->ext_coding) 2226 s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr]; 2227 else 2228 s->core_ext_mask = 0; 2229 2230 core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8; 2231 2232 /* only scan for extensions if ext_descr was unknown or indicated a 2233 * supported XCh extension */ 2234 if (s->core_ext_mask < 0 || s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH)) { 2235 2236 /* if ext_descr was unknown, clear s->core_ext_mask so that the 2237 * extensions scan can fill it up */ 2238 s->core_ext_mask = FFMAX(s->core_ext_mask, 0); 2239 2240 /* extensions start at 32-bit boundaries into bitstream */ 2241 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31); 2242 2243 while (core_ss_end - get_bits_count(&s->gb) >= 32) { 2244 uint32_t bits = get_bits_long(&s->gb, 32); 2245 2246 switch (bits) { 2247 case 0x5a5a5a5a: { 2248 int ext_amode, xch_fsize; 2249 2250 s->xch_base_channel = s->prim_channels; 2251 2252 /* validate sync word using XCHFSIZE field */ 2253 xch_fsize = show_bits(&s->gb, 10); 2254 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) && 2255 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1)) 2256 continue; 2257 2258 /* skip length-to-end-of-frame field for the moment */ 2259 skip_bits(&s->gb, 10); 2260 2261 s->core_ext_mask |= DCA_EXT_XCH; 2262 2263 /* extension amode(number of channels in extension) should be 1 */ 2264 /* AFAIK XCh is not used for more channels */ 2265 if ((ext_amode = get_bits(&s->gb, 4)) != 1) { 2266 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not" 2267 " supported!\n", ext_amode); 2268 continue; 2269 } 2270 2271 if (s->xch_base_channel < 2) { 2272 avpriv_request_sample(avctx, "XCh with fewer than 2 base channels"); 2273 continue; 2274 } 2275 2276 /* much like core primary audio coding header */ 2277 dca_parse_audio_coding_header(s, s->xch_base_channel, 0); 2278 2279 for (i = 0; i < (s->sample_blocks / 8); i++) 2280 if ((ret = dca_decode_block(s, s->xch_base_channel, i))) { 2281 av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n"); 2282 continue; 2283 } 2284 2285 s->xch_present = 1; 2286 break; 2287 } 2288 case 0x47004a03: 2289 /* XXCh: extended channels */ 2290 /* usually found either in core or HD part in DTS-HD HRA streams, 2291 * but not in DTS-ES which contains XCh extensions instead */ 2292 s->core_ext_mask |= DCA_EXT_XXCH; 2293 dca_xxch_decode_frame(s); 2294 break; 2295 2296 case 0x1d95f262: { 2297 int fsize96 = show_bits(&s->gb, 12) + 1; 2298 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96) 2299 continue; 2300 2301 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n", 2302 get_bits_count(&s->gb)); 2303 skip_bits(&s->gb, 12); 2304 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96); 2305 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4)); 2306 2307 s->core_ext_mask |= DCA_EXT_X96; 2308 break; 2309 } 2310 } 2311 2312 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31); 2313 } 2314 } else { 2315 /* no supported extensions, skip the rest of the core substream */ 2316 skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb)); 2317 } 2318 2319 if (s->core_ext_mask & DCA_EXT_X96) 2320 s->profile = FF_PROFILE_DTS_96_24; 2321 else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH)) 2322 s->profile = FF_PROFILE_DTS_ES; 2323 2324 /* check for ExSS (HD part) */ 2325 if (s->dca_buffer_size - s->frame_size > 32 && 2326 get_bits_long(&s->gb, 32) == DCA_HD_MARKER) 2327 dca_exss_parse_header(s); 2328 2329 avctx->profile = s->profile; 2330 2331 full_channels = channels = s->prim_channels + !!s->lfe; 2332 2333 /* If we have XXCH then the channel layout is managed differently */ 2334 /* note that XLL will also have another way to do things */ 2335 if (!(s->core_ext_mask & DCA_EXT_XXCH) 2336 || (s->core_ext_mask & DCA_EXT_XXCH && avctx->request_channels > 0 2337 && avctx->request_channels 2338 < num_core_channels + !!s->lfe + s->xxch_chset_nch[0])) 2339 { /* xxx should also do MA extensions */ 2340 if (s->amode < 16) { 2341 avctx->channel_layout = dca_core_channel_layout[s->amode]; 2342 2343 if (s->prim_channels + !!s->lfe > 2 && 2344 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) { 2345 /* 2346 * Neither the core's auxiliary data nor our default tables contain 2347 * downmix coefficients for the additional channel coded in the XCh 2348 * extension, so when we're doing a Stereo downmix, don't decode it. 2349 */ 2350 s->xch_disable = 1; 2351 } 2352 2353#if FF_API_REQUEST_CHANNELS 2354FF_DISABLE_DEPRECATION_WARNINGS 2355 if (s->xch_present && !s->xch_disable && 2356 (!avctx->request_channels || 2357 avctx->request_channels > num_core_channels + !!s->lfe)) { 2358FF_ENABLE_DEPRECATION_WARNINGS 2359#else 2360 if (s->xch_present && !s->xch_disable) { 2361#endif 2362 avctx->channel_layout |= AV_CH_BACK_CENTER; 2363 if (s->lfe) { 2364 avctx->channel_layout |= AV_CH_LOW_FREQUENCY; 2365 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode]; 2366 } else { 2367 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode]; 2368 } 2369 if (s->channel_order_tab[s->xch_base_channel] < 0) 2370 return AVERROR_INVALIDDATA; 2371 } else { 2372 channels = num_core_channels + !!s->lfe; 2373 s->xch_present = 0; /* disable further xch processing */ 2374 if (s->lfe) { 2375 avctx->channel_layout |= AV_CH_LOW_FREQUENCY; 2376 s->channel_order_tab = dca_channel_reorder_lfe[s->amode]; 2377 } else 2378 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode]; 2379 } 2380 2381 if (channels > !!s->lfe && 2382 s->channel_order_tab[channels - 1 - !!s->lfe] < 0) 2383 return AVERROR_INVALIDDATA; 2384 2385 if (av_get_channel_layout_nb_channels(avctx->channel_layout) != channels) { 2386 av_log(avctx, AV_LOG_ERROR, "Number of channels %d mismatches layout %d\n", channels, av_get_channel_layout_nb_channels(avctx->channel_layout)); 2387 return AVERROR_INVALIDDATA; 2388 } 2389 2390 if (num_core_channels + !!s->lfe > 2 && 2391 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) { 2392 channels = 2; 2393 s->output = s->prim_channels == 2 ? s->amode : DCA_STEREO; 2394 avctx->channel_layout = AV_CH_LAYOUT_STEREO; 2395 } 2396 else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) { 2397 static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 }; 2398 s->channel_order_tab = dca_channel_order_native; 2399 } 2400 s->lfe_index = dca_lfe_index[s->amode]; 2401 } else { 2402 av_log(avctx, AV_LOG_ERROR, 2403 "Non standard configuration %d !\n", s->amode); 2404 return AVERROR_INVALIDDATA; 2405 } 2406 2407 s->xxch_dmix_embedded = 0; 2408 } else { 2409 /* we only get here if an XXCH channel set can be added to the mix */ 2410 channel_mask = s->xxch_core_spkmask; 2411 2412 if (avctx->request_channels > 0 2413 && avctx->request_channels < s->prim_channels) { 2414 channels = num_core_channels + !!s->lfe; 2415 for (i = 0; i < s->xxch_chset && channels + s->xxch_chset_nch[i] 2416 <= avctx->request_channels; i++) { 2417 channels += s->xxch_chset_nch[i]; 2418 channel_mask |= s->xxch_spk_masks[i]; 2419 } 2420 } else { 2421 channels = s->prim_channels + !!s->lfe; 2422 for (i = 0; i < s->xxch_chset; i++) { 2423 channel_mask |= s->xxch_spk_masks[i]; 2424 } 2425 } 2426 2427 /* Given the DTS spec'ed channel mask, generate an avcodec version */ 2428 channel_layout = 0; 2429 for (i = 0; i < s->xxch_nbits_spk_mask; ++i) { 2430 if (channel_mask & (1 << i)) { 2431 channel_layout |= map_xxch_to_native[i]; 2432 } 2433 } 2434 2435 /* make sure that we have managed to get equivalent dts/avcodec channel 2436 * masks in some sense -- unfortunately some channels could overlap */ 2437 if (av_popcount(channel_mask) != av_popcount(channel_layout)) { 2438 av_log(avctx, AV_LOG_DEBUG, 2439 "DTS-XXCH: Inconsistent avcodec/dts channel layouts\n"); 2440 return AVERROR_INVALIDDATA; 2441 } 2442 2443 avctx->channel_layout = channel_layout; 2444 2445 if (!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)) { 2446 /* Estimate DTS --> avcodec ordering table */ 2447 for (chset = -1, j = 0; chset < s->xxch_chset; ++chset) { 2448 mask = chset >= 0 ? s->xxch_spk_masks[chset] 2449 : s->xxch_core_spkmask; 2450 for (i = 0; i < s->xxch_nbits_spk_mask; i++) { 2451 if (mask & ~(DCA_XXCH_LFE1 | DCA_XXCH_LFE2) & (1 << i)) { 2452 lavc = map_xxch_to_native[i]; 2453 posn = av_popcount(channel_layout & (lavc - 1)); 2454 s->xxch_order_tab[j++] = posn; 2455 } 2456 } 2457 2458 } 2459 2460 s->lfe_index = av_popcount(channel_layout & (AV_CH_LOW_FREQUENCY-1)); 2461 } else { /* native ordering */ 2462 for (i = 0; i < channels; i++) 2463 s->xxch_order_tab[i] = i; 2464 2465 s->lfe_index = channels - 1; 2466 } 2467 2468 s->channel_order_tab = s->xxch_order_tab; 2469 } 2470 2471 if (avctx->channels != channels) { 2472 if (avctx->channels) 2473 av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels); 2474 avctx->channels = channels; 2475 } 2476 2477 /* get output buffer */ 2478 frame->nb_samples = 256 * (s->sample_blocks / 8); 2479 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 2480 return ret; 2481 samples_flt = (float **)frame->extended_data; 2482 2483 /* allocate buffer for extra channels if downmixing */ 2484 if (avctx->channels < full_channels) { 2485 ret = av_samples_get_buffer_size(NULL, full_channels - channels, 2486 frame->nb_samples, 2487 avctx->sample_fmt, 0); 2488 if (ret < 0) 2489 return ret; 2490 2491 av_fast_malloc(&s->extra_channels_buffer, 2492 &s->extra_channels_buffer_size, ret); 2493 if (!s->extra_channels_buffer) 2494 return AVERROR(ENOMEM); 2495 2496 ret = av_samples_fill_arrays((uint8_t **)s->extra_channels, NULL, 2497 s->extra_channels_buffer, 2498 full_channels - channels, 2499 frame->nb_samples, avctx->sample_fmt, 0); 2500 if (ret < 0) 2501 return ret; 2502 } 2503 2504 /* filter to get final output */ 2505 for (i = 0; i < (s->sample_blocks / 8); i++) { 2506 int ch; 2507 2508 for (ch = 0; ch < channels; ch++) 2509 s->samples_chanptr[ch] = samples_flt[ch] + i * 256; 2510 for (; ch < full_channels; ch++) 2511 s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256; 2512 2513 dca_filter_channels(s, i); 2514 2515 /* If this was marked as a DTS-ES stream we need to subtract back- */ 2516 /* channel from SL & SR to remove matrixed back-channel signal */ 2517 if ((s->source_pcm_res & 1) && s->xch_present) { 2518 float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]]; 2519 float *lt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]]; 2520 float *rt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]]; 2521 s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256); 2522 s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256); 2523 } 2524 2525 /* If stream contains XXCH, we might need to undo an embedded downmix */ 2526 if (s->xxch_dmix_embedded) { 2527 /* Loop over channel sets in turn */ 2528 ch = num_core_channels; 2529 for (chset = 0; chset < s->xxch_chset; chset++) { 2530 endch = ch + s->xxch_chset_nch[chset]; 2531 mask = s->xxch_dmix_embedded; 2532 2533 /* undo downmix */ 2534 for (j = ch; j < endch; j++) { 2535 if (mask & (1 << j)) { /* this channel has been mixed-out */ 2536 src_chan = s->samples_chanptr[s->channel_order_tab[j]]; 2537 for (k = 0; k < endch; k++) { 2538 achan = s->channel_order_tab[k]; 2539 scale = s->xxch_dmix_coeff[j][k]; 2540 if (scale != 0.0) { 2541 dst_chan = s->samples_chanptr[achan]; 2542 s->fdsp.vector_fmac_scalar(dst_chan, src_chan, 2543 -scale, 256); 2544 } 2545 } 2546 } 2547 } 2548 2549 /* if a downmix has been embedded then undo the pre-scaling */ 2550 if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) { 2551 scale = s->xxch_dmix_sf[chset]; 2552 2553 for (j = 0; j < ch; j++) { 2554 src_chan = s->samples_chanptr[s->channel_order_tab[j]]; 2555 for (k = 0; k < 256; k++) 2556 src_chan[k] *= scale; 2557 } 2558 2559 /* LFE channel is always part of core, scale if it exists */ 2560 if (s->lfe) { 2561 src_chan = s->samples_chanptr[s->lfe_index]; 2562 for (k = 0; k < 256; k++) 2563 src_chan[k] *= scale; 2564 } 2565 } 2566 2567 ch = endch; 2568 } 2569 2570 } 2571 } 2572 2573 /* update lfe history */ 2574 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8); 2575 for (i = 0; i < 2 * s->lfe * 4; i++) 2576 s->lfe_data[i] = s->lfe_data[i + lfe_samples]; 2577 2578 /* AVMatrixEncoding 2579 * 2580 * DCA_STEREO_TOTAL (Lt/Rt) is equivalent to Dolby Surround */ 2581 ret = ff_side_data_update_matrix_encoding(frame, 2582 (s->output & ~DCA_LFE) == DCA_STEREO_TOTAL ? 2583 AV_MATRIX_ENCODING_DOLBY : AV_MATRIX_ENCODING_NONE); 2584 if (ret < 0) 2585 return ret; 2586 2587 *got_frame_ptr = 1; 2588 2589 return buf_size; 2590} 2591 2592 2593 2594/** 2595 * DCA initialization 2596 * 2597 * @param avctx pointer to the AVCodecContext 2598 */ 2599 2600static av_cold int dca_decode_init(AVCodecContext *avctx) 2601{ 2602 DCAContext *s = avctx->priv_data; 2603 2604 s->avctx = avctx; 2605 dca_init_vlcs(); 2606 2607 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT); 2608 ff_mdct_init(&s->imdct, 6, 1, 1.0); 2609 ff_synth_filter_init(&s->synth); 2610 ff_dcadsp_init(&s->dcadsp); 2611 ff_fmt_convert_init(&s->fmt_conv, avctx); 2612 2613 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; 2614 2615 /* allow downmixing to stereo */ 2616#if FF_API_REQUEST_CHANNELS 2617FF_DISABLE_DEPRECATION_WARNINGS 2618 if (avctx->request_channels == 2) 2619 avctx->request_channel_layout = AV_CH_LAYOUT_STEREO; 2620FF_ENABLE_DEPRECATION_WARNINGS 2621#endif 2622 if (avctx->channels > 2 && 2623 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) 2624 avctx->channels = 2; 2625 2626 return 0; 2627} 2628 2629static av_cold int dca_decode_end(AVCodecContext *avctx) 2630{ 2631 DCAContext *s = avctx->priv_data; 2632 ff_mdct_end(&s->imdct); 2633 av_freep(&s->extra_channels_buffer); 2634 return 0; 2635} 2636 2637static const AVProfile profiles[] = { 2638 { FF_PROFILE_DTS, "DTS" }, 2639 { FF_PROFILE_DTS_ES, "DTS-ES" }, 2640 { FF_PROFILE_DTS_96_24, "DTS 96/24" }, 2641 { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" }, 2642 { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" }, 2643 { FF_PROFILE_UNKNOWN }, 2644}; 2645 2646static const AVOption options[] = { 2647 { "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 }, 2648 { NULL }, 2649}; 2650 2651static const AVClass dca_decoder_class = { 2652 .class_name = "DCA decoder", 2653 .item_name = av_default_item_name, 2654 .option = options, 2655 .version = LIBAVUTIL_VERSION_INT, 2656 .category = AV_CLASS_CATEGORY_DECODER, 2657}; 2658 2659AVCodec ff_dca_decoder = { 2660 .name = "dca", 2661 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"), 2662 .type = AVMEDIA_TYPE_AUDIO, 2663 .id = AV_CODEC_ID_DTS, 2664 .priv_data_size = sizeof(DCAContext), 2665 .init = dca_decode_init, 2666 .decode = dca_decode_frame, 2667 .close = dca_decode_end, 2668 .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1, 2669 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, 2670 AV_SAMPLE_FMT_NONE }, 2671 .profiles = NULL_IF_CONFIG_SMALL(profiles), 2672 .priv_class = &dca_decoder_class, 2673}; 2674