2018-02-26 20:17:00 +01:00
|
|
|
/* -----------------------------------------------------------------------------
|
2012-07-11 19:15:24 +02:00
|
|
|
Software License for The Fraunhofer FDK AAC Codec Library for Android
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
© Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
|
|
|
|
Forschung e.V. All rights reserved.
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
1. INTRODUCTION
|
2018-02-26 20:17:00 +01:00
|
|
|
The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
|
|
|
|
that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
|
|
|
|
scheme for digital audio. This FDK AAC Codec software is intended to be used on
|
|
|
|
a wide variety of Android devices.
|
|
|
|
|
|
|
|
AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
|
|
|
|
general perceptual audio codecs. AAC-ELD is considered the best-performing
|
|
|
|
full-bandwidth communications codec by independent studies and is widely
|
|
|
|
deployed. AAC has been standardized by ISO and IEC as part of the MPEG
|
|
|
|
specifications.
|
|
|
|
|
|
|
|
Patent licenses for necessary patent claims for the FDK AAC Codec (including
|
|
|
|
those of Fraunhofer) may be obtained through Via Licensing
|
|
|
|
(www.vialicensing.com) or through the respective patent owners individually for
|
|
|
|
the purpose of encoding or decoding bit streams in products that are compliant
|
|
|
|
with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
|
|
|
|
Android devices already license these patent claims through Via Licensing or
|
|
|
|
directly from the patent owners, and therefore FDK AAC Codec software may
|
|
|
|
already be covered under those patent licenses when it is used for those
|
|
|
|
licensed purposes only.
|
|
|
|
|
|
|
|
Commercially-licensed AAC software libraries, including floating-point versions
|
|
|
|
with enhanced sound quality, are also available from Fraunhofer. Users are
|
|
|
|
encouraged to check the Fraunhofer website for additional applications
|
|
|
|
information and documentation.
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
2. COPYRIGHT LICENSE
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
|
|
are permitted without payment of copyright license fees provided that you
|
|
|
|
satisfy the following conditions:
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
You must retain the complete text of this software license in redistributions of
|
|
|
|
the FDK AAC Codec or your modifications thereto in source code form.
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
You must retain the complete text of this software license in the documentation
|
|
|
|
and/or other materials provided with redistributions of the FDK AAC Codec or
|
|
|
|
your modifications thereto in binary form. You must make available free of
|
|
|
|
charge copies of the complete source code of the FDK AAC Codec and your
|
2012-07-11 19:15:24 +02:00
|
|
|
modifications thereto to recipients of copies in binary form.
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
The name of Fraunhofer may not be used to endorse or promote products derived
|
|
|
|
from this library without prior written permission.
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
You may not charge copyright license fees for anyone to use, copy or distribute
|
|
|
|
the FDK AAC Codec software or your modifications thereto.
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
Your modified versions of the FDK AAC Codec must carry prominent notices stating
|
|
|
|
that you changed the software and the date of any change. For modified versions
|
|
|
|
of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
|
|
|
|
must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
|
|
|
|
AAC Codec Library for Android."
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
3. NO PATENT LICENSE
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
|
|
|
|
limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
|
|
|
|
Fraunhofer provides no warranty of patent non-infringement with respect to this
|
|
|
|
software.
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
You may use this FDK AAC Codec software or modifications thereto only for
|
|
|
|
purposes that are authorized by appropriate patent licenses.
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
4. DISCLAIMER
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
|
|
|
|
holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
|
|
including but not limited to the implied warranties of merchantability and
|
|
|
|
fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
|
|
CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
|
|
|
|
or consequential damages, including but not limited to procurement of substitute
|
|
|
|
goods or services; loss of use, data, or profits, or business interruption,
|
|
|
|
however caused and on any theory of liability, whether in contract, strict
|
|
|
|
liability, or tort (including negligence), arising in any way out of the use of
|
|
|
|
this software, even if advised of the possibility of such damage.
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
5. CONTACT INFORMATION
|
|
|
|
|
|
|
|
Fraunhofer Institute for Integrated Circuits IIS
|
|
|
|
Attention: Audio and Multimedia Departments - FDK AAC LL
|
|
|
|
Am Wolfsmantel 33
|
|
|
|
91058 Erlangen, Germany
|
|
|
|
|
|
|
|
www.iis.fraunhofer.de/amm
|
|
|
|
amm-info@iis.fraunhofer.de
|
2018-02-26 20:17:00 +01:00
|
|
|
----------------------------------------------------------------------------- */
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
/**************************** AAC encoder library ******************************
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
Author(s): V. Bacigalupo
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
Description: Metadata Encoder library interface functions
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
*******************************************************************************/
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
#include "metadata_main.h"
|
|
|
|
#include "metadata_compressor.h"
|
|
|
|
#include "FDK_bitstream.h"
|
|
|
|
#include "FDK_audio.h"
|
|
|
|
#include "genericStds.h"
|
|
|
|
|
|
|
|
/*----------------- defines ----------------------*/
|
2018-02-26 20:17:00 +01:00
|
|
|
#define MAX_DRC_BANDS (1 << 4)
|
|
|
|
#define MAX_DRC_FRAMELEN (2 * 1024)
|
|
|
|
#define MAX_DELAY_FRAMES (3)
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
/*--------------- structure definitions --------------------*/
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
typedef struct AAC_METADATA {
|
2012-07-11 19:15:24 +02:00
|
|
|
/* MPEG: Dynamic Range Control */
|
|
|
|
struct {
|
2018-02-26 20:17:00 +01:00
|
|
|
UCHAR prog_ref_level_present;
|
|
|
|
SCHAR prog_ref_level;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
UCHAR dyn_rng_sgn[MAX_DRC_BANDS];
|
|
|
|
UCHAR dyn_rng_ctl[MAX_DRC_BANDS];
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
UCHAR drc_bands_present;
|
|
|
|
UCHAR drc_band_incr;
|
|
|
|
UCHAR drc_band_top[MAX_DRC_BANDS];
|
|
|
|
UCHAR drc_interpolation_scheme;
|
|
|
|
AACENC_METADATA_DRC_PROFILE drc_profile;
|
|
|
|
INT drc_TargetRefLevel; /* used for Limiter */
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
/* excluded channels */
|
2018-02-26 20:17:00 +01:00
|
|
|
UCHAR excluded_chns_present;
|
|
|
|
UCHAR exclude_mask[2]; /* MAX_NUMBER_CHANNELS/8 */
|
2012-07-11 19:15:24 +02:00
|
|
|
} mpegDrc;
|
|
|
|
|
|
|
|
/* ETSI: addtl ancillary data */
|
|
|
|
struct {
|
|
|
|
/* Heavy Compression */
|
2018-02-26 20:17:00 +01:00
|
|
|
UCHAR compression_on; /* flag, if compression value should be written */
|
|
|
|
UCHAR compression_value; /* compression value */
|
|
|
|
AACENC_METADATA_DRC_PROFILE comp_profile;
|
|
|
|
INT comp_TargetRefLevel; /* used for Limiter */
|
|
|
|
INT timecode_coarse_status;
|
|
|
|
INT timecode_fine_status;
|
|
|
|
|
|
|
|
UCHAR extAncDataStatus;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
UCHAR ext_downmix_lvl_status;
|
|
|
|
UCHAR ext_downmix_gain_status;
|
|
|
|
UCHAR ext_lfe_downmix_status;
|
|
|
|
UCHAR
|
|
|
|
ext_dmix_a_idx; /* extended downmix level (0..7, according to table)
|
|
|
|
*/
|
|
|
|
UCHAR
|
|
|
|
ext_dmix_b_idx; /* extended downmix level (0..7, according to table)
|
|
|
|
*/
|
|
|
|
UCHAR dmx_gain_5_sgn;
|
|
|
|
UCHAR dmx_gain_5_idx;
|
|
|
|
UCHAR dmx_gain_2_sgn;
|
|
|
|
UCHAR dmx_gain_2_idx;
|
|
|
|
UCHAR ext_dmix_lfe_idx; /* extended downmix level for lfe (0..15,
|
|
|
|
according to table) */
|
|
|
|
|
|
|
|
} extAncData;
|
|
|
|
|
2012-07-11 19:15:24 +02:00
|
|
|
} etsiAncData;
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
SCHAR centerMixLevel; /* center downmix level (0...7, according to table) */
|
|
|
|
SCHAR
|
|
|
|
surroundMixLevel; /* surround downmix level (0...7, according to table) */
|
|
|
|
UCHAR WritePCEMixDwnIdx; /* flag */
|
|
|
|
UCHAR DmxLvl_On; /* flag */
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
UCHAR dolbySurroundMode;
|
|
|
|
UCHAR drcPresentationMode;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
UCHAR
|
|
|
|
metadataMode; /* indicate meta data mode in current frame (delay line) */
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
} AAC_METADATA;
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
typedef struct FDK_METADATA_ENCODER {
|
|
|
|
INT metadataMode;
|
|
|
|
HDRC_COMP hDrcComp;
|
|
|
|
AACENC_MetaData submittedMetaData;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
INT nAudioDataDelay; /* Additional delay to round up to next frame border (in
|
|
|
|
samples) */
|
|
|
|
INT nMetaDataDelay; /* Meta data delay (in frames) */
|
|
|
|
INT nChannels;
|
|
|
|
CHANNEL_MODE channelMode;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
INT_PCM* pAudioDelayBuffer;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
AAC_METADATA metaDataBuffer[MAX_DELAY_FRAMES];
|
|
|
|
INT metaDataDelayIdx;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
UCHAR drcInfoPayload[12];
|
|
|
|
UCHAR drcDsePayload[8];
|
|
|
|
|
|
|
|
INT matrix_mixdown_idx;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
AACENC_EXT_PAYLOAD exPayload[2];
|
2018-02-26 20:17:00 +01:00
|
|
|
INT nExtensions;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
UINT maxChannels; /* Maximum number of audio channels to be supported. */
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
INT finalizeMetaData; /* Delay switch off by one frame and write default
|
|
|
|
configuration to finalize the metadata setup. */
|
|
|
|
INT initializeMetaData; /* Fill up delay line with first meta data info. This
|
|
|
|
is required to have meta data already in first
|
|
|
|
frame. */
|
|
|
|
} FDK_METADATA_ENCODER;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
/*---------------- constants -----------------------*/
|
|
|
|
static const AACENC_MetaData defaultMetaDataSetup = {
|
2018-02-26 20:17:00 +01:00
|
|
|
AACENC_METADATA_DRC_NONE, /* drc_profile */
|
|
|
|
AACENC_METADATA_DRC_NOT_PRESENT, /* comp_profile */
|
|
|
|
-(31 << 16), /* drc_TargetRefLevel */
|
|
|
|
-(23 << 16), /* comp_TargetRefLevel */
|
|
|
|
0, /* prog_ref_level_present */
|
|
|
|
-(23 << 16), /* prog_ref_level */
|
|
|
|
0, /* PCE_mixdown_idx_present */
|
|
|
|
0, /* ETSI_DmxLvl_present */
|
|
|
|
0, /* centerMixLevel */
|
|
|
|
0, /* surroundMixLevel */
|
|
|
|
0, /* dolbySurroundMode */
|
|
|
|
0, /* drcPresentationMode */
|
|
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0} /* ExtMetaData */
|
2012-07-11 19:15:24 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static const FIXP_DBL dmxTable[8] = {
|
2018-02-26 20:17:00 +01:00
|
|
|
((FIXP_DBL)MAXVAL_DBL), FL2FXCONST_DBL(0.841f), FL2FXCONST_DBL(0.707f),
|
|
|
|
FL2FXCONST_DBL(0.596f), FL2FXCONST_DBL(0.500f), FL2FXCONST_DBL(0.422f),
|
|
|
|
FL2FXCONST_DBL(0.355f), FL2FXCONST_DBL(0.000f)};
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
#define FL2DMXLFE(a) FL2FXCONST_DBL((a) / (1 << LFE_LEV_SCALE))
|
|
|
|
static const FIXP_DBL dmxLfeTable[16] = {
|
|
|
|
FL2DMXLFE(3.162f), FL2DMXLFE(2.000f), FL2DMXLFE(1.679f), FL2DMXLFE(1.413f),
|
|
|
|
FL2DMXLFE(1.189f), FL2DMXLFE(1.000f), FL2DMXLFE(0.841f), FL2DMXLFE(0.707f),
|
|
|
|
FL2DMXLFE(0.596f), FL2DMXLFE(0.500f), FL2DMXLFE(0.316f), FL2DMXLFE(0.178f),
|
|
|
|
FL2DMXLFE(0.100f), FL2DMXLFE(0.032f), FL2DMXLFE(0.010f), FL2DMXLFE(0.000f)};
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
static const UCHAR surmix2matrix_mixdown_idx[8] = {0, 0, 0, 1, 1, 2, 2, 3};
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
/*--------------- function declarations --------------------*/
|
|
|
|
static FDK_METADATA_ERROR WriteMetadataPayload(
|
2018-02-26 20:17:00 +01:00
|
|
|
const HANDLE_FDK_METADATA_ENCODER hMetaData,
|
|
|
|
const AAC_METADATA* const pMetadata);
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
static INT WriteDynamicRangeInfoPayload(const AAC_METADATA* const pMetadata,
|
|
|
|
UCHAR* const pExtensionPayload);
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
static INT WriteEtsiAncillaryDataPayload(const AAC_METADATA* const pMetadata,
|
|
|
|
UCHAR* const pExtensionPayload);
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
static FDK_METADATA_ERROR CompensateAudioDelay(
|
2018-02-26 20:17:00 +01:00
|
|
|
HANDLE_FDK_METADATA_ENCODER hMetaDataEnc, INT_PCM* const pAudioSamples,
|
|
|
|
const UINT audioSamplesBufSize, const INT nAudioSamples);
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
static FDK_METADATA_ERROR LoadSubmittedMetadata(
|
2018-02-26 20:17:00 +01:00
|
|
|
const AACENC_MetaData* const hMetadata, const INT nChannels,
|
|
|
|
const INT metadataMode, AAC_METADATA* const pAacMetaData);
|
|
|
|
|
|
|
|
static FDK_METADATA_ERROR ProcessCompressor(AAC_METADATA* pMetadata,
|
|
|
|
HDRC_COMP hDrcComp,
|
|
|
|
const INT_PCM* const pSamples,
|
|
|
|
const UINT samplesBufSize,
|
|
|
|
const INT nSamples);
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
/*------------- function definitions ----------------*/
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
static DRC_PROFILE convertProfile(AACENC_METADATA_DRC_PROFILE aacProfile) {
|
|
|
|
DRC_PROFILE drcProfile = DRC_NONE;
|
|
|
|
|
|
|
|
switch (aacProfile) {
|
|
|
|
case AACENC_METADATA_DRC_NONE:
|
|
|
|
drcProfile = DRC_NONE;
|
|
|
|
break;
|
|
|
|
case AACENC_METADATA_DRC_FILMSTANDARD:
|
|
|
|
drcProfile = DRC_FILMSTANDARD;
|
|
|
|
break;
|
|
|
|
case AACENC_METADATA_DRC_FILMLIGHT:
|
|
|
|
drcProfile = DRC_FILMLIGHT;
|
|
|
|
break;
|
|
|
|
case AACENC_METADATA_DRC_MUSICSTANDARD:
|
|
|
|
drcProfile = DRC_MUSICSTANDARD;
|
|
|
|
break;
|
|
|
|
case AACENC_METADATA_DRC_MUSICLIGHT:
|
|
|
|
drcProfile = DRC_MUSICLIGHT;
|
|
|
|
break;
|
|
|
|
case AACENC_METADATA_DRC_SPEECH:
|
|
|
|
drcProfile = DRC_SPEECH;
|
|
|
|
break;
|
|
|
|
case AACENC_METADATA_DRC_NOT_PRESENT:
|
|
|
|
drcProfile = DRC_NOT_PRESENT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
drcProfile = DRC_NONE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return drcProfile;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* convert dialog normalization to program reference level */
|
2018-02-26 20:17:00 +01:00
|
|
|
/* NOTE: this only is correct, if the decoder target level is set to -31dB for
|
|
|
|
* line mode / -20dB for RF mode */
|
|
|
|
static UCHAR dialnorm2progreflvl(const INT d) {
|
|
|
|
return ((UCHAR)fMax(0, fMin((-d + (1 << 13)) >> 14, 127)));
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* convert program reference level to dialog normalization */
|
2018-02-26 20:17:00 +01:00
|
|
|
static INT progreflvl2dialnorm(const UCHAR p) {
|
|
|
|
return -((INT)(p << (16 - 2)));
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* encode downmix levels to Downmixing_levels_MPEG4 */
|
2018-02-26 20:17:00 +01:00
|
|
|
static SCHAR encodeDmxLvls(const SCHAR cmixlev, const SCHAR surmixlev) {
|
|
|
|
SCHAR dmxLvls = 0;
|
|
|
|
dmxLvls |= 0x80 | (cmixlev << 4); /* center_mix_level_on */
|
|
|
|
dmxLvls |= 0x08 | surmixlev; /* surround_mix_level_on */
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
return dmxLvls;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* encode AAC DRC gain (ISO/IEC 14496-3:2005 4.5.2.7) */
|
2018-02-26 20:17:00 +01:00
|
|
|
static void encodeDynrng(INT gain, UCHAR* const dyn_rng_ctl,
|
|
|
|
UCHAR* const dyn_rng_sgn) {
|
|
|
|
if (gain < 0) {
|
|
|
|
*dyn_rng_sgn = 1;
|
|
|
|
gain = -gain;
|
|
|
|
} else {
|
|
|
|
*dyn_rng_sgn = 0;
|
|
|
|
}
|
|
|
|
gain = fMin(gain, (127 << 14));
|
|
|
|
|
|
|
|
*dyn_rng_ctl = (UCHAR)((gain + (1 << 13)) >> 14);
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* decode AAC DRC gain (ISO/IEC 14496-3:2005 4.5.2.7) */
|
2018-02-26 20:17:00 +01:00
|
|
|
static INT decodeDynrng(const UCHAR dyn_rng_ctl, const UCHAR dyn_rng_sgn) {
|
|
|
|
INT tmp = ((INT)dyn_rng_ctl << (16 - 2));
|
|
|
|
if (dyn_rng_sgn) tmp = -tmp;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
return tmp;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* encode AAC compression value (ETSI TS 101 154 page 99) */
|
2018-02-26 20:17:00 +01:00
|
|
|
static UCHAR encodeCompr(INT gain) {
|
|
|
|
UCHAR x, y;
|
|
|
|
INT tmp;
|
|
|
|
|
|
|
|
/* tmp = (int)((48.164f - gain) / 6.0206f * 15 + 0.5f); */
|
|
|
|
tmp = ((3156476 - gain) * 15 + 197283) / 394566;
|
|
|
|
|
|
|
|
if (tmp >= 240) {
|
|
|
|
return 0xFF;
|
|
|
|
} else if (tmp < 0) {
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
x = tmp / 15;
|
|
|
|
y = tmp % 15;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (x << 4) | y;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* decode AAC compression value (ETSI TS 101 154 page 99) */
|
2018-02-26 20:17:00 +01:00
|
|
|
static INT decodeCompr(const UCHAR compr) {
|
|
|
|
INT gain;
|
|
|
|
SCHAR x = compr >> 4; /* 4 MSB of compr */
|
|
|
|
UCHAR y = (compr & 0x0F); /* 4 LSB of compr */
|
|
|
|
|
|
|
|
/* gain = (INT)((48.164f - 6.0206f * x - 0.4014f * y) ); */
|
|
|
|
gain = (INT)(
|
|
|
|
scaleValue((FIXP_DBL)(((LONG)FL2FXCONST_DBL(6.0206f / 128.f) * (8 - x) -
|
|
|
|
(LONG)FL2FXCONST_DBL(0.4014f / 128.f) * y)),
|
|
|
|
-(DFRACT_BITS - 1 - 7 - 16)));
|
|
|
|
|
|
|
|
return gain;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
FDK_METADATA_ERROR FDK_MetadataEnc_Open(HANDLE_FDK_METADATA_ENCODER* phMetaData,
|
|
|
|
const UINT maxChannels) {
|
|
|
|
FDK_METADATA_ERROR err = METADATA_OK;
|
|
|
|
HANDLE_FDK_METADATA_ENCODER hMetaData = NULL;
|
|
|
|
|
|
|
|
if (phMetaData == NULL) {
|
|
|
|
err = METADATA_INVALID_HANDLE;
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allocate memory */
|
|
|
|
if (NULL == (hMetaData = (HANDLE_FDK_METADATA_ENCODER)FDKcalloc(
|
|
|
|
1, sizeof(FDK_METADATA_ENCODER)))) {
|
|
|
|
err = METADATA_MEMORY_ERROR;
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
FDKmemclear(hMetaData, sizeof(FDK_METADATA_ENCODER));
|
|
|
|
|
|
|
|
if (NULL == (hMetaData->pAudioDelayBuffer = (INT_PCM*)FDKcalloc(
|
|
|
|
maxChannels * MAX_DRC_FRAMELEN, sizeof(INT_PCM)))) {
|
|
|
|
err = METADATA_MEMORY_ERROR;
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
FDKmemclear(hMetaData->pAudioDelayBuffer,
|
|
|
|
maxChannels * MAX_DRC_FRAMELEN * sizeof(INT_PCM));
|
|
|
|
hMetaData->maxChannels = maxChannels;
|
|
|
|
|
|
|
|
/* Allocate DRC Compressor. */
|
|
|
|
if (FDK_DRC_Generator_Open(&hMetaData->hDrcComp) != 0) {
|
|
|
|
err = METADATA_MEMORY_ERROR;
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
hMetaData->channelMode = MODE_UNKNOWN;
|
|
|
|
|
|
|
|
/* Return metadata instance */
|
|
|
|
*phMetaData = hMetaData;
|
|
|
|
|
|
|
|
return err;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
bail:
|
2018-02-26 20:17:00 +01:00
|
|
|
FDK_MetadataEnc_Close(&hMetaData);
|
|
|
|
return err;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
FDK_METADATA_ERROR FDK_MetadataEnc_Close(
|
2018-02-26 20:17:00 +01:00
|
|
|
HANDLE_FDK_METADATA_ENCODER* phMetaData) {
|
|
|
|
FDK_METADATA_ERROR err = METADATA_OK;
|
|
|
|
|
|
|
|
if (phMetaData == NULL) {
|
|
|
|
err = METADATA_INVALID_HANDLE;
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*phMetaData != NULL) {
|
|
|
|
FDK_DRC_Generator_Close(&(*phMetaData)->hDrcComp);
|
|
|
|
FDKfree((*phMetaData)->pAudioDelayBuffer);
|
|
|
|
FDKfree(*phMetaData);
|
|
|
|
*phMetaData = NULL;
|
|
|
|
}
|
2012-07-11 19:15:24 +02:00
|
|
|
bail:
|
2018-02-26 20:17:00 +01:00
|
|
|
return err;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
FDK_METADATA_ERROR FDK_MetadataEnc_Init(
|
2018-02-26 20:17:00 +01:00
|
|
|
HANDLE_FDK_METADATA_ENCODER hMetaData, const INT resetStates,
|
|
|
|
const INT metadataMode, const INT audioDelay, const UINT frameLength,
|
|
|
|
const UINT sampleRate, const UINT nChannels, const CHANNEL_MODE channelMode,
|
|
|
|
const CHANNEL_ORDER channelOrder) {
|
|
|
|
FDK_METADATA_ERROR err = METADATA_OK;
|
|
|
|
int i, nFrames, delay;
|
|
|
|
|
|
|
|
if (hMetaData == NULL) {
|
|
|
|
err = METADATA_INVALID_HANDLE;
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Determine values for delay compensation. */
|
|
|
|
for (nFrames = 0, delay = audioDelay - (INT)frameLength; delay > 0;
|
|
|
|
delay -= (INT)frameLength, nFrames++)
|
|
|
|
;
|
|
|
|
|
|
|
|
if ((nChannels > (8)) || (nChannels > hMetaData->maxChannels) ||
|
|
|
|
((-delay) > MAX_DRC_FRAMELEN) || nFrames >= MAX_DELAY_FRAMES) {
|
|
|
|
err = METADATA_INIT_ERROR;
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize with default setup. */
|
|
|
|
FDKmemcpy(&hMetaData->submittedMetaData, &defaultMetaDataSetup,
|
|
|
|
sizeof(AACENC_MetaData));
|
|
|
|
|
|
|
|
hMetaData->finalizeMetaData =
|
|
|
|
0; /* finalize meta data only while on/off switching, else disabled */
|
|
|
|
hMetaData->initializeMetaData =
|
|
|
|
0; /* fill up meta data delay line only at a reset otherwise disabled */
|
|
|
|
|
|
|
|
/* Reset delay lines. */
|
|
|
|
if (resetStates || (hMetaData->nAudioDataDelay != -delay) ||
|
|
|
|
(hMetaData->channelMode != channelMode)) {
|
|
|
|
if (resetStates || (hMetaData->channelMode == MODE_UNKNOWN)) {
|
|
|
|
/* clear delay buffer */
|
|
|
|
FDKmemclear(hMetaData->pAudioDelayBuffer,
|
|
|
|
hMetaData->maxChannels * MAX_DRC_FRAMELEN * sizeof(INT_PCM));
|
|
|
|
} else {
|
|
|
|
/* if possible, keep static audio channels for seamless channel
|
|
|
|
* reconfiguration */
|
|
|
|
FDK_channelMapDescr mapDescrPrev, mapDescr;
|
|
|
|
int c, src[2] = {-1, -1}, dst[2] = {-1, -1};
|
|
|
|
|
|
|
|
FDK_chMapDescr_init(&mapDescrPrev, NULL, 0,
|
|
|
|
(channelOrder == CH_ORDER_MPEG) ? 1 : 0);
|
|
|
|
FDK_chMapDescr_init(&mapDescr, NULL, 0,
|
|
|
|
(channelOrder == CH_ORDER_MPEG) ? 1 : 0);
|
|
|
|
|
|
|
|
switch (channelMode) {
|
|
|
|
case MODE_1:
|
|
|
|
if ((INT)nChannels != 2) {
|
|
|
|
/* preserve center channel */
|
|
|
|
src[0] = FDK_chMapDescr_getMapValue(&mapDescrPrev, 0,
|
|
|
|
hMetaData->channelMode);
|
|
|
|
dst[0] = FDK_chMapDescr_getMapValue(&mapDescr, 0, channelMode);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case MODE_2:
|
|
|
|
case MODE_1_2:
|
|
|
|
case MODE_1_2_1:
|
|
|
|
case MODE_1_2_2:
|
|
|
|
case MODE_1_2_2_1:
|
|
|
|
if (hMetaData->nChannels >= 2) {
|
|
|
|
/* preserve left/right channel */
|
|
|
|
src[0] = FDK_chMapDescr_getMapValue(
|
|
|
|
&mapDescrPrev, ((hMetaData->channelMode == 2) ? 0 : 1),
|
|
|
|
hMetaData->channelMode);
|
|
|
|
src[1] = FDK_chMapDescr_getMapValue(
|
|
|
|
&mapDescrPrev, ((hMetaData->channelMode == 2) ? 1 : 2),
|
|
|
|
hMetaData->channelMode);
|
|
|
|
dst[0] = FDK_chMapDescr_getMapValue(
|
|
|
|
&mapDescr, ((channelMode == 2) ? 0 : 1), channelMode);
|
|
|
|
dst[1] = FDK_chMapDescr_getMapValue(
|
|
|
|
&mapDescr, ((channelMode == 2) ? 1 : 2), channelMode);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
2018-02-26 20:17:00 +01:00
|
|
|
C_ALLOC_SCRATCH_START(scratch_audioDelayBuffer, INT_PCM, (8));
|
|
|
|
FDKmemclear(scratch_audioDelayBuffer, (8) * sizeof(INT_PCM));
|
|
|
|
|
|
|
|
i = (hMetaData->nChannels > (INT)nChannels)
|
|
|
|
? 0
|
|
|
|
: hMetaData->nAudioDataDelay - 1;
|
|
|
|
do {
|
|
|
|
for (c = 0; c < 2; c++) {
|
|
|
|
if (src[c] != -1 && dst[c] != -1) {
|
|
|
|
scratch_audioDelayBuffer[dst[c]] =
|
|
|
|
hMetaData->pAudioDelayBuffer[i * hMetaData->nChannels + src[c]];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
FDKmemcpy(&hMetaData->pAudioDelayBuffer[i * nChannels],
|
|
|
|
scratch_audioDelayBuffer, nChannels * sizeof(INT_PCM));
|
|
|
|
i += (hMetaData->nChannels > (INT)nChannels) ? 1 : -1;
|
|
|
|
} while ((i < hMetaData->nAudioDataDelay) && (i >= 0));
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
C_ALLOC_SCRATCH_END(scratch_audioDelayBuffer, INT_PCM, (8));
|
|
|
|
}
|
|
|
|
FDKmemclear(hMetaData->metaDataBuffer, sizeof(hMetaData->metaDataBuffer));
|
|
|
|
hMetaData->metaDataDelayIdx = 0;
|
|
|
|
hMetaData->initializeMetaData =
|
|
|
|
1; /* fill up delay line with first meta data info */
|
|
|
|
} else {
|
|
|
|
/* Enable meta data. */
|
|
|
|
if ((hMetaData->metadataMode == 0) && (metadataMode != 0)) {
|
|
|
|
/* disable meta data in all delay lines */
|
|
|
|
for (i = 0;
|
|
|
|
i < (int)(sizeof(hMetaData->metaDataBuffer) / sizeof(AAC_METADATA));
|
|
|
|
i++) {
|
|
|
|
LoadSubmittedMetadata(&hMetaData->submittedMetaData, nChannels, 0,
|
|
|
|
&hMetaData->metaDataBuffer[i]);
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
/* Disable meta data.*/
|
|
|
|
if ((hMetaData->metadataMode != 0) && (metadataMode == 0)) {
|
|
|
|
hMetaData->finalizeMetaData = hMetaData->metadataMode;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize delay. */
|
|
|
|
hMetaData->nAudioDataDelay = -delay;
|
|
|
|
hMetaData->nMetaDataDelay = nFrames;
|
|
|
|
hMetaData->nChannels = nChannels;
|
|
|
|
hMetaData->channelMode = channelMode;
|
|
|
|
hMetaData->metadataMode = metadataMode;
|
|
|
|
|
|
|
|
/* Initialize compressor. */
|
|
|
|
if ((metadataMode == 1) || (metadataMode == 2)) {
|
|
|
|
if (FDK_DRC_Generator_Initialize(hMetaData->hDrcComp, DRC_NONE, DRC_NONE,
|
|
|
|
frameLength, sampleRate, channelMode,
|
|
|
|
channelOrder, 1) != 0) {
|
|
|
|
err = METADATA_INIT_ERROR;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
2018-02-26 20:17:00 +01:00
|
|
|
}
|
2012-07-11 19:15:24 +02:00
|
|
|
bail:
|
2018-02-26 20:17:00 +01:00
|
|
|
return err;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
static FDK_METADATA_ERROR ProcessCompressor(AAC_METADATA* pMetadata,
|
|
|
|
HDRC_COMP hDrcComp,
|
|
|
|
const INT_PCM* const pSamples,
|
|
|
|
const UINT samplesBufSize,
|
|
|
|
const INT nSamples) {
|
|
|
|
FDK_METADATA_ERROR err = METADATA_OK;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
INT dynrng, compr;
|
|
|
|
INT dmxGain5, dmxGain2;
|
|
|
|
DRC_PROFILE profileDrc;
|
|
|
|
DRC_PROFILE profileComp;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
if ((pMetadata == NULL) || (hDrcComp == NULL)) {
|
|
|
|
err = METADATA_INVALID_HANDLE;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
profileDrc = convertProfile(pMetadata->mpegDrc.drc_profile);
|
|
|
|
profileComp = convertProfile(pMetadata->etsiAncData.comp_profile);
|
|
|
|
|
|
|
|
/* first, check if profile is same as last frame
|
|
|
|
* otherwise, update setup */
|
|
|
|
if ((profileDrc != FDK_DRC_Generator_getDrcProfile(hDrcComp)) ||
|
|
|
|
(profileComp != FDK_DRC_Generator_getCompProfile(hDrcComp))) {
|
|
|
|
FDK_DRC_Generator_setDrcProfile(hDrcComp, profileDrc, profileComp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if (profileComp == DRC_NONE) {
|
|
|
|
pMetadata->etsiAncData.compression_value = 0x80; /* to ensure no external
|
|
|
|
values will be written
|
|
|
|
if not configured */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* in case of embedding external values, copy this now (limiter may overwrite
|
|
|
|
* them) */
|
|
|
|
dynrng = decodeDynrng(pMetadata->mpegDrc.dyn_rng_ctl[0],
|
|
|
|
pMetadata->mpegDrc.dyn_rng_sgn[0]);
|
|
|
|
compr = decodeCompr(pMetadata->etsiAncData.compression_value);
|
|
|
|
|
|
|
|
dmxGain5 = decodeDynrng(pMetadata->etsiAncData.extAncData.dmx_gain_5_idx,
|
|
|
|
pMetadata->etsiAncData.extAncData.dmx_gain_5_sgn);
|
|
|
|
dmxGain2 = decodeDynrng(pMetadata->etsiAncData.extAncData.dmx_gain_2_idx,
|
|
|
|
pMetadata->etsiAncData.extAncData.dmx_gain_2_sgn);
|
|
|
|
|
|
|
|
/* Call compressor */
|
|
|
|
if (FDK_DRC_Generator_Calc(
|
|
|
|
hDrcComp, pSamples, samplesBufSize,
|
|
|
|
progreflvl2dialnorm(pMetadata->mpegDrc.prog_ref_level),
|
|
|
|
pMetadata->mpegDrc.drc_TargetRefLevel,
|
|
|
|
pMetadata->etsiAncData.comp_TargetRefLevel,
|
|
|
|
dmxTable[pMetadata->centerMixLevel],
|
|
|
|
dmxTable[pMetadata->surroundMixLevel],
|
|
|
|
dmxTable[pMetadata->etsiAncData.extAncData.ext_dmix_a_idx],
|
|
|
|
dmxTable[pMetadata->etsiAncData.extAncData.ext_dmix_b_idx],
|
|
|
|
pMetadata->etsiAncData.extAncData.ext_lfe_downmix_status
|
|
|
|
? dmxLfeTable[pMetadata->etsiAncData.extAncData.ext_dmix_lfe_idx]
|
|
|
|
: (FIXP_DBL)0,
|
|
|
|
dmxGain5, dmxGain2, &dynrng, &compr) != 0) {
|
|
|
|
err = METADATA_ENCODE_ERROR;
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write DRC values */
|
|
|
|
pMetadata->mpegDrc.drc_band_incr = 0;
|
|
|
|
encodeDynrng(dynrng, pMetadata->mpegDrc.dyn_rng_ctl,
|
|
|
|
pMetadata->mpegDrc.dyn_rng_sgn);
|
|
|
|
pMetadata->etsiAncData.compression_value = encodeCompr(compr);
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
bail:
|
2018-02-26 20:17:00 +01:00
|
|
|
return err;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
FDK_METADATA_ERROR FDK_MetadataEnc_Process(
|
2018-02-26 20:17:00 +01:00
|
|
|
HANDLE_FDK_METADATA_ENCODER hMetaDataEnc, INT_PCM* const pAudioSamples,
|
|
|
|
const UINT audioSamplesBufSize, const INT nAudioSamples,
|
|
|
|
const AACENC_MetaData* const pMetadata,
|
|
|
|
AACENC_EXT_PAYLOAD** ppMetaDataExtPayload, UINT* nMetaDataExtensions,
|
|
|
|
INT* matrix_mixdown_idx) {
|
|
|
|
FDK_METADATA_ERROR err = METADATA_OK;
|
|
|
|
int metaDataDelayWriteIdx, metaDataDelayReadIdx, metadataMode;
|
|
|
|
|
|
|
|
/* Where to write new meta data info */
|
|
|
|
metaDataDelayWriteIdx = hMetaDataEnc->metaDataDelayIdx;
|
|
|
|
|
|
|
|
/* How to write the data */
|
|
|
|
metadataMode = hMetaDataEnc->metadataMode;
|
|
|
|
|
|
|
|
/* Compensate meta data delay. */
|
|
|
|
hMetaDataEnc->metaDataDelayIdx++;
|
|
|
|
if (hMetaDataEnc->metaDataDelayIdx > hMetaDataEnc->nMetaDataDelay)
|
|
|
|
hMetaDataEnc->metaDataDelayIdx = 0;
|
|
|
|
|
|
|
|
/* Where to read pending meta data info from. */
|
|
|
|
metaDataDelayReadIdx = hMetaDataEnc->metaDataDelayIdx;
|
|
|
|
|
|
|
|
/* Submit new data if available. */
|
|
|
|
if (pMetadata != NULL) {
|
|
|
|
FDKmemcpy(&hMetaDataEnc->submittedMetaData, pMetadata,
|
|
|
|
sizeof(AACENC_MetaData));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write one additional frame with default configuration of meta data. Ensure
|
|
|
|
* defined behaviour on decoder side. */
|
|
|
|
if ((hMetaDataEnc->finalizeMetaData != 0) &&
|
|
|
|
(hMetaDataEnc->metadataMode == 0)) {
|
|
|
|
FDKmemcpy(&hMetaDataEnc->submittedMetaData, &defaultMetaDataSetup,
|
|
|
|
sizeof(AACENC_MetaData));
|
|
|
|
metadataMode = hMetaDataEnc->finalizeMetaData;
|
|
|
|
hMetaDataEnc->finalizeMetaData = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get last submitted data. */
|
|
|
|
if ((err = LoadSubmittedMetadata(
|
|
|
|
&hMetaDataEnc->submittedMetaData, hMetaDataEnc->nChannels,
|
|
|
|
metadataMode,
|
|
|
|
&hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx])) !=
|
|
|
|
METADATA_OK) {
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Calculate compressor if necessary and updata meta data info */
|
|
|
|
if ((hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx].metadataMode == 1) ||
|
|
|
|
(hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx].metadataMode == 2)) {
|
|
|
|
if ((err = ProcessCompressor(
|
|
|
|
&hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx],
|
|
|
|
hMetaDataEnc->hDrcComp, pAudioSamples, audioSamplesBufSize,
|
|
|
|
nAudioSamples)) != METADATA_OK) {
|
|
|
|
/* Get last submitted data again. */
|
|
|
|
LoadSubmittedMetadata(
|
|
|
|
&hMetaDataEnc->submittedMetaData, hMetaDataEnc->nChannels,
|
|
|
|
metadataMode, &hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx]);
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
2018-02-26 20:17:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill up delay line with initial meta data info.*/
|
|
|
|
if ((hMetaDataEnc->initializeMetaData != 0) &&
|
|
|
|
(hMetaDataEnc->metadataMode != 0)) {
|
|
|
|
int i;
|
|
|
|
for (i = 0;
|
|
|
|
i < (int)(sizeof(hMetaDataEnc->metaDataBuffer) / sizeof(AAC_METADATA));
|
|
|
|
i++) {
|
|
|
|
if (i != metaDataDelayWriteIdx) {
|
|
|
|
FDKmemcpy(&hMetaDataEnc->metaDataBuffer[i],
|
|
|
|
&hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx],
|
|
|
|
sizeof(hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx]));
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
}
|
2018-02-26 20:17:00 +01:00
|
|
|
hMetaDataEnc->initializeMetaData = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert Meta Data side info to bitstream data. */
|
|
|
|
FDK_ASSERT(metaDataDelayReadIdx < MAX_DELAY_FRAMES);
|
|
|
|
if ((err = WriteMetadataPayload(
|
|
|
|
hMetaDataEnc,
|
|
|
|
&hMetaDataEnc->metaDataBuffer[metaDataDelayReadIdx])) !=
|
|
|
|
METADATA_OK) {
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Assign meta data to output */
|
|
|
|
*ppMetaDataExtPayload = hMetaDataEnc->exPayload;
|
|
|
|
*nMetaDataExtensions = hMetaDataEnc->nExtensions;
|
|
|
|
*matrix_mixdown_idx = hMetaDataEnc->matrix_mixdown_idx;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
bail:
|
2018-02-26 20:17:00 +01:00
|
|
|
/* Compensate audio delay, reset err status. */
|
|
|
|
err = CompensateAudioDelay(hMetaDataEnc, pAudioSamples, audioSamplesBufSize,
|
|
|
|
nAudioSamples / hMetaDataEnc->nChannels);
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
return err;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static FDK_METADATA_ERROR CompensateAudioDelay(
|
2018-02-26 20:17:00 +01:00
|
|
|
HANDLE_FDK_METADATA_ENCODER hMetaDataEnc, INT_PCM* const pAudioSamples,
|
|
|
|
const UINT audioSamplesBufSize, const INT nAudioSamples) {
|
|
|
|
FDK_METADATA_ERROR err = METADATA_OK;
|
|
|
|
|
|
|
|
if (hMetaDataEnc->nAudioDataDelay) {
|
|
|
|
C_ALLOC_SCRATCH_START(scratch_audioDelayBuffer, INT_PCM, 1024);
|
|
|
|
|
|
|
|
for (int c = 0; c < hMetaDataEnc->nChannels; c++) {
|
|
|
|
int M = 1024;
|
|
|
|
INT_PCM* pAudioSamples2 = pAudioSamples + c * audioSamplesBufSize;
|
|
|
|
int delayIdx = hMetaDataEnc->nAudioDataDelay;
|
|
|
|
|
|
|
|
do {
|
|
|
|
M = fMin(M, delayIdx);
|
|
|
|
delayIdx -= M;
|
|
|
|
|
|
|
|
FDKmemcpy(&scratch_audioDelayBuffer[0],
|
|
|
|
&pAudioSamples2[(nAudioSamples - M)], sizeof(INT_PCM) * M);
|
|
|
|
FDKmemmove(&pAudioSamples2[M], &pAudioSamples2[0],
|
|
|
|
sizeof(INT_PCM) * (nAudioSamples - M));
|
|
|
|
FDKmemcpy(
|
|
|
|
&pAudioSamples2[0],
|
|
|
|
&hMetaDataEnc->pAudioDelayBuffer[delayIdx +
|
|
|
|
c * hMetaDataEnc->nAudioDataDelay],
|
|
|
|
sizeof(INT_PCM) * M);
|
|
|
|
FDKmemcpy(
|
|
|
|
&hMetaDataEnc->pAudioDelayBuffer[delayIdx +
|
|
|
|
c * hMetaDataEnc->nAudioDataDelay],
|
|
|
|
&scratch_audioDelayBuffer[0], sizeof(INT_PCM) * M);
|
|
|
|
|
|
|
|
} while (delayIdx > 0);
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
C_ALLOC_SCRATCH_END(scratch_audioDelayBuffer, INT_PCM, 1024);
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
functionname: WriteMetadataPayload
|
|
|
|
description: fills anc data and extension payload
|
|
|
|
returns: Error status
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
|
|
static FDK_METADATA_ERROR WriteMetadataPayload(
|
2018-02-26 20:17:00 +01:00
|
|
|
const HANDLE_FDK_METADATA_ENCODER hMetaData,
|
|
|
|
const AAC_METADATA* const pMetadata) {
|
|
|
|
FDK_METADATA_ERROR err = METADATA_OK;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
if ((hMetaData == NULL) || (pMetadata == NULL)) {
|
|
|
|
err = METADATA_INVALID_HANDLE;
|
|
|
|
goto bail;
|
|
|
|
}
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
hMetaData->nExtensions = 0;
|
|
|
|
hMetaData->matrix_mixdown_idx = -1;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
if (pMetadata->metadataMode != 0) {
|
|
|
|
/* AAC-DRC */
|
|
|
|
if ((pMetadata->metadataMode == 1) || (pMetadata->metadataMode == 2)) {
|
|
|
|
hMetaData->exPayload[hMetaData->nExtensions].pData =
|
|
|
|
hMetaData->drcInfoPayload;
|
|
|
|
hMetaData->exPayload[hMetaData->nExtensions].dataType = EXT_DYNAMIC_RANGE;
|
|
|
|
hMetaData->exPayload[hMetaData->nExtensions].associatedChElement = -1;
|
|
|
|
|
|
|
|
hMetaData->exPayload[hMetaData->nExtensions].dataSize =
|
|
|
|
WriteDynamicRangeInfoPayload(
|
|
|
|
pMetadata, hMetaData->exPayload[hMetaData->nExtensions].pData);
|
|
|
|
|
|
|
|
hMetaData->nExtensions++;
|
|
|
|
} /* pMetadata->metadataMode==1 || pMetadata->metadataMode==2 */
|
|
|
|
|
|
|
|
/* Matrix Mixdown Coefficient in PCE */
|
|
|
|
if (pMetadata->WritePCEMixDwnIdx) {
|
|
|
|
hMetaData->matrix_mixdown_idx =
|
|
|
|
surmix2matrix_mixdown_idx[pMetadata->surroundMixLevel];
|
|
|
|
}
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
/* ETSI TS 101 154 (DVB) - MPEG4 ancillary_data() */
|
|
|
|
if ((pMetadata->metadataMode == 2) ||
|
|
|
|
(pMetadata->metadataMode == 3)) /* MP4_METADATA_MPEG_ETSI */
|
|
|
|
{
|
|
|
|
hMetaData->exPayload[hMetaData->nExtensions].pData =
|
|
|
|
hMetaData->drcDsePayload;
|
|
|
|
hMetaData->exPayload[hMetaData->nExtensions].dataType = EXT_DATA_ELEMENT;
|
|
|
|
hMetaData->exPayload[hMetaData->nExtensions].associatedChElement = -1;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
hMetaData->exPayload[hMetaData->nExtensions].dataSize =
|
|
|
|
WriteEtsiAncillaryDataPayload(
|
|
|
|
pMetadata, hMetaData->exPayload[hMetaData->nExtensions].pData);
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
hMetaData->nExtensions++;
|
|
|
|
} /* metadataMode==2 || metadataMode==3 */
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
} /* metadataMode != 0 */
|
2012-07-11 19:15:24 +02:00
|
|
|
|
|
|
|
bail:
|
2018-02-26 20:17:00 +01:00
|
|
|
return err;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
static INT WriteDynamicRangeInfoPayload(const AAC_METADATA* const pMetadata,
|
|
|
|
UCHAR* const pExtensionPayload) {
|
|
|
|
const INT pce_tag_present = 0; /* yet fixed setting! */
|
|
|
|
const INT prog_ref_lev_res_bits = 0;
|
|
|
|
INT i, drc_num_bands = 1;
|
|
|
|
|
|
|
|
FDK_BITSTREAM bsWriter;
|
|
|
|
FDKinitBitStream(&bsWriter, pExtensionPayload, 16, 0, BS_WRITER);
|
|
|
|
|
|
|
|
/* dynamic_range_info() */
|
|
|
|
FDKwriteBits(&bsWriter, pce_tag_present, 1); /* pce_tag_present */
|
|
|
|
if (pce_tag_present) {
|
|
|
|
FDKwriteBits(&bsWriter, 0x0, 4); /* pce_instance_tag */
|
|
|
|
FDKwriteBits(&bsWriter, 0x0, 4); /* drc_tag_reserved_bits */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Exclude channels */
|
|
|
|
FDKwriteBits(&bsWriter, (pMetadata->mpegDrc.excluded_chns_present) ? 1 : 0,
|
|
|
|
1); /* excluded_chns_present*/
|
|
|
|
|
|
|
|
/* Multiband DRC */
|
|
|
|
FDKwriteBits(&bsWriter, (pMetadata->mpegDrc.drc_bands_present) ? 1 : 0,
|
|
|
|
1); /* drc_bands_present */
|
|
|
|
if (pMetadata->mpegDrc.drc_bands_present) {
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->mpegDrc.drc_band_incr,
|
|
|
|
4); /* drc_band_incr */
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->mpegDrc.drc_interpolation_scheme,
|
|
|
|
4); /* drc_interpolation_scheme */
|
|
|
|
drc_num_bands += pMetadata->mpegDrc.drc_band_incr;
|
|
|
|
for (i = 0; i < drc_num_bands; i++) {
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->mpegDrc.drc_band_top[i],
|
|
|
|
8); /* drc_band_top */
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
2018-02-26 20:17:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Program Reference Level */
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->mpegDrc.prog_ref_level_present,
|
|
|
|
1); /* prog_ref_level_present */
|
|
|
|
if (pMetadata->mpegDrc.prog_ref_level_present) {
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->mpegDrc.prog_ref_level,
|
|
|
|
7); /* prog_ref_level */
|
|
|
|
FDKwriteBits(&bsWriter, prog_ref_lev_res_bits,
|
|
|
|
1); /* prog_ref_level_reserved_bits */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* DRC Values */
|
|
|
|
for (i = 0; i < drc_num_bands; i++) {
|
|
|
|
FDKwriteBits(&bsWriter, (pMetadata->mpegDrc.dyn_rng_sgn[i]) ? 1 : 0,
|
|
|
|
1); /* dyn_rng_sgn[ */
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->mpegDrc.dyn_rng_ctl[i],
|
|
|
|
7); /* dyn_rng_ctl */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* return number of valid bits in extension payload. */
|
|
|
|
return FDKgetValidBits(&bsWriter);
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
static INT WriteEtsiAncillaryDataPayload(const AAC_METADATA* const pMetadata,
|
|
|
|
UCHAR* const pExtensionPayload) {
|
|
|
|
FDK_BITSTREAM bsWriter;
|
|
|
|
FDKinitBitStream(&bsWriter, pExtensionPayload, 16, 0, BS_WRITER);
|
|
|
|
|
|
|
|
/* ancillary_data_sync */
|
|
|
|
FDKwriteBits(&bsWriter, 0xBC, 8);
|
|
|
|
|
|
|
|
/* bs_info */
|
|
|
|
FDKwriteBits(&bsWriter, 0x3, 2); /* mpeg_audio_type */
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->dolbySurroundMode,
|
|
|
|
2); /* dolby_surround_mode */
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->drcPresentationMode,
|
|
|
|
2); /* DRC presentation mode */
|
|
|
|
FDKwriteBits(&bsWriter, 0x0, 1); /* stereo_downmix_mode */
|
|
|
|
FDKwriteBits(&bsWriter, 0x0, 1); /* reserved */
|
|
|
|
|
|
|
|
/* ancillary_data_status */
|
|
|
|
FDKwriteBits(&bsWriter, 0, 3); /* 3 bit Reserved, set to "0" */
|
|
|
|
FDKwriteBits(&bsWriter, (pMetadata->DmxLvl_On) ? 1 : 0,
|
|
|
|
1); /* downmixing_levels_MPEG4_status */
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncDataStatus,
|
|
|
|
1); /* ext_anc_data_status */
|
|
|
|
FDKwriteBits(&bsWriter, (pMetadata->etsiAncData.compression_on) ? 1 : 0,
|
|
|
|
1); /* audio_coding_mode_and_compression status */
|
|
|
|
FDKwriteBits(&bsWriter,
|
|
|
|
(pMetadata->etsiAncData.timecode_coarse_status) ? 1 : 0,
|
|
|
|
1); /* coarse_grain_timecode_status */
|
|
|
|
FDKwriteBits(&bsWriter, (pMetadata->etsiAncData.timecode_fine_status) ? 1 : 0,
|
|
|
|
1); /* fine_grain_timecode_status */
|
|
|
|
|
|
|
|
/* downmixing_levels_MPEG4_status */
|
|
|
|
if (pMetadata->DmxLvl_On) {
|
|
|
|
FDKwriteBits(
|
|
|
|
&bsWriter,
|
|
|
|
encodeDmxLvls(pMetadata->centerMixLevel, pMetadata->surroundMixLevel),
|
|
|
|
8);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* audio_coding_mode_and_compression_status */
|
|
|
|
if (pMetadata->etsiAncData.compression_on) {
|
|
|
|
FDKwriteBits(&bsWriter, 0x01, 8); /* audio coding mode */
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->etsiAncData.compression_value,
|
|
|
|
8); /* compression value */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* grain-timecode coarse/fine */
|
|
|
|
if (pMetadata->etsiAncData.timecode_coarse_status) {
|
|
|
|
FDKwriteBits(&bsWriter, 0x0, 16); /* not yet supported */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pMetadata->etsiAncData.timecode_fine_status) {
|
|
|
|
FDKwriteBits(&bsWriter, 0x0, 16); /* not yet supported */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* extended ancillary data structure */
|
|
|
|
if (pMetadata->etsiAncData.extAncDataStatus) {
|
|
|
|
/* ext_ancillary_data_status */
|
|
|
|
FDKwriteBits(&bsWriter, 0, 1); /* Reserved, set to "0" */
|
|
|
|
FDKwriteBits(&bsWriter,
|
|
|
|
pMetadata->etsiAncData.extAncData.ext_downmix_lvl_status,
|
|
|
|
1); /* ext_downmixing_levels_status */
|
|
|
|
FDKwriteBits(&bsWriter,
|
|
|
|
pMetadata->etsiAncData.extAncData.ext_downmix_gain_status,
|
|
|
|
1); /* ext_downmixing_global_gains_status */
|
|
|
|
FDKwriteBits(&bsWriter,
|
|
|
|
pMetadata->etsiAncData.extAncData.ext_lfe_downmix_status,
|
|
|
|
1); /* ext_downmixing_lfe_level_status" */
|
|
|
|
FDKwriteBits(&bsWriter, 0, 4); /* Reserved, set to "0" */
|
|
|
|
|
|
|
|
/* ext_downmixing_levels */
|
|
|
|
if (pMetadata->etsiAncData.extAncData.ext_downmix_lvl_status) {
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.ext_dmix_a_idx,
|
|
|
|
3); /* dmix_a_idx */
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.ext_dmix_b_idx,
|
|
|
|
3); /* dmix_b_idx */
|
|
|
|
FDKwriteBits(&bsWriter, 0, 2); /* Reserved, set to "0" */
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
/* ext_downmixing_gains */
|
|
|
|
if (pMetadata->etsiAncData.extAncData.ext_downmix_gain_status) {
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.dmx_gain_5_sgn,
|
|
|
|
1); /* dmx_gain_5_sign */
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.dmx_gain_5_idx,
|
|
|
|
6); /* dmx_gain_5_idx */
|
|
|
|
FDKwriteBits(&bsWriter, 0, 1); /* Reserved, set to "0" */
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.dmx_gain_2_sgn,
|
|
|
|
1); /* dmx_gain_2_sign */
|
|
|
|
FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.dmx_gain_2_idx,
|
|
|
|
6); /* dmx_gain_2_idx */
|
|
|
|
FDKwriteBits(&bsWriter, 0, 1); /* Reserved, set to "0" */
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
if (pMetadata->etsiAncData.extAncData.ext_lfe_downmix_status) {
|
|
|
|
FDKwriteBits(&bsWriter,
|
|
|
|
pMetadata->etsiAncData.extAncData.ext_dmix_lfe_idx,
|
|
|
|
4); /* dmix_lfe_idx */
|
|
|
|
FDKwriteBits(&bsWriter, 0, 4); /* Reserved, set to "0" */
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
2018-02-26 20:17:00 +01:00
|
|
|
}
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
return FDKgetValidBits(&bsWriter);
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static FDK_METADATA_ERROR LoadSubmittedMetadata(
|
2018-02-26 20:17:00 +01:00
|
|
|
const AACENC_MetaData* const hMetadata, const INT nChannels,
|
|
|
|
const INT metadataMode, AAC_METADATA* const pAacMetaData) {
|
|
|
|
FDK_METADATA_ERROR err = METADATA_OK;
|
|
|
|
|
|
|
|
if (pAacMetaData == NULL) {
|
|
|
|
err = METADATA_INVALID_HANDLE;
|
|
|
|
} else {
|
|
|
|
/* init struct */
|
|
|
|
FDKmemclear(pAacMetaData, sizeof(AAC_METADATA));
|
|
|
|
|
|
|
|
if (hMetadata != NULL) {
|
|
|
|
/* convert data */
|
|
|
|
pAacMetaData->mpegDrc.drc_profile = hMetadata->drc_profile;
|
|
|
|
pAacMetaData->etsiAncData.comp_profile = hMetadata->comp_profile;
|
|
|
|
pAacMetaData->mpegDrc.drc_TargetRefLevel = hMetadata->drc_TargetRefLevel;
|
|
|
|
pAacMetaData->etsiAncData.comp_TargetRefLevel =
|
|
|
|
hMetadata->comp_TargetRefLevel;
|
|
|
|
pAacMetaData->mpegDrc.prog_ref_level_present =
|
|
|
|
hMetadata->prog_ref_level_present;
|
|
|
|
pAacMetaData->mpegDrc.prog_ref_level =
|
|
|
|
dialnorm2progreflvl(hMetadata->prog_ref_level);
|
|
|
|
|
|
|
|
pAacMetaData->centerMixLevel = hMetadata->centerMixLevel;
|
|
|
|
pAacMetaData->surroundMixLevel = hMetadata->surroundMixLevel;
|
|
|
|
pAacMetaData->WritePCEMixDwnIdx = hMetadata->PCE_mixdown_idx_present;
|
|
|
|
pAacMetaData->DmxLvl_On = hMetadata->ETSI_DmxLvl_present;
|
|
|
|
|
|
|
|
pAacMetaData->etsiAncData.compression_on =
|
|
|
|
(hMetadata->comp_profile == AACENC_METADATA_DRC_NOT_PRESENT ? 0 : 1);
|
|
|
|
|
|
|
|
if (pAacMetaData->mpegDrc.drc_profile ==
|
|
|
|
AACENC_METADATA_DRC_NOT_PRESENT) {
|
|
|
|
pAacMetaData->mpegDrc.drc_profile =
|
|
|
|
AACENC_METADATA_DRC_NONE; /* MPEG DRC gains are
|
|
|
|
always present in BS
|
|
|
|
syntax */
|
|
|
|
/* we should give a warning, but ErrorHandler does not support this */
|
|
|
|
}
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
if (nChannels == 2) {
|
|
|
|
pAacMetaData->dolbySurroundMode =
|
|
|
|
hMetadata->dolbySurroundMode; /* dolby_surround_mode */
|
|
|
|
} else {
|
|
|
|
pAacMetaData->dolbySurroundMode = 0;
|
|
|
|
}
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
pAacMetaData->drcPresentationMode = hMetadata->drcPresentationMode;
|
|
|
|
/* override external values if DVB DRC presentation mode is given */
|
|
|
|
if (pAacMetaData->drcPresentationMode == 1) {
|
|
|
|
pAacMetaData->mpegDrc.drc_TargetRefLevel =
|
|
|
|
fMax(-(31 << 16), pAacMetaData->mpegDrc.drc_TargetRefLevel);
|
|
|
|
pAacMetaData->etsiAncData.comp_TargetRefLevel = fMax(
|
|
|
|
-(20 << 16),
|
|
|
|
pAacMetaData->etsiAncData.comp_TargetRefLevel); /* implies -23dB */
|
|
|
|
}
|
|
|
|
if (pAacMetaData->drcPresentationMode == 2) {
|
|
|
|
pAacMetaData->mpegDrc.drc_TargetRefLevel =
|
|
|
|
fMax(-(23 << 16), pAacMetaData->mpegDrc.drc_TargetRefLevel);
|
|
|
|
pAacMetaData->etsiAncData.comp_TargetRefLevel =
|
|
|
|
fMax(-(23 << 16), pAacMetaData->etsiAncData.comp_TargetRefLevel);
|
|
|
|
}
|
|
|
|
if (pAacMetaData->etsiAncData.comp_profile ==
|
|
|
|
AACENC_METADATA_DRC_NOT_PRESENT) {
|
|
|
|
/* DVB defines to revert to Light DRC if heavy is not present */
|
|
|
|
if (pAacMetaData->drcPresentationMode != 0) {
|
|
|
|
/* we exclude the "not indicated" mode as this requires the user to
|
|
|
|
* define desired levels anyway */
|
|
|
|
pAacMetaData->mpegDrc.drc_TargetRefLevel =
|
|
|
|
fMax(pAacMetaData->etsiAncData.comp_TargetRefLevel,
|
|
|
|
pAacMetaData->mpegDrc.drc_TargetRefLevel);
|
|
|
|
}
|
|
|
|
}
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
pAacMetaData->etsiAncData.timecode_coarse_status =
|
|
|
|
0; /* not yet supported - attention: Update
|
|
|
|
GetEstMetadataBytesPerFrame() if enable this! */
|
|
|
|
pAacMetaData->etsiAncData.timecode_fine_status =
|
|
|
|
0; /* not yet supported - attention: Update
|
|
|
|
GetEstMetadataBytesPerFrame() if enable this! */
|
|
|
|
|
|
|
|
/* extended ancillary data */
|
|
|
|
pAacMetaData->etsiAncData.extAncDataStatus =
|
|
|
|
((hMetadata->ExtMetaData.extAncDataEnable == 1) ? 1 : 0);
|
|
|
|
|
|
|
|
if (pAacMetaData->etsiAncData.extAncDataStatus) {
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_downmix_lvl_status =
|
|
|
|
(hMetadata->ExtMetaData.extDownmixLevelEnable ? 1 : 0);
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_downmix_gain_status =
|
|
|
|
(hMetadata->ExtMetaData.dmxGainEnable ? 1 : 0);
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_lfe_downmix_status =
|
|
|
|
(hMetadata->ExtMetaData.lfeDmxEnable ? 1 : 0);
|
|
|
|
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_dmix_a_idx =
|
|
|
|
hMetadata->ExtMetaData.extDownmixLevel_A;
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_dmix_b_idx =
|
|
|
|
hMetadata->ExtMetaData.extDownmixLevel_B;
|
|
|
|
|
|
|
|
if (pAacMetaData->etsiAncData.extAncData.ext_downmix_gain_status) {
|
|
|
|
encodeDynrng(hMetadata->ExtMetaData.dmxGain5,
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_idx),
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_sgn));
|
|
|
|
encodeDynrng(hMetadata->ExtMetaData.dmxGain2,
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_idx),
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_sgn));
|
2012-07-11 19:15:24 +02:00
|
|
|
} else {
|
2018-02-26 20:17:00 +01:00
|
|
|
encodeDynrng(1 << 16,
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_idx),
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_sgn));
|
|
|
|
encodeDynrng(1 << 16,
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_idx),
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_sgn));
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
if (pAacMetaData->etsiAncData.extAncData.ext_lfe_downmix_status) {
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_dmix_lfe_idx =
|
|
|
|
hMetadata->ExtMetaData.lfeDmxLevel;
|
|
|
|
} else {
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_dmix_lfe_idx =
|
|
|
|
15; /* -inf dB */
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_downmix_lvl_status = 0;
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_downmix_gain_status = 0;
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_lfe_downmix_status = 0;
|
|
|
|
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_dmix_a_idx = 7; /* -inf dB */
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_dmix_b_idx = 7; /* -inf dB */
|
|
|
|
|
|
|
|
encodeDynrng(1 << 16,
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_idx),
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_sgn));
|
|
|
|
encodeDynrng(1 << 16,
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_idx),
|
|
|
|
&(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_sgn));
|
|
|
|
|
|
|
|
pAacMetaData->etsiAncData.extAncData.ext_dmix_lfe_idx =
|
|
|
|
15; /* -inf dB */
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
2018-02-26 20:17:00 +01:00
|
|
|
|
|
|
|
pAacMetaData->metadataMode = metadataMode;
|
|
|
|
} else {
|
|
|
|
pAacMetaData->metadataMode = 0; /* there is no configuration available */
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
2018-02-26 20:17:00 +01:00
|
|
|
}
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
return err;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
INT FDK_MetadataEnc_GetDelay(HANDLE_FDK_METADATA_ENCODER hMetadataEnc) {
|
|
|
|
INT delay = 0;
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
if (hMetadataEnc != NULL) {
|
|
|
|
delay = hMetadataEnc->nAudioDataDelay;
|
|
|
|
}
|
2012-07-11 19:15:24 +02:00
|
|
|
|
2018-02-26 20:17:00 +01:00
|
|
|
return delay;
|
2012-07-11 19:15:24 +02:00
|
|
|
}
|