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/intmath.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/audioconvert.h"
41 #include "synth_filter.h"
43 #include "fmtconvert.h"
51 #define DCA_PRIM_CHANNELS_MAX (7)
52 #define DCA_SUBBANDS (32)
53 #define DCA_ABITS_MAX (32) /* Should be 28 */
54 #define DCA_SUBSUBFRAMES_MAX (4)
55 #define DCA_SUBFRAMES_MAX (16)
56 #define DCA_BLOCKS_MAX (16)
57 #define DCA_LFE_MAX (3)
73 /* these are unconfirmed but should be mostly correct */
74 enum DCAExSSSpeakerMask {
75 DCA_EXSS_FRONT_CENTER = 0x0001,
76 DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002,
77 DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004,
78 DCA_EXSS_LFE = 0x0008,
79 DCA_EXSS_REAR_CENTER = 0x0010,
80 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
81 DCA_EXSS_REAR_LEFT_RIGHT = 0x0040,
82 DCA_EXSS_FRONT_HIGH_CENTER = 0x0080,
83 DCA_EXSS_OVERHEAD = 0x0100,
84 DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200,
85 DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400,
86 DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800,
87 DCA_EXSS_LFE2 = 0x1000,
88 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000,
89 DCA_EXSS_REAR_HIGH_CENTER = 0x4000,
90 DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000,
93 enum DCAExtensionMask {
94 DCA_EXT_CORE = 0x001, ///< core in core substream
95 DCA_EXT_XXCH = 0x002, ///< XXCh channels extension in core substream
96 DCA_EXT_X96 = 0x004, ///< 96/24 extension in core substream
97 DCA_EXT_XCH = 0x008, ///< XCh channel extension in core substream
98 DCA_EXT_EXSS_CORE = 0x010, ///< core in ExSS (extension substream)
99 DCA_EXT_EXSS_XBR = 0x020, ///< extended bitrate extension in ExSS
100 DCA_EXT_EXSS_XXCH = 0x040, ///< XXCh channels extension in ExSS
101 DCA_EXT_EXSS_X96 = 0x080, ///< 96/24 extension in ExSS
102 DCA_EXT_EXSS_LBR = 0x100, ///< low bitrate component in ExSS
103 DCA_EXT_EXSS_XLL = 0x200, ///< lossless extension in ExSS
106 /* -1 are reserved or unknown */
107 static const int dca_ext_audio_descr_mask[] = {
111 DCA_EXT_XCH | DCA_EXT_X96,
118 /* extensions that reside in core substream */
119 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
121 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
122 * Some compromises have been made for special configurations. Most configurations
123 * are never used so complete accuracy is not needed.
125 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
126 * S -> side, when both rear and back are configured move one of them to the side channel
128 * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
130 static const uint64_t dca_core_channel_layout[] = {
131 AV_CH_FRONT_CENTER, ///< 1, A
132 AV_CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
133 AV_CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
134 AV_CH_LAYOUT_STEREO, ///< 2, (L + R) + (L - R) (sum-difference)
135 AV_CH_LAYOUT_STEREO, ///< 2, LT + RT (left and right total)
136 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER, ///< 3, C + L + R
137 AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER, ///< 3, L + R + S
138 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 4, C + L + R + S
139 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 4, L + R + SL + SR
141 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
142 AV_CH_SIDE_RIGHT, ///< 5, C + L + R + SL + SR
144 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
145 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
147 AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
148 AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 6, C + L + R + LR + RR + OV
150 AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
151 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER |
152 AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 6, CF + CR + LF + RF + LR + RR
154 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
155 AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
156 AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
158 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
159 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
160 AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2
162 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
163 AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
164 AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT, ///< 8, CL + C + CR + L + R + SL + S + SR
167 static const int8_t dca_lfe_index[] = {
168 1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
171 static const int8_t dca_channel_reorder_lfe[][9] = {
172 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
173 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
174 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
175 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
176 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
177 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
178 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
179 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
180 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
181 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
182 { 3, 4, 0, 1, 5, 6, -1, -1, -1},
183 { 2, 0, 1, 4, 5, 6, -1, -1, -1},
184 { 0, 6, 4, 5, 2, 3, -1, -1, -1},
185 { 4, 2, 5, 0, 1, 6, 7, -1, -1},
186 { 5, 6, 0, 1, 7, 3, 8, 4, -1},
187 { 4, 2, 5, 0, 1, 6, 8, 7, -1},
190 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
191 { 0, 2, -1, -1, -1, -1, -1, -1, -1},
192 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
193 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
194 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
195 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
196 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
197 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
198 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
199 { 0, 1, 4, 5, 3, -1, -1, -1, -1},
200 { 2, 0, 1, 5, 6, 4, -1, -1, -1},
201 { 3, 4, 0, 1, 6, 7, 5, -1, -1},
202 { 2, 0, 1, 4, 5, 6, 7, -1, -1},
203 { 0, 6, 4, 5, 2, 3, 7, -1, -1},
204 { 4, 2, 5, 0, 1, 7, 8, 6, -1},
205 { 5, 6, 0, 1, 8, 3, 9, 4, 7},
206 { 4, 2, 5, 0, 1, 6, 9, 8, 7},
209 static const int8_t dca_channel_reorder_nolfe[][9] = {
210 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
211 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
212 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
213 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
214 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
215 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
216 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
217 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
218 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
219 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
220 { 2, 3, 0, 1, 4, 5, -1, -1, -1},
221 { 2, 0, 1, 3, 4, 5, -1, -1, -1},
222 { 0, 5, 3, 4, 1, 2, -1, -1, -1},
223 { 3, 2, 4, 0, 1, 5, 6, -1, -1},
224 { 4, 5, 0, 1, 6, 2, 7, 3, -1},
225 { 3, 2, 4, 0, 1, 5, 7, 6, -1},
228 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
229 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
230 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
231 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
232 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
233 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
234 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
235 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
236 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
237 { 0, 1, 3, 4, 2, -1, -1, -1, -1},
238 { 2, 0, 1, 4, 5, 3, -1, -1, -1},
239 { 2, 3, 0, 1, 5, 6, 4, -1, -1},
240 { 2, 0, 1, 3, 4, 5, 6, -1, -1},
241 { 0, 5, 3, 4, 1, 2, 6, -1, -1},
242 { 3, 2, 4, 0, 1, 6, 7, 5, -1},
243 { 4, 5, 0, 1, 7, 2, 8, 3, 6},
244 { 3, 2, 4, 0, 1, 5, 8, 7, 6},
247 #define DCA_DOLBY 101 /* FIXME */
249 #define DCA_CHANNEL_BITS 6
250 #define DCA_CHANNEL_MASK 0x3F
254 #define HEADER_SIZE 14
256 #define DCA_MAX_FRAME_SIZE 16384
257 #define DCA_MAX_EXSS_HEADER_SIZE 4096
259 #define DCA_BUFFER_PADDING_SIZE 1024
261 /** Bit allocation */
263 int offset; ///< code values offset
264 int maxbits[8]; ///< max bits in VLC
265 int wrap; ///< wrap for get_vlc2()
266 VLC vlc[8]; ///< actual codes
269 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
270 static BitAlloc dca_tmode; ///< transition mode VLCs
271 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
272 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
274 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
277 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
282 AVCodecContext *avctx;
285 int frame_type; ///< type of the current frame
286 int samples_deficit; ///< deficit sample count
287 int crc_present; ///< crc is present in the bitstream
288 int sample_blocks; ///< number of PCM sample blocks
289 int frame_size; ///< primary frame byte size
290 int amode; ///< audio channels arrangement
291 int sample_rate; ///< audio sampling rate
292 int bit_rate; ///< transmission bit rate
293 int bit_rate_index; ///< transmission bit rate index
295 int downmix; ///< embedded downmix enabled
296 int dynrange; ///< embedded dynamic range flag
297 int timestamp; ///< embedded time stamp flag
298 int aux_data; ///< auxiliary data flag
299 int hdcd; ///< source material is mastered in HDCD
300 int ext_descr; ///< extension audio descriptor flag
301 int ext_coding; ///< extended coding flag
302 int aspf; ///< audio sync word insertion flag
303 int lfe; ///< low frequency effects flag
304 int predictor_history; ///< predictor history flag
305 int header_crc; ///< header crc check bytes
306 int multirate_inter; ///< multirate interpolator switch
307 int version; ///< encoder software revision
308 int copy_history; ///< copy history
309 int source_pcm_res; ///< source pcm resolution
310 int front_sum; ///< front sum/difference flag
311 int surround_sum; ///< surround sum/difference flag
312 int dialog_norm; ///< dialog normalisation parameter
314 /* Primary audio coding header */
315 int subframes; ///< number of subframes
316 int total_channels; ///< number of channels including extensions
317 int prim_channels; ///< number of primary audio channels
318 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
319 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
320 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
321 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
322 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
323 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
324 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
325 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
327 /* Primary audio coding side information */
328 int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
329 int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
330 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
331 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
332 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
333 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
334 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
335 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
336 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
337 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
338 int dynrange_coef; ///< dynamic range coefficient
340 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
342 float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
343 int lfe_scale_factor;
345 /* Subband samples history (for ADPCM) */
346 DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
347 DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
348 DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
349 int hist_index[DCA_PRIM_CHANNELS_MAX];
350 DECLARE_ALIGNED(32, float, raXin)[32];
352 int output; ///< type of output
353 float scale_bias; ///< output scale
355 DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
356 DECLARE_ALIGNED(32, float, samples)[(DCA_PRIM_CHANNELS_MAX + 1) * 256];
357 const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
359 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
360 int dca_buffer_size; ///< how much data is in the dca_buffer
362 const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
364 /* Current position in DCA frame */
365 int current_subframe;
366 int current_subsubframe;
368 int core_ext_mask; ///< present extensions in the core substream
370 /* XCh extension information */
371 int xch_present; ///< XCh extension present and valid
372 int xch_base_channel; ///< index of first (only) channel containing XCH data
374 /* ExSS header parser */
375 int static_fields; ///< static fields present
376 int mix_metadata; ///< mixing metadata present
377 int num_mix_configs; ///< number of mix out configurations
378 int mix_config_num_ch[4]; ///< number of channels in each mix out configuration
382 int debug_flag; ///< used for suppressing repeated error messages output
385 SynthFilterContext synth;
386 DCADSPContext dcadsp;
387 FmtConvertContext fmt_conv;
390 static const uint16_t dca_vlc_offs[] = {
391 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
392 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
393 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
394 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
395 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
396 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
399 static av_cold void dca_init_vlcs(void)
401 static int vlcs_initialized = 0;
403 static VLC_TYPE dca_table[23622][2];
405 if (vlcs_initialized)
408 dca_bitalloc_index.offset = 1;
409 dca_bitalloc_index.wrap = 2;
410 for (i = 0; i < 5; i++) {
411 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
412 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
413 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
414 bitalloc_12_bits[i], 1, 1,
415 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
417 dca_scalefactor.offset = -64;
418 dca_scalefactor.wrap = 2;
419 for (i = 0; i < 5; i++) {
420 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
421 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
422 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
423 scales_bits[i], 1, 1,
424 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
426 dca_tmode.offset = 0;
428 for (i = 0; i < 4; i++) {
429 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
430 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
431 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
433 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
436 for (i = 0; i < 10; i++)
437 for (j = 0; j < 7; j++) {
438 if (!bitalloc_codes[i][j])
440 dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i];
441 dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4);
442 dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
443 dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
445 init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
447 bitalloc_bits[i][j], 1, 1,
448 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
451 vlcs_initialized = 1;
454 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
457 *dst++ = get_bits(gb, bits);
460 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel)
463 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
464 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
465 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
467 s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
468 s->prim_channels = s->total_channels;
470 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
471 s->prim_channels = DCA_PRIM_CHANNELS_MAX;
474 for (i = base_channel; i < s->prim_channels; i++) {
475 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
476 if (s->subband_activity[i] > DCA_SUBBANDS)
477 s->subband_activity[i] = DCA_SUBBANDS;
479 for (i = base_channel; i < s->prim_channels; i++) {
480 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
481 if (s->vq_start_subband[i] > DCA_SUBBANDS)
482 s->vq_start_subband[i] = DCA_SUBBANDS;
484 get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
485 get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
486 get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
487 get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
489 /* Get codebooks quantization indexes */
491 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
492 for (j = 1; j < 11; j++)
493 for (i = base_channel; i < s->prim_channels; i++)
494 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
496 /* Get scale factor adjustment */
497 for (j = 0; j < 11; j++)
498 for (i = base_channel; i < s->prim_channels; i++)
499 s->scalefactor_adj[i][j] = 1;
501 for (j = 1; j < 11; j++)
502 for (i = base_channel; i < s->prim_channels; i++)
503 if (s->quant_index_huffman[i][j] < thr[j])
504 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
506 if (s->crc_present) {
507 /* Audio header CRC check */
508 get_bits(&s->gb, 16);
511 s->current_subframe = 0;
512 s->current_subsubframe = 0;
515 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
516 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
517 for (i = base_channel; i < s->prim_channels; i++) {
518 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
519 s->subband_activity[i]);
520 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
521 s->vq_start_subband[i]);
522 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
523 s->joint_intensity[i]);
524 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
525 s->transient_huffman[i]);
526 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
527 s->scalefactor_huffman[i]);
528 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
529 s->bitalloc_huffman[i]);
530 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
531 for (j = 0; j < 11; j++)
532 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
533 av_log(s->avctx, AV_LOG_DEBUG, "\n");
534 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
535 for (j = 0; j < 11; j++)
536 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
537 av_log(s->avctx, AV_LOG_DEBUG, "\n");
544 static int dca_parse_frame_header(DCAContext *s)
546 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
549 skip_bits_long(&s->gb, 32);
552 s->frame_type = get_bits(&s->gb, 1);
553 s->samples_deficit = get_bits(&s->gb, 5) + 1;
554 s->crc_present = get_bits(&s->gb, 1);
555 s->sample_blocks = get_bits(&s->gb, 7) + 1;
556 s->frame_size = get_bits(&s->gb, 14) + 1;
557 if (s->frame_size < 95)
558 return AVERROR_INVALIDDATA;
559 s->amode = get_bits(&s->gb, 6);
560 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
562 return AVERROR_INVALIDDATA;
563 s->bit_rate_index = get_bits(&s->gb, 5);
564 s->bit_rate = dca_bit_rates[s->bit_rate_index];
566 return AVERROR_INVALIDDATA;
568 s->downmix = get_bits(&s->gb, 1);
569 s->dynrange = get_bits(&s->gb, 1);
570 s->timestamp = get_bits(&s->gb, 1);
571 s->aux_data = get_bits(&s->gb, 1);
572 s->hdcd = get_bits(&s->gb, 1);
573 s->ext_descr = get_bits(&s->gb, 3);
574 s->ext_coding = get_bits(&s->gb, 1);
575 s->aspf = get_bits(&s->gb, 1);
576 s->lfe = get_bits(&s->gb, 2);
577 s->predictor_history = get_bits(&s->gb, 1);
579 /* TODO: check CRC */
581 s->header_crc = get_bits(&s->gb, 16);
583 s->multirate_inter = get_bits(&s->gb, 1);
584 s->version = get_bits(&s->gb, 4);
585 s->copy_history = get_bits(&s->gb, 2);
586 s->source_pcm_res = get_bits(&s->gb, 3);
587 s->front_sum = get_bits(&s->gb, 1);
588 s->surround_sum = get_bits(&s->gb, 1);
589 s->dialog_norm = get_bits(&s->gb, 4);
591 /* FIXME: channels mixing levels */
592 s->output = s->amode;
594 s->output |= DCA_LFE;
597 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
598 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
599 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
600 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
601 s->sample_blocks, s->sample_blocks * 32);
602 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
603 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
604 s->amode, dca_channels[s->amode]);
605 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
607 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
609 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
610 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
611 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
612 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
613 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
614 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
615 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
616 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
617 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
618 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
619 s->predictor_history);
620 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
621 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
623 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
624 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
625 av_log(s->avctx, AV_LOG_DEBUG,
626 "source pcm resolution: %i (%i bits/sample)\n",
627 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
628 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
629 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
630 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
631 av_log(s->avctx, AV_LOG_DEBUG, "\n");
634 /* Primary audio coding header */
635 s->subframes = get_bits(&s->gb, 4) + 1;
637 return dca_parse_audio_coding_header(s, 0);
641 static inline int get_scale(GetBitContext *gb, int level, int value)
644 /* huffman encoded */
645 value += get_bitalloc(gb, &dca_scalefactor, level);
646 } else if (level < 8)
647 value = get_bits(gb, level + 1);
651 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
653 /* Primary audio coding side information */
656 if (get_bits_left(&s->gb) < 0)
657 return AVERROR_INVALIDDATA;
660 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
661 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
664 for (j = base_channel; j < s->prim_channels; j++) {
665 for (k = 0; k < s->subband_activity[j]; k++)
666 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
669 /* Get prediction codebook */
670 for (j = base_channel; j < s->prim_channels; j++) {
671 for (k = 0; k < s->subband_activity[j]; k++) {
672 if (s->prediction_mode[j][k] > 0) {
673 /* (Prediction coefficient VQ address) */
674 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
679 /* Bit allocation index */
680 for (j = base_channel; j < s->prim_channels; j++) {
681 for (k = 0; k < s->vq_start_subband[j]; k++) {
682 if (s->bitalloc_huffman[j] == 6)
683 s->bitalloc[j][k] = get_bits(&s->gb, 5);
684 else if (s->bitalloc_huffman[j] == 5)
685 s->bitalloc[j][k] = get_bits(&s->gb, 4);
686 else if (s->bitalloc_huffman[j] == 7) {
687 av_log(s->avctx, AV_LOG_ERROR,
688 "Invalid bit allocation index\n");
689 return AVERROR_INVALIDDATA;
692 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
695 if (s->bitalloc[j][k] > 26) {
696 // av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index [%i][%i] too big (%i)\n",
697 // j, k, s->bitalloc[j][k]);
698 return AVERROR_INVALIDDATA;
703 /* Transition mode */
704 for (j = base_channel; j < s->prim_channels; j++) {
705 for (k = 0; k < s->subband_activity[j]; k++) {
706 s->transition_mode[j][k] = 0;
707 if (s->subsubframes[s->current_subframe] > 1 &&
708 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
709 s->transition_mode[j][k] =
710 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
715 if (get_bits_left(&s->gb) < 0)
716 return AVERROR_INVALIDDATA;
718 for (j = base_channel; j < s->prim_channels; j++) {
719 const uint32_t *scale_table;
722 memset(s->scale_factor[j], 0,
723 s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
725 if (s->scalefactor_huffman[j] == 6)
726 scale_table = scale_factor_quant7;
728 scale_table = scale_factor_quant6;
730 /* When huffman coded, only the difference is encoded */
733 for (k = 0; k < s->subband_activity[j]; k++) {
734 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
735 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
736 s->scale_factor[j][k][0] = scale_table[scale_sum];
739 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
740 /* Get second scale factor */
741 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
742 s->scale_factor[j][k][1] = scale_table[scale_sum];
747 /* Joint subband scale factor codebook select */
748 for (j = base_channel; j < s->prim_channels; j++) {
749 /* Transmitted only if joint subband coding enabled */
750 if (s->joint_intensity[j] > 0)
751 s->joint_huff[j] = get_bits(&s->gb, 3);
754 if (get_bits_left(&s->gb) < 0)
755 return AVERROR_INVALIDDATA;
757 /* Scale factors for joint subband coding */
758 for (j = base_channel; j < s->prim_channels; j++) {
761 /* Transmitted only if joint subband coding enabled */
762 if (s->joint_intensity[j] > 0) {
764 source_channel = s->joint_intensity[j] - 1;
766 /* When huffman coded, only the difference is encoded
767 * (is this valid as well for joint scales ???) */
769 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
770 scale = get_scale(&s->gb, s->joint_huff[j], 0);
771 scale += 64; /* bias */
772 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
775 if (!(s->debug_flag & 0x02)) {
776 av_log(s->avctx, AV_LOG_DEBUG,
777 "Joint stereo coding not supported\n");
778 s->debug_flag |= 0x02;
783 /* Stereo downmix coefficients */
784 if (!base_channel && s->prim_channels > 2) {
786 for (j = base_channel; j < s->prim_channels; j++) {
787 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
788 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
791 int am = s->amode & DCA_CHANNEL_MASK;
792 for (j = base_channel; j < s->prim_channels; j++) {
793 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
794 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
799 /* Dynamic range coefficient */
800 if (!base_channel && s->dynrange)
801 s->dynrange_coef = get_bits(&s->gb, 8);
803 /* Side information CRC check word */
804 if (s->crc_present) {
805 get_bits(&s->gb, 16);
809 * Primary audio data arrays
812 /* VQ encoded high frequency subbands */
813 for (j = base_channel; j < s->prim_channels; j++)
814 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
815 /* 1 vector -> 32 samples */
816 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
818 /* Low frequency effect data */
819 if (!base_channel && s->lfe) {
821 int lfe_samples = 2 * s->lfe * (4 + block_index);
822 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
825 for (j = lfe_samples; j < lfe_end_sample; j++) {
826 /* Signed 8 bits int */
827 s->lfe_data[j] = get_sbits(&s->gb, 8);
830 /* Scale factor index */
831 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
833 /* Quantization step size * scale factor */
834 lfe_scale = 0.035 * s->lfe_scale_factor;
836 for (j = lfe_samples; j < lfe_end_sample; j++)
837 s->lfe_data[j] *= lfe_scale;
841 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
842 s->subsubframes[s->current_subframe]);
843 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
844 s->partial_samples[s->current_subframe]);
846 for (j = base_channel; j < s->prim_channels; j++) {
847 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
848 for (k = 0; k < s->subband_activity[j]; k++)
849 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
850 av_log(s->avctx, AV_LOG_DEBUG, "\n");
852 for (j = base_channel; j < s->prim_channels; j++) {
853 for (k = 0; k < s->subband_activity[j]; k++)
854 av_log(s->avctx, AV_LOG_DEBUG,
855 "prediction coefs: %f, %f, %f, %f\n",
856 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
857 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
858 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
859 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
861 for (j = base_channel; j < s->prim_channels; j++) {
862 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
863 for (k = 0; k < s->vq_start_subband[j]; k++)
864 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
865 av_log(s->avctx, AV_LOG_DEBUG, "\n");
867 for (j = base_channel; j < s->prim_channels; j++) {
868 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
869 for (k = 0; k < s->subband_activity[j]; k++)
870 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
871 av_log(s->avctx, AV_LOG_DEBUG, "\n");
873 for (j = base_channel; j < s->prim_channels; j++) {
874 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
875 for (k = 0; k < s->subband_activity[j]; k++) {
876 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
877 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
878 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
879 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
881 av_log(s->avctx, AV_LOG_DEBUG, "\n");
883 for (j = base_channel; j < s->prim_channels; j++) {
884 if (s->joint_intensity[j] > 0) {
885 int source_channel = s->joint_intensity[j] - 1;
886 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
887 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
888 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
889 av_log(s->avctx, AV_LOG_DEBUG, "\n");
892 if (!base_channel && s->prim_channels > 2 && s->downmix) {
893 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
894 for (j = 0; j < s->prim_channels; j++) {
895 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
896 dca_downmix_coeffs[s->downmix_coef[j][0]]);
897 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
898 dca_downmix_coeffs[s->downmix_coef[j][1]]);
900 av_log(s->avctx, AV_LOG_DEBUG, "\n");
902 for (j = base_channel; j < s->prim_channels; j++)
903 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
904 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
905 if (!base_channel && s->lfe) {
906 int lfe_samples = 2 * s->lfe * (4 + block_index);
907 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
909 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
910 for (j = lfe_samples; j < lfe_end_sample; j++)
911 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
912 av_log(s->avctx, AV_LOG_DEBUG, "\n");
919 static void qmf_32_subbands(DCAContext *s, int chans,
920 float samples_in[32][8], float *samples_out,
923 const float *prCoeff;
926 int sb_act = s->subband_activity[chans];
929 scale *= sqrt(1 / 8.0);
932 if (!s->multirate_inter) /* Non-perfect reconstruction */
933 prCoeff = fir_32bands_nonperfect;
934 else /* Perfect reconstruction */
935 prCoeff = fir_32bands_perfect;
937 for (i = sb_act; i < 32; i++)
940 /* Reconstructed channel sample index */
941 for (subindex = 0; subindex < 8; subindex++) {
942 /* Load in one sample from each subband and clear inactive subbands */
943 for (i = 0; i < sb_act; i++) {
944 unsigned sign = (i - 1) & 2;
945 uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
946 AV_WN32A(&s->raXin[i], v);
949 s->synth.synth_filter_float(&s->imdct,
950 s->subband_fir_hist[chans],
951 &s->hist_index[chans],
952 s->subband_fir_noidea[chans], prCoeff,
953 samples_out, s->raXin, scale);
958 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
959 int num_deci_sample, float *samples_in,
960 float *samples_out, float scale)
962 /* samples_in: An array holding decimated samples.
963 * Samples in current subframe starts from samples_in[0],
964 * while samples_in[-1], samples_in[-2], ..., stores samples
965 * from last subframe as history.
967 * samples_out: An array holding interpolated samples
971 const float *prCoeff;
974 /* Select decimation filter */
975 if (decimation_select == 1) {
977 prCoeff = lfe_fir_128;
980 prCoeff = lfe_fir_64;
983 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
984 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
986 samples_out += 2 * decifactor;
990 /* downmixing routines */
991 #define MIX_REAR1(samples, si1, rs, coef) \
992 samples[i] += samples[si1] * coef[rs][0]; \
993 samples[i+256] += samples[si1] * coef[rs][1];
995 #define MIX_REAR2(samples, si1, si2, rs, coef) \
996 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs + 1][0]; \
997 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs + 1][1];
999 #define MIX_FRONT3(samples, coef) \
1000 t = samples[i + c]; \
1001 u = samples[i + l]; \
1002 v = samples[i + r]; \
1003 samples[i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1004 samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1006 #define DOWNMIX_TO_STEREO(op1, op2) \
1007 for (i = 0; i < 256; i++) { \
1012 static void dca_downmix(float *samples, int srcfmt,
1013 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
1014 const int8_t *channel_mapping)
1016 int c, l, r, sl, sr, s;
1019 float coef[DCA_PRIM_CHANNELS_MAX][2];
1021 for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
1022 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
1023 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
1029 case DCA_STEREO_TOTAL:
1030 case DCA_STEREO_SUMDIFF:
1032 av_log(NULL, 0, "Not implemented!\n");
1037 c = channel_mapping[0] * 256;
1038 l = channel_mapping[1] * 256;
1039 r = channel_mapping[2] * 256;
1040 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1043 s = channel_mapping[2] * 256;
1044 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef), );
1047 c = channel_mapping[0] * 256;
1048 l = channel_mapping[1] * 256;
1049 r = channel_mapping[2] * 256;
1050 s = channel_mapping[3] * 256;
1051 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1052 MIX_REAR1(samples, i + s, 3, coef));
1055 sl = channel_mapping[2] * 256;
1056 sr = channel_mapping[3] * 256;
1057 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef), );
1060 c = channel_mapping[0] * 256;
1061 l = channel_mapping[1] * 256;
1062 r = channel_mapping[2] * 256;
1063 sl = channel_mapping[3] * 256;
1064 sr = channel_mapping[4] * 256;
1065 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1066 MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1072 #ifndef decode_blockcodes
1073 /* Very compact version of the block code decoder that does not use table
1074 * look-up but is slightly slower */
1075 static int decode_blockcode(int code, int levels, int *values)
1078 int offset = (levels - 1) >> 1;
1080 for (i = 0; i < 4; i++) {
1081 int div = FASTDIV(code, levels);
1082 values[i] = code - offset - div * levels;
1089 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1091 return decode_blockcode(code1, levels, values) |
1092 decode_blockcode(code2, levels, values + 4);
1096 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1097 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1099 #ifndef int8x8_fmul_int32
1100 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1102 float fscale = scale / 16.0;
1104 for (i = 0; i < 8; i++)
1105 dst[i] = src[i] * fscale;
1109 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1112 int subsubframe = s->current_subsubframe;
1114 const float *quant_step_table;
1117 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1118 LOCAL_ALIGNED_16(int, block, [8]);
1124 /* Select quantization step size table */
1125 if (s->bit_rate_index == 0x1f)
1126 quant_step_table = lossless_quant_d;
1128 quant_step_table = lossy_quant_d;
1130 for (k = base_channel; k < s->prim_channels; k++) {
1131 if (get_bits_left(&s->gb) < 0)
1132 return AVERROR_INVALIDDATA;
1134 for (l = 0; l < s->vq_start_subband[k]; l++) {
1137 /* Select the mid-tread linear quantizer */
1138 int abits = s->bitalloc[k][l];
1140 float quant_step_size = quant_step_table[abits];
1143 * Determine quantization index code book and its type
1146 /* Select quantization index code book */
1147 int sel = s->quant_index_huffman[k][abits];
1150 * Extract bits from the bit stream
1153 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1155 /* Deal with transients */
1156 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1157 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
1158 s->scalefactor_adj[k][sel];
1160 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1163 int block_code1, block_code2, size, levels, err;
1165 size = abits_sizes[abits - 1];
1166 levels = abits_levels[abits - 1];
1168 block_code1 = get_bits(&s->gb, size);
1169 block_code2 = get_bits(&s->gb, size);
1170 err = decode_blockcodes(block_code1, block_code2,
1173 av_log(s->avctx, AV_LOG_ERROR,
1174 "ERROR: block code look-up failed\n");
1175 return AVERROR_INVALIDDATA;
1179 for (m = 0; m < 8; m++)
1180 block[m] = get_sbits(&s->gb, abits - 3);
1184 for (m = 0; m < 8; m++)
1185 block[m] = get_bitalloc(&s->gb,
1186 &dca_smpl_bitalloc[abits], sel);
1189 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1194 * Inverse ADPCM if in prediction mode
1196 if (s->prediction_mode[k][l]) {
1198 for (m = 0; m < 8; m++) {
1199 for (n = 1; n <= 4; n++)
1201 subband_samples[k][l][m] +=
1202 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1203 subband_samples[k][l][m - n] / 8192);
1204 else if (s->predictor_history)
1205 subband_samples[k][l][m] +=
1206 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1207 s->subband_samples_hist[k][l][m - n + 4] / 8192);
1213 * Decode VQ encoded high frequencies
1215 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1216 /* 1 vector -> 32 samples but we only need the 8 samples
1217 * for this subsubframe. */
1218 int hfvq = s->high_freq_vq[k][l];
1220 if (!s->debug_flag & 0x01) {
1221 av_log(s->avctx, AV_LOG_DEBUG,
1222 "Stream with high frequencies VQ coding\n");
1223 s->debug_flag |= 0x01;
1226 int8x8_fmul_int32(subband_samples[k][l],
1227 &high_freq_vq[hfvq][subsubframe * 8],
1228 s->scale_factor[k][l][0]);
1232 /* Check for DSYNC after subsubframe */
1233 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1234 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1236 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1239 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1243 /* Backup predictor history for adpcm */
1244 for (k = base_channel; k < s->prim_channels; k++)
1245 for (l = 0; l < s->vq_start_subband[k]; l++)
1246 memcpy(s->subband_samples_hist[k][l],
1247 &subband_samples[k][l][4],
1248 4 * sizeof(subband_samples[0][0][0]));
1253 static int dca_filter_channels(DCAContext *s, int block_index)
1255 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1258 /* 32 subbands QMF */
1259 for (k = 0; k < s->prim_channels; k++) {
1260 /* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1261 0, 8388608.0, 8388608.0 };*/
1262 qmf_32_subbands(s, k, subband_samples[k],
1263 &s->samples[256 * s->channel_order_tab[k]],
1264 M_SQRT1_2 * s->scale_bias /* pcm_to_double[s->source_pcm_res] */);
1268 if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1269 dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
1272 /* Generate LFE samples for this subsubframe FIXME!!! */
1273 if (s->output & DCA_LFE) {
1274 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1275 s->lfe_data + 2 * s->lfe * (block_index + 4),
1276 &s->samples[256 * dca_lfe_index[s->amode]],
1277 (1.0 / 256.0) * s->scale_bias);
1278 /* Outputs 20bits pcm samples */
1285 static int dca_subframe_footer(DCAContext *s, int base_channel)
1287 int aux_data_count = 0, i;
1290 * Unpack optional information
1293 /* presumably optional information only appears in the core? */
1294 if (!base_channel) {
1296 skip_bits_long(&s->gb, 32);
1299 aux_data_count = get_bits(&s->gb, 6);
1301 for (i = 0; i < aux_data_count; i++)
1302 get_bits(&s->gb, 8);
1304 if (s->crc_present && (s->downmix || s->dynrange))
1305 get_bits(&s->gb, 16);
1312 * Decode a dca frame block
1314 * @param s pointer to the DCAContext
1317 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1322 if (s->current_subframe >= s->subframes) {
1323 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1324 s->current_subframe, s->subframes);
1325 return AVERROR_INVALIDDATA;
1328 if (!s->current_subsubframe) {
1330 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1332 /* Read subframe header */
1333 if ((ret = dca_subframe_header(s, base_channel, block_index)))
1337 /* Read subsubframe */
1339 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1341 if ((ret = dca_subsubframe(s, base_channel, block_index)))
1345 s->current_subsubframe++;
1346 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1347 s->current_subsubframe = 0;
1348 s->current_subframe++;
1350 if (s->current_subframe >= s->subframes) {
1352 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1354 /* Read subframe footer */
1355 if ((ret = dca_subframe_footer(s, base_channel)))
1363 * Convert bitstream to one representation based on sync marker
1365 static int dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
1370 const uint16_t *ssrc = (const uint16_t *) src;
1371 uint16_t *sdst = (uint16_t *) dst;
1374 if ((unsigned) src_size > (unsigned) max_size) {
1375 // av_log(NULL, AV_LOG_ERROR, "Input frame size larger than DCA_MAX_FRAME_SIZE!\n");
1377 src_size = max_size;
1382 case DCA_MARKER_RAW_BE:
1383 memcpy(dst, src, src_size);
1385 case DCA_MARKER_RAW_LE:
1386 for (i = 0; i < (src_size + 1) >> 1; i++)
1387 *sdst++ = av_bswap16(*ssrc++);
1389 case DCA_MARKER_14B_BE:
1390 case DCA_MARKER_14B_LE:
1391 init_put_bits(&pb, dst, max_size);
1392 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1393 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1394 put_bits(&pb, 14, tmp);
1396 flush_put_bits(&pb);
1397 return (put_bits_count(&pb) + 7) >> 3;
1399 return AVERROR_INVALIDDATA;
1404 * Return the number of channels in an ExSS speaker mask (HD)
1406 static int dca_exss_mask2count(int mask)
1408 /* count bits that mean speaker pairs twice */
1409 return av_popcount(mask) +
1410 av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
1411 DCA_EXSS_FRONT_LEFT_RIGHT |
1412 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
1413 DCA_EXSS_WIDE_LEFT_RIGHT |
1414 DCA_EXSS_SIDE_LEFT_RIGHT |
1415 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
1416 DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
1417 DCA_EXSS_REAR_LEFT_RIGHT |
1418 DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1422 * Skip mixing coefficients of a single mix out configuration (HD)
1424 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1428 for (i = 0; i < channels; i++) {
1429 int mix_map_mask = get_bits(gb, out_ch);
1430 int num_coeffs = av_popcount(mix_map_mask);
1431 skip_bits_long(gb, num_coeffs * 6);
1436 * Parse extension substream asset header (HD)
1438 static int dca_exss_parse_asset_header(DCAContext *s)
1440 int header_pos = get_bits_count(&s->gb);
1443 int embedded_stereo = 0;
1444 int embedded_6ch = 0;
1445 int drc_code_present;
1446 int av_uninit(extensions_mask);
1449 if (get_bits_left(&s->gb) < 16)
1452 /* We will parse just enough to get to the extensions bitmask with which
1453 * we can set the profile value. */
1455 header_size = get_bits(&s->gb, 9) + 1;
1456 skip_bits(&s->gb, 3); // asset index
1458 if (s->static_fields) {
1459 if (get_bits1(&s->gb))
1460 skip_bits(&s->gb, 4); // asset type descriptor
1461 if (get_bits1(&s->gb))
1462 skip_bits_long(&s->gb, 24); // language descriptor
1464 if (get_bits1(&s->gb)) {
1465 /* How can one fit 1024 bytes of text here if the maximum value
1466 * for the asset header size field above was 512 bytes? */
1467 int text_length = get_bits(&s->gb, 10) + 1;
1468 if (get_bits_left(&s->gb) < text_length * 8)
1470 skip_bits_long(&s->gb, text_length * 8); // info text
1473 skip_bits(&s->gb, 5); // bit resolution - 1
1474 skip_bits(&s->gb, 4); // max sample rate code
1475 channels = get_bits(&s->gb, 8) + 1;
1477 if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1478 int spkr_remap_sets;
1479 int spkr_mask_size = 16;
1483 embedded_stereo = get_bits1(&s->gb);
1485 embedded_6ch = get_bits1(&s->gb);
1487 if (get_bits1(&s->gb)) {
1488 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1489 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1492 spkr_remap_sets = get_bits(&s->gb, 3);
1494 for (i = 0; i < spkr_remap_sets; i++) {
1495 /* std layout mask for each remap set */
1496 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1499 for (i = 0; i < spkr_remap_sets; i++) {
1500 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1501 if (get_bits_left(&s->gb) < 0)
1504 for (j = 0; j < num_spkrs[i]; j++) {
1505 int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1506 int num_dec_ch = av_popcount(remap_dec_ch_mask);
1507 skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1512 skip_bits(&s->gb, 3); // representation type
1516 drc_code_present = get_bits1(&s->gb);
1517 if (drc_code_present)
1518 get_bits(&s->gb, 8); // drc code
1520 if (get_bits1(&s->gb))
1521 skip_bits(&s->gb, 5); // dialog normalization code
1523 if (drc_code_present && embedded_stereo)
1524 get_bits(&s->gb, 8); // drc stereo code
1526 if (s->mix_metadata && get_bits1(&s->gb)) {
1527 skip_bits(&s->gb, 1); // external mix
1528 skip_bits(&s->gb, 6); // post mix gain code
1530 if (get_bits(&s->gb, 2) != 3) // mixer drc code
1531 skip_bits(&s->gb, 3); // drc limit
1533 skip_bits(&s->gb, 8); // custom drc code
1535 if (get_bits1(&s->gb)) // channel specific scaling
1536 for (i = 0; i < s->num_mix_configs; i++)
1537 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1539 skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1541 for (i = 0; i < s->num_mix_configs; i++) {
1542 if (get_bits_left(&s->gb) < 0)
1544 dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1546 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1547 if (embedded_stereo)
1548 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1552 switch (get_bits(&s->gb, 2)) {
1553 case 0: extensions_mask = get_bits(&s->gb, 12); break;
1554 case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1555 case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1556 case 3: extensions_mask = 0; /* aux coding */ break;
1559 /* not parsed further, we were only interested in the extensions mask */
1561 if (get_bits_left(&s->gb) < 0)
1564 if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1565 av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1568 skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1570 if (extensions_mask & DCA_EXT_EXSS_XLL)
1571 s->profile = FF_PROFILE_DTS_HD_MA;
1572 else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1574 s->profile = FF_PROFILE_DTS_HD_HRA;
1576 if (!(extensions_mask & DCA_EXT_CORE))
1577 av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1578 if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1579 av_log(s->avctx, AV_LOG_WARNING,
1580 "DTS extensions detection mismatch (%d, %d)\n",
1581 extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1587 * Parse extension substream header (HD)
1589 static void dca_exss_parse_header(DCAContext *s)
1595 int active_ss_mask[8];
1598 if (get_bits_left(&s->gb) < 52)
1601 skip_bits(&s->gb, 8); // user data
1602 ss_index = get_bits(&s->gb, 2);
1604 blownup = get_bits1(&s->gb);
1605 skip_bits(&s->gb, 8 + 4 * blownup); // header_size
1606 skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1608 s->static_fields = get_bits1(&s->gb);
1609 if (s->static_fields) {
1610 skip_bits(&s->gb, 2); // reference clock code
1611 skip_bits(&s->gb, 3); // frame duration code
1613 if (get_bits1(&s->gb))
1614 skip_bits_long(&s->gb, 36); // timestamp
1616 /* a single stream can contain multiple audio assets that can be
1617 * combined to form multiple audio presentations */
1619 num_audiop = get_bits(&s->gb, 3) + 1;
1620 if (num_audiop > 1) {
1621 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1622 /* ignore such streams for now */
1626 num_assets = get_bits(&s->gb, 3) + 1;
1627 if (num_assets > 1) {
1628 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1629 /* ignore such streams for now */
1633 for (i = 0; i < num_audiop; i++)
1634 active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1636 for (i = 0; i < num_audiop; i++)
1637 for (j = 0; j <= ss_index; j++)
1638 if (active_ss_mask[i] & (1 << j))
1639 skip_bits(&s->gb, 8); // active asset mask
1641 s->mix_metadata = get_bits1(&s->gb);
1642 if (s->mix_metadata) {
1643 int mix_out_mask_size;
1645 skip_bits(&s->gb, 2); // adjustment level
1646 mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1647 s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1649 for (i = 0; i < s->num_mix_configs; i++) {
1650 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1651 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1656 for (i = 0; i < num_assets; i++)
1657 skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1659 for (i = 0; i < num_assets; i++) {
1660 if (dca_exss_parse_asset_header(s))
1664 /* not parsed further, we were only interested in the extensions mask
1665 * from the asset header */
1669 * Main frame decoding function
1670 * FIXME add arguments
1672 static int dca_decode_frame(AVCodecContext *avctx, void *data,
1673 int *got_frame_ptr, AVPacket *avpkt)
1675 const uint8_t *buf = avpkt->data;
1676 int buf_size = avpkt->size;
1679 int num_core_channels = 0;
1682 int16_t *samples_s16;
1683 DCAContext *s = avctx->priv_data;
1690 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1691 DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1692 if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
1693 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1694 return AVERROR_INVALIDDATA;
1697 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1698 if ((ret = dca_parse_frame_header(s)) < 0) {
1699 //seems like the frame is corrupt, try with the next one
1702 //set AVCodec values with parsed data
1703 avctx->sample_rate = s->sample_rate;
1704 avctx->bit_rate = s->bit_rate;
1705 avctx->frame_size = s->sample_blocks * 32;
1707 s->profile = FF_PROFILE_DTS;
1709 for (i = 0; i < (s->sample_blocks / 8); i++) {
1710 if ((ret = dca_decode_block(s, 0, i))) {
1711 av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
1716 /* record number of core channels incase less than max channels are requested */
1717 num_core_channels = s->prim_channels;
1720 s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
1722 s->core_ext_mask = 0;
1724 core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1726 /* only scan for extensions if ext_descr was unknown or indicated a
1727 * supported XCh extension */
1728 if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
1730 /* if ext_descr was unknown, clear s->core_ext_mask so that the
1731 * extensions scan can fill it up */
1732 s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
1734 /* extensions start at 32-bit boundaries into bitstream */
1735 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1737 while (core_ss_end - get_bits_count(&s->gb) >= 32) {
1738 uint32_t bits = get_bits_long(&s->gb, 32);
1742 int ext_amode, xch_fsize;
1744 s->xch_base_channel = s->prim_channels;
1746 /* validate sync word using XCHFSIZE field */
1747 xch_fsize = show_bits(&s->gb, 10);
1748 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1749 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1752 /* skip length-to-end-of-frame field for the moment */
1753 skip_bits(&s->gb, 10);
1755 s->core_ext_mask |= DCA_EXT_XCH;
1757 /* extension amode(number of channels in extension) should be 1 */
1758 /* AFAIK XCh is not used for more channels */
1759 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1760 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1761 " supported!\n", ext_amode);
1765 /* much like core primary audio coding header */
1766 dca_parse_audio_coding_header(s, s->xch_base_channel);
1768 for (i = 0; i < (s->sample_blocks / 8); i++)
1769 if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
1770 av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
1778 /* XXCh: extended channels */
1779 /* usually found either in core or HD part in DTS-HD HRA streams,
1780 * but not in DTS-ES which contains XCh extensions instead */
1781 s->core_ext_mask |= DCA_EXT_XXCH;
1785 int fsize96 = show_bits(&s->gb, 12) + 1;
1786 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1789 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
1790 get_bits_count(&s->gb));
1791 skip_bits(&s->gb, 12);
1792 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1793 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1795 s->core_ext_mask |= DCA_EXT_X96;
1800 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1803 /* no supported extensions, skip the rest of the core substream */
1804 skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
1807 if (s->core_ext_mask & DCA_EXT_X96)
1808 s->profile = FF_PROFILE_DTS_96_24;
1809 else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
1810 s->profile = FF_PROFILE_DTS_ES;
1812 /* check for ExSS (HD part) */
1813 if (s->dca_buffer_size - s->frame_size > 32 &&
1814 get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1815 dca_exss_parse_header(s);
1817 avctx->profile = s->profile;
1819 channels = s->prim_channels + !!s->lfe;
1821 if (s->amode < 16) {
1822 avctx->channel_layout = dca_core_channel_layout[s->amode];
1824 if (s->xch_present && (!avctx->request_channels ||
1825 avctx->request_channels > num_core_channels + !!s->lfe)) {
1826 avctx->channel_layout |= AV_CH_BACK_CENTER;
1828 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1829 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1831 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1834 channels = num_core_channels + !!s->lfe;
1835 s->xch_present = 0; /* disable further xch processing */
1837 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1838 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1840 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1843 if (channels > !!s->lfe &&
1844 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1845 return AVERROR_INVALIDDATA;
1847 if (avctx->request_channels == 2 && s->prim_channels > 2) {
1849 s->output = DCA_STEREO;
1850 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1852 else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
1853 static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
1854 s->channel_order_tab = dca_channel_order_native;
1857 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
1858 return AVERROR_INVALIDDATA;
1861 if (avctx->channels != channels) {
1862 if (avctx->channels)
1863 av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
1864 avctx->channels = channels;
1867 /* get output buffer */
1868 s->frame.nb_samples = 256 * (s->sample_blocks / 8);
1869 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1870 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1873 samples_flt = (float *) s->frame.data[0];
1874 samples_s16 = (int16_t *) s->frame.data[0];
1876 /* filter to get final output */
1877 for (i = 0; i < (s->sample_blocks / 8); i++) {
1878 dca_filter_channels(s, i);
1880 /* If this was marked as a DTS-ES stream we need to subtract back- */
1881 /* channel from SL & SR to remove matrixed back-channel signal */
1882 if ((s->source_pcm_res & 1) && s->xch_present) {
1883 float *back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1884 float *lt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1885 float *rt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1886 s->dsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
1887 s->dsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
1890 if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1891 s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
1893 samples_flt += 256 * channels;
1895 s->fmt_conv.float_to_int16_interleave(samples_s16,
1896 s->samples_chanptr, 256,
1898 samples_s16 += 256 * channels;
1902 /* update lfe history */
1903 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1904 for (i = 0; i < 2 * s->lfe * 4; i++)
1905 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1908 *(AVFrame *) data = s->frame;
1916 * DCA initialization
1918 * @param avctx pointer to the AVCodecContext
1921 static av_cold int dca_decode_init(AVCodecContext *avctx)
1923 DCAContext *s = avctx->priv_data;
1929 dsputil_init(&s->dsp, avctx);
1930 ff_mdct_init(&s->imdct, 6, 1, 1.0);
1931 ff_synth_filter_init(&s->synth);
1932 ff_dcadsp_init(&s->dcadsp);
1933 ff_fmt_convert_init(&s->fmt_conv, avctx);
1935 for (i = 0; i < DCA_PRIM_CHANNELS_MAX + 1; i++)
1936 s->samples_chanptr[i] = s->samples + i * 256;
1938 if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
1939 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1940 s->scale_bias = 1.0 / 32768.0;
1942 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1943 s->scale_bias = 1.0;
1946 /* allow downmixing to stereo */
1947 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1948 avctx->request_channels == 2) {
1949 avctx->channels = avctx->request_channels;
1952 avcodec_get_frame_defaults(&s->frame);
1953 avctx->coded_frame = &s->frame;
1958 static av_cold int dca_decode_end(AVCodecContext *avctx)
1960 DCAContext *s = avctx->priv_data;
1961 ff_mdct_end(&s->imdct);
1965 static const AVProfile profiles[] = {
1966 { FF_PROFILE_DTS, "DTS" },
1967 { FF_PROFILE_DTS_ES, "DTS-ES" },
1968 { FF_PROFILE_DTS_96_24, "DTS 96/24" },
1969 { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1970 { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
1971 { FF_PROFILE_UNKNOWN },
1974 AVCodec ff_dca_decoder = {
1976 .type = AVMEDIA_TYPE_AUDIO,
1978 .priv_data_size = sizeof(DCAContext),
1979 .init = dca_decode_init,
1980 .decode = dca_decode_frame,
1981 .close = dca_decode_end,
1982 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1983 .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
1984 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
1986 AV_SAMPLE_FMT_NONE },
1987 .profiles = NULL_IF_CONFIG_SMALL(profiles),