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
8 * This file is part of FFmpeg.
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.
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.
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
29 #include "libavutil/common.h"
30 #include "libavutil/float_dsp.h"
31 #include "libavutil/intmath.h"
32 #include "libavutil/intreadwrite.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/audioconvert.h"
43 #include "dca_parser.h"
44 #include "synth_filter.h"
46 #include "fmtconvert.h"
54 #define DCA_PRIM_CHANNELS_MAX (7)
55 #define DCA_SUBBANDS (64)
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)
78 /* these are unconfirmed but should be mostly correct */
79 enum 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,
98 enum 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,
129 static const uint32_t map_xxch_to_native[28] = {
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,
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 */
160 enum 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
173 /* -1 are reserved or unknown */
174 static const int dca_ext_audio_descr_mask[] = {
178 DCA_EXT_XCH | DCA_EXT_X96,
185 /* extensions that reside in core substream */
186 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
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.
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
195 * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
197 static 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
208 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
209 AV_CH_SIDE_RIGHT, ///< 5, C + L + R + SL + SR
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
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
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
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
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
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
234 static const int8_t dca_lfe_index[] = {
235 1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
238 static 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},
257 static 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},
276 static 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},
295 static 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},
314 #define DCA_DOLBY 101 /* FIXME */
316 #define DCA_CHANNEL_BITS 6
317 #define DCA_CHANNEL_MASK 0x3F
321 #define HEADER_SIZE 14
323 #define DCA_MAX_FRAME_SIZE 16384
324 #define DCA_MAX_EXSS_HEADER_SIZE 4096
326 #define DCA_BUFFER_PADDING_SIZE 1024
328 /** Bit allocation */
330 int offset; ///< code values offset
331 int maxbits[8]; ///< max bits in VLC
332 int wrap; ///< wrap for get_vlc2()
333 VLC vlc[8]; ///< actual codes
336 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
337 static BitAlloc dca_tmode; ///< transition mode VLCs
338 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
339 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
341 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
344 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
349 AVCodecContext *avctx;
352 int frame_type; ///< type of the current frame
353 int samples_deficit; ///< deficit sample count
354 int crc_present; ///< crc is present in the bitstream
355 int sample_blocks; ///< number of PCM sample blocks
356 int frame_size; ///< primary frame byte size
357 int amode; ///< audio channels arrangement
358 int sample_rate; ///< audio sampling rate
359 int bit_rate; ///< transmission bit rate
360 int bit_rate_index; ///< transmission bit rate index
362 int downmix; ///< embedded downmix enabled
363 int dynrange; ///< embedded dynamic range flag
364 int timestamp; ///< embedded time stamp flag
365 int aux_data; ///< auxiliary data flag
366 int hdcd; ///< source material is mastered in HDCD
367 int ext_descr; ///< extension audio descriptor flag
368 int ext_coding; ///< extended coding flag
369 int aspf; ///< audio sync word insertion flag
370 int lfe; ///< low frequency effects flag
371 int predictor_history; ///< predictor history flag
372 int header_crc; ///< header crc check bytes
373 int multirate_inter; ///< multirate interpolator switch
374 int version; ///< encoder software revision
375 int copy_history; ///< copy history
376 int source_pcm_res; ///< source pcm resolution
377 int front_sum; ///< front sum/difference flag
378 int surround_sum; ///< surround sum/difference flag
379 int dialog_norm; ///< dialog normalisation parameter
381 /* Primary audio coding header */
382 int subframes; ///< number of subframes
383 int total_channels; ///< number of channels including extensions
384 int prim_channels; ///< number of primary audio channels
385 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
386 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
387 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
388 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
389 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
390 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
391 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
392 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
394 /* Primary audio coding side information */
395 int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
396 int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
397 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
398 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
399 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
400 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
401 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
402 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
403 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
404 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
405 int dynrange_coef; ///< dynamic range coefficient
407 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
409 float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
410 int lfe_scale_factor;
412 /* Subband samples history (for ADPCM) */
413 DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
414 DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
415 DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
416 int hist_index[DCA_PRIM_CHANNELS_MAX];
417 DECLARE_ALIGNED(32, float, raXin)[32];
419 int output; ///< type of output
420 float scale_bias; ///< output scale
422 DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
423 DECLARE_ALIGNED(32, float, samples)[(DCA_PRIM_CHANNELS_MAX + 1) * 256];
424 const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
426 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
427 int dca_buffer_size; ///< how much data is in the dca_buffer
429 const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
431 /* Current position in DCA frame */
432 int current_subframe;
433 int current_subsubframe;
435 int core_ext_mask; ///< present extensions in the core substream
437 /* XCh extension information */
438 int xch_present; ///< XCh extension present and valid
439 int xch_base_channel; ///< index of first (only) channel containing XCH data
441 /* XXCH extension information */
443 int xxch_nbits_spk_mask;
444 uint32_t xxch_core_spkmask;
445 uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */
446 int xxch_chset_nch[4];
447 float xxch_dmix_sf[DCA_CHSETS_MAX];
449 uint32_t xxch_downmix; /* downmix enabled per channel set */
450 uint32_t xxch_dmix_embedded; /* lower layer has mix pre-embedded, per chset */
451 float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */
453 int8_t xxch_order_tab[32];
456 /* ExSS header parser */
457 int static_fields; ///< static fields present
458 int mix_metadata; ///< mixing metadata present
459 int num_mix_configs; ///< number of mix out configurations
460 int mix_config_num_ch[4]; ///< number of channels in each mix out configuration
464 int debug_flag; ///< used for suppressing repeated error messages output
465 AVFloatDSPContext fdsp;
467 SynthFilterContext synth;
468 DCADSPContext dcadsp;
469 FmtConvertContext fmt_conv;
472 static const uint16_t dca_vlc_offs[] = {
473 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
474 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
475 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
476 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
477 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
478 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
481 static av_cold void dca_init_vlcs(void)
483 static int vlcs_initialized = 0;
485 static VLC_TYPE dca_table[23622][2];
487 if (vlcs_initialized)
490 dca_bitalloc_index.offset = 1;
491 dca_bitalloc_index.wrap = 2;
492 for (i = 0; i < 5; i++) {
493 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
494 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
495 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
496 bitalloc_12_bits[i], 1, 1,
497 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
499 dca_scalefactor.offset = -64;
500 dca_scalefactor.wrap = 2;
501 for (i = 0; i < 5; i++) {
502 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
503 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
504 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
505 scales_bits[i], 1, 1,
506 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
508 dca_tmode.offset = 0;
510 for (i = 0; i < 4; i++) {
511 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
512 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
513 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
515 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
518 for (i = 0; i < 10; i++)
519 for (j = 0; j < 7; j++) {
520 if (!bitalloc_codes[i][j])
522 dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i];
523 dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4);
524 dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
525 dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
527 init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
529 bitalloc_bits[i][j], 1, 1,
530 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
533 vlcs_initialized = 1;
536 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
539 *dst++ = get_bits(gb, bits);
542 static inline int dca_xxch2index(DCAContext *s, int xxch_ch)
546 /* locate channel set containing the channel */
547 for (i = -1, base = 0, mask = (s->xxch_core_spkmask & ~DCA_XXCH_LFE1);
548 i <= s->xxch_chset && !(mask & xxch_ch); mask = s->xxch_spk_masks[++i])
549 base += av_popcount(mask);
551 return base + av_popcount(mask & (xxch_ch - 1));
554 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,
558 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
559 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
560 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
561 int hdr_pos = 0, hdr_size = 0;
562 float sign, mag, scale_factor;
563 int this_chans, acc_mask;
564 int embedded_downmix;
568 /* xxch has arbitrary sized audio coding headers */
570 hdr_pos = get_bits_count(&s->gb);
571 hdr_size = get_bits(&s->gb, 7) + 1;
574 nchans = get_bits(&s->gb, 3) + 1;
575 s->total_channels = nchans + base_channel;
576 s->prim_channels = s->total_channels;
578 /* obtain speaker layout mask & downmix coefficients for XXCH */
580 acc_mask = s->xxch_core_spkmask;
582 this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6;
583 s->xxch_spk_masks[s->xxch_chset] = this_chans;
584 s->xxch_chset_nch[s->xxch_chset] = nchans;
586 for (i = 0; i <= s->xxch_chset; i++)
587 acc_mask |= s->xxch_spk_masks[i];
589 /* check for downmixing information */
590 if (get_bits1(&s->gb)) {
591 embedded_downmix = get_bits1(&s->gb);
593 1.0f / dca_downmix_scale_factors[(get_bits(&s->gb, 6) - 1) << 2];
595 s->xxch_dmix_sf[s->xxch_chset] = scale_factor;
597 for (i = base_channel; i < s->prim_channels; i++) {
598 s->xxch_downmix |= (1 << i);
599 mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask);
602 for (j = base_channel; j < s->prim_channels; j++) {
603 memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0]));
604 s->xxch_dmix_embedded |= (embedded_downmix << j);
605 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
606 if (mask[j] & (1 << i)) {
607 if ((1 << i) == DCA_XXCH_LFE1) {
608 av_log(s->avctx, AV_LOG_WARNING,
609 "DCA-XXCH: dmix to LFE1 not supported.\n");
613 coeff = get_bits(&s->gb, 7);
614 sign = (coeff & 64) ? 1.0 : -1.0;
615 mag = dca_downmix_scale_factors[((coeff & 63) - 1) << 2];
616 ichan = dca_xxch2index(s, 1 << i);
617 s->xxch_dmix_coeff[j][ichan] = sign * mag;
624 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
625 s->prim_channels = DCA_PRIM_CHANNELS_MAX;
628 for (i = base_channel; i < s->prim_channels; i++) {
629 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
630 if (s->subband_activity[i] > DCA_SUBBANDS)
631 s->subband_activity[i] = DCA_SUBBANDS;
633 for (i = base_channel; i < s->prim_channels; i++) {
634 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
635 if (s->vq_start_subband[i] > DCA_SUBBANDS)
636 s->vq_start_subband[i] = DCA_SUBBANDS;
638 get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
639 get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
640 get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
641 get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
643 /* Get codebooks quantization indexes */
645 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
646 for (j = 1; j < 11; j++)
647 for (i = base_channel; i < s->prim_channels; i++)
648 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
650 /* Get scale factor adjustment */
651 for (j = 0; j < 11; j++)
652 for (i = base_channel; i < s->prim_channels; i++)
653 s->scalefactor_adj[i][j] = 1;
655 for (j = 1; j < 11; j++)
656 for (i = base_channel; i < s->prim_channels; i++)
657 if (s->quant_index_huffman[i][j] < thr[j])
658 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
661 if (s->crc_present) {
662 /* Audio header CRC check */
663 get_bits(&s->gb, 16);
666 /* Skip to the end of the header, also ignore CRC if present */
667 i = get_bits_count(&s->gb);
668 if (hdr_pos + 8 * hdr_size > i)
669 skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);
672 s->current_subframe = 0;
673 s->current_subsubframe = 0;
676 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
677 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
678 for (i = base_channel; i < s->prim_channels; i++) {
679 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
680 s->subband_activity[i]);
681 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
682 s->vq_start_subband[i]);
683 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
684 s->joint_intensity[i]);
685 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
686 s->transient_huffman[i]);
687 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
688 s->scalefactor_huffman[i]);
689 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
690 s->bitalloc_huffman[i]);
691 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
692 for (j = 0; j < 11; j++)
693 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
694 av_log(s->avctx, AV_LOG_DEBUG, "\n");
695 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
696 for (j = 0; j < 11; j++)
697 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
698 av_log(s->avctx, AV_LOG_DEBUG, "\n");
705 static int dca_parse_frame_header(DCAContext *s)
707 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
710 skip_bits_long(&s->gb, 32);
713 s->frame_type = get_bits(&s->gb, 1);
714 s->samples_deficit = get_bits(&s->gb, 5) + 1;
715 s->crc_present = get_bits(&s->gb, 1);
716 s->sample_blocks = get_bits(&s->gb, 7) + 1;
717 s->frame_size = get_bits(&s->gb, 14) + 1;
718 if (s->frame_size < 95)
719 return AVERROR_INVALIDDATA;
720 s->amode = get_bits(&s->gb, 6);
721 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
723 return AVERROR_INVALIDDATA;
724 s->bit_rate_index = get_bits(&s->gb, 5);
725 s->bit_rate = dca_bit_rates[s->bit_rate_index];
727 return AVERROR_INVALIDDATA;
729 s->downmix = get_bits(&s->gb, 1); /* note: this is FixedBit == 0 */
730 s->dynrange = get_bits(&s->gb, 1);
731 s->timestamp = get_bits(&s->gb, 1);
732 s->aux_data = get_bits(&s->gb, 1);
733 s->hdcd = get_bits(&s->gb, 1);
734 s->ext_descr = get_bits(&s->gb, 3);
735 s->ext_coding = get_bits(&s->gb, 1);
736 s->aspf = get_bits(&s->gb, 1);
737 s->lfe = get_bits(&s->gb, 2);
738 s->predictor_history = get_bits(&s->gb, 1);
740 /* TODO: check CRC */
742 s->header_crc = get_bits(&s->gb, 16);
744 s->multirate_inter = get_bits(&s->gb, 1);
745 s->version = get_bits(&s->gb, 4);
746 s->copy_history = get_bits(&s->gb, 2);
747 s->source_pcm_res = get_bits(&s->gb, 3);
748 s->front_sum = get_bits(&s->gb, 1);
749 s->surround_sum = get_bits(&s->gb, 1);
750 s->dialog_norm = get_bits(&s->gb, 4);
752 /* FIXME: channels mixing levels */
753 s->output = s->amode;
755 s->output |= DCA_LFE;
758 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
759 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
760 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
761 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
762 s->sample_blocks, s->sample_blocks * 32);
763 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
764 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
765 s->amode, dca_channels[s->amode]);
766 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
768 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
770 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
771 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
772 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
773 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
774 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
775 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
776 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
777 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
778 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
779 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
780 s->predictor_history);
781 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
782 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
784 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
785 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
786 av_log(s->avctx, AV_LOG_DEBUG,
787 "source pcm resolution: %i (%i bits/sample)\n",
788 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
789 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
790 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
791 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
792 av_log(s->avctx, AV_LOG_DEBUG, "\n");
795 /* Primary audio coding header */
796 s->subframes = get_bits(&s->gb, 4) + 1;
798 return dca_parse_audio_coding_header(s, 0, 0);
802 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
805 /* huffman encoded */
806 value += get_bitalloc(gb, &dca_scalefactor, level);
807 value = av_clip(value, 0, (1 << log2range) - 1);
808 } else if (level < 8) {
809 if (level + 1 > log2range) {
810 skip_bits(gb, level + 1 - log2range);
811 value = get_bits(gb, log2range);
813 value = get_bits(gb, level + 1);
819 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
821 /* Primary audio coding side information */
824 if (get_bits_left(&s->gb) < 0)
825 return AVERROR_INVALIDDATA;
828 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
829 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
832 for (j = base_channel; j < s->prim_channels; j++) {
833 for (k = 0; k < s->subband_activity[j]; k++)
834 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
837 /* Get prediction codebook */
838 for (j = base_channel; j < s->prim_channels; j++) {
839 for (k = 0; k < s->subband_activity[j]; k++) {
840 if (s->prediction_mode[j][k] > 0) {
841 /* (Prediction coefficient VQ address) */
842 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
847 /* Bit allocation index */
848 for (j = base_channel; j < s->prim_channels; j++) {
849 for (k = 0; k < s->vq_start_subband[j]; k++) {
850 if (s->bitalloc_huffman[j] == 6)
851 s->bitalloc[j][k] = get_bits(&s->gb, 5);
852 else if (s->bitalloc_huffman[j] == 5)
853 s->bitalloc[j][k] = get_bits(&s->gb, 4);
854 else if (s->bitalloc_huffman[j] == 7) {
855 av_log(s->avctx, AV_LOG_ERROR,
856 "Invalid bit allocation index\n");
857 return AVERROR_INVALIDDATA;
860 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
863 if (s->bitalloc[j][k] > 26) {
864 // av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index [%i][%i] too big (%i)\n",
865 // j, k, s->bitalloc[j][k]);
866 return AVERROR_INVALIDDATA;
871 /* Transition mode */
872 for (j = base_channel; j < s->prim_channels; j++) {
873 for (k = 0; k < s->subband_activity[j]; k++) {
874 s->transition_mode[j][k] = 0;
875 if (s->subsubframes[s->current_subframe] > 1 &&
876 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
877 s->transition_mode[j][k] =
878 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
883 if (get_bits_left(&s->gb) < 0)
884 return AVERROR_INVALIDDATA;
886 for (j = base_channel; j < s->prim_channels; j++) {
887 const uint32_t *scale_table;
888 int scale_sum, log_size;
890 memset(s->scale_factor[j], 0,
891 s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
893 if (s->scalefactor_huffman[j] == 6) {
894 scale_table = scale_factor_quant7;
897 scale_table = scale_factor_quant6;
901 /* When huffman coded, only the difference is encoded */
904 for (k = 0; k < s->subband_activity[j]; k++) {
905 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
906 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
907 s->scale_factor[j][k][0] = scale_table[scale_sum];
910 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
911 /* Get second scale factor */
912 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
913 s->scale_factor[j][k][1] = scale_table[scale_sum];
918 /* Joint subband scale factor codebook select */
919 for (j = base_channel; j < s->prim_channels; j++) {
920 /* Transmitted only if joint subband coding enabled */
921 if (s->joint_intensity[j] > 0)
922 s->joint_huff[j] = get_bits(&s->gb, 3);
925 if (get_bits_left(&s->gb) < 0)
926 return AVERROR_INVALIDDATA;
928 /* Scale factors for joint subband coding */
929 for (j = base_channel; j < s->prim_channels; j++) {
932 /* Transmitted only if joint subband coding enabled */
933 if (s->joint_intensity[j] > 0) {
935 source_channel = s->joint_intensity[j] - 1;
937 /* When huffman coded, only the difference is encoded
938 * (is this valid as well for joint scales ???) */
940 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
941 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
942 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
945 if (!(s->debug_flag & 0x02)) {
946 av_log(s->avctx, AV_LOG_DEBUG,
947 "Joint stereo coding not supported\n");
948 s->debug_flag |= 0x02;
953 /* Stereo downmix coefficients */
954 if (!base_channel && s->prim_channels > 2) {
956 for (j = base_channel; j < s->prim_channels; j++) {
957 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
958 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
961 int am = s->amode & DCA_CHANNEL_MASK;
962 if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
963 av_log(s->avctx, AV_LOG_ERROR,
964 "Invalid channel mode %d\n", am);
965 return AVERROR_INVALIDDATA;
967 for (j = base_channel; j < FFMIN(s->prim_channels, FF_ARRAY_ELEMS(dca_default_coeffs[am])); j++) {
968 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
969 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
974 /* Dynamic range coefficient */
975 if (!base_channel && s->dynrange)
976 s->dynrange_coef = get_bits(&s->gb, 8);
978 /* Side information CRC check word */
979 if (s->crc_present) {
980 get_bits(&s->gb, 16);
984 * Primary audio data arrays
987 /* VQ encoded high frequency subbands */
988 for (j = base_channel; j < s->prim_channels; j++)
989 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
990 /* 1 vector -> 32 samples */
991 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
993 /* Low frequency effect data */
994 if (!base_channel && s->lfe) {
997 int lfe_samples = 2 * s->lfe * (4 + block_index);
998 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
1001 for (j = lfe_samples; j < lfe_end_sample; j++) {
1002 /* Signed 8 bits int */
1003 s->lfe_data[j] = get_sbits(&s->gb, 8);
1006 /* Scale factor index */
1007 quant7 = get_bits(&s->gb, 8);
1009 av_log_ask_for_sample(s->avctx, "LFEScaleIndex larger than 127\n");
1010 return AVERROR_INVALIDDATA;
1012 s->lfe_scale_factor = scale_factor_quant7[quant7];
1014 /* Quantization step size * scale factor */
1015 lfe_scale = 0.035 * s->lfe_scale_factor;
1017 for (j = lfe_samples; j < lfe_end_sample; j++)
1018 s->lfe_data[j] *= lfe_scale;
1022 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
1023 s->subsubframes[s->current_subframe]);
1024 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
1025 s->partial_samples[s->current_subframe]);
1027 for (j = base_channel; j < s->prim_channels; j++) {
1028 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
1029 for (k = 0; k < s->subband_activity[j]; k++)
1030 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
1031 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1033 for (j = base_channel; j < s->prim_channels; j++) {
1034 for (k = 0; k < s->subband_activity[j]; k++)
1035 av_log(s->avctx, AV_LOG_DEBUG,
1036 "prediction coefs: %f, %f, %f, %f\n",
1037 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
1038 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
1039 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
1040 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
1042 for (j = base_channel; j < s->prim_channels; j++) {
1043 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
1044 for (k = 0; k < s->vq_start_subband[j]; k++)
1045 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
1046 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1048 for (j = base_channel; j < s->prim_channels; j++) {
1049 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
1050 for (k = 0; k < s->subband_activity[j]; k++)
1051 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
1052 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1054 for (j = base_channel; j < s->prim_channels; j++) {
1055 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
1056 for (k = 0; k < s->subband_activity[j]; k++) {
1057 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
1058 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
1059 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
1060 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
1062 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1064 for (j = base_channel; j < s->prim_channels; j++) {
1065 if (s->joint_intensity[j] > 0) {
1066 int source_channel = s->joint_intensity[j] - 1;
1067 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
1068 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
1069 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
1070 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1073 if (!base_channel && s->prim_channels > 2 && s->downmix) {
1074 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
1075 for (j = 0; j < s->prim_channels; j++) {
1076 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
1077 dca_downmix_coeffs[s->downmix_coef[j][0]]);
1078 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
1079 dca_downmix_coeffs[s->downmix_coef[j][1]]);
1081 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1083 for (j = base_channel; j < s->prim_channels; j++)
1084 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
1085 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
1086 if (!base_channel && s->lfe) {
1087 int lfe_samples = 2 * s->lfe * (4 + block_index);
1088 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
1090 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
1091 for (j = lfe_samples; j < lfe_end_sample; j++)
1092 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
1093 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1100 static void qmf_32_subbands(DCAContext *s, int chans,
1101 float samples_in[32][8], float *samples_out,
1104 const float *prCoeff;
1107 int sb_act = s->subband_activity[chans];
1110 scale *= sqrt(1 / 8.0);
1113 if (!s->multirate_inter) /* Non-perfect reconstruction */
1114 prCoeff = fir_32bands_nonperfect;
1115 else /* Perfect reconstruction */
1116 prCoeff = fir_32bands_perfect;
1118 for (i = sb_act; i < 32; i++)
1121 /* Reconstructed channel sample index */
1122 for (subindex = 0; subindex < 8; subindex++) {
1123 /* Load in one sample from each subband and clear inactive subbands */
1124 for (i = 0; i < sb_act; i++) {
1125 unsigned sign = (i - 1) & 2;
1126 uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
1127 AV_WN32A(&s->raXin[i], v);
1130 s->synth.synth_filter_float(&s->imdct,
1131 s->subband_fir_hist[chans],
1132 &s->hist_index[chans],
1133 s->subband_fir_noidea[chans], prCoeff,
1134 samples_out, s->raXin, scale);
1139 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
1140 int num_deci_sample, float *samples_in,
1141 float *samples_out, float scale)
1143 /* samples_in: An array holding decimated samples.
1144 * Samples in current subframe starts from samples_in[0],
1145 * while samples_in[-1], samples_in[-2], ..., stores samples
1146 * from last subframe as history.
1148 * samples_out: An array holding interpolated samples
1152 const float *prCoeff;
1155 /* Select decimation filter */
1156 if (decimation_select == 1) {
1158 prCoeff = lfe_fir_128;
1161 prCoeff = lfe_fir_64;
1164 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
1165 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
1167 samples_out += 2 * decifactor;
1171 /* downmixing routines */
1172 #define MIX_REAR1(samples, si1, rs, coef) \
1173 samples[i] += samples[si1] * coef[rs][0]; \
1174 samples[i+256] += samples[si1] * coef[rs][1];
1176 #define MIX_REAR2(samples, si1, si2, rs, coef) \
1177 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs + 1][0]; \
1178 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs + 1][1];
1180 #define MIX_FRONT3(samples, coef) \
1181 t = samples[i + c]; \
1182 u = samples[i + l]; \
1183 v = samples[i + r]; \
1184 samples[i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1185 samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1187 #define DOWNMIX_TO_STEREO(op1, op2) \
1188 for (i = 0; i < 256; i++) { \
1193 static void dca_downmix(float *samples, int srcfmt,
1194 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
1195 const int8_t *channel_mapping)
1197 int c, l, r, sl, sr, s;
1200 float coef[DCA_PRIM_CHANNELS_MAX][2];
1202 for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
1203 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
1204 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
1210 case DCA_STEREO_TOTAL:
1211 case DCA_STEREO_SUMDIFF:
1213 av_log(NULL, 0, "Not implemented!\n");
1218 c = channel_mapping[0] * 256;
1219 l = channel_mapping[1] * 256;
1220 r = channel_mapping[2] * 256;
1221 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1224 s = channel_mapping[2] * 256;
1225 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef), );
1228 c = channel_mapping[0] * 256;
1229 l = channel_mapping[1] * 256;
1230 r = channel_mapping[2] * 256;
1231 s = channel_mapping[3] * 256;
1232 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1233 MIX_REAR1(samples, i + s, 3, coef));
1236 sl = channel_mapping[2] * 256;
1237 sr = channel_mapping[3] * 256;
1238 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef), );
1241 c = channel_mapping[0] * 256;
1242 l = channel_mapping[1] * 256;
1243 r = channel_mapping[2] * 256;
1244 sl = channel_mapping[3] * 256;
1245 sr = channel_mapping[4] * 256;
1246 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1247 MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1253 #ifndef decode_blockcodes
1254 /* Very compact version of the block code decoder that does not use table
1255 * look-up but is slightly slower */
1256 static int decode_blockcode(int code, int levels, int *values)
1259 int offset = (levels - 1) >> 1;
1261 for (i = 0; i < 4; i++) {
1262 int div = FASTDIV(code, levels);
1263 values[i] = code - offset - div * levels;
1270 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1272 return decode_blockcode(code1, levels, values) |
1273 decode_blockcode(code2, levels, values + 4);
1277 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1278 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1280 #ifndef int8x8_fmul_int32
1281 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1283 float fscale = scale / 16.0;
1285 for (i = 0; i < 8; i++)
1286 dst[i] = src[i] * fscale;
1290 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1293 int subsubframe = s->current_subsubframe;
1295 const float *quant_step_table;
1298 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1299 LOCAL_ALIGNED_16(int, block, [8]);
1305 /* Select quantization step size table */
1306 if (s->bit_rate_index == 0x1f)
1307 quant_step_table = lossless_quant_d;
1309 quant_step_table = lossy_quant_d;
1311 for (k = base_channel; k < s->prim_channels; k++) {
1312 if (get_bits_left(&s->gb) < 0)
1313 return AVERROR_INVALIDDATA;
1315 for (l = 0; l < s->vq_start_subband[k]; l++) {
1318 /* Select the mid-tread linear quantizer */
1319 int abits = s->bitalloc[k][l];
1321 float quant_step_size = quant_step_table[abits];
1324 * Determine quantization index code book and its type
1327 /* Select quantization index code book */
1328 int sel = s->quant_index_huffman[k][abits];
1331 * Extract bits from the bit stream
1334 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1336 /* Deal with transients */
1337 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1338 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
1339 s->scalefactor_adj[k][sel];
1341 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1344 int block_code1, block_code2, size, levels, err;
1346 size = abits_sizes[abits - 1];
1347 levels = abits_levels[abits - 1];
1349 block_code1 = get_bits(&s->gb, size);
1350 block_code2 = get_bits(&s->gb, size);
1351 err = decode_blockcodes(block_code1, block_code2,
1354 av_log(s->avctx, AV_LOG_ERROR,
1355 "ERROR: block code look-up failed\n");
1356 return AVERROR_INVALIDDATA;
1360 for (m = 0; m < 8; m++)
1361 block[m] = get_sbits(&s->gb, abits - 3);
1365 for (m = 0; m < 8; m++)
1366 block[m] = get_bitalloc(&s->gb,
1367 &dca_smpl_bitalloc[abits], sel);
1370 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1375 * Inverse ADPCM if in prediction mode
1377 if (s->prediction_mode[k][l]) {
1379 for (m = 0; m < 8; m++) {
1380 for (n = 1; n <= 4; n++)
1382 subband_samples[k][l][m] +=
1383 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1384 subband_samples[k][l][m - n] / 8192);
1385 else if (s->predictor_history)
1386 subband_samples[k][l][m] +=
1387 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1388 s->subband_samples_hist[k][l][m - n + 4] / 8192);
1394 * Decode VQ encoded high frequencies
1396 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1397 /* 1 vector -> 32 samples but we only need the 8 samples
1398 * for this subsubframe. */
1399 int hfvq = s->high_freq_vq[k][l];
1401 if (!s->debug_flag & 0x01) {
1402 av_log(s->avctx, AV_LOG_DEBUG,
1403 "Stream with high frequencies VQ coding\n");
1404 s->debug_flag |= 0x01;
1407 int8x8_fmul_int32(subband_samples[k][l],
1408 &high_freq_vq[hfvq][subsubframe * 8],
1409 s->scale_factor[k][l][0]);
1413 /* Check for DSYNC after subsubframe */
1414 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1415 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1417 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1420 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1424 /* Backup predictor history for adpcm */
1425 for (k = base_channel; k < s->prim_channels; k++)
1426 for (l = 0; l < s->vq_start_subband[k]; l++)
1427 memcpy(s->subband_samples_hist[k][l],
1428 &subband_samples[k][l][4],
1429 4 * sizeof(subband_samples[0][0][0]));
1434 static int dca_filter_channels(DCAContext *s, int block_index)
1436 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1439 /* 32 subbands QMF */
1440 for (k = 0; k < s->prim_channels; k++) {
1441 /* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1442 0, 8388608.0, 8388608.0 };*/
1443 qmf_32_subbands(s, k, subband_samples[k],
1444 &s->samples[256 * s->channel_order_tab[k]],
1445 M_SQRT1_2 * s->scale_bias /* pcm_to_double[s->source_pcm_res] */);
1449 if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1450 dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
1453 /* Generate LFE samples for this subsubframe FIXME!!! */
1454 if (s->output & DCA_LFE) {
1455 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1456 s->lfe_data + 2 * s->lfe * (block_index + 4),
1457 &s->samples[256 * s->lfe_index],
1458 (1.0 / 256.0) * s->scale_bias);
1459 /* Outputs 20bits pcm samples */
1466 static int dca_subframe_footer(DCAContext *s, int base_channel)
1468 int aux_data_count = 0, i;
1471 * Unpack optional information
1474 /* presumably optional information only appears in the core? */
1475 if (!base_channel) {
1477 skip_bits_long(&s->gb, 32);
1480 aux_data_count = get_bits(&s->gb, 6);
1482 for (i = 0; i < aux_data_count; i++)
1483 get_bits(&s->gb, 8);
1485 if (s->crc_present && (s->downmix || s->dynrange))
1486 get_bits(&s->gb, 16);
1493 * Decode a dca frame block
1495 * @param s pointer to the DCAContext
1498 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1503 if (s->current_subframe >= s->subframes) {
1504 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1505 s->current_subframe, s->subframes);
1506 return AVERROR_INVALIDDATA;
1509 if (!s->current_subsubframe) {
1511 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1513 /* Read subframe header */
1514 if ((ret = dca_subframe_header(s, base_channel, block_index)))
1518 /* Read subsubframe */
1520 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1522 if ((ret = dca_subsubframe(s, base_channel, block_index)))
1526 s->current_subsubframe++;
1527 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1528 s->current_subsubframe = 0;
1529 s->current_subframe++;
1531 if (s->current_subframe >= s->subframes) {
1533 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1535 /* Read subframe footer */
1536 if ((ret = dca_subframe_footer(s, base_channel)))
1544 * Return the number of channels in an ExSS speaker mask (HD)
1546 static int dca_exss_mask2count(int mask)
1548 /* count bits that mean speaker pairs twice */
1549 return av_popcount(mask) +
1550 av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
1551 DCA_EXSS_FRONT_LEFT_RIGHT |
1552 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
1553 DCA_EXSS_WIDE_LEFT_RIGHT |
1554 DCA_EXSS_SIDE_LEFT_RIGHT |
1555 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
1556 DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
1557 DCA_EXSS_REAR_LEFT_RIGHT |
1558 DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1562 * Skip mixing coefficients of a single mix out configuration (HD)
1564 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1568 for (i = 0; i < channels; i++) {
1569 int mix_map_mask = get_bits(gb, out_ch);
1570 int num_coeffs = av_popcount(mix_map_mask);
1571 skip_bits_long(gb, num_coeffs * 6);
1576 * Parse extension substream asset header (HD)
1578 static int dca_exss_parse_asset_header(DCAContext *s)
1580 int header_pos = get_bits_count(&s->gb);
1583 int embedded_stereo = 0;
1584 int embedded_6ch = 0;
1585 int drc_code_present;
1586 int av_uninit(extensions_mask);
1589 if (get_bits_left(&s->gb) < 16)
1592 /* We will parse just enough to get to the extensions bitmask with which
1593 * we can set the profile value. */
1595 header_size = get_bits(&s->gb, 9) + 1;
1596 skip_bits(&s->gb, 3); // asset index
1598 if (s->static_fields) {
1599 if (get_bits1(&s->gb))
1600 skip_bits(&s->gb, 4); // asset type descriptor
1601 if (get_bits1(&s->gb))
1602 skip_bits_long(&s->gb, 24); // language descriptor
1604 if (get_bits1(&s->gb)) {
1605 /* How can one fit 1024 bytes of text here if the maximum value
1606 * for the asset header size field above was 512 bytes? */
1607 int text_length = get_bits(&s->gb, 10) + 1;
1608 if (get_bits_left(&s->gb) < text_length * 8)
1610 skip_bits_long(&s->gb, text_length * 8); // info text
1613 skip_bits(&s->gb, 5); // bit resolution - 1
1614 skip_bits(&s->gb, 4); // max sample rate code
1615 channels = get_bits(&s->gb, 8) + 1;
1617 if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1618 int spkr_remap_sets;
1619 int spkr_mask_size = 16;
1623 embedded_stereo = get_bits1(&s->gb);
1625 embedded_6ch = get_bits1(&s->gb);
1627 if (get_bits1(&s->gb)) {
1628 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1629 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1632 spkr_remap_sets = get_bits(&s->gb, 3);
1634 for (i = 0; i < spkr_remap_sets; i++) {
1635 /* std layout mask for each remap set */
1636 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1639 for (i = 0; i < spkr_remap_sets; i++) {
1640 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1641 if (get_bits_left(&s->gb) < 0)
1644 for (j = 0; j < num_spkrs[i]; j++) {
1645 int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1646 int num_dec_ch = av_popcount(remap_dec_ch_mask);
1647 skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1652 skip_bits(&s->gb, 3); // representation type
1656 drc_code_present = get_bits1(&s->gb);
1657 if (drc_code_present)
1658 get_bits(&s->gb, 8); // drc code
1660 if (get_bits1(&s->gb))
1661 skip_bits(&s->gb, 5); // dialog normalization code
1663 if (drc_code_present && embedded_stereo)
1664 get_bits(&s->gb, 8); // drc stereo code
1666 if (s->mix_metadata && get_bits1(&s->gb)) {
1667 skip_bits(&s->gb, 1); // external mix
1668 skip_bits(&s->gb, 6); // post mix gain code
1670 if (get_bits(&s->gb, 2) != 3) // mixer drc code
1671 skip_bits(&s->gb, 3); // drc limit
1673 skip_bits(&s->gb, 8); // custom drc code
1675 if (get_bits1(&s->gb)) // channel specific scaling
1676 for (i = 0; i < s->num_mix_configs; i++)
1677 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1679 skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1681 for (i = 0; i < s->num_mix_configs; i++) {
1682 if (get_bits_left(&s->gb) < 0)
1684 dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1686 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1687 if (embedded_stereo)
1688 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1692 switch (get_bits(&s->gb, 2)) {
1693 case 0: extensions_mask = get_bits(&s->gb, 12); break;
1694 case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1695 case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1696 case 3: extensions_mask = 0; /* aux coding */ break;
1699 /* not parsed further, we were only interested in the extensions mask */
1701 if (get_bits_left(&s->gb) < 0)
1704 if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1705 av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1708 skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1710 if (extensions_mask & DCA_EXT_EXSS_XLL)
1711 s->profile = FF_PROFILE_DTS_HD_MA;
1712 else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1714 s->profile = FF_PROFILE_DTS_HD_HRA;
1716 if (!(extensions_mask & DCA_EXT_CORE))
1717 av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1718 if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1719 av_log(s->avctx, AV_LOG_WARNING,
1720 "DTS extensions detection mismatch (%d, %d)\n",
1721 extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1726 static int dca_xbr_parse_frame(DCAContext *s)
1728 int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];
1729 int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];
1730 int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS];
1731 int anctemp[DCA_CHSET_CHANS_MAX];
1732 int chset_fsize[DCA_CHSETS_MAX];
1733 int n_xbr_ch[DCA_CHSETS_MAX];
1734 int hdr_size, num_chsets, xbr_tmode, hdr_pos;
1735 int i, j, k, l, chset, chan_base;
1737 av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n");
1739 /* get bit position of sync header */
1740 hdr_pos = get_bits_count(&s->gb) - 32;
1742 hdr_size = get_bits(&s->gb, 6) + 1;
1743 num_chsets = get_bits(&s->gb, 2) + 1;
1745 for(i = 0; i < num_chsets; i++)
1746 chset_fsize[i] = get_bits(&s->gb, 14) + 1;
1748 xbr_tmode = get_bits1(&s->gb);
1750 for(i = 0; i < num_chsets; i++) {
1751 n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;
1752 k = get_bits(&s->gb, 2) + 5;
1753 for(j = 0; j < n_xbr_ch[i]; j++)
1754 active_bands[i][j] = get_bits(&s->gb, k) + 1;
1757 /* skip to the end of the header */
1758 i = get_bits_count(&s->gb);
1759 if(hdr_pos + hdr_size * 8 > i)
1760 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1762 /* loop over the channel data sets */
1763 /* only decode as many channels as we've decoded base data for */
1764 for(chset = 0, chan_base = 0;
1765 chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels;
1766 chan_base += n_xbr_ch[chset++]) {
1767 int start_posn = get_bits_count(&s->gb);
1768 int subsubframe = 0;
1771 /* loop over subframes */
1772 for (k = 0; k < (s->sample_blocks / 8); k++) {
1773 /* parse header if we're on first subsubframe of a block */
1774 if(subsubframe == 0) {
1775 /* Parse subframe header */
1776 for(i = 0; i < n_xbr_ch[chset]; i++) {
1777 anctemp[i] = get_bits(&s->gb, 2) + 2;
1780 for(i = 0; i < n_xbr_ch[chset]; i++) {
1781 get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]);
1784 for(i = 0; i < n_xbr_ch[chset]; i++) {
1785 anctemp[i] = get_bits(&s->gb, 3);
1786 if(anctemp[i] < 1) {
1787 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n");
1788 return AVERROR_INVALIDDATA;
1792 /* generate scale factors */
1793 for(i = 0; i < n_xbr_ch[chset]; i++) {
1794 const uint32_t *scale_table;
1797 if (s->scalefactor_huffman[chan_base+i] == 6) {
1798 scale_table = scale_factor_quant7;
1800 scale_table = scale_factor_quant6;
1805 for(j = 0; j < active_bands[chset][i]; j++) {
1806 if(abits_high[i][j] > 0) {
1807 scale_table_high[i][j][0] =
1808 scale_table[get_bits(&s->gb, nbits)];
1810 if(xbr_tmode && s->transition_mode[i][j]) {
1811 scale_table_high[i][j][1] =
1812 scale_table[get_bits(&s->gb, nbits)];
1819 /* decode audio array for this block */
1820 for(i = 0; i < n_xbr_ch[chset]; i++) {
1821 for(j = 0; j < active_bands[chset][i]; j++) {
1822 const int xbr_abits = abits_high[i][j];
1823 const float quant_step_size = lossless_quant_d[xbr_abits];
1824 const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j];
1825 const float rscale = quant_step_size * scale_table_high[i][j][sfi];
1826 float *subband_samples = s->subband_samples[k][chan_base+i][j];
1833 get_array(&s->gb, block, 8, xbr_abits - 3);
1835 int block_code1, block_code2, size, levels, err;
1837 size = abits_sizes[xbr_abits - 1];
1838 levels = abits_levels[xbr_abits - 1];
1840 block_code1 = get_bits(&s->gb, size);
1841 block_code2 = get_bits(&s->gb, size);
1842 err = decode_blockcodes(block_code1, block_code2,
1845 av_log(s->avctx, AV_LOG_ERROR,
1846 "ERROR: DTS-XBR: block code look-up failed\n");
1847 return AVERROR_INVALIDDATA;
1851 /* scale & sum into subband */
1852 for(l = 0; l < 8; l++)
1853 subband_samples[l] += (float)block[l] * rscale;
1857 /* check DSYNC marker */
1858 if(s->aspf || subsubframe == s->subsubframes[subframe] - 1) {
1859 if(get_bits(&s->gb, 16) != 0xffff) {
1860 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n");
1861 return AVERROR_INVALIDDATA;
1865 /* advance sub-sub-frame index */
1866 if(++subsubframe >= s->subsubframes[subframe]) {
1872 /* skip to next channel set */
1873 i = get_bits_count(&s->gb);
1874 if(start_posn + chset_fsize[chset] * 8 != i) {
1875 j = start_posn + chset_fsize[chset] * 8 - i;
1877 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set,"
1878 " skipping further than expected (%d bits)\n", j);
1879 skip_bits_long(&s->gb, j);
1886 /* parse initial header for XXCH and dump details */
1887 static int dca_xxch_decode_frame(DCAContext *s)
1889 int hdr_size, chhdr_crc, spkmsk_bits, num_chsets, core_spk, hdr_pos;
1890 int i, chset, base_channel, chstart, fsize[8];
1892 /* assume header word has already been parsed */
1893 hdr_pos = get_bits_count(&s->gb) - 32;
1894 hdr_size = get_bits(&s->gb, 6) + 1;
1895 chhdr_crc = get_bits1(&s->gb);
1896 spkmsk_bits = get_bits(&s->gb, 5) + 1;
1897 num_chsets = get_bits(&s->gb, 2) + 1;
1899 for (i = 0; i < num_chsets; i++)
1900 fsize[i] = get_bits(&s->gb, 14) + 1;
1902 core_spk = get_bits(&s->gb, spkmsk_bits);
1903 s->xxch_core_spkmask = core_spk;
1904 s->xxch_nbits_spk_mask = spkmsk_bits;
1905 s->xxch_downmix = 0;
1906 s->xxch_dmix_embedded = 0;
1908 /* skip to the end of the header */
1909 i = get_bits_count(&s->gb);
1910 if (hdr_pos + hdr_size * 8 > i)
1911 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1913 for (chset = 0; chset < num_chsets; chset++) {
1914 chstart = get_bits_count(&s->gb);
1915 base_channel = s->prim_channels;
1916 s->xxch_chset = chset;
1918 /* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs.
1919 5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */
1920 dca_parse_audio_coding_header(s, base_channel, 1);
1922 /* decode channel data */
1923 for (i = 0; i < (s->sample_blocks / 8); i++) {
1924 if (dca_decode_block(s, base_channel, i)) {
1925 av_log(s->avctx, AV_LOG_ERROR,
1926 "Error decoding DTS-XXCH extension\n");
1931 /* skip to end of this section */
1932 i = get_bits_count(&s->gb);
1933 if (chstart + fsize[chset] * 8 > i)
1934 skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i);
1936 s->xxch_chset = num_chsets;
1942 * Parse extension substream header (HD)
1944 static void dca_exss_parse_header(DCAContext *s)
1951 int active_ss_mask[8];
1957 if (get_bits_left(&s->gb) < 52)
1960 start_posn = get_bits_count(&s->gb) - 32;
1962 skip_bits(&s->gb, 8); // user data
1963 ss_index = get_bits(&s->gb, 2);
1965 blownup = get_bits1(&s->gb);
1966 hdrsize = get_bits(&s->gb, 8 + 4 * blownup) + 1; // header_size
1967 skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1969 s->static_fields = get_bits1(&s->gb);
1970 if (s->static_fields) {
1971 skip_bits(&s->gb, 2); // reference clock code
1972 skip_bits(&s->gb, 3); // frame duration code
1974 if (get_bits1(&s->gb))
1975 skip_bits_long(&s->gb, 36); // timestamp
1977 /* a single stream can contain multiple audio assets that can be
1978 * combined to form multiple audio presentations */
1980 num_audiop = get_bits(&s->gb, 3) + 1;
1981 if (num_audiop > 1) {
1982 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1983 /* ignore such streams for now */
1987 num_assets = get_bits(&s->gb, 3) + 1;
1988 if (num_assets > 1) {
1989 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1990 /* ignore such streams for now */
1994 for (i = 0; i < num_audiop; i++)
1995 active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1997 for (i = 0; i < num_audiop; i++)
1998 for (j = 0; j <= ss_index; j++)
1999 if (active_ss_mask[i] & (1 << j))
2000 skip_bits(&s->gb, 8); // active asset mask
2002 s->mix_metadata = get_bits1(&s->gb);
2003 if (s->mix_metadata) {
2004 int mix_out_mask_size;
2006 skip_bits(&s->gb, 2); // adjustment level
2007 mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
2008 s->num_mix_configs = get_bits(&s->gb, 2) + 1;
2010 for (i = 0; i < s->num_mix_configs; i++) {
2011 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
2012 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
2017 for (i = 0; i < num_assets; i++)
2018 asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup);
2020 for (i = 0; i < num_assets; i++) {
2021 if (dca_exss_parse_asset_header(s))
2025 /* not parsed further, we were only interested in the extensions mask
2026 * from the asset header */
2028 if (num_assets > 0) {
2029 j = get_bits_count(&s->gb);
2030 if (start_posn + hdrsize * 8 > j)
2031 skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j);
2033 for (i = 0; i < num_assets; i++) {
2034 start_posn = get_bits_count(&s->gb);
2035 mkr = get_bits_long(&s->gb, 32);
2037 /* parse extensions that we know about */
2038 if (mkr == 0x655e315e) {
2039 dca_xbr_parse_frame(s);
2040 } else if (mkr == 0x47004a03) {
2041 dca_xxch_decode_frame(s);
2042 s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
2044 av_log(s->avctx, AV_LOG_DEBUG,
2045 "DTS-ExSS: unknown marker = 0x%08x\n", mkr);
2048 /* skip to end of block */
2049 j = get_bits_count(&s->gb);
2050 if (start_posn + asset_size[i] * 8 > j)
2051 skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j);
2057 * Main frame decoding function
2058 * FIXME add arguments
2060 static int dca_decode_frame(AVCodecContext *avctx, void *data,
2061 int *got_frame_ptr, AVPacket *avpkt)
2063 const uint8_t *buf = avpkt->data;
2064 int buf_size = avpkt->size;
2068 int num_core_channels = 0;
2073 int16_t *samples_s16;
2074 DCAContext *s = avctx->priv_data;
2089 s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
2090 DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
2091 if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
2092 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
2093 return AVERROR_INVALIDDATA;
2096 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
2097 if ((ret = dca_parse_frame_header(s)) < 0) {
2098 //seems like the frame is corrupt, try with the next one
2101 //set AVCodec values with parsed data
2102 avctx->sample_rate = s->sample_rate;
2103 avctx->bit_rate = s->bit_rate;
2105 s->profile = FF_PROFILE_DTS;
2107 for (i = 0; i < (s->sample_blocks / 8); i++) {
2108 if ((ret = dca_decode_block(s, 0, i))) {
2109 av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
2114 /* record number of core channels incase less than max channels are requested */
2115 num_core_channels = s->prim_channels;
2118 s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
2120 s->core_ext_mask = 0;
2122 core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
2124 /* only scan for extensions if ext_descr was unknown or indicated a
2125 * supported XCh extension */
2126 if (s->core_ext_mask < 0 || s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH)) {
2128 /* if ext_descr was unknown, clear s->core_ext_mask so that the
2129 * extensions scan can fill it up */
2130 s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
2132 /* extensions start at 32-bit boundaries into bitstream */
2133 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2135 while (core_ss_end - get_bits_count(&s->gb) >= 32) {
2136 uint32_t bits = get_bits_long(&s->gb, 32);
2140 int ext_amode, xch_fsize;
2142 s->xch_base_channel = s->prim_channels;
2144 /* validate sync word using XCHFSIZE field */
2145 xch_fsize = show_bits(&s->gb, 10);
2146 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
2147 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
2150 /* skip length-to-end-of-frame field for the moment */
2151 skip_bits(&s->gb, 10);
2153 s->core_ext_mask |= DCA_EXT_XCH;
2155 /* extension amode(number of channels in extension) should be 1 */
2156 /* AFAIK XCh is not used for more channels */
2157 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
2158 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
2159 " supported!\n", ext_amode);
2163 /* much like core primary audio coding header */
2164 dca_parse_audio_coding_header(s, s->xch_base_channel, 0);
2166 for (i = 0; i < (s->sample_blocks / 8); i++)
2167 if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
2168 av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
2176 /* XXCh: extended channels */
2177 /* usually found either in core or HD part in DTS-HD HRA streams,
2178 * but not in DTS-ES which contains XCh extensions instead */
2179 s->core_ext_mask |= DCA_EXT_XXCH;
2180 dca_xxch_decode_frame(s);
2184 int fsize96 = show_bits(&s->gb, 12) + 1;
2185 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
2188 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
2189 get_bits_count(&s->gb));
2190 skip_bits(&s->gb, 12);
2191 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
2192 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
2194 s->core_ext_mask |= DCA_EXT_X96;
2199 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2202 /* no supported extensions, skip the rest of the core substream */
2203 skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
2206 if (s->core_ext_mask & DCA_EXT_X96)
2207 s->profile = FF_PROFILE_DTS_96_24;
2208 else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
2209 s->profile = FF_PROFILE_DTS_ES;
2211 /* check for ExSS (HD part) */
2212 if (s->dca_buffer_size - s->frame_size > 32 &&
2213 get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
2214 dca_exss_parse_header(s);
2216 avctx->profile = s->profile;
2218 channels = s->prim_channels + !!s->lfe;
2220 /* If we have XXCH then the channel layout is managed differently */
2221 /* note that XLL will also have another way to do things */
2222 if (!(s->core_ext_mask & DCA_EXT_XXCH)
2223 || (s->core_ext_mask & DCA_EXT_XXCH && avctx->request_channels > 0
2224 && avctx->request_channels
2225 < num_core_channels + !!s->lfe + s->xxch_chset_nch[0]))
2226 { /* xxx should also do MA extensions */
2227 if (s->amode < 16) {
2228 avctx->channel_layout = dca_core_channel_layout[s->amode];
2230 if (s->xch_present && (!avctx->request_channels ||
2231 avctx->request_channels
2232 > num_core_channels + !!s->lfe)) {
2233 avctx->channel_layout |= AV_CH_BACK_CENTER;
2235 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2236 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
2238 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
2241 channels = num_core_channels + !!s->lfe;
2242 s->xch_present = 0; /* disable further xch processing */
2244 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2245 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
2247 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
2250 if (channels > !!s->lfe &&
2251 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
2252 return AVERROR_INVALIDDATA;
2254 if (avctx->request_channels == 2 && s->prim_channels > 2) {
2256 s->output = DCA_STEREO;
2257 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
2259 else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
2260 static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
2261 s->channel_order_tab = dca_channel_order_native;
2263 s->lfe_index = dca_lfe_index[s->amode];
2265 av_log(avctx, AV_LOG_ERROR,
2266 "Non standard configuration %d !\n", s->amode);
2267 return AVERROR_INVALIDDATA;
2270 s->xxch_downmix = 0;
2272 /* we only get here if an XXCH channel set can be added to the mix */
2273 channel_mask = s->xxch_core_spkmask;
2275 if (avctx->request_channels > 0
2276 && avctx->request_channels < s->prim_channels) {
2277 channels = num_core_channels + !!s->lfe;
2278 for (i = 0; i < s->xxch_chset && channels + s->xxch_chset_nch[i]
2279 <= avctx->request_channels; i++) {
2280 channels += s->xxch_chset_nch[i];
2281 channel_mask |= s->xxch_spk_masks[i];
2284 channels = s->prim_channels + !!s->lfe;
2285 for (i = 0; i < s->xxch_chset; i++) {
2286 channel_mask |= s->xxch_spk_masks[i];
2290 /* Given the DTS spec'ed channel mask, generate an avcodec version */
2292 for (i = 0; i < s->xxch_nbits_spk_mask; ++i) {
2293 if (channel_mask & (1 << i)) {
2294 channel_layout |= map_xxch_to_native[i];
2298 /* make sure that we have managed to get equivelant dts/avcodec channel
2299 * masks in some sense -- unfortunately some channels could overlap */
2300 if (av_popcount(channel_mask) != av_popcount(channel_layout)) {
2301 av_log(avctx, AV_LOG_DEBUG,
2302 "DTS-XXCH: Inconsistant avcodec/dts channel layouts\n");
2303 return AVERROR_INVALIDDATA;
2306 avctx->channel_layout = channel_layout;
2308 if (!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)) {
2309 /* Estimate DTS --> avcodec ordering table */
2310 for (chset = -1, j = 0; chset < s->xxch_chset; ++chset) {
2311 mask = chset >= 0 ? s->xxch_spk_masks[chset]
2312 : s->xxch_core_spkmask;
2313 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
2314 if (mask & ~(DCA_XXCH_LFE1 | DCA_XXCH_LFE2) & (1 << i)) {
2315 lavc = map_xxch_to_native[i];
2316 posn = av_popcount(channel_layout & (lavc - 1));
2317 s->xxch_order_tab[j++] = posn;
2322 s->lfe_index = av_popcount(channel_layout & (AV_CH_LOW_FREQUENCY-1));
2323 } else { /* native ordering */
2324 for (i = 0; i < channels; i++)
2325 s->xxch_order_tab[i] = i;
2327 s->lfe_index = channels - 1;
2330 s->channel_order_tab = s->xxch_order_tab;
2333 if (avctx->channels != channels) {
2334 if (avctx->channels)
2335 av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
2336 avctx->channels = channels;
2339 /* get output buffer */
2340 s->frame.nb_samples = 256 * (s->sample_blocks / 8);
2341 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
2342 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2345 samples_flt = (float *) s->frame.data[0];
2346 samples_s16 = (int16_t *) s->frame.data[0];
2348 /* filter to get final output */
2349 for (i = 0; i < (s->sample_blocks / 8); i++) {
2350 dca_filter_channels(s, i);
2352 /* If this was marked as a DTS-ES stream we need to subtract back- */
2353 /* channel from SL & SR to remove matrixed back-channel signal */
2354 if ((s->source_pcm_res & 1) && s->xch_present) {
2355 float *back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
2356 float *lt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
2357 float *rt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
2358 s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
2359 s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
2362 /* If stream contains XXCH, we might need to undo an embedded downmix */
2363 if (s->xxch_dmix_embedded) {
2364 /* Loop over channel sets in turn */
2365 ch = num_core_channels;
2366 for (chset = 0; chset < s->xxch_chset; chset++) {
2367 endch = ch + s->xxch_chset_nch[chset];
2368 mask = s->xxch_dmix_embedded;
2371 for (j = ch; j < endch; j++) {
2372 if (mask & (1 << j)) { /* this channel has been mixed-out */
2373 src_chan = s->samples + s->channel_order_tab[j] * 256;
2374 for (k = 0; k < endch; k++) {
2375 achan = s->channel_order_tab[k];
2376 scale = s->xxch_dmix_coeff[j][k];
2378 dst_chan = s->samples + achan * 256;
2379 s->fdsp.vector_fmac_scalar(dst_chan, src_chan,
2386 /* if a downmix has been embedded then undo the pre-scaling */
2387 if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) {
2388 scale = s->xxch_dmix_sf[chset];
2390 for (j = 0; j < ch; j++) {
2391 src_chan = s->samples + s->channel_order_tab[j] * 256;
2392 for (k = 0; k < 256; k++)
2393 src_chan[k] *= scale;
2396 /* LFE channel is always part of core, scale if it exists */
2398 src_chan = s->samples + s->lfe_index * 256;
2399 for (k = 0; k < 256; k++)
2400 src_chan[k] *= scale;
2409 if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
2410 s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
2412 samples_flt += 256 * channels;
2414 s->fmt_conv.float_to_int16_interleave(samples_s16,
2415 s->samples_chanptr, 256,
2417 samples_s16 += 256 * channels;
2421 /* update lfe history */
2422 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
2423 for (i = 0; i < 2 * s->lfe * 4; i++)
2424 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
2427 *(AVFrame *) data = s->frame;
2435 * DCA initialization
2437 * @param avctx pointer to the AVCodecContext
2440 static av_cold int dca_decode_init(AVCodecContext *avctx)
2442 DCAContext *s = avctx->priv_data;
2448 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
2449 ff_mdct_init(&s->imdct, 6, 1, 1.0);
2450 ff_synth_filter_init(&s->synth);
2451 ff_dcadsp_init(&s->dcadsp);
2452 ff_fmt_convert_init(&s->fmt_conv, avctx);
2454 for (i = 0; i < DCA_PRIM_CHANNELS_MAX + 1; i++)
2455 s->samples_chanptr[i] = s->samples + i * 256;
2457 if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
2458 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
2459 s->scale_bias = 1.0 / 32768.0;
2461 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
2462 s->scale_bias = 1.0;
2465 /* allow downmixing to stereo */
2466 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
2467 avctx->request_channels == 2) {
2468 avctx->channels = avctx->request_channels;
2471 avcodec_get_frame_defaults(&s->frame);
2472 avctx->coded_frame = &s->frame;
2477 static av_cold int dca_decode_end(AVCodecContext *avctx)
2479 DCAContext *s = avctx->priv_data;
2480 ff_mdct_end(&s->imdct);
2484 static const AVProfile profiles[] = {
2485 { FF_PROFILE_DTS, "DTS" },
2486 { FF_PROFILE_DTS_ES, "DTS-ES" },
2487 { FF_PROFILE_DTS_96_24, "DTS 96/24" },
2488 { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
2489 { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
2490 { FF_PROFILE_UNKNOWN },
2493 AVCodec ff_dca_decoder = {
2495 .type = AVMEDIA_TYPE_AUDIO,
2497 .priv_data_size = sizeof(DCAContext),
2498 .init = dca_decode_init,
2499 .decode = dca_decode_frame,
2500 .close = dca_decode_end,
2501 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
2502 .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
2503 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
2505 AV_SAMPLE_FMT_NONE },
2506 .profiles = NULL_IF_CONFIG_SMALL(profiles),