media/libaudioprocessing/AudioResamplerFirProcess.h - platform/frameworks/av - Git at Google

 /*
  * 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 sanity check 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*/
	/*
	* 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 sanity check 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/