ffmpeg / libavcodec / dca.c @ 7d485f16
History  View  Annotate  Download (49.4 KB)
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 021101301 USA

23 
*/

24  
25 
/**

26 
* @file libavcodec/dca.c

27 
*/

28  
29 
#include <math.h> 
30 
#include <stddef.h> 
31 
#include <stdio.h> 
32  
33 
#include "avcodec.h" 
34 
#include "dsputil.h" 
35 
#include "get_bits.h" 
36 
#include "put_bits.h" 
37 
#include "dcadata.h" 
38 
#include "dcahuff.h" 
39 
#include "dca.h" 
40  
41 
//#define TRACE

42  
43 
#define DCA_PRIM_CHANNELS_MAX (5) 
44 
#define DCA_SUBBANDS (32) 
45 
#define DCA_ABITS_MAX (32) /* Should be 28 */ 
46 
#define DCA_SUBSUBFAMES_MAX (4) 
47 
#define DCA_LFE_MAX (3) 
48  
49 
enum DCAMode {

50 
DCA_MONO = 0,

51 
DCA_CHANNEL, 
52 
DCA_STEREO, 
53 
DCA_STEREO_SUMDIFF, 
54 
DCA_STEREO_TOTAL, 
55 
DCA_3F, 
56 
DCA_2F1R, 
57 
DCA_3F1R, 
58 
DCA_2F2R, 
59 
DCA_3F2R, 
60 
DCA_4F2R 
61 
}; 
62  
63 
/* Tables for mapping dts channel configurations to libavcodec multichannel api.

64 
* Some compromises have been made for special configurations. Most configurations

65 
* are never used so complete accuracy is not needed.

66 
*

67 
* L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.

68 
* S > side, when both rear and back are configured move one of them to the side channel

69 
* OV > center back

70 
* All 2 channel configurations > CH_LAYOUT_STEREO

71 
*/

72  
73 
static const int64_t dca_core_channel_layout[] = { 
74 
CH_FRONT_CENTER, ///< 1, A

75 
CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)

76 
CH_LAYOUT_STEREO, ///< 2, L + R (stereo)

77 
CH_LAYOUT_STEREO, ///< 2, (L+R) + (LR) (sumdifference)

78 
CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total)

79 
CH_LAYOUT_STEREOCH_FRONT_CENTER, ///< 3, C+L+R

80 
CH_LAYOUT_STEREOCH_BACK_CENTER, ///< 3, L+R+S

81 
CH_LAYOUT_STEREOCH_FRONT_CENTERCH_BACK_CENTER, ///< 4, C + L + R+ S

82 
CH_LAYOUT_STEREOCH_SIDE_LEFTCH_SIDE_RIGHT, ///< 4, L + R +SL+ SR

83 
CH_LAYOUT_STEREOCH_FRONT_CENTERCH_SIDE_LEFTCH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR

84 
CH_LAYOUT_STEREOCH_SIDE_LEFTCH_SIDE_RIGHTCH_FRONT_LEFT_OF_CENTERCH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR

85 
CH_LAYOUT_STEREOCH_BACK_LEFTCH_BACK_RIGHTCH_FRONT_CENTERCH_BACK_CENTER, ///< 6, C + L + R+ LR + RR + OV

86 
CH_FRONT_CENTERCH_FRONT_RIGHT_OF_CENTERCH_FRONT_LEFT_OF_CENTERCH_BACK_CENTERCH_BACK_LEFTCH_BACK_RIGHT, ///< 6, CF+ CR+LF+ RF+LR + RR

87 
CH_FRONT_LEFT_OF_CENTERCH_FRONT_CENTERCH_FRONT_RIGHT_OF_CENTERCH_LAYOUT_STEREOCH_SIDE_LEFTCH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR

88 
CH_FRONT_LEFT_OF_CENTERCH_FRONT_RIGHT_OF_CENTERCH_LAYOUT_STEREOCH_SIDE_LEFTCH_SIDE_RIGHTCH_BACK_LEFTCH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2

89 
CH_FRONT_LEFT_OF_CENTERCH_FRONT_CENTERCH_FRONT_RIGHT_OF_CENTERCH_LAYOUT_STEREOCH_SIDE_LEFTCH_BACK_CENTERCH_SIDE_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR

90 
}; 
91  
92 
static const int8_t dca_lfe_index[] = { 
93 
1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3 
94 
}; 
95  
96 
static const int8_t dca_channel_reorder_lfe[][8] = { 
97 
{ 0, 1, 1, 1, 1, 1, 1, 1}, 
98 
{ 0, 1, 1, 1, 1, 1, 1, 1}, 
99 
{ 0, 1, 1, 1, 1, 1, 1, 1}, 
100 
{ 0, 1, 1, 1, 1, 1, 1, 1}, 
101 
{ 0, 1, 1, 1, 1, 1, 1, 1}, 
102 
{ 2, 0, 1, 1, 1, 1, 1, 1}, 
103 
{ 0, 1, 3, 1, 1, 1, 1, 1}, 
104 
{ 2, 0, 1, 4, 1, 1, 1, 1}, 
105 
{ 0, 1, 3, 4, 1, 1, 1, 1}, 
106 
{ 2, 0, 1, 4, 5, 1, 1, 1}, 
107 
{ 3, 4, 0, 1, 5, 6, 1, 1}, 
108 
{ 2, 0, 1, 4, 5, 6, 1, 1}, 
109 
{ 0, 6, 4, 5, 2, 3, 1, 1}, 
110 
{ 4, 2, 5, 0, 1, 6, 7, 1}, 
111 
{ 5, 6, 0, 1, 7, 3, 8, 4}, 
112 
{ 4, 2, 5, 0, 1, 6, 8, 7}, 
113 
}; 
114  
115 
static const int8_t dca_channel_reorder_nolfe[][8] = { 
116 
{ 0, 1, 1, 1, 1, 1, 1, 1}, 
117 
{ 0, 1, 1, 1, 1, 1, 1, 1}, 
118 
{ 0, 1, 1, 1, 1, 1, 1, 1}, 
119 
{ 0, 1, 1, 1, 1, 1, 1, 1}, 
120 
{ 0, 1, 1, 1, 1, 1, 1, 1}, 
121 
{ 2, 0, 1, 1, 1, 1, 1, 1}, 
122 
{ 0, 1, 2, 1, 1, 1, 1, 1}, 
123 
{ 2, 0, 1, 3, 1, 1, 1, 1}, 
124 
{ 0, 1, 2, 3, 1, 1, 1, 1}, 
125 
{ 2, 0, 1, 3, 4, 1, 1, 1}, 
126 
{ 2, 3, 0, 1, 4, 5, 1, 1}, 
127 
{ 2, 0, 1, 3, 4, 5, 1, 1}, 
128 
{ 0, 5, 3, 4, 1, 2, 1, 1}, 
129 
{ 3, 2, 4, 0, 1, 5, 6, 1}, 
130 
{ 4, 5, 0, 1, 6, 2, 7, 3}, 
131 
{ 3, 2, 4, 0, 1, 5, 7, 6}, 
132 
}; 
133  
134  
135 
#define DCA_DOLBY 101 /* FIXME */ 
136  
137 
#define DCA_CHANNEL_BITS 6 
138 
#define DCA_CHANNEL_MASK 0x3F 
139  
140 
#define DCA_LFE 0x80 
141  
142 
#define HEADER_SIZE 14 
143  
144 
#define DCA_MAX_FRAME_SIZE 16384 
145  
146 
/** Bit allocation */

