repositories / deb_ffmpeg.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Debian version 2.4.3~trusty1
[deb_ffmpeg.git] / ffmpeg / libavcodec / dcadec.c
CommitLineData
2ba45a60
DM		 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#include <math.h>
26#include <stddef.h>
27#include <stdio.h>
28
29#include "libavutil/channel_layout.h"
30#include "libavutil/common.h"
31#include "libavutil/float_dsp.h"
32#include "libavutil/internal.h"
33#include "libavutil/intreadwrite.h"
34#include "libavutil/mathematics.h"
35#include "libavutil/opt.h"
36#include "libavutil/samplefmt.h"
37#include "avcodec.h"
38#include "fft.h"
39#include "get_bits.h"
40#include "dcadata.h"
41#include "dcahuff.h"
42#include "dca.h"
43#include "mathops.h"
44#include "synth_filter.h"
45#include "dcadsp.h"
46#include "fmtconvert.h"
47#include "internal.h"
48
49#if ARCH_ARM
50# include "arm/dca.h"
51#endif
52
53//#define TRACE
54
55#define DCA_PRIM_CHANNELS_MAX (7)
56#define DCA_ABITS_MAX (32) /* Should be 28 */
57#define DCA_SUBSUBFRAMES_MAX (4)
58#define DCA_SUBFRAMES_MAX (16)
59#define DCA_BLOCKS_MAX (16)
60#define DCA_LFE_MAX (3)
61#define DCA_CHSETS_MAX (4)
62#define DCA_CHSET_CHANS_MAX (8)
63
64enum DCAMode {
65 DCA_MONO = 0,
66 DCA_CHANNEL,
67 DCA_STEREO,
68 DCA_STEREO_SUMDIFF,
69 DCA_STEREO_TOTAL,
70 DCA_3F,
71 DCA_2F1R,
72 DCA_3F1R,
73 DCA_2F2R,
74 DCA_3F2R,
75 DCA_4F2R
76};
77
78/* these are unconfirmed but should be mostly correct */
79enum DCAExSSSpeakerMask {
80 DCA_EXSS_FRONT_CENTER = 0x0001,
81 DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002,
82 DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004,
83 DCA_EXSS_LFE = 0x0008,
84 DCA_EXSS_REAR_CENTER = 0x0010,
85 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
86 DCA_EXSS_REAR_LEFT_RIGHT = 0x0040,
87 DCA_EXSS_FRONT_HIGH_CENTER = 0x0080,
88 DCA_EXSS_OVERHEAD = 0x0100,
89 DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200,
90 DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400,
91 DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800,
92 DCA_EXSS_LFE2 = 0x1000,
93 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000,
94 DCA_EXSS_REAR_HIGH_CENTER = 0x4000,
95 DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000,
96};
97
98enum DCAXxchSpeakerMask {
99 DCA_XXCH_FRONT_CENTER = 0x0000001,
100 DCA_XXCH_FRONT_LEFT = 0x0000002,
101 DCA_XXCH_FRONT_RIGHT = 0x0000004,
102 DCA_XXCH_SIDE_REAR_LEFT = 0x0000008,
103 DCA_XXCH_SIDE_REAR_RIGHT = 0x0000010,
104 DCA_XXCH_LFE1 = 0x0000020,
105 DCA_XXCH_REAR_CENTER = 0x0000040,
106 DCA_XXCH_SURROUND_REAR_LEFT = 0x0000080,
107 DCA_XXCH_SURROUND_REAR_RIGHT = 0x0000100,
108 DCA_XXCH_SIDE_SURROUND_LEFT = 0x0000200,
109 DCA_XXCH_SIDE_SURROUND_RIGHT = 0x0000400,
110 DCA_XXCH_FRONT_CENTER_LEFT = 0x0000800,
111 DCA_XXCH_FRONT_CENTER_RIGHT = 0x0001000,
112 DCA_XXCH_FRONT_HIGH_LEFT = 0x0002000,
113 DCA_XXCH_FRONT_HIGH_CENTER = 0x0004000,
114 DCA_XXCH_FRONT_HIGH_RIGHT = 0x0008000,
115 DCA_XXCH_LFE2 = 0x0010000,
116 DCA_XXCH_SIDE_FRONT_LEFT = 0x0020000,
117 DCA_XXCH_SIDE_FRONT_RIGHT = 0x0040000,
118 DCA_XXCH_OVERHEAD = 0x0080000,
119 DCA_XXCH_SIDE_HIGH_LEFT = 0x0100000,
120 DCA_XXCH_SIDE_HIGH_RIGHT = 0x0200000,
121 DCA_XXCH_REAR_HIGH_CENTER = 0x0400000,
122 DCA_XXCH_REAR_HIGH_LEFT = 0x0800000,
123 DCA_XXCH_REAR_HIGH_RIGHT = 0x1000000,
124 DCA_XXCH_REAR_LOW_CENTER = 0x2000000,
125 DCA_XXCH_REAR_LOW_LEFT = 0x4000000,
126 DCA_XXCH_REAR_LOW_RIGHT = 0x8000000,
127};
128
129static const uint32_t map_xxch_to_native[28] = {
130 AV_CH_FRONT_CENTER,
131 AV_CH_FRONT_LEFT,
132 AV_CH_FRONT_RIGHT,
133 AV_CH_SIDE_LEFT,
134 AV_CH_SIDE_RIGHT,
135 AV_CH_LOW_FREQUENCY,
136 AV_CH_BACK_CENTER,
137 AV_CH_BACK_LEFT,
138 AV_CH_BACK_RIGHT,
139 AV_CH_SIDE_LEFT, /* side surround left -- dup sur side L */
140 AV_CH_SIDE_RIGHT, /* side surround right -- dup sur side R */
141 AV_CH_FRONT_LEFT_OF_CENTER,
142 AV_CH_FRONT_RIGHT_OF_CENTER,
143 AV_CH_TOP_FRONT_LEFT,
144 AV_CH_TOP_FRONT_CENTER,
145 AV_CH_TOP_FRONT_RIGHT,
146 AV_CH_LOW_FREQUENCY, /* lfe2 -- duplicate lfe1 position */
147 AV_CH_FRONT_LEFT_OF_CENTER, /* side front left -- dup front cntr L */
148 AV_CH_FRONT_RIGHT_OF_CENTER,/* side front right -- dup front cntr R */
149 AV_CH_TOP_CENTER, /* overhead */
150 AV_CH_TOP_FRONT_LEFT, /* side high left -- dup */
151 AV_CH_TOP_FRONT_RIGHT, /* side high right -- dup */
152 AV_CH_TOP_BACK_CENTER,
153 AV_CH_TOP_BACK_LEFT,
154 AV_CH_TOP_BACK_RIGHT,
155 AV_CH_BACK_CENTER, /* rear low center -- dup */
156 AV_CH_BACK_LEFT, /* rear low left -- dup */
157 AV_CH_BACK_RIGHT /* read low right -- dup */
158};
159
160enum DCAExtensionMask {
161 DCA_EXT_CORE = 0x001, ///< core in core substream
162 DCA_EXT_XXCH = 0x002, ///< XXCh channels extension in core substream
163 DCA_EXT_X96 = 0x004, ///< 96/24 extension in core substream
164 DCA_EXT_XCH = 0x008, ///< XCh channel extension in core substream
165 DCA_EXT_EXSS_CORE = 0x010, ///< core in ExSS (extension substream)
166 DCA_EXT_EXSS_XBR = 0x020, ///< extended bitrate extension in ExSS
167 DCA_EXT_EXSS_XXCH = 0x040, ///< XXCh channels extension in ExSS
168 DCA_EXT_EXSS_X96 = 0x080, ///< 96/24 extension in ExSS
169 DCA_EXT_EXSS_LBR = 0x100, ///< low bitrate component in ExSS
170 DCA_EXT_EXSS_XLL = 0x200, ///< lossless extension in ExSS
171};
172
173/* -1 are reserved or unknown */
174static const int dca_ext_audio_descr_mask[] = {
175 DCA_EXT_XCH,
176 -1,
177 DCA_EXT_X96,
178 DCA_EXT_XCH | DCA_EXT_X96,
179 -1,
180 -1,
181 DCA_EXT_XXCH,
182 -1,
183};
184
185/* extensions that reside in core substream */
186#define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
187
188/* Tables for mapping dts channel configurations to libavcodec multichannel api.
189 * Some compromises have been made for special configurations. Most configurations
190 * are never used so complete accuracy is not needed.
191 *
192 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
193 * S -> side, when both rear and back are configured move one of them to the side channel
194 * OV -> center back
195 * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
196 */
197static const uint64_t dca_core_channel_layout[] = {
198 AV_CH_FRONT_CENTER, ///< 1, A
199 AV_CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
200 AV_CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
201 AV_CH_LAYOUT_STEREO, ///< 2, (L + R) + (L - R) (sum-difference)
202 AV_CH_LAYOUT_STEREO, ///< 2, LT + RT (left and right total)
203 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER, ///< 3, C + L + R
204 AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER, ///< 3, L + R + S
205 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 4, C + L + R + S
206 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 4, L + R + SL + SR
207
208 AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
209 AV_CH_SIDE_RIGHT, ///< 5, C + L + R + SL + SR
210
211 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
212 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
213
214 AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
215 AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 6, C + L + R + LR + RR + OV
216
217 AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
218 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER |
219 AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 6, CF + CR + LF + RF + LR + RR
220
221 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
222 AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
223 AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
224
225 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
226 AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
227 AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2
228
229 AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
230 AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
231 AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT, ///< 8, CL + C + CR + L + R + SL + S + SR
232};
233
234static const int8_t dca_lfe_index[] = {
235 1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
236};
237
238static const int8_t dca_channel_reorder_lfe[][9] = {
239 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
240 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
241 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
242 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
243 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
244 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
245 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
246 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
247 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
248 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
249 { 3, 4, 0, 1, 5, 6, -1, -1, -1},
250 { 2, 0, 1, 4, 5, 6, -1, -1, -1},
251 { 0, 6, 4, 5, 2, 3, -1, -1, -1},
252 { 4, 2, 5, 0, 1, 6, 7, -1, -1},
253 { 5, 6, 0, 1, 7, 3, 8, 4, -1},
254 { 4, 2, 5, 0, 1, 6, 8, 7, -1},
255};
256
257static const int8_t dca_channel_reorder_lfe_xch[][9] = {
258 { 0, 2, -1, -1, -1, -1, -1, -1, -1},
259 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
260 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
261 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
262 { 0, 1, 3, -1, -1, -1, -1, -1, -1},
263 { 2, 0, 1, 4, -1, -1, -1, -1, -1},
264 { 0, 1, 3, 4, -1, -1, -1, -1, -1},
265 { 2, 0, 1, 4, 5, -1, -1, -1, -1},
266 { 0, 1, 4, 5, 3, -1, -1, -1, -1},
267 { 2, 0, 1, 5, 6, 4, -1, -1, -1},
268 { 3, 4, 0, 1, 6, 7, 5, -1, -1},
269 { 2, 0, 1, 4, 5, 6, 7, -1, -1},
270 { 0, 6, 4, 5, 2, 3, 7, -1, -1},
271 { 4, 2, 5, 0, 1, 7, 8, 6, -1},
272 { 5, 6, 0, 1, 8, 3, 9, 4, 7},
273 { 4, 2, 5, 0, 1, 6, 9, 8, 7},
274};
275
276static const int8_t dca_channel_reorder_nolfe[][9] = {
277 { 0, -1, -1, -1, -1, -1, -1, -1, -1},
278 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
279 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
280 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
281 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
282 { 2, 0, 1, -1, -1, -1, -1, -1, -1},
283 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
284 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
285 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
286 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
287 { 2, 3, 0, 1, 4, 5, -1, -1, -1},
288 { 2, 0, 1, 3, 4, 5, -1, -1, -1},
289 { 0, 5, 3, 4, 1, 2, -1, -1, -1},
290 { 3, 2, 4, 0, 1, 5, 6, -1, -1},
291 { 4, 5, 0, 1, 6, 2, 7, 3, -1},
292 { 3, 2, 4, 0, 1, 5, 7, 6, -1},
293};
294
295static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
296 { 0, 1, -1, -1, -1, -1, -1, -1, -1},
297 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
298 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
299 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
300 { 0, 1, 2, -1, -1, -1, -1, -1, -1},
301 { 2, 0, 1, 3, -1, -1, -1, -1, -1},
302 { 0, 1, 2, 3, -1, -1, -1, -1, -1},
303 { 2, 0, 1, 3, 4, -1, -1, -1, -1},
304 { 0, 1, 3, 4, 2, -1, -1, -1, -1},
305 { 2, 0, 1, 4, 5, 3, -1, -1, -1},
306 { 2, 3, 0, 1, 5, 6, 4, -1, -1},
307 { 2, 0, 1, 3, 4, 5, 6, -1, -1},
308 { 0, 5, 3, 4, 1, 2, 6, -1, -1},
309 { 3, 2, 4, 0, 1, 6, 7, 5, -1},
310 { 4, 5, 0, 1, 7, 2, 8, 3, 6},
311 { 3, 2, 4, 0, 1, 5, 8, 7, 6},
312};
313
314#define DCA_DOLBY 101 /* FIXME */
315
316#define DCA_CHANNEL_BITS 6
317#define DCA_CHANNEL_MASK 0x3F
318
319#define DCA_LFE 0x80
320
321#define HEADER_SIZE 14
322
323#define DCA_MAX_FRAME_SIZE 16384
324#define DCA_MAX_EXSS_HEADER_SIZE 4096
325
326#define DCA_BUFFER_PADDING_SIZE 1024
327
328#define DCA_NSYNCAUX 0x9A1105A0
329
330/** Bit allocation */
331typedef struct {
332 int offset; ///< code values offset
333 int maxbits[8]; ///< max bits in VLC
334 int wrap; ///< wrap for get_vlc2()
335 VLC vlc[8]; ///< actual codes
336} BitAlloc;
337
338static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
339static BitAlloc dca_tmode; ///< transition mode VLCs
340static BitAlloc dca_scalefactor; ///< scalefactor VLCs
341static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
342
343static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
344 int idx)
345{
346 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
347 ba->offset;
348}
349
350typedef struct {
351 const AVClass *class; ///< class for AVOptions
352 AVCodecContext *avctx;
353 /* Frame header */
354 int frame_type; ///< type of the current frame
355 int samples_deficit; ///< deficit sample count
356 int crc_present; ///< crc is present in the bitstream
357 int sample_blocks; ///< number of PCM sample blocks
358 int frame_size; ///< primary frame byte size
359 int amode; ///< audio channels arrangement
360 int sample_rate; ///< audio sampling rate
361 int bit_rate; ///< transmission bit rate
362 int bit_rate_index; ///< transmission bit rate index
363
364 int dynrange; ///< embedded dynamic range flag
365 int timestamp; ///< embedded time stamp flag
366 int aux_data; ///< auxiliary data flag
367 int hdcd; ///< source material is mastered in HDCD
368 int ext_descr; ///< extension audio descriptor flag
369 int ext_coding; ///< extended coding flag
370 int aspf; ///< audio sync word insertion flag
371 int lfe; ///< low frequency effects flag
372 int predictor_history; ///< predictor history flag
373 int header_crc; ///< header crc check bytes
374 int multirate_inter; ///< multirate interpolator switch
375 int version; ///< encoder software revision
376 int copy_history; ///< copy history
377 int source_pcm_res; ///< source pcm resolution
378 int front_sum; ///< front sum/difference flag
379 int surround_sum; ///< surround sum/difference flag
380 int dialog_norm; ///< dialog normalisation parameter
381
382 /* Primary audio coding header */
383 int subframes; ///< number of subframes
384 int total_channels; ///< number of channels including extensions
385 int prim_channels; ///< number of primary audio channels
386 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
387 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
388 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
389 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
390 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
391 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
392 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
393 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
394
395 /* Primary audio coding side information */
396 int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
397 int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
398 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
399 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
400 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
401 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
402 int32_t scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];///< scale factors (2 if transient)
403 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
404 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
405 float downmix_coef[DCA_PRIM_CHANNELS_MAX + 1][2]; ///< stereo downmix coefficients
406 int dynrange_coef; ///< dynamic range coefficient
407
408 /* Core substream's embedded downmix coefficients (cf. ETSI TS 102 114 V1.4.1)
409 * Input: primary audio channels (incl. LFE if present)
410 * Output: downmix audio channels (up to 4, no LFE) */
411 uint8_t core_downmix; ///< embedded downmix coefficients available
412 uint8_t core_downmix_amode; ///< audio channel arrangement of embedded downmix
413 uint16_t core_downmix_codes[DCA_PRIM_CHANNELS_MAX + 1][4]; ///< embedded downmix coefficients (9-bit codes)
414
415 int32_t high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
416
417 float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
418 int lfe_scale_factor;
419
420 /* Subband samples history (for ADPCM) */
421 DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
422 DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
423 DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
424 int hist_index[DCA_PRIM_CHANNELS_MAX];
425 DECLARE_ALIGNED(32, float, raXin)[32];
426
427 int output; ///< type of output
428
429 DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
430 float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
431 float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
432 uint8_t *extra_channels_buffer;
433 unsigned int extra_channels_buffer_size;
434
435 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
436 int dca_buffer_size; ///< how much data is in the dca_buffer
437
438 const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
439 GetBitContext gb;
440 /* Current position in DCA frame */
441 int current_subframe;
442 int current_subsubframe;
443
444 int core_ext_mask; ///< present extensions in the core substream
445
446 /* XCh extension information */
447 int xch_present; ///< XCh extension present and valid
448 int xch_base_channel; ///< index of first (only) channel containing XCH data
449 int xch_disable; ///< whether the XCh extension should be decoded or not
450
451 /* XXCH extension information */
452 int xxch_chset;
453 int xxch_nbits_spk_mask;
454 uint32_t xxch_core_spkmask;
455 uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */
456 int xxch_chset_nch[4];
457 float xxch_dmix_sf[DCA_CHSETS_MAX];
458
459 uint32_t xxch_dmix_embedded; /* lower layer has mix pre-embedded, per chset */
460 float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */
461
462 int8_t xxch_order_tab[32];
463 int8_t lfe_index;
464
465 /* ExSS header parser */
466 int static_fields; ///< static fields present
467 int mix_metadata; ///< mixing metadata present
468 int num_mix_configs; ///< number of mix out configurations
469 int mix_config_num_ch[4]; ///< number of channels in each mix out configuration
470
471 int profile;
472
473 int debug_flag; ///< used for suppressing repeated error messages output
474 AVFloatDSPContext fdsp;
475 FFTContext imdct;
476 SynthFilterContext synth;
477 DCADSPContext dcadsp;
478 FmtConvertContext fmt_conv;
479} DCAContext;
480
481static float dca_dmix_code(unsigned code);
482
483static const uint16_t dca_vlc_offs[] = {
484 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
485 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
486 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
487 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
488 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
489 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
490};
491
492static av_cold void dca_init_vlcs(void)
493{
494 static int vlcs_initialized = 0;
495 int i, j, c = 14;
496 static VLC_TYPE dca_table[23622][2];
497
498 if (vlcs_initialized)
499 return;
500
501 dca_bitalloc_index.offset = 1;
502 dca_bitalloc_index.wrap = 2;
503 for (i = 0; i < 5; i++) {
504 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
505 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
506 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
507 bitalloc_12_bits[i], 1, 1,
508 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
509 }
510 dca_scalefactor.offset = -64;
511 dca_scalefactor.wrap = 2;
512 for (i = 0; i < 5; i++) {
513 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
514 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
515 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
516 scales_bits[i], 1, 1,
517 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
518 }
519 dca_tmode.offset = 0;
520 dca_tmode.wrap = 1;
521 for (i = 0; i < 4; i++) {
522 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
523 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
524 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
525 tmode_bits[i], 1, 1,
526 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
527 }
528
529 for (i = 0; i < 10; i++)
530 for (j = 0; j < 7; j++) {
531 if (!bitalloc_codes[i][j])
532 break;
533 dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i];
534 dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4);
535 dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
536 dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
537
538 init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
539 bitalloc_sizes[i],
540 bitalloc_bits[i][j], 1, 1,
541 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
542 c++;
543 }
544 vlcs_initialized = 1;
545}
546
547static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
548{
549 while (len--)
550 *dst++ = get_bits(gb, bits);
551}
552
553static inline int dca_xxch2index(DCAContext *s, int xxch_ch)
554{
555 int i, base, mask;
556
557 /* locate channel set containing the channel */
558 for (i = -1, base = 0, mask = (s->xxch_core_spkmask & ~DCA_XXCH_LFE1);
559 i <= s->xxch_chset && !(mask & xxch_ch); mask = s->xxch_spk_masks[++i])
560 base += av_popcount(mask);
561
562 return base + av_popcount(mask & (xxch_ch - 1));
563}
564
565static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,
566 int xxch)
567{
568 int i, j;
569 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
570 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
571 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
572 int hdr_pos = 0, hdr_size = 0;
573 float scale_factor;
574 int this_chans, acc_mask;
575 int embedded_downmix;
576 int nchans, mask[8];
577 int coeff, ichan;
578
579 /* xxch has arbitrary sized audio coding headers */
580 if (xxch) {
581 hdr_pos = get_bits_count(&s->gb);
582 hdr_size = get_bits(&s->gb, 7) + 1;
583 }
584
585 nchans = get_bits(&s->gb, 3) + 1;
586 s->total_channels = nchans + base_channel;
587 s->prim_channels = s->total_channels;
588
589 /* obtain speaker layout mask & downmix coefficients for XXCH */
590 if (xxch) {
591 acc_mask = s->xxch_core_spkmask;
592
593 this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6;
594 s->xxch_spk_masks[s->xxch_chset] = this_chans;
595 s->xxch_chset_nch[s->xxch_chset] = nchans;
596
597 for (i = 0; i <= s->xxch_chset; i++)
598 acc_mask |= s->xxch_spk_masks[i];
599
600 /* check for downmixing information */
601 if (get_bits1(&s->gb)) {
602 embedded_downmix = get_bits1(&s->gb);
603 coeff = get_bits(&s->gb, 6);
604
605 if (coeff<1 || coeff>61) {
606 av_log(s->avctx, AV_LOG_ERROR, "6bit coeff %d is out of range\n", coeff);
607 return AVERROR_INVALIDDATA;
608 }
609
610 scale_factor = -1.0f / dca_dmix_code((coeff<<2)-3);
611
612 s->xxch_dmix_sf[s->xxch_chset] = scale_factor;
613
614 for (i = base_channel; i < s->prim_channels; i++) {
615 mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask);
616 }
617
618 for (j = base_channel; j < s->prim_channels; j++) {
619 memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0]));
620 s->xxch_dmix_embedded |= (embedded_downmix << j);
621 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
622 if (mask[j] & (1 << i)) {
623 if ((1 << i) == DCA_XXCH_LFE1) {
624 av_log(s->avctx, AV_LOG_WARNING,
625 "DCA-XXCH: dmix to LFE1 not supported.\n");
626 continue;
627 }
628
629 coeff = get_bits(&s->gb, 7);
630 ichan = dca_xxch2index(s, 1 << i);
631 if ((coeff&63)<1 || (coeff&63)>61) {
632 av_log(s->avctx, AV_LOG_ERROR, "7bit coeff %d is out of range\n", coeff);
633 return AVERROR_INVALIDDATA;
634 }
635 s->xxch_dmix_coeff[j][ichan] = dca_dmix_code((coeff<<2)-3);
636 }
637 }
638 }
639 }
640 }
641
642 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
643 s->prim_channels = DCA_PRIM_CHANNELS_MAX;
644
645
646 for (i = base_channel; i < s->prim_channels; i++) {
647 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
648 if (s->subband_activity[i] > DCA_SUBBANDS)
649 s->subband_activity[i] = DCA_SUBBANDS;
650 }
651 for (i = base_channel; i < s->prim_channels; i++) {
652 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
653 if (s->vq_start_subband[i] > DCA_SUBBANDS)
654 s->vq_start_subband[i] = DCA_SUBBANDS;
655 }
656 get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
657 get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
658 get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
659 get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
660
661 /* Get codebooks quantization indexes */
662 if (!base_channel)
663 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
664 for (j = 1; j < 11; j++)
665 for (i = base_channel; i < s->prim_channels; i++)
666 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
667
668 /* Get scale factor adjustment */
669 for (j = 0; j < 11; j++)
670 for (i = base_channel; i < s->prim_channels; i++)
671 s->scalefactor_adj[i][j] = 1;
672
673 for (j = 1; j < 11; j++)
674 for (i = base_channel; i < s->prim_channels; i++)
675 if (s->quant_index_huffman[i][j] < thr[j])
676 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
677
678 if (!xxch) {
679 if (s->crc_present) {
680 /* Audio header CRC check */
681 get_bits(&s->gb, 16);
682 }
683 } else {
684 /* Skip to the end of the header, also ignore CRC if present */
685 i = get_bits_count(&s->gb);
686 if (hdr_pos + 8 * hdr_size > i)
687 skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);
688 }
689
690 s->current_subframe = 0;
691 s->current_subsubframe = 0;
692
693#ifdef TRACE
694 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
695 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
696 for (i = base_channel; i < s->prim_channels; i++) {
697 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
698 s->subband_activity[i]);
699 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
700 s->vq_start_subband[i]);
701 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
702 s->joint_intensity[i]);
703 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
704 s->transient_huffman[i]);
705 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
706 s->scalefactor_huffman[i]);
707 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
708 s->bitalloc_huffman[i]);
709 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
710 for (j = 0; j < 11; j++)
711 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
712 av_log(s->avctx, AV_LOG_DEBUG, "\n");
713 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
714 for (j = 0; j < 11; j++)
715 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
716 av_log(s->avctx, AV_LOG_DEBUG, "\n");
717 }
718#endif
719
720 return 0;
721}
722
723static int dca_parse_frame_header(DCAContext *s)
724{
725 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
726
727 /* Sync code */
728 skip_bits_long(&s->gb, 32);
729
730 /* Frame header */
731 s->frame_type = get_bits(&s->gb, 1);
732 s->samples_deficit = get_bits(&s->gb, 5) + 1;
733 s->crc_present = get_bits(&s->gb, 1);
734 s->sample_blocks = get_bits(&s->gb, 7) + 1;
735 s->frame_size = get_bits(&s->gb, 14) + 1;
736 if (s->frame_size < 95)
737 return AVERROR_INVALIDDATA;
738 s->amode = get_bits(&s->gb, 6);
739 s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
740 if (!s->sample_rate)
741 return AVERROR_INVALIDDATA;
742 s->bit_rate_index = get_bits(&s->gb, 5);
743 s->bit_rate = dca_bit_rates[s->bit_rate_index];
744 if (!s->bit_rate)
745 return AVERROR_INVALIDDATA;
746
747 skip_bits1(&s->gb); // always 0 (reserved, cf. ETSI TS 102 114 V1.4.1)
748 s->dynrange = get_bits(&s->gb, 1);
749 s->timestamp = get_bits(&s->gb, 1);
750 s->aux_data = get_bits(&s->gb, 1);
751 s->hdcd = get_bits(&s->gb, 1);
752 s->ext_descr = get_bits(&s->gb, 3);
753 s->ext_coding = get_bits(&s->gb, 1);
754 s->aspf = get_bits(&s->gb, 1);
755 s->lfe = get_bits(&s->gb, 2);
756 s->predictor_history = get_bits(&s->gb, 1);
757
758 if (s->lfe > 2) {
759 s->lfe = 0;
760 av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
761 return AVERROR_INVALIDDATA;
762 }
763
764 /* TODO: check CRC */
765 if (s->crc_present)
766 s->header_crc = get_bits(&s->gb, 16);
767
768 s->multirate_inter = get_bits(&s->gb, 1);
769 s->version = get_bits(&s->gb, 4);
770 s->copy_history = get_bits(&s->gb, 2);
771 s->source_pcm_res = get_bits(&s->gb, 3);
772 s->front_sum = get_bits(&s->gb, 1);
773 s->surround_sum = get_bits(&s->gb, 1);
774 s->dialog_norm = get_bits(&s->gb, 4);
775
776 /* FIXME: channels mixing levels */
777 s->output = s->amode;
778 if (s->lfe)
779 s->output |= DCA_LFE;
780
781#ifdef TRACE
782 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
783 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
784 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
785 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
786 s->sample_blocks, s->sample_blocks * 32);
787 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
788 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
789 s->amode, dca_channels[s->amode]);
790 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
791 s->sample_rate);
792 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
793 s->bit_rate);
794 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
795 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
796 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
797 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
798 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
799 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
800 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
801 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
802 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
803 s->predictor_history);
804 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
805 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
806 s->multirate_inter);
807 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
808 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
809 av_log(s->avctx, AV_LOG_DEBUG,
810 "source pcm resolution: %i (%i bits/sample)\n",
811 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
812 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
813 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
814 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
815 av_log(s->avctx, AV_LOG_DEBUG, "\n");
816#endif
817
818 /* Primary audio coding header */
819 s->subframes = get_bits(&s->gb, 4) + 1;
820
821 return dca_parse_audio_coding_header(s, 0, 0);
822}
823
824
825static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
826{
827 if (level < 5) {
828 /* huffman encoded */
829 value += get_bitalloc(gb, &dca_scalefactor, level);
830 value = av_clip(value, 0, (1 << log2range) - 1);
831 } else if (level < 8) {
832 if (level + 1 > log2range) {
833 skip_bits(gb, level + 1 - log2range);
834 value = get_bits(gb, log2range);
835 } else {
836 value = get_bits(gb, level + 1);
837 }
838 }
839 return value;
840}
841
842static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
843{
844 /* Primary audio coding side information */
845 int j, k;
846
847 if (get_bits_left(&s->gb) < 0)
848 return AVERROR_INVALIDDATA;
849
850 if (!base_channel) {
851 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
852 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
853 }
854
855 for (j = base_channel; j < s->prim_channels; j++) {
856 for (k = 0; k < s->subband_activity[j]; k++)
857 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
858 }
859
860 /* Get prediction codebook */
861 for (j = base_channel; j < s->prim_channels; j++) {
862 for (k = 0; k < s->subband_activity[j]; k++) {
863 if (s->prediction_mode[j][k] > 0) {
864 /* (Prediction coefficient VQ address) */
865 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
866 }
867 }
868 }
869
870 /* Bit allocation index */
871 for (j = base_channel; j < s->prim_channels; j++) {
872 for (k = 0; k < s->vq_start_subband[j]; k++) {
873 if (s->bitalloc_huffman[j] == 6)
874 s->bitalloc[j][k] = get_bits(&s->gb, 5);
875 else if (s->bitalloc_huffman[j] == 5)
876 s->bitalloc[j][k] = get_bits(&s->gb, 4);
877 else if (s->bitalloc_huffman[j] == 7) {
878 av_log(s->avctx, AV_LOG_ERROR,
879 "Invalid bit allocation index\n");
880 return AVERROR_INVALIDDATA;
881 } else {
882 s->bitalloc[j][k] =
883 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
884 }
885
886 if (s->bitalloc[j][k] > 26) {
887 av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
888 j, k, s->bitalloc[j][k]);
889 return AVERROR_INVALIDDATA;
890 }
891 }
892 }
893
894 /* Transition mode */
895 for (j = base_channel; j < s->prim_channels; j++) {
896 for (k = 0; k < s->subband_activity[j]; k++) {
897 s->transition_mode[j][k] = 0;
898 if (s->subsubframes[s->current_subframe] > 1 &&
899 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
900 s->transition_mode[j][k] =
901 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
902 }
903 }
904 }
905
906 if (get_bits_left(&s->gb) < 0)
907 return AVERROR_INVALIDDATA;
908
909 for (j = base_channel; j < s->prim_channels; j++) {
910 const uint32_t *scale_table;
911 int scale_sum, log_size;
912
913 memset(s->scale_factor[j], 0,
914 s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
915
916 if (s->scalefactor_huffman[j] == 6) {
917 scale_table = scale_factor_quant7;
918 log_size = 7;
919 } else {
920 scale_table = scale_factor_quant6;
921 log_size = 6;
922 }
923
924 /* When huffman coded, only the difference is encoded */
925 scale_sum = 0;
926
927 for (k = 0; k < s->subband_activity[j]; k++) {
928 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
929 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
930 s->scale_factor[j][k][0] = scale_table[scale_sum];
931 }
932
933 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
934 /* Get second scale factor */
935 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
936 s->scale_factor[j][k][1] = scale_table[scale_sum];
937 }
938 }
939 }
940
941 /* Joint subband scale factor codebook select */
942 for (j = base_channel; j < s->prim_channels; j++) {
943 /* Transmitted only if joint subband coding enabled */
944 if (s->joint_intensity[j] > 0)
945 s->joint_huff[j] = get_bits(&s->gb, 3);
946 }
947
948 if (get_bits_left(&s->gb) < 0)
949 return AVERROR_INVALIDDATA;
950
951 /* Scale factors for joint subband coding */
952 for (j = base_channel; j < s->prim_channels; j++) {
953 int source_channel;
954
955 /* Transmitted only if joint subband coding enabled */
956 if (s->joint_intensity[j] > 0) {
957 int scale = 0;
958 source_channel = s->joint_intensity[j] - 1;
959
960 /* When huffman coded, only the difference is encoded
961 * (is this valid as well for joint scales ???) */
962
963 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
964 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
965 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
966 }
967
968 if (!(s->debug_flag & 0x02)) {
969 av_log(s->avctx, AV_LOG_DEBUG,
970 "Joint stereo coding not supported\n");
971 s->debug_flag |= 0x02;
972 }
973 }
974 }
975
976 /* Dynamic range coefficient */
977 if (!base_channel && s->dynrange)
978 s->dynrange_coef = get_bits(&s->gb, 8);
979
980 /* Side information CRC check word */
981 if (s->crc_present) {
982 get_bits(&s->gb, 16);
983 }
984
985 /*
986 * Primary audio data arrays
987 */
988
989 /* VQ encoded high frequency subbands */
990 for (j = base_channel; j < s->prim_channels; j++)
991 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
992 /* 1 vector -> 32 samples */
993 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
994
995 /* Low frequency effect data */
996 if (!base_channel && s->lfe) {
997 int quant7;
998 /* LFE samples */
999 int lfe_samples = 2 * s->lfe * (4 + block_index);
1000 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
1001 float lfe_scale;
1002
1003 for (j = lfe_samples; j < lfe_end_sample; j++) {
1004 /* Signed 8 bits int */
1005 s->lfe_data[j] = get_sbits(&s->gb, 8);
1006 }
1007
1008 /* Scale factor index */
1009 quant7 = get_bits(&s->gb, 8);
1010 if (quant7 > 127) {
1011 avpriv_request_sample(s->avctx, "LFEScaleIndex larger than 127");
1012 return AVERROR_INVALIDDATA;
1013 }
1014 s->lfe_scale_factor = scale_factor_quant7[quant7];
1015
1016 /* Quantization step size * scale factor */
1017 lfe_scale = 0.035 * s->lfe_scale_factor;
1018
1019 for (j = lfe_samples; j < lfe_end_sample; j++)
1020 s->lfe_data[j] *= lfe_scale;
1021 }
1022
1023#ifdef TRACE
1024 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
1025 s->subsubframes[s->current_subframe]);
1026 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
1027 s->partial_samples[s->current_subframe]);
1028
1029 for (j = base_channel; j < s->prim_channels; j++) {
1030 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
1031 for (k = 0; k < s->subband_activity[j]; k++)
1032 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
1033 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1034 }
1035 for (j = base_channel; j < s->prim_channels; j++) {
1036 for (k = 0; k < s->subband_activity[j]; k++)
1037 av_log(s->avctx, AV_LOG_DEBUG,
1038 "prediction coefs: %f, %f, %f, %f\n",
1039 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
1040 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
1041 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
1042 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
1043 }
1044 for (j = base_channel; j < s->prim_channels; j++) {
1045 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
1046 for (k = 0; k < s->vq_start_subband[j]; k++)
1047 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
1048 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1049 }
1050 for (j = base_channel; j < s->prim_channels; j++) {
1051 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
1052 for (k = 0; k < s->subband_activity[j]; k++)
1053 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
1054 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1055 }
1056 for (j = base_channel; j < s->prim_channels; j++) {
1057 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
1058 for (k = 0; k < s->subband_activity[j]; k++) {
1059 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
1060 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
1061 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
1062 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
1063 }
1064 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1065 }
1066 for (j = base_channel; j < s->prim_channels; j++) {
1067 if (s->joint_intensity[j] > 0) {
1068 int source_channel = s->joint_intensity[j] - 1;
1069 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
1070 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
1071 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
1072 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1073 }
1074 }
1075 for (j = base_channel; j < s->prim_channels; j++)
1076 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
1077 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
1078 if (!base_channel && s->lfe) {
1079 int lfe_samples = 2 * s->lfe * (4 + block_index);
1080 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
1081
1082 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
1083 for (j = lfe_samples; j < lfe_end_sample; j++)
1084 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
1085 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1086 }
1087#endif
1088
1089 return 0;
1090}
1091
1092static void qmf_32_subbands(DCAContext *s, int chans,
1093 float samples_in[32][8], float *samples_out,
1094 float scale)
1095{
1096 const float *prCoeff;
1097
1098 int sb_act = s->subband_activity[chans];
1099
1100 scale *= sqrt(1 / 8.0);
1101
1102 /* Select filter */
1103 if (!s->multirate_inter) /* Non-perfect reconstruction */
1104 prCoeff = fir_32bands_nonperfect;
1105 else /* Perfect reconstruction */
1106 prCoeff = fir_32bands_perfect;
1107
1108 s->dcadsp.qmf_32_subbands(samples_in, sb_act, &s->synth, &s->imdct,
1109 s->subband_fir_hist[chans],
1110 &s->hist_index[chans],
1111 s->subband_fir_noidea[chans], prCoeff,
1112 samples_out, s->raXin, scale);
1113}
1114
1115static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
1116 int num_deci_sample, float *samples_in,
1117 float *samples_out)
1118{
1119 /* samples_in: An array holding decimated samples.
1120 * Samples in current subframe starts from samples_in[0],
1121 * while samples_in[-1], samples_in[-2], ..., stores samples
1122 * from last subframe as history.
1123 *
1124 * samples_out: An array holding interpolated samples
1125 */
1126
1127 int idx;
1128 const float *prCoeff;
1129 int deciindex;
1130
1131 /* Select decimation filter */
1132 if (decimation_select == 1) {
1133 idx = 1;
1134 prCoeff = lfe_fir_128;
1135 } else {
1136 idx = 0;
1137 prCoeff = lfe_fir_64;
1138 }
1139 /* Interpolation */
1140 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
1141 s->dcadsp.lfe_fir[idx](samples_out, samples_in, prCoeff);
1142 samples_in++;
1143 samples_out += 2 * 32 * (1 + idx);
1144 }
1145}
1146
1147/* downmixing routines */
1148#define MIX_REAR1(samples, s1, rs, coef) \
1149 samples[0][i] += samples[s1][i] * coef[rs][0]; \
1150 samples[1][i] += samples[s1][i] * coef[rs][1];
1151
1152#define MIX_REAR2(samples, s1, s2, rs, coef) \
1153 samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
1154 samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
1155
1156#define MIX_FRONT3(samples, coef) \
1157 t = samples[c][i]; \
1158 u = samples[l][i]; \
1159 v = samples[r][i]; \
1160 samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1161 samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1162
1163#define DOWNMIX_TO_STEREO(op1, op2) \
1164 for (i = 0; i < 256; i++) { \
1165 op1 \
1166 op2 \
1167 }
1168
1169static void dca_downmix(float **samples, int srcfmt, int lfe_present,
1170 float coef[DCA_PRIM_CHANNELS_MAX + 1][2],
1171 const int8_t *channel_mapping)
1172{
1173 int c, l, r, sl, sr, s;
1174 int i;
1175 float t, u, v;
1176
1177 switch (srcfmt) {
1178 case DCA_MONO:
1179 case DCA_4F2R:
1180 av_log(NULL, AV_LOG_ERROR, "Not implemented!\n");
1181 break;
1182 case DCA_CHANNEL:
1183 case DCA_STEREO:
1184 case DCA_STEREO_TOTAL:
1185 case DCA_STEREO_SUMDIFF:
1186 break;
1187 case DCA_3F:
1188 c = channel_mapping[0];
1189 l = channel_mapping[1];
1190 r = channel_mapping[2];
1191 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1192 break;
1193 case DCA_2F1R:
1194 s = channel_mapping[2];
1195 DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
1196 break;
1197 case DCA_3F1R:
1198 c = channel_mapping[0];
1199 l = channel_mapping[1];
1200 r = channel_mapping[2];
1201 s = channel_mapping[3];
1202 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1203 MIX_REAR1(samples, s, 3, coef));
1204 break;
1205 case DCA_2F2R:
1206 sl = channel_mapping[2];
1207 sr = channel_mapping[3];
1208 DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
1209 break;
1210 case DCA_3F2R:
1211 c = channel_mapping[0];
1212 l = channel_mapping[1];
1213 r = channel_mapping[2];
1214 sl = channel_mapping[3];
1215 sr = channel_mapping[4];
1216 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1217 MIX_REAR2(samples, sl, sr, 3, coef));
1218 break;
1219 }
1220 if (lfe_present) {
1221 int lf_buf = dca_lfe_index[srcfmt];
1222 int lf_idx = dca_channels [srcfmt];
1223 for (i = 0; i < 256; i++) {
1224 samples[0][i] += samples[lf_buf][i] * coef[lf_idx][0];
1225 samples[1][i] += samples[lf_buf][i] * coef[lf_idx][1];
1226 }
1227 }
1228}
1229
1230
1231#ifndef decode_blockcodes
1232/* Very compact version of the block code decoder that does not use table
1233 * look-up but is slightly slower */
1234static int decode_blockcode(int code, int levels, int32_t *values)
1235{
1236 int i;
1237 int offset = (levels - 1) >> 1;
1238
1239 for (i = 0; i < 4; i++) {
1240 int div = FASTDIV(code, levels);
1241 values[i] = code - offset - div * levels;
1242 code = div;
1243 }
1244
1245 return code;
1246}
1247
1248static int decode_blockcodes(int code1, int code2, int levels, int32_t *values)
1249{
1250 return decode_blockcode(code1, levels, values) |
1251 decode_blockcode(code2, levels, values + 4);
1252}
1253#endif
1254
1255static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1256static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1257
1258static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1259{
1260 int k, l;
1261 int subsubframe = s->current_subsubframe;
1262
1263 const float *quant_step_table;
1264
1265 /* FIXME */
1266 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1267 LOCAL_ALIGNED_16(int32_t, block, [8 * DCA_SUBBANDS]);
1268
1269 /*
1270 * Audio data
1271 */
1272
1273 /* Select quantization step size table */
1274 if (s->bit_rate_index == 0x1f)
1275 quant_step_table = lossless_quant_d;
1276 else
1277 quant_step_table = lossy_quant_d;
1278
1279 for (k = base_channel; k < s->prim_channels; k++) {
1280 float rscale[DCA_SUBBANDS];
1281
1282 if (get_bits_left(&s->gb) < 0)
1283 return AVERROR_INVALIDDATA;
1284
1285 for (l = 0; l < s->vq_start_subband[k]; l++) {
1286 int m;
1287
1288 /* Select the mid-tread linear quantizer */
1289 int abits = s->bitalloc[k][l];
1290
1291 float quant_step_size = quant_step_table[abits];
1292
1293 /*
1294 * Determine quantization index code book and its type
1295 */
1296
1297 /* Select quantization index code book */
1298 int sel = s->quant_index_huffman[k][abits];
1299
1300 /*
1301 * Extract bits from the bit stream
1302 */
1303 if (!abits) {
1304 rscale[l] = 0;
1305 memset(block + 8 * l, 0, 8 * sizeof(block[0]));
1306 } else {
1307 /* Deal with transients */
1308 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1309 rscale[l] = quant_step_size * s->scale_factor[k][l][sfi] *
1310 s->scalefactor_adj[k][sel];
1311
1312 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1313 if (abits <= 7) {
1314 /* Block code */
1315 int block_code1, block_code2, size, levels, err;
1316
1317 size = abits_sizes[abits - 1];
1318 levels = abits_levels[abits - 1];
1319
1320 block_code1 = get_bits(&s->gb, size);
1321 block_code2 = get_bits(&s->gb, size);
1322 err = decode_blockcodes(block_code1, block_code2,
1323 levels, block + 8 * l);
1324 if (err) {
1325 av_log(s->avctx, AV_LOG_ERROR,
1326 "ERROR: block code look-up failed\n");
1327 return AVERROR_INVALIDDATA;
1328 }
1329 } else {
1330 /* no coding */
1331 for (m = 0; m < 8; m++)
1332 block[8 * l + m] = get_sbits(&s->gb, abits - 3);
1333 }
1334 } else {
1335 /* Huffman coded */
1336 for (m = 0; m < 8; m++)
1337 block[8 * l + m] = get_bitalloc(&s->gb,
1338 &dca_smpl_bitalloc[abits], sel);
1339 }
1340
1341 }
1342 }
1343
1344 s->fmt_conv.int32_to_float_fmul_array8(&s->fmt_conv, subband_samples[k][0],
1345 block, rscale, 8 * s->vq_start_subband[k]);
1346
1347 for (l = 0; l < s->vq_start_subband[k]; l++) {
1348 int m;
1349 /*
1350 * Inverse ADPCM if in prediction mode
1351 */
1352 if (s->prediction_mode[k][l]) {
1353 int n;
1354 if (s->predictor_history)
1355 subband_samples[k][l][0] += (adpcm_vb[s->prediction_vq[k][l]][0] *
1356 s->subband_samples_hist[k][l][3] +
1357 adpcm_vb[s->prediction_vq[k][l]][1] *
1358 s->subband_samples_hist[k][l][2] +
1359 adpcm_vb[s->prediction_vq[k][l]][2] *
1360 s->subband_samples_hist[k][l][1] +
1361 adpcm_vb[s->prediction_vq[k][l]][3] *
1362 s->subband_samples_hist[k][l][0]) *
1363 (1.0f / 8192);
1364 for (m = 1; m < 8; m++) {
1365 float sum = adpcm_vb[s->prediction_vq[k][l]][0] *
1366 subband_samples[k][l][m - 1];
1367 for (n = 2; n <= 4; n++)
1368 if (m >= n)
1369 sum += adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1370 subband_samples[k][l][m - n];
1371 else if (s->predictor_history)
1372 sum += adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1373 s->subband_samples_hist[k][l][m - n + 4];
1374 subband_samples[k][l][m] += sum * (1.0f / 8192);
1375 }
1376 }
1377 }
1378
1379 /*
1380 * Decode VQ encoded high frequencies
1381 */
1382 if (s->subband_activity[k] > s->vq_start_subband[k]) {
1383 if (!(s->debug_flag & 0x01)) {
1384 av_log(s->avctx, AV_LOG_DEBUG,
1385 "Stream with high frequencies VQ coding\n");
1386 s->debug_flag |= 0x01;
1387 }
1388 s->dcadsp.decode_hf(subband_samples[k], s->high_freq_vq[k],
1389 high_freq_vq, subsubframe * 8,
1390 s->scale_factor[k], s->vq_start_subband[k],
1391 s->subband_activity[k]);
1392 }
1393 }
1394
1395 /* Check for DSYNC after subsubframe */
1396 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1397 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1398#ifdef TRACE
1399 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1400#endif
1401 } else {
1402 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1403 return AVERROR_INVALIDDATA;
1404 }
1405 }
1406
1407 /* Backup predictor history for adpcm */
1408 for (k = base_channel; k < s->prim_channels; k++)
1409 for (l = 0; l < s->vq_start_subband[k]; l++)
1410 AV_COPY128(s->subband_samples_hist[k][l], &subband_samples[k][l][4]);
1411
1412 return 0;
1413}
1414
1415static int dca_filter_channels(DCAContext *s, int block_index)
1416{
1417 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1418 int k;
1419
1420 /* 32 subbands QMF */
1421 for (k = 0; k < s->prim_channels; k++) {
1422/* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1423 0, 8388608.0, 8388608.0 };*/
1424 if (s->channel_order_tab[k] >= 0)
1425 qmf_32_subbands(s, k, subband_samples[k],
1426 s->samples_chanptr[s->channel_order_tab[k]],
1427 M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */);
1428 }
1429
1430 /* Generate LFE samples for this subsubframe FIXME!!! */
1431 if (s->lfe) {
1432 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1433 s->lfe_data + 2 * s->lfe * (block_index + 4),
1434 s->samples_chanptr[s->lfe_index]);
1435 /* Outputs 20bits pcm samples */
1436 }
1437
1438 /* Downmixing to Stereo */
1439 if (s->prim_channels + !!s->lfe > 2 &&
1440 s->avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1441 dca_downmix(s->samples_chanptr, s->amode, !!s->lfe, s->downmix_coef,
1442 s->channel_order_tab);
1443 }
1444
1445 return 0;
1446}
1447
1448
1449static int dca_subframe_footer(DCAContext *s, int base_channel)
1450{
1451 int in, out, aux_data_count, aux_data_end, reserved;
1452 uint32_t nsyncaux;
1453
1454 /*
1455 * Unpack optional information
1456 */
1457
1458 /* presumably optional information only appears in the core? */
1459 if (!base_channel) {
1460 if (s->timestamp)
1461 skip_bits_long(&s->gb, 32);
1462
1463 if (s->aux_data) {
1464 aux_data_count = get_bits(&s->gb, 6);
1465
1466 // align (32-bit)
1467 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1468
1469 aux_data_end = 8 * aux_data_count + get_bits_count(&s->gb);
1470
1471 if ((nsyncaux = get_bits_long(&s->gb, 32)) != DCA_NSYNCAUX) {
1472 av_log(s->avctx, AV_LOG_ERROR, "nSYNCAUX mismatch %#"PRIx32"\n",
1473 nsyncaux);
1474 return AVERROR_INVALIDDATA;
1475 }
1476
1477 if (get_bits1(&s->gb)) { // bAUXTimeStampFlag
1478 avpriv_request_sample(s->avctx,
1479 "Auxiliary Decode Time Stamp Flag");
1480 // align (4-bit)
1481 skip_bits(&s->gb, (-get_bits_count(&s->gb)) & 4);
1482 // 44 bits: nMSByte (8), nMarker (4), nLSByte (28), nMarker (4)
1483 skip_bits_long(&s->gb, 44);
1484 }
1485
1486 if ((s->core_downmix = get_bits1(&s->gb))) {
1487 int am = get_bits(&s->gb, 3);
1488 switch (am) {
1489 case 0:
1490 s->core_downmix_amode = DCA_MONO;
1491 break;
1492 case 1:
1493 s->core_downmix_amode = DCA_STEREO;
1494 break;
1495 case 2:
1496 s->core_downmix_amode = DCA_STEREO_TOTAL;
1497 break;
1498 case 3:
1499 s->core_downmix_amode = DCA_3F;
1500 break;
1501 case 4:
1502 s->core_downmix_amode = DCA_2F1R;
1503 break;
1504 case 5:
1505 s->core_downmix_amode = DCA_2F2R;
1506 break;
1507 case 6:
1508 s->core_downmix_amode = DCA_3F1R;
1509 break;
1510 default:
1511 av_log(s->avctx, AV_LOG_ERROR,
1512 "Invalid mode %d for embedded downmix coefficients\n",
1513 am);
1514 return AVERROR_INVALIDDATA;
1515 }
1516 for (out = 0; out < dca_channels[s->core_downmix_amode]; out++) {
1517 for (in = 0; in < s->prim_channels + !!s->lfe; in++) {
1518 uint16_t tmp = get_bits(&s->gb, 9);
1519 if ((tmp & 0xFF) > 241) {
1520 av_log(s->avctx, AV_LOG_ERROR,
1521 "Invalid downmix coefficient code %"PRIu16"\n",
1522 tmp);
1523 return AVERROR_INVALIDDATA;
1524 }
1525 s->core_downmix_codes[in][out] = tmp;
1526 }
1527 }
1528 }
1529
1530 align_get_bits(&s->gb); // byte align
1531 skip_bits(&s->gb, 16); // nAUXCRC16
1532
1533 // additional data (reserved, cf. ETSI TS 102 114 V1.4.1)
1534 if ((reserved = (aux_data_end - get_bits_count(&s->gb))) < 0) {
1535 av_log(s->avctx, AV_LOG_ERROR,
1536 "Overread auxiliary data by %d bits\n", -reserved);
1537 return AVERROR_INVALIDDATA;
1538 } else if (reserved) {
1539 avpriv_request_sample(s->avctx,
1540 "Core auxiliary data reserved content");
1541 skip_bits_long(&s->gb, reserved);
1542 }
1543 }
1544
1545 if (s->crc_present && s->dynrange)
1546 get_bits(&s->gb, 16);
1547 }
1548
1549 return 0;
1550}
1551
1552/**
1553 * Decode a dca frame block
1554 *
1555 * @param s pointer to the DCAContext
1556 */
1557
1558static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1559{
1560 int ret;
1561
1562 /* Sanity check */
1563 if (s->current_subframe >= s->subframes) {
1564 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1565 s->current_subframe, s->subframes);
1566 return AVERROR_INVALIDDATA;
1567 }
1568
1569 if (!s->current_subsubframe) {
1570#ifdef TRACE
1571 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1572#endif
1573 /* Read subframe header */
1574 if ((ret = dca_subframe_header(s, base_channel, block_index)))
1575 return ret;
1576 }
1577
1578 /* Read subsubframe */
1579#ifdef TRACE
1580 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1581#endif
1582 if ((ret = dca_subsubframe(s, base_channel, block_index)))
1583 return ret;
1584
1585 /* Update state */
1586 s->current_subsubframe++;
1587 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1588 s->current_subsubframe = 0;
1589 s->current_subframe++;
1590 }
1591 if (s->current_subframe >= s->subframes) {
1592#ifdef TRACE
1593 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1594#endif
1595 /* Read subframe footer */
1596 if ((ret = dca_subframe_footer(s, base_channel)))
1597 return ret;
1598 }
1599
1600 return 0;
1601}
1602
1603/**
1604 * Return the number of channels in an ExSS speaker mask (HD)
1605 */
1606static int dca_exss_mask2count(int mask)
1607{
1608 /* count bits that mean speaker pairs twice */
1609 return av_popcount(mask) +
1610 av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
1611 DCA_EXSS_FRONT_LEFT_RIGHT |
1612 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
1613 DCA_EXSS_WIDE_LEFT_RIGHT |
1614 DCA_EXSS_SIDE_LEFT_RIGHT |
1615 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
1616 DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
1617 DCA_EXSS_REAR_LEFT_RIGHT |
1618 DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1619}
1620
1621/**
1622 * Skip mixing coefficients of a single mix out configuration (HD)
1623 */
1624static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1625{
1626 int i;
1627
1628 for (i = 0; i < channels; i++) {
1629 int mix_map_mask = get_bits(gb, out_ch);
1630 int num_coeffs = av_popcount(mix_map_mask);
1631 skip_bits_long(gb, num_coeffs * 6);
1632 }
1633}
1634
1635/**
1636 * Parse extension substream asset header (HD)
1637 */
1638static int dca_exss_parse_asset_header(DCAContext *s)
1639{
1640 int header_pos = get_bits_count(&s->gb);
1641 int header_size;
1642 int channels = 0;
1643 int embedded_stereo = 0;
1644 int embedded_6ch = 0;
1645 int drc_code_present;
1646 int av_uninit(extensions_mask);
1647 int i, j;
1648
1649 if (get_bits_left(&s->gb) < 16)
1650 return -1;
1651
1652 /* We will parse just enough to get to the extensions bitmask with which
1653 * we can set the profile value. */
1654
1655 header_size = get_bits(&s->gb, 9) + 1;
1656 skip_bits(&s->gb, 3); // asset index
1657
1658 if (s->static_fields) {
1659 if (get_bits1(&s->gb))
1660 skip_bits(&s->gb, 4); // asset type descriptor
1661 if (get_bits1(&s->gb))
1662 skip_bits_long(&s->gb, 24); // language descriptor
1663
1664 if (get_bits1(&s->gb)) {
1665 /* How can one fit 1024 bytes of text here if the maximum value
1666 * for the asset header size field above was 512 bytes? */
1667 int text_length = get_bits(&s->gb, 10) + 1;
1668 if (get_bits_left(&s->gb) < text_length * 8)
1669 return -1;
1670 skip_bits_long(&s->gb, text_length * 8); // info text
1671 }
1672
1673 skip_bits(&s->gb, 5); // bit resolution - 1
1674 skip_bits(&s->gb, 4); // max sample rate code
1675 channels = get_bits(&s->gb, 8) + 1;
1676
1677 if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1678 int spkr_remap_sets;
1679 int spkr_mask_size = 16;
1680 int num_spkrs[7];
1681
1682 if (channels > 2)
1683 embedded_stereo = get_bits1(&s->gb);
1684 if (channels > 6)
1685 embedded_6ch = get_bits1(&s->gb);
1686
1687 if (get_bits1(&s->gb)) {
1688 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1689 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1690 }
1691
1692 spkr_remap_sets = get_bits(&s->gb, 3);
1693
1694 for (i = 0; i < spkr_remap_sets; i++) {
1695 /* std layout mask for each remap set */
1696 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1697 }
1698
1699 for (i = 0; i < spkr_remap_sets; i++) {
1700 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1701 if (get_bits_left(&s->gb) < 0)
1702 return -1;
1703
1704 for (j = 0; j < num_spkrs[i]; j++) {
1705 int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1706 int num_dec_ch = av_popcount(remap_dec_ch_mask);
1707 skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1708 }
1709 }
1710
1711 } else {
1712 skip_bits(&s->gb, 3); // representation type
1713 }
1714 }
1715
1716 drc_code_present = get_bits1(&s->gb);
1717 if (drc_code_present)
1718 get_bits(&s->gb, 8); // drc code
1719
1720 if (get_bits1(&s->gb))
1721 skip_bits(&s->gb, 5); // dialog normalization code
1722
1723 if (drc_code_present && embedded_stereo)
1724 get_bits(&s->gb, 8); // drc stereo code
1725
1726 if (s->mix_metadata && get_bits1(&s->gb)) {
1727 skip_bits(&s->gb, 1); // external mix
1728 skip_bits(&s->gb, 6); // post mix gain code
1729
1730 if (get_bits(&s->gb, 2) != 3) // mixer drc code
1731 skip_bits(&s->gb, 3); // drc limit
1732 else
1733 skip_bits(&s->gb, 8); // custom drc code
1734
1735 if (get_bits1(&s->gb)) // channel specific scaling
1736 for (i = 0; i < s->num_mix_configs; i++)
1737 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1738 else
1739 skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1740
1741 for (i = 0; i < s->num_mix_configs; i++) {
1742 if (get_bits_left(&s->gb) < 0)
1743 return -1;
1744 dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1745 if (embedded_6ch)
1746 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1747 if (embedded_stereo)
1748 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1749 }
1750 }
1751
1752 switch (get_bits(&s->gb, 2)) {
1753 case 0: extensions_mask = get_bits(&s->gb, 12); break;
1754 case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1755 case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1756 case 3: extensions_mask = 0; /* aux coding */ break;
1757 }
1758
1759 /* not parsed further, we were only interested in the extensions mask */
1760
1761 if (get_bits_left(&s->gb) < 0)
1762 return -1;
1763
1764 if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1765 av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1766 return -1;
1767 }
1768 skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1769
1770 if (extensions_mask & DCA_EXT_EXSS_XLL)
1771 s->profile = FF_PROFILE_DTS_HD_MA;
1772 else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1773 DCA_EXT_EXSS_XXCH))
1774 s->profile = FF_PROFILE_DTS_HD_HRA;
1775
1776 if (!(extensions_mask & DCA_EXT_CORE))
1777 av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1778 if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1779 av_log(s->avctx, AV_LOG_WARNING,
1780 "DTS extensions detection mismatch (%d, %d)\n",
1781 extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1782
1783 return 0;
1784}
1785
1786static int dca_xbr_parse_frame(DCAContext *s)
1787{
1788 int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];
1789 int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];
1790 int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS];
1791 int anctemp[DCA_CHSET_CHANS_MAX];
1792 int chset_fsize[DCA_CHSETS_MAX];
1793 int n_xbr_ch[DCA_CHSETS_MAX];
1794 int hdr_size, num_chsets, xbr_tmode, hdr_pos;
1795 int i, j, k, l, chset, chan_base;
1796
1797 av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n");
1798
1799 /* get bit position of sync header */
1800 hdr_pos = get_bits_count(&s->gb) - 32;
1801
1802 hdr_size = get_bits(&s->gb, 6) + 1;
1803 num_chsets = get_bits(&s->gb, 2) + 1;
1804
1805 for(i = 0; i < num_chsets; i++)
1806 chset_fsize[i] = get_bits(&s->gb, 14) + 1;
1807
1808 xbr_tmode = get_bits1(&s->gb);
1809
1810 for(i = 0; i < num_chsets; i++) {
1811 n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;
1812 k = get_bits(&s->gb, 2) + 5;
1813 for(j = 0; j < n_xbr_ch[i]; j++)
1814 active_bands[i][j] = get_bits(&s->gb, k) + 1;
1815 }
1816
1817 /* skip to the end of the header */
1818 i = get_bits_count(&s->gb);
1819 if(hdr_pos + hdr_size * 8 > i)
1820 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1821
1822 /* loop over the channel data sets */
1823 /* only decode as many channels as we've decoded base data for */
1824 for(chset = 0, chan_base = 0;
1825 chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels;
1826 chan_base += n_xbr_ch[chset++]) {
1827 int start_posn = get_bits_count(&s->gb);
1828 int subsubframe = 0;
1829 int subframe = 0;
1830
1831 /* loop over subframes */
1832 for (k = 0; k < (s->sample_blocks / 8); k++) {
1833 /* parse header if we're on first subsubframe of a block */
1834 if(subsubframe == 0) {
1835 /* Parse subframe header */
1836 for(i = 0; i < n_xbr_ch[chset]; i++) {
1837 anctemp[i] = get_bits(&s->gb, 2) + 2;
1838 }
1839
1840 for(i = 0; i < n_xbr_ch[chset]; i++) {
1841 get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]);
1842 }
1843
1844 for(i = 0; i < n_xbr_ch[chset]; i++) {
1845 anctemp[i] = get_bits(&s->gb, 3);
1846 if(anctemp[i] < 1) {
1847 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n");
1848 return AVERROR_INVALIDDATA;
1849 }
1850 }
1851
1852 /* generate scale factors */
1853 for(i = 0; i < n_xbr_ch[chset]; i++) {
1854 const uint32_t *scale_table;
1855 int nbits;
1856
1857 if (s->scalefactor_huffman[chan_base+i] == 6) {
1858 scale_table = scale_factor_quant7;
1859 } else {
1860 scale_table = scale_factor_quant6;
1861 }
1862
1863 nbits = anctemp[i];
1864
1865 for(j = 0; j < active_bands[chset][i]; j++) {
1866 if(abits_high[i][j] > 0) {
1867 scale_table_high[i][j][0] =
1868 scale_table[get_bits(&s->gb, nbits)];
1869
1870 if(xbr_tmode && s->transition_mode[i][j]) {
1871 scale_table_high[i][j][1] =
1872 scale_table[get_bits(&s->gb, nbits)];
1873 }
1874 }
1875 }
1876 }
1877 }
1878
1879 /* decode audio array for this block */
1880 for(i = 0; i < n_xbr_ch[chset]; i++) {
1881 for(j = 0; j < active_bands[chset][i]; j++) {
1882 const int xbr_abits = abits_high[i][j];
1883 const float quant_step_size = lossless_quant_d[xbr_abits];
1884 const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j];
1885 const float rscale = quant_step_size * scale_table_high[i][j][sfi];
1886 float *subband_samples = s->subband_samples[k][chan_base+i][j];
1887 int block[8];
1888
1889 if(xbr_abits <= 0)
1890 continue;
1891
1892 if(xbr_abits > 7) {
1893 get_array(&s->gb, block, 8, xbr_abits - 3);
1894 } else {
1895 int block_code1, block_code2, size, levels, err;
1896
1897 size = abits_sizes[xbr_abits - 1];
1898 levels = abits_levels[xbr_abits - 1];
1899
1900 block_code1 = get_bits(&s->gb, size);
1901 block_code2 = get_bits(&s->gb, size);
1902 err = decode_blockcodes(block_code1, block_code2,
1903 levels, block);
1904 if (err) {
1905 av_log(s->avctx, AV_LOG_ERROR,
1906 "ERROR: DTS-XBR: block code look-up failed\n");
1907 return AVERROR_INVALIDDATA;
1908 }
1909 }
1910
1911 /* scale & sum into subband */
1912 for(l = 0; l < 8; l++)
1913 subband_samples[l] += (float)block[l] * rscale;
1914 }
1915 }
1916
1917 /* check DSYNC marker */
1918 if(s->aspf || subsubframe == s->subsubframes[subframe] - 1) {
1919 if(get_bits(&s->gb, 16) != 0xffff) {
1920 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n");
1921 return AVERROR_INVALIDDATA;
1922 }
1923 }
1924
1925 /* advance sub-sub-frame index */
1926 if(++subsubframe >= s->subsubframes[subframe]) {
1927 subsubframe = 0;
1928 subframe++;
1929 }
1930 }
1931
1932 /* skip to next channel set */
1933 i = get_bits_count(&s->gb);
1934 if(start_posn + chset_fsize[chset] * 8 != i) {
1935 j = start_posn + chset_fsize[chset] * 8 - i;
1936 if(j < 0 || j >= 8)
1937 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set,"
1938 " skipping further than expected (%d bits)\n", j);
1939 skip_bits_long(&s->gb, j);
1940 }
1941 }
1942
1943 return 0;
1944}
1945
1946/* parse initial header for XXCH and dump details */
1947static int dca_xxch_decode_frame(DCAContext *s)
1948{
1949 int hdr_size, spkmsk_bits, num_chsets, core_spk, hdr_pos;
1950 int i, chset, base_channel, chstart, fsize[8];
1951
1952 /* assume header word has already been parsed */
1953 hdr_pos = get_bits_count(&s->gb) - 32;
1954 hdr_size = get_bits(&s->gb, 6) + 1;
1955 /*chhdr_crc =*/ skip_bits1(&s->gb);
1956 spkmsk_bits = get_bits(&s->gb, 5) + 1;
1957 num_chsets = get_bits(&s->gb, 2) + 1;
1958
1959 for (i = 0; i < num_chsets; i++)
1960 fsize[i] = get_bits(&s->gb, 14) + 1;
1961
1962 core_spk = get_bits(&s->gb, spkmsk_bits);
1963 s->xxch_core_spkmask = core_spk;
1964 s->xxch_nbits_spk_mask = spkmsk_bits;
1965 s->xxch_dmix_embedded = 0;
1966
1967 /* skip to the end of the header */
1968 i = get_bits_count(&s->gb);
1969 if (hdr_pos + hdr_size * 8 > i)
1970 skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1971
1972 for (chset = 0; chset < num_chsets; chset++) {
1973 chstart = get_bits_count(&s->gb);
1974 base_channel = s->prim_channels;
1975 s->xxch_chset = chset;
1976
1977 /* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs.
1978 5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */
1979 dca_parse_audio_coding_header(s, base_channel, 1);
1980
1981 /* decode channel data */
1982 for (i = 0; i < (s->sample_blocks / 8); i++) {
1983 if (dca_decode_block(s, base_channel, i)) {
1984 av_log(s->avctx, AV_LOG_ERROR,
1985 "Error decoding DTS-XXCH extension\n");
1986 continue;
1987 }
1988 }
1989
1990 /* skip to end of this section */
1991 i = get_bits_count(&s->gb);
1992 if (chstart + fsize[chset] * 8 > i)
1993 skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i);
1994 }
1995 s->xxch_chset = num_chsets;
1996
1997 return 0;
1998}
1999
2000/**
2001 * Parse extension substream header (HD)
2002 */
2003static void dca_exss_parse_header(DCAContext *s)
2004{
2005 int asset_size[8];
2006 int ss_index;
2007 int blownup;
2008 int num_audiop = 1;
2009 int num_assets = 1;
2010 int active_ss_mask[8];
2011 int i, j;
2012 int start_posn;
2013 int hdrsize;
2014 uint32_t mkr;
2015
2016 if (get_bits_left(&s->gb) < 52)
2017 return;
2018
2019 start_posn = get_bits_count(&s->gb) - 32;
2020
2021 skip_bits(&s->gb, 8); // user data
2022 ss_index = get_bits(&s->gb, 2);
2023
2024 blownup = get_bits1(&s->gb);
2025 hdrsize = get_bits(&s->gb, 8 + 4 * blownup) + 1; // header_size
2026 skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
2027
2028 s->static_fields = get_bits1(&s->gb);
2029 if (s->static_fields) {
2030 skip_bits(&s->gb, 2); // reference clock code
2031 skip_bits(&s->gb, 3); // frame duration code
2032
2033 if (get_bits1(&s->gb))
2034 skip_bits_long(&s->gb, 36); // timestamp
2035
2036 /* a single stream can contain multiple audio assets that can be
2037 * combined to form multiple audio presentations */
2038
2039 num_audiop = get_bits(&s->gb, 3) + 1;
2040 if (num_audiop > 1) {
2041 avpriv_request_sample(s->avctx,
2042 "Multiple DTS-HD audio presentations");
2043 /* ignore such streams for now */
2044 return;
2045 }
2046
2047 num_assets = get_bits(&s->gb, 3) + 1;
2048 if (num_assets > 1) {
2049 avpriv_request_sample(s->avctx, "Multiple DTS-HD audio assets");
2050 /* ignore such streams for now */
2051 return;
2052 }
2053
2054 for (i = 0; i < num_audiop; i++)
2055 active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
2056
2057 for (i = 0; i < num_audiop; i++)
2058 for (j = 0; j <= ss_index; j++)
2059 if (active_ss_mask[i] & (1 << j))
2060 skip_bits(&s->gb, 8); // active asset mask
2061
2062 s->mix_metadata = get_bits1(&s->gb);
2063 if (s->mix_metadata) {
2064 int mix_out_mask_size;
2065
2066 skip_bits(&s->gb, 2); // adjustment level
2067 mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
2068 s->num_mix_configs = get_bits(&s->gb, 2) + 1;
2069
2070 for (i = 0; i < s->num_mix_configs; i++) {
2071 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
2072 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
2073 }
2074 }
2075 }
2076
2077 av_assert0(num_assets > 0); // silence a warning
2078
2079 for (i = 0; i < num_assets; i++)
2080 asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup);
2081
2082 for (i = 0; i < num_assets; i++) {
2083 if (dca_exss_parse_asset_header(s))
2084 return;
2085 }
2086
2087 /* not parsed further, we were only interested in the extensions mask
2088 * from the asset header */
2089
2090 j = get_bits_count(&s->gb);
2091 if (start_posn + hdrsize * 8 > j)
2092 skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j);
2093
2094 for (i = 0; i < num_assets; i++) {
2095 start_posn = get_bits_count(&s->gb);
2096 mkr = get_bits_long(&s->gb, 32);
2097
2098 /* parse extensions that we know about */
2099 if (mkr == 0x655e315e) {
2100 dca_xbr_parse_frame(s);
2101 } else if (mkr == 0x47004a03) {
2102 dca_xxch_decode_frame(s);
2103 s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
2104 } else {
2105 av_log(s->avctx, AV_LOG_DEBUG,
2106 "DTS-ExSS: unknown marker = 0x%08x\n", mkr);
2107 }
2108
2109 /* skip to end of block */
2110 j = get_bits_count(&s->gb);
2111 if (start_posn + asset_size[i] * 8 > j)
2112 skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j);
2113 }
2114}
2115
2116static float dca_dmix_code(unsigned code)
2117{
2118 int sign = (code >> 8) - 1;
2119 code &= 0xff;
2120 return ((dca_dmixtable[code] ^ sign) - sign) * (1.0 / (1 << 15));
2121}
2122
2123/**
2124 * Main frame decoding function
2125 * FIXME add arguments
2126 */
2127static int dca_decode_frame(AVCodecContext *avctx, void *data,
2128 int *got_frame_ptr, AVPacket *avpkt)
2129{
2130 AVFrame *frame = data;
2131 const uint8_t *buf = avpkt->data;
2132 int buf_size = avpkt->size;
2133 int channel_mask;
2134 int channel_layout;
2135 int lfe_samples;
2136 int num_core_channels = 0;
2137 int i, ret;
2138 float **samples_flt;
2139 float *src_chan;
2140 float *dst_chan;
2141 DCAContext *s = avctx->priv_data;
2142 int core_ss_end;
2143 int channels, full_channels;
2144 float scale;
2145 int achan;
2146 int chset;
2147 int mask;
2148 int lavc;
2149 int posn;
2150 int j, k;
2151 int endch;
2152
2153 s->xch_present = 0;
2154
2155 s->dca_buffer_size = avpriv_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
2156 DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
2157 if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
2158 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
2159 return AVERROR_INVALIDDATA;
2160 }
2161
2162 if ((ret = dca_parse_frame_header(s)) < 0) {
2163 //seems like the frame is corrupt, try with the next one
2164 return ret;
2165 }
2166 //set AVCodec values with parsed data
2167 avctx->sample_rate = s->sample_rate;
2168 avctx->bit_rate = s->bit_rate;
2169
2170 s->profile = FF_PROFILE_DTS;
2171
2172 for (i = 0; i < (s->sample_blocks / 8); i++) {
2173 if ((ret = dca_decode_block(s, 0, i))) {
2174 av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
2175 return ret;
2176 }
2177 }
2178
2179 /* record number of core channels incase less than max channels are requested */
2180 num_core_channels = s->prim_channels;
2181
2182 if (s->prim_channels + !!s->lfe > 2 &&
2183 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
2184 /* Stereo downmix coefficients
2185 *
2186 * The decoder can only downmix to 2-channel, so we need to ensure
2187 * embedded downmix coefficients are actually targeting 2-channel.
2188 */
2189 if (s->core_downmix && (s->core_downmix_amode == DCA_STEREO ||
2190 s->core_downmix_amode == DCA_STEREO_TOTAL)) {
2191 for (i = 0; i < num_core_channels + !!s->lfe; i++) {
2192 /* Range checked earlier */
2193 s->downmix_coef[i][0] = dca_dmix_code(s->core_downmix_codes[i][0]);
2194 s->downmix_coef[i][1] = dca_dmix_code(s->core_downmix_codes[i][1]);
2195 }
2196 s->output = s->core_downmix_amode;
2197 } else {
2198 int am = s->amode & DCA_CHANNEL_MASK;
2199 if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
2200 av_log(s->avctx, AV_LOG_ERROR,
2201 "Invalid channel mode %d\n", am);
2202 return AVERROR_INVALIDDATA;
2203 }
2204 if (num_core_channels + !!s->lfe >
2205 FF_ARRAY_ELEMS(dca_default_coeffs[0])) {
2206 avpriv_request_sample(s->avctx, "Downmixing %d channels",
2207 s->prim_channels + !!s->lfe);
2208 return AVERROR_PATCHWELCOME;
2209 }
2210 for (i = 0; i < num_core_channels + !!s->lfe; i++) {
2211 s->downmix_coef[i][0] = dca_default_coeffs[am][i][0];
2212 s->downmix_coef[i][1] = dca_default_coeffs[am][i][1];
2213 }
2214 }
2215 av_dlog(s->avctx, "Stereo downmix coeffs:\n");
2216 for (i = 0; i < num_core_channels + !!s->lfe; i++) {
2217 av_dlog(s->avctx, "L, input channel %d = %f\n", i,
2218 s->downmix_coef[i][0]);
2219 av_dlog(s->avctx, "R, input channel %d = %f\n", i,
2220 s->downmix_coef[i][1]);
2221 }
2222 av_dlog(s->avctx, "\n");
2223 }
2224
2225 if (s->ext_coding)
2226 s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
2227 else
2228 s->core_ext_mask = 0;
2229
2230 core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
2231
2232 /* only scan for extensions if ext_descr was unknown or indicated a
2233 * supported XCh extension */
2234 if (s->core_ext_mask < 0 || s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH)) {
2235
2236 /* if ext_descr was unknown, clear s->core_ext_mask so that the
2237 * extensions scan can fill it up */
2238 s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
2239
2240 /* extensions start at 32-bit boundaries into bitstream */
2241 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2242
2243 while (core_ss_end - get_bits_count(&s->gb) >= 32) {
2244 uint32_t bits = get_bits_long(&s->gb, 32);
2245
2246 switch (bits) {
2247 case 0x5a5a5a5a: {
2248 int ext_amode, xch_fsize;
2249
2250 s->xch_base_channel = s->prim_channels;
2251
2252 /* validate sync word using XCHFSIZE field */
2253 xch_fsize = show_bits(&s->gb, 10);
2254 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
2255 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
2256 continue;
2257
2258 /* skip length-to-end-of-frame field for the moment */
2259 skip_bits(&s->gb, 10);
2260
2261 s->core_ext_mask |= DCA_EXT_XCH;
2262
2263 /* extension amode(number of channels in extension) should be 1 */
2264 /* AFAIK XCh is not used for more channels */
2265 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
2266 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
2267 " supported!\n", ext_amode);
2268 continue;
2269 }
2270
2271 if (s->xch_base_channel < 2) {
2272 avpriv_request_sample(avctx, "XCh with fewer than 2 base channels");
2273 continue;
2274 }
2275
2276 /* much like core primary audio coding header */
2277 dca_parse_audio_coding_header(s, s->xch_base_channel, 0);
2278
2279 for (i = 0; i < (s->sample_blocks / 8); i++)
2280 if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
2281 av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
2282 continue;
2283 }
2284
2285 s->xch_present = 1;
2286 break;
2287 }
2288 case 0x47004a03:
2289 /* XXCh: extended channels */
2290 /* usually found either in core or HD part in DTS-HD HRA streams,
2291 * but not in DTS-ES which contains XCh extensions instead */
2292 s->core_ext_mask |= DCA_EXT_XXCH;
2293 dca_xxch_decode_frame(s);
2294 break;
2295
2296 case 0x1d95f262: {
2297 int fsize96 = show_bits(&s->gb, 12) + 1;
2298 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
2299 continue;
2300
2301 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
2302 get_bits_count(&s->gb));
2303 skip_bits(&s->gb, 12);
2304 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
2305 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
2306
2307 s->core_ext_mask |= DCA_EXT_X96;
2308 break;
2309 }
2310 }
2311
2312 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2313 }
2314 } else {
2315 /* no supported extensions, skip the rest of the core substream */
2316 skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
2317 }
2318
2319 if (s->core_ext_mask & DCA_EXT_X96)
2320 s->profile = FF_PROFILE_DTS_96_24;
2321 else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
2322 s->profile = FF_PROFILE_DTS_ES;
2323
2324 /* check for ExSS (HD part) */
2325 if (s->dca_buffer_size - s->frame_size > 32 &&
2326 get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
2327 dca_exss_parse_header(s);
2328
2329 avctx->profile = s->profile;
2330
2331 full_channels = channels = s->prim_channels + !!s->lfe;
2332
2333 /* If we have XXCH then the channel layout is managed differently */
2334 /* note that XLL will also have another way to do things */
2335 if (!(s->core_ext_mask & DCA_EXT_XXCH)
2336 || (s->core_ext_mask & DCA_EXT_XXCH && avctx->request_channels > 0
2337 && avctx->request_channels
2338 < num_core_channels + !!s->lfe + s->xxch_chset_nch[0]))
2339 { /* xxx should also do MA extensions */
2340 if (s->amode < 16) {
2341 avctx->channel_layout = dca_core_channel_layout[s->amode];
2342
2343 if (s->prim_channels + !!s->lfe > 2 &&
2344 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
2345 /*
2346 * Neither the core's auxiliary data nor our default tables contain
2347 * downmix coefficients for the additional channel coded in the XCh
2348 * extension, so when we're doing a Stereo downmix, don't decode it.
2349 */
2350 s->xch_disable = 1;
2351 }
2352
2353#if FF_API_REQUEST_CHANNELS
2354FF_DISABLE_DEPRECATION_WARNINGS
2355 if (s->xch_present && !s->xch_disable &&
2356 (!avctx->request_channels ||
2357 avctx->request_channels > num_core_channels + !!s->lfe)) {
2358FF_ENABLE_DEPRECATION_WARNINGS
2359#else
2360 if (s->xch_present && !s->xch_disable) {
2361#endif
2362 avctx->channel_layout |= AV_CH_BACK_CENTER;
2363 if (s->lfe) {
2364 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2365 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
2366 } else {
2367 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
2368 }
2369 if (s->channel_order_tab[s->xch_base_channel] < 0)
2370 return AVERROR_INVALIDDATA;
2371 } else {
2372 channels = num_core_channels + !!s->lfe;
2373 s->xch_present = 0; /* disable further xch processing */
2374 if (s->lfe) {
2375 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2376 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
2377 } else
2378 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
2379 }
2380
2381 if (channels > !!s->lfe &&
2382 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
2383 return AVERROR_INVALIDDATA;
2384
2385 if (av_get_channel_layout_nb_channels(avctx->channel_layout) != channels) {
2386 av_log(avctx, AV_LOG_ERROR, "Number of channels %d mismatches layout %d\n", channels, av_get_channel_layout_nb_channels(avctx->channel_layout));
2387 return AVERROR_INVALIDDATA;
2388 }
2389
2390 if (num_core_channels + !!s->lfe > 2 &&
2391 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
2392 channels = 2;
2393 s->output = s->prim_channels == 2 ? s->amode : DCA_STEREO;
2394 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
2395 }
2396 else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
2397 static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
2398 s->channel_order_tab = dca_channel_order_native;
2399 }
2400 s->lfe_index = dca_lfe_index[s->amode];
2401 } else {
2402 av_log(avctx, AV_LOG_ERROR,
2403 "Non standard configuration %d !\n", s->amode);
2404 return AVERROR_INVALIDDATA;
2405 }
2406
2407 s->xxch_dmix_embedded = 0;
2408 } else {
2409 /* we only get here if an XXCH channel set can be added to the mix */
2410 channel_mask = s->xxch_core_spkmask;
2411
2412 if (avctx->request_channels > 0
2413 && avctx->request_channels < s->prim_channels) {
2414 channels = num_core_channels + !!s->lfe;
2415 for (i = 0; i < s->xxch_chset && channels + s->xxch_chset_nch[i]
2416 <= avctx->request_channels; i++) {
2417 channels += s->xxch_chset_nch[i];
2418 channel_mask |= s->xxch_spk_masks[i];
2419 }
2420 } else {
2421 channels = s->prim_channels + !!s->lfe;
2422 for (i = 0; i < s->xxch_chset; i++) {
2423 channel_mask |= s->xxch_spk_masks[i];
2424 }
2425 }
2426
2427 /* Given the DTS spec'ed channel mask, generate an avcodec version */
2428 channel_layout = 0;
2429 for (i = 0; i < s->xxch_nbits_spk_mask; ++i) {
2430 if (channel_mask & (1 << i)) {
2431 channel_layout |= map_xxch_to_native[i];
2432 }
2433 }
2434
2435 /* make sure that we have managed to get equivalent dts/avcodec channel
2436 * masks in some sense -- unfortunately some channels could overlap */
2437 if (av_popcount(channel_mask) != av_popcount(channel_layout)) {
2438 av_log(avctx, AV_LOG_DEBUG,
2439 "DTS-XXCH: Inconsistent avcodec/dts channel layouts\n");
2440 return AVERROR_INVALIDDATA;
2441 }
2442
2443 avctx->channel_layout = channel_layout;
2444
2445 if (!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)) {
2446 /* Estimate DTS --> avcodec ordering table */
2447 for (chset = -1, j = 0; chset < s->xxch_chset; ++chset) {
2448 mask = chset >= 0 ? s->xxch_spk_masks[chset]
2449 : s->xxch_core_spkmask;
2450 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
2451 if (mask & ~(DCA_XXCH_LFE1 | DCA_XXCH_LFE2) & (1 << i)) {
2452 lavc = map_xxch_to_native[i];
2453 posn = av_popcount(channel_layout & (lavc - 1));
2454 s->xxch_order_tab[j++] = posn;
2455 }
2456 }
2457
2458 }
2459
2460 s->lfe_index = av_popcount(channel_layout & (AV_CH_LOW_FREQUENCY-1));
2461 } else { /* native ordering */
2462 for (i = 0; i < channels; i++)
2463 s->xxch_order_tab[i] = i;
2464
2465 s->lfe_index = channels - 1;
2466 }
2467
2468 s->channel_order_tab = s->xxch_order_tab;
2469 }
2470
2471 if (avctx->channels != channels) {
2472 if (avctx->channels)
2473 av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
2474 avctx->channels = channels;
2475 }
2476
2477 /* get output buffer */
2478 frame->nb_samples = 256 * (s->sample_blocks / 8);
2479 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
2480 return ret;
2481 samples_flt = (float **)frame->extended_data;
2482
2483 /* allocate buffer for extra channels if downmixing */
2484 if (avctx->channels < full_channels) {
2485 ret = av_samples_get_buffer_size(NULL, full_channels - channels,
2486 frame->nb_samples,
2487 avctx->sample_fmt, 0);
2488 if (ret < 0)
2489 return ret;
2490
2491 av_fast_malloc(&s->extra_channels_buffer,
2492 &s->extra_channels_buffer_size, ret);
2493 if (!s->extra_channels_buffer)
2494 return AVERROR(ENOMEM);
2495
2496 ret = av_samples_fill_arrays((uint8_t **)s->extra_channels, NULL,
2497 s->extra_channels_buffer,
2498 full_channels - channels,
2499 frame->nb_samples, avctx->sample_fmt, 0);
2500 if (ret < 0)
2501 return ret;
2502 }
2503
2504 /* filter to get final output */
2505 for (i = 0; i < (s->sample_blocks / 8); i++) {
2506 int ch;
2507
2508 for (ch = 0; ch < channels; ch++)
2509 s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
2510 for (; ch < full_channels; ch++)
2511 s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
2512
2513 dca_filter_channels(s, i);
2514
2515 /* If this was marked as a DTS-ES stream we need to subtract back- */
2516 /* channel from SL & SR to remove matrixed back-channel signal */
2517 if ((s->source_pcm_res & 1) && s->xch_present) {
2518 float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];
2519 float *lt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];
2520 float *rt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];
2521 s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
2522 s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
2523 }
2524
2525 /* If stream contains XXCH, we might need to undo an embedded downmix */
2526 if (s->xxch_dmix_embedded) {
2527 /* Loop over channel sets in turn */
2528 ch = num_core_channels;
2529 for (chset = 0; chset < s->xxch_chset; chset++) {
2530 endch = ch + s->xxch_chset_nch[chset];
2531 mask = s->xxch_dmix_embedded;
2532
2533 /* undo downmix */
2534 for (j = ch; j < endch; j++) {
2535 if (mask & (1 << j)) { /* this channel has been mixed-out */
2536 src_chan = s->samples_chanptr[s->channel_order_tab[j]];
2537 for (k = 0; k < endch; k++) {
2538 achan = s->channel_order_tab[k];
2539 scale = s->xxch_dmix_coeff[j][k];
2540 if (scale != 0.0) {
2541 dst_chan = s->samples_chanptr[achan];
2542 s->fdsp.vector_fmac_scalar(dst_chan, src_chan,
2543 -scale, 256);
2544 }
2545 }
2546 }
2547 }
2548
2549 /* if a downmix has been embedded then undo the pre-scaling */
2550 if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) {
2551 scale = s->xxch_dmix_sf[chset];
2552
2553 for (j = 0; j < ch; j++) {
2554 src_chan = s->samples_chanptr[s->channel_order_tab[j]];
2555 for (k = 0; k < 256; k++)
2556 src_chan[k] *= scale;
2557 }
2558
2559 /* LFE channel is always part of core, scale if it exists */
2560 if (s->lfe) {
2561 src_chan = s->samples_chanptr[s->lfe_index];
2562 for (k = 0; k < 256; k++)
2563 src_chan[k] *= scale;
2564 }
2565 }
2566
2567 ch = endch;
2568 }
2569
2570 }
2571 }
2572
2573 /* update lfe history */
2574 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
2575 for (i = 0; i < 2 * s->lfe * 4; i++)
2576 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
2577
2578 /* AVMatrixEncoding
2579 *
2580 * DCA_STEREO_TOTAL (Lt/Rt) is equivalent to Dolby Surround */
2581 ret = ff_side_data_update_matrix_encoding(frame,
2582 (s->output & ~DCA_LFE) == DCA_STEREO_TOTAL ?
2583 AV_MATRIX_ENCODING_DOLBY : AV_MATRIX_ENCODING_NONE);
2584 if (ret < 0)
2585 return ret;
2586
2587 *got_frame_ptr = 1;
2588
2589 return buf_size;
2590}
2591
2592
2593
2594/**
2595 * DCA initialization
2596 *
2597 * @param avctx pointer to the AVCodecContext
2598 */
2599
2600static av_cold int dca_decode_init(AVCodecContext *avctx)
2601{
2602 DCAContext *s = avctx->priv_data;
2603
2604 s->avctx = avctx;
2605 dca_init_vlcs();
2606
2607 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
2608 ff_mdct_init(&s->imdct, 6, 1, 1.0);
2609 ff_synth_filter_init(&s->synth);
2610 ff_dcadsp_init(&s->dcadsp);
2611 ff_fmt_convert_init(&s->fmt_conv, avctx);
2612
2613 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
2614
2615 /* allow downmixing to stereo */
2616#if FF_API_REQUEST_CHANNELS
2617FF_DISABLE_DEPRECATION_WARNINGS
2618 if (avctx->request_channels == 2)
2619 avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
2620FF_ENABLE_DEPRECATION_WARNINGS
2621#endif
2622 if (avctx->channels > 2 &&
2623 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
2624 avctx->channels = 2;
2625
2626 return 0;
2627}
2628
2629static av_cold int dca_decode_end(AVCodecContext *avctx)
2630{
2631 DCAContext *s = avctx->priv_data;
2632 ff_mdct_end(&s->imdct);
2633 av_freep(&s->extra_channels_buffer);
2634 return 0;
2635}
2636
2637static const AVProfile profiles[] = {
2638 { FF_PROFILE_DTS, "DTS" },
2639 { FF_PROFILE_DTS_ES, "DTS-ES" },
2640 { FF_PROFILE_DTS_96_24, "DTS 96/24" },
2641 { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
2642 { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
2643 { FF_PROFILE_UNKNOWN },
2644};
2645
2646static const AVOption options[] = {
2647 { "disable_xch", "disable decoding of the XCh extension", offsetof(DCAContext, xch_disable), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM|AV_OPT_FLAG_AUDIO_PARAM },
2648 { NULL },
2649};
2650
2651static const AVClass dca_decoder_class = {
2652 .class_name = "DCA decoder",
2653 .item_name = av_default_item_name,
2654 .option = options,
2655 .version = LIBAVUTIL_VERSION_INT,
2656 .category = AV_CLASS_CATEGORY_DECODER,
2657};
2658
2659AVCodec ff_dca_decoder = {
2660 .name = "dca",
2661 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
2662 .type = AVMEDIA_TYPE_AUDIO,
2663 .id = AV_CODEC_ID_DTS,
2664 .priv_data_size = sizeof(DCAContext),
2665 .init = dca_decode_init,
2666 .decode = dca_decode_frame,
2667 .close = dca_decode_end,
2668 .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
2669 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2670 AV_SAMPLE_FMT_NONE },
2671 .profiles = NULL_IF_CONFIG_SMALL(profiles),
2672 .priv_class = &dca_decoder_class,
2673};
ffmpeg Piment Noir Debian package repository