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/channel_layout.h"
30 #include "libavutil/common.h"
31 #include "libavutil/float_dsp.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/mathematics.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/samplefmt.h"
44 #include "synth_filter.h"
46 #include "fmtconvert.h"
55 #define DCA_PRIM_CHANNELS_MAX (7)
56 #define DCA_SUBBANDS (64)
57 #define DCA_ABITS_MAX (32) /* Should be 28 */
58 #define DCA_SUBSUBFRAMES_MAX (4)
59 #define DCA_SUBFRAMES_MAX (16)
60 #define DCA_BLOCKS_MAX (16)
61 #define DCA_LFE_MAX (3)
62 #define DCA_CHSETS_MAX (4)
63 #define DCA_CHSET_CHANS_MAX (8)
79 /* these are unconfirmed but should be mostly correct */
80 enum DCAExSSSpeakerMask {
81 DCA_EXSS_FRONT_CENTER = 0x0001,
82 DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002,
83 DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004,
84 DCA_EXSS_LFE = 0x0008,
85 DCA_EXSS_REAR_CENTER = 0x0010,
86 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
87 DCA_EXSS_REAR_LEFT_RIGHT = 0x0040,
88 DCA_EXSS_FRONT_HIGH_CENTER = 0x0080,
89 DCA_EXSS_OVERHEAD = 0x0100,
90 DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200,
91 DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400,
92 DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800,
93 DCA_EXSS_LFE2 = 0x1000,
94 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000,
95 DCA_EXSS_REAR_HIGH_CENTER = 0x4000,
96 DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000,
99 enum DCAXxchSpeakerMask {
100 DCA_XXCH_FRONT_CENTER = 0x0000001,
101 DCA_XXCH_FRONT_LEFT = 0x0000002,
102 DCA_XXCH_FRONT_RIGHT = 0x0000004,
103 DCA_XXCH_SIDE_REAR_LEFT = 0x0000008,
104 DCA_XXCH_SIDE_REAR_RIGHT = 0x0000010,
105 DCA_XXCH_LFE1 = 0x0000020,
106 DCA_XXCH_REAR_CENTER = 0x0000040,
107 DCA_XXCH_SURROUND_REAR_LEFT = 0x0000080,
108 DCA_XXCH_SURROUND_REAR_RIGHT = 0x0000100,
109 DCA_XXCH_SIDE_SURROUND_LEFT = 0x0000200,
110 DCA_XXCH_SIDE_SURROUND_RIGHT = 0x0000400,
111 DCA_XXCH_FRONT_CENTER_LEFT = 0x0000800,
112 DCA_XXCH_FRONT_CENTER_RIGHT = 0x0001000,
113 DCA_XXCH_FRONT_HIGH_LEFT = 0x0002000,
114 DCA_XXCH_FRONT_HIGH_CENTER = 0x0004000,
115 DCA_XXCH_FRONT_HIGH_RIGHT = 0x0008000,
116 DCA_XXCH_LFE2 = 0x0010000,
117 DCA_XXCH_SIDE_FRONT_LEFT = 0x0020000,
118 DCA_XXCH_SIDE_FRONT_RIGHT = 0x0040000,
119 DCA_XXCH_OVERHEAD = 0x0080000,
120 DCA_XXCH_SIDE_HIGH_LEFT = 0x0100000,
121 DCA_XXCH_SIDE_HIGH_RIGHT = 0x0200000,
122 DCA_XXCH_REAR_HIGH_CENTER = 0x0400000,
123 DCA_XXCH_REAR_HIGH_LEFT = 0x0800000,
124 DCA_XXCH_REAR_HIGH_RIGHT = 0x1000000,
125 DCA_XXCH_REAR_LOW_CENTER = 0x2000000,
126 DCA_XXCH_REAR_LOW_LEFT = 0x4000000,
127 DCA_XXCH_REAR_LOW_RIGHT = 0x8000000,
130 static const uint32_t map_xxch_to_native[28] = {
140 AV_CH_SIDE_LEFT, /* side surround left -- dup sur side L */
141 AV_CH_SIDE_RIGHT, /* side surround right -- dup sur side R */
142 AV_CH_FRONT_LEFT_OF_CENTER,
143 AV_CH_FRONT_RIGHT_OF_CENTER,
144 AV_CH_TOP_FRONT_LEFT,
145 AV_CH_TOP_FRONT_CENTER,
146 AV_CH_TOP_FRONT_RIGHT,
147 AV_CH_LOW_FREQUENCY, /* lfe2 -- duplicate lfe1 position */
148 AV_CH_FRONT_LEFT_OF_CENTER, /* side front left -- dup front cntr L */
149 AV_CH_FRONT_RIGHT_OF_CENTER,/* side front right -- dup front cntr R */
150 AV_CH_TOP_CENTER, /* overhead */
151 AV_CH_TOP_FRONT_LEFT, /* side high left -- dup */
152 AV_CH_TOP_FRONT_RIGHT, /* side high right -- dup */
153 AV_CH_TOP_BACK_CENTER,
155 AV_CH_TOP_BACK_RIGHT,
156 AV_CH_BACK_CENTER, /* rear low center -- dup */
157 AV_CH_BACK_LEFT, /* rear low left -- dup */
158 AV_CH_BACK_RIGHT /* read low right -- dup */
161 enum DCAExtensionMask {
162 DCA_EXT_CORE = 0x001, ///< core in core substream
163 DCA_EXT_XXCH = 0x002, ///< XXCh channels extension in core substream
164 DCA_EXT_X96 = 0x004, ///< 96/24 extension in core substream
165 DCA_EXT_XCH = 0x008, ///< XCh channel extension in core substream
166 DCA_EXT_EXSS_CORE = 0x010, ///< core in ExSS (extension substream)
167 DCA_EXT_EXSS_XBR = 0x020, ///< extended bitrate extension in ExSS
168 DCA_EXT_EXSS_XXCH = 0x040, ///< XXCh channels extension in ExSS
169 DCA_EXT_EXSS_X96 = 0x080, ///< 96/24 extension in ExSS
170 DCA_EXT_EXSS_LBR = 0x100, ///< low bitrate component in ExSS
171 DCA_EXT_EXSS_XLL = 0x200, ///< lossless extension in ExSS
174 /* -1 are reserved or unknown */
175 static const int dca_ext_audio_descr_mask[] = {
179 DCA_EXT_XCH | DCA_EXT_X96,
186 /* extensions that reside in core substream */
187 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
189 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
190 * Some compromises have been made for special configurations. Most configurations
191 * are never used so complete accuracy is not needed.
193 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
194 * S -> side, when both rear and back are configured move one of them to the side channel
196 * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
198 static const uint64_t dca_core_channel_layout[] = {
199 AV_CH_FRONT_CENTER, ///< 1, A
200 AV_CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
201 AV_CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
202 AV_CH_LAYOUT_STEREO, ///< 2, (L + R) + (L - R) (sum-difference)
203 AV_CH_LAYOUT_STEREO, ///< 2, LT + RT (left and right total)
204 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER, ///< 3, C + L + R
205 AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER, ///< 3, L + R + S
206 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 4, C + L + R + S
207 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 4, L + R + SL + SR
209 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
210 AV_CH_SIDE_RIGHT, ///< 5, C + L + R + SL + SR
212 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
213 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
215 AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
216 AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 6, C + L + R + LR + RR + OV
218 AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
219 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER |
220 AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 6, CF + CR + LF + RF + LR + RR
222 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
223 AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
224 AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
226 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
227 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
228 AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2
230 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
231 AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
232 AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT, ///< 8, CL + C + CR + L + R + SL + S + SR
235 static const int8_t dca_lfe_index[] = {
236 1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
239 static const int8_t dca_channel_reorder_lfe[][9] = {
240 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
241 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
242 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
243 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
244 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
245 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
246 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
247 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
248 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
249 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
250 { 3, 4, 0, 1, 5, 6, -1, -1, -1},
251 { 2, 0, 1, 4, 5, 6, -1, -1, -1},
252 { 0, 6, 4, 5, 2, 3, -1, -1, -1},
253 { 4, 2, 5, 0, 1, 6, 7, -1, -1},
254 { 5, 6, 0, 1, 7, 3, 8, 4, -1},
255 { 4, 2, 5, 0, 1, 6, 8, 7, -1},
258 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
259 { 0, 2, -1, -1, -1, -1, -1, -1, -1},
260 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
261 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
262 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
263 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
264 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
265 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
266 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
267 { 0, 1, 4, 5, 3, -1, -1, -1, -1},
268 { 2, 0, 1, 5, 6, 4, -1, -1, -1},
269 { 3, 4, 0, 1, 6, 7, 5, -1, -1},
270 { 2, 0, 1, 4, 5, 6, 7, -1, -1},
271 { 0, 6, 4, 5, 2, 3, 7, -1, -1},
272 { 4, 2, 5, 0, 1, 7, 8, 6, -1},
273 { 5, 6, 0, 1, 8, 3, 9, 4, 7},
274 { 4, 2, 5, 0, 1, 6, 9, 8, 7},
277 static const int8_t dca_channel_reorder_nolfe[][9] = {
278 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
279 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
280 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
281 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
282 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
283 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
284 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
285 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
286 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
287 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
288 { 2, 3, 0, 1, 4, 5, -1, -1, -1},
289 { 2, 0, 1, 3, 4, 5, -1, -1, -1},
290 { 0, 5, 3, 4, 1, 2, -1, -1, -1},
291 { 3, 2, 4, 0, 1, 5, 6, -1, -1},
292 { 4, 5, 0, 1, 6, 2, 7, 3, -1},
293 { 3, 2, 4, 0, 1, 5, 7, 6, -1},
296 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
297 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
298 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
299 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
300 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
301 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
302 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
303 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
304 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
305 { 0, 1, 3, 4, 2, -1, -1, -1, -1},
306 { 2, 0, 1, 4, 5, 3, -1, -1, -1},
307 { 2, 3, 0, 1, 5, 6, 4, -1, -1},
308 { 2, 0, 1, 3, 4, 5, 6, -1, -1},
309 { 0, 5, 3, 4, 1, 2, 6, -1, -1},
310 { 3, 2, 4, 0, 1, 6, 7, 5, -1},
311 { 4, 5, 0, 1, 7, 2, 8, 3, 6},
312 { 3, 2, 4, 0, 1, 5, 8, 7, 6},
315 #define DCA_DOLBY 101 /* FIXME */
317 #define DCA_CHANNEL_BITS 6
318 #define DCA_CHANNEL_MASK 0x3F
322 #define HEADER_SIZE 14
324 #define DCA_MAX_FRAME_SIZE 16384
325 #define DCA_MAX_EXSS_HEADER_SIZE 4096
327 #define DCA_BUFFER_PADDING_SIZE 1024
329 /** Bit allocation */
331 int offset; ///< code values offset
332 int maxbits[8]; ///< max bits in VLC
333 int wrap; ///< wrap for get_vlc2()
334 VLC vlc[8]; ///< actual codes
337 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
338 static BitAlloc dca_tmode; ///< transition mode VLCs
339 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
340 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
342 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
345 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
350 const AVClass *class; ///< class for AVOptions
351 AVCodecContext *avctx;
353 int frame_type; ///< type of the current frame
354 int samples_deficit; ///< deficit sample count
355 int crc_present; ///< crc is present in the bitstream
356 int sample_blocks; ///< number of PCM sample blocks
357 int frame_size; ///< primary frame byte size
358 int amode; ///< audio channels arrangement
359 int sample_rate; ///< audio sampling rate
360 int bit_rate; ///< transmission bit rate
361 int bit_rate_index; ///< transmission bit rate index
363 int dynrange; ///< embedded dynamic range flag
364 int timestamp; ///< embedded time stamp flag
365 int aux_data; ///< auxiliary data flag
366 int hdcd; ///< source material is mastered in HDCD
367 int ext_descr; ///< extension audio descriptor flag
368 int ext_coding; ///< extended coding flag
369 int aspf; ///< audio sync word insertion flag
370 int lfe; ///< low frequency effects flag
371 int predictor_history; ///< predictor history flag
372 int header_crc; ///< header crc check bytes
373 int multirate_inter; ///< multirate interpolator switch
374 int version; ///< encoder software revision
375 int copy_history; ///< copy history
376 int source_pcm_res; ///< source pcm resolution
377 int front_sum; ///< front sum/difference flag
378 int surround_sum; ///< surround sum/difference flag
379 int dialog_norm; ///< dialog normalisation parameter
381 /* Primary audio coding header */
382 int subframes; ///< number of subframes
383 int total_channels; ///< number of channels including extensions
384 int prim_channels; ///< number of primary audio channels
385 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
386 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
387 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
388 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
389 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
390 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
391 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
392 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
394 /* Primary audio coding side information */
395 int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
396 int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
397 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
398 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
399 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
400 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
401 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
402 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
403 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
404 float downmix_coef[DCA_PRIM_CHANNELS_MAX + 1][2]; ///< stereo downmix coefficients
405 int dynrange_coef; ///< dynamic range coefficient
407 /* Core substream's embedded downmix coefficients (cf. ETSI TS 102 114 V1.4.1)
408 * Input: primary audio channels (incl. LFE if present)
409 * Output: downmix audio channels (up to 4, no LFE) */
410 uint8_t core_downmix; ///< embedded downmix coefficients available
411 uint8_t core_downmix_amode; ///< audio channel arrangement of embedded downmix
412 uint16_t core_downmix_codes[DCA_PRIM_CHANNELS_MAX + 1][4]; ///< embedded downmix coefficients (9-bit codes)
414 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
416 float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
417 int lfe_scale_factor;
419 /* Subband samples history (for ADPCM) */
420 DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
421 DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
422 DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
423 int hist_index[DCA_PRIM_CHANNELS_MAX];
424 DECLARE_ALIGNED(32, float, raXin)[32];
426 int output; ///< type of output
428 DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
429 float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
430 float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
431 uint8_t *extra_channels_buffer;
432 unsigned int extra_channels_buffer_size;
434 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
435 int dca_buffer_size; ///< how much data is in the dca_buffer
437 const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
439 /* Current position in DCA frame */
440 int current_subframe;
441 int current_subsubframe;
443 int core_ext_mask; ///< present extensions in the core substream
445 /* XCh extension information */
446 int xch_present; ///< XCh extension present and valid
447 int xch_base_channel; ///< index of first (only) channel containing XCH data
448 int xch_disable; ///< whether the XCh extension should be decoded or not
450 /* XXCH extension information */
452 int xxch_nbits_spk_mask;
453 uint32_t xxch_core_spkmask;
454 uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */
455 int xxch_chset_nch[4];
456 float xxch_dmix_sf[DCA_CHSETS_MAX];
458 uint32_t xxch_dmix_embedded; /* lower layer has mix pre-embedded, per chset */
459 float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */
461 int8_t xxch_order_tab[32];
464 /* ExSS header parser */
465 int static_fields; ///< static fields present
466 int mix_metadata; ///< mixing metadata present
467 int num_mix_configs; ///< number of mix out configurations
468 int mix_config_num_ch[4]; ///< number of channels in each mix out configuration
472 int debug_flag; ///< used for suppressing repeated error messages output
473 AVFloatDSPContext fdsp;
475 SynthFilterContext synth;
476 DCADSPContext dcadsp;
477 FmtConvertContext fmt_conv;
480 static const uint16_t dca_vlc_offs[] = {
481 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
482 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
483 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
484 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
485 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
486 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
489 static av_cold void dca_init_vlcs(void)
491 static int vlcs_initialized = 0;
493 static VLC_TYPE dca_table[23622][2];
495 if (vlcs_initialized)
498 dca_bitalloc_index.offset = 1;
499 dca_bitalloc_index.wrap = 2;
500 for (i = 0; i < 5; i++) {
501 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
502 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
503 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
504 bitalloc_12_bits[i], 1, 1,
505 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
507 dca_scalefactor.offset = -64;
508 dca_scalefactor.wrap = 2;
509 for (i = 0; i < 5; i++) {
510 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
511 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
512 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
513 scales_bits[i], 1, 1,
514 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
516 dca_tmode.offset = 0;
518 for (i = 0; i < 4; i++) {
519 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
520 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
521 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
523 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
526 for (i = 0; i < 10; i++)
527 for (j = 0; j < 7; j++) {
528 if (!bitalloc_codes[i][j])
530 dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i];
531 dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4);
532 dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
533 dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
535 init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
537 bitalloc_bits[i][j], 1, 1,
538 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
541 vlcs_initialized = 1;
544 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
547 *dst++ = get_bits(gb, bits);
550 static inline int dca_xxch2index(DCAContext *s, int xxch_ch)
554 /* locate channel set containing the channel */
555 for (i = -1, base = 0, mask = (s->xxch_core_spkmask & ~DCA_XXCH_LFE1);
556 i <= s->xxch_chset && !(mask & xxch_ch); mask = s->xxch_spk_masks[++i])
557 base += av_popcount(mask);
559 return base + av_popcount(mask & (xxch_ch - 1));
562 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,
566 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
567 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
568 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
569 int hdr_pos = 0, hdr_size = 0;
570 float sign, mag, scale_factor;
571 int this_chans, acc_mask;
572 int embedded_downmix;
576 /* xxch has arbitrary sized audio coding headers */
578 hdr_pos = get_bits_count(&s->gb);
579 hdr_size = get_bits(&s->gb, 7) + 1;
582 nchans = get_bits(&s->gb, 3) + 1;
583 s->total_channels = nchans + base_channel;
584 s->prim_channels = s->total_channels;
586 /* obtain speaker layout mask & downmix coefficients for XXCH */
588 acc_mask = s->xxch_core_spkmask;
590 this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6;
591 s->xxch_spk_masks[s->xxch_chset] = this_chans;
592 s->xxch_chset_nch[s->xxch_chset] = nchans;
594 for (i = 0; i <= s->xxch_chset; i++)
595 acc_mask |= s->xxch_spk_masks[i];
597 /* check for downmixing information */
598 if (get_bits1(&s->gb)) {
599 embedded_downmix = get_bits1(&s->gb);
601 1.0f / dca_dmixtable[(get_bits(&s->gb, 6) - 1) << 2];
603 s->xxch_dmix_sf[s->xxch_chset] = scale_factor;
605 for (i = base_channel; i < s->prim_channels; i++) {
606 mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask);
609 for (j = base_channel; j < s->prim_channels; j++) {
610 memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0]));
611 s->xxch_dmix_embedded |= (embedded_downmix << j);
612 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
613 if (mask[j] & (1 << i)) {
614 if ((1 << i) == DCA_XXCH_LFE1) {
615 av_log(s->avctx, AV_LOG_WARNING,
616 "DCA-XXCH: dmix to LFE1 not supported.\n");
620 coeff = get_bits(&s->gb, 7);
621 sign = (coeff & 64) ? 1.0 : -1.0;
622 mag = dca_dmixtable[((coeff & 63) - 1) << 2];
623 ichan = dca_xxch2index(s, 1 << i);
624 s->xxch_dmix_coeff[j][ichan] = sign * mag;
631 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
632 s->prim_channels = DCA_PRIM_CHANNELS_MAX;
635 for (i = base_channel; i < s->prim_channels; i++) {
636 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
637 if (s->subband_activity[i] > DCA_SUBBANDS)
638 s->subband_activity[i] = DCA_SUBBANDS;
640 for (i = base_channel; i < s->prim_channels; i++) {
641 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
642 if (s->vq_start_subband[i] > DCA_SUBBANDS)
643 s->vq_start_subband[i] = DCA_SUBBANDS;
645 get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
646 get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
647 get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
648 get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
650 /* Get codebooks quantization indexes */
652 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
653 for (j = 1; j < 11; j++)
654 for (i = base_channel; i < s->prim_channels; i++)
655 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
657 /* Get scale factor adjustment */
658 for (j = 0; j < 11; j++)
659 for (i = base_channel; i < s->prim_channels; i++)
660 s->scalefactor_adj[i][j] = 1;
662 for (j = 1; j < 11; j++)
663 for (i = base_channel; i < s->prim_channels; i++)
664 if (s->quant_index_huffman[i][j] < thr[j])
665 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
668 if (s->crc_present) {
669 /* Audio header CRC check */
670 get_bits(&s->gb, 16);
673 /* Skip to the end of the header, also ignore CRC if present */
674 i = get_bits_count(&s->gb);
675 if (hdr_pos + 8 * hdr_size > i)
676 skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);
679 s->current_subframe = 0;
680 s->current_subsubframe = 0;
683 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
684 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
685 for (i = base_channel; i < s->prim_channels; i++) {
686 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
687 s->subband_activity[i]);
688 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
689 s->vq_start_subband[i]);
690 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
691 s->joint_intensity[i]);
692 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
693 s->transient_huffman[i]);
694 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
695 s->scalefactor_huffman[i]);
696 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
697 s->bitalloc_huffman[i]);
698 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
699 for (j = 0; j < 11; j++)
700 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
701 av_log(s->avctx, AV_LOG_DEBUG, "\n");
702 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
703 for (j = 0; j < 11; j++)
704 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
705 av_log(s->avctx, AV_LOG_DEBUG, "\n");
712 static int dca_parse_frame_header(DCAContext *s)
714 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
717 skip_bits_long(&s->gb, 32);
720 s->frame_type = get_bits(&s->gb, 1);
721 s->samples_deficit = get_bits(&s->gb, 5) + 1;
722 s->crc_present = get_bits(&s->gb, 1);
723 s->sample_blocks = get_bits(&s->gb, 7) + 1;
724 s->frame_size = get_bits(&s->gb, 14) + 1;
725 if (s->frame_size < 95)
726 return AVERROR_INVALIDDATA;
727 s->amode = get_bits(&s->gb, 6);
728 s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
730 return AVERROR_INVALIDDATA;
731 s->bit_rate_index = get_bits(&s->gb, 5);
732 s->bit_rate = dca_bit_rates[s->bit_rate_index];
734 return AVERROR_INVALIDDATA;
736 skip_bits1(&s->gb); // always 0 (reserved, cf. ETSI TS 102 114 V1.4.1)
737 s->dynrange = get_bits(&s->gb, 1);
738 s->timestamp = get_bits(&s->gb, 1);
739 s->aux_data = get_bits(&s->gb, 1);
740 s->hdcd = get_bits(&s->gb, 1);
741 s->ext_descr = get_bits(&s->gb, 3);
742 s->ext_coding = get_bits(&s->gb, 1);
743 s->aspf = get_bits(&s->gb, 1);
744 s->lfe = get_bits(&s->gb, 2);
745 s->predictor_history = get_bits(&s->gb, 1);
749 av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
750 return AVERROR_INVALIDDATA;
753 /* TODO: check CRC */
755 s->header_crc = get_bits(&s->gb, 16);
757 s->multirate_inter = get_bits(&s->gb, 1);
758 s->version = get_bits(&s->gb, 4);
759 s->copy_history = get_bits(&s->gb, 2);
760 s->source_pcm_res = get_bits(&s->gb, 3);
761 s->front_sum = get_bits(&s->gb, 1);
762 s->surround_sum = get_bits(&s->gb, 1);
763 s->dialog_norm = get_bits(&s->gb, 4);
765 /* FIXME: channels mixing levels */
766 s->output = s->amode;
768 s->output |= DCA_LFE;
771 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
772 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
773 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
774 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
775 s->sample_blocks, s->sample_blocks * 32);
776 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
777 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
778 s->amode, dca_channels[s->amode]);
779 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
781 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
783 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
784 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
785 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
786 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
787 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
788 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
789 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
790 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
791 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
792 s->predictor_history);
793 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
794 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
796 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
797 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
798 av_log(s->avctx, AV_LOG_DEBUG,
799 "source pcm resolution: %i (%i bits/sample)\n",
800 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
801 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
802 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
803 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
804 av_log(s->avctx, AV_LOG_DEBUG, "\n");
807 /* Primary audio coding header */
808 s->subframes = get_bits(&s->gb, 4) + 1;
810 return dca_parse_audio_coding_header(s, 0, 0);
814 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
817 /* huffman encoded */
818 value += get_bitalloc(gb, &dca_scalefactor, level);
819 value = av_clip(value, 0, (1 << log2range) - 1);
820 } else if (level < 8) {
821 if (level + 1 > log2range) {
822 skip_bits(gb, level + 1 - log2range);
823 value = get_bits(gb, log2range);
825 value = get_bits(gb, level + 1);
831 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
833 /* Primary audio coding side information */
836 if (get_bits_left(&s->gb) < 0)
837 return AVERROR_INVALIDDATA;
840 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
841 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
844 for (j = base_channel; j < s->prim_channels; j++) {
845 for (k = 0; k < s->subband_activity[j]; k++)
846 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
849 /* Get prediction codebook */
850 for (j = base_channel; j < s->prim_channels; j++) {
851 for (k = 0; k < s->subband_activity[j]; k++) {
852 if (s->prediction_mode[j][k] > 0) {
853 /* (Prediction coefficient VQ address) */
854 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
859 /* Bit allocation index */
860 for (j = base_channel; j < s->prim_channels; j++) {
861 for (k = 0; k < s->vq_start_subband[j]; k++) {
862 if (s->bitalloc_huffman[j] == 6)
863 s->bitalloc[j][k] = get_bits(&s->gb, 5);
864 else if (s->bitalloc_huffman[j] == 5)
865 s->bitalloc[j][k] = get_bits(&s->gb, 4);
866 else if (s->bitalloc_huffman[j] == 7) {
867 av_log(s->avctx, AV_LOG_ERROR,
868 "Invalid bit allocation index\n");
869 return AVERROR_INVALIDDATA;
872 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
875 if (s->bitalloc[j][k] > 26) {
876 av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
877 j, k, s->bitalloc[j][k]);
878 return AVERROR_INVALIDDATA;
883 /* Transition mode */
884 for (j = base_channel; j < s->prim_channels; j++) {
885 for (k = 0; k < s->subband_activity[j]; k++) {
886 s->transition_mode[j][k] = 0;
887 if (s->subsubframes[s->current_subframe] > 1 &&
888 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
889 s->transition_mode[j][k] =
890 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
895 if (get_bits_left(&s->gb) < 0)
896 return AVERROR_INVALIDDATA;
898 for (j = base_channel; j < s->prim_channels; j++) {
899 const uint32_t *scale_table;
900 int scale_sum, log_size;
902 memset(s->scale_factor[j], 0,
903 s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
905 if (s->scalefactor_huffman[j] == 6) {
906 scale_table = scale_factor_quant7;
909 scale_table = scale_factor_quant6;
913 /* When huffman coded, only the difference is encoded */
916 for (k = 0; k < s->subband_activity[j]; k++) {
917 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
918 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
919 s->scale_factor[j][k][0] = scale_table[scale_sum];
922 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
923 /* Get second scale factor */
924 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
925 s->scale_factor[j][k][1] = scale_table[scale_sum];
930 /* Joint subband scale factor codebook select */
931 for (j = base_channel; j < s->prim_channels; j++) {
932 /* Transmitted only if joint subband coding enabled */
933 if (s->joint_intensity[j] > 0)
934 s->joint_huff[j] = get_bits(&s->gb, 3);
937 if (get_bits_left(&s->gb) < 0)
938 return AVERROR_INVALIDDATA;
940 /* Scale factors for joint subband coding */
941 for (j = base_channel; j < s->prim_channels; j++) {
944 /* Transmitted only if joint subband coding enabled */
945 if (s->joint_intensity[j] > 0) {
947 source_channel = s->joint_intensity[j] - 1;
949 /* When huffman coded, only the difference is encoded
950 * (is this valid as well for joint scales ???) */
952 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
953 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
954 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
957 if (!(s->debug_flag & 0x02)) {
958 av_log(s->avctx, AV_LOG_DEBUG,
959 "Joint stereo coding not supported\n");
960 s->debug_flag |= 0x02;
965 /* Dynamic range coefficient */
966 if (!base_channel && s->dynrange)
967 s->dynrange_coef = get_bits(&s->gb, 8);
969 /* Side information CRC check word */
970 if (s->crc_present) {
971 get_bits(&s->gb, 16);
975 * Primary audio data arrays
978 /* VQ encoded high frequency subbands */
979 for (j = base_channel; j < s->prim_channels; j++)
980 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
981 /* 1 vector -> 32 samples */
982 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
984 /* Low frequency effect data */
985 if (!base_channel && s->lfe) {
988 int lfe_samples = 2 * s->lfe * (4 + block_index);
989 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
992 for (j = lfe_samples; j < lfe_end_sample; j++) {
993 /* Signed 8 bits int */
994 s->lfe_data[j] = get_sbits(&s->gb, 8);
997 /* Scale factor index */
998 quant7 = get_bits(&s->gb, 8);
1000 avpriv_request_sample(s->avctx, "LFEScaleIndex larger than 127");
1001 return AVERROR_INVALIDDATA;
1003 s->lfe_scale_factor = scale_factor_quant7[quant7];
1005 /* Quantization step size * scale factor */
1006 lfe_scale = 0.035 * s->lfe_scale_factor;
1008 for (j = lfe_samples; j < lfe_end_sample; j++)
1009 s->lfe_data[j] *= lfe_scale;
1013 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
1014 s->subsubframes[s->current_subframe]);
1015 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
1016 s->partial_samples[s->current_subframe]);
1018 for (j = base_channel; j < s->prim_channels; j++) {
1019 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
1020 for (k = 0; k < s->subband_activity[j]; k++)
1021 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
1022 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1024 for (j = base_channel; j < s->prim_channels; j++) {
1025 for (k = 0; k < s->subband_activity[j]; k++)
1026 av_log(s->avctx, AV_LOG_DEBUG,
1027 "prediction coefs: %f, %f, %f, %f\n",
1028 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
1029 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
1030 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
1031 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
1033 for (j = base_channel; j < s->prim_channels; j++) {
1034 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
1035 for (k = 0; k < s->vq_start_subband[j]; k++)
1036 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
1037 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1039 for (j = base_channel; j < s->prim_channels; j++) {
1040 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
1041 for (k = 0; k < s->subband_activity[j]; k++)
1042 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
1043 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1045 for (j = base_channel; j < s->prim_channels; j++) {
1046 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
1047 for (k = 0; k < s->subband_activity[j]; k++) {
1048 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
1049 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
1050 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
1051 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
1053 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1055 for (j = base_channel; j < s->prim_channels; j++) {
1056 if (s->joint_intensity[j] > 0) {
1057 int source_channel = s->joint_intensity[j] - 1;
1058 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
1059 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
1060 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
1061 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1064 for (j = base_channel; j < s->prim_channels; j++)
1065 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
1066 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
1067 if (!base_channel && s->lfe) {
1068 int lfe_samples = 2 * s->lfe * (4 + block_index);
1069 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
1071 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
1072 for (j = lfe_samples; j < lfe_end_sample; j++)
1073 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
1074 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1081 static void qmf_32_subbands(DCAContext *s, int chans,
1082 float samples_in[32][8], float *samples_out,
1085 const float *prCoeff;
1087 int sb_act = s->subband_activity[chans];
1089 scale *= sqrt(1 / 8.0);
1092 if (!s->multirate_inter) /* Non-perfect reconstruction */
1093 prCoeff = fir_32bands_nonperfect;
1094 else /* Perfect reconstruction */
1095 prCoeff = fir_32bands_perfect;
1097 s->dcadsp.qmf_32_subbands(samples_in, sb_act, &s->synth, &s->imdct,
1098 s->subband_fir_hist[chans],
1099 &s->hist_index[chans],
1100 s->subband_fir_noidea[chans], prCoeff,
1101 samples_out, s->raXin, scale);
1104 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
1105 int num_deci_sample, float *samples_in,
1106 float *samples_out, float scale)
1108 /* samples_in: An array holding decimated samples.
1109 * Samples in current subframe starts from samples_in[0],
1110 * while samples_in[-1], samples_in[-2], ..., stores samples
1111 * from last subframe as history.
1113 * samples_out: An array holding interpolated samples
1117 const float *prCoeff;
1120 /* Select decimation filter */
1121 if (decimation_select == 1) {
1123 prCoeff = lfe_fir_128;
1126 prCoeff = lfe_fir_64;
1129 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
1130 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
1132 samples_out += 2 * decifactor;
1136 /* downmixing routines */
1137 #define MIX_REAR1(samples, s1, rs, coef) \
1138 samples[0][i] += samples[s1][i] * coef[rs][0]; \
1139 samples[1][i] += samples[s1][i] * coef[rs][1];
1141 #define MIX_REAR2(samples, s1, s2, rs, coef) \
1142 samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
1143 samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
1145 #define MIX_FRONT3(samples, coef) \
1146 t = samples[c][i]; \
1147 u = samples[l][i]; \
1148 v = samples[r][i]; \
1149 samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1150 samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1152 #define DOWNMIX_TO_STEREO(op1, op2) \
1153 for (i = 0; i < 256; i++) { \
1158 static void dca_downmix(float **samples, int srcfmt, int lfe_present,
1159 float coef[DCA_PRIM_CHANNELS_MAX + 1][2],
1160 const int8_t *channel_mapping)
1162 int c, l, r, sl, sr, s;
1169 av_log(NULL, AV_LOG_ERROR, "Not implemented!\n");
1173 case DCA_STEREO_TOTAL:
1174 case DCA_STEREO_SUMDIFF:
1177 c = channel_mapping[0];
1178 l = channel_mapping[1];
1179 r = channel_mapping[2];
1180 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1183 s = channel_mapping[2];
1184 DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
1187 c = channel_mapping[0];
1188 l = channel_mapping[1];
1189 r = channel_mapping[2];
1190 s = channel_mapping[3];
1191 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1192 MIX_REAR1(samples, s, 3, coef));
1195 sl = channel_mapping[2];
1196 sr = channel_mapping[3];
1197 DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
1200 c = channel_mapping[0];
1201 l = channel_mapping[1];
1202 r = channel_mapping[2];
1203 sl = channel_mapping[3];
1204 sr = channel_mapping[4];
1205 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1206 MIX_REAR2(samples, sl, sr, 3, coef));
1210 int lf_buf = dca_lfe_index[srcfmt];
1211 int lf_idx = dca_channels [srcfmt];
1212 for (i = 0; i < 256; i++) {
1213 samples[0][i] += samples[lf_buf][i] * coef[lf_idx][0];
1214 samples[1][i] += samples[lf_buf][i] * coef[lf_idx][1];
1220 #ifndef decode_blockcodes
1221 /* Very compact version of the block code decoder that does not use table
1222 * look-up but is slightly slower */
1223 static int decode_blockcode(int code, int levels, int32_t *values)
1226 int offset = (levels - 1) >> 1;
1228 for (i = 0; i < 4; i++) {
1229 int div = FASTDIV(code, levels);
1230 values[i] = code - offset - div * levels;
1237 static int decode_blockcodes(int code1, int code2, int levels, int32_t *values)
1239 return decode_blockcode(code1, levels, values) |
1240 decode_blockcode(code2, levels, values + 4);
1244 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1245 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1247 #ifndef int8x8_fmul_int32
1248 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1250 float fscale = scale / 16.0;
1252 for (i = 0; i < 8; i++)
1253 dst[i] = src[i] * fscale;
1257 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1260 int subsubframe = s->current_subsubframe;
1262 const float *quant_step_table;
1265 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1266 LOCAL_ALIGNED_16(int32_t, block, [8 * DCA_SUBBANDS]);
1272 /* Select quantization step size table */
1273 if (s->bit_rate_index == 0x1f)
1274 quant_step_table = lossless_quant_d;
1276 quant_step_table = lossy_quant_d;
1278 for (k = base_channel; k < s->prim_channels; k++) {
1279 float rscale[DCA_SUBBANDS];
1281 if (get_bits_left(&s->gb) < 0)
1282 return AVERROR_INVALIDDATA;
1284 for (l = 0; l < s->vq_start_subband[k]; l++) {
1287 /* Select the mid-tread linear quantizer */
1288 int abits = s->bitalloc[k][l];
1290 float quant_step_size = quant_step_table[abits];
1293 * Determine quantization index code book and its type
1296 /* Select quantization index code book */
1297 int sel = s->quant_index_huffman[k][abits];
1300 * Extract bits from the bit stream
1304 memset(block + 8 * l, 0, 8 * sizeof(block[0]));
1306 /* Deal with transients */
1307 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1308 rscale[l] = quant_step_size * s->scale_factor[k][l][sfi] *
1309 s->scalefactor_adj[k][sel];
1311 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1314 int block_code1, block_code2, size, levels, err;
1316 size = abits_sizes[abits - 1];
1317 levels = abits_levels[abits - 1];
1319 block_code1 = get_bits(&s->gb, size);
1320 block_code2 = get_bits(&s->gb, size);
1321 err = decode_blockcodes(block_code1, block_code2,
1322 levels, block + 8 * l);
1324 av_log(s->avctx, AV_LOG_ERROR,
1325 "ERROR: block code look-up failed\n");
1326 return AVERROR_INVALIDDATA;
1330 for (m = 0; m < 8; m++)
1331 block[8 * l + m] = get_sbits(&s->gb, abits - 3);
1335 for (m = 0; m < 8; m++)
1336 block[8 * l + m] = get_bitalloc(&s->gb,
1337 &dca_smpl_bitalloc[abits], sel);
1343 s->fmt_conv.int32_to_float_fmul_array8(&s->fmt_conv, subband_samples[k][0],
1344 block, rscale, 8 * s->vq_start_subband[k]);
1346 for (l = 0; l < s->vq_start_subband[k]; l++) {
1349 * Inverse ADPCM if in prediction mode
1351 if (s->prediction_mode[k][l]) {
1353 for (m = 0; m < 8; m++) {
1354 for (n = 1; n <= 4; n++)
1356 subband_samples[k][l][m] +=
1357 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1358 subband_samples[k][l][m - n] / 8192);
1359 else if (s->predictor_history)
1360 subband_samples[k][l][m] +=
1361 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1362 s->subband_samples_hist[k][l][m - n + 4] / 8192);
1368 * Decode VQ encoded high frequencies
1370 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1371 /* 1 vector -> 32 samples but we only need the 8 samples
1372 * for this subsubframe. */
1373 int hfvq = s->high_freq_vq[k][l];
1375 if (!s->debug_flag & 0x01) {
1376 av_log(s->avctx, AV_LOG_DEBUG,
1377 "Stream with high frequencies VQ coding\n");
1378 s->debug_flag |= 0x01;
1381 int8x8_fmul_int32(subband_samples[k][l],
1382 &high_freq_vq[hfvq][subsubframe * 8],
1383 s->scale_factor[k][l][0]);
1387 /* Check for DSYNC after subsubframe */
1388 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1389 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1391 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1394 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1395 return AVERROR_INVALIDDATA;
1399 /* Backup predictor history for adpcm */
1400 for (k = base_channel; k < s->prim_channels; k++)
1401 for (l = 0; l < s->vq_start_subband[k]; l++)
1402 memcpy(s->subband_samples_hist[k][l],
1403 &subband_samples[k][l][4],
1404 4 * sizeof(subband_samples[0][0][0]));
1409 static int dca_filter_channels(DCAContext *s, int block_index)
1411 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1414 /* 32 subbands QMF */
1415 for (k = 0; k < s->prim_channels; k++) {
1416 /* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1417 0, 8388608.0, 8388608.0 };*/
1418 if (s->channel_order_tab[k] >= 0)
1419 qmf_32_subbands(s, k, subband_samples[k],
1420 s->samples_chanptr[s->channel_order_tab[k]],
1421 M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */);
1424 /* Generate LFE samples for this subsubframe FIXME!!! */
1426 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1427 s->lfe_data + 2 * s->lfe * (block_index + 4),
1428 s->samples_chanptr[s->lfe_index],
1429 1.0 / (256.0 * 32768.0));
1430 /* Outputs 20bits pcm samples */
1433 /* Downmixing to Stereo */
1434 if (s->prim_channels + !!s->lfe > 2 &&
1435 s->avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1436 dca_downmix(s->samples_chanptr, s->amode, !!s->lfe, s->downmix_coef,
1437 s->channel_order_tab);
1444 static int dca_subframe_footer(DCAContext *s, int base_channel)
1446 int in, out, aux_data_count, aux_data_end, reserved;
1449 * Unpack optional information
1452 /* presumably optional information only appears in the core? */
1453 if (!base_channel) {
1455 skip_bits_long(&s->gb, 32);
1458 aux_data_count = get_bits(&s->gb, 6);
1461 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1463 aux_data_end = 8 * aux_data_count + get_bits_count(&s->gb);
1465 if (get_bits_long(&s->gb, 32) != 0x9A1105A0) { // nSYNCAUX
1466 av_log(s->avctx,AV_LOG_ERROR, "nSYNCAUX mismatching\n");
1467 return AVERROR_INVALIDDATA;
1470 if (get_bits1(&s->gb)) { // bAUXTimeStampFlag
1471 avpriv_request_sample(s->avctx,
1472 "Auxiliary Decode Time Stamp Flag");
1474 skip_bits(&s->gb, (-get_bits_count(&s->gb)) & 4);
1475 // 44 bits: nMSByte (8), nMarker (4), nLSByte (28), nMarker (4)
1476 skip_bits_long(&s->gb, 44);
1479 if ((s->core_downmix = get_bits1(&s->gb))) {
1480 switch (get_bits(&s->gb, 3)) {
1482 s->core_downmix_amode = DCA_MONO;
1485 s->core_downmix_amode = DCA_STEREO;
1488 s->core_downmix_amode = DCA_STEREO_TOTAL;
1491 s->core_downmix_amode = DCA_3F;
1494 s->core_downmix_amode = DCA_2F1R;
1497 s->core_downmix_amode = DCA_2F2R;
1500 s->core_downmix_amode = DCA_3F1R;
1503 return AVERROR_INVALIDDATA;
1505 for (out = 0; out < dca_channels[s->core_downmix_amode]; out++) {
1506 for (in = 0; in < s->prim_channels + !!s->lfe; in++) {
1507 uint16_t tmp = get_bits(&s->gb, 9);
1508 if ((tmp & 0xFF) > 241)
1509 return AVERROR_INVALIDDATA;
1510 s->core_downmix_codes[in][out] = tmp;
1515 align_get_bits(&s->gb); // byte align
1516 skip_bits(&s->gb, 16); // nAUXCRC16
1518 // additional data (reserved, cf. ETSI TS 102 114 V1.4.1)
1519 if ((reserved = (aux_data_end - get_bits_count(&s->gb))) < 0) {
1520 av_log(s->avctx, AV_LOG_ERROR, "overread aux by %d bits\n", -reserved);
1521 return AVERROR_INVALIDDATA;
1522 } else if (reserved) {
1523 avpriv_request_sample(s->avctx,
1524 "Core auxiliary data reserved content");
1525 skip_bits_long(&s->gb, reserved);
1529 if (s->crc_present && s->dynrange)
1530 get_bits(&s->gb, 16);
1537 * Decode a dca frame block
1539 * @param s pointer to the DCAContext
1542 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1547 if (s->current_subframe >= s->subframes) {
1548 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1549 s->current_subframe, s->subframes);
1550 return AVERROR_INVALIDDATA;
1553 if (!s->current_subsubframe) {
1555 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1557 /* Read subframe header */
1558 if ((ret = dca_subframe_header(s, base_channel, block_index)))
1562 /* Read subsubframe */
1564 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1566 if ((ret = dca_subsubframe(s, base_channel, block_index)))
1570 s->current_subsubframe++;
1571 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1572 s->current_subsubframe = 0;
1573 s->current_subframe++;
1575 if (s->current_subframe >= s->subframes) {
1577 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1579 /* Read subframe footer */
1580 if ((ret = dca_subframe_footer(s, base_channel)))
1588 * Return the number of channels in an ExSS speaker mask (HD)
1590 static int dca_exss_mask2count(int mask)
1592 /* count bits that mean speaker pairs twice */
1593 return av_popcount(mask) +
1594 av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
1595 DCA_EXSS_FRONT_LEFT_RIGHT |
1596 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
1597 DCA_EXSS_WIDE_LEFT_RIGHT |
1598 DCA_EXSS_SIDE_LEFT_RIGHT |
1599 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
1600 DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
1601 DCA_EXSS_REAR_LEFT_RIGHT |
1602 DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1606 * Skip mixing coefficients of a single mix out configuration (HD)
1608 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1612 for (i = 0; i < channels; i++) {
1613 int mix_map_mask = get_bits(gb, out_ch);
1614 int num_coeffs = av_popcount(mix_map_mask);
1615 skip_bits_long(gb, num_coeffs * 6);
1620 * Parse extension substream asset header (HD)
1622 static int dca_exss_parse_asset_header(DCAContext *s)
1624 int header_pos = get_bits_count(&s->gb);
1627 int embedded_stereo = 0;
1628 int embedded_6ch = 0;
1629 int drc_code_present;
1630 int av_uninit(extensions_mask);
1633 if (get_bits_left(&s->gb) < 16)
1636 /* We will parse just enough to get to the extensions bitmask with which
1637 * we can set the profile value. */
1639 header_size = get_bits(&s->gb, 9) + 1;
1640 skip_bits(&s->gb, 3); // asset index
1642 if (s->static_fields) {
1643 if (get_bits1(&s->gb))
1644 skip_bits(&s->gb, 4); // asset type descriptor
1645 if (get_bits1(&s->gb))
1646 skip_bits_long(&s->gb, 24); // language descriptor
1648 if (get_bits1(&s->gb)) {
1649 /* How can one fit 1024 bytes of text here if the maximum value
1650 * for the asset header size field above was 512 bytes? */
1651 int text_length = get_bits(&s->gb, 10) + 1;
1652 if (get_bits_left(&s->gb) < text_length * 8)
1654 skip_bits_long(&s->gb, text_length * 8); // info text
1657 skip_bits(&s->gb, 5); // bit resolution - 1
1658 skip_bits(&s->gb, 4); // max sample rate code
1659 channels = get_bits(&s->gb, 8) + 1;
1661 if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1662 int spkr_remap_sets;
1663 int spkr_mask_size = 16;
1667 embedded_stereo = get_bits1(&s->gb);
1669 embedded_6ch = get_bits1(&s->gb);
1671 if (get_bits1(&s->gb)) {
1672 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1673 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1676 spkr_remap_sets = get_bits(&s->gb, 3);
1678 for (i = 0; i < spkr_remap_sets; i++) {
1679 /* std layout mask for each remap set */
1680 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1683 for (i = 0; i < spkr_remap_sets; i++) {
1684 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1685 if (get_bits_left(&s->gb) < 0)
1688 for (j = 0; j < num_spkrs[i]; j++) {
1689 int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1690 int num_dec_ch = av_popcount(remap_dec_ch_mask);
1691 skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1696 skip_bits(&s->gb, 3); // representation type
1700 drc_code_present = get_bits1(&s->gb);
1701 if (drc_code_present)
1702 get_bits(&s->gb, 8); // drc code
1704 if (get_bits1(&s->gb))
1705 skip_bits(&s->gb, 5); // dialog normalization code
1707 if (drc_code_present && embedded_stereo)
1708 get_bits(&s->gb, 8); // drc stereo code
1710 if (s->mix_metadata && get_bits1(&s->gb)) {
1711 skip_bits(&s->gb, 1); // external mix
1712 skip_bits(&s->gb, 6); // post mix gain code
1714 if (get_bits(&s->gb, 2) != 3) // mixer drc code
1715 skip_bits(&s->gb, 3); // drc limit
1717 skip_bits(&s->gb, 8); // custom drc code
1719 if (get_bits1(&s->gb)) // channel specific scaling
1720 for (i = 0; i < s->num_mix_configs; i++)
1721 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1723 skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1725 for (i = 0; i < s->num_mix_configs; i++) {
1726 if (get_bits_left(&s->gb) < 0)
1728 dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1730 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1731 if (embedded_stereo)
1732 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1736 switch (get_bits(&s->gb, 2)) {
1737 case 0: extensions_mask = get_bits(&s->gb, 12); break;
1738 case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1739 case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1740 case 3: extensions_mask = 0; /* aux coding */ break;
1743 /* not parsed further, we were only interested in the extensions mask */
1745 if (get_bits_left(&s->gb) < 0)
1748 if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1749 av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1752 skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1754 if (extensions_mask & DCA_EXT_EXSS_XLL)
1755 s->profile = FF_PROFILE_DTS_HD_MA;
1756 else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1758 s->profile = FF_PROFILE_DTS_HD_HRA;
1760 if (!(extensions_mask & DCA_EXT_CORE))
1761 av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1762 if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1763 av_log(s->avctx, AV_LOG_WARNING,
1764 "DTS extensions detection mismatch (%d, %d)\n",
1765 extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1770 static int dca_xbr_parse_frame(DCAContext *s)
1772 int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];
1773 int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];
1774 int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS];
1775 int anctemp[DCA_CHSET_CHANS_MAX];
1776 int chset_fsize[DCA_CHSETS_MAX];
1777 int n_xbr_ch[DCA_CHSETS_MAX];
1778 int hdr_size, num_chsets, xbr_tmode, hdr_pos;
1779 int i, j, k, l, chset, chan_base;
1781 av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n");
1783 /* get bit position of sync header */
1784 hdr_pos = get_bits_count(&s->gb) - 32;
1786 hdr_size = get_bits(&s->gb, 6) + 1;
1787 num_chsets = get_bits(&s->gb, 2) + 1;
1789 for(i = 0; i < num_chsets; i++)
1790 chset_fsize[i] = get_bits(&s->gb, 14) + 1;
1792 xbr_tmode = get_bits1(&s->gb);
1794 for(i = 0; i < num_chsets; i++) {
1795 n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;
1796 k = get_bits(&s->gb, 2) + 5;
1797 for(j = 0; j < n_xbr_ch[i]; j++)
1798 active_bands[i][j] = get_bits(&s->gb, k) + 1;
1801 /* skip to the end of the header */
1802 i = get_bits_count(&s->gb);
1803 if(hdr_pos + hdr_size * 8 > i)
1804 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1806 /* loop over the channel data sets */
1807 /* only decode as many channels as we've decoded base data for */
1808 for(chset = 0, chan_base = 0;
1809 chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels;
1810 chan_base += n_xbr_ch[chset++]) {
1811 int start_posn = get_bits_count(&s->gb);
1812 int subsubframe = 0;
1815 /* loop over subframes */
1816 for (k = 0; k < (s->sample_blocks / 8); k++) {
1817 /* parse header if we're on first subsubframe of a block */
1818 if(subsubframe == 0) {
1819 /* Parse subframe header */
1820 for(i = 0; i < n_xbr_ch[chset]; i++) {
1821 anctemp[i] = get_bits(&s->gb, 2) + 2;
1824 for(i = 0; i < n_xbr_ch[chset]; i++) {
1825 get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]);
1828 for(i = 0; i < n_xbr_ch[chset]; i++) {
1829 anctemp[i] = get_bits(&s->gb, 3);
1830 if(anctemp[i] < 1) {
1831 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n");
1832 return AVERROR_INVALIDDATA;
1836 /* generate scale factors */
1837 for(i = 0; i < n_xbr_ch[chset]; i++) {
1838 const uint32_t *scale_table;
1841 if (s->scalefactor_huffman[chan_base+i] == 6) {
1842 scale_table = scale_factor_quant7;
1844 scale_table = scale_factor_quant6;
1849 for(j = 0; j < active_bands[chset][i]; j++) {
1850 if(abits_high[i][j] > 0) {
1851 scale_table_high[i][j][0] =
1852 scale_table[get_bits(&s->gb, nbits)];
1854 if(xbr_tmode && s->transition_mode[i][j]) {
1855 scale_table_high[i][j][1] =
1856 scale_table[get_bits(&s->gb, nbits)];
1863 /* decode audio array for this block */
1864 for(i = 0; i < n_xbr_ch[chset]; i++) {
1865 for(j = 0; j < active_bands[chset][i]; j++) {
1866 const int xbr_abits = abits_high[i][j];
1867 const float quant_step_size = lossless_quant_d[xbr_abits];
1868 const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j];
1869 const float rscale = quant_step_size * scale_table_high[i][j][sfi];
1870 float *subband_samples = s->subband_samples[k][chan_base+i][j];
1877 get_array(&s->gb, block, 8, xbr_abits - 3);
1879 int block_code1, block_code2, size, levels, err;
1881 size = abits_sizes[xbr_abits - 1];
1882 levels = abits_levels[xbr_abits - 1];
1884 block_code1 = get_bits(&s->gb, size);
1885 block_code2 = get_bits(&s->gb, size);
1886 err = decode_blockcodes(block_code1, block_code2,
1889 av_log(s->avctx, AV_LOG_ERROR,
1890 "ERROR: DTS-XBR: block code look-up failed\n");
1891 return AVERROR_INVALIDDATA;
1895 /* scale & sum into subband */
1896 for(l = 0; l < 8; l++)
1897 subband_samples[l] += (float)block[l] * rscale;
1901 /* check DSYNC marker */
1902 if(s->aspf || subsubframe == s->subsubframes[subframe] - 1) {
1903 if(get_bits(&s->gb, 16) != 0xffff) {
1904 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n");
1905 return AVERROR_INVALIDDATA;
1909 /* advance sub-sub-frame index */
1910 if(++subsubframe >= s->subsubframes[subframe]) {
1916 /* skip to next channel set */
1917 i = get_bits_count(&s->gb);
1918 if(start_posn + chset_fsize[chset] * 8 != i) {
1919 j = start_posn + chset_fsize[chset] * 8 - i;
1921 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set,"
1922 " skipping further than expected (%d bits)\n", j);
1923 skip_bits_long(&s->gb, j);
1930 /* parse initial header for XXCH and dump details */
1931 static int dca_xxch_decode_frame(DCAContext *s)
1933 int hdr_size, spkmsk_bits, num_chsets, core_spk, hdr_pos;
1934 int i, chset, base_channel, chstart, fsize[8];
1936 /* assume header word has already been parsed */
1937 hdr_pos = get_bits_count(&s->gb) - 32;
1938 hdr_size = get_bits(&s->gb, 6) + 1;
1939 /*chhdr_crc =*/ skip_bits1(&s->gb);
1940 spkmsk_bits = get_bits(&s->gb, 5) + 1;
1941 num_chsets = get_bits(&s->gb, 2) + 1;
1943 for (i = 0; i < num_chsets; i++)
1944 fsize[i] = get_bits(&s->gb, 14) + 1;
1946 core_spk = get_bits(&s->gb, spkmsk_bits);
1947 s->xxch_core_spkmask = core_spk;
1948 s->xxch_nbits_spk_mask = spkmsk_bits;
1949 s->xxch_dmix_embedded = 0;
1951 /* skip to the end of the header */
1952 i = get_bits_count(&s->gb);
1953 if (hdr_pos + hdr_size * 8 > i)
1954 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1956 for (chset = 0; chset < num_chsets; chset++) {
1957 chstart = get_bits_count(&s->gb);
1958 base_channel = s->prim_channels;
1959 s->xxch_chset = chset;
1961 /* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs.
1962 5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */
1963 dca_parse_audio_coding_header(s, base_channel, 1);
1965 /* decode channel data */
1966 for (i = 0; i < (s->sample_blocks / 8); i++) {
1967 if (dca_decode_block(s, base_channel, i)) {
1968 av_log(s->avctx, AV_LOG_ERROR,
1969 "Error decoding DTS-XXCH extension\n");
1974 /* skip to end of this section */
1975 i = get_bits_count(&s->gb);
1976 if (chstart + fsize[chset] * 8 > i)
1977 skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i);
1979 s->xxch_chset = num_chsets;
1985 * Parse extension substream header (HD)
1987 static void dca_exss_parse_header(DCAContext *s)
1994 int active_ss_mask[8];
2000 if (get_bits_left(&s->gb) < 52)
2003 start_posn = get_bits_count(&s->gb) - 32;
2005 skip_bits(&s->gb, 8); // user data
2006 ss_index = get_bits(&s->gb, 2);
2008 blownup = get_bits1(&s->gb);
2009 hdrsize = get_bits(&s->gb, 8 + 4 * blownup) + 1; // header_size
2010 skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
2012 s->static_fields = get_bits1(&s->gb);
2013 if (s->static_fields) {
2014 skip_bits(&s->gb, 2); // reference clock code
2015 skip_bits(&s->gb, 3); // frame duration code
2017 if (get_bits1(&s->gb))
2018 skip_bits_long(&s->gb, 36); // timestamp
2020 /* a single stream can contain multiple audio assets that can be
2021 * combined to form multiple audio presentations */
2023 num_audiop = get_bits(&s->gb, 3) + 1;
2024 if (num_audiop > 1) {
2025 avpriv_request_sample(s->avctx,
2026 "Multiple DTS-HD audio presentations");
2027 /* ignore such streams for now */
2031 num_assets = get_bits(&s->gb, 3) + 1;
2032 if (num_assets > 1) {
2033 avpriv_request_sample(s->avctx, "Multiple DTS-HD audio assets");
2034 /* ignore such streams for now */
2038 for (i = 0; i < num_audiop; i++)
2039 active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
2041 for (i = 0; i < num_audiop; i++)
2042 for (j = 0; j <= ss_index; j++)
2043 if (active_ss_mask[i] & (1 << j))
2044 skip_bits(&s->gb, 8); // active asset mask
2046 s->mix_metadata = get_bits1(&s->gb);
2047 if (s->mix_metadata) {
2048 int mix_out_mask_size;
2050 skip_bits(&s->gb, 2); // adjustment level
2051 mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
2052 s->num_mix_configs = get_bits(&s->gb, 2) + 1;
2054 for (i = 0; i < s->num_mix_configs; i++) {
2055 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
2056 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
2061 for (i = 0; i < num_assets; i++)
2062 asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup);
2064 for (i = 0; i < num_assets; i++) {
2065 if (dca_exss_parse_asset_header(s))
2069 /* not parsed further, we were only interested in the extensions mask
2070 * from the asset header */
2072 if (num_assets > 0) {
2073 j = get_bits_count(&s->gb);
2074 if (start_posn + hdrsize * 8 > j)
2075 skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j);
2077 for (i = 0; i < num_assets; i++) {
2078 start_posn = get_bits_count(&s->gb);
2079 mkr = get_bits_long(&s->gb, 32);
2081 /* parse extensions that we know about */
2082 if (mkr == 0x655e315e) {
2083 dca_xbr_parse_frame(s);
2084 } else if (mkr == 0x47004a03) {
2085 dca_xxch_decode_frame(s);
2086 s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
2088 av_log(s->avctx, AV_LOG_DEBUG,
2089 "DTS-ExSS: unknown marker = 0x%08x\n", mkr);
2092 /* skip to end of block */
2093 j = get_bits_count(&s->gb);
2094 if (start_posn + asset_size[i] * 8 > j)
2095 skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j);
2101 * Main frame decoding function
2102 * FIXME add arguments
2104 static int dca_decode_frame(AVCodecContext *avctx, void *data,
2105 int *got_frame_ptr, AVPacket *avpkt)
2107 AVFrame *frame = data;
2108 const uint8_t *buf = avpkt->data;
2109 int buf_size = avpkt->size;
2113 int num_core_channels = 0;
2115 float **samples_flt;
2118 DCAContext *s = avctx->priv_data;
2120 int channels, full_channels;
2132 s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
2133 DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
2134 if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
2135 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
2136 return AVERROR_INVALIDDATA;
2139 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
2140 if ((ret = dca_parse_frame_header(s)) < 0) {
2141 //seems like the frame is corrupt, try with the next one
2144 //set AVCodec values with parsed data
2145 avctx->sample_rate = s->sample_rate;
2146 avctx->bit_rate = s->bit_rate;
2148 s->profile = FF_PROFILE_DTS;
2150 for (i = 0; i < (s->sample_blocks / 8); i++) {
2151 if ((ret = dca_decode_block(s, 0, i))) {
2152 av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
2157 /* record number of core channels incase less than max channels are requested */
2158 num_core_channels = s->prim_channels;
2160 if (s->prim_channels + !!s->lfe > 2 &&
2161 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
2162 /* Stereo downmix coefficients
2164 * The decoder can only downmix to 2-channel, so we need to ensure
2165 * embedded downmix coefficients are actually targeting 2-channel.
2167 if (s->core_downmix && (s->core_downmix_amode == DCA_STEREO ||
2168 s->core_downmix_amode == DCA_STEREO_TOTAL)) {
2170 for (i = 0; i < s->prim_channels + !!s->lfe; i++) {
2171 sign = s->core_downmix_codes[i][0] & 0x100 ? 1 : -1;
2172 code = s->core_downmix_codes[i][0] & 0x0FF;
2173 s->downmix_coef[i][0] = (!code ? 0.0f :
2174 sign * dca_dmixtable[code - 1]);
2175 sign = s->core_downmix_codes[i][1] & 0x100 ? 1 : -1;
2176 code = s->core_downmix_codes[i][1] & 0x0FF;
2177 s->downmix_coef[i][1] = (!code ? 0.0f :
2178 sign * dca_dmixtable[code - 1]);
2181 int am = s->amode & DCA_CHANNEL_MASK;
2182 if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
2183 av_log(s->avctx, AV_LOG_ERROR,
2184 "Invalid channel mode %d\n", am);
2185 return AVERROR_INVALIDDATA;
2187 if (s->prim_channels + !!s->lfe >
2188 FF_ARRAY_ELEMS(dca_default_coeffs[0])) {
2189 avpriv_request_sample(s->avctx, "Downmixing %d channels",
2190 s->prim_channels + !!s->lfe);
2191 return AVERROR_PATCHWELCOME;
2193 for (i = 0; i < s->prim_channels + !!s->lfe; i++) {
2194 s->downmix_coef[i][0] = dca_default_coeffs[am][i][0];
2195 s->downmix_coef[i][1] = dca_default_coeffs[am][i][1];
2198 av_dlog(s->avctx, "Stereo downmix coeffs:\n");
2199 for (i = 0; i < s->prim_channels + !!s->lfe; i++) {
2200 av_dlog(s->avctx, "L, input channel %d = %f\n", i,
2201 s->downmix_coef[i][0]);
2202 av_dlog(s->avctx, "R, input channel %d = %f\n", i,
2203 s->downmix_coef[i][1]);
2205 av_dlog(s->avctx, "\n");
2209 s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
2211 s->core_ext_mask = 0;
2213 core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
2215 /* only scan for extensions if ext_descr was unknown or indicated a
2216 * supported XCh extension */
2217 if (s->core_ext_mask < 0 || s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH)) {
2219 /* if ext_descr was unknown, clear s->core_ext_mask so that the
2220 * extensions scan can fill it up */
2221 s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
2223 /* extensions start at 32-bit boundaries into bitstream */
2224 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2226 while (core_ss_end - get_bits_count(&s->gb) >= 32) {
2227 uint32_t bits = get_bits_long(&s->gb, 32);
2231 int ext_amode, xch_fsize;
2233 s->xch_base_channel = s->prim_channels;
2235 /* validate sync word using XCHFSIZE field */
2236 xch_fsize = show_bits(&s->gb, 10);
2237 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
2238 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
2241 /* skip length-to-end-of-frame field for the moment */
2242 skip_bits(&s->gb, 10);
2244 s->core_ext_mask |= DCA_EXT_XCH;
2246 /* extension amode(number of channels in extension) should be 1 */
2247 /* AFAIK XCh is not used for more channels */
2248 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
2249 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
2250 " supported!\n", ext_amode);
2254 if (s->xch_base_channel < 2) {
2255 avpriv_request_sample(avctx, "XCh with fewer than 2 base channels");
2259 /* much like core primary audio coding header */
2260 dca_parse_audio_coding_header(s, s->xch_base_channel, 0);
2262 for (i = 0; i < (s->sample_blocks / 8); i++)
2263 if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
2264 av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
2272 /* XXCh: extended channels */
2273 /* usually found either in core or HD part in DTS-HD HRA streams,
2274 * but not in DTS-ES which contains XCh extensions instead */
2275 s->core_ext_mask |= DCA_EXT_XXCH;
2276 dca_xxch_decode_frame(s);
2280 int fsize96 = show_bits(&s->gb, 12) + 1;
2281 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
2284 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
2285 get_bits_count(&s->gb));
2286 skip_bits(&s->gb, 12);
2287 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
2288 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
2290 s->core_ext_mask |= DCA_EXT_X96;
2295 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2298 /* no supported extensions, skip the rest of the core substream */
2299 skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
2302 if (s->core_ext_mask & DCA_EXT_X96)
2303 s->profile = FF_PROFILE_DTS_96_24;
2304 else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
2305 s->profile = FF_PROFILE_DTS_ES;
2307 /* check for ExSS (HD part) */
2308 if (s->dca_buffer_size - s->frame_size > 32 &&
2309 get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
2310 dca_exss_parse_header(s);
2312 avctx->profile = s->profile;
2314 full_channels = channels = s->prim_channels + !!s->lfe;
2316 /* If we have XXCH then the channel layout is managed differently */
2317 /* note that XLL will also have another way to do things */
2318 if (!(s->core_ext_mask & DCA_EXT_XXCH)
2319 || (s->core_ext_mask & DCA_EXT_XXCH && avctx->request_channels > 0
2320 && avctx->request_channels
2321 < num_core_channels + !!s->lfe + s->xxch_chset_nch[0]))
2322 { /* xxx should also do MA extensions */
2323 if (s->amode < 16) {
2324 avctx->channel_layout = dca_core_channel_layout[s->amode];
2325 #if FF_API_REQUEST_CHANNELS
2326 FF_DISABLE_DEPRECATION_WARNINGS
2327 if (s->xch_present && !s->xch_disable &&
2328 (!avctx->request_channels ||
2329 avctx->request_channels > num_core_channels + !!s->lfe)) {
2330 FF_ENABLE_DEPRECATION_WARNINGS
2332 if (s->xch_present && !s->xch_disable) {
2334 avctx->channel_layout |= AV_CH_BACK_CENTER;
2336 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2337 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
2339 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
2341 if (s->channel_order_tab[s->xch_base_channel] < 0)
2342 return AVERROR_INVALIDDATA;
2344 channels = num_core_channels + !!s->lfe;
2345 s->xch_present = 0; /* disable further xch processing */
2347 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2348 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
2350 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
2353 if (channels > !!s->lfe &&
2354 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
2355 return AVERROR_INVALIDDATA;
2357 if (av_get_channel_layout_nb_channels(avctx->channel_layout) != channels) {
2358 av_log(avctx, AV_LOG_ERROR, "Number of channels %d mismatches layout %d\n", channels, av_get_channel_layout_nb_channels(avctx->channel_layout));
2359 return AVERROR_INVALIDDATA;
2362 if (s->prim_channels + !!s->lfe > 2 &&
2363 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
2365 s->output = DCA_STEREO;
2366 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
2368 else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
2369 static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
2370 s->channel_order_tab = dca_channel_order_native;
2372 s->lfe_index = dca_lfe_index[s->amode];
2374 av_log(avctx, AV_LOG_ERROR,
2375 "Non standard configuration %d !\n", s->amode);
2376 return AVERROR_INVALIDDATA;
2379 s->xxch_dmix_embedded = 0;
2381 /* we only get here if an XXCH channel set can be added to the mix */
2382 channel_mask = s->xxch_core_spkmask;
2384 if (avctx->request_channels > 0
2385 && avctx->request_channels < s->prim_channels) {
2386 channels = num_core_channels + !!s->lfe;
2387 for (i = 0; i < s->xxch_chset && channels + s->xxch_chset_nch[i]
2388 <= avctx->request_channels; i++) {
2389 channels += s->xxch_chset_nch[i];
2390 channel_mask |= s->xxch_spk_masks[i];
2393 channels = s->prim_channels + !!s->lfe;
2394 for (i = 0; i < s->xxch_chset; i++) {
2395 channel_mask |= s->xxch_spk_masks[i];
2399 /* Given the DTS spec'ed channel mask, generate an avcodec version */
2401 for (i = 0; i < s->xxch_nbits_spk_mask; ++i) {
2402 if (channel_mask & (1 << i)) {
2403 channel_layout |= map_xxch_to_native[i];
2407 /* make sure that we have managed to get equivelant dts/avcodec channel
2408 * masks in some sense -- unfortunately some channels could overlap */
2409 if (av_popcount(channel_mask) != av_popcount(channel_layout)) {
2410 av_log(avctx, AV_LOG_DEBUG,
2411 "DTS-XXCH: Inconsistant avcodec/dts channel layouts\n");
2412 return AVERROR_INVALIDDATA;
2415 avctx->channel_layout = channel_layout;
2417 if (!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)) {
2418 /* Estimate DTS --> avcodec ordering table */
2419 for (chset = -1, j = 0; chset < s->xxch_chset; ++chset) {
2420 mask = chset >= 0 ? s->xxch_spk_masks[chset]
2421 : s->xxch_core_spkmask;
2422 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
2423 if (mask & ~(DCA_XXCH_LFE1 | DCA_XXCH_LFE2) & (1 << i)) {
2424 lavc = map_xxch_to_native[i];
2425 posn = av_popcount(channel_layout & (lavc - 1));
2426 s->xxch_order_tab[j++] = posn;
2431 s->lfe_index = av_popcount(channel_layout & (AV_CH_LOW_FREQUENCY-1));
2432 } else { /* native ordering */
2433 for (i = 0; i < channels; i++)
2434 s->xxch_order_tab[i] = i;
2436 s->lfe_index = channels - 1;
2439 s->channel_order_tab = s->xxch_order_tab;
2442 if (avctx->channels != channels) {
2443 if (avctx->channels)
2444 av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
2445 avctx->channels = channels;
2448 /* get output buffer */
2449 frame->nb_samples = 256 * (s->sample_blocks / 8);
2450 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
2452 samples_flt = (float **)frame->extended_data;
2454 /* allocate buffer for extra channels if downmixing */
2455 if (avctx->channels < full_channels) {
2456 ret = av_samples_get_buffer_size(NULL, full_channels - channels,
2458 avctx->sample_fmt, 0);
2462 av_fast_malloc(&s->extra_channels_buffer,
2463 &s->extra_channels_buffer_size, ret);
2464 if (!s->extra_channels_buffer)
2465 return AVERROR(ENOMEM);
2467 ret = av_samples_fill_arrays((uint8_t **)s->extra_channels, NULL,
2468 s->extra_channels_buffer,
2469 full_channels - channels,
2470 frame->nb_samples, avctx->sample_fmt, 0);
2475 /* filter to get final output */
2476 for (i = 0; i < (s->sample_blocks / 8); i++) {
2479 for (ch = 0; ch < channels; ch++)
2480 s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
2481 for (; ch < full_channels; ch++)
2482 s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
2484 dca_filter_channels(s, i);
2486 /* If this was marked as a DTS-ES stream we need to subtract back- */
2487 /* channel from SL & SR to remove matrixed back-channel signal */
2488 if ((s->source_pcm_res & 1) && s->xch_present) {
2489 float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];
2490 float *lt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];
2491 float *rt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];
2492 s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
2493 s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
2496 /* If stream contains XXCH, we might need to undo an embedded downmix */
2497 if (s->xxch_dmix_embedded) {
2498 /* Loop over channel sets in turn */
2499 ch = num_core_channels;
2500 for (chset = 0; chset < s->xxch_chset; chset++) {
2501 endch = ch + s->xxch_chset_nch[chset];
2502 mask = s->xxch_dmix_embedded;
2505 for (j = ch; j < endch; j++) {
2506 if (mask & (1 << j)) { /* this channel has been mixed-out */
2507 src_chan = s->samples_chanptr[s->channel_order_tab[j]];
2508 for (k = 0; k < endch; k++) {
2509 achan = s->channel_order_tab[k];
2510 scale = s->xxch_dmix_coeff[j][k];
2512 dst_chan = s->samples_chanptr[achan];
2513 s->fdsp.vector_fmac_scalar(dst_chan, src_chan,
2520 /* if a downmix has been embedded then undo the pre-scaling */
2521 if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) {
2522 scale = s->xxch_dmix_sf[chset];
2524 for (j = 0; j < ch; j++) {
2525 src_chan = s->samples_chanptr[s->channel_order_tab[j]];
2526 for (k = 0; k < 256; k++)
2527 src_chan[k] *= scale;
2530 /* LFE channel is always part of core, scale if it exists */
2532 src_chan = s->samples_chanptr[s->lfe_index];
2533 for (k = 0; k < 256; k++)
2534 src_chan[k] *= scale;
2544 /* update lfe history */
2545 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
2546 for (i = 0; i < 2 * s->lfe * 4; i++)
2547 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
2557 * DCA initialization
2559 * @param avctx pointer to the AVCodecContext
2562 static av_cold int dca_decode_init(AVCodecContext *avctx)
2564 DCAContext *s = avctx->priv_data;
2569 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
2570 ff_mdct_init(&s->imdct, 6, 1, 1.0);
2571 ff_synth_filter_init(&s->synth);
2572 ff_dcadsp_init(&s->dcadsp);
2573 ff_fmt_convert_init(&s->fmt_conv, avctx);
2575 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
2577 /* allow downmixing to stereo */
2578 #if FF_API_REQUEST_CHANNELS
2579 FF_DISABLE_DEPRECATION_WARNINGS
2580 if (avctx->request_channels == 2)
2581 avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
2582 FF_ENABLE_DEPRECATION_WARNINGS
2584 if (avctx->channels > 2 &&
2585 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
2586 avctx->channels = 2;
2591 static av_cold int dca_decode_end(AVCodecContext *avctx)
2593 DCAContext *s = avctx->priv_data;
2594 ff_mdct_end(&s->imdct);
2595 av_freep(&s->extra_channels_buffer);
2599 static const AVProfile profiles[] = {
2600 { FF_PROFILE_DTS, "DTS" },
2601 { FF_PROFILE_DTS_ES, "DTS-ES" },
2602 { FF_PROFILE_DTS_96_24, "DTS 96/24" },
2603 { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
2604 { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
2605 { FF_PROFILE_UNKNOWN },
2608 static const AVOption options[] = {
2609 { "disable_xch", "disable decoding of the XCh extension", offsetof(DCAContext, xch_disable), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM|AV_OPT_FLAG_AUDIO_PARAM },
2613 static const AVClass dca_decoder_class = {
2614 .class_name = "DCA decoder",
2615 .item_name = av_default_item_name,
2617 .version = LIBAVUTIL_VERSION_INT,
2618 .category = AV_CLASS_CATEGORY_DECODER,
2621 AVCodec ff_dca_decoder = {
2623 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
2624 .type = AVMEDIA_TYPE_AUDIO,
2625 .id = AV_CODEC_ID_DTS,
2626 .priv_data_size = sizeof(DCAContext),
2627 .init = dca_decode_init,
2628 .decode = dca_decode_frame,
2629 .close = dca_decode_end,
2630 .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
2631 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2632 AV_SAMPLE_FMT_NONE },
2633 .profiles = NULL_IF_CONFIG_SMALL(profiles),
2634 .priv_class = &dca_decoder_class,