147 
typedef struct { 
148 
int offset; ///< code values offset 
149 
int maxbits[8]; ///< max bits in VLC 
150 
int wrap; ///< wrap for get_vlc2() 
151 
VLC vlc[8]; ///< actual codes 
152 
} BitAlloc; 
153  
154 
static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select 
155 
static BitAlloc dca_tmode; ///< transition mode VLCs 
156 
static BitAlloc dca_scalefactor; ///< scalefactor VLCs 
157 
static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs 
158  
159 
static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx) 
160 
{ 
161 
return get_vlc2(gb, ba>vlc[idx].table, ba>vlc[idx].bits, ba>wrap) + ba>offset;

162 
} 
163  
164 
typedef struct { 
165 
AVCodecContext *avctx; 
166 
/* Frame header */

167 
int frame_type; ///< type of the current frame 
168 
int samples_deficit; ///< deficit sample count 
169 
int crc_present; ///< crc is present in the bitstream 
170 
int sample_blocks; ///< number of PCM sample blocks 
171 
int frame_size; ///< primary frame byte size 
172 
int amode; ///< audio channels arrangement 
173 
int sample_rate; ///< audio sampling rate 
174 
int bit_rate; ///< transmission bit rate 
175 
int bit_rate_index; ///< transmission bit rate index 
176  
177 
int downmix; ///< embedded downmix enabled 
178 
int dynrange; ///< embedded dynamic range flag 
179 
int timestamp; ///< embedded time stamp flag 
180 
int aux_data; ///< auxiliary data flag 
181 
int hdcd; ///< source material is mastered in HDCD 
182 
int ext_descr; ///< extension audio descriptor flag 
183 
int ext_coding; ///< extended coding flag 
184 
int aspf; ///< audio sync word insertion flag 
185 
int lfe; ///< low frequency effects flag 
186 
int predictor_history; ///< predictor history flag 
187 
int header_crc; ///< header crc check bytes 
188 
int multirate_inter; ///< multirate interpolator switch 
189 
int version; ///< encoder software revision 
190 
int copy_history; ///< copy history 
191 
int source_pcm_res; ///< source pcm resolution 
192 
int front_sum; ///< front sum/difference flag 
193 
int surround_sum; ///< surround sum/difference flag 
194 
int dialog_norm; ///< dialog normalisation parameter 
195  
196 
/* Primary audio coding header */

197 
int subframes; ///< number of subframes 
198 
int total_channels; ///< number of channels including extensions 
199 
int prim_channels; ///< number of primary audio channels 
200 
int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count 
201 
int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband 
202 
int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index 
203 
int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book 
204 
int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book 
205 
int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select 
206 
int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select 
207 
float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment 
208  
209 
/* Primary audio coding side information */

210 
int subsubframes; ///< number of subsubframes 
211 
int partial_samples; ///< partial subsubframe samples count 
212 
int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not) 
213 
int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs 
214 
int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index 
215 
int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients) 
216 
int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient) 
217 
int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook 
218 
int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors 
219 
int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients 
220 
int dynrange_coef; ///< dynamic range coefficient 
221  
222 
int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands 
223  
224 
float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX * 
225 
2 /*history */ ]; ///< Low frequency effect data 
226 
int lfe_scale_factor;

227  
228 
/* Subband samples history (for ADPCM) */

229 
float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4]; 
230 
DECLARE_ALIGNED_16(float, subband_fir_hist[DCA_PRIM_CHANNELS_MAX][512]); 
231 
float subband_fir_noidea[DCA_PRIM_CHANNELS_MAX][32]; 
232 
int hist_index[DCA_PRIM_CHANNELS_MAX];

233  
234 
int output; ///< type of output 
235 
float add_bias; ///< output bias 
236 
float scale_bias; ///< output scale 
237  
238 
DECLARE_ALIGNED_16(float, samples[1536]); /* 6 * 256 = 1536, might only need 5 */ 
239 
const float *samples_chanptr[6]; 
240  
241 
uint8_t dca_buffer[DCA_MAX_FRAME_SIZE]; 
242 
int dca_buffer_size; ///< how much data is in the dca_buffer 
243  
244 
const int8_t* channel_order_tab; ///< channel reordering table, lfe and non lfe 
245 
GetBitContext gb; 
246 
/* Current position in DCA frame */

247 
int current_subframe;

248 
int current_subsubframe;

249  
250 
int debug_flag; ///< used for suppressing repeated error messages output 
251 
DSPContext dsp; 
252 
MDCTContext imdct; 
253 
} DCAContext; 
254  
255 
static const uint16_t dca_vlc_offs[] = { 
256 
0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364, 
257 
5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508, 
258 
5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564, 
259 
7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240, 
260 
12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264, 
261 
18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622, 
262 
}; 
263  
264 
static av_cold void dca_init_vlcs(void) 
265 
{ 
266 
static int vlcs_initialized = 0; 
267 
int i, j, c = 14; 
268 
static VLC_TYPE dca_table[23622][2]; 
269  
270 
if (vlcs_initialized)

271 
return;

272  
273 
dca_bitalloc_index.offset = 1;

274 
dca_bitalloc_index.wrap = 2;

275 
for (i = 0; i < 5; i++) { 
276 
dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]]; 
277 
dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1]  dca_vlc_offs[i];

278 
init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,

279 
bitalloc_12_bits[i], 1, 1, 
280 
bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); 
281 
} 
282 
dca_scalefactor.offset = 64;

283 
dca_scalefactor.wrap = 2;

284 
for (i = 0; i < 5; i++) { 
285 
dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];

286 
dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6]  dca_vlc_offs[i + 5]; 
287 
init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,

288 
scales_bits[i], 1, 1, 
289 
scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); 
290 
} 
291 
dca_tmode.offset = 0;

292 
dca_tmode.wrap = 1;

293 
for (i = 0; i < 4; i++) { 
294 
dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];

295 
dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11]  dca_vlc_offs[i + 10]; 
296 
init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,

297 
tmode_bits[i], 1, 1, 
298 
tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); 
299 
} 
300  
301 
for(i = 0; i < 10; i++) 
302 
for(j = 0; j < 7; j++){ 
303 
if(!bitalloc_codes[i][j]) break; 
304 
dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];

305 
dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4); 
306 
dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];

307 
dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1]  dca_vlc_offs[c]; 
308 
init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],

309 
bitalloc_sizes[i], 
310 
bitalloc_bits[i][j], 1, 1, 
311 
bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC); 
312 
c++; 
313 
} 
314 
vlcs_initialized = 1;

315 
} 
316  
317 
static inline void get_array(GetBitContext *gb, int *dst, int len, int bits) 
318 
{ 
319 
while(len)

320 
*dst++ = get_bits(gb, bits); 
321 
} 
322  
323 
static int dca_parse_frame_header(DCAContext * s) 
324 
{ 
325 
int i, j;

326 
static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 }; 
327 
static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 }; 
328 
static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 }; 
329  
330 
init_get_bits(&s>gb, s>dca_buffer, s>dca_buffer_size * 8);

331  
332 
/* Sync code */

333 
get_bits(&s>gb, 32);

334  
335 
/* Frame header */

336 
s>frame_type = get_bits(&s>gb, 1);

337 
s>samples_deficit = get_bits(&s>gb, 5) + 1; 
338 
s>crc_present = get_bits(&s>gb, 1);

