mirror of
https://git.videolan.org/git/ffmpeg.git
synced 2024-09-12 02:14:56 +02:00
![foo86](/assets/img/avatar_default.png)
Avoids unwanted parser dependency on dcadata. Signed-off-by: James Almer <jamrial@gmail.com>
515 lines
16 KiB
C
515 lines
16 KiB
C
/*
|
|
* Copyright (C) 2016 foo86
|
|
*
|
|
* 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 "dcadec.h"
|
|
|
|
static void parse_xll_parameters(DCAExssParser *s, DCAExssAsset *asset)
|
|
{
|
|
// Size of XLL data in extension substream
|
|
asset->xll_size = get_bits(&s->gb, s->exss_size_nbits) + 1;
|
|
|
|
// XLL sync word present flag
|
|
if (asset->xll_sync_present = get_bits1(&s->gb)) {
|
|
int xll_delay_nbits;
|
|
|
|
// Peak bit rate smoothing buffer size
|
|
skip_bits(&s->gb, 4);
|
|
|
|
// Number of bits for XLL decoding delay
|
|
xll_delay_nbits = get_bits(&s->gb, 5) + 1;
|
|
|
|
// Initial XLL decoding delay in frames
|
|
asset->xll_delay_nframes = get_bits_long(&s->gb, xll_delay_nbits);
|
|
|
|
// Number of bytes offset to XLL sync
|
|
asset->xll_sync_offset = get_bits(&s->gb, s->exss_size_nbits);
|
|
} else {
|
|
asset->xll_delay_nframes = 0;
|
|
asset->xll_sync_offset = 0;
|
|
}
|
|
}
|
|
|
|
static void parse_lbr_parameters(DCAExssParser *s, DCAExssAsset *asset)
|
|
{
|
|
// Size of LBR component in extension substream
|
|
asset->lbr_size = get_bits(&s->gb, 14) + 1;
|
|
|
|
// LBR sync word present flag
|
|
if (get_bits1(&s->gb))
|
|
// LBR sync distance
|
|
skip_bits(&s->gb, 2);
|
|
}
|
|
|
|
static int parse_descriptor(DCAExssParser *s, DCAExssAsset *asset)
|
|
{
|
|
int i, j, drc_present, descr_size, descr_pos = get_bits_count(&s->gb);
|
|
|
|
// Size of audio asset descriptor in bytes
|
|
descr_size = get_bits(&s->gb, 9) + 1;
|
|
|
|
// Audio asset identifier
|
|
asset->asset_index = get_bits(&s->gb, 3);
|
|
|
|
//
|
|
// Per stream static metadata
|
|
//
|
|
|
|
if (s->static_fields_present) {
|
|
// Asset type descriptor presence
|
|
if (get_bits1(&s->gb))
|
|
// Asset type descriptor
|
|
skip_bits(&s->gb, 4);
|
|
|
|
// Language descriptor presence
|
|
if (get_bits1(&s->gb))
|
|
// Language descriptor
|
|
skip_bits(&s->gb, 24);
|
|
|
|
// Additional textual information presence
|
|
if (get_bits1(&s->gb)) {
|
|
// Byte size of additional text info
|
|
int text_size = get_bits(&s->gb, 10) + 1;
|
|
|
|
// Sanity check available size
|
|
if (get_bits_left(&s->gb) < text_size * 8)
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
// Additional textual information string
|
|
skip_bits_long(&s->gb, text_size * 8);
|
|
}
|
|
|
|
// PCM bit resolution
|
|
asset->pcm_bit_res = get_bits(&s->gb, 5) + 1;
|
|
|
|
// Maximum sample rate
|
|
asset->max_sample_rate = ff_dca_sampling_freqs[get_bits(&s->gb, 4)];
|
|
|
|
// Total number of channels
|
|
asset->nchannels_total = get_bits(&s->gb, 8) + 1;
|
|
|
|
// One to one map channel to speakers
|
|
if (asset->one_to_one_map_ch_to_spkr = get_bits1(&s->gb)) {
|
|
int spkr_mask_nbits = 0;
|
|
int spkr_remap_nsets;
|
|
int nspeakers[8];
|
|
|
|
// Embedded stereo flag
|
|
asset->embedded_stereo = asset->nchannels_total > 2 && get_bits1(&s->gb);
|
|
|
|
// Embedded 6 channels flag
|
|
asset->embedded_6ch = asset->nchannels_total > 6 && get_bits1(&s->gb);
|
|
|
|
// Speaker mask enabled flag
|
|
if (asset->spkr_mask_enabled = get_bits1(&s->gb)) {
|
|
// Number of bits for speaker activity mask
|
|
spkr_mask_nbits = (get_bits(&s->gb, 2) + 1) << 2;
|
|
|
|
// Loudspeaker activity mask
|
|
asset->spkr_mask = get_bits(&s->gb, spkr_mask_nbits);
|
|
}
|
|
|
|
// Number of speaker remapping sets
|
|
if ((spkr_remap_nsets = get_bits(&s->gb, 3)) && !spkr_mask_nbits) {
|
|
if (s->avctx)
|
|
av_log(s->avctx, AV_LOG_ERROR, "Speaker mask disabled yet there are remapping sets\n");
|
|
return AVERROR_INVALIDDATA;
|
|
}
|
|
|
|
// Standard loudspeaker layout mask
|
|
for (i = 0; i < spkr_remap_nsets; i++)
|
|
nspeakers[i] = ff_dca_count_chs_for_mask(get_bits(&s->gb, spkr_mask_nbits));
|
|
|
|
for (i = 0; i < spkr_remap_nsets; i++) {
|
|
// Number of channels to be decoded for speaker remapping
|
|
int nch_for_remaps = get_bits(&s->gb, 5) + 1;
|
|
|
|
for (j = 0; j < nspeakers[i]; j++) {
|
|
// Decoded channels to output speaker mapping mask
|
|
int remap_ch_mask = get_bits_long(&s->gb, nch_for_remaps);
|
|
|
|
// Loudspeaker remapping codes
|
|
skip_bits_long(&s->gb, av_popcount(remap_ch_mask) * 5);
|
|
}
|
|
}
|
|
} else {
|
|
asset->embedded_stereo = 0;
|
|
asset->embedded_6ch = 0;
|
|
asset->spkr_mask_enabled = 0;
|
|
asset->spkr_mask = 0;
|
|
|
|
// Representation type
|
|
asset->representation_type = get_bits(&s->gb, 3);
|
|
}
|
|
}
|
|
|
|
//
|
|
// DRC, DNC and mixing metadata
|
|
//
|
|
|
|
// Dynamic range coefficient presence flag
|
|
drc_present = get_bits1(&s->gb);
|
|
|
|
// Code for dynamic range coefficient
|
|
if (drc_present)
|
|
skip_bits(&s->gb, 8);
|
|
|
|
// Dialog normalization presence flag
|
|
if (get_bits1(&s->gb))
|
|
// Dialog normalization code
|
|
skip_bits(&s->gb, 5);
|
|
|
|
// DRC for stereo downmix
|
|
if (drc_present && asset->embedded_stereo)
|
|
skip_bits(&s->gb, 8);
|
|
|
|
// Mixing metadata presence flag
|
|
if (s->mix_metadata_enabled && get_bits1(&s->gb)) {
|
|
int nchannels_dmix;
|
|
|
|
// External mixing flag
|
|
skip_bits1(&s->gb);
|
|
|
|
// Post mixing / replacement gain adjustment
|
|
skip_bits(&s->gb, 6);
|
|
|
|
// DRC prior to mixing
|
|
if (get_bits(&s->gb, 2) == 3)
|
|
// Custom code for mixing DRC
|
|
skip_bits(&s->gb, 8);
|
|
else
|
|
// Limit for mixing DRC
|
|
skip_bits(&s->gb, 3);
|
|
|
|
// Scaling type for channels of main audio
|
|
// Scaling parameters of main audio
|
|
if (get_bits1(&s->gb))
|
|
for (i = 0; i < s->nmixoutconfigs; i++)
|
|
skip_bits_long(&s->gb, 6 * s->nmixoutchs[i]);
|
|
else
|
|
skip_bits_long(&s->gb, 6 * s->nmixoutconfigs);
|
|
|
|
nchannels_dmix = asset->nchannels_total;
|
|
if (asset->embedded_6ch)
|
|
nchannels_dmix += 6;
|
|
if (asset->embedded_stereo)
|
|
nchannels_dmix += 2;
|
|
|
|
for (i = 0; i < s->nmixoutconfigs; i++) {
|
|
if (!s->nmixoutchs[i]) {
|
|
if (s->avctx)
|
|
av_log(s->avctx, AV_LOG_ERROR, "Invalid speaker layout mask for mixing configuration\n");
|
|
return AVERROR_INVALIDDATA;
|
|
}
|
|
for (j = 0; j < nchannels_dmix; j++) {
|
|
// Mix output mask
|
|
int mix_map_mask = get_bits(&s->gb, s->nmixoutchs[i]);
|
|
|
|
// Mixing coefficients
|
|
skip_bits_long(&s->gb, av_popcount(mix_map_mask) * 6);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Decoder navigation data
|
|
//
|
|
|
|
// Coding mode for the asset
|
|
asset->coding_mode = get_bits(&s->gb, 2);
|
|
|
|
// Coding components used in asset
|
|
switch (asset->coding_mode) {
|
|
case 0: // Coding mode that may contain multiple coding components
|
|
asset->extension_mask = get_bits(&s->gb, 12);
|
|
|
|
if (asset->extension_mask & DCA_EXSS_CORE) {
|
|
// Size of core component in extension substream
|
|
asset->core_size = get_bits(&s->gb, 14) + 1;
|
|
// Core sync word present flag
|
|
if (get_bits1(&s->gb))
|
|
// Core sync distance
|
|
skip_bits(&s->gb, 2);
|
|
}
|
|
|
|
if (asset->extension_mask & DCA_EXSS_XBR)
|
|
// Size of XBR extension in extension substream
|
|
asset->xbr_size = get_bits(&s->gb, 14) + 1;
|
|
|
|
if (asset->extension_mask & DCA_EXSS_XXCH)
|
|
// Size of XXCH extension in extension substream
|
|
asset->xxch_size = get_bits(&s->gb, 14) + 1;
|
|
|
|
if (asset->extension_mask & DCA_EXSS_X96)
|
|
// Size of X96 extension in extension substream
|
|
asset->x96_size = get_bits(&s->gb, 12) + 1;
|
|
|
|
if (asset->extension_mask & DCA_EXSS_LBR)
|
|
parse_lbr_parameters(s, asset);
|
|
|
|
if (asset->extension_mask & DCA_EXSS_XLL)
|
|
parse_xll_parameters(s, asset);
|
|
|
|
if (asset->extension_mask & DCA_EXSS_RSV1)
|
|
skip_bits(&s->gb, 16);
|
|
|
|
if (asset->extension_mask & DCA_EXSS_RSV2)
|
|
skip_bits(&s->gb, 16);
|
|
break;
|
|
|
|
case 1: // Loss-less coding mode without CBR component
|
|
asset->extension_mask = DCA_EXSS_XLL;
|
|
parse_xll_parameters(s, asset);
|
|
break;
|
|
|
|
case 2: // Low bit rate mode
|
|
asset->extension_mask = DCA_EXSS_LBR;
|
|
parse_lbr_parameters(s, asset);
|
|
break;
|
|
|
|
case 3: // Auxiliary coding mode
|
|
asset->extension_mask = 0;
|
|
|
|
// Size of auxiliary coded data
|
|
skip_bits(&s->gb, 14);
|
|
|
|
// Auxiliary codec identification
|
|
skip_bits(&s->gb, 8);
|
|
|
|
// Aux sync word present flag
|
|
if (get_bits1(&s->gb))
|
|
// Aux sync distance
|
|
skip_bits(&s->gb, 3);
|
|
break;
|
|
}
|
|
|
|
if (asset->extension_mask & DCA_EXSS_XLL)
|
|
// DTS-HD stream ID
|
|
asset->hd_stream_id = get_bits(&s->gb, 3);
|
|
|
|
// One to one mixing flag
|
|
// Per channel main audio scaling flag
|
|
// Main audio scaling codes
|
|
// Decode asset in secondary decoder flag
|
|
// Revision 2 DRC metadata
|
|
// Reserved
|
|
// Zero pad
|
|
if (ff_dca_seek_bits(&s->gb, descr_pos + descr_size * 8)) {
|
|
if (s->avctx)
|
|
av_log(s->avctx, AV_LOG_ERROR, "Read past end of EXSS asset descriptor\n");
|
|
return AVERROR_INVALIDDATA;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int set_exss_offsets(DCAExssAsset *asset)
|
|
{
|
|
int offs = asset->asset_offset;
|
|
int size = asset->asset_size;
|
|
|
|
if (asset->extension_mask & DCA_EXSS_CORE) {
|
|
asset->core_offset = offs;
|
|
if (asset->core_size > size)
|
|
return AVERROR_INVALIDDATA;
|
|
offs += asset->core_size;
|
|
size -= asset->core_size;
|
|
}
|
|
|
|
if (asset->extension_mask & DCA_EXSS_XBR) {
|
|
asset->xbr_offset = offs;
|
|
if (asset->xbr_size > size)
|
|
return AVERROR_INVALIDDATA;
|
|
offs += asset->xbr_size;
|
|
size -= asset->xbr_size;
|
|
}
|
|
|
|
if (asset->extension_mask & DCA_EXSS_XXCH) {
|
|
asset->xxch_offset = offs;
|
|
if (asset->xxch_size > size)
|
|
return AVERROR_INVALIDDATA;
|
|
offs += asset->xxch_size;
|
|
size -= asset->xxch_size;
|
|
}
|
|
|
|
if (asset->extension_mask & DCA_EXSS_X96) {
|
|
asset->x96_offset = offs;
|
|
if (asset->x96_size > size)
|
|
return AVERROR_INVALIDDATA;
|
|
offs += asset->x96_size;
|
|
size -= asset->x96_size;
|
|
}
|
|
|
|
if (asset->extension_mask & DCA_EXSS_LBR) {
|
|
asset->lbr_offset = offs;
|
|
if (asset->lbr_size > size)
|
|
return AVERROR_INVALIDDATA;
|
|
offs += asset->lbr_size;
|
|
size -= asset->lbr_size;
|
|
}
|
|
|
|
if (asset->extension_mask & DCA_EXSS_XLL) {
|
|
asset->xll_offset = offs;
|
|
if (asset->xll_size > size)
|
|
return AVERROR_INVALIDDATA;
|
|
offs += asset->xll_size;
|
|
size -= asset->xll_size;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ff_dca_exss_parse(DCAExssParser *s, const uint8_t *data, int size)
|
|
{
|
|
int i, ret, offset, wide_hdr, header_size;
|
|
|
|
if ((ret = init_get_bits8(&s->gb, data, size)) < 0)
|
|
return ret;
|
|
|
|
// Extension substream sync word
|
|
skip_bits_long(&s->gb, 32);
|
|
|
|
// User defined bits
|
|
skip_bits(&s->gb, 8);
|
|
|
|
// Extension substream index
|
|
s->exss_index = get_bits(&s->gb, 2);
|
|
|
|
// Flag indicating short or long header size
|
|
wide_hdr = get_bits1(&s->gb);
|
|
|
|
// Extension substream header length
|
|
header_size = get_bits(&s->gb, 8 + 4 * wide_hdr) + 1;
|
|
|
|
// Check CRC
|
|
if (s->avctx && ff_dca_check_crc(s->avctx, &s->gb, 32 + 8, header_size * 8)) {
|
|
av_log(s->avctx, AV_LOG_ERROR, "Invalid EXSS header checksum\n");
|
|
return AVERROR_INVALIDDATA;
|
|
}
|
|
|
|
s->exss_size_nbits = 16 + 4 * wide_hdr;
|
|
|
|
// Number of bytes of extension substream
|
|
s->exss_size = get_bits(&s->gb, s->exss_size_nbits) + 1;
|
|
if (s->exss_size > size) {
|
|
if (s->avctx)
|
|
av_log(s->avctx, AV_LOG_ERROR, "Packet too short for EXSS frame\n");
|
|
return AVERROR_INVALIDDATA;
|
|
}
|
|
|
|
// Per stream static fields presence flag
|
|
if (s->static_fields_present = get_bits1(&s->gb)) {
|
|
int active_exss_mask[8];
|
|
|
|
// Reference clock code
|
|
skip_bits(&s->gb, 2);
|
|
|
|
// Extension substream frame duration
|
|
skip_bits(&s->gb, 3);
|
|
|
|
// Timecode presence flag
|
|
if (get_bits1(&s->gb))
|
|
// Timecode data
|
|
skip_bits_long(&s->gb, 36);
|
|
|
|
// Number of defined audio presentations
|
|
s->npresents = get_bits(&s->gb, 3) + 1;
|
|
if (s->npresents > 1) {
|
|
if (s->avctx)
|
|
avpriv_request_sample(s->avctx, "%d audio presentations", s->npresents);
|
|
return AVERROR_PATCHWELCOME;
|
|
}
|
|
|
|
// Number of audio assets in extension substream
|
|
s->nassets = get_bits(&s->gb, 3) + 1;
|
|
if (s->nassets > 1) {
|
|
if (s->avctx)
|
|
avpriv_request_sample(s->avctx, "%d audio assets", s->nassets);
|
|
return AVERROR_PATCHWELCOME;
|
|
}
|
|
|
|
// Active extension substream mask for audio presentation
|
|
for (i = 0; i < s->npresents; i++)
|
|
active_exss_mask[i] = get_bits(&s->gb, s->exss_index + 1);
|
|
|
|
// Active audio asset mask
|
|
for (i = 0; i < s->npresents; i++)
|
|
skip_bits_long(&s->gb, av_popcount(active_exss_mask[i]) * 8);
|
|
|
|
// Mixing metadata enable flag
|
|
if (s->mix_metadata_enabled = get_bits1(&s->gb)) {
|
|
int spkr_mask_nbits;
|
|
|
|
// Mixing metadata adjustment level
|
|
skip_bits(&s->gb, 2);
|
|
|
|
// Number of bits for mixer output speaker activity mask
|
|
spkr_mask_nbits = (get_bits(&s->gb, 2) + 1) << 2;
|
|
|
|
// Number of mixing configurations
|
|
s->nmixoutconfigs = get_bits(&s->gb, 2) + 1;
|
|
|
|
// Speaker layout mask for mixer output channels
|
|
for (i = 0; i < s->nmixoutconfigs; i++)
|
|
s->nmixoutchs[i] = ff_dca_count_chs_for_mask(get_bits(&s->gb, spkr_mask_nbits));
|
|
}
|
|
} else {
|
|
s->npresents = 1;
|
|
s->nassets = 1;
|
|
}
|
|
|
|
// Size of encoded asset data in bytes
|
|
offset = header_size;
|
|
for (i = 0; i < s->nassets; i++) {
|
|
s->assets[i].asset_offset = offset;
|
|
s->assets[i].asset_size = get_bits(&s->gb, s->exss_size_nbits) + 1;
|
|
offset += s->assets[i].asset_size;
|
|
if (offset > s->exss_size) {
|
|
if (s->avctx)
|
|
av_log(s->avctx, AV_LOG_ERROR, "EXSS asset out of bounds\n");
|
|
return AVERROR_INVALIDDATA;
|
|
}
|
|
}
|
|
|
|
// Audio asset descriptor
|
|
for (i = 0; i < s->nassets; i++) {
|
|
if ((ret = parse_descriptor(s, &s->assets[i])) < 0)
|
|
return ret;
|
|
if ((ret = set_exss_offsets(&s->assets[i])) < 0) {
|
|
if (s->avctx)
|
|
av_log(s->avctx, AV_LOG_ERROR, "Invalid extension size in EXSS asset descriptor\n");
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
// Backward compatible core present
|
|
// Backward compatible core substream index
|
|
// Backward compatible core asset index
|
|
// Reserved
|
|
// Byte align
|
|
// CRC16 of extension substream header
|
|
if (ff_dca_seek_bits(&s->gb, header_size * 8)) {
|
|
if (s->avctx)
|
|
av_log(s->avctx, AV_LOG_ERROR, "Read past end of EXSS header\n");
|
|
return AVERROR_INVALIDDATA;
|
|
}
|
|
|
|
return 0;
|
|
}
|