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 #define DCA_NSYNCAUX 0x9A1105A0
331 /** Bit allocation */
333 int offset; ///< code values offset
334 int maxbits[8]; ///< max bits in VLC
335 int wrap; ///< wrap for get_vlc2()
336 VLC vlc[8]; ///< actual codes
339 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
340 static BitAlloc dca_tmode; ///< transition mode VLCs
341 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
342 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
344 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
347 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
352 const AVClass *class; ///< class for AVOptions
353 AVCodecContext *avctx;
355 int frame_type; ///< type of the current frame
356 int samples_deficit; ///< deficit sample count
357 int crc_present; ///< crc is present in the bitstream
358 int sample_blocks; ///< number of PCM sample blocks
359 int frame_size; ///< primary frame byte size
360 int amode; ///< audio channels arrangement
361 int sample_rate; ///< audio sampling rate
362 int bit_rate; ///< transmission bit rate
363 int bit_rate_index; ///< transmission bit rate index
365 int dynrange; ///< embedded dynamic range flag
366 int timestamp; ///< embedded time stamp flag
367 int aux_data; ///< auxiliary data flag
368 int hdcd; ///< source material is mastered in HDCD
369 int ext_descr; ///< extension audio descriptor flag
370 int ext_coding; ///< extended coding flag
371 int aspf; ///< audio sync word insertion flag
372 int lfe; ///< low frequency effects flag
373 int predictor_history; ///< predictor history flag
374 int header_crc; ///< header crc check bytes
375 int multirate_inter; ///< multirate interpolator switch
376 int version; ///< encoder software revision
377 int copy_history; ///< copy history
378 int source_pcm_res; ///< source pcm resolution
379 int front_sum; ///< front sum/difference flag
380 int surround_sum; ///< surround sum/difference flag
381 int dialog_norm; ///< dialog normalisation parameter
383 /* Primary audio coding header */
384 int subframes; ///< number of subframes
385 int total_channels; ///< number of channels including extensions
386 int prim_channels; ///< number of primary audio channels
387 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
388 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
389 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
390 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
391 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
392 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
393 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
394 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
396 /* Primary audio coding side information */
397 int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
398 int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
399 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
400 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
401 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
402 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
403 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
404 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
405 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
406 float downmix_coef[DCA_PRIM_CHANNELS_MAX + 1][2]; ///< stereo downmix coefficients
407 int dynrange_coef; ///< dynamic range coefficient
409 /* Core substream's embedded downmix coefficients (cf. ETSI TS 102 114 V1.4.1)
410 * Input: primary audio channels (incl. LFE if present)
411 * Output: downmix audio channels (up to 4, no LFE) */
412 uint8_t core_downmix; ///< embedded downmix coefficients available
413 uint8_t core_downmix_amode; ///< audio channel arrangement of embedded downmix
414 uint16_t core_downmix_codes[DCA_PRIM_CHANNELS_MAX + 1][4]; ///< embedded downmix coefficients (9-bit codes)
416 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
418 float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
419 int lfe_scale_factor;
421 /* Subband samples history (for ADPCM) */
422 DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
423 DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
424 DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
425 int hist_index[DCA_PRIM_CHANNELS_MAX];
426 DECLARE_ALIGNED(32, float, raXin)[32];
428 int output; ///< type of output
430 DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
431 float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
432 float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
433 uint8_t *extra_channels_buffer;
434 unsigned int extra_channels_buffer_size;
436 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
437 int dca_buffer_size; ///< how much data is in the dca_buffer
439 const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
441 /* Current position in DCA frame */
442 int current_subframe;
443 int current_subsubframe;
445 int core_ext_mask; ///< present extensions in the core substream
447 /* XCh extension information */
448 int xch_present; ///< XCh extension present and valid
449 int xch_base_channel; ///< index of first (only) channel containing XCH data
450 int xch_disable; ///< whether the XCh extension should be decoded or not
452 /* XXCH extension information */
454 int xxch_nbits_spk_mask;
455 uint32_t xxch_core_spkmask;
456 uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */
457 int xxch_chset_nch[4];
458 float xxch_dmix_sf[DCA_CHSETS_MAX];
460 uint32_t xxch_dmix_embedded; /* lower layer has mix pre-embedded, per chset */
461 float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */
463 int8_t xxch_order_tab[32];
466 /* ExSS header parser */
467 int static_fields; ///< static fields present
468 int mix_metadata; ///< mixing metadata present
469 int num_mix_configs; ///< number of mix out configurations
470 int mix_config_num_ch[4]; ///< number of channels in each mix out configuration
474 int debug_flag; ///< used for suppressing repeated error messages output
475 AVFloatDSPContext fdsp;
477 SynthFilterContext synth;
478 DCADSPContext dcadsp;
479 FmtConvertContext fmt_conv;
482 static const uint16_t dca_vlc_offs[] = {
483 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
484 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
485 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
486 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
487 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
488 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
491 static av_cold void dca_init_vlcs(void)
493 static int vlcs_initialized = 0;
495 static VLC_TYPE dca_table[23622][2];
497 if (vlcs_initialized)
500 dca_bitalloc_index.offset = 1;
501 dca_bitalloc_index.wrap = 2;
502 for (i = 0; i < 5; i++) {
503 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
504 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
505 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
506 bitalloc_12_bits[i], 1, 1,
507 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
509 dca_scalefactor.offset = -64;
510 dca_scalefactor.wrap = 2;
511 for (i = 0; i < 5; i++) {
512 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
513 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
514 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
515 scales_bits[i], 1, 1,
516 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
518 dca_tmode.offset = 0;
520 for (i = 0; i < 4; i++) {
521 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
522 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
523 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
525 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
528 for (i = 0; i < 10; i++)
529 for (j = 0; j < 7; j++) {
530 if (!bitalloc_codes[i][j])
532 dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i];
533 dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4);
534 dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
535 dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
537 init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
539 bitalloc_bits[i][j], 1, 1,
540 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
543 vlcs_initialized = 1;
546 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
549 *dst++ = get_bits(gb, bits);
552 static inline int dca_xxch2index(DCAContext *s, int xxch_ch)
556 /* locate channel set containing the channel */
557 for (i = -1, base = 0, mask = (s->xxch_core_spkmask & ~DCA_XXCH_LFE1);
558 i <= s->xxch_chset && !(mask & xxch_ch); mask = s->xxch_spk_masks[++i])
559 base += av_popcount(mask);
561 return base + av_popcount(mask & (xxch_ch - 1));
564 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,
568 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
569 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
570 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
571 int hdr_pos = 0, hdr_size = 0;
572 float sign, mag, scale_factor;
573 int this_chans, acc_mask;
574 int embedded_downmix;
578 /* xxch has arbitrary sized audio coding headers */
580 hdr_pos = get_bits_count(&s->gb);
581 hdr_size = get_bits(&s->gb, 7) + 1;
584 nchans = get_bits(&s->gb, 3) + 1;
585 s->total_channels = nchans + base_channel;
586 s->prim_channels = s->total_channels;
588 /* obtain speaker layout mask & downmix coefficients for XXCH */
590 acc_mask = s->xxch_core_spkmask;
592 this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6;
593 s->xxch_spk_masks[s->xxch_chset] = this_chans;
594 s->xxch_chset_nch[s->xxch_chset] = nchans;
596 for (i = 0; i <= s->xxch_chset; i++)
597 acc_mask |= s->xxch_spk_masks[i];
599 /* check for downmixing information */
600 if (get_bits1(&s->gb)) {
601 embedded_downmix = get_bits1(&s->gb);
603 1.0f / dca_dmixtable[(get_bits(&s->gb, 6) - 1) << 2];
605 s->xxch_dmix_sf[s->xxch_chset] = scale_factor;
607 for (i = base_channel; i < s->prim_channels; i++) {
608 mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask);
611 for (j = base_channel; j < s->prim_channels; j++) {
612 memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0]));
613 s->xxch_dmix_embedded |= (embedded_downmix << j);
614 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
615 if (mask[j] & (1 << i)) {
616 if ((1 << i) == DCA_XXCH_LFE1) {
617 av_log(s->avctx, AV_LOG_WARNING,
618 "DCA-XXCH: dmix to LFE1 not supported.\n");
622 coeff = get_bits(&s->gb, 7);
623 sign = (coeff & 64) ? 1.0 : -1.0;
624 mag = dca_dmixtable[((coeff & 63) - 1) << 2];
625 ichan = dca_xxch2index(s, 1 << i);
626 s->xxch_dmix_coeff[j][ichan] = sign * mag;
633 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
634 s->prim_channels = DCA_PRIM_CHANNELS_MAX;
637 for (i = base_channel; i < s->prim_channels; i++) {
638 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
639 if (s->subband_activity[i] > DCA_SUBBANDS)
640 s->subband_activity[i] = DCA_SUBBANDS;
642 for (i = base_channel; i < s->prim_channels; i++) {
643 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
644 if (s->vq_start_subband[i] > DCA_SUBBANDS)
645 s->vq_start_subband[i] = DCA_SUBBANDS;
647 get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
648 get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
649 get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
650 get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
652 /* Get codebooks quantization indexes */
654 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
655 for (j = 1; j < 11; j++)
656 for (i = base_channel; i < s->prim_channels; i++)
657 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
659 /* Get scale factor adjustment */
660 for (j = 0; j < 11; j++)
661 for (i = base_channel; i < s->prim_channels; i++)
662 s->scalefactor_adj[i][j] = 1;
664 for (j = 1; j < 11; j++)
665 for (i = base_channel; i < s->prim_channels; i++)
666 if (s->quant_index_huffman[i][j] < thr[j])
667 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
670 if (s->crc_present) {
671 /* Audio header CRC check */
672 get_bits(&s->gb, 16);
675 /* Skip to the end of the header, also ignore CRC if present */
676 i = get_bits_count(&s->gb);
677 if (hdr_pos + 8 * hdr_size > i)
678 skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);
681 s->current_subframe = 0;
682 s->current_subsubframe = 0;
685 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
686 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
687 for (i = base_channel; i < s->prim_channels; i++) {
688 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
689 s->subband_activity[i]);
690 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
691 s->vq_start_subband[i]);
692 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
693 s->joint_intensity[i]);
694 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
695 s->transient_huffman[i]);
696 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
697 s->scalefactor_huffman[i]);
698 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
699 s->bitalloc_huffman[i]);
700 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
701 for (j = 0; j < 11; j++)
702 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
703 av_log(s->avctx, AV_LOG_DEBUG, "\n");
704 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
705 for (j = 0; j < 11; j++)
706 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
707 av_log(s->avctx, AV_LOG_DEBUG, "\n");
714 static int dca_parse_frame_header(DCAContext *s)
716 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
719 skip_bits_long(&s->gb, 32);
722 s->frame_type = get_bits(&s->gb, 1);
723 s->samples_deficit = get_bits(&s->gb, 5) + 1;
724 s->crc_present = get_bits(&s->gb, 1);
725 s->sample_blocks = get_bits(&s->gb, 7) + 1;
726 s->frame_size = get_bits(&s->gb, 14) + 1;
727 if (s->frame_size < 95)
728 return AVERROR_INVALIDDATA;
729 s->amode = get_bits(&s->gb, 6);
730 s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
732 return AVERROR_INVALIDDATA;
733 s->bit_rate_index = get_bits(&s->gb, 5);
734 s->bit_rate = dca_bit_rates[s->bit_rate_index];
736 return AVERROR_INVALIDDATA;
738 skip_bits1(&s->gb); // always 0 (reserved, cf. ETSI TS 102 114 V1.4.1)
739 s->dynrange = get_bits(&s->gb, 1);
740 s->timestamp = get_bits(&s->gb, 1);
741 s->aux_data = get_bits(&s->gb, 1);
742 s->hdcd = get_bits(&s->gb, 1);
743 s->ext_descr = get_bits(&s->gb, 3);
744 s->ext_coding = get_bits(&s->gb, 1);
745 s->aspf = get_bits(&s->gb, 1);
746 s->lfe = get_bits(&s->gb, 2);
747 s->predictor_history = get_bits(&s->gb, 1);
751 av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
752 return AVERROR_INVALIDDATA;
755 /* TODO: check CRC */
757 s->header_crc = get_bits(&s->gb, 16);
759 s->multirate_inter = get_bits(&s->gb, 1);
760 s->version = get_bits(&s->gb, 4);
761 s->copy_history = get_bits(&s->gb, 2);
762 s->source_pcm_res = get_bits(&s->gb, 3);
763 s->front_sum = get_bits(&s->gb, 1);
764 s->surround_sum = get_bits(&s->gb, 1);
765 s->dialog_norm = get_bits(&s->gb, 4);
767 /* FIXME: channels mixing levels */
768 s->output = s->amode;
770 s->output |= DCA_LFE;
773 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
774 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
775 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
776 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
777 s->sample_blocks, s->sample_blocks * 32);
778 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
779 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
780 s->amode, dca_channels[s->amode]);
781 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
783 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
785 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
786 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
787 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
788 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
789 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
790 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
791 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
792 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
793 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
794 s->predictor_history);
795 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
796 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
798 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
799 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
800 av_log(s->avctx, AV_LOG_DEBUG,
801 "source pcm resolution: %i (%i bits/sample)\n",
802 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
803 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
804 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
805 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
806 av_log(s->avctx, AV_LOG_DEBUG, "\n");
809 /* Primary audio coding header */
810 s->subframes = get_bits(&s->gb, 4) + 1;
812 return dca_parse_audio_coding_header(s, 0, 0);
816 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
819 /* huffman encoded */
820 value += get_bitalloc(gb, &dca_scalefactor, level);
821 value = av_clip(value, 0, (1 << log2range) - 1);
822 } else if (level < 8) {
823 if (level + 1 > log2range) {
824 skip_bits(gb, level + 1 - log2range);
825 value = get_bits(gb, log2range);
827 value = get_bits(gb, level + 1);
833 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
835 /* Primary audio coding side information */
838 if (get_bits_left(&s->gb) < 0)
839 return AVERROR_INVALIDDATA;
842 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
843 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
846 for (j = base_channel; j < s->prim_channels; j++) {
847 for (k = 0; k < s->subband_activity[j]; k++)
848 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
851 /* Get prediction codebook */
852 for (j = base_channel; j < s->prim_channels; j++) {
853 for (k = 0; k < s->subband_activity[j]; k++) {
854 if (s->prediction_mode[j][k] > 0) {
855 /* (Prediction coefficient VQ address) */
856 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
861 /* Bit allocation index */
862 for (j = base_channel; j < s->prim_channels; j++) {
863 for (k = 0; k < s->vq_start_subband[j]; k++) {
864 if (s->bitalloc_huffman[j] == 6)
865 s->bitalloc[j][k] = get_bits(&s->gb, 5);
866 else if (s->bitalloc_huffman[j] == 5)
867 s->bitalloc[j][k] = get_bits(&s->gb, 4);
868 else if (s->bitalloc_huffman[j] == 7) {
869 av_log(s->avctx, AV_LOG_ERROR,
870 "Invalid bit allocation index\n");
871 return AVERROR_INVALIDDATA;
874 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
877 if (s->bitalloc[j][k] > 26) {
878 av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
879 j, k, s->bitalloc[j][k]);
880 return AVERROR_INVALIDDATA;
885 /* Transition mode */
886 for (j = base_channel; j < s->prim_channels; j++) {
887 for (k = 0; k < s->subband_activity[j]; k++) {
888 s->transition_mode[j][k] = 0;
889 if (s->subsubframes[s->current_subframe] > 1 &&
890 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
891 s->transition_mode[j][k] =
892 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
897 if (get_bits_left(&s->gb) < 0)
898 return AVERROR_INVALIDDATA;
900 for (j = base_channel; j < s->prim_channels; j++) {
901 const uint32_t *scale_table;
902 int scale_sum, log_size;
904 memset(s->scale_factor[j], 0,
905 s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
907 if (s->scalefactor_huffman[j] == 6) {
908 scale_table = scale_factor_quant7;
911 scale_table = scale_factor_quant6;
915 /* When huffman coded, only the difference is encoded */
918 for (k = 0; k < s->subband_activity[j]; k++) {
919 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
920 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
921 s->scale_factor[j][k][0] = scale_table[scale_sum];
924 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
925 /* Get second scale factor */
926 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
927 s->scale_factor[j][k][1] = scale_table[scale_sum];
932 /* Joint subband scale factor codebook select */
933 for (j = base_channel; j < s->prim_channels; j++) {
934 /* Transmitted only if joint subband coding enabled */
935 if (s->joint_intensity[j] > 0)
936 s->joint_huff[j] = get_bits(&s->gb, 3);
939 if (get_bits_left(&s->gb) < 0)
940 return AVERROR_INVALIDDATA;
942 /* Scale factors for joint subband coding */
943 for (j = base_channel; j < s->prim_channels; j++) {
946 /* Transmitted only if joint subband coding enabled */
947 if (s->joint_intensity[j] > 0) {
949 source_channel = s->joint_intensity[j] - 1;
951 /* When huffman coded, only the difference is encoded
952 * (is this valid as well for joint scales ???) */
954 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
955 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
956 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
959 if (!(s->debug_flag & 0x02)) {
960 av_log(s->avctx, AV_LOG_DEBUG,
961 "Joint stereo coding not supported\n");
962 s->debug_flag |= 0x02;
967 /* Dynamic range coefficient */
968 if (!base_channel && s->dynrange)
969 s->dynrange_coef = get_bits(&s->gb, 8);
971 /* Side information CRC check word */
972 if (s->crc_present) {
973 get_bits(&s->gb, 16);
977 * Primary audio data arrays
980 /* VQ encoded high frequency subbands */
981 for (j = base_channel; j < s->prim_channels; j++)
982 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
983 /* 1 vector -> 32 samples */
984 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
986 /* Low frequency effect data */
987 if (!base_channel && s->lfe) {
990 int lfe_samples = 2 * s->lfe * (4 + block_index);
991 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
994 for (j = lfe_samples; j < lfe_end_sample; j++) {
995 /* Signed 8 bits int */
996 s->lfe_data[j] = get_sbits(&s->gb, 8);
999 /* Scale factor index */
1000 quant7 = get_bits(&s->gb, 8);
1002 avpriv_request_sample(s->avctx, "LFEScaleIndex larger than 127");
1003 return AVERROR_INVALIDDATA;
1005 s->lfe_scale_factor = scale_factor_quant7[quant7];
1007 /* Quantization step size * scale factor */
1008 lfe_scale = 0.035 * s->lfe_scale_factor;
1010 for (j = lfe_samples; j < lfe_end_sample; j++)
1011 s->lfe_data[j] *= lfe_scale;
1015 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
1016 s->subsubframes[s->current_subframe]);
1017 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
1018 s->partial_samples[s->current_subframe]);
1020 for (j = base_channel; j < s->prim_channels; j++) {
1021 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
1022 for (k = 0; k < s->subband_activity[j]; k++)
1023 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
1024 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1026 for (j = base_channel; j < s->prim_channels; j++) {
1027 for (k = 0; k < s->subband_activity[j]; k++)
1028 av_log(s->avctx, AV_LOG_DEBUG,
1029 "prediction coefs: %f, %f, %f, %f\n",
1030 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
1031 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
1032 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
1033 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
1035 for (j = base_channel; j < s->prim_channels; j++) {
1036 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
1037 for (k = 0; k < s->vq_start_subband[j]; k++)
1038 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
1039 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1041 for (j = base_channel; j < s->prim_channels; j++) {
1042 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
1043 for (k = 0; k < s->subband_activity[j]; k++)
1044 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
1045 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1047 for (j = base_channel; j < s->prim_channels; j++) {
1048 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
1049 for (k = 0; k < s->subband_activity[j]; k++) {
1050 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
1051 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
1052 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
1053 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
1055 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1057 for (j = base_channel; j < s->prim_channels; j++) {
1058 if (s->joint_intensity[j] > 0) {
1059 int source_channel = s->joint_intensity[j] - 1;
1060 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
1061 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
1062 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
1063 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1066 for (j = base_channel; j < s->prim_channels; j++)
1067 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
1068 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
1069 if (!base_channel && s->lfe) {
1070 int lfe_samples = 2 * s->lfe * (4 + block_index);
1071 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
1073 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
1074 for (j = lfe_samples; j < lfe_end_sample; j++)
1075 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
1076 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1083 static void qmf_32_subbands(DCAContext *s, int chans,
1084 float samples_in[32][8], float *samples_out,
1087 const float *prCoeff;
1089 int sb_act = s->subband_activity[chans];
1091 scale *= sqrt(1 / 8.0);
1094 if (!s->multirate_inter) /* Non-perfect reconstruction */
1095 prCoeff = fir_32bands_nonperfect;
1096 else /* Perfect reconstruction */
1097 prCoeff = fir_32bands_perfect;
1099 s->dcadsp.qmf_32_subbands(samples_in, sb_act, &s->synth, &s->imdct,
1100 s->subband_fir_hist[chans],
1101 &s->hist_index[chans],
1102 s->subband_fir_noidea[chans], prCoeff,
1103 samples_out, s->raXin, scale);
1106 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
1107 int num_deci_sample, float *samples_in,
1108 float *samples_out, float scale)
1110 /* samples_in: An array holding decimated samples.
1111 * Samples in current subframe starts from samples_in[0],
1112 * while samples_in[-1], samples_in[-2], ..., stores samples
1113 * from last subframe as history.
1115 * samples_out: An array holding interpolated samples
1119 const float *prCoeff;
1122 /* Select decimation filter */
1123 if (decimation_select == 1) {
1125 prCoeff = lfe_fir_128;
1128 prCoeff = lfe_fir_64;
1131 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
1132 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
1134 samples_out += 2 * decifactor;
1138 /* downmixing routines */
1139 #define MIX_REAR1(samples, s1, rs, coef) \
1140 samples[0][i] += samples[s1][i] * coef[rs][0]; \
1141 samples[1][i] += samples[s1][i] * coef[rs][1];
1143 #define MIX_REAR2(samples, s1, s2, rs, coef) \
1144 samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
1145 samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
1147 #define MIX_FRONT3(samples, coef) \
1148 t = samples[c][i]; \
1149 u = samples[l][i]; \
1150 v = samples[r][i]; \
1151 samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1152 samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1154 #define DOWNMIX_TO_STEREO(op1, op2) \
1155 for (i = 0; i < 256; i++) { \
1160 static void dca_downmix(float **samples, int srcfmt, int lfe_present,
1161 float coef[DCA_PRIM_CHANNELS_MAX + 1][2],
1162 const int8_t *channel_mapping)
1164 int c, l, r, sl, sr, s;
1171 av_log(NULL, AV_LOG_ERROR, "Not implemented!\n");
1175 case DCA_STEREO_TOTAL:
1176 case DCA_STEREO_SUMDIFF:
1179 c = channel_mapping[0];
1180 l = channel_mapping[1];
1181 r = channel_mapping[2];
1182 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1185 s = channel_mapping[2];
1186 DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
1189 c = channel_mapping[0];
1190 l = channel_mapping[1];
1191 r = channel_mapping[2];
1192 s = channel_mapping[3];
1193 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1194 MIX_REAR1(samples, s, 3, coef));
1197 sl = channel_mapping[2];
1198 sr = channel_mapping[3];
1199 DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
1202 c = channel_mapping[0];
1203 l = channel_mapping[1];
1204 r = channel_mapping[2];
1205 sl = channel_mapping[3];
1206 sr = channel_mapping[4];
1207 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1208 MIX_REAR2(samples, sl, sr, 3, coef));
1212 int lf_buf = dca_lfe_index[srcfmt];
1213 int lf_idx = dca_channels [srcfmt];
1214 for (i = 0; i < 256; i++) {
1215 samples[0][i] += samples[lf_buf][i] * coef[lf_idx][0];
1216 samples[1][i] += samples[lf_buf][i] * coef[lf_idx][1];
1222 #ifndef decode_blockcodes
1223 /* Very compact version of the block code decoder that does not use table
1224 * look-up but is slightly slower */
1225 static int decode_blockcode(int code, int levels, int32_t *values)
1228 int offset = (levels - 1) >> 1;
1230 for (i = 0; i < 4; i++) {
1231 int div = FASTDIV(code, levels);
1232 values[i] = code - offset - div * levels;
1239 static int decode_blockcodes(int code1, int code2, int levels, int32_t *values)
1241 return decode_blockcode(code1, levels, values) |
1242 decode_blockcode(code2, levels, values + 4);
1246 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1247 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1249 #ifndef int8x8_fmul_int32
1250 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1252 float fscale = scale / 16.0;
1254 for (i = 0; i < 8; i++)
1255 dst[i] = src[i] * fscale;
1259 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1262 int subsubframe = s->current_subsubframe;
1264 const float *quant_step_table;
1267 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1268 LOCAL_ALIGNED_16(int32_t, block, [8 * DCA_SUBBANDS]);
1274 /* Select quantization step size table */
1275 if (s->bit_rate_index == 0x1f)
1276 quant_step_table = lossless_quant_d;
1278 quant_step_table = lossy_quant_d;
1280 for (k = base_channel; k < s->prim_channels; k++) {
1281 float rscale[DCA_SUBBANDS];
1283 if (get_bits_left(&s->gb) < 0)
1284 return AVERROR_INVALIDDATA;
1286 for (l = 0; l < s->vq_start_subband[k]; l++) {
1289 /* Select the mid-tread linear quantizer */
1290 int abits = s->bitalloc[k][l];
1292 float quant_step_size = quant_step_table[abits];
1295 * Determine quantization index code book and its type
1298 /* Select quantization index code book */
1299 int sel = s->quant_index_huffman[k][abits];
1302 * Extract bits from the bit stream
1306 memset(block + 8 * l, 0, 8 * sizeof(block[0]));
1308 /* Deal with transients */
1309 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1310 rscale[l] = quant_step_size * s->scale_factor[k][l][sfi] *
1311 s->scalefactor_adj[k][sel];
1313 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1316 int block_code1, block_code2, size, levels, err;
1318 size = abits_sizes[abits - 1];
1319 levels = abits_levels[abits - 1];
1321 block_code1 = get_bits(&s->gb, size);
1322 block_code2 = get_bits(&s->gb, size);
1323 err = decode_blockcodes(block_code1, block_code2,
1324 levels, block + 8 * l);
1326 av_log(s->avctx, AV_LOG_ERROR,
1327 "ERROR: block code look-up failed\n");
1328 return AVERROR_INVALIDDATA;
1332 for (m = 0; m < 8; m++)
1333 block[8 * l + m] = get_sbits(&s->gb, abits - 3);
1337 for (m = 0; m < 8; m++)
1338 block[8 * l + m] = get_bitalloc(&s->gb,
1339 &dca_smpl_bitalloc[abits], sel);
1345 s->fmt_conv.int32_to_float_fmul_array8(&s->fmt_conv, subband_samples[k][0],
1346 block, rscale, 8 * s->vq_start_subband[k]);
1348 for (l = 0; l < s->vq_start_subband[k]; l++) {
1351 * Inverse ADPCM if in prediction mode
1353 if (s->prediction_mode[k][l]) {
1355 for (m = 0; m < 8; m++) {
1356 for (n = 1; n <= 4; n++)
1358 subband_samples[k][l][m] +=
1359 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1360 subband_samples[k][l][m - n] / 8192);
1361 else if (s->predictor_history)
1362 subband_samples[k][l][m] +=
1363 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1364 s->subband_samples_hist[k][l][m - n + 4] / 8192);
1370 * Decode VQ encoded high frequencies
1372 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1373 /* 1 vector -> 32 samples but we only need the 8 samples
1374 * for this subsubframe. */
1375 int hfvq = s->high_freq_vq[k][l];
1377 if (!s->debug_flag & 0x01) {
1378 av_log(s->avctx, AV_LOG_DEBUG,
1379 "Stream with high frequencies VQ coding\n");
1380 s->debug_flag |= 0x01;
1383 int8x8_fmul_int32(subband_samples[k][l],
1384 &high_freq_vq[hfvq][subsubframe * 8],
1385 s->scale_factor[k][l][0]);
1389 /* Check for DSYNC after subsubframe */
1390 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1391 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1393 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1396 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1397 return AVERROR_INVALIDDATA;
1401 /* Backup predictor history for adpcm */
1402 for (k = base_channel; k < s->prim_channels; k++)
1403 for (l = 0; l < s->vq_start_subband[k]; l++)
1404 memcpy(s->subband_samples_hist[k][l],
1405 &subband_samples[k][l][4],
1406 4 * sizeof(subband_samples[0][0][0]));
1411 static int dca_filter_channels(DCAContext *s, int block_index)
1413 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1416 /* 32 subbands QMF */
1417 for (k = 0; k < s->prim_channels; k++) {
1418 /* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1419 0, 8388608.0, 8388608.0 };*/
1420 if (s->channel_order_tab[k] >= 0)
1421 qmf_32_subbands(s, k, subband_samples[k],
1422 s->samples_chanptr[s->channel_order_tab[k]],
1423 M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */);
1426 /* Generate LFE samples for this subsubframe FIXME!!! */
1428 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1429 s->lfe_data + 2 * s->lfe * (block_index + 4),
1430 s->samples_chanptr[s->lfe_index],
1431 1.0 / (256.0 * 32768.0));
1432 /* Outputs 20bits pcm samples */
1435 /* Downmixing to Stereo */
1436 if (s->prim_channels + !!s->lfe > 2 &&
1437 s->avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1438 dca_downmix(s->samples_chanptr, s->amode, !!s->lfe, s->downmix_coef,
1439 s->channel_order_tab);
1446 static int dca_subframe_footer(DCAContext *s, int base_channel)
1448 int in, out, aux_data_count, aux_data_end, reserved;
1452 * Unpack optional information
1455 /* presumably optional information only appears in the core? */
1456 if (!base_channel) {
1458 skip_bits_long(&s->gb, 32);
1461 aux_data_count = get_bits(&s->gb, 6);
1464 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1466 aux_data_end = 8 * aux_data_count + get_bits_count(&s->gb);
1468 if ((nsyncaux = get_bits_long(&s->gb, 32)) != DCA_NSYNCAUX) {
1469 av_log(s->avctx, AV_LOG_ERROR, "nSYNCAUX mismatch %#"PRIx32"\n",
1471 return AVERROR_INVALIDDATA;
1474 if (get_bits1(&s->gb)) { // bAUXTimeStampFlag
1475 avpriv_request_sample(s->avctx,
1476 "Auxiliary Decode Time Stamp Flag");
1478 skip_bits(&s->gb, (-get_bits_count(&s->gb)) & 4);
1479 // 44 bits: nMSByte (8), nMarker (4), nLSByte (28), nMarker (4)
1480 skip_bits_long(&s->gb, 44);
1483 if ((s->core_downmix = get_bits1(&s->gb))) {
1484 int am = get_bits(&s->gb, 3);
1487 s->core_downmix_amode = DCA_MONO;
1490 s->core_downmix_amode = DCA_STEREO;
1493 s->core_downmix_amode = DCA_STEREO_TOTAL;
1496 s->core_downmix_amode = DCA_3F;
1499 s->core_downmix_amode = DCA_2F1R;
1502 s->core_downmix_amode = DCA_2F2R;
1505 s->core_downmix_amode = DCA_3F1R;
1508 av_log(s->avctx, AV_LOG_ERROR,
1509 "Invalid mode %d for embedded downmix coefficients\n",
1511 return AVERROR_INVALIDDATA;
1513 for (out = 0; out < dca_channels[s->core_downmix_amode]; out++) {
1514 for (in = 0; in < s->prim_channels + !!s->lfe; in++) {
1515 uint16_t tmp = get_bits(&s->gb, 9);
1516 if ((tmp & 0xFF) > 241) {
1517 av_log(s->avctx, AV_LOG_ERROR,
1518 "Invalid downmix coefficient code %"PRIu16"\n",
1520 return AVERROR_INVALIDDATA;
1522 s->core_downmix_codes[in][out] = tmp;
1527 align_get_bits(&s->gb); // byte align
1528 skip_bits(&s->gb, 16); // nAUXCRC16
1530 // additional data (reserved, cf. ETSI TS 102 114 V1.4.1)
1531 if ((reserved = (aux_data_end - get_bits_count(&s->gb))) < 0) {
1532 av_log(s->avctx, AV_LOG_ERROR,
1533 "Overread auxiliary data by %d bits\n", -reserved);
1534 return AVERROR_INVALIDDATA;
1535 } else if (reserved) {
1536 avpriv_request_sample(s->avctx,
1537 "Core auxiliary data reserved content");
1538 skip_bits_long(&s->gb, reserved);
1542 if (s->crc_present && s->dynrange)
1543 get_bits(&s->gb, 16);
1550 * Decode a dca frame block
1552 * @param s pointer to the DCAContext
1555 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1560 if (s->current_subframe >= s->subframes) {
1561 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1562 s->current_subframe, s->subframes);
1563 return AVERROR_INVALIDDATA;
1566 if (!s->current_subsubframe) {
1568 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1570 /* Read subframe header */
1571 if ((ret = dca_subframe_header(s, base_channel, block_index)))
1575 /* Read subsubframe */
1577 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1579 if ((ret = dca_subsubframe(s, base_channel, block_index)))
1583 s->current_subsubframe++;
1584 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1585 s->current_subsubframe = 0;
1586 s->current_subframe++;
1588 if (s->current_subframe >= s->subframes) {
1590 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1592 /* Read subframe footer */
1593 if ((ret = dca_subframe_footer(s, base_channel)))
1601 * Return the number of channels in an ExSS speaker mask (HD)
1603 static int dca_exss_mask2count(int mask)
1605 /* count bits that mean speaker pairs twice */
1606 return av_popcount(mask) +
1607 av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
1608 DCA_EXSS_FRONT_LEFT_RIGHT |
1609 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
1610 DCA_EXSS_WIDE_LEFT_RIGHT |
1611 DCA_EXSS_SIDE_LEFT_RIGHT |
1612 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
1613 DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
1614 DCA_EXSS_REAR_LEFT_RIGHT |
1615 DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1619 * Skip mixing coefficients of a single mix out configuration (HD)
1621 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1625 for (i = 0; i < channels; i++) {
1626 int mix_map_mask = get_bits(gb, out_ch);
1627 int num_coeffs = av_popcount(mix_map_mask);
1628 skip_bits_long(gb, num_coeffs * 6);
1633 * Parse extension substream asset header (HD)
1635 static int dca_exss_parse_asset_header(DCAContext *s)
1637 int header_pos = get_bits_count(&s->gb);
1640 int embedded_stereo = 0;
1641 int embedded_6ch = 0;
1642 int drc_code_present;
1643 int av_uninit(extensions_mask);
1646 if (get_bits_left(&s->gb) < 16)
1649 /* We will parse just enough to get to the extensions bitmask with which
1650 * we can set the profile value. */
1652 header_size = get_bits(&s->gb, 9) + 1;
1653 skip_bits(&s->gb, 3); // asset index
1655 if (s->static_fields) {
1656 if (get_bits1(&s->gb))
1657 skip_bits(&s->gb, 4); // asset type descriptor
1658 if (get_bits1(&s->gb))
1659 skip_bits_long(&s->gb, 24); // language descriptor
1661 if (get_bits1(&s->gb)) {
1662 /* How can one fit 1024 bytes of text here if the maximum value
1663 * for the asset header size field above was 512 bytes? */
1664 int text_length = get_bits(&s->gb, 10) + 1;
1665 if (get_bits_left(&s->gb) < text_length * 8)
1667 skip_bits_long(&s->gb, text_length * 8); // info text
1670 skip_bits(&s->gb, 5); // bit resolution - 1
1671 skip_bits(&s->gb, 4); // max sample rate code
1672 channels = get_bits(&s->gb, 8) + 1;
1674 if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1675 int spkr_remap_sets;
1676 int spkr_mask_size = 16;
1680 embedded_stereo = get_bits1(&s->gb);
1682 embedded_6ch = get_bits1(&s->gb);
1684 if (get_bits1(&s->gb)) {
1685 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1686 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1689 spkr_remap_sets = get_bits(&s->gb, 3);
1691 for (i = 0; i < spkr_remap_sets; i++) {
1692 /* std layout mask for each remap set */
1693 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1696 for (i = 0; i < spkr_remap_sets; i++) {
1697 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1698 if (get_bits_left(&s->gb) < 0)
1701 for (j = 0; j < num_spkrs[i]; j++) {
1702 int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1703 int num_dec_ch = av_popcount(remap_dec_ch_mask);
1704 skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1709 skip_bits(&s->gb, 3); // representation type
1713 drc_code_present = get_bits1(&s->gb);
1714 if (drc_code_present)
1715 get_bits(&s->gb, 8); // drc code
1717 if (get_bits1(&s->gb))
1718 skip_bits(&s->gb, 5); // dialog normalization code
1720 if (drc_code_present && embedded_stereo)
1721 get_bits(&s->gb, 8); // drc stereo code
1723 if (s->mix_metadata && get_bits1(&s->gb)) {
1724 skip_bits(&s->gb, 1); // external mix
1725 skip_bits(&s->gb, 6); // post mix gain code
1727 if (get_bits(&s->gb, 2) != 3) // mixer drc code
1728 skip_bits(&s->gb, 3); // drc limit
1730 skip_bits(&s->gb, 8); // custom drc code
1732 if (get_bits1(&s->gb)) // channel specific scaling
1733 for (i = 0; i < s->num_mix_configs; i++)
1734 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1736 skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1738 for (i = 0; i < s->num_mix_configs; i++) {
1739 if (get_bits_left(&s->gb) < 0)
1741 dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1743 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1744 if (embedded_stereo)
1745 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1749 switch (get_bits(&s->gb, 2)) {
1750 case 0: extensions_mask = get_bits(&s->gb, 12); break;
1751 case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1752 case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1753 case 3: extensions_mask = 0; /* aux coding */ break;
1756 /* not parsed further, we were only interested in the extensions mask */
1758 if (get_bits_left(&s->gb) < 0)
1761 if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1762 av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1765 skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1767 if (extensions_mask & DCA_EXT_EXSS_XLL)
1768 s->profile = FF_PROFILE_DTS_HD_MA;
1769 else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1771 s->profile = FF_PROFILE_DTS_HD_HRA;
1773 if (!(extensions_mask & DCA_EXT_CORE))
1774 av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1775 if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1776 av_log(s->avctx, AV_LOG_WARNING,
1777 "DTS extensions detection mismatch (%d, %d)\n",
1778 extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1783 static int dca_xbr_parse_frame(DCAContext *s)
1785 int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];
1786 int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];
1787 int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS];
1788 int anctemp[DCA_CHSET_CHANS_MAX];
1789 int chset_fsize[DCA_CHSETS_MAX];
1790 int n_xbr_ch[DCA_CHSETS_MAX];
1791 int hdr_size, num_chsets, xbr_tmode, hdr_pos;
1792 int i, j, k, l, chset, chan_base;
1794 av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n");
1796 /* get bit position of sync header */
1797 hdr_pos = get_bits_count(&s->gb) - 32;
1799 hdr_size = get_bits(&s->gb, 6) + 1;
1800 num_chsets = get_bits(&s->gb, 2) + 1;
1802 for(i = 0; i < num_chsets; i++)
1803 chset_fsize[i] = get_bits(&s->gb, 14) + 1;
1805 xbr_tmode = get_bits1(&s->gb);
1807 for(i = 0; i < num_chsets; i++) {
1808 n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;
1809 k = get_bits(&s->gb, 2) + 5;
1810 for(j = 0; j < n_xbr_ch[i]; j++)
1811 active_bands[i][j] = get_bits(&s->gb, k) + 1;
1814 /* skip to the end of the header */
1815 i = get_bits_count(&s->gb);
1816 if(hdr_pos + hdr_size * 8 > i)
1817 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1819 /* loop over the channel data sets */
1820 /* only decode as many channels as we've decoded base data for */
1821 for(chset = 0, chan_base = 0;
1822 chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels;
1823 chan_base += n_xbr_ch[chset++]) {
1824 int start_posn = get_bits_count(&s->gb);
1825 int subsubframe = 0;
1828 /* loop over subframes */
1829 for (k = 0; k < (s->sample_blocks / 8); k++) {
1830 /* parse header if we're on first subsubframe of a block */
1831 if(subsubframe == 0) {
1832 /* Parse subframe header */
1833 for(i = 0; i < n_xbr_ch[chset]; i++) {
1834 anctemp[i] = get_bits(&s->gb, 2) + 2;
1837 for(i = 0; i < n_xbr_ch[chset]; i++) {
1838 get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]);
1841 for(i = 0; i < n_xbr_ch[chset]; i++) {
1842 anctemp[i] = get_bits(&s->gb, 3);
1843 if(anctemp[i] < 1) {
1844 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n");
1845 return AVERROR_INVALIDDATA;
1849 /* generate scale factors */
1850 for(i = 0; i < n_xbr_ch[chset]; i++) {
1851 const uint32_t *scale_table;
1854 if (s->scalefactor_huffman[chan_base+i] == 6) {
1855 scale_table = scale_factor_quant7;
1857 scale_table = scale_factor_quant6;
1862 for(j = 0; j < active_bands[chset][i]; j++) {
1863 if(abits_high[i][j] > 0) {
1864 scale_table_high[i][j][0] =
1865 scale_table[get_bits(&s->gb, nbits)];
1867 if(xbr_tmode && s->transition_mode[i][j]) {
1868 scale_table_high[i][j][1] =
1869 scale_table[get_bits(&s->gb, nbits)];
1876 /* decode audio array for this block */
1877 for(i = 0; i < n_xbr_ch[chset]; i++) {
1878 for(j = 0; j < active_bands[chset][i]; j++) {
1879 const int xbr_abits = abits_high[i][j];
1880 const float quant_step_size = lossless_quant_d[xbr_abits];
1881 const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j];
1882 const float rscale = quant_step_size * scale_table_high[i][j][sfi];
1883 float *subband_samples = s->subband_samples[k][chan_base+i][j];
1890 get_array(&s->gb, block, 8, xbr_abits - 3);
1892 int block_code1, block_code2, size, levels, err;
1894 size = abits_sizes[xbr_abits - 1];
1895 levels = abits_levels[xbr_abits - 1];
1897 block_code1 = get_bits(&s->gb, size);
1898 block_code2 = get_bits(&s->gb, size);
1899 err = decode_blockcodes(block_code1, block_code2,
1902 av_log(s->avctx, AV_LOG_ERROR,
1903 "ERROR: DTS-XBR: block code look-up failed\n");
1904 return AVERROR_INVALIDDATA;
1908 /* scale & sum into subband */
1909 for(l = 0; l < 8; l++)
1910 subband_samples[l] += (float)block[l] * rscale;
1914 /* check DSYNC marker */
1915 if(s->aspf || subsubframe == s->subsubframes[subframe] - 1) {
1916 if(get_bits(&s->gb, 16) != 0xffff) {
1917 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n");
1918 return AVERROR_INVALIDDATA;
1922 /* advance sub-sub-frame index */
1923 if(++subsubframe >= s->subsubframes[subframe]) {
1929 /* skip to next channel set */
1930 i = get_bits_count(&s->gb);
1931 if(start_posn + chset_fsize[chset] * 8 != i) {
1932 j = start_posn + chset_fsize[chset] * 8 - i;
1934 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set,"
1935 " skipping further than expected (%d bits)\n", j);
1936 skip_bits_long(&s->gb, j);
1943 /* parse initial header for XXCH and dump details */
1944 static int dca_xxch_decode_frame(DCAContext *s)
1946 int hdr_size, spkmsk_bits, num_chsets, core_spk, hdr_pos;
1947 int i, chset, base_channel, chstart, fsize[8];
1949 /* assume header word has already been parsed */
1950 hdr_pos = get_bits_count(&s->gb) - 32;
1951 hdr_size = get_bits(&s->gb, 6) + 1;
1952 /*chhdr_crc =*/ skip_bits1(&s->gb);
1953 spkmsk_bits = get_bits(&s->gb, 5) + 1;
1954 num_chsets = get_bits(&s->gb, 2) + 1;
1956 for (i = 0; i < num_chsets; i++)
1957 fsize[i] = get_bits(&s->gb, 14) + 1;
1959 core_spk = get_bits(&s->gb, spkmsk_bits);
1960 s->xxch_core_spkmask = core_spk;
1961 s->xxch_nbits_spk_mask = spkmsk_bits;
1962 s->xxch_dmix_embedded = 0;
1964 /* skip to the end of the header */
1965 i = get_bits_count(&s->gb);
1966 if (hdr_pos + hdr_size * 8 > i)
1967 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1969 for (chset = 0; chset < num_chsets; chset++) {
1970 chstart = get_bits_count(&s->gb);
1971 base_channel = s->prim_channels;
1972 s->xxch_chset = chset;
1974 /* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs.
1975 5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */
1976 dca_parse_audio_coding_header(s, base_channel, 1);
1978 /* decode channel data */
1979 for (i = 0; i < (s->sample_blocks / 8); i++) {
1980 if (dca_decode_block(s, base_channel, i)) {
1981 av_log(s->avctx, AV_LOG_ERROR,
1982 "Error decoding DTS-XXCH extension\n");
1987 /* skip to end of this section */
1988 i = get_bits_count(&s->gb);
1989 if (chstart + fsize[chset] * 8 > i)
1990 skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i);
1992 s->xxch_chset = num_chsets;
1998 * Parse extension substream header (HD)
2000 static void dca_exss_parse_header(DCAContext *s)
2007 int active_ss_mask[8];
2013 if (get_bits_left(&s->gb) < 52)
2016 start_posn = get_bits_count(&s->gb) - 32;
2018 skip_bits(&s->gb, 8); // user data
2019 ss_index = get_bits(&s->gb, 2);
2021 blownup = get_bits1(&s->gb);
2022 hdrsize = get_bits(&s->gb, 8 + 4 * blownup) + 1; // header_size
2023 skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
2025 s->static_fields = get_bits1(&s->gb);
2026 if (s->static_fields) {
2027 skip_bits(&s->gb, 2); // reference clock code
2028 skip_bits(&s->gb, 3); // frame duration code
2030 if (get_bits1(&s->gb))
2031 skip_bits_long(&s->gb, 36); // timestamp
2033 /* a single stream can contain multiple audio assets that can be
2034 * combined to form multiple audio presentations */
2036 num_audiop = get_bits(&s->gb, 3) + 1;
2037 if (num_audiop > 1) {
2038 avpriv_request_sample(s->avctx,
2039 "Multiple DTS-HD audio presentations");
2040 /* ignore such streams for now */
2044 num_assets = get_bits(&s->gb, 3) + 1;
2045 if (num_assets > 1) {
2046 avpriv_request_sample(s->avctx, "Multiple DTS-HD audio assets");
2047 /* ignore such streams for now */
2051 for (i = 0; i < num_audiop; i++)
2052 active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
2054 for (i = 0; i < num_audiop; i++)
2055 for (j = 0; j <= ss_index; j++)
2056 if (active_ss_mask[i] & (1 << j))
2057 skip_bits(&s->gb, 8); // active asset mask
2059 s->mix_metadata = get_bits1(&s->gb);
2060 if (s->mix_metadata) {
2061 int mix_out_mask_size;
2063 skip_bits(&s->gb, 2); // adjustment level
2064 mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
2065 s->num_mix_configs = get_bits(&s->gb, 2) + 1;
2067 for (i = 0; i < s->num_mix_configs; i++) {
2068 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
2069 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
2074 for (i = 0; i < num_assets; i++)
2075 asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup);
2077 for (i = 0; i < num_assets; i++) {
2078 if (dca_exss_parse_asset_header(s))
2082 /* not parsed further, we were only interested in the extensions mask
2083 * from the asset header */
2085 if (num_assets > 0) {
2086 j = get_bits_count(&s->gb);
2087 if (start_posn + hdrsize * 8 > j)
2088 skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j);
2090 for (i = 0; i < num_assets; i++) {
2091 start_posn = get_bits_count(&s->gb);
2092 mkr = get_bits_long(&s->gb, 32);
2094 /* parse extensions that we know about */
2095 if (mkr == 0x655e315e) {
2096 dca_xbr_parse_frame(s);
2097 } else if (mkr == 0x47004a03) {
2098 dca_xxch_decode_frame(s);
2099 s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
2101 av_log(s->avctx, AV_LOG_DEBUG,
2102 "DTS-ExSS: unknown marker = 0x%08x\n", mkr);
2105 /* skip to end of block */
2106 j = get_bits_count(&s->gb);
2107 if (start_posn + asset_size[i] * 8 > j)
2108 skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j);
2114 * Main frame decoding function
2115 * FIXME add arguments
2117 static int dca_decode_frame(AVCodecContext *avctx, void *data,
2118 int *got_frame_ptr, AVPacket *avpkt)
2120 AVFrame *frame = data;
2121 const uint8_t *buf = avpkt->data;
2122 int buf_size = avpkt->size;
2126 int num_core_channels = 0;
2128 float **samples_flt;
2131 DCAContext *s = avctx->priv_data;
2133 int channels, full_channels;
2145 s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
2146 DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
2147 if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
2148 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
2149 return AVERROR_INVALIDDATA;
2152 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
2153 if ((ret = dca_parse_frame_header(s)) < 0) {
2154 //seems like the frame is corrupt, try with the next one
2157 //set AVCodec values with parsed data
2158 avctx->sample_rate = s->sample_rate;
2159 avctx->bit_rate = s->bit_rate;
2161 s->profile = FF_PROFILE_DTS;
2163 for (i = 0; i < (s->sample_blocks / 8); i++) {
2164 if ((ret = dca_decode_block(s, 0, i))) {
2165 av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
2170 /* record number of core channels incase less than max channels are requested */
2171 num_core_channels = s->prim_channels;
2173 if (s->prim_channels + !!s->lfe > 2 &&
2174 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
2175 /* Stereo downmix coefficients
2177 * The decoder can only downmix to 2-channel, so we need to ensure
2178 * embedded downmix coefficients are actually targeting 2-channel.
2180 if (s->core_downmix && (s->core_downmix_amode == DCA_STEREO ||
2181 s->core_downmix_amode == DCA_STEREO_TOTAL)) {
2183 for (i = 0; i < s->prim_channels + !!s->lfe; i++) {
2184 sign = s->core_downmix_codes[i][0] & 0x100 ? 1 : -1;
2185 code = s->core_downmix_codes[i][0] & 0x0FF;
2186 s->downmix_coef[i][0] = (!code ? 0.0f :
2187 sign * dca_dmixtable[code - 1]);
2188 sign = s->core_downmix_codes[i][1] & 0x100 ? 1 : -1;
2189 code = s->core_downmix_codes[i][1] & 0x0FF;
2190 s->downmix_coef[i][1] = (!code ? 0.0f :
2191 sign * dca_dmixtable[code - 1]);
2194 int am = s->amode & DCA_CHANNEL_MASK;
2195 if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
2196 av_log(s->avctx, AV_LOG_ERROR,
2197 "Invalid channel mode %d\n", am);
2198 return AVERROR_INVALIDDATA;
2200 if (s->prim_channels + !!s->lfe >
2201 FF_ARRAY_ELEMS(dca_default_coeffs[0])) {
2202 avpriv_request_sample(s->avctx, "Downmixing %d channels",
2203 s->prim_channels + !!s->lfe);
2204 return AVERROR_PATCHWELCOME;
2206 for (i = 0; i < s->prim_channels + !!s->lfe; i++) {
2207 s->downmix_coef[i][0] = dca_default_coeffs[am][i][0];
2208 s->downmix_coef[i][1] = dca_default_coeffs[am][i][1];
2211 av_dlog(s->avctx, "Stereo downmix coeffs:\n");
2212 for (i = 0; i < s->prim_channels + !!s->lfe; i++) {
2213 av_dlog(s->avctx, "L, input channel %d = %f\n", i,
2214 s->downmix_coef[i][0]);
2215 av_dlog(s->avctx, "R, input channel %d = %f\n", i,
2216 s->downmix_coef[i][1]);
2218 av_dlog(s->avctx, "\n");
2222 s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
2224 s->core_ext_mask = 0;
2226 core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
2228 /* only scan for extensions if ext_descr was unknown or indicated a
2229 * supported XCh extension */
2230 if (s->core_ext_mask < 0 || s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH)) {
2232 /* if ext_descr was unknown, clear s->core_ext_mask so that the
2233 * extensions scan can fill it up */
2234 s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
2236 /* extensions start at 32-bit boundaries into bitstream */
2237 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2239 while (core_ss_end - get_bits_count(&s->gb) >= 32) {
2240 uint32_t bits = get_bits_long(&s->gb, 32);
2244 int ext_amode, xch_fsize;
2246 s->xch_base_channel = s->prim_channels;
2248 /* validate sync word using XCHFSIZE field */
2249 xch_fsize = show_bits(&s->gb, 10);
2250 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
2251 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
2254 /* skip length-to-end-of-frame field for the moment */
2255 skip_bits(&s->gb, 10);
2257 s->core_ext_mask |= DCA_EXT_XCH;
2259 /* extension amode(number of channels in extension) should be 1 */
2260 /* AFAIK XCh is not used for more channels */
2261 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
2262 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
2263 " supported!\n", ext_amode);
2267 if (s->xch_base_channel < 2) {
2268 avpriv_request_sample(avctx, "XCh with fewer than 2 base channels");
2272 /* much like core primary audio coding header */
2273 dca_parse_audio_coding_header(s, s->xch_base_channel, 0);
2275 for (i = 0; i < (s->sample_blocks / 8); i++)
2276 if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
2277 av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
2285 /* XXCh: extended channels */
2286 /* usually found either in core or HD part in DTS-HD HRA streams,
2287 * but not in DTS-ES which contains XCh extensions instead */
2288 s->core_ext_mask |= DCA_EXT_XXCH;
2289 dca_xxch_decode_frame(s);
2293 int fsize96 = show_bits(&s->gb, 12) + 1;
2294 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
2297 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
2298 get_bits_count(&s->gb));
2299 skip_bits(&s->gb, 12);
2300 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
2301 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
2303 s->core_ext_mask |= DCA_EXT_X96;
2308 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2311 /* no supported extensions, skip the rest of the core substream */
2312 skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
2315 if (s->core_ext_mask & DCA_EXT_X96)
2316 s->profile = FF_PROFILE_DTS_96_24;
2317 else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
2318 s->profile = FF_PROFILE_DTS_ES;
2320 /* check for ExSS (HD part) */
2321 if (s->dca_buffer_size - s->frame_size > 32 &&
2322 get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
2323 dca_exss_parse_header(s);
2325 avctx->profile = s->profile;
2327 full_channels = channels = s->prim_channels + !!s->lfe;
2329 /* If we have XXCH then the channel layout is managed differently */
2330 /* note that XLL will also have another way to do things */
2331 if (!(s->core_ext_mask & DCA_EXT_XXCH)
2332 || (s->core_ext_mask & DCA_EXT_XXCH && avctx->request_channels > 0
2333 && avctx->request_channels
2334 < num_core_channels + !!s->lfe + s->xxch_chset_nch[0]))
2335 { /* xxx should also do MA extensions */
2336 if (s->amode < 16) {
2337 avctx->channel_layout = dca_core_channel_layout[s->amode];
2338 #if FF_API_REQUEST_CHANNELS
2339 FF_DISABLE_DEPRECATION_WARNINGS
2340 if (s->xch_present && !s->xch_disable &&
2341 (!avctx->request_channels ||
2342 avctx->request_channels > num_core_channels + !!s->lfe)) {
2343 FF_ENABLE_DEPRECATION_WARNINGS
2345 if (s->xch_present && !s->xch_disable) {
2347 avctx->channel_layout |= AV_CH_BACK_CENTER;
2349 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2350 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
2352 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
2354 if (s->channel_order_tab[s->xch_base_channel] < 0)
2355 return AVERROR_INVALIDDATA;
2357 channels = num_core_channels + !!s->lfe;
2358 s->xch_present = 0; /* disable further xch processing */
2360 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2361 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
2363 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
2366 if (channels > !!s->lfe &&
2367 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
2368 return AVERROR_INVALIDDATA;
2370 if (av_get_channel_layout_nb_channels(avctx->channel_layout) != channels) {
2371 av_log(avctx, AV_LOG_ERROR, "Number of channels %d mismatches layout %d\n", channels, av_get_channel_layout_nb_channels(avctx->channel_layout));
2372 return AVERROR_INVALIDDATA;
2375 if (s->prim_channels + !!s->lfe > 2 &&
2376 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
2378 s->output = DCA_STEREO;
2379 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
2381 else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
2382 static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
2383 s->channel_order_tab = dca_channel_order_native;
2385 s->lfe_index = dca_lfe_index[s->amode];
2387 av_log(avctx, AV_LOG_ERROR,
2388 "Non standard configuration %d !\n", s->amode);
2389 return AVERROR_INVALIDDATA;
2392 s->xxch_dmix_embedded = 0;
2394 /* we only get here if an XXCH channel set can be added to the mix */
2395 channel_mask = s->xxch_core_spkmask;
2397 if (avctx->request_channels > 0
2398 && avctx->request_channels < s->prim_channels) {
2399 channels = num_core_channels + !!s->lfe;
2400 for (i = 0; i < s->xxch_chset && channels + s->xxch_chset_nch[i]
2401 <= avctx->request_channels; i++) {
2402 channels += s->xxch_chset_nch[i];
2403 channel_mask |= s->xxch_spk_masks[i];
2406 channels = s->prim_channels + !!s->lfe;
2407 for (i = 0; i < s->xxch_chset; i++) {
2408 channel_mask |= s->xxch_spk_masks[i];
2412 /* Given the DTS spec'ed channel mask, generate an avcodec version */
2414 for (i = 0; i < s->xxch_nbits_spk_mask; ++i) {
2415 if (channel_mask & (1 << i)) {
2416 channel_layout |= map_xxch_to_native[i];
2420 /* make sure that we have managed to get equivelant dts/avcodec channel
2421 * masks in some sense -- unfortunately some channels could overlap */
2422 if (av_popcount(channel_mask) != av_popcount(channel_layout)) {
2423 av_log(avctx, AV_LOG_DEBUG,
2424 "DTS-XXCH: Inconsistant avcodec/dts channel layouts\n");
2425 return AVERROR_INVALIDDATA;
2428 avctx->channel_layout = channel_layout;
2430 if (!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)) {
2431 /* Estimate DTS --> avcodec ordering table */
2432 for (chset = -1, j = 0; chset < s->xxch_chset; ++chset) {
2433 mask = chset >= 0 ? s->xxch_spk_masks[chset]
2434 : s->xxch_core_spkmask;
2435 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
2436 if (mask & ~(DCA_XXCH_LFE1 | DCA_XXCH_LFE2) & (1 << i)) {
2437 lavc = map_xxch_to_native[i];
2438 posn = av_popcount(channel_layout & (lavc - 1));
2439 s->xxch_order_tab[j++] = posn;
2444 s->lfe_index = av_popcount(channel_layout & (AV_CH_LOW_FREQUENCY-1));
2445 } else { /* native ordering */
2446 for (i = 0; i < channels; i++)
2447 s->xxch_order_tab[i] = i;
2449 s->lfe_index = channels - 1;
2452 s->channel_order_tab = s->xxch_order_tab;
2455 if (avctx->channels != channels) {
2456 if (avctx->channels)
2457 av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
2458 avctx->channels = channels;
2461 /* get output buffer */
2462 frame->nb_samples = 256 * (s->sample_blocks / 8);
2463 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
2465 samples_flt = (float **)frame->extended_data;
2467 /* allocate buffer for extra channels if downmixing */
2468 if (avctx->channels < full_channels) {
2469 ret = av_samples_get_buffer_size(NULL, full_channels - channels,
2471 avctx->sample_fmt, 0);
2475 av_fast_malloc(&s->extra_channels_buffer,
2476 &s->extra_channels_buffer_size, ret);
2477 if (!s->extra_channels_buffer)
2478 return AVERROR(ENOMEM);
2480 ret = av_samples_fill_arrays((uint8_t **)s->extra_channels, NULL,
2481 s->extra_channels_buffer,
2482 full_channels - channels,
2483 frame->nb_samples, avctx->sample_fmt, 0);
2488 /* filter to get final output */
2489 for (i = 0; i < (s->sample_blocks / 8); i++) {
2492 for (ch = 0; ch < channels; ch++)
2493 s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
2494 for (; ch < full_channels; ch++)
2495 s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
2497 dca_filter_channels(s, i);
2499 /* If this was marked as a DTS-ES stream we need to subtract back- */
2500 /* channel from SL & SR to remove matrixed back-channel signal */
2501 if ((s->source_pcm_res & 1) && s->xch_present) {
2502 float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];
2503 float *lt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];
2504 float *rt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];
2505 s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
2506 s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
2509 /* If stream contains XXCH, we might need to undo an embedded downmix */
2510 if (s->xxch_dmix_embedded) {
2511 /* Loop over channel sets in turn */
2512 ch = num_core_channels;
2513 for (chset = 0; chset < s->xxch_chset; chset++) {
2514 endch = ch + s->xxch_chset_nch[chset];
2515 mask = s->xxch_dmix_embedded;
2518 for (j = ch; j < endch; j++) {
2519 if (mask & (1 << j)) { /* this channel has been mixed-out */
2520 src_chan = s->samples_chanptr[s->channel_order_tab[j]];
2521 for (k = 0; k < endch; k++) {
2522 achan = s->channel_order_tab[k];
2523 scale = s->xxch_dmix_coeff[j][k];
2525 dst_chan = s->samples_chanptr[achan];
2526 s->fdsp.vector_fmac_scalar(dst_chan, src_chan,
2533 /* if a downmix has been embedded then undo the pre-scaling */
2534 if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) {
2535 scale = s->xxch_dmix_sf[chset];
2537 for (j = 0; j < ch; j++) {
2538 src_chan = s->samples_chanptr[s->channel_order_tab[j]];
2539 for (k = 0; k < 256; k++)
2540 src_chan[k] *= scale;
2543 /* LFE channel is always part of core, scale if it exists */
2545 src_chan = s->samples_chanptr[s->lfe_index];
2546 for (k = 0; k < 256; k++)
2547 src_chan[k] *= scale;
2557 /* update lfe history */
2558 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
2559 for (i = 0; i < 2 * s->lfe * 4; i++)
2560 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
2570 * DCA initialization
2572 * @param avctx pointer to the AVCodecContext
2575 static av_cold int dca_decode_init(AVCodecContext *avctx)
2577 DCAContext *s = avctx->priv_data;
2582 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
2583 ff_mdct_init(&s->imdct, 6, 1, 1.0);
2584 ff_synth_filter_init(&s->synth);
2585 ff_dcadsp_init(&s->dcadsp);
2586 ff_fmt_convert_init(&s->fmt_conv, avctx);
2588 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
2590 /* allow downmixing to stereo */
2591 #if FF_API_REQUEST_CHANNELS
2592 FF_DISABLE_DEPRECATION_WARNINGS
2593 if (avctx->request_channels == 2)
2594 avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
2595 FF_ENABLE_DEPRECATION_WARNINGS
2597 if (avctx->channels > 2 &&
2598 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
2599 avctx->channels = 2;
2604 static av_cold int dca_decode_end(AVCodecContext *avctx)
2606 DCAContext *s = avctx->priv_data;
2607 ff_mdct_end(&s->imdct);
2608 av_freep(&s->extra_channels_buffer);
2612 static const AVProfile profiles[] = {
2613 { FF_PROFILE_DTS, "DTS" },
2614 { FF_PROFILE_DTS_ES, "DTS-ES" },
2615 { FF_PROFILE_DTS_96_24, "DTS 96/24" },
2616 { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
2617 { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
2618 { FF_PROFILE_UNKNOWN },
2621 static const AVOption options[] = {
2622 { "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 },
2626 static const AVClass dca_decoder_class = {
2627 .class_name = "DCA decoder",
2628 .item_name = av_default_item_name,
2630 .version = LIBAVUTIL_VERSION_INT,
2631 .category = AV_CLASS_CATEGORY_DECODER,
2634 AVCodec ff_dca_decoder = {
2636 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
2637 .type = AVMEDIA_TYPE_AUDIO,
2638 .id = AV_CODEC_ID_DTS,
2639 .priv_data_size = sizeof(DCAContext),
2640 .init = dca_decode_init,
2641 .decode = dca_decode_frame,
2642 .close = dca_decode_end,
2643 .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
2644 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2645 AV_SAMPLE_FMT_NONE },
2646 .profiles = NULL_IF_CONFIG_SMALL(profiles),
2647 .priv_class = &dca_decoder_class,