339 
s>sample_blocks = get_bits(&s>gb, 7) + 1; 
340 
s>frame_size = get_bits(&s>gb, 14) + 1; 
341 
if (s>frame_size < 95) 
342 
return 1; 
343 
s>amode = get_bits(&s>gb, 6);

344 
s>sample_rate = dca_sample_rates[get_bits(&s>gb, 4)];

345 
if (!s>sample_rate)

346 
return 1; 
347 
s>bit_rate_index = get_bits(&s>gb, 5);

348 
s>bit_rate = dca_bit_rates[s>bit_rate_index]; 
349 
if (!s>bit_rate)

350 
return 1; 
351  
352 
s>downmix = get_bits(&s>gb, 1);

353 
s>dynrange = get_bits(&s>gb, 1);

354 
s>timestamp = get_bits(&s>gb, 1);

355 
s>aux_data = get_bits(&s>gb, 1);

356 
s>hdcd = get_bits(&s>gb, 1);

357 
s>ext_descr = get_bits(&s>gb, 3);

358 
s>ext_coding = get_bits(&s>gb, 1);

359 
s>aspf = get_bits(&s>gb, 1);

360 
s>lfe = get_bits(&s>gb, 2);

361 
s>predictor_history = get_bits(&s>gb, 1);

362  
363 
/* TODO: check CRC */

364 
if (s>crc_present)

365 
s>header_crc = get_bits(&s>gb, 16);

366  
367 
s>multirate_inter = get_bits(&s>gb, 1);

368 
s>version = get_bits(&s>gb, 4);

369 
s>copy_history = get_bits(&s>gb, 2);

370 
s>source_pcm_res = get_bits(&s>gb, 3);

371 
s>front_sum = get_bits(&s>gb, 1);

372 
s>surround_sum = get_bits(&s>gb, 1);

373 
s>dialog_norm = get_bits(&s>gb, 4);

374  
375 
/* FIXME: channels mixing levels */

376 
s>output = s>amode; 
377 
if(s>lfe) s>output = DCA_LFE;

378  
379 
#ifdef TRACE

380 
av_log(s>avctx, AV_LOG_DEBUG, "frame type: %i\n", s>frame_type);

381 
av_log(s>avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s>samples_deficit);

382 
av_log(s>avctx, AV_LOG_DEBUG, "crc present: %i\n", s>crc_present);

383 
av_log(s>avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",

384 
s>sample_blocks, s>sample_blocks * 32);

385 
av_log(s>avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s>frame_size);

386 
av_log(s>avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",

387 
s>amode, dca_channels[s>amode]); 
388 
av_log(s>avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",

389 
s>sample_rate); 
390 
av_log(s>avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",

391 
s>bit_rate); 
392 
av_log(s>avctx, AV_LOG_DEBUG, "downmix: %i\n", s>downmix);

393 
av_log(s>avctx, AV_LOG_DEBUG, "dynrange: %i\n", s>dynrange);

394 
av_log(s>avctx, AV_LOG_DEBUG, "timestamp: %i\n", s>timestamp);

395 
av_log(s>avctx, AV_LOG_DEBUG, "aux_data: %i\n", s>aux_data);

396 
av_log(s>avctx, AV_LOG_DEBUG, "hdcd: %i\n", s>hdcd);

397 
av_log(s>avctx, AV_LOG_DEBUG, "ext descr: %i\n", s>ext_descr);

398 
av_log(s>avctx, AV_LOG_DEBUG, "ext coding: %i\n", s>ext_coding);

399 
av_log(s>avctx, AV_LOG_DEBUG, "aspf: %i\n", s>aspf);

400 
av_log(s>avctx, AV_LOG_DEBUG, "lfe: %i\n", s>lfe);

401 
av_log(s>avctx, AV_LOG_DEBUG, "predictor history: %i\n",

402 
s>predictor_history); 
403 
av_log(s>avctx, AV_LOG_DEBUG, "header crc: %i\n", s>header_crc);

404 
av_log(s>avctx, AV_LOG_DEBUG, "multirate inter: %i\n",

405 
s>multirate_inter); 
406 
av_log(s>avctx, AV_LOG_DEBUG, "version number: %i\n", s>version);

407 
av_log(s>avctx, AV_LOG_DEBUG, "copy history: %i\n", s>copy_history);

408 
av_log(s>avctx, AV_LOG_DEBUG, 
409 
"source pcm resolution: %i (%i bits/sample)\n",

410 
s>source_pcm_res, dca_bits_per_sample[s>source_pcm_res]); 
411 
av_log(s>avctx, AV_LOG_DEBUG, "front sum: %i\n", s>front_sum);

412 
av_log(s>avctx, AV_LOG_DEBUG, "surround sum: %i\n", s>surround_sum);

413 
av_log(s>avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s>dialog_norm);

414 
av_log(s>avctx, AV_LOG_DEBUG, "\n");

415 
#endif

416  
417 
/* Primary audio coding header */

418 
s>subframes = get_bits(&s>gb, 4) + 1; 
419 
s>total_channels = get_bits(&s>gb, 3) + 1; 
420 
s>prim_channels = s>total_channels; 
421 
if (s>prim_channels > DCA_PRIM_CHANNELS_MAX)

422 
s>prim_channels = DCA_PRIM_CHANNELS_MAX; /* We only support DTS core */

423  
424  
425 
for (i = 0; i < s>prim_channels; i++) { 
426 
s>subband_activity[i] = get_bits(&s>gb, 5) + 2; 
427 
if (s>subband_activity[i] > DCA_SUBBANDS)

428 
s>subband_activity[i] = DCA_SUBBANDS; 
429 
} 
430 
for (i = 0; i < s>prim_channels; i++) { 
431 
s>vq_start_subband[i] = get_bits(&s>gb, 5) + 1; 
432 
if (s>vq_start_subband[i] > DCA_SUBBANDS)

433 
s>vq_start_subband[i] = DCA_SUBBANDS; 
434 
} 
435 
get_array(&s>gb, s>joint_intensity, s>prim_channels, 3);

436 
get_array(&s>gb, s>transient_huffman, s>prim_channels, 2);

437 
get_array(&s>gb, s>scalefactor_huffman, s>prim_channels, 3);

438 
get_array(&s>gb, s>bitalloc_huffman, s>prim_channels, 3);

439  
440 
/* Get codebooks quantization indexes */

441 
memset(s>quant_index_huffman, 0, sizeof(s>quant_index_huffman)); 
442 
for (j = 1; j < 11; j++) 
443 
for (i = 0; i < s>prim_channels; i++) 
444 
s>quant_index_huffman[i][j] = get_bits(&s>gb, bitlen[j]); 
445  
446 
/* Get scale factor adjustment */

447 
for (j = 0; j < 11; j++) 
448 
for (i = 0; i < s>prim_channels; i++) 
449 
s>scalefactor_adj[i][j] = 1;

450  
451 
for (j = 1; j < 11; j++) 
452 
for (i = 0; i < s>prim_channels; i++) 
453 
if (s>quant_index_huffman[i][j] < thr[j])

454 
s>scalefactor_adj[i][j] = adj_table[get_bits(&s>gb, 2)];

455  
456 
if (s>crc_present) {

457 
/* Audio header CRC check */

458 
get_bits(&s>gb, 16);

459 
} 
460  
461 
s>current_subframe = 0;

462 
s>current_subsubframe = 0;

463  
464 
#ifdef TRACE

465 
av_log(s>avctx, AV_LOG_DEBUG, "subframes: %i\n", s>subframes);

