/* -----------------------------------------------------------------------------
|
Software License for The Fraunhofer FDK AAC Codec Library for Android
|
|
© Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
|
Forschung e.V. All rights reserved.
|
|
1. INTRODUCTION
|
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.
|
|
2. COPYRIGHT LICENSE
|
|
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:
|
|
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.
|
|
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
|
modifications thereto to recipients of copies in binary form.
|
|
The name of Fraunhofer may not be used to endorse or promote products derived
|
from this library without prior written permission.
|
|
You may not charge copyright license fees for anyone to use, copy or distribute
|
the FDK AAC Codec software or your modifications thereto.
|
|
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."
|
|
3. NO PATENT LICENSE
|
|
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.
|
|
You may use this FDK AAC Codec software or modifications thereto only for
|
purposes that are authorized by appropriate patent licenses.
|
|
4. DISCLAIMER
|
|
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.
|
|
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
|
----------------------------------------------------------------------------- */
|
|
/*********************** MPEG surround encoder library *************************
|
|
Author(s): M. Luis Valero
|
|
Description: Enhanced Time Domain Downmix
|
|
*******************************************************************************/
|
|
/* Includes ******************************************************************/
|
#include "sacenc_dmx_tdom_enh.h"
|
|
#include "FDK_matrixCalloc.h"
|
#include "FDK_trigFcts.h"
|
#include "fixpoint_math.h"
|
|
/* Defines *******************************************************************/
|
#define PI_FLT 3.1415926535897931f
|
#define ALPHA_FLT 0.0001f
|
|
#define PI_E (2)
|
#define PI_M (FL2FXCONST_DBL(PI_FLT / (1 << PI_E)))
|
|
#define ALPHA_E (13)
|
#define ALPHA_M (FL2FXCONST_DBL(ALPHA_FLT * (1 << ALPHA_E)))
|
|
enum { L = 0, R = 1 };
|
|
/* Data Types ****************************************************************/
|
typedef struct T_ENHANCED_TIME_DOMAIN_DMX {
|
int maxFramelength;
|
|
int framelength;
|
|
FIXP_DBL prev_gain_m[2];
|
INT prev_gain_e;
|
FIXP_DBL prev_H1_m[2];
|
INT prev_H1_e;
|
|
FIXP_DBL *sinusWindow_m;
|
SCHAR sinusWindow_e;
|
|
FIXP_DBL prev_Left_m;
|
INT prev_Left_e;
|
FIXP_DBL prev_Right_m;
|
INT prev_Right_e;
|
FIXP_DBL prev_XNrg_m;
|
INT prev_XNrg_e;
|
|
FIXP_DBL lin_bbCld_weight_m;
|
INT lin_bbCld_weight_e;
|
FIXP_DBL gain_weight_m[2];
|
INT gain_weight_e;
|
|
} ENHANCED_TIME_DOMAIN_DMX;
|
|
/* Constants *****************************************************************/
|
|
/* Function / Class Declarations *********************************************/
|
static void calculateRatio(const FIXP_DBL sqrt_linCld_m,
|
const INT sqrt_linCld_e, const FIXP_DBL lin_Cld_m,
|
const INT lin_Cld_e, const FIXP_DBL Icc_m,
|
const INT Icc_e, FIXP_DBL G_m[2], INT *G_e);
|
|
static void calculateDmxGains(const FIXP_DBL lin_Cld_m, const INT lin_Cld_e,
|
const FIXP_DBL lin_Cld2_m, const INT lin_Cld2_e,
|
const FIXP_DBL Icc_m, const INT Icc_e,
|
const FIXP_DBL G_m[2], const INT G_e,
|
FIXP_DBL H1_m[2], INT *pH1_e);
|
|
/* Function / Class Definition ***********************************************/
|
static FIXP_DBL invSqrtNorm2(const FIXP_DBL op_m, const INT op_e,
|
INT *const result_e) {
|
FIXP_DBL src_m = op_m;
|
int src_e = op_e;
|
|
if (src_e & 1) {
|
src_m >>= 1;
|
src_e += 1;
|
}
|
|
src_m = invSqrtNorm2(src_m, result_e);
|
*result_e = (*result_e) - (src_e >> 1);
|
|
return src_m;
|
}
|
|
static FIXP_DBL sqrtFixp(const FIXP_DBL op_m, const INT op_e,
|
INT *const result_e) {
|
FIXP_DBL src_m = op_m;
|
int src_e = op_e;
|
|
if (src_e & 1) {
|
src_m >>= 1;
|
src_e += 1;
|
}
|
|
*result_e = (src_e >> 1);
|
return sqrtFixp(src_m);
|
}
|
|
static FIXP_DBL fixpAdd(const FIXP_DBL src1_m, const INT src1_e,
|
const FIXP_DBL src2_m, const INT src2_e,
|
INT *const dst_e) {
|
FIXP_DBL dst_m;
|
|
if (src1_m == FL2FXCONST_DBL(0.f)) {
|
*dst_e = src2_e;
|
dst_m = src2_m;
|
} else if (src2_m == FL2FXCONST_DBL(0.f)) {
|
*dst_e = src1_e;
|
dst_m = src1_m;
|
} else {
|
*dst_e = fixMax(src1_e, src2_e) + 1;
|
dst_m =
|
scaleValue(src1_m, fixMax((src1_e - (*dst_e)), -(DFRACT_BITS - 1))) +
|
scaleValue(src2_m, fixMax((src2_e - (*dst_e)), -(DFRACT_BITS - 1)));
|
}
|
return dst_m;
|
}
|
|
/**
|
* \brief Sum up fixpoint values with best possible accuracy.
|
*
|
* \param value1 First input value.
|
* \param q1 Scaling factor of first input value.
|
* \param pValue2 Pointer to second input value, will be modified on
|
* return.
|
* \param pQ2 Pointer to second scaling factor, will be modified on
|
* return.
|
*
|
* \return void
|
*/
|
static void fixpAddNorm(const FIXP_DBL value1, const INT q1,
|
FIXP_DBL *const pValue2, INT *const pQ2) {
|
const int headroom1 = fNormz(fixp_abs(value1)) - 1;
|
const int headroom2 = fNormz(fixp_abs(*pValue2)) - 1;
|
int resultScale = fixMax(q1 - headroom1, (*pQ2) - headroom2);
|
|
if ((value1 != FL2FXCONST_DBL(0.f)) && (*pValue2 != FL2FXCONST_DBL(0.f))) {
|
resultScale++;
|
}
|
|
*pValue2 =
|
scaleValue(value1, q1 - resultScale) +
|
scaleValue(*pValue2, fixMax(-(DFRACT_BITS - 1), ((*pQ2) - resultScale)));
|
*pQ2 = (*pValue2 != (FIXP_DBL)0) ? resultScale : DFRACT_BITS - 1;
|
}
|
|
FDK_SACENC_ERROR fdk_sacenc_open_enhancedTimeDomainDmx(
|
HANDLE_ENHANCED_TIME_DOMAIN_DMX *phEnhancedTimeDmx, const INT framelength) {
|
FDK_SACENC_ERROR error = SACENC_OK;
|
HANDLE_ENHANCED_TIME_DOMAIN_DMX hEnhancedTimeDmx = NULL;
|
|
if (NULL == phEnhancedTimeDmx) {
|
error = SACENC_INVALID_HANDLE;
|
} else {
|
FDK_ALLOCATE_MEMORY_1D(hEnhancedTimeDmx, 1, ENHANCED_TIME_DOMAIN_DMX);
|
FDK_ALLOCATE_MEMORY_1D(hEnhancedTimeDmx->sinusWindow_m, 1 + framelength,
|
FIXP_DBL);
|
hEnhancedTimeDmx->maxFramelength = framelength;
|
*phEnhancedTimeDmx = hEnhancedTimeDmx;
|
}
|
return error;
|
|
bail:
|
fdk_sacenc_close_enhancedTimeDomainDmx(&hEnhancedTimeDmx);
|
return ((SACENC_OK == error) ? SACENC_MEMORY_ERROR : error);
|
}
|
|
FDK_SACENC_ERROR fdk_sacenc_init_enhancedTimeDomainDmx(
|
HANDLE_ENHANCED_TIME_DOMAIN_DMX hEnhancedTimeDmx,
|
const FIXP_DBL *const pInputGain_m, const INT inputGain_e,
|
const FIXP_DBL outputGain_m, const INT outputGain_e,
|
const INT framelength) {
|
FDK_SACENC_ERROR error = SACENC_OK;
|
|
if (hEnhancedTimeDmx == NULL) {
|
error = SACENC_INVALID_HANDLE;
|
} else {
|
int smp;
|
if (framelength > hEnhancedTimeDmx->maxFramelength) {
|
error = SACENC_INIT_ERROR;
|
goto bail;
|
}
|
|
hEnhancedTimeDmx->framelength = framelength;
|
|
INT deltax_e;
|
FIXP_DBL deltax_m;
|
|
deltax_m = fDivNormHighPrec(
|
PI_M, (FIXP_DBL)(2 * hEnhancedTimeDmx->framelength), &deltax_e);
|
deltax_m = scaleValue(deltax_m, PI_E + deltax_e - (DFRACT_BITS - 1) - 1);
|
deltax_e = 1;
|
|
for (smp = 0; smp < hEnhancedTimeDmx->framelength + 1; smp++) {
|
hEnhancedTimeDmx->sinusWindow_m[smp] =
|
fMult(ALPHA_M, fPow2(fixp_sin(smp * deltax_m, deltax_e)));
|
}
|
hEnhancedTimeDmx->sinusWindow_e = -ALPHA_E;
|
|
hEnhancedTimeDmx->prev_Left_m = hEnhancedTimeDmx->prev_Right_m =
|
hEnhancedTimeDmx->prev_XNrg_m = FL2FXCONST_DBL(0.f);
|
hEnhancedTimeDmx->prev_Left_e = hEnhancedTimeDmx->prev_Right_e =
|
hEnhancedTimeDmx->prev_XNrg_e = DFRACT_BITS - 1;
|
|
hEnhancedTimeDmx->lin_bbCld_weight_m =
|
fDivNormHighPrec(fPow2(pInputGain_m[L]), fPow2(pInputGain_m[R]),
|
&hEnhancedTimeDmx->lin_bbCld_weight_e);
|
|
hEnhancedTimeDmx->gain_weight_m[L] = fMult(pInputGain_m[L], outputGain_m);
|
hEnhancedTimeDmx->gain_weight_m[R] = fMult(pInputGain_m[R], outputGain_m);
|
hEnhancedTimeDmx->gain_weight_e =
|
-fNorm(fixMax(hEnhancedTimeDmx->gain_weight_m[L],
|
hEnhancedTimeDmx->gain_weight_m[R]));
|
|
hEnhancedTimeDmx->gain_weight_m[L] = scaleValue(
|
hEnhancedTimeDmx->gain_weight_m[L], -hEnhancedTimeDmx->gain_weight_e);
|
hEnhancedTimeDmx->gain_weight_m[R] = scaleValue(
|
hEnhancedTimeDmx->gain_weight_m[R], -hEnhancedTimeDmx->gain_weight_e);
|
hEnhancedTimeDmx->gain_weight_e += inputGain_e + outputGain_e;
|
|
hEnhancedTimeDmx->prev_gain_m[L] = hEnhancedTimeDmx->gain_weight_m[L] >> 1;
|
hEnhancedTimeDmx->prev_gain_m[R] = hEnhancedTimeDmx->gain_weight_m[R] >> 1;
|
hEnhancedTimeDmx->prev_gain_e = hEnhancedTimeDmx->gain_weight_e + 1;
|
|
hEnhancedTimeDmx->prev_H1_m[L] =
|
scaleValue(hEnhancedTimeDmx->gain_weight_m[L], -4);
|
hEnhancedTimeDmx->prev_H1_m[R] =
|
scaleValue(hEnhancedTimeDmx->gain_weight_m[R], -4);
|
hEnhancedTimeDmx->prev_H1_e = 2 + 2 + hEnhancedTimeDmx->gain_weight_e;
|
}
|
bail:
|
return error;
|
}
|
|
FDK_SACENC_ERROR fdk_sacenc_apply_enhancedTimeDomainDmx(
|
HANDLE_ENHANCED_TIME_DOMAIN_DMX hEnhancedTimeDmx,
|
const INT_PCM *const *const inputTime, INT_PCM *const outputTimeDmx,
|
const INT InputDelay) {
|
FDK_SACENC_ERROR error = SACENC_OK;
|
|
if ((NULL == hEnhancedTimeDmx) || (NULL == inputTime) ||
|
(NULL == inputTime[L]) || (NULL == inputTime[R]) ||
|
(NULL == outputTimeDmx)) {
|
error = SACENC_INVALID_HANDLE;
|
} else {
|
int smp;
|
FIXP_DBL lin_bbCld_m, lin_Cld_m, bbCorr_m, sqrt_linCld_m, G_m[2], H1_m[2],
|
gainLeft_m, gainRight_m;
|
FIXP_DBL bbNrgLeft_m, bbNrgRight_m, bbXNrg_m, nrgLeft_m, nrgRight_m, nrgX_m;
|
INT lin_bbCld_e, lin_Cld_e, bbCorr_e, sqrt_linCld_e, G_e, H1_e;
|
INT bbNrgLeft_e, bbNrgRight_e, bbXNrg_e, nrgLeft_e, nrgRight_e, nrgX_e;
|
|
/* Increase energy time resolution with shorter processing blocks. 128 is an
|
* empiric value. */
|
const int granuleLength = fixMin(128, hEnhancedTimeDmx->framelength);
|
int granuleShift =
|
(granuleLength > 1)
|
? ((DFRACT_BITS - 1) - fNorm((FIXP_DBL)(granuleLength - 1)))
|
: 0;
|
granuleShift = fixMax(
|
3, granuleShift +
|
1); /* one bit more headroom for worst case accumulation */
|
|
smp = 0;
|
|
/* Prevent division by zero. */
|
bbNrgLeft_m = bbNrgRight_m = bbXNrg_m = (FIXP_DBL)(1);
|
bbNrgLeft_e = bbNrgRight_e = bbXNrg_e = 0;
|
|
do {
|
const int offset = smp;
|
FIXP_DBL partialL, partialR, partialX;
|
partialL = partialR = partialX = FL2FXCONST_DBL(0.f);
|
|
int in_margin = FDKmin(
|
getScalefactorPCM(
|
&inputTime[L][offset],
|
fixMin(offset + granuleLength, hEnhancedTimeDmx->framelength) -
|
offset,
|
1),
|
getScalefactorPCM(
|
&inputTime[R][offset],
|
fixMin(offset + granuleLength, hEnhancedTimeDmx->framelength) -
|
offset,
|
1));
|
|
/* partial energy */
|
for (smp = offset;
|
smp < fixMin(offset + granuleLength, hEnhancedTimeDmx->framelength);
|
smp++) {
|
FIXP_PCM inputL =
|
scaleValue((FIXP_PCM)inputTime[L][smp], in_margin - 1);
|
FIXP_PCM inputR =
|
scaleValue((FIXP_PCM)inputTime[R][smp], in_margin - 1);
|
|
partialL += fPow2Div2(inputL) >> (granuleShift - 3);
|
partialR += fPow2Div2(inputR) >> (granuleShift - 3);
|
partialX += fMultDiv2(inputL, inputR) >> (granuleShift - 3);
|
}
|
|
fixpAddNorm(partialL, granuleShift - 2 * in_margin, &bbNrgLeft_m,
|
&bbNrgLeft_e);
|
fixpAddNorm(partialR, granuleShift - 2 * in_margin, &bbNrgRight_m,
|
&bbNrgRight_e);
|
fixpAddNorm(partialX, granuleShift - 2 * in_margin, &bbXNrg_m, &bbXNrg_e);
|
} while (smp < hEnhancedTimeDmx->framelength);
|
|
nrgLeft_m =
|
fixpAdd(hEnhancedTimeDmx->prev_Left_m, hEnhancedTimeDmx->prev_Left_e,
|
bbNrgLeft_m, bbNrgLeft_e, &nrgLeft_e);
|
nrgRight_m =
|
fixpAdd(hEnhancedTimeDmx->prev_Right_m, hEnhancedTimeDmx->prev_Right_e,
|
bbNrgRight_m, bbNrgRight_e, &nrgRight_e);
|
nrgX_m =
|
fixpAdd(hEnhancedTimeDmx->prev_XNrg_m, hEnhancedTimeDmx->prev_XNrg_e,
|
bbXNrg_m, bbXNrg_e, &nrgX_e);
|
|
lin_bbCld_m = fMult(hEnhancedTimeDmx->lin_bbCld_weight_m,
|
fDivNorm(nrgLeft_m, nrgRight_m, &lin_bbCld_e));
|
lin_bbCld_e +=
|
hEnhancedTimeDmx->lin_bbCld_weight_e + nrgLeft_e - nrgRight_e;
|
|
bbCorr_m = fMult(nrgX_m, invSqrtNorm2(fMult(nrgLeft_m, nrgRight_m),
|
nrgLeft_e + nrgRight_e, &bbCorr_e));
|
bbCorr_e += nrgX_e;
|
|
hEnhancedTimeDmx->prev_Left_m = bbNrgLeft_m;
|
hEnhancedTimeDmx->prev_Left_e = bbNrgLeft_e;
|
hEnhancedTimeDmx->prev_Right_m = bbNrgRight_m;
|
hEnhancedTimeDmx->prev_Right_e = bbNrgRight_e;
|
hEnhancedTimeDmx->prev_XNrg_m = bbXNrg_m;
|
hEnhancedTimeDmx->prev_XNrg_e = bbXNrg_e;
|
|
/*
|
bbCld = 10.f*log10(lin_bbCld)
|
|
lin_Cld = pow(10,bbCld/20)
|
= pow(10,10.f*log10(lin_bbCld)/20.f)
|
= sqrt(lin_bbCld)
|
|
lin_Cld2 = lin_Cld*lin_Cld
|
= sqrt(lin_bbCld)*sqrt(lin_bbCld)
|
= lin_bbCld
|
*/
|
lin_Cld_m = sqrtFixp(lin_bbCld_m, lin_bbCld_e, &lin_Cld_e);
|
sqrt_linCld_m = sqrtFixp(lin_Cld_m, lin_Cld_e, &sqrt_linCld_e);
|
|
/*calculate how much right and how much left signal, to avoid signal
|
* cancellations*/
|
calculateRatio(sqrt_linCld_m, sqrt_linCld_e, lin_Cld_m, lin_Cld_e, bbCorr_m,
|
bbCorr_e, G_m, &G_e);
|
|
/*calculate downmix gains*/
|
calculateDmxGains(lin_Cld_m, lin_Cld_e, lin_bbCld_m, lin_bbCld_e, bbCorr_m,
|
bbCorr_e, G_m, G_e, H1_m, &H1_e);
|
|
/*adapt output gains*/
|
H1_m[L] = fMult(H1_m[L], hEnhancedTimeDmx->gain_weight_m[L]);
|
H1_m[R] = fMult(H1_m[R], hEnhancedTimeDmx->gain_weight_m[R]);
|
H1_e += hEnhancedTimeDmx->gain_weight_e;
|
|
gainLeft_m = hEnhancedTimeDmx->prev_gain_m[L];
|
gainRight_m = hEnhancedTimeDmx->prev_gain_m[R];
|
|
INT intermediate_gain_e =
|
+hEnhancedTimeDmx->sinusWindow_e + H1_e - hEnhancedTimeDmx->prev_gain_e;
|
|
for (smp = 0; smp < hEnhancedTimeDmx->framelength; smp++) {
|
const INT N = hEnhancedTimeDmx->framelength;
|
FIXP_DBL intermediate_gainLeft_m, intermediate_gainRight_m, tmp;
|
|
intermediate_gainLeft_m =
|
scaleValue((fMult(hEnhancedTimeDmx->sinusWindow_m[smp], H1_m[L]) +
|
fMult(hEnhancedTimeDmx->sinusWindow_m[N - smp],
|
hEnhancedTimeDmx->prev_H1_m[L])),
|
intermediate_gain_e);
|
intermediate_gainRight_m =
|
scaleValue((fMult(hEnhancedTimeDmx->sinusWindow_m[smp], H1_m[R]) +
|
fMult(hEnhancedTimeDmx->sinusWindow_m[N - smp],
|
hEnhancedTimeDmx->prev_H1_m[R])),
|
intermediate_gain_e);
|
|
gainLeft_m = intermediate_gainLeft_m +
|
fMult(FL2FXCONST_DBL(1.f - ALPHA_FLT), gainLeft_m);
|
gainRight_m = intermediate_gainRight_m +
|
fMult(FL2FXCONST_DBL(1.f - ALPHA_FLT), gainRight_m);
|
|
tmp = fMultDiv2(gainLeft_m, (FIXP_PCM)inputTime[L][smp + InputDelay]) +
|
fMultDiv2(gainRight_m, (FIXP_PCM)inputTime[R][smp + InputDelay]);
|
outputTimeDmx[smp] = (INT_PCM)SATURATE_SHIFT(
|
tmp,
|
-(hEnhancedTimeDmx->prev_gain_e + 1 - (DFRACT_BITS - SAMPLE_BITS)),
|
SAMPLE_BITS);
|
}
|
|
hEnhancedTimeDmx->prev_gain_m[L] = gainLeft_m;
|
hEnhancedTimeDmx->prev_gain_m[R] = gainRight_m;
|
|
hEnhancedTimeDmx->prev_H1_m[L] = H1_m[L];
|
hEnhancedTimeDmx->prev_H1_m[R] = H1_m[R];
|
hEnhancedTimeDmx->prev_H1_e = H1_e;
|
}
|
|
return error;
|
}
|
|
static void calculateRatio(const FIXP_DBL sqrt_linCld_m,
|
const INT sqrt_linCld_e, const FIXP_DBL lin_Cld_m,
|
const INT lin_Cld_e, const FIXP_DBL Icc_m,
|
const INT Icc_e, FIXP_DBL G_m[2], INT *G_e) {
|
#define G_SCALE_FACTOR (2)
|
|
if (Icc_m >= FL2FXCONST_DBL(0.f)) {
|
G_m[0] = G_m[1] = FL2FXCONST_DBL(1.f / (float)(1 << G_SCALE_FACTOR));
|
G_e[0] = G_SCALE_FACTOR;
|
} else {
|
const FIXP_DBL max_gain_factor =
|
FL2FXCONST_DBL(2.f / (float)(1 << G_SCALE_FACTOR));
|
FIXP_DBL tmp1_m, tmp2_m, numerator_m, denominator_m, r_m, r4_m, q;
|
INT tmp1_e, tmp2_e, numerator_e, denominator_e, r_e, r4_e;
|
|
/* r = (lin_Cld + 1 + 2*Icc*sqrt_linCld) / (lin_Cld + 1 -
|
* 2*Icc*sqrt_linCld) = (tmp1 + tmp2) / (tmp1 - tmp2)
|
*/
|
tmp1_m =
|
fixpAdd(lin_Cld_m, lin_Cld_e, FL2FXCONST_DBL(1.f / 2.f), 1, &tmp1_e);
|
|
tmp2_m = fMult(Icc_m, sqrt_linCld_m);
|
tmp2_e = 1 + Icc_e + sqrt_linCld_e;
|
numerator_m = fixpAdd(tmp1_m, tmp1_e, tmp2_m, tmp2_e, &numerator_e);
|
denominator_m = fixpAdd(tmp1_m, tmp1_e, -tmp2_m, tmp2_e, &denominator_e);
|
|
if ((numerator_m > FL2FXCONST_DBL(0.f)) &&
|
(denominator_m > FL2FXCONST_DBL(0.f))) {
|
r_m = fDivNorm(numerator_m, denominator_m, &r_e);
|
r_e += numerator_e - denominator_e;
|
|
/* r_4 = sqrt( sqrt( r ) ) */
|
r4_m = sqrtFixp(r_m, r_e, &r4_e);
|
r4_m = sqrtFixp(r4_m, r4_e, &r4_e);
|
|
r4_e -= G_SCALE_FACTOR;
|
|
/* q = min(r4_m, max_gain_factor) */
|
q = ((r4_e >= 0) && (r4_m >= (max_gain_factor >> r4_e)))
|
? max_gain_factor
|
: scaleValue(r4_m, r4_e);
|
} else {
|
q = FL2FXCONST_DBL(0.f);
|
}
|
|
G_m[0] = max_gain_factor - q;
|
G_m[1] = q;
|
|
*G_e = G_SCALE_FACTOR;
|
}
|
}
|
|
static void calculateDmxGains(const FIXP_DBL lin_Cld_m, const INT lin_Cld_e,
|
const FIXP_DBL lin_Cld2_m, const INT lin_Cld2_e,
|
const FIXP_DBL Icc_m, const INT Icc_e,
|
const FIXP_DBL G_m[2], const INT G_e,
|
FIXP_DBL H1_m[2], INT *pH1_e) {
|
#define H1_SCALE_FACTOR (2)
|
const FIXP_DBL max_gain_factor =
|
FL2FXCONST_DBL(2.f / (float)(1 << H1_SCALE_FACTOR));
|
|
FIXP_DBL nrgRight_m, nrgLeft_m, crossNrg_m, inv_weight_num_m,
|
inv_weight_denom_m, inverse_weight_m, inverse_weight_limited;
|
INT nrgRight_e, nrgLeft_e, crossNrg_e, inv_weight_num_e, inv_weight_denom_e,
|
inverse_weight_e;
|
|
/* nrgRight = sqrt(1/(lin_Cld2 + 1) */
|
nrgRight_m = fixpAdd(lin_Cld2_m, lin_Cld2_e, FL2FXCONST_DBL(1.f / 2.f), 1,
|
&nrgRight_e);
|
nrgRight_m = invSqrtNorm2(nrgRight_m, nrgRight_e, &nrgRight_e);
|
|
/* nrgLeft = lin_Cld * nrgRight */
|
nrgLeft_m = fMult(lin_Cld_m, nrgRight_m);
|
nrgLeft_e = lin_Cld_e + nrgRight_e;
|
|
/* crossNrg = sqrt(nrgLeft*nrgRight) */
|
crossNrg_m = sqrtFixp(fMult(nrgLeft_m, nrgRight_m), nrgLeft_e + nrgRight_e,
|
&crossNrg_e);
|
|
/* inverse_weight = sqrt((nrgLeft + nrgRight) / ( (G[0]*G[0]*nrgLeft) +
|
* (G[1]*G[1]*nrgRight) + 2*G[0]*G[1]*Icc*crossNrg)) = sqrt(inv_weight_num /
|
* inv_weight_denom)
|
*/
|
inv_weight_num_m =
|
fixpAdd(nrgRight_m, nrgRight_e, nrgLeft_m, nrgLeft_e, &inv_weight_num_e);
|
|
inv_weight_denom_m =
|
fixpAdd(fMult(fPow2(G_m[0]), nrgLeft_m), 2 * G_e + nrgLeft_e,
|
fMult(fPow2(G_m[1]), nrgRight_m), 2 * G_e + nrgRight_e,
|
&inv_weight_denom_e);
|
|
inv_weight_denom_m =
|
fixpAdd(fMult(fMult(fMult(G_m[0], G_m[1]), crossNrg_m), Icc_m),
|
1 + 2 * G_e + crossNrg_e + Icc_e, inv_weight_denom_m,
|
inv_weight_denom_e, &inv_weight_denom_e);
|
|
if (inv_weight_denom_m > FL2FXCONST_DBL(0.f)) {
|
inverse_weight_m =
|
fDivNorm(inv_weight_num_m, inv_weight_denom_m, &inverse_weight_e);
|
inverse_weight_m =
|
sqrtFixp(inverse_weight_m,
|
inverse_weight_e + inv_weight_num_e - inv_weight_denom_e,
|
&inverse_weight_e);
|
inverse_weight_e -= H1_SCALE_FACTOR;
|
|
/* inverse_weight_limited = min(max_gain_factor, inverse_weight) */
|
inverse_weight_limited =
|
((inverse_weight_e >= 0) &&
|
(inverse_weight_m >= (max_gain_factor >> inverse_weight_e)))
|
? max_gain_factor
|
: scaleValue(inverse_weight_m, inverse_weight_e);
|
} else {
|
inverse_weight_limited = max_gain_factor;
|
}
|
|
H1_m[0] = fMult(G_m[0], inverse_weight_limited);
|
H1_m[1] = fMult(G_m[1], inverse_weight_limited);
|
|
*pH1_e = G_e + H1_SCALE_FACTOR;
|
}
|
|
FDK_SACENC_ERROR fdk_sacenc_close_enhancedTimeDomainDmx(
|
HANDLE_ENHANCED_TIME_DOMAIN_DMX *phEnhancedTimeDmx) {
|
FDK_SACENC_ERROR error = SACENC_OK;
|
|
if (phEnhancedTimeDmx == NULL) {
|
error = SACENC_INVALID_HANDLE;
|
} else {
|
if (*phEnhancedTimeDmx != NULL) {
|
if ((*phEnhancedTimeDmx)->sinusWindow_m != NULL) {
|
FDK_FREE_MEMORY_1D((*phEnhancedTimeDmx)->sinusWindow_m);
|
}
|
FDK_FREE_MEMORY_1D(*phEnhancedTimeDmx);
|
}
|
}
|
return error;
|
}
|
