Remove explicit filename from Doxygen @file commands.
[libav.git] / libavcodec / dca.c
1 /*
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
7 *
8 * This file is part of FFmpeg.
9 *
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.
14 *
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.
19 *
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
23 */
24
25 #include <math.h>
26 #include <stddef.h>
27 #include <stdio.h>
28
29 #include "libavutil/intmath.h"
30 #include "libavutil/intreadwrite.h"
31 #include "avcodec.h"
32 #include "dsputil.h"
33 #include "fft.h"
34 #include "get_bits.h"
35 #include "put_bits.h"
36 #include "dcadata.h"
37 #include "dcahuff.h"
38 #include "dca.h"
39 #include "synth_filter.h"
40 #include "dcadsp.h"
41
42 //#define TRACE
43
44 #define DCA_PRIM_CHANNELS_MAX (5)
45 #define DCA_SUBBANDS (32)
46 #define DCA_ABITS_MAX (32) /* Should be 28 */
47 #define DCA_SUBSUBFAMES_MAX (4)
48 #define DCA_LFE_MAX (3)
49
50 enum DCAMode {
51 DCA_MONO = 0,
52 DCA_CHANNEL,
53 DCA_STEREO,
54 DCA_STEREO_SUMDIFF,
55 DCA_STEREO_TOTAL,
56 DCA_3F,
57 DCA_2F1R,
58 DCA_3F1R,
59 DCA_2F2R,
60 DCA_3F2R,
61 DCA_4F2R
62 };
63
64 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
65 * Some compromises have been made for special configurations. Most configurations
66 * are never used so complete accuracy is not needed.
67 *
68 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
69 * S -> side, when both rear and back are configured move one of them to the side channel
70 * OV -> center back
71 * All 2 channel configurations -> CH_LAYOUT_STEREO
72 */
73
74 static const int64_t dca_core_channel_layout[] = {
75 CH_FRONT_CENTER, ///< 1, A
76 CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
77 CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
78 CH_LAYOUT_STEREO, ///< 2, (L+R) + (L-R) (sum-difference)
79 CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total)
80 CH_LAYOUT_STEREO|CH_FRONT_CENTER, ///< 3, C+L+R
81 CH_LAYOUT_STEREO|CH_BACK_CENTER, ///< 3, L+R+S
82 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 4, C + L + R+ S
83 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 4, L + R +SL+ SR
84 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
85 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
86 CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 6, C + L + R+ LR + RR + OV
87 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
88 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
89 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
90 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
91 };
92
93 static const int8_t dca_lfe_index[] = {
94 1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
95 };
96
97 static const int8_t dca_channel_reorder_lfe[][8] = {
98 { 0, -1, -1, -1, -1, -1, -1, -1},
99 { 0, 1, -1, -1, -1, -1, -1, -1},
100 { 0, 1, -1, -1, -1, -1, -1, -1},
101 { 0, 1, -1, -1, -1, -1, -1, -1},
102 { 0, 1, -1, -1, -1, -1, -1, -1},
103 { 2, 0, 1, -1, -1, -1, -1, -1},
104 { 0, 1, 3, -1, -1, -1, -1, -1},
105 { 2, 0, 1, 4, -1, -1, -1, -1},
106 { 0, 1, 3, 4, -1, -1, -1, -1},
107 { 2, 0, 1, 4, 5, -1, -1, -1},
108 { 3, 4, 0, 1, 5, 6, -1, -1},
109 { 2, 0, 1, 4, 5, 6, -1, -1},
110 { 0, 6, 4, 5, 2, 3, -1, -1},
111 { 4, 2, 5, 0, 1, 6, 7, -1},
112 { 5, 6, 0, 1, 7, 3, 8, 4},
113 { 4, 2, 5, 0, 1, 6, 8, 7},
114 };
115
116 static const int8_t dca_channel_reorder_nolfe[][8] = {
117 { 0, -1, -1, -1, -1, -1, -1, -1},
118 { 0, 1, -1, -1, -1, -1, -1, -1},
119 { 0, 1, -1, -1, -1, -1, -1, -1},
120 { 0, 1, -1, -1, -1, -1, -1, -1},
121 { 0, 1, -1, -1, -1, -1, -1, -1},
122 { 2, 0, 1, -1, -1, -1, -1, -1},
123 { 0, 1, 2, -1, -1, -1, -1, -1},
124 { 2, 0, 1, 3, -1, -1, -1, -1},
125 { 0, 1, 2, 3, -1, -1, -1, -1},
126 { 2, 0, 1, 3, 4, -1, -1, -1},
127 { 2, 3, 0, 1, 4, 5, -1, -1},
128 { 2, 0, 1, 3, 4, 5, -1, -1},
129 { 0, 5, 3, 4, 1, 2, -1, -1},
130 { 3, 2, 4, 0, 1, 5, 6, -1},
131 { 4, 5, 0, 1, 6, 2, 7, 3},
132 { 3, 2, 4, 0, 1, 5, 7, 6},
133 };
134
135
136 #define DCA_DOLBY 101 /* FIXME */
137
138 #define DCA_CHANNEL_BITS 6
139 #define DCA_CHANNEL_MASK 0x3F
140
141 #define DCA_LFE 0x80
142
143 #define HEADER_SIZE 14
144
145 #define DCA_MAX_FRAME_SIZE 16384
146
147 /** Bit allocation */
148 typedef struct {
149 int offset; ///< code values offset
150 int maxbits[8]; ///< max bits in VLC
151 int wrap; ///< wrap for get_vlc2()
152 VLC vlc[8]; ///< actual codes
153 } BitAlloc;
154
155 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
156 static BitAlloc dca_tmode; ///< transition mode VLCs
157 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
158 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
159
160 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
161 {
162 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
163 }
164
165 typedef struct {
166 AVCodecContext *avctx;
167 /* Frame header */
168 int frame_type; ///< type of the current frame
169 int samples_deficit; ///< deficit sample count
170 int crc_present; ///< crc is present in the bitstream
171 int sample_blocks; ///< number of PCM sample blocks
172 int frame_size; ///< primary frame byte size
173 int amode; ///< audio channels arrangement
174 int sample_rate; ///< audio sampling rate
175 int bit_rate; ///< transmission bit rate
176 int bit_rate_index; ///< transmission bit rate index
177
178 int downmix; ///< embedded downmix enabled
179 int dynrange; ///< embedded dynamic range flag
180 int timestamp; ///< embedded time stamp flag
181 int aux_data; ///< auxiliary data flag
182 int hdcd; ///< source material is mastered in HDCD
183 int ext_descr; ///< extension audio descriptor flag
184 int ext_coding; ///< extended coding flag
185 int aspf; ///< audio sync word insertion flag
186 int lfe; ///< low frequency effects flag
187 int predictor_history; ///< predictor history flag
188 int header_crc; ///< header crc check bytes
189 int multirate_inter; ///< multirate interpolator switch
190 int version; ///< encoder software revision
191 int copy_history; ///< copy history
192 int source_pcm_res; ///< source pcm resolution
193 int front_sum; ///< front sum/difference flag
194 int surround_sum; ///< surround sum/difference flag
195 int dialog_norm; ///< dialog normalisation parameter
196
197 /* Primary audio coding header */
198 int subframes; ///< number of subframes
199 int total_channels; ///< number of channels including extensions
200 int prim_channels; ///< number of primary audio channels
201 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
202 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
203 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
204 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
205 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
206 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
207 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
208 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
209
210 /* Primary audio coding side information */
211 int subsubframes; ///< number of subsubframes
212 int partial_samples; ///< partial subsubframe samples count
213 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
214 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
215 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
216 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
217 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
218 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
219 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
220 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
221 int dynrange_coef; ///< dynamic range coefficient
222
223 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
224
225 float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *
226 2 /*history */ ]; ///< Low frequency effect data
227 int lfe_scale_factor;
228
229 /* Subband samples history (for ADPCM) */
230 float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
231 DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
232 DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
233 int hist_index[DCA_PRIM_CHANNELS_MAX];
234 DECLARE_ALIGNED(16, float, raXin)[32];
235
236 int output; ///< type of output
237 float add_bias; ///< output bias
238 float scale_bias; ///< output scale
239
240 DECLARE_ALIGNED(16, float, samples)[1536]; /* 6 * 256 = 1536, might only need 5 */
241 const float *samples_chanptr[6];
242
243 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
244 int dca_buffer_size; ///< how much data is in the dca_buffer
245
246 const int8_t* channel_order_tab; ///< channel reordering table, lfe and non lfe
247 GetBitContext gb;
248 /* Current position in DCA frame */
249 int current_subframe;
250 int current_subsubframe;
251
252 int debug_flag; ///< used for suppressing repeated error messages output
253 DSPContext dsp;
254 FFTContext imdct;
255 SynthFilterContext synth;
256 DCADSPContext dcadsp;
257 } DCAContext;
258
259 static const uint16_t dca_vlc_offs[] = {
260 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
261 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
262 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
263 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
264 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
265 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
266 };
267
268 static av_cold void dca_init_vlcs(void)
269 {
270 static int vlcs_initialized = 0;
271 int i, j, c = 14;
272 static VLC_TYPE dca_table[23622][2];
273
274 if (vlcs_initialized)
275 return;
276
277 dca_bitalloc_index.offset = 1;
278 dca_bitalloc_index.wrap = 2;
279 for (i = 0; i < 5; i++) {
280 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
281 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
282 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
283 bitalloc_12_bits[i], 1, 1,
284 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
285 }
286 dca_scalefactor.offset = -64;
287 dca_scalefactor.wrap = 2;
288 for (i = 0; i < 5; i++) {
289 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
290 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
291 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
292 scales_bits[i], 1, 1,
293 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
294 }
295 dca_tmode.offset = 0;
296 dca_tmode.wrap = 1;
297 for (i = 0; i < 4; i++) {
298 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
299 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
300 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
301 tmode_bits[i], 1, 1,
302 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
303 }
304
305 for(i = 0; i < 10; i++)
306 for(j = 0; j < 7; j++){
307 if(!bitalloc_codes[i][j]) break;
308 dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
309 dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
310 dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
311 dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
312 init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
313 bitalloc_sizes[i],
314 bitalloc_bits[i][j], 1, 1,
315 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
316 c++;
317 }
318 vlcs_initialized = 1;
319 }
320
321 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
322 {
323 while(len--)
324 *dst++ = get_bits(gb, bits);
325 }
326
327 static int dca_parse_frame_header(DCAContext * s)
328 {
329 int i, j;
330 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
331 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
332 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
333
334 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
335
336 /* Sync code */
337 get_bits(&s->gb, 32);
338
339 /* Frame header */
340 s->frame_type = get_bits(&s->gb, 1);
341 s->samples_deficit = get_bits(&s->gb, 5) + 1;
342 s->crc_present = get_bits(&s->gb, 1);
343 s->sample_blocks = get_bits(&s->gb, 7) + 1;
344 s->frame_size = get_bits(&s->gb, 14) + 1;
345 if (s->frame_size < 95)
346 return -1;
347 s->amode = get_bits(&s->gb, 6);
348 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
349 if (!s->sample_rate)
350 return -1;
351 s->bit_rate_index = get_bits(&s->gb, 5);
352 s->bit_rate = dca_bit_rates[s->bit_rate_index];
353 if (!s->bit_rate)
354 return -1;
355
356 s->downmix = get_bits(&s->gb, 1);
357 s->dynrange = get_bits(&s->gb, 1);
358 s->timestamp = get_bits(&s->gb, 1);
359 s->aux_data = get_bits(&s->gb, 1);
360 s->hdcd = get_bits(&s->gb, 1);
361 s->ext_descr = get_bits(&s->gb, 3);
362 s->ext_coding = get_bits(&s->gb, 1);
363 s->aspf = get_bits(&s->gb, 1);
364 s->lfe = get_bits(&s->gb, 2);
365 s->predictor_history = get_bits(&s->gb, 1);
366
367 /* TODO: check CRC */
368 if (s->crc_present)
369 s->header_crc = get_bits(&s->gb, 16);
370
371 s->multirate_inter = get_bits(&s->gb, 1);
372 s->version = get_bits(&s->gb, 4);
373 s->copy_history = get_bits(&s->gb, 2);
374 s->source_pcm_res = get_bits(&s->gb, 3);
375 s->front_sum = get_bits(&s->gb, 1);
376 s->surround_sum = get_bits(&s->gb, 1);
377 s->dialog_norm = get_bits(&s->gb, 4);
378
379 /* FIXME: channels mixing levels */
380 s->output = s->amode;
381 if(s->lfe) s->output |= DCA_LFE;
382
383 #ifdef TRACE
384 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
385 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
386 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
387 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
388 s->sample_blocks, s->sample_blocks * 32);
389 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
390 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
391 s->amode, dca_channels[s->amode]);
392 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
393 s->sample_rate);
394 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
395 s->bit_rate);
396 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
397 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
398 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
399 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
400 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
401 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
402 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
403 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
404 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
405 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
406 s->predictor_history);
407 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
408 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
409 s->multirate_inter);
410 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
411 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
412 av_log(s->avctx, AV_LOG_DEBUG,
413 "source pcm resolution: %i (%i bits/sample)\n",
414 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
415 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
416 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
417 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
418 av_log(s->avctx, AV_LOG_DEBUG, "\n");
419 #endif
420
421 /* Primary audio coding header */
422 s->subframes = get_bits(&s->gb, 4) + 1;
423 s->total_channels = get_bits(&s->gb, 3) + 1;
424 s->prim_channels = s->total_channels;
425 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
426 s->prim_channels = DCA_PRIM_CHANNELS_MAX; /* We only support DTS core */
427
428
429 for (i = 0; i < s->prim_channels; i++) {
430 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
431 if (s->subband_activity[i] > DCA_SUBBANDS)
432 s->subband_activity[i] = DCA_SUBBANDS;
433 }
434 for (i = 0; i < s->prim_channels; i++) {
435 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
436 if (s->vq_start_subband[i] > DCA_SUBBANDS)
437 s->vq_start_subband[i] = DCA_SUBBANDS;
438 }
439 get_array(&s->gb, s->joint_intensity, s->prim_channels, 3);
440 get_array(&s->gb, s->transient_huffman, s->prim_channels, 2);
441 get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
442 get_array(&s->gb, s->bitalloc_huffman, s->prim_channels, 3);
443
444 /* Get codebooks quantization indexes */
445 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
446 for (j = 1; j < 11; j++)
447 for (i = 0; i < s->prim_channels; i++)
448 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
449
450 /* Get scale factor adjustment */
451 for (j = 0; j < 11; j++)
452 for (i = 0; i < s->prim_channels; i++)
453 s->scalefactor_adj[i][j] = 1;
454
455 for (j = 1; j < 11; j++)
456 for (i = 0; i < s->prim_channels; i++)
457 if (s->quant_index_huffman[i][j] < thr[j])
458 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
459
460 if (s->crc_present) {
461 /* Audio header CRC check */
462 get_bits(&s->gb, 16);
463 }
464
465 s->current_subframe = 0;
466 s->current_subsubframe = 0;
467
468 #ifdef TRACE
469 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
470 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
471 for(i = 0; i < s->prim_channels; i++){
472 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
473 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
474 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
475 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
476 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
477 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
478 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
479 for (j = 0; j < 11; j++)
480 av_log(s->avctx, AV_LOG_DEBUG, " %i",
481 s->quant_index_huffman[i][j]);
482 av_log(s->avctx, AV_LOG_DEBUG, "\n");
483 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
484 for (j = 0; j < 11; j++)
485 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
486 av_log(s->avctx, AV_LOG_DEBUG, "\n");
487 }
488 #endif
489
490 return 0;
491 }
492
493
494 static inline int get_scale(GetBitContext *gb, int level, int value)
495 {
496 if (level < 5) {
497 /* huffman encoded */
498 value += get_bitalloc(gb, &dca_scalefactor, level);
499 } else if(level < 8)
500 value = get_bits(gb, level + 1);
501 return value;
502 }
503
504 static int dca_subframe_header(DCAContext * s)
505 {
506 /* Primary audio coding side information */
507 int j, k;
508
509 s->subsubframes = get_bits(&s->gb, 2) + 1;
510 s->partial_samples = get_bits(&s->gb, 3);
511 for (j = 0; j < s->prim_channels; j++) {
512 for (k = 0; k < s->subband_activity[j]; k++)
513 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
514 }
515
516 /* Get prediction codebook */
517 for (j = 0; j < s->prim_channels; j++) {
518 for (k = 0; k < s->subband_activity[j]; k++) {
519 if (s->prediction_mode[j][k] > 0) {
520 /* (Prediction coefficient VQ address) */
521 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
522 }
523 }
524 }
525
526 /* Bit allocation index */
527 for (j = 0; j < s->prim_channels; j++) {
528 for (k = 0; k < s->vq_start_subband[j]; k++) {
529 if (s->bitalloc_huffman[j] == 6)
530 s->bitalloc[j][k] = get_bits(&s->gb, 5);
531 else if (s->bitalloc_huffman[j] == 5)
532 s->bitalloc[j][k] = get_bits(&s->gb, 4);
533 else if (s->bitalloc_huffman[j] == 7) {
534 av_log(s->avctx, AV_LOG_ERROR,
535 "Invalid bit allocation index\n");
536 return -1;
537 } else {
538 s->bitalloc[j][k] =
539 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
540 }
541
542 if (s->bitalloc[j][k] > 26) {
543 // av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
544 // j, k, s->bitalloc[j][k]);
545 return -1;
546 }
547 }
548 }
549
550 /* Transition mode */
551 for (j = 0; j < s->prim_channels; j++) {
552 for (k = 0; k < s->subband_activity[j]; k++) {
553 s->transition_mode[j][k] = 0;
554 if (s->subsubframes > 1 &&
555 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
556 s->transition_mode[j][k] =
557 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
558 }
559 }
560 }
561
562 for (j = 0; j < s->prim_channels; j++) {
563 const uint32_t *scale_table;
564 int scale_sum;
565
566 memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
567
568 if (s->scalefactor_huffman[j] == 6)
569 scale_table = scale_factor_quant7;
570 else
571 scale_table = scale_factor_quant6;
572
573 /* When huffman coded, only the difference is encoded */
574 scale_sum = 0;
575
576 for (k = 0; k < s->subband_activity[j]; k++) {
577 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
578 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
579 s->scale_factor[j][k][0] = scale_table[scale_sum];
580 }
581
582 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
583 /* Get second scale factor */
584 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
585 s->scale_factor[j][k][1] = scale_table[scale_sum];
586 }
587 }
588 }
589
590 /* Joint subband scale factor codebook select */
591 for (j = 0; j < s->prim_channels; j++) {
592 /* Transmitted only if joint subband coding enabled */
593 if (s->joint_intensity[j] > 0)
594 s->joint_huff[j] = get_bits(&s->gb, 3);
595 }
596
597 /* Scale factors for joint subband coding */
598 for (j = 0; j < s->prim_channels; j++) {
599 int source_channel;
600
601 /* Transmitted only if joint subband coding enabled */
602 if (s->joint_intensity[j] > 0) {
603 int scale = 0;
604 source_channel = s->joint_intensity[j] - 1;
605
606 /* When huffman coded, only the difference is encoded
607 * (is this valid as well for joint scales ???) */
608
609 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
610 scale = get_scale(&s->gb, s->joint_huff[j], 0);
611 scale += 64; /* bias */
612 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
613 }
614
615 if (!(s->debug_flag & 0x02)) {
616 av_log(s->avctx, AV_LOG_DEBUG,
617 "Joint stereo coding not supported\n");
618 s->debug_flag |= 0x02;
619 }
620 }
621 }
622
623 /* Stereo downmix coefficients */
624 if (s->prim_channels > 2) {
625 if(s->downmix) {
626 for (j = 0; j < s->prim_channels; j++) {
627 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
628 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
629 }
630 } else {
631 int am = s->amode & DCA_CHANNEL_MASK;
632 for (j = 0; j < s->prim_channels; j++) {
633 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
634 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
635 }
636 }
637 }
638
639 /* Dynamic range coefficient */
640 if (s->dynrange)
641 s->dynrange_coef = get_bits(&s->gb, 8);
642
643 /* Side information CRC check word */
644 if (s->crc_present) {
645 get_bits(&s->gb, 16);
646 }
647
648 /*
649 * Primary audio data arrays
650 */
651
652 /* VQ encoded high frequency subbands */
653 for (j = 0; j < s->prim_channels; j++)
654 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
655 /* 1 vector -> 32 samples */
656 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
657
658 /* Low frequency effect data */
659 if (s->lfe) {
660 /* LFE samples */
661 int lfe_samples = 2 * s->lfe * s->subsubframes;
662 float lfe_scale;
663
664 for (j = lfe_samples; j < lfe_samples * 2; j++) {
665 /* Signed 8 bits int */
666 s->lfe_data[j] = get_sbits(&s->gb, 8);
667 }
668
669 /* Scale factor index */
670 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
671
672 /* Quantization step size * scale factor */
673 lfe_scale = 0.035 * s->lfe_scale_factor;
674
675 for (j = lfe_samples; j < lfe_samples * 2; j++)
676 s->lfe_data[j] *= lfe_scale;
677 }
678
679 #ifdef TRACE
680 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
681 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
682 s->partial_samples);
683 for (j = 0; j < s->prim_channels; j++) {
684 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
685 for (k = 0; k < s->subband_activity[j]; k++)
686 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
687 av_log(s->avctx, AV_LOG_DEBUG, "\n");
688 }
689 for (j = 0; j < s->prim_channels; j++) {
690 for (k = 0; k < s->subband_activity[j]; k++)
691 av_log(s->avctx, AV_LOG_DEBUG,
692 "prediction coefs: %f, %f, %f, %f\n",
693 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
694 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
695 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
696 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
697 }
698 for (j = 0; j < s->prim_channels; j++) {
699 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
700 for (k = 0; k < s->vq_start_subband[j]; k++)
701 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
702 av_log(s->avctx, AV_LOG_DEBUG, "\n");
703 }
704 for (j = 0; j < s->prim_channels; j++) {
705 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
706 for (k = 0; k < s->subband_activity[j]; k++)
707 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
708 av_log(s->avctx, AV_LOG_DEBUG, "\n");
709 }
710 for (j = 0; j < s->prim_channels; j++) {
711 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
712 for (k = 0; k < s->subband_activity[j]; k++) {
713 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
714 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
715 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
716 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
717 }
718 av_log(s->avctx, AV_LOG_DEBUG, "\n");
719 }
720 for (j = 0; j < s->prim_channels; j++) {
721 if (s->joint_intensity[j] > 0) {
722 int source_channel = s->joint_intensity[j] - 1;
723 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
724 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
725 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
726 av_log(s->avctx, AV_LOG_DEBUG, "\n");
727 }
728 }
729 if (s->prim_channels > 2 && s->downmix) {
730 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
731 for (j = 0; j < s->prim_channels; j++) {
732 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
733 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
734 }
735 av_log(s->avctx, AV_LOG_DEBUG, "\n");
736 }
737 for (j = 0; j < s->prim_channels; j++)
738 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
739 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
740 if(s->lfe){
741 int lfe_samples = 2 * s->lfe * s->subsubframes;
742 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
743 for (j = lfe_samples; j < lfe_samples * 2; j++)
744 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
745 av_log(s->avctx, AV_LOG_DEBUG, "\n");
746 }
747 #endif
748
749 return 0;
750 }
751
752 static void qmf_32_subbands(DCAContext * s, int chans,
753 float samples_in[32][8], float *samples_out,
754 float scale, float bias)
755 {
756 const float *prCoeff;
757 int i;
758
759 int sb_act = s->subband_activity[chans];
760 int subindex;
761
762 scale *= sqrt(1/8.0);
763
764 /* Select filter */
765 if (!s->multirate_inter) /* Non-perfect reconstruction */
766 prCoeff = fir_32bands_nonperfect;
767 else /* Perfect reconstruction */
768 prCoeff = fir_32bands_perfect;
769
770 /* Reconstructed channel sample index */
771 for (subindex = 0; subindex < 8; subindex++) {
772 /* Load in one sample from each subband and clear inactive subbands */
773 for (i = 0; i < sb_act; i++){
774 uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
775 AV_WN32A(&s->raXin[i], v);
776 }
777 for (; i < 32; i++)
778 s->raXin[i] = 0.0;
779
780 s->synth.synth_filter_float(&s->imdct,
781 s->subband_fir_hist[chans], &s->hist_index[chans],
782 s->subband_fir_noidea[chans], prCoeff,
783 samples_out, s->raXin, scale, bias);
784 samples_out+= 32;
785
786 }
787 }
788
789 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
790 int num_deci_sample, float *samples_in,
791 float *samples_out, float scale,
792 float bias)
793 {
794 /* samples_in: An array holding decimated samples.
795 * Samples in current subframe starts from samples_in[0],
796 * while samples_in[-1], samples_in[-2], ..., stores samples
797 * from last subframe as history.
798 *
799 * samples_out: An array holding interpolated samples
800 */
801
802 int decifactor;
803 const float *prCoeff;
804 int deciindex;
805
806 /* Select decimation filter */
807 if (decimation_select == 1) {
808 decifactor = 64;
809 prCoeff = lfe_fir_128;
810 } else {
811 decifactor = 32;
812 prCoeff = lfe_fir_64;
813 }
814 /* Interpolation */
815 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
816 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
817 scale, bias);
818 samples_in++;
819 samples_out += 2 * decifactor;
820 }
821 }
822
823 /* downmixing routines */
824 #define MIX_REAR1(samples, si1, rs, coef) \
825 samples[i] += samples[si1] * coef[rs][0]; \
826 samples[i+256] += samples[si1] * coef[rs][1];
827
828 #define MIX_REAR2(samples, si1, si2, rs, coef) \
829 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
830 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
831
832 #define MIX_FRONT3(samples, coef) \
833 t = samples[i]; \
834 samples[i] = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
835 samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
836
837 #define DOWNMIX_TO_STEREO(op1, op2) \
838 for(i = 0; i < 256; i++){ \
839 op1 \
840 op2 \
841 }
842
843 static void dca_downmix(float *samples, int srcfmt,
844 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
845 {
846 int i;
847 float t;
848 float coef[DCA_PRIM_CHANNELS_MAX][2];
849
850 for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
851 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
852 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
853 }
854
855 switch (srcfmt) {
856 case DCA_MONO:
857 case DCA_CHANNEL:
858 case DCA_STEREO_TOTAL:
859 case DCA_STEREO_SUMDIFF:
860 case DCA_4F2R:
861 av_log(NULL, 0, "Not implemented!\n");
862 break;
863 case DCA_STEREO:
864 break;
865 case DCA_3F:
866 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
867 break;
868 case DCA_2F1R:
869 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
870 break;
871 case DCA_3F1R:
872 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
873 MIX_REAR1(samples, i + 768, 3, coef));
874 break;
875 case DCA_2F2R:
876 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
877 break;
878 case DCA_3F2R:
879 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
880 MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
881 break;
882 }
883 }
884
885
886 /* Very compact version of the block code decoder that does not use table
887 * look-up but is slightly slower */
888 static int decode_blockcode(int code, int levels, int *values)
889 {
890 int i;
891 int offset = (levels - 1) >> 1;
892
893 for (i = 0; i < 4; i++) {
894 int div = FASTDIV(code, levels);
895 values[i] = code - offset - div*levels;
896 code = div;
897 }
898
899 if (code == 0)
900 return 0;
901 else {
902 av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
903 return -1;
904 }
905 }
906
907 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
908 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
909
910 static int dca_subsubframe(DCAContext * s)
911 {
912 int k, l;
913 int subsubframe = s->current_subsubframe;
914
915 const float *quant_step_table;
916
917 /* FIXME */
918 LOCAL_ALIGNED_16(float, subband_samples, [DCA_PRIM_CHANNELS_MAX], [DCA_SUBBANDS][8]);
919 LOCAL_ALIGNED_16(int, block, [8]);
920
921 /*
922 * Audio data
923 */
924
925 /* Select quantization step size table */
926 if (s->bit_rate_index == 0x1f)
927 quant_step_table = lossless_quant_d;
928 else
929 quant_step_table = lossy_quant_d;
930
931 for (k = 0; k < s->prim_channels; k++) {
932 for (l = 0; l < s->vq_start_subband[k]; l++) {
933 int m;
934
935 /* Select the mid-tread linear quantizer */
936 int abits = s->bitalloc[k][l];
937
938 float quant_step_size = quant_step_table[abits];
939
940 /*
941 * Determine quantization index code book and its type
942 */
943
944 /* Select quantization index code book */
945 int sel = s->quant_index_huffman[k][abits];
946
947 /*
948 * Extract bits from the bit stream
949 */
950 if(!abits){
951 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
952 } else {
953 /* Deal with transients */
954 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
955 float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
956
957 if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
958 if(abits <= 7){
959 /* Block code */
960 int block_code1, block_code2, size, levels;
961
962 size = abits_sizes[abits-1];
963 levels = abits_levels[abits-1];
964
965 block_code1 = get_bits(&s->gb, size);
966 /* FIXME Should test return value */
967 decode_blockcode(block_code1, levels, block);
968 block_code2 = get_bits(&s->gb, size);
969 decode_blockcode(block_code2, levels, &block[4]);
970 }else{
971 /* no coding */
972 for (m = 0; m < 8; m++)
973 block[m] = get_sbits(&s->gb, abits - 3);
974 }
975 }else{
976 /* Huffman coded */
977 for (m = 0; m < 8; m++)
978 block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
979 }
980
981 s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
982 block, rscale, 8);
983 }
984
985 /*
986 * Inverse ADPCM if in prediction mode
987 */
988 if (s->prediction_mode[k][l]) {
989 int n;
990 for (m = 0; m < 8; m++) {
991 for (n = 1; n <= 4; n++)
992 if (m >= n)
993 subband_samples[k][l][m] +=
994 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
995 subband_samples[k][l][m - n] / 8192);
996 else if (s->predictor_history)
997 subband_samples[k][l][m] +=
998 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
999 s->subband_samples_hist[k][l][m - n +
1000 4] / 8192);
1001 }
1002 }
1003 }
1004
1005 /*
1006 * Decode VQ encoded high frequencies
1007 */
1008 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1009 /* 1 vector -> 32 samples but we only need the 8 samples
1010 * for this subsubframe. */
1011 int m;
1012
1013 if (!s->debug_flag & 0x01) {
1014 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1015 s->debug_flag |= 0x01;
1016 }
1017
1018 for (m = 0; m < 8; m++) {
1019 subband_samples[k][l][m] =
1020 high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1021 m]
1022 * (float) s->scale_factor[k][l][0] / 16.0;
1023 }
1024 }
1025 }
1026
1027 /* Check for DSYNC after subsubframe */
1028 if (s->aspf || subsubframe == s->subsubframes - 1) {
1029 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1030 #ifdef TRACE
1031 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1032 #endif
1033 } else {
1034 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1035 }
1036 }
1037
1038 /* Backup predictor history for adpcm */
1039 for (k = 0; k < s->prim_channels; k++)
1040 for (l = 0; l < s->vq_start_subband[k]; l++)
1041 memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1042 4 * sizeof(subband_samples[0][0][0]));
1043
1044 /* 32 subbands QMF */
1045 for (k = 0; k < s->prim_channels; k++) {
1046 /* static float pcm_to_double[8] =
1047 {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1048 qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1049 M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1050 s->add_bias );
1051 }
1052
1053 /* Down mixing */
1054
1055 if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1056 dca_downmix(s->samples, s->amode, s->downmix_coef);
1057 }
1058
1059 /* Generate LFE samples for this subsubframe FIXME!!! */
1060 if (s->output & DCA_LFE) {
1061 int lfe_samples = 2 * s->lfe * s->subsubframes;
1062
1063 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1064 s->lfe_data + lfe_samples +
1065 2 * s->lfe * subsubframe,
1066 &s->samples[256 * dca_lfe_index[s->amode]],
1067 (1.0/256.0)*s->scale_bias, s->add_bias);
1068 /* Outputs 20bits pcm samples */
1069 }
1070
1071 return 0;
1072 }
1073
1074
1075 static int dca_subframe_footer(DCAContext * s)
1076 {
1077 int aux_data_count = 0, i;
1078 int lfe_samples;
1079
1080 /*
1081 * Unpack optional information
1082 */
1083
1084 if (s->timestamp)
1085 get_bits(&s->gb, 32);
1086
1087 if (s->aux_data)
1088 aux_data_count = get_bits(&s->gb, 6);
1089
1090 for (i = 0; i < aux_data_count; i++)
1091 get_bits(&s->gb, 8);
1092
1093 if (s->crc_present && (s->downmix || s->dynrange))
1094 get_bits(&s->gb, 16);
1095
1096 lfe_samples = 2 * s->lfe * s->subsubframes;
1097 for (i = 0; i < lfe_samples; i++) {
1098 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1099 }
1100
1101 return 0;
1102 }
1103
1104 /**
1105 * Decode a dca frame block
1106 *
1107 * @param s pointer to the DCAContext
1108 */
1109
1110 static int dca_decode_block(DCAContext * s)
1111 {
1112
1113 /* Sanity check */
1114 if (s->current_subframe >= s->subframes) {
1115 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1116 s->current_subframe, s->subframes);
1117 return -1;
1118 }
1119
1120 if (!s->current_subsubframe) {
1121 #ifdef TRACE
1122 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1123 #endif
1124 /* Read subframe header */
1125 if (dca_subframe_header(s))
1126 return -1;
1127 }
1128
1129 /* Read subsubframe */
1130 #ifdef TRACE
1131 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1132 #endif
1133 if (dca_subsubframe(s))
1134 return -1;
1135
1136 /* Update state */
1137 s->current_subsubframe++;
1138 if (s->current_subsubframe >= s->subsubframes) {
1139 s->current_subsubframe = 0;
1140 s->current_subframe++;
1141 }
1142 if (s->current_subframe >= s->subframes) {
1143 #ifdef TRACE
1144 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1145 #endif
1146 /* Read subframe footer */
1147 if (dca_subframe_footer(s))
1148 return -1;
1149 }
1150
1151 return 0;
1152 }
1153
1154 /**
1155 * Convert bitstream to one representation based on sync marker
1156 */
1157 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1158 int max_size)
1159 {
1160 uint32_t mrk;
1161 int i, tmp;
1162 const uint16_t *ssrc = (const uint16_t *) src;
1163 uint16_t *sdst = (uint16_t *) dst;
1164 PutBitContext pb;
1165
1166 if((unsigned)src_size > (unsigned)max_size) {
1167 // av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1168 // return -1;
1169 src_size = max_size;
1170 }
1171
1172 mrk = AV_RB32(src);
1173 switch (mrk) {
1174 case DCA_MARKER_RAW_BE:
1175 memcpy(dst, src, src_size);
1176 return src_size;
1177 case DCA_MARKER_RAW_LE:
1178 for (i = 0; i < (src_size + 1) >> 1; i++)
1179 *sdst++ = bswap_16(*ssrc++);
1180 return src_size;
1181 case DCA_MARKER_14B_BE:
1182 case DCA_MARKER_14B_LE:
1183 init_put_bits(&pb, dst, max_size);
1184 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1185 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1186 put_bits(&pb, 14, tmp);
1187 }
1188 flush_put_bits(&pb);
1189 return (put_bits_count(&pb) + 7) >> 3;
1190 default:
1191 return -1;
1192 }
1193 }
1194
1195 /**
1196 * Main frame decoding function
1197 * FIXME add arguments
1198 */
1199 static int dca_decode_frame(AVCodecContext * avctx,
1200 void *data, int *data_size,
1201 AVPacket *avpkt)
1202 {
1203 const uint8_t *buf = avpkt->data;
1204 int buf_size = avpkt->size;
1205
1206 int i;
1207 int16_t *samples = data;
1208 DCAContext *s = avctx->priv_data;
1209 int channels;
1210
1211
1212 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1213 if (s->dca_buffer_size == -1) {
1214 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1215 return -1;
1216 }
1217
1218 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1219 if (dca_parse_frame_header(s) < 0) {
1220 //seems like the frame is corrupt, try with the next one
1221 *data_size=0;
1222 return buf_size;
1223 }
1224 //set AVCodec values with parsed data
1225 avctx->sample_rate = s->sample_rate;
1226 avctx->bit_rate = s->bit_rate;
1227
1228 channels = s->prim_channels + !!s->lfe;
1229
1230 if (s->amode<16) {
1231 avctx->channel_layout = dca_core_channel_layout[s->amode];
1232
1233 if (s->lfe) {
1234 avctx->channel_layout |= CH_LOW_FREQUENCY;
1235 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1236 } else
1237 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1238
1239 if (s->prim_channels > 0 &&
1240 s->channel_order_tab[s->prim_channels - 1] < 0)
1241 return -1;
1242
1243 if(avctx->request_channels == 2 && s->prim_channels > 2) {
1244 channels = 2;
1245 s->output = DCA_STEREO;
1246 avctx->channel_layout = CH_LAYOUT_STEREO;
1247 }
1248 } else {
1249 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1250 return -1;
1251 }
1252
1253
1254 /* There is nothing that prevents a dts frame to change channel configuration
1255 but FFmpeg doesn't support that so only set the channels if it is previously
1256 unset. Ideally during the first probe for channels the crc should be checked
1257 and only set avctx->channels when the crc is ok. Right now the decoder could
1258 set the channels based on a broken first frame.*/
1259 if (!avctx->channels)
1260 avctx->channels = channels;
1261
1262 if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1263 return -1;
1264 *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1265 for (i = 0; i < (s->sample_blocks / 8); i++) {
1266 dca_decode_block(s);
1267 s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1268 samples += 256 * channels;
1269 }
1270
1271 return buf_size;
1272 }
1273
1274
1275
1276 /**
1277 * DCA initialization
1278 *
1279 * @param avctx pointer to the AVCodecContext
1280 */
1281
1282 static av_cold int dca_decode_init(AVCodecContext * avctx)
1283 {
1284 DCAContext *s = avctx->priv_data;
1285 int i;
1286
1287 s->avctx = avctx;
1288 dca_init_vlcs();
1289
1290 dsputil_init(&s->dsp, avctx);
1291 ff_mdct_init(&s->imdct, 6, 1, 1.0);
1292 ff_synth_filter_init(&s->synth);
1293 ff_dcadsp_init(&s->dcadsp);
1294
1295 for(i = 0; i < 6; i++)
1296 s->samples_chanptr[i] = s->samples + i * 256;
1297 avctx->sample_fmt = SAMPLE_FMT_S16;
1298
1299 if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1300 s->add_bias = 385.0f;
1301 s->scale_bias = 1.0 / 32768.0;
1302 } else {
1303 s->add_bias = 0.0f;
1304 s->scale_bias = 1.0;
1305
1306 /* allow downmixing to stereo */
1307 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1308 avctx->request_channels == 2) {
1309 avctx->channels = avctx->request_channels;
1310 }
1311 }
1312
1313
1314 return 0;
1315 }
1316
1317 static av_cold int dca_decode_end(AVCodecContext * avctx)
1318 {
1319 DCAContext *s = avctx->priv_data;
1320 ff_mdct_end(&s->imdct);
1321 return 0;
1322 }
1323
1324 AVCodec dca_decoder = {
1325 .name = "dca",
1326 .type = AVMEDIA_TYPE_AUDIO,
1327 .id = CODEC_ID_DTS,
1328 .priv_data_size = sizeof(DCAContext),
1329 .init = dca_decode_init,
1330 .decode = dca_decode_frame,
1331 .close = dca_decode_end,
1332 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1333 };