466 
av_log(s>avctx, AV_LOG_DEBUG, "prim channels: %i\n", s>prim_channels);

467 
for(i = 0; i < s>prim_channels; i++){ 
468 
av_log(s>avctx, AV_LOG_DEBUG, "subband activity: %i\n", s>subband_activity[i]);

469 
av_log(s>avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s>vq_start_subband[i]);

470 
av_log(s>avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s>joint_intensity[i]);

471 
av_log(s>avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s>transient_huffman[i]);

472 
av_log(s>avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s>scalefactor_huffman[i]);

473 
av_log(s>avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s>bitalloc_huffman[i]);

474 
av_log(s>avctx, AV_LOG_DEBUG, "quant index huff:");

475 
for (j = 0; j < 11; j++) 
476 
av_log(s>avctx, AV_LOG_DEBUG, " %i",

477 
s>quant_index_huffman[i][j]); 
478 
av_log(s>avctx, AV_LOG_DEBUG, "\n");

479 
av_log(s>avctx, AV_LOG_DEBUG, "scalefac adj:");

480 
for (j = 0; j < 11; j++) 
481 
av_log(s>avctx, AV_LOG_DEBUG, " %1.3f", s>scalefactor_adj[i][j]);

482 
av_log(s>avctx, AV_LOG_DEBUG, "\n");

483 
} 
484 
#endif

