2 * DCA compatible decoder
3 * Copyright (C) 2004 Gildas Bazin
4 * Copyright (C) 2004 Benjamin Zores
5 * Copyright (C) 2006 Benjamin Larsson
6 * Copyright (C) 2007 Konstantin Shishkov
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29 #include "libavutil/common.h"
30 #include "libavutil/intmath.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavcore/audioconvert.h"
41 #include "synth_filter.h"
46 #define DCA_PRIM_CHANNELS_MAX (7)
47 #define DCA_SUBBANDS (32)
48 #define DCA_ABITS_MAX (32) /* Should be 28 */
49 #define DCA_SUBSUBFRAMES_MAX (4)
50 #define DCA_SUBFRAMES_MAX (16)
51 #define DCA_BLOCKS_MAX (16)
52 #define DCA_LFE_MAX (3)
68 /* these are unconfirmed but should be mostly correct */
69 enum DCAExSSSpeakerMask {
70 DCA_EXSS_FRONT_CENTER = 0x0001,
71 DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002,
72 DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004,
73 DCA_EXSS_LFE = 0x0008,
74 DCA_EXSS_REAR_CENTER = 0x0010,
75 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
76 DCA_EXSS_REAR_LEFT_RIGHT = 0x0040,
77 DCA_EXSS_FRONT_HIGH_CENTER = 0x0080,
78 DCA_EXSS_OVERHEAD = 0x0100,
79 DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200,
80 DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400,
81 DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800,
82 DCA_EXSS_LFE2 = 0x1000,
83 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000,
84 DCA_EXSS_REAR_HIGH_CENTER = 0x4000,
85 DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000,
88 enum DCAExtensionMask {
89 DCA_EXT_CORE = 0x001, ///< core in core substream
90 DCA_EXT_XXCH = 0x002, ///< XXCh channels extension in core substream
91 DCA_EXT_X96 = 0x004, ///< 96/24 extension in core substream
92 DCA_EXT_XCH = 0x008, ///< XCh channel extension in core substream
93 DCA_EXT_EXSS_CORE = 0x010, ///< core in ExSS (extension substream)
94 DCA_EXT_EXSS_XBR = 0x020, ///< extended bitrate extension in ExSS
95 DCA_EXT_EXSS_XXCH = 0x040, ///< XXCh channels extension in ExSS
96 DCA_EXT_EXSS_X96 = 0x080, ///< 96/24 extension in ExSS
97 DCA_EXT_EXSS_LBR = 0x100, ///< low bitrate component in ExSS
98 DCA_EXT_EXSS_XLL = 0x200, ///< lossless extension in ExSS
101 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
102 * Some compromises have been made for special configurations. Most configurations
103 * are never used so complete accuracy is not needed.
105 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
106 * S -> side, when both rear and back are configured move one of them to the side channel
108 * All 2 channel configurations -> CH_LAYOUT_STEREO
111 static const int64_t dca_core_channel_layout[] = {
112 AV_CH_FRONT_CENTER, ///< 1, A
113 AV_CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
114 AV_CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
115 AV_CH_LAYOUT_STEREO, ///< 2, (L+R) + (L-R) (sum-difference)
116 AV_CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total)
117 AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER, ///< 3, C+L+R
118 AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER, ///< 3, L+R+S
119 AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|CH_BACK_CENTER, ///< 4, C + L + R+ S
120 AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 4, L + R +SL+ SR
121 AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
122 AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
123 AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT|AV_CH_FRONT_CENTER|AV_CH_BACK_CENTER, ///< 6, C + L + R+ LR + RR + OV
124 AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_BACK_CENTER|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT, ///< 6, CF+ CR+LF+ RF+LR + RR
125 AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
126 AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2
127 AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_BACK_CENTER|AV_CH_SIDE_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR
130 static const int8_t dca_lfe_index[] = {
131 1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
134 static const int8_t dca_channel_reorder_lfe[][9] = {
135 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
136 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
137 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
138 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
139 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
140 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
141 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
142 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
143 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
144 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
145 { 3, 4, 0, 1, 5, 6, -1, -1, -1},
146 { 2, 0, 1, 4, 5, 6, -1, -1, -1},
147 { 0, 6, 4, 5, 2, 3, -1, -1, -1},
148 { 4, 2, 5, 0, 1, 6, 7, -1, -1},
149 { 5, 6, 0, 1, 7, 3, 8, 4, -1},
150 { 4, 2, 5, 0, 1, 6, 8, 7, -1},
153 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
154 { 0, 2, -1, -1, -1, -1, -1, -1, -1},
155 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
156 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
157 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
158 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
159 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
160 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
161 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
162 { 0, 1, 4, 5, 3, -1, -1, -1, -1},
163 { 2, 0, 1, 5, 6, 4, -1, -1, -1},
164 { 3, 4, 0, 1, 6, 7, 5, -1, -1},
165 { 2, 0, 1, 4, 5, 6, 7, -1, -1},
166 { 0, 6, 4, 5, 2, 3, 7, -1, -1},
167 { 4, 2, 5, 0, 1, 7, 8, 6, -1},
168 { 5, 6, 0, 1, 8, 3, 9, 4, 7},
169 { 4, 2, 5, 0, 1, 6, 9, 8, 7},
172 static const int8_t dca_channel_reorder_nolfe[][9] = {
173 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
174 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
175 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
176 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
177 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
178 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
179 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
180 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
181 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
182 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
183 { 2, 3, 0, 1, 4, 5, -1, -1, -1},
184 { 2, 0, 1, 3, 4, 5, -1, -1, -1},
185 { 0, 5, 3, 4, 1, 2, -1, -1, -1},
186 { 3, 2, 4, 0, 1, 5, 6, -1, -1},
187 { 4, 5, 0, 1, 6, 2, 7, 3, -1},
188 { 3, 2, 4, 0, 1, 5, 7, 6, -1},
191 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
192 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
193 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
194 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
195 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
196 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
197 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
198 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
199 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
200 { 0, 1, 3, 4, 2, -1, -1, -1, -1},
201 { 2, 0, 1, 4, 5, 3, -1, -1, -1},
202 { 2, 3, 0, 1, 5, 6, 4, -1, -1},
203 { 2, 0, 1, 3, 4, 5, 6, -1, -1},
204 { 0, 5, 3, 4, 1, 2, 6, -1, -1},
205 { 3, 2, 4, 0, 1, 6, 7, 5, -1},
206 { 4, 5, 0, 1, 7, 2, 8, 3, 6},
207 { 3, 2, 4, 0, 1, 5, 8, 7, 6},
210 #define DCA_DOLBY 101 /* FIXME */
212 #define DCA_CHANNEL_BITS 6
213 #define DCA_CHANNEL_MASK 0x3F
217 #define HEADER_SIZE 14
219 #define DCA_MAX_FRAME_SIZE 16384
220 #define DCA_MAX_EXSS_HEADER_SIZE 4096
222 #define DCA_BUFFER_PADDING_SIZE 1024
224 /** Bit allocation */
226 int offset; ///< code values offset
227 int maxbits[8]; ///< max bits in VLC
228 int wrap; ///< wrap for get_vlc2()
229 VLC vlc[8]; ///< actual codes
232 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
233 static BitAlloc dca_tmode; ///< transition mode VLCs
234 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
235 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
237 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
239 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
243 AVCodecContext *avctx;
245 int frame_type; ///< type of the current frame
246 int samples_deficit; ///< deficit sample count
247 int crc_present; ///< crc is present in the bitstream
248 int sample_blocks; ///< number of PCM sample blocks
249 int frame_size; ///< primary frame byte size
250 int amode; ///< audio channels arrangement
251 int sample_rate; ///< audio sampling rate
252 int bit_rate; ///< transmission bit rate
253 int bit_rate_index; ///< transmission bit rate index
255 int downmix; ///< embedded downmix enabled
256 int dynrange; ///< embedded dynamic range flag
257 int timestamp; ///< embedded time stamp flag
258 int aux_data; ///< auxiliary data flag
259 int hdcd; ///< source material is mastered in HDCD
260 int ext_descr; ///< extension audio descriptor flag
261 int ext_coding; ///< extended coding flag
262 int aspf; ///< audio sync word insertion flag
263 int lfe; ///< low frequency effects flag
264 int predictor_history; ///< predictor history flag
265 int header_crc; ///< header crc check bytes
266 int multirate_inter; ///< multirate interpolator switch
267 int version; ///< encoder software revision
268 int copy_history; ///< copy history
269 int source_pcm_res; ///< source pcm resolution
270 int front_sum; ///< front sum/difference flag
271 int surround_sum; ///< surround sum/difference flag
272 int dialog_norm; ///< dialog normalisation parameter
274 /* Primary audio coding header */
275 int subframes; ///< number of subframes
276 int is_channels_set; ///< check for if the channel number is already set
277 int total_channels; ///< number of channels including extensions
278 int prim_channels; ///< number of primary audio channels
279 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
280 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
281 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
282 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
283 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
284 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
285 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
286 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
288 /* Primary audio coding side information */
289 int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
290 int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
291 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
292 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
293 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
294 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
295 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
296 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
297 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
298 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
299 int dynrange_coef; ///< dynamic range coefficient
301 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
303 float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
304 int lfe_scale_factor;
306 /* Subband samples history (for ADPCM) */
307 float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
308 DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
309 DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
310 int hist_index[DCA_PRIM_CHANNELS_MAX];
311 DECLARE_ALIGNED(16, float, raXin)[32];
313 int output; ///< type of output
314 float scale_bias; ///< output scale
316 DECLARE_ALIGNED(16, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
317 DECLARE_ALIGNED(16, float, samples)[(DCA_PRIM_CHANNELS_MAX+1)*256];
318 const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX+1];
320 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
321 int dca_buffer_size; ///< how much data is in the dca_buffer
323 const int8_t* channel_order_tab; ///< channel reordering table, lfe and non lfe
325 /* Current position in DCA frame */
326 int current_subframe;
327 int current_subsubframe;
329 /* XCh extension information */
331 int xch_base_channel; ///< index of first (only) channel containing XCH data
333 /* Other detected extensions in the core substream */
337 /* ExSS header parser */
338 int static_fields; ///< static fields present
339 int mix_metadata; ///< mixing metadata present
340 int num_mix_configs; ///< number of mix out configurations
341 int mix_config_num_ch[4]; ///< number of channels in each mix out configuration
345 int debug_flag; ///< used for suppressing repeated error messages output
348 SynthFilterContext synth;
349 DCADSPContext dcadsp;
352 static const uint16_t dca_vlc_offs[] = {
353 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
354 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
355 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
356 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
357 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
358 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
361 static av_cold void dca_init_vlcs(void)
363 static int vlcs_initialized = 0;
365 static VLC_TYPE dca_table[23622][2];
367 if (vlcs_initialized)
370 dca_bitalloc_index.offset = 1;
371 dca_bitalloc_index.wrap = 2;
372 for (i = 0; i < 5; i++) {
373 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
374 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
375 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
376 bitalloc_12_bits[i], 1, 1,
377 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
379 dca_scalefactor.offset = -64;
380 dca_scalefactor.wrap = 2;
381 for (i = 0; i < 5; i++) {
382 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
383 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
384 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
385 scales_bits[i], 1, 1,
386 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
388 dca_tmode.offset = 0;
390 for (i = 0; i < 4; i++) {
391 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
392 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
393 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
395 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
398 for (i = 0; i < 10; i++)
399 for (j = 0; j < 7; j++){
400 if (!bitalloc_codes[i][j]) break;
401 dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
402 dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
403 dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
404 dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
405 init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
407 bitalloc_bits[i][j], 1, 1,
408 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
411 vlcs_initialized = 1;
414 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
417 *dst++ = get_bits(gb, bits);
420 static int dca_parse_audio_coding_header(DCAContext * s, int base_channel)
423 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
424 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
425 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
427 s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
428 s->prim_channels = s->total_channels;
430 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
431 s->prim_channels = DCA_PRIM_CHANNELS_MAX;
434 for (i = base_channel; i < s->prim_channels; i++) {
435 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
436 if (s->subband_activity[i] > DCA_SUBBANDS)
437 s->subband_activity[i] = DCA_SUBBANDS;
439 for (i = base_channel; i < s->prim_channels; i++) {
440 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
441 if (s->vq_start_subband[i] > DCA_SUBBANDS)
442 s->vq_start_subband[i] = DCA_SUBBANDS;
444 get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
445 get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
446 get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
447 get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
449 /* Get codebooks quantization indexes */
451 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
452 for (j = 1; j < 11; j++)
453 for (i = base_channel; i < s->prim_channels; i++)
454 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
456 /* Get scale factor adjustment */
457 for (j = 0; j < 11; j++)
458 for (i = base_channel; i < s->prim_channels; i++)
459 s->scalefactor_adj[i][j] = 1;
461 for (j = 1; j < 11; j++)
462 for (i = base_channel; i < s->prim_channels; i++)
463 if (s->quant_index_huffman[i][j] < thr[j])
464 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
466 if (s->crc_present) {
467 /* Audio header CRC check */
468 get_bits(&s->gb, 16);
471 s->current_subframe = 0;
472 s->current_subsubframe = 0;
475 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
476 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
477 for (i = base_channel; i < s->prim_channels; i++){
478 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
479 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
480 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
481 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
482 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
483 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
484 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
485 for (j = 0; j < 11; j++)
486 av_log(s->avctx, AV_LOG_DEBUG, " %i",
487 s->quant_index_huffman[i][j]);
488 av_log(s->avctx, AV_LOG_DEBUG, "\n");
489 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
490 for (j = 0; j < 11; j++)
491 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
492 av_log(s->avctx, AV_LOG_DEBUG, "\n");
499 static int dca_parse_frame_header(DCAContext * s)
501 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
504 get_bits(&s->gb, 32);
507 s->frame_type = get_bits(&s->gb, 1);
508 s->samples_deficit = get_bits(&s->gb, 5) + 1;
509 s->crc_present = get_bits(&s->gb, 1);
510 s->sample_blocks = get_bits(&s->gb, 7) + 1;
511 s->frame_size = get_bits(&s->gb, 14) + 1;
512 if (s->frame_size < 95)
514 s->amode = get_bits(&s->gb, 6);
515 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
518 s->bit_rate_index = get_bits(&s->gb, 5);
519 s->bit_rate = dca_bit_rates[s->bit_rate_index];
523 s->downmix = get_bits(&s->gb, 1);
524 s->dynrange = get_bits(&s->gb, 1);
525 s->timestamp = get_bits(&s->gb, 1);
526 s->aux_data = get_bits(&s->gb, 1);
527 s->hdcd = get_bits(&s->gb, 1);
528 s->ext_descr = get_bits(&s->gb, 3);
529 s->ext_coding = get_bits(&s->gb, 1);
530 s->aspf = get_bits(&s->gb, 1);
531 s->lfe = get_bits(&s->gb, 2);
532 s->predictor_history = get_bits(&s->gb, 1);
534 /* TODO: check CRC */
536 s->header_crc = get_bits(&s->gb, 16);
538 s->multirate_inter = get_bits(&s->gb, 1);
539 s->version = get_bits(&s->gb, 4);
540 s->copy_history = get_bits(&s->gb, 2);
541 s->source_pcm_res = get_bits(&s->gb, 3);
542 s->front_sum = get_bits(&s->gb, 1);
543 s->surround_sum = get_bits(&s->gb, 1);
544 s->dialog_norm = get_bits(&s->gb, 4);
546 /* FIXME: channels mixing levels */
547 s->output = s->amode;
548 if (s->lfe) s->output |= DCA_LFE;
551 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
552 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
553 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
554 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
555 s->sample_blocks, s->sample_blocks * 32);
556 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
557 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
558 s->amode, dca_channels[s->amode]);
559 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
561 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
563 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
564 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
565 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
566 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
567 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
568 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
569 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
570 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
571 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
572 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
573 s->predictor_history);
574 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
575 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
577 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
578 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
579 av_log(s->avctx, AV_LOG_DEBUG,
580 "source pcm resolution: %i (%i bits/sample)\n",
581 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
582 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
583 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
584 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
585 av_log(s->avctx, AV_LOG_DEBUG, "\n");
588 /* Primary audio coding header */
589 s->subframes = get_bits(&s->gb, 4) + 1;
591 return dca_parse_audio_coding_header(s, 0);
595 static inline int get_scale(GetBitContext *gb, int level, int value)
598 /* huffman encoded */
599 value += get_bitalloc(gb, &dca_scalefactor, level);
600 } else if (level < 8)
601 value = get_bits(gb, level + 1);
605 static int dca_subframe_header(DCAContext * s, int base_channel, int block_index)
607 /* Primary audio coding side information */
610 if (get_bits_left(&s->gb) < 0)
614 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
615 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
618 for (j = base_channel; j < s->prim_channels; j++) {
619 for (k = 0; k < s->subband_activity[j]; k++)
620 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
623 /* Get prediction codebook */
624 for (j = base_channel; j < s->prim_channels; j++) {
625 for (k = 0; k < s->subband_activity[j]; k++) {
626 if (s->prediction_mode[j][k] > 0) {
627 /* (Prediction coefficient VQ address) */
628 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
633 /* Bit allocation index */
634 for (j = base_channel; j < s->prim_channels; j++) {
635 for (k = 0; k < s->vq_start_subband[j]; k++) {
636 if (s->bitalloc_huffman[j] == 6)
637 s->bitalloc[j][k] = get_bits(&s->gb, 5);
638 else if (s->bitalloc_huffman[j] == 5)
639 s->bitalloc[j][k] = get_bits(&s->gb, 4);
640 else if (s->bitalloc_huffman[j] == 7) {
641 av_log(s->avctx, AV_LOG_ERROR,
642 "Invalid bit allocation index\n");
646 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
649 if (s->bitalloc[j][k] > 26) {
650 // av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
651 // j, k, s->bitalloc[j][k]);
657 /* Transition mode */
658 for (j = base_channel; j < s->prim_channels; j++) {
659 for (k = 0; k < s->subband_activity[j]; k++) {
660 s->transition_mode[j][k] = 0;
661 if (s->subsubframes[s->current_subframe] > 1 &&
662 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
663 s->transition_mode[j][k] =
664 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
669 if (get_bits_left(&s->gb) < 0)
672 for (j = base_channel; j < s->prim_channels; j++) {
673 const uint32_t *scale_table;
676 memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
678 if (s->scalefactor_huffman[j] == 6)
679 scale_table = scale_factor_quant7;
681 scale_table = scale_factor_quant6;
683 /* When huffman coded, only the difference is encoded */
686 for (k = 0; k < s->subband_activity[j]; k++) {
687 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
688 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
689 s->scale_factor[j][k][0] = scale_table[scale_sum];
692 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
693 /* Get second scale factor */
694 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
695 s->scale_factor[j][k][1] = scale_table[scale_sum];
700 /* Joint subband scale factor codebook select */
701 for (j = base_channel; j < s->prim_channels; j++) {
702 /* Transmitted only if joint subband coding enabled */
703 if (s->joint_intensity[j] > 0)
704 s->joint_huff[j] = get_bits(&s->gb, 3);
707 if (get_bits_left(&s->gb) < 0)
710 /* Scale factors for joint subband coding */
711 for (j = base_channel; j < s->prim_channels; j++) {
714 /* Transmitted only if joint subband coding enabled */
715 if (s->joint_intensity[j] > 0) {
717 source_channel = s->joint_intensity[j] - 1;
719 /* When huffman coded, only the difference is encoded
720 * (is this valid as well for joint scales ???) */
722 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
723 scale = get_scale(&s->gb, s->joint_huff[j], 0);
724 scale += 64; /* bias */
725 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
728 if (!(s->debug_flag & 0x02)) {
729 av_log(s->avctx, AV_LOG_DEBUG,
730 "Joint stereo coding not supported\n");
731 s->debug_flag |= 0x02;
736 /* Stereo downmix coefficients */
737 if (!base_channel && s->prim_channels > 2) {
739 for (j = base_channel; j < s->prim_channels; j++) {
740 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
741 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
744 int am = s->amode & DCA_CHANNEL_MASK;
745 for (j = base_channel; j < s->prim_channels; j++) {
746 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
747 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
752 /* Dynamic range coefficient */
753 if (!base_channel && s->dynrange)
754 s->dynrange_coef = get_bits(&s->gb, 8);
756 /* Side information CRC check word */
757 if (s->crc_present) {
758 get_bits(&s->gb, 16);
762 * Primary audio data arrays
765 /* VQ encoded high frequency subbands */
766 for (j = base_channel; j < s->prim_channels; j++)
767 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
768 /* 1 vector -> 32 samples */
769 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
771 /* Low frequency effect data */
772 if (!base_channel && s->lfe) {
774 int lfe_samples = 2 * s->lfe * (4 + block_index);
775 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
778 for (j = lfe_samples; j < lfe_end_sample; j++) {
779 /* Signed 8 bits int */
780 s->lfe_data[j] = get_sbits(&s->gb, 8);
783 /* Scale factor index */
784 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
786 /* Quantization step size * scale factor */
787 lfe_scale = 0.035 * s->lfe_scale_factor;
789 for (j = lfe_samples; j < lfe_end_sample; j++)
790 s->lfe_data[j] *= lfe_scale;
794 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes[s->current_subframe]);
795 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
796 s->partial_samples[s->current_subframe]);
797 for (j = base_channel; j < s->prim_channels; j++) {
798 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
799 for (k = 0; k < s->subband_activity[j]; k++)
800 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
801 av_log(s->avctx, AV_LOG_DEBUG, "\n");
803 for (j = base_channel; j < s->prim_channels; j++) {
804 for (k = 0; k < s->subband_activity[j]; k++)
805 av_log(s->avctx, AV_LOG_DEBUG,
806 "prediction coefs: %f, %f, %f, %f\n",
807 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
808 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
809 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
810 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
812 for (j = base_channel; j < s->prim_channels; j++) {
813 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
814 for (k = 0; k < s->vq_start_subband[j]; k++)
815 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
816 av_log(s->avctx, AV_LOG_DEBUG, "\n");
818 for (j = base_channel; j < s->prim_channels; j++) {
819 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
820 for (k = 0; k < s->subband_activity[j]; k++)
821 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
822 av_log(s->avctx, AV_LOG_DEBUG, "\n");
824 for (j = base_channel; j < s->prim_channels; j++) {
825 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
826 for (k = 0; k < s->subband_activity[j]; k++) {
827 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
828 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
829 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
830 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
832 av_log(s->avctx, AV_LOG_DEBUG, "\n");
834 for (j = base_channel; j < s->prim_channels; j++) {
835 if (s->joint_intensity[j] > 0) {
836 int source_channel = s->joint_intensity[j] - 1;
837 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
838 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
839 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
840 av_log(s->avctx, AV_LOG_DEBUG, "\n");
843 if (!base_channel && s->prim_channels > 2 && s->downmix) {
844 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
845 for (j = 0; j < s->prim_channels; j++) {
846 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
847 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
849 av_log(s->avctx, AV_LOG_DEBUG, "\n");
851 for (j = base_channel; j < s->prim_channels; j++)
852 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
853 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
854 if (!base_channel && s->lfe) {
855 int lfe_samples = 2 * s->lfe * (4 + block_index);
856 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
858 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
859 for (j = lfe_samples; j < lfe_end_sample; j++)
860 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
861 av_log(s->avctx, AV_LOG_DEBUG, "\n");
868 static void qmf_32_subbands(DCAContext * s, int chans,
869 float samples_in[32][8], float *samples_out,
872 const float *prCoeff;
875 int sb_act = s->subband_activity[chans];
878 scale *= sqrt(1/8.0);
881 if (!s->multirate_inter) /* Non-perfect reconstruction */
882 prCoeff = fir_32bands_nonperfect;
883 else /* Perfect reconstruction */
884 prCoeff = fir_32bands_perfect;
886 /* Reconstructed channel sample index */
887 for (subindex = 0; subindex < 8; subindex++) {
888 /* Load in one sample from each subband and clear inactive subbands */
889 for (i = 0; i < sb_act; i++){
890 uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
891 AV_WN32A(&s->raXin[i], v);
896 s->synth.synth_filter_float(&s->imdct,
897 s->subband_fir_hist[chans], &s->hist_index[chans],
898 s->subband_fir_noidea[chans], prCoeff,
899 samples_out, s->raXin, scale, 0);
905 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
906 int num_deci_sample, float *samples_in,
907 float *samples_out, float scale)
909 /* samples_in: An array holding decimated samples.
910 * Samples in current subframe starts from samples_in[0],
911 * while samples_in[-1], samples_in[-2], ..., stores samples
912 * from last subframe as history.
914 * samples_out: An array holding interpolated samples
918 const float *prCoeff;
921 /* Select decimation filter */
922 if (decimation_select == 1) {
924 prCoeff = lfe_fir_128;
927 prCoeff = lfe_fir_64;
930 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
931 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
934 samples_out += 2 * decifactor;
938 /* downmixing routines */
939 #define MIX_REAR1(samples, si1, rs, coef) \
940 samples[i] += samples[si1] * coef[rs][0]; \
941 samples[i+256] += samples[si1] * coef[rs][1];
943 #define MIX_REAR2(samples, si1, si2, rs, coef) \
944 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
945 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
947 #define MIX_FRONT3(samples, coef) \
951 samples[i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
952 samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
954 #define DOWNMIX_TO_STEREO(op1, op2) \
955 for (i = 0; i < 256; i++){ \
960 static void dca_downmix(float *samples, int srcfmt,
961 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
962 const int8_t *channel_mapping)
967 float coef[DCA_PRIM_CHANNELS_MAX][2];
969 for (i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
970 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
971 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
977 case DCA_STEREO_TOTAL:
978 case DCA_STEREO_SUMDIFF:
980 av_log(NULL, 0, "Not implemented!\n");
985 c = channel_mapping[0] * 256;
986 l = channel_mapping[1] * 256;
987 r = channel_mapping[2] * 256;
988 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
991 s = channel_mapping[2] * 256;
992 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef),);
995 c = channel_mapping[0] * 256;
996 l = channel_mapping[1] * 256;
997 r = channel_mapping[2] * 256;
998 s = channel_mapping[3] * 256;
999 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1000 MIX_REAR1(samples, i + s, 3, coef));
1003 sl = channel_mapping[2] * 256;
1004 sr = channel_mapping[3] * 256;
1005 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef),);
1008 c = channel_mapping[0] * 256;
1009 l = channel_mapping[1] * 256;
1010 r = channel_mapping[2] * 256;
1011 sl = channel_mapping[3] * 256;
1012 sr = channel_mapping[4] * 256;
1013 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1014 MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1020 /* Very compact version of the block code decoder that does not use table
1021 * look-up but is slightly slower */
1022 static int decode_blockcode(int code, int levels, int *values)
1025 int offset = (levels - 1) >> 1;
1027 for (i = 0; i < 4; i++) {
1028 int div = FASTDIV(code, levels);
1029 values[i] = code - offset - div*levels;
1036 av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
1041 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1042 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1044 static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
1047 int subsubframe = s->current_subsubframe;
1049 const float *quant_step_table;
1052 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1053 LOCAL_ALIGNED_16(int, block, [8]);
1059 /* Select quantization step size table */
1060 if (s->bit_rate_index == 0x1f)
1061 quant_step_table = lossless_quant_d;
1063 quant_step_table = lossy_quant_d;
1065 for (k = base_channel; k < s->prim_channels; k++) {
1066 if (get_bits_left(&s->gb) < 0)
1069 for (l = 0; l < s->vq_start_subband[k]; l++) {
1072 /* Select the mid-tread linear quantizer */
1073 int abits = s->bitalloc[k][l];
1075 float quant_step_size = quant_step_table[abits];
1078 * Determine quantization index code book and its type
1081 /* Select quantization index code book */
1082 int sel = s->quant_index_huffman[k][abits];
1085 * Extract bits from the bit stream
1088 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1090 /* Deal with transients */
1091 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1092 float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
1094 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
1097 int block_code1, block_code2, size, levels;
1099 size = abits_sizes[abits-1];
1100 levels = abits_levels[abits-1];
1102 block_code1 = get_bits(&s->gb, size);
1103 /* FIXME Should test return value */
1104 decode_blockcode(block_code1, levels, block);
1105 block_code2 = get_bits(&s->gb, size);
1106 decode_blockcode(block_code2, levels, &block[4]);
1109 for (m = 0; m < 8; m++)
1110 block[m] = get_sbits(&s->gb, abits - 3);
1114 for (m = 0; m < 8; m++)
1115 block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1118 s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
1123 * Inverse ADPCM if in prediction mode
1125 if (s->prediction_mode[k][l]) {
1127 for (m = 0; m < 8; m++) {
1128 for (n = 1; n <= 4; n++)
1130 subband_samples[k][l][m] +=
1131 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1132 subband_samples[k][l][m - n] / 8192);
1133 else if (s->predictor_history)
1134 subband_samples[k][l][m] +=
1135 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1136 s->subband_samples_hist[k][l][m - n +
1143 * Decode VQ encoded high frequencies
1145 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1146 /* 1 vector -> 32 samples but we only need the 8 samples
1147 * for this subsubframe. */
1150 if (!s->debug_flag & 0x01) {
1151 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1152 s->debug_flag |= 0x01;
1155 for (m = 0; m < 8; m++) {
1156 subband_samples[k][l][m] =
1157 high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1159 * (float) s->scale_factor[k][l][0] / 16.0;
1164 /* Check for DSYNC after subsubframe */
1165 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1166 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1168 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1171 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1175 /* Backup predictor history for adpcm */
1176 for (k = base_channel; k < s->prim_channels; k++)
1177 for (l = 0; l < s->vq_start_subband[k]; l++)
1178 memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1179 4 * sizeof(subband_samples[0][0][0]));
1184 static int dca_filter_channels(DCAContext * s, int block_index)
1186 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1189 /* 32 subbands QMF */
1190 for (k = 0; k < s->prim_channels; k++) {
1191 /* static float pcm_to_double[8] =
1192 {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1193 qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1194 M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ );
1198 if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1199 dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
1202 /* Generate LFE samples for this subsubframe FIXME!!! */
1203 if (s->output & DCA_LFE) {
1204 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1205 s->lfe_data + 2 * s->lfe * (block_index + 4),
1206 &s->samples[256 * dca_lfe_index[s->amode]],
1207 (1.0/256.0)*s->scale_bias);
1208 /* Outputs 20bits pcm samples */
1215 static int dca_subframe_footer(DCAContext * s, int base_channel)
1217 int aux_data_count = 0, i;
1220 * Unpack optional information
1223 /* presumably optional information only appears in the core? */
1224 if (!base_channel) {
1226 get_bits(&s->gb, 32);
1229 aux_data_count = get_bits(&s->gb, 6);
1231 for (i = 0; i < aux_data_count; i++)
1232 get_bits(&s->gb, 8);
1234 if (s->crc_present && (s->downmix || s->dynrange))
1235 get_bits(&s->gb, 16);
1242 * Decode a dca frame block
1244 * @param s pointer to the DCAContext
1247 static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1251 if (s->current_subframe >= s->subframes) {
1252 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1253 s->current_subframe, s->subframes);
1257 if (!s->current_subsubframe) {
1259 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1261 /* Read subframe header */
1262 if (dca_subframe_header(s, base_channel, block_index))
1266 /* Read subsubframe */
1268 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1270 if (dca_subsubframe(s, base_channel, block_index))
1274 s->current_subsubframe++;
1275 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1276 s->current_subsubframe = 0;
1277 s->current_subframe++;
1279 if (s->current_subframe >= s->subframes) {
1281 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1283 /* Read subframe footer */
1284 if (dca_subframe_footer(s, base_channel))
1292 * Convert bitstream to one representation based on sync marker
1294 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1299 const uint16_t *ssrc = (const uint16_t *) src;
1300 uint16_t *sdst = (uint16_t *) dst;
1303 if ((unsigned)src_size > (unsigned)max_size) {
1304 // av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1306 src_size = max_size;
1311 case DCA_MARKER_RAW_BE:
1312 memcpy(dst, src, src_size);
1314 case DCA_MARKER_RAW_LE:
1315 for (i = 0; i < (src_size + 1) >> 1; i++)
1316 *sdst++ = av_bswap16(*ssrc++);
1318 case DCA_MARKER_14B_BE:
1319 case DCA_MARKER_14B_LE:
1320 init_put_bits(&pb, dst, max_size);
1321 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1322 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1323 put_bits(&pb, 14, tmp);
1325 flush_put_bits(&pb);
1326 return (put_bits_count(&pb) + 7) >> 3;
1333 * Return the number of channels in an ExSS speaker mask (HD)
1335 static int dca_exss_mask2count(int mask)
1337 /* count bits that mean speaker pairs twice */
1338 return av_popcount(mask)
1339 + av_popcount(mask & (
1340 DCA_EXSS_CENTER_LEFT_RIGHT
1341 | DCA_EXSS_FRONT_LEFT_RIGHT
1342 | DCA_EXSS_FRONT_HIGH_LEFT_RIGHT
1343 | DCA_EXSS_WIDE_LEFT_RIGHT
1344 | DCA_EXSS_SIDE_LEFT_RIGHT
1345 | DCA_EXSS_SIDE_HIGH_LEFT_RIGHT
1346 | DCA_EXSS_SIDE_REAR_LEFT_RIGHT
1347 | DCA_EXSS_REAR_LEFT_RIGHT
1348 | DCA_EXSS_REAR_HIGH_LEFT_RIGHT
1353 * Skip mixing coefficients of a single mix out configuration (HD)
1355 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1357 for (int i = 0; i < channels; i++) {
1358 int mix_map_mask = get_bits(gb, out_ch);
1359 int num_coeffs = av_popcount(mix_map_mask);
1360 skip_bits_long(gb, num_coeffs * 6);
1365 * Parse extension substream asset header (HD)
1367 static int dca_exss_parse_asset_header(DCAContext *s)
1369 int header_pos = get_bits_count(&s->gb);
1372 int embedded_stereo = 0;
1373 int embedded_6ch = 0;
1374 int drc_code_present;
1375 int extensions_mask;
1378 if (get_bits_left(&s->gb) < 16)
1381 /* We will parse just enough to get to the extensions bitmask with which
1382 * we can set the profile value. */
1384 header_size = get_bits(&s->gb, 9) + 1;
1385 skip_bits(&s->gb, 3); // asset index
1387 if (s->static_fields) {
1388 if (get_bits1(&s->gb))
1389 skip_bits(&s->gb, 4); // asset type descriptor
1390 if (get_bits1(&s->gb))
1391 skip_bits_long(&s->gb, 24); // language descriptor
1393 if (get_bits1(&s->gb)) {
1394 /* How can one fit 1024 bytes of text here if the maximum value
1395 * for the asset header size field above was 512 bytes? */
1396 int text_length = get_bits(&s->gb, 10) + 1;
1397 if (get_bits_left(&s->gb) < text_length * 8)
1399 skip_bits_long(&s->gb, text_length * 8); // info text
1402 skip_bits(&s->gb, 5); // bit resolution - 1
1403 skip_bits(&s->gb, 4); // max sample rate code
1404 channels = get_bits(&s->gb, 8) + 1;
1406 if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1407 int spkr_remap_sets;
1408 int spkr_mask_size = 16;
1412 embedded_stereo = get_bits1(&s->gb);
1414 embedded_6ch = get_bits1(&s->gb);
1416 if (get_bits1(&s->gb)) {
1417 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1418 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1421 spkr_remap_sets = get_bits(&s->gb, 3);
1423 for (i = 0; i < spkr_remap_sets; i++) {
1424 /* std layout mask for each remap set */
1425 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1428 for (i = 0; i < spkr_remap_sets; i++) {
1429 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1430 if (get_bits_left(&s->gb) < 0)
1433 for (j = 0; j < num_spkrs[i]; j++) {
1434 int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1435 int num_dec_ch = av_popcount(remap_dec_ch_mask);
1436 skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1441 skip_bits(&s->gb, 3); // representation type
1445 drc_code_present = get_bits1(&s->gb);
1446 if (drc_code_present)
1447 get_bits(&s->gb, 8); // drc code
1449 if (get_bits1(&s->gb))
1450 skip_bits(&s->gb, 5); // dialog normalization code
1452 if (drc_code_present && embedded_stereo)
1453 get_bits(&s->gb, 8); // drc stereo code
1455 if (s->mix_metadata && get_bits1(&s->gb)) {
1456 skip_bits(&s->gb, 1); // external mix
1457 skip_bits(&s->gb, 6); // post mix gain code
1459 if (get_bits(&s->gb, 2) != 3) // mixer drc code
1460 skip_bits(&s->gb, 3); // drc limit
1462 skip_bits(&s->gb, 8); // custom drc code
1464 if (get_bits1(&s->gb)) // channel specific scaling
1465 for (i = 0; i < s->num_mix_configs; i++)
1466 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1468 skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1470 for (i = 0; i < s->num_mix_configs; i++) {
1471 if (get_bits_left(&s->gb) < 0)
1473 dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1475 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1476 if (embedded_stereo)
1477 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1481 switch (get_bits(&s->gb, 2)) {
1482 case 0: extensions_mask = get_bits(&s->gb, 12); break;
1483 case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1484 case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1485 case 3: extensions_mask = 0; /* aux coding */ break;
1488 /* not parsed further, we were only interested in the extensions mask */
1490 if (get_bits_left(&s->gb) < 0)
1493 if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1494 av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1497 skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1499 if (extensions_mask & DCA_EXT_EXSS_XLL)
1500 s->profile = FF_PROFILE_DTS_HD_MA;
1501 else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1503 s->profile = FF_PROFILE_DTS_HD_HRA;
1505 if (!(extensions_mask & DCA_EXT_CORE))
1506 av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1507 if (!!(extensions_mask & DCA_EXT_XCH) != s->xch_present)
1508 av_log(s->avctx, AV_LOG_WARNING, "DTS XCh detection mismatch.\n");
1509 if (!!(extensions_mask & DCA_EXT_XXCH) != s->xxch_present)
1510 av_log(s->avctx, AV_LOG_WARNING, "DTS XXCh detection mismatch.\n");
1511 if (!!(extensions_mask & DCA_EXT_X96) != s->x96_present)
1512 av_log(s->avctx, AV_LOG_WARNING, "DTS X96 detection mismatch.\n");
1518 * Parse extension substream header (HD)
1520 static void dca_exss_parse_header(DCAContext *s)
1528 int active_ss_mask[8];
1531 if (get_bits_left(&s->gb) < 52)
1534 skip_bits(&s->gb, 8); // user data
1535 ss_index = get_bits(&s->gb, 2);
1537 blownup = get_bits1(&s->gb);
1538 header_size = get_bits(&s->gb, 8 + 4 * blownup) + 1;
1539 hd_size = get_bits_long(&s->gb, 16 + 4 * blownup) + 1;
1541 s->static_fields = get_bits1(&s->gb);
1542 if (s->static_fields) {
1543 skip_bits(&s->gb, 2); // reference clock code
1544 skip_bits(&s->gb, 3); // frame duration code
1546 if (get_bits1(&s->gb))
1547 skip_bits_long(&s->gb, 36); // timestamp
1549 /* a single stream can contain multiple audio assets that can be
1550 * combined to form multiple audio presentations */
1552 num_audiop = get_bits(&s->gb, 3) + 1;
1553 if (num_audiop > 1) {
1554 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1555 /* ignore such streams for now */
1559 num_assets = get_bits(&s->gb, 3) + 1;
1560 if (num_assets > 1) {
1561 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1562 /* ignore such streams for now */
1566 for (i = 0; i < num_audiop; i++)
1567 active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1569 for (i = 0; i < num_audiop; i++)
1570 for (j = 0; j <= ss_index; j++)
1571 if (active_ss_mask[i] & (1 << j))
1572 skip_bits(&s->gb, 8); // active asset mask
1574 s->mix_metadata = get_bits1(&s->gb);
1575 if (s->mix_metadata) {
1576 int mix_out_mask_size;
1578 skip_bits(&s->gb, 2); // adjustment level
1579 mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1580 s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1582 for (i = 0; i < s->num_mix_configs; i++) {
1583 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1584 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1589 for (i = 0; i < num_assets; i++)
1590 skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1592 for (i = 0; i < num_assets; i++) {
1593 if (dca_exss_parse_asset_header(s))
1597 /* not parsed further, we were only interested in the extensions mask
1598 * from the asset header */
1602 * Main frame decoding function
1603 * FIXME add arguments
1605 static int dca_decode_frame(AVCodecContext * avctx,
1606 void *data, int *data_size,
1609 const uint8_t *buf = avpkt->data;
1610 int buf_size = avpkt->size;
1613 int num_core_channels = 0;
1615 int16_t *samples = data;
1616 DCAContext *s = avctx->priv_data;
1623 s->xxch_present = 0;
1625 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1626 DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1627 if (s->dca_buffer_size == -1) {
1628 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1632 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1633 if (dca_parse_frame_header(s) < 0) {
1634 //seems like the frame is corrupt, try with the next one
1638 //set AVCodec values with parsed data
1639 avctx->sample_rate = s->sample_rate;
1640 avctx->bit_rate = s->bit_rate;
1642 s->profile = FF_PROFILE_DTS;
1644 for (i = 0; i < (s->sample_blocks / 8); i++) {
1645 dca_decode_block(s, 0, i);
1648 /* record number of core channels incase less than max channels are requested */
1649 num_core_channels = s->prim_channels;
1651 /* extensions start at 32-bit boundaries into bitstream */
1652 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1654 core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1656 while(core_ss_end - get_bits_count(&s->gb) >= 32) {
1657 uint32_t bits = get_bits_long(&s->gb, 32);
1661 int ext_amode, xch_fsize;
1663 s->xch_base_channel = s->prim_channels;
1665 /* validate sync word using XCHFSIZE field */
1666 xch_fsize = show_bits(&s->gb, 10);
1667 if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1668 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1671 /* skip length-to-end-of-frame field for the moment */
1672 skip_bits(&s->gb, 10);
1674 s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1676 /* extension amode should == 1, number of channels in extension */
1677 /* AFAIK XCh is not used for more channels */
1678 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1679 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1680 " supported!\n",ext_amode);
1684 /* much like core primary audio coding header */
1685 dca_parse_audio_coding_header(s, s->xch_base_channel);
1687 for (i = 0; i < (s->sample_blocks / 8); i++) {
1688 dca_decode_block(s, s->xch_base_channel, i);
1695 /* XXCh: extended channels */
1696 /* usually found either in core or HD part in DTS-HD HRA streams,
1697 * but not in DTS-ES which contains XCh extensions instead */
1698 s->xxch_present = 1;
1699 s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1703 int fsize96 = show_bits(&s->gb, 12) + 1;
1704 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1707 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n", get_bits_count(&s->gb));
1708 skip_bits(&s->gb, 12);
1709 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1710 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1713 s->profile = FFMAX(s->profile, FF_PROFILE_DTS_96_24);
1718 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1721 /* check for ExSS (HD part) */
1722 if (s->dca_buffer_size - s->frame_size > 32
1723 && get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1724 dca_exss_parse_header(s);
1726 avctx->profile = s->profile;
1728 channels = s->prim_channels + !!s->lfe;
1731 avctx->channel_layout = dca_core_channel_layout[s->amode];
1733 if (s->xch_present && (!avctx->request_channels ||
1734 avctx->request_channels > num_core_channels + !!s->lfe)) {
1735 avctx->channel_layout |= AV_CH_BACK_CENTER;
1737 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1738 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1740 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1743 channels = num_core_channels + !!s->lfe;
1744 s->xch_present = 0; /* disable further xch processing */
1746 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1747 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1749 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1752 if (channels > !!s->lfe &&
1753 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1756 if (avctx->request_channels == 2 && s->prim_channels > 2) {
1758 s->output = DCA_STEREO;
1759 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1762 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1767 /* There is nothing that prevents a dts frame to change channel configuration
1768 but FFmpeg doesn't support that so only set the channels if it is previously
1769 unset. Ideally during the first probe for channels the crc should be checked
1770 and only set avctx->channels when the crc is ok. Right now the decoder could
1771 set the channels based on a broken first frame.*/
1772 if (s->is_channels_set == 0) {
1773 s->is_channels_set = 1;
1774 avctx->channels = channels;
1776 if (avctx->channels != channels) {
1777 av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
1778 "channels changing in stream. Skipping frame.\n");
1782 if (*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1784 *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1786 /* filter to get final output */
1787 for (i = 0; i < (s->sample_blocks / 8); i++) {
1788 dca_filter_channels(s, i);
1790 /* If this was marked as a DTS-ES stream we need to subtract back- */
1791 /* channel from SL & SR to remove matrixed back-channel signal */
1792 if((s->source_pcm_res & 1) && s->xch_present) {
1793 float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1794 float* lt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1795 float* rt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1797 for(j = 0; j < 256; ++j) {
1798 lt_chan[j] -= back_chan[j] * M_SQRT1_2;
1799 rt_chan[j] -= back_chan[j] * M_SQRT1_2;
1803 s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1804 samples += 256 * channels;
1807 /* update lfe history */
1808 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1809 for (i = 0; i < 2 * s->lfe * 4; i++) {
1810 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1819 * DCA initialization
1821 * @param avctx pointer to the AVCodecContext
1824 static av_cold int dca_decode_init(AVCodecContext * avctx)
1826 DCAContext *s = avctx->priv_data;
1832 dsputil_init(&s->dsp, avctx);
1833 ff_mdct_init(&s->imdct, 6, 1, 1.0);
1834 ff_synth_filter_init(&s->synth);
1835 ff_dcadsp_init(&s->dcadsp);
1837 for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
1838 s->samples_chanptr[i] = s->samples + i * 256;
1839 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1841 s->scale_bias = 1.0;
1843 /* allow downmixing to stereo */
1844 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1845 avctx->request_channels == 2) {
1846 avctx->channels = avctx->request_channels;
1852 static av_cold int dca_decode_end(AVCodecContext * avctx)
1854 DCAContext *s = avctx->priv_data;
1855 ff_mdct_end(&s->imdct);
1859 static const AVProfile profiles[] = {
1860 { FF_PROFILE_DTS, "DTS" },
1861 { FF_PROFILE_DTS_ES, "DTS-ES" },
1862 { FF_PROFILE_DTS_96_24, "DTS 96/24" },
1863 { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1864 { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
1865 { FF_PROFILE_UNKNOWN },
1868 AVCodec ff_dca_decoder = {
1870 .type = AVMEDIA_TYPE_AUDIO,
1872 .priv_data_size = sizeof(DCAContext),
1873 .init = dca_decode_init,
1874 .decode = dca_decode_frame,
1875 .close = dca_decode_end,
1876 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1877 .capabilities = CODEC_CAP_CHANNEL_CONF,
1878 .profiles = NULL_IF_CONFIG_SMALL(profiles),