forked from KolibriOS/kolibrios
374 lines
13 KiB
C
374 lines
13 KiB
C
/*
|
|
* DCA ExSS extension
|
|
*
|
|
* This file is part of FFmpeg.
|
|
*
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "libavutil/common.h"
|
|
#include "libavutil/log.h"
|
|
|
|
#include "dca.h"
|
|
#include "dca_syncwords.h"
|
|
#include "get_bits.h"
|
|
|
|
/* extensions that reside in core substream */
|
|
#define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
|
|
|
|
/* these are unconfirmed but should be mostly correct */
|
|
enum DCAExSSSpeakerMask {
|
|
DCA_EXSS_FRONT_CENTER = 0x0001,
|
|
DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002,
|
|
DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004,
|
|
DCA_EXSS_LFE = 0x0008,
|
|
DCA_EXSS_REAR_CENTER = 0x0010,
|
|
DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
|
|
DCA_EXSS_REAR_LEFT_RIGHT = 0x0040,
|
|
DCA_EXSS_FRONT_HIGH_CENTER = 0x0080,
|
|
DCA_EXSS_OVERHEAD = 0x0100,
|
|
DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200,
|
|
DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400,
|
|
DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800,
|
|
DCA_EXSS_LFE2 = 0x1000,
|
|
DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000,
|
|
DCA_EXSS_REAR_HIGH_CENTER = 0x4000,
|
|
DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000,
|
|
};
|
|
|
|
/**
|
|
* Return the number of channels in an ExSS speaker mask (HD)
|
|
*/
|
|
static int dca_exss_mask2count(int mask)
|
|
{
|
|
/* count bits that mean speaker pairs twice */
|
|
return av_popcount(mask) +
|
|
av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
|
|
DCA_EXSS_FRONT_LEFT_RIGHT |
|
|
DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
|
|
DCA_EXSS_WIDE_LEFT_RIGHT |
|
|
DCA_EXSS_SIDE_LEFT_RIGHT |
|
|
DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
|
|
DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
|
|
DCA_EXSS_REAR_LEFT_RIGHT |
|
|
DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
|
|
}
|
|
|
|
/**
|
|
* Skip mixing coefficients of a single mix out configuration (HD)
|
|
*/
|
|
static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < channels; i++) {
|
|
int mix_map_mask = get_bits(gb, out_ch);
|
|
int num_coeffs = av_popcount(mix_map_mask);
|
|
skip_bits_long(gb, num_coeffs * 6);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parse extension substream asset header (HD)
|
|
*/
|
|
static int dca_exss_parse_asset_header(DCAContext *s)
|
|
{
|
|
int header_pos = get_bits_count(&s->gb);
|
|
int header_size;
|
|
int channels = 0;
|
|
int embedded_stereo = 0;
|
|
int embedded_6ch = 0;
|
|
int drc_code_present;
|
|
int extensions_mask = 0;
|
|
int i, j;
|
|
|
|
if (get_bits_left(&s->gb) < 16)
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
/* We will parse just enough to get to the extensions bitmask with which
|
|
* we can set the profile value. */
|
|
|
|
header_size = get_bits(&s->gb, 9) + 1;
|
|
skip_bits(&s->gb, 3); // asset index
|
|
|
|
if (s->static_fields) {
|
|
if (get_bits1(&s->gb))
|
|
skip_bits(&s->gb, 4); // asset type descriptor
|
|
if (get_bits1(&s->gb))
|
|
skip_bits_long(&s->gb, 24); // language descriptor
|
|
|
|
if (get_bits1(&s->gb)) {
|
|
/* How can one fit 1024 bytes of text here if the maximum value
|
|
* for the asset header size field above was 512 bytes? */
|
|
int text_length = get_bits(&s->gb, 10) + 1;
|
|
if (get_bits_left(&s->gb) < text_length * 8)
|
|
return AVERROR_INVALIDDATA;
|
|
skip_bits_long(&s->gb, text_length * 8); // info text
|
|
}
|
|
|
|
skip_bits(&s->gb, 5); // bit resolution - 1
|
|
skip_bits(&s->gb, 4); // max sample rate code
|
|
channels = get_bits(&s->gb, 8) + 1;
|
|
|
|
s->one2one_map_chtospkr = get_bits1(&s->gb);
|
|
if (s->one2one_map_chtospkr) {
|
|
int spkr_remap_sets;
|
|
int spkr_mask_size = 16;
|
|
int num_spkrs[7];
|
|
|
|
if (channels > 2)
|
|
embedded_stereo = get_bits1(&s->gb);
|
|
if (channels > 6)
|
|
embedded_6ch = get_bits1(&s->gb);
|
|
|
|
if (get_bits1(&s->gb)) {
|
|
spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
|
|
skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
|
|
}
|
|
|
|
spkr_remap_sets = get_bits(&s->gb, 3);
|
|
|
|
for (i = 0; i < spkr_remap_sets; i++) {
|
|
/* std layout mask for each remap set */
|
|
num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
|
|
}
|
|
|
|
for (i = 0; i < spkr_remap_sets; i++) {
|
|
int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
|
|
if (get_bits_left(&s->gb) < 0)
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
for (j = 0; j < num_spkrs[i]; j++) {
|
|
int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
|
|
int num_dec_ch = av_popcount(remap_dec_ch_mask);
|
|
skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
|
|
}
|
|
}
|
|
} else {
|
|
skip_bits(&s->gb, 3); // representation type
|
|
}
|
|
}
|
|
|
|
drc_code_present = get_bits1(&s->gb);
|
|
if (drc_code_present)
|
|
get_bits(&s->gb, 8); // drc code
|
|
|
|
if (get_bits1(&s->gb))
|
|
skip_bits(&s->gb, 5); // dialog normalization code
|
|
|
|
if (drc_code_present && embedded_stereo)
|
|
get_bits(&s->gb, 8); // drc stereo code
|
|
|
|
if (s->mix_metadata && get_bits1(&s->gb)) {
|
|
skip_bits(&s->gb, 1); // external mix
|
|
skip_bits(&s->gb, 6); // post mix gain code
|
|
|
|
if (get_bits(&s->gb, 2) != 3) // mixer drc code
|
|
skip_bits(&s->gb, 3); // drc limit
|
|
else
|
|
skip_bits(&s->gb, 8); // custom drc code
|
|
|
|
if (get_bits1(&s->gb)) // channel specific scaling
|
|
for (i = 0; i < s->num_mix_configs; i++)
|
|
skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
|
|
else
|
|
skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
|
|
|
|
for (i = 0; i < s->num_mix_configs; i++) {
|
|
if (get_bits_left(&s->gb) < 0)
|
|
return AVERROR_INVALIDDATA;
|
|
dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
|
|
if (embedded_6ch)
|
|
dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
|
|
if (embedded_stereo)
|
|
dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
|
|
}
|
|
}
|
|
|
|
switch (get_bits(&s->gb, 2)) {
|
|
case 0:
|
|
extensions_mask = get_bits(&s->gb, 12);
|
|
break;
|
|
case 1:
|
|
extensions_mask = DCA_EXT_EXSS_XLL;
|
|
break;
|
|
case 2:
|
|
extensions_mask = DCA_EXT_EXSS_LBR;
|
|
break;
|
|
case 3:
|
|
extensions_mask = 0; /* aux coding */
|
|
break;
|
|
}
|
|
|
|
/* not parsed further, we were only interested in the extensions mask */
|
|
|
|
if (get_bits_left(&s->gb) < 0)
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
|
|
av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
|
|
return AVERROR_INVALIDDATA;
|
|
}
|
|
skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
|
|
|
|
if (extensions_mask & DCA_EXT_EXSS_XLL)
|
|
s->profile = FF_PROFILE_DTS_HD_MA;
|
|
else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
|
|
DCA_EXT_EXSS_XXCH))
|
|
s->profile = FF_PROFILE_DTS_HD_HRA;
|
|
|
|
if (!(extensions_mask & DCA_EXT_CORE))
|
|
av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
|
|
if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
|
|
av_log(s->avctx, AV_LOG_WARNING,
|
|
"DTS extensions detection mismatch (%d, %d)\n",
|
|
extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Parse extension substream header (HD)
|
|
*/
|
|
void ff_dca_exss_parse_header(DCAContext *s)
|
|
{
|
|
int asset_size[8];
|
|
int ss_index;
|
|
int blownup;
|
|
int num_audiop = 1;
|
|
int num_assets = 1;
|
|
int active_ss_mask[8];
|
|
int i, j;
|
|
int start_pos;
|
|
int hdrsize;
|
|
uint32_t mkr;
|
|
|
|
if (get_bits_left(&s->gb) < 52)
|
|
return;
|
|
|
|
start_pos = get_bits_count(&s->gb) - 32;
|
|
|
|
skip_bits(&s->gb, 8); // user data
|
|
ss_index = get_bits(&s->gb, 2);
|
|
|
|
blownup = get_bits1(&s->gb);
|
|
hdrsize = get_bits(&s->gb, 8 + 4 * blownup) + 1; // header_size
|
|
skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
|
|
|
|
s->static_fields = get_bits1(&s->gb);
|
|
if (s->static_fields) {
|
|
skip_bits(&s->gb, 2); // reference clock code
|
|
skip_bits(&s->gb, 3); // frame duration code
|
|
|
|
if (get_bits1(&s->gb))
|
|
skip_bits_long(&s->gb, 36); // timestamp
|
|
|
|
/* a single stream can contain multiple audio assets that can be
|
|
* combined to form multiple audio presentations */
|
|
|
|
num_audiop = get_bits(&s->gb, 3) + 1;
|
|
if (num_audiop > 1) {
|
|
avpriv_request_sample(s->avctx,
|
|
"Multiple DTS-HD audio presentations");
|
|
/* ignore such streams for now */
|
|
return;
|
|
}
|
|
|
|
num_assets = get_bits(&s->gb, 3) + 1;
|
|
if (num_assets > 1) {
|
|
avpriv_request_sample(s->avctx, "Multiple DTS-HD audio assets");
|
|
/* ignore such streams for now */
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < num_audiop; i++)
|
|
active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
|
|
|
|
for (i = 0; i < num_audiop; i++)
|
|
for (j = 0; j <= ss_index; j++)
|
|
if (active_ss_mask[i] & (1 << j))
|
|
skip_bits(&s->gb, 8); // active asset mask
|
|
|
|
s->mix_metadata = get_bits1(&s->gb);
|
|
if (s->mix_metadata) {
|
|
int mix_out_mask_size;
|
|
|
|
skip_bits(&s->gb, 2); // adjustment level
|
|
mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
|
|
s->num_mix_configs = get_bits(&s->gb, 2) + 1;
|
|
|
|
for (i = 0; i < s->num_mix_configs; i++) {
|
|
int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
|
|
s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
|
|
}
|
|
}
|
|
}
|
|
|
|
av_assert0(num_assets > 0); // silence a warning
|
|
|
|
for (i = 0; i < num_assets; i++)
|
|
asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup) + 1;
|
|
|
|
for (i = 0; i < num_assets; i++) {
|
|
if (dca_exss_parse_asset_header(s))
|
|
return;
|
|
}
|
|
|
|
j = get_bits_count(&s->gb);
|
|
if (start_pos + hdrsize * 8 > j)
|
|
skip_bits_long(&s->gb, start_pos + hdrsize * 8 - j);
|
|
|
|
for (i = 0; i < num_assets; i++) {
|
|
int end_pos;
|
|
start_pos = get_bits_count(&s->gb);
|
|
end_pos = start_pos + asset_size[i] * 8;
|
|
mkr = get_bits_long(&s->gb, 32);
|
|
|
|
/* parse extensions that we know about */
|
|
switch (mkr) {
|
|
case DCA_SYNCWORD_XBR:
|
|
ff_dca_xbr_parse_frame(s);
|
|
break;
|
|
case DCA_SYNCWORD_XXCH:
|
|
ff_dca_xxch_decode_frame(s);
|
|
s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
|
|
break;
|
|
case DCA_SYNCWORD_XLL:
|
|
if (s->xll_disable) {
|
|
av_log(s->avctx, AV_LOG_DEBUG,
|
|
"DTS-XLL: ignoring XLL extension\n");
|
|
break;
|
|
}
|
|
av_log(s->avctx, AV_LOG_DEBUG,
|
|
"DTS-XLL: decoding XLL extension\n");
|
|
if (ff_dca_xll_decode_header(s) == 0 &&
|
|
ff_dca_xll_decode_navi(s, end_pos) == 0)
|
|
s->exss_ext_mask |= DCA_EXT_EXSS_XLL;
|
|
break;
|
|
default:
|
|
av_log(s->avctx, AV_LOG_DEBUG,
|
|
"DTS-ExSS: unknown marker = 0x%08x\n", mkr);
|
|
}
|
|
|
|
/* skip to end of block */
|
|
j = get_bits_count(&s->gb);
|
|
if (j > end_pos)
|
|
av_log(s->avctx, AV_LOG_ERROR,
|
|
"DTS-ExSS: Processed asset too long.\n");
|
|
if (j < end_pos)
|
|
skip_bits_long(&s->gb, end_pos - j);
|
|
}
|
|
}
|