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