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"
35 #include "libavutil/samplefmt.h"
44 #include "dca_parser.h"
45 #include "synth_filter.h"
47 #include "fmtconvert.h"
55 #define DCA_PRIM_CHANNELS_MAX (7)
56 #define DCA_SUBBANDS (64)
57 #define DCA_ABITS_MAX (32) /* Should be 28 */
58 #define DCA_SUBSUBFRAMES_MAX (4)
59 #define DCA_SUBFRAMES_MAX (16)
60 #define DCA_BLOCKS_MAX (16)
61 #define DCA_LFE_MAX (3)
62 #define DCA_CHSETS_MAX (4)
63 #define DCA_CHSET_CHANS_MAX (8)
79 /* these are unconfirmed but should be mostly correct */
80 enum DCAExSSSpeakerMask {
81 DCA_EXSS_FRONT_CENTER = 0x0001,
82 DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002,
83 DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004,
84 DCA_EXSS_LFE = 0x0008,
85 DCA_EXSS_REAR_CENTER = 0x0010,
86 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
87 DCA_EXSS_REAR_LEFT_RIGHT = 0x0040,
88 DCA_EXSS_FRONT_HIGH_CENTER = 0x0080,
89 DCA_EXSS_OVERHEAD = 0x0100,
90 DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200,
91 DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400,
92 DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800,
93 DCA_EXSS_LFE2 = 0x1000,
94 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000,
95 DCA_EXSS_REAR_HIGH_CENTER = 0x4000,
96 DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000,
99 enum DCAXxchSpeakerMask {
100 DCA_XXCH_FRONT_CENTER = 0x0000001,
101 DCA_XXCH_FRONT_LEFT = 0x0000002,
102 DCA_XXCH_FRONT_RIGHT = 0x0000004,
103 DCA_XXCH_SIDE_REAR_LEFT = 0x0000008,
104 DCA_XXCH_SIDE_REAR_RIGHT = 0x0000010,
105 DCA_XXCH_LFE1 = 0x0000020,
106 DCA_XXCH_REAR_CENTER = 0x0000040,
107 DCA_XXCH_SURROUND_REAR_LEFT = 0x0000080,
108 DCA_XXCH_SURROUND_REAR_RIGHT = 0x0000100,
109 DCA_XXCH_SIDE_SURROUND_LEFT = 0x0000200,
110 DCA_XXCH_SIDE_SURROUND_RIGHT = 0x0000400,
111 DCA_XXCH_FRONT_CENTER_LEFT = 0x0000800,
112 DCA_XXCH_FRONT_CENTER_RIGHT = 0x0001000,
113 DCA_XXCH_FRONT_HIGH_LEFT = 0x0002000,
114 DCA_XXCH_FRONT_HIGH_CENTER = 0x0004000,
115 DCA_XXCH_FRONT_HIGH_RIGHT = 0x0008000,
116 DCA_XXCH_LFE2 = 0x0010000,
117 DCA_XXCH_SIDE_FRONT_LEFT = 0x0020000,
118 DCA_XXCH_SIDE_FRONT_RIGHT = 0x0040000,
119 DCA_XXCH_OVERHEAD = 0x0080000,
120 DCA_XXCH_SIDE_HIGH_LEFT = 0x0100000,
121 DCA_XXCH_SIDE_HIGH_RIGHT = 0x0200000,
122 DCA_XXCH_REAR_HIGH_CENTER = 0x0400000,
123 DCA_XXCH_REAR_HIGH_LEFT = 0x0800000,
124 DCA_XXCH_REAR_HIGH_RIGHT = 0x1000000,
125 DCA_XXCH_REAR_LOW_CENTER = 0x2000000,
126 DCA_XXCH_REAR_LOW_LEFT = 0x4000000,
127 DCA_XXCH_REAR_LOW_RIGHT = 0x8000000,
130 static const uint32_t map_xxch_to_native[28] = {
140 AV_CH_SIDE_LEFT, /* side surround left -- dup sur side L */
141 AV_CH_SIDE_RIGHT, /* side surround right -- dup sur side R */
142 AV_CH_FRONT_LEFT_OF_CENTER,
143 AV_CH_FRONT_RIGHT_OF_CENTER,
144 AV_CH_TOP_FRONT_LEFT,
145 AV_CH_TOP_FRONT_CENTER,
146 AV_CH_TOP_FRONT_RIGHT,
147 AV_CH_LOW_FREQUENCY, /* lfe2 -- duplicate lfe1 position */
148 AV_CH_FRONT_LEFT_OF_CENTER, /* side front left -- dup front cntr L */
149 AV_CH_FRONT_RIGHT_OF_CENTER,/* side front right -- dup front cntr R */
150 AV_CH_TOP_CENTER, /* overhead */
151 AV_CH_TOP_FRONT_LEFT, /* side high left -- dup */
152 AV_CH_TOP_FRONT_RIGHT, /* side high right -- dup */
153 AV_CH_TOP_BACK_CENTER,
155 AV_CH_TOP_BACK_RIGHT,
156 AV_CH_BACK_CENTER, /* rear low center -- dup */
157 AV_CH_BACK_LEFT, /* rear low left -- dup */
158 AV_CH_BACK_RIGHT /* read low right -- dup */
161 enum DCAExtensionMask {
162 DCA_EXT_CORE = 0x001, ///< core in core substream
163 DCA_EXT_XXCH = 0x002, ///< XXCh channels extension in core substream
164 DCA_EXT_X96 = 0x004, ///< 96/24 extension in core substream
165 DCA_EXT_XCH = 0x008, ///< XCh channel extension in core substream
166 DCA_EXT_EXSS_CORE = 0x010, ///< core in ExSS (extension substream)
167 DCA_EXT_EXSS_XBR = 0x020, ///< extended bitrate extension in ExSS
168 DCA_EXT_EXSS_XXCH = 0x040, ///< XXCh channels extension in ExSS
169 DCA_EXT_EXSS_X96 = 0x080, ///< 96/24 extension in ExSS
170 DCA_EXT_EXSS_LBR = 0x100, ///< low bitrate component in ExSS
171 DCA_EXT_EXSS_XLL = 0x200, ///< lossless extension in ExSS
174 /* -1 are reserved or unknown */
175 static const int dca_ext_audio_descr_mask[] = {
179 DCA_EXT_XCH | DCA_EXT_X96,
186 /* extensions that reside in core substream */
187 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
189 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
190 * Some compromises have been made for special configurations. Most configurations
191 * are never used so complete accuracy is not needed.
193 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
194 * S -> side, when both rear and back are configured move one of them to the side channel
196 * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
198 static const uint64_t dca_core_channel_layout[] = {
199 AV_CH_FRONT_CENTER, ///< 1, A
200 AV_CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
201 AV_CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
202 AV_CH_LAYOUT_STEREO, ///< 2, (L + R) + (L - R) (sum-difference)
203 AV_CH_LAYOUT_STEREO, ///< 2, LT + RT (left and right total)
204 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER, ///< 3, C + L + R
205 AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER, ///< 3, L + R + S
206 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 4, C + L + R + S
207 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 4, L + R + SL + SR
209 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
210 AV_CH_SIDE_RIGHT, ///< 5, C + L + R + SL + SR
212 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
213 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
215 AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
216 AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 6, C + L + R + LR + RR + OV
218 AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
219 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER |
220 AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 6, CF + CR + LF + RF + LR + RR
222 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
223 AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
224 AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
226 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
227 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
228 AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2
230 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
231 AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
232 AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT, ///< 8, CL + C + CR + L + R + SL + S + SR
235 static const int8_t dca_lfe_index[] = {
236 1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
239 static const int8_t dca_channel_reorder_lfe[][9] = {
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 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
245 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
246 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
247 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
248 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
249 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
250 { 3, 4, 0, 1, 5, 6, -1, -1, -1},
251 { 2, 0, 1, 4, 5, 6, -1, -1, -1},
252 { 0, 6, 4, 5, 2, 3, -1, -1, -1},
253 { 4, 2, 5, 0, 1, 6, 7, -1, -1},
254 { 5, 6, 0, 1, 7, 3, 8, 4, -1},
255 { 4, 2, 5, 0, 1, 6, 8, 7, -1},
258 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
259 { 0, 2, -1, -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 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
264 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
265 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
266 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
267 { 0, 1, 4, 5, 3, -1, -1, -1, -1},
268 { 2, 0, 1, 5, 6, 4, -1, -1, -1},
269 { 3, 4, 0, 1, 6, 7, 5, -1, -1},
270 { 2, 0, 1, 4, 5, 6, 7, -1, -1},
271 { 0, 6, 4, 5, 2, 3, 7, -1, -1},
272 { 4, 2, 5, 0, 1, 7, 8, 6, -1},
273 { 5, 6, 0, 1, 8, 3, 9, 4, 7},
274 { 4, 2, 5, 0, 1, 6, 9, 8, 7},
277 static const int8_t dca_channel_reorder_nolfe[][9] = {
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 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
283 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
284 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
285 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
286 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
287 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
288 { 2, 3, 0, 1, 4, 5, -1, -1, -1},
289 { 2, 0, 1, 3, 4, 5, -1, -1, -1},
290 { 0, 5, 3, 4, 1, 2, -1, -1, -1},
291 { 3, 2, 4, 0, 1, 5, 6, -1, -1},
292 { 4, 5, 0, 1, 6, 2, 7, 3, -1},
293 { 3, 2, 4, 0, 1, 5, 7, 6, -1},
296 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
297 { 0, 1, -1, -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 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
302 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
303 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
304 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
305 { 0, 1, 3, 4, 2, -1, -1, -1, -1},
306 { 2, 0, 1, 4, 5, 3, -1, -1, -1},
307 { 2, 3, 0, 1, 5, 6, 4, -1, -1},
308 { 2, 0, 1, 3, 4, 5, 6, -1, -1},
309 { 0, 5, 3, 4, 1, 2, 6, -1, -1},
310 { 3, 2, 4, 0, 1, 6, 7, 5, -1},
311 { 4, 5, 0, 1, 7, 2, 8, 3, 6},
312 { 3, 2, 4, 0, 1, 5, 8, 7, 6},
315 #define DCA_DOLBY 101 /* FIXME */
317 #define DCA_CHANNEL_BITS 6
318 #define DCA_CHANNEL_MASK 0x3F
322 #define HEADER_SIZE 14
324 #define DCA_MAX_FRAME_SIZE 16384
325 #define DCA_MAX_EXSS_HEADER_SIZE 4096
327 #define DCA_BUFFER_PADDING_SIZE 1024
329 /** Bit allocation */
331 int offset; ///< code values offset
332 int maxbits[8]; ///< max bits in VLC
333 int wrap; ///< wrap for get_vlc2()
334 VLC vlc[8]; ///< actual codes
337 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
338 static BitAlloc dca_tmode; ///< transition mode VLCs
339 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
340 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
342 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
345 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
350 AVCodecContext *avctx;
353 int frame_type; ///< type of the current frame
354 int samples_deficit; ///< deficit sample count
355 int crc_present; ///< crc is present in the bitstream
356 int sample_blocks; ///< number of PCM sample blocks
357 int frame_size; ///< primary frame byte size
358 int amode; ///< audio channels arrangement
359 int sample_rate; ///< audio sampling rate
360 int bit_rate; ///< transmission bit rate
361 int bit_rate_index; ///< transmission bit rate index
363 int downmix; ///< embedded downmix enabled
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
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
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 int 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 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
406 int dynrange_coef; ///< dynamic range coefficient
408 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
410 float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
411 int lfe_scale_factor;
413 /* Subband samples history (for ADPCM) */
414 DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
415 DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
416 DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
417 int hist_index[DCA_PRIM_CHANNELS_MAX];
418 DECLARE_ALIGNED(32, float, raXin)[32];
420 int output; ///< type of output
422 DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
423 float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
424 float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
425 uint8_t *extra_channels_buffer;
426 unsigned int extra_channels_buffer_size;
428 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
429 int dca_buffer_size; ///< how much data is in the dca_buffer
431 const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
433 /* Current position in DCA frame */
434 int current_subframe;
435 int current_subsubframe;
437 int core_ext_mask; ///< present extensions in the core substream
439 /* XCh extension information */
440 int xch_present; ///< XCh extension present and valid
441 int xch_base_channel; ///< index of first (only) channel containing XCH data
443 /* XXCH extension information */
445 int xxch_nbits_spk_mask;
446 uint32_t xxch_core_spkmask;
447 uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */
448 int xxch_chset_nch[4];
449 float xxch_dmix_sf[DCA_CHSETS_MAX];
451 uint32_t xxch_downmix; /* downmix enabled per channel set */
452 uint32_t xxch_dmix_embedded; /* lower layer has mix pre-embedded, per chset */
453 float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */
455 int8_t xxch_order_tab[32];
458 /* ExSS header parser */
459 int static_fields; ///< static fields present
460 int mix_metadata; ///< mixing metadata present
461 int num_mix_configs; ///< number of mix out configurations
462 int mix_config_num_ch[4]; ///< number of channels in each mix out configuration
466 int debug_flag; ///< used for suppressing repeated error messages output
467 AVFloatDSPContext fdsp;
469 SynthFilterContext synth;
470 DCADSPContext dcadsp;
471 FmtConvertContext fmt_conv;
474 static const uint16_t dca_vlc_offs[] = {
475 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
476 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
477 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
478 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
479 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
480 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
483 static av_cold void dca_init_vlcs(void)
485 static int vlcs_initialized = 0;
487 static VLC_TYPE dca_table[23622][2];
489 if (vlcs_initialized)
492 dca_bitalloc_index.offset = 1;
493 dca_bitalloc_index.wrap = 2;
494 for (i = 0; i < 5; i++) {
495 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
496 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
497 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
498 bitalloc_12_bits[i], 1, 1,
499 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
501 dca_scalefactor.offset = -64;
502 dca_scalefactor.wrap = 2;
503 for (i = 0; i < 5; i++) {
504 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
505 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
506 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
507 scales_bits[i], 1, 1,
508 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
510 dca_tmode.offset = 0;
512 for (i = 0; i < 4; i++) {
513 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
514 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
515 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
517 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
520 for (i = 0; i < 10; i++)
521 for (j = 0; j < 7; j++) {
522 if (!bitalloc_codes[i][j])
524 dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i];
525 dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4);
526 dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
527 dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
529 init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
531 bitalloc_bits[i][j], 1, 1,
532 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
535 vlcs_initialized = 1;
538 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
541 *dst++ = get_bits(gb, bits);
544 static inline int dca_xxch2index(DCAContext *s, int xxch_ch)
548 /* locate channel set containing the channel */
549 for (i = -1, base = 0, mask = (s->xxch_core_spkmask & ~DCA_XXCH_LFE1);
550 i <= s->xxch_chset && !(mask & xxch_ch); mask = s->xxch_spk_masks[++i])
551 base += av_popcount(mask);
553 return base + av_popcount(mask & (xxch_ch - 1));
556 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,
560 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
561 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
562 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
563 int hdr_pos = 0, hdr_size = 0;
564 float sign, mag, scale_factor;
565 int this_chans, acc_mask;
566 int embedded_downmix;
570 /* xxch has arbitrary sized audio coding headers */
572 hdr_pos = get_bits_count(&s->gb);
573 hdr_size = get_bits(&s->gb, 7) + 1;
576 nchans = get_bits(&s->gb, 3) + 1;
577 s->total_channels = nchans + base_channel;
578 s->prim_channels = s->total_channels;
580 /* obtain speaker layout mask & downmix coefficients for XXCH */
582 acc_mask = s->xxch_core_spkmask;
584 this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6;
585 s->xxch_spk_masks[s->xxch_chset] = this_chans;
586 s->xxch_chset_nch[s->xxch_chset] = nchans;
588 for (i = 0; i <= s->xxch_chset; i++)
589 acc_mask |= s->xxch_spk_masks[i];
591 /* check for downmixing information */
592 if (get_bits1(&s->gb)) {
593 embedded_downmix = get_bits1(&s->gb);
595 1.0f / dca_downmix_scale_factors[(get_bits(&s->gb, 6) - 1) << 2];
597 s->xxch_dmix_sf[s->xxch_chset] = scale_factor;
599 for (i = base_channel; i < s->prim_channels; i++) {
600 s->xxch_downmix |= (1 << i);
601 mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask);
604 for (j = base_channel; j < s->prim_channels; j++) {
605 memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0]));
606 s->xxch_dmix_embedded |= (embedded_downmix << j);
607 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
608 if (mask[j] & (1 << i)) {
609 if ((1 << i) == DCA_XXCH_LFE1) {
610 av_log(s->avctx, AV_LOG_WARNING,
611 "DCA-XXCH: dmix to LFE1 not supported.\n");
615 coeff = get_bits(&s->gb, 7);
616 sign = (coeff & 64) ? 1.0 : -1.0;
617 mag = dca_downmix_scale_factors[((coeff & 63) - 1) << 2];
618 ichan = dca_xxch2index(s, 1 << i);
619 s->xxch_dmix_coeff[j][ichan] = sign * mag;
626 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
627 s->prim_channels = DCA_PRIM_CHANNELS_MAX;
630 for (i = base_channel; i < s->prim_channels; i++) {
631 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
632 if (s->subband_activity[i] > DCA_SUBBANDS)
633 s->subband_activity[i] = DCA_SUBBANDS;
635 for (i = base_channel; i < s->prim_channels; i++) {
636 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
637 if (s->vq_start_subband[i] > DCA_SUBBANDS)
638 s->vq_start_subband[i] = DCA_SUBBANDS;
640 get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
641 get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
642 get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
643 get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
645 /* Get codebooks quantization indexes */
647 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
648 for (j = 1; j < 11; j++)
649 for (i = base_channel; i < s->prim_channels; i++)
650 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
652 /* Get scale factor adjustment */
653 for (j = 0; j < 11; j++)
654 for (i = base_channel; i < s->prim_channels; i++)
655 s->scalefactor_adj[i][j] = 1;
657 for (j = 1; j < 11; j++)
658 for (i = base_channel; i < s->prim_channels; i++)
659 if (s->quant_index_huffman[i][j] < thr[j])
660 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
663 if (s->crc_present) {
664 /* Audio header CRC check */
665 get_bits(&s->gb, 16);
668 /* Skip to the end of the header, also ignore CRC if present */
669 i = get_bits_count(&s->gb);
670 if (hdr_pos + 8 * hdr_size > i)
671 skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);
674 s->current_subframe = 0;
675 s->current_subsubframe = 0;
678 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
679 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
680 for (i = base_channel; i < s->prim_channels; i++) {
681 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
682 s->subband_activity[i]);
683 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
684 s->vq_start_subband[i]);
685 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
686 s->joint_intensity[i]);
687 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
688 s->transient_huffman[i]);
689 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
690 s->scalefactor_huffman[i]);
691 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
692 s->bitalloc_huffman[i]);
693 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
694 for (j = 0; j < 11; j++)
695 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
696 av_log(s->avctx, AV_LOG_DEBUG, "\n");
697 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
698 for (j = 0; j < 11; j++)
699 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
700 av_log(s->avctx, AV_LOG_DEBUG, "\n");
707 static int dca_parse_frame_header(DCAContext *s)
709 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
712 skip_bits_long(&s->gb, 32);
715 s->frame_type = get_bits(&s->gb, 1);
716 s->samples_deficit = get_bits(&s->gb, 5) + 1;
717 s->crc_present = get_bits(&s->gb, 1);
718 s->sample_blocks = get_bits(&s->gb, 7) + 1;
719 s->frame_size = get_bits(&s->gb, 14) + 1;
720 if (s->frame_size < 95)
721 return AVERROR_INVALIDDATA;
722 s->amode = get_bits(&s->gb, 6);
723 s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
725 return AVERROR_INVALIDDATA;
726 s->bit_rate_index = get_bits(&s->gb, 5);
727 s->bit_rate = dca_bit_rates[s->bit_rate_index];
729 return AVERROR_INVALIDDATA;
731 s->downmix = get_bits(&s->gb, 1); /* note: this is FixedBit == 0 */
732 s->dynrange = get_bits(&s->gb, 1);
733 s->timestamp = get_bits(&s->gb, 1);
734 s->aux_data = get_bits(&s->gb, 1);
735 s->hdcd = get_bits(&s->gb, 1);
736 s->ext_descr = get_bits(&s->gb, 3);
737 s->ext_coding = get_bits(&s->gb, 1);
738 s->aspf = get_bits(&s->gb, 1);
739 s->lfe = get_bits(&s->gb, 2);
740 s->predictor_history = get_bits(&s->gb, 1);
742 /* TODO: check CRC */
744 s->header_crc = get_bits(&s->gb, 16);
746 s->multirate_inter = get_bits(&s->gb, 1);
747 s->version = get_bits(&s->gb, 4);
748 s->copy_history = get_bits(&s->gb, 2);
749 s->source_pcm_res = get_bits(&s->gb, 3);
750 s->front_sum = get_bits(&s->gb, 1);
751 s->surround_sum = get_bits(&s->gb, 1);
752 s->dialog_norm = get_bits(&s->gb, 4);
754 /* FIXME: channels mixing levels */
755 s->output = s->amode;
757 s->output |= DCA_LFE;
760 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
761 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
762 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
763 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
764 s->sample_blocks, s->sample_blocks * 32);
765 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
766 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
767 s->amode, dca_channels[s->amode]);
768 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
770 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
772 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
773 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
774 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
775 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
776 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
777 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
778 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
779 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
780 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
781 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
782 s->predictor_history);
783 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
784 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
786 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
787 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
788 av_log(s->avctx, AV_LOG_DEBUG,
789 "source pcm resolution: %i (%i bits/sample)\n",
790 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
791 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
792 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
793 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
794 av_log(s->avctx, AV_LOG_DEBUG, "\n");
797 /* Primary audio coding header */
798 s->subframes = get_bits(&s->gb, 4) + 1;
800 return dca_parse_audio_coding_header(s, 0, 0);
804 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
807 /* huffman encoded */
808 value += get_bitalloc(gb, &dca_scalefactor, level);
809 value = av_clip(value, 0, (1 << log2range) - 1);
810 } else if (level < 8) {
811 if (level + 1 > log2range) {
812 skip_bits(gb, level + 1 - log2range);
813 value = get_bits(gb, log2range);
815 value = get_bits(gb, level + 1);
821 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
823 /* Primary audio coding side information */
826 if (get_bits_left(&s->gb) < 0)
827 return AVERROR_INVALIDDATA;
830 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
831 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
834 for (j = base_channel; j < s->prim_channels; j++) {
835 for (k = 0; k < s->subband_activity[j]; k++)
836 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
839 /* Get prediction codebook */
840 for (j = base_channel; j < s->prim_channels; j++) {
841 for (k = 0; k < s->subband_activity[j]; k++) {
842 if (s->prediction_mode[j][k] > 0) {
843 /* (Prediction coefficient VQ address) */
844 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
849 /* Bit allocation index */
850 for (j = base_channel; j < s->prim_channels; j++) {
851 for (k = 0; k < s->vq_start_subband[j]; k++) {
852 if (s->bitalloc_huffman[j] == 6)
853 s->bitalloc[j][k] = get_bits(&s->gb, 5);
854 else if (s->bitalloc_huffman[j] == 5)
855 s->bitalloc[j][k] = get_bits(&s->gb, 4);
856 else if (s->bitalloc_huffman[j] == 7) {
857 av_log(s->avctx, AV_LOG_ERROR,
858 "Invalid bit allocation index\n");
859 return AVERROR_INVALIDDATA;
862 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
865 if (s->bitalloc[j][k] > 26) {
866 av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
867 j, k, s->bitalloc[j][k]);
868 return AVERROR_INVALIDDATA;
873 /* Transition mode */
874 for (j = base_channel; j < s->prim_channels; j++) {
875 for (k = 0; k < s->subband_activity[j]; k++) {
876 s->transition_mode[j][k] = 0;
877 if (s->subsubframes[s->current_subframe] > 1 &&
878 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
879 s->transition_mode[j][k] =
880 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
885 if (get_bits_left(&s->gb) < 0)
886 return AVERROR_INVALIDDATA;
888 for (j = base_channel; j < s->prim_channels; j++) {
889 const uint32_t *scale_table;
890 int scale_sum, log_size;
892 memset(s->scale_factor[j], 0,
893 s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
895 if (s->scalefactor_huffman[j] == 6) {
896 scale_table = scale_factor_quant7;
899 scale_table = scale_factor_quant6;
903 /* When huffman coded, only the difference is encoded */
906 for (k = 0; k < s->subband_activity[j]; k++) {
907 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
908 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
909 s->scale_factor[j][k][0] = scale_table[scale_sum];
912 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
913 /* Get second scale factor */
914 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
915 s->scale_factor[j][k][1] = scale_table[scale_sum];
920 /* Joint subband scale factor codebook select */
921 for (j = base_channel; j < s->prim_channels; j++) {
922 /* Transmitted only if joint subband coding enabled */
923 if (s->joint_intensity[j] > 0)
924 s->joint_huff[j] = get_bits(&s->gb, 3);
927 if (get_bits_left(&s->gb) < 0)
928 return AVERROR_INVALIDDATA;
930 /* Scale factors for joint subband coding */
931 for (j = base_channel; j < s->prim_channels; j++) {
934 /* Transmitted only if joint subband coding enabled */
935 if (s->joint_intensity[j] > 0) {
937 source_channel = s->joint_intensity[j] - 1;
939 /* When huffman coded, only the difference is encoded
940 * (is this valid as well for joint scales ???) */
942 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
943 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
944 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
947 if (!(s->debug_flag & 0x02)) {
948 av_log(s->avctx, AV_LOG_DEBUG,
949 "Joint stereo coding not supported\n");
950 s->debug_flag |= 0x02;
955 /* Stereo downmix coefficients */
956 if (!base_channel && s->prim_channels > 2) {
958 for (j = base_channel; j < s->prim_channels; j++) {
959 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
960 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
963 int am = s->amode & DCA_CHANNEL_MASK;
964 if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
965 av_log(s->avctx, AV_LOG_ERROR,
966 "Invalid channel mode %d\n", am);
967 return AVERROR_INVALIDDATA;
969 for (j = base_channel; j < FFMIN(s->prim_channels, FF_ARRAY_ELEMS(dca_default_coeffs[am])); j++) {
970 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
971 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
976 /* Dynamic range coefficient */
977 if (!base_channel && s->dynrange)
978 s->dynrange_coef = get_bits(&s->gb, 8);
980 /* Side information CRC check word */
981 if (s->crc_present) {
982 get_bits(&s->gb, 16);
986 * Primary audio data arrays
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);
995 /* Low frequency effect data */
996 if (!base_channel && s->lfe) {
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]);
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);
1008 /* Scale factor index */
1009 quant7 = get_bits(&s->gb, 8);
1011 av_log_ask_for_sample(s->avctx, "LFEScaleIndex larger than 127\n");
1012 return AVERROR_INVALIDDATA;
1014 s->lfe_scale_factor = scale_factor_quant7[quant7];
1016 /* Quantization step size * scale factor */
1017 lfe_scale = 0.035 * s->lfe_scale_factor;
1019 for (j = lfe_samples; j < lfe_end_sample; j++)
1020 s->lfe_data[j] *= lfe_scale;
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]);
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");
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);
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");
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");
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]);
1064 av_log(s->avctx, AV_LOG_DEBUG, "\n");
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");
1075 if (!base_channel && s->prim_channels > 2 && s->downmix) {
1076 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
1077 for (j = 0; j < s->prim_channels; j++) {
1078 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
1079 dca_downmix_coeffs[s->downmix_coef[j][0]]);
1080 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
1081 dca_downmix_coeffs[s->downmix_coef[j][1]]);
1083 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1085 for (j = base_channel; j < s->prim_channels; j++)
1086 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
1087 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
1088 if (!base_channel && s->lfe) {
1089 int lfe_samples = 2 * s->lfe * (4 + block_index);
1090 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
1092 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
1093 for (j = lfe_samples; j < lfe_end_sample; j++)
1094 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
1095 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1102 static void qmf_32_subbands(DCAContext *s, int chans,
1103 float samples_in[32][8], float *samples_out,
1106 const float *prCoeff;
1109 int sb_act = s->subband_activity[chans];
1112 scale *= sqrt(1 / 8.0);
1115 if (!s->multirate_inter) /* Non-perfect reconstruction */
1116 prCoeff = fir_32bands_nonperfect;
1117 else /* Perfect reconstruction */
1118 prCoeff = fir_32bands_perfect;
1120 for (i = sb_act; i < 32; i++)
1123 /* Reconstructed channel sample index */
1124 for (subindex = 0; subindex < 8; subindex++) {
1125 /* Load in one sample from each subband and clear inactive subbands */
1126 for (i = 0; i < sb_act; i++) {
1127 unsigned sign = (i - 1) & 2;
1128 uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
1129 AV_WN32A(&s->raXin[i], v);
1132 s->synth.synth_filter_float(&s->imdct,
1133 s->subband_fir_hist[chans],
1134 &s->hist_index[chans],
1135 s->subband_fir_noidea[chans], prCoeff,
1136 samples_out, s->raXin, scale);
1141 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
1142 int num_deci_sample, float *samples_in,
1143 float *samples_out, float scale)
1145 /* samples_in: An array holding decimated samples.
1146 * Samples in current subframe starts from samples_in[0],
1147 * while samples_in[-1], samples_in[-2], ..., stores samples
1148 * from last subframe as history.
1150 * samples_out: An array holding interpolated samples
1154 const float *prCoeff;
1157 /* Select decimation filter */
1158 if (decimation_select == 1) {
1160 prCoeff = lfe_fir_128;
1163 prCoeff = lfe_fir_64;
1166 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
1167 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
1169 samples_out += 2 * decifactor;
1173 /* downmixing routines */
1174 #define MIX_REAR1(samples, s1, rs, coef) \
1175 samples[0][i] += samples[s1][i] * coef[rs][0]; \
1176 samples[1][i] += samples[s1][i] * coef[rs][1];
1178 #define MIX_REAR2(samples, s1, s2, rs, coef) \
1179 samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
1180 samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
1182 #define MIX_FRONT3(samples, coef) \
1183 t = samples[c][i]; \
1184 u = samples[l][i]; \
1185 v = samples[r][i]; \
1186 samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1187 samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1189 #define DOWNMIX_TO_STEREO(op1, op2) \
1190 for (i = 0; i < 256; i++) { \
1195 static void dca_downmix(float **samples, int srcfmt,
1196 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
1197 const int8_t *channel_mapping)
1199 int c, l, r, sl, sr, s;
1202 float coef[DCA_PRIM_CHANNELS_MAX][2];
1204 for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
1205 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
1206 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
1212 case DCA_STEREO_TOTAL:
1213 case DCA_STEREO_SUMDIFF:
1215 av_log(NULL, 0, "Not implemented!\n");
1220 c = channel_mapping[0];
1221 l = channel_mapping[1];
1222 r = channel_mapping[2];
1223 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1226 s = channel_mapping[2];
1227 DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
1230 c = channel_mapping[0];
1231 l = channel_mapping[1];
1232 r = channel_mapping[2];
1233 s = channel_mapping[3];
1234 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1235 MIX_REAR1(samples, s, 3, coef));
1238 sl = channel_mapping[2];
1239 sr = channel_mapping[3];
1240 DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
1243 c = channel_mapping[0];
1244 l = channel_mapping[1];
1245 r = channel_mapping[2];
1246 sl = channel_mapping[3];
1247 sr = channel_mapping[4];
1248 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1249 MIX_REAR2(samples, sl, sr, 3, coef));
1255 #ifndef decode_blockcodes
1256 /* Very compact version of the block code decoder that does not use table
1257 * look-up but is slightly slower */
1258 static int decode_blockcode(int code, int levels, int *values)
1261 int offset = (levels - 1) >> 1;
1263 for (i = 0; i < 4; i++) {
1264 int div = FASTDIV(code, levels);
1265 values[i] = code - offset - div * levels;
1272 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1274 return decode_blockcode(code1, levels, values) |
1275 decode_blockcode(code2, levels, values + 4);
1279 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1280 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1282 #ifndef int8x8_fmul_int32
1283 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1285 float fscale = scale / 16.0;
1287 for (i = 0; i < 8; i++)
1288 dst[i] = src[i] * fscale;
1292 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1295 int subsubframe = s->current_subsubframe;
1297 const float *quant_step_table;
1300 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1301 LOCAL_ALIGNED_16(int, block, [8]);
1307 /* Select quantization step size table */
1308 if (s->bit_rate_index == 0x1f)
1309 quant_step_table = lossless_quant_d;
1311 quant_step_table = lossy_quant_d;
1313 for (k = base_channel; k < s->prim_channels; k++) {
1314 if (get_bits_left(&s->gb) < 0)
1315 return AVERROR_INVALIDDATA;
1317 for (l = 0; l < s->vq_start_subband[k]; l++) {
1320 /* Select the mid-tread linear quantizer */
1321 int abits = s->bitalloc[k][l];
1323 float quant_step_size = quant_step_table[abits];
1326 * Determine quantization index code book and its type
1329 /* Select quantization index code book */
1330 int sel = s->quant_index_huffman[k][abits];
1333 * Extract bits from the bit stream
1336 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1338 /* Deal with transients */
1339 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1340 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
1341 s->scalefactor_adj[k][sel];
1343 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1346 int block_code1, block_code2, size, levels, err;
1348 size = abits_sizes[abits - 1];
1349 levels = abits_levels[abits - 1];
1351 block_code1 = get_bits(&s->gb, size);
1352 block_code2 = get_bits(&s->gb, size);
1353 err = decode_blockcodes(block_code1, block_code2,
1356 av_log(s->avctx, AV_LOG_ERROR,
1357 "ERROR: block code look-up failed\n");
1358 return AVERROR_INVALIDDATA;
1362 for (m = 0; m < 8; m++)
1363 block[m] = get_sbits(&s->gb, abits - 3);
1367 for (m = 0; m < 8; m++)
1368 block[m] = get_bitalloc(&s->gb,
1369 &dca_smpl_bitalloc[abits], sel);
1372 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1377 * Inverse ADPCM if in prediction mode
1379 if (s->prediction_mode[k][l]) {
1381 for (m = 0; m < 8; m++) {
1382 for (n = 1; n <= 4; n++)
1384 subband_samples[k][l][m] +=
1385 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1386 subband_samples[k][l][m - n] / 8192);
1387 else if (s->predictor_history)
1388 subband_samples[k][l][m] +=
1389 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1390 s->subband_samples_hist[k][l][m - n + 4] / 8192);
1396 * Decode VQ encoded high frequencies
1398 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1399 /* 1 vector -> 32 samples but we only need the 8 samples
1400 * for this subsubframe. */
1401 int hfvq = s->high_freq_vq[k][l];
1403 if (!s->debug_flag & 0x01) {
1404 av_log(s->avctx, AV_LOG_DEBUG,
1405 "Stream with high frequencies VQ coding\n");
1406 s->debug_flag |= 0x01;
1409 int8x8_fmul_int32(subband_samples[k][l],
1410 &high_freq_vq[hfvq][subsubframe * 8],
1411 s->scale_factor[k][l][0]);
1415 /* Check for DSYNC after subsubframe */
1416 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1417 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1419 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1422 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1426 /* Backup predictor history for adpcm */
1427 for (k = base_channel; k < s->prim_channels; k++)
1428 for (l = 0; l < s->vq_start_subband[k]; l++)
1429 memcpy(s->subband_samples_hist[k][l],
1430 &subband_samples[k][l][4],
1431 4 * sizeof(subband_samples[0][0][0]));
1436 static int dca_filter_channels(DCAContext *s, int block_index)
1438 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1441 /* 32 subbands QMF */
1442 for (k = 0; k < s->prim_channels; k++) {
1443 /* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1444 0, 8388608.0, 8388608.0 };*/
1445 qmf_32_subbands(s, k, subband_samples[k],
1446 s->samples_chanptr[s->channel_order_tab[k]],
1447 M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */);
1451 if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1452 dca_downmix(s->samples_chanptr, s->amode, s->downmix_coef, s->channel_order_tab);
1455 /* Generate LFE samples for this subsubframe FIXME!!! */
1456 if (s->output & DCA_LFE) {
1457 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1458 s->lfe_data + 2 * s->lfe * (block_index + 4),
1459 s->samples_chanptr[s->lfe_index],
1460 1.0 / (256.0 * 32768.0));
1461 /* Outputs 20bits pcm samples */
1468 static int dca_subframe_footer(DCAContext *s, int base_channel)
1470 int aux_data_count = 0, i;
1473 * Unpack optional information
1476 /* presumably optional information only appears in the core? */
1477 if (!base_channel) {
1479 skip_bits_long(&s->gb, 32);
1482 aux_data_count = get_bits(&s->gb, 6);
1484 for (i = 0; i < aux_data_count; i++)
1485 get_bits(&s->gb, 8);
1487 if (s->crc_present && (s->downmix || s->dynrange))
1488 get_bits(&s->gb, 16);
1495 * Decode a dca frame block
1497 * @param s pointer to the DCAContext
1500 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1505 if (s->current_subframe >= s->subframes) {
1506 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1507 s->current_subframe, s->subframes);
1508 return AVERROR_INVALIDDATA;
1511 if (!s->current_subsubframe) {
1513 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1515 /* Read subframe header */
1516 if ((ret = dca_subframe_header(s, base_channel, block_index)))
1520 /* Read subsubframe */
1522 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1524 if ((ret = dca_subsubframe(s, base_channel, block_index)))
1528 s->current_subsubframe++;
1529 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1530 s->current_subsubframe = 0;
1531 s->current_subframe++;
1533 if (s->current_subframe >= s->subframes) {
1535 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1537 /* Read subframe footer */
1538 if ((ret = dca_subframe_footer(s, base_channel)))
1546 * Return the number of channels in an ExSS speaker mask (HD)
1548 static int dca_exss_mask2count(int mask)
1550 /* count bits that mean speaker pairs twice */
1551 return av_popcount(mask) +
1552 av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
1553 DCA_EXSS_FRONT_LEFT_RIGHT |
1554 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
1555 DCA_EXSS_WIDE_LEFT_RIGHT |
1556 DCA_EXSS_SIDE_LEFT_RIGHT |
1557 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
1558 DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
1559 DCA_EXSS_REAR_LEFT_RIGHT |
1560 DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1564 * Skip mixing coefficients of a single mix out configuration (HD)
1566 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1570 for (i = 0; i < channels; i++) {
1571 int mix_map_mask = get_bits(gb, out_ch);
1572 int num_coeffs = av_popcount(mix_map_mask);
1573 skip_bits_long(gb, num_coeffs * 6);
1578 * Parse extension substream asset header (HD)
1580 static int dca_exss_parse_asset_header(DCAContext *s)
1582 int header_pos = get_bits_count(&s->gb);
1585 int embedded_stereo = 0;
1586 int embedded_6ch = 0;
1587 int drc_code_present;
1588 int av_uninit(extensions_mask);
1591 if (get_bits_left(&s->gb) < 16)
1594 /* We will parse just enough to get to the extensions bitmask with which
1595 * we can set the profile value. */
1597 header_size = get_bits(&s->gb, 9) + 1;
1598 skip_bits(&s->gb, 3); // asset index
1600 if (s->static_fields) {
1601 if (get_bits1(&s->gb))
1602 skip_bits(&s->gb, 4); // asset type descriptor
1603 if (get_bits1(&s->gb))
1604 skip_bits_long(&s->gb, 24); // language descriptor
1606 if (get_bits1(&s->gb)) {
1607 /* How can one fit 1024 bytes of text here if the maximum value
1608 * for the asset header size field above was 512 bytes? */
1609 int text_length = get_bits(&s->gb, 10) + 1;
1610 if (get_bits_left(&s->gb) < text_length * 8)
1612 skip_bits_long(&s->gb, text_length * 8); // info text
1615 skip_bits(&s->gb, 5); // bit resolution - 1
1616 skip_bits(&s->gb, 4); // max sample rate code
1617 channels = get_bits(&s->gb, 8) + 1;
1619 if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1620 int spkr_remap_sets;
1621 int spkr_mask_size = 16;
1625 embedded_stereo = get_bits1(&s->gb);
1627 embedded_6ch = get_bits1(&s->gb);
1629 if (get_bits1(&s->gb)) {
1630 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1631 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1634 spkr_remap_sets = get_bits(&s->gb, 3);
1636 for (i = 0; i < spkr_remap_sets; i++) {
1637 /* std layout mask for each remap set */
1638 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1641 for (i = 0; i < spkr_remap_sets; i++) {
1642 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1643 if (get_bits_left(&s->gb) < 0)
1646 for (j = 0; j < num_spkrs[i]; j++) {
1647 int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1648 int num_dec_ch = av_popcount(remap_dec_ch_mask);
1649 skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1654 skip_bits(&s->gb, 3); // representation type
1658 drc_code_present = get_bits1(&s->gb);
1659 if (drc_code_present)
1660 get_bits(&s->gb, 8); // drc code
1662 if (get_bits1(&s->gb))
1663 skip_bits(&s->gb, 5); // dialog normalization code
1665 if (drc_code_present && embedded_stereo)
1666 get_bits(&s->gb, 8); // drc stereo code
1668 if (s->mix_metadata && get_bits1(&s->gb)) {
1669 skip_bits(&s->gb, 1); // external mix
1670 skip_bits(&s->gb, 6); // post mix gain code
1672 if (get_bits(&s->gb, 2) != 3) // mixer drc code
1673 skip_bits(&s->gb, 3); // drc limit
1675 skip_bits(&s->gb, 8); // custom drc code
1677 if (get_bits1(&s->gb)) // channel specific scaling
1678 for (i = 0; i < s->num_mix_configs; i++)
1679 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1681 skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1683 for (i = 0; i < s->num_mix_configs; i++) {
1684 if (get_bits_left(&s->gb) < 0)
1686 dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1688 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1689 if (embedded_stereo)
1690 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1694 switch (get_bits(&s->gb, 2)) {
1695 case 0: extensions_mask = get_bits(&s->gb, 12); break;
1696 case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1697 case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1698 case 3: extensions_mask = 0; /* aux coding */ break;
1701 /* not parsed further, we were only interested in the extensions mask */
1703 if (get_bits_left(&s->gb) < 0)
1706 if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1707 av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1710 skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1712 if (extensions_mask & DCA_EXT_EXSS_XLL)
1713 s->profile = FF_PROFILE_DTS_HD_MA;
1714 else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1716 s->profile = FF_PROFILE_DTS_HD_HRA;
1718 if (!(extensions_mask & DCA_EXT_CORE))
1719 av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1720 if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1721 av_log(s->avctx, AV_LOG_WARNING,
1722 "DTS extensions detection mismatch (%d, %d)\n",
1723 extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1728 static int dca_xbr_parse_frame(DCAContext *s)
1730 int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];
1731 int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];
1732 int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS];
1733 int anctemp[DCA_CHSET_CHANS_MAX];
1734 int chset_fsize[DCA_CHSETS_MAX];
1735 int n_xbr_ch[DCA_CHSETS_MAX];
1736 int hdr_size, num_chsets, xbr_tmode, hdr_pos;
1737 int i, j, k, l, chset, chan_base;
1739 av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n");
1741 /* get bit position of sync header */
1742 hdr_pos = get_bits_count(&s->gb) - 32;
1744 hdr_size = get_bits(&s->gb, 6) + 1;
1745 num_chsets = get_bits(&s->gb, 2) + 1;
1747 for(i = 0; i < num_chsets; i++)
1748 chset_fsize[i] = get_bits(&s->gb, 14) + 1;
1750 xbr_tmode = get_bits1(&s->gb);
1752 for(i = 0; i < num_chsets; i++) {
1753 n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;
1754 k = get_bits(&s->gb, 2) + 5;
1755 for(j = 0; j < n_xbr_ch[i]; j++)
1756 active_bands[i][j] = get_bits(&s->gb, k) + 1;
1759 /* skip to the end of the header */
1760 i = get_bits_count(&s->gb);
1761 if(hdr_pos + hdr_size * 8 > i)
1762 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1764 /* loop over the channel data sets */
1765 /* only decode as many channels as we've decoded base data for */
1766 for(chset = 0, chan_base = 0;
1767 chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels;
1768 chan_base += n_xbr_ch[chset++]) {
1769 int start_posn = get_bits_count(&s->gb);
1770 int subsubframe = 0;
1773 /* loop over subframes */
1774 for (k = 0; k < (s->sample_blocks / 8); k++) {
1775 /* parse header if we're on first subsubframe of a block */
1776 if(subsubframe == 0) {
1777 /* Parse subframe header */
1778 for(i = 0; i < n_xbr_ch[chset]; i++) {
1779 anctemp[i] = get_bits(&s->gb, 2) + 2;
1782 for(i = 0; i < n_xbr_ch[chset]; i++) {
1783 get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]);
1786 for(i = 0; i < n_xbr_ch[chset]; i++) {
1787 anctemp[i] = get_bits(&s->gb, 3);
1788 if(anctemp[i] < 1) {
1789 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n");
1790 return AVERROR_INVALIDDATA;
1794 /* generate scale factors */
1795 for(i = 0; i < n_xbr_ch[chset]; i++) {
1796 const uint32_t *scale_table;
1799 if (s->scalefactor_huffman[chan_base+i] == 6) {
1800 scale_table = scale_factor_quant7;
1802 scale_table = scale_factor_quant6;
1807 for(j = 0; j < active_bands[chset][i]; j++) {
1808 if(abits_high[i][j] > 0) {
1809 scale_table_high[i][j][0] =
1810 scale_table[get_bits(&s->gb, nbits)];
1812 if(xbr_tmode && s->transition_mode[i][j]) {
1813 scale_table_high[i][j][1] =
1814 scale_table[get_bits(&s->gb, nbits)];
1821 /* decode audio array for this block */
1822 for(i = 0; i < n_xbr_ch[chset]; i++) {
1823 for(j = 0; j < active_bands[chset][i]; j++) {
1824 const int xbr_abits = abits_high[i][j];
1825 const float quant_step_size = lossless_quant_d[xbr_abits];
1826 const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j];
1827 const float rscale = quant_step_size * scale_table_high[i][j][sfi];
1828 float *subband_samples = s->subband_samples[k][chan_base+i][j];
1835 get_array(&s->gb, block, 8, xbr_abits - 3);
1837 int block_code1, block_code2, size, levels, err;
1839 size = abits_sizes[xbr_abits - 1];
1840 levels = abits_levels[xbr_abits - 1];
1842 block_code1 = get_bits(&s->gb, size);
1843 block_code2 = get_bits(&s->gb, size);
1844 err = decode_blockcodes(block_code1, block_code2,
1847 av_log(s->avctx, AV_LOG_ERROR,
1848 "ERROR: DTS-XBR: block code look-up failed\n");
1849 return AVERROR_INVALIDDATA;
1853 /* scale & sum into subband */
1854 for(l = 0; l < 8; l++)
1855 subband_samples[l] += (float)block[l] * rscale;
1859 /* check DSYNC marker */
1860 if(s->aspf || subsubframe == s->subsubframes[subframe] - 1) {
1861 if(get_bits(&s->gb, 16) != 0xffff) {
1862 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n");
1863 return AVERROR_INVALIDDATA;
1867 /* advance sub-sub-frame index */
1868 if(++subsubframe >= s->subsubframes[subframe]) {
1874 /* skip to next channel set */
1875 i = get_bits_count(&s->gb);
1876 if(start_posn + chset_fsize[chset] * 8 != i) {
1877 j = start_posn + chset_fsize[chset] * 8 - i;
1879 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set,"
1880 " skipping further than expected (%d bits)\n", j);
1881 skip_bits_long(&s->gb, j);
1888 /* parse initial header for XXCH and dump details */
1889 static int dca_xxch_decode_frame(DCAContext *s)
1891 int hdr_size, spkmsk_bits, num_chsets, core_spk, hdr_pos;
1892 int i, chset, base_channel, chstart, fsize[8];
1894 /* assume header word has already been parsed */
1895 hdr_pos = get_bits_count(&s->gb) - 32;
1896 hdr_size = get_bits(&s->gb, 6) + 1;
1897 /*chhdr_crc =*/ skip_bits1(&s->gb);
1898 spkmsk_bits = get_bits(&s->gb, 5) + 1;
1899 num_chsets = get_bits(&s->gb, 2) + 1;
1901 for (i = 0; i < num_chsets; i++)
1902 fsize[i] = get_bits(&s->gb, 14) + 1;
1904 core_spk = get_bits(&s->gb, spkmsk_bits);
1905 s->xxch_core_spkmask = core_spk;
1906 s->xxch_nbits_spk_mask = spkmsk_bits;
1907 s->xxch_downmix = 0;
1908 s->xxch_dmix_embedded = 0;
1910 /* skip to the end of the header */
1911 i = get_bits_count(&s->gb);
1912 if (hdr_pos + hdr_size * 8 > i)
1913 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1915 for (chset = 0; chset < num_chsets; chset++) {
1916 chstart = get_bits_count(&s->gb);
1917 base_channel = s->prim_channels;
1918 s->xxch_chset = chset;
1920 /* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs.
1921 5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */
1922 dca_parse_audio_coding_header(s, base_channel, 1);
1924 /* decode channel data */
1925 for (i = 0; i < (s->sample_blocks / 8); i++) {
1926 if (dca_decode_block(s, base_channel, i)) {
1927 av_log(s->avctx, AV_LOG_ERROR,
1928 "Error decoding DTS-XXCH extension\n");
1933 /* skip to end of this section */
1934 i = get_bits_count(&s->gb);
1935 if (chstart + fsize[chset] * 8 > i)
1936 skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i);
1938 s->xxch_chset = num_chsets;
1944 * Parse extension substream header (HD)
1946 static void dca_exss_parse_header(DCAContext *s)
1953 int active_ss_mask[8];
1959 if (get_bits_left(&s->gb) < 52)
1962 start_posn = get_bits_count(&s->gb) - 32;
1964 skip_bits(&s->gb, 8); // user data
1965 ss_index = get_bits(&s->gb, 2);
1967 blownup = get_bits1(&s->gb);
1968 hdrsize = get_bits(&s->gb, 8 + 4 * blownup) + 1; // header_size
1969 skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1971 s->static_fields = get_bits1(&s->gb);
1972 if (s->static_fields) {
1973 skip_bits(&s->gb, 2); // reference clock code
1974 skip_bits(&s->gb, 3); // frame duration code
1976 if (get_bits1(&s->gb))
1977 skip_bits_long(&s->gb, 36); // timestamp
1979 /* a single stream can contain multiple audio assets that can be
1980 * combined to form multiple audio presentations */
1982 num_audiop = get_bits(&s->gb, 3) + 1;
1983 if (num_audiop > 1) {
1984 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1985 /* ignore such streams for now */
1989 num_assets = get_bits(&s->gb, 3) + 1;
1990 if (num_assets > 1) {
1991 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1992 /* ignore such streams for now */
1996 for (i = 0; i < num_audiop; i++)
1997 active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1999 for (i = 0; i < num_audiop; i++)
2000 for (j = 0; j <= ss_index; j++)
2001 if (active_ss_mask[i] & (1 << j))
2002 skip_bits(&s->gb, 8); // active asset mask
2004 s->mix_metadata = get_bits1(&s->gb);
2005 if (s->mix_metadata) {
2006 int mix_out_mask_size;
2008 skip_bits(&s->gb, 2); // adjustment level
2009 mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
2010 s->num_mix_configs = get_bits(&s->gb, 2) + 1;
2012 for (i = 0; i < s->num_mix_configs; i++) {
2013 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
2014 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
2019 for (i = 0; i < num_assets; i++)
2020 asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup);
2022 for (i = 0; i < num_assets; i++) {
2023 if (dca_exss_parse_asset_header(s))
2027 /* not parsed further, we were only interested in the extensions mask
2028 * from the asset header */
2030 if (num_assets > 0) {
2031 j = get_bits_count(&s->gb);
2032 if (start_posn + hdrsize * 8 > j)
2033 skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j);
2035 for (i = 0; i < num_assets; i++) {
2036 start_posn = get_bits_count(&s->gb);
2037 mkr = get_bits_long(&s->gb, 32);
2039 /* parse extensions that we know about */
2040 if (mkr == 0x655e315e) {
2041 dca_xbr_parse_frame(s);
2042 } else if (mkr == 0x47004a03) {
2043 dca_xxch_decode_frame(s);
2044 s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
2046 av_log(s->avctx, AV_LOG_DEBUG,
2047 "DTS-ExSS: unknown marker = 0x%08x\n", mkr);
2050 /* skip to end of block */
2051 j = get_bits_count(&s->gb);
2052 if (start_posn + asset_size[i] * 8 > j)
2053 skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j);
2059 * Main frame decoding function
2060 * FIXME add arguments
2062 static int dca_decode_frame(AVCodecContext *avctx, void *data,
2063 int *got_frame_ptr, AVPacket *avpkt)
2065 const uint8_t *buf = avpkt->data;
2066 int buf_size = avpkt->size;
2070 int num_core_channels = 0;
2072 float **samples_flt;
2075 DCAContext *s = avctx->priv_data;
2077 int channels, full_channels;
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 full_channels = 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.extended_data;
2347 /* allocate buffer for extra channels if downmixing */
2348 if (avctx->channels < full_channels) {
2349 ret = av_samples_get_buffer_size(NULL, full_channels - channels,
2350 s->frame.nb_samples,
2351 avctx->sample_fmt, 0);
2355 av_fast_malloc(&s->extra_channels_buffer,
2356 &s->extra_channels_buffer_size, ret);
2357 if (!s->extra_channels_buffer)
2358 return AVERROR(ENOMEM);
2360 ret = av_samples_fill_arrays((uint8_t **)s->extra_channels, NULL,
2361 s->extra_channels_buffer,
2362 full_channels - channels,
2363 s->frame.nb_samples, avctx->sample_fmt, 0);
2368 /* filter to get final output */
2369 for (i = 0; i < (s->sample_blocks / 8); i++) {
2372 for (ch = 0; ch < channels; ch++)
2373 s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
2374 for (; ch < full_channels; ch++)
2375 s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
2377 dca_filter_channels(s, i);
2379 /* If this was marked as a DTS-ES stream we need to subtract back- */
2380 /* channel from SL & SR to remove matrixed back-channel signal */
2381 if ((s->source_pcm_res & 1) && s->xch_present) {
2382 float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];
2383 float *lt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];
2384 float *rt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];
2385 s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
2386 s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
2389 /* If stream contains XXCH, we might need to undo an embedded downmix */
2390 if (s->xxch_dmix_embedded) {
2391 /* Loop over channel sets in turn */
2392 ch = num_core_channels;
2393 for (chset = 0; chset < s->xxch_chset; chset++) {
2394 endch = ch + s->xxch_chset_nch[chset];
2395 mask = s->xxch_dmix_embedded;
2398 for (j = ch; j < endch; j++) {
2399 if (mask & (1 << j)) { /* this channel has been mixed-out */
2400 src_chan = s->samples_chanptr[s->channel_order_tab[j]];
2401 for (k = 0; k < endch; k++) {
2402 achan = s->channel_order_tab[k];
2403 scale = s->xxch_dmix_coeff[j][k];
2405 dst_chan = s->samples_chanptr[achan];
2406 s->fdsp.vector_fmac_scalar(dst_chan, src_chan,
2413 /* if a downmix has been embedded then undo the pre-scaling */
2414 if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) {
2415 scale = s->xxch_dmix_sf[chset];
2417 for (j = 0; j < ch; j++) {
2418 src_chan = s->samples_chanptr[s->channel_order_tab[j]];
2419 for (k = 0; k < 256; k++)
2420 src_chan[k] *= scale;
2423 /* LFE channel is always part of core, scale if it exists */
2425 src_chan = s->samples_chanptr[s->lfe_index];
2426 for (k = 0; k < 256; k++)
2427 src_chan[k] *= scale;
2437 /* update lfe history */
2438 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
2439 for (i = 0; i < 2 * s->lfe * 4; i++)
2440 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
2443 *(AVFrame *) data = s->frame;
2451 * DCA initialization
2453 * @param avctx pointer to the AVCodecContext
2456 static av_cold int dca_decode_init(AVCodecContext *avctx)
2458 DCAContext *s = avctx->priv_data;
2463 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
2464 ff_mdct_init(&s->imdct, 6, 1, 1.0);
2465 ff_synth_filter_init(&s->synth);
2466 ff_dcadsp_init(&s->dcadsp);
2467 ff_fmt_convert_init(&s->fmt_conv, avctx);
2469 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
2471 /* allow downmixing to stereo */
2472 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
2473 avctx->request_channels == 2) {
2474 avctx->channels = avctx->request_channels;
2477 avcodec_get_frame_defaults(&s->frame);
2478 avctx->coded_frame = &s->frame;
2483 static av_cold int dca_decode_end(AVCodecContext *avctx)
2485 DCAContext *s = avctx->priv_data;
2486 ff_mdct_end(&s->imdct);
2487 av_freep(&s->extra_channels_buffer);
2491 static const AVProfile profiles[] = {
2492 { FF_PROFILE_DTS, "DTS" },
2493 { FF_PROFILE_DTS_ES, "DTS-ES" },
2494 { FF_PROFILE_DTS_96_24, "DTS 96/24" },
2495 { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
2496 { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
2497 { FF_PROFILE_UNKNOWN },
2500 AVCodec ff_dca_decoder = {
2502 .type = AVMEDIA_TYPE_AUDIO,
2503 .id = AV_CODEC_ID_DTS,
2504 .priv_data_size = sizeof(DCAContext),
2505 .init = dca_decode_init,
2506 .decode = dca_decode_frame,
2507 .close = dca_decode_end,
2508 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
2509 .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
2510 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2511 AV_SAMPLE_FMT_NONE },
2512 .profiles = NULL_IF_CONFIG_SMALL(profiles),