485  
486 
return 0; 
487 
} 
488  
489  
490 
static inline int get_scale(GetBitContext *gb, int level, int value) 
491 
{ 
492 
if (level < 5) { 
493 
/* huffman encoded */

494 
value += get_bitalloc(gb, &dca_scalefactor, level); 
495 
} else if(level < 8) 
496 
value = get_bits(gb, level + 1);

497 
return value;

498 
} 
499  
500 
static int dca_subframe_header(DCAContext * s) 
501 
{ 
502 
/* Primary audio coding side information */

503 
int j, k;

504  
505 
s>subsubframes = get_bits(&s>gb, 2) + 1; 
506 
s>partial_samples = get_bits(&s>gb, 3);

507 
for (j = 0; j < s>prim_channels; j++) { 
508 
for (k = 0; k < s>subband_activity[j]; k++) 
509 
s>prediction_mode[j][k] = get_bits(&s>gb, 1);

510 
} 
511  
512 
/* Get prediction codebook */

513 
for (j = 0; j < s>prim_channels; j++) { 
514 
for (k = 0; k < s>subband_activity[j]; k++) { 
515 
if (s>prediction_mode[j][k] > 0) { 
516 
/* (Prediction coefficient VQ address) */

517 
s>prediction_vq[j][k] = get_bits(&s>gb, 12);

518 
} 
519 
} 
520 
} 
521  
522 
/* Bit allocation index */

523 
for (j = 0; j < s>prim_channels; j++) { 
524 
for (k = 0; k < s>vq_start_subband[j]; k++) { 
525 
if (s>bitalloc_huffman[j] == 6) 
526 
s>bitalloc[j][k] = get_bits(&s>gb, 5);

527 
else if (s>bitalloc_huffman[j] == 5) 
528 
s>bitalloc[j][k] = get_bits(&s>gb, 4);

529 
else if (s>bitalloc_huffman[j] == 7) { 
530 
av_log(s>avctx, AV_LOG_ERROR, 
531 
"Invalid bit allocation index\n");

532 
return 1; 
533 
} else {

534 
s>bitalloc[j][k] = 
535 
get_bitalloc(&s>gb, &dca_bitalloc_index, s>bitalloc_huffman[j]); 
536 
} 
537  
538 
if (s>bitalloc[j][k] > 26) { 
539 
// av_log(s>avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",

540 
// j, k, s>bitalloc[j][k]);

541 
return 1; 
542 
} 
543 
} 
544 
} 
545  
546 
/* Transition mode */

547 
for (j = 0; j < s>prim_channels; j++) { 
548 
for (k = 0; k < s>subband_activity[j]; k++) { 
549 
s>transition_mode[j][k] = 0;

550 
if (s>subsubframes > 1 && 
551 
k < s>vq_start_subband[j] && s>bitalloc[j][k] > 0) {

552 
s>transition_mode[j][k] = 
553 
get_bitalloc(&s>gb, &dca_tmode, s>transient_huffman[j]); 
554 
} 
555 
} 
556 
} 
557  
558 
for (j = 0; j < s>prim_channels; j++) { 
559 
const uint32_t *scale_table;

560 
int scale_sum;

561  
562 
memset(s>scale_factor[j], 0, s>subband_activity[j] * sizeof(s>scale_factor[0][0][0]) * 2); 
563  
564 
if (s>scalefactor_huffman[j] == 6) 
565 
scale_table = scale_factor_quant7; 
566 
else

567 
scale_table = scale_factor_quant6; 
568  
569 
/* When huffman coded, only the difference is encoded */

570 
scale_sum = 0;

571  
572 
for (k = 0; k < s>subband_activity[j]; k++) { 
573 
if (k >= s>vq_start_subband[j]  s>bitalloc[j][k] > 0) { 
574 
scale_sum = get_scale(&s>gb, s>scalefactor_huffman[j], scale_sum); 
575 
s>scale_factor[j][k][0] = scale_table[scale_sum];

576 
} 
577  
578 
if (k < s>vq_start_subband[j] && s>transition_mode[j][k]) {

579 
/* Get second scale factor */

580 
scale_sum = get_scale(&s>gb, s>scalefactor_huffman[j], scale_sum); 
581 
s>scale_factor[j][k][1] = scale_table[scale_sum];

582 
} 
583 
} 
584 
} 
585  
586 
/* Joint subband scale factor codebook select */

587 
for (j = 0; j < s>prim_channels; j++) { 
588 
/* Transmitted only if joint subband coding enabled */

589 
if (s>joint_intensity[j] > 0) 
590 
s>joint_huff[j] = get_bits(&s>gb, 3);

591 
} 
592  
593 
/* Scale factors for joint subband coding */

594 
for (j = 0; j < s>prim_channels; j++) { 
595 
int source_channel;

596  
597 
/* Transmitted only if joint subband coding enabled */

598 
if (s>joint_intensity[j] > 0) { 
599 
int scale = 0; 
600 
source_channel = s>joint_intensity[j]  1;

601  
602 
/* When huffman coded, only the difference is encoded

603 
* (is this valid as well for joint scales ???) */

604  
605 
for (k = s>subband_activity[j]; k < s>subband_activity[source_channel]; k++) {

606 
scale = get_scale(&s>gb, s>joint_huff[j], 0);

607 
scale += 64; /* bias */ 
608 
s>joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */

609 
} 
610  
611 
if (!s>debug_flag & 0x02) { 
612 
av_log(s>avctx, AV_LOG_DEBUG, 
613 
"Joint stereo coding not supported\n");

614 
s>debug_flag = 0x02;

615 
} 
616 
} 
617 
} 
618  
619 
/* Stereo downmix coefficients */

620 
if (s>prim_channels > 2) { 
621 
if(s>downmix) {

622 
for (j = 0; j < s>prim_channels; j++) { 
623 
s>downmix_coef[j][0] = get_bits(&s>gb, 7); 
624 
s>downmix_coef[j][1] = get_bits(&s>gb, 7); 
625 
} 
626 
} else {

627 
int am = s>amode & DCA_CHANNEL_MASK;

628 
for (j = 0; j < s>prim_channels; j++) { 
629 
s>downmix_coef[j][0] = dca_default_coeffs[am][j][0]; 
630 
s>downmix_coef[j][1] = dca_default_coeffs[am][j][1]; 
631 
} 
632 
} 
633 
} 
634  
635 
/* Dynamic range coefficient */

636 
if (s>dynrange)

637 
s>dynrange_coef = get_bits(&s>gb, 8);

638  
639 
/* Side information CRC check word */

640 
if (s>crc_present) {

641 
get_bits(&s>gb, 16);

642 
} 
643  
644 
/*

645 
* Primary audio data arrays

646 
*/

647  
648 
/* VQ encoded high frequency subbands */

649 
for (j = 0; j < s>prim_channels; j++) 
650 
for (k = s>vq_start_subband[j]; k < s>subband_activity[j]; k++)

651 
/* 1 vector > 32 samples */

652 
s>high_freq_vq[j][k] = get_bits(&s>gb, 10);

653  
654 
/* Low frequency effect data */

655 
if (s>lfe) {

656 
/* LFE samples */

657 
int lfe_samples = 2 * s>lfe * s>subsubframes; 
658 
float lfe_scale;

659  
660 
for (j = lfe_samples; j < lfe_samples * 2; j++) { 
661 
/* Signed 8 bits int */

662 
s>lfe_data[j] = get_sbits(&s>gb, 8);

663 
} 
664  
665 
/* Scale factor index */

666 
s>lfe_scale_factor = scale_factor_quant7[get_bits(&s>gb, 8)];

667  
668 
/* Quantization step size * scale factor */

669 
lfe_scale = 0.035 * s>lfe_scale_factor; 
670  
671 
for (j = lfe_samples; j < lfe_samples * 2; j++) 
672 
s>lfe_data[j] *= lfe_scale; 
673 
} 
674  
675 
#ifdef TRACE

676 
av_log(s>avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s>subsubframes);

677 
av_log(s>avctx, AV_LOG_DEBUG, "partial samples: %i\n",

678 
s>partial_samples); 
679 
for (j = 0; j < s>prim_channels; j++) { 
680 
av_log(s>avctx, AV_LOG_DEBUG, "prediction mode:");

681 
for (k = 0; k < s>subband_activity[j]; k++) 
682 
av_log(s>avctx, AV_LOG_DEBUG, " %i", s>prediction_mode[j][k]);

683 
av_log(s>avctx, AV_LOG_DEBUG, "\n");

684 
} 
685 
for (j = 0; j < s>prim_channels; j++) { 
686 
for (k = 0; k < s>subband_activity[j]; k++) 
687 
av_log(s>avctx, AV_LOG_DEBUG, 
688 
"prediction coefs: %f, %f, %f, %f\n",

689 
(float) adpcm_vb[s>prediction_vq[j][k]][0] / 8192, 
690 
(float) adpcm_vb[s>prediction_vq[j][k]][1] / 8192, 
691 
(float) adpcm_vb[s>prediction_vq[j][k]][2] / 8192, 
692 
(float) adpcm_vb[s>prediction_vq[j][k]][3] / 8192); 
693 
} 
694 
for (j = 0; j < s>prim_channels; j++) { 
695 
av_log(s>avctx, AV_LOG_DEBUG, "bitalloc index: ");

696 
for (k = 0; k < s>vq_start_subband[j]; k++) 
697 
av_log(s>avctx, AV_LOG_DEBUG, "%2.2i ", s>bitalloc[j][k]);

698 
av_log(s>avctx, AV_LOG_DEBUG, "\n");

699 
} 
700 
for (j = 0; j < s>prim_channels; j++) { 
701 
av_log(s>avctx, AV_LOG_DEBUG, "Transition mode:");

702 
for (k = 0; k < s>subband_activity[j]; k++) 
703 
av_log(s>avctx, AV_LOG_DEBUG, " %i", s>transition_mode[j][k]);

704 
av_log(s>avctx, AV_LOG_DEBUG, "\n");

705 
} 
706 
for (j = 0; j < s>prim_channels; j++) { 
707 
av_log(s>avctx, AV_LOG_DEBUG, "Scale factor:");

708 
for (k = 0; k < s>subband_activity[j]; k++) { 
709 
if (k >= s>vq_start_subband[j]  s>bitalloc[j][k] > 0) 
710 
av_log(s>avctx, AV_LOG_DEBUG, " %i", s>scale_factor[j][k][0]); 
711 
if (k < s>vq_start_subband[j] && s>transition_mode[j][k])

712 
av_log(s>avctx, AV_LOG_DEBUG, " %i(t)", s>scale_factor[j][k][1]); 
713 
} 
714 
av_log(s>avctx, AV_LOG_DEBUG, "\n");

715 
} 
716 
for (j = 0; j < s>prim_channels; j++) { 
717 
if (s>joint_intensity[j] > 0) { 
718 
int source_channel = s>joint_intensity[j]  1; 
719 
av_log(s>avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");

720 
for (k = s>subband_activity[j]; k < s>subband_activity[source_channel]; k++)

721 
av_log(s>avctx, AV_LOG_DEBUG, " %i", s>joint_scale_factor[j][k]);

722 
av_log(s>avctx, AV_LOG_DEBUG, "\n");

723 
} 
724 
} 
725 
if (s>prim_channels > 2 && s>downmix) { 
726 
av_log(s>avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");

727 
for (j = 0; j < s>prim_channels; j++) { 
728 
av_log(s>avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s>downmix_coef[j][0]]); 
729 
av_log(s>avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s>downmix_coef[j][1]]); 
730 
} 
731 
av_log(s>avctx, AV_LOG_DEBUG, "\n");

732 
} 
733 
for (j = 0; j < s>prim_channels; j++) 
734 
for (k = s>vq_start_subband[j]; k < s>subband_activity[j]; k++)

735 
av_log(s>avctx, AV_LOG_DEBUG, "VQ index: %i\n", s>high_freq_vq[j][k]);

736 
if(s>lfe){

737 
int lfe_samples = 2 * s>lfe * s>subsubframes; 
738 
av_log(s>avctx, AV_LOG_DEBUG, "LFE samples:\n");

739 
for (j = lfe_samples; j < lfe_samples * 2; j++) 
740 
av_log(s>avctx, AV_LOG_DEBUG, " %f", s>lfe_data[j]);

741 
av_log(s>avctx, AV_LOG_DEBUG, "\n");

742 
} 
743 
#endif

744  
745 
return 0; 
746 
} 
747  
748 
static void qmf_32_subbands(DCAContext * s, int chans, 
749 
float samples_in[32][8], float *samples_out, 
750 
float scale, float bias) 
751 
{ 
752 
const float *prCoeff; 
753 
int i, j;

754 
DECLARE_ALIGNED_16(float, raXin[32]); 
755  
756 
int hist_index= s>hist_index[chans];

757 
float *subband_fir_hist2 = s>subband_fir_noidea[chans];

758  
759 
int subindex;

760  
761 
scale *= sqrt(1/8.0); 
762  
763 
/* Select filter */

764 
if (!s>multirate_inter) /* Nonperfect reconstruction */ 
765 
prCoeff = fir_32bands_nonperfect; 
766 
else /* Perfect reconstruction */ 
767 
prCoeff = fir_32bands_perfect; 
768  
769 
/* Reconstructed channel sample index */

770 
for (subindex = 0; subindex < 8; subindex++) { 
771 
float *subband_fir_hist = s>subband_fir_hist[chans] + hist_index;

772 
/* Load in one sample from each subband and clear inactive subbands */

773 
for (i = 0; i < s>subband_activity[chans]; i++){ 
774 
if((i1)&2) raXin[i] = samples_in[i][subindex]; 
775 
else raXin[i] = samples_in[i][subindex];

776 
} 
777 
for (; i < 32; i++) 
778 
raXin[i] = 0.0; 
779  
780 
ff_imdct_half(&s>imdct, subband_fir_hist, raXin); 
781  
782 
/* Multiply by filter coefficients */

783 
for (i = 0; i < 16; i++){ 
784 
float a= subband_fir_hist2[i ];

785 
float b= subband_fir_hist2[i+16]; 
786 
float c= 0; 
787 
float d= 0; 
788 
for (j = 0; j < 512hist_index; j += 64){ 
789 
a += prCoeff[i+j ]*(subband_fir_hist[15i+j]);

790 
b += prCoeff[i+j+16]*( subband_fir_hist[ i+j]);

791 
c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j]); 
792 
d += prCoeff[i+j+48]*( subband_fir_hist[31i+j]); 
793 
} 
794 
for ( ; j < 512; j += 64){ 
795 
a += prCoeff[i+j ]*(subband_fir_hist[15i+j512]); 
796 
b += prCoeff[i+j+16]*( subband_fir_hist[ i+j512]); 
797 
c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j512]); 
798 
d += prCoeff[i+j+48]*( subband_fir_hist[31i+j512]); 
799 
} 
800 
samples_out[i ] = a * scale + bias; 
801 
samples_out[i+16] = b * scale + bias;

