?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Replace 5 with AOT_SBR when referring to the MPEG-4 audio object type.
[FFMpeg-mirror/lagarith.git] / libavcodec / dca.c
blobb42d3df0832c893e8a8e1ab57940ac0fecb223ec
1 /*
2 * DCA compatible decoder
3 * Copyright (C) 2004 Gildas Bazin
4 * Copyright (C) 2004 Benjamin Zores
5 * Copyright (C) 2006 Benjamin Larsson
6 * Copyright (C) 2007 Konstantin Shishkov
7 *
8 * This file is part of FFmpeg.
9 *
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 /**
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) + (L-R) (sum-difference)
78 CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total)
79 CH_LAYOUT_STEREO|CH_FRONT_CENTER, ///< 3, C+L+R
80 CH_LAYOUT_STEREO|CH_BACK_CENTER, ///< 3, L+R+S
81 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 4, C + L + R+ S
82 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 4, L + R +SL+ SR
83 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
84 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
85 CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 6, C + L + R+ LR + RR + OV
86 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
87 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
88 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
89 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
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) /* Non-perfect 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((i-1)&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 < 512-hist_index; j += 64){
789 a += prCoeff[i+j ]*(-subband_fir_hist[15-i+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[31-i+j]);
793 }
794 for ( ; j < 512; j += 64){
795 a += prCoeff[i+j ]*(-subband_fir_hist[15-i+j-512]);
796 b += prCoeff[i+j+16]*( subband_fir_hist[ i+j-512]);
797 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j-512]);
798 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j-512]);
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_index-32)&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 * look-up 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 look-up 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 mid-tread 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[abits-1];
987 levels = abits_levels[abits-1];
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 };
ffmpeg Lagarith lossless decoder