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 Libav.
10 * Libav is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * Libav is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with Libav; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
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 is_channels_set; ///< check for if the channel number is already set
317 int total_channels; ///< number of channels including extensions
318 int prim_channels; ///< number of primary audio channels
319 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
320 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
321 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
322 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
323 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
324 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
325 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
326 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
328 /* Primary audio coding side information */
329 int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
330 int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
331 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
332 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
333 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
334 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
335 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
336 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
337 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
338 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
339 int dynrange_coef; ///< dynamic range coefficient
341 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
343 float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
344 int lfe_scale_factor;
346 /* Subband samples history (for ADPCM) */
347 DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
348 DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
349 DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
350 int hist_index[DCA_PRIM_CHANNELS_MAX];
351 DECLARE_ALIGNED(32, float, raXin)[32];
353 int output; ///< type of output
354 float scale_bias; ///< output scale
356 DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
357 DECLARE_ALIGNED(32, float, samples)[(DCA_PRIM_CHANNELS_MAX + 1) * 256];
358 const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
360 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
361 int dca_buffer_size; ///< how much data is in the dca_buffer
363 const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
365 /* Current position in DCA frame */
366 int current_subframe;
367 int current_subsubframe;
369 int core_ext_mask; ///< present extensions in the core substream
371 /* XCh extension information */
372 int xch_present; ///< XCh extension present and valid
373 int xch_base_channel; ///< index of first (only) channel containing XCH data
375 /* ExSS header parser */
376 int static_fields; ///< static fields present
377 int mix_metadata; ///< mixing metadata present
378 int num_mix_configs; ///< number of mix out configurations
379 int mix_config_num_ch[4]; ///< number of channels in each mix out configuration
383 int debug_flag; ///< used for suppressing repeated error messages output
386 SynthFilterContext synth;
387 DCADSPContext dcadsp;
388 FmtConvertContext fmt_conv;
391 static const uint16_t dca_vlc_offs[] = {
392 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
393 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
394 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
395 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
396 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
397 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
400 static av_cold void dca_init_vlcs(void)
402 static int vlcs_initialized = 0;
404 static VLC_TYPE dca_table[23622][2];
406 if (vlcs_initialized)
409 dca_bitalloc_index.offset = 1;
410 dca_bitalloc_index.wrap = 2;
411 for (i = 0; i < 5; i++) {
412 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
413 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
414 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
415 bitalloc_12_bits[i], 1, 1,
416 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
418 dca_scalefactor.offset = -64;
419 dca_scalefactor.wrap = 2;
420 for (i = 0; i < 5; i++) {
421 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
422 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
423 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
424 scales_bits[i], 1, 1,
425 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
427 dca_tmode.offset = 0;
429 for (i = 0; i < 4; i++) {
430 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
431 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
432 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
434 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
437 for (i = 0; i < 10; i++)
438 for (j = 0; j < 7; j++) {
439 if (!bitalloc_codes[i][j])
441 dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i];
442 dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4);
443 dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
444 dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
446 init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
448 bitalloc_bits[i][j], 1, 1,
449 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
452 vlcs_initialized = 1;
455 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
458 *dst++ = get_bits(gb, bits);
461 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel)
464 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
465 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
466 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
468 s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
469 s->prim_channels = s->total_channels;
471 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
472 s->prim_channels = DCA_PRIM_CHANNELS_MAX;
475 for (i = base_channel; i < s->prim_channels; i++) {
476 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
477 if (s->subband_activity[i] > DCA_SUBBANDS)
478 s->subband_activity[i] = DCA_SUBBANDS;
480 for (i = base_channel; i < s->prim_channels; i++) {
481 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
482 if (s->vq_start_subband[i] > DCA_SUBBANDS)
483 s->vq_start_subband[i] = DCA_SUBBANDS;
485 get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
486 get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
487 get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
488 get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
490 /* Get codebooks quantization indexes */
492 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
493 for (j = 1; j < 11; j++)
494 for (i = base_channel; i < s->prim_channels; i++)
495 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
497 /* Get scale factor adjustment */
498 for (j = 0; j < 11; j++)
499 for (i = base_channel; i < s->prim_channels; i++)
500 s->scalefactor_adj[i][j] = 1;
502 for (j = 1; j < 11; j++)
503 for (i = base_channel; i < s->prim_channels; i++)
504 if (s->quant_index_huffman[i][j] < thr[j])
505 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
507 if (s->crc_present) {
508 /* Audio header CRC check */
509 get_bits(&s->gb, 16);
512 s->current_subframe = 0;
513 s->current_subsubframe = 0;
516 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
517 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
518 for (i = base_channel; i < s->prim_channels; i++) {
519 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
520 s->subband_activity[i]);
521 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
522 s->vq_start_subband[i]);
523 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
524 s->joint_intensity[i]);
525 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
526 s->transient_huffman[i]);
527 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
528 s->scalefactor_huffman[i]);
529 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
530 s->bitalloc_huffman[i]);
531 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
532 for (j = 0; j < 11; j++)
533 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
534 av_log(s->avctx, AV_LOG_DEBUG, "\n");
535 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
536 for (j = 0; j < 11; j++)
537 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
538 av_log(s->avctx, AV_LOG_DEBUG, "\n");
545 static int dca_parse_frame_header(DCAContext *s)
547 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
550 skip_bits_long(&s->gb, 32);
553 s->frame_type = get_bits(&s->gb, 1);
554 s->samples_deficit = get_bits(&s->gb, 5) + 1;
555 s->crc_present = get_bits(&s->gb, 1);
556 s->sample_blocks = get_bits(&s->gb, 7) + 1;
557 s->frame_size = get_bits(&s->gb, 14) + 1;
558 if (s->frame_size < 95)
559 return AVERROR_INVALIDDATA;
560 s->amode = get_bits(&s->gb, 6);
561 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
563 return AVERROR_INVALIDDATA;
564 s->bit_rate_index = get_bits(&s->gb, 5);
565 s->bit_rate = dca_bit_rates[s->bit_rate_index];
567 return AVERROR_INVALIDDATA;
569 s->downmix = get_bits(&s->gb, 1);
570 s->dynrange = get_bits(&s->gb, 1);
571 s->timestamp = get_bits(&s->gb, 1);
572 s->aux_data = get_bits(&s->gb, 1);
573 s->hdcd = get_bits(&s->gb, 1);
574 s->ext_descr = get_bits(&s->gb, 3);
575 s->ext_coding = get_bits(&s->gb, 1);
576 s->aspf = get_bits(&s->gb, 1);
577 s->lfe = get_bits(&s->gb, 2);
578 s->predictor_history = get_bits(&s->gb, 1);
580 /* TODO: check CRC */
582 s->header_crc = get_bits(&s->gb, 16);
584 s->multirate_inter = get_bits(&s->gb, 1);
585 s->version = get_bits(&s->gb, 4);
586 s->copy_history = get_bits(&s->gb, 2);
587 s->source_pcm_res = get_bits(&s->gb, 3);
588 s->front_sum = get_bits(&s->gb, 1);
589 s->surround_sum = get_bits(&s->gb, 1);
590 s->dialog_norm = get_bits(&s->gb, 4);
592 /* FIXME: channels mixing levels */
593 s->output = s->amode;
595 s->output |= DCA_LFE;
598 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
599 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
600 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
601 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
602 s->sample_blocks, s->sample_blocks * 32);
603 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
604 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
605 s->amode, dca_channels[s->amode]);
606 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
608 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
610 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
611 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
612 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
613 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
614 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
615 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
616 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
617 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
618 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
619 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
620 s->predictor_history);
621 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
622 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
624 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
625 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
626 av_log(s->avctx, AV_LOG_DEBUG,
627 "source pcm resolution: %i (%i bits/sample)\n",
628 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
629 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
630 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
631 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
632 av_log(s->avctx, AV_LOG_DEBUG, "\n");
635 /* Primary audio coding header */
636 s->subframes = get_bits(&s->gb, 4) + 1;
638 return dca_parse_audio_coding_header(s, 0);
642 static inline int get_scale(GetBitContext *gb, int level, int value)
645 /* huffman encoded */
646 value += get_bitalloc(gb, &dca_scalefactor, level);
647 } else if (level < 8)
648 value = get_bits(gb, level + 1);
652 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
654 /* Primary audio coding side information */
657 if (get_bits_left(&s->gb) < 0)
658 return AVERROR_INVALIDDATA;
661 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
662 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
665 for (j = base_channel; j < s->prim_channels; j++) {
666 for (k = 0; k < s->subband_activity[j]; k++)
667 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
670 /* Get prediction codebook */
671 for (j = base_channel; j < s->prim_channels; j++) {
672 for (k = 0; k < s->subband_activity[j]; k++) {
673 if (s->prediction_mode[j][k] > 0) {
674 /* (Prediction coefficient VQ address) */
675 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
680 /* Bit allocation index */
681 for (j = base_channel; j < s->prim_channels; j++) {
682 for (k = 0; k < s->vq_start_subband[j]; k++) {
683 if (s->bitalloc_huffman[j] == 6)
684 s->bitalloc[j][k] = get_bits(&s->gb, 5);
685 else if (s->bitalloc_huffman[j] == 5)
686 s->bitalloc[j][k] = get_bits(&s->gb, 4);
687 else if (s->bitalloc_huffman[j] == 7) {
688 av_log(s->avctx, AV_LOG_ERROR,
689 "Invalid bit allocation index\n");
690 return AVERROR_INVALIDDATA;
693 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
696 if (s->bitalloc[j][k] > 26) {
697 // av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index [%i][%i] too big (%i)\n",
698 // j, k, s->bitalloc[j][k]);
699 return AVERROR_INVALIDDATA;
704 /* Transition mode */
705 for (j = base_channel; j < s->prim_channels; j++) {
706 for (k = 0; k < s->subband_activity[j]; k++) {
707 s->transition_mode[j][k] = 0;
708 if (s->subsubframes[s->current_subframe] > 1 &&
709 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
710 s->transition_mode[j][k] =
711 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
716 if (get_bits_left(&s->gb) < 0)
717 return AVERROR_INVALIDDATA;
719 for (j = base_channel; j < s->prim_channels; j++) {
720 const uint32_t *scale_table;
723 memset(s->scale_factor[j], 0,
724 s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
726 if (s->scalefactor_huffman[j] == 6)
727 scale_table = scale_factor_quant7;
729 scale_table = scale_factor_quant6;
731 /* When huffman coded, only the difference is encoded */
734 for (k = 0; k < s->subband_activity[j]; k++) {
735 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
736 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
737 s->scale_factor[j][k][0] = scale_table[scale_sum];
740 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
741 /* Get second scale factor */
742 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
743 s->scale_factor[j][k][1] = scale_table[scale_sum];
748 /* Joint subband scale factor codebook select */
749 for (j = base_channel; j < s->prim_channels; j++) {
750 /* Transmitted only if joint subband coding enabled */
751 if (s->joint_intensity[j] > 0)
752 s->joint_huff[j] = get_bits(&s->gb, 3);
755 if (get_bits_left(&s->gb) < 0)
756 return AVERROR_INVALIDDATA;
758 /* Scale factors for joint subband coding */
759 for (j = base_channel; j < s->prim_channels; j++) {
762 /* Transmitted only if joint subband coding enabled */
763 if (s->joint_intensity[j] > 0) {
765 source_channel = s->joint_intensity[j] - 1;
767 /* When huffman coded, only the difference is encoded
768 * (is this valid as well for joint scales ???) */
770 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
771 scale = get_scale(&s->gb, s->joint_huff[j], 0);
772 scale += 64; /* bias */
773 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
776 if (!(s->debug_flag & 0x02)) {
777 av_log(s->avctx, AV_LOG_DEBUG,
778 "Joint stereo coding not supported\n");
779 s->debug_flag |= 0x02;
784 /* Stereo downmix coefficients */
785 if (!base_channel && s->prim_channels > 2) {
787 for (j = base_channel; j < s->prim_channels; j++) {
788 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
789 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
792 int am = s->amode & DCA_CHANNEL_MASK;
793 for (j = base_channel; j < s->prim_channels; j++) {
794 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
795 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
800 /* Dynamic range coefficient */
801 if (!base_channel && s->dynrange)
802 s->dynrange_coef = get_bits(&s->gb, 8);
804 /* Side information CRC check word */
805 if (s->crc_present) {
806 get_bits(&s->gb, 16);
810 * Primary audio data arrays
813 /* VQ encoded high frequency subbands */
814 for (j = base_channel; j < s->prim_channels; j++)
815 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
816 /* 1 vector -> 32 samples */
817 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
819 /* Low frequency effect data */
820 if (!base_channel && s->lfe) {
822 int lfe_samples = 2 * s->lfe * (4 + block_index);
823 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
826 for (j = lfe_samples; j < lfe_end_sample; j++) {
827 /* Signed 8 bits int */
828 s->lfe_data[j] = get_sbits(&s->gb, 8);
831 /* Scale factor index */
832 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
834 /* Quantization step size * scale factor */
835 lfe_scale = 0.035 * s->lfe_scale_factor;
837 for (j = lfe_samples; j < lfe_end_sample; j++)
838 s->lfe_data[j] *= lfe_scale;
842 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
843 s->subsubframes[s->current_subframe]);
844 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
845 s->partial_samples[s->current_subframe]);
847 for (j = base_channel; j < s->prim_channels; j++) {
848 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
849 for (k = 0; k < s->subband_activity[j]; k++)
850 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
851 av_log(s->avctx, AV_LOG_DEBUG, "\n");
853 for (j = base_channel; j < s->prim_channels; j++) {
854 for (k = 0; k < s->subband_activity[j]; k++)
855 av_log(s->avctx, AV_LOG_DEBUG,
856 "prediction coefs: %f, %f, %f, %f\n",
857 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
858 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
859 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
860 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
862 for (j = base_channel; j < s->prim_channels; j++) {
863 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
864 for (k = 0; k < s->vq_start_subband[j]; k++)
865 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
866 av_log(s->avctx, AV_LOG_DEBUG, "\n");
868 for (j = base_channel; j < s->prim_channels; j++) {
869 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
870 for (k = 0; k < s->subband_activity[j]; k++)
871 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
872 av_log(s->avctx, AV_LOG_DEBUG, "\n");
874 for (j = base_channel; j < s->prim_channels; j++) {
875 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
876 for (k = 0; k < s->subband_activity[j]; k++) {
877 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
878 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
879 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
880 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
882 av_log(s->avctx, AV_LOG_DEBUG, "\n");
884 for (j = base_channel; j < s->prim_channels; j++) {
885 if (s->joint_intensity[j] > 0) {
886 int source_channel = s->joint_intensity[j] - 1;
887 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
888 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
889 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
890 av_log(s->avctx, AV_LOG_DEBUG, "\n");
893 if (!base_channel && s->prim_channels > 2 && s->downmix) {
894 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
895 for (j = 0; j < s->prim_channels; j++) {
896 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
897 dca_downmix_coeffs[s->downmix_coef[j][0]]);
898 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
899 dca_downmix_coeffs[s->downmix_coef[j][1]]);
901 av_log(s->avctx, AV_LOG_DEBUG, "\n");
903 for (j = base_channel; j < s->prim_channels; j++)
904 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
905 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
906 if (!base_channel && s->lfe) {
907 int lfe_samples = 2 * s->lfe * (4 + block_index);
908 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
910 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
911 for (j = lfe_samples; j < lfe_end_sample; j++)
912 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
913 av_log(s->avctx, AV_LOG_DEBUG, "\n");
920 static void qmf_32_subbands(DCAContext *s, int chans,
921 float samples_in[32][8], float *samples_out,
924 const float *prCoeff;
927 int sb_act = s->subband_activity[chans];
930 scale *= sqrt(1 / 8.0);
933 if (!s->multirate_inter) /* Non-perfect reconstruction */
934 prCoeff = fir_32bands_nonperfect;
935 else /* Perfect reconstruction */
936 prCoeff = fir_32bands_perfect;
938 for (i = sb_act; i < 32; i++)
941 /* Reconstructed channel sample index */
942 for (subindex = 0; subindex < 8; subindex++) {
943 /* Load in one sample from each subband and clear inactive subbands */
944 for (i = 0; i < sb_act; i++) {
945 unsigned sign = (i - 1) & 2;
946 uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
947 AV_WN32A(&s->raXin[i], v);
950 s->synth.synth_filter_float(&s->imdct,
951 s->subband_fir_hist[chans],
952 &s->hist_index[chans],
953 s->subband_fir_noidea[chans], prCoeff,
954 samples_out, s->raXin, scale);
959 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
960 int num_deci_sample, float *samples_in,
961 float *samples_out, float scale)
963 /* samples_in: An array holding decimated samples.
964 * Samples in current subframe starts from samples_in[0],
965 * while samples_in[-1], samples_in[-2], ..., stores samples
966 * from last subframe as history.
968 * samples_out: An array holding interpolated samples
972 const float *prCoeff;
975 /* Select decimation filter */
976 if (decimation_select == 1) {
978 prCoeff = lfe_fir_128;
981 prCoeff = lfe_fir_64;
984 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
985 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
987 samples_out += 2 * decifactor;
991 /* downmixing routines */
992 #define MIX_REAR1(samples, si1, rs, coef) \
993 samples[i] += samples[si1] * coef[rs][0]; \
994 samples[i+256] += samples[si1] * coef[rs][1];
996 #define MIX_REAR2(samples, si1, si2, rs, coef) \
997 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs + 1][0]; \
998 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs + 1][1];
1000 #define MIX_FRONT3(samples, coef) \
1001 t = samples[i + c]; \
1002 u = samples[i + l]; \
1003 v = samples[i + r]; \
1004 samples[i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1005 samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1007 #define DOWNMIX_TO_STEREO(op1, op2) \
1008 for (i = 0; i < 256; i++) { \
1013 static void dca_downmix(float *samples, int srcfmt,
1014 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
1015 const int8_t *channel_mapping)
1017 int c, l, r, sl, sr, s;
1020 float coef[DCA_PRIM_CHANNELS_MAX][2];
1022 for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
1023 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
1024 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
1030 case DCA_STEREO_TOTAL:
1031 case DCA_STEREO_SUMDIFF:
1033 av_log(NULL, 0, "Not implemented!\n");
1038 c = channel_mapping[0] * 256;
1039 l = channel_mapping[1] * 256;
1040 r = channel_mapping[2] * 256;
1041 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1044 s = channel_mapping[2] * 256;
1045 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef), );
1048 c = channel_mapping[0] * 256;
1049 l = channel_mapping[1] * 256;
1050 r = channel_mapping[2] * 256;
1051 s = channel_mapping[3] * 256;
1052 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1053 MIX_REAR1(samples, i + s, 3, coef));
1056 sl = channel_mapping[2] * 256;
1057 sr = channel_mapping[3] * 256;
1058 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef), );
1061 c = channel_mapping[0] * 256;
1062 l = channel_mapping[1] * 256;
1063 r = channel_mapping[2] * 256;
1064 sl = channel_mapping[3] * 256;
1065 sr = channel_mapping[4] * 256;
1066 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1067 MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1073 #ifndef decode_blockcodes
1074 /* Very compact version of the block code decoder that does not use table
1075 * look-up but is slightly slower */
1076 static int decode_blockcode(int code, int levels, int *values)
1079 int offset = (levels - 1) >> 1;
1081 for (i = 0; i < 4; i++) {
1082 int div = FASTDIV(code, levels);
1083 values[i] = code - offset - div * levels;
1090 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1092 return decode_blockcode(code1, levels, values) |
1093 decode_blockcode(code2, levels, values + 4);
1097 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1098 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1100 #ifndef int8x8_fmul_int32
1101 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1103 float fscale = scale / 16.0;
1105 for (i = 0; i < 8; i++)
1106 dst[i] = src[i] * fscale;
1110 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1113 int subsubframe = s->current_subsubframe;
1115 const float *quant_step_table;
1118 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1119 LOCAL_ALIGNED_16(int, block, [8]);
1125 /* Select quantization step size table */
1126 if (s->bit_rate_index == 0x1f)
1127 quant_step_table = lossless_quant_d;
1129 quant_step_table = lossy_quant_d;
1131 for (k = base_channel; k < s->prim_channels; k++) {
1132 if (get_bits_left(&s->gb) < 0)
1133 return AVERROR_INVALIDDATA;
1135 for (l = 0; l < s->vq_start_subband[k]; l++) {
1138 /* Select the mid-tread linear quantizer */
1139 int abits = s->bitalloc[k][l];
1141 float quant_step_size = quant_step_table[abits];
1144 * Determine quantization index code book and its type
1147 /* Select quantization index code book */
1148 int sel = s->quant_index_huffman[k][abits];
1151 * Extract bits from the bit stream
1154 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1156 /* Deal with transients */
1157 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1158 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
1159 s->scalefactor_adj[k][sel];
1161 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1164 int block_code1, block_code2, size, levels, err;
1166 size = abits_sizes[abits - 1];
1167 levels = abits_levels[abits - 1];
1169 block_code1 = get_bits(&s->gb, size);
1170 block_code2 = get_bits(&s->gb, size);
1171 err = decode_blockcodes(block_code1, block_code2,
1174 av_log(s->avctx, AV_LOG_ERROR,
1175 "ERROR: block code look-up failed\n");
1176 return AVERROR_INVALIDDATA;
1180 for (m = 0; m < 8; m++)
1181 block[m] = get_sbits(&s->gb, abits - 3);
1185 for (m = 0; m < 8; m++)
1186 block[m] = get_bitalloc(&s->gb,
1187 &dca_smpl_bitalloc[abits], sel);
1190 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1195 * Inverse ADPCM if in prediction mode
1197 if (s->prediction_mode[k][l]) {
1199 for (m = 0; m < 8; m++) {
1200 for (n = 1; n <= 4; n++)
1202 subband_samples[k][l][m] +=
1203 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1204 subband_samples[k][l][m - n] / 8192);
1205 else if (s->predictor_history)
1206 subband_samples[k][l][m] +=
1207 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1208 s->subband_samples_hist[k][l][m - n + 4] / 8192);
1214 * Decode VQ encoded high frequencies
1216 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1217 /* 1 vector -> 32 samples but we only need the 8 samples
1218 * for this subsubframe. */
1219 int hfvq = s->high_freq_vq[k][l];
1221 if (!s->debug_flag & 0x01) {
1222 av_log(s->avctx, AV_LOG_DEBUG,
1223 "Stream with high frequencies VQ coding\n");
1224 s->debug_flag |= 0x01;
1227 int8x8_fmul_int32(subband_samples[k][l],
1228 &high_freq_vq[hfvq][subsubframe * 8],
1229 s->scale_factor[k][l][0]);
1233 /* Check for DSYNC after subsubframe */
1234 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1235 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1237 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1240 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1244 /* Backup predictor history for adpcm */
1245 for (k = base_channel; k < s->prim_channels; k++)
1246 for (l = 0; l < s->vq_start_subband[k]; l++)
1247 memcpy(s->subband_samples_hist[k][l],
1248 &subband_samples[k][l][4],
1249 4 * sizeof(subband_samples[0][0][0]));
1254 static int dca_filter_channels(DCAContext *s, int block_index)
1256 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1259 /* 32 subbands QMF */
1260 for (k = 0; k < s->prim_channels; k++) {
1261 /* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1262 0, 8388608.0, 8388608.0 };*/
1263 qmf_32_subbands(s, k, subband_samples[k],
1264 &s->samples[256 * s->channel_order_tab[k]],
1265 M_SQRT1_2 * s->scale_bias /* pcm_to_double[s->source_pcm_res] */);
1269 if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1270 dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
1273 /* Generate LFE samples for this subsubframe FIXME!!! */
1274 if (s->output & DCA_LFE) {
1275 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1276 s->lfe_data + 2 * s->lfe * (block_index + 4),
1277 &s->samples[256 * dca_lfe_index[s->amode]],
1278 (1.0 / 256.0) * s->scale_bias);
1279 /* Outputs 20bits pcm samples */
1286 static int dca_subframe_footer(DCAContext *s, int base_channel)
1288 int aux_data_count = 0, i;
1291 * Unpack optional information
1294 /* presumably optional information only appears in the core? */
1295 if (!base_channel) {
1297 skip_bits_long(&s->gb, 32);
1300 aux_data_count = get_bits(&s->gb, 6);
1302 for (i = 0; i < aux_data_count; i++)
1303 get_bits(&s->gb, 8);
1305 if (s->crc_present && (s->downmix || s->dynrange))
1306 get_bits(&s->gb, 16);
1313 * Decode a dca frame block
1315 * @param s pointer to the DCAContext
1318 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1323 if (s->current_subframe >= s->subframes) {
1324 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1325 s->current_subframe, s->subframes);
1326 return AVERROR_INVALIDDATA;
1329 if (!s->current_subsubframe) {
1331 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1333 /* Read subframe header */
1334 if ((ret = dca_subframe_header(s, base_channel, block_index)))
1338 /* Read subsubframe */
1340 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1342 if ((ret = dca_subsubframe(s, base_channel, block_index)))
1346 s->current_subsubframe++;
1347 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1348 s->current_subsubframe = 0;
1349 s->current_subframe++;
1351 if (s->current_subframe >= s->subframes) {
1353 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1355 /* Read subframe footer */
1356 if ((ret = dca_subframe_footer(s, base_channel)))
1364 * Convert bitstream to one representation based on sync marker
1366 static int dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
1371 const uint16_t *ssrc = (const uint16_t *) src;
1372 uint16_t *sdst = (uint16_t *) dst;
1375 if ((unsigned) src_size > (unsigned) max_size) {
1376 // av_log(NULL, AV_LOG_ERROR, "Input frame size larger than DCA_MAX_FRAME_SIZE!\n");
1378 src_size = max_size;
1383 case DCA_MARKER_RAW_BE:
1384 memcpy(dst, src, src_size);
1386 case DCA_MARKER_RAW_LE:
1387 for (i = 0; i < (src_size + 1) >> 1; i++)
1388 *sdst++ = av_bswap16(*ssrc++);
1390 case DCA_MARKER_14B_BE:
1391 case DCA_MARKER_14B_LE:
1392 init_put_bits(&pb, dst, max_size);
1393 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1394 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1395 put_bits(&pb, 14, tmp);
1397 flush_put_bits(&pb);
1398 return (put_bits_count(&pb) + 7) >> 3;
1400 return AVERROR_INVALIDDATA;
1405 * Return the number of channels in an ExSS speaker mask (HD)
1407 static int dca_exss_mask2count(int mask)
1409 /* count bits that mean speaker pairs twice */
1410 return av_popcount(mask) +
1411 av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
1412 DCA_EXSS_FRONT_LEFT_RIGHT |
1413 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
1414 DCA_EXSS_WIDE_LEFT_RIGHT |
1415 DCA_EXSS_SIDE_LEFT_RIGHT |
1416 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
1417 DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
1418 DCA_EXSS_REAR_LEFT_RIGHT |
1419 DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1423 * Skip mixing coefficients of a single mix out configuration (HD)
1425 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1429 for (i = 0; i < channels; i++) {
1430 int mix_map_mask = get_bits(gb, out_ch);
1431 int num_coeffs = av_popcount(mix_map_mask);
1432 skip_bits_long(gb, num_coeffs * 6);
1437 * Parse extension substream asset header (HD)
1439 static int dca_exss_parse_asset_header(DCAContext *s)
1441 int header_pos = get_bits_count(&s->gb);
1444 int embedded_stereo = 0;
1445 int embedded_6ch = 0;
1446 int drc_code_present;
1447 int extensions_mask;
1450 if (get_bits_left(&s->gb) < 16)
1453 /* We will parse just enough to get to the extensions bitmask with which
1454 * we can set the profile value. */
1456 header_size = get_bits(&s->gb, 9) + 1;
1457 skip_bits(&s->gb, 3); // asset index
1459 if (s->static_fields) {
1460 if (get_bits1(&s->gb))
1461 skip_bits(&s->gb, 4); // asset type descriptor
1462 if (get_bits1(&s->gb))
1463 skip_bits_long(&s->gb, 24); // language descriptor
1465 if (get_bits1(&s->gb)) {
1466 /* How can one fit 1024 bytes of text here if the maximum value
1467 * for the asset header size field above was 512 bytes? */
1468 int text_length = get_bits(&s->gb, 10) + 1;
1469 if (get_bits_left(&s->gb) < text_length * 8)
1471 skip_bits_long(&s->gb, text_length * 8); // info text
1474 skip_bits(&s->gb, 5); // bit resolution - 1
1475 skip_bits(&s->gb, 4); // max sample rate code
1476 channels = get_bits(&s->gb, 8) + 1;
1478 if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1479 int spkr_remap_sets;
1480 int spkr_mask_size = 16;
1484 embedded_stereo = get_bits1(&s->gb);
1486 embedded_6ch = get_bits1(&s->gb);
1488 if (get_bits1(&s->gb)) {
1489 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1490 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1493 spkr_remap_sets = get_bits(&s->gb, 3);
1495 for (i = 0; i < spkr_remap_sets; i++) {
1496 /* std layout mask for each remap set */
1497 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1500 for (i = 0; i < spkr_remap_sets; i++) {
1501 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1502 if (get_bits_left(&s->gb) < 0)
1505 for (j = 0; j < num_spkrs[i]; j++) {
1506 int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1507 int num_dec_ch = av_popcount(remap_dec_ch_mask);
1508 skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1513 skip_bits(&s->gb, 3); // representation type
1517 drc_code_present = get_bits1(&s->gb);
1518 if (drc_code_present)
1519 get_bits(&s->gb, 8); // drc code
1521 if (get_bits1(&s->gb))
1522 skip_bits(&s->gb, 5); // dialog normalization code
1524 if (drc_code_present && embedded_stereo)
1525 get_bits(&s->gb, 8); // drc stereo code
1527 if (s->mix_metadata && get_bits1(&s->gb)) {
1528 skip_bits(&s->gb, 1); // external mix
1529 skip_bits(&s->gb, 6); // post mix gain code
1531 if (get_bits(&s->gb, 2) != 3) // mixer drc code
1532 skip_bits(&s->gb, 3); // drc limit
1534 skip_bits(&s->gb, 8); // custom drc code
1536 if (get_bits1(&s->gb)) // channel specific scaling
1537 for (i = 0; i < s->num_mix_configs; i++)
1538 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1540 skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1542 for (i = 0; i < s->num_mix_configs; i++) {
1543 if (get_bits_left(&s->gb) < 0)
1545 dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1547 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1548 if (embedded_stereo)
1549 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1553 switch (get_bits(&s->gb, 2)) {
1554 case 0: extensions_mask = get_bits(&s->gb, 12); break;
1555 case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1556 case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1557 case 3: extensions_mask = 0; /* aux coding */ break;
1560 /* not parsed further, we were only interested in the extensions mask */
1562 if (get_bits_left(&s->gb) < 0)
1565 if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1566 av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1569 skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1571 if (extensions_mask & DCA_EXT_EXSS_XLL)
1572 s->profile = FF_PROFILE_DTS_HD_MA;
1573 else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1575 s->profile = FF_PROFILE_DTS_HD_HRA;
1577 if (!(extensions_mask & DCA_EXT_CORE))
1578 av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1579 if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1580 av_log(s->avctx, AV_LOG_WARNING,
1581 "DTS extensions detection mismatch (%d, %d)\n",
1582 extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1588 * Parse extension substream header (HD)
1590 static void dca_exss_parse_header(DCAContext *s)
1596 int active_ss_mask[8];
1599 if (get_bits_left(&s->gb) < 52)
1602 skip_bits(&s->gb, 8); // user data
1603 ss_index = get_bits(&s->gb, 2);
1605 blownup = get_bits1(&s->gb);
1606 skip_bits(&s->gb, 8 + 4 * blownup); // header_size
1607 skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1609 s->static_fields = get_bits1(&s->gb);
1610 if (s->static_fields) {
1611 skip_bits(&s->gb, 2); // reference clock code
1612 skip_bits(&s->gb, 3); // frame duration code
1614 if (get_bits1(&s->gb))
1615 skip_bits_long(&s->gb, 36); // timestamp
1617 /* a single stream can contain multiple audio assets that can be
1618 * combined to form multiple audio presentations */
1620 num_audiop = get_bits(&s->gb, 3) + 1;
1621 if (num_audiop > 1) {
1622 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1623 /* ignore such streams for now */
1627 num_assets = get_bits(&s->gb, 3) + 1;
1628 if (num_assets > 1) {
1629 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1630 /* ignore such streams for now */
1634 for (i = 0; i < num_audiop; i++)
1635 active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1637 for (i = 0; i < num_audiop; i++)
1638 for (j = 0; j <= ss_index; j++)
1639 if (active_ss_mask[i] & (1 << j))
1640 skip_bits(&s->gb, 8); // active asset mask
1642 s->mix_metadata = get_bits1(&s->gb);
1643 if (s->mix_metadata) {
1644 int mix_out_mask_size;
1646 skip_bits(&s->gb, 2); // adjustment level
1647 mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1648 s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1650 for (i = 0; i < s->num_mix_configs; i++) {
1651 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1652 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1657 for (i = 0; i < num_assets; i++)
1658 skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1660 for (i = 0; i < num_assets; i++) {
1661 if (dca_exss_parse_asset_header(s))
1665 /* not parsed further, we were only interested in the extensions mask
1666 * from the asset header */
1670 * Main frame decoding function
1671 * FIXME add arguments
1673 static int dca_decode_frame(AVCodecContext *avctx, void *data,
1674 int *got_frame_ptr, AVPacket *avpkt)
1676 const uint8_t *buf = avpkt->data;
1677 int buf_size = avpkt->size;
1680 int num_core_channels = 0;
1683 int16_t *samples_s16;
1684 DCAContext *s = avctx->priv_data;
1691 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1692 DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1693 if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
1694 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1695 return AVERROR_INVALIDDATA;
1698 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1699 if ((ret = dca_parse_frame_header(s)) < 0) {
1700 //seems like the frame is corrupt, try with the next one
1703 //set AVCodec values with parsed data
1704 avctx->sample_rate = s->sample_rate;
1705 avctx->bit_rate = s->bit_rate;
1706 avctx->frame_size = s->sample_blocks * 32;
1708 s->profile = FF_PROFILE_DTS;
1710 for (i = 0; i < (s->sample_blocks / 8); i++) {
1711 if ((ret = dca_decode_block(s, 0, i))) {
1712 av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
1717 /* record number of core channels incase less than max channels are requested */
1718 num_core_channels = s->prim_channels;
1721 s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
1723 s->core_ext_mask = 0;
1725 core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1727 /* only scan for extensions if ext_descr was unknown or indicated a
1728 * supported XCh extension */
1729 if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
1731 /* if ext_descr was unknown, clear s->core_ext_mask so that the
1732 * extensions scan can fill it up */
1733 s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
1735 /* extensions start at 32-bit boundaries into bitstream */
1736 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1738 while (core_ss_end - get_bits_count(&s->gb) >= 32) {
1739 uint32_t bits = get_bits_long(&s->gb, 32);
1743 int ext_amode, xch_fsize;
1745 s->xch_base_channel = s->prim_channels;
1747 /* validate sync word using XCHFSIZE field */
1748 xch_fsize = show_bits(&s->gb, 10);
1749 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1750 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1753 /* skip length-to-end-of-frame field for the moment */
1754 skip_bits(&s->gb, 10);
1756 s->core_ext_mask |= DCA_EXT_XCH;
1758 /* extension amode(number of channels in extension) should be 1 */
1759 /* AFAIK XCh is not used for more channels */
1760 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1761 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1762 " supported!\n", ext_amode);
1766 /* much like core primary audio coding header */
1767 dca_parse_audio_coding_header(s, s->xch_base_channel);
1769 for (i = 0; i < (s->sample_blocks / 8); i++)
1770 if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
1771 av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
1779 /* XXCh: extended channels */
1780 /* usually found either in core or HD part in DTS-HD HRA streams,
1781 * but not in DTS-ES which contains XCh extensions instead */
1782 s->core_ext_mask |= DCA_EXT_XXCH;
1786 int fsize96 = show_bits(&s->gb, 12) + 1;
1787 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1790 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
1791 get_bits_count(&s->gb));
1792 skip_bits(&s->gb, 12);
1793 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1794 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1796 s->core_ext_mask |= DCA_EXT_X96;
1801 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1804 /* no supported extensions, skip the rest of the core substream */
1805 skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
1808 if (s->core_ext_mask & DCA_EXT_X96)
1809 s->profile = FF_PROFILE_DTS_96_24;
1810 else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
1811 s->profile = FF_PROFILE_DTS_ES;
1813 /* check for ExSS (HD part) */
1814 if (s->dca_buffer_size - s->frame_size > 32 &&
1815 get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1816 dca_exss_parse_header(s);
1818 avctx->profile = s->profile;
1820 channels = s->prim_channels + !!s->lfe;
1822 if (s->amode < 16) {
1823 avctx->channel_layout = dca_core_channel_layout[s->amode];
1825 if (s->xch_present && (!avctx->request_channels ||
1826 avctx->request_channels > num_core_channels + !!s->lfe)) {
1827 avctx->channel_layout |= AV_CH_BACK_CENTER;
1829 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1830 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1832 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1835 channels = num_core_channels + !!s->lfe;
1836 s->xch_present = 0; /* disable further xch processing */
1838 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1839 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1841 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1844 if (channels > !!s->lfe &&
1845 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1846 return AVERROR_INVALIDDATA;
1848 if (avctx->request_channels == 2 && s->prim_channels > 2) {
1850 s->output = DCA_STEREO;
1851 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1854 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
1855 return AVERROR_INVALIDDATA;
1859 /* There is nothing that prevents a dts frame to change channel configuration
1860 but Libav doesn't support that so only set the channels if it is previously
1861 unset. Ideally during the first probe for channels the crc should be checked
1862 and only set avctx->channels when the crc is ok. Right now the decoder could
1863 set the channels based on a broken first frame.*/
1864 if (s->is_channels_set == 0) {
1865 s->is_channels_set = 1;
1866 avctx->channels = channels;
1868 if (avctx->channels != channels) {
1869 av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
1870 "channels changing in stream. Skipping frame.\n");
1871 return AVERROR_PATCHWELCOME;
1874 /* get output buffer */
1875 s->frame.nb_samples = 256 * (s->sample_blocks / 8);
1876 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1877 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1880 samples_flt = (float *) s->frame.data[0];
1881 samples_s16 = (int16_t *) s->frame.data[0];
1883 /* filter to get final output */
1884 for (i = 0; i < (s->sample_blocks / 8); i++) {
1885 dca_filter_channels(s, i);
1887 /* If this was marked as a DTS-ES stream we need to subtract back- */
1888 /* channel from SL & SR to remove matrixed back-channel signal */
1889 if ((s->source_pcm_res & 1) && s->xch_present) {
1890 float *back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1891 float *lt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1892 float *rt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1893 s->dsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
1894 s->dsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
1897 if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1898 s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
1900 samples_flt += 256 * channels;
1902 s->fmt_conv.float_to_int16_interleave(samples_s16,
1903 s->samples_chanptr, 256,
1905 samples_s16 += 256 * channels;
1909 /* update lfe history */
1910 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1911 for (i = 0; i < 2 * s->lfe * 4; i++)
1912 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1915 *(AVFrame *) data = s->frame;
1923 * DCA initialization
1925 * @param avctx pointer to the AVCodecContext
1928 static av_cold int dca_decode_init(AVCodecContext *avctx)
1930 DCAContext *s = avctx->priv_data;
1936 dsputil_init(&s->dsp, avctx);
1937 ff_mdct_init(&s->imdct, 6, 1, 1.0);
1938 ff_synth_filter_init(&s->synth);
1939 ff_dcadsp_init(&s->dcadsp);
1940 ff_fmt_convert_init(&s->fmt_conv, avctx);
1942 for (i = 0; i < DCA_PRIM_CHANNELS_MAX + 1; i++)
1943 s->samples_chanptr[i] = s->samples + i * 256;
1945 if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
1946 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1947 s->scale_bias = 1.0 / 32768.0;
1949 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1950 s->scale_bias = 1.0;
1953 /* allow downmixing to stereo */
1954 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1955 avctx->request_channels == 2) {
1956 avctx->channels = avctx->request_channels;
1959 avcodec_get_frame_defaults(&s->frame);
1960 avctx->coded_frame = &s->frame;
1965 static av_cold int dca_decode_end(AVCodecContext *avctx)
1967 DCAContext *s = avctx->priv_data;
1968 ff_mdct_end(&s->imdct);
1972 static const AVProfile profiles[] = {
1973 { FF_PROFILE_DTS, "DTS" },
1974 { FF_PROFILE_DTS_ES, "DTS-ES" },
1975 { FF_PROFILE_DTS_96_24, "DTS 96/24" },
1976 { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1977 { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
1978 { FF_PROFILE_UNKNOWN },
1981 AVCodec ff_dca_decoder = {
1983 .type = AVMEDIA_TYPE_AUDIO,
1985 .priv_data_size = sizeof(DCAContext),
1986 .init = dca_decode_init,
1987 .decode = dca_decode_frame,
1988 .close = dca_decode_end,
1989 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1990 .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
1991 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
1993 AV_SAMPLE_FMT_NONE },
1994 .profiles = NULL_IF_CONFIG_SMALL(profiles),