802 
subband_fir_hist2[i ] = c; 
803 
subband_fir_hist2[i+16] = d;

804 
} 
805 
samples_out+= 32;

806  
807 
hist_index = (hist_index32)&511; 
808 
} 
809 
s>hist_index[chans]= hist_index; 
810 
} 
811  
812 
static void lfe_interpolation_fir(int decimation_select, 
813 
int num_deci_sample, float *samples_in, 
814 
float *samples_out, float scale, 
815 
float bias)

816 
{ 
817 
/* samples_in: An array holding decimated samples.

818 
* Samples in current subframe starts from samples_in[0],

819 
* while samples_in[1], samples_in[2], ..., stores samples

820 
* from last subframe as history.

821 
*

822 
* samples_out: An array holding interpolated samples

823 
*/

824  
825 
int decifactor, k, j;

826 
const float *prCoeff; 
827  
828 
int interp_index = 0; /* Index to the interpolated samples */ 
829 
int deciindex;

830  
831 
/* Select decimation filter */

832 
if (decimation_select == 1) { 
833 
decifactor = 128;

834 
prCoeff = lfe_fir_128; 
835 
} else {

836 
decifactor = 64;

837 
prCoeff = lfe_fir_64; 
838 
} 
839 
/* Interpolation */

840 
for (deciindex = 0; deciindex < num_deci_sample; deciindex++) { 
841 
/* One decimated sample generates decifactor interpolated ones */

842 
for (k = 0; k < decifactor; k++) { 
843 
float rTmp = 0.0; 
844 
//FIXME the coeffs are symetric, fix that

845 
for (j = 0; j < 512 / decifactor; j++) 
846 
rTmp += samples_in[deciindex  j] * prCoeff[k + j * decifactor]; 
847 
samples_out[interp_index++] = (rTmp * scale) + bias; 
848 
} 
849 
} 
850 
} 
851  
852 
/* downmixing routines */

853 
#define MIX_REAR1(samples, si1, rs, coef) \

854 
samples[i] += samples[si1] * coef[rs][0]; \

855 
samples[i+256] += samples[si1] * coef[rs][1]; 
856  
857 
#define MIX_REAR2(samples, si1, si2, rs, coef) \

858 
samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \ 
859 
samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1]; 
860  
861 
#define MIX_FRONT3(samples, coef) \

862 
t = samples[i]; \ 
863 
samples[i] = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \ 
864 
samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1]; 
865  
866 
#define DOWNMIX_TO_STEREO(op1, op2) \

867 
for(i = 0; i < 256; i++){ \ 
868 
op1 \ 
869 
op2 \ 
870 
} 
871  
872 
static void dca_downmix(float *samples, int srcfmt, 
873 
int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]) 
874 
{ 
875 
int i;

876 
float t;

877 
float coef[DCA_PRIM_CHANNELS_MAX][2]; 
878  
879 
for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) { 
880 
coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]]; 
881 
coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]]; 
882 
} 
883  
884 
switch (srcfmt) {

885 
case DCA_MONO:

886 
case DCA_CHANNEL:

887 
case DCA_STEREO_TOTAL:

888 
case DCA_STEREO_SUMDIFF:

889 
case DCA_4F2R:

890 
av_log(NULL, 0, "Not implemented!\n"); 
891 
break;

892 
case DCA_STEREO:

893 
break;

894 
case DCA_3F:

895 
DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),); 
896 
break;

897 
case DCA_2F1R:

898 
DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),); 
899 
break;

900 
case DCA_3F1R:

901 
DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), 
902 
MIX_REAR1(samples, i + 768, 3, coef)); 
903 
break;

904 
case DCA_2F2R:

905 
DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),); 
906 
break;

907 
case DCA_3F2R:

908 
DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), 
909 
MIX_REAR2(samples, i + 768, i + 1024, 3, coef)); 
910 
break;

911 
} 
912 
} 
913  
914  
915 
/* Very compact version of the block code decoder that does not use table

916 
* lookup but is slightly slower */

917 
static int decode_blockcode(int code, int levels, int *values) 
918 
{ 
919 
int i;

920 
int offset = (levels  1) >> 1; 
921  
922 
for (i = 0; i < 4; i++) { 
923 
values[i] = (code % levels)  offset; 
924 
code /= levels; 
925 
} 
926  
927 
if (code == 0) 
928 
return 0; 
929 
else {

930 
av_log(NULL, AV_LOG_ERROR, "ERROR: block code lookup failed\n"); 
931 
return 1; 
932 
} 
933 
} 
934  
935 
static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 }; 
936 
static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 }; 
937  
938 
static int dca_subsubframe(DCAContext * s) 
939 
{ 
940 
int k, l;

941 
int subsubframe = s>current_subsubframe;

942  
943 
const float *quant_step_table; 
944  
945 
/* FIXME */

946 
float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8]; 
947  
948 
/*

949 
* Audio data

950 
*/

951  
952 
/* Select quantization step size table */

953 
if (s>bit_rate_index == 0x1f) 
954 
quant_step_table = lossless_quant_d; 
955 
else

