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
8
* This file is part of Libav.
10
* Libav 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.
15
* Libav 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.
20
* You should have received a copy of the GNU Lesser General Public
21
* License along with Libav; if not, write to the Free Software
22
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29
#include "libavutil/common.h"
30
#include "libavutil/intmath.h"
31
#include "libavutil/intreadwrite.h"
32
#include "libavutil/audioconvert.h"
41
#include "synth_filter.h"
43
#include "fmtconvert.h"
47
#define DCA_PRIM_CHANNELS_MAX (7)
48
#define DCA_SUBBANDS (32)
49
#define DCA_ABITS_MAX (32) /* Should be 28 */
50
#define DCA_SUBSUBFRAMES_MAX (4)
51
#define DCA_SUBFRAMES_MAX (16)
52
#define DCA_BLOCKS_MAX (16)
53
#define DCA_LFE_MAX (3)
69
/* these are unconfirmed but should be mostly correct */
70
enum DCAExSSSpeakerMask {
71
DCA_EXSS_FRONT_CENTER = 0x0001,
72
DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002,
73
DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004,
74
DCA_EXSS_LFE = 0x0008,
75
DCA_EXSS_REAR_CENTER = 0x0010,
76
DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
77
DCA_EXSS_REAR_LEFT_RIGHT = 0x0040,
78
DCA_EXSS_FRONT_HIGH_CENTER = 0x0080,
79
DCA_EXSS_OVERHEAD = 0x0100,
80
DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200,
81
DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400,
82
DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800,
83
DCA_EXSS_LFE2 = 0x1000,
84
DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000,
85
DCA_EXSS_REAR_HIGH_CENTER = 0x4000,
86
DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000,
89
enum DCAExtensionMask {
90
DCA_EXT_CORE = 0x001, ///< core in core substream
91
DCA_EXT_XXCH = 0x002, ///< XXCh channels extension in core substream
92
DCA_EXT_X96 = 0x004, ///< 96/24 extension in core substream
93
DCA_EXT_XCH = 0x008, ///< XCh channel extension in core substream
94
DCA_EXT_EXSS_CORE = 0x010, ///< core in ExSS (extension substream)
95
DCA_EXT_EXSS_XBR = 0x020, ///< extended bitrate extension in ExSS
96
DCA_EXT_EXSS_XXCH = 0x040, ///< XXCh channels extension in ExSS
97
DCA_EXT_EXSS_X96 = 0x080, ///< 96/24 extension in ExSS
98
DCA_EXT_EXSS_LBR = 0x100, ///< low bitrate component in ExSS
99
DCA_EXT_EXSS_XLL = 0x200, ///< lossless extension in ExSS
102
/* -1 are reserved or unknown */
103
static const int dca_ext_audio_descr_mask[] = {
107
DCA_EXT_XCH | DCA_EXT_X96,
114
/* extensions that reside in core substream */
115
#define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
117
/* Tables for mapping dts channel configurations to libavcodec multichannel api.
118
* Some compromises have been made for special configurations. Most configurations
119
* are never used so complete accuracy is not needed.
121
* L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
122
* S -> side, when both rear and back are configured move one of them to the side channel
124
* All 2 channel configurations -> AV_CH_LAYOUT_STEREO
127
static const int64_t dca_core_channel_layout[] = {
128
AV_CH_FRONT_CENTER, ///< 1, A
129
AV_CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
130
AV_CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
131
AV_CH_LAYOUT_STEREO, ///< 2, (L+R) + (L-R) (sum-difference)
132
AV_CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total)
133
AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER, ///< 3, C+L+R
134
AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER, ///< 3, L+R+S
135
AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|AV_CH_BACK_CENTER, ///< 4, C + L + R+ S
136
AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 4, L + R +SL+ SR
137
AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
138
AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
139
AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT|AV_CH_FRONT_CENTER|AV_CH_BACK_CENTER, ///< 6, C + L + R+ LR + RR + OV
140
AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_BACK_CENTER|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT, ///< 6, CF+ CR+LF+ RF+LR + RR
141
AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
142
AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2
143
AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_BACK_CENTER|AV_CH_SIDE_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR
146
static const int8_t dca_lfe_index[] = {
147
1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
150
static const int8_t dca_channel_reorder_lfe[][9] = {
151
{ 0, -1, -1, -1, -1, -1, -1, -1, -1},
152
{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
153
{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
154
{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
155
{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
156
{ 2, 0, 1, -1, -1, -1, -1, -1, -1},
157
{ 0, 1, 3, -1, -1, -1, -1, -1, -1},
158
{ 2, 0, 1, 4, -1, -1, -1, -1, -1},
159
{ 0, 1, 3, 4, -1, -1, -1, -1, -1},
160
{ 2, 0, 1, 4, 5, -1, -1, -1, -1},
161
{ 3, 4, 0, 1, 5, 6, -1, -1, -1},
162
{ 2, 0, 1, 4, 5, 6, -1, -1, -1},
163
{ 0, 6, 4, 5, 2, 3, -1, -1, -1},
164
{ 4, 2, 5, 0, 1, 6, 7, -1, -1},
165
{ 5, 6, 0, 1, 7, 3, 8, 4, -1},
166
{ 4, 2, 5, 0, 1, 6, 8, 7, -1},
169
static const int8_t dca_channel_reorder_lfe_xch[][9] = {
170
{ 0, 2, -1, -1, -1, -1, -1, -1, -1},
171
{ 0, 1, 3, -1, -1, -1, -1, -1, -1},
172
{ 0, 1, 3, -1, -1, -1, -1, -1, -1},
173
{ 0, 1, 3, -1, -1, -1, -1, -1, -1},
174
{ 0, 1, 3, -1, -1, -1, -1, -1, -1},
175
{ 2, 0, 1, 4, -1, -1, -1, -1, -1},
176
{ 0, 1, 3, 4, -1, -1, -1, -1, -1},
177
{ 2, 0, 1, 4, 5, -1, -1, -1, -1},
178
{ 0, 1, 4, 5, 3, -1, -1, -1, -1},
179
{ 2, 0, 1, 5, 6, 4, -1, -1, -1},
180
{ 3, 4, 0, 1, 6, 7, 5, -1, -1},
181
{ 2, 0, 1, 4, 5, 6, 7, -1, -1},
182
{ 0, 6, 4, 5, 2, 3, 7, -1, -1},
183
{ 4, 2, 5, 0, 1, 7, 8, 6, -1},
184
{ 5, 6, 0, 1, 8, 3, 9, 4, 7},
185
{ 4, 2, 5, 0, 1, 6, 9, 8, 7},
188
static const int8_t dca_channel_reorder_nolfe[][9] = {
189
{ 0, -1, -1, -1, -1, -1, -1, -1, -1},
190
{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
191
{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
192
{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
193
{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
194
{ 2, 0, 1, -1, -1, -1, -1, -1, -1},
195
{ 0, 1, 2, -1, -1, -1, -1, -1, -1},
196
{ 2, 0, 1, 3, -1, -1, -1, -1, -1},
197
{ 0, 1, 2, 3, -1, -1, -1, -1, -1},
198
{ 2, 0, 1, 3, 4, -1, -1, -1, -1},
199
{ 2, 3, 0, 1, 4, 5, -1, -1, -1},
200
{ 2, 0, 1, 3, 4, 5, -1, -1, -1},
201
{ 0, 5, 3, 4, 1, 2, -1, -1, -1},
202
{ 3, 2, 4, 0, 1, 5, 6, -1, -1},
203
{ 4, 5, 0, 1, 6, 2, 7, 3, -1},
204
{ 3, 2, 4, 0, 1, 5, 7, 6, -1},
207
static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
208
{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
209
{ 0, 1, 2, -1, -1, -1, -1, -1, -1},
210
{ 0, 1, 2, -1, -1, -1, -1, -1, -1},
211
{ 0, 1, 2, -1, -1, -1, -1, -1, -1},
212
{ 0, 1, 2, -1, -1, -1, -1, -1, -1},
213
{ 2, 0, 1, 3, -1, -1, -1, -1, -1},
214
{ 0, 1, 2, 3, -1, -1, -1, -1, -1},
215
{ 2, 0, 1, 3, 4, -1, -1, -1, -1},
216
{ 0, 1, 3, 4, 2, -1, -1, -1, -1},
217
{ 2, 0, 1, 4, 5, 3, -1, -1, -1},
218
{ 2, 3, 0, 1, 5, 6, 4, -1, -1},
219
{ 2, 0, 1, 3, 4, 5, 6, -1, -1},
220
{ 0, 5, 3, 4, 1, 2, 6, -1, -1},
221
{ 3, 2, 4, 0, 1, 6, 7, 5, -1},
222
{ 4, 5, 0, 1, 7, 2, 8, 3, 6},
223
{ 3, 2, 4, 0, 1, 5, 8, 7, 6},
226
#define DCA_DOLBY 101 /* FIXME */
228
#define DCA_CHANNEL_BITS 6
229
#define DCA_CHANNEL_MASK 0x3F
233
#define HEADER_SIZE 14
235
#define DCA_MAX_FRAME_SIZE 16384
236
#define DCA_MAX_EXSS_HEADER_SIZE 4096
238
#define DCA_BUFFER_PADDING_SIZE 1024
240
/** Bit allocation */
242
int offset; ///< code values offset
243
int maxbits[8]; ///< max bits in VLC
244
int wrap; ///< wrap for get_vlc2()
245
VLC vlc[8]; ///< actual codes
248
static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
249
static BitAlloc dca_tmode; ///< transition mode VLCs
250
static BitAlloc dca_scalefactor; ///< scalefactor VLCs
251
static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
253
static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
255
return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
259
AVCodecContext *avctx;
261
int frame_type; ///< type of the current frame
262
int samples_deficit; ///< deficit sample count
263
int crc_present; ///< crc is present in the bitstream
264
int sample_blocks; ///< number of PCM sample blocks
265
int frame_size; ///< primary frame byte size
266
int amode; ///< audio channels arrangement
267
int sample_rate; ///< audio sampling rate
268
int bit_rate; ///< transmission bit rate
269
int bit_rate_index; ///< transmission bit rate index
271
int downmix; ///< embedded downmix enabled
272
int dynrange; ///< embedded dynamic range flag
273
int timestamp; ///< embedded time stamp flag
274
int aux_data; ///< auxiliary data flag
275
int hdcd; ///< source material is mastered in HDCD
276
int ext_descr; ///< extension audio descriptor flag
277
int ext_coding; ///< extended coding flag
278
int aspf; ///< audio sync word insertion flag
279
int lfe; ///< low frequency effects flag
280
int predictor_history; ///< predictor history flag
281
int header_crc; ///< header crc check bytes
282
int multirate_inter; ///< multirate interpolator switch
283
int version; ///< encoder software revision
284
int copy_history; ///< copy history
285
int source_pcm_res; ///< source pcm resolution
286
int front_sum; ///< front sum/difference flag
287
int surround_sum; ///< surround sum/difference flag
288
int dialog_norm; ///< dialog normalisation parameter
290
/* Primary audio coding header */
291
int subframes; ///< number of subframes
292
int is_channels_set; ///< check for if the channel number is already set
293
int total_channels; ///< number of channels including extensions
294
int prim_channels; ///< number of primary audio channels
295
int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
296
int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
297
int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
298
int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
299
int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
300
int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
301
int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
302
float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
304
/* Primary audio coding side information */
305
int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
306
int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
307
int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
308
int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
309
int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
310
int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
311
int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
312
int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
313
int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
314
int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
315
int dynrange_coef; ///< dynamic range coefficient
317
int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
319
float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
320
int lfe_scale_factor;
322
/* Subband samples history (for ADPCM) */
323
float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
324
DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
325
DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
326
int hist_index[DCA_PRIM_CHANNELS_MAX];
327
DECLARE_ALIGNED(32, float, raXin)[32];
329
int output; ///< type of output
330
float scale_bias; ///< output scale
332
DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
333
DECLARE_ALIGNED(32, float, samples)[(DCA_PRIM_CHANNELS_MAX+1)*256];
334
const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX+1];
336
uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
337
int dca_buffer_size; ///< how much data is in the dca_buffer
339
const int8_t* channel_order_tab; ///< channel reordering table, lfe and non lfe
341
/* Current position in DCA frame */
342
int current_subframe;
343
int current_subsubframe;
345
int core_ext_mask; ///< present extensions in the core substream
347
/* XCh extension information */
348
int xch_present; ///< XCh extension present and valid
349
int xch_base_channel; ///< index of first (only) channel containing XCH data
351
/* ExSS header parser */
352
int static_fields; ///< static fields present
353
int mix_metadata; ///< mixing metadata present
354
int num_mix_configs; ///< number of mix out configurations
355
int mix_config_num_ch[4]; ///< number of channels in each mix out configuration
359
int debug_flag; ///< used for suppressing repeated error messages output
362
SynthFilterContext synth;
363
DCADSPContext dcadsp;
364
FmtConvertContext fmt_conv;
367
static const uint16_t dca_vlc_offs[] = {
368
0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
369
5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
370
5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
371
7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
372
12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
373
18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
376
static av_cold void dca_init_vlcs(void)
378
static int vlcs_initialized = 0;
380
static VLC_TYPE dca_table[23622][2];
382
if (vlcs_initialized)
385
dca_bitalloc_index.offset = 1;
386
dca_bitalloc_index.wrap = 2;
387
for (i = 0; i < 5; i++) {
388
dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
389
dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
390
init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
391
bitalloc_12_bits[i], 1, 1,
392
bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
394
dca_scalefactor.offset = -64;
395
dca_scalefactor.wrap = 2;
396
for (i = 0; i < 5; i++) {
397
dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
398
dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
399
init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
400
scales_bits[i], 1, 1,
401
scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
403
dca_tmode.offset = 0;
405
for (i = 0; i < 4; i++) {
406
dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
407
dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
408
init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
410
tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
413
for (i = 0; i < 10; i++)
414
for (j = 0; j < 7; j++){
415
if (!bitalloc_codes[i][j]) break;
416
dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
417
dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
418
dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
419
dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
420
init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
422
bitalloc_bits[i][j], 1, 1,
423
bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
426
vlcs_initialized = 1;
429
static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
432
*dst++ = get_bits(gb, bits);
435
static int dca_parse_audio_coding_header(DCAContext * s, int base_channel)
438
static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
439
static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
440
static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
442
s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
443
s->prim_channels = s->total_channels;
445
if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
446
s->prim_channels = DCA_PRIM_CHANNELS_MAX;
449
for (i = base_channel; i < s->prim_channels; i++) {
450
s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
451
if (s->subband_activity[i] > DCA_SUBBANDS)
452
s->subband_activity[i] = DCA_SUBBANDS;
454
for (i = base_channel; i < s->prim_channels; i++) {
455
s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
456
if (s->vq_start_subband[i] > DCA_SUBBANDS)
457
s->vq_start_subband[i] = DCA_SUBBANDS;
459
get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
460
get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
461
get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
462
get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
464
/* Get codebooks quantization indexes */
466
memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
467
for (j = 1; j < 11; j++)
468
for (i = base_channel; i < s->prim_channels; i++)
469
s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
471
/* Get scale factor adjustment */
472
for (j = 0; j < 11; j++)
473
for (i = base_channel; i < s->prim_channels; i++)
474
s->scalefactor_adj[i][j] = 1;
476
for (j = 1; j < 11; j++)
477
for (i = base_channel; i < s->prim_channels; i++)
478
if (s->quant_index_huffman[i][j] < thr[j])
479
s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
481
if (s->crc_present) {
482
/* Audio header CRC check */
483
get_bits(&s->gb, 16);
486
s->current_subframe = 0;
487
s->current_subsubframe = 0;
490
av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
491
av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
492
for (i = base_channel; i < s->prim_channels; i++){
493
av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
494
av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
495
av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
496
av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
497
av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
498
av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
499
av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
500
for (j = 0; j < 11; j++)
501
av_log(s->avctx, AV_LOG_DEBUG, " %i",
502
s->quant_index_huffman[i][j]);
503
av_log(s->avctx, AV_LOG_DEBUG, "\n");
504
av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
505
for (j = 0; j < 11; j++)
506
av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
507
av_log(s->avctx, AV_LOG_DEBUG, "\n");
514
static int dca_parse_frame_header(DCAContext * s)
516
init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
519
get_bits(&s->gb, 32);
522
s->frame_type = get_bits(&s->gb, 1);
523
s->samples_deficit = get_bits(&s->gb, 5) + 1;
524
s->crc_present = get_bits(&s->gb, 1);
525
s->sample_blocks = get_bits(&s->gb, 7) + 1;
526
s->frame_size = get_bits(&s->gb, 14) + 1;
527
if (s->frame_size < 95)
529
s->amode = get_bits(&s->gb, 6);
530
s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
533
s->bit_rate_index = get_bits(&s->gb, 5);
534
s->bit_rate = dca_bit_rates[s->bit_rate_index];
538
s->downmix = get_bits(&s->gb, 1);
539
s->dynrange = get_bits(&s->gb, 1);
540
s->timestamp = get_bits(&s->gb, 1);
541
s->aux_data = get_bits(&s->gb, 1);
542
s->hdcd = get_bits(&s->gb, 1);
543
s->ext_descr = get_bits(&s->gb, 3);
544
s->ext_coding = get_bits(&s->gb, 1);
545
s->aspf = get_bits(&s->gb, 1);
546
s->lfe = get_bits(&s->gb, 2);
547
s->predictor_history = get_bits(&s->gb, 1);
549
/* TODO: check CRC */
551
s->header_crc = get_bits(&s->gb, 16);
553
s->multirate_inter = get_bits(&s->gb, 1);
554
s->version = get_bits(&s->gb, 4);
555
s->copy_history = get_bits(&s->gb, 2);
556
s->source_pcm_res = get_bits(&s->gb, 3);
557
s->front_sum = get_bits(&s->gb, 1);
558
s->surround_sum = get_bits(&s->gb, 1);
559
s->dialog_norm = get_bits(&s->gb, 4);
561
/* FIXME: channels mixing levels */
562
s->output = s->amode;
563
if (s->lfe) s->output |= DCA_LFE;
566
av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
567
av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
568
av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
569
av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
570
s->sample_blocks, s->sample_blocks * 32);
571
av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
572
av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
573
s->amode, dca_channels[s->amode]);
574
av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
576
av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
578
av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
579
av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
580
av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
581
av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
582
av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
583
av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
584
av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
585
av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
586
av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
587
av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
588
s->predictor_history);
589
av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
590
av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
592
av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
593
av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
594
av_log(s->avctx, AV_LOG_DEBUG,
595
"source pcm resolution: %i (%i bits/sample)\n",
596
s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
597
av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
598
av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
599
av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
600
av_log(s->avctx, AV_LOG_DEBUG, "\n");
603
/* Primary audio coding header */
604
s->subframes = get_bits(&s->gb, 4) + 1;
606
return dca_parse_audio_coding_header(s, 0);
610
static inline int get_scale(GetBitContext *gb, int level, int value)
613
/* huffman encoded */
614
value += get_bitalloc(gb, &dca_scalefactor, level);
615
} else if (level < 8)
616
value = get_bits(gb, level + 1);
620
static int dca_subframe_header(DCAContext * s, int base_channel, int block_index)
622
/* Primary audio coding side information */
625
if (get_bits_left(&s->gb) < 0)
629
s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
630
s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
633
for (j = base_channel; j < s->prim_channels; j++) {
634
for (k = 0; k < s->subband_activity[j]; k++)
635
s->prediction_mode[j][k] = get_bits(&s->gb, 1);
638
/* Get prediction codebook */
639
for (j = base_channel; j < s->prim_channels; j++) {
640
for (k = 0; k < s->subband_activity[j]; k++) {
641
if (s->prediction_mode[j][k] > 0) {
642
/* (Prediction coefficient VQ address) */
643
s->prediction_vq[j][k] = get_bits(&s->gb, 12);
648
/* Bit allocation index */
649
for (j = base_channel; j < s->prim_channels; j++) {
650
for (k = 0; k < s->vq_start_subband[j]; k++) {
651
if (s->bitalloc_huffman[j] == 6)
652
s->bitalloc[j][k] = get_bits(&s->gb, 5);
653
else if (s->bitalloc_huffman[j] == 5)
654
s->bitalloc[j][k] = get_bits(&s->gb, 4);
655
else if (s->bitalloc_huffman[j] == 7) {
656
av_log(s->avctx, AV_LOG_ERROR,
657
"Invalid bit allocation index\n");
661
get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
664
if (s->bitalloc[j][k] > 26) {
665
// av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
666
// j, k, s->bitalloc[j][k]);
672
/* Transition mode */
673
for (j = base_channel; j < s->prim_channels; j++) {
674
for (k = 0; k < s->subband_activity[j]; k++) {
675
s->transition_mode[j][k] = 0;
676
if (s->subsubframes[s->current_subframe] > 1 &&
677
k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
678
s->transition_mode[j][k] =
679
get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
684
if (get_bits_left(&s->gb) < 0)
687
for (j = base_channel; j < s->prim_channels; j++) {
688
const uint32_t *scale_table;
691
memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
693
if (s->scalefactor_huffman[j] == 6)
694
scale_table = scale_factor_quant7;
696
scale_table = scale_factor_quant6;
698
/* When huffman coded, only the difference is encoded */
701
for (k = 0; k < s->subband_activity[j]; k++) {
702
if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
703
scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
704
s->scale_factor[j][k][0] = scale_table[scale_sum];
707
if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
708
/* Get second scale factor */
709
scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
710
s->scale_factor[j][k][1] = scale_table[scale_sum];
715
/* Joint subband scale factor codebook select */
716
for (j = base_channel; j < s->prim_channels; j++) {
717
/* Transmitted only if joint subband coding enabled */
718
if (s->joint_intensity[j] > 0)
719
s->joint_huff[j] = get_bits(&s->gb, 3);
722
if (get_bits_left(&s->gb) < 0)
725
/* Scale factors for joint subband coding */
726
for (j = base_channel; j < s->prim_channels; j++) {
729
/* Transmitted only if joint subband coding enabled */
730
if (s->joint_intensity[j] > 0) {
732
source_channel = s->joint_intensity[j] - 1;
734
/* When huffman coded, only the difference is encoded
735
* (is this valid as well for joint scales ???) */
737
for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
738
scale = get_scale(&s->gb, s->joint_huff[j], 0);
739
scale += 64; /* bias */
740
s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
743
if (!(s->debug_flag & 0x02)) {
744
av_log(s->avctx, AV_LOG_DEBUG,
745
"Joint stereo coding not supported\n");
746
s->debug_flag |= 0x02;
751
/* Stereo downmix coefficients */
752
if (!base_channel && s->prim_channels > 2) {
754
for (j = base_channel; j < s->prim_channels; j++) {
755
s->downmix_coef[j][0] = get_bits(&s->gb, 7);
756
s->downmix_coef[j][1] = get_bits(&s->gb, 7);
759
int am = s->amode & DCA_CHANNEL_MASK;
760
for (j = base_channel; j < s->prim_channels; j++) {
761
s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
762
s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
767
/* Dynamic range coefficient */
768
if (!base_channel && s->dynrange)
769
s->dynrange_coef = get_bits(&s->gb, 8);
771
/* Side information CRC check word */
772
if (s->crc_present) {
773
get_bits(&s->gb, 16);
777
* Primary audio data arrays
780
/* VQ encoded high frequency subbands */
781
for (j = base_channel; j < s->prim_channels; j++)
782
for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
783
/* 1 vector -> 32 samples */
784
s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
786
/* Low frequency effect data */
787
if (!base_channel && s->lfe) {
789
int lfe_samples = 2 * s->lfe * (4 + block_index);
790
int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
793
for (j = lfe_samples; j < lfe_end_sample; j++) {
794
/* Signed 8 bits int */
795
s->lfe_data[j] = get_sbits(&s->gb, 8);
798
/* Scale factor index */
799
s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
801
/* Quantization step size * scale factor */
802
lfe_scale = 0.035 * s->lfe_scale_factor;
804
for (j = lfe_samples; j < lfe_end_sample; j++)
805
s->lfe_data[j] *= lfe_scale;
809
av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes[s->current_subframe]);
810
av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
811
s->partial_samples[s->current_subframe]);
812
for (j = base_channel; j < s->prim_channels; j++) {
813
av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
814
for (k = 0; k < s->subband_activity[j]; k++)
815
av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
816
av_log(s->avctx, AV_LOG_DEBUG, "\n");
818
for (j = base_channel; j < s->prim_channels; j++) {
819
for (k = 0; k < s->subband_activity[j]; k++)
820
av_log(s->avctx, AV_LOG_DEBUG,
821
"prediction coefs: %f, %f, %f, %f\n",
822
(float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
823
(float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
824
(float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
825
(float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
827
for (j = base_channel; j < s->prim_channels; j++) {
828
av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
829
for (k = 0; k < s->vq_start_subband[j]; k++)
830
av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
831
av_log(s->avctx, AV_LOG_DEBUG, "\n");
833
for (j = base_channel; j < s->prim_channels; j++) {
834
av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
835
for (k = 0; k < s->subband_activity[j]; k++)
836
av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
837
av_log(s->avctx, AV_LOG_DEBUG, "\n");
839
for (j = base_channel; j < s->prim_channels; j++) {
840
av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
841
for (k = 0; k < s->subband_activity[j]; k++) {
842
if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
843
av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
844
if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
845
av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
847
av_log(s->avctx, AV_LOG_DEBUG, "\n");
849
for (j = base_channel; j < s->prim_channels; j++) {
850
if (s->joint_intensity[j] > 0) {
851
int source_channel = s->joint_intensity[j] - 1;
852
av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
853
for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
854
av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
855
av_log(s->avctx, AV_LOG_DEBUG, "\n");
858
if (!base_channel && s->prim_channels > 2 && s->downmix) {
859
av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
860
for (j = 0; j < s->prim_channels; j++) {
861
av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
862
av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
864
av_log(s->avctx, AV_LOG_DEBUG, "\n");
866
for (j = base_channel; j < s->prim_channels; j++)
867
for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
868
av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
869
if (!base_channel && s->lfe) {
870
int lfe_samples = 2 * s->lfe * (4 + block_index);
871
int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
873
av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
874
for (j = lfe_samples; j < lfe_end_sample; j++)
875
av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
876
av_log(s->avctx, AV_LOG_DEBUG, "\n");
883
static void qmf_32_subbands(DCAContext * s, int chans,
884
float samples_in[32][8], float *samples_out,
887
const float *prCoeff;
890
int sb_act = s->subband_activity[chans];
893
scale *= sqrt(1/8.0);
896
if (!s->multirate_inter) /* Non-perfect reconstruction */
897
prCoeff = fir_32bands_nonperfect;
898
else /* Perfect reconstruction */
899
prCoeff = fir_32bands_perfect;
901
/* Reconstructed channel sample index */
902
for (subindex = 0; subindex < 8; subindex++) {
903
/* Load in one sample from each subband and clear inactive subbands */
904
for (i = 0; i < sb_act; i++){
905
uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
906
AV_WN32A(&s->raXin[i], v);
911
s->synth.synth_filter_float(&s->imdct,
912
s->subband_fir_hist[chans], &s->hist_index[chans],
913
s->subband_fir_noidea[chans], prCoeff,
914
samples_out, s->raXin, scale);
920
static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
921
int num_deci_sample, float *samples_in,
922
float *samples_out, float scale)
924
/* samples_in: An array holding decimated samples.
925
* Samples in current subframe starts from samples_in[0],
926
* while samples_in[-1], samples_in[-2], ..., stores samples
927
* from last subframe as history.
929
* samples_out: An array holding interpolated samples
933
const float *prCoeff;
936
/* Select decimation filter */
937
if (decimation_select == 1) {
939
prCoeff = lfe_fir_128;
942
prCoeff = lfe_fir_64;
945
for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
946
s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
949
samples_out += 2 * decifactor;
953
/* downmixing routines */
954
#define MIX_REAR1(samples, si1, rs, coef) \
955
samples[i] += samples[si1] * coef[rs][0]; \
956
samples[i+256] += samples[si1] * coef[rs][1];
958
#define MIX_REAR2(samples, si1, si2, rs, coef) \
959
samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
960
samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
962
#define MIX_FRONT3(samples, coef) \
966
samples[i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
967
samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
969
#define DOWNMIX_TO_STEREO(op1, op2) \
970
for (i = 0; i < 256; i++){ \
975
static void dca_downmix(float *samples, int srcfmt,
976
int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
977
const int8_t *channel_mapping)
982
float coef[DCA_PRIM_CHANNELS_MAX][2];
984
for (i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
985
coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
986
coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
992
case DCA_STEREO_TOTAL:
993
case DCA_STEREO_SUMDIFF:
995
av_log(NULL, 0, "Not implemented!\n");
1000
c = channel_mapping[0] * 256;
1001
l = channel_mapping[1] * 256;
1002
r = channel_mapping[2] * 256;
1003
DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
1006
s = channel_mapping[2] * 256;
1007
DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef),);
1010
c = channel_mapping[0] * 256;
1011
l = channel_mapping[1] * 256;
1012
r = channel_mapping[2] * 256;
1013
s = channel_mapping[3] * 256;
1014
DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1015
MIX_REAR1(samples, i + s, 3, coef));
1018
sl = channel_mapping[2] * 256;
1019
sr = channel_mapping[3] * 256;
1020
DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef),);
1023
c = channel_mapping[0] * 256;
1024
l = channel_mapping[1] * 256;
1025
r = channel_mapping[2] * 256;
1026
sl = channel_mapping[3] * 256;
1027
sr = channel_mapping[4] * 256;
1028
DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1029
MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1035
/* Very compact version of the block code decoder that does not use table
1036
* look-up but is slightly slower */
1037
static int decode_blockcode(int code, int levels, int *values)
1040
int offset = (levels - 1) >> 1;
1042
for (i = 0; i < 4; i++) {
1043
int div = FASTDIV(code, levels);
1044
values[i] = code - offset - div*levels;
1051
av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
1056
static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1057
static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1059
static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
1062
int subsubframe = s->current_subsubframe;
1064
const float *quant_step_table;
1067
float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1068
LOCAL_ALIGNED_16(int, block, [8]);
1074
/* Select quantization step size table */
1075
if (s->bit_rate_index == 0x1f)
1076
quant_step_table = lossless_quant_d;
1078
quant_step_table = lossy_quant_d;
1080
for (k = base_channel; k < s->prim_channels; k++) {
1081
if (get_bits_left(&s->gb) < 0)
1084
for (l = 0; l < s->vq_start_subband[k]; l++) {
1087
/* Select the mid-tread linear quantizer */
1088
int abits = s->bitalloc[k][l];
1090
float quant_step_size = quant_step_table[abits];
1093
* Determine quantization index code book and its type
1096
/* Select quantization index code book */
1097
int sel = s->quant_index_huffman[k][abits];
1100
* Extract bits from the bit stream
1103
memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1105
/* Deal with transients */
1106
int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1107
float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
1109
if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
1112
int block_code1, block_code2, size, levels;
1114
size = abits_sizes[abits-1];
1115
levels = abits_levels[abits-1];
1117
block_code1 = get_bits(&s->gb, size);
1118
/* FIXME Should test return value */
1119
decode_blockcode(block_code1, levels, block);
1120
block_code2 = get_bits(&s->gb, size);
1121
decode_blockcode(block_code2, levels, &block[4]);
1124
for (m = 0; m < 8; m++)
1125
block[m] = get_sbits(&s->gb, abits - 3);
1129
for (m = 0; m < 8; m++)
1130
block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1133
s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1138
* Inverse ADPCM if in prediction mode
1140
if (s->prediction_mode[k][l]) {
1142
for (m = 0; m < 8; m++) {
1143
for (n = 1; n <= 4; n++)
1145
subband_samples[k][l][m] +=
1146
(adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1147
subband_samples[k][l][m - n] / 8192);
1148
else if (s->predictor_history)
1149
subband_samples[k][l][m] +=
1150
(adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1151
s->subband_samples_hist[k][l][m - n +
1158
* Decode VQ encoded high frequencies
1160
for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1161
/* 1 vector -> 32 samples but we only need the 8 samples
1162
* for this subsubframe. */
1165
if (!s->debug_flag & 0x01) {
1166
av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1167
s->debug_flag |= 0x01;
1170
for (m = 0; m < 8; m++) {
1171
subband_samples[k][l][m] =
1172
high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1174
* (float) s->scale_factor[k][l][0] / 16.0;
1179
/* Check for DSYNC after subsubframe */
1180
if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1181
if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1183
av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1186
av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1190
/* Backup predictor history for adpcm */
1191
for (k = base_channel; k < s->prim_channels; k++)
1192
for (l = 0; l < s->vq_start_subband[k]; l++)
1193
memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1194
4 * sizeof(subband_samples[0][0][0]));
1199
static int dca_filter_channels(DCAContext * s, int block_index)
1201
float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1204
/* 32 subbands QMF */
1205
for (k = 0; k < s->prim_channels; k++) {
1206
/* static float pcm_to_double[8] =
1207
{32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1208
qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1209
M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ );
1213
if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1214
dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
1217
/* Generate LFE samples for this subsubframe FIXME!!! */
1218
if (s->output & DCA_LFE) {
1219
lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1220
s->lfe_data + 2 * s->lfe * (block_index + 4),
1221
&s->samples[256 * dca_lfe_index[s->amode]],
1222
(1.0/256.0)*s->scale_bias);
1223
/* Outputs 20bits pcm samples */
1230
static int dca_subframe_footer(DCAContext * s, int base_channel)
1232
int aux_data_count = 0, i;
1235
* Unpack optional information
1238
/* presumably optional information only appears in the core? */
1239
if (!base_channel) {
1241
get_bits(&s->gb, 32);
1244
aux_data_count = get_bits(&s->gb, 6);
1246
for (i = 0; i < aux_data_count; i++)
1247
get_bits(&s->gb, 8);
1249
if (s->crc_present && (s->downmix || s->dynrange))
1250
get_bits(&s->gb, 16);
1257
* Decode a dca frame block
1259
* @param s pointer to the DCAContext
1262
static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1266
if (s->current_subframe >= s->subframes) {
1267
av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1268
s->current_subframe, s->subframes);
1272
if (!s->current_subsubframe) {
1274
av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1276
/* Read subframe header */
1277
if (dca_subframe_header(s, base_channel, block_index))
1281
/* Read subsubframe */
1283
av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1285
if (dca_subsubframe(s, base_channel, block_index))
1289
s->current_subsubframe++;
1290
if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1291
s->current_subsubframe = 0;
1292
s->current_subframe++;
1294
if (s->current_subframe >= s->subframes) {
1296
av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1298
/* Read subframe footer */
1299
if (dca_subframe_footer(s, base_channel))
1307
* Convert bitstream to one representation based on sync marker
1309
static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1314
const uint16_t *ssrc = (const uint16_t *) src;
1315
uint16_t *sdst = (uint16_t *) dst;
1318
if ((unsigned)src_size > (unsigned)max_size) {
1319
// av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1321
src_size = max_size;
1326
case DCA_MARKER_RAW_BE:
1327
memcpy(dst, src, src_size);
1329
case DCA_MARKER_RAW_LE:
1330
for (i = 0; i < (src_size + 1) >> 1; i++)
1331
*sdst++ = av_bswap16(*ssrc++);
1333
case DCA_MARKER_14B_BE:
1334
case DCA_MARKER_14B_LE:
1335
init_put_bits(&pb, dst, max_size);
1336
for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1337
tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1338
put_bits(&pb, 14, tmp);
1340
flush_put_bits(&pb);
1341
return (put_bits_count(&pb) + 7) >> 3;
1348
* Return the number of channels in an ExSS speaker mask (HD)
1350
static int dca_exss_mask2count(int mask)
1352
/* count bits that mean speaker pairs twice */
1353
return av_popcount(mask)
1354
+ av_popcount(mask & (
1355
DCA_EXSS_CENTER_LEFT_RIGHT
1356
| DCA_EXSS_FRONT_LEFT_RIGHT
1357
| DCA_EXSS_FRONT_HIGH_LEFT_RIGHT
1358
| DCA_EXSS_WIDE_LEFT_RIGHT
1359
| DCA_EXSS_SIDE_LEFT_RIGHT
1360
| DCA_EXSS_SIDE_HIGH_LEFT_RIGHT
1361
| DCA_EXSS_SIDE_REAR_LEFT_RIGHT
1362
| DCA_EXSS_REAR_LEFT_RIGHT
1363
| DCA_EXSS_REAR_HIGH_LEFT_RIGHT
1368
* Skip mixing coefficients of a single mix out configuration (HD)
1370
static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1374
for (i = 0; i < channels; i++) {
1375
int mix_map_mask = get_bits(gb, out_ch);
1376
int num_coeffs = av_popcount(mix_map_mask);
1377
skip_bits_long(gb, num_coeffs * 6);
1382
* Parse extension substream asset header (HD)
1384
static int dca_exss_parse_asset_header(DCAContext *s)
1386
int header_pos = get_bits_count(&s->gb);
1389
int embedded_stereo = 0;
1390
int embedded_6ch = 0;
1391
int drc_code_present;
1392
int extensions_mask;
1395
if (get_bits_left(&s->gb) < 16)
1398
/* We will parse just enough to get to the extensions bitmask with which
1399
* we can set the profile value. */
1401
header_size = get_bits(&s->gb, 9) + 1;
1402
skip_bits(&s->gb, 3); // asset index
1404
if (s->static_fields) {
1405
if (get_bits1(&s->gb))
1406
skip_bits(&s->gb, 4); // asset type descriptor
1407
if (get_bits1(&s->gb))
1408
skip_bits_long(&s->gb, 24); // language descriptor
1410
if (get_bits1(&s->gb)) {
1411
/* How can one fit 1024 bytes of text here if the maximum value
1412
* for the asset header size field above was 512 bytes? */
1413
int text_length = get_bits(&s->gb, 10) + 1;
1414
if (get_bits_left(&s->gb) < text_length * 8)
1416
skip_bits_long(&s->gb, text_length * 8); // info text
1419
skip_bits(&s->gb, 5); // bit resolution - 1
1420
skip_bits(&s->gb, 4); // max sample rate code
1421
channels = get_bits(&s->gb, 8) + 1;
1423
if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1424
int spkr_remap_sets;
1425
int spkr_mask_size = 16;
1429
embedded_stereo = get_bits1(&s->gb);
1431
embedded_6ch = get_bits1(&s->gb);
1433
if (get_bits1(&s->gb)) {
1434
spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1435
skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1438
spkr_remap_sets = get_bits(&s->gb, 3);
1440
for (i = 0; i < spkr_remap_sets; i++) {
1441
/* std layout mask for each remap set */
1442
num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1445
for (i = 0; i < spkr_remap_sets; i++) {
1446
int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1447
if (get_bits_left(&s->gb) < 0)
1450
for (j = 0; j < num_spkrs[i]; j++) {
1451
int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1452
int num_dec_ch = av_popcount(remap_dec_ch_mask);
1453
skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1458
skip_bits(&s->gb, 3); // representation type
1462
drc_code_present = get_bits1(&s->gb);
1463
if (drc_code_present)
1464
get_bits(&s->gb, 8); // drc code
1466
if (get_bits1(&s->gb))
1467
skip_bits(&s->gb, 5); // dialog normalization code
1469
if (drc_code_present && embedded_stereo)
1470
get_bits(&s->gb, 8); // drc stereo code
1472
if (s->mix_metadata && get_bits1(&s->gb)) {
1473
skip_bits(&s->gb, 1); // external mix
1474
skip_bits(&s->gb, 6); // post mix gain code
1476
if (get_bits(&s->gb, 2) != 3) // mixer drc code
1477
skip_bits(&s->gb, 3); // drc limit
1479
skip_bits(&s->gb, 8); // custom drc code
1481
if (get_bits1(&s->gb)) // channel specific scaling
1482
for (i = 0; i < s->num_mix_configs; i++)
1483
skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1485
skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1487
for (i = 0; i < s->num_mix_configs; i++) {
1488
if (get_bits_left(&s->gb) < 0)
1490
dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1492
dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1493
if (embedded_stereo)
1494
dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1498
switch (get_bits(&s->gb, 2)) {
1499
case 0: extensions_mask = get_bits(&s->gb, 12); break;
1500
case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1501
case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1502
case 3: extensions_mask = 0; /* aux coding */ break;
1505
/* not parsed further, we were only interested in the extensions mask */
1507
if (get_bits_left(&s->gb) < 0)
1510
if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1511
av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1514
skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1516
if (extensions_mask & DCA_EXT_EXSS_XLL)
1517
s->profile = FF_PROFILE_DTS_HD_MA;
1518
else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1520
s->profile = FF_PROFILE_DTS_HD_HRA;
1522
if (!(extensions_mask & DCA_EXT_CORE))
1523
av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1524
if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1525
av_log(s->avctx, AV_LOG_WARNING, "DTS extensions detection mismatch (%d, %d)\n",
1526
extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1532
* Parse extension substream header (HD)
1534
static void dca_exss_parse_header(DCAContext *s)
1540
int active_ss_mask[8];
1543
if (get_bits_left(&s->gb) < 52)
1546
skip_bits(&s->gb, 8); // user data
1547
ss_index = get_bits(&s->gb, 2);
1549
blownup = get_bits1(&s->gb);
1550
skip_bits(&s->gb, 8 + 4 * blownup); // header_size
1551
skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1553
s->static_fields = get_bits1(&s->gb);
1554
if (s->static_fields) {
1555
skip_bits(&s->gb, 2); // reference clock code
1556
skip_bits(&s->gb, 3); // frame duration code
1558
if (get_bits1(&s->gb))
1559
skip_bits_long(&s->gb, 36); // timestamp
1561
/* a single stream can contain multiple audio assets that can be
1562
* combined to form multiple audio presentations */
1564
num_audiop = get_bits(&s->gb, 3) + 1;
1565
if (num_audiop > 1) {
1566
av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1567
/* ignore such streams for now */
1571
num_assets = get_bits(&s->gb, 3) + 1;
1572
if (num_assets > 1) {
1573
av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1574
/* ignore such streams for now */
1578
for (i = 0; i < num_audiop; i++)
1579
active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1581
for (i = 0; i < num_audiop; i++)
1582
for (j = 0; j <= ss_index; j++)
1583
if (active_ss_mask[i] & (1 << j))
1584
skip_bits(&s->gb, 8); // active asset mask
1586
s->mix_metadata = get_bits1(&s->gb);
1587
if (s->mix_metadata) {
1588
int mix_out_mask_size;
1590
skip_bits(&s->gb, 2); // adjustment level
1591
mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1592
s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1594
for (i = 0; i < s->num_mix_configs; i++) {
1595
int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1596
s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1601
for (i = 0; i < num_assets; i++)
1602
skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1604
for (i = 0; i < num_assets; i++) {
1605
if (dca_exss_parse_asset_header(s))
1609
/* not parsed further, we were only interested in the extensions mask
1610
* from the asset header */
1614
* Main frame decoding function
1615
* FIXME add arguments
1617
static int dca_decode_frame(AVCodecContext * avctx,
1618
void *data, int *data_size,
1621
const uint8_t *buf = avpkt->data;
1622
int buf_size = avpkt->size;
1625
int num_core_channels = 0;
1627
float *samples_flt = data;
1628
int16_t *samples_s16 = data;
1630
DCAContext *s = avctx->priv_data;
1637
s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1638
DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1639
if (s->dca_buffer_size == -1) {
1640
av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1644
init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1645
if (dca_parse_frame_header(s) < 0) {
1646
//seems like the frame is corrupt, try with the next one
1650
//set AVCodec values with parsed data
1651
avctx->sample_rate = s->sample_rate;
1652
avctx->bit_rate = s->bit_rate;
1654
s->profile = FF_PROFILE_DTS;
1656
for (i = 0; i < (s->sample_blocks / 8); i++) {
1657
dca_decode_block(s, 0, i);
1660
/* record number of core channels incase less than max channels are requested */
1661
num_core_channels = s->prim_channels;
1664
s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
1666
s->core_ext_mask = 0;
1668
core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1670
/* only scan for extensions if ext_descr was unknown or indicated a
1671
* supported XCh extension */
1672
if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
1674
/* if ext_descr was unknown, clear s->core_ext_mask so that the
1675
* extensions scan can fill it up */
1676
s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
1678
/* extensions start at 32-bit boundaries into bitstream */
1679
skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1681
while(core_ss_end - get_bits_count(&s->gb) >= 32) {
1682
uint32_t bits = get_bits_long(&s->gb, 32);
1686
int ext_amode, xch_fsize;
1688
s->xch_base_channel = s->prim_channels;
1690
/* validate sync word using XCHFSIZE field */
1691
xch_fsize = show_bits(&s->gb, 10);
1692
if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1693
(s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1696
/* skip length-to-end-of-frame field for the moment */
1697
skip_bits(&s->gb, 10);
1699
s->core_ext_mask |= DCA_EXT_XCH;
1701
/* extension amode should == 1, number of channels in extension */
1702
/* AFAIK XCh is not used for more channels */
1703
if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1704
av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1705
" supported!\n",ext_amode);
1709
/* much like core primary audio coding header */
1710
dca_parse_audio_coding_header(s, s->xch_base_channel);
1712
for (i = 0; i < (s->sample_blocks / 8); i++) {
1713
dca_decode_block(s, s->xch_base_channel, i);
1720
/* XXCh: extended channels */
1721
/* usually found either in core or HD part in DTS-HD HRA streams,
1722
* but not in DTS-ES which contains XCh extensions instead */
1723
s->core_ext_mask |= DCA_EXT_XXCH;
1727
int fsize96 = show_bits(&s->gb, 12) + 1;
1728
if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1731
av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n", get_bits_count(&s->gb));
1732
skip_bits(&s->gb, 12);
1733
av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1734
av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1736
s->core_ext_mask |= DCA_EXT_X96;
1741
skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1745
/* no supported extensions, skip the rest of the core substream */
1746
skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
1749
if (s->core_ext_mask & DCA_EXT_X96)
1750
s->profile = FF_PROFILE_DTS_96_24;
1751
else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
1752
s->profile = FF_PROFILE_DTS_ES;
1754
/* check for ExSS (HD part) */
1755
if (s->dca_buffer_size - s->frame_size > 32
1756
&& get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1757
dca_exss_parse_header(s);
1759
avctx->profile = s->profile;
1761
channels = s->prim_channels + !!s->lfe;
1764
avctx->channel_layout = dca_core_channel_layout[s->amode];
1766
if (s->xch_present && (!avctx->request_channels ||
1767
avctx->request_channels > num_core_channels + !!s->lfe)) {
1768
avctx->channel_layout |= AV_CH_BACK_CENTER;
1770
avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1771
s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1773
s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1776
channels = num_core_channels + !!s->lfe;
1777
s->xch_present = 0; /* disable further xch processing */
1779
avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1780
s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1782
s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1785
if (channels > !!s->lfe &&
1786
s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1789
if (avctx->request_channels == 2 && s->prim_channels > 2) {
1791
s->output = DCA_STEREO;
1792
avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1795
av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1800
/* There is nothing that prevents a dts frame to change channel configuration
1801
but Libav doesn't support that so only set the channels if it is previously
1802
unset. Ideally during the first probe for channels the crc should be checked
1803
and only set avctx->channels when the crc is ok. Right now the decoder could
1804
set the channels based on a broken first frame.*/
1805
if (s->is_channels_set == 0) {
1806
s->is_channels_set = 1;
1807
avctx->channels = channels;
1809
if (avctx->channels != channels) {
1810
av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
1811
"channels changing in stream. Skipping frame.\n");
1815
out_size = 256 / 8 * s->sample_blocks * channels *
1816
(av_get_bits_per_sample_fmt(avctx->sample_fmt) / 8);
1817
if (*data_size < out_size)
1819
*data_size = out_size;
1821
/* filter to get final output */
1822
for (i = 0; i < (s->sample_blocks / 8); i++) {
1823
dca_filter_channels(s, i);
1825
/* If this was marked as a DTS-ES stream we need to subtract back- */
1826
/* channel from SL & SR to remove matrixed back-channel signal */
1827
if((s->source_pcm_res & 1) && s->xch_present) {
1828
float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1829
float* lt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1830
float* rt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1832
for(j = 0; j < 256; ++j) {
1833
lt_chan[j] -= back_chan[j] * M_SQRT1_2;
1834
rt_chan[j] -= back_chan[j] * M_SQRT1_2;
1838
if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1839
s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
1841
samples_flt += 256 * channels;
1843
s->fmt_conv.float_to_int16_interleave(samples_s16,
1844
s->samples_chanptr, 256,
1846
samples_s16 += 256 * channels;
1850
/* update lfe history */
1851
lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1852
for (i = 0; i < 2 * s->lfe * 4; i++) {
1853
s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1862
* DCA initialization
1864
* @param avctx pointer to the AVCodecContext
1867
static av_cold int dca_decode_init(AVCodecContext * avctx)
1869
DCAContext *s = avctx->priv_data;
1875
dsputil_init(&s->dsp, avctx);
1876
ff_mdct_init(&s->imdct, 6, 1, 1.0);
1877
ff_synth_filter_init(&s->synth);
1878
ff_dcadsp_init(&s->dcadsp);
1879
ff_fmt_convert_init(&s->fmt_conv, avctx);
1881
for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
1882
s->samples_chanptr[i] = s->samples + i * 256;
1884
if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
1885
avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1886
s->scale_bias = 1.0 / 32768.0;
1888
avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1889
s->scale_bias = 1.0;
1892
/* allow downmixing to stereo */
1893
if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1894
avctx->request_channels == 2) {
1895
avctx->channels = avctx->request_channels;
1901
static av_cold int dca_decode_end(AVCodecContext * avctx)
1903
DCAContext *s = avctx->priv_data;
1904
ff_mdct_end(&s->imdct);
1908
static const AVProfile profiles[] = {
1909
{ FF_PROFILE_DTS, "DTS" },
1910
{ FF_PROFILE_DTS_ES, "DTS-ES" },
1911
{ FF_PROFILE_DTS_96_24, "DTS 96/24" },
1912
{ FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1913
{ FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
1914
{ FF_PROFILE_UNKNOWN },
1917
AVCodec ff_dca_decoder = {
1919
.type = AVMEDIA_TYPE_AUDIO,
1921
.priv_data_size = sizeof(DCAContext),
1922
.init = dca_decode_init,
1923
.decode = dca_decode_frame,
1924
.close = dca_decode_end,
1925
.long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1926
.capabilities = CODEC_CAP_CHANNEL_CONF,
1927
.sample_fmts = (const enum AVSampleFormat[]) {
1928
AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
1930
.profiles = NULL_IF_CONFIG_SMALL(profiles),
added
removed
.pc/post-0.7.1/0008-dca-set-AVCodecContext-frame_size-for-DTS-audio.patch/libavcodec/dca.c
