You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
440 lines
16 KiB
440 lines
16 KiB
/*
|
|
* Copyright (C) 2013 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_AUDIO_RESAMPLER_FIR_PROCESS_H
|
|
#define ANDROID_AUDIO_RESAMPLER_FIR_PROCESS_H
|
|
|
|
namespace android {
|
|
|
|
// depends on AudioResamplerFirOps.h
|
|
|
|
/* variant for input type TI = int16_t input samples */
|
|
template<typename TC>
|
|
static inline
|
|
void mac(int32_t& l, int32_t& r, TC coef, const int16_t* samples)
|
|
{
|
|
uint32_t rl = *reinterpret_cast<const uint32_t*>(samples);
|
|
l = mulAddRL(1, rl, coef, l);
|
|
r = mulAddRL(0, rl, coef, r);
|
|
}
|
|
|
|
template<typename TC>
|
|
static inline
|
|
void mac(int32_t& l, TC coef, const int16_t* samples)
|
|
{
|
|
l = mulAdd(samples[0], coef, l);
|
|
}
|
|
|
|
/* variant for input type TI = float input samples */
|
|
template<typename TC>
|
|
static inline
|
|
void mac(float& l, float& r, TC coef, const float* samples)
|
|
{
|
|
l += *samples++ * coef;
|
|
r += *samples * coef;
|
|
}
|
|
|
|
template<typename TC>
|
|
static inline
|
|
void mac(float& l, TC coef, const float* samples)
|
|
{
|
|
l += *samples * coef;
|
|
}
|
|
|
|
/* variant for output type TO = int32_t output samples */
|
|
static inline
|
|
int32_t volumeAdjust(int32_t value, int32_t volume)
|
|
{
|
|
return 2 * mulRL(0, value, volume); // Note: only use top 16b
|
|
}
|
|
|
|
/* variant for output type TO = float output samples */
|
|
static inline
|
|
float volumeAdjust(float value, float volume)
|
|
{
|
|
return value * volume;
|
|
}
|
|
|
|
/*
|
|
* Helper template functions for loop unrolling accumulator operations.
|
|
*
|
|
* Unrolling the loops achieves about 2x gain.
|
|
* Using a recursive template rather than an array of TO[] for the accumulator
|
|
* values is an additional 10-20% gain.
|
|
*/
|
|
|
|
template<int CHANNELS, typename TO>
|
|
class Accumulator : public Accumulator<CHANNELS-1, TO> // recursive
|
|
{
|
|
public:
|
|
inline void clear() {
|
|
value = 0;
|
|
Accumulator<CHANNELS-1, TO>::clear();
|
|
}
|
|
template<typename TC, typename TI>
|
|
inline void acc(TC coef, const TI*& data) {
|
|
mac(value, coef, data++);
|
|
Accumulator<CHANNELS-1, TO>::acc(coef, data);
|
|
}
|
|
inline void volume(TO*& out, TO gain) {
|
|
*out++ += volumeAdjust(value, gain);
|
|
Accumulator<CHANNELS-1, TO>::volume(out, gain);
|
|
}
|
|
|
|
TO value; // one per recursive inherited base class
|
|
};
|
|
|
|
template<typename TO>
|
|
class Accumulator<0, TO> {
|
|
public:
|
|
inline void clear() {
|
|
}
|
|
template<typename TC, typename TI>
|
|
inline void acc(TC coef __unused, const TI*& data __unused) {
|
|
}
|
|
inline void volume(TO*& out __unused, TO gain __unused) {
|
|
}
|
|
};
|
|
|
|
template<typename TC, typename TINTERP>
|
|
inline
|
|
TC interpolate(TC coef_0, TC coef_1, TINTERP lerp)
|
|
{
|
|
return lerp * (coef_1 - coef_0) + coef_0;
|
|
}
|
|
|
|
template<>
|
|
inline
|
|
int16_t interpolate<int16_t, uint32_t>(int16_t coef_0, int16_t coef_1, uint32_t lerp)
|
|
{ // in some CPU architectures 16b x 16b multiplies are faster.
|
|
return (static_cast<int16_t>(lerp) * static_cast<int16_t>(coef_1 - coef_0) >> 15) + coef_0;
|
|
}
|
|
|
|
template<>
|
|
inline
|
|
int32_t interpolate<int32_t, uint32_t>(int32_t coef_0, int32_t coef_1, uint32_t lerp)
|
|
{
|
|
return (lerp * static_cast<int64_t>(coef_1 - coef_0) >> 31) + coef_0;
|
|
}
|
|
|
|
/* class scope for passing in functions into templates */
|
|
struct InterpCompute {
|
|
template<typename TC, typename TINTERP>
|
|
static inline
|
|
TC interpolatep(TC coef_0, TC coef_1, TINTERP lerp) {
|
|
return interpolate(coef_0, coef_1, lerp);
|
|
}
|
|
|
|
template<typename TC, typename TINTERP>
|
|
static inline
|
|
TC interpolaten(TC coef_0, TC coef_1, TINTERP lerp) {
|
|
return interpolate(coef_0, coef_1, lerp);
|
|
}
|
|
};
|
|
|
|
struct InterpNull {
|
|
template<typename TC, typename TINTERP>
|
|
static inline
|
|
TC interpolatep(TC coef_0, TC coef_1 __unused, TINTERP lerp __unused) {
|
|
return coef_0;
|
|
}
|
|
|
|
template<typename TC, typename TINTERP>
|
|
static inline
|
|
TC interpolaten(TC coef_0 __unused, TC coef_1, TINTERP lerp __unused) {
|
|
return coef_1;
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Calculates a single output frame (two samples).
|
|
*
|
|
* The Process*() functions compute both the positive half FIR dot product and
|
|
* the negative half FIR dot product, accumulates, and then applies the volume.
|
|
*
|
|
* Use fir() to compute the proper coefficient pointers for a polyphase
|
|
* filter bank.
|
|
*
|
|
* ProcessBase() is the fundamental processing template function.
|
|
*
|
|
* ProcessL() calls ProcessBase() with TFUNC = InterpNull, for fixed/locked phase.
|
|
* Process() calls ProcessBase() with TFUNC = InterpCompute, for interpolated phase.
|
|
*/
|
|
|
|
template <int CHANNELS, int STRIDE, typename TFUNC, typename TC, typename TI, typename TO,
|
|
typename TINTERP>
|
|
static inline
|
|
void ProcessBase(TO* const out,
|
|
size_t count,
|
|
const TC* coefsP,
|
|
const TC* coefsN,
|
|
const TI* sP,
|
|
const TI* sN,
|
|
TINTERP lerpP,
|
|
const TO* const volumeLR)
|
|
{
|
|
static_assert(CHANNELS > 0, "CHANNELS must be > 0");
|
|
|
|
if (CHANNELS > 2) {
|
|
// TO accum[CHANNELS];
|
|
Accumulator<CHANNELS, TO> accum;
|
|
|
|
// for (int j = 0; j < CHANNELS; ++j) accum[j] = 0;
|
|
accum.clear();
|
|
for (size_t i = 0; i < count; ++i) {
|
|
TC c = TFUNC::interpolatep(coefsP[0], coefsP[count], lerpP);
|
|
|
|
// for (int j = 0; j < CHANNELS; ++j) mac(accum[j], c, sP + j);
|
|
const TI *tmp_data = sP; // tmp_ptr seems to work better
|
|
accum.acc(c, tmp_data);
|
|
|
|
coefsP++;
|
|
sP -= CHANNELS;
|
|
c = TFUNC::interpolaten(coefsN[count], coefsN[0], lerpP);
|
|
|
|
// for (int j = 0; j < CHANNELS; ++j) mac(accum[j], c, sN + j);
|
|
tmp_data = sN; // tmp_ptr seems faster than directly using sN
|
|
accum.acc(c, tmp_data);
|
|
|
|
coefsN++;
|
|
sN += CHANNELS;
|
|
}
|
|
// for (int j = 0; j < CHANNELS; ++j) out[j] += volumeAdjust(accum[j], volumeLR[0]);
|
|
TO *tmp_out = out; // may remove if const out definition changes.
|
|
accum.volume(tmp_out, volumeLR[0]);
|
|
} else if (CHANNELS == 2) {
|
|
TO l = 0;
|
|
TO r = 0;
|
|
for (size_t i = 0; i < count; ++i) {
|
|
mac(l, r, TFUNC::interpolatep(coefsP[0], coefsP[count], lerpP), sP);
|
|
coefsP++;
|
|
sP -= CHANNELS;
|
|
mac(l, r, TFUNC::interpolaten(coefsN[count], coefsN[0], lerpP), sN);
|
|
coefsN++;
|
|
sN += CHANNELS;
|
|
}
|
|
out[0] += volumeAdjust(l, volumeLR[0]);
|
|
out[1] += volumeAdjust(r, volumeLR[1]);
|
|
} else { /* CHANNELS == 1 */
|
|
TO l = 0;
|
|
for (size_t i = 0; i < count; ++i) {
|
|
mac(l, TFUNC::interpolatep(coefsP[0], coefsP[count], lerpP), sP);
|
|
coefsP++;
|
|
sP -= CHANNELS;
|
|
mac(l, TFUNC::interpolaten(coefsN[count], coefsN[0], lerpP), sN);
|
|
coefsN++;
|
|
sN += CHANNELS;
|
|
}
|
|
out[0] += volumeAdjust(l, volumeLR[0]);
|
|
out[1] += volumeAdjust(l, volumeLR[1]);
|
|
}
|
|
}
|
|
|
|
/* Calculates a single output frame from a polyphase resampling filter.
|
|
* See Process() for parameter details.
|
|
*/
|
|
template <int CHANNELS, int STRIDE, typename TC, typename TI, typename TO>
|
|
static inline
|
|
void ProcessL(TO* const out,
|
|
int count,
|
|
const TC* coefsP,
|
|
const TC* coefsN,
|
|
const TI* sP,
|
|
const TI* sN,
|
|
const TO* const volumeLR)
|
|
{
|
|
ProcessBase<CHANNELS, STRIDE, InterpNull>(out, count, coefsP, coefsN, sP, sN, 0, volumeLR);
|
|
}
|
|
|
|
/*
|
|
* Calculates a single output frame from a polyphase resampling filter,
|
|
* with filter phase interpolation.
|
|
*
|
|
* @param out should point to the output buffer with space for at least one output frame.
|
|
*
|
|
* @param count should be half the size of the total filter length (halfNumCoefs), as we
|
|
* use symmetry in filter coefficients to evaluate two dot products.
|
|
*
|
|
* @param coefsP is one phase of the polyphase filter bank of size halfNumCoefs, corresponding
|
|
* to the positive sP.
|
|
*
|
|
* @param coefsN is one phase of the polyphase filter bank of size halfNumCoefs, corresponding
|
|
* to the negative sN.
|
|
*
|
|
* @param coefsP1 is the next phase of coefsP (used for interpolation).
|
|
*
|
|
* @param coefsN1 is the next phase of coefsN (used for interpolation).
|
|
*
|
|
* @param sP is the positive half of the coefficients (as viewed by a convolution),
|
|
* starting at the original samples pointer and decrementing (by CHANNELS).
|
|
*
|
|
* @param sN is the negative half of the samples (as viewed by a convolution),
|
|
* starting at the original samples pointer + CHANNELS and incrementing (by CHANNELS).
|
|
*
|
|
* @param lerpP The fractional siting between the polyphase indices is given by the bits
|
|
* below coefShift. See fir() for details.
|
|
*
|
|
* @param volumeLR is a pointer to an array of two 32 bit volume values, one per stereo channel,
|
|
* expressed as a S32 integer or float. A negative value inverts the channel 180 degrees.
|
|
* The pointer volumeLR should be aligned to a minimum of 8 bytes.
|
|
* A typical value for volume is 0x1000 to align to a unity gain output of 20.12.
|
|
*/
|
|
template <int CHANNELS, int STRIDE, typename TC, typename TI, typename TO, typename TINTERP>
|
|
static inline
|
|
void Process(TO* const out,
|
|
int count,
|
|
const TC* coefsP,
|
|
const TC* coefsN,
|
|
const TC* coefsP1 __unused,
|
|
const TC* coefsN1 __unused,
|
|
const TI* sP,
|
|
const TI* sN,
|
|
TINTERP lerpP,
|
|
const TO* const volumeLR)
|
|
{
|
|
ProcessBase<CHANNELS, STRIDE, InterpCompute>(out, count, coefsP, coefsN, sP, sN, lerpP,
|
|
volumeLR);
|
|
}
|
|
|
|
/*
|
|
* Calculates a single output frame from input sample pointer.
|
|
*
|
|
* This sets up the params for the accelerated Process() and ProcessL()
|
|
* functions to do the appropriate dot products.
|
|
*
|
|
* @param out should point to the output buffer with space for at least one output frame.
|
|
*
|
|
* @param phase is the fractional distance between input frames for interpolation:
|
|
* phase >= 0 && phase < phaseWrapLimit. It can be thought of as a rational fraction
|
|
* of phase/phaseWrapLimit.
|
|
*
|
|
* @param phaseWrapLimit is #polyphases<<coefShift, where #polyphases is the number of polyphases
|
|
* in the polyphase filter. Likewise, #polyphases can be obtained as (phaseWrapLimit>>coefShift).
|
|
*
|
|
* @param coefShift gives the bit alignment of the polyphase index in the phase parameter.
|
|
*
|
|
* @param halfNumCoefs is the half the number of coefficients per polyphase filter. Since the
|
|
* overall filterbank is odd-length symmetric, only halfNumCoefs need be stored.
|
|
*
|
|
* @param coefs is the polyphase filter bank, starting at from polyphase index 0, and ranging to
|
|
* and including the #polyphases. Each polyphase of the filter has half-length halfNumCoefs
|
|
* (due to symmetry). The total size of the filter bank in coefficients is
|
|
* (#polyphases+1)*halfNumCoefs.
|
|
*
|
|
* The filter bank coefs should be aligned to a minimum of 16 bytes (preferrably to cache line).
|
|
*
|
|
* The coefs should be attenuated (to compensate for passband ripple)
|
|
* if storing back into the native format.
|
|
*
|
|
* @param samples are unaligned input samples. The position is in the "middle" of the
|
|
* sample array with respect to the FIR filter:
|
|
* the negative half of the filter is dot product from samples+1 to samples+halfNumCoefs;
|
|
* the positive half of the filter is dot product from samples to samples-halfNumCoefs+1.
|
|
*
|
|
* @param volumeLR is a pointer to an array of two 32 bit volume values, one per stereo channel,
|
|
* expressed as a S32 integer or float. A negative value inverts the channel 180 degrees.
|
|
* The pointer volumeLR should be aligned to a minimum of 8 bytes.
|
|
* A typical value for volume is 0x1000 to align to a unity gain output of 20.12.
|
|
*
|
|
* In between calls to filterCoefficient, the phase is incremented by phaseIncrement, where
|
|
* phaseIncrement is calculated as inputSampling * phaseWrapLimit / outputSampling.
|
|
*
|
|
* The filter polyphase index is given by indexP = phase >> coefShift. Due to
|
|
* odd length symmetric filter, the polyphase index of the negative half depends on
|
|
* whether interpolation is used.
|
|
*
|
|
* The fractional siting between the polyphase indices is given by the bits below coefShift:
|
|
*
|
|
* lerpP = phase << 32 - coefShift >> 1; // for 32 bit unsigned phase multiply
|
|
* lerpP = phase << 32 - coefShift >> 17; // for 16 bit unsigned phase multiply
|
|
*
|
|
* For integer types, this is expressed as:
|
|
*
|
|
* lerpP = phase << sizeof(phase)*8 - coefShift
|
|
* >> (sizeof(phase)-sizeof(*coefs))*8 + 1;
|
|
*
|
|
* For floating point, lerpP is the fractional phase scaled to [0.0, 1.0):
|
|
*
|
|
* lerpP = (phase << 32 - coefShift) / (1 << 32); // floating point equivalent
|
|
*/
|
|
|
|
template<int CHANNELS, bool LOCKED, int STRIDE, typename TC, typename TI, typename TO>
|
|
static inline
|
|
void fir(TO* const out,
|
|
const uint32_t phase, const uint32_t phaseWrapLimit,
|
|
const int coefShift, const int halfNumCoefs, const TC* const coefs,
|
|
const TI* const samples, const TO* const volumeLR)
|
|
{
|
|
// NOTE: be very careful when modifying the code here. register
|
|
// pressure is very high and a small change might cause the compiler
|
|
// to generate far less efficient code.
|
|
// Always validate the result with objdump or test-resample.
|
|
|
|
if (LOCKED) {
|
|
// locked polyphase (no interpolation)
|
|
// Compute the polyphase filter index on the positive and negative side.
|
|
uint32_t indexP = phase >> coefShift;
|
|
uint32_t indexN = (phaseWrapLimit - phase) >> coefShift;
|
|
const TC* coefsP = coefs + indexP*halfNumCoefs;
|
|
const TC* coefsN = coefs + indexN*halfNumCoefs;
|
|
const TI* sP = samples;
|
|
const TI* sN = samples + CHANNELS;
|
|
|
|
// dot product filter.
|
|
ProcessL<CHANNELS, STRIDE>(out,
|
|
halfNumCoefs, coefsP, coefsN, sP, sN, volumeLR);
|
|
} else {
|
|
// interpolated polyphase
|
|
// Compute the polyphase filter index on the positive and negative side.
|
|
uint32_t indexP = phase >> coefShift;
|
|
uint32_t indexN = (phaseWrapLimit - phase - 1) >> coefShift; // one's complement.
|
|
const TC* coefsP = coefs + indexP*halfNumCoefs;
|
|
const TC* coefsN = coefs + indexN*halfNumCoefs;
|
|
const TC* coefsP1 = coefsP + halfNumCoefs;
|
|
const TC* coefsN1 = coefsN + halfNumCoefs;
|
|
const TI* sP = samples;
|
|
const TI* sN = samples + CHANNELS;
|
|
|
|
// Interpolation fraction lerpP derived by shifting all the way up and down
|
|
// to clear the appropriate bits and align to the appropriate level
|
|
// for the integer multiply. The constants should resolve in compile time.
|
|
//
|
|
// The interpolated filter coefficient is derived as follows for the pos/neg half:
|
|
//
|
|
// interpolated[P] = index[P]*lerpP + index[P+1]*(1-lerpP)
|
|
// interpolated[N] = index[N+1]*lerpP + index[N]*(1-lerpP)
|
|
|
|
// on-the-fly interpolated dot product filter
|
|
if (is_same<TC, float>::value || is_same<TC, double>::value) {
|
|
static const TC scale = 1. / (65536. * 65536.); // scale phase bits to [0.0, 1.0)
|
|
TC lerpP = TC(phase << (sizeof(phase)*8 - coefShift)) * scale;
|
|
|
|
Process<CHANNELS, STRIDE>(out,
|
|
halfNumCoefs, coefsP, coefsN, coefsP1, coefsN1, sP, sN, lerpP, volumeLR);
|
|
} else {
|
|
uint32_t lerpP = phase << (sizeof(phase)*8 - coefShift)
|
|
>> ((sizeof(phase)-sizeof(*coefs))*8 + 1);
|
|
|
|
Process<CHANNELS, STRIDE>(out,
|
|
halfNumCoefs, coefsP, coefsN, coefsP1, coefsN1, sP, sN, lerpP, volumeLR);
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace android
|
|
|
|
#endif /*ANDROID_AUDIO_RESAMPLER_FIR_PROCESS_H*/
|