956 
quant_step_table = lossy_quant_d; 
957  
958 
for (k = 0; k < s>prim_channels; k++) { 
959 
for (l = 0; l < s>vq_start_subband[k]; l++) { 
960 
int m;

961  
962 
/* Select the midtread linear quantizer */

963 
int abits = s>bitalloc[k][l];

964  
965 
float quant_step_size = quant_step_table[abits];

966 
float rscale;

967  
968 
/*

969 
* Determine quantization index code book and its type

970 
*/

971  
972 
/* Select quantization index code book */

973 
int sel = s>quant_index_huffman[k][abits];

974  
975 
/*

976 
* Extract bits from the bit stream

977 
*/

978 
if(!abits){

979 
memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0])); 
980 
}else if(abits >= 11  !dca_smpl_bitalloc[abits].vlc[sel].table){ 
981 
if(abits <= 7){ 
982 
/* Block code */

983 
int block_code1, block_code2, size, levels;

984 
int block[8]; 
985  
986 
size = abits_sizes[abits1];

987 
levels = abits_levels[abits1];

988  
989 
block_code1 = get_bits(&s>gb, size); 
990 
/* FIXME Should test return value */

991 
decode_blockcode(block_code1, levels, block); 
992 
block_code2 = get_bits(&s>gb, size); 
993 
decode_blockcode(block_code2, levels, &block[4]);

994 
for (m = 0; m < 8; m++) 
995 
subband_samples[k][l][m] = block[m]; 
996 
}else{

997 
/* no coding */

998 
for (m = 0; m < 8; m++) 
999 
subband_samples[k][l][m] = get_sbits(&s>gb, abits  3);

1000 
} 
1001 
}else{

1002 
/* Huffman coded */

1003 
for (m = 0; m < 8; m++) 
1004 
subband_samples[k][l][m] = get_bitalloc(&s>gb, &dca_smpl_bitalloc[abits], sel); 
1005 
} 
1006  
1007 
/* Deal with transients */

1008 
if (s>transition_mode[k][l] &&

1009 
subsubframe >= s>transition_mode[k][l]) 
1010 
rscale = quant_step_size * s>scale_factor[k][l][1];

1011 
else

1012 
rscale = quant_step_size * s>scale_factor[k][l][0];

1013  
1014 
rscale *= s>scalefactor_adj[k][sel]; 
1015  
1016 
for (m = 0; m < 8; m++) 
1017 
subband_samples[k][l][m] *= rscale; 
1018  
1019 
/*

1020 
* Inverse ADPCM if in prediction mode

1021 
*/

1022 
if (s>prediction_mode[k][l]) {

1023 
int n;

1024 
for (m = 0; m < 8; m++) { 
1025 
for (n = 1; n <= 4; n++) 
1026 
if (m >= n)

1027 
subband_samples[k][l][m] += 
1028 
(adpcm_vb[s>prediction_vq[k][l]][n  1] *

1029 
subband_samples[k][l][m  n] / 8192);

1030 
else if (s>predictor_history) 
1031 
subband_samples[k][l][m] += 
1032 
(adpcm_vb[s>prediction_vq[k][l]][n  1] *

1033 
s>subband_samples_hist[k][l][m  n + 
1034 
4] / 8192); 
1035 
} 
1036 
} 
1037 
} 
1038  
1039 
/*

1040 
* Decode VQ encoded high frequencies

1041 
*/

1042 
for (l = s>vq_start_subband[k]; l < s>subband_activity[k]; l++) {

1043 
/* 1 vector > 32 samples but we only need the 8 samples

1044 
* for this subsubframe. */

1045 
int m;

1046  
1047 
if (!s>debug_flag & 0x01) { 
1048 
av_log(s>avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");

1049 
s>debug_flag = 0x01;

1050 
} 
1051  
1052 
for (m = 0; m < 8; m++) { 
1053 
subband_samples[k][l][m] = 
1054 
high_freq_vq[s>high_freq_vq[k][l]][subsubframe * 8 +

1055 
m] 
1056 
* (float) s>scale_factor[k][l][0] / 16.0; 
1057 
} 
1058 
} 
1059 
} 
1060  
1061 
/* Check for DSYNC after subsubframe */

1062 
if (s>aspf  subsubframe == s>subsubframes  1) { 
1063 
if (0xFFFF == get_bits(&s>gb, 16)) { /* 0xFFFF */ 
1064 
#ifdef TRACE

1065 
av_log(s>avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");

1066 
#endif

1067 
} else {

1068 
av_log(s>avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");

1069 
} 
1070 
} 
1071  
1072 
/* Backup predictor history for adpcm */

1073 
for (k = 0; k < s>prim_channels; k++) 
1074 
for (l = 0; l < s>vq_start_subband[k]; l++) 
1075 
memcpy(s>subband_samples_hist[k][l], &subband_samples[k][l][4],

1076 
4 * sizeof(subband_samples[0][0][0])); 
1077  
1078 
/* 32 subbands QMF */

1079 
for (k = 0; k < s>prim_channels; k++) { 
1080 
/* static float pcm_to_double[8] =

1081 
{32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/

1082 
qmf_32_subbands(s, k, subband_samples[k], &s>samples[256 * s>channel_order_tab[k]],

1083 
M_SQRT1_2*s>scale_bias /*pcm_to_double[s>source_pcm_res] */ ,

1084 
s>add_bias ); 
1085 
} 
1086  
1087 
/* Down mixing */

1088  
1089 
if (s>prim_channels > dca_channels[s>output & DCA_CHANNEL_MASK]) {

1090 
dca_downmix(s>samples, s>amode, s>downmix_coef); 
1091 
} 
1092  
1093 
/* Generate LFE samples for this subsubframe FIXME!!! */

1094 
if (s>output & DCA_LFE) {

1095 
int lfe_samples = 2 * s>lfe * s>subsubframes; 
1096  
1097 
lfe_interpolation_fir(s>lfe, 2 * s>lfe,

1098 
s>lfe_data + lfe_samples + 
1099 
2 * s>lfe * subsubframe,

1100 
&s>samples[256 * dca_lfe_index[s>amode]],

1101 
(1.0/256.0)*s>scale_bias, s>add_bias); 
1102 
/* Outputs 20bits pcm samples */

1103 
} 
1104  
1105 
return 0; 
1106 
} 
1107  
1108  
1109 
static int dca_subframe_footer(DCAContext * s) 
1110 
{ 
1111 
int aux_data_count = 0, i; 
1112 
int lfe_samples;

1113  
1114 
/*

1115 
* Unpack optional information

1116 
*/

1117  
1118 
if (s>timestamp)

1119 
get_bits(&s>gb, 32);

1120  
1121 
if (s>aux_data)

1122 
aux_data_count = get_bits(&s>gb, 6);

1123  
1124 
for (i = 0; i < aux_data_count; i++) 
1125 
get_bits(&s>gb, 8);

1126  
1127 
if (s>crc_present && (s>downmix  s>dynrange))

1128 
get_bits(&s>gb, 16);

1129  
1130 
lfe_samples = 2 * s>lfe * s>subsubframes;

1131 
for (i = 0; i < lfe_samples; i++) { 
1132 
s>lfe_data[i] = s>lfe_data[i + lfe_samples]; 
1133 
} 
1134  
1135 
return 0; 
1136 
} 
1137  
1138 
/**

1139 
* Decode a dca frame block

1140 
*

1141 
* @param s pointer to the DCAContext

1142 
*/

1143  
1144 
static int dca_decode_block(DCAContext * s) 
1145 
{ 
1146  
1147 
/* Sanity check */

1148 
if (s>current_subframe >= s>subframes) {

1149 
av_log(s>avctx, AV_LOG_DEBUG, "check failed: %i>%i",

1150 
s>current_subframe, s>subframes); 
1151 
return 1; 
1152 
} 
1153  
1154 
if (!s>current_subsubframe) {

1155 
#ifdef TRACE

1156 
av_log(s>avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");

1157 
#endif

1158 
/* Read subframe header */

1159 
if (dca_subframe_header(s))

1160 
return 1; 
1161 
} 
1162  
1163 
/* Read subsubframe */

1164 
#ifdef TRACE

1165 
av_log(s>avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");

1166 
#endif

1167 
if (dca_subsubframe(s))

1168 
return 1; 
1169  
1170 
/* Update state */

1171 
s>current_subsubframe++; 
1172 
if (s>current_subsubframe >= s>subsubframes) {

1173 
s>current_subsubframe = 0;

1174 
s>current_subframe++; 
1175 
} 
1176 
if (s>current_subframe >= s>subframes) {

1177 
#ifdef TRACE

1178 
av_log(s>avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");

1179 
#endif

1180 
/* Read subframe footer */

1181 
if (dca_subframe_footer(s))

1182 
return 1; 
1183 
} 
1184  
1185 
return 0; 
1186 
} 
1187  
1188 
/**

1189 
* Convert bitstream to one representation based on sync marker

1190 
*/

1191 
static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst, 
1192 
int max_size)

1193 
{ 
1194 
uint32_t mrk; 
1195 
int i, tmp;

1196 
const uint16_t *ssrc = (const uint16_t *) src; 
1197 
uint16_t *sdst = (uint16_t *) dst; 
1198 
PutBitContext pb; 
1199  
1200 
if((unsigned)src_size > (unsigned)max_size) { 
1201 
// av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");

1202 
// return 1;

1203 
src_size = max_size; 
1204 
} 
1205  
1206 
mrk = AV_RB32(src); 
1207 
switch (mrk) {

1208 
case DCA_MARKER_RAW_BE:

1209 
memcpy(dst, src, src_size); 
1210 
return src_size;

1211 
case DCA_MARKER_RAW_LE:

1212 
for (i = 0; i < (src_size + 1) >> 1; i++) 
1213 
*sdst++ = bswap_16(*ssrc++); 
1214 
return src_size;

1215 
case DCA_MARKER_14B_BE:

1216 
case DCA_MARKER_14B_LE:

1217 
init_put_bits(&pb, dst, max_size); 
1218 
for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) { 
1219 
tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;

1220 
put_bits(&pb, 14, tmp);

1221 
} 
1222 
flush_put_bits(&pb); 
1223 
return (put_bits_count(&pb) + 7) >> 3; 
1224 
default:

1225 
return 1; 
1226 
} 
1227 
} 
1228  
1229 
/**

1230 
* Main frame decoding function

1231 
* FIXME add arguments

1232 
*/

1233 
static int dca_decode_frame(AVCodecContext * avctx, 
1234 
void *data, int *data_size, 
1235 
AVPacket *avpkt) 
1236 
{ 
1237 
const uint8_t *buf = avpkt>data;

1238 
int buf_size = avpkt>size;

1239  
1240 
int i;

1241 
int16_t *samples = data; 
1242 
DCAContext *s = avctx>priv_data; 
1243 
int channels;

1244  
1245  
1246 
s>dca_buffer_size = dca_convert_bitstream(buf, buf_size, s>dca_buffer, DCA_MAX_FRAME_SIZE); 
1247 
if (s>dca_buffer_size == 1) { 
1248 
av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");

1249 
return 1; 
1250 
} 
1251  
1252 
init_get_bits(&s>gb, s>dca_buffer, s>dca_buffer_size * 8);

1253 
if (dca_parse_frame_header(s) < 0) { 
1254 
//seems like the frame is corrupt, try with the next one

1255 
*data_size=0;

1256 
return buf_size;

1257 
} 
1258 
//set AVCodec values with parsed data

1259 
avctx>sample_rate = s>sample_rate; 
1260 
avctx>bit_rate = s>bit_rate; 
1261  
1262 
channels = s>prim_channels + !!s>lfe; 
1263  
1264 
if (s>amode<16) { 
1265 
avctx>channel_layout = dca_core_channel_layout[s>amode]; 
1266  
1267 
if (s>lfe) {

1268 
avctx>channel_layout = CH_LOW_FREQUENCY; 
1269 
s>channel_order_tab = dca_channel_reorder_lfe[s>amode]; 
1270 
} else

1271 
s>channel_order_tab = dca_channel_reorder_nolfe[s>amode]; 
1272  
1273 
if(avctx>request_channels == 2 && s>prim_channels > 2) { 
1274 
channels = 2;

1275 
s>output = DCA_STEREO; 
1276 
avctx>channel_layout = CH_LAYOUT_STEREO; 
1277 
} 
1278 
} else {

1279 
av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s>amode);

1280 
return 1; 
1281 
} 
1282  
1283  
1284 
/* There is nothing that prevents a dts frame to change channel configuration

1285 
but FFmpeg doesn't support that so only set the channels if it is previously

1286 
unset. Ideally during the first probe for channels the crc should be checked

1287 
and only set avctx>channels when the crc is ok. Right now the decoder could

1288 
set the channels based on a broken first frame.*/

1289 
if (!avctx>channels)

1290 
avctx>channels = channels; 
1291  
1292 
if(*data_size < (s>sample_blocks / 8) * 256 * sizeof(int16_t) * channels) 
1293 
return 1; 
1294 
*data_size = 256 / 8 * s>sample_blocks * sizeof(int16_t) * channels; 
1295 
for (i = 0; i < (s>sample_blocks / 8); i++) { 
1296 
dca_decode_block(s); 
1297 
s>dsp.float_to_int16_interleave(samples, s>samples_chanptr, 256, channels);

1298 
samples += 256 * channels;

1299 
} 
1300  
1301 
return buf_size;

1302 
} 
1303  
1304  
1305  
1306 
/**

1307 
* DCA initialization

1308 
*

1309 
* @param avctx pointer to the AVCodecContext

1310 
*/

1311  
1312 
static av_cold int dca_decode_init(AVCodecContext * avctx) 
1313 
{ 
1314 
DCAContext *s = avctx>priv_data; 
1315 
int i;

1316  
1317 
s>avctx = avctx; 
1318 
dca_init_vlcs(); 
1319  
1320 
dsputil_init(&s>dsp, avctx); 
1321 
ff_mdct_init(&s>imdct, 6, 1, 1.0); 
1322  
1323 
for(i = 0; i < 6; i++) 
1324 
s>samples_chanptr[i] = s>samples + i * 256;

1325 
avctx>sample_fmt = SAMPLE_FMT_S16; 
1326  
1327 
if(s>dsp.float_to_int16 == ff_float_to_int16_c) {

1328 
s>add_bias = 385.0f; 
1329 
s>scale_bias = 1.0 / 32768.0; 
1330 
} else {

1331 
s>add_bias = 0.0f; 
1332 
s>scale_bias = 1.0; 
1333  
1334 
/* allow downmixing to stereo */

1335 
if (avctx>channels > 0 && avctx>request_channels < avctx>channels && 
1336 
avctx>request_channels == 2) {

1337 
avctx>channels = avctx>request_channels; 
1338 
} 
1339 
} 
1340  
1341  
1342 
return 0; 
1343 
} 
1344  
1345 
static av_cold int dca_decode_end(AVCodecContext * avctx) 
1346 
{ 
1347 
DCAContext *s = avctx>priv_data; 
1348 
ff_mdct_end(&s>imdct); 
1349 
return 0; 
1350 
} 
1351  
1352 
AVCodec dca_decoder = { 
1353 
.name = "dca",

1354 
.type = CODEC_TYPE_AUDIO, 
1355 
.id = CODEC_ID_DTS, 
1356 
.priv_data_size = sizeof(DCAContext),

1357 
.init = dca_decode_init, 
1358 
.decode = dca_decode_frame, 
1359 
.close = dca_decode_end, 
1360 
.long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),

1361 
}; 