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/intmath.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavcore/audioconvert.h"
40 #include "synth_filter.h"
45 #define DCA_PRIM_CHANNELS_MAX (7)
46 #define DCA_SUBBANDS (32)
47 #define DCA_ABITS_MAX (32) /* Should be 28 */
48 #define DCA_SUBSUBFRAMES_MAX (4)
49 #define DCA_SUBFRAMES_MAX (16)
50 #define DCA_BLOCKS_MAX (16)
51 #define DCA_LFE_MAX (3)
67 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
68 * Some compromises have been made for special configurations. Most configurations
69 * are never used so complete accuracy is not needed.
71 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
72 * S -> side, when both rear and back are configured move one of them to the side channel
74 * All 2 channel configurations -> CH_LAYOUT_STEREO
77 static const int64_t dca_core_channel_layout[] = {
78 AV_CH_FRONT_CENTER, ///< 1, A
79 AV_CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
80 AV_CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
81 AV_CH_LAYOUT_STEREO, ///< 2, (L+R) + (L-R) (sum-difference)
82 AV_CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total)
83 AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER, ///< 3, C+L+R
84 AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER, ///< 3, L+R+S
85 AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|CH_BACK_CENTER, ///< 4, C + L + R+ S
86 AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 4, L + R +SL+ SR
87 AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
88 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
89 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
90 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
91 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
92 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
93 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
96 static const int8_t dca_lfe_index[] = {
97 1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
100 static const int8_t dca_channel_reorder_lfe[][9] = {
101 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
102 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
103 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
104 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
105 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
106 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
107 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
108 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
109 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
110 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
111 { 3, 4, 0, 1, 5, 6, -1, -1, -1},
112 { 2, 0, 1, 4, 5, 6, -1, -1, -1},
113 { 0, 6, 4, 5, 2, 3, -1, -1, -1},
114 { 4, 2, 5, 0, 1, 6, 7, -1, -1},
115 { 5, 6, 0, 1, 7, 3, 8, 4, -1},
116 { 4, 2, 5, 0, 1, 6, 8, 7, -1},
119 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
120 { 0, 2, -1, -1, -1, -1, -1, -1, -1},
121 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
122 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
123 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
124 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
125 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
126 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
127 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
128 { 0, 1, 4, 5, 3, -1, -1, -1, -1},
129 { 2, 0, 1, 5, 6, 4, -1, -1, -1},
130 { 3, 4, 0, 1, 6, 7, 5, -1, -1},
131 { 2, 0, 1, 4, 5, 6, 7, -1, -1},
132 { 0, 6, 4, 5, 2, 3, 7, -1, -1},
133 { 4, 2, 5, 0, 1, 7, 8, 6, -1},
134 { 5, 6, 0, 1, 8, 3, 9, 4, 7},
135 { 4, 2, 5, 0, 1, 6, 9, 8, 7},
138 static const int8_t dca_channel_reorder_nolfe[][9] = {
139 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
140 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
141 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
142 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
143 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
144 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
145 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
146 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
147 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
148 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
149 { 2, 3, 0, 1, 4, 5, -1, -1, -1},
150 { 2, 0, 1, 3, 4, 5, -1, -1, -1},
151 { 0, 5, 3, 4, 1, 2, -1, -1, -1},
152 { 3, 2, 4, 0, 1, 5, 6, -1, -1},
153 { 4, 5, 0, 1, 6, 2, 7, 3, -1},
154 { 3, 2, 4, 0, 1, 5, 7, 6, -1},
157 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
158 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
159 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
160 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
161 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
162 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
163 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
164 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
165 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
166 { 0, 1, 3, 4, 2, -1, -1, -1, -1},
167 { 2, 0, 1, 4, 5, 3, -1, -1, -1},
168 { 2, 3, 0, 1, 5, 6, 4, -1, -1},
169 { 2, 0, 1, 3, 4, 5, 6, -1, -1},
170 { 0, 5, 3, 4, 1, 2, 6, -1, -1},
171 { 3, 2, 4, 0, 1, 6, 7, 5, -1},
172 { 4, 5, 0, 1, 7, 2, 8, 3, 6},
173 { 3, 2, 4, 0, 1, 5, 8, 7, 6},
176 #define DCA_DOLBY 101 /* FIXME */
178 #define DCA_CHANNEL_BITS 6
179 #define DCA_CHANNEL_MASK 0x3F
183 #define HEADER_SIZE 14
185 #define DCA_MAX_FRAME_SIZE 16384
187 /** Bit allocation */
189 int offset; ///< code values offset
190 int maxbits[8]; ///< max bits in VLC
191 int wrap; ///< wrap for get_vlc2()
192 VLC vlc[8]; ///< actual codes
195 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
196 static BitAlloc dca_tmode; ///< transition mode VLCs
197 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
198 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
200 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
202 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
206 AVCodecContext *avctx;
208 int frame_type; ///< type of the current frame
209 int samples_deficit; ///< deficit sample count
210 int crc_present; ///< crc is present in the bitstream
211 int sample_blocks; ///< number of PCM sample blocks
212 int frame_size; ///< primary frame byte size
213 int amode; ///< audio channels arrangement
214 int sample_rate; ///< audio sampling rate
215 int bit_rate; ///< transmission bit rate
216 int bit_rate_index; ///< transmission bit rate index
218 int downmix; ///< embedded downmix enabled
219 int dynrange; ///< embedded dynamic range flag
220 int timestamp; ///< embedded time stamp flag
221 int aux_data; ///< auxiliary data flag
222 int hdcd; ///< source material is mastered in HDCD
223 int ext_descr; ///< extension audio descriptor flag
224 int ext_coding; ///< extended coding flag
225 int aspf; ///< audio sync word insertion flag
226 int lfe; ///< low frequency effects flag
227 int predictor_history; ///< predictor history flag
228 int header_crc; ///< header crc check bytes
229 int multirate_inter; ///< multirate interpolator switch
230 int version; ///< encoder software revision
231 int copy_history; ///< copy history
232 int source_pcm_res; ///< source pcm resolution
233 int front_sum; ///< front sum/difference flag
234 int surround_sum; ///< surround sum/difference flag
235 int dialog_norm; ///< dialog normalisation parameter
237 /* Primary audio coding header */
238 int subframes; ///< number of subframes
239 int total_channels; ///< number of channels including extensions
240 int prim_channels; ///< number of primary audio channels
241 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
242 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
243 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
244 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
245 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
246 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
247 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
248 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
250 /* Primary audio coding side information */
251 int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
252 int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
253 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
254 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
255 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
256 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
257 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
258 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
259 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
260 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
261 int dynrange_coef; ///< dynamic range coefficient
263 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
265 float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
266 int lfe_scale_factor;
268 /* Subband samples history (for ADPCM) */
269 float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
270 DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
271 DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
272 int hist_index[DCA_PRIM_CHANNELS_MAX];
273 DECLARE_ALIGNED(16, float, raXin)[32];
275 int output; ///< type of output
276 float add_bias; ///< output bias
277 float scale_bias; ///< output scale
279 DECLARE_ALIGNED(16, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
280 DECLARE_ALIGNED(16, float, samples)[(DCA_PRIM_CHANNELS_MAX+1)*256];
281 const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX+1];
283 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
284 int dca_buffer_size; ///< how much data is in the dca_buffer
286 const int8_t* channel_order_tab; ///< channel reordering table, lfe and non lfe
288 /* Current position in DCA frame */
289 int current_subframe;
290 int current_subsubframe;
292 /* XCh extension information */
294 int xch_base_channel; ///< index of first (only) channel containing XCH data
296 int debug_flag; ///< used for suppressing repeated error messages output
299 SynthFilterContext synth;
300 DCADSPContext dcadsp;
303 static const uint16_t dca_vlc_offs[] = {
304 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
305 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
306 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
307 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
308 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
309 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
312 static av_cold void dca_init_vlcs(void)
314 static int vlcs_initialized = 0;
316 static VLC_TYPE dca_table[23622][2];
318 if (vlcs_initialized)
321 dca_bitalloc_index.offset = 1;
322 dca_bitalloc_index.wrap = 2;
323 for (i = 0; i < 5; i++) {
324 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
325 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
326 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
327 bitalloc_12_bits[i], 1, 1,
328 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
330 dca_scalefactor.offset = -64;
331 dca_scalefactor.wrap = 2;
332 for (i = 0; i < 5; i++) {
333 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
334 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
335 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
336 scales_bits[i], 1, 1,
337 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
339 dca_tmode.offset = 0;
341 for (i = 0; i < 4; i++) {
342 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
343 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
344 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
346 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
349 for (i = 0; i < 10; i++)
350 for (j = 0; j < 7; j++){
351 if (!bitalloc_codes[i][j]) break;
352 dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
353 dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
354 dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
355 dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
356 init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
358 bitalloc_bits[i][j], 1, 1,
359 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
362 vlcs_initialized = 1;
365 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
368 *dst++ = get_bits(gb, bits);
371 static int dca_parse_audio_coding_header(DCAContext * s, int base_channel)
374 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
375 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
376 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
378 s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
379 s->prim_channels = s->total_channels;
381 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
382 s->prim_channels = DCA_PRIM_CHANNELS_MAX;
385 for (i = base_channel; i < s->prim_channels; i++) {
386 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
387 if (s->subband_activity[i] > DCA_SUBBANDS)
388 s->subband_activity[i] = DCA_SUBBANDS;
390 for (i = base_channel; i < s->prim_channels; i++) {
391 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
392 if (s->vq_start_subband[i] > DCA_SUBBANDS)
393 s->vq_start_subband[i] = DCA_SUBBANDS;
395 get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
396 get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
397 get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
398 get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
400 /* Get codebooks quantization indexes */
402 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
403 for (j = 1; j < 11; j++)
404 for (i = base_channel; i < s->prim_channels; i++)
405 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
407 /* Get scale factor adjustment */
408 for (j = 0; j < 11; j++)
409 for (i = base_channel; i < s->prim_channels; i++)
410 s->scalefactor_adj[i][j] = 1;
412 for (j = 1; j < 11; j++)
413 for (i = base_channel; i < s->prim_channels; i++)
414 if (s->quant_index_huffman[i][j] < thr[j])
415 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
417 if (s->crc_present) {
418 /* Audio header CRC check */
419 get_bits(&s->gb, 16);
422 s->current_subframe = 0;
423 s->current_subsubframe = 0;
426 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
427 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
428 for (i = base_channel; i < s->prim_channels; i++){
429 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
430 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
431 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
432 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
433 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
434 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
435 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
436 for (j = 0; j < 11; j++)
437 av_log(s->avctx, AV_LOG_DEBUG, " %i",
438 s->quant_index_huffman[i][j]);
439 av_log(s->avctx, AV_LOG_DEBUG, "\n");
440 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
441 for (j = 0; j < 11; j++)
442 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
443 av_log(s->avctx, AV_LOG_DEBUG, "\n");
450 static int dca_parse_frame_header(DCAContext * s)
452 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
455 get_bits(&s->gb, 32);
458 s->frame_type = get_bits(&s->gb, 1);
459 s->samples_deficit = get_bits(&s->gb, 5) + 1;
460 s->crc_present = get_bits(&s->gb, 1);
461 s->sample_blocks = get_bits(&s->gb, 7) + 1;
462 s->frame_size = get_bits(&s->gb, 14) + 1;
463 if (s->frame_size < 95)
465 s->amode = get_bits(&s->gb, 6);
466 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
469 s->bit_rate_index = get_bits(&s->gb, 5);
470 s->bit_rate = dca_bit_rates[s->bit_rate_index];
474 s->downmix = get_bits(&s->gb, 1);
475 s->dynrange = get_bits(&s->gb, 1);
476 s->timestamp = get_bits(&s->gb, 1);
477 s->aux_data = get_bits(&s->gb, 1);
478 s->hdcd = get_bits(&s->gb, 1);
479 s->ext_descr = get_bits(&s->gb, 3);
480 s->ext_coding = get_bits(&s->gb, 1);
481 s->aspf = get_bits(&s->gb, 1);
482 s->lfe = get_bits(&s->gb, 2);
483 s->predictor_history = get_bits(&s->gb, 1);
485 /* TODO: check CRC */
487 s->header_crc = get_bits(&s->gb, 16);
489 s->multirate_inter = get_bits(&s->gb, 1);
490 s->version = get_bits(&s->gb, 4);
491 s->copy_history = get_bits(&s->gb, 2);
492 s->source_pcm_res = get_bits(&s->gb, 3);
493 s->front_sum = get_bits(&s->gb, 1);
494 s->surround_sum = get_bits(&s->gb, 1);
495 s->dialog_norm = get_bits(&s->gb, 4);
497 /* FIXME: channels mixing levels */
498 s->output = s->amode;
499 if (s->lfe) s->output |= DCA_LFE;
502 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
503 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
504 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
505 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
506 s->sample_blocks, s->sample_blocks * 32);
507 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
508 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
509 s->amode, dca_channels[s->amode]);
510 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
512 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
514 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
515 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
516 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
517 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
518 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
519 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
520 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
521 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
522 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
523 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
524 s->predictor_history);
525 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
526 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
528 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
529 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
530 av_log(s->avctx, AV_LOG_DEBUG,
531 "source pcm resolution: %i (%i bits/sample)\n",
532 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
533 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
534 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
535 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
536 av_log(s->avctx, AV_LOG_DEBUG, "\n");
539 /* Primary audio coding header */
540 s->subframes = get_bits(&s->gb, 4) + 1;
542 return dca_parse_audio_coding_header(s, 0);
546 static inline int get_scale(GetBitContext *gb, int level, int value)
549 /* huffman encoded */
550 value += get_bitalloc(gb, &dca_scalefactor, level);
551 } else if (level < 8)
552 value = get_bits(gb, level + 1);
556 static int dca_subframe_header(DCAContext * s, int base_channel, int block_index)
558 /* Primary audio coding side information */
562 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
563 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
566 for (j = base_channel; j < s->prim_channels; j++) {
567 for (k = 0; k < s->subband_activity[j]; k++)
568 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
571 /* Get prediction codebook */
572 for (j = base_channel; j < s->prim_channels; j++) {
573 for (k = 0; k < s->subband_activity[j]; k++) {
574 if (s->prediction_mode[j][k] > 0) {
575 /* (Prediction coefficient VQ address) */
576 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
581 /* Bit allocation index */
582 for (j = base_channel; j < s->prim_channels; j++) {
583 for (k = 0; k < s->vq_start_subband[j]; k++) {
584 if (s->bitalloc_huffman[j] == 6)
585 s->bitalloc[j][k] = get_bits(&s->gb, 5);
586 else if (s->bitalloc_huffman[j] == 5)
587 s->bitalloc[j][k] = get_bits(&s->gb, 4);
588 else if (s->bitalloc_huffman[j] == 7) {
589 av_log(s->avctx, AV_LOG_ERROR,
590 "Invalid bit allocation index\n");
594 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
597 if (s->bitalloc[j][k] > 26) {
598 // av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
599 // j, k, s->bitalloc[j][k]);
605 /* Transition mode */
606 for (j = base_channel; j < s->prim_channels; j++) {
607 for (k = 0; k < s->subband_activity[j]; k++) {
608 s->transition_mode[j][k] = 0;
609 if (s->subsubframes[s->current_subframe] > 1 &&
610 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
611 s->transition_mode[j][k] =
612 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
617 for (j = base_channel; j < s->prim_channels; j++) {
618 const uint32_t *scale_table;
621 memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
623 if (s->scalefactor_huffman[j] == 6)
624 scale_table = scale_factor_quant7;
626 scale_table = scale_factor_quant6;
628 /* When huffman coded, only the difference is encoded */
631 for (k = 0; k < s->subband_activity[j]; k++) {
632 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
633 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
634 s->scale_factor[j][k][0] = scale_table[scale_sum];
637 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
638 /* Get second scale factor */
639 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
640 s->scale_factor[j][k][1] = scale_table[scale_sum];
645 /* Joint subband scale factor codebook select */
646 for (j = base_channel; j < s->prim_channels; j++) {
647 /* Transmitted only if joint subband coding enabled */
648 if (s->joint_intensity[j] > 0)
649 s->joint_huff[j] = get_bits(&s->gb, 3);
652 /* Scale factors for joint subband coding */
653 for (j = base_channel; j < s->prim_channels; j++) {
656 /* Transmitted only if joint subband coding enabled */
657 if (s->joint_intensity[j] > 0) {
659 source_channel = s->joint_intensity[j] - 1;
661 /* When huffman coded, only the difference is encoded
662 * (is this valid as well for joint scales ???) */
664 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
665 scale = get_scale(&s->gb, s->joint_huff[j], 0);
666 scale += 64; /* bias */
667 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
670 if (!(s->debug_flag & 0x02)) {
671 av_log(s->avctx, AV_LOG_DEBUG,
672 "Joint stereo coding not supported\n");
673 s->debug_flag |= 0x02;
678 /* Stereo downmix coefficients */
679 if (!base_channel && s->prim_channels > 2) {
681 for (j = base_channel; j < s->prim_channels; j++) {
682 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
683 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
686 int am = s->amode & DCA_CHANNEL_MASK;
687 for (j = base_channel; j < s->prim_channels; j++) {
688 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
689 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
694 /* Dynamic range coefficient */
695 if (!base_channel && s->dynrange)
696 s->dynrange_coef = get_bits(&s->gb, 8);
698 /* Side information CRC check word */
699 if (s->crc_present) {
700 get_bits(&s->gb, 16);
704 * Primary audio data arrays
707 /* VQ encoded high frequency subbands */
708 for (j = base_channel; j < s->prim_channels; j++)
709 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
710 /* 1 vector -> 32 samples */
711 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
713 /* Low frequency effect data */
714 if (!base_channel && s->lfe) {
716 int lfe_samples = 2 * s->lfe * (4 + block_index);
717 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
720 for (j = lfe_samples; j < lfe_end_sample; j++) {
721 /* Signed 8 bits int */
722 s->lfe_data[j] = get_sbits(&s->gb, 8);
725 /* Scale factor index */
726 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
728 /* Quantization step size * scale factor */
729 lfe_scale = 0.035 * s->lfe_scale_factor;
731 for (j = lfe_samples; j < lfe_end_sample; j++)
732 s->lfe_data[j] *= lfe_scale;
736 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes[s->current_subframe]);
737 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
738 s->partial_samples[s->current_subframe]);
739 for (j = base_channel; j < s->prim_channels; j++) {
740 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
741 for (k = 0; k < s->subband_activity[j]; k++)
742 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
743 av_log(s->avctx, AV_LOG_DEBUG, "\n");
745 for (j = base_channel; j < s->prim_channels; j++) {
746 for (k = 0; k < s->subband_activity[j]; k++)
747 av_log(s->avctx, AV_LOG_DEBUG,
748 "prediction coefs: %f, %f, %f, %f\n",
749 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
750 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
751 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
752 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
754 for (j = base_channel; j < s->prim_channels; j++) {
755 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
756 for (k = 0; k < s->vq_start_subband[j]; k++)
757 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
758 av_log(s->avctx, AV_LOG_DEBUG, "\n");
760 for (j = base_channel; j < s->prim_channels; j++) {
761 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
762 for (k = 0; k < s->subband_activity[j]; k++)
763 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
764 av_log(s->avctx, AV_LOG_DEBUG, "\n");
766 for (j = base_channel; j < s->prim_channels; j++) {
767 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
768 for (k = 0; k < s->subband_activity[j]; k++) {
769 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
770 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
771 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
772 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
774 av_log(s->avctx, AV_LOG_DEBUG, "\n");
776 for (j = base_channel; j < s->prim_channels; j++) {
777 if (s->joint_intensity[j] > 0) {
778 int source_channel = s->joint_intensity[j] - 1;
779 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
780 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
781 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
782 av_log(s->avctx, AV_LOG_DEBUG, "\n");
785 if (!base_channel && s->prim_channels > 2 && s->downmix) {
786 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
787 for (j = 0; j < s->prim_channels; j++) {
788 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
789 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
791 av_log(s->avctx, AV_LOG_DEBUG, "\n");
793 for (j = base_channel; j < s->prim_channels; j++)
794 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
795 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
796 if (!base_channel && s->lfe) {
797 int lfe_samples = 2 * s->lfe * (4 + block_index);
798 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
800 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
801 for (j = lfe_samples; j < lfe_end_sample; j++)
802 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
803 av_log(s->avctx, AV_LOG_DEBUG, "\n");
810 static void qmf_32_subbands(DCAContext * s, int chans,
811 float samples_in[32][8], float *samples_out,
812 float scale, float bias)
814 const float *prCoeff;
817 int sb_act = s->subband_activity[chans];
820 scale *= sqrt(1/8.0);
823 if (!s->multirate_inter) /* Non-perfect reconstruction */
824 prCoeff = fir_32bands_nonperfect;
825 else /* Perfect reconstruction */
826 prCoeff = fir_32bands_perfect;
828 /* Reconstructed channel sample index */
829 for (subindex = 0; subindex < 8; subindex++) {
830 /* Load in one sample from each subband and clear inactive subbands */
831 for (i = 0; i < sb_act; i++){
832 uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
833 AV_WN32A(&s->raXin[i], v);
838 s->synth.synth_filter_float(&s->imdct,
839 s->subband_fir_hist[chans], &s->hist_index[chans],
840 s->subband_fir_noidea[chans], prCoeff,
841 samples_out, s->raXin, scale, bias);
847 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
848 int num_deci_sample, float *samples_in,
849 float *samples_out, float scale,
852 /* samples_in: An array holding decimated samples.
853 * Samples in current subframe starts from samples_in[0],
854 * while samples_in[-1], samples_in[-2], ..., stores samples
855 * from last subframe as history.
857 * samples_out: An array holding interpolated samples
861 const float *prCoeff;
864 /* Select decimation filter */
865 if (decimation_select == 1) {
867 prCoeff = lfe_fir_128;
870 prCoeff = lfe_fir_64;
873 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
874 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
877 samples_out += 2 * decifactor;
881 /* downmixing routines */
882 #define MIX_REAR1(samples, si1, rs, coef) \
883 samples[i] += (samples[si1] - add_bias) * coef[rs][0]; \
884 samples[i+256] += (samples[si1] - add_bias) * coef[rs][1];
886 #define MIX_REAR2(samples, si1, si2, rs, coef) \
887 samples[i] += (samples[si1] - add_bias) * coef[rs][0] + (samples[si2] - add_bias) * coef[rs+1][0]; \
888 samples[i+256] += (samples[si1] - add_bias) * coef[rs][1] + (samples[si2] - add_bias) * coef[rs+1][1];
890 #define MIX_FRONT3(samples, coef) \
891 t = samples[i+c] - add_bias; \
892 u = samples[i+l] - add_bias; \
893 v = samples[i+r] - add_bias; \
894 samples[i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0] + add_bias; \
895 samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1] + add_bias;
897 #define DOWNMIX_TO_STEREO(op1, op2) \
898 for (i = 0; i < 256; i++){ \
903 static void dca_downmix(float *samples, int srcfmt,
904 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
905 const int8_t *channel_mapping, float add_bias)
910 float coef[DCA_PRIM_CHANNELS_MAX][2];
912 for (i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
913 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
914 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
920 case DCA_STEREO_TOTAL:
921 case DCA_STEREO_SUMDIFF:
923 av_log(NULL, 0, "Not implemented!\n");
928 c = channel_mapping[0] * 256;
929 l = channel_mapping[1] * 256;
930 r = channel_mapping[2] * 256;
931 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
934 s = channel_mapping[2] * 256;
935 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef),);
938 c = channel_mapping[0] * 256;
939 l = channel_mapping[1] * 256;
940 r = channel_mapping[2] * 256;
941 s = channel_mapping[3] * 256;
942 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
943 MIX_REAR1(samples, i + s, 3, coef));
946 sl = channel_mapping[2] * 256;
947 sr = channel_mapping[3] * 256;
948 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef),);
951 c = channel_mapping[0] * 256;
952 l = channel_mapping[1] * 256;
953 r = channel_mapping[2] * 256;
954 sl = channel_mapping[3] * 256;
955 sr = channel_mapping[4] * 256;
956 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
957 MIX_REAR2(samples, i + sl, i + sr, 3, coef));
963 /* Very compact version of the block code decoder that does not use table
964 * look-up but is slightly slower */
965 static int decode_blockcode(int code, int levels, int *values)
968 int offset = (levels - 1) >> 1;
970 for (i = 0; i < 4; i++) {
971 int div = FASTDIV(code, levels);
972 values[i] = code - offset - div*levels;
979 av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
984 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
985 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
987 static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
990 int subsubframe = s->current_subsubframe;
992 const float *quant_step_table;
995 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
996 LOCAL_ALIGNED_16(int, block, [8]);
1002 /* Select quantization step size table */
1003 if (s->bit_rate_index == 0x1f)
1004 quant_step_table = lossless_quant_d;
1006 quant_step_table = lossy_quant_d;
1008 for (k = base_channel; k < s->prim_channels; k++) {
1009 for (l = 0; l < s->vq_start_subband[k]; l++) {
1012 /* Select the mid-tread linear quantizer */
1013 int abits = s->bitalloc[k][l];
1015 float quant_step_size = quant_step_table[abits];
1018 * Determine quantization index code book and its type
1021 /* Select quantization index code book */
1022 int sel = s->quant_index_huffman[k][abits];
1025 * Extract bits from the bit stream
1028 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1030 /* Deal with transients */
1031 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1032 float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
1034 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
1037 int block_code1, block_code2, size, levels;
1039 size = abits_sizes[abits-1];
1040 levels = abits_levels[abits-1];
1042 block_code1 = get_bits(&s->gb, size);
1043 /* FIXME Should test return value */
1044 decode_blockcode(block_code1, levels, block);
1045 block_code2 = get_bits(&s->gb, size);
1046 decode_blockcode(block_code2, levels, &block[4]);
1049 for (m = 0; m < 8; m++)
1050 block[m] = get_sbits(&s->gb, abits - 3);
1054 for (m = 0; m < 8; m++)
1055 block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1058 s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
1063 * Inverse ADPCM if in prediction mode
1065 if (s->prediction_mode[k][l]) {
1067 for (m = 0; m < 8; m++) {
1068 for (n = 1; n <= 4; n++)
1070 subband_samples[k][l][m] +=
1071 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1072 subband_samples[k][l][m - n] / 8192);
1073 else if (s->predictor_history)
1074 subband_samples[k][l][m] +=
1075 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1076 s->subband_samples_hist[k][l][m - n +
1083 * Decode VQ encoded high frequencies
1085 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1086 /* 1 vector -> 32 samples but we only need the 8 samples
1087 * for this subsubframe. */
1090 if (!s->debug_flag & 0x01) {
1091 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1092 s->debug_flag |= 0x01;
1095 for (m = 0; m < 8; m++) {
1096 subband_samples[k][l][m] =
1097 high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1099 * (float) s->scale_factor[k][l][0] / 16.0;
1104 /* Check for DSYNC after subsubframe */
1105 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1106 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1108 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1111 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1115 /* Backup predictor history for adpcm */
1116 for (k = base_channel; k < s->prim_channels; k++)
1117 for (l = 0; l < s->vq_start_subband[k]; l++)
1118 memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1119 4 * sizeof(subband_samples[0][0][0]));
1124 static int dca_filter_channels(DCAContext * s, int block_index)
1126 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1129 /* 32 subbands QMF */
1130 for (k = 0; k < s->prim_channels; k++) {
1131 /* static float pcm_to_double[8] =
1132 {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1133 qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1134 M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1139 if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1140 dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab, s->add_bias);
1143 /* Generate LFE samples for this subsubframe FIXME!!! */
1144 if (s->output & DCA_LFE) {
1145 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1146 s->lfe_data + 2 * s->lfe * (block_index + 4),
1147 &s->samples[256 * dca_lfe_index[s->amode]],
1148 (1.0/256.0)*s->scale_bias, s->add_bias);
1149 /* Outputs 20bits pcm samples */
1156 static int dca_subframe_footer(DCAContext * s, int base_channel)
1158 int aux_data_count = 0, i;
1161 * Unpack optional information
1164 /* presumably optional information only appears in the core? */
1165 if (!base_channel) {
1167 get_bits(&s->gb, 32);
1170 aux_data_count = get_bits(&s->gb, 6);
1172 for (i = 0; i < aux_data_count; i++)
1173 get_bits(&s->gb, 8);
1175 if (s->crc_present && (s->downmix || s->dynrange))
1176 get_bits(&s->gb, 16);
1183 * Decode a dca frame block
1185 * @param s pointer to the DCAContext
1188 static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1192 if (s->current_subframe >= s->subframes) {
1193 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1194 s->current_subframe, s->subframes);
1198 if (!s->current_subsubframe) {
1200 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1202 /* Read subframe header */
1203 if (dca_subframe_header(s, base_channel, block_index))
1207 /* Read subsubframe */
1209 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1211 if (dca_subsubframe(s, base_channel, block_index))
1215 s->current_subsubframe++;
1216 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1217 s->current_subsubframe = 0;
1218 s->current_subframe++;
1220 if (s->current_subframe >= s->subframes) {
1222 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1224 /* Read subframe footer */
1225 if (dca_subframe_footer(s, base_channel))
1233 * Convert bitstream to one representation based on sync marker
1235 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1240 const uint16_t *ssrc = (const uint16_t *) src;
1241 uint16_t *sdst = (uint16_t *) dst;
1244 if ((unsigned)src_size > (unsigned)max_size) {
1245 // av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1247 src_size = max_size;
1252 case DCA_MARKER_RAW_BE:
1253 memcpy(dst, src, src_size);
1255 case DCA_MARKER_RAW_LE:
1256 for (i = 0; i < (src_size + 1) >> 1; i++)
1257 *sdst++ = av_bswap16(*ssrc++);
1259 case DCA_MARKER_14B_BE:
1260 case DCA_MARKER_14B_LE:
1261 init_put_bits(&pb, dst, max_size);
1262 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1263 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1264 put_bits(&pb, 14, tmp);
1266 flush_put_bits(&pb);
1267 return (put_bits_count(&pb) + 7) >> 3;
1274 * Main frame decoding function
1275 * FIXME add arguments
1277 static int dca_decode_frame(AVCodecContext * avctx,
1278 void *data, int *data_size,
1281 const uint8_t *buf = avpkt->data;
1282 int buf_size = avpkt->size;
1285 int num_core_channels = 0;
1287 int16_t *samples = data;
1288 DCAContext *s = avctx->priv_data;
1293 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1294 if (s->dca_buffer_size == -1) {
1295 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1299 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1300 if (dca_parse_frame_header(s) < 0) {
1301 //seems like the frame is corrupt, try with the next one
1305 //set AVCodec values with parsed data
1306 avctx->sample_rate = s->sample_rate;
1307 avctx->bit_rate = s->bit_rate;
1309 for (i = 0; i < (s->sample_blocks / 8); i++) {
1310 dca_decode_block(s, 0, i);
1313 /* record number of core channels incase less than max channels are requested */
1314 num_core_channels = s->prim_channels;
1316 /* extensions start at 32-bit boundaries into bitstream */
1317 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1319 while(get_bits_left(&s->gb) >= 32) {
1320 uint32_t bits = get_bits_long(&s->gb, 32);
1324 int ext_amode, xch_fsize;
1326 s->xch_base_channel = s->prim_channels;
1328 /* validate sync word using XCHFSIZE field */
1329 xch_fsize = show_bits(&s->gb, 10);
1330 if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1331 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1334 /* skip length-to-end-of-frame field for the moment */
1335 skip_bits(&s->gb, 10);
1337 /* extension amode should == 1, number of channels in extension */
1338 /* AFAIK XCh is not used for more channels */
1339 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1340 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1341 " supported!\n",ext_amode);
1345 /* much like core primary audio coding header */
1346 dca_parse_audio_coding_header(s, s->xch_base_channel);
1348 for (i = 0; i < (s->sample_blocks / 8); i++) {
1349 dca_decode_block(s, s->xch_base_channel, i);
1356 av_log(avctx, AV_LOG_DEBUG, "Possible X96 extension found at %d bits\n", get_bits_count(&s->gb));
1357 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", get_bits(&s->gb, 12)+1);
1358 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1362 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1365 channels = s->prim_channels + !!s->lfe;
1368 avctx->channel_layout = dca_core_channel_layout[s->amode];
1370 if (s->xch_present && (!avctx->request_channels ||
1371 avctx->request_channels > num_core_channels + !!s->lfe)) {
1372 avctx->channel_layout |= AV_CH_BACK_CENTER;
1374 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1375 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1377 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1380 channels = num_core_channels + !!s->lfe;
1381 s->xch_present = 0; /* disable further xch processing */
1383 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1384 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1386 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1389 if (channels > !!s->lfe &&
1390 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1393 if (avctx->request_channels == 2 && s->prim_channels > 2) {
1395 s->output = DCA_STEREO;
1396 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1399 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1404 /* There is nothing that prevents a dts frame to change channel configuration
1405 but FFmpeg doesn't support that so only set the channels if it is previously
1406 unset. Ideally during the first probe for channels the crc should be checked
1407 and only set avctx->channels when the crc is ok. Right now the decoder could
1408 set the channels based on a broken first frame.*/
1409 avctx->channels = channels;
1411 if (*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1413 *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1415 /* filter to get final output */
1416 for (i = 0; i < (s->sample_blocks / 8); i++) {
1417 dca_filter_channels(s, i);
1419 /* If this was marked as a DTS-ES stream we need to subtract back- */
1420 /* channel from SL & SR to remove matrixed back-channel signal */
1421 if((s->source_pcm_res & 1) && s->xch_present) {
1422 float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1423 float* lt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1424 float* rt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1426 for(j = 0; j < 256; ++j) {
1427 lt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1428 rt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1432 s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1433 samples += 256 * channels;
1436 /* update lfe history */
1437 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1438 for (i = 0; i < 2 * s->lfe * 4; i++) {
1439 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1448 * DCA initialization
1450 * @param avctx pointer to the AVCodecContext
1453 static av_cold int dca_decode_init(AVCodecContext * avctx)
1455 DCAContext *s = avctx->priv_data;
1461 dsputil_init(&s->dsp, avctx);
1462 ff_mdct_init(&s->imdct, 6, 1, 1.0);
1463 ff_synth_filter_init(&s->synth);
1464 ff_dcadsp_init(&s->dcadsp);
1466 for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
1467 s->samples_chanptr[i] = s->samples + i * 256;
1468 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1470 if (s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1471 s->add_bias = 385.0f;
1472 s->scale_bias = 1.0 / 32768.0;
1475 s->scale_bias = 1.0;
1477 /* allow downmixing to stereo */
1478 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1479 avctx->request_channels == 2) {
1480 avctx->channels = avctx->request_channels;
1488 static av_cold int dca_decode_end(AVCodecContext * avctx)
1490 DCAContext *s = avctx->priv_data;
1491 ff_mdct_end(&s->imdct);
1495 AVCodec dca_decoder = {
1497 .type = AVMEDIA_TYPE_AUDIO,
1499 .priv_data_size = sizeof(DCAContext),
1500 .init = dca_decode_init,
1501 .decode = dca_decode_frame,
1502 .close = dca_decode_end,
1503 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1504 .capabilities = CODEC_CAP_CHANNEL_CONF,