425 lines
16 KiB
C
425 lines
16 KiB
C
|
/*
|
||
|
|
* Copyright (C) 2008 The Android Open Source Project
|
||
|
|
*
|
||
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
* you may not use this file except in compliance with the License.
|
||
|
|
* You may obtain a copy of the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
* See the License for the specific language governing permissions and
|
||
|
|
* limitations under the License.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#ifndef ANDROID_EFFECTSMATH_H_
|
||
|
|
#define ANDROID_EFFECTSMATH_H_
|
||
|
|
|
||
|
|
#include <stdint.h>
|
||
|
|
|
||
|
|
#if __cplusplus
|
||
|
|
extern "C" {
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/** coefs for pan, generates sin, cos */
|
||
|
|
#define COEFF_PAN_G2 -27146 /* -0.82842712474619 = 2 - 4/sqrt(2) */
|
||
|
|
#define COEFF_PAN_G0 23170 /* 0.707106781186547 = 1/sqrt(2) */
|
||
|
|
|
||
|
|
/*
|
||
|
|
coefficients for approximating
|
||
|
|
2^x = gn2toX0 + gn2toX1*x + gn2toX2*x^2 + gn2toX3*x^3
|
||
|
|
where x is a int.frac number representing number of octaves.
|
||
|
|
Actually, we approximate only the 2^(frac) using the power series
|
||
|
|
and implement the 2^(int) as a shift, so that
|
||
|
|
2^x == 2^(int.frac) == 2^(int) * 2^(fract)
|
||
|
|
== (gn2toX0 + gn2toX1*x + gn2toX2*x^2 + gn2toX3*x^3) << (int)
|
||
|
|
|
||
|
|
The gn2toX.. were generated using a best fit for a 3rd
|
||
|
|
order polynomial, instead of taking the coefficients from
|
||
|
|
a truncated Taylor (or Maclaurin?) series.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#define GN2_TO_X0 32768 /* 1 */
|
||
|
|
#define GN2_TO_X1 22833 /* 0.696807861328125 */
|
||
|
|
#define GN2_TO_X2 7344 /* 0.22412109375 */
|
||
|
|
#define GN2_TO_X3 2588 /* 0.0789794921875 */
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------------
|
||
|
|
* Fixed Point Math
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
* These macros are used for fixed point multiplies. If the processor
|
||
|
|
* supports fixed point multiplies, replace these macros with inline
|
||
|
|
* assembly code to improve performance.
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
*/
|
||
|
|
|
||
|
|
/* Fixed point multiply 0.15 x 0.15 = 0.15 returned as 32-bits */
|
||
|
|
#define FMUL_15x15(a,b) \
|
||
|
|
/*lint -e(704) <avoid multiply for performance>*/ \
|
||
|
|
(((int32_t)(a) * (int32_t)(b)) >> 15)
|
||
|
|
|
||
|
|
/* Fixed point multiply 0.7 x 0.7 = 0.15 returned as 32-bits */
|
||
|
|
#define FMUL_7x7(a,b) \
|
||
|
|
/*lint -e(704) <avoid multiply for performance>*/ \
|
||
|
|
(((int32_t)(a) * (int32_t)(b) ) << 1)
|
||
|
|
|
||
|
|
/* Fixed point multiply 0.8 x 0.8 = 0.15 returned as 32-bits */
|
||
|
|
#define FMUL_8x8(a,b) \
|
||
|
|
/*lint -e(704) <avoid multiply for performance>*/ \
|
||
|
|
(((int32_t)(a) * (int32_t)(b) ) >> 1)
|
||
|
|
|
||
|
|
/* Fixed point multiply 0.8 x 1.15 = 0.15 returned as 32-bits */
|
||
|
|
#define FMUL_8x15(a,b) \
|
||
|
|
/*lint -e(704) <avoid divide for performance>*/ \
|
||
|
|
(((int32_t)((a) << 7) * (int32_t)(b)) >> 15)
|
||
|
|
|
||
|
|
/* macros for fractional phase accumulator */
|
||
|
|
/*
|
||
|
|
Note: changed the _U32 to _I32 on 03/14/02. This should not
|
||
|
|
affect the phase calculations, and should allow us to reuse these
|
||
|
|
macros for other audio sample related math.
|
||
|
|
*/
|
||
|
|
#define HARDWARE_BIT_WIDTH 32
|
||
|
|
|
||
|
|
#define NUM_PHASE_INT_BITS 1
|
||
|
|
#define NUM_PHASE_FRAC_BITS 15
|
||
|
|
|
||
|
|
#define PHASE_FRAC_MASK (uint32_t) ((0x1L << NUM_PHASE_FRAC_BITS) -1)
|
||
|
|
|
||
|
|
#define GET_PHASE_INT_PART(x) (uint32_t)((uint32_t)(x) >> NUM_PHASE_FRAC_BITS)
|
||
|
|
#define GET_PHASE_FRAC_PART(x) (uint32_t)((uint32_t)(x) & PHASE_FRAC_MASK)
|
||
|
|
|
||
|
|
#define DEFAULT_PHASE_FRAC 0
|
||
|
|
#define DEFAULT_PHASE_INT 0
|
||
|
|
|
||
|
|
/*
|
||
|
|
Linear interpolation calculates:
|
||
|
|
output = (1-frac) * sample[n] + (frac) * sample[n+1]
|
||
|
|
|
||
|
|
where conceptually 0 <= frac < 1
|
||
|
|
|
||
|
|
For a fixed point implementation, frac is actually an integer value
|
||
|
|
with an implied binary point one position to the left. The value of
|
||
|
|
one (unity) is given by PHASE_ONE
|
||
|
|
one half and one quarter are useful for 4-point linear interp.
|
||
|
|
*/
|
||
|
|
#define PHASE_ONE (int32_t) (0x1L << NUM_PHASE_FRAC_BITS)
|
||
|
|
|
||
|
|
/*
|
||
|
|
Multiply the signed audio sample by the unsigned fraction.
|
||
|
|
- a is the signed audio sample
|
||
|
|
- b is the unsigned fraction (cast to signed int as long as coef
|
||
|
|
uses (n-1) or less bits, where n == hardware bit width)
|
||
|
|
*/
|
||
|
|
#define MULT_AUDIO_COEF(audio,coef) /*lint -e704 <avoid divide for performance>*/ \
|
||
|
|
(int32_t)( \
|
||
|
|
( \
|
||
|
|
((int32_t)(audio)) * ((int32_t)(coef)) \
|
||
|
|
) \
|
||
|
|
>> NUM_PHASE_FRAC_BITS \
|
||
|
|
) \
|
||
|
|
/* lint +704 <restore checking>*/
|
||
|
|
|
||
|
|
/* wet / dry calculation macros */
|
||
|
|
#define NUM_WET_DRY_FRAC_BITS 7 // 15
|
||
|
|
#define NUM_WET_DRY_INT_BITS 9 // 1
|
||
|
|
|
||
|
|
/* define a 1.0 */
|
||
|
|
#define WET_DRY_ONE (int32_t) ((0x1L << NUM_WET_DRY_FRAC_BITS))
|
||
|
|
#define WET_DRY_MINUS_ONE (int32_t) (~WET_DRY_ONE)
|
||
|
|
#define WET_DRY_FULL_SCALE (int32_t) (WET_DRY_ONE - 1)
|
||
|
|
|
||
|
|
#define MULT_AUDIO_WET_DRY_COEF(audio,coef) /*lint -e(702) <avoid divide for performance>*/ \
|
||
|
|
(int32_t)( \
|
||
|
|
( \
|
||
|
|
((int32_t)(audio)) * ((int32_t)(coef)) \
|
||
|
|
) \
|
||
|
|
>> NUM_WET_DRY_FRAC_BITS \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* Envelope 1 (EG1) calculation macros */
|
||
|
|
#define NUM_EG1_INT_BITS 1
|
||
|
|
#define NUM_EG1_FRAC_BITS 15
|
||
|
|
|
||
|
|
/* the max positive gain used in the synth for EG1 */
|
||
|
|
/* SYNTH_FULL_SCALE_EG1_GAIN must match the value in the dls2eas
|
||
|
|
converter, otherwise, the values we read from the .eas file are bogus. */
|
||
|
|
#define SYNTH_FULL_SCALE_EG1_GAIN (int32_t) ((0x1L << NUM_EG1_FRAC_BITS) -1)
|
||
|
|
|
||
|
|
/* define a 1.0 */
|
||
|
|
#define EG1_ONE (int32_t) ((0x1L << NUM_EG1_FRAC_BITS))
|
||
|
|
#define EG1_MINUS_ONE (int32_t) (~SYNTH_FULL_SCALE_EG1_GAIN)
|
||
|
|
|
||
|
|
#define EG1_HALF (int32_t) (EG1_ONE/2)
|
||
|
|
#define EG1_MINUS_HALF (int32_t) (EG1_MINUS_ONE/2)
|
||
|
|
|
||
|
|
/*
|
||
|
|
We implement the EG1 using a linear gain value, which means that the
|
||
|
|
attack segment is handled by incrementing (adding) the linear gain.
|
||
|
|
However, EG1 treats the Decay, Sustain, and Release differently than
|
||
|
|
the Attack portion. For Decay, Sustain, and Release, the gain is
|
||
|
|
linear on dB scale, which is equivalent to exponential damping on
|
||
|
|
a linear scale. Because we use a linear gain for EG1, we implement
|
||
|
|
the Decay and Release as multiplication (instead of incrementing
|
||
|
|
as we did for the attack segment).
|
||
|
|
Therefore, we need the following macro to implement the multiplication
|
||
|
|
(i.e., exponential damping) during the Decay and Release segments of
|
||
|
|
the EG1
|
||
|
|
*/
|
||
|
|
#define MULT_EG1_EG1(gain,damping) /*lint -e(704) <avoid divide for performance>*/ \
|
||
|
|
(int32_t)( \
|
||
|
|
( \
|
||
|
|
((int32_t)(gain)) * ((int32_t)(damping)) \
|
||
|
|
) \
|
||
|
|
>> NUM_EG1_FRAC_BITS \
|
||
|
|
)
|
||
|
|
|
||
|
|
// Use the following macro specifically for the filter, when multiplying
|
||
|
|
// the b1 coefficient. The 0 <= |b1| < 2, which therefore might overflow
|
||
|
|
// in certain conditions because we store b1 as a 1.15 value.
|
||
|
|
// Instead, we could store b1 as b1p (b1' == b1 "prime") where
|
||
|
|
// b1p == b1/2, thus ensuring no potential overflow for b1p because
|
||
|
|
// 0 <= |b1p| < 1
|
||
|
|
// However, during the filter calculation, we must account for the fact
|
||
|
|
// that we are using b1p instead of b1, and thereby multiply by
|
||
|
|
// an extra factor of 2. Rather than multiply by an extra factor of 2,
|
||
|
|
// we can instead shift the result right by one less, hence the
|
||
|
|
// modified shift right value of (NUM_EG1_FRAC_BITS -1)
|
||
|
|
#define MULT_EG1_EG1_X2(gain,damping) /*lint -e(702) <avoid divide for performance>*/ \
|
||
|
|
(int32_t)( \
|
||
|
|
( \
|
||
|
|
((int32_t)(gain)) * ((int32_t)(damping)) \
|
||
|
|
) \
|
||
|
|
>> (NUM_EG1_FRAC_BITS -1) \
|
||
|
|
)
|
||
|
|
|
||
|
|
#define SATURATE_EG1(x) /*lint -e{734} saturation operation */ \
|
||
|
|
((int32_t)(x) > SYNTH_FULL_SCALE_EG1_GAIN) ? (SYNTH_FULL_SCALE_EG1_GAIN) : \
|
||
|
|
((int32_t)(x) < EG1_MINUS_ONE) ? (EG1_MINUS_ONE) : (x);
|
||
|
|
|
||
|
|
|
||
|
|
/* use "digital cents" == "dents" instead of cents */
|
||
|
|
/* we coudl re-use the phase frac macros, but if we do,
|
||
|
|
we must change the phase macros to cast to _I32 instead of _U32,
|
||
|
|
because using a _U32 cast causes problems when shifting the exponent
|
||
|
|
for the 2^x calculation, because right shift a negative values MUST
|
||
|
|
be sign extended, or else the 2^x calculation is wrong */
|
||
|
|
|
||
|
|
/* use "digital cents" == "dents" instead of cents */
|
||
|
|
#define NUM_DENTS_FRAC_BITS 12
|
||
|
|
#define NUM_DENTS_INT_BITS (HARDWARE_BIT_WIDTH - NUM_DENTS_FRAC_BITS)
|
||
|
|
|
||
|
|
#define DENTS_FRAC_MASK (int32_t) ((0x1L << NUM_DENTS_FRAC_BITS) -1)
|
||
|
|
|
||
|
|
#define GET_DENTS_INT_PART(x) /*lint -e(704) <avoid divide for performance>*/ \
|
||
|
|
(int32_t)((int32_t)(x) >> NUM_DENTS_FRAC_BITS)
|
||
|
|
|
||
|
|
#define GET_DENTS_FRAC_PART(x) (int32_t)((int32_t)(x) & DENTS_FRAC_MASK)
|
||
|
|
|
||
|
|
#define DENTS_ONE (int32_t) (0x1L << NUM_DENTS_FRAC_BITS)
|
||
|
|
|
||
|
|
/* use CENTS_TO_DENTS to convert a value in cents to dents */
|
||
|
|
#define CENTS_TO_DENTS (int32_t) (DENTS_ONE * (0x1L << NUM_EG1_FRAC_BITS) / 1200L) \
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
For gain, the LFO generates a value that modulates in terms
|
||
|
|
of dB. However, we use a linear gain value, so we must convert
|
||
|
|
the LFO value in dB to a linear gain. Normally, we would use
|
||
|
|
linear gain = 10^x, where x = LFO value in dB / 20.
|
||
|
|
Instead, we implement 10^x using our 2^x approximation.
|
||
|
|
because
|
||
|
|
|
||
|
|
10^x = 2^(log2(10^x)) = 2^(x * log2(10))
|
||
|
|
|
||
|
|
so we need to multiply by log2(10) which is just a constant.
|
||
|
|
Ah, but just wait -- our 2^x actually doesn't exactly implement
|
||
|
|
2^x, but it actually assumes that the input is in cents, and within
|
||
|
|
the 2^x approximation converts its input from cents to octaves
|
||
|
|
by dividing its input by 1200.
|
||
|
|
|
||
|
|
So, in order to convert the LFO gain value in dB to something
|
||
|
|
that our existing 2^x approximation can use, multiply the LFO gain
|
||
|
|
by log2(10) * 1200 / 20
|
||
|
|
|
||
|
|
The divide by 20 helps convert dB to linear gain, and we might
|
||
|
|
as well incorporate that operation into this conversion.
|
||
|
|
Of course, we need to keep some fractional bits, so multiply
|
||
|
|
the constant by NUM_EG1_FRAC_BITS
|
||
|
|
*/
|
||
|
|
|
||
|
|
/* use LFO_GAIN_TO_CENTS to convert the LFO gain value to cents */
|
||
|
|
#if 0
|
||
|
|
#define DOUBLE_LOG2_10 (double) (3.32192809488736) /* log2(10) */
|
||
|
|
|
||
|
|
#define DOUBLE_LFO_GAIN_TO_CENTS (double) \
|
||
|
|
( \
|
||
|
|
(DOUBLE_LOG2_10) * \
|
||
|
|
1200.0 / \
|
||
|
|
20.0 \
|
||
|
|
)
|
||
|
|
|
||
|
|
#define LFO_GAIN_TO_CENTS (int32_t) \
|
||
|
|
( \
|
||
|
|
DOUBLE_LFO_GAIN_TO_CENTS * \
|
||
|
|
(0x1L << NUM_EG1_FRAC_BITS) \
|
||
|
|
)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#define LFO_GAIN_TO_CENTS (int32_t) (1671981156L >> (23 - NUM_EG1_FRAC_BITS))
|
||
|
|
|
||
|
|
|
||
|
|
#define MULT_DENTS_COEF(dents,coef) /*lint -e704 <avoid divide for performance>*/ \
|
||
|
|
(int32_t)( \
|
||
|
|
( \
|
||
|
|
((int32_t)(dents)) * ((int32_t)(coef)) \
|
||
|
|
) \
|
||
|
|
>> NUM_DENTS_FRAC_BITS \
|
||
|
|
) \
|
||
|
|
/* lint +e704 <restore checking>*/
|
||
|
|
|
||
|
|
|
||
|
|
/* we use 16-bits in the PC per audio sample */
|
||
|
|
#define BITS_PER_AUDIO_SAMPLE 16
|
||
|
|
|
||
|
|
/* we define 1 as 1.0 - 1 LSbit */
|
||
|
|
#define DISTORTION_ONE (int32_t)((0x1L << (BITS_PER_AUDIO_SAMPLE-1)) -1)
|
||
|
|
#define DISTORTION_MINUS_ONE (int32_t)(~DISTORTION_ONE)
|
||
|
|
|
||
|
|
/* drive coef is given as int.frac */
|
||
|
|
#define NUM_DRIVE_COEF_INT_BITS 1
|
||
|
|
#define NUM_DRIVE_COEF_FRAC_BITS 4
|
||
|
|
|
||
|
|
#define MULT_AUDIO_DRIVE(audio,drive) /*lint -e(702) <avoid divide for performance>*/ \
|
||
|
|
(int32_t) ( \
|
||
|
|
( \
|
||
|
|
((int32_t)(audio)) * ((int32_t)(drive)) \
|
||
|
|
) \
|
||
|
|
>> NUM_DRIVE_COEF_FRAC_BITS \
|
||
|
|
)
|
||
|
|
|
||
|
|
#define MULT_AUDIO_AUDIO(audio1,audio2) /*lint -e(702) <avoid divide for performance>*/ \
|
||
|
|
(int32_t) ( \
|
||
|
|
( \
|
||
|
|
((int32_t)(audio1)) * ((int32_t)(audio2)) \
|
||
|
|
) \
|
||
|
|
>> (BITS_PER_AUDIO_SAMPLE-1) \
|
||
|
|
)
|
||
|
|
|
||
|
|
#define SATURATE(x) \
|
||
|
|
((((int32_t)(x)) > DISTORTION_ONE) ? (DISTORTION_ONE) : \
|
||
|
|
(((int32_t)(x)) < DISTORTION_MINUS_ONE) ? (DISTORTION_MINUS_ONE) : ((int32_t)(x)));
|
||
|
|
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------------
|
||
|
|
* Effects_log2()
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
* Purpose:
|
||
|
|
* Fixed-point log2 function.
|
||
|
|
*
|
||
|
|
* Inputs:
|
||
|
|
* Input is interpreted as an integer (should not be 0).
|
||
|
|
*
|
||
|
|
* Outputs:
|
||
|
|
* Output is in 15-bit precision.
|
||
|
|
*
|
||
|
|
* Side Effects:
|
||
|
|
*
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
*/
|
||
|
|
int32_t Effects_log2(uint32_t x);
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------------
|
||
|
|
* Effects_exp2()
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
* Purpose:
|
||
|
|
* Fixed-point radix-2 exponent.
|
||
|
|
*
|
||
|
|
* Inputs:
|
||
|
|
* Input is in 15-bit precision. Must be non-negative and less than 32.
|
||
|
|
*
|
||
|
|
* Outputs:
|
||
|
|
* Output is an integer.
|
||
|
|
*
|
||
|
|
* Side Effects:
|
||
|
|
*
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
*/
|
||
|
|
uint32_t Effects_exp2(int32_t x);
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------------
|
||
|
|
* Effects_MillibelsToLinear16()
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
* Purpose:
|
||
|
|
* Transform gain in millibels to linear gain multiplier:
|
||
|
|
*
|
||
|
|
* mB = 2000*log(lin/32767)
|
||
|
|
* => lin = 2^((mB+2000*log(32767))/2000*log(2))
|
||
|
|
* => lin = Effects_exp2(((mB + K1) << 15) / K2)
|
||
|
|
* with:
|
||
|
|
* K1 = 2000*log(32767) and K2 = 2000*log(2)
|
||
|
|
*
|
||
|
|
* Inputs:
|
||
|
|
* nGain - log scale value in millibels.
|
||
|
|
*
|
||
|
|
* Outputs:
|
||
|
|
* Returns a 16-bit linear value approximately equal to 2^(nGain/1024)
|
||
|
|
*
|
||
|
|
* Side Effects:
|
||
|
|
*
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
*/
|
||
|
|
#define MB_TO_LIN_K1 9031
|
||
|
|
#define MB_TO_LIN_K2 602
|
||
|
|
int16_t Effects_MillibelsToLinear16 (int32_t nGain);
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------------
|
||
|
|
* Effects_Linear16ToMillibels()
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
* Purpose:
|
||
|
|
* Transform linear gain multiplier to millibels
|
||
|
|
* mB = 2000*log(lin/32767)
|
||
|
|
* = 2000*log(2)*log2(lin)-2000*log(32767)
|
||
|
|
* => mB = K1*Effects_log2(lin) + K2
|
||
|
|
* with:
|
||
|
|
* K1 = 2000*log(2) and K2 = -2000*log(32767)
|
||
|
|
*
|
||
|
|
* Inputs:
|
||
|
|
* nGain - linear multiplier ranging form 0 to 32767 (corresponding to [0 1] gain range).
|
||
|
|
*
|
||
|
|
* Outputs:
|
||
|
|
* Returns a 16-bit log value expressed in milllibels.
|
||
|
|
*
|
||
|
|
* Side Effects:
|
||
|
|
*
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
*/
|
||
|
|
int16_t Effects_Linear16ToMillibels (int32_t nGain);
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------------
|
||
|
|
* Effects_Sqrt()
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
* Purpose:
|
||
|
|
* Returns the square root of the argument given.
|
||
|
|
*
|
||
|
|
* Inputs:
|
||
|
|
* in - positive number in the range 0 - 2^28
|
||
|
|
*
|
||
|
|
* Outputs:
|
||
|
|
* Returned value: square root of in.
|
||
|
|
*
|
||
|
|
* Side Effects:
|
||
|
|
*
|
||
|
|
*----------------------------------------------------------------------------
|
||
|
|
*/
|
||
|
|
int32_t Effects_Sqrt(int32_t in);
|
||
|
|
|
||
|
|
#if __cplusplus
|
||
|
|
} // extern "C"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif /*ANDROID_EFFECTSMATH_H_*/
|
||
|
|
|