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"
39 #include "synth_filter.h"
44 #define DCA_PRIM_CHANNELS_MAX (7)
45 #define DCA_SUBBANDS (32)
46 #define DCA_ABITS_MAX (32) /* Should be 28 */
47 #define DCA_SUBSUBFRAMES_MAX (4)
48 #define DCA_SUBFRAMES_MAX (16)
49 #define DCA_BLOCKS_MAX (16)
50 #define DCA_LFE_MAX (3)
66 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
67 * Some compromises have been made for special configurations. Most configurations
68 * are never used so complete accuracy is not needed.
70 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
71 * S -> side, when both rear and back are configured move one of them to the side channel
73 * All 2 channel configurations -> CH_LAYOUT_STEREO
76 static const int64_t dca_core_channel_layout[] = {
77 CH_FRONT_CENTER, ///< 1, A
78 CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
79 CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
80 CH_LAYOUT_STEREO, ///< 2, (L+R) + (L-R) (sum-difference)
81 CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total)
82 CH_LAYOUT_STEREO|CH_FRONT_CENTER, ///< 3, C+L+R
83 CH_LAYOUT_STEREO|CH_BACK_CENTER, ///< 3, L+R+S
84 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 4, C + L + R+ S
85 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 4, L + R +SL+ SR
86 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
87 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
88 CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 6, C + L + R+ LR + RR + OV
89 CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_FRONT_LEFT_OF_CENTER|CH_BACK_CENTER|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 6, CF+ CR+LF+ RF+LR + RR
90 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
91 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2
92 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_BACK_CENTER|CH_SIDE_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR
95 static const int8_t dca_lfe_index[] = {
96 1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
99 static const int8_t dca_channel_reorder_lfe[][9] = {
100 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
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 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
106 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
107 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
108 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
109 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
110 { 3, 4, 0, 1, 5, 6, -1, -1, -1},
111 { 2, 0, 1, 4, 5, 6, -1, -1, -1},
112 { 0, 6, 4, 5, 2, 3, -1, -1, -1},
113 { 4, 2, 5, 0, 1, 6, 7, -1, -1},
114 { 5, 6, 0, 1, 7, 3, 8, 4, -1},
115 { 4, 2, 5, 0, 1, 6, 8, 7, -1},
118 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
119 { 0, 2, -1, -1, -1, -1, -1, -1, -1},
120 { 0, 1, 3, -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 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
125 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
126 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
127 { 0, 1, 4, 5, 3, -1, -1, -1, -1},
128 { 2, 0, 1, 5, 6, 4, -1, -1, -1},
129 { 3, 4, 0, 1, 6, 7, 5, -1, -1},
130 { 2, 0, 1, 4, 5, 6, 7, -1, -1},
131 { 0, 6, 4, 5, 2, 3, 7, -1, -1},
132 { 4, 2, 5, 0, 1, 7, 8, 6, -1},
133 { 5, 6, 0, 1, 8, 3, 9, 4, 7},
134 { 4, 2, 5, 0, 1, 6, 9, 8, 7},
137 static const int8_t dca_channel_reorder_nolfe[][9] = {
138 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
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 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
144 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
145 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
146 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
147 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
148 { 2, 3, 0, 1, 4, 5, -1, -1, -1},
149 { 2, 0, 1, 3, 4, 5, -1, -1, -1},
150 { 0, 5, 3, 4, 1, 2, -1, -1, -1},
151 { 3, 2, 4, 0, 1, 5, 6, -1, -1},
152 { 4, 5, 0, 1, 6, 2, 7, 3, -1},
153 { 3, 2, 4, 0, 1, 5, 7, 6, -1},
156 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
157 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
158 { 0, 1, 2, -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 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
163 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
164 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
165 { 0, 1, 3, 4, 2, -1, -1, -1, -1},
166 { 2, 0, 1, 4, 5, 3, -1, -1, -1},
167 { 2, 3, 0, 1, 5, 6, 4, -1, -1},
168 { 2, 0, 1, 3, 4, 5, 6, -1, -1},
169 { 0, 5, 3, 4, 1, 2, 6, -1, -1},
170 { 3, 2, 4, 0, 1, 6, 7, 5, -1},
171 { 4, 5, 0, 1, 7, 2, 8, 3, 6},
172 { 3, 2, 4, 0, 1, 5, 8, 7, 6},
175 #define DCA_DOLBY 101 /* FIXME */
177 #define DCA_CHANNEL_BITS 6
178 #define DCA_CHANNEL_MASK 0x3F
182 #define HEADER_SIZE 14
184 #define DCA_MAX_FRAME_SIZE 16384
186 /** Bit allocation */
188 int offset; ///< code values offset
189 int maxbits[8]; ///< max bits in VLC
190 int wrap; ///< wrap for get_vlc2()
191 VLC vlc[8]; ///< actual codes
194 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
195 static BitAlloc dca_tmode; ///< transition mode VLCs
196 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
197 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
199 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
201 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
205 AVCodecContext *avctx;
207 int frame_type; ///< type of the current frame
208 int samples_deficit; ///< deficit sample count
209 int crc_present; ///< crc is present in the bitstream
210 int sample_blocks; ///< number of PCM sample blocks
211 int frame_size; ///< primary frame byte size
212 int amode; ///< audio channels arrangement
213 int sample_rate; ///< audio sampling rate
214 int bit_rate; ///< transmission bit rate
215 int bit_rate_index; ///< transmission bit rate index
217 int downmix; ///< embedded downmix enabled
218 int dynrange; ///< embedded dynamic range flag
219 int timestamp; ///< embedded time stamp flag
220 int aux_data; ///< auxiliary data flag
221 int hdcd; ///< source material is mastered in HDCD
222 int ext_descr; ///< extension audio descriptor flag
223 int ext_coding; ///< extended coding flag
224 int aspf; ///< audio sync word insertion flag
225 int lfe; ///< low frequency effects flag
226 int predictor_history; ///< predictor history flag
227 int header_crc; ///< header crc check bytes
228 int multirate_inter; ///< multirate interpolator switch
229 int version; ///< encoder software revision
230 int copy_history; ///< copy history
231 int source_pcm_res; ///< source pcm resolution
232 int front_sum; ///< front sum/difference flag
233 int surround_sum; ///< surround sum/difference flag
234 int dialog_norm; ///< dialog normalisation parameter
236 /* Primary audio coding header */
237 int subframes; ///< number of subframes
238 int total_channels; ///< number of channels including extensions
239 int prim_channels; ///< number of primary audio channels
240 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
241 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
242 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
243 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
244 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
245 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
246 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
247 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
249 /* Primary audio coding side information */
250 int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
251 int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
252 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
253 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
254 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
255 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
256 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
257 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
258 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
259 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
260 int dynrange_coef; ///< dynamic range coefficient
262 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
264 float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
265 int lfe_scale_factor;
267 /* Subband samples history (for ADPCM) */
268 float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
269 DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
270 DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
271 int hist_index[DCA_PRIM_CHANNELS_MAX];
272 DECLARE_ALIGNED(16, float, raXin)[32];
274 int output; ///< type of output
275 float add_bias; ///< output bias
276 float scale_bias; ///< output scale
278 DECLARE_ALIGNED(16, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
279 DECLARE_ALIGNED(16, float, samples)[(DCA_PRIM_CHANNELS_MAX+1)*256];
280 const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX+1];
282 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
283 int dca_buffer_size; ///< how much data is in the dca_buffer
285 const int8_t* channel_order_tab; ///< channel reordering table, lfe and non lfe
287 /* Current position in DCA frame */
288 int current_subframe;
289 int current_subsubframe;
291 /* XCh extension information */
293 int xch_base_channel; ///< index of first (only) channel containing XCH data
295 int debug_flag; ///< used for suppressing repeated error messages output
298 SynthFilterContext synth;
299 DCADSPContext dcadsp;
302 static const uint16_t dca_vlc_offs[] = {
303 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
304 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
305 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
306 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
307 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
308 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
311 static av_cold void dca_init_vlcs(void)
313 static int vlcs_initialized = 0;
315 static VLC_TYPE dca_table[23622][2];
317 if (vlcs_initialized)
320 dca_bitalloc_index.offset = 1;
321 dca_bitalloc_index.wrap = 2;
322 for (i = 0; i < 5; i++) {
323 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
324 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
325 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
326 bitalloc_12_bits[i], 1, 1,
327 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
329 dca_scalefactor.offset = -64;
330 dca_scalefactor.wrap = 2;
331 for (i = 0; i < 5; i++) {
332 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
333 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
334 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
335 scales_bits[i], 1, 1,
336 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
338 dca_tmode.offset = 0;
340 for (i = 0; i < 4; i++) {
341 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
342 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
343 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
345 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
348 for (i = 0; i < 10; i++)
349 for (j = 0; j < 7; j++){
350 if (!bitalloc_codes[i][j]) break;
351 dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
352 dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
353 dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
354 dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
355 init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
357 bitalloc_bits[i][j], 1, 1,
358 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
361 vlcs_initialized = 1;
364 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
367 *dst++ = get_bits(gb, bits);
370 static int dca_parse_audio_coding_header(DCAContext * s, int base_channel)
373 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
374 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
375 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
377 s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
378 s->prim_channels = s->total_channels;
380 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
381 s->prim_channels = DCA_PRIM_CHANNELS_MAX;
384 for (i = base_channel; i < s->prim_channels; i++) {
385 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
386 if (s->subband_activity[i] > DCA_SUBBANDS)
387 s->subband_activity[i] = DCA_SUBBANDS;
389 for (i = base_channel; i < s->prim_channels; i++) {
390 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
391 if (s->vq_start_subband[i] > DCA_SUBBANDS)
392 s->vq_start_subband[i] = DCA_SUBBANDS;
394 get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
395 get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
396 get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
397 get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
399 /* Get codebooks quantization indexes */
401 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
402 for (j = 1; j < 11; j++)
403 for (i = base_channel; i < s->prim_channels; i++)
404 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
406 /* Get scale factor adjustment */
407 for (j = 0; j < 11; j++)
408 for (i = base_channel; i < s->prim_channels; i++)
409 s->scalefactor_adj[i][j] = 1;
411 for (j = 1; j < 11; j++)
412 for (i = base_channel; i < s->prim_channels; i++)
413 if (s->quant_index_huffman[i][j] < thr[j])
414 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
416 if (s->crc_present) {
417 /* Audio header CRC check */
418 get_bits(&s->gb, 16);
421 s->current_subframe = 0;
422 s->current_subsubframe = 0;
425 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
426 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
427 for (i = base_channel; i < s->prim_channels; i++){
428 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
429 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
430 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
431 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
432 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
433 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
434 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
435 for (j = 0; j < 11; j++)
436 av_log(s->avctx, AV_LOG_DEBUG, " %i",
437 s->quant_index_huffman[i][j]);
438 av_log(s->avctx, AV_LOG_DEBUG, "\n");
439 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
440 for (j = 0; j < 11; j++)
441 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
442 av_log(s->avctx, AV_LOG_DEBUG, "\n");
449 static int dca_parse_frame_header(DCAContext * s)
451 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
454 get_bits(&s->gb, 32);
457 s->frame_type = get_bits(&s->gb, 1);
458 s->samples_deficit = get_bits(&s->gb, 5) + 1;
459 s->crc_present = get_bits(&s->gb, 1);
460 s->sample_blocks = get_bits(&s->gb, 7) + 1;
461 s->frame_size = get_bits(&s->gb, 14) + 1;
462 if (s->frame_size < 95)
464 s->amode = get_bits(&s->gb, 6);
465 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
468 s->bit_rate_index = get_bits(&s->gb, 5);
469 s->bit_rate = dca_bit_rates[s->bit_rate_index];
473 s->downmix = get_bits(&s->gb, 1);
474 s->dynrange = get_bits(&s->gb, 1);
475 s->timestamp = get_bits(&s->gb, 1);
476 s->aux_data = get_bits(&s->gb, 1);
477 s->hdcd = get_bits(&s->gb, 1);
478 s->ext_descr = get_bits(&s->gb, 3);
479 s->ext_coding = get_bits(&s->gb, 1);
480 s->aspf = get_bits(&s->gb, 1);
481 s->lfe = get_bits(&s->gb, 2);
482 s->predictor_history = get_bits(&s->gb, 1);
484 /* TODO: check CRC */
486 s->header_crc = get_bits(&s->gb, 16);
488 s->multirate_inter = get_bits(&s->gb, 1);
489 s->version = get_bits(&s->gb, 4);
490 s->copy_history = get_bits(&s->gb, 2);
491 s->source_pcm_res = get_bits(&s->gb, 3);
492 s->front_sum = get_bits(&s->gb, 1);
493 s->surround_sum = get_bits(&s->gb, 1);
494 s->dialog_norm = get_bits(&s->gb, 4);
496 /* FIXME: channels mixing levels */
497 s->output = s->amode;
498 if (s->lfe) s->output |= DCA_LFE;
501 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
502 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
503 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
504 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
505 s->sample_blocks, s->sample_blocks * 32);
506 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
507 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
508 s->amode, dca_channels[s->amode]);
509 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
511 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
513 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
514 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
515 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
516 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
517 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
518 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
519 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
520 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
521 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
522 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
523 s->predictor_history);
524 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
525 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
527 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
528 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
529 av_log(s->avctx, AV_LOG_DEBUG,
530 "source pcm resolution: %i (%i bits/sample)\n",
531 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
532 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
533 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
534 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
535 av_log(s->avctx, AV_LOG_DEBUG, "\n");
538 /* Primary audio coding header */
539 s->subframes = get_bits(&s->gb, 4) + 1;
541 return dca_parse_audio_coding_header(s, 0);
545 static inline int get_scale(GetBitContext *gb, int level, int value)
548 /* huffman encoded */
549 value += get_bitalloc(gb, &dca_scalefactor, level);
550 } else if (level < 8)
551 value = get_bits(gb, level + 1);
555 static int dca_subframe_header(DCAContext * s, int base_channel, int block_index)
557 /* Primary audio coding side information */
561 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
562 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
565 for (j = base_channel; j < s->prim_channels; j++) {
566 for (k = 0; k < s->subband_activity[j]; k++)
567 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
570 /* Get prediction codebook */
571 for (j = base_channel; j < s->prim_channels; j++) {
572 for (k = 0; k < s->subband_activity[j]; k++) {
573 if (s->prediction_mode[j][k] > 0) {
574 /* (Prediction coefficient VQ address) */
575 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
580 /* Bit allocation index */
581 for (j = base_channel; j < s->prim_channels; j++) {
582 for (k = 0; k < s->vq_start_subband[j]; k++) {
583 if (s->bitalloc_huffman[j] == 6)
584 s->bitalloc[j][k] = get_bits(&s->gb, 5);
585 else if (s->bitalloc_huffman[j] == 5)
586 s->bitalloc[j][k] = get_bits(&s->gb, 4);
587 else if (s->bitalloc_huffman[j] == 7) {
588 av_log(s->avctx, AV_LOG_ERROR,
589 "Invalid bit allocation index\n");
593 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
596 if (s->bitalloc[j][k] > 26) {
597 // av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
598 // j, k, s->bitalloc[j][k]);
604 /* Transition mode */
605 for (j = base_channel; j < s->prim_channels; j++) {
606 for (k = 0; k < s->subband_activity[j]; k++) {
607 s->transition_mode[j][k] = 0;
608 if (s->subsubframes[s->current_subframe] > 1 &&
609 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
610 s->transition_mode[j][k] =
611 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
616 for (j = base_channel; j < s->prim_channels; j++) {
617 const uint32_t *scale_table;
620 memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
622 if (s->scalefactor_huffman[j] == 6)
623 scale_table = scale_factor_quant7;
625 scale_table = scale_factor_quant6;
627 /* When huffman coded, only the difference is encoded */
630 for (k = 0; k < s->subband_activity[j]; k++) {
631 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
632 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
633 s->scale_factor[j][k][0] = scale_table[scale_sum];
636 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
637 /* Get second scale factor */
638 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
639 s->scale_factor[j][k][1] = scale_table[scale_sum];
644 /* Joint subband scale factor codebook select */
645 for (j = base_channel; j < s->prim_channels; j++) {
646 /* Transmitted only if joint subband coding enabled */
647 if (s->joint_intensity[j] > 0)
648 s->joint_huff[j] = get_bits(&s->gb, 3);
651 /* Scale factors for joint subband coding */
652 for (j = base_channel; j < s->prim_channels; j++) {
655 /* Transmitted only if joint subband coding enabled */
656 if (s->joint_intensity[j] > 0) {
658 source_channel = s->joint_intensity[j] - 1;
660 /* When huffman coded, only the difference is encoded
661 * (is this valid as well for joint scales ???) */
663 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
664 scale = get_scale(&s->gb, s->joint_huff[j], 0);
665 scale += 64; /* bias */
666 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
669 if (!(s->debug_flag & 0x02)) {
670 av_log(s->avctx, AV_LOG_DEBUG,
671 "Joint stereo coding not supported\n");
672 s->debug_flag |= 0x02;
677 /* Stereo downmix coefficients */
678 if (!base_channel && s->prim_channels > 2) {
680 for (j = base_channel; j < s->prim_channels; j++) {
681 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
682 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
685 int am = s->amode & DCA_CHANNEL_MASK;
686 for (j = base_channel; j < s->prim_channels; j++) {
687 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
688 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
693 /* Dynamic range coefficient */
694 if (!base_channel && s->dynrange)
695 s->dynrange_coef = get_bits(&s->gb, 8);
697 /* Side information CRC check word */
698 if (s->crc_present) {
699 get_bits(&s->gb, 16);
703 * Primary audio data arrays
706 /* VQ encoded high frequency subbands */
707 for (j = base_channel; j < s->prim_channels; j++)
708 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
709 /* 1 vector -> 32 samples */
710 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
712 /* Low frequency effect data */
713 if (!base_channel && s->lfe) {
715 int lfe_samples = 2 * s->lfe * (4 + block_index);
716 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
719 for (j = lfe_samples; j < lfe_end_sample; j++) {
720 /* Signed 8 bits int */
721 s->lfe_data[j] = get_sbits(&s->gb, 8);
724 /* Scale factor index */
725 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
727 /* Quantization step size * scale factor */
728 lfe_scale = 0.035 * s->lfe_scale_factor;
730 for (j = lfe_samples; j < lfe_end_sample; j++)
731 s->lfe_data[j] *= lfe_scale;
735 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes[s->current_subframe]);
736 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
737 s->partial_samples[s->current_subframe]);
738 for (j = base_channel; j < s->prim_channels; j++) {
739 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
740 for (k = 0; k < s->subband_activity[j]; k++)
741 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
742 av_log(s->avctx, AV_LOG_DEBUG, "\n");
744 for (j = base_channel; j < s->prim_channels; j++) {
745 for (k = 0; k < s->subband_activity[j]; k++)
746 av_log(s->avctx, AV_LOG_DEBUG,
747 "prediction coefs: %f, %f, %f, %f\n",
748 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
749 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
750 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
751 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
753 for (j = base_channel; j < s->prim_channels; j++) {
754 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
755 for (k = 0; k < s->vq_start_subband[j]; k++)
756 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
757 av_log(s->avctx, AV_LOG_DEBUG, "\n");
759 for (j = base_channel; j < s->prim_channels; j++) {
760 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
761 for (k = 0; k < s->subband_activity[j]; k++)
762 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
763 av_log(s->avctx, AV_LOG_DEBUG, "\n");
765 for (j = base_channel; j < s->prim_channels; j++) {
766 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
767 for (k = 0; k < s->subband_activity[j]; k++) {
768 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
769 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
770 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
771 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
773 av_log(s->avctx, AV_LOG_DEBUG, "\n");
775 for (j = base_channel; j < s->prim_channels; j++) {
776 if (s->joint_intensity[j] > 0) {
777 int source_channel = s->joint_intensity[j] - 1;
778 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
779 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
780 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
781 av_log(s->avctx, AV_LOG_DEBUG, "\n");
784 if (!base_channel && s->prim_channels > 2 && s->downmix) {
785 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
786 for (j = 0; j < s->prim_channels; j++) {
787 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
788 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
790 av_log(s->avctx, AV_LOG_DEBUG, "\n");
792 for (j = base_channel; j < s->prim_channels; j++)
793 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
794 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
795 if (!base_channel && s->lfe) {
796 int lfe_samples = 2 * s->lfe * (4 + block_index);
797 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
799 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
800 for (j = lfe_samples; j < lfe_end_sample; j++)
801 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
802 av_log(s->avctx, AV_LOG_DEBUG, "\n");
809 static void qmf_32_subbands(DCAContext * s, int chans,
810 float samples_in[32][8], float *samples_out,
811 float scale, float bias)
813 const float *prCoeff;
816 int sb_act = s->subband_activity[chans];
819 scale *= sqrt(1/8.0);
822 if (!s->multirate_inter) /* Non-perfect reconstruction */
823 prCoeff = fir_32bands_nonperfect;
824 else /* Perfect reconstruction */
825 prCoeff = fir_32bands_perfect;
827 /* Reconstructed channel sample index */
828 for (subindex = 0; subindex < 8; subindex++) {
829 /* Load in one sample from each subband and clear inactive subbands */
830 for (i = 0; i < sb_act; i++){
831 uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
832 AV_WN32A(&s->raXin[i], v);
837 s->synth.synth_filter_float(&s->imdct,
838 s->subband_fir_hist[chans], &s->hist_index[chans],
839 s->subband_fir_noidea[chans], prCoeff,
840 samples_out, s->raXin, scale, bias);
846 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
847 int num_deci_sample, float *samples_in,
848 float *samples_out, float scale,
851 /* samples_in: An array holding decimated samples.
852 * Samples in current subframe starts from samples_in[0],
853 * while samples_in[-1], samples_in[-2], ..., stores samples
854 * from last subframe as history.
856 * samples_out: An array holding interpolated samples
860 const float *prCoeff;
863 /* Select decimation filter */
864 if (decimation_select == 1) {
866 prCoeff = lfe_fir_128;
869 prCoeff = lfe_fir_64;
872 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
873 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
876 samples_out += 2 * decifactor;
880 /* downmixing routines */
881 #define MIX_REAR1(samples, si1, rs, coef) \
882 samples[i] += (samples[si1] - add_bias) * coef[rs][0]; \
883 samples[i+256] += (samples[si1] - add_bias) * coef[rs][1];
885 #define MIX_REAR2(samples, si1, si2, rs, coef) \
886 samples[i] += (samples[si1] - add_bias) * coef[rs][0] + (samples[si2] - add_bias) * coef[rs+1][0]; \
887 samples[i+256] += (samples[si1] - add_bias) * coef[rs][1] + (samples[si2] - add_bias) * coef[rs+1][1];
889 #define MIX_FRONT3(samples, coef) \
890 t = samples[i+c] - add_bias; \
891 u = samples[i+l] - add_bias; \
892 v = samples[i+r] - add_bias; \
893 samples[i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0] + add_bias; \
894 samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1] + add_bias;
896 #define DOWNMIX_TO_STEREO(op1, op2) \
897 for (i = 0; i < 256; i++){ \
902 static void dca_downmix(float *samples, int srcfmt,
903 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
904 const int8_t *channel_mapping, float add_bias)
909 float coef[DCA_PRIM_CHANNELS_MAX][2];
911 for (i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
912 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
913 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
919 case DCA_STEREO_TOTAL:
920 case DCA_STEREO_SUMDIFF:
922 av_log(NULL, 0, "Not implemented!\n");
927 c = channel_mapping[0] * 256;
928 l = channel_mapping[1] * 256;
929 r = channel_mapping[2] * 256;
930 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
933 s = channel_mapping[2] * 256;
934 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef),);
937 c = channel_mapping[0] * 256;
938 l = channel_mapping[1] * 256;
939 r = channel_mapping[2] * 256;
940 s = channel_mapping[3] * 256;
941 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
942 MIX_REAR1(samples, i + s, 3, coef));
945 sl = channel_mapping[2] * 256;
946 sr = channel_mapping[3] * 256;
947 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef),);
950 c = channel_mapping[0] * 256;
951 l = channel_mapping[1] * 256;
952 r = channel_mapping[2] * 256;
953 sl = channel_mapping[3] * 256;
954 sr = channel_mapping[4] * 256;
955 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
956 MIX_REAR2(samples, i + sl, i + sr, 3, coef));
962 /* Very compact version of the block code decoder that does not use table
963 * look-up but is slightly slower */
964 static int decode_blockcode(int code, int levels, int *values)
967 int offset = (levels - 1) >> 1;
969 for (i = 0; i < 4; i++) {
970 int div = FASTDIV(code, levels);
971 values[i] = code - offset - div*levels;
978 av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
983 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
984 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
986 static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
989 int subsubframe = s->current_subsubframe;
991 const float *quant_step_table;
994 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
995 LOCAL_ALIGNED_16(int, block, [8]);
1001 /* Select quantization step size table */
1002 if (s->bit_rate_index == 0x1f)
1003 quant_step_table = lossless_quant_d;
1005 quant_step_table = lossy_quant_d;
1007 for (k = base_channel; k < s->prim_channels; k++) {
1008 for (l = 0; l < s->vq_start_subband[k]; l++) {
1011 /* Select the mid-tread linear quantizer */
1012 int abits = s->bitalloc[k][l];
1014 float quant_step_size = quant_step_table[abits];
1017 * Determine quantization index code book and its type
1020 /* Select quantization index code book */
1021 int sel = s->quant_index_huffman[k][abits];
1024 * Extract bits from the bit stream
1027 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1029 /* Deal with transients */
1030 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1031 float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
1033 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
1036 int block_code1, block_code2, size, levels;
1038 size = abits_sizes[abits-1];
1039 levels = abits_levels[abits-1];
1041 block_code1 = get_bits(&s->gb, size);
1042 /* FIXME Should test return value */
1043 decode_blockcode(block_code1, levels, block);
1044 block_code2 = get_bits(&s->gb, size);
1045 decode_blockcode(block_code2, levels, &block[4]);
1048 for (m = 0; m < 8; m++)
1049 block[m] = get_sbits(&s->gb, abits - 3);
1053 for (m = 0; m < 8; m++)
1054 block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1057 s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
1062 * Inverse ADPCM if in prediction mode
1064 if (s->prediction_mode[k][l]) {
1066 for (m = 0; m < 8; m++) {
1067 for (n = 1; n <= 4; n++)
1069 subband_samples[k][l][m] +=
1070 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1071 subband_samples[k][l][m - n] / 8192);
1072 else if (s->predictor_history)
1073 subband_samples[k][l][m] +=
1074 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1075 s->subband_samples_hist[k][l][m - n +
1082 * Decode VQ encoded high frequencies
1084 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1085 /* 1 vector -> 32 samples but we only need the 8 samples
1086 * for this subsubframe. */
1089 if (!s->debug_flag & 0x01) {
1090 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1091 s->debug_flag |= 0x01;
1094 for (m = 0; m < 8; m++) {
1095 subband_samples[k][l][m] =
1096 high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1098 * (float) s->scale_factor[k][l][0] / 16.0;
1103 /* Check for DSYNC after subsubframe */
1104 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1105 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1107 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1110 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1114 /* Backup predictor history for adpcm */
1115 for (k = base_channel; k < s->prim_channels; k++)
1116 for (l = 0; l < s->vq_start_subband[k]; l++)
1117 memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1118 4 * sizeof(subband_samples[0][0][0]));
1123 static int dca_filter_channels(DCAContext * s, int block_index)
1125 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1128 /* 32 subbands QMF */
1129 for (k = 0; k < s->prim_channels; k++) {
1130 /* static float pcm_to_double[8] =
1131 {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1132 qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1133 M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1138 if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1139 dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab, s->add_bias);
1142 /* Generate LFE samples for this subsubframe FIXME!!! */
1143 if (s->output & DCA_LFE) {
1144 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1145 s->lfe_data + 2 * s->lfe * (block_index + 4),
1146 &s->samples[256 * dca_lfe_index[s->amode]],
1147 (1.0/256.0)*s->scale_bias, s->add_bias);
1148 /* Outputs 20bits pcm samples */
1155 static int dca_subframe_footer(DCAContext * s, int base_channel)
1157 int aux_data_count = 0, i;
1160 * Unpack optional information
1163 /* presumably optional information only appears in the core? */
1164 if (!base_channel) {
1166 get_bits(&s->gb, 32);
1169 aux_data_count = get_bits(&s->gb, 6);
1171 for (i = 0; i < aux_data_count; i++)
1172 get_bits(&s->gb, 8);
1174 if (s->crc_present && (s->downmix || s->dynrange))
1175 get_bits(&s->gb, 16);
1182 * Decode a dca frame block
1184 * @param s pointer to the DCAContext
1187 static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1191 if (s->current_subframe >= s->subframes) {
1192 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1193 s->current_subframe, s->subframes);
1197 if (!s->current_subsubframe) {
1199 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1201 /* Read subframe header */
1202 if (dca_subframe_header(s, base_channel, block_index))
1206 /* Read subsubframe */
1208 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1210 if (dca_subsubframe(s, base_channel, block_index))
1214 s->current_subsubframe++;
1215 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1216 s->current_subsubframe = 0;
1217 s->current_subframe++;
1219 if (s->current_subframe >= s->subframes) {
1221 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1223 /* Read subframe footer */
1224 if (dca_subframe_footer(s, base_channel))
1232 * Convert bitstream to one representation based on sync marker
1234 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1239 const uint16_t *ssrc = (const uint16_t *) src;
1240 uint16_t *sdst = (uint16_t *) dst;
1243 if ((unsigned)src_size > (unsigned)max_size) {
1244 // av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1246 src_size = max_size;
1251 case DCA_MARKER_RAW_BE:
1252 memcpy(dst, src, src_size);
1254 case DCA_MARKER_RAW_LE:
1255 for (i = 0; i < (src_size + 1) >> 1; i++)
1256 *sdst++ = av_bswap16(*ssrc++);
1258 case DCA_MARKER_14B_BE:
1259 case DCA_MARKER_14B_LE:
1260 init_put_bits(&pb, dst, max_size);
1261 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1262 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1263 put_bits(&pb, 14, tmp);
1265 flush_put_bits(&pb);
1266 return (put_bits_count(&pb) + 7) >> 3;
1273 * Main frame decoding function
1274 * FIXME add arguments
1276 static int dca_decode_frame(AVCodecContext * avctx,
1277 void *data, int *data_size,
1280 const uint8_t *buf = avpkt->data;
1281 int buf_size = avpkt->size;
1284 int num_core_channels = 0;
1286 int16_t *samples = data;
1287 DCAContext *s = avctx->priv_data;
1292 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1293 if (s->dca_buffer_size == -1) {
1294 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1298 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1299 if (dca_parse_frame_header(s) < 0) {
1300 //seems like the frame is corrupt, try with the next one
1304 //set AVCodec values with parsed data
1305 avctx->sample_rate = s->sample_rate;
1306 avctx->bit_rate = s->bit_rate;
1308 for (i = 0; i < (s->sample_blocks / 8); i++) {
1309 dca_decode_block(s, 0, i);
1312 /* record number of core channels incase less than max channels are requested */
1313 num_core_channels = s->prim_channels;
1315 /* extensions start at 32-bit boundaries into bitstream */
1316 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1318 while(get_bits_left(&s->gb) >= 32) {
1319 uint32_t bits = get_bits_long(&s->gb, 32);
1323 int ext_amode, xch_fsize;
1325 s->xch_base_channel = s->prim_channels;
1327 /* validate sync word using XCHFSIZE field */
1328 xch_fsize = show_bits(&s->gb, 10);
1329 if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1330 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1333 /* skip length-to-end-of-frame field for the moment */
1334 skip_bits(&s->gb, 10);
1336 /* extension amode should == 1, number of channels in extension */
1337 /* AFAIK XCh is not used for more channels */
1338 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1339 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1340 " supported!\n",ext_amode);
1344 /* much like core primary audio coding header */
1345 dca_parse_audio_coding_header(s, s->xch_base_channel);
1347 for (i = 0; i < (s->sample_blocks / 8); i++) {
1348 dca_decode_block(s, s->xch_base_channel, i);
1355 av_log(avctx, AV_LOG_DEBUG, "Possible X96 extension found at %d bits\n", get_bits_count(&s->gb));
1356 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", get_bits(&s->gb, 12)+1);
1357 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1361 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1364 channels = s->prim_channels + !!s->lfe;
1367 avctx->channel_layout = dca_core_channel_layout[s->amode];
1369 if (s->xch_present && (!avctx->request_channels ||
1370 avctx->request_channels > num_core_channels + !!s->lfe)) {
1371 avctx->channel_layout |= CH_BACK_CENTER;
1373 avctx->channel_layout |= CH_LOW_FREQUENCY;
1374 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1376 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1379 channels = num_core_channels + !!s->lfe;
1380 s->xch_present = 0; /* disable further xch processing */
1382 avctx->channel_layout |= CH_LOW_FREQUENCY;
1383 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1385 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1388 if (channels > !!s->lfe &&
1389 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1392 if (avctx->request_channels == 2 && s->prim_channels > 2) {
1394 s->output = DCA_STEREO;
1395 avctx->channel_layout = CH_LAYOUT_STEREO;
1398 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1403 /* There is nothing that prevents a dts frame to change channel configuration
1404 but FFmpeg doesn't support that so only set the channels if it is previously
1405 unset. Ideally during the first probe for channels the crc should be checked
1406 and only set avctx->channels when the crc is ok. Right now the decoder could
1407 set the channels based on a broken first frame.*/
1408 avctx->channels = channels;
1410 if (*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1412 *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1414 /* filter to get final output */
1415 for (i = 0; i < (s->sample_blocks / 8); i++) {
1416 dca_filter_channels(s, i);
1418 /* If this was marked as a DTS-ES stream we need to subtract back- */
1419 /* channel from SL & SR to remove matrixed back-channel signal */
1420 if((s->source_pcm_res & 1) && s->xch_present) {
1421 float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1422 float* lt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1423 float* rt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1425 for(j = 0; j < 256; ++j) {
1426 lt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1427 rt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1431 s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1432 samples += 256 * channels;
1435 /* update lfe history */
1436 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1437 for (i = 0; i < 2 * s->lfe * 4; i++) {
1438 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1447 * DCA initialization
1449 * @param avctx pointer to the AVCodecContext
1452 static av_cold int dca_decode_init(AVCodecContext * avctx)
1454 DCAContext *s = avctx->priv_data;
1460 dsputil_init(&s->dsp, avctx);
1461 ff_mdct_init(&s->imdct, 6, 1, 1.0);
1462 ff_synth_filter_init(&s->synth);
1463 ff_dcadsp_init(&s->dcadsp);
1465 for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
1466 s->samples_chanptr[i] = s->samples + i * 256;
1467 avctx->sample_fmt = SAMPLE_FMT_S16;
1469 if (s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1470 s->add_bias = 385.0f;
1471 s->scale_bias = 1.0 / 32768.0;
1474 s->scale_bias = 1.0;
1476 /* allow downmixing to stereo */
1477 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1478 avctx->request_channels == 2) {
1479 avctx->channels = avctx->request_channels;
1487 static av_cold int dca_decode_end(AVCodecContext * avctx)
1489 DCAContext *s = avctx->priv_data;
1490 ff_mdct_end(&s->imdct);
1494 AVCodec dca_decoder = {
1496 .type = AVMEDIA_TYPE_AUDIO,
1498 .priv_data_size = sizeof(DCAContext),
1499 .init = dca_decode_init,
1500 .decode = dca_decode_frame,
1501 .close = dca_decode_end,
1502 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),