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