4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #include "libavutil/common.h"
22 #include "libavutil/log.h"
25 #include "dca_syncwords.h"
28 /* extensions that reside in core substream */
29 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
31 /* these are unconfirmed but should be mostly correct */
32 enum DCAExSSSpeakerMask {
33 DCA_EXSS_FRONT_CENTER = 0x0001,
34 DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002,
35 DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004,
36 DCA_EXSS_LFE = 0x0008,
37 DCA_EXSS_REAR_CENTER = 0x0010,
38 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
39 DCA_EXSS_REAR_LEFT_RIGHT = 0x0040,
40 DCA_EXSS_FRONT_HIGH_CENTER = 0x0080,
41 DCA_EXSS_OVERHEAD = 0x0100,
42 DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200,
43 DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400,
44 DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800,
45 DCA_EXSS_LFE2 = 0x1000,
46 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000,
47 DCA_EXSS_REAR_HIGH_CENTER = 0x4000,
48 DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000,
52 * Return the number of channels in an ExSS speaker mask (HD)
54 static int dca_exss_mask2count(int mask)
56 /* count bits that mean speaker pairs twice */
57 return av_popcount(mask) +
58 av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
59 DCA_EXSS_FRONT_LEFT_RIGHT |
60 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
61 DCA_EXSS_WIDE_LEFT_RIGHT |
62 DCA_EXSS_SIDE_LEFT_RIGHT |
63 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
64 DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
65 DCA_EXSS_REAR_LEFT_RIGHT |
66 DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
70 * Skip mixing coefficients of a single mix out configuration (HD)
72 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
76 for (i = 0; i < channels; i++) {
77 int mix_map_mask = get_bits(gb, out_ch);
78 int num_coeffs = av_popcount(mix_map_mask);
79 skip_bits_long(gb, num_coeffs * 6);
84 * Parse extension substream asset header (HD)
86 static int dca_exss_parse_asset_header(DCAContext *s)
88 int header_pos = get_bits_count(&s->gb);
91 int embedded_stereo = 0;
94 int extensions_mask = 0;
97 if (get_bits_left(&s->gb) < 16)
98 return AVERROR_INVALIDDATA;
100 /* We will parse just enough to get to the extensions bitmask with which
101 * we can set the profile value. */
103 header_size = get_bits(&s->gb, 9) + 1;
104 skip_bits(&s->gb, 3); // asset index
106 if (s->static_fields) {
107 if (get_bits1(&s->gb))
108 skip_bits(&s->gb, 4); // asset type descriptor
109 if (get_bits1(&s->gb))
110 skip_bits_long(&s->gb, 24); // language descriptor
112 if (get_bits1(&s->gb)) {
113 /* How can one fit 1024 bytes of text here if the maximum value
114 * for the asset header size field above was 512 bytes? */
115 int text_length = get_bits(&s->gb, 10) + 1;
116 if (get_bits_left(&s->gb) < text_length * 8)
117 return AVERROR_INVALIDDATA;
118 skip_bits_long(&s->gb, text_length * 8); // info text
121 skip_bits(&s->gb, 5); // bit resolution - 1
122 skip_bits(&s->gb, 4); // max sample rate code
123 channels = get_bits(&s->gb, 8) + 1;
125 s->one2one_map_chtospkr = get_bits1(&s->gb);
126 if (s->one2one_map_chtospkr) {
128 int spkr_mask_size = 16;
132 embedded_stereo = get_bits1(&s->gb);
134 embedded_6ch = get_bits1(&s->gb);
136 if (get_bits1(&s->gb)) {
137 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
138 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
141 spkr_remap_sets = get_bits(&s->gb, 3);
143 for (i = 0; i < spkr_remap_sets; i++) {
144 /* std layout mask for each remap set */
145 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
148 for (i = 0; i < spkr_remap_sets; i++) {
149 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
150 if (get_bits_left(&s->gb) < 0)
151 return AVERROR_INVALIDDATA;
153 for (j = 0; j < num_spkrs[i]; j++) {
154 int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
155 int num_dec_ch = av_popcount(remap_dec_ch_mask);
156 skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
160 skip_bits(&s->gb, 3); // representation type
164 drc_code_present = get_bits1(&s->gb);
165 if (drc_code_present)
166 get_bits(&s->gb, 8); // drc code
168 if (get_bits1(&s->gb))
169 skip_bits(&s->gb, 5); // dialog normalization code
171 if (drc_code_present && embedded_stereo)
172 get_bits(&s->gb, 8); // drc stereo code
174 if (s->mix_metadata && get_bits1(&s->gb)) {
175 skip_bits(&s->gb, 1); // external mix
176 skip_bits(&s->gb, 6); // post mix gain code
178 if (get_bits(&s->gb, 2) != 3) // mixer drc code
179 skip_bits(&s->gb, 3); // drc limit
181 skip_bits(&s->gb, 8); // custom drc code
183 if (get_bits1(&s->gb)) // channel specific scaling
184 for (i = 0; i < s->num_mix_configs; i++)
185 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
187 skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
189 for (i = 0; i < s->num_mix_configs; i++) {
190 if (get_bits_left(&s->gb) < 0)
191 return AVERROR_INVALIDDATA;
192 dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
194 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
196 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
200 switch (get_bits(&s->gb, 2)) {
202 extensions_mask = get_bits(&s->gb, 12);
205 extensions_mask = DCA_EXT_EXSS_XLL;
208 extensions_mask = DCA_EXT_EXSS_LBR;
211 extensions_mask = 0; /* aux coding */
215 /* not parsed further, we were only interested in the extensions mask */
217 if (get_bits_left(&s->gb) < 0)
218 return AVERROR_INVALIDDATA;
220 if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
221 av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
222 return AVERROR_INVALIDDATA;
224 skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
226 if (extensions_mask & DCA_EXT_EXSS_XLL)
227 s->profile = FF_PROFILE_DTS_HD_MA;
228 else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
230 s->profile = FF_PROFILE_DTS_HD_HRA;
232 if (!(extensions_mask & DCA_EXT_CORE))
233 av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
234 if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
235 av_log(s->avctx, AV_LOG_WARNING,
236 "DTS extensions detection mismatch (%d, %d)\n",
237 extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
243 * Parse extension substream header (HD)
245 void ff_dca_exss_parse_header(DCAContext *s)
252 int active_ss_mask[8];
258 if (get_bits_left(&s->gb) < 52)
261 start_pos = get_bits_count(&s->gb) - 32;
263 skip_bits(&s->gb, 8); // user data
264 ss_index = get_bits(&s->gb, 2);
266 blownup = get_bits1(&s->gb);
267 hdrsize = get_bits(&s->gb, 8 + 4 * blownup) + 1; // header_size
268 skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
270 s->static_fields = get_bits1(&s->gb);
271 if (s->static_fields) {
272 skip_bits(&s->gb, 2); // reference clock code
273 skip_bits(&s->gb, 3); // frame duration code
275 if (get_bits1(&s->gb))
276 skip_bits_long(&s->gb, 36); // timestamp
278 /* a single stream can contain multiple audio assets that can be
279 * combined to form multiple audio presentations */
281 num_audiop = get_bits(&s->gb, 3) + 1;
282 if (num_audiop > 1) {
283 avpriv_request_sample(s->avctx,
284 "Multiple DTS-HD audio presentations");
285 /* ignore such streams for now */
289 num_assets = get_bits(&s->gb, 3) + 1;
290 if (num_assets > 1) {
291 avpriv_request_sample(s->avctx, "Multiple DTS-HD audio assets");
292 /* ignore such streams for now */
296 for (i = 0; i < num_audiop; i++)
297 active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
299 for (i = 0; i < num_audiop; i++)
300 for (j = 0; j <= ss_index; j++)
301 if (active_ss_mask[i] & (1 << j))
302 skip_bits(&s->gb, 8); // active asset mask
304 s->mix_metadata = get_bits1(&s->gb);
305 if (s->mix_metadata) {
306 int mix_out_mask_size;
308 skip_bits(&s->gb, 2); // adjustment level
309 mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
310 s->num_mix_configs = get_bits(&s->gb, 2) + 1;
312 for (i = 0; i < s->num_mix_configs; i++) {
313 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
314 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
319 av_assert0(num_assets > 0); // silence a warning
321 for (i = 0; i < num_assets; i++)
322 asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup) + 1;
324 for (i = 0; i < num_assets; i++) {
325 if (dca_exss_parse_asset_header(s))
329 j = get_bits_count(&s->gb);
330 if (start_pos + hdrsize * 8 > j)
331 skip_bits_long(&s->gb, start_pos + hdrsize * 8 - j);
333 for (i = 0; i < num_assets; i++) {
335 start_pos = get_bits_count(&s->gb);
336 end_pos = start_pos + asset_size[i] * 8;
337 mkr = get_bits_long(&s->gb, 32);
339 /* parse extensions that we know about */
341 case DCA_SYNCWORD_XBR:
342 ff_dca_xbr_parse_frame(s);
344 case DCA_SYNCWORD_XXCH:
345 ff_dca_xxch_decode_frame(s);
346 s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
348 case DCA_SYNCWORD_XLL:
349 if (s->xll_disable) {
350 av_log(s->avctx, AV_LOG_DEBUG,
351 "DTS-XLL: ignoring XLL extension\n");
354 av_log(s->avctx, AV_LOG_DEBUG,
355 "DTS-XLL: decoding XLL extension\n");
356 if (ff_dca_xll_decode_header(s) == 0 &&
357 ff_dca_xll_decode_navi(s, end_pos) == 0)
358 s->exss_ext_mask |= DCA_EXT_EXSS_XLL;
361 av_log(s->avctx, AV_LOG_DEBUG,
362 "DTS-ExSS: unknown marker = 0x%08x\n", mkr);
365 /* skip to end of block */
366 j = get_bits_count(&s->gb);
368 av_log(s->avctx, AV_LOG_ERROR,
369 "DTS-ExSS: Processed asset too long.\n");
371 skip_bits_long(&s->gb, end